def onChange(isSelected):
if isSelected:
WWISE.WW_eventGlobal(_FrontLineSounds.__SELECT_EVENT)
WWISE.WW_setState(_FrontLineSounds.__STATE_GROUP, _FrontLineSounds.__STATE_SELECTED)
else:
WWISE.WW_eventGlobal(_FrontLineSounds.__DESELECT_EVENT)
WWISE.WW_setState(_FrontLineSounds.__STATE_GROUP, _FrontLineSounds.__STATE_DESELECTED)
def changePlayMode(self, mode):
if BigWorld.player().getVehicleAttached() is not None:
__ceilLess = BigWorld.player().getVehicleAttached().typeDescriptor.turret['ceilless']
else:
__ceilLess = BigWorld.player().vehicleTypeDescriptor.turret['ceilless']
if mode == 0:
WWISE.WW_setRTCPGlobal('RTPC_ext_viewPlayMode', 1)
if __ceilLess is True:
WWISE.WW_setState('STATE_viewPlayMode', 'STATE_viewplaymode_arcade_ceilless')
else:
WWISE.WW_setState('STATE_viewPlayMode', 'STATE_viewPlayMode_arcade')
WWISE.WWsetCameraShift(None)
elif mode == 1:
WWISE.WW_setRTCPGlobal('RTPC_ext_viewPlayMode', 0)
if __ceilLess is True:
WWISE.WW_setState('STATE_viewPlayMode', 'STATE_viewplaymode_sniper_ceilless')
else:
WWISE.WW_setState('STATE_viewPlayMode', 'STATE_viewPlayMode_sniper')
if BigWorld.player().getVehicleAttached() is not None:
compoundModel = BigWorld.player().getVehicleAttached().appearance.compoundModel
WWISE.WWsetCameraShift(compoundModel.node(TankPartNames.TURRET))
elif mode == 2:
WWISE.WW_setRTCPGlobal('RTPC_ext_viewPlayMode', 2)
WWISE.WW_setState('STATE_viewPlayMode', 'STATE_viewPlayMode_strategic')
WWISE.WWsetCameraShift(None)
__ceilLess = None
return
def setOverlayHangarGeneral(onState):
if onState:
WWISE.WW_setState(Sounds.OVERLAY_HANGAR_GENERAL,
Sounds.OVERLAY_HANGAR_GENERAL_ON)
else:
WWISE.WW_setState(Sounds.OVERLAY_HANGAR_GENERAL,
Sounds.OVERLAY_HANGAR_GENERAL_OFF)
def setProgressSound(self, divisionUserID=None, isLoud=True):
if isLoud:
WWISE.WW_setState(Sounds.SUBVIEW_HANGAR_GENERAL,
Sounds.SUBVIEW_HANGAR_GENERAL_OFF)
else:
WWISE.WW_setState(Sounds.SUBVIEW_HANGAR_GENERAL,
Sounds.SUBVIEW_HANGAR_GENERAL_ON)
if divisionUserID is None:
WWISE.WW_setState(Sounds.PROGRESSION_STATE,
Sounds.PROGRESSION_STATE_LEAGUES)
else:
stateSound = _DIVISION_TO_PROGRESSION_SOUND.get(divisionUserID)
if stateSound is not None:
WWISE.WW_setState(Sounds.PROGRESSION_STATE, stateSound)
return
def __handleEntityUpdated(self, event):
ctx = event.ctx
state = ctx['state']
if state == CameraMovementStates.FROM_OBJECT:
return
if self.hangarSpace.spaceInited:
isMainView = ctx['entityId'] == self.hangarSpace.space.vehicleEntityId
else:
isMainView = True
if state == CameraMovementStates.MOVING_TO_OBJECT:
SoundGroupsInstance.playSound2D(self._MoveCameraEvents.MOVE_TO_MAIN if isMainView else self._MoveCameraEvents.MOVE_TO_HERO)
if isMainView != self.__isMainView:
self.__isMainView = isMainView
WWISE.WW_setState(self._SelectedVehicleStates.STATE_NAME, self._SelectedVehicleStates.MAIN_VEHICLE if self.__isMainView else self._SelectedVehicleStates.HERO_VEHICLE)
WWISE.WW_setState(self._CameraStates.STATE_NAME, self._CameraStates.MAIN_VEHICLE_AND_NOT_IN_IDLE if self.__isMainView else self._CameraStates.HERO_VEHICLE_OR_IN_IDLE)
def _onLoading(self, itemCD, vehicleCD, progressionLevel, showSecondButton):
self.__item = self.__itemsCache.items.getItemByCD(itemCD)
self.__vehicle = self.__itemsCache.items.getItemByCD(vehicleCD) if vehicleCD != UNBOUND_VEH_KEY else g_currentVehicle.item
self.__level = progressionLevel
self.__itemsInNeedToUpgrade = self.__getItemsInNeedToUpgrade()
if self.__item is None:
raise SoftException('invalid item: &s', itemCD)
if self.__vehicle is None:
raise SoftException('invalid vehicle: &s', vehicleCD)
if self.__level > 1 and not self.__itemsInNeedToUpgrade and getItemInstalledCount(self.__item) > 0:
self.__resetItemNovelty()
isNewItem = self.__level == 1
with self.viewModel.transaction() as model:
model.setIsNewItem(isNewItem)
showSecondButton = showSecondButton and isVehicleCanBeCustomized(self.__vehicle, GUI_ITEM_TYPE.STYLE, itemsFilter=lambda item: item.isProgressionRequiredCanBeEdited(self.__vehicle.intCD))
if vehicleCD != UNBOUND_VEH_KEY:
self.__setVehicleInfo(model)
self.__setItemInfo(model)
self.__setButtons(model, showSecondButton)
self.__updateButtons(model=model)
if isNewItem:
eventName = SOUNDS.NEW_PROGRESSIVE_DECAL
else:
eventName = SOUNDS.PROGRESSIVE_DECAL_UPGRADE
WWISE.WW_eventGlobal(eventName)
WWISE.WW_setState(ProgressiveRewardSoundEvents.PROGRESSIVE_REWARD_VIEW_GROUP, ProgressiveRewardSoundEvents.PROGRESSIVE_REWARD_VIEW_ENTER)
return
def _initialize(self, *args, **kwargs):
super(NationChangeScreen, self)._initialize()
with self.viewModel.transaction() as vm:
vm.setCurrentTankLvl(int2roman(self.__currentVehicle.level))
vm.setTargetTankLvl(int2roman(self.__targetVehicle.level))
vm.setCurrentTankType(
getVehTypeIconName(self.__currentVehicle.type,
self.__currentVehicle.isElite))
vm.setTargetTankType(
getVehTypeIconName(self.__targetVehicle.type,
self.__targetVehicle.isElite))
vm.setCurrenTankName(self.__currentVehicle.userName)
vm.setTargetTankName(self.__targetVehicle.userName)
vm.setCurrentNation(
getIconResourceName(self.__currentVehicle.nationName))
vm.setTargetNation(
getIconResourceName(self.__targetVehicle.nationName))
vm.setCurrentTankTooltipHeader(self.__currentVehicle.longUserName)
vm.setCurrentTankTooltipBody(self.__currentVehicle.fullDescription)
currentVehicle = self.__currentVehicle
targetVehicle = self.__targetVehicle
currentVehNumSetups = self.__updateTankSlot(
vm.currentNation, currentVehicle)
vm.setCurrentTankSetupsNumber(currentVehNumSetups)
targetVehNumSetups = self.__updateTankSlot(vm.targetNation,
targetVehicle)
vm.setTargetTankSetupsNumber(targetVehNumSetups)
self.__addListeners()
self.__setViewed()
WWISE.WW_setState(self._HANGAR_SOUND_FILTERED_STATE_NAME,
self._HANGAR_SOUND_FILTERED_STATE_ON)
def __handleIdleCameraActivation(self, event):
if not self.__isMainView:
return
WWISE.WW_setState(
self._CameraStates.STATE_NAME,
self._CameraStates.HERO_VEHICLE_OR_IN_IDLE if event.ctx['started']
else self._CameraStates.MAIN_VEHICLE_AND_NOT_IN_IDLE)
def setPeriod(self, period):
if BattleReplay.g_replayCtrl.isTimeWarpInProgress and period in (
ARENA_PERIOD.WAITING, ARENA_PERIOD.PREBATTLE):
return
else:
state_value = self._ARENA_PERIOD_STATE.get(period, None)
if state_value is not None:
WWISE.WW_setState(self._STATE_ID, state_value)
return
def onVideoStart(videoId, sourceID=''):
eventName = _MarathonVideoEvents.VIDEO_START.get(videoId)
if eventName is not None:
if videoId in (MarathonVideos.VEHICLE, ):
eventName = eventName.format(sourceID.replace('-', '_'))
WWISE.WW_eventGlobal(eventName)
WWISE.WW_setState(_MarathonVideoStates.GROUP,
_MarathonVideoStates.START)
return
def __updateSounds(self, key):
if self.__soundConfig is None:
return
else:
actionSoundConfig = self.__soundConfig.get(key)
if actionSoundConfig is not None:
event = actionSoundConfig.get('event')
state = actionSoundConfig.get('state')
if event is not None:
WWISE.WW_eventGlobal(event)
if state is not None:
WWISE.WW_setState(state[0], state[1])
return
def onVideoStart(self, videoId, sourceID=''):
eventName = LootBoxVideoEvents.VIDEO_START.get(videoId)
if eventName is not None:
if videoId in (LootBoxVideos.VEHICLE, LootBoxVideos.STYLE):
eventName = eventName.format(sourceID.replace('-', '_'))
elif videoId == LootBoxVideos.OPEN_BOX:
eventName = eventName.format(sourceID)
WWISE.WW_eventGlobal(eventName)
WWISE.WW_setState(_LootBoxVideoStates.GROUP,
_LootBoxVideoStates.START)
self.__started = True
if self.__checkPauseOnStart and not Windowing.isWindowAccessible():
playSound(LootBoxVideoEvents.VIDEO_PAUSE)
return
def changePlayMode(self, mode):
__ceilLess = None
if BigWorld.player().getVehicleAttached() is not None:
vehicleTypeDescriptor = BigWorld.player().getVehicleAttached(
).typeDescriptor
else:
vehicleTypeDescriptor = BigWorld.player().vehicleTypeDescriptor
if vehicleTypeDescriptor is not None:
__ceilLess = vehicleTypeDescriptor.turret.ceilless
if mode == 0:
self.__viewPlayModeParam.set(1)
if __ceilLess is True:
WWISE.WW_setState('STATE_viewPlayMode',
'STATE_viewplaymode_arcade_ceilless')
else:
WWISE.WW_setState('STATE_viewPlayMode',
'STATE_viewPlayMode_arcade')
WWISE.WWsetCameraShift(None)
elif mode == 1:
self.__viewPlayModeParam.set(0)
if __ceilLess is True:
WWISE.WW_setState('STATE_viewPlayMode',
'STATE_viewplaymode_sniper_ceilless')
else:
WWISE.WW_setState('STATE_viewPlayMode',
'STATE_viewPlayMode_sniper')
if BigWorld.player().getVehicleAttached() is not None:
compoundModel = BigWorld.player().getVehicleAttached(
).appearance.compoundModel
WWISE.WWsetCameraShift(compoundModel.node(
TankPartNames.TURRET))
elif mode == 2:
self.__viewPlayModeParam.set(2)
WWISE.WW_setState('STATE_viewPlayMode',
'STATE_viewPlayMode_strategic')
WWISE.WWsetCameraShift(None)
return
def onSoundModeChanged(self,
isRankedSoundMode,
initialProgressionState=None):
if isRankedSoundMode:
if self.__isFirstEntrance:
self.__isFirstEntrance = False
WWISE.WW_eventGlobal(Sounds.FIRST_SELECT_EVENT)
else:
WWISE.WW_eventGlobal(Sounds.SELECT_EVENT)
if initialProgressionState is not None:
WWISE.WW_setState(Sounds.PROGRESSION_STATE,
initialProgressionState)
else:
WWISE.WW_eventGlobal(Sounds.DESELECT_EVENT)
return
def __onArenaStateChanged(self, *args):
from BattleReplay import g_replayCtrl
if self._skipArenaChanges:
return
else:
arena = BigWorld.player().arena
period = arena.period
if not g_replayCtrl.isTimeWarpInProgress or period == ARENA_PERIOD.BATTLE:
stateValue = _ARENA_PERIOD_STATE.get(period, None)
if stateValue is not None:
WWISE.WW_setState(_ARENA_PERIOD_STATE_NAME, stateValue)
if period == ARENA_PERIOD.PREBATTLE or period == ARENA_PERIOD.BATTLE:
if self.__isOnArena and not g_replayCtrl.isTimeWarpInProgress:
if not self.isPlaying(AMBIENT_EVENT_COMBAT):
self.play(AMBIENT_EVENT_COMBAT)
if period == ARENA_PERIOD.BATTLE and self.__isOnArena:
self.play(MUSIC_EVENT_COMBAT)
elif period == ARENA_PERIOD.AFTERBATTLE:
wwSetup = self.__specialSounds.arenaMusicSetup
self.stopAmbient()
if wwSetup is not None:
import SoundGroups
SoundGroups.g_instance.playSound2D(
wwSetup.get('wwmusicEndbattleStop', ''))
lastBattleEvents = {}
if wwSetup is not None:
lastBattleEvents[MUSIC_EVENT_COMBAT_VICTORY] = wwSetup.get(
'wwmusicResultWin', '')
lastBattleEvents[MUSIC_EVENT_COMBAT_DRAW] = wwSetup.get(
'wwmusicResultDrawn', '')
lastBattleEvents[MUSIC_EVENT_COMBAT_LOSE] = wwSetup.get(
'wwmusicResultDefeat', '')
elif hasattr(arena.arenaType, 'battleLoseMusic'):
lastBattleEvents[
MUSIC_EVENT_COMBAT_LOSE] = arena.arenaType.battleLoseMusic
MusicController.__lastBattleResultEvents = lastBattleEvents
return
def onBecomePlayer(self):
WWISE.WW_setState(_ARENA_PERIOD_STATE_NAME,
_ARENA_PERIOD_STATE[ARENA_PERIOD.WAITING])
def _onLoading(self, highlightedComponentId=-1, makeTopView=False):
_logger.debug('DogTags::_onLoading')
self.__update(highlightedComponentId)
switchHangarOverlaySoundFilter(on=True)
WWISE.WW_setState(SOUNDS.STATE_PLACE, SOUNDS.STATE_PLACE_DOG_TAGS)
self.viewModel.setIsTopView(makeTopView)
def setDefaultProgressSound(self):
WWISE.WW_setState(Sounds.PROGRESSION_STATE,
Sounds.PROGRESSION_STATE_DEFAULT)
def start(self):
WWISE.WW_setState(self._stateID, '%s_on' % self._stateID)
def __onWindowClose(self):
WWISE.WW_setState(ProgressiveRewardSoundEvents.PROGRESSIVE_REWARD_VIEW_GROUP, ProgressiveRewardSoundEvents.PROGRESSIVE_REWARD_VIEW_EXIT)
self.destroyWindow()
def _removeSoundEvent(cls):
if SoundViewMixin.__globSoundEntryCount > 0:
SoundViewMixin.__globSoundEntryCount -= 1
if SoundViewMixin.__globSoundEntryCount == 0:
WWISE.WW_setState(cls.PREM_VIEW_STATE_TEMPL,
cls.PREM_VIEW_STATE_EXIT)
def setState(stateName, stateValue):
WWISE.WW_setState(stateName, stateValue)
def setState(name, value):
WWISE.WW_setState(name, value)
def _populate(self):
super(ImageView, self)._populate()
self.setBgPath()
WWISE.WW_setState(STATE_HANGAR_FILTERED,
'{}_on'.format(STATE_HANGAR_FILTERED))
def stop(self):
WWISE.WW_setState(self._stateID, '%s_off' % self._stateID)
def setAmbient(self, ambientType=AmbientType.NATURE):
WWISE.WW_setState(Sounds.MAIN_PAGE_AMBIENT_STATE,
_TYPE_TO_AMBIENT.get(ambientType))
def tick(self):
if not SoundGroups.ENABLE_ENGINE_N_TRACKS:
return
else:
soundEngine = self.__engineSound
if soundEngine is None:
return
soundTrack = self.__movementSound
if soundTrack is None:
return
vehicleAttached = BigWorld.player().getVehicleAttached()
if vehicleAttached is None:
return
cameraUnit = vehicleAttached.id == self.__vehicleId
speedInfo = vehicleAttached.speedInfo.value
speed = speedInfo[0]
engineRPM = clamp(0.0, 100.0, self.detailedEngineState.rpm)
soundEngine.setRTPC('RTPC_ext_rpm', engineRPM)
soundTrack.setRTPC('RTPC_ext_rpm', engineRPM)
soundEngine.setRTPC('RTPC_ext_engine_load', self.detailedEngineState.engineLoad)
soundTrack.setRTPC('RTPC_ext_engine_load', self.detailedEngineState.engineLoad)
if cameraUnit:
WWISE.WW_setRTCPGlobal('RTPC_ext_engine_load_global', self.detailedEngineState.engineLoad)
soundEngine.setRTPC('RTPC_ext_submersion', 1 if self.isUnderwaterLink() else 0)
soundTrack.setRTPC('RTPC_ext_submersion', 1 if self.isUnderwaterLink() else 0)
if cameraUnit:
WWISE.WW_setState('STATE_underwater', 'STATE_underwater_on' if self.isUnderwaterLink() else 'STATE_underwater_off')
soundEngine.setRTPC('RTPC_ext_speed_abs', clamp(-10, 30, speed))
soundTrack.setRTPC('RTPC_ext_speed_abs', clamp(-10, 30, speed))
soundEngine.setRTPC('RTPC_ext_speed_rel', clamp(-1.0, 1.0, self.detailedEngineState.relativeSpeed))
soundTrack.setRTPC('RTPC_ext_speed_rel', clamp(-1.0, 1.0, self.detailedEngineState.relativeSpeed))
soundEngine.setRTPC('RTPC_ext_speed_rel2', self.detailedEngineState.relativeSpeed)
soundTrack.setRTPC('RTPC_ext_speed_rel2', self.detailedEngineState.relativeSpeed)
soundEngine.setRTPC('RTPC_ext_rot_speed_abs', clamp(-1.0, 1.0, self.detailedEngineState.rotationSpeed))
soundTrack.setRTPC('RTPC_ext_rot_speed_abs', clamp(-1.0, 1.0, self.detailedEngineState.rotationSpeed))
soundEngine.setRTPC('RTPC_ext_rot_speed_rel', clamp(-1.0, 1.0, self.detailedEngineState.roatationRelSpeed))
soundTrack.setRTPC('RTPC_ext_rot_speed_rel', clamp(-1.0, 1.0, self.detailedEngineState.roatationRelSpeed))
if not self.__isPlayerVehicle:
soundEngine.setRTPC('RTPC_ext_turbine_npc', engineRPM)
if cameraUnit:
if not self.__isPlayerVehicle:
soundTrack.setRTPC('RTPC_ext_gear_2', self.detailedEngineState.gear2)
soundTrack.setRTPC('RTPC_ext_gear_3', self.detailedEngineState.gear3)
soundEngine.setRTPC('RTPC_ext_gear_2', self.detailedEngineState.gear2)
soundEngine.setRTPC('RTPC_ext_gear_3', self.detailedEngineState.gear3)
soundEngine.setRTPC('RTPC_ext_gear_num', clamp(0.0, 4.0, self.detailedEngineState.gearNum))
soundTrack.setRTPC('RTPC_ext_gear_num', clamp(0.0, 4.0, self.detailedEngineState.gearNum))
else:
gear = self.detailedEngineState.gearNum
soundTrack.setRTPC('RTPC_ext_physic_rpm_rel', self.detailedEngineState.rpmPhysicRel)
soundEngine.setRTPC('RTPC_ext_physic_rpm_rel', self.detailedEngineState.rpmPhysicRel)
if self.detailedEngineState.engineState == EngineState._CRITICAL:
soundEngine.setRTPC('RTPC_ext_turbine', 0.0)
else:
soundEngine.setRTPC('RTPC_ext_turbine', self.detailedEngineState.rpmPhysicRel * 100.0)
soundTrack.setRTPC('RTPC_ext_physic_rpm_abs', self.detailedEngineState.rpmPhysicAbs)
soundEngine.setRTPC('RTPC_ext_physic_rpm_abs', self.detailedEngineState.rpmPhysicAbs)
soundTrack.setRTPC('RTPC_ext_physic_gear', gear)
soundEngine.setRTPC('RTPC_ext_physic_gear', gear)
soundTrack.setRTPC('RTPC_ext_engine_state', 1.0 if gear > 0 and gear < 127 else 0.0)
soundEngine.setRTPC('RTPC_ext_engine_state', 1.0 if gear > 0 and gear < 127 else 0.0)
for i in range(1, 8):
if i != gear:
soundTrack.setRTPC('RTPC_ext_physic_gear_' + str(i), 0)
soundEngine.setRTPC('RTPC_ext_physic_gear_' + str(i), 0)
if self.detailedEngineState.gearUp:
soundTrack.setRTPC('RTPC_ext_physic_gear_' + str(gear), 100)
soundEngine.setRTPC('RTPC_ext_physic_gear_' + str(gear), 100)
accelerationAbs = 0.0
if self.__prevVelocity is not None and self.__prevTime is not None:
deltaTime = BigWorld.time() - self.__prevTime
if deltaTime > 0.0:
accelerationAbs = (speed - self.__prevVelocity) / (BigWorld.time() - self.__prevTime)
accelerationAbs = clamp(-1.5, 1.5, accelerationAbs)
else:
accelerationAbs = 0.0
self.__prevVelocity = speed
self.__prevTime = BigWorld.time()
soundEngine.setRTPC('RTPC_ext_acc_abs', accelerationAbs)
soundTrack.setRTPC('RTPC_ext_acc_abs', accelerationAbs)
moveValue = 100 if math.fabs(speed) > 1.0 else 0
soundTrack.setRTPC('RTPC_ext_move', moveValue)
soundEngine.setRTPC('RTPC_ext_move', moveValue)
soundEngine.setRTPC('RTPC_ext_physic_load', self.detailedEngineState.physicLoad)
soundTrack.setRTPC('RTPC_ext_physic_load', self.detailedEngineState.physicLoad)
if cameraUnit:
WWISE.WW_setRTCPGlobal('RTPC_ext_physic_load_global', self.detailedEngineState.physicLoad)
WWISE.WW_setRTCPGlobal('RTPC_ext_speed_rel_global', clamp(-1.0, 1.0, self.detailedEngineState.relativeSpeed))
WWISE.WW_setRTCPGlobal('RTPC_ext_speed_abs_global', speed)
soundTrack.setRTPC('RTPC_ext_flying', self.isFlyingLink())
if not cameraUnit:
return
deltaR = self.rightTrackScrollRelativeLink()
deltaL = self.leftTrackScrollRelativeLink()
slideFriction = clamp(0.0, 1.0, max(deltaR, deltaL) / 5.0)
soundTrack.setRTPC('RTPC_ext_slide_friction', slideFriction)
soundEngine.setRTPC('RTPC_ext_slide_friction', slideFriction)
matEffectsUnderTracks = dict(((effectMaterial, 0.0) for effectMaterial in _EFFECT_MATERIALS_HARDNESS_RTPC))
currTerrainMatKind = self.curTerrainMatKindLink()
if self.isInWaterLink():
matEffectsUnderTracks['water'] = len(currTerrainMatKind)
else:
for matKind in currTerrainMatKind:
effectIndex = calcEffectMaterialIndex(matKind)
if effectIndex is not None:
effectMaterial = material_kinds.EFFECT_MATERIALS[effectIndex]
if effectMaterial in matEffectsUnderTracks:
matEffectsUnderTracks[effectMaterial] = matEffectsUnderTracks.get(effectMaterial, 0) + 1.0
hardness = 0.0
for effectMaterial, amount in matEffectsUnderTracks.iteritems():
hardness += _EFFECT_MATERIALS_HARDNESS_RTPC.get(effectMaterial, 0) * amount
for effectMaterial, amount in matEffectsUnderTracks.iteritems():
if amount >= 2 and self.__prevTerrSwitch != effectMaterial:
soundTrack.setSwitch('SWITCH_ext_surfaceType', 'SWITCH_ext_surfaceType_' + effectMaterial)
self.__prevTerrSwitch = effectMaterial
break
hardnessValue = hardness / len(currTerrainMatKind)
soundTrack.setRTPC('RTPC_ext_hardness', hardnessValue)
angPart = min(abs(self.vehicleFilter.angularSpeed) * _FRICTION_ANG_FACTOR, _FRICTION_ANG_BOUND)
strafePart = min(abs(self.vehicleFilter.strafeSpeed) * _FRICTION_STRAFE_FACTOR, _FRICTION_STRAFE_BOUND)
frictionValue = max(angPart, strafePart)
soundTrack.setRTPC('RTPC_ext_friction', frictionValue)
roughnessValue = self.detailedEngineState.roughnessValue
if cameraUnit:
WWISE.WW_setRTCPGlobal('RTPC_ext_roughness_global', math.fabs(roughnessValue))
soundTrack.setRTPC('RTPC_ext_roughness_abs', math.fabs(roughnessValue))
soundEngine.setRTPC('RTPC_ext_roughness_abs', math.fabs(roughnessValue))
soundTrack.setRTPC('RTPC_ext_roughness2', roughnessValue)
soundEngine.setRTPC('RTPC_ext_roughness2', roughnessValue)
soundTrack.setRTPC('RTPC_ext_roughness_eng', roughnessValue)
soundEngine.setRTPC('RTPC_ext_roughness_eng', roughnessValue)
rotationSpeed = speedInfo[1]
roatationRelSpeed = rotationSpeed / self.__typeDesc.physics['rotationSpeedLimit']
RTPC_ext_treads_sum_affect = math.fabs(roatationRelSpeed * 0.33) + math.fabs(roughnessValue * 0.33) + (clamp(0.5, 1.0, self.detailedEngineState.physicLoad) - 0.5) * 0.66
soundTrack.setRTPC('RTPC_ext_treads_sum_affect', RTPC_ext_treads_sum_affect)
rightTrackScroll = math.fabs(self.rightTrackScrollLink())
leftTrackScroll = math.fabs(self.leftTrackScrollLink())
if rightTrackScroll > leftTrackScroll:
trackScroll = rightTrackScroll
else:
trackScroll = leftTrackScroll
if self.__isPlayerVehicle:
self.__commonTrackScroll += (trackScroll - self.__commonTrackScroll) * _PERIODIC_TIME / 0.2
self.__commonTrackScroll = self.__commonTrackScroll if self.__commonTrackScroll > 0.0 else 0.0
soundTrack.setRTPC('RTPC_ext_speed_scroll', self.__commonTrackScroll)
soundEngine.setRTPC('RTPC_ext_speed_scroll', self.__commonTrackScroll)
if self.__vt is not None:
self.__vt.addValue2('RTPC_ext_flying', self.isFlyingLink())
self.__vt.addValue2('RTPC_ext_hardness', hardnessValue)
self.__vt.addValue2('RTPC_ext_friction', frictionValue)
self.__vt.addValue2('RTPC_ext_roughness_abs', roughnessValue)
self.__vt.addValue2('RTPC_ext_treads_sum_affect', RTPC_ext_treads_sum_affect)
self.__vt.addValue2('speed_abs', speed)
self.__vt.addValue2('speed_rel', self.detailedEngineState.relativeSpeed)
self.__vt.addValue2('rot_speed_abs', rotationSpeed)
self.__vt.addValue2('rot_speed_rel', roatationRelSpeed)
self.__vt.addValue2('gear', self.detailedEngineState.gearNum)
self.__vt.addValue2('acc_abs', accelerationAbs)
self.__vt.addValue2('physic_load', self.detailedEngineState.physicLoad)
self.__vt.addValue2('RTPC_ext_move', moveValue)
self.__vt.addValue2('RTPC_ext_speed_scroll', self.__commonTrackScroll)
self.__vt.addValue2('engine_load', self.detailedEngineState.engineLoad)
self.__vt.addValue2('submersion', self.isUnderwaterLink())
if self.__isPlayerVehicle:
self.__vt.addValue2('RPM', self.detailedEngineState.rpmPhysicAbs)
self.__vt.addValue2('RPM_REL', self.detailedEngineState.rpmPhysicRel)
return
def setOverlayStateOff(self):
WWISE.WW_setState(Sounds.OVERLAY_HANGAR_FILTERED,
Sounds.OVERLAY_HANGAR_FILTERED_OFF)
WWISE.WW_setState(Sounds.OVERLAY_HANGAR_GENERAL,
Sounds.OVERLAY_HANGAR_GENERAL_OFF)
def onClose(self):
self.destroy()
WWISE.WW_setState(STATE_HANGAR_FILTERED,
'{}_off'.format(STATE_HANGAR_FILTERED))
def _addSoundEvent(cls):
WWISE.WW_setState(cls.PREM_VIEW_STATE_TEMPL, cls.PREM_VIEW_STATE_ENTER)
SoundViewMixin.__globSoundEntryCount += 1
