def update_hp(vehicleID, hp):
try:
team = 0 if avatar_getter.getPlayerTeam() == avatar_getter.getArena(
).vehicles[vehicleID]['team'] else 1
global teams_vehicles, teams_totalhp, total_hp_color, total_hp_sign
#log('update_hp: {} {} => {}'.format(vehicleID, teams_vehicles[team].get(vehicleID, None), hp))
teams_vehicles[team][vehicleID] = max(hp, 0)
teams_totalhp[team] = sum(teams_vehicles[team].values())
if teams_totalhp[0] < teams_totalhp[1]:
ratio = max(
min(2.0 * teams_totalhp[0] / teams_totalhp[1] - 0.9, 1), 0)
total_hp_color = color_gradient(hp_colors['neutral'],
hp_colors['bad'], ratio)
total_hp_sign = '<'
elif teams_totalhp[0] > teams_totalhp[1]:
ratio = max(
min(2.0 * teams_totalhp[1] / teams_totalhp[0] - 0.9, 1), 0)
total_hp_color = color_gradient(hp_colors['neutral'],
hp_colors['good'], ratio)
total_hp_sign = '>'
else:
total_hp_color = color_gradient(hp_colors['neutral'],
hp_colors['neutral'], 1)
total_hp_sign = '='
except Exception, ex:
err(traceback.format_exc())
def BattleEndWarningPanel_setTotalTime(self, totalTime):
try:
if config.get('sounds/enabled'):
period = avatar_getter.getArena().period
if period == ARENA_PERIOD.BATTLE:
if totalTime == 300:
SoundGroups.g_instance.playSound2D(
XVM_SOUND_EVENT.BATTLE_END_300)
elif totalTime == 180:
SoundGroups.g_instance.playSound2D(
XVM_SOUND_EVENT.BATTLE_END_180)
elif totalTime == 120:
SoundGroups.g_instance.playSound2D(
XVM_SOUND_EVENT.BATTLE_END_120)
elif totalTime == 60:
SoundGroups.g_instance.playSound2D(
XVM_SOUND_EVENT.BATTLE_END_60)
elif totalTime == 30:
SoundGroups.g_instance.playSound2D(
XVM_SOUND_EVENT.BATTLE_END_30)
elif totalTime == 5:
SoundGroups.g_instance.playSound2D(
XVM_SOUND_EVENT.BATTLE_END_5)
except:
err(traceback.format_exc())
def onVMCommand(self, cmd, *args):
try:
if cmd == XVM_VM_COMMAND.LOG:
log(*args)
elif cmd == XVM_VM_COMMAND.INITIALIZED:
self.initialized = True
arena = avatar_getter.getArena()
self.guiType = arena.guiType
self.battleType = arena.bonusType
log('[VM] initialized')
elif cmd == XVM_COMMAND.REQUEST_CONFIG:
#self.respondConfig()
pass # vehicle markers config loading controlled by python
elif cmd == XVM_BATTLE_COMMAND.REQUEST_BATTLE_GLOBAL_DATA:
self.respondGlobalBattleData()
elif cmd == XVM_COMMAND.PYTHON_MACRO:
self.call(XVM_VM_COMMAND.AS_CMD_RESPONSE, python_macro.process_python_macro(args[0]))
elif cmd == XVM_COMMAND.GET_CLAN_ICON:
self.call(XVM_VM_COMMAND.AS_CMD_RESPONSE, stats.getClanIcon(int(args[0])))
elif cmd == XVM_COMMAND.LOAD_STAT_BATTLE:
stats.getBattleStat(args, self.call)
# profiler
elif cmd in (XVM_PROFILER_COMMAND.BEGIN, XVM_PROFILER_COMMAND.END):
g_eventBus.handleEvent(events.HasCtxEvent(cmd, args[0]))
else:
warn('Unknown command: {}'.format(cmd))
except Exception, ex:
err(traceback.format_exc())
def __onSectorBaseCaptured(self, baseId, isPlayerTeam):
componentSystem = self.__sessionProvider.arenaVisitor.getComponentSystem()
sectorBaseComp = getattr(componentSystem, 'sectorBaseComponent', None)
if sectorBaseComp is None:
LOG_ERROR('Expected SectorBaseComponent not present!')
return
else:
sectorComp = getattr(componentSystem, 'sectorComponent', None)
if sectorComp is None:
LOG_ERROR('Expected SectorComponent not present!')
return
sectorBase = sectorBaseComp.getSectorForSectorBase(baseId)
baseLane = sectorBase.playerGroup
baseSectorId = sectorBase.sectorID
baseSector = sectorComp.getSectorById(baseSectorId)
onPlayerLane = baseLane == self.__currentLane
settings = avatar_getter.getArena().arenaType.epicSectorSettings
seconds = settings.addGameTimePerCapture[baseSector.IDInPlayerGroup - 1]
if sectorBaseComp.getNumCapturedBases() == len(sectorBaseComp.sectorBases):
seconds += settings.addGameTimeAllCaptured
minutes = int(seconds / 60)
seconds -= minutes * 60
self.__sendIngameMessage(self.__makeMessageData(GAME_MESSAGES_CONSTS.BASE_CAPTURED_POSITIVE if self.__isAttacker() else GAME_MESSAGES_CONSTS.BASE_CAPTURED, {'baseID': baseId,
'title': EPIC_BATTLE.ZONE_CAPTURED_TEXT if isPlayerTeam else EPIC_BATTLE.ZONE_LOST_TEXT,
'timerText': i18n.makeString(EPIC_BATTLE.ZONE_TIME_ADDED, minutes=':'.join(('{:02d}'.format(int(minutes)), '{:02d}'.format(int(seconds)))))}))
if onPlayerLane:
if self.__isAttacker():
self.__nextObjectiveMessage(self.__isAttacker())
elif sectorComp.getSectorById(sectorComp.currentPlayerSectorId).IDInPlayerGroup <= baseSector.IDInPlayerGroup:
self.__sendIngameMessage(self.__makeMessageData(GAME_MESSAGES_CONSTS.RETREAT, {'title': EPIC_BATTLE.ZONE_LEAVE_ZONE}))
else:
self.__nextObjectiveMessage(self.__isAttacker())
self.__contestedEndTime[baseLane - 1] = 0
self.__isLaneContested[baseLane - 1] = False
return
def _PlayerAvatar_onBecomeNonPlayer(base, self):
try:
arena = avatar_getter.getArena()
if arena:
arena.onVehicleStatisticsUpdate -= g_markers.onVehicleStatisticsUpdate
except Exception, ex:
err(traceback.format_exc())
def getTeamName(self, teamIdx):
arena = avatar_getter.getArena()
teamName = _getDefaultTeamName(teamIdx in self.__arenaDP.getAllyTeams())
if arena and 'opponents' in (arena.extraData or {}):
opponents = arena.extraData['opponents']
teamName = opponents.get('%s' % teamIdx, {}).get('name', teamName)
return teamName
def init(self, minimapComponent):
self.initialized = True
arena = avatar_getter.getArena()
self.guiType = arena.guiType
self.battleType = arena.bonusType
self.minimapComponent = minimapComponent
self.entrySymbols = {}
def _PlayerAvatar_onBecomeNonPlayer(base, self):
try:
arena = avatar_getter.getArena()
if arena:
arena.onVehicleStatisticsUpdate -= g_markers.onVehicleStatisticsUpdate
except Exception, ex:
err(traceback.format_exc())
def invalidateArenaInfo(self):
#debug('battle: invalidateArenaInfo')
if self.battle_page:
if battle_loading.isBattleLoadingShowed():
if 'battleLoading' in self.battle_page.as_getComponentsVisibilityS(
):
battleLoading = self.battle_page.getComponent(
BATTLE_VIEW_ALIASES.BATTLE_LOADING)
if battleLoading:
battle_loading._setBattleLoading(False)
try:
battleLoading.invalidateArenaInfo()
except Exception:
err(traceback.format_exc())
ctrl = self.battle_page.getComponent(
BATTLE_VIEW_ALIASES.BATTLE_STATISTIC_DATA_CONTROLLER)
if ctrl and not isinstance(ctrl, EpicStatisticsDataController):
ctrl._dispose()
ctrl._populate()
# update vehicles data
for (vehicleID,
vData) in avatar_getter.getArena().vehicles.iteritems():
self.updatePlayerState(vehicleID, INV.ALL)
g_eventBus.handleEvent(
events.HasCtxEvent(XVM_BATTLE_EVENT.ARENA_INFO_INVALIDATED))
def _start(e=None):
g_eventBus.removeListener(XVM_EVENT.XVM_SERVICES_INITIALIZED, _start)
if not g_xvm.xvmServicesInitialized:
g_eventBus.addListener(XVM_EVENT.XVM_SERVICES_INITIALIZED, _start)
return
if (config.networkServicesSettings.xmqp and not isReplay()) or XMQP_DEVELOPMENT:
token = config.token.token
if token:
players = []
for (vehicleID, vData) in avatar_getter.getArena().vehicles.iteritems():
# ally team only
if vData['team'] == avatar_getter.getPlayerTeam():
players.append(vData['accountDBID'])
if XMQP_DEVELOPMENT:
accountDBID = utils.getAccountDBID()
if accountDBID not in players:
players.append(accountDBID)
#players.append(42)
#players.append(43)
players.sort()
# start
stop()
global _xmqp_thread, _xmqp
_xmqp = _XMQP(players)
_xmqp_thread = threading.Thread(target=_xmqp.start, name='xmqp')
_xmqp_thread.setDaemon(True)
_xmqp_thread.start()
debug('[XMQP] Thread started')
def init(self, minimapComponent):
self.initialized = True
arena = avatar_getter.getArena()
self.guiType = arena.guiType
self.battleType = arena.bonusType
self.minimapComponent = minimapComponent
self.entrySymbols = {}
def onVMCommand(self, cmd, *args):
try:
if cmd == XVM_VM_COMMAND.LOG:
log(*args)
elif cmd == XVM_VM_COMMAND.INITIALIZED:
self.initialized = True
arena = avatar_getter.getArena()
self.guiType = arena.guiType
self.battleType = arena.bonusType
log('[VM] initialized')
elif cmd == XVM_COMMAND.REQUEST_CONFIG:
#self.respondConfig()
pass # vehicle markers config loading controlled by python
elif cmd == XVM_BATTLE_COMMAND.REQUEST_BATTLE_GLOBAL_DATA:
self.respondGlobalBattleData()
elif cmd == XVM_COMMAND.PYTHON_MACRO:
self.call(XVM_VM_COMMAND.AS_CMD_RESPONSE,
python_macro.process_python_macro(args[0]))
elif cmd == XVM_COMMAND.GET_CLAN_ICON:
self.call(XVM_VM_COMMAND.AS_CMD_RESPONSE,
stats.getClanIcon(int(args[0])))
elif cmd == XVM_COMMAND.LOAD_STAT_BATTLE:
stats.getBattleStat(args, self.call)
# profiler
elif cmd in (XVM_PROFILER_COMMAND.BEGIN, XVM_PROFILER_COMMAND.END):
g_eventBus.handleEvent(events.HasCtxEvent(cmd, args[0]))
else:
warn('Unknown command: {}'.format(cmd))
except Exception, ex:
err(traceback.format_exc())
def _PostMortemControlMode_onMinimapClicked(self, worldPos):
#log('_PostMortemControlMode_onMinimapClicked active=' + str(g_minimap.active))
if g_minimap.active and g_minimap.opt_minimapDeadSwitch:
try:
battle = getBattleApp()
if not battle:
return
if isReplay() and not IS_DEVELOPMENT:
return
minDistance = None
toID = None
plugin = g_minimap.minimapComponent.getPlugin('vehicles')
for vehicleID, entry in plugin._entries.iteritems():
vData = avatar_getter.getArena().vehicles[vehicleID]
if avatar_getter.getPlayerTeam() != vData['team'] or not vData['isAlive']:
continue
matrix = entry.getMatrix()
if matrix is not None:
pos = Math.Matrix(matrix).translation
distance = Math.Vector3(worldPos - pos).length
if minDistance is None or minDistance > distance:
minDistance = distance
toID = vehicleID
if toID is not None:
self.selectPlayer(toID)
except Exception as ex:
if IS_DEVELOPMENT:
err(traceback.format_exc())
def onEnterWorld(self, vehicle):
self.macros.setChooseRating()
self.player = BigWorld.player()
self.playerVehicleID = self.player.playerVehicleID
self.ammo = self.guiSessionProvider.shared.ammo
shots = vehicle.typeDescriptor.gun.shots
nation = nations.NAMES[vehicle.typeDescriptor.type.id[0]]
xmlPath = '%s%s%s%s' % (ITEM_DEFS_PATH, 'vehicles/', nation,
'/components/shells.xml')
xmlCtx_s = (((None, '{}/{}'.format(xmlPath, n)), s)
for n, s in ResMgr.openSection(xmlPath).items()
if (n != 'icons') and (n != 'xmlns:xmlref'))
goldShells = [
_xml.readInt(xmlCtx, s, 'id', 0, 65535) for xmlCtx, s in xmlCtx_s
if s.readBool('improved', False)
]
for shot in shots:
shell = shot.shell
intCD = shell.compactDescr
self.shells[intCD] = {}
self.shells[intCD]['shellKind'] = shell.kind.lower()
self.shells[intCD]['shellDamage'] = shell.damage[0]
self.shells[intCD]['costShell'] = 'gold-shell' if shell.id[
1] in goldShells else 'silver-shell'
ResMgr.purge(xmlPath, True)
arena = avatar_getter.getArena()
self.battletypeKey = BATTLE_TYPE.get(arena.guiType,
ARENA_GUI_TYPE.UNKNOWN)
def stop(self):
self.__removeMarkerCallbacks()
while self._markers:
_, marker = self._markers.popitem()
marker.destroy()
while self._markerTimers:
_, timers = self._markerTimers.popitem()
while timers:
_, timer = timers.popitem()
timer.clear()
self._markerTimers.clear()
handler = avatar_getter.getInputHandler()
if handler is not None:
if isinstance(handler, AvatarInputHandler):
handler.onCameraChanged -= self.__onCameraChanged
ctrl = self.sessionProvider.shared.feedback
if ctrl is not None:
ctrl.onVehicleMarkerAdded -= self.__onVehicleMarkerAdded
ctrl.onVehicleMarkerRemoved -= self.__onVehicleMarkerRemoved
ctrl.onVehicleFeedbackReceived -= self._onVehicleFeedbackReceived
ctrl.setInFocusForPlayer -= self.__setInFocusForPlayer
ctrl.onRemoveCommandReceived -= self.__onRemoveCommandReceived
vStateCtrl = self.sessionProvider.shared.vehicleState
if vStateCtrl is not None:
vStateCtrl.onVehicleStateUpdated -= self._onVehicleStateUpdated
arena = avatar_getter.getArena()
if arena is not None:
arena.onChatCommandTargetUpdate -= self._onChatCommandTargetUpdate
g_messengerEvents.voip.onPlayerSpeaking -= self.__onPlayerSpeaking
g_playerEvents.onTeamChanged -= self.__onTeamChanged
self.settingsCore.onSettingsChanged -= self.__onSettingsChanged
super(VehicleMarkerPlugin, self).stop()
return
def __onProtZoneAdded(self, protZone, center, bounds):
lowerleft, upperright = bounds
protZoneComp = getattr(
self.sessionProvider.arenaVisitor.getComponentSystem(),
'protectionZoneComponent', None)
if protZoneComp is None:
LOG_ERROR('Expected ProtectionZoneComponent not present!')
return
else:
zone = protZoneComp.getProtectionZoneById(protZone)
if zone is None:
return
isPlayerTeam = self.__personalTeam == zone.team
isVertical = avatar_getter.getArena(
).arenaType.epicSectorGrid.mainDirection in (AAD.PLUS_Z,
AAD.MINUS_Z)
frontPosition = upperright if zone.team == EPIC_BATTLE_TEAM_ID.TEAM_ATTACKER else lowerleft
frontPosition = (center.x if isVertical else center.y, 0,
frontPosition.y
if isVertical else frontPosition.x)
if protZone not in self._zonesDict:
self._zonesDict[
protZone] = entryID = self.__addProtectionZoneEntry(
self._symbol, frontPosition)
else:
entryID = self._zonesDict[protZone]
if entryID is not None:
self._invoke(entryID, 'setOwningTeam', isPlayerTeam)
return
def startControl(self):
arena = avatar_getter.getArena()
if arena:
arena.onTeamHealthPercentUpdate += self.__onTeamHealthPercentUpdate
g_eventBus.addListener(events.GameEvent.BATTLE_LOADING,
self.__handleBattleLoading,
EVENT_BUS_SCOPE.BATTLE)
def invalidateArenaInfo(self):
#debug('battle: invalidateArenaInfo')
if self.battle_page:
if battle_loading.isBattleLoadingShowed():
if 'battleLoading' in self.battle_page.as_getComponentsVisibilityS(
):
battleLoading = self.battle_page.getComponent(
BATTLE_VIEW_ALIASES.BATTLE_LOADING)
if battleLoading:
battle_loading._setBattleLoading(False)
battleLoading.invalidateArenaInfo()
ctrl = self.battle_page.getComponent(
BATTLE_VIEW_ALIASES.BATTLE_STATISTIC_DATA_CONTROLLER)
if ctrl:
ctrl._BattleStatisticsDataController__setPersonalStatus()
ctrl._BattleStatisticsDataController__setArenaDescription()
arenaDP = ctrl._battleCtx.getArenaDP()
ctrl.invalidateVehiclesInfo(arenaDP)
ctrl.invalidateVehiclesStats(arenaDP)
# update vehicles data
for (vehicleID,
vData) in avatar_getter.getArena().vehicles.iteritems():
self.updatePlayerState(vehicleID, INV.ALL)
g_eventBus.handleEvent(
events.HasCtxEvent(XVM_BATTLE_EVENT.ARENA_INFO_INVALIDATED))
def getTeamName(self, teamIdx):
arena = avatar_getter.getArena()
teamName = _getDefaultTeamName(teamIdx in self.__arenaDP.getAllyTeams())
if arena and 'opponents' in (arena.extraData or {}):
opponents = arena.extraData['opponents']
teamName = opponents.get('%s' % teamIdx, {}).get('name', teamName)
return teamName
def start(self):
super(VehicleMarkerPlugin, self).start()
self._playerVehicleID = self.sessionProvider.getArenaDP().getPlayerVehicleID()
self.sessionProvider.addArenaCtrl(self)
settingsDamageIcon = self.settingsCore.getSetting(GAME.SHOW_DAMAGE_ICON)
isInBootcamp = self.bootcamp.isInBootcamp()
enableInBootcamp = isInBootcamp and self.bootcamp.isEnableDamageIcon()
self.__showDamageIcon = settingsDamageIcon and (not isInBootcamp or enableInBootcamp)
handler = avatar_getter.getInputHandler()
if handler is not None:
if isinstance(handler, AvatarInputHandler):
handler.onCameraChanged += self.__onCameraChanged
ctrl = self.sessionProvider.shared.feedback
if ctrl is not None:
ctrl.onVehicleMarkerAdded += self.__onVehicleMarkerAdded
ctrl.onVehicleMarkerRemoved += self.__onVehicleMarkerRemoved
ctrl.onVehicleFeedbackReceived += self._onVehicleFeedbackReceived
ctrl.setInFocusForPlayer += self.__setInFocusForPlayer
ctrl.onRemoveCommandReceived += self.__onRemoveCommandReceived
vStateCtrl = self.sessionProvider.shared.vehicleState
if vStateCtrl is not None:
vStateCtrl.onVehicleStateUpdated += self.__onVehicleStateUpdated
arena = avatar_getter.getArena()
if arena is not None:
arena.onChatCommandTargetUpdate += self._onChatCommandTargetUpdate
self.__equipmentCtrl = self.sessionProvider.shared.equipments
g_messengerEvents.voip.onPlayerSpeaking += self.__onPlayerSpeaking
g_playerEvents.onTeamChanged += self.__onTeamChanged
self.settingsCore.onSettingsChanged += self.__onSettingsChanged
return
def _PostMortemControlMode_onMinimapClicked(base, self, worldPos):
base(self, worldPos)
#log('_PostMortemControlMode_onMinimapClicked active=' + str(g_minimap.active))
if g_minimap.active and g_minimap.opt_minimapDeadSwitch:
try:
battle = getBattleApp()
if not battle:
return
if isReplay() and not IS_DEVELOPMENT:
return
minDistance = None
toID = None
plugin = g_minimap.minimapComponent.getPlugin('vehicles')
for vehicleID, entry in plugin._entries.iteritems():
vData = avatar_getter.getArena().vehicles[vehicleID]
if avatar_getter.getPlayerTeam(
) != vData['team'] or not vData['isAlive']:
continue
matrix = entry.getMatrix()
if matrix is not None:
pos = Math.Matrix(matrix).translation
distance = Math.Vector3(worldPos - pos).length
if minDistance is None or minDistance > distance:
minDistance = distance
toID = vehicleID
if toID is not None:
self.selectPlayer(toID)
except Exception as ex:
if IS_DEVELOPMENT:
err(traceback.format_exc())
def _PlayerAvatar_onBecomePlayer(base, self):
global isBattleTypeSupported
base(self)
try:
arena = avatar_getter.getArena()
if arena:
isBattleTypeSupported = arena.guiType not in NOT_SUPPORT_BATTLE_TYPE
arena.onVehicleKilled += g_battle.onVehicleKilled
arena.onAvatarReady += g_battle.onAvatarReady
arena.onVehicleStatisticsUpdate += g_battle.onVehicleStatisticsUpdate
arena.onNewVehicleListReceived += xmqp.start
sessionProvider = dependency.instance(IBattleSessionProvider)
ctrl = sessionProvider.shared.feedback
if ctrl:
ctrl.onVehicleFeedbackReceived += g_battle.onVehicleFeedbackReceived
ctrl = sessionProvider.shared.vehicleState
if ctrl:
ctrl.onVehicleStateUpdated += g_battle.onVehicleStateUpdated
ctrl = sessionProvider.shared.optionalDevices
if ctrl:
ctrl.onOptionalDeviceAdded += g_battle.onOptionalDeviceAdded
ctrl.onOptionalDeviceUpdated += g_battle.onOptionalDeviceUpdated
g_battle.onStartBattle()
except Exception, ex:
err(traceback.format_exc())
def teamDamage_onHealthChanged(self, diffHealth, attackerID, attackReasonID):
player = BigWorld.player()
attacker = avatar_getter.getArena().vehicles.get(attackerID)
if (None in (player, attacker)) or (
diffHealth <=
battleMessagesConfig['teamDamage']['ignoreLessThan']):
return
if (player.team == attacker['team'] ==
self.publicInfo.team) and (self.id != attackerID):
message = _getL10n(battleMessagesConfig['teamDamage']['format'])
message = message.replace('{{damage}}', str(diffHealth))
message = message.replace('{{damage-reason}}',
l10n(ATTACK_REASONS[attackReasonID]))
message = message.replace('{{victim-name}}', self.publicInfo.name)
message = message.replace('{{victim-vehicle}}',
self.typeDescriptor.type.shortUserString)
message = message.replace('{{attacker-name}}', attacker['name'])
message = message.replace('{{attacker-vehicle}}',
attacker['vehicleType'].type.shortUserString)
enabledFor = battleMessagesConfig['teamDamage']['enabledFor']
if enabledFor == 'all':
showTeamDamage(message)
elif (enabledFor
== 'player') and ((self.publicInfo.name == player.name) or
(attacker['name'] == player.name)):
showTeamDamage(message)
elif (enabledFor
== 'ally') and (self.publicInfo.name != player.name) and (
attacker['name'] != player.name):
showTeamDamage(message)
def __init__(self,
vehicleID,
team=0,
isAlive=None,
isAvatarReady=None,
isTeamKiller=None,
prebattleID=None,
events=None,
forbidInBattleInvitations=False,
ranked=None,
**kwargs):
super(VehicleArenaInfoVO, self).__init__()
self.vehicleID = vehicleID
self.team = team
self.player = PlayerInfoVO(
forbidInBattleInvitations=forbidInBattleInvitations, **kwargs)
self.vehicleType = VehicleTypeInfoVO(**kwargs)
self.prebattleID = prebattleID
self.vehicleStatus = self.__getVehicleStatus(isAlive, isAvatarReady)
self.playerStatus = self.__getPlayerStatus(isTeamKiller)
self.invitationDeliveryStatus = self.__getInvitationStatus(
forbidInBattleInvitations)
self.events = events or {}
self.squadIndex = 0
self.ranked = PlayerRankedInfoVO(
*ranked) if ranked is not None else PlayerRankedInfoVO()
arena = avatar_getter.getArena()
guiType = None if not arena else arena.guiType
self.gameModeSpecific = GameModeDataVO(guiType, True)
return
def _PlayerAvatar_onBecomePlayer(base, self):
global isBattleTypeSupported
base(self)
try:
arena = avatar_getter.getArena()
if arena:
isBattleTypeSupported = arena.guiType not in NOT_SUPPORT_BATTLE_TYPE
arena.onVehicleKilled += g_battle.onVehicleKilled
arena.onAvatarReady += g_battle.onAvatarReady
arena.onVehicleStatisticsUpdate += g_battle.onVehicleStatisticsUpdate
arena.onNewVehicleListReceived += xmqp.start
sessionProvider = dependency.instance(IBattleSessionProvider)
ctrl = sessionProvider.shared.feedback
if ctrl:
ctrl.onVehicleFeedbackReceived += g_battle.onVehicleFeedbackReceived
ctrl = sessionProvider.shared.vehicleState
if ctrl:
ctrl.onVehicleStateUpdated += g_battle.onVehicleStateUpdated
ctrl = sessionProvider.shared.optionalDevices
if ctrl:
ctrl.onOptionalDeviceAdded += g_battle.onOptionalDeviceAdded
ctrl.onOptionalDeviceUpdated += g_battle.onOptionalDeviceUpdated
g_battle.onStartBattle()
except Exception, ex:
err(traceback.format_exc())
def _start(e=None):
g_eventBus.removeListener(XVM_EVENT.XVM_SERVICES_INITIALIZED, _start)
if not g_xvm.xvmServicesInitialized:
g_eventBus.addListener(XVM_EVENT.XVM_SERVICES_INITIALIZED, _start)
return
if (config.networkServicesSettings.xmqp
and not isReplay()) or XMQP_DEVELOPMENT:
token = config.token.token
if token:
players = []
for (vehicleID,
vData) in avatar_getter.getArena().vehicles.iteritems():
# ally team only
if vData['team'] == avatar_getter.getPlayerTeam():
players.append(vData['accountDBID'])
if XMQP_DEVELOPMENT:
accountDBID = utils.getAccountDBID()
if accountDBID not in players:
players.append(accountDBID)
#players.append(42)
#players.append(43)
players = list(set(players))
players.sort()
# start
stop()
global _xmqp_thread, _xmqp
_xmqp = _XMQP(players)
_xmqp_thread = threading.Thread(target=_xmqp.start, name='xmqp')
_xmqp_thread.setDaemon(True)
_xmqp_thread.start()
debug('[XMQP] Thread started')
def updateArenaInfo(self):
stats = self.clientStatus
if stats is None:
return
stats.arenaName = avatar_getter.getArena().arenaType.geometryName
stats.vehicleName = avatar_getter.getVehicleTypeDescriptor().type.name
session = dependency.instance(IBattleSessionProvider)
stats.playerTeam = session.getArenaDP().getNumberOfTeam()
def __updatePlayerOutOfLives(self, playerList, hasRespawns):
arena = avatar_getter.getArena()
if not arena:
return
gameModeStats = dict(((vehID, {
'hasRespawns': hasRespawns
}) for vehID in playerList))
arena.onGameModeSpecifcStats(False, gameModeStats)
def new_setPlayerVehicle(base, self, *a, **k):
base(self, *a, **k)
arena = avatar_getter.getArena()
if arena is None:
return
self._SpecialSoundCtrl__arenaMusicSetup = musicSetup = arena.arenaType.wwmusicSetup.copy()
tag = g_config.music_modes[g_config.data['music']].tag
musicSetup.update(self._SpecialSoundCtrl__arenaMusicByStyle.get(tag, ()))
def detachedFromCtrl(self, ctrlID):
super(MinefieldPlayerMessenger, self).detachedFromCtrl(ctrlID)
arena = avatar_getter.getArena()
arena.onCombatEquipmentUsed -= self.__onCombatEquipmentUsed
ctrl = self.__sessionProvider.shared.feedback
ctrl.onPlayerFeedbackReceived -= self._onPlayerFeedbackReceived
self.__equipmentCtrl = None
return
def getOptionalDevicesByVehID(vehicleID, avatar=None):
arena = avatar_getter.getArena(avatar=avatar)
if arena is None:
return []
elif vehicleID not in arena.vehicles:
return []
else:
vehicleType = arena.vehicles[vehicleID].get('vehicleType')
return [] if vehicleType is None else vehicleType.optionalDevices
def __populateData(self, isMutlipleTeams = False):
arena = avatar_getter.getArena()
arenaDP = g_sessionProvider.getArenaDP()
arenaData = ['',
0,
'',
'',
'']
if arena:
arenaData = [toUpper(arena.arenaType.name)]
descExtra = getPrebattleFullDescription(arena.extraData or {})
arenaSubType = getArenaSubTypeName(BigWorld.player().arenaTypeID)
if descExtra:
arenaData.extend([arena.guiType + 1, descExtra])
elif arena.guiType in [constants.ARENA_GUI_TYPE.RANDOM, constants.ARENA_GUI_TYPE.TRAINING]:
arenaTypeName = '#arenas:type/%s/name' % arenaSubType
arenaData.extend([getNecessaryArenaFrameName(arenaSubType, isBaseExists(BigWorld.player().arenaTypeID, BigWorld.player().team)), arenaTypeName])
elif arena.guiType in constants.ARENA_GUI_TYPE.RANGE:
arenaData.append(constants.ARENA_GUI_TYPE_LABEL.LABELS[arena.guiType])
if arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES and hasResourcePoints():
arenaData.append(i18n.makeString(MENU.LOADING_BATTLETYPES_RESOURCEPOINTS_UPPER))
elif arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES and isMutlipleTeams:
arenaData.append(i18n.makeString(MENU.LOADING_BATTLETYPES_MIX_UPPER))
else:
arenaData.append('#menu:loading/battleTypes/%d' % arena.guiType)
else:
arenaData.extend([arena.guiType + 1, '#menu:loading/battleTypes/%d' % arena.guiType])
myTeamNumber = arenaDP.getNumberOfTeam()
getTeamName = g_sessionProvider.getCtx().getTeamName
arenaData.extend([getTeamName(myTeamNumber), getTeamName(arenaDP.getNumberOfTeam(enemy=True))])
teamHasBase = 1 if isBaseExists(BigWorld.player().arenaTypeID, myTeamNumber) else 2
if not isEventBattle():
typeEvent = 'normal'
winText = getBattleSubTypeWinText(BigWorld.player().arenaTypeID, teamHasBase)
else:
typeEvent = 'fallout'
if getIsMultiteam():
winText = i18n.makeString(ARENAS.TYPE_FALLOUTMUTLITEAM_DESCRIPTION)
else:
winText = i18n.makeString('#arenas:type/%s/description' % arenaSubType)
arenaData.append(winText)
arenaData.append(typeEvent)
vehInfo = arenaDP.getVehicleInfo(arenaDP.getPlayerVehicleID())
pqTipData = [None] * 3
pQuests = vehInfo.player.getPotapovQuests()
serverSettings = g_lobbyContext.getServerSettings()
isPQEnabled = serverSettings is not None and serverSettings.isPotapovQuestEnabled()
if isPQEnabled and (arena.guiType == constants.ARENA_GUI_TYPE.RANDOM or arena.guiType == constants.ARENA_GUI_TYPE.TRAINING and constants.IS_DEVELOPMENT):
if len(pQuests):
quest = pQuests[0]
pqTipData = [quest.getUserName(), quest.getUserMainCondition(), quest.getUserAddCondition()]
else:
pqTipData = [i18n.makeString('#ingame_gui:potapovQuests/tip'), None, None]
arenaData.extend(pqTipData)
arenaData.extend([getArenaIcon(_SMALL_MAP_SOURCE)])
self.__callEx('arenaData', arenaData)
return
def isChatCommandsDisabled(self, isAlly):
if not self.player.accountDBID:
if isAlly:
return True
arena = avatar_getter.getArena()
if arena is None or arena.guiType not in (ARENA_GUI_TYPE.RANDOM,
ARENA_GUI_TYPE.TRAINING):
return True
return False
def __populateData(self, isMutlipleTeams = False):
arena = avatar_getter.getArena()
arenaDP = g_sessionProvider.getArenaDP()
arenaData = ['',
0,
'',
'',
'']
if arena:
arenaData = [toUpper(arena.arenaType.name)]
descExtra = getPrebattleFullDescription(arena.extraData or {})
arenaSubType = getArenaSubTypeName(BigWorld.player().arenaTypeID)
if descExtra:
arenaData.extend([arena.guiType + 1, descExtra])
elif arena.guiType in [constants.ARENA_GUI_TYPE.RANDOM, constants.ARENA_GUI_TYPE.TRAINING]:
arenaTypeName = '#arenas:type/%s/name' % arenaSubType
arenaData.extend([getNecessaryArenaFrameName(arenaSubType, isBaseExists(BigWorld.player().arenaTypeID, BigWorld.player().team)), arenaTypeName])
elif arena.guiType in constants.ARENA_GUI_TYPE.RANGE:
arenaData.append(constants.ARENA_GUI_TYPE_LABEL.LABELS[arena.guiType])
if arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES and hasResourcePoints():
arenaData.append(i18n.makeString(MENU.LOADING_BATTLETYPES_RESOURCEPOINTS_UPPER))
elif arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES and isMutlipleTeams:
arenaData.append(i18n.makeString(MENU.LOADING_BATTLETYPES_MIX_UPPER))
else:
arenaData.append('#menu:loading/battleTypes/%d' % arena.guiType)
else:
arenaData.extend([arena.guiType + 1, '#menu:loading/battleTypes/%d' % arena.guiType])
myTeamNumber = arenaDP.getNumberOfTeam()
getTeamName = g_sessionProvider.getCtx().getTeamName
arenaData.extend([getTeamName(myTeamNumber), getTeamName(arenaDP.getNumberOfTeam(enemy=True))])
teamHasBase = 1 if isBaseExists(BigWorld.player().arenaTypeID, myTeamNumber) else 2
if not isEventBattle():
typeEvent = 'normal'
winText = getBattleSubTypeWinText(BigWorld.player().arenaTypeID, teamHasBase)
else:
typeEvent = 'fallout'
if getIsMultiteam():
winText = i18n.makeString(ARENAS.TYPE_FALLOUTMUTLITEAM_DESCRIPTION)
else:
winText = i18n.makeString('#arenas:type/%s/description' % arenaSubType)
arenaData.append(winText)
arenaData.append(typeEvent)
vehInfo = arenaDP.getVehicleInfo(arenaDP.getPlayerVehicleID())
pqTipData = [None] * 3
pQuests = vehInfo.player.getPotapovQuests()
serverSettings = g_lobbyContext.getServerSettings()
isPQEnabled = serverSettings is not None and serverSettings.isPotapovQuestEnabled()
if isPQEnabled and (arena.guiType == constants.ARENA_GUI_TYPE.RANDOM or arena.guiType == constants.ARENA_GUI_TYPE.TRAINING and constants.IS_DEVELOPMENT):
if len(pQuests):
quest = pQuests[0]
pqTipData = [quest.getUserName(), quest.getUserMainCondition(), quest.getUserAddCondition()]
else:
pqTipData = [i18n.makeString('#ingame_gui:potapovQuests/tip'), None, None]
arenaData.extend(pqTipData)
arenaData.extend([getArenaIcon(_SMALL_MAP_SOURCE)])
self.__callEx('arenaData', arenaData)
def _DynSquadFunctional_updateVehiclesInfo(self, updated, arenaDP):
# debug("> _DynSquadFunctional_updateVehiclesInfo")
try:
# is dynamic squad created
if avatar_getter.getArena().guiType == constants.ARENA_GUI_TYPE.RANDOM:
for flags, vo in updated:
if flags & INVALIDATE_OP.PREBATTLE_CHANGED and vo.squadIndex > 0:
g_battle.updatePlayerState(vo.vehicleID, INV.SQUAD_INDEX) # | INV.PLAYER_STATUS
except Exception, ex:
err(traceback.format_exc())
def __init__(self):
super(MinefieldPlayerMessenger, self).__init__()
arena = avatar_getter.getArena()
if arena is not None:
arena.onCombatEquipmentUsed += self.__onCombatEquipmentUsed
ctrl = self.__sessionProvider.shared.feedback
if ctrl is not None:
ctrl.onPlayerFeedbackReceived += self._onPlayerFeedbackReceived
self.__equipmentCtrl = self.__sessionProvider.shared.equipments
return
def _vehiclePlayerGroupsUpdated(self, args):
arena = avatar_getter.getArena()
if arena is not None:
key = 'playerGroup'
gameModeStats = dict(((vehID, {
key: playerGroup
}) for vehID, playerGroup in args.iteritems()))
arena.onGameModeSpecifcStats(True, gameModeStats)
self.onPlayerGroupsUpdated(args)
return
def stopControl(self):
arena = avatar_getter.getArena()
if arena:
arena.onTeamHealthPercentUpdate -= self.__onTeamHealthPercentUpdate
g_eventBus.removeListener(events.GameEvent.BATTLE_LOADING,
self.__handleBattleLoading,
EVENT_BUS_SCOPE.BATTLE)
self.__arenaVisitor = None
self.__arenaDP = None
return
def _DynSquadFunctional_updateVehiclesInfo(self, updated, arenaDP):
# debug("> _DynSquadFunctional_updateVehiclesInfo")
try:
# is dynamic squad created
if avatar_getter.getArena().guiType == constants.ARENA_GUI_TYPE.RANDOM:
for flags, vo in updated:
if flags & INVALIDATE_OP.PREBATTLE_CHANGED and vo.squadIndex > 0:
g_battle.updatePlayerState(vo.vehicleID, INV.SQUAD_INDEX) # | INV.PLAYER_STATUS
except Exception, ex:
err(traceback.format_exc())
def _PersonalEntriesPlugin_start(base, self):
base(self)
if g_minimap.active and g_minimap.opt_linesEnabled:
if not self._PersonalEntriesPlugin__yawLimits:
vehicle = avatar_getter.getArena().vehicles.get(avatar_getter.getPlayerVehicleID())
staticTurretYaw = vehicle['vehicleType'].gun.staticTurretYaw
if staticTurretYaw is None:
vInfoVO = self._arenaDP.getVehicleInfo()
yawLimits = vInfoVO.vehicleType.turretYawLimits
if yawLimits:
self._PersonalEntriesPlugin__yawLimits = (math.degrees(yawLimits[0]), math.degrees(yawLimits[1]))
def _removeGameListeners(self):
ctrl = g_sessionProvider.getBattleMessagesCtrl()
if ctrl:
ctrl.onShowPlayerMessageByCode -= self.__onShowPlayerMessageByCode
ctrl.onShowPlayerMessageByKey -= self.__onShowPlayerMessageByKey
ctrl = g_sessionProvider.getEquipmentsCtrl()
if ctrl:
ctrl.onEquipmentUpdated -= self.__onCombatEquipmentUpdated
arena = avatar_getter.getArena()
if arena:
arena.onCombatEquipmentUsed -= self.__onCombatEquipmentUsed
super(PlayerMessages, self)._removeGameListeners()
def _PlayerAvatar_onBecomePlayer(base, self):
base(self)
try:
arena = avatar_getter.getArena()
arena.onVehicleKilled += onVehicleKilled
sessionProvider = dependency.instance(IBattleSessionProvider)
ctrl = sessionProvider.shared.feedback
if ctrl:
ctrl.onVehicleFeedbackReceived += onVehicleFeedbackReceived
g_guiResetters.add(update_conf_hp)
except Exception, ex:
err(traceback.format_exc())
def _removeGameListeners(self):
ctrl = g_sessionProvider.shared.messages
if ctrl is not None:
ctrl.onShowPlayerMessageByCode -= self.__onShowPlayerMessageByCode
ctrl.onShowPlayerMessageByKey -= self.__onShowPlayerMessageByKey
ctrl = g_sessionProvider.shared.equipments
if ctrl is not None:
ctrl.onEquipmentUpdated -= self.__onCombatEquipmentUpdated
arena = avatar_getter.getArena()
if arena:
arena.onCombatEquipmentUsed -= self.__onCombatEquipmentUsed
super(PlayerMessages, self)._removeGameListeners()
return
def _getVehicleDamageType(self, attackerID):
entryVehicle = avatar_getter.getArena().vehicles.get(attackerID, None)
if not entryVehicle:
return markers2d_settings.DAMAGE_TYPE.FROM_UNKNOWN
if attackerID == avatar_getter.getPlayerVehicleID():
return markers2d_settings.DAMAGE_TYPE.FROM_PLAYER
entityName = self.sessionProvider.getCtx().getPlayerGuiProps(attackerID, entryVehicle['team'])
if entityName == PLAYER_GUI_PROPS.squadman:
return markers2d_settings.DAMAGE_TYPE.FROM_SQUAD
if entityName == PLAYER_GUI_PROPS.ally:
return markers2d_settings.DAMAGE_TYPE.FROM_ALLY
if entityName == PLAYER_GUI_PROPS.enemy:
return markers2d_settings.DAMAGE_TYPE.FROM_ENEMY
return markers2d_settings.DAMAGE_TYPE.FROM_UNKNOWN
def getBattleStat(self, tries=0):
try:
arena = avatar_getter.getArena()
if arena is None:
debug('WARNING: arena not created, but getBattleStat() called')
## Long initialization with high ping
#if tries < 5:
# time.sleep(1)
#self.getBattleStat(tries+1)
else:
self._get_battle()
return # required to prevent deadlock
except Exception:
err(traceback.format_exc())
with self.lock:
if not self.resp:
self.resp = {}
def invalidateArenaInfo(self):
#debug('battle: invalidateArenaInfo')
if self.battle_page:
if battle_loading.isBattleLoadingShowed():
if 'battleLoading' in self.battle_page.as_getComponentsVisibilityS():
battleLoading = self.battle_page.getComponent(BATTLE_VIEW_ALIASES.BATTLE_LOADING)
if battleLoading:
battle_loading._setBattleLoading(False)
battleLoading.invalidateArenaInfo()
ctrl = self.battle_page.getComponent(BATTLE_VIEW_ALIASES.BATTLE_STATISTIC_DATA_CONTROLLER)
if ctrl:
ctrl._dispose()
ctrl._populate()
# update vehicles data
for (vehicleID, vData) in avatar_getter.getArena().vehicles.iteritems():
self.updatePlayerState(vehicleID, INV.ALL)
g_eventBus.handleEvent(events.HasCtxEvent(XVM_BATTLE_EVENT.ARENA_INFO_INVALIDATED))
def __populateData(self, isMutlipleTeams = False):
arena = avatar_getter.getArena()
arenaDP = g_sessionProvider.getArenaDP()
arenaData = ['',
0,
'',
'',
'']
if arena:
arenaData = [toUpper(arena.arenaType.name)]
descExtra = getPrebattleFullDescription(arena.extraData or {})
arenaSubType = getArenaSubTypeName(BigWorld.player().arenaTypeID)
if descExtra:
arenaData.extend([arena.guiType + 1, descExtra])
elif arena.guiType in [constants.ARENA_GUI_TYPE.RANDOM, constants.ARENA_GUI_TYPE.TRAINING]:
arenaTypeName = '#arenas:type/%s/name' % arenaSubType
arenaData.extend([getNecessaryArenaFrameName(arenaSubType, isBaseExists(BigWorld.player().arenaTypeID, BigWorld.player().team)), arenaTypeName])
elif arena.guiType in constants.ARENA_GUI_TYPE.RANGE:
arenaData.append(constants.ARENA_GUI_TYPE_LABEL.LABELS[arena.guiType])
if arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES and hasResourcePoints():
arenaData.append(i18n.makeString(MENU.LOADING_BATTLETYPES_RESOURCEPOINTS_UPPER))
elif arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES and isMutlipleTeams:
arenaData.append(i18n.makeString(MENU.LOADING_BATTLETYPES_MIX_UPPER))
else:
arenaData.append('#menu:loading/battleTypes/%d' % arena.guiType)
else:
arenaData.extend([arena.guiType + 1, '#menu:loading/battleTypes/%d' % arena.guiType])
myTeamNumber = arenaDP.getNumberOfTeam()
getTeamName = g_sessionProvider.getCtx().getTeamName
arenaData.extend([getTeamName(myTeamNumber), getTeamName(arenaDP.getNumberOfTeam(enemy=True))])
teamHasBase = 1 if isBaseExists(BigWorld.player().arenaTypeID, myTeamNumber) else 2
if not isEventBattle():
typeEvent = 'normal'
winText = getBattleSubTypeWinText(BigWorld.player().arenaTypeID, teamHasBase)
else:
typeEvent = 'fallout'
if getIsMultiteam():
winText = i18n.makeString(ARENAS.TYPE_FALLOUTMUTLITEAM_DESCRIPTION)
else:
winText = i18n.makeString('#arenas:type/%s/description' % arenaSubType)
arenaData.append(winText)
arenaData.append(typeEvent)
arenaData.extend(_getQuestsTipData(arena, arenaDP))
arenaData.extend([getArenaIcon(_SMALL_MAP_SOURCE)])
self.__callEx('arenaData', arenaData)
def _get_battle(self):
arenaUniqueID = avatar_getter.getArenaUniqueID()
if arenaUniqueID is None or arenaUniqueID != self.arenaId:
self.arenaId = arenaUniqueID
self.players = {}
# update players
self._loadingClanIconsCount = 0
vehicles = avatar_getter.getArena().vehicles
for (vehicleID, vData) in vehicles.iteritems():
if vehicleID not in self.players:
pl = _Player(vehicleID, vData)
self._load_clanIcon(pl)
# cleanup same player with different vehicleID (bug?)
self.players = {k:v for k,v in self.players.iteritems() if v.accountDBID != pl.accountDBID}
self.players[vehicleID] = pl
self.players[vehicleID].update(vData)
# sleepCounter = 0
while self._loadingClanIconsCount > 0:
time.sleep(0.01)
# # FIX: temporary workaround
# sleepCounter += 1
# if sleepCounter > 1000: # 10 sec
# log('WARNING: icons loading too long')
# break;
self._load_stat(avatar_getter.getPlayerVehicleID())
players = {}
for (vehicleID, pl) in self.players.iteritems():
cacheKey = "%d=%d" % (pl.accountDBID, pl.vehCD)
if cacheKey not in self.cacheBattle:
cacheKey2 = "%d" % pl.accountDBID
if cacheKey2 not in self.cacheBattle:
self.cacheBattle[cacheKey] = self._get_battle_stub(pl)
stat = self.cacheBattle[cacheKey]
self._fix(stat)
players[pl.name] = stat
# pprint(players)
with self.lock:
self.resp = {'players': players}
def getGlobalBattleData():
vehicleID = avatar_getter.getPlayerVehicleID()
arena = avatar_getter.getArena()
arenaVehicle = arena.vehicles.get(vehicleID)
vehCD = getVehCD(vehicleID)
clan = arenaVehicle['clanAbbrev']
if not clan:
clan = None
return (
vehicleID, # playerVehicleID
arenaVehicle['name'], # playerName
clan, # playerClan
vehCD, # playerVehCD
arena.extraData.get('battleLevel', 0), # battleLevel
arena.bonusType, # battleType
arena.guiType, # arenaGuiType
utils.getMapSize(), # mapSize
minimap_circles.getMinimapCirclesData(), # minimapCirclesData
vehinfo.getXtdbDataArray(vehCD)) # xtdb_data
def BattleEndWarningPanel_setTotalTime(self, totalTime):
try:
if config.get('sounds/enabled'):
period = avatar_getter.getArena().period
if period == ARENA_PERIOD.BATTLE:
if totalTime == 300:
SoundGroups.g_instance.playSound2D(XVM_SOUND_EVENT.BATTLE_END_300)
elif totalTime == 180:
SoundGroups.g_instance.playSound2D(XVM_SOUND_EVENT.BATTLE_END_180)
elif totalTime == 120:
SoundGroups.g_instance.playSound2D(XVM_SOUND_EVENT.BATTLE_END_120)
elif totalTime == 60:
SoundGroups.g_instance.playSound2D(XVM_SOUND_EVENT.BATTLE_END_60)
elif totalTime == 30:
SoundGroups.g_instance.playSound2D(XVM_SOUND_EVENT.BATTLE_END_30)
elif totalTime == 5:
SoundGroups.g_instance.playSound2D(XVM_SOUND_EVENT.BATTLE_END_5)
except:
err(traceback.format_exc())
def _PlayerAvatar_onBecomeNonPlayer(base, self):
try:
arena = avatar_getter.getArena()
if arena:
arena.onVehicleKilled -= g_battle.onVehicleKilled
arena.onAvatarReady -= g_battle.onAvatarReady
arena.onVehicleStatisticsUpdate -= g_battle.onVehicleStatisticsUpdate
arena.onNewVehicleListReceived -= xmqp.start
sessionProvider = dependency.instance(IBattleSessionProvider)
ctrl = sessionProvider.shared.feedback
if ctrl:
ctrl.onVehicleFeedbackReceived -= g_battle.onVehicleFeedbackReceived
ctrl = sessionProvider.shared.vehicleState
if ctrl:
ctrl.onVehicleStateUpdated -= g_battle.onVehicleStateUpdated
ctrl = sessionProvider.shared.optionalDevices
if ctrl:
ctrl.onOptionalDeviceAdded -= g_battle.onOptionalDeviceAdded
ctrl.onOptionalDeviceUpdated -= g_battle.onOptionalDeviceUpdated
xmqp.stop()
except Exception, ex:
err(traceback.format_exc())
def update_hp(vehicleID, hp):
try:
team = 0 if avatar_getter.getPlayerTeam() == avatar_getter.getArena().vehicles[vehicleID]['team'] else 1
global teams_vehicles, teams_totalhp, total_hp_color, total_hp_sign
#log('update_hp: {} {} => {}'.format(vehicleID, teams_vehicles[team].get(vehicleID, None), hp))
teams_vehicles[team][vehicleID] = max(hp, 0)
teams_totalhp[team] = sum(teams_vehicles[team].values())
if teams_totalhp[0] < teams_totalhp[1]:
ratio = max(min(2.0 * teams_totalhp[0] / teams_totalhp[1] - 0.9, 1), 0)
total_hp_color = color_gradient(hp_colors['neutral'], hp_colors['bad'], ratio)
total_hp_sign = '<'
elif teams_totalhp[0] > teams_totalhp[1]:
ratio = max(min(2.0 * teams_totalhp[1] / teams_totalhp[0] - 0.9, 1), 0)
total_hp_color = color_gradient(hp_colors['neutral'], hp_colors['good'], ratio)
total_hp_sign = '>'
else:
total_hp_color = color_gradient(hp_colors['neutral'], hp_colors['neutral'], 1)
total_hp_sign = '='
except Exception, ex:
err(traceback.format_exc())
def __init__(self, avatar=None):
self._arena = avatar_getter.getArena()
def getMapSize():
(b, l), (t, r) = avatar_getter.getArena().arenaType.boundingBox
return t - b
def updatePlayerStates(self):
for vehicleID, vData in avatar_getter.getArena().vehicles.iteritems():
g_markers.updatePlayerState(vehicleID, INV.ALL)
def onGUISpaceEntered(spaceID):
if spaceID == GUI_GLOBAL_SPACE_ID.BATTLE:
cleanup()
for vehicleID, vData in avatar_getter.getArena().vehicles.iteritems():
if vData['vehicleType']:
update_hp(vehicleID, vData['vehicleType'].maxHealth)
def start():
arena = avatar_getter.getArena()
arena.onNewVehicleListReceived -= start
BigWorld.callback(0, _start)
def getTeamAmount(avatar = None):
arena = avatar_getter.getArena(avatar)
team = avatar_getter.getPlayerTeam(avatar)
return len([ k for k, v in arena.vehicles.items() if v['team'] == team and v['isAlive'] ])
