def __init__(self): player = BigWorld.player() visualSettings = player.settings.airplane.visualSettings aircraftVibrationMatrix = player.resMatrix.a.a customOutputSettings = BigWorld.player( ).settings.airplane.visualSettings.accelFovSettings.outputSettings customOutputHalflifes = {} for outputData in customOutputSettings.itervalues(): customOutputHalflifes[outputData.id] = outputData.settingHalflife GameEnvironment.getCamera().getAircraftCam().effectController.init( CAMERAEFFECTS_PATH, visualSettings.camera, aircraftVibrationMatrix, customOutputHalflifes) self.__forsageValue = self.PS_NORMAL self.__paramPreprocessor = {} shootingEffectID = visualSettings.cameraEffects.shooting self.__paramPreprocessor[ shootingEffectID] = self.__preprocessShootingParams self.__paramPreprocessor[ 'NEAR_PLANE_AIRWAVE'] = self.__preprocessNearPlaneParams self.__speedStateMachine = SpeedStateMachine() self.__maxSpeed = VELLOCITY_OF_SOUND self.__initSpeedStateMachine() self.__nearPlaneDistances = {} self.__wakePlaneForces = {} self.__cbUpdateNearPlaneEffects = None self.__rollkeyboardAxisValue = 0 self.__stateEffects = self._createStateEffectsController() return
def __init__(self, inputAxis, notControlledByUser): self._notControlledByUser = notControlledByUser self._forciblySendAxis = False self.__overlookCameraInput = cameraOverlookInput() InputMapping.g_instance.onSaveControls += self._onSaveControls GameEnvironment.getCamera( ).eZoomStateChanged += self.__zoomStateChanged GameEnvironment.getInput( ).eBattleModeChange += self.__eBattleModeChange self.__axisKeyBoard = [0.0] * 5 self.__axisJoy = [0.0] * 5 self.__axisExtra = [0.0] * 5 self.__lastAxis = [0.0] * 5 self._isSlipComp = False self.__battleMode = BATTLE_MODE.COMBAT_MODE self.__lastJoyMouseEvent = JoyMouseEvent() self.__mpp = MouseProfileProxy(self) planeType = getattr(BigWorld.player(), 'planeType', -1) self._mouse = getMouseInput(planeType)(self.__mpp) self.__gunner = getGunnerInput(planeType)(self.__mpp) self._kef = KeysTurnLikeMouse(self) self.__keyboard = KeyboardInput(self._kef.get_filter()) self.__keyboard.isMultiplySignal = False self.__joystick = JoystickExpertInput(self) self.__joystick.pushLastEvent() ICMultiFunction = lambda: (self.__autopilotUpdate() if self._notControlledByUser else None) joyMouseEventGenerator = lambda: (self.__generateMouseEvent() if self._altActivityState else None) ICMultiUpdate.__init__(self, (0.1, ICMultiFunction), (mouse_event_dt, joyMouseEventGenerator)) self._onSaveControls()
def processMouseEvent(self, event): X = event.dx Y = event.dy if math.hypot(event.dx, event.dy): X = self.__signalSmoothing('x', event.dx) Y = self.__signalSmoothing('y', event.dy) else: self.__smoothStack = {'x': [0], 'y': [0]} signY = 1.0 if self._profile.settings.MOUSE_INVERT_VERT else -1.0 sensitivityX = ( 0.1 + 0.9 * self._profile.mouseSensitivity(event) ) * self._sensitivityCfc * self._additionalMouseSensitivity sensitivityY = signY * sensitivityX BigWorld.setSpectatorMouseSensitivity( sensitivityX * SENSITIVITY_OVERVIEW_MODE_MULTIPLIER, sensitivityY * SENSITIVITY_OVERVIEW_MODE_MULTIPLIER) dx = self._backRevert * X * sensitivityX dy = self.modYSensOnLowAlt(Y * sensitivityY) if GameEnvironment.getCamera().isSniperMode: dx *= SENSITIVITY_SNIPER_MODE_MULTIPLIER dy *= SENSITIVITY_SNIPER_MODE_MULTIPLIER elif self._isExtraMode: dx *= SENSITIVITY_OVERVIEW_MODE_MULTIPLIER dy *= SENSITIVITY_OVERVIEW_MODE_MULTIPLIER if GameEnvironment.getCamera().getState() != CameraState.Target: self._cameraStrategy.rotateCursor(math.radians(dy), math.radians(dx)) self.__isMoved = True else: self._cameraStrategy.rotateCursor(0, 0)
def _onSaveControls(self): camType = InputMapping.g_instance.mouseSettings.CAMERA_TYPE MouseCombatStrategy = GameEnvironment.getCamera().getDefualtStrategies['CameraStrategyMouse'] GameEnvironment.getCamera().stateObject(CameraState.Free).setInvertVertical(InputMapping.g_instance.primarySettings.MOUSE_INVERT_VERT) if camType == 1: self.__switchMouseInput(self.__mouseList[CAMERA_STRATEGY.LOCAL]) MouseCombatStrategy.behaviorHorizon = 0 BigWorld.player().cell.sendCameraModType(0) elif camType == 0: MouseCombatStrategy.behaviorHorizon = 1 self.__switchMouseInput(self.__mouseList[CAMERA_STRATEGY.WORLD]) BigWorld.player().cell.sendCameraModType(1) elif camType == 2: MouseCombatStrategy.behaviorHorizon = 1 self.__switchMouseInput(self.__mouseList[CAMERA_STRATEGY.WORLD]) BigWorld.player().cell.sendCameraModType(1) else: raise spline = InputMapping.g_instance.mouseSettings.MOUSE_INTENSITY_SPLINE self.__setMouseSpline(spline) MouseCombatStrategy.reset() MouseCombatStrategy.flexibility = 0.0 self._mouse.window = 1 BigWorld.player().cell.sendAutomaticFlapsChanged(InputMapping.g_instance.mouseSettings.AUTOMATIC_FLAPS) BigWorld.player().cell.sendFlipFlag(InputMapping.g_instance.mouseSettings.SHIFT_TURN) BigWorld.player().cell.sendInputSimpleMode(InputMapping.g_instance.mouseSettings.SAFE_ROLL_ON_LOW_ALTITUDE) BigWorld.player().cell.sendRollSpeedCfc(FloatToUCInt8(1.0 * InputMapping.g_instance.mouseSettings.ROLL_SPEED_CFC + 0.0)) BigWorld.player().cell.sendIntensityAlignmentInCenter(FloatToUCInt8(InputMapping.g_instance.mouseSettings.EQUALIZER_FORCE)) BigWorld.player().cell.sendTrackingCamera(InputMapping.g_instance.mouseSettings.ALLOW_LEAD) BigWorld.player().cell.sendMixingMethod(InputMapping.g_instance.mouseSettings.METHOD_OF_MIXING) self._mouse.restart()
def play(self, display): #GameEnvironment.game(display, npc, self) #print '1' GameEnvironment.game(display, npc.npc1(20,20), self) """
def __init__(self, *battleStates): self._targetID = -1 self._ownBattleStateTuple = battleStates self._currBattleState = None GameEnvironment.getInput( ).eBattleModeChange += self.__onBattleStateChange return
def __init__(self, inputAxis, notControlledByUser, currentBattleMode): self.__mouseList = [MousePlaneDirection, MouseCursorDirection] self.__axisKeyBoard = [0.0] * 5 self.__axisExtra = [0.0] * 5 self.__lastAxis = [0.0] * 5 self.__lastKeyBoardAxis = [0.0] * 5 self.__resetAxis() self._notControlledByUser = notControlledByUser self.__battleMode = currentBattleMode self.__spline = None self.__smoothSpline = None self.__processor = None self.__inputAxis = inputAxis self._mouse = MouseInputProxy(self) self._kef = KeysTurnLikeMouse(self) self.__keyboard = KeyboardInput(self._kef.get_filter()) self.__keyboard.isMultiplySignal = False self.__gunner = GunnerInput(self) self._onSaveControls() self.__camDirection = Math.Vector3() InputMapping.g_instance.onSaveControls += self._onSaveControls GameEnvironment.getInput().eBattleModeChange += self.__eBattleModeChange ICMultiFunction = lambda : (self.__autopilotUpdate() if self._notControlledByUser else None) ICMultiUpdate.__init__(self, (0.1, self.__updateVisibleAxis), (0.1, ICMultiFunction)) return
def _clearEvents(self): AircraftEngineStrategyPlayerBase._clearEvents(self) BigWorld.player( ).eUpdateEngineTemperature -= self.__updateEngineTemperature BigWorld.player().eEngineOverheat -= self.__onEngineOverheat GameEnvironment.g_instance.ePartStateChanging -= self.__onPartState GameEnvironment.getInput( ).eBattleModeChange -= self.__onBattleModeChange
def _init(self, interface): self._interface = interface self._battleMode = BATTLE_MODE.COMBAT_MODE self._owner.eTacticalRespawnEnd += self._onTacticalRespawn GameEnvironment.getInput( ).eBattleModeChange += self._onBattleModeChange self._updateCategoryDistances() self._updateCircleRadius()
def dispose(self): ICMultiUpdate._SuspendUpdates(self) if self.__lockCursor: self.__cameraStrategy.unlockCursor() self.__cameraStrategy = None self.__profile = None GameEnvironment.getCamera().leaveState(CameraState.Back) return
def dispose(self): ICMultiUpdate.dispose(self) if self._lockCursor: self._cameraStrategy.unlockCursor() self._profile = None self._cameraStrategy = None GameEnvironment.getCamera().leaveState(CameraState.Back) GlobalEvents.onSetFocus -= self.__onSetFocus return
def _destroy(self): self._owner.eTacticalRespawnEnd -= self._tacticalRespawn GameEnvironment.g_instance.eAvatarHealthChange -= self._hitEntity GameEnvironment.getInput( ).eAddProcessorListeners -= self._addInputListeners GameEnvironment.getInput( ).eBattleModeChange -= self.__onBattleModeChange self.__cppObj = None self._lockingAdapter.destroy() return
def __init__(self, owner, lockingAdapter): AvatarControllerBase.__init__(self, owner) self.__cppObj = None self._lockingAdapter = lockingAdapter self._owner.eTacticalRespawnEnd += self._tacticalRespawn GameEnvironment.g_instance.eAvatarHealthChange += self._hitEntity GameEnvironment.getInput( ).eAddProcessorListeners += self._addInputListeners GameEnvironment.getInput( ).eBattleModeChange += self.__onBattleModeChange return
def __initSpeedStateMachine(self, *args, **kwargs): self.__speedStateMachine.reset() player = BigWorld.player() playerCameraID = player.settings.airplane.visualSettings.camera camPresetInfo = db.DBLogic.g_instance.cameraEffects.camPresetInfo if playerCameraID in camPresetInfo: curHullID = player.logicalParts[LOGICAL_PART.HULL] curEngineID = player.logicalParts[LOGICAL_PART.ENGINE] try: stallSpeed = player.settings.airplane.flightModel.hull[ curHullID].stallSpeed diveSpeed = player.settings.airplane.flightModel.hull[ curHullID].diveSpeed except: LOG_ERROR( 'Failed to get speed values for current parts (Airplane ID: {0}, Hull ID: {1}, Engine ID: {2}). Using default part values.' .format(player.settings.airplane.name, curHullID, curEngineID)) stallSpeed = player.settings.airplane.flightModel.hull[ 0].stallSpeed diveSpeed = player.settings.airplane.flightModel.hull[ 0].diveSpeed slowZoneStart = 0.0 fastZoneEnd = 1.0 self.__minSpeed = stallSpeed self.__maxSpeed = diveSpeed engineMaxSpeed = player.settings.airplane.flightModel.engine[ curEngineID].maxSpeed idle_start = ( 1.0 - (diveSpeed - engineMaxSpeed) / SPEED_EFFECT_DIVIDE_COEF * (1.0 - engineMaxSpeed / diveSpeed) ) * SPEED_IDLE_EFFECT_START_COEF idle_end = ( 1.0 - (diveSpeed - engineMaxSpeed) / SPEED_EFFECT_DIVIDE_COEF * (1.0 - engineMaxSpeed / diveSpeed) ) * SPEED_IDLE_EFFECT_END_COEF GameEnvironment.getCamera().onSpeedStateMachineInitialized( self.__minSpeed, self.__maxSpeed) slowSpeedState = SpeedState(slowZoneStart, idle_start, 'SLOW_SPEED', None, SpeedState.NORMAL, self.__speedStateMachine) self.__speedStateMachine.addState(SpeedState.SLOW, slowSpeedState) idleSpeedState = SpeedState(idle_start, idle_end, 'NORMAL_SPEED', SpeedState.SLOW, SpeedState.FAST, self.__speedStateMachine) self.__speedStateMachine.addState(SpeedState.NORMAL, idleSpeedState) fastSpeedState = SpeedState(idle_end, fastZoneEnd, 'FAST_SPEED', SpeedState.NORMAL, None, self.__speedStateMachine) self.__speedStateMachine.addState(SpeedState.FAST, fastSpeedState) return
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 destroy(self): GameEnvironment.getCamera().eStateChanged -= self._setBomberState self.setVisible(False) if self._inited: for el in self._hud.elements.itervalues(): GUI.delRoot(el) el.bombMP = None self._inited = False self._visible = False self._hud.delete() self.dispose() return
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 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 loadArena(self): self.__interactiveMix.createArena() self.__voice = VoiceoversSoundObject() self.__hits = HitSFXFactory() self.__explosions = ExplosionSFXFactory() self.music.playArena() self.__prevTarget = None self.__winner = False self.__draw = False self.__prevTarget = None self.__burning = {} postGlobalEvent(GLOBAL_EVENTS.LOAD_ARENA) GameEnvironment.getClientArena( ).onGameResultChanged += self.__onGameResultChanged SoundUpdateManager.instance().start() return
def __getFightPhase(self, flag=FLAG.NONE): if self.__currentSoundPhase in ( SOUND_PHASES.RESULT_SCREEN, SOUND_PHASES.SCREEN) or self.__currentSoundPhase in ( SOUND_PHASES.SPECTATOR, SOUND_PHASES.NOSEDIVING) and not flag == FLAG.RESPAWN: return phase = SOUND_PHASES.PILOTING player = BigWorld.player() visibleAvatars = player.visibleAvatars.values() if flag == FLAG.LEAVE_WORLD: enemiesCounter = 0 for avatar in visibleAvatars: arena = GameEnvironment.getClientArena() isTeamate = arena.avatarInfos.get(player.id).get( 'teamIndex', -1) == arena.avatarInfos.get(avatar.id).get('teamIndex', -1) if not isTeamate and not EntityStates.inState( avatar, EntityStates.DESTROYED): if not flag == FLAG.LEAVE_WORLD or enemiesCounter: phase = SOUND_PHASES.DOGFIGHT break else: enemiesCounter += 1 return phase
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 _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, 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 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 _sendMouseData(self): import BattleReplay if BattleReplay.isPlaying(): if self._inGame and not self._isExtraMode: self._updateCurrentRadius() return MouseInput._sendMouseData(self) if self._inGame and not self._isExtraMode: self._updateCurrentRadius() direction = self._cameraStrategy.cursorDirection direction = direction if not self._isExtraMode else self.__lastDirection self._profile.setCamDirection(direction) if not isValid(direction): print 'trap', direction, BigWorld.player().getRotation( ).getAxisZ() return dataDir, exAxis = self._prepareMousePackage(direction) up = self._cameraStrategy.cursorUp if not self._isExtraMode else Math.Vector3( 0, 1, 0) up = FloatArrayToTupleOfCInt16(up) self.__lastDirection = direction if dataDir != self._lastDataDir: self._profile.setBattleDirection(Math.Vector3(direction)) self._lastDataDir = dataDir timeSend = GameEnvironment.getInput().inputAxis.serverTime BigWorld.player().cell.sendMouseDirData(timeSend, dataDir) if up != self._lastUp: self._lastUp = up BigWorld.player().cell.sendMouseUp(up) if exAxis != self._lastExSpeed: self._lastExSpeed = exAxis BigWorld.player().cell.sendMouseExtRSpeed(exAxis)
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 handleMessage(self, toJid, senderId, senderName, message): LOG_DEBUG('Xmpp chat: handleMessage:', toJid, senderId, senderName, message) hud = GameEnvironment.getHUD() if hud and toJid == self.__curSquadChannel: hud.showTextMessageFromLobby(int(senderId), MESSAGE_TYPE.BATTLE_SQUAD, message)
def _createControllers(self): controllersData = GameEnvironment.getClientArena( ).createTeamObjectControllers(self.id, self._settings, self, self.partTypes, self.partStates) modelManipulator = controllersData['modelManipulator'] self._registerController('modelManipulator', modelManipulator) self.model = modelManipulator.getRootModel() self.model.delMotor(self.model.motors[0]) self.model.addMotor(BigWorld.Servo(self.resMatrix)) modelManipulator.setMatrixProvider(self.resMatrix) turretsLogic = controllersData.get('turretsLogic', None) if turretsLogic: turretsLogic.setOwner(self) self._registerController('turretsLogic', turretsLogic) self.ePartStateChanged += turretsLogic.onPartStateChanged if self.scenarioName != '': if not self.scenarioName.endswith( '.xml') and not self.scenarioName.endswith('.plan'): scenarioData = db.DBLogic.g_instance.getScenario( self.scenarioName) if scenarioData: scenarioController = TeamObjectScenarioController( self, scenarioData) self._registerController('scenarioController', scenarioController) else: LOG_ERROR("Can't find scenario", self.scenarioName) soundController = controllersData['soundController'] self._registerController('soundController', soundController) return
def init(self): self.initSpeedSystem() camera = GameEnvironment.getCamera() camera.eStateChanged += self.__onCameraStateChanged self.__initOscillations() self.startAccelerationEffect() BigWorld.player().eTacticalRespawnEnd += self.__initSpeedStateMachine
def getFitness(self, display): self.fitness = 0 #print '1' self.fitness += GameEnvironment.game(display, npc.npc1(20,20), self) #print '2' self.fitness += GameEnvironment.game(display, npc.npc2(20,20), self) #print '3' self.fitness += GameEnvironment.game(display, npc.npc3(20,20), self) #print '4' self.fitness += GameEnvironment.game(display, npc.npc4(20,20), self) #print '5' self.fitness += GameEnvironment.game(display, npc.npc5(20,20), self) #print '6' self.fitness += GameEnvironment.game(display, npc.npc6(20,20), self) self.fitness = self.fitness/6