def __onWriteCache(self, name, packet):
try:
if not isPlayerAccount():
LOG_DEBUG_DEV(
'Trying to write cache record to db while in battle')
startTime = time.time()
if self.__db is not None and isPlayerAccount():
self.__db[name] = packet
self.__db.sync()
_LOG_EXECUTING_TIME(startTime, '__onWriteCache', 5.0)
except Exception:
LOG_CURRENT_EXCEPTION()
self.__written_cache.discard(name)
return
def onChunkLoad(self, chunkID, numDestructibles):
if self.__spaceID is None:
LOG_ERROR("Notification about chunk load came when no space started")
return
if numDestructibles > 256:
if not isPlayerAccount():
self.__logErrorTooMuchDestructibles(chunkID)
destrFilenames = BigWorld.wg_getChunkDestrFilenames(self.__spaceID, chunkID)
if destrFilenames is None:
LOG_ERROR("Can't get destructibles filenames list for space %s, chunk %s" % (self.__spaceID, chunkID))
return
for destrIndex in xrange(numDestructibles):
self.__setDestructibleInitialState(chunkID, destrIndex)
self.__loadedChunkIDs[chunkID] = numDestructibles
chunkEntries = self.__destructiblesWaitDestroy.get(chunkID)
if chunkEntries is not None:
for dmgType, destrData, isNeedAnimation in chunkEntries:
self.__destroyDestructible(chunkID, dmgType, destrData, isNeedAnimation)
del self.__destructiblesWaitDestroy[chunkID]
consideredNames = set()
prereqs = set()
for fname in destrFilenames:
if fname not in consideredNames:
consideredNames.add(fname)
desc = g_cache.getDescByFilename(fname)
if desc is not None:
effLists = _extractEffectLists(desc)
for effList in effLists:
prereqs.update(effList.prerequisites())
if prereqs:
BigWorld.loadResourceListBG(list(prereqs), partial(self.__onResourceLoad, self.__spaceID, chunkID))
def __launchTreeFallEffect(self,
chunkID,
destrIndex,
effectType,
fallDirYaw,
tintColor=COLOR_WHITE):
player = BigWorld.player()
if player is None or isPlayerAccount():
return
else:
effectName = BigWorld.wg_getDestructibleEffectName(
self.__spaceID, chunkID, destrIndex, -1, effectType)
if effectName == 'none':
return
effectVars = g_cache._getEffect(effectName, 'trees', False)
if effectVars is None:
return
effectStuff = random.choice(effectVars)
chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID)
destrMatrix = BigWorld.wg_getDestructibleMatrix(
self.__spaceID, chunkID, destrIndex)
pos = chunkMatrix.translation + destrMatrix.translation
direction = Math.Vector3(math.sin(fallDirYaw), 0.0,
math.cos(fallDirYaw))
treeScale = destrMatrix.applyVector((0.0, 1.0, 0.0)).length
scale = 1.0 + (treeScale - 1.0) * _TREE_EFFECTS_SCALE_RATIO
player.terrainEffects.addNew(pos,
effectStuff.effectsList,
effectStuff.keyPoints,
None,
dir=direction,
scale=scale,
tintColor=tintColor)
return
def __cooldownCallback(self, callback):
if isPlayerAccount():
BigWorld.player().requestWGMBalanceInfo(callback)
else:
self.__request = None
LOG_WARNING('The player is no longer an Account, the request to WGM is skipped')
return
def onClientUpdate(diff):
yield lambda callback: callback(None)
if isPlayerAccount():
yield g_itemsCache.update(CACHE_SYNC_REASON.CLIENT_UPDATE, diff)
yield g_eventsCache.update(diff)
yield g_clanCache.update(diff)
g_clientUpdateManager.update(diff)
def __launchFallEffect(self, chunkID, destrIndex, effectType, fallDirYaw):
player = BigWorld.player()
if player is None or isPlayerAccount():
return
else:
effectName = BigWorld.wg_getDestructibleEffectName(
self.__spaceID, chunkID, destrIndex, -1, effectType)
if effectName == 'none':
return
effectVars = g_cache._getEffect(effectName, 'fallingAtoms', False)
if effectVars is None:
return
effectStuff = random.choice(effectVars)
chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID)
destrMatrix = BigWorld.wg_getDestructibleMatrix(
self.__spaceID, chunkID, destrIndex)
pos = chunkMatrix.translation + destrMatrix.translation
dir = Math.Vector3(math.sin(fallDirYaw), 0.0, math.cos(fallDirYaw))
scale = BigWorld.wg_getDestructibleEffectScale(
self.__spaceID, chunkID, destrIndex, -1)
player.terrainEffects.addNew(pos,
effectStuff.effectsList,
effectStuff.keyPoints,
None,
dir=dir,
scale=scale)
return
def __launchTreeFallEffect(self, chunkID, destrIndex, effectName,
fallDirYaw):
player = BigWorld.player()
if player is None or isPlayerAccount():
return
else:
desc = g_cache.getDestructibleDesc(self.__spaceID, chunkID,
destrIndex)
if desc is None:
_printErrDescNotAvailable(self.__spaceID, chunkID, destrIndex)
return
effectVars = desc.get(effectName)
if effectVars is None:
return
effectStuff = random.choice(effectVars)
chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID)
destrMatrix = BigWorld.wg_getDestructibleMatrix(
self.__spaceID, chunkID, destrIndex)
pos = chunkMatrix.translation + destrMatrix.translation
dir = Math.Vector3(math.sin(fallDirYaw), 0.0, math.cos(fallDirYaw))
treeScale = destrMatrix.applyVector((0.0, 1.0, 0.0)).length
scale = 1.0 + (treeScale - 1.0) * _TREE_EFFECTS_SCALE_RATIO
player.terrainEffects.addNew(pos,
effectStuff.effectsList,
effectStuff.keyPoints,
None,
dir=dir,
scale=scale)
return
def __onAccountBecomePlayer(self):
self.enableAutoRecordingBattles(True)
if not isPlayerAccount():
return
else:
player = BigWorld.player()
serverSettings = player.serverSettings
self.__serverSettings['roaming'] = serverSettings['roaming']
self.__serverSettings[
'isPotapovQuestEnabled'] = serverSettings.get(
'isPotapovQuestEnabled', False)
if 'spgRedesignFeatures' in serverSettings:
self.__serverSettings['spgRedesignFeatures'] = serverSettings[
'spgRedesignFeatures']
self.__serverSettings['ranked_config'] = serverSettings[
'ranked_config']
self.__serverSettings['battle_royale_config'] = serverSettings[
'battle_royale_config']
self.__serverSettings['epic_config'] = serverSettings[
'epic_config']
self.__serverSettings[SERVER_SETTINGS_KEY] = serverSettings[
SERVER_SETTINGS_KEY]
if player.databaseID is None:
BigWorld.callback(0.1, self.__onAccountBecomePlayer)
else:
self.__playerDatabaseID = player.databaseID
return
def onCreateTypedTooltip(self, type, args, stateType):
if not isPlayerAccount():
return
else:
from gui.Scaleform.daapi.settings.tooltips import TOOLTIPS
if type in TOOLTIPS:
item = TOOLTIPS[type]
getDataMethod = item['method']
tooltipType = item['tooltip']
if getDataMethod is not None:
tooltipData = getDataMethod(*args)
if tooltipData:
complexCondition = item['complex']
if complexCondition is not None:
if complexCondition(tooltipData['data']):
self.as_showS(tooltipData, tooltipType)
else:
self.__genComplexToolTipFromData(tooltipData['data'], stateType, self.__getDefaultTooltipType())
else:
self.as_showS(tooltipData, tooltipType)
elif tooltipType is not None:
self.as_showS(args, tooltipType)
else:
return
return
def __launchEffect(self, args, callbackOnStop=None):
if args.effectName == 'none':
return
else:
effectVars = g_cache._getEffect(args.effectName,
args.effectCategory, False)
if not effectVars:
LOG_ERROR('Could not find any effects vars for: ' +
str(args.effectName) + ' - type: ' +
str(args.effectType) + ' - cat: ' +
str(args.effectCategory) + ' (' +
str(args.destrType) + ')')
return
player = BigWorld.player()
if player is None or isPlayerAccount():
return
effectStuff = random.choice(effectVars)
effectID = player.terrainEffects.addNew(
args.pos,
effectStuff.effectsList,
effectStuff.keyPoints,
callbackOnStop,
dir=args.dir,
scale=args.scale,
havokSpawnedDestructibles=args.isHavokSpawnedDestructibles,
waitForKeyOff=args.effectType == 'lifetimeEffect')
return effectID
def onLobbyInited(self, event):
if not isPlayerAccount():
return
self._updatePromo(self._getPromoEventNotifications())
self._getEventsFotificationController().onEventNotificationsChanged += self.__onEventNotification
self._getBrowserController().onBrowserDeleted += self.__onBrowserDeleted
self._processPromo(self._getEventNotifications())
def __init__(self):
userPrefs = Settings.g_instance.userPrefs
if not userPrefs.has_key(Settings.KEY_REPLAY_PREFERENCES):
userPrefs.write(Settings.KEY_REPLAY_PREFERENCES, '')
self.__settings = userPrefs[Settings.KEY_REPLAY_PREFERENCES]
self.__fileName = None
self.__replayCtrl = BigWorld.WGReplayController()
self.__replayCtrl.replayFinishedCallback = self.onReplayFinished
self.__replayCtrl.controlModeChangedCallback = self.onControlModeChanged
self.__replayCtrl.ammoButtonPressedCallback = self.__onAmmoButtonPressed
self.__replayCtrl.playerVehicleIDChangedCallback = self.onPlayerVehicleIDChanged
self.__replayCtrl.clientVersionDiffersCallback = self.onClientVersionDiffers
self.__replayCtrl.battleChatMessageCallback = self.onBattleChatMessage
self.__replayCtrl.lockTargetCallback = self.onLockTarget
self.__replayCtrl.cruiseModeCallback = self.onSetCruiseMode
self.__replayCtrl.equipmentIdCallback = self.onSetEquipmentId
self.__isAutoRecordingEnabled = False
self.__quitAfterStop = False
self.__isPlayingPlayList = False
self.__playList = []
self.__isFinished = False
self.__isMenuShowed = False
self.__updateGunOnTimeWarp = False
self.__isBattleSimulation = False
battleSimulationSection = userPrefs[_BATTLE_SIMULATION_KEY_PATH]
if battleSimulationSection is not None:
self.__isBattleSimulation = battleSimulationSection.asBool
self.__playerDatabaseID = 0
self.__serverSettings = dict()
if isPlayerAccount():
self.__playerDatabaseID = BigWorld.player().databaseID
self.__playbackSpeedModifiers = (0.0, 0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0)
self.__playbackSpeedModifiersStr = ('0', '1/16', '1/8', '1/4', '1/2', '1', '2', '4', '8', '16')
self.__playbackSpeedIdx = self.__playbackSpeedModifiers.index(1.0)
self.__savedPlaybackSpeedIdx = self.__playbackSpeedIdx
self.__gunWasLockedBeforePause = False
self.__wasVideoBeforeRewind = False
self.__videoCameraMatrix = Math.Matrix()
self.__replayDir = './replays'
self.__replayCtrl.clientVersion = BigWorld.wg_getProductVersion()
self.__timeWarpCleanupCb = None
self.__enableTimeWarp = False
self.__isChatPlaybackEnabled = True
self.__warpTime = -1.0
self.__skipMessage = False
self.__equipmentId = None
self.__rewind = False
self.replayTimeout = 0
self.__arenaPeriod = -1
self.enableAutoRecordingBattles(True)
self.onCommandReceived = Event.Event()
self.onAmmoSettingChanged = Event.Event()
self.onStopped = Event.Event()
if IS_DEVELOPMENT:
try:
import development.replay_override
except:
pass
return
def __launchEffect(self, chunkID, destrIndex, desc, effectType, modelFile, isHavokVisible, callbackOnStop = None):
effectVars = desc.get(effectType)
if effectVars is None:
return
else:
type = desc.get('type')
if type == DESTR_TYPE_TREE or type == DESTR_TYPE_FALLING_ATOM:
chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID)
destrMatrix = BigWorld.wg_getDestructibleMatrix(self.__spaceID, chunkID, destrIndex)
dir = destrMatrix.applyVector((0, 0, 1))
pos = chunkMatrix.translation + destrMatrix.translation
if type == DESTR_TYPE_TREE:
treeScale = destrMatrix.applyVector((0.0, 1.0, 0.0)).length
scale = 1.0 + (treeScale - 1.0) * _TREE_EFFECTS_SCALE_RATIO
else:
scale = desc['effectScale']
else:
hpMatrix = BigWorld.wg_getHardPointMatrix(self.__spaceID, chunkID, destrIndex, desc['effectHP'])
if hpMatrix is None:
LOG_ERROR("Can't find hardpoint %s in model %s" % (desc['effectHP'], modelFile))
return
dir = hpMatrix.applyVector((0, 0, 1))
pos = hpMatrix.translation
scale = desc['effectScale']
player = BigWorld.player()
if player is None or isPlayerAccount():
return
effectStuff = random.choice(effectVars)
effectID = player.terrainEffects.addNew(pos, effectStuff.effectsList, effectStuff.keyPoints, callbackOnStop, dir=dir, scale=scale, havokEnabled=isHavokVisible)
return effectID
def onLobbyInited(self, event):
if not isPlayerAccount():
return
self._updatePromo(self._getPromoEventNotifications())
self.eventsNotification.onEventNotificationsChanged += self.__onEventNotification
self.browserCtrl.onBrowserDeleted += self.__onBrowserDeleted
self._processPromo(self.eventsNotification.getEventsNotifications())
def onLobbyInited(self, event):
if not isPlayerAccount():
return
self._updatePromo(self._getPromoEventNotifications())
self._getEventsFotificationController().onEventNotificationsChanged += self.__onEventNotification
self._getBrowserController().onBrowserDeleted += self.__onBrowserDeleted
self._processPromo(self._getEventNotifications())
def onLobbyStarted(self, event):
if not isPlayerAccount():
return
self._isEnabled = int(self._lobbyContext.getServerSettings().getBlueprintsConvertSaleConfig().isEnabled())
self.__updateActionState()
self._lobbyContext.getServerSettings().onServerSettingsChange += self.__onSettingsChanged
self._eventsCache.onSyncCompleted += self.__onEventsCacheSyncCompleted
def __setClanInfo(self, clanInfo):
"""
Sets the clan info.
:param clanInfo: tuple(clanName, clanAbbrev, chatChannelDBID, memberFlags, enteringTime)
:return:
"""
if not isPlayerAccount():
return
else:
name = BigWorld.player().name
if clanInfo and len(clanInfo) > 1:
clanAbbrev = clanInfo[1]
else:
clanAbbrev = None
hasNew = not AccountSettings.getFilter(BOOSTERS)['wasShown']
activeBoosters = self.goodiesCache.getBoosters(
criteria=REQ_CRITERIA.BOOSTER.ACTIVE).values()
hasActiveBooster = len(activeBoosters) > 0
readyBoosters = self.goodiesCache.getBoosters(
criteria=REQ_CRITERIA.BOOSTER.IS_READY_TO_ACTIVATE).values()
boostersAvailable = sum(
(booster.count for booster in readyBoosters))
hasAvailableBoosters = boostersAvailable > 0
boosterIcon, boosterText = (None, None)
if hasActiveBooster:
boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERICON
booster = sorted(activeBoosters,
key=lambda x: x.getUsageLeftTime())[0]
boosterText = booster.getShortLeftTimeStr()
elif hasAvailableBoosters:
boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_AVAILABLEBOOSTERICON
if boostersAvailable <= _MAX_BOOSTERS_TO_DISPLAY:
boosterText = str(boostersAvailable)
else:
boosterText = str(_MAX_BOOSTERS_TO_DISPLAY) + '+'
self.as_nameResponseS({
'userVO': {
'fullName':
self.lobbyContext.getPlayerFullName(name,
clanInfo=clanInfo),
'userName':
name,
'clanAbbrev':
clanAbbrev
},
'isTeamKiller': self.itemsCache.items.stats.isTeamKiller,
'hasNew': hasNew,
'hasActiveBooster': hasActiveBooster,
'hasAvailableBoosters': hasAvailableBoosters,
'tooltip': TOOLTIPS.HEADER_ACCOUNT,
'tooltipType': TOOLTIP_TYPES.COMPLEX,
'boosterIcon': boosterIcon,
'boosterBg': RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERBG,
'boosterText': boosterText
})
if g_clanCache.clanDBID:
self.requestClanEmblem16x16(g_clanCache.clanDBID)
self.__updateBadge()
return
def onClientUpdate(diff):
yield lambda callback: callback(None)
if isPlayerAccount():
yield g_itemsCache.update(CACHE_SYNC_REASON.CLIENT_UPDATE, diff)
yield ServicesLocator.eventsCache.update(diff)
yield g_clanCache.update(diff)
g_lobbyContext.update(diff)
g_clientUpdateManager.update(diff)
def request(self, callback):
self.__synced = False
if not isPlayerAccount():
yield lambda callback: callback(None)
LOG_ERROR('[class %s] Player is not account.' % self.__class__.__name__)
else:
self._data = yield self._requestCache()
callback(self)
def request(self, callback):
self.__synced = False
if not isPlayerAccount():
yield lambda callback: callback(None)
LOG_ERROR('[class %s] Player is not account.' % self.__class__.__name__)
else:
self._data = yield self._requestCache()
callback(self)
def getPlayerDBID(self):
p = BigWorld.player()
if isPlayerAccount():
return p.databaseID
elif isPlayerAvatar() and hasattr(p, 'playerVehicleID'):
return p.arena.vehicles[p.playerVehicleID].get('accountDBID', None)
else:
return None
def getPlayerDBID(self):
p = BigWorld.player()
if isPlayerAccount():
return p.databaseID
elif isPlayerAvatar() and hasattr(p, 'playerVehicleID'):
return p.arena.vehicles[p.playerVehicleID].get('accountDBID', None)
else:
return None
def __init__(self):
userPrefs = Settings.g_instance.userPrefs
if not userPrefs.has_key(Settings.KEY_REPLAY_PREFERENCES):
userPrefs.write(Settings.KEY_REPLAY_PREFERENCES, '')
self.__settings = userPrefs[Settings.KEY_REPLAY_PREFERENCES]
self.__fileName = None
self.__replayCtrl = BigWorld.WGReplayController()
self.__replayCtrl.replayFinishedCallback = self.onReplayFinished
self.__replayCtrl.controlModeChangedCallback = self.onControlModeChanged
self.__replayCtrl.ammoButtonPressedCallback = self.__onAmmoButtonPressed
self.__replayCtrl.playerVehicleIDChangedCallback = self.onPlayerVehicleIDChanged
self.__replayCtrl.clientVersionDiffersCallback = self.onClientVersionDiffers
self.__replayCtrl.battleChatMessageCallback = self.onBattleChatMessage
self.__replayCtrl.lockTargetCallback = self.onLockTarget
self.__replayCtrl.cruiseModeCallback = self.onSetCruiseMode
self.__replayCtrl.equipmentIdCallback = self.onSetEquipmentId
self.__isAutoRecordingEnabled = False
self.__quitAfterStop = False
self.__isPlayingPlayList = False
self.__playList = []
self.__isFinished = False
self.__isMenuShowed = False
self.__updateGunOnTimeWarp = False
g_playerEvents.onBattleResultsReceived += self.__onBattleResultsReceived
g_playerEvents.onAccountBecomePlayer += self.__onAccountBecomePlayer
g_playerEvents.onArenaPeriodChange += self.__onArenaPeriodChange
from account_helpers.settings_core.SettingsCore import g_settingsCore
g_settingsCore.onSettingsChanged += self.__onSettingsChanging
self.__playerDatabaseID = 0
self.__serverSettings = dict()
if isPlayerAccount():
self.__playerDatabaseID = BigWorld.player().databaseID
self.__playbackSpeedModifiers = (0.0, 0.0625, 0.125, 0.25, 0.5, 1.0,
2.0, 4.0, 8.0, 16.0)
self.__playbackSpeedModifiersStr = ('0', '1/16', '1/8', '1/4', '1/2',
'1', '2', '4', '8', '16')
self.__playbackSpeedIdx = self.__playbackSpeedModifiers.index(1.0)
self.__savedPlaybackSpeedIdx = self.__playbackSpeedIdx
self.__gunWasLockedBeforePause = False
self.__wasVideoBeforeRewind = False
self.__videoCameraMatrix = Math.Matrix()
self.__replayDir = './replays'
self.__replayCtrl.clientVersion = BigWorld.wg_getProductVersion()
self.__timeWarpCleanupCb = None
self.__enableTimeWarp = False
self.__isChatPlaybackEnabled = True
self.__warpTime = -1.0
self.__skipMessage = False
self.__equipmentId = None
self.__rewind = False
self.replayTimeout = 0
self.__arenaPeriod = -1
self.enableAutoRecordingBattles(True)
gui.Scaleform.CursorDelegator.g_cursorDelegator.detachCursor()
self.onCommandReceived = Event.Event()
self.onAmmoSettingChanged = Event.Event()
self.onStopped = Event.Event()
return
def __launchEffect(self, chunkID, destrIndex, moduleIndex, effectType, isHavokVisible, callbackOnStop=None):
destrType = BigWorld.wg_getDestructibleEffectCategory(self.__spaceID, chunkID, destrIndex, moduleIndex)
effectCat = ""
if destrType == DESTR_TYPE_TREE:
effectCat = "trees"
elif destrType == DESTR_TYPE_FALLING_ATOM:
effectCat = "fallingAtoms"
elif destrType == DESTR_TYPE_FRAGILE:
effectCat = "fragiles"
elif destrType == DESTR_TYPE_STRUCTURE:
effectCat = "structures"
effectName = BigWorld.wg_getDestructibleEffectName(self.__spaceID, chunkID, destrIndex, moduleIndex, effectType)
if effectName == "none":
return
else:
effectVars = g_cache._getEffect(effectName, effectCat, False)
if effectVars is None:
LOG_ERROR(
"Could not find any effects vars for: "
+ str(effectName)
+ " - type: "
+ str(effectType)
+ " - cat: "
+ str(effectCat)
+ " ("
+ str(destrType)
+ ")"
)
return
if destrType == DESTR_TYPE_TREE or destrType == DESTR_TYPE_FALLING_ATOM:
chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID)
destrMatrix = BigWorld.wg_getDestructibleMatrix(self.__spaceID, chunkID, destrIndex)
dir = destrMatrix.applyVector((0, 0, 1))
pos = chunkMatrix.translation + destrMatrix.translation
if destrType == DESTR_TYPE_TREE:
treeScale = destrMatrix.applyVector((0.0, 1.0, 0.0)).length
scale = 1.0 + (treeScale - 1.0) * _TREE_EFFECTS_SCALE_RATIO
else:
scale = BigWorld.wg_getDestructibleEffectScale(self.__spaceID, chunkID, destrIndex, moduleIndex)
else:
hpMatrix = BigWorld.wg_getNMHardPointMatrix(self.__spaceID, chunkID, destrIndex, moduleIndex)
dir = hpMatrix.applyVector((0, 0, 1))
pos = hpMatrix.translation
scale = BigWorld.wg_getDestructibleEffectScale(self.__spaceID, chunkID, destrIndex, moduleIndex)
player = BigWorld.player()
if player is None or isPlayerAccount():
return
effectStuff = random.choice(effectVars)
effectID = player.terrainEffects.addNew(
pos,
effectStuff.effectsList,
effectStuff.keyPoints,
callbackOnStop,
dir=dir,
scale=scale,
havokEnabled=isHavokVisible,
)
return effectID
def onClientUpdate(diff):
yield lambda callback: callback(None)
if isPlayerAccount():
yield g_itemsCache.update(diff)
yield g_questsCache.update()
MusicController.g_musicController.setAccountAttrs(g_itemsCache.items.stats.attributes, True)
MusicController.g_musicController.play(MusicController.MUSIC_EVENT_LOBBY)
MusicController.g_musicController.play(MusicController.MUSIC_EVENT_LOBBY)
g_clientUpdateManager.update(diff)
def fini(self, woEvents = False):
self._hasEntity = False
if isPlayerAccount():
for listener in self._listeners:
listener.onPreQueueFunctionalFinished()
self._setListenerClass(None)
self._subscriber.unsubscribe(self)
return
def __stopLifetimeEffect(self, chunkID, destrIndex, moduleKind):
code = _encodeModule(chunkID, destrIndex, moduleKind)
lifetimeEffectID = self.__lifetimeEffects.get(code)
if lifetimeEffectID is None:
return
del self.__lifetimeEffects[code]
player = BigWorld.player()
if player is not None and not isPlayerAccount():
player.terrainEffects.stop(lifetimeEffectID)
def __onAccountBecomePlayer(self):
if not isPlayerAccount():
return
player = BigWorld.player()
if player.databaseID is None:
BigWorld.callback(0.1, self.__onAccountBecomePlayer)
else:
self.__playerDatabaseID = player.databaseID
self.__roamingSettings = player.serverSettings['roaming']
def __startAutoRecord(self):
if not self.__isAutoRecordingEnabled:
return
if self.isPlaying:
return
if self.isRecording or not isPlayerAccount():
BigWorld.callback(0.1, self.__startAutoRecord)
return
self.record()
def __startAutoRecord(self):
if not self.__isAutoRecordingEnabled:
return
if self.isPlaying:
return
if self.isRecording or not isPlayerAccount():
BigWorld.callback(0.1, self.__startAutoRecord)
return
self.record()
def __init__(self):
userPrefs = Settings.g_instance.userPrefs
if not userPrefs.has_key(Settings.KEY_REPLAY_PREFERENCES):
userPrefs.write(Settings.KEY_REPLAY_PREFERENCES, '')
self.__settings = userPrefs[Settings.KEY_REPLAY_PREFERENCES]
self.__fileName = None
self.__replayCtrl = BigWorld.WGReplayController()
self.__replayCtrl.replayFinishedCallback = self.onReplayFinished
self.__replayCtrl.controlModeChangedCallback = self.onControlModeChanged
self.__replayCtrl.ammoButtonPressedCallback = self.__onAmmoButtonPressed
self.__replayCtrl.playerVehicleIDChangedCallback = self.onPlayerVehicleIDChanged
self.__replayCtrl.clientVersionDiffersCallback = self.onClientVersionDiffers
self.__replayCtrl.battleChatMessageCallback = self.onBattleChatMessage
self.__replayCtrl.lockTargetCallback = self.onLockTarget
self.__replayCtrl.cruiseModeCallback = self.onSetCruiseMode
self.__replayCtrl.equipmentIdCallback = self.onSetEquipmentId
self.__isAutoRecordingEnabled = False
self.__quitAfterStop = False
self.__isPlayingPlayList = False
self.__playList = []
self.__isFinished = False
self.__isMenuShowed = False
self.__updateGunOnTimeWarp = False
g_playerEvents.onBattleResultsReceived += self.__onBattleResultsReceived
g_playerEvents.onAccountBecomePlayer += self.__onAccountBecomePlayer
g_playerEvents.onArenaPeriodChange += self.__onArenaPeriodChange
from account_helpers.settings_core.SettingsCore import g_settingsCore
g_settingsCore.onSettingsChanged += self.__onSettingsChanging
self.__playerDatabaseID = 0
self.__serverSettings = dict()
if isPlayerAccount():
self.__playerDatabaseID = BigWorld.player().databaseID
self.__playbackSpeedModifiers = (0.0, 0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0)
self.__playbackSpeedModifiersStr = ('0', '1/16', '1/8', '1/4', '1/2', '1', '2', '4', '8', '16')
self.__playbackSpeedIdx = self.__playbackSpeedModifiers.index(1.0)
self.__savedPlaybackSpeedIdx = self.__playbackSpeedIdx
self.__gunWasLockedBeforePause = False
self.__wasVideoBeforeRewind = False
self.__videoCameraMatrix = Math.Matrix()
self.__replayDir = './replays'
self.__replayCtrl.clientVersion = BigWorld.wg_getProductVersion()
self.__timeWarpCleanupCb = None
self.__enableTimeWarp = False
self.__isChatPlaybackEnabled = True
self.__warpTime = -1.0
self.__skipMessage = False
self.__equipmentId = None
self.__rewind = False
self.replayTimeout = 0
self.__arenaPeriod = -1
self.enableAutoRecordingBattles(True)
gui.Scaleform.CursorDelegator.g_cursorDelegator.detachCursor()
self.onCommandReceived = Event.Event()
self.onAmmoSettingChanged = Event.Event()
self.onStopped = Event.Event()
return
def onLobbyInited(self, event):
if not isPlayerAccount():
return
self.__isLobbyInited = True
self._updatePromo(self._getPromoEventNotifications())
self.eventsNotification.onEventNotificationsChanged += self.__onEventNotification
self.browserCtrl.onBrowserDeleted += self.__onBrowserDeleted
popupsWindowsDisabled = isPopupsWindowsOpenDisabled()
if not popupsWindowsDisabled:
self._processPromo(self.eventsNotification.getEventsNotifications())
def setSystemValue(self, value):
key = 'KEY_NONE'
if value is not None:
key = getBigworldNameFromKey(getBigworldKey(value))
LOG_DEBUG('Settings key command', self.settingName, value, key)
if self.settingName == 'CMD_VOICECHAT_MUTE' and isPlayerAccount():
self.app.gameInputManager.updateChatKeyHandlers(value)
CommandMapping.g_instance.remove(self.settingName)
CommandMapping.g_instance.add(self.settingName, key)
return
def addStatsAccountBecomePlayer():
if isPlayerAccount():
if getattr(BigWorld.player(), 'databaseID', None) is None:
BigWorld.callback(0.2, addStatsAccountBecomePlayer)
else:
g_HomeRegion.setAccountDBID(BigWorld.player().databaseID)
if g_HomeRegion.accountDBID == 0:
print '[%s] "wg_statistics": Invalid accountDBID, you must re-enter the game client!' % __author__
elif g_WGStatisticsEvents.OnStatsAccountBecomePlayer._delegates:
g_WGConsole.getStatsFull_Async(g_HomeRegion.accountDBID, g_WGStatisticsEvents.OnStatsAccountBecomePlayer)
def __processVehicleChange(self):
if not isPlayerAccount():
return
else:
if self.__vehicleBonus is not None:
vehicle, _ = first(self.__vehicleBonus.getVehicles(),
(None, None))
if vehicle is not None:
g_currentVehicle.selectVehicle(vehicle.invID)
return
def setSystemValue(self, value):
key = 'KEY_NONE'
if value is not None:
key = getBigworldNameFromKey(getBigworldKey(value))
LOG_DEBUG('Settings key command', self.settingName, value, key)
if self.settingName == 'CMD_VOICECHAT_MUTE' and isPlayerAccount():
self.app.gameInputManager.updateChatKeyHandlers(value)
CommandMapping.g_instance.remove(self.settingName)
CommandMapping.g_instance.add(self.settingName, key)
return
def __onAccountBecomePlayer(self):
player = BigWorld.player()
if not isPlayerAccount():
return
else:
if player.databaseID is None:
BigWorld.callback(0.1, self.__onAccountBecomePlayer)
else:
self.__playerDatabaseID = player.databaseID
return
def __onAccountBecomePlayer(self):
player = BigWorld.player()
if not isPlayerAccount():
return
else:
if player.databaseID is None:
BigWorld.callback(0.1, self.__onAccountBecomePlayer)
else:
self.__playerDatabaseID = player.databaseID
return
def request(self, callback):
_logger.debug('Prepare requester %s', self.__class__.__name__)
self.__synced = False
if not isPlayerAccount():
yield lambda callback: callback(None)
_logger.error('Player is not account, requester %s can not be invoked.', self.__class__.__name__)
else:
_logger.debug('Invoke requester %s', self.__class__.__name__)
self._data = yield self._requestCache()
callback(self)
def __onAccountBecomePlayer(self):
if not isPlayerAccount():
return
player = BigWorld.player()
self.__serverSettings['roaming'] = player.serverSettings['roaming']
self.__serverSettings['isPotapovQuestEnabled'] = player.serverSettings.get('isPotapovQuestEnabled', False)
if player.databaseID is None:
BigWorld.callback(0.1, self.__onAccountBecomePlayer)
else:
self.__playerDatabaseID = player.databaseID
def addStatsAccountBecomePlayer():
if isPlayerAccount():
if getattr(BigWorld.player(), 'databaseID', None) is None:
BigWorld.callback(0.2, addStatsAccountBecomePlayer)
else:
g_UserToken.init()
if g_UserToken.errorStatus:
print '[%s] "xvm_statistics": %s' % (__author__, g_UserToken.errorStatus)
elif g_XVMStatisticsEvents.OnStatsAccountBecomePlayer._Event__delegates:
g_XVMConsole.getStatsByID_Async(g_UserToken.accountDBID, g_XVMStatisticsEvents.OnStatsAccountBecomePlayer)
def __onServerSettingChanged(self, diff):
self.__configIsOld = True
if isPlayerAccount():
cooldownDelta = BigWorld.time() - self.__lastRequestTime
if not self.__lastRequestTime or cooldownDelta < REQUEST_COOLDOWN.MAPS_TRAINING_INITIAL_CONFIGURATION:
self.requestInitialDataFromServer()
else:
self.__configIsOld = False
if not diff.get('isMapsTrainingEnabled', True):
if self.isMapsTrainingPrbActive and not self.prbEntity.isInQueue():
self.selectRandomMode()
def __getEventsData(cls, eventsTypeName):
try:
if isPlayerAccount():
if eventsTypeName in BigWorld.player().eventsData:
return pickle.loads(zlib.decompress(BigWorld.player().eventsData[eventsTypeName]))
return {}
LOG_DEBUG('Trying to get quests data from not account player', eventsTypeName, BigWorld.player())
except Exception:
LOG_CURRENT_EXCEPTION()
return {}
def _finalize(self):
self.__stopVideo()
if self.__openBoxesFunc is not None:
self.__openBoxesFunc = None
self.__unsubscribeListeners()
g_messengerEvents.onUnlockPopUpMessages(key=self.__class__.__name__)
if isPlayerAccount():
LootBoxNotification.saveSettings()
self.settingsCore.applyStorages(False)
super(NyLootBoxMainView, self)._finalize()
return
def __stopLifetimeEffect(self, chunkID, destrIndex, moduleKind):
code = _encodeModule(chunkID, destrIndex, moduleKind)
lifetimeEffectID = self.__lifetimeEffects.get(code)
if lifetimeEffectID is None:
return
else:
del self.__lifetimeEffects[code]
player = BigWorld.player()
if player is not None and not isPlayerAccount():
player.terrainEffects.stop(lifetimeEffectID)
return
def __getEventsData(cls, eventsTypeName):
try:
if isPlayerAccount():
if eventsTypeName in BigWorld.player().eventsData:
return pickle.loads(zlib.decompress(BigWorld.player().eventsData[eventsTypeName]))
return {}
LOG_ERROR('Trying to get quests data from not account player', eventsTypeName, BigWorld.player())
except Exception:
LOG_CURRENT_EXCEPTION()
return {}
def __getQuestsData(self):
try:
if isPlayerAccount():
if 'questsClientData' in BigWorld.player().eventsData:
return pickle.loads(zlib.decompress(BigWorld.player().eventsData['questsClientData']))
return {}
LOG_ERROR('Trying to get quests data from not account player', BigWorld.player())
except Exception:
LOG_CURRENT_EXCEPTION()
return {}
def _get(self):
marker = {}
for mType in self.OPTIONS.TYPES.ALL():
for param in self.OPTIONS.PARAMS.ALL():
on = self.OPTIONS.getOptionName(mType, param)
value = self._storage.extract(self.settingName, on, self._default[on])
if param == self.OPTIONS.PARAMS.HP and isPlayerAccount():
marker[on] = self.PackStruct(value, [ '#settings:marker/hp/type%d' % mid for mid in xrange(4) ])._asdict()
else:
marker[on] = value
return marker
def checkAccount(*fargs, **fkwargs):
if not isPlayerAccount():
LOG_NOTE('Server call "StatsRequester.%s" canceled: player is not account.' % fn.func_name)
returnFurnc = dkwargs.get('func', None)
if returnFurnc:
returnArgs = dkwargs.get('args', None)
if returnArgs:
return fkwargs['callback'](returnFurnc(returnArgs))
return fkwargs['callback'](returnFurnc())
return fkwargs['callback'](*dargs, **dkwargs)
fargs[0].setCallback(fkwargs['callback'])
return fn(*fargs, **fkwargs)
def request(self, callback = None):
"""
Public request method. Validate player entity to request
possibility and itself as single callback argument.
"""
self.__synced = False
if not isPlayerAccount():
yield lambda callback: callback(None)
LOG_ERROR('[class %s] Player is not account.' % self.__class__.__name__)
else:
self.__cache = yield self._requestCache()
callback(self)
def __onAccountBecomePlayer(self):
if not isPlayerAccount():
return
player = BigWorld.player()
self.__serverSettings['roaming'] = player.serverSettings['roaming']
self.__serverSettings[
'isPotapovQuestEnabled'] = player.serverSettings.get(
'isPotapovQuestEnabled', False)
if player.databaseID is None:
BigWorld.callback(0.1, self.__onAccountBecomePlayer)
else:
self.__playerDatabaseID = player.databaseID
def onLobbyInited(self, event):
if not isPlayerAccount():
return None
else:
self.__weaver = Weaver()
BigWorld.player().stats.get('battlesTillCaptcha', self.__pc_onReceiveBattlesTillCaptcha)
BigWorld.player().stats.get('captchaTriesLeft', self.__pc_onReceiveCaptchaTriesLeft)
g_playerEvents.onEnqueueRandomFailure += self.__pe_onEnqueueRandomFailure
g_playerEvents.onEnqueueEventBattlesFailure += self.__pe_onEnqueueEventBattlesFailure
g_clientUpdateManager.addCallbacks({'stats.battlesTillCaptcha': self.__onBattlesTillCaptcha,
'stats.captchaTriesLeft': self.__onCaptchaTriesLeft})
return None
def onClientUpdate(diff):
yield lambda callback: callback(None)
if isPlayerAccount():
yield g_itemsCache.update(diff)
yield g_questsCache.update()
MusicController.g_musicController.setAccountAttrs(
g_itemsCache.items.stats.attributes, True)
MusicController.g_musicController.play(
MusicController.MUSIC_EVENT_LOBBY)
MusicController.g_musicController.play(
MusicController.MUSIC_EVENT_LOBBY)
g_clientUpdateManager.update(diff)
def onScreenChange(currentScreen = None):
if not currentScreen and isPlayerAccount():
currentScreen = 'hangar'
if currentScreen in LogitechMonitor.SCREEN_TO_FRAME.keys():
LogitechMonitor.__currentScreen = currentScreen
if LogitechMonitor.__component:
screenClass = LogitechMonitor.SCREEN_TO_FRAME[LogitechMonitor.__currentScreen]
if not isinstance(LogitechMonitor.__screen, screenClass):
if LogitechMonitor.__screen:
LogitechMonitor.__screen.destroy(LogitechMonitor.__isColored)
LogitechMonitor.__screen = screenClass(LogitechMonitor.__component)
LogitechMonitor.__screen.load(LogitechMonitor.__isColored)
LogitechMonitor.onSwitchMessenger(currentScreen)
def apply(self, restartApproved):
if self._settings:
LOG_DEBUG('Applying video settings: ', self._settings)
cWindowSize = g_monitorSettings.currentWindowSize
windowSizeWidth, windowSizeHeight = self.windowSize
cIsFullScreen = g_monitorSettings.isFullscreen
isFullscreen = self.fullscreen
cVideoMode = g_monitorSettings.currentVideoMode
videoMode = self.videoMode
monitor = self.monitor
cMonitor = g_monitorSettings.activeMonitor
windowSizeChanged = cWindowSize is not None and windowSizeWidth is not None and windowSizeHeight is not None and (windowSizeWidth != cWindowSize.width or windowSizeHeight != cWindowSize.height)
monitorChanged = monitor != cMonitor
videModeChanged = cVideoMode is not None and videoMode is not None and videoMode.index != cVideoMode.index
fullScreenChanged = isFullscreen != cIsFullScreen
deviseRecreated = False
if monitorChanged:
g_monitorSettings.changeMonitor(monitor)
deviseRecreated = isFullscreen or cIsFullScreen
if windowSizeChanged and not isFullscreen:
deviseRecreated = True
g_monitorSettings.changeWindowSize(windowSizeWidth, windowSizeHeight)
elif (not monitorChanged or restartApproved) and (videModeChanged or fullScreenChanged):
deviseRecreated = True
BigWorld.changeVideoMode(videoMode.index, not isFullscreen)
self.clear()
self._core.isDeviseRecreated = deviseRecreated
if deviseRecreated:
def wrapper(monitorChanged, windowSizeChanged, cMonitor, cWindowSize, cVideoMode, cIsFullScreen):
def revert():
if monitorChanged:
g_monitorSettings.changeMonitor(cMonitor)
if windowSizeChanged and not cIsFullScreen:
g_monitorSettings.changeWindowSize(cWindowSize.width, cWindowSize.height)
elif not monitorChanged and (videModeChanged or fullScreenChanged):
BigWorld.changeVideoMode(cVideoMode.index, not cIsFullScreen)
return revert
if isPlayerAccount():
@async
def confirmator(callback = None):
BigWorld.callback(0.0, lambda : DialogsInterface.showI18nConfirmDialog('graphicsChangeConfirmation', callback, TimerConfirmDialogMeta('graphicsChangeConfirmation', timer=15)))
else:
confirmator = 'graphicsChangeConfirmation'
return (confirmator, wrapper(monitorChanged, windowSizeChanged, cMonitor, cWindowSize, cVideoMode, cIsFullScreen))
return super(VideoSettingsStorage, self).apply(restartApproved)
def onChunkLoad(self, chunkID, numDestructibles):
if self.__spaceID is None:
LOG_ERROR("Notification about chunk load came when no space started")
return
else:
if numDestructibles > 256:
if not isPlayerAccount():
self.__logErrorTooMuchDestructibles(chunkID)
self.__loadedChunkIDs[chunkID] = numDestructibles
chunkEntries = self.__destructiblesWaitDestroy.get(chunkID)
if chunkEntries is not None:
for dmgType, destrData, isNeedAnimation in chunkEntries:
self.__destroyDestructible(chunkID, dmgType, destrData, isNeedAnimation)
del self.__destructiblesWaitDestroy[chunkID]
return
def __setClanInfo(self, clanInfo):
if not isPlayerAccount():
return
else:
name = BigWorld.player().name
if clanInfo and len(clanInfo) > 1:
clanAbbrev = clanInfo[1]
else:
clanAbbrev = None
hasNew = not AccountSettings.getFilter(BOOSTERS)['wasShown']
hasActiveBooster = len(g_goodiesCache.getBoosters(criteria=REQ_CRITERIA.BOOSTER.ACTIVE)) > 0
self.as_nameResponseS(g_lobbyContext.getPlayerFullName(name, clanInfo=clanInfo), name, clanAbbrev, g_itemsCache.items.stats.isTeamKiller, g_clanCache.isInClan, hasNew, hasActiveBooster, TOOLTIPS.HEADER_ACCOUNT, TOOLTIP_TYPES.COMPLEX)
if g_clanCache.clanDBID:
self.requestClanEmblem32x32(g_clanCache.clanDBID)
else:
self.as_setClanEmblemS(None)
return
def __setClanInfo(self, clanInfo):
if not isPlayerAccount():
return
else:
name = BigWorld.player().name
if clanInfo and len(clanInfo) > 1:
clanAbbrev = clanInfo[1]
else:
clanAbbrev = None
hasNew = not AccountSettings.getFilter(BOOSTERS)['wasShown']
activeBoosters = g_goodiesCache.getBoosters(criteria=REQ_CRITERIA.BOOSTER.ACTIVE).values()
hasActiveBooster = len(activeBoosters) > 0
readyBoosters = g_goodiesCache.getBoosters(criteria=REQ_CRITERIA.BOOSTER.IS_READY_TO_ACTIVATE).values()
boostersAvailable = sum((booster.count for booster in readyBoosters))
hasAvailableBoosters = boostersAvailable > 0
boosterIcon, boosterText = (None, None)
if hasActiveBooster:
boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERICON
booster = sorted(activeBoosters, key=lambda x: x.getUsageLeftTime())[0]
boosterText = booster.getShortLeftTimeStr()
elif hasAvailableBoosters:
boosterIcon = RES_ICONS.MAPS_ICONS_BOOSTERS_AVAILABLEBOOSTERICON
if boostersAvailable <= _MAX_BOOSTERS_TO_DISPLAY:
boosterText = str(boostersAvailable)
else:
boosterText = str(_MAX_BOOSTERS_TO_DISPLAY) + '+'
self.as_nameResponseS({'userVO': {'fullName': g_lobbyContext.getPlayerFullName(name, clanInfo=clanInfo),
'userName': name,
'clanAbbrev': clanAbbrev},
'isTeamKiller': g_itemsCache.items.stats.isTeamKiller,
'hasNew': hasNew,
'hasActiveBooster': hasActiveBooster,
'hasAvailableBoosters': hasAvailableBoosters,
'tooltip': TOOLTIPS.HEADER_ACCOUNT,
'tooltipType': TOOLTIP_TYPES.COMPLEX,
'boosterIcon': boosterIcon,
'boosterBg': RES_ICONS.MAPS_ICONS_BOOSTERS_ACTIVEBOOSTERBG,
'boosterText': boosterText})
if g_clanCache.clanDBID:
self.requestClanEmblem32x32(g_clanCache.clanDBID)
else:
self.as_setClanEmblemS(None)
return
def __launchFallEffect(self, chunkID, destrIndex, effectType, fallDirYaw):
player = BigWorld.player()
if player is None or isPlayerAccount():
return
else:
effectName = BigWorld.wg_getDestructibleEffectName(self.__spaceID, chunkID, destrIndex, -1, effectType)
if effectName == 'none':
return
effectVars = g_cache._getEffect(effectName, 'fallingAtoms', False)
if effectVars is None:
return
effectStuff = random.choice(effectVars)
chunkMatrix = BigWorld.wg_getChunkMatrix(self.__spaceID, chunkID)
destrMatrix = BigWorld.wg_getDestructibleMatrix(self.__spaceID, chunkID, destrIndex)
pos = chunkMatrix.translation + destrMatrix.translation
dir = Math.Vector3(math.sin(fallDirYaw), 0.0, math.cos(fallDirYaw))
scale = BigWorld.wg_getDestructibleEffectScale(self.__spaceID, chunkID, destrIndex, -1)
player.terrainEffects.addNew(pos, effectStuff.effectsList, effectStuff.keyPoints, None, dir=dir, scale=scale)
return
def __init__(self):
userPrefs = Settings.g_instance.userPrefs
if not userPrefs.has_key(Settings.KEY_REPLAY_PREFERENCES):
userPrefs.write(Settings.KEY_REPLAY_PREFERENCES, '')
self.__settings = userPrefs[Settings.KEY_REPLAY_PREFERENCES]
self.__fileName = None
self.__replayCtrl = BigWorld.WGReplayController()
self.__replayCtrl.replayFinishedCallback = self.onReplayFinished
self.__replayCtrl.controlModeChangedCallback = self.onControlModeChanged
self.__replayCtrl.ammoButtonPressedCallback = self.onAmmoButtonPressed
self.__replayCtrl.minimapCellClickedCallback = self.onMinimapCellClicked
self.__replayCtrl.playerVehicleIDChangedCallback = self.onPlayerVehicleIDChanged
self.__replayCtrl.clientVersionDiffersCallback = self.onClientVersionDiffers
self.__replayCtrl.battleChatMessageCallback = self.onBattleChatMessage
self.__replayCtrl.lockTargetCallback = self.onLockTarget
self.__replayCtrl.cruiseModeCallback = self.onSetCruiseMode
self.__isAutoRecordingEnabled = False
self.__quitAfterStop = False
self.__isPlayingPlayList = False
self.__playList = []
self.__isFinished = False
g_playerEvents.onBattleResultsReceived += self.__onBattleResultsReceived
g_playerEvents.onAccountBecomePlayer += self.__onAccountBecomePlayer
from account_helpers.SettingsCore import g_settingsCore
g_settingsCore.onSettingsChanged += self.__onSettingsChanging
self.__playerDatabaseID = 0
self.__roamingSettings = None
if isPlayerAccount():
self.__playerDatabaseID = BigWorld.player().databaseID
self.__playbackSpeedModifiers = (0.0, 0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0)
self.__playbackSpeedModifiersStr = ('0', '1/16', '1/8', '1/4', '1/2', '1', '2', '4', '8', '16')
self.__playbackSpeedIdx = self.__playbackSpeedModifiers.index(1.0)
self.__savedPlaybackSpeedIdx = self.__playbackSpeedIdx
self.__gunWasLockedBeforePause = False
self.__replayDir = './replays'
self.__replayCtrl.clientVersion = BigWorld.wg_getProductVersion()
self.__timeWarpCleanupCb = None
self.__enableTimeWarp = False
self.__disableSidePanelContextMenuCb = None
self.__isChatPlaybackEnabled = True
self.enableAutoRecordingBattles(True)
gui.Scaleform.CursorDelegator.g_cursorDelegator.detachCursor()
