def __updateAim(self):
if self.getPlaybackSpeedIdx() == 0:
player = BigWorld.player()
if isPlayerAvatar():
if player.inputHandler.aim is not None:
player.inputHandler.aim._update()
BigWorld.callback(0, self.__updateAim)
def applySettings(self):
yield self._updateToVersion()
enableBattleReplay = self._core.options.getSetting(self.GAME.REPLAY_ENABLED)
enableBattleReplayValue = enableBattleReplay.get()
from BattleReplay import g_replayCtrl
g_replayCtrl.enableAutoRecordingBattles(enableBattleReplayValue)
enablePostMortem = self._core.options.getSetting(self.GAME.ENABLE_POSTMORTEM)
enablePostMortemValue = enablePostMortem.get()
from post_processing import g_postProcessing
g_postProcessing.setSetting('mortem_post_effect', enablePostMortemValue)
g_postProcessing.refresh()
enableDynamicCamera = self._core.options.getSetting(self.GAME.DYNAMIC_CAMERA)
enableDynamicCameraValue = enableDynamicCamera.get()
enableSniperStabilization = self._core.options.getSetting(self.GAME.SNIPER_MODE_STABILIZATION)
enableSniperStabilizationValue = enableSniperStabilization.get()
from AvatarInputHandler import AvatarInputHandler
AvatarInputHandler.enableDynamicCamera(enableDynamicCameraValue, enableSniperStabilizationValue)
from messenger.doc_loaders import user_prefs
from messenger import g_settings as messenger_settings
user_prefs.loadFromServer(messenger_settings)
masks = self.SECTIONS[SETTINGS_SECTIONS.GRAPHICS].masks
offsets = self.SECTIONS[SETTINGS_SECTIONS.GRAPHICS].offsets
graphicSettingNames = masks.keys() + offsets.keys()
for setting in graphicSettingNames:
settingOption = self._core.options.getSetting(setting)
settingValue = settingOption.get()
settingOption.setSystemValue(settingValue)
alternativeVoices = self._core.options.getSetting(self.SOUND.ALT_VOICES)
alternativeVoicesValue = alternativeVoices.get()
alternativeVoices.setSystemValue(alternativeVoicesValue)
self._core.options.getSetting('keyboard').setSystemValue()
if isPlayerAvatar():
BigWorld.player().invRotationOnBackMovement = self._core.getSetting('backDraftInvert')
def __isTargetCorrect(self, player):
import Vehicle
if self.__currentTarget is not None:
if isinstance(self.__currentTarget, Vehicle.Vehicle):
if self.__currentTarget.isAlive():
return player is not None and isPlayerAvatar() and True
return False
def update(self):
self.__cbID = BigWorld.callback(self.UPDATE_PERIOD, self.update)
if not self.isActive:
return
player = BigWorld.player()
if not isPlayerAvatar():
return
camPos = BigWorld.camera().position
camDir = BigWorld.camera().direction
vehicle = BigWorld.entities.get(player.playerVehicleID)
try:
for type, (isTwoState, args) in self.__pendingManualTriggers.iteritems():
params = dict(args)
params['type'] = type
for listener in self.__listeners:
listener.onTriggerActivated(params)
if isTwoState:
self.__activeManualTriggers[type] = params
self.__pendingManualTriggers = {}
for id, params in self.__autoTriggers.iteritems():
wasActive = id in self.__activeAutoTriggers
isActive = False
distance = -1.0
type = params['type']
if type == TRIGGER_TYPE.AREA and vehicle is not None:
triggerRadius = params['radius']
if wasActive:
triggerRadius = triggerRadius + params['exitInterval']
offset = vehicle.position - Math.Vector3(params['position'])
offset.y = 0
distance = offset.length
isActive = distance < triggerRadius
if type == TRIGGER_TYPE.AIM:
camToTrigger = Math.Vector3(params['position']) - camPos
vehicleToTrigger = Math.Vector3(params['position']) - vehicle.position
distance = camToTrigger.length
if distance <= params['maxDistance'] and vehicleToTrigger.dot(camToTrigger) > 0.0:
camToTrigger.normalise()
dp = camToTrigger.dot(camDir)
if dp > 0.0:
sinAngle = math.sqrt(1.0 - dp * dp)
isActive = sinAngle * distance < params['radius']
params['distance'] = distance
if wasActive != isActive:
if isActive:
self.__activeAutoTriggers.add(id)
for listener in self.__listeners:
listener.onTriggerActivated(params)
else:
self.__activeAutoTriggers.discard(id)
for listener in self.__listeners:
listener.onTriggerDeactivated(params)
self.__explodePoints = []
self.__shotPoints = []
except:
LOG_CURRENT_EXCEPTION()
def disable(self):
self.stopCallback(self.__update)
BigWorld.projection().fov = self.__defaultFov
BigWorld.camera(None)
self.__alignerToLand.disable()
if isPlayerAvatar():
BigWorld.player().positionControl.followCamera(False)
self.__showAim(False)
def __isTargetCorrect(self, player):
import Vehicle
if self.__currentTarget is not None and isinstance(self.__currentTarget, Vehicle.Vehicle):
if self.__currentTarget.isAlive():
if player is not None and isPlayerAvatar():
vInfo = g_sessionProvider.getArenaDP().getVehicleInfo(self.__currentTarget.id)
return not vInfo.isActionsDisabled()
return False
def __toggleView(self):
if not isPlayerAvatar():
return
self.__isModeOverride = not self.__isModeOverride
if self.__isModeOverride:
gui_event_dispatcher.overrideCrosshairView(CTRL_MODE_NAME.POSTMORTEM)
else:
gui_event_dispatcher.overrideCrosshairView(CTRL_MODE_NAME.VIDEO)
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 cursorVisibility(self, callbackId, visible, x = None, y = None, customCall = False, enableAiming = True):
if visible:
g_cursorDelegator.syncMousePosition(self, x, y, customCall)
else:
g_cursorDelegator.restoreMousePosition()
if BigWorld.player() is not None and isPlayerAvatar():
BigWorld.player().setForcedGuiControlMode(visible, False, enableAiming)
return
def onControlModeChanged(self, forceControlMode = None):
player = BigWorld.player()
if not self.isPlaying or not isPlayerAvatar():
return
if not self.isControllingCamera and forceControlMode is None:
return
controlMode = self.getControlMode() if forceControlMode is None else forceControlMode
player.inputHandler.onControlModeChanged(controlMode, camMatrix=BigWorld.camera().matrix, preferredPos=self.getGunRotatorTargetPoint(), saveZoom=False, saveDist=False)
def onAmmoButtonPressed(self, idx):
player = BigWorld.player()
if not isPlayerAvatar():
return
if self.isPlaying:
player.onAmmoButtonPressed(idx)
elif self.isRecording:
self.__replayCtrl.onAmmoButtonPressed(idx)
def onMinimapCellClicked(self, cellIdx):
player = BigWorld.player()
if not isPlayerAvatar():
return
if self.isRecording:
self.__replayCtrl.onMinimapCellClicked(cellIdx)
elif self.isPlaying:
self.guiWindowManager.battleWindow.minimap.markCell(cellIdx, 3.0)
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 __checkSpaceBounds(self, startPos, endPos):
if not isPlayerAvatar():
return endPos
moveDir = endPos - startPos
moveDir.normalise()
collisionPointWithBorders = BigWorld.player().arena.collideWithSpaceBB(startPos - moveDir, endPos + moveDir)
if collisionPointWithBorders is not None:
return collisionPointWithBorders
return endPos
def handleMouseEvent(self, dx, dy, dz):
if self.isPlaying:
if not self.isClientReady:
return False
player = BigWorld.player()
if not isPlayerAvatar():
return False
if self.isControllingCamera:
return dz != 0 and True
return False
def __showAim(self, show):
if not isPlayerAvatar():
return
if self.__aim is None:
self.__aim = createAim('postmortem')
self.__aim.create()
if show:
self.__aim.enable()
else:
self.__aim.disable()
def __isTargetCorrect(self, player, target):
import Vehicle
from gui.battle_control import g_sessionProvider
from helpers import isPlayerAvatar
if target is not None and isinstance(target, Vehicle.Vehicle):
if target.isAlive():
if player is not None and isPlayerAvatar():
vInfo = g_sessionProvider.getArenaDP().getVehicleInfo(target.id)
return not vInfo.isActionsDisabled()
return False
def onControlModeChanged(self, forceControlMode = None):
player = BigWorld.player()
if not self.isPlaying or not isPlayerAvatar():
return
if not self.isControllingCamera and forceControlMode is None:
return
controlMode = self.getControlMode() if forceControlMode is None else forceControlMode
preferredPos = self.getGunRotatorTargetPoint()
if controlMode == 'mapcase':
_, preferredPos, _ = self.getGunMarkerParams(preferredPos, Math.Vector3(0.0, 0.0, 1.0))
player.inputHandler.onControlModeChanged(controlMode, camMatrix=BigWorld.camera().matrix, preferredPos=preferredPos, saveZoom=False, saveDist=False, equipmentID=self.__equipmentId)
def handleMouseEvent(self, dx, dy, dz):
if not (self.isPlaying and self.isClientReady):
return False
if self.isTimeWarpInProgress:
return True
player = BigWorld.player()
if not isPlayerAvatar():
return False
if self.isControllingCamera:
if dz != 0:
return True
return False
def onLockTarget(self, lock):
player = BigWorld.player()
if not isPlayerAvatar():
return
if self.isPlaying:
if lock == 1:
player.soundNotifications.play('target_captured')
elif lock == 0:
player.soundNotifications.play('target_unlocked')
else:
player.soundNotifications.play('target_lost')
elif self.isRecording:
self.__replayCtrl.onLockTarget(lock)
def hook_on_lock_target(self, lock):
if config.enable:
player = BigWorld.player()
if not isPlayerAvatar():
return
if self.isPlaying:
if lock == 1:
player.autoAim(autoaim_extended.find_autoaim_target())
elif lock == 0:
player.autoAim(None)
else:
player.autoAim(None)
elif self.isRecording:
self._BattleReplay__replayCtrl.onLockTarget(lock)
else:
hooked_onLockTarget(self, lock)
def __cameraUpdate(self):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
aimOffset = replayCtrl.getAimClipPosition()
else:
aimOffset = self.__calcAimOffset()
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(aimOffset)
self.__aimOffsetFunc(aimOffset)
shotDescr = BigWorld.player().vehicleTypeDescriptor.shot
BigWorld.wg_trajectory_drawer().setParams(shotDescr['maxDistance'], Math.Vector3(0, -shotDescr['gravity'], 0), self.__aimOffsetFunc())
curTime = BigWorld.time()
deltaTime = curTime - self.__prevTime
self.__prevTime = curTime
if replayCtrl.isPlaying:
if self.__needReset != 0:
if self.__needReset > 1:
from helpers import isPlayerAvatar
player = BigWorld.player()
if isPlayerAvatar():
if player.inputHandler.ctrl is not None:
player.inputHandler.ctrl.resetGunMarkers()
self.__needReset = 0
else:
self.__needReset += 1
if replayCtrl.isControllingCamera:
self.__aimingSystem.updateTargetPos(replayCtrl.getGunRotatorTargetPoint())
else:
self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense)
if self.__dxdydz.x != 0 or self.__dxdydz.y != 0 or self.__dxdydz.z != 0:
self.__needReset = 2
else:
self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense)
distRange = self.__cfg['distRange']
self.__camDist -= self.__dxdydz.z * float(self.__curSense)
maxPivotHeight = distRange[1] - distRange[0]
self.__camDist = mathUtils.clamp(0, maxPivotHeight, self.__camDist)
self.__cfg['camDist'] = self.__camDist
self.__cam.pivotPosition = Math.Vector3(0.0, self.__camDist, 0.0)
if self.__dxdydz.z != 0 and self.__onChangeControlMode is not None and mathUtils.almostZero(self.__camDist - maxPivotHeight):
self.__onChangeControlMode()
self.__updateOscillator(deltaTime)
if not self.__autoUpdatePosition:
self.__dxdydz = Vector3(0, 0, 0)
return 0.0
def __getArenaSoundEvent(self, eventId):
soundEventName = None
if eventId in _BATTLE_RESULT_MUSIC_EVENTS:
soundEventName = MusicController.__lastBattleResultEventName
else:
player = BigWorld.player()
if not isPlayerAvatar():
return
if player.arena is None:
return
arenaType = player.arena.arenaType
if eventId == MUSIC_EVENT_COMBAT:
soundEventName = arenaType.music
elif eventId == MUSIC_EVENT_COMBAT_LOADING:
soundEventName = arenaType.loadingMusic
elif eventId == AMBIENT_EVENT_COMBAT:
soundEventName = arenaType.ambientSound
if soundEventName:
return SoundGroups.g_instance.getSound2D(soundEventName)
else:
return
def enable(self, **args):
self.measureDeltaTime()
self.delayCallback(0.0, self.__update)
camMatrix = args.get('camMatrix', BigWorld.camera().matrix)
self.__cam.set(camMatrix)
self.__cam.invViewProvider.a = camMatrix
self.__cam.invViewProvider.b = mathUtils.createIdentityMatrix()
BigWorld.camera(self.__cam)
worldMat = Math.Matrix(self.__cam.invViewMatrix)
self.__ypr = Math.Vector3(worldMat.yaw, worldMat.pitch, worldMat.roll)
self.__position = worldMat.translation
self.__velocity = Math.Vector3()
self.__yprVelocity = Math.Vector3()
self.__zoomVelocity = 0.0
self.__resetSenses()
self.__basisMProv.bind(None)
self.__rotateAroundPointEnabled = False
self.__alignerToLand.disable()
if isPlayerAvatar() and g_sessionProvider.getCtx().isPlayerObserver():
BigWorld.player().positionControl.moveTo(self.__position)
BigWorld.player().positionControl.followCamera(True)
def __getArenaSoundEvent(self, eventId):
player = BigWorld.player()
soundEvent = None
soundEventName = None
if not isPlayerAvatar():
return
elif player.arena is None:
return
else:
arenaType = player.arena.arenaType
if eventId == MUSIC_EVENT_COMBAT:
soundEventName = arenaType.music
elif eventId == MUSIC_EVENT_COMBAT_LOADING:
soundEventName = arenaType.loadingMusic
elif eventId == AMBIENT_EVENT_COMBAT:
soundEventName = arenaType.ambientSound
if soundEventName is not None:
soundEvent = FMOD.getSound(soundEventName)
if soundEvent is not None:
soundEvent.stop()
return soundEvent
def stop(self, rewindToTime = None, delete = False):
if not self.isPlaying and not self.isRecording:
return False
else:
self.onStopped()
wasPlaying = self.isPlaying
isOffline = self.__replayCtrl.isOfflinePlaybackMode
self.__replayCtrl.stop(delete)
self.__fileName = None
if wasPlaying:
if isPlayerAvatar():
BigWorld.player().onVehicleEnterWorld -= self.__onVehicleEnterWorld
if not isOffline:
connectionManager.onDisconnected += self.__showLoginPage
BigWorld.clearEntitiesAndSpaces()
BigWorld.disconnect()
if self.__quitAfterStop:
BigWorld.quit()
elif isOffline:
self.__showLoginPage()
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 handleKeyEvent(self, isDown, key, mods, isRepeat, event):
if not self.isPlaying:
return False
if self.isTimeWarpInProgress:
return True
if key == Keys.KEY_F1:
return True
if not self.isClientReady:
return False
cmdMap = CommandMapping.g_instance
player = BigWorld.player()
if not isPlayerAvatar():
return
currReplayTime = self.__replayCtrl.getTimeMark(REPLAY_TIME_MARK_CURRENT_TIME)
finishReplayTime = self.__replayCtrl.getTimeMark(REPLAY_TIME_MARK_REPLAY_FINISHED)
if currReplayTime > finishReplayTime:
currReplayTime = finishReplayTime
isCursorVisible = gui.Scaleform.CursorDelegator.g_cursorDelegator._CursorDelegator__activated
fastForwardStep = FAST_FORWARD_STEP * (2.0 if mods == 2 else 1.0)
if (key == Keys.KEY_LEFTMOUSE or cmdMap.isFired(CommandMapping.CMD_CM_SHOOT, key)) and isDown and not isCursorVisible:
if self.isControllingCamera:
controlMode = self.getControlMode()
self.onControlModeChanged('arcade')
self.__replayCtrl.isControllingCamera = False
self.onControlModeChanged(controlMode)
self.__showInfoMessage('replayFreeCameraActivated')
else:
self.__replayCtrl.isControllingCamera = True
self.onControlModeChanged()
self.__showInfoMessage('replaySavedCameraActivated')
return True
if cmdMap.isFired(CommandMapping.CMD_CM_ALTERNATE_MODE, key) and isDown:
if self.isControllingCamera:
return True
if key == Keys.KEY_SPACE and isDown and not self.__isFinished:
if self.__playbackSpeedIdx > 0:
self.setPlaybackSpeedIdx(0)
else:
self.setPlaybackSpeedIdx(self.__savedPlaybackSpeedIdx if self.__savedPlaybackSpeedIdx != 0 else self.__playbackSpeedModifiers.index(1.0))
return True
if key == Keys.KEY_DOWNARROW and isDown and not self.__isFinished:
if self.__playbackSpeedIdx > 0:
self.setPlaybackSpeedIdx(self.__playbackSpeedIdx - 1)
return True
if key == Keys.KEY_UPARROW and isDown and not self.__isFinished:
if self.__playbackSpeedIdx < len(self.__playbackSpeedModifiers) - 1:
self.setPlaybackSpeedIdx(self.__playbackSpeedIdx + 1)
return True
if key == Keys.KEY_RIGHTARROW and isDown and not self.__isFinished:
self.__timeWarp(currReplayTime + fastForwardStep)
return True
if key == Keys.KEY_LEFTARROW:
self.__timeWarp(currReplayTime - fastForwardStep)
return True
if key == Keys.KEY_HOME and isDown:
self.__timeWarp(0.0)
return True
if key == Keys.KEY_END and isDown and not self.__isFinished:
self.__timeWarp(finishReplayTime)
return True
if key == Keys.KEY_C and isDown:
self.__isChatPlaybackEnabled = not self.__isChatPlaybackEnabled
playerControlMode = player.inputHandler.ctrl
from AvatarInputHandler.control_modes import VideoCameraControlMode
isVideoCamera = isinstance(playerControlMode, VideoCameraControlMode)
suppressCommand = False
if cmdMap.isFiredList(xrange(CommandMapping.CMD_AMMO_CHOICE_1, CommandMapping.CMD_AMMO_CHOICE_0 + 1), key) and isDown:
suppressCommand = True
elif cmdMap.isFiredList((CommandMapping.CMD_CM_LOCK_TARGET,
CommandMapping.CMD_CM_LOCK_TARGET_OFF,
CommandMapping.CMD_USE_HORN,
CommandMapping.CMD_STOP_UNTIL_FIRE,
CommandMapping.CMD_INCREMENT_CRUISE_MODE,
CommandMapping.CMD_DECREMENT_CRUISE_MODE,
CommandMapping.CMD_MOVE_FORWARD,
CommandMapping.CMD_MOVE_FORWARD_SPEC,
CommandMapping.CMD_MOVE_BACKWARD,
CommandMapping.CMD_CM_POSTMORTEM_NEXT_VEHICLE,
CommandMapping.CMD_CM_POSTMORTEM_SELF_VEHICLE,
CommandMapping.CMD_RADIAL_MENU_SHOW,
CommandMapping.CMD_RELOAD_PARTIAL_CLIP), key) and isDown and not isCursorVisible:
suppressCommand = True
elif (key == Keys.KEY_RETURN or key == Keys.KEY_NUMPADENTER) and isDown and mods != 4:
suppressCommand = True
if suppressCommand:
if isVideoCamera:
playerControlMode.handleKeyEvent(isDown, key, mods, event)
return True
return False
def setPlayerVehicleID(self, vehicleID):
if vehicleID == 0 and isPlayerAvatar():
vehicleID = BigWorld.player().playerVehicleID
self.__replayCtrl.playerVehicleID = vehicleID
def isTargetCorrect(player, target):
if target is not None and isinstance(target, Vehicle) and target.isAlive() and player is not None and isPlayerAvatar():
return not g_sessionProvider.getArenaDP().getVehicleInfo(target.id).isActionsDisabled()
return False
def handleKeyEvent(self, isDown, key, mods, isRepeat, event):
if not self.isPlaying:
return False
elif self.isTimeWarpInProgress:
return True
elif key == Keys.KEY_F1:
return True
elif not self.isClientReady:
return False
cmdMap = CommandMapping.g_instance
player = BigWorld.player()
if not isPlayerAvatar():
return False
if key == Keys.KEY_ESCAPE:
if isDown and not player.isForcedGuiControlMode():
self.__isMenuShowed = True
return False
if not player.isForcedGuiControlMode():
self.__isMenuShowed = False
if self.__isMenuShowed:
return False
currReplayTime = self.__replayCtrl.getTimeMark(
REPLAY_TIME_MARK_CURRENT_TIME)
finishReplayTime = self.__replayCtrl.getTimeMark(
REPLAY_TIME_MARK_REPLAY_FINISHED)
if currReplayTime > finishReplayTime:
currReplayTime = finishReplayTime
app = g_appLoader.getDefBattleApp()
if app is not None:
isCursorVisible = app.ctrlModeFlags & GUI_CTRL_MODE_FLAG.CURSOR_ATTACHED > 0
else:
isCursorVisible = False
fastForwardStep = FAST_FORWARD_STEP * (2.0 if mods == 2 else 1.0)
if (key == Keys.KEY_LEFTMOUSE
or cmdMap.isFired(CommandMapping.CMD_CM_SHOOT,
key)) and isDown and not isCursorVisible:
if self.isControllingCamera:
controlMode = self.getControlMode()
self.onControlModeChanged('arcade')
self.__replayCtrl.isControllingCamera = False
self.onControlModeChanged(controlMode)
self.__showInfoMessage('replayFreeCameraActivated')
else:
self.__replayCtrl.isControllingCamera = True
self.onControlModeChanged()
self.__showInfoMessage('replaySavedCameraActivated')
return True
if cmdMap.isFired(CommandMapping.CMD_CM_ALTERNATE_MODE,
key) and isDown:
if self.isControllingCamera:
return True
if key == Keys.KEY_SPACE and isDown and not self.__isFinished:
if self.__playbackSpeedIdx > 0:
self.setPlaybackSpeedIdx(0)
else:
self.setPlaybackSpeedIdx(self.__savedPlaybackSpeedIdx if self.
__savedPlaybackSpeedIdx != 0 else self
.__playbackSpeedModifiers.index(1.0))
return True
elif key == Keys.KEY_DOWNARROW and isDown and not self.__isFinished:
if self.__playbackSpeedIdx > 0:
self.setPlaybackSpeedIdx(self.__playbackSpeedIdx - 1)
return True
elif key == Keys.KEY_UPARROW and isDown and not self.__isFinished:
if self.__playbackSpeedIdx < len(
self.__playbackSpeedModifiers) - 1:
self.setPlaybackSpeedIdx(self.__playbackSpeedIdx + 1)
return True
elif key == Keys.KEY_RIGHTARROW and isDown and not self.__isFinished:
self.__timeWarp(currReplayTime + fastForwardStep)
return True
elif key == Keys.KEY_LEFTARROW:
self.__timeWarp(currReplayTime - fastForwardStep)
return True
elif key == Keys.KEY_HOME and isDown:
self.__timeWarp(0.0)
return True
elif key == Keys.KEY_END and isDown and not self.__isFinished:
self.__timeWarp(finishReplayTime)
return True
if key == Keys.KEY_C and isDown:
self.__isChatPlaybackEnabled = not self.__isChatPlaybackEnabled
playerControlMode = player.inputHandler.ctrl
isVideoCamera = _isVideoCameraCtrl(playerControlMode) or _isCatCtrl(
playerControlMode)
suppressCommand = False
if cmdMap.isFiredList(
xrange(CommandMapping.CMD_AMMO_CHOICE_1,
CommandMapping.CMD_AMMO_CHOICE_0 + 1), key) and isDown:
suppressCommand = True
elif cmdMap.isFiredList((CommandMapping.CMD_CM_LOCK_TARGET,
CommandMapping.CMD_CM_LOCK_TARGET_OFF,
CommandMapping.CMD_CM_POSTMORTEM_NEXT_VEHICLE,
CommandMapping.CMD_CM_POSTMORTEM_SELF_VEHICLE,
CommandMapping.CMD_RADIAL_MENU_SHOW,
CommandMapping.CMD_RELOAD_PARTIAL_CLIP),
key) and isDown and not isCursorVisible:
suppressCommand = True
elif cmdMap.isFiredList(
(CommandMapping.CMD_USE_HORN, CommandMapping.CMD_STOP_UNTIL_FIRE,
CommandMapping.CMD_INCREMENT_CRUISE_MODE,
CommandMapping.CMD_DECREMENT_CRUISE_MODE,
CommandMapping.CMD_MOVE_FORWARD,
CommandMapping.CMD_MOVE_FORWARD_SPEC,
CommandMapping.CMD_MOVE_BACKWARD, CommandMapping.CMD_ROTATE_LEFT,
CommandMapping.CMD_ROTATE_RIGHT), key):
suppressCommand = True
if suppressCommand:
if isVideoCamera:
playerControlMode.handleKeyEvent(isDown, key, mods, event)
return True
else:
return False
def getPlayerDBID(self):
p = BigWorld.player()
if isPlayerAccount():
return p.databaseID
if isPlayerAvatar() and hasattr(p, 'playerVehicleID'):
return p.arena.vehicles[p.playerVehicleID].get('accountDBID', None)
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:
if not BigWorld.IS_CONSUMER_CLIENT_BUILD:
self.__logSVNInfo()
AreaDestructibles.g_destructiblesManager.onAfterReplayTimeWarp(
)
if isPlayerAvatar():
BigWorld.player(
).onVehicleEnterWorld += self.__onVehicleEnterWorld
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 not BigWorld.IS_CONSUMER_CLIENT_BUILD:
arenaInfo['branchURL'], arenaInfo[
'lastChangedRevision'] = self.__getBranchAndRevision()
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
def enable(self, **args):
super(EpicVideoCamera, self).enable(**args)
self._alignerToLand.enableWithFixedHeight(self.__heightAboveTerrain)
if isPlayerAvatar():
BigWorld.player().positionControl.moveTo(self._cam.position)
BigWorld.player().positionControl.followCamera(True)
def selectPlayer(self, _, vehId):
player = BigWorld.player()
if isPlayerAvatar():
player.selectPlayer(int(vehId))
def __cameraUpdate(self):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
aimOffset = replayCtrl.getAimClipPosition()
else:
aimOffset = self.__calcAimOffset()
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(aimOffset)
self.__aimOffset = aimOffset
self.__updateCameraYaw()
shotDescr = BigWorld.player().getVehicleDescriptor().shot
BigWorld.wg_trajectory_drawer().setParams(shotDescr.maxDistance, Math.Vector3(0, -shotDescr.gravity, 0), aimOffset)
curTime = BigWorld.time()
deltaTime = curTime - self.__prevTime
self.__prevTime = curTime
self.__aimingSystem.update(deltaTime)
if replayCtrl.isPlaying:
if self.__needReset != 0:
if self.__needReset > 1:
from helpers import isPlayerAvatar
player = BigWorld.player()
if isPlayerAvatar():
if player.inputHandler.ctrl is not None:
player.inputHandler.ctrl.resetGunMarkers()
self.__needReset = 0
else:
self.__needReset += 1
if replayCtrl.isControllingCamera:
self.__aimingSystem.updateTargetPos(replayCtrl.getGunRotatorTargetPoint())
else:
self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense)
if self.__dxdydz.x != 0 or self.__dxdydz.y != 0 or self.__dxdydz.z != 0:
self.__needReset = 2
else:
self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense)
self.__calcSmoothingPivotDelta(deltaTime)
self.__camDist -= self.__dxdydz.z * float(self.__curSense)
self.__camDist = self.__aimingSystem.overrideCamDist(self.__camDist)
distRange = self.__getDistRange()
maxPivotHeight = distRange[1] - distRange[0]
transitionDist = self._cfg['transitionDist'] - distRange[0]
if self.__switchers.isEnabled():
self.__camDist = math_utils.clamp(transitionDist, maxPivotHeight, self.__camDist)
scrollLimits = (transitionDist, maxPivotHeight)
else:
self.__camDist = math_utils.clamp(0, maxPivotHeight, self.__camDist)
scrollLimits = (0, maxPivotHeight)
if self.__saveDist:
self._cfg['camDist'] = self.__camDist
self.__scrollSmoother.moveTo(self.__camDist, scrollLimits)
currentCamDist = self.__scrollSmoother.update(deltaTime)
camDistWithSmoothing = currentCamDist + self.__smoothingPivotDelta - self.__aimingSystem.heightFromPlane
self.__cam.pivotPosition = Math.Vector3(0.0, camDistWithSmoothing, 0.0)
if self.__onChangeControlMode is not None and self.__switchers.needToSwitch(self.__dxdydz.z, self.__camDist, 0, maxPivotHeight, transitionDist):
self.__onChangeControlMode(*self.__switchers.getSwitchParams())
if not self.__transitionEnabled and self.__camDist + TRANSITION_DIST_HYSTERESIS >= transitionDist:
self.__transitionEnabled = True
self.__enableSwitchers(False)
self.__updateOscillator(deltaTime)
if not self.__autoUpdatePosition:
self.__dxdydz = Vector3(0, 0, 0)
return 0.0
def activate(self):
super(AvatarRelatedComponent, self).activate()
if isPlayerAvatar():
self._initialize()
else:
g_playerEvents.onAvatarBecomePlayer += self._initialize
def setPlayerVehicleID(self, vehicleID):
if vehicleID == 0 and isPlayerAvatar():
vehicleID = BigWorld.player().playerVehicleID
self.__replayCtrl.playerVehicleID = vehicleID
def __updateIdle(self):
if isPlayerAvatar(
) and BigWorld.player().arena.period > ARENA_PERIOD.IDLE:
self.__updateFunc = self.__updatePrebattle
self.__updateFunc()
def selectPlayer(self, cid, vehId):
player = BigWorld.player()
if isPlayerAvatar():
player.selectPlayer(int(vehId))
def showGUI(self, appFactory, appNS, appState):
isValidAvatar = isPlayerAvatar(
) and not g_playerEvents.isPlayerEntityChanging
if appState == ApplicationStateID.INITIALIZED and isValidAvatar:
appFactory.loadBattlePage(appNS, arenaGuiType=self._arenaGuiType)
def handleKeyEvent(self, isDown, key, mods, isRepeat, event):
if not self.isPlaying:
return False
if self.isBattleSimulation:
return False
if self.isTimeWarpInProgress:
return True
if key == Keys.KEY_F1:
if not isRepeat and not isDown:
self.__showInfoMessages()
return True
if not self.isClientReady:
return False
cmdMap = CommandMapping.g_instance
player = BigWorld.player()
if not isPlayerAvatar():
return False
isCursorVisible = player.isForcedGuiControlMode()
if key == Keys.KEY_ESCAPE:
if isDown and not isCursorVisible:
self.__isMenuShowed = True
return False
if not player.isForcedGuiControlMode():
self.__isMenuShowed = False
if self.__isMenuShowed:
return False
currReplayTime = self.__replayCtrl.getTimeMark(
REPLAY_TIME_MARK_CURRENT_TIME)
finishReplayTime = self.__replayCtrl.getTimeMark(
REPLAY_TIME_MARK_REPLAY_FINISHED)
if currReplayTime > finishReplayTime:
currReplayTime = finishReplayTime
fastForwardStep = FAST_FORWARD_STEP * (2.0 if mods == 2 else 1.0)
if key == Keys.KEY_F11 and isDown:
if self.isPlaying:
self.__replayCtrl.onPutScreenshotMark()
return True
if (key == Keys.KEY_LEFTMOUSE
or cmdMap.isFired(CommandMapping.CMD_CM_SHOOT,
key)) and isDown and not isCursorVisible:
if self.isControllingCamera:
self.appLoader.detachCursor(settings.APP_NAME_SPACE.SF_BATTLE)
controlMode = self.getControlMode()
if controlMode not in _POSTMORTEM_CTRL_MODES:
self.onControlModeChanged('arcade')
self.__replayCtrl.isControllingCamera = False
self.onControlModeChanged(controlMode)
self.__showInfoMessage('replayFreeCameraActivated')
else:
self.__replayCtrl.isControllingCamera = True
self.onControlModeChanged()
self.__showInfoMessage('replaySavedCameraActivated')
return True
if cmdMap.isFired(CommandMapping.CMD_CM_ALTERNATE_MODE,
key) and isDown:
if self.isControllingCamera:
return True
if key == Keys.KEY_SPACE and isDown and not self.__isFinished:
if self.__playbackSpeedIdx > 0:
self.setPlaybackSpeedIdx(0)
else:
self.setPlaybackSpeedIdx(self.__savedPlaybackSpeedIdx if self.
__savedPlaybackSpeedIdx != 0 else self
.__playbackSpeedModifiers.index(1.0))
return True
if key == Keys.KEY_DOWNARROW and isDown and not self.__isFinished:
if self.__playbackSpeedIdx > 0:
self.setPlaybackSpeedIdx(self.__playbackSpeedIdx - 1)
return True
if key == Keys.KEY_UPARROW and isDown and not self.__isFinished:
if self.__playbackSpeedIdx < len(
self.__playbackSpeedModifiers) - 1:
self.setPlaybackSpeedIdx(self.__playbackSpeedIdx + 1)
return True
if key == Keys.KEY_RIGHTARROW and isDown and not self.__isFinished:
self.__timeWarp(currReplayTime + fastForwardStep)
return True
if key == Keys.KEY_LEFTARROW:
self.__timeWarp(currReplayTime - fastForwardStep)
return True
if key == Keys.KEY_HOME and isDown:
self.__timeWarp(0.0)
return True
if key == Keys.KEY_END and isDown and not self.__isFinished:
self.__timeWarp(finishReplayTime)
return True
if key == Keys.KEY_C and isDown:
self.__isChatPlaybackEnabled = not self.__isChatPlaybackEnabled
suppressCommand = False
if cmdMap.isFiredList(
xrange(CommandMapping.CMD_AMMO_CHOICE_1,
CommandMapping.CMD_AMMO_CHOICE_0 + 1), key) and isDown:
suppressCommand = True
elif cmdMap.isFiredList((CommandMapping.CMD_CM_LOCK_TARGET,
CommandMapping.CMD_CM_LOCK_TARGET_OFF,
CommandMapping.CMD_CM_POSTMORTEM_NEXT_VEHICLE,
CommandMapping.CMD_CM_POSTMORTEM_SELF_VEHICLE,
CommandMapping.CMD_RADIAL_MENU_SHOW,
CommandMapping.CMD_RELOAD_PARTIAL_CLIP),
key) and isDown and not isCursorVisible:
suppressCommand = True
elif cmdMap.isFiredList(
(CommandMapping.CMD_STOP_UNTIL_FIRE,
CommandMapping.CMD_INCREMENT_CRUISE_MODE,
CommandMapping.CMD_DECREMENT_CRUISE_MODE,
CommandMapping.CMD_MOVE_FORWARD,
CommandMapping.CMD_MOVE_FORWARD_SPEC,
CommandMapping.CMD_MOVE_BACKWARD, CommandMapping.CMD_ROTATE_LEFT,
CommandMapping.CMD_ROTATE_RIGHT,
CommandMapping.CMD_CM_VEHICLE_SWITCH_AUTOROTATION), key):
suppressCommand = True
if suppressCommand:
playerControlModeName = player.inputHandler.ctrlModeName
isForwardInputToCtrlMode = playerControlModeName in _FORWARD_INPUT_CTRL_MODES
if isForwardInputToCtrlMode:
player.inputHandler.ctrl.handleKeyEvent(
isDown, key, mods, event)
return True
return False
def setAmmoSetting(self, idx):
if not isPlayerAvatar():
return
if self.isRecording:
self.__replayCtrl.onAmmoButtonPressed(idx)
def setAmmoSetting(self, idx):
if not isPlayerAvatar():
return
if self.isRecording:
self.__replayCtrl.onAmmoButtonPressed(idx)
