public void InitSoundSettings(NodeAddedEvent e, SoundListenerNode listener)
{
listener.soundListenerResources.Resources.SfxMixer.SetFloat(SoundSettingsUtils.VOLUME_PARAM_KEY, !SoundSettingsUtils.GetSavedMuteFlag(SoundType.SFX) ? SoundSettingsUtils.GetSavedVolume(SoundType.SFX) : SoundSettingsUtils.MUTED_VOLUME_VALUE);
listener.soundListenerResources.Resources.UIMixer.SetFloat(SoundSettingsUtils.VOLUME_PARAM_KEY, !SoundSettingsUtils.GetSavedMuteFlag(SoundType.UI) ? SoundSettingsUtils.GetSavedVolume(SoundType.UI) : SoundSettingsUtils.MUTED_VOLUME_VALUE);
listener.soundListenerResources.Resources.MusicMixer.SetFloat(SoundSettingsUtils.MUSIC_VOLUME_PARAM_KEY, !SoundSettingsUtils.GetSavedMuteFlag(SoundType.Music) ? SoundSettingsUtils.GetSavedVolume(SoundType.Music) : SoundSettingsUtils.MUTED_VOLUME_VALUE);
listener.soundListenerResources.Resources.MusicMixer.SetFloat(SoundSettingsUtils.LAZY_UI_VOLUME_PARAM_KEY, !SoundSettingsUtils.GetSavedMuteFlag(SoundType.UI) ? SoundSettingsUtils.GetSavedVolume(SoundType.UI) : SoundSettingsUtils.MUTED_VOLUME_VALUE);
}
public void InitSounds(NodeAddedEvent e, SoundListenerNode listener, UserReadyForLobbyNode user)
{
if (UISoundEffectController.UITransformRoot.gameObject.GetComponent <DailyBonusScreenSoundsRoot>() == null)
{
UISoundEffectController.UITransformRoot.gameObject.AddComponent <DailyBonusScreenSoundsRoot>().dailyBonusSoundsBehaviour = Object.Instantiate <DailyBonusSoundsBehaviour>(listener.soundListenerResources.Resources.DailyBonusSounds, UISoundEffectController.UITransformRoot.position, UISoundEffectController.UITransformRoot.rotation, UISoundEffectController.UITransformRoot);
}
}
public void InitSoundListenerESM(NodeAddedEvent evt, SoundListenerNode listener)
{
SoundListenerESMComponent component = new SoundListenerESMComponent();
EntityStateMachine esm = component.Esm;
esm.AddState <SoundListenerStates.SoundListenerSpawnState>();
esm.AddState <SoundListenerStates.SoundListenerBattleState>();
esm.AddState <SoundListenerStates.SoundListenerLobbyState>();
esm.AddState <SoundListenerStates.SoundListenerBattleFinishState>();
esm.AddState <SoundListenerStates.SoundListenerSelfRankRewardState>();
listener.Entity.AddComponent(component);
}
public void SwitchToLowHealthMode(HealthChangedEvent evt, SelfActiveTankNode tank, [JoinAll] SoundListenerNode listener)
{
if ((tank.health.CurrentHealth / tank.health.MaxHealth) > listener.healthFeedbackSoundListener.MaxHealthPercentForSound)
{
listener.healthFeedbackSoundListener.SwitchToNormalHealthMode();
}
else
{
listener.healthFeedbackSoundListener.SwitchToLowHealthMode();
}
}
public void DisableHealthFilter(NodeRemoveEvent evt, SelfTankNode tank, [JoinAll] SoundListenerNode listener)
{
listener.healthFeedbackSoundListener.SwitchToNormalHealthMode();
}
public void StartIsisHealingFeedbackSound(NodeAddedEvent e, SingleNode <StreamHitTeammateFeedbackComponent> weapon, [JoinSelf, Context] IsisReadyWeaponNode isis, SoundListenerNode listener)
{
isis.isisHitFeedbackReady.HealingSoundController.FadeIn();
}
public void PrepareCleaningForModuleEffectsParts(RemoveEffectEvent evt, SingleNode <EffectComponent> effect, [JoinByUnit] SingleNode <WeaponSoundRootComponent> weapon, [JoinAll] SoundListenerNode listener)
{
Transform tankPartTransform = weapon.component.transform;
this.PrepareCleaningForTankPart(tankPartTransform, listener.soundListenerCleaner.TankPartCleanTimeSec);
}
public void PrepareCleaningForMines(PrepareDestroyModuleEffectEvent evt, SingleNode <SpiderMineSoundsComponent> mine, [JoinAll] SoundListenerNode listener)
{
float mineCleanTimeSec = listener.soundListenerCleaner.MineCleanTimeSec;
this.PrepareCleaningForTankPart(mine.component.RunSoundController.transform, mineCleanTimeSec);
}
public void PrepareCleaningForEffects(PrepareDestroyModuleEffectEvent evt, SingleNode <EffectRemovingSoundComponent> effect, [JoinAll] SoundListenerNode listener)
{
float mineCleanTimeSec = listener.soundListenerCleaner.MineCleanTimeSec;
this.PrepareCleaningForTankPart(effect.component.Sound, mineCleanTimeSec);
}
public void FilterLobbyAmbientSoundPlayEvent(BeforeLobbyAmbientSoundPlayEvent evt, SoundListenerNode listener, [JoinAll] SingleNode <HangarInstanceComponent> hangar, [JoinAll] PlayLobbySoundScreenNode screen, [JoinAll] Optional <SingleNode <MapInstanceComponent> > map)
{
if (!map.IsPresent())
{
base.ScheduleEvent(new LobbyAmbientSoundPlayEvent(evt.HymnMode), listener);
}
}
private HangarAmbientSoundController PrepareNewEffect(InitialHangarAmbientSoundNode hangar, SoundListenerNode soundListener)
{
HangarAmbientSoundController controller2 = Object.Instantiate <HangarAmbientSoundController>(hangar.hangarAmbientSoundPrefab.HangarAmbientSoundController);
Transform transform = controller2.transform;
transform.parent = soundListener.soundListener.transform;
transform.localRotation = Quaternion.identity;
transform.localPosition = Vector3.zero;
return(controller2);
}
public void StopLowEnergyOnHitFeedback(HitFeedbackEvent e, TankNode tank, [JoinAll] SoundListenerNode listener)
{
this.StopSound(tank);
}
public void PlayLowEnergyForVulcanSlowDownWeapon(TimeUpdateEvent e, VulcanWeaponSlowDownNode weapon, [JoinByTank] TankNode tank, [JoinAll] SoundListenerNode listener)
{
if (InputManager.GetActionKeyDown(ShotActions.SHOT))
{
this.PlayLowEnergyFeedback(tank);
}
}
public void PlayLowEnergyForVulcanIdleWeapon(TimeUpdateEvent e, VulcanWeaponIdleNode weapon, [JoinByTank] TankNode tank, [JoinAll] SoundListenerNode listener)
{
if (InputManager.GetActionKeyDown(ShotActions.SHOT) && !weapon.Entity.HasComponent <ShootableComponent>())
{
this.PlayLowEnergyFeedback(tank);
}
}
public void PlayLowEnergyForSimpleDiscreteEnergyWeapon(TimeUpdateEvent e, SimpleDiscreteWeaponEnergyNode weapon, [JoinByTank] TankNode tank, [JoinAll] SoundListenerNode listener)
{
if (InputManager.GetActionKeyDown(ShotActions.SHOT))
{
if (!weapon.Entity.HasComponent <ShootableComponent>())
{
this.PlayLowEnergyFeedback(tank);
}
else if (weapon.weaponEnergy.Energy < weapon.discreteWeaponEnergy.UnloadEnergyPerShot)
{
this.PlayLowEnergyFeedback(tank);
}
}
}
public void PrepareCleaningForTankParts(NodeRemoveEvent evt, WeaponNode weapon, [JoinByTank] TankNode tank, [JoinAll] SoundListenerNode listener)
{
Transform tankPartTransform = weapon.weaponSoundRoot.transform;
Transform soundRootTransform = tank.tankSoundRoot.SoundRootTransform;
float tankPartCleanTimeSec = listener.soundListenerCleaner.TankPartCleanTimeSec;
this.PrepareCleaningForTankPart(soundRootTransform, tankPartCleanTimeSec);
this.PrepareCleaningForTankPart(tankPartTransform, tankPartCleanTimeSec);
}
public void PrepareCleaningForCTF(PrepareDestroyCTFSoundsEvent evt, SingleNode <CTFSoundsComponent> battle, [JoinAll] SoundListenerNode listener)
{
Object.DestroyObject(battle.component.EffectRoot, listener.soundListenerCleaner.CTFCleanTimeSec);
}
public void FilterMapAmbientSoundPlayEvent(BeforeMapAmbientSoundPlayEvent evt, SoundListenerNode soundListener, [JoinAll] SingleNode <MapInstanceComponent> map, [JoinAll] BattleScreenNode battleScreen)
{
base.ScheduleEvent <MapAmbientSoundPlayEvent>(soundListener);
}
public void PrepareCleaningForEffects(PrepareDestroyModuleEffectEvent evt, SingleNode <WeaponStreamHitSoundsEffectComponent> effect, [JoinAll] SoundListenerNode listener)
{
float mineCleanTimeSec = listener.soundListenerCleaner.MineCleanTimeSec;
this.PrepareCleaningForTankPart(effect.component.SoundController.transform, mineCleanTimeSec);
}
public void FinalizeAmbientSoundEffect(NodeAddedEvent evt, BattleScreenNode battleScreen, [JoinAll] SoundListenerNode soundListener)
{
base.NewEvent <BeforeMapAmbientSoundPlayEvent>().Attach(soundListener).ScheduleDelayed(soundListener.soundListener.DelayForBattleEnterState);
}
public void PrepareCleaningForMines(PrepareDestroyModuleEffectEvent evt, SingleNode <MineSoundsComponent> mine, [JoinAll] SoundListenerNode listener)
{
float mineCleanTimeSec = listener.soundListenerCleaner.MineCleanTimeSec;
this.PrepareCleaningForTankPart(mine.component.DeactivationSound, mineCleanTimeSec);
this.PrepareCleaningForTankPart(mine.component.ExplosionSound, mineCleanTimeSec);
this.PrepareCleaningForTankPart(mine.component.DropGroundSound, mineCleanTimeSec);
this.PrepareCleaningForTankPart(mine.component.DropNonGroundSound, mineCleanTimeSec);
}
private void Switch(SoundListenerNode listener, AudioMixerSnapshot snapshot, float transition)
{
AudioMixerSnapshot[] snapshots = new AudioMixerSnapshot[] { snapshot };
float[] weights = new float[] { 1f };
listener.soundListenerResources.Resources.SfxMixer.TransitionToSnapshots(snapshots, weights, transition);
}
public void PlayHitFeedbackSound(HitFeedbackEvent e, SingleNode <HitFeedbackSoundsComponent> tank, [JoinByTank] ThunderHitFeedbackSoundNode weapon, [JoinAll] SoundListenerNode listener)
{
this.PlayHitFeedbackSound(tank.component.ThunderHitFeedbackSoundAsset, weapon.hitFeedbackSoundsPlayingSettings);
}
public void SwitchToLoudFromUser(NodeRemoveEvent e, SingleNode <SoundListenerSelfRankRewardStateComponent> selfRankReward, [JoinSelf] SingleNode <SoundListenerBattleStateComponent> battleState, [JoinSelf] SoundListenerNode listener, [JoinAll] SingleNode <MapInstanceComponent> map, [JoinAll] SingleNode <RoundActiveStateComponent> round)
{
this.Switch(listener, listener.soundListenerResources.Resources.SfxMixerSnapshots[listener.soundListenerBattleMixerSnapshots.LoudSnapshotIndex], listener.soundListenerBattleMixerSnapshotTransition.TransitionToLoudTimeInSelfUserMode);
}
public void DisableHealthFilter(NodeAddedEvent evt, SelfTankNode tank, SoundListenerNode listener)
{
listener.healthFeedbackSoundListener.ResetHealthFeedbackData();
}
private void SwitchToSilent(SoundListenerNode listener, float transitionTime)
{
this.Switch(listener, listener.soundListenerResources.Resources.SfxMixerSnapshots[listener.soundListenerBattleMixerSnapshots.SilentSnapshotIndex], transitionTime);
}
public void DisableHealthFilterOnEnterLobby(LobbyAmbientSoundPlayEvent evt, SoundListenerNode listener)
{
listener.healthFeedbackSoundListener.SwitchToNormalHealthMode();
}
public void SwitchToSilentWhenExitBattle(ExitBattleEvent e, Node node, [JoinAll] SoundListenerNode listener)
{
this.SwitchToSilent(listener, listener.soundListenerBattleMixerSnapshotTransition.TransitionTimeToSilentAfterExitBattle);
}
public void SwitchToNormalMode(NodeAddedEvent evt, SelfDeadTankNode tank, SoundListenerNode listener)
{
listener.healthFeedbackSoundListener.SwitchToNormalHealthMode();
}
public void SwitchToSilentWhenRoundFinish(NodeRemoveEvent e, SingleNode <RoundActiveStateComponent> roundActive, [JoinSelf] RoundNode round, [JoinByBattle] SelfBattleUserNode battleUser, [JoinAll] SoundListenerNode listener)
{
this.SwitchToSilent(listener, listener.soundListenerBattleMixerSnapshotTransition.TransitionTimeToSilentAfterRoundFinish);
}
