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()