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
