def getVehicleList():
import nations
from constants import VEHICLE_CLASSES
from items.vehicles import g_list
from helpers import getFullClientVersion
data = {}
for nationId in nations.INDICES.values():
for v in g_list.getList(nationId).values():
nation, tag = v.name.split(':')
data[v.compactDescr] = {
'name': v.userString,
'nation': nation,
'tag': tag,
'tier': v.level,
'type': list(set(VEHICLE_CLASSES) & v.tags)[0],
'tank_id': v.compactDescr
}
size = len(data)
result = {
'meta': {
'count': size,
'total': size,
'version': getFullClientVersion()
},
'data': data
}
saveDataJSON(FILE_VEHICLELIST, result)
def run(self):
try:
self.result = feedparser.parse(self.url, None, None, helpers.getFullClientVersion())
except Exception:
LOG_CURRENT_EXCEPTION()
return
def afterCreate(self):
super(GameLoading, self).afterCreate()
self.as_setLocaleS(getClientOverride())
self.as_setVersionS(getFullClientVersion())
if getClientLanguage() == 'ko':
self.as_setInfoS(MENU.LOADING_GAMEINFO)
self._updateStage()
def onClientReady(self):
if not (self.isPlaying or self.isRecording):
return
elif self.isRecording and BigWorld.player().arena.guiType == constants.ARENA_GUI_TYPE.TUTORIAL:
self.stop(None, True)
return
else:
self.__replayCtrl.playerVehicleID = BigWorld.player().playerVehicleID
self.__replayCtrl.onClientReady()
if self.isPlaying:
AreaDestructibles.g_destructiblesManager.onAfterReplayTimeWarp()
if isPlayerAvatar():
BigWorld.player().onVehicleEnterWorld += self.__onVehicleEnterWorld
if self.isRecording:
player = BigWorld.player()
arena = player.arena
arenaName = arena.arenaType.geometry
i = arenaName.find('/')
if i != -1:
arenaName = arenaName[i + 1:]
now = datetime.datetime.now()
now = '%02d.%02d.%04d %02d:%02d:%02d' % (now.day,
now.month,
now.year,
now.hour,
now.minute,
now.second)
vehicleName = BigWorld.entities[player.playerVehicleID].typeDescriptor.name
vehicleName = vehicleName.replace(':', '-')
vehicles = self.__getArenaVehiclesInfo()
gameplayID = player.arenaTypeID >> 16
clientVersionFromXml = getFullClientVersion()
clientVersionFromExe = BigWorld.wg_getProductVersion()
arenaInfo = {'dateTime': now,
'playerName': player.name,
'playerID': self.__playerDatabaseID,
'playerVehicle': vehicleName,
'mapName': arenaName,
'mapDisplayName': arena.arenaType.name,
'gameplayID': ArenaType.getGameplayName(gameplayID) or gameplayID,
'vehicles': vehicles,
'battleType': arena.bonusType,
'clientVersionFromExe': clientVersionFromExe,
'clientVersionFromXml': clientVersionFromXml,
'serverName': connectionManager.serverUserName,
'regionCode': constants.AUTH_REALM,
'serverSettings': self.__serverSettings,
'hasMods': self.__replayCtrl.hasMods}
self.__replayCtrl.recMapName = arenaName
self.__replayCtrl.recPlayerVehicleName = vehicleName
self.__replayCtrl.setArenaInfoStr(json.dumps(arenaInfo))
else:
self.__showInfoMessage('replayControlsHelp1')
self.__showInfoMessage('replayControlsHelp2')
self.__showInfoMessage('replayControlsHelp3')
if self.replayTimeout > 0:
LOG_DEBUG('replayTimeout set for %.2f' % float(self.replayTimeout))
BigWorld.callback(float(self.replayTimeout), BigWorld.quit)
return
def onClientReady(self):
if not (self.isPlaying or self.isRecording):
return
elif self.isRecording and BigWorld.player().arena.guiType == constants.ARENA_GUI_TYPE.TUTORIAL:
self.stop(None, True)
return
else:
self.__replayCtrl.playerVehicleID = BigWorld.player().playerVehicleID
self.__replayCtrl.onClientReady()
if self.isPlaying:
AreaDestructibles.g_destructiblesManager.onAfterReplayTimeWarp()
if isPlayerAvatar():
BigWorld.player().onVehicleEnterWorld += self.__onVehicleEnterWorld
if self.isRecording:
player = BigWorld.player()
arena = player.arena
arenaName = arena.arenaType.geometry
i = arenaName.find('/')
if i != -1:
arenaName = arenaName[i + 1:]
now = datetime.datetime.now()
now = '%02d.%02d.%04d %02d:%02d:%02d' % (now.day,
now.month,
now.year,
now.hour,
now.minute,
now.second)
vehicleName = BigWorld.entities[player.playerVehicleID].typeDescriptor.name
vehicleName = vehicleName.replace(':', '-')
vehicles = self.__getArenaVehiclesInfo()
gameplayID = player.arenaTypeID >> 16
clientVersionFromXml = getFullClientVersion()
clientVersionFromExe = BigWorld.wg_getProductVersion()
arenaInfo = {'dateTime': now,
'playerName': player.name,
'playerID': self.__playerDatabaseID,
'playerVehicle': vehicleName,
'mapName': arenaName,
'mapDisplayName': arena.arenaType.name,
'gameplayID': ArenaType.getGameplayName(gameplayID) or gameplayID,
'vehicles': vehicles,
'battleType': arena.bonusType,
'clientVersionFromExe': clientVersionFromExe,
'clientVersionFromXml': clientVersionFromXml,
'serverName': connectionManager.serverUserName,
'regionCode': constants.AUTH_REALM,
'serverSettings': self.__serverSettings}
self.__replayCtrl.recMapName = arenaName
self.__replayCtrl.recPlayerVehicleName = vehicleName
self.__replayCtrl.setArenaInfoStr(json.dumps(arenaInfo))
else:
self.__showInfoMessage('replayControlsHelp1')
self.__showInfoMessage('replayControlsHelp2')
self.__showInfoMessage('replayControlsHelp3')
if self.replayTimeout > 0:
LOG_DEBUG('replayTimeout set for %.2f' % float(self.replayTimeout))
BigWorld.callback(float(self.replayTimeout), BigWorld.quit)
return
def __init__(self, component = None):
Flash.__init__(self, 'gameLoading.swf', path=SCALEFORM_SWF_PATH_V3)
self._displayRoot = self.getMember('root.main')
if self._displayRoot is not None:
self._displayRoot.resync()
self._displayRoot.setLocale(getClientOverride())
self._displayRoot.setVersion(getFullClientVersion())
(width, height,) = GUI.screenResolution()
self._displayRoot.updateStage(width, height)
def afterCreate(self):
super(GameLoading, self).afterCreate()
self.as_setLocaleS(getClientOverride())
self.as_setVersionS(getFullClientVersion())
if getClientLanguage() == 'ko':
self.as_setInfoS(
backport.text(R.strings.menu.loading.gameInfo(),
age=makeHtmlString('html_templates:loading',
'game-info-age')))
self._updateStage()
def __init__(self, component = None):
Flash.__init__(self, 'gameLoading.swf', path=SCALEFORM_SWF_PATH_V3)
self._displayRoot = self.getMember('root.main')
if self._displayRoot is not None:
self._displayRoot.resync()
self._displayRoot.setLocale(getClientOverride())
self._displayRoot.setVersion(getFullClientVersion())
if constants.IS_KOREA:
self._displayRoot.setInfo(MENU.LOADING_GAMEINFO)
g_guiResetters.add(self.onUpdateStage)
self.onUpdateStage()
def __init__(self, component=None):
Flash.__init__(self, 'gameLoading.swf', path=SCALEFORM_SWF_PATH_V3)
self._displayRoot = self.getMember('root.main')
if self._displayRoot is not None:
self._displayRoot.resync()
self._displayRoot.setLocale(getClientOverride())
self._displayRoot.setVersion(getFullClientVersion())
if constants.IS_KOREA:
self._displayRoot.setInfo(MENU.LOADING_GAMEINFO)
g_guiResetters.add(self.onUpdateStage)
self.onUpdateStage()
def _populate(self):
View._populate(self)
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
connectionManager.onRejected += self._onLoginRejected
g_playerEvents.onLoginQueueNumberReceived += self._onHandleQueue
g_playerEvents.onKickWhileLoginReceived += self._onKickedWhileLogin
g_playerEvents.onAccountShowGUI += self._clearLoginView
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
self.__loadRandomBgImage()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(0.1, self.__checkUserInputState)
g_sessionProvider.getCtx().lastArenaUniqueID = None
self._setData()
self._showForm()
return
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
connectionManager.onRejected += self._onLoginRejected
connectionManager.onKickWhileLoginReceived += self._onKickedWhileLogin
connectionManager.onQueued += self._onHandleQueue
g_playerEvents.onAccountShowGUI += self._clearLoginView
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
ScaleformFileLoader.enableStreaming([getPathForFlash(_LOGIN_VIDEO_FILE)])
self.__backgroundMode.show()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(0.1, self.__checkUserInputState)
g_sessionProvider.getCtx().lastArenaUniqueID = None
self._setData()
self._showForm()
return
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
self.connectionMgr.onRejected += self._onLoginRejected
self.connectionMgr.onKickWhileLoginReceived += self._onKickedWhileLogin
self.connectionMgr.onQueued += self._onHandleQueue
self.connectionMgr.onLoggedOn += self._onLoggedOn
g_playerEvents.onAccountShowGUI += self._clearLoginView
g_playerEvents.onEntityCheckOutEnqueued += self._onEntityCheckoutEnqueued
g_playerEvents.onAccountBecomeNonPlayer += self._onAccountBecomeNonPlayer
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
self.sessionProvider.getCtx().lastArenaUniqueID = None
self._loginMode.init()
self.update()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(0.0, self.__checkUserInputState)
return
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
connectionManager.onRejected += self._onLoginRejected
connectionManager.onKickWhileLoginReceived += self._onKickedWhileLogin
connectionManager.onQueued += self._onHandleQueue
g_playerEvents.onAccountShowGUI += self._clearLoginView
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
if BigWorld.isLowProductivityPC():
self._showOnlyStaticBackground()
else:
self._showBackground()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(0.1, self.__checkUserInputState)
g_sessionProvider.getCtx().lastArenaUniqueID = None
self._setData()
self._showForm()
return
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
connectionManager.onRejected += self._onLoginRejected
connectionManager.onKickWhileLoginReceived += self._onKickedWhileLogin
connectionManager.onQueued += self._onHandleQueue
g_playerEvents.onAccountShowGUI += self._clearLoginView
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
ScaleformFileLoader.enableStreaming(
[getPathForFlash(_LOGIN_VIDEO_FILE)])
self.__backgroundMode.show()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(
0.1, self.__checkUserInputState)
g_sessionProvider.getCtx().lastArenaUniqueID = None
self._setData()
self._showForm()
return
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
connectionManager.onRejected += self._onLoginRejected
connectionManager.onKickWhileLoginReceived += self._onKickedWhileLogin
connectionManager.onQueued += self._onHandleQueue
g_playerEvents.onAccountShowGUI += self._clearLoginView
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
if BigWorld.isLowProductivityPC():
self._showOnlyStaticBackground()
else:
self._showBackground()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(
0.1, self.__checkUserInputState)
g_sessionProvider.getCtx().lastArenaUniqueID = None
self._setData()
self._showForm()
return
def __loadVersion(self):
self.as_setVersionS(getFullClientVersion())
import urllib2
import binascii
import threading
import random
import shelve as provider
from functools import partial
from Queue import Queue
import BigWorld
from debug_utils import LOG_WARNING, LOG_ERROR, LOG_CURRENT_EXCEPTION, LOG_DEBUG
from helpers import getFullClientVersion
from soft_exception import SoftException
_MIN_LIFE_TIME = 900
_MAX_LIFE_TIME = 86400
_LIFE_TIME_IN_MEMORY = 1200
_CACHE_VERSION = 2
_CLIENT_VERSION = getFullClientVersion()
def _LOG_EXECUTING_TIME(startTime, methodName, deltaTime=0.1):
finishTime = time.time()
if finishTime - startTime > deltaTime:
LOG_WARNING('Method "%s" takes too much time %s' %
(methodName, finishTime - startTime))
def parseHttpTime(t):
if t is None:
return
elif isinstance(t, int):
return t
else:
def __loadVersion(self):
self.as_setVersionS(getFullClientVersion())
def _getClientVersion():
global _CLIENT_VERSION
if _CLIENT_VERSION is None:
_CLIENT_VERSION = getFullClientVersion()
return _CLIENT_VERSION
# 2016.08.04 19:53:46 Støední Evropa (letní èas)
# Embedded file name: scripts/client/helpers/RSSDownloader.py
import threading
import helpers
import BigWorld
import feedparser
from debug_utils import *
_CLIENT_VERSION = helpers.getFullClientVersion()
feedparser.PARSE_MICROFORMATS = 0
feedparser.SANITIZE_HTML = 0
class RSSDownloader:
UPDATE_INTERVAL = 0.1
lastRSS = property(lambda self: self.__lastRSS)
isBusy = property(lambda self: self.__thread is not None)
def __init__(self):
self.__thread = None
self.__lastDownloadTime = None
self.__cbID = BigWorld.callback(self.UPDATE_INTERVAL, self.__update)
self.__lastRSS = {}
self.__onCompleteCallbacks = set()
return
def destroy(self):
self.__thread = None
self.__onCompleteCallbacks = None
self.__lastDownloadTime = None
if self.__cbID is not None:
BigWorld.cancelCallback(self.__cbID)
self.__cbID = None
# 2016.02.14 12:41:24 Støední Evropa (bìžný èas)
# Embedded file name: scripts/client/gui/shared/RemoteDataDownloader.py
import time
import httplib
import base64
import threading
from functools import partial
from collections import namedtuple
from debug_utils import LOG_DEBUG
from helpers import threads, getFullClientVersion, http, time_utils, local_cache
_CLIENT_VERSION = getFullClientVersion()
_TIMEOUT = 10.0
_REMOTE_DATA_CACHE_VERSION = 1
class LIFE_TIME(object):
MIN = time_utils.QUARTER_HOUR
MAX = time_utils.ONE_DAY
@classmethod
def isExpired(cls, expires):
ct = time_utils.getCurrentTimestamp()
return not ct <= expires <= ct + cls.MAX
class _HttpOpenPageJob(threads.Job):
def __init__(self, page, lastModified, callback):
super(_HttpOpenPageJob, self).__init__()
self.__page = page
self.__lastModified = lastModified
self.__callback = callback
def onClientReady(self):
if not (self.isPlaying or self.isRecording):
return
elif self.isRecording and BigWorld.player(
).arena.guiType == constants.ARENA_GUI_TYPE.TUTORIAL:
self.stop(None, True)
return
else:
self.__replayCtrl.playerVehicleID = BigWorld.player(
).playerVehicleID
self.__replayCtrl.onClientReady()
if self.isPlaying:
AreaDestructibles.g_destructiblesManager.onAfterReplayTimeWarp(
)
if isPlayerAvatar():
BigWorld.player(
).onVehicleEnterWorld += self.__onVehicleEnterWorld
from gui.app_loader import settings
self.appLoader.attachCursor(
settings.APP_NAME_SPACE.SF_BATTLE,
flags=GUI_CTRL_MODE_FLAG.CURSOR_ATTACHED)
if self.isRecording:
player = BigWorld.player()
arena = player.arena
arenaName = arena.arenaType.geometry
i = arenaName.find('/')
if i != -1:
arenaName = arenaName[i + 1:]
now = datetime.datetime.now()
now = '%02d.%02d.%04d %02d:%02d:%02d' % (
now.day, now.month, now.year, now.hour, now.minute,
now.second)
vehicleName = BigWorld.entities[
player.playerVehicleID].typeDescriptor.name
vehicleName = vehicleName.replace(':', '-')
vehicles = self.__getArenaVehiclesInfo()
gameplayID = player.arenaTypeID >> 16
clientVersionFromXml = getFullClientVersion()
clientVersionFromExe = BigWorld.wg_getProductVersion()
arenaInfo = {
'dateTime': now,
'playerName': player.name,
'playerID': self.__playerDatabaseID,
'playerVehicle': vehicleName,
'mapName': arenaName,
'mapDisplayName': arena.arenaType.name,
'gameplayID': ArenaType.getGameplayName(gameplayID)
or gameplayID,
'vehicles': vehicles,
'battleType': arena.bonusType,
'clientVersionFromExe': clientVersionFromExe,
'clientVersionFromXml': clientVersionFromXml,
'serverName': self.connectionMgr.serverUserName,
'regionCode': constants.AUTH_REALM,
'serverSettings': self.__serverSettings,
'hasMods': self.__replayCtrl.hasMods
}
if BigWorld.player(
).arena.guiType == constants.ARENA_GUI_TYPE.BOOTCAMP:
from bootcamp.Bootcamp import g_bootcamp
arenaInfo['lessonId'] = g_bootcamp.getLessonNum()
arenaInfo['bootcampCtx'] = g_bootcamp.serializeContext()
self.__replayCtrl.recMapName = arenaName
self.__replayCtrl.recPlayerVehicleName = vehicleName
self.__replayCtrl.setArenaInfoStr(
json.dumps(_JSON_Encode(arenaInfo)))
else:
self.__showInfoMessages()
if self.replayTimeout > 0:
LOG_DEBUG('replayTimeout set for %.2f' %
float(self.replayTimeout))
BigWorld.callback(float(self.replayTimeout), BigWorld.quit)
return
