def __init__(self, start, end, effectID, prevStateID, nextStateID,
stateMachine):
self.__startValue = start
self.__endValue = end
self.__effectID = '%s_%s' % (GameEnvironment.getCamera(
).context.entity.settings.airplane.visualSettings.camera, effectID)
if not GameEnvironment.getCamera().getAircraftCam(
).effectController.isEffectDefined(self.__effectID):
self.__effectID = effectID
self.__prevStateID = prevStateID
self.__nextStateID = nextStateID
self.__stateMachine = stateMachine
self.__isActive = False
def _setCrossHairTargetMtx(self, targetID):
if self._active:
resMtx = self._controlMtx
targetEntity = BigWorld.entities.get(targetID, None)
if targetEntity is not None:
sMtx = self._owner.realMatrix
tMtx = targetEntity.matrix
tm = BigWorld.TurretDirectionProvider(sMtx, tMtx, sMtx, 0, 0,
0, 0)
resMtx = MatrixCombiner()
resMtx.r = tm
resMtx.t = tMtx
GameEnvironment.getCamera().leSetMovingTargetMatrix(resMtx)
return
def init(self):
self.initSpeedSystem()
camera = GameEnvironment.getCamera()
camera.eStateChanged += self.__onCameraStateChanged
self.__initOscillations()
self.startAccelerationEffect()
BigWorld.player().eTacticalRespawnEnd += self.__initSpeedStateMachine
def cinematic(actionData, environmentData):
camera = GameEnvironment.getCamera()
from CameraStates import CameraState
if camera.getState() == CameraState.SpectatorSide:
camera.getStateObject().updateParams(actionData)
else:
camera.setState(CameraState.SpectatorSide, actionData)
def handleForsage(self, value):
cam = GameEnvironment.getCamera()
cameraState = cam.getState()
signal = self.__forsageValueToSignal(value)
if signal != self.__forsageValue and (
signal == self.PS_NORMAL
or cameraState in self.__class__.__FORSAGE_STATES):
normalizedSpeed = clamp(
0.0,
BigWorld.player().getSpeed() / self.__maxSpeed, 1.0)
if signal == self.PS_FORSAGE:
self.__setCommonGameState(
self.__class__.CommonGameStates.FORSAGE_ACTIVATED)
self.onForsageStarted(normalizedSpeed)
if self.__forsageValue == self.PS_STOP:
self.onBrakingStopped(normalizedSpeed)
elif signal == self.PS_STOP:
self.onBrakingStarted(normalizedSpeed)
if self.__forsageValue == self.PS_FORSAGE:
self.__unsetCommonGameState(
self.__class__.CommonGameStates.FORSAGE_ACTIVATED)
self.onForsageStopped(normalizedSpeed)
elif self.__forsageValue == self.PS_FORSAGE:
self.__unsetCommonGameState(
self.__class__.CommonGameStates.FORSAGE_ACTIVATED)
self.onForsageStopped(normalizedSpeed)
elif self.__forsageValue == self.PS_STOP:
self.onBrakingStopped(normalizedSpeed)
self.__forsageValue = signal
def __init__(self, profile):
self.__profile = profile
self.__isExtraMode = False
self.__axisValue = {
VERTICAL_AXIS: 0,
HORIZONTAL_AXIS: 0,
FREE_HORIZONTAL_CAM: 0,
FREE_VERTICAL_CAM: 0
}
self.__rAxisValue = {VERTICAL_AXIS: 0, HORIZONTAL_AXIS: 0}
self.__cameraStrategy = GameEnvironment.getCamera(
).getDefualtStrategies['CameraStrategyGamepad']
self.__lastCorrectMaxAngle = None
self.__correctMaxAngle = None
self.__lastDataDir = None
self.__lastUp = None
self.__notControlledByUser = False
self.__lastDirection = Math.Vector3(0, 0, 1)
self.__lockCursor = False
self.__triggerRight = 0.0
self.__triggerLeft = 0.0
joyEvent = JoyEvent()
for deviceId in BWPersonality.axis:
for axis in BWPersonality.axis[deviceId]:
joyEvent.deviceId = deviceId
joyEvent.axis = axis
joyEvent.value = BWPersonality.axis[deviceId][axis]
self.processJoystickEvent(joyEvent)
BigWorld.player().onStateChanged += self.__ePlayerAvatarChangeState
ICMultiUpdate.__init__(self, (0.05, self.__sendCursor))
return
def handleForsage(self, value):
if not CameraEffect.g_instance:
return
else:
if self.__forsageValue is None:
self.__forsageValue = CameraEffect.CameraEffectManager.PS_NORMAL
cam = GameEnvironment.getCamera()
cameraState = cam.getState()
signal = CameraEffect.g_instance._CameraEffectManager__forsageValueToSignal(
value)
if signal != self.__forsageValue and (
signal == CameraEffect.CameraEffectManager.PS_NORMAL
or cameraState in CameraEffect.g_instance.
_CameraEffectManager__FORSAGE_STATES):
if signal == CameraEffect.CameraEffectManager.PS_FORSAGE:
WWISE_.setState(CAMERA_SOUND.FORSAGE.STATE,
CAMERA_SOUND.FORSAGE.ON)
elif signal == CameraEffect.CameraEffectManager.PS_STOP:
if self.__forsageValue == CameraEffect.CameraEffectManager.PS_FORSAGE:
WWISE_.setState(CAMERA_SOUND.FORSAGE.STATE,
CAMERA_SOUND.FORSAGE.OFF)
elif self.__forsageValue == CameraEffect.CameraEffectManager.PS_FORSAGE:
WWISE_.setState(CAMERA_SOUND.FORSAGE.STATE,
CAMERA_SOUND.FORSAGE.OFF)
self.__forsageValue = signal
return
def __init__(self, profile):
self._profile = profile
self._holdDirection = None
self._isExtraMode = False
self._lastCorrectMaxAngle = 0.0
self._additionalMouseSensitivity = 1.0
self._sensitivityCfc = 0.1
self._mousePosition = Math.Vector2(0.0, 0.0)
self._Q = Math.Quaternion()
self.__smoothStack = {'x': [0], 'y': [0]}
self.__lastMoved = False
self.__isMoved = False
self._notControlledByUser = self._profile._notControlledByUser
self._lastUp = None
self._lastExSpeed = None
self._lastDataDir = None
self.__window = 1
self._backRevert = 1
self._cameraStrategy = GameEnvironment.getCamera(
).getDefualtStrategies['CameraStrategyMouse']
self._lockCursor = False
self.__onSetFocus = Event()
GlobalEvents.onSetFocus += self.__onSetFocus
self.__mouseLock = None
ICMultiUpdate.__init__(self, (0.01, self._update),
(0.05, self._sendMouseData))
return
def _setExtraMode(self, value):
camera = GameEnvironment.getCamera()
self._isExtraMode = value
EffectManager.g_instance.onFreeCameraStateChange(value)
if value:
camera.resetToZoomMin()
camera.getDefualtStrategies[
'CameraStrategyMouse'].overviewModeEnable()
BigWorld.player().setLockCursorMtx(FAKE_ROTATION_LOCKS.FREE_CAMERA,
True)
else:
camera.resetToBackZoom()
camera.getDefualtStrategies[
'CameraStrategyMouse'].overviewModeDisable()
BigWorld.player().setLockCursorMtx(FAKE_ROTATION_LOCKS.FREE_CAMERA,
False)
lastDataDir = self._lastDataDir if self._lastDataDir is not None else BigWorld.player(
).getRotation().getAxisZ()
up = Math.Vector3(0, 1, 0)
from MathExt import TupleOfCInt16ToFloatArray
direction = TupleOfCInt16ToFloatArray(lastDataDir, Math.Vector3)
angle = direction.angle(up)
if 0 < angle < math.pi:
q = Math.Quaternion()
q.fromAngleAxis(0.5 * math.pi, direction.cross(up))
currUp = q.rotateVec(direction)
mtx = Math.Matrix()
mtx.lookAt(Math.Vector3(0, 0, 0), direction, currUp)
self._cameraStrategy.setCameraOrientation(mtx)
mtx.invert()
self._cameraStrategy.setCursorOrientation(mtx)
BigWorld.player()._crossHairMatrix.reset()
return
def __init__(self, entityID, position, ev, dmgType = None, enemyID = None):
dmgRamming = [DAMAGE_REASON.RAMMING]
self.__isPlayer = ev in ('Play_hit_LOGIC_Avatar', 'Play_hit_EFFECT_damage_Avatar')
if dmgType == DAMAGE_REASON.TREES:
ev = HitSFXFactory.OTHER_DAMAGE + 'Threes'
elif dmgType in dmgRamming:
ev = HitSFXFactory.OTHER_DAMAGE + 'Ram'
ctx = node = 0
if not position:
entity = BigWorld.entities.get(entityID, None)
if entity:
soundController = entity.controllers.get('soundController', None)
if soundController:
so = soundController.soundObjects.get(SOUND_OBJECT_TYPES.ENGINE, None)
if so:
ctx = so.context.cidProxy.handle
node = so.node.id
WwiseGameObject.__init__(self, 'HitSound-{0}'.format(ev), ctx, node, position)
cam = GameEnvironment.getCamera()
if self.__isPlayer and cam:
cam.eZoomStateChanged += self.__onZoomStateChanged
cam.eDistanceChanged += self.__onDistanceChanged
self.__onZoomStateChanged(RTPC_Zoomstate_MAX if cam.isSniperMode else Settings.g_instance.camZoomIndex)
if hasattr(BigWorld.player(), 'eLeaveWorldEvent'):
BigWorld.player().eLeaveWorldEvent += self.__onLeaveWorld
if self.__isPlayer and enemyID:
self.__setHitDirectionRTPC(enemyID)
em = GS().hitSFXManager
if em is not None:
em.register(self)
self.postEvent(ev, self.__onLeaveWorld)
return
def setEffectForce(self, effectName, val, additionalParams=None):
force = val
if effectName in self.__paramPreprocessor:
force = self.__paramPreprocessor[effectName](force,
additionalParams)
effectController = GameEnvironment.getCamera().getAircraftCam(
).effectController
effectController.setEffectForce(effectName, force)
def _initMovingTarget(self):
from gui.HudElements.CrosshairVariants import MovingTarget
self.__crosshairProvider = MovingTarget()
self.__crosshairProvider.init(self.movie)
camera = GameEnvironment.getCamera()
camera.leSetMovingTargetMatrix += self.__setMovingTargetMatrix
BigWorld.player().eLeaveWorldEvent += self._disposeMovingTarget
self._proxyPlayer.leTacticalSpectator += self.__setMovingTargetMatrixTS
def onAirEffect(self, effectName, enable=True):
LOG_DEBUG('### onCameraEffect: ', effectName, enable)
effectController = GameEnvironment.getCamera().getAircraftCam(
).effectController
if enable:
effectController.startAirEffect(effectName)
else:
effectController.stopAirEffect(effectName)
def _disposeCenterPoint(self):
camera = GameEnvironment.getCamera()
camera.leSetCenterPointMatrix -= self.__setCenterPointMatrix
self._proxyPlayer.leTacticalSpectator -= self.__setCenterPointMatrixTS
BigWorld.player().eLeaveWorldEvent -= self._disposeCenterPoint
self.__centerPoint.removeMatrixProvider()
self.__centerPoint = None
return
def cycleSpectatorMode():
cam = GameEnvironment.getCamera()
if cam.getState() != CameraState.DynamicSpectator:
cam.setState(CameraState.DynamicSpectator,
SPECTATOR_TYPE.CINEMATIC,
replayMode=True)
cam.getStateObject().updateTarget(BigWorld.player().id)
cam.getStateObject().cycleSpectatorType()
def _setBomberState(self, newState):
ibs = GameEnvironment.getCamera().getState() is CameraState.Bomber
if self._matrixProvider is not None:
maxBombExplosionD = self._player.getShellController(
).getMaxBombExplosionRadius() / WORLD_SCALING
self._matrixProvider.minTargetSize = maxBombExplosionD if ibs else MIN_BOMB_TARGET_SIZE
self._hud.set_bomber_state(ibs)
return
def dispose(self):
InputMapping.g_instance.onSaveControls -= self._onSaveControls
GameEnvironment.getCamera(
).eZoomStateChanged -= self.__zoomStateChanged
GameEnvironment.getInput(
).eBattleModeChange -= self.__eBattleModeChange
ICMultiUpdate.dispose(self)
self._mouse.dispose()
self.__gunner.dispose()
self._kef = KeysTurnLikeMouse(self)
self.__joystick.dispose()
self.__keyboard.dispose()
self.__overlookCameraInput.dispose()
self.__joystick = None
self.__keyboard = None
self.__overlookCameraInput = None
return
def _disposeMovingTarget(self):
self.__crosshairProvider.removeProviders()
self.__crosshairProvider = None
camera = GameEnvironment.getCamera()
camera.leSetMovingTargetMatrix -= self.__setMovingTargetMatrix
BigWorld.player().eLeaveWorldEvent -= self._disposeMovingTarget
self._proxyPlayer.leTacticalSpectator -= self.__setMovingTargetMatrixTS
return
def _clearEvents(self):
BigWorld.player().eUpdateForce -= self.__onForce
BigWorld.player().onStateChanged -= self.__onPlayerStateChanged
BigWorld.player().eUpdateSpectator -= self.__onSpectator
BigWorld.player().eArenaLoaded -= self.__onArenaLoaded
cam = GameEnvironment.getCamera()
cam.eZoomStateChanged -= self.__onZoomStateChanged
cam.eDistanceChanged -= self.__onDistanceChanged
GS().eLoadingScreenClosed -= self.play
def destroy(self):
self.__stateEffects.destroy()
self.stopNearPlaneEffects()
self.__speedStateMachine.destroy()
self.__paramPreprocessor.clear()
camera = GameEnvironment.getCamera()
camera.getAircraftCam().effectController.clear()
camera.eStateChanged -= self.__onCameraStateChanged
BigWorld.player().eTacticalRespawnEnd -= self.__initSpeedStateMachine
def _initCenterPoint(self):
from gui.HudElements.CenterPointVariants import CenterPoint
self.__centerPoint = CenterPoint()
self.__centerPoint.init(None, self.movie)
camera = GameEnvironment.getCamera()
camera.leSetCenterPointMatrix += self.__setCenterPointMatrix
self._proxyPlayer.leTacticalSpectator += self.__setCenterPointMatrixTS
BigWorld.player().eLeaveWorldEvent += self._disposeCenterPoint
return
def __init__(self, profile):
self._profile = profile
self._cameraStrategy = GameEnvironment.getCamera(
).getDefualtStrategies['CameraStrategyGunner']
self._sensitivityCfc = 0.1
self._cameraStrategy.flexibility = 0
self._isActive = False
self._lastDataToSend = None
ICMultiUpdate.__init__(self, (0.1, self._sendMouseData))
return
def handleSpeed(self, speedMPS, ignoreNonForsageStates=True):
cam = GameEnvironment.getCamera()
cameraState = cam.getState()
isValidCameraState = cameraState in self.__class__.__FORSAGE_STATES if ignoreNonForsageStates else True
if EntityStates.inState(
BigWorld.player(),
EntityStates.GAME | EntityStates.PRE_START_INTRO
) and speedMPS > 0 and isValidCameraState:
speedNorm = clamp(0.0, speedMPS / self.__maxSpeed, 1.0)
self.__speedStateMachine.setTargetSpeed(speedNorm)
def dispose(self):
ICMultiUpdate.dispose(self)
self.__gamePad.dispose()
self.__keyboard.dispose()
self.__gamePad = None
self.__keyboard = None
freeState = GameEnvironment.getCamera().stateObject(CameraState.Free)
if freeState:
freeState.setInvertVertical(False)
InputMapping.g_instance.onSaveControls -= self._onSaveControls
GameEnvironment.getInput().eBattleModeChange -= self.__eBattleModeChange
return
def __onLeaveWorld(self):
player = BigWorld.player()
if hasattr(player, 'eLeaveWorldEvent'):
player.eLeaveWorldEvent -= self.__onLeaveWorld
cam = GameEnvironment.getCamera()
if self.__isPlayer and cam:
cam.eZoomStateChanged -= self.__onZoomStateChanged
cam.eDistanceChanged -= self.__onDistanceChanged
self.stopAll(500, True)
em = GS().hitSFXManager
if em is not None:
em.unregister(self)
self.destroy()
return
def notControlledByUser(self, value):
self._cameraStrategy.rotateCursor(0, 0)
self._notControlledByUser = value
if value and not self._lockCursor:
self._cameraStrategy.lockCursor()
if not value and self._lockCursor:
self._cameraStrategy.unlockCursor()
self._lockCursor = bool(value)
if value & NOT_CONTROLLED_MOD.AUTOPILOT:
GameEnvironment.getCamera(
).getDefualtStrategies['CameraStrategyMouse'].autopilot = True
if value & NOT_CONTROLLED_MOD.PLANE_ALIGN:
self._mousePosition.x = 0
self._mousePosition.y = 0
def _onSaveControls(self):
self.__isSlipComp = InputMapping.g_instance.mouseSettings.SLIP_COMPENSATION
BigWorld.player().cell.sendLiningFlag(
clamp(0, self.__isSlipComp * 255, 255))
settings = InputMapping.g_instance.mouseSettings
camera = GameEnvironment.getCamera(
).getDefualtStrategies['CameraStrategyNormal']
cameraInertia = settings.INERTIA_CAMERA
camera.speedRoll = CAMERA_ROLL_SPEED
camera.speedYaw = CAMERA_YAW_SPEED + 2.0 * CAMERA_YAW_SPEED * (
1.0 - cameraInertia) if cameraInertia > 0 else 100
camera.speedPitch = CAMERA_PITCH_SPEED + 2.0 * CAMERA_PITCH_SPEED * (
1.0 - cameraInertia) if cameraInertia > 0 else 100
if InputMapping.g_instance.primarySettings.INVERT_VERT:
self.__keyboard.verticalSign(1.0)
else:
self.__keyboard.verticalSign(-1.0)
def onCameraEffect(self,
effectName,
enable=True,
force=1.0,
dir=Math.Vector3(0.0, 0.0, 0.0),
additionalParams=None,
stopImmediately=False):
effectController = GameEnvironment.getCamera().getAircraftCam(
).effectController
if enable:
if effectName in self.__paramPreprocessor:
newForce = self.__paramPreprocessor[effectName](
force, additionalParams)
if newForce is not None:
force = newForce
effectController.startEffect(effectName, force, dir)
else:
effectController.stopEffect(effectName, stopImmediately)
return
def _onSaveControls(self):
jSet = InputMapping.g_instance.joystickSettings
spline = type('splineDummy', (), {'p': [Math.Vector2(0.0, 1.0), Math.Vector2(1.0, 1.0)],
'pointCount': 100})
self.__setMouseSpline(spline)
combatStrategy = GameEnvironment.getCamera().getDefualtStrategies['CameraStrategyGamepad']
if jSet.CAMERA_TYPE == 0:
combatStrategy.behaviorHorizon = 0
BigWorld.player().cell.sendCameraModType(0)
elif jSet.CAMERA_TYPE == 2:
combatStrategy.behaviorHorizon = 1
BigWorld.player().cell.sendCameraModType(1)
else:
raise
combatStrategy.reset()
combatStrategy.flexibility = jSet.CAMERA_FLEXIBILITY
BigWorld.player().cell.sendAutomaticFlapsChanged(jSet.AUTOMATIC_FLAPS)
BigWorld.player().cell.sendFlipFlag(jSet.SHIFT_TURN)
BigWorld.player().cell.sendInputSimpleMode(jSet.SAFE_ROLL_ON_LOW_ALTITUDE)
BigWorld.player().cell.sendRollSpeedCfc(FloatToUCInt8(1.0 * jSet.ROLL_SPEED_CFC + 0.0))
BigWorld.player().cell.sendIntensityAlignmentInCenter(FloatToUCInt8(jSet.EQUALIZER_FORCE))
BigWorld.player().cell.sendTrackingCamera(InputMapping.g_instance.mouseSettings.ALLOW_LEAD)
def _onSaveControls(self):
settings = InputMapping.g_instance.mouseSettings
camera = GameEnvironment.getCamera(
).getDefualtStrategies['CameraStrategyNormal']
cameraInertia = settings.INERTIA_CAMERA
cameraInertiaRoll = settings.INERTIA_CAMERA_ROLL
camera.speedRoll = CAMERA_ROLL_SPEED + 2.0 * CAMERA_ROLL_SPEED * (
1.0 - cameraInertiaRoll) if cameraInertiaRoll > 0 else 100
camera.speedYaw = CAMERA_YAW_SPEED + 2.0 * CAMERA_YAW_SPEED * (
1.0 - cameraInertia) if cameraInertia > 0 else 100
camera.speedPitch = CAMERA_PITCH_SPEED + 2.0 * CAMERA_PITCH_SPEED * (
1.0 - cameraInertia) if cameraInertia > 0 else 100
flex = lambda x, min_, max_: (max_ - min_) * math.pow(
x, 2.0) * math.exp(x - 1) + min_
self.__overlookCameraInput.setTurnSpeed(
flex(settings.HATKA_MOVE_SPEED, 100, 400))
camera.flexibility = flex(1.0 - settings.HATKA_MOVE_SPEED, 1e-15,
0.0001)
self._isSlipComp = settings.SLIP_COMPENSATION_VALUE
BigWorld.player().cell.sendLiningFlag(
int(clamp(0.0, settings.SLIP_COMPENSATION_VALUE * 255, 255)))
BigWorld.player().cell.sendJoyVersionFlag(
settings.JOY_VERSION_SWITCHER)
self.__joystick.pushLastEvent()
