def init(scriptConfig, engineConfig, userPreferences, loadingScreenGUI = None):
global g_replayCtrl
try:
if constants.IS_DEVELOPMENT:
autoFlushPythonLog()
LOG_DEBUG('init')
BigWorld.wg_initCustomSettings()
Settings.g_instance = Settings.Settings(scriptConfig, engineConfig, userPreferences)
CommandMapping.g_instance = CommandMapping.CommandMapping()
from helpers import DecalMap
DecalMap.g_instance = DecalMap.DecalMap(scriptConfig['decal'])
from helpers import EdgeDetectColorController
EdgeDetectColorController.g_instance = EdgeDetectColorController.EdgeDetectColorController(scriptConfig['silhouetteColors'])
import SoundGroups
SoundGroups.g_instance = SoundGroups.SoundGroups()
import BattleReplay
g_replayCtrl = BattleReplay.g_replayCtrl = BattleReplay.BattleReplay()
g_replayCtrl.registerWotReplayFileExtension()
try:
import Vibroeffects
Vibroeffects.VibroManager.g_instance = Vibroeffects.VibroManager.VibroManager()
Vibroeffects.VibroManager.g_instance.connect()
except:
LOG_CURRENT_EXCEPTION()
tutorialLoaderInit()
BigWorld.callback(0.1, asyncore_call)
MessengerEntry.g_instance.init()
import items
items.init(True, None if not constants.IS_DEVELOPMENT else {})
import ArenaType
ArenaType.init()
import dossiers1
dossiers1.init()
import dossiers2
dossiers2.init()
BigWorld.worldDrawEnabled(False)
import LcdKeyboard
LcdKeyboard.enableLcdKeyboardSpecificKeys(True)
gui_personality.init(loadingScreenGUI=loadingScreenGUI)
AreaDestructibles.init()
MusicController.init()
TriggersManager.init()
RSSDownloader.init()
g_postProcessing.init()
try:
from LightFx import LightManager
LightManager.g_instance = LightManager.LightManager()
import AuxiliaryFx
AuxiliaryFx.g_instance = AuxiliaryFx.AuxiliaryFxManager()
except:
LOG_CURRENT_EXCEPTION()
except Exception:
LOG_CURRENT_EXCEPTION()
BigWorld.quit()
return
def _migrateTo6(core, data, initialized):
from account_helpers.settings_core.ServerSettingsManager import SETTINGS_SECTIONS
storedValue = g_settingsCache.getSectionSettings(SETTINGS_SECTIONS.GAME, 0)
maskOffset = 7168
currentMask = (storedValue & maskOffset) >> 10
import ArenaType
newMask = currentMask | ArenaType.getVisibilityMask(ArenaType.getGameplayIDForName('nations'))
data['gameplayData'][GAME.GAMEPLAY_MASK] = newMask
clear = data['clear']
clear[SETTINGS_SECTIONS.GAME] = clear.get(SETTINGS_SECTIONS.GAME, 0) | maskOffset
def _migrateTo6(core, data, initialized):
from account_helpers.settings_core.ServerSettingsManager import SETTINGS_SECTIONS
storedValue = _getSettingsCache().getSectionSettings(
SETTINGS_SECTIONS.GAME, 0)
maskOffset = 7168
currentMask = (storedValue & maskOffset) >> 10
import ArenaType
newMask = currentMask | ArenaType.getVisibilityMask(
ArenaType.getGameplayIDForName('nations'))
data['gameplayData'][GAME.GAMEPLAY_MASK] = newMask
clear = data['clear']
clear[SETTINGS_SECTIONS.GAME] = clear.get(SETTINGS_SECTIONS.GAME,
0) | maskOffset
def _migrateTo36(core, data, initialized):
from account_helpers.settings_core.ServerSettingsManager import SETTINGS_SECTIONS
from account_helpers.AccountSettings import AccountSettings
default = AccountSettings.getSettingsDefault(GAME.GAMEPLAY_MASK)
storedValue = _getSettingsCache().getSectionSettings(
SETTINGS_SECTIONS.GAMEPLAY, default)
currentMask = storedValue & 65535
import ArenaType
newMask = currentMask | ArenaType.getVisibilityMask(
ArenaType.getGameplayIDForName('ctf30x30'))
newnewMask = newMask | ArenaType.getVisibilityMask(
ArenaType.getGameplayIDForName('domination30x30'))
data['gameplayData'][GAME.GAMEPLAY_MASK] = newnewMask
def _migrateTo38(core, data, initialized):
from account_helpers.settings_core.ServerSettingsManager import SETTINGS_SECTIONS
from account_helpers.AccountSettings import AccountSettings
default = AccountSettings.getSettingsDefault(GAME.GAMEPLAY_MASK)
storedValue = _getSettingsCache().getSectionSettings(SETTINGS_SECTIONS.GAMEPLAY, default)
currentGameplayMask = storedValue & 65535
import ArenaType
epicCtfEnabled = bool(currentGameplayMask & 1 << ArenaType.getGameplayIDForName('ctf30x30'))
dominationEnabled = bool(currentGameplayMask & 1 << ArenaType.getGameplayIDForName('domination'))
if not epicCtfEnabled or not dominationEnabled:
currentGameplayMask &= ~ArenaType.getVisibilityMask(ArenaType.getGameplayIDForName('domination30x30'))
data['gameplayData'][GAME.GAMEPLAY_MASK] = currentGameplayMask
data['gameData'][GAME.MINIMAP_ALPHA] = 0
data['gameExtData'][GAME.MINIMAP_ALPHA_ENABLED] = False
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 getMask():
from account_helpers.settings_core.ServerSettingsManager import SETTINGS_SECTIONS
settingsCore = dependency.instance(ISettingsCore)
settingsMask = userMask = settingsCore.serverSettings.getSectionSettings(
SETTINGS_SECTIONS.GAMEPLAY, 'gameplayMask', getDefaultMask())
ctfMask = ArenaType.getGameplaysMask(('ctf', ))
nationsMask = ArenaType.getGameplaysMask(('nations', ))
if not userMask:
LOG_WARNING('Gameplay is not defined', userMask)
else:
if userMask & ctfMask == 0:
LOG_WARNING('Gameplay "ctf" is not defined', userMask)
if userMask & nationsMask:
userMask ^= nationsMask
LOG_DEBUG('Nations battle mode currently unavailable')
userMask |= ctfMask
if settingsMask != userMask:
_setMask(userMask)
return userMask
def setMaskByNames(names):
gameplayNames = {'ctf'}
for name in names:
if name in ArenaType.g_gameplayNames:
gameplayNames.add(name)
LOG_ERROR('Gameplay is not available', name)
gameplayMask = ArenaType.getGameplaysMask(gameplayNames)
LOG_DEBUG('Set gameplay (names, mask)', gameplayNames, gameplayMask)
_setMask(gameplayMask)
def setMaskByNames(names):
gameplayNames = {'ctf'}
for name in names:
if name in ArenaType.g_gameplayNames:
gameplayNames.add(name)
else:
LOG_ERROR('Gameplay is not available', name)
gameplayMask = ArenaType.getGameplaysMask(gameplayNames)
LOG_DEBUG('Set gameplay (names, mask)', gameplayNames, gameplayMask)
_setMask(gameplayMask)
def setMaskByNames(names):
gameplayNames = {'ctf'}
for name in names:
if name in ArenaType.g_gameplayNames:
gameplayNames.add(name)
else:
LOG_ERROR('Gameplay is not available', name)
gameplayMask = ArenaType.getGameplaysMask(gameplayNames)
LOG_DEBUG('Set gameplay (names, mask)', gameplayNames, gameplayMask)
from account_helpers.settings_core.SettingsCore import g_settingsCore
g_settingsCore.serverSettings.setGameplaySettings({'gameplayMask': gameplayMask})
def onClientReady(self):
if not (self.isPlaying or self.isRecording):
return
if self.isRecording and BigWorld.player().arena.guiType == constants.ARENA_GUI_TYPE.TUTORIAL:
self.stop()
return
self.__replayCtrl.playerVehicleID = BigWorld.player().playerVehicleID
self.__replayCtrl.onClientReady()
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
sec = ResMgr.openSection(VERSION_FILE_PATH)
clientVersionFromXml = i18n.makeString(sec.readString('appname')) + ' ' + sec.readString('version')
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,
'roamingSettings': self.__roamingSettings}
self.__replayCtrl.recMapName = arenaName
self.__replayCtrl.recPlayerVehicleName = vehicleName
self.__replayCtrl.setArenaInfoStr(json.dumps(arenaInfo))
else:
self.isPlaying = True
self.__enableTimeWarp = True
currReplayTime = self.__replayCtrl.getTimeMark(REPLAY_TIME_MARK_CURRENT_TIME)
self.__timeWarp(currReplayTime + 30.0)
self.triggerRecord()
self.__disableSidePanelContextMenu()
def createTrainingRequest(self):
settings = EpicTrainingSettingsCtx()
gameplayID = ArenaType.getGameplayIDForName('epic')
geometryID = 96
arenaTypeID = geometryID | gameplayID << 16
settings.setArenaTypeID(arenaTypeID)
settings.setRoundLen(190)
settings.setOpened(True)
settings._isRequestToCreate = True
self.fireEvent(events.TrainingSettingsEvent(
events.TrainingSettingsEvent.UPDATE_EPIC_TRAINING_SETTINGS,
ctx={'settings': settings}),
scope=EVENT_BUS_SCOPE.LOBBY)
def setMaskByNames(names):
gameplayNames = set(['ctf'])
for name in names:
if name in ArenaType.g_gameplayNames:
gameplayNames.add(name)
else:
LOG_ERROR('Gameplay is not available', name)
gameplayMask = ArenaType.getGameplaysMask(gameplayNames)
LOG_DEBUG('Set gameplay (names, mask)', gameplayNames, gameplayMask)
from account_helpers.SettingsCore import g_settingsCore
g_settingsCore.serverSettings.setGameSettings(
{'gameplayMask': gameplayMask})
def onClientReady(self):
if not self.isPlaying:
if not self.isRecording:
return
if self.isRecording and BigWorld.player(
).arena.guiType == constants.ARENA_GUI_TYPE.TUTORIAL:
self.stop()
return
self.__replayCtrl.playerVehicleID = BigWorld.player(
).playerVehicleID
self.__replayCtrl.onClientReady()
if self.isRecording:
player = BigWorld.player()
arena = player.arena
arenaName = arena.arenaType.geometry
i = arenaName.find('/')
arenaName = i != -1 and 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
sec = ResMgr.openSection(VERSION_FILE_PATH)
clientVersionFromXml = i18n.makeString(
sec.readString('appname')) + ' ' + sec.readString('version')
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
}
self.__replayCtrl.recMapName = arenaName
self.__replayCtrl.recPlayerVehicleName = vehicleName
self.__replayCtrl.setArenaInfoStr(json.dumps(arenaInfo))
else:
self.__showInfoMessage('replayControlsHelp1')
self.__showInfoMessage('replayControlsHelp2')
self.__showInfoMessage('replayControlsHelp3')
self.__disableSidePanelContextMenu()
def onClientReady(self):
if not self.isPlaying:
if not self.isRecording:
return
if self.isRecording and BigWorld.player().arena.guiType == constants.ARENA_GUI_TYPE.TUTORIAL:
self.stop()
return
self.__replayCtrl.playerVehicleID = BigWorld.player().playerVehicleID
self.__replayCtrl.onClientReady()
if self.isRecording:
player = BigWorld.player()
arena = player.arena
arenaName = arena.arenaType.geometry
i = arenaName.find('/')
arenaName = i != -1 and 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
sec = ResMgr.openSection(VERSION_FILE_PATH)
clientVersionFromXml = i18n.makeString(sec.readString('appname')) + ' ' + sec.readString('version')
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}
self.__replayCtrl.recMapName = arenaName
self.__replayCtrl.recPlayerVehicleName = vehicleName
self.__replayCtrl.setArenaInfoStr(json.dumps(arenaInfo))
else:
self.__showInfoMessage('replayControlsHelp1')
self.__showInfoMessage('replayControlsHelp2')
self.__showInfoMessage('replayControlsHelp3')
self.__disableSidePanelContextMenu()
def __startWGPhysics(self):
if not hasattr(self.filter, 'setVehiclePhysics'):
return
typeDescr = self.typeDescriptor
physics = BigWorld.WGVehiclePhysics()
physics_shared.initVehiclePhysicsClient(physics, typeDescr)
arenaMinBound, arenaMaxBound = (-10000, -10000), (10000, 10000)
physics.setArenaBounds(arenaMinBound, arenaMaxBound)
physics.owner = weakref.ref(self)
physics.staticMode = False
physics.movementSignals = 0
self.filter.setVehiclePhysics(physics)
physics.visibilityMask = ArenaType.getVisibilityMask(BigWorld.player().arenaTypeID >> 16)
yaw, pitch = decodeGunAngles(self.gunAnglesPacked, typeDescr.gun.pitchLimits['absolute'])
self.filter.syncGunAngles(yaw, pitch)
self.__speedInfo.set(self.filter.speedInfo)
def __setGoalsData(self):
typeID = self.sessionProvider.arenaVisitor.type.getID()
_, geometryID = ArenaType.parseTypeID(typeID)
mapScenarios = self.mapsTrainingController.getConfig(
)['scenarios'][geometryID]
goals = mapScenarios[self.__playerTeam][self.__playerClass]['goals']
text = backport.text(R.strings.maps_training.prebattle.targets(),
count=sum(goals.values()))
self.as_updateS([{
'vehClass': vehCls,
'total': goals[vehCls]
} for vehCls in VEHICLE_CLASSES_ORDER], text)
player = BigWorld.player()
if not player.userSeesWorld():
g_playerEvents.onAvatarReady += self.__onAvatarReady
else:
self.__playSoundNotification()
def __startWGPhysics(self):
typeDescr = self.typeDescriptor
self.wgPhysics = BigWorld.WGVehiclePhysics()
physics = self.wgPhysics
physics_shared.initVehiclePhysics(physics, typeDescr)
arenaMinBound, arenaMaxBound = (-10000, -10000), (10000, 10000)
physics.setArenaBounds(arenaMinBound, arenaMaxBound)
physics.enginePower = typeDescr.physics['enginePower'] / 1000.0
physics.owner = weakref.ref(self)
physics.staticMode = False
physics.movementSignals = 0
physics.damageDestructibleCb = None
physics.destructibleHealthRequestCb = None
self.filter.setVehiclePhysics(physics)
player = BigWorld.player()
physics.visibilityMask = ArenaType.getVisibilityMask(player.arenaTypeID >> 16)
yaw, pitch = decodeGunAngles(self.gunAnglesPacked, typeDescr.gun['pitchLimits']['absolute'])
self.filter.syncGunAngles(yaw, pitch)
self.appearance.fashion.placingCompensationMatrix = self.filter.placingCompensationMatrix
def __startWGPhysics(self):
if not hasattr(self.filter, 'setVehiclePhysics'):
return
typeDescr = self.typeDescriptor
physics = BigWorld.WGVehiclePhysics()
physics_shared.initVehiclePhysics(physics, typeDescr)
arenaMinBound, arenaMaxBound = (-10000, -10000), (10000, 10000)
physics.setArenaBounds(arenaMinBound, arenaMaxBound)
physics.enginePower = typeDescr.physics['enginePower'] / 1000.0
physics.owner = weakref.ref(self)
physics.staticMode = False
physics.movementSignals = 0
physics.damageDestructibleCb = None
physics.destructibleHealthRequestCb = None
self.filter.setVehiclePhysics(physics)
physics.visibilityMask = ArenaType.getVisibilityMask(BigWorld.player().arenaTypeID >> 16)
yaw, pitch = decodeGunAngles(self.gunAnglesPacked, typeDescr.gun['pitchLimits']['absolute'])
self.filter.syncGunAngles(yaw, pitch)
self.appearance.fashion.placingCompensationMatrix = self.filter.placingCompensationMatrix
def _setGoals(self):
if not isPlayerAvatar():
return
typeID = self.sessionProvider.arenaVisitor.type.getID()
_, geometryID = ArenaType.parseTypeID(typeID)
mapScenarios = self.mapsTrainingController.getConfig(
)['scenarios'][geometryID]
playerVehicle = self.sessionProvider.arenaVisitor.vehicles.getVehicleInfo(
BigWorld.player().playerVehicleID)
playerClass = vehicles.getVehicleClassFromVehicleType(
playerVehicle['vehicleType'].type)
playerTeam = playerVehicle['team']
goals = mapScenarios[playerTeam][playerClass]['goals']
sortedData = []
for vehCls in VEHICLE_CLASSES_ORDER:
goal = self.goalsByType[vehCls]
goal['total'] = goals[vehCls]
sortedData.append(goal)
self.as_updateS(sortedData)
def __startWGPhysics(self):
if not hasattr(self.filter, 'setVehiclePhysics'):
return
else:
typeDescr = self.typeDescriptor
physics = BigWorld.WGVehiclePhysics()
physics_shared.initVehiclePhysics(physics, typeDescr, None, False)
arenaMinBound, arenaMaxBound = (-10000, -10000), (10000, 10000)
physics.setArenaBounds(arenaMinBound, arenaMaxBound)
physics.enginePower = typeDescr.physics['enginePower'] / 1000.0
physics.owner = weakref.ref(self)
physics.staticMode = False
physics.movementSignals = 0
physics.damageDestructibleCb = None
physics.destructibleHealthRequestCb = None
self.filter.setVehiclePhysics(physics)
physics.visibilityMask = ArenaType.getVisibilityMask(BigWorld.player().arenaTypeID >> 16)
yaw, pitch = decodeGunAngles(self.gunAnglesPacked, typeDescr.gun['pitchLimits']['absolute'])
self.filter.syncGunAngles(yaw, pitch)
self.__speedInfo.set(self.filter.speedInfo)
return
def _populate(self):
super(DemonstratorWindow, self)._populate()
maps = dict(ctf=[], assault=[], domination=[], nations=[], ctf30x30=[], domination30x30=[])
serverSettings = self.lobbyContext.getServerSettings()
availableRandomMaps = serverSettings.getRandomMapsForDemonstrator()
for arenaTypeID, arenaType in ArenaType.g_cache.iteritems():
if arenaType.explicitRequestOnly:
continue
if arenaType.gameplayName not in maps:
continue
gameplayID, geometryID = ArenaType.parseTypeID(arenaTypeID)
geometry = (geometryID, gameplayID)
if any((geometry in divisionMaps for divisionMaps in availableRandomMaps.itervalues())):
maps[arenaType.gameplayName].append({'id': arenaTypeID,
'name': arenaType.name,
'type': arenaType.gameplayName})
sorting = lambda item: item['name']
self.as_setDataS({'standard': sorted(maps['ctf'] + maps['ctf30x30'], key=sorting),
'assault': sorted(maps['assault'], key=sorting),
'encounter': sorted(maps['domination'] + maps['domination30x30'], key=sorting),
'nations': sorted(maps['nations'], key=sorting)})
def init(scriptConfig, engineConfig, userPreferences, loadingScreenGUI=None):
global g_replayCtrl
global g_onBeforeSendEvent
try:
log.config.setupFromXML()
if constants.IS_DEVELOPMENT:
autoFlushPythonLog()
from development_features import initDevBonusTypes
initDevBonusTypes()
import Event
g_onBeforeSendEvent = Event.Event()
BigWorld.wg_initCustomSettings()
Settings.g_instance = Settings.Settings(scriptConfig, engineConfig, userPreferences)
CommandMapping.g_instance = CommandMapping.CommandMapping()
from helpers import DecalMap
DecalMap.g_instance = DecalMap.DecalMap(scriptConfig['decal'])
from helpers import EdgeDetectColorController
EdgeDetectColorController.g_instance = EdgeDetectColorController.EdgeDetectColorController(scriptConfig['silhouetteColors'])
SoundGroups.g_instance = SoundGroups.SoundGroups()
import BattleReplay
g_replayCtrl = BattleReplay.g_replayCtrl = BattleReplay.BattleReplay()
g_replayCtrl.registerWotReplayFileExtension()
g_bootcamp.replayCallbackSubscribe()
try:
from Vibroeffects import VibroManager
VibroManager.g_instance = VibroManager.VibroManager()
VibroManager.g_instance.connect()
except Exception:
LOG_CURRENT_EXCEPTION()
tutorialLoaderInit()
BigWorld.callback(0.1, asyncore_call)
import items
items.init(True, None if not constants.IS_DEVELOPMENT else {})
import win_points
win_points.init()
import rage
rage.init()
import ArenaType
ArenaType.init()
import dossiers2
dossiers2.init()
import personal_missions
personal_missions.init()
import motivation_quests
motivation_quests.init()
BigWorld.worldDrawEnabled(False)
dependency.configure(services_config.getClientServicesConfig)
gui_personality.init(loadingScreenGUI=loadingScreenGUI)
EdgeDetectColorController.g_instance.create()
g_replayCtrl.subscribe()
MessengerEntry.g_instance.init()
AreaDestructibles.init()
MusicControllerWWISE.create()
TriggersManager.init()
RSSDownloader.init()
items.clearXMLCache()
SoundGroups.loadLightSoundsDB()
import player_ranks
player_ranks.init()
import destructible_entities
destructible_entities.init()
try:
from LightFx import LightManager
LightManager.g_instance = LightManager.LightManager()
import AuxiliaryFx
AuxiliaryFx.g_instance = AuxiliaryFx.AuxiliaryFxManager()
except Exception:
LOG_CURRENT_EXCEPTION()
from AvatarInputHandler.cameras import FovExtended
FovExtended.instance().resetFov()
BigWorld.pauseDRRAutoscaling(True)
except Exception:
LOG_CURRENT_EXCEPTION()
BigWorld.quit()
return
def getValue(name):
return ArenaType.getVisibilityMask(ArenaType.getGameplayIDForName(name))
from gui.Scaleform.daapi.view.lobby.trainings.TrainingSettingsWindow import TrainingSettingsWindow
from gui.Scaleform.genConsts.PREBATTLE_ALIASES import PREBATTLE_ALIASES
from gui.app_loader import states
from gui.app_loader.loader import g_appLoader
from gui.Scaleform.framework.managers.loaders import ViewLoadParams
from gui.modsListApi import g_modsListApi
from gui.mods.observer import LOG_NOTE, LOG_DEBUG, WOT_UTILS, IS_AUTOSTART
from helpers import dependency
from skeletons.connection_mgr import IConnectionManager
from skeletons.gui.lobby_context import ILobbyContext
ArenaType.init()
OBSERVER_ALIAS = 'mod_observer'
DEFAULT_SPACE_NAME = sorted(ArenaType.g_geometryNamesToIDs.keys())[0]
# DEFAULT_SPACE_NAME = '208_bf_epic_normandy'
# DEFAULT_SPACE_NAME = '00_tank_tutorial'
# DEFAULT_SPACE_NAME = '04_himmelsdorf'
# DEFAULT_SPACE_NAME = '06_ensk'
# DEFAULT_SPACE_NAME = '02_malinovka'
# DEFAULT_SPACE_NAME = '112_eiffel_tower_ctf'
class ObserverWindow(AbstractWindowView):
def _populate(self):
g_instance.onUpdate += self.onUpdate
super(ObserverWindow, self)._populate()
def getValue(name):
return ArenaType.getVisibilityMask(ArenaType.getGameplayIDForName(name))
def arenaVisibilityMask(self):
return ArenaType.getVisibilityMask(self.arenaTypeID >> 16)
def __init__(self, settingName, gameplayName, storage):
super(GameplaySetting, self).__init__(settingName, storage)
self.gameplayName = gameplayName
self.bit = ArenaType.getVisibilityMask(
ArenaType.getGameplayIDForName(self.gameplayName))
def getDefaultMask():
return ArenaType.getGameplaysMask(ENABLED_ARENA_GAMEPLAY_NAMES)
def init(scriptConfig, engineConfig, userPreferences, loadingScreenGUI=None):
global g_replayCtrl
try:
if constants.IS_DEVELOPMENT:
autoFlushPythonLog()
LOG_DEBUG('init')
BigWorld.wg_initCustomSettings()
Settings.g_instance = Settings.Settings(scriptConfig, engineConfig,
userPreferences)
CommandMapping.g_instance = CommandMapping.CommandMapping()
from helpers import DecalMap
DecalMap.g_instance = DecalMap.DecalMap(scriptConfig['decal'])
from helpers import EdgeDetectColorController
EdgeDetectColorController.g_instance = EdgeDetectColorController.EdgeDetectColorController(
scriptConfig['silhouetteColors'])
import SoundGroups
SoundGroups.g_instance = SoundGroups.SoundGroups()
import BattleReplay
g_replayCtrl = BattleReplay.g_replayCtrl = BattleReplay.BattleReplay()
g_replayCtrl.registerWotReplayFileExtension()
try:
import Vibroeffects
Vibroeffects.VibroManager.g_instance = Vibroeffects.VibroManager.VibroManager(
)
Vibroeffects.VibroManager.g_instance.connect()
except:
LOG_CURRENT_EXCEPTION()
tutorialLoaderInit()
BigWorld.callback(0.1, asyncore_call)
MessengerEntry.g_instance.init()
import items
items.init(True, None if not constants.IS_DEVELOPMENT else {})
import ArenaType
ArenaType.init()
import dossiers1
dossiers1.init()
import dossiers2
dossiers2.init()
BigWorld.worldDrawEnabled(False)
import LcdKeyboard
LcdKeyboard.enableLcdKeyboardSpecificKeys(True)
gui_personality.init(loadingScreenGUI=loadingScreenGUI)
AreaDestructibles.init()
MusicController.init()
TriggersManager.init()
RSSDownloader.init()
g_postProcessing.init()
try:
from LightFx import LightManager
LightManager.g_instance = LightManager.LightManager()
import AuxiliaryFx
AuxiliaryFx.g_instance = AuxiliaryFx.AuxiliaryFxManager()
except:
LOG_CURRENT_EXCEPTION()
except Exception:
LOG_CURRENT_EXCEPTION()
BigWorld.quit()
return
def __init__(self, settingName, gameplayName, storage):
super(GameplaySetting, self).__init__(settingName, storage)
self.gameplayName = gameplayName
self.bit = ArenaType.getVisibilityMask(ArenaType.getGameplayIDForName(self.gameplayName))
def __getSettings(self):
settings = [self.graphicsPresets.getGraphicsPresetsData()]
import VOIP
rh = VOIP.getVOIPManager()
g_windowsStoredData.start()
vManager = VibroManager.g_instance
vEffGroups = vManager.getGroupsSettings()
vEffDefGroup = VibroManager.VibroManager.GroupSettings()
vEffDefGroup.enabled = False
vEffDefGroup.gain = 0
markers = {
'enemy': g_settingsCore.getSetting('enemy'),
'dead': g_settingsCore.getSetting('dead'),
'ally': g_settingsCore.getSetting('ally')
}
config = {
'locale':
getClientOverride(),
'aspectRatio': {
'current': self.resolutions.aspectRatioIndex,
'options': self.resolutions.aspectRatiosList
},
'vertSync':
self.resolutions.isVideoVSync,
'tripleBuffered':
self.resolutions.isTripleBuffered,
'multisampling': {
'current': self.resolutions.multisamplingTypeIndex,
'options': self.resolutions.multisamplingTypesList
},
'customAA': {
'current': self.resolutions.customAAModeIndex,
'options': self.resolutions.customAAModesList
},
'gamma':
self.resolutions.gamma,
'masterVolume':
round(SoundGroups.g_instance.getMasterVolume() * 100),
'musicVolume':
round(SoundGroups.g_instance.getVolume('music') * 100),
'voiceVolume':
round(SoundGroups.g_instance.getVolume('voice') * 100),
'vehiclesVolume':
round(SoundGroups.g_instance.getVolume('vehicles') * 100),
'effectsVolume':
round(SoundGroups.g_instance.getVolume('effects') * 100),
'guiVolume':
round(SoundGroups.g_instance.getVolume('gui') * 100),
'ambientVolume':
round(SoundGroups.g_instance.getVolume('ambient') * 100),
'masterVivoxVolume':
round(SoundGroups.g_instance.getVolume('masterVivox') * 100),
'micVivoxVolume':
round(SoundGroups.g_instance.getVolume('micVivox') * 100),
'masterFadeVivoxVolume':
round(SoundGroups.g_instance.getVolume('masterFadeVivox') * 100),
'captureDevice':
self.__getCaptureDeviceSettings(),
'voiceChatNotSupported':
rh.vivoxDomain == '' or not VoiceChatInterface.g_instance.ready,
'datetimeIdx':
g_settingsCore.serverSettings.getGameSetting('datetimeIdx', 2),
'enableOlFilter':
g_settingsCore.getSetting('enableOlFilter'),
'enableSpamFilter':
g_settingsCore.getSetting('enableSpamFilter'),
'enableStoreChatMws':
g_settingsCore.getSetting('enableStoreMws'),
'enableStoreChatCws':
g_settingsCore.getSetting('enableStoreCws'),
'invitesFromFriendsOnly':
g_settingsCore.getSetting('invitesFromFriendsOnly'),
'storeReceiverInBattle':
g_settingsCore.getSetting('storeReceiverInBattle'),
'dynamicCamera':
g_settingsCore.getSetting('dynamicCamera'),
'horStabilizationSnp':
g_settingsCore.getSetting('horStabilizationSnp'),
'enableVoIP':
VOIP.getVOIPManager().channelsMgr.enabled,
'enablePostMortemEffect':
g_settingsCore.getSetting('enablePostMortemEffect'),
'nationalVoices':
AccountSettings.getSettings('nationalVoices'),
'isColorBlind':
AccountSettings.getSettings('isColorBlind'),
'useServerAim':
g_settingsCore.getSetting('useServerAim'),
'showVehiclesCounter':
g_settingsCore.getSetting('showVehiclesCounter'),
'minimapAlpha':
g_settingsCore.getSetting('minimapAlpha'),
'vibroIsConnected':
vManager.connect(),
'vibroGain':
vManager.getGain() * 100,
'vibroEngine':
vEffGroups.get('engine', vEffDefGroup).gain * 100,
'vibroAcceleration':
vEffGroups.get('acceleration', vEffDefGroup).gain * 100,
'vibroShots':
vEffGroups.get('shots', vEffDefGroup).gain * 100,
'vibroHits':
vEffGroups.get('hits', vEffDefGroup).gain * 100,
'vibroCollisions':
vEffGroups.get('collisions', vEffDefGroup).gain * 100,
'vibroDamage':
vEffGroups.get('damage', vEffDefGroup).gain * 100,
'vibroGUI':
vEffGroups.get('gui', vEffDefGroup).gain * 100,
'ppShowLevels':
g_settingsCore.getSetting('ppShowLevels'),
'ppShowTypes':
AccountSettings.getSettings('players_panel')['showTypes'],
'replayEnabled':
g_settingsCore.getSetting('replayEnabled'),
'fpsPerfomancer':
g_settingsCore.getSetting('fpsPerfomancer'),
'arcade': {
'values':
g_settingsCore.options.getSetting(
'arcade').toAccountSettings(),
'options':
SettingsInterface.CURSOR_VALUES
},
'sniper': {
'values':
g_settingsCore.options.getSetting(
'sniper').toAccountSettings(),
'options':
SettingsInterface.SNIPER_VALUES
},
'markers': {
'values': markers,
'options': SettingsInterface.MARKER_VALUES,
'types': SettingsInterface.MARKER_TYPES
}
}
if self.__altVoiceSetting.isOptionEnabled():
altVoices = []
for idx, desc in enumerate(self.__altVoiceSetting.getOptions()):
altVoices.append({'data': idx, 'label': desc})
config['alternativeVoices'] = {
'current': self.__altVoiceSetting.get(),
'options': altVoices
}
gameplayMask = gameplay_ctx.getMask()
for name in ArenaType.g_gameplayNames:
key = self.GAMEPLAY_KEY_FORMAT.format(name)
bit = ArenaType.getVisibilityMask(
ArenaType.getGameplayIDForName(name))
config[key] = gameplayMask & bit > 0
settings.append(config)
if not LogitechMonitor.isPresentColor():
if self.KEYBOARD_MAPPING_BLOCKS.has_key('logitech_keyboard'):
del self.KEYBOARD_MAPPING_BLOCKS['logitech_keyboard']
else:
self.KEYBOARD_MAPPING_BLOCKS['logitech_keyboard'] = (
'switch_view', )
cmdMap = CommandMapping.g_instance
defaults = cmdMap.getDefaults()
keyboard = []
for group_name in self.KEYBOARD_MAPPING_BLOCKS_ORDER:
if group_name in self.KEYBOARD_MAPPING_BLOCKS.keys():
group = {'id': group_name, 'commands': []}
keyboard.append(group)
for key_setting in self.KEYBOARD_MAPPING_BLOCKS[group_name]:
command = cmdMap.getCommand(
self.KEYBOARD_MAPPING_COMMANDS[group_name]
[key_setting])
keyCode = cmdMap.get(
self.KEYBOARD_MAPPING_COMMANDS[group_name]
[key_setting])
defaultCode = defaults[command] if defaults.has_key(
command) else 0
key = {
'id': key_setting,
'command': command,
'key': getScaleformKey(keyCode),
'keyDefault': getScaleformKey(defaultCode)
}
group['commands'].append(key)
settings.append(keyboard)
mouse = {}
player = BigWorld.player()
if hasattr(player.inputHandler, 'ctrls'):
for key, path in SettingsInterface.MOUSE_KEYS['ingame'].items():
if key == 'horInvert':
value = g_settingsCore.getSetting('mouseHorzInvert')
elif key == 'vertInvert':
value = g_settingsCore.getSetting('mouseVertInvert')
elif key == 'backDraftInvert':
value = g_settingsCore.getSetting('backDraftInvert')
else:
value = player.inputHandler.ctrls[
path[0]].camera.getUserConfigValue(path[1])
mouse[key] = {
'defaultValue':
SettingsInterface.MOUSE_KEYS['default'][key],
'value': value
}
else:
ds = Settings.g_instance.userPrefs[Settings.KEY_CONTROL_MODE]
for key, path in SettingsInterface.MOUSE_KEYS['lobby'].items():
default = SettingsInterface.MOUSE_KEYS['default'][key]
value = default
if key == 'horInvert':
value = g_settingsCore.getSetting('mouseHorzInvert')
elif key == 'vertInvert':
value = g_settingsCore.getSetting('mouseVertInvert')
elif key == 'backDraftInvert':
value = g_settingsCore.getSetting('backDraftInvert')
elif ds is not None:
if path[2] == 'float':
value = ds[path[0]].readFloat(path[1], default)
elif path[2] == 'bool':
value = ds[path[0]].readBool(path[1], default)
else:
LOG_DEBUG('Unknown mouse settings type %s %s' %
(key, path))
mouse[key] = {'defaultValue': default, 'value': value}
settings.append(mouse)
g_windowsStoredData.stop()
return settings
def __getSettings(self):
settings = [self.graphicsPresets.getGraphicsPresetsData()]
import VOIP
rh = VOIP.getVOIPManager()
g_windowsStoredData.start()
vManager = VibroManager.g_instance
vEffGroups = vManager.getGroupsSettings()
vEffDefGroup = VibroManager.VibroManager.GroupSettings()
vEffDefGroup.enabled = False
vEffDefGroup.gain = 0
markers = {'enemy': g_settingsCore.getSetting('enemy'),
'dead': g_settingsCore.getSetting('dead'),
'ally': g_settingsCore.getSetting('ally')}
config = {'locale': getClientOverride(),
'aspectRatio': {'current': self.resolutions.aspectRatioIndex,
'options': self.resolutions.aspectRatiosList},
'vertSync': self.resolutions.isVideoVSync,
'tripleBuffered': self.resolutions.isTripleBuffered,
'multisampling': {'current': self.resolutions.multisamplingTypeIndex,
'options': self.resolutions.multisamplingTypesList},
'customAA': {'current': self.resolutions.customAAModeIndex,
'options': self.resolutions.customAAModesList},
'gamma': self.resolutions.gamma,
'masterVolume': round(SoundGroups.g_instance.getMasterVolume() * 100),
'musicVolume': round(SoundGroups.g_instance.getVolume('music') * 100),
'voiceVolume': round(SoundGroups.g_instance.getVolume('voice') * 100),
'vehiclesVolume': round(SoundGroups.g_instance.getVolume('vehicles') * 100),
'effectsVolume': round(SoundGroups.g_instance.getVolume('effects') * 100),
'guiVolume': round(SoundGroups.g_instance.getVolume('gui') * 100),
'ambientVolume': round(SoundGroups.g_instance.getVolume('ambient') * 100),
'masterVivoxVolume': round(SoundGroups.g_instance.getVolume('masterVivox') * 100),
'micVivoxVolume': round(SoundGroups.g_instance.getVolume('micVivox') * 100),
'masterFadeVivoxVolume': round(SoundGroups.g_instance.getVolume('masterFadeVivox') * 100),
'captureDevice': self.__getCaptureDeviceSettings(),
'voiceChatNotSupported': rh.vivoxDomain == '' or not VoiceChatInterface.g_instance.ready,
'datetimeIdx': g_settingsCore.serverSettings.getGameSetting('datetimeIdx', 2),
'enableOlFilter': g_settingsCore.getSetting('enableOlFilter'),
'enableSpamFilter': g_settingsCore.getSetting('enableSpamFilter'),
'enableStoreChatMws': g_settingsCore.getSetting('enableStoreMws'),
'enableStoreChatCws': g_settingsCore.getSetting('enableStoreCws'),
'invitesFromFriendsOnly': g_settingsCore.getSetting('invitesFromFriendsOnly'),
'storeReceiverInBattle': g_settingsCore.getSetting('storeReceiverInBattle'),
'dynamicCamera': g_settingsCore.getSetting('dynamicCamera'),
'horStabilizationSnp': g_settingsCore.getSetting('horStabilizationSnp'),
'enableVoIP': VOIP.getVOIPManager().channelsMgr.enabled,
'enablePostMortemEffect': g_settingsCore.getSetting('enablePostMortemEffect'),
'nationalVoices': AccountSettings.getSettings('nationalVoices'),
'isColorBlind': AccountSettings.getSettings('isColorBlind'),
'useServerAim': g_settingsCore.getSetting('useServerAim'),
'showVehiclesCounter': g_settingsCore.getSetting('showVehiclesCounter'),
'minimapAlpha': g_settingsCore.getSetting('minimapAlpha'),
'vibroIsConnected': vManager.connect(),
'vibroGain': vManager.getGain() * 100,
'vibroEngine': vEffGroups.get('engine', vEffDefGroup).gain * 100,
'vibroAcceleration': vEffGroups.get('acceleration', vEffDefGroup).gain * 100,
'vibroShots': vEffGroups.get('shots', vEffDefGroup).gain * 100,
'vibroHits': vEffGroups.get('hits', vEffDefGroup).gain * 100,
'vibroCollisions': vEffGroups.get('collisions', vEffDefGroup).gain * 100,
'vibroDamage': vEffGroups.get('damage', vEffDefGroup).gain * 100,
'vibroGUI': vEffGroups.get('gui', vEffDefGroup).gain * 100,
'ppShowLevels': g_settingsCore.getSetting('ppShowLevels'),
'ppShowTypes': AccountSettings.getSettings('players_panel')['showTypes'],
'replayEnabled': g_settingsCore.getSetting('replayEnabled'),
'fpsPerfomancer': g_settingsCore.getSetting('fpsPerfomancer'),
'arcade': {'values': g_settingsCore.options.getSetting('arcade').toAccountSettings(),
'options': SettingsInterface.CURSOR_VALUES},
'sniper': {'values': g_settingsCore.options.getSetting('sniper').toAccountSettings(),
'options': SettingsInterface.SNIPER_VALUES},
'markers': {'values': markers,
'options': SettingsInterface.MARKER_VALUES,
'types': SettingsInterface.MARKER_TYPES}}
if self.__altVoiceSetting.isOptionEnabled():
altVoices = []
for idx, desc in enumerate(self.__altVoiceSetting.getOptions()):
altVoices.append({'data': idx,
'label': desc})
config['alternativeVoices'] = {'current': self.__altVoiceSetting.get(),
'options': altVoices}
gameplayMask = gameplay_ctx.getMask()
for name in ArenaType.g_gameplayNames:
key = self.GAMEPLAY_KEY_FORMAT.format(name)
bit = ArenaType.getVisibilityMask(ArenaType.getGameplayIDForName(name))
config[key] = gameplayMask & bit > 0
settings.append(config)
if not LogitechMonitor.isPresentColor():
if self.KEYBOARD_MAPPING_BLOCKS.has_key('logitech_keyboard'):
del self.KEYBOARD_MAPPING_BLOCKS['logitech_keyboard']
else:
self.KEYBOARD_MAPPING_BLOCKS['logitech_keyboard'] = ('switch_view',)
cmdMap = CommandMapping.g_instance
defaults = cmdMap.getDefaults()
keyboard = []
for group_name in self.KEYBOARD_MAPPING_BLOCKS_ORDER:
if group_name in self.KEYBOARD_MAPPING_BLOCKS.keys():
group = {'id': group_name,
'commands': []}
keyboard.append(group)
for key_setting in self.KEYBOARD_MAPPING_BLOCKS[group_name]:
command = cmdMap.getCommand(self.KEYBOARD_MAPPING_COMMANDS[group_name][key_setting])
keyCode = cmdMap.get(self.KEYBOARD_MAPPING_COMMANDS[group_name][key_setting])
defaultCode = defaults[command] if defaults.has_key(command) else 0
key = {'id': key_setting,
'command': command,
'key': getScaleformKey(keyCode),
'keyDefault': getScaleformKey(defaultCode)}
group['commands'].append(key)
settings.append(keyboard)
mouse = {}
player = BigWorld.player()
if hasattr(player.inputHandler, 'ctrls'):
for key, path in SettingsInterface.MOUSE_KEYS['ingame'].items():
if key == 'horInvert':
value = g_settingsCore.getSetting('mouseHorzInvert')
elif key == 'vertInvert':
value = g_settingsCore.getSetting('mouseVertInvert')
elif key == 'backDraftInvert':
value = g_settingsCore.getSetting('backDraftInvert')
else:
value = player.inputHandler.ctrls[path[0]].camera.getUserConfigValue(path[1])
mouse[key] = {'defaultValue': SettingsInterface.MOUSE_KEYS['default'][key],
'value': value}
else:
ds = Settings.g_instance.userPrefs[Settings.KEY_CONTROL_MODE]
for key, path in SettingsInterface.MOUSE_KEYS['lobby'].items():
default = SettingsInterface.MOUSE_KEYS['default'][key]
value = default
if key == 'horInvert':
value = g_settingsCore.getSetting('mouseHorzInvert')
elif key == 'vertInvert':
value = g_settingsCore.getSetting('mouseVertInvert')
elif key == 'backDraftInvert':
value = g_settingsCore.getSetting('backDraftInvert')
elif ds is not None:
if path[2] == 'float':
value = ds[path[0]].readFloat(path[1], default)
elif path[2] == 'bool':
value = ds[path[0]].readBool(path[1], default)
else:
LOG_DEBUG('Unknown mouse settings type %s %s' % (key, path))
mouse[key] = {'defaultValue': default,
'value': value}
settings.append(mouse)
g_windowsStoredData.stop()
return settings
def init(scriptConfig, engineConfig, userPreferences, loadingScreenGUI=None):
global g_replayCtrl
try:
if constants.IS_DEVELOPMENT:
autoFlushPythonLog()
BigWorld.wg_initCustomSettings()
g_postProcessing.init()
Settings.g_instance = Settings.Settings(scriptConfig, engineConfig,
userPreferences)
CommandMapping.g_instance = CommandMapping.CommandMapping()
from helpers import DecalMap
DecalMap.g_instance = DecalMap.DecalMap(scriptConfig['decal'])
from helpers import EdgeDetectColorController
EdgeDetectColorController.g_instance = EdgeDetectColorController.EdgeDetectColorController(
scriptConfig['silhouetteColors'])
import SoundGroups
SoundGroups.g_instance = SoundGroups.SoundGroups()
import BattleReplay
g_replayCtrl = BattleReplay.g_replayCtrl = BattleReplay.BattleReplay()
g_replayCtrl.registerWotReplayFileExtension()
try:
from Vibroeffects import VibroManager
VibroManager.g_instance = VibroManager.VibroManager()
VibroManager.g_instance.connect()
except:
LOG_CURRENT_EXCEPTION()
tutorialLoaderInit()
BigWorld.callback(0.1, asyncore_call)
import items
items.init(True, None if not constants.IS_DEVELOPMENT else {})
import win_points
win_points.init()
import rage
rage.init()
import ArenaType
ArenaType.init()
import dossiers2
dossiers2.init()
import fortified_regions
fortified_regions.init()
import clubs_settings
clubs_settings.init()
import potapov_quests
potapov_quests.init()
import clubs_quests
clubs_quests.init()
import motivation_quests
motivation_quests.init()
BigWorld.worldDrawEnabled(False)
import LcdKeyboard
LcdKeyboard.enableLcdKeyboardSpecificKeys(True)
dependency.configure(services_config.getClientServicesConfig)
gui_personality.init(loadingScreenGUI=loadingScreenGUI)
EdgeDetectColorController.g_instance.create()
g_replayCtrl.subscribe()
MessengerEntry.g_instance.init()
AreaDestructibles.init()
MusicControllerWWISE.create()
TriggersManager.init()
RSSDownloader.init()
SoundGroups.loadLightSoundsDB()
try:
from LightFx import LightManager
LightManager.g_instance = LightManager.LightManager()
import AuxiliaryFx
AuxiliaryFx.g_instance = AuxiliaryFx.AuxiliaryFxManager()
except:
LOG_CURRENT_EXCEPTION()
from AvatarInputHandler.cameras import FovExtended
FovExtended.instance().resetFov()
BigWorld.pauseDRRAutoscaling(True)
except Exception:
LOG_CURRENT_EXCEPTION()
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
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
