-using System.Linq;
-using System.Numerics;
using Content.Shared.Audio;
using Content.Shared.CCVar;
-using Robust.Client.GameObjects;
using Robust.Client.Graphics;
using Robust.Client.Player;
using Robust.Shared.Audio;
+using Robust.Shared.Log;
using Robust.Shared.Configuration;
+using Robust.Shared.Map;
using Robust.Shared.Physics;
using Robust.Shared.Random;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
+using System.Linq;
+using System.Numerics;
+using Robust.Client.GameObjects;
+using Robust.Shared.Audio.Effects;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Player;
namespace Content.Client.Audio;
//TODO: This is using a incomplete version of the whole "only play nearest sounds" algo, that breaks down a bit should the ambient sound cap get hit.
private TimeSpan _targetTime = TimeSpan.Zero;
private float _ambienceVolume = 0.0f;
- private static AudioParams _params = AudioParams.Default.WithVariation(0.01f).WithLoop(true).WithAttenuation(Attenuation.LinearDistance);
+ private static AudioParams _params = AudioParams.Default
+ .WithVariation(0.01f)
+ .WithLoop(true)
+ .WithAttenuation(Attenuation.LinearDistance)
+ .WithMaxDistance(7f);
/// <summary>
/// How many times we can be playing 1 particular sound at once.
/// </summary>
private int MaxSingleSound => (int) (_maxAmbientCount / (16.0f / 6.0f));
- private readonly Dictionary<Entity<AmbientSoundComponent>, (IPlayingAudioStream? Stream, SoundSpecifier Sound, string Path)> _playingSounds = new();
+ private readonly Dictionary<AmbientSoundComponent, (EntityUid? Stream, SoundSpecifier Sound, string Path)> _playingSounds = new();
private readonly Dictionary<string, int> _playingCount = new();
public bool OverlayEnabled
private void OnShutdown(EntityUid uid, AmbientSoundComponent component, ComponentShutdown args)
{
- if (!_playingSounds.Remove((uid, component), out var sound))
+ if (!_playingSounds.Remove(component, out var sound))
return;
- sound.Stream?.Stop();
+ _audio.Stop(sound.Stream);
_playingCount[sound.Path] -= 1;
if (_playingCount[sound.Path] == 0)
_playingCount.Remove(sound.Path);
{
_ambienceVolume = value;
- foreach (var ((_, comp), values) in _playingSounds)
+ foreach (var (comp, values) in _playingSounds)
{
if (values.Stream == null)
continue;
- var stream = (AudioSystem.PlayingStream) values.Stream;
- stream.Volume = _params.Volume + comp.Volume + _ambienceVolume;
+ var stream = values.Stream;
+ _audio.SetVolume(stream, _params.Volume + comp.Volume + _ambienceVolume);
}
}
private void SetCooldown(float value) => _cooldown = value;
{
foreach (var (stream, _, _) in _playingSounds.Values)
{
- stream?.Stop();
+ _audio.Stop(stream);
}
_playingSounds.Clear();
private readonly struct QueryState
{
- public readonly Dictionary<string, List<(float Importance, Entity<AmbientSoundComponent>)>> SourceDict = new();
+ public readonly Dictionary<string, List<(float Importance, AmbientSoundComponent)>> SourceDict = new();
public readonly Vector2 MapPos;
public readonly TransformComponent Player;
public readonly EntityQuery<TransformComponent> Query;
// Prioritize far away & loud sounds.
var importance = range * (ambientComp.Volume + 32);
- state.SourceDict.GetOrNew(key).Add((importance, (ambientComp.Owner, ambientComp)));
+ state.SourceDict.GetOrNew(key).Add((importance, ambientComp));
return true;
}
var mapPos = playerXform.MapPosition;
// Remove out-of-range ambiences
- foreach (var (ent, sound) in _playingSounds)
+ foreach (var (comp, sound) in _playingSounds)
{
- var entity = ent.Owner;
- var comp = ent.Comp;
+ var entity = comp.Owner;
if (comp.Enabled &&
// Don't keep playing sounds that have changed since.
continue;
}
- sound.Stream?.Stop();
- _playingSounds.Remove((entity, comp));
+ _audio.Stop(sound.Stream);
+ _playingSounds.Remove(comp);
_playingCount[sound.Path] -= 1;
if (_playingCount[sound.Path] == 0)
_playingCount.Remove(sound.Path);
sources.Sort(static (a, b) => b.Importance.CompareTo(a.Importance));
- foreach (var (_, ent) in sources)
+ foreach (var (_, comp) in sources)
{
- var uid = ent.Owner;
- var comp = ent.Comp;
+ var uid = comp.Owner;
- if (_playingSounds.ContainsKey(ent) ||
+ if (_playingSounds.ContainsKey(comp) ||
metaQuery.GetComponent(uid).EntityPaused)
continue;
.WithPlayOffset(_random.NextFloat(0.0f, 100.0f))
.WithMaxDistance(comp.Range);
- var stream = _audio.PlayPvs(comp.Sound, uid, audioParams);
- if (stream == null)
- continue;
-
- _playingSounds[ent] = (stream, comp.Sound, key);
+ var stream = _audio.PlayEntity(comp.Sound, Filter.Local(), uid, false, audioParams);
+ _playingSounds[comp] = (stream.Value.Entity, comp.Sound, key);
playingCount++;
if (_playingSounds.Count >= _maxAmbientCount)
using Robust.Client;
using Robust.Client.State;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Player;
private readonly AudioParams _lobbyParams = new(-5f, 1, "Master", 0, 0, 0, true, 0f);
- private IPlayingAudioStream? _lobbyStream;
+ private EntityUid? _lobbyStream;
public override void Initialize()
{
}
_lobbyStream = _audio.PlayGlobal(file, Filter.Local(), false,
- _lobbyParams.WithVolume(_lobbyParams.Volume + _configManager.GetCVar(CCVars.LobbyMusicVolume)));
+ _lobbyParams.WithVolume(_lobbyParams.Volume + _configManager.GetCVar(CCVars.LobbyMusicVolume)))?.Entity;
}
private void EndLobbyMusic()
{
- _lobbyStream?.Stop();
- _lobbyStream = null;
+ _lobbyStream = _audio.Stop(_lobbyStream);
}
}
using Content.Shared.CCVar;
using Content.Shared.GameTicking;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Player;
// Admin music
private bool _adminAudioEnabled = true;
- private List<IPlayingAudioStream?> _adminAudio = new(1);
+ private List<EntityUid?> _adminAudio = new(1);
// Event sounds (e.g. nuke timer)
private bool _eventAudioEnabled = true;
- private Dictionary<StationEventMusicType, IPlayingAudioStream?> _eventAudio = new(1);
+ private Dictionary<StationEventMusicType, EntityUid?> _eventAudio = new(1);
public override void Initialize()
{
{
foreach (var stream in _adminAudio)
{
- stream?.Stop();
+ _audio.Stop(stream);
}
_adminAudio.Clear();
- foreach (var (_, stream) in _eventAudio)
+ foreach (var stream in _eventAudio.Values)
{
- stream?.Stop();
+ _audio.Stop(stream);
}
_eventAudio.Clear();
if(!_adminAudioEnabled) return;
var stream = _audio.PlayGlobal(soundEvent.Filename, Filter.Local(), false, soundEvent.AudioParams);
- _adminAudio.Add(stream);
+ _adminAudio.Add(stream.Value.Entity);
}
private void PlayStationEventMusic(StationEventMusicEvent soundEvent)
if(!_eventAudioEnabled || _eventAudio.ContainsKey(soundEvent.Type)) return;
var stream = _audio.PlayGlobal(soundEvent.Filename, Filter.Local(), false, soundEvent.AudioParams);
- _eventAudio.Add(soundEvent.Type, stream);
+ _eventAudio.Add(soundEvent.Type, stream.Value.Entity);
}
private void PlayGameSound(GameGlobalSoundEvent soundEvent)
private void StopStationEventMusic(StopStationEventMusic soundEvent)
{
- if (!_eventAudio.TryGetValue(soundEvent.Type, out var stream)) return;
- stream?.Stop();
+ if (!_eventAudio.TryGetValue(soundEvent.Type, out var stream))
+ return;
+
+ _audio.Stop(stream);
_eventAudio.Remove(soundEvent.Type);
}
if (_adminAudioEnabled) return;
foreach (var stream in _adminAudio)
{
- stream?.Stop();
+ _audio.Stop(stream);
}
_adminAudio.Clear();
}
if (_eventAudioEnabled) return;
foreach (var stream in _eventAudio)
{
- stream.Value?.Stop();
+ _audio.Stop(stream.Value);
}
_eventAudio.Clear();
}
using Robust.Client.ResourceManagement;
using Robust.Client.State;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
// Don't need to worry about this being serializable or pauseable as it doesn't affect the sim.
private TimeSpan _nextAudio;
- private AudioSystem.PlayingStream? _ambientMusicStream;
+ private EntityUid? _ambientMusicStream;
private AmbientMusicPrototype? _musicProto;
/// <summary>
if (_ambientMusicStream != null && _musicProto != null)
{
- _ambientMusicStream.Volume = _musicProto.Sound.Params.Volume + _volumeSlider;
+ _audio.SetVolume(_ambientMusicStream, _musicProto.Sound.Params.Volume + _volumeSlider);
}
}
_configManager.UnsubValueChanged(CCVars.AmbientMusicVolume, AmbienceCVarChanged);
_proto.PrototypesReloaded -= OnProtoReload;
_state.OnStateChanged -= OnStateChange;
- _ambientMusicStream?.Stop();
+ _ambientMusicStream = _audio.Stop(_ambientMusicStream);
}
private void OnProtoReload(PrototypesReloadedEventArgs obj)
private void OnRoundEndMessage(RoundEndMessageEvent ev)
{
// If scoreboard shows then just stop the music
- _ambientMusicStream?.Stop();
- _ambientMusicStream = null;
+ _ambientMusicStream = _audio.Stop(_ambientMusicStream);
_nextAudio = TimeSpan.FromMinutes(3);
}
return;
}
- var isDone = _ambientMusicStream?.Done;
+ var isDone = !Exists(_ambientMusicStream);
if (_interruptable)
{
if (player == null || _musicProto == null || !_rules.IsTrue(player.Value, _proto.Index<RulesPrototype>(_musicProto.Rules)))
{
- FadeOut(_ambientMusicStream, AmbientMusicFadeTime);
+ FadeOut(_ambientMusicStream, duration: AmbientMusicFadeTime);
_musicProto = null;
_interruptable = false;
isDone = true;
false,
AudioParams.Default.WithVolume(_musicProto.Sound.Params.Volume + _volumeSlider));
- if (strim != null)
- {
- _ambientMusicStream = (AudioSystem.PlayingStream) strim;
+ _ambientMusicStream = strim.Value.Entity;
- if (_musicProto.FadeIn)
- {
- FadeIn(_ambientMusicStream, AmbientMusicFadeTime);
- }
+ if (_musicProto.FadeIn)
+ {
+ FadeIn(_ambientMusicStream, strim.Value.Component, AmbientMusicFadeTime);
}
// Refresh the list
using Content.Shared.Audio;
using Robust.Client.GameObjects;
+using Robust.Shared.Audio;
+using AudioComponent = Robust.Shared.Audio.Components.AudioComponent;
namespace Content.Client.Audio;
public sealed partial class ContentAudioSystem : SharedContentAudioSystem
{
// Need how much volume to change per tick and just remove it when it drops below "0"
- private readonly Dictionary<AudioSystem.PlayingStream, float> _fadingOut = new();
+ private readonly Dictionary<EntityUid, float> _fadingOut = new();
// Need volume change per tick + target volume.
- private readonly Dictionary<AudioSystem.PlayingStream, (float VolumeChange, float TargetVolume)> _fadingIn = new();
+ private readonly Dictionary<EntityUid, (float VolumeChange, float TargetVolume)> _fadingIn = new();
- private readonly List<AudioSystem.PlayingStream> _fadeToRemove = new();
+ private readonly List<EntityUid> _fadeToRemove = new();
private const float MinVolume = -32f;
private const float DefaultDuration = 2f;
#region Fades
- public void FadeOut(AudioSystem.PlayingStream? stream, float duration = DefaultDuration)
+ public void FadeOut(EntityUid? stream, AudioComponent? component = null, float duration = DefaultDuration)
{
- if (stream == null || duration <= 0f)
+ if (stream == null || duration <= 0f || !Resolve(stream.Value, ref component))
return;
// Just in case
// TODO: Maybe handle the removals by making it seamless?
- _fadingIn.Remove(stream);
- var diff = stream.Volume - MinVolume;
- _fadingOut.Add(stream, diff / duration);
+ _fadingIn.Remove(stream.Value);
+ var diff = component.Volume - MinVolume;
+ _fadingOut.Add(stream.Value, diff / duration);
}
- public void FadeIn(AudioSystem.PlayingStream? stream, float duration = DefaultDuration)
+ public void FadeIn(EntityUid? stream, AudioComponent? component = null, float duration = DefaultDuration)
{
- if (stream == null || duration <= 0f || stream.Volume < MinVolume)
+ if (stream == null || duration <= 0f || !Resolve(stream.Value, ref component) || component.Volume < MinVolume)
return;
- _fadingOut.Remove(stream);
- var curVolume = stream.Volume;
+ _fadingOut.Remove(stream.Value);
+ var curVolume = component.Volume;
var change = (curVolume - MinVolume) / duration;
- _fadingIn.Add(stream, (change, stream.Volume));
- stream.Volume = MinVolume;
+ _fadingIn.Add(stream.Value, (change, component.Volume));
+ component.Volume = MinVolume;
}
private void UpdateFades(float frameTime)
foreach (var (stream, change) in _fadingOut)
{
- // Cancelled elsewhere
- if (stream.Done)
+ if (!TryComp(stream, out AudioComponent? component))
{
_fadeToRemove.Add(stream);
continue;
}
- var volume = stream.Volume - change * frameTime;
- stream.Volume = MathF.Max(MinVolume, volume);
+ var volume = component.Volume - change * frameTime;
+ component.Volume = MathF.Max(MinVolume, volume);
- if (stream.Volume.Equals(MinVolume))
+ if (component.Volume.Equals(MinVolume))
{
- stream.Stop();
+ _audio.Stop(stream);
_fadeToRemove.Add(stream);
}
}
foreach (var (stream, (change, target)) in _fadingIn)
{
// Cancelled elsewhere
- if (stream.Done)
+ if (!TryComp(stream, out AudioComponent? component))
{
_fadeToRemove.Add(stream);
continue;
}
- var volume = stream.Volume + change * frameTime;
- stream.Volume = MathF.Min(target, volume);
+ var volume = component.Volume + change * frameTime;
+ component.Volume = MathF.Min(target, volume);
- if (stream.Volume.Equals(target))
+ if (component.Volume.Equals(target))
{
_fadeToRemove.Add(stream);
}
using Robust.Client.UserInterface;
using Robust.Client.UserInterface.Controls;
using Robust.Client.UserInterface.XAML;
+using Robust.Shared.ContentPack;
using Robust.Shared.Utility;
using static Content.Client.Changelog.ChangelogManager;
using static Robust.Client.UserInterface.Controls.BoxContainer;
using Robust.Client.UserInterface.CustomControls;
using Robust.Client.UserInterface.XAML;
using Robust.Shared.Configuration;
+using Robust.Shared.ContentPack;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Maths;
[GenerateTypedNameReferences]
public sealed partial class CreditsWindow : DefaultWindow
{
- [Dependency] private readonly IResourceCache _resourceManager = default!;
+ [Dependency] private readonly IResourceManager _resourceManager = default!;
[Dependency] private readonly IConfigurationManager _cfg = default!;
private static readonly Dictionary<string, int> PatronTierPriority = new()
private void PopulateLicenses(BoxContainer licensesContainer)
{
- foreach (var entry in CreditsManager.GetLicenses().OrderBy(p => p.Name))
+ foreach (var entry in CreditsManager.GetLicenses(_resourceManager).OrderBy(p => p.Name))
{
licensesContainer.AddChild(new Label {StyleClasses = {StyleBase.StyleClassLabelHeading}, Text = entry.Name});
using Robust.Client.GameObjects;
using Robust.Client.Animations;
using Robust.Client.Graphics;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.GameStates;
using Robust.Shared.Physics.Events;
using static Content.Shared.Disposal.Components.SharedDisposalUnitComponent;
protected override void PlaySound(EntityUid uid, SoundSpecifier soundSpecifier, AudioParams audioParams, EntityUid? predictingPlayer, bool predicted)
{
if (GameTiming.InPrediction && GameTiming.IsFirstTimePredicted)
- Audio.Play(soundSpecifier, Filter.Local(), uid, false, audioParams);
+ Audio.PlayEntity(soundSpecifier, Filter.Local(), uid, false, audioParams);
}
}
using JetBrains.Annotations;
using Robust.Client.Graphics;
using Robust.Client.State;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Player;
using Robust.Shared.Utility;
using Content.Shared.Gravity;
using Robust.Client.Player;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Random;
using Content.Shared.Verbs;
using Robust.Client.GameObjects;
using Robust.Client.Player;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Player;
using Robust.Shared.Timing;
{
public sealed class RulesAndInfoWindow : DefaultWindow
{
- [Dependency] private readonly IResourceCache _resourceManager = default!;
+ [Dependency] private readonly IResourceManager _resourceManager = default!;
[Dependency] private readonly RulesManager _rules = default!;
public RulesAndInfoWindow()
using Robust.Client.ResourceManagement;
+using Robust.Shared.ContentPack;
using Robust.Shared.IoC;
namespace Content.Client.IoC
/// The sound that plays when the expendable light is lit.
/// </summary>
[Access(typeof(ExpendableLightSystem))]
- public IPlayingAudioStream? PlayingStream;
+ public EntityUid? PlayingStream;
}
public enum ExpendableLightVisualLayers : byte
using Content.Shared.Light.Components;
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Client.Light.EntitySystems;
private void OnLightShutdown(EntityUid uid, ExpendableLightComponent component, ComponentShutdown args)
{
- component.PlayingStream?.Stop();
+ component.PlayingStream = _audioSystem.Stop(component.PlayingStream);
}
protected override void OnAppearanceChange(EntityUid uid, ExpendableLightComponent comp, ref AppearanceChangeEvent args)
switch (state)
{
case ExpendableLightState.Lit:
- comp.PlayingStream?.Stop();
+ _audioSystem.Stop(comp.PlayingStream);
comp.PlayingStream = _audioSystem.PlayPvs(
- comp.LoopedSound,
- uid,
- SharedExpendableLightComponent.LoopedSoundParams
- );
+ comp.LoopedSound, uid, SharedExpendableLightComponent.LoopedSoundParams)?.Entity;
+
if (args.Sprite.LayerMapTryGet(ExpendableLightVisualLayers.Overlay, out var layerIdx, true))
{
if (!string.IsNullOrWhiteSpace(comp.IconStateLit))
break;
case ExpendableLightState.Dead:
- comp.PlayingStream?.Stop();
+ comp.PlayingStream = _audioSystem.Stop(comp.PlayingStream);
if (args.Sprite.LayerMapTryGet(ExpendableLightVisualLayers.Overlay, out layerIdx, true))
{
if (!string.IsNullOrWhiteSpace(comp.IconStateSpent))
using Robust.Client.Animations;
using Robust.Client.GameObjects;
using Robust.Shared.Animations;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Random;
namespace Content.Client.Light.Visualizers;
using Content.Shared.CCVar;
+using Robust.Client.Audio;
using Robust.Client.AutoGenerated;
+using Robust.Client.GameObjects;
using Robust.Client.Graphics;
using Robust.Client.UserInterface;
using Robust.Client.UserInterface.Controls;
public sealed partial class AudioTab : Control
{
[Dependency] private readonly IConfigurationManager _cfg = default!;
- [Dependency] private readonly IClydeAudio _clydeAudio = default!;
+ private readonly AudioSystem _audio;
public AudioTab()
{
RobustXamlLoader.Load(this);
IoCManager.InjectDependencies(this);
+ _audio = IoCManager.Resolve<IEntityManager>().System<AudioSystem>();
LobbyMusicCheckBox.Pressed = _cfg.GetCVar(CCVars.LobbyMusicEnabled);
RestartSoundsCheckBox.Pressed = _cfg.GetCVar(CCVars.RestartSoundsEnabled);
EventMusicCheckBox.Pressed = _cfg.GetCVar(CCVars.EventMusicEnabled);
private void OnMasterVolumeSliderChanged(Range range)
{
- _clydeAudio.SetMasterVolume(MasterVolumeSlider.Value / 100);
+ _audio.SetMasterVolume(MasterVolumeSlider.Value / 100);
UpdateChanges();
}
private void OnApplyButtonPressed(BaseButton.ButtonEventArgs args)
{
- _cfg.SetCVar(CVars.AudioMasterVolume, MasterVolumeSlider.Value / 100);
+ _cfg.SetCVar(CVars.AudioMasterVolume, LV100ToDB(MasterVolumeSlider.Value, CCVars.MasterMultiplier));
// Want the CVar updated values to have the multiplier applied
// For the UI we just display 0-100 still elsewhere
_cfg.SetCVar(CVars.MidiVolume, LV100ToDB(MidiVolumeSlider.Value, CCVars.MidiMultiplier));
private void Reset()
{
- MasterVolumeSlider.Value = _cfg.GetCVar(CVars.AudioMasterVolume) * 100;
+ MasterVolumeSlider.Value = DBToLV100(_cfg.GetCVar(CVars.AudioMasterVolume), CCVars.MasterMultiplier);
MidiVolumeSlider.Value = DBToLV100(_cfg.GetCVar(CVars.MidiVolume), CCVars.MidiMultiplier);
AmbienceVolumeSlider.Value = DBToLV100(_cfg.GetCVar(CCVars.AmbienceVolume), CCVars.AmbienceMultiplier);
AmbientMusicVolumeSlider.Value =
// Do be sure to rename the setting though
private float DBToLV100(float db, float multiplier = 1f)
{
- var weh = (float) (Math.Pow(10, db / 10) * 100 / multiplier);
- return weh;
+ var beri = (float) (Math.Pow(10, db / 10) * 100 / multiplier);
+ return beri;
}
private float LV100ToDB(float lv100, float multiplier = 1f)
private void UpdateChanges()
{
var isMasterVolumeSame =
- Math.Abs(MasterVolumeSlider.Value - _cfg.GetCVar(CVars.AudioMasterVolume) * 100) < 0.01f;
+ Math.Abs(MasterVolumeSlider.Value - DBToLV100(_cfg.GetCVar(CVars.AudioMasterVolume), CCVars.MasterMultiplier)) < 0.01f;
var isMidiVolumeSame =
Math.Abs(MidiVolumeSlider.Value - DBToLV100(_cfg.GetCVar(CVars.MidiVolume), CCVars.MidiMultiplier)) < 0.01f;
var isAmbientVolumeSame =
}
var debugParallax = IoCManager.Resolve<IConfigurationManager>().GetCVar(CCVars.ParallaxDebug);
+ var resManager = IoCManager.Resolve<IResourceManager>();
if (debugParallax
- || !StaticIoC.ResC.UserData.TryReadAllText(PreviousParallaxConfigPath, out var previousParallaxConfig)
+ || !resManager.UserData.TryReadAllText(PreviousParallaxConfigPath, out var previousParallaxConfig)
|| previousParallaxConfig != parallaxConfig)
{
var table = Toml.ReadString(parallaxConfig);
await UpdateCachedTexture(table, debugParallax, cancel);
//Update the previous config
- using var writer = StaticIoC.ResC.UserData.OpenWriteText(PreviousParallaxConfigPath);
+ using var writer = resManager.UserData.OpenWriteText(PreviousParallaxConfigPath);
writer.Write(parallaxConfig);
}
try
{
// Also try to at least sort of fix this if we've been fooled by a config backup
- StaticIoC.ResC.UserData.Delete(PreviousParallaxConfigPath);
+ resManager.UserData.Delete(PreviousParallaxConfigPath);
}
catch (Exception)
{
// And load it in the main thread for safety reasons.
// But before spending time saving it, make sure to exit out early if it's not wanted.
cancel.ThrowIfCancellationRequested();
+ var resManager = IoCManager.Resolve<IResourceManager>();
// Store it and CRC so further game starts don't need to regenerate it.
- using var imageStream = StaticIoC.ResC.UserData.OpenWrite(ParallaxCachedImagePath);
- newParallexImage.SaveAsPng(imageStream);
+ await using var imageStream = resManager.UserData.OpenWrite(ParallaxCachedImagePath);
+ await newParallexImage.SaveAsPngAsync(imageStream, cancel);
if (saveDebugLayers)
{
for (var i = 0; i < debugImages!.Count; i++)
{
var debugImage = debugImages[i];
- using var debugImageStream = StaticIoC.ResC.UserData.OpenWrite(new ResPath($"/parallax_{Identifier}debug_{i}.png"));
- debugImage.SaveAsPng(debugImageStream);
+ await using var debugImageStream = resManager.UserData.OpenWrite(new ResPath($"/parallax_{Identifier}debug_{i}.png"));
+ await debugImage.SaveAsPngAsync(debugImageStream, cancel);
}
}
}
private Texture GetCachedTexture()
{
- using var imageStream = StaticIoC.ResC.UserData.OpenRead(ParallaxCachedImagePath);
+ var resManager = IoCManager.Resolve<IResourceManager>();
+ using var imageStream = resManager.UserData.OpenRead(ParallaxCachedImagePath);
return Texture.LoadFromPNGStream(imageStream, "Parallax");
}
private string? GetParallaxConfig()
{
- if (!StaticIoC.ResC.TryContentFileRead(ParallaxConfigPath, out var configStream))
+ var resManager = IoCManager.Resolve<IResourceManager>();
+ if (!resManager.TryContentFileRead(ParallaxConfigPath, out var configStream))
{
return null;
}
{
case RoundEndMessageEvent:
case PopupEvent:
- case AudioMessage:
case PickupAnimationEvent:
case MeleeLungeEvent:
case SharedGunSystem.HitscanEvent:
using Robust.Shared.Random;
using Robust.Client.Player;
using Robust.Shared.Player;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Timing;
namespace Content.Client.Traits;
private void OnPlayerDetach(EntityUid uid, ParacusiaComponent component, LocalPlayerDetachedEvent args)
{
- component.Stream?.Stop();
+ component.Stream = _audio.Stop(component.Stream);
}
private void PlayParacusiaSounds(EntityUid uid)
var newCoords = Transform(uid).Coordinates.Offset(randomOffset);
// Play the sound
- paracusia.Stream = _audio.PlayStatic(paracusia.Sounds, uid, newCoords);
+ paracusia.Stream = _audio.PlayStatic(paracusia.Sounds, uid, newCoords).Value.Entity;
}
}
using Content.Shared.Trigger;
using Robust.Client.Animations;
using Robust.Client.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.GameObjects;
namespace Content.Client.Trigger;
using Robust.Client.UserInterface.Controls;
using Robust.Client.UserInterface.CustomControls;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Input.Binding;
using Robust.Shared.Network;
using Robust.Shared.Player;
[Dependency] private readonly IPlayerManager _playerManager = default!;
[Dependency] private readonly IClyde _clyde = default!;
[Dependency] private readonly IUserInterfaceManager _uiManager = default!;
+ [UISystemDependency] private readonly SharedAudioSystem _audio = default!;
private BwoinkSystem? _bwoinkSystem;
private MenuButton? GameAHelpButton => UIManager.GetActiveUIWidgetOrNull<GameTopMenuBar>()?.AHelpButton;
}
if (localPlayer.UserId != message.TrueSender)
{
- SoundSystem.Play("/Audio/Effects/adminhelp.ogg", Filter.Local());
+ _audio.PlayGlobal("/Audio/Effects/adminhelp.ogg", Filter.Local(), false);
_clyde.RequestWindowAttention();
}
using Content.Client.UserInterface.Systems.Chat.Controls;
using Content.Shared.Chat;
using Content.Shared.Input;
+using Robust.Client.Audio;
using Robust.Client.AutoGenerated;
+using Robust.Client.GameObjects;
using Robust.Client.UserInterface;
using Robust.Client.UserInterface.Controls;
using Robust.Client.UserInterface.XAML;
#pragma warning restore RA0003
{
private readonly ChatUIController _controller;
+ private readonly IEntityManager _entManager;
public bool Main { get; set; }
public ChatBox()
{
RobustXamlLoader.Load(this);
+ _entManager = IoCManager.Resolve<IEntityManager>();
ChatInput.Input.OnTextEntered += OnTextEntered;
ChatInput.Input.OnKeyBindDown += OnKeyBindDown;
return;
}
- if (msg is { Read: false, AudioPath: not null })
- SoundSystem.Play(msg.AudioPath, Filter.Local(), new AudioParams().WithVolume(msg.AudioVolume));
+ if (msg is { Read: false, AudioPath: { } })
+ _entManager.System<AudioSystem>().PlayGlobal(msg.AudioPath, Filter.Local(), false, AudioParams.Default.WithVolume(msg.AudioVolume));
msg.Read = true;
using System.Linq;
using Content.Shared.Voting;
using Robust.Client;
+using Robust.Client.Audio;
using Robust.Client.Console;
using Robust.Client.GameObjects;
using Robust.Client.UserInterface;
using Content.Shared.Weapons.Ranged.Components;
using Content.Shared.Weapons.Ranged.Systems;
using Robust.Client.Player;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Physics.Events;
using Robust.Shared.Player;
using Robust.Shared.Random;
using System.Numerics;
using Content.Shared.Weather;
+using Robust.Client.Audio;
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
using Robust.Client.Player;
+using Robust.Shared.Audio;
using Robust.Shared.GameStates;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Player;
+using AudioComponent = Robust.Shared.Audio.Components.AudioComponent;
namespace Content.Client.Weather;
{
weather.LastOcclusion = 0f;
weather.LastAlpha = 0f;
- weather.Stream?.Stop();
- weather.Stream = null;
+ weather.Stream = _audio.Stop(weather.Stream);
return;
}
if (!Timing.IsFirstTimePredicted || weatherProto.Sound == null)
return;
- weather.Stream ??= _audio.PlayGlobal(weatherProto.Sound, Filter.Local(), true);
+ weather.Stream ??= _audio.PlayGlobal(weatherProto.Sound, Filter.Local(), true).Value.Entity;
var volumeMod = MathF.Pow(10, weatherProto.Sound.Params.Volume / 10f);
- var stream = (AudioSystem.PlayingStream) weather.Stream!;
+ var stream = weather.Stream.Value;
+ var comp = Comp<AudioComponent>(stream);
var alpha = weather.LastAlpha;
alpha = MathF.Pow(alpha, 2f) * volumeMod;
// TODO: Lerp this occlusion.
{
occlusion = _physics.IntersectRayPenetration(entXform.MapID,
new CollisionRay(entPos, sourceRelative.Normalized(), _audio.OcclusionCollisionMask),
- sourceRelative.Length(), stream.TrackingEntity);
+ sourceRelative.Length(), stream);
}
}
}
weather.LastAlpha += (alpha - weather.LastAlpha) * AlphaLerpRate * frameTime;
// Full volume if not on grid
- stream.Source.SetVolumeDirect(weather.LastAlpha);
- stream.Source.SetOcclusion(weather.LastOcclusion);
+ comp.Gain = weather.LastAlpha;
+ comp.Occlusion = weather.LastOcclusion;
}
protected override void EndWeather(EntityUid uid, WeatherComponent component, string proto)
return true;
// TODO: Fades (properly)
- weather.Stream?.Stop();
- weather.Stream = null;
- weather.Stream = _audio.PlayGlobal(weatherProto.Sound, Filter.Local(), true);
+ weather.Stream = _audio.Stop(weather.Stream);
+ weather.Stream = _audio.PlayGlobal(weatherProto.Sound, Filter.Local(), true)?.Entity;
return true;
}
using Content.Shared.Damage;
using Content.Shared.Damage.Prototypes;
using Content.Shared.FixedPoint;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.GameObjects;
using Robust.Shared.Prototypes;
using static Content.IntegrationTests.Tests.Destructible.DestructibleTestPrototypes;
{
foreach (var (proto, quantity) in expected.Entities)
{
+ if (proto == "Audio")
+ continue;
+
if (quantity < 0 && failOnExcess)
Assert.Fail($"Unexpected entity/stack: {proto}, quantity: {-quantity}");
using Content.Shared.Decals;
using Robust.Client.ResourceManagement;
using Robust.Client.Utility;
+using Robust.Shared.ContentPack;
using Robust.Shared.Prototypes;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
public sealed class DecalPainter
{
- private readonly IResourceCache _cResourceCache;
+ private readonly IResourceManager _resManager;
private readonly IPrototypeManager _sPrototypeManager;
public DecalPainter(ClientIntegrationInstance client, ServerIntegrationInstance server)
{
- _cResourceCache = client.ResolveDependency<IResourceCache>();
+ _resManager = client.ResolveDependency<IResourceManager>();
_sPrototypeManager = server.ResolveDependency<IPrototypeManager>();
}
Stream stream;
if (sprite is SpriteSpecifier.Texture texture)
{
- stream = _cResourceCache.ContentFileRead(texture.TexturePath);
+ stream = _resManager.ContentFileRead(texture.TexturePath);
}
else if (sprite is SpriteSpecifier.Rsi rsi)
{
path = $"/Textures/{path}";
}
- stream = _cResourceCache.ContentFileRead(path);
+ stream = _resManager.ContentFileRead(path);
}
else
{
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
using Robust.Client.ResourceManagement;
+using Robust.Shared.ContentPack;
using Robust.Shared.GameObjects;
using Robust.Shared.Timing;
using SixLabors.ImageSharp;
public sealed class EntityPainter
{
- private readonly IResourceCache _cResourceCache;
+ private readonly IResourceManager _resManager;
private readonly Dictionary<(string path, string state), Image> _images;
private readonly Image _errorImage;
public EntityPainter(ClientIntegrationInstance client, ServerIntegrationInstance server)
{
- _cResourceCache = client.ResolveDependency<IResourceCache>();
+ _resManager = client.ResolveDependency<IResourceManager>();
_sEntityManager = server.ResolveDependency<IEntityManager>();
_images = new Dictionary<(string path, string state), Image>();
- _errorImage = Image.Load<Rgba32>(_cResourceCache.ContentFileRead("/Textures/error.rsi/error.png"));
+ _errorImage = Image.Load<Rgba32>(_resManager.ContentFileRead("/Textures/error.rsi/error.png"));
}
public void Run(Image canvas, List<EntityData> entities)
if (!_images.TryGetValue(key, out image!))
{
- var stream = _cResourceCache.ContentFileRead($"{rsi.Path}/{state.StateId}.png");
+ var stream = _resManager.ContentFileRead($"{rsi.Path}/{state.StateId}.png");
image = Image.Load<Rgba32>(stream);
_images[key] = image;
using System.Linq;
using Robust.Client.Graphics;
using Robust.Client.ResourceManagement;
+using Robust.Shared.ContentPack;
using Robust.Shared.GameObjects;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
public const int TileImageSize = EyeManager.PixelsPerMeter;
private readonly ITileDefinitionManager _sTileDefinitionManager;
- private readonly IResourceCache _cResourceCache;
+ private readonly IResourceManager _resManager;
public TilePainter(ClientIntegrationInstance client, ServerIntegrationInstance server)
{
_sTileDefinitionManager = server.ResolveDependency<ITileDefinitionManager>();
- _cResourceCache = client.ResolveDependency<IResourceCache>();
+ _resManager = client.ResolveDependency<IResourceManager>();
}
public void Run(Image gridCanvas, EntityUid gridUid, MapGridComponent grid)
var yOffset = -bounds.Bottom;
var tileSize = grid.TileSize * TileImageSize;
- var images = GetTileImages(_sTileDefinitionManager, _cResourceCache, tileSize);
+ var images = GetTileImages(_sTileDefinitionManager, _resManager, tileSize);
var i = 0;
grid.GetAllTiles().AsParallel().ForAll(tile =>
private Dictionary<string, List<Image>> GetTileImages(
ITileDefinitionManager tileDefinitionManager,
- IResourceCache resourceCache,
+ IResourceManager resManager,
int tileSize)
{
var stopwatch = new Stopwatch();
images[path] = new List<Image>(definition.Variants);
- using var stream = resourceCache.ContentFileRead(path);
+ using var stream = resManager.ContentFileRead(path);
Image tileSheet = Image.Load<Rgba32>(stream);
if (tileSheet.Width != tileSize * definition.Variants || tileSheet.Height != tileSize)
<OutputType>Exe</OutputType>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
+ <ServerGarbageCollection>True</ServerGarbageCollection>
</PropertyGroup>
<ItemGroup>
- <PackageReference Include="NVorbis" Version="0.10.1" PrivateAssets="compile" />
+ <PackageReference Include="NVorbis" Version="0.10.5" PrivateAssets="compile" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\RobustToolbox\Robust.Packaging\Robust.Packaging.csproj" />
using System.Diagnostics;
-using System.Globalization;
using System.IO.Compression;
using Robust.Packaging;
using Robust.Packaging.AssetProcessing;
using Robust.Packaging.AssetProcessing.Passes;
using Robust.Packaging.Utility;
-using Robust.Shared.Audio;
-using Robust.Shared.Serialization;
using Robust.Shared.Timing;
-using YamlDotNet.Core;
-using YamlDotNet.RepresentationModel;
namespace Content.Packaging;
bool hybridAcz,
CancellationToken cancel)
{
- var graph = new RobustClientAssetGraph();
+ var graph = new RobustServerAssetGraph();
var passes = graph.AllPasses.ToList();
pass.Dependencies.Add(new AssetPassDependency(graph.Output.Name));
AssetGraph.CalculateGraph(passes, logger);
- var inputPass = graph.Input;
+ var inputPassCore = graph.InputCore;
+ var inputPassResources = graph.InputResources;
var contentAssemblies = new List<string>(ServerContentAssemblies);
// Additional assemblies that need to be copied such as EFCore.
Path.Combine("RobustToolbox", "bin", "Server",
platform.Rid,
"publish"),
- inputPass,
+ inputPassCore,
BinSkipFolders,
cancel: cancel);
await RobustSharedPackaging.WriteContentAssemblies(
- inputPass,
+ inputPassResources,
contentDir,
"Content.Server",
contentAssemblies,
- Path.Combine("Resources", "Assemblies"),
- cancel);
+ cancel: cancel);
- await RobustServerPackaging.WriteServerResources(contentDir, inputPass, cancel);
+ await RobustServerPackaging.WriteServerResources(contentDir, inputPassResources, cancel);
if (hybridAcz)
{
- inputPass.InjectFileFromDisk("Content.Client.zip", Path.Combine("release", "SS14.Client.zip"));
+ inputPassCore.InjectFileFromDisk("Content.Client.zip", Path.Combine("release", "SS14.Client.zip"));
}
- inputPass.InjectFinished();
+ inputPassCore.InjectFinished();
+ inputPassResources.InjectFinished();
}
private readonly record struct PlatformReg(string Rid, string TargetOs, bool BuildByDefault);
using Content.Shared.Interaction;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Player;
using static Content.Shared.Access.Components.AccessOverriderComponent;
using Robust.Server.GameObjects;
using Robust.Server.Player;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Enums;
using Robust.Shared.Network;
[Dependency] private readonly IChatManager _chat = default!;
[Dependency] private readonly IConfigurationManager _config = default!;
[Dependency] private readonly IPlayerManager _playerManager = default!;
- [Dependency] private readonly AudioSystem _audio = default!;
[Dependency] private readonly HandsSystem _hands = default!;
[Dependency] private readonly SharedJobSystem _jobs = default!;
[Dependency] private readonly InventorySystem _inventory = default!;
[Dependency] private readonly PlayTimeTrackingManager _playTime = default!;
[Dependency] private readonly SharedRoleSystem _role = default!;
[Dependency] private readonly GameTicker _gameTicker = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly StationRecordsSystem _stationRecords = default!;
[Dependency] private readonly TransformSystem _transform = default!;
_popup.PopupCoordinates(Loc.GetString("admin-erase-popup", ("user", name)), coordinates, PopupType.LargeCaution);
var filter = Filter.Pvs(coordinates, 1, EntityManager, _playerManager);
var audioParams = new AudioParams().WithVolume(3);
- _audio.Play("/Audio/Effects/pop_high.ogg", filter, coordinates, true, audioParams);
+ _audio.PlayStatic("/Audio/Effects/pop_high.ogg", filter, coordinates, true, audioParams);
}
foreach (var item in _inventory.GetHandOrInventoryEntities(entity.Value))
using Content.Server.Station.Systems;
using Content.Shared.CCVar;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Prototypes;
public sealed class AlertLevelSystem : EntitySystem
{
+ [Dependency] private readonly IConfigurationManager _cfg = default!;
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
[Dependency] private readonly ChatSystem _chatSystem = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly StationSystem _stationSystem = default!;
- [Dependency] private readonly IConfigurationManager _cfg = default!;
// Until stations are a prototype, this is how it's going to have to be.
public const string DefaultAlertLevelSet = "stationAlerts";
if (detail.Sound != null)
{
var filter = _stationSystem.GetInOwningStation(station);
- SoundSystem.Play(detail.Sound.GetSound(), filter, detail.Sound.Params);
+ _audio.PlayGlobal(detail.Sound.GetSound(), filter, true, detail.Sound.Params);
}
else
{
using Robust.Server.Containers;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Player;
using Robust.Shared.Timing;
using Content.Shared.Database;
using Content.Shared.Hands.Components;
using Content.Shared.Interaction;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
namespace Content.Server.Ame.EntitySystems;
using Content.Shared.Nutrition.Components;
using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Storage;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Player;
using Robust.Shared.Random;
using Content.Shared.Anomaly.Components;
using Content.Shared.Interaction;
using Content.Shared.Popups;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Anomaly;
var generating = EnsureComp<GeneratingAnomalyGeneratorComponent>(uid);
generating.EndTime = Timing.CurTime + component.GenerationLength;
- generating.AudioStream = Audio.PlayPvs(component.GeneratingSound, uid, AudioParams.Default.WithLoop(true));
+ generating.AudioStream = Audio.PlayPvs(component.GeneratingSound, uid, AudioParams.Default.WithLoop(true))?.Entity;
component.CooldownEndTime = Timing.CurTime + component.CooldownLength;
UpdateGeneratorUi(uid, component);
}
{
if (Timing.CurTime < active.EndTime)
continue;
- active.AudioStream?.Stop();
+
+ active.AudioStream = _audio.Stop(active.AudioStream);
OnGeneratingFinished(ent, gen);
}
}
using Content.Shared.Anomaly.Components;
using Content.Shared.DoAfter;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Physics.Events;
using Robust.Shared.Prototypes;
[Dependency] private readonly SharedPointLightSystem _pointLight = default!;
[Dependency] private readonly StationSystem _station = default!;
[Dependency] private readonly RadioSystem _radio = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly UserInterfaceSystem _ui = default!;
public const float MinParticleVariation = 0.8f;
[DataField("endTime", customTypeSerializer: typeof(TimeOffsetSerializer))]
public TimeSpan EndTime = TimeSpan.Zero;
- public IPlayingAudioStream? AudioStream;
+ public EntityUid? AudioStream;
}
using Content.Shared.Anomaly.Components;
using Content.Shared.Mobs.Components;
using Content.Shared.Teleportation.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Random;
namespace Content.Server.Anomaly.Effects;
using Robust.Shared.Prototypes;
using Content.Shared.Sprite;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Anomaly.Effects;
if (anomaly.Severity >= 0.97) reagentProducingAmount *= component.SupercriticalReagentProducingModifier;
newSol.AddReagent(component.ProducingReagent, reagentProducingAmount);
- _solutionContainer.TryAddSolution(uid, producerSol, newSol); //TO DO - the container is not fully filled.
+ _solutionContainer.TryAddSolution(uid, producerSol, newSol); //TO DO - the container is not fully filled.
component.AccumulatedFrametime = 0;
using Content.Server.Station.Systems;
using Content.Server.Shuttles.Systems;
using Content.Shared.Mobs;
+using Robust.Server.Audio;
using Robust.Server.Containers;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using static Content.Shared.Arcade.SharedSpaceVillainArcadeComponent;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Random;
namespace Content.Server.Arcade.SpaceVillain;
using static Content.Shared.Arcade.SharedSpaceVillainArcadeComponent;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Random;
namespace Content.Server.Arcade.SpaceVillain;
// Cancel toggles sounds if we re-toggle again.
- public IPlayingAudioStream? ConnectStream;
- public IPlayingAudioStream? DisconnectStream;
+ public EntityUid? ConnectStream;
+ public EntityUid? DisconnectStream;
[DataField("air"), ViewVariables(VVAccess.ReadWrite)]
public GasMixture Air { get; set; } = new();
if(_spaceWindSoundCooldown == 0 && !string.IsNullOrEmpty(SpaceWindSound))
{
var coordinates = tile.GridIndices.ToEntityCoordinates(tile.GridIndex, _mapManager);
- SoundSystem.Play(SpaceWindSound, Filter.Pvs(coordinates),
- coordinates, AudioHelpers.WithVariation(0.125f).WithVolume(MathHelper.Clamp(tile.PressureDifference / 10, 10, 100)));
+ _audio.PlayPvs(SpaceWindSound, coordinates, AudioParams.Default.WithVariation(0.125f).WithVolume(MathHelper.Clamp(tile.PressureDifference / 10, 10, 100)));
}
}
// A few details on the audio parameters for fire.
// The greater the fire state, the lesser the pitch variation.
// The greater the fire state, the greater the volume.
- SoundSystem.Play(HotspotSound, Filter.Pvs(coordinates),
- coordinates, AudioHelpers.WithVariation(0.15f/tile.Hotspot.State).WithVolume(-5f + 5f * tile.Hotspot.State));
+ _audio.PlayPvs(HotspotSound, coordinates, AudioParams.Default.WithVariation(0.15f/tile.Hotspot.State).WithVolume(-5f + 5f * tile.Hotspot.State));
}
if (_hotspotSoundCooldown > HotspotSoundCooldownCycles)
using Content.Shared.Maps;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Physics.Systems;
[Dependency] private readonly SharedContainerSystem _containers = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
[Dependency] private readonly GasTileOverlaySystem _gasTileOverlaySystem = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly TransformSystem _transformSystem = default!;
[Dependency] private readonly TileSystem _tile = default!;
using Content.Shared.Timing;
using Content.Shared.Toggleable;
using Content.Shared.Weapons.Melee.Events;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Events;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Player;
if (!component.IsConnected)
return;
- component.ConnectStream?.Stop();
-
- if (component.ConnectSound != null)
- component.ConnectStream = _audioSys.PlayPvs(component.ConnectSound, owner);
+ component.ConnectStream = _audioSys.Stop(component.ConnectStream);
+ component.ConnectStream = _audioSys.PlayPvs(component.ConnectSound, component.Owner)?.Entity;
UpdateUserInterface(ent);
}
_actions.SetToggled(component.ToggleActionEntity, false);
_internals.DisconnectTank(internals);
- component.DisconnectStream?.Stop();
-
- if (component.DisconnectSound != null)
- component.DisconnectStream = _audioSys.PlayPvs(component.DisconnectSound, owner);
+ component.DisconnectStream = _audioSys.Stop(component.DisconnectStream);
+ component.DisconnectStream = _audioSys.PlayPvs(component.DisconnectSound, component.Owner)?.Entity;
UpdateUserInterface(ent);
}
if(environment != null)
_atmosphereSystem.Merge(environment, component.Air);
- _audioSys.Play(component.RuptureSound, Filter.Pvs(owner), Transform(owner).Coordinates, true, AudioParams.Default.WithVariation(0.125f));
+ _audioSys.PlayPvs(component.RuptureSound, Transform(component.Owner).Coordinates, AudioParams.Default.WithVariation(0.125f));
QueueDel(owner);
return;
using Content.Server.Power.Components;
using Content.Shared.Atmos.Monitor;
using Content.Shared.Tag;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Utility;
using Content.Shared.Interaction;
using JetBrains.Annotations;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Atmos.Piping.Binary.EntitySystems
{
[Dependency] private readonly SharedAmbientSoundSystem _ambientSoundSystem = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly NodeContainerSystem _nodeContainer = default!;
public override void Initialize()
return;
if (Loc.TryGetString("gas-valve-system-examined", out var str,
- ("statusColor", valve.Open ? "green" : "orange"),
- ("open", valve.Open)
- ))
+ ("statusColor", valve.Open ? "green" : "orange"),
+ ("open", valve.Open)))
+ {
args.PushMarkup(str);
+ }
}
private void OnStartup(EntityUid uid, GasValveComponent component, ComponentStartup args)
private void OnActivate(EntityUid uid, GasValveComponent component, ActivateInWorldEvent args)
{
Toggle(uid, component);
- SoundSystem.Play(component.ValveSound.GetSound(), Filter.Pvs(uid), uid, AudioHelpers.WithVariation(0.25f));
+ _audio.PlayPvs(component.ValveSound, uid, AudioParams.Default.WithVariation(0.25f));
}
public void Set(EntityUid uid, GasValveComponent component, bool value)
using Content.Shared.Interaction;
using Content.Shared.Lock;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Player;
+using Content.Server.GameTicking.Events;
using Content.Shared.Audio;
+using Robust.Server.Audio;
+using Robust.Shared.Audio;
+using Robust.Shared.Prototypes;
namespace Content.Server.Audio;
public sealed class ContentAudioSystem : SharedContentAudioSystem
{
+ [Dependency] private readonly AudioSystem _serverAudio = default!;
+ [Dependency] private readonly IPrototypeManager _protoManager = default!;
+ public override void Initialize()
+ {
+ base.Initialize();
+ SubscribeLocalEvent<RoundStartingEvent>(OnRoundStart);
+ _protoManager.PrototypesReloaded += OnProtoReload;
+ }
+
+ private void OnProtoReload(PrototypesReloadedEventArgs obj)
+ {
+ if (!obj.ByType.ContainsKey(typeof(AudioPresetPrototype)))
+ return;
+
+ _serverAudio.ReloadPresets();
+ }
+
+ public override void Shutdown()
+ {
+ base.Shutdown();
+ _protoManager.PrototypesReloaded -= OnProtoReload;
+ }
+
+ private void OnRoundStart(RoundStartingEvent ev)
+ {
+ // On cleanup all entities get purged so need to ensure audio presets are still loaded
+ // yeah it's whacky af.
+ _serverAudio.ReloadPresets();
+ }
}
using Content.Shared.Beam;
using Content.Shared.Beam.Components;
using Content.Shared.Physics;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Collision.Shapes;
using Content.Shared.StatusEffect;
using Content.Shared.Stunnable;
using Content.Shared.Verbs;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Content.Shared.Timing;
using Content.Shared.Verbs;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Random;
[Dependency] private readonly MobStateSystem _mobStateSystem = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
[Dependency] private readonly SharedActionsSystem _actionsSystem = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly UseDelaySystem _delay = default!;
public override void Initialize()
summonableComp.Summon = null;
}
summonableComp.AlreadySummoned = false;
- _popupSystem.PopupEntity(Loc.GetString("bible-summon-respawn-ready", ("book", uid)), uid, PopupType.Medium);
- SoundSystem.Play("/Audio/Effects/radpulse9.ogg", Filter.Pvs(uid), uid, AudioParams.Default.WithVolume(-4f));
+ _popupSystem.PopupEntity(Loc.GetString("bible-summon-respawn-ready", ("book", summonableComp.Owner)), summonableComp.Owner, PopupType.Medium);
+ _audio.PlayPvs("/Audio/Effects/radpulse9.ogg", summonableComp.Owner, AudioParams.Default.WithVolume(-4f));
// Clean up the accumulator and respawn tracking component
summonableComp.Accumulator = 0;
_remQueue.Enqueue(uid);
{
_popupSystem.PopupEntity(Loc.GetString("bible-sizzle"), args.User, args.User);
- SoundSystem.Play(component.SizzleSoundPath.GetSound(), Filter.Pvs(args.User), args.User);
+ _audio.PlayPvs(component.SizzleSoundPath, args.User);
_damageableSystem.TryChangeDamage(args.User, component.DamageOnUntrainedUse, true, origin: uid);
_delay.BeginDelay(uid, delay);
var selfFailMessage = Loc.GetString(component.LocPrefix + "-heal-fail-self", ("target", Identity.Entity(args.Target.Value, EntityManager)),("bible", uid));
_popupSystem.PopupEntity(selfFailMessage, args.User, args.User, PopupType.MediumCaution);
- SoundSystem.Play("/Audio/Effects/hit_kick.ogg", Filter.Pvs(args.Target.Value), args.User);
+ _audio.PlayPvs("/Audio/Effects/hit_kick.ogg", args.User);
_damageableSystem.TryChangeDamage(args.Target.Value, component.DamageOnFail, true, origin: uid);
_delay.BeginDelay(uid, delay);
return;
var selfMessage = Loc.GetString(component.LocPrefix + "-heal-success-self", ("target", Identity.Entity(args.Target.Value, EntityManager)),("bible", uid));
_popupSystem.PopupEntity(selfMessage, args.User, args.User, PopupType.Large);
- SoundSystem.Play(component.HealSoundPath.GetSound(), Filter.Pvs(args.Target.Value), args.User);
+ _audio.PlayPvs(component.HealSoundPath, args.User);
_delay.BeginDelay(uid, delay);
}
}
using Robust.Server.GameObjects;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
+using Content.Shared.Speech.EntitySystems;
+using Robust.Server.Audio;
namespace Content.Server.Body.Systems;
using Robust.Shared.Random;
using Robust.Shared.Timing;
using System.Numerics;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Body.Systems;
var filter = Filter.Pvs(bodyId, entityManager: EntityManager);
var audio = AudioParams.Default.WithVariation(0.025f);
- _audio.Play(body.GibSound, filter, coordinates, true, audio);
+ _audio.PlayStatic(body.GibSound, filter, coordinates, true, audio);
foreach (var entity in gibs)
{
using Content.Shared.Tag;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Content.Shared.Stealth.Components;
using Content.Shared.Storage.Components;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Player;
using Robust.Shared.Timing;
using Content.Shared.Mobs.Components;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Map;
using Robust.Shared.Prototypes;
using Content.Shared.CartridgeLoader.Cartridges;
using Content.Shared.Popups;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Random;
using Content.Shared.Radio;
using Robust.Server.Player;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Console;
using Robust.Shared.Network;
_chatManager.ChatMessageToAll(ChatChannel.Radio, message, wrappedMessage, default, false, true, colorOverride);
if (playSound)
{
- SoundSystem.Play(announcementSound?.GetSound() ?? DefaultAnnouncementSound, Filter.Broadcast(), AudioParams.Default.WithVolume(-2f));
+ _audio.PlayGlobal(announcementSound?.GetSound() ?? DefaultAnnouncementSound, Filter.Broadcast(), true, AudioParams.Default.WithVolume(-2f));
}
_adminLogger.Add(LogType.Chat, LogImpact.Low, $"Global station announcement from {sender}: {message}");
}
if (playDefaultSound)
{
- SoundSystem.Play(announcementSound?.GetSound() ?? DefaultAnnouncementSound, filter, AudioParams.Default.WithVolume(-2f));
+ _audio.PlayGlobal(announcementSound?.GetSound() ?? DefaultAnnouncementSound, filter, true, AudioParams.Default.WithVolume(-2f));
}
_adminLogger.Add(LogType.Chat, LogImpact.Low, $"Station Announcement on {station} from {sender}: {message}");
using Content.Shared.FixedPoint;
using Content.Shared.Storage;
using JetBrains.Annotations;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.DoAfter;
using Content.Shared.Mobs.Systems;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Chemistry.EntitySystems;
using Content.Shared.Emag.Components;
using Content.Shared.Emag.Systems;
using JetBrains.Annotations;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
using Content.Shared.Maps;
using JetBrains.Annotations;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
var smoke = args.EntityManager.System<SmokeSystem>();
smoke.StartSmoke(ent, splitSolution, _duration, spreadAmount);
- args.EntityManager.System<SharedAudioSystem>().PlayPvs(_sound, args.SolutionEntity, AudioHelpers.WithVariation(0.125f));
+ var audio = args.EntityManager.System<SharedAudioSystem>();
+ audio.PlayPvs(_sound, args.SolutionEntity, AudioHelpers.WithVariation(0.125f));
}
}
}
using Robust.Server.Containers;
using Robust.Server.GameObjects;
using Robust.Server.Player;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Containers;
using Robust.Shared.Physics.Components;
using Content.Server.Speech.EntitySystems;
using Content.Shared.Cluwne;
using Content.Shared.Interaction.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Cluwne;
using Content.Shared.Construction;
using JetBrains.Annotations;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Random;
namespace Content.Server.Construction.Completions
[DataField("exchangeSound")]
public SoundSpecifier ExchangeSound = new SoundPathSpecifier("/Audio/Items/rped.ogg");
- public IPlayingAudioStream? AudioStream;
+ public EntityUid? AudioStream;
}
using Robust.Shared.Containers;
using Robust.Shared.Utility;
using Content.Shared.Wires;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Collections;
namespace Content.Server.Construction;
{
if (args.Cancelled)
{
- component.AudioStream?.Stop();
+ component.AudioStream = _audio.Stop(component.AudioStream);
return;
}
return;
}
- component.AudioStream = _audio.PlayPvs(component.ExchangeSound, uid);
+ component.AudioStream = _audio.PlayPvs(component.ExchangeSound, uid).Value.Entity;
_doAfter.TryStartDoAfter(new DoAfterArgs(EntityManager, args.User, component.ExchangeDuration, new ExchangerDoAfterEvent(), uid, target: args.Target, used: uid)
{
using Content.Shared.Interaction.Events;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.GameStates;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Content.Shared.Verbs;
using Content.Shared.Wires;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Defusable.Systems;
using Content.Shared.Destructible;
using Content.Shared.FixedPoint;
using JetBrains.Annotations;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Containers;
using Robust.Shared.Prototypes;
using Content.Shared.Audio;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Destructible.Thresholds.Behaviors
using Content.Server.DeviceLinking.Components;
using Content.Server.DeviceLinking.Components.Overload;
using Content.Server.DeviceLinking.Events;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Content.Shared.Interaction;
using Content.Shared.Tools;
using Content.Shared.Popups;
-using SharedToolSystem = Content.Shared.Tools.Systems.SharedToolSystem;
+using Content.Shared.Tools.Systems;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using SignalReceivedEvent = Content.Server.DeviceLinking.Events.SignalReceivedEvent;
namespace Content.Server.DeviceLinking.Systems;
using Content.Server.DeviceNetwork;
using Content.Shared.Interaction;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.DeviceLinking.Systems;
using Content.Shared.MachineLinking;
using Content.Shared.TextScreen;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Timing;
namespace Content.Server.DeviceLinking.Systems;
using Content.Shared.Popups;
using Content.Shared.Verbs;
using JetBrains.Annotations;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Player;
using Content.Shared.Dice;
using Content.Shared.Popups;
using JetBrains.Annotations;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Random;
namespace Content.Server.Dice;
using Content.Shared.Movement.Events;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Physics;
using Content.Shared.Item;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
using Robust.Shared.Player;
using Robust.Shared.Serialization.Manager;
using System.Numerics;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Dragon;
using Content.Shared.Mind.Components;
using Content.Shared.Mobs;
using Content.Shared.Movement.Systems;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.GameStates;
using Robust.Shared.Map;
using Robust.Shared.Player;
private void Roar(EntityUid uid, DragonComponent comp)
{
if (comp.SoundRoar != null)
- _audio.Play(comp.SoundRoar, Filter.Pvs(uid, 4f, EntityManager), uid, true);
+ _audio.PlayPvs(comp.SoundRoar, uid);
}
/// <summary>
using Content.Shared.Tag;
using Content.Shared.Weapons.Melee.Events;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Physics.Events;
using Robust.Shared.Player;
comp.Intensity = iterationIntensity;
comp.SpaceMatrix = spaceMatrix;
comp.SpaceTileSize = spaceData?.TileSize ?? DefaultTileSize;
- Dirty(comp);
+ Dirty(explosionEntity, comp);
// Light, sound & visuals may extend well beyond normal PVS range. In principle, this should probably still be
// restricted to something like the same map, but whatever.
- _pvsSys.AddGlobalOverride(explosionEntity);
+ _pvsSys.AddGlobalOverride(GetNetEntity(explosionEntity));
var appearance = AddComp<AppearanceComponent>(explosionEntity);
_appearance.SetData(explosionEntity, ExplosionAppearanceData.Progress, 1, appearance);
using Robust.Server.GameStates;
using Robust.Server.Player;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Map;
using Robust.Shared.Physics.Components;
[Dependency] private readonly IChatManager _chat = default!;
[Dependency] private readonly ThrowingSystem _throwingSystem = default!;
[Dependency] private readonly PvsOverrideSystem _pvsSys = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly SharedTransformSystem _transformSystem = default!;
[Dependency] private readonly SharedMapSystem _map = default!;
// play sound.
var audioRange = iterationIntensity.Count * 5;
var filter = Filter.Pvs(epicenter).AddInRange(epicenter, audioRange);
- SoundSystem.Play(type.Sound.GetSound(), filter, mapEntityCoords, _audioParams);
+ _audio.PlayStatic(type.Sound.GetSound(), filter, mapEntityCoords, true, _audioParams);
return new Explosion(this,
type,
using Content.Shared.Mobs;
using Content.Shared.Mobs.Components;
using Content.Shared.Weapons.Ranged.Events;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Explosion.EntitySystems
{
using Content.Shared.Interaction.Events;
using Content.Shared.Verbs;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Extinguisher;
[Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
public override void Initialize()
{
var drained = _solutionContainerSystem.Drain(target, targetSolution, transfer);
_solutionContainerSystem.TryAddSolution(uid, container, drained);
- SoundSystem.Play(component.RefillSound.GetSound(), Filter.Pvs(uid), uid);
+ _audio.PlayPvs(component.RefillSound, uid);
_popupSystem.PopupEntity(Loc.GetString("fire-extinguisher-component-after-interact-refilled-message", ("owner", uid)),
uid, args.Target.Value);
}
return;
extinguisher.Safety = !extinguisher.Safety;
- SoundSystem.Play(extinguisher.SafetySound.GetSound(), Filter.Pvs(uid),
- uid, AudioHelpers.WithVariation(0.125f).WithVolume(-4f));
+ _audio.PlayPvs(extinguisher.SafetySound, uid, AudioParams.Default.WithVariation(0.125f).WithVolume(-4f));
UpdateAppearance(uid, extinguisher);
}
}
using Content.Shared.Paper;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Player;
using Content.Shared.Tag;
using Content.Shared.Traits.Assorted;
using Content.Shared.Weapons.Melee.Events;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Player;
}
if (sound != null)
{
- SoundSystem.Play(sound.GetSound(), Filter.Pvs(transform), source);
+ _audio.PlayPvs(sound, source);
}
}
using Content.Shared.Interaction;
using Content.Shared.Timing;
using Content.Shared.Weapons.Melee;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Map;
using Robust.Shared.Prototypes;
using Content.Shared.Interaction;
using Content.Shared.Tag;
using Content.Shared.Verbs;
+using Content.Shared.Fluids.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Collections;
using Robust.Shared.Random;
using Robust.Shared.Utility;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Robust.Shared.Timing;
+using Content.Shared.Movement.Components;
+using Content.Shared.Movement.Systems;
+using Content.Shared.Maps;
+using Content.Shared.Effects;
+using Robust.Server.Audio;
namespace Content.Server.Fluids.EntitySystems;
return true;
}
- SoundSystem.Play(puddleComponent.SpillSound.GetSound(),
- Filter.Pvs(puddleUid), puddleUid);
+ _audio.PlayPvs(puddleComponent.SpillSound, puddleUid);
return true;
}
using Content.Shared.Interaction;
using Content.Shared.Vapor;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Physics.Components;
using Robust.Shared.Prototypes;
using Robust.Shared.Timing;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction;
using Content.Shared.Verbs;
+using Robust.Shared.Audio.Systems;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Player;
if (args.NewStatus != SessionStatus.Disconnected)
{
mind.Session = session;
- _pvsOverride.AddSessionOverride(mindId.Value, session);
+ _pvsOverride.AddSessionOverride(GetNetEntity(mindId.Value), session);
}
DebugTools.Assert(mind.Session == session);
_chatManager.SendAdminAnnouncement(Loc.GetString("player-leave-message", ("name", args.Session.Name)));
if (mind != null)
{
- _pvsOverride.ClearOverride(mindId!.Value);
+ _pvsOverride.ClearOverride(GetNetEntity(mindId!.Value));
mind.Session = null;
}
playerIcName = icName;
if (TryGetEntity(mind.OriginalOwnedEntity, out var entity))
- _pvsOverride.AddGlobalOverride(entity.Value, recursive: true);
+ _pvsOverride.AddGlobalOverride(GetNetEntity(entity.Value), recursive: true);
var roles = _roles.MindGetAllRoles(mindId);
_chatSystem.DispatchGlobalAnnouncement(Loc.GetString(proto.Message), playSound: true);
if (proto.Sound != null)
- SoundSystem.Play(proto.Sound.GetSound(), Filter.Broadcast());
+ _audio.PlayGlobal(proto.Sound, Filter.Broadcast(), true);
}
private async void SendRoundStartedDiscordMessage()
using Robust.Server;
using Robust.Server.GameObjects;
using Robust.Server.GameStates;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Console;
using Robust.Shared.Map;
[Dependency] private readonly PlayTimeTrackingSystem _playTimeTrackings = default!;
[Dependency] private readonly PvsOverrideSystem _pvsOverride = default!;
[Dependency] private readonly ServerUpdateManager _serverUpdates = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly StationJobsSystem _stationJobs = default!;
[Dependency] private readonly StationSpawningSystem _stationSpawning = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
using Robust.Server.Maps;
using Robust.Server.Player;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Content.Shared.Roles;
using Robust.Server.GameObjects;
using Robust.Server.Maps;
+using Robust.Server.Player;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Enums;
using Robust.Shared.Map;
using Content.Shared.Roles;
using Content.Shared.Stunnable;
using Content.Shared.Zombies;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Timing;
using Content.Shared.Preferences;
using Content.Shared.Roles;
using Content.Shared.Roles.Jobs;
+using Robust.Server.Player;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Content.Shared.Zombies;
using Robust.Server.GameObjects;
using Robust.Server.Player;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Player;
using Robust.Shared.Random;
using Content.Shared.Teleportation.Systems;
using Content.Shared.Verbs;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.GameObjects;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
using Content.Shared.Tag;
using Content.Shared.Weapons.Melee.Events;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Content.Shared.Hands;
using Robust.Shared.Timing;
using Content.Shared.Interaction.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Glue;
using Content.Shared.Mobs;
using Content.Shared.Popups;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Player;
using Robust.Shared.Utility;
if (TryComp<GuardianComponent>(guardian, out var guardianComp))
{
guardianComp.Host = args.Args.Target.Value;
- // TODO this should be a data field, not a hardcoded path
- _audio.Play("/Audio/Effects/guardian_inject.ogg", Filter.Pvs(args.Args.Target.Value), args.Args.Target.Value, true);
+ _audio.PlayPvs("/Audio/Effects/guardian_inject.ogg", args.Args.Target.Value);
_popupSystem.PopupEntity(Loc.GetString("guardian-created"), args.Args.Target.Value, args.Args.Target.Value);
// Exhaust the activator
component.Used = true;
if (args.NewMobState == MobState.Critical)
{
_popupSystem.PopupEntity(Loc.GetString("guardian-host-critical-warn"), component.HostedGuardian.Value, component.HostedGuardian.Value);
- // TODO this should be a data field, not a hardcoded path
- _audio.Play("/Audio/Effects/guardian_warn.ogg", Filter.Pvs(component.HostedGuardian.Value), component.HostedGuardian.Value, true);
+ _audio.PlayPvs("/Audio/Effects/guardian_warn.ogg", component.HostedGuardian.Value);
}
else if (args.NewMobState == MobState.Dead)
{
//TODO: Replace WithVariation with datafield
- _audio.Play("/Audio/Voice/Human/malescream_guardian.ogg", Filter.Pvs(uid), uid, true, AudioHelpers.WithVariation(0.20f));
+ _audio.PlayPvs("/Audio/Voice/Human/malescream_guardian.ogg", uid, AudioParams.Default.WithVariation(0.20f));
RemComp<GuardianHostComponent>(uid);
}
}
using Content.Shared.Examine;
using Content.Shared.Interaction.Events;
using Content.Shared.Item;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
using Content.Server.Explosion.EntitySystems;
using Content.Shared.Timing;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Timing;
namespace Content.Server.IgnitionSource;
using Content.Shared.Body.Components;
using Content.Shared.Examine;
using Content.Shared.Popups;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Events;
using Content.Shared.Mobs.Components;
using Content.Shared.Mobs.Systems;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Random;
using Robust.Shared.Timing;
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly MobStateSystem _mobStateSystem = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
public override void Initialize()
{
if (curTime < component.LastInteractTime + component.InteractDelay)
return;
- if (TryComp<MobStateComponent>(uid, out var state) // if it has a MobStateComponent,
- && !_mobStateSystem.IsAlive(uid, state)) // AND if that state is not Alive (e.g. dead/incapacitated/critical)
+ if (TryComp<MobStateComponent>(uid, out var state)
+ && !_mobStateSystem.IsAlive(uid, state))
+ {
return;
+ }
// TODO: Should be an attempt event
// TODO: Need to handle pausing with an accumulator.
string msg = ""; // Stores the text to be shown in the popup message
- string? sfx = null; // Stores the filepath of the sound to be played
+ SoundSpecifier? sfx = null; // Stores the filepath of the sound to be played
if (_random.Prob(component.SuccessChance))
{
msg = Loc.GetString(component.InteractSuccessString, ("target", Identity.Entity(uid, EntityManager))); // Success message (localized).
if (component.InteractSuccessSound != null)
- sfx = component.InteractSuccessSound.GetSound();
+ sfx = component.InteractSuccessSound;
if (component.InteractSuccessSpawn != null)
Spawn(component.InteractSuccessSpawn, Transform(uid).MapPosition);
msg = Loc.GetString(component.InteractFailureString, ("target", Identity.Entity(uid, EntityManager))); // Failure message (localized).
if (component.InteractFailureSound != null)
- sfx = component.InteractFailureSound.GetSound();
+ sfx = component.InteractFailureSound;
if (component.InteractFailureSpawn != null)
Spawn(component.InteractFailureSpawn, Transform(uid).MapPosition);
if (component.MessagePerceivedByOthers != null)
{
- string msgOthers = Loc.GetString(component.MessagePerceivedByOthers,
+ var msgOthers = Loc.GetString(component.MessagePerceivedByOthers,
("user", Identity.Entity(args.User, EntityManager)), ("target", Identity.Entity(uid, EntityManager)));
_popupSystem.PopupEntity(msg, uid, args.User);
_popupSystem.PopupEntity(msgOthers, uid, Filter.PvsExcept(args.User, entityManager: EntityManager), true);
if (sfx is not null) //not all cases will have sound.
{
if (component.SoundPerceivedByOthers)
- SoundSystem.Play(sfx, Filter.Pvs(args.Target), args.Target); //play for everyone in range
+ _audio.PlayPvs(sfx, args.Target); //play for everyone in range
else
- SoundSystem.Play(sfx, Filter.Entities(args.User, args.Target), args.Target); //play only for the initiating entity and its target.
+ _audio.PlayEntity(sfx, Filter.Entities(args.User, args.Target), args.Target, true); //play only for the initiating entity and its target.
}
component.LastInteractTime = curTime;
using Content.Shared.Item;
using Content.Shared.Toggleable;
using Content.Shared.Tools.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Weapons.Melee.ItemToggle;
if (TryComp<DisarmMalusComponent>(uid, out var malus))
malus.Malus -= comp.ActivatedDisarmMalus;
- _audio.Play(comp.DeActivateSound, Filter.Pvs(uid, entityManager: EntityManager), uid, true, comp.DeActivateSound.Params);
+ _audio.PlayEntity(comp.DeActivateSound, Filter.Pvs(uid, entityManager: EntityManager), uid, true, comp.DeActivateSound.Params);
comp.Activated = false;
}
if (TryComp<DisarmMalusComponent>(uid, out var malus))
malus.Malus += comp.ActivatedDisarmMalus;
- _audio.Play(comp.ActivateSound, Filter.Pvs(uid, entityManager: EntityManager), uid, true, comp.ActivateSound.Params);
+ _audio.PlayEntity(comp.ActivateSound, Filter.Pvs(uid, entityManager: EntityManager), uid, true, comp.ActivateSound.Params);
comp.Activated = true;
}
[DataField("ItemBreakSound")]
public SoundSpecifier ItemBreakSound = new SoundPathSpecifier("/Audio/Effects/clang.ogg");
- public IPlayingAudioStream? PlayingStream { get; set; }
+ public EntityUid? PlayingStream;
+
[DataField("loopingSound")]
public SoundSpecifier LoopingSound = new SoundPathSpecifier("/Audio/Machines/microwave_loop.ogg");
#endregion
[DataField("juiceSound"), ViewVariables(VVAccess.ReadWrite)]
public SoundSpecifier JuiceSound { get; set; } = new SoundPathSpecifier("/Audio/Machines/juicer.ogg");
- public IPlayingAudioStream? AudioStream;
+ public EntityUid? AudioStream;
}
[Access(typeof(ReagentGrinderSystem)), RegisterComponent]
using Content.Shared.Popups;
using Content.Shared.Storage;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Random;
using static Content.Shared.Kitchen.Components.KitchenSpikeComponent;
QueueDel(gib);
}
- _audio.Play(component.SpikeSound, Filter.Pvs(uid), uid, true);
+ _audio.PlayEntity(component.SpikeSound, Filter.Pvs(uid), uid, true);
}
private bool TryGetPiece(EntityUid uid, EntityUid user, EntityUid used,
using Robust.Server.Containers;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Player;
SetAppearance(uid, MicrowaveVisualState.Cooking, microwaveComponent);
microwaveComponent.PlayingStream =
- _audio.PlayPvs(microwaveComponent.LoopingSound, uid, AudioParams.Default.WithLoop(true).WithMaxDistance(5));
+ _audio.PlayPvs(microwaveComponent.LoopingSound, uid, AudioParams.Default.WithLoop(true).WithMaxDistance(5)).Value.Entity;
}
private void OnCookStop(EntityUid uid, ActiveMicrowaveComponent component, ComponentShutdown args)
return;
SetAppearance(uid, MicrowaveVisualState.Idle, microwaveComponent);
- microwaveComponent.PlayingStream?.Stop();
+ microwaveComponent.PlayingStream = _audio.Stop(microwaveComponent.PlayingStream);
}
/// <summary>
using JetBrains.Annotations;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Timing;
if (active.EndTime > _timing.CurTime)
continue;
- reagentGrinder.AudioStream?.Stop();
+ reagentGrinder.AudioStream = _audioSystem.Stop(reagentGrinder.AudioStream);
RemCompDeferred<ActiveReagentGrinderComponent>(uid);
var inputContainer = _containerSystem.EnsureContainer<Container>(uid, SharedReagentGrinder.InputContainerId);
active.Program = program;
reagentGrinder.AudioStream = _audioSystem.PlayPvs(sound, uid,
- AudioParams.Default.WithPitchScale(1 / reagentGrinder.WorkTimeMultiplier)); //slightly higher pitched
+ AudioParams.Default.WithPitchScale(1 / reagentGrinder.WorkTimeMultiplier)).Value.Entity; //slightly higher pitched
_userInterfaceSystem.TrySendUiMessage(uid, ReagentGrinderUiKey.Key,
new ReagentGrinderWorkStartedMessage(program));
}
using Content.Shared.Research.Prototypes;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Prototypes;
using Robust.Shared.Timing;
using Content.Shared.Verbs;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Player;
using Robust.Shared.Utility;
namespace Content.Server.Light.EntitySystems
using Content.Shared.Rounding;
using Content.Shared.Toggleable;
using Content.Shared.Verbs;
+using JetBrains.Annotations;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.GameStates;
using Robust.Shared.Utility;
using Content.Shared.Throwing;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Light.EntitySystems
public sealed class LightBulbSystem : EntitySystem
{
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
public override void Initialize()
{
if (!Resolve(uid, ref bulb))
return;
- SoundSystem.Play(bulb.BreakSound.GetSound(), Filter.Pvs(uid), uid);
+ _audio.PlayPvs(bulb.BreakSound, uid);
}
private void UpdateAppearance(EntityUid uid, LightBulbComponent? bulb = null,
using Content.Shared.Popups;
using Content.Shared.Storage;
using JetBrains.Annotations;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
namespace Content.Server.Light.EntitySystems;
using Content.Shared.Temperature;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Light.EntitySystems
{
[Dependency] private readonly AtmosphereSystem _atmosphereSystem = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly SharedItemSystem _item = default!;
[Dependency] private readonly SharedPointLightSystem _lights = default!;
[Dependency] private readonly TransformSystem _transformSystem = default!;
var component = matchstick.Comp;
// Play Sound
- SoundSystem.Play(component.IgniteSound.GetSound(), Filter.Pvs(matchstick),
- matchstick, AudioHelpers.WithVariation(0.125f).WithVolume(-0.125f));
+ _audio.PlayPvs(component.IgniteSound, matchstick, AudioParams.Default.WithVariation(0.125f).WithVolume(-0.125f));
// Change state
SetState(matchstick, component, SmokableState.Lit);
using Robust.Shared.Containers;
using Robust.Shared.Player;
using Robust.Shared.Timing;
+using Content.Shared.DoAfter;
+using Content.Server.Emp;
+using Content.Server.DeviceLinking.Events;
+using Content.Server.DeviceLinking.Systems;
+using Content.Shared.Inventory;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Light.EntitySystems
{
if (damage != null)
_adminLogger.Add(LogType.Damaged, $"{ToPrettyString(args.User):user} burned their hand on {ToPrettyString(args.Target):target} and received {damage.Total:damage} damage");
- _audio.Play(light.BurnHandSound, Filter.Pvs(uid), uid, true);
+ _audio.PlayEntity(light.BurnHandSound, Filter.Pvs(uid), uid, true);
args.Handled = true;
return;
if (time > light.LastThunk + ThunkDelay)
{
light.LastThunk = time;
- _audio.Play(light.TurnOnSound, Filter.Pvs(uid), uid, true, AudioParams.Default.WithVolume(-10f));
+ _audio.PlayEntity(light.TurnOnSound, Filter.Pvs(uid), uid, true, AudioParams.Default.WithVolume(-10f));
}
}
else
private void OnPowerChanged(EntityUid uid, PoweredLightComponent component, ref PowerChangedEvent args)
{
// TODO: Power moment
- if (MetaData(uid).EntityPaused)
+ var metadata = MetaData(uid);
+
+ if (metadata.EntityPaused || TerminatingOrDeleted(uid, metadata))
return;
UpdateLight(uid, component);
using Content.Shared.Mind.Components;
using Content.Shared.Toggleable;
using Content.Shared.Verbs;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Robust.Shared.Utility;
using Content.Shared.Item;
using Content.Shared.Lube;
using Content.Shared.Popups;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Random;
namespace Content.Server.Lube;
using Content.Shared.Storage;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Random;
using Robust.Shared.Serialization.Manager;
using Content.Shared.MassMedia.Systems;
using Content.Shared.PDA;
using Robust.Server.GameObjects;
+using System.Linq;
+using Content.Server.Administration.Logs;
+using Content.Server.CartridgeLoader.Cartridges;
+using Content.Shared.CartridgeLoader;
+using Content.Shared.CartridgeLoader.Cartridges;
+using Content.Server.CartridgeLoader;
+using Content.Server.GameTicking;
+using Robust.Shared.Timing;
+using Content.Server.Popups;
+using Content.Server.StationRecords.Systems;
+using Content.Shared.Database;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Player;
using Robust.Shared.Timing;
using Content.Shared.Construction;
using Content.Shared.Database;
using JetBrains.Annotations;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Prototypes;
[DataField("grabSound")]
public SoundSpecifier GrabSound = new SoundPathSpecifier("/Audio/Mecha/sound_mecha_hydraulic.ogg");
- public IPlayingAudioStream? AudioStream;
+ public EntityUid? AudioStream;
[ViewVariables(VVAccess.ReadWrite)]
public Container ItemContainer = default!;
using Content.Shared.Mobs.Components;
using Content.Shared.Wall;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Physics;
return;
args.Handled = true;
- component.AudioStream = _audio.PlayPvs(component.GrabSound, uid);
+ component.AudioStream = _audio.PlayPvs(component.GrabSound, uid).Value.Entity;
_doAfter.TryStartDoAfter(new DoAfterArgs(EntityManager, args.User, component.GrabDelay, new GrabberDoAfterEvent(), uid, target: target, used: uid)
{
BreakOnTargetMove = true,
{
if (args.Cancelled)
{
- component.AudioStream?.Stop();
+ component.AudioStream = _audio.Stop(component.AudioStream);
return;
}
using Content.Shared.Popups;
using Content.Shared.Throwing;
using Robust.Server.Player;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Physics.Components;
using Robust.Shared.Random;
using Content.Shared.PowerCell;
using Content.Shared.Timing;
using Content.Shared.Toggleable;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Timing;
using Content.Shared.Mobs.Systems;
using Content.Shared.Stacks;
using Content.Server.Popups;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Random;
namespace Content.Server.Medical;
using Robust.Server.GameObjects;
using Content.Server.Temperature.Components;
using Content.Server.Body.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Medical
using Content.Shared.Nutrition.Components;
using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.StatusEffect;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Prototypes;
return;
Dirty(mindId, mind);
- _pvsOverride.ClearOverride(mindId);
+ var netMind = GetNetEntity(mindId);
+ _pvsOverride.ClearOverride(netMind);
if (userId != null && !_players.TryGetPlayerData(userId.Value, out _))
{
Log.Error($"Attempted to set mind user to invalid value {userId}");
if (_players.TryGetSessionById(userId.Value, out var ret))
{
mind.Session = ret;
- _pvsOverride.AddSessionOverride(mindId, ret);
+ _pvsOverride.AddSessionOverride(netMind, ret);
_players.SetAttachedEntity(ret, mind.CurrentEntity);
}
using Content.Shared.Storage.Components;
using Content.Shared.Verbs;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Morgue;
using Content.Shared.Examine;
using Content.Shared.Morgue;
using Content.Shared.Morgue.Components;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Morgue;
using Content.Shared.Interaction;
using Content.Shared.Popups;
using Content.Shared.Silicons.Bots;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Player;
namespace Content.Server.NPC.HTN.PrimitiveTasks.Operators.Specific;
using Content.Server.Interaction;
using Content.Server.Weapons.Ranged.Systems;
using Content.Shared.Weapons.Melee;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Random;
using Content.Shared.Ninja.Systems;
using Content.Shared.Popups;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Ninja.Systems;
using Robust.Shared.Player;
using Robust.Shared.Random;
using System.Diagnostics.CodeAnalysis;
+using System.Linq;
using Content.Server.Objectives.Components;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Ninja.Systems;
using Content.Shared.Whitelist;
using Robust.Shared.Audio;
using Robust.Shared.Prototypes;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Timing;
namespace Content.Server.Ninja.Systems;
/// </summary>
public bool PlayedAlertSound = false;
- public IPlayingAudioStream? AlertAudioStream = default;
+ public EntityUid? AlertAudioStream = default;
/// <summary>
/// The radius from the nuke for which there must be floor tiles for it to be anchorable.
using Content.Shared.Popups;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Player;
private void OnClearButtonPressed(EntityUid uid, NukeComponent component, NukeKeypadClearMessage args)
{
- _audio.Play(component.KeypadPressSound, Filter.Pvs(uid), uid, true);
+ _audio.PlayEntity(component.KeypadPressSound, Filter.Pvs(uid), uid, true);
if (component.Status != NukeStatus.AWAIT_CODE)
return;
{
component.Status = NukeStatus.AWAIT_ARM;
component.RemainingTime = component.Timer;
- _audio.Play(component.AccessGrantedSound, Filter.Pvs(uid), uid, true);
+ _audio.PlayEntity(component.AccessGrantedSound, Filter.Pvs(uid), uid, true);
}
else
{
component.EnteredCode = "";
- _audio.Play(component.AccessDeniedSound, Filter.Pvs(uid), uid, true);
+ _audio.PlayEntity(component.AccessDeniedSound, Filter.Pvs(uid), uid, true);
}
break;
// Don't double-dip on the octave shifting
component.LastPlayedKeypadSemitones = number == 0 ? component.LastPlayedKeypadSemitones : semitoneShift;
- _audio.Play(component.KeypadPressSound, Filter.Pvs(uid), uid, true, AudioHelpers.ShiftSemitone(semitoneShift).WithVolume(-5f));
+ _audio.PlayEntity(component.KeypadPressSound, Filter.Pvs(uid), uid, true, AudioHelpers.ShiftSemitone(semitoneShift).WithVolume(-5f));
}
public string GenerateRandomNumberString(int length)
// disable sound and reset it
component.PlayedAlertSound = false;
- component.AlertAudioStream?.Stop();
+ component.AlertAudioStream = _audio.Stop(component.AlertAudioStream);
// turn off the spinny light
_pointLight.SetEnabled(uid, false);
[DataField("processSound")]
public SoundSpecifier? ProcessSound;
- public IPlayingAudioStream? Stream;
+ public EntityUid? Stream;
/// <summary>
/// A minium hunger threshold for extracting nutrition.
using Content.Shared.Nutrition.Components;
using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Storage;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Random;
using Robust.Shared.Timing;
[Dependency] private readonly SharedTransformSystem _transform = default!;
private readonly HashSet<EntityUid> _failedAttempts = new();
+ private readonly HashSet<EntityUid> _birthQueue = new();
/// <inheritdoc/>
public override void Initialize()
{
base.Update(frameTime);
- HashSet<EntityUid> birthQueue = new();
+ _birthQueue.Clear();
_failedAttempts.Clear();
var query = EntityQueryEnumerator<ReproductiveComponent>();
{
if (reproductive.GestationEndTime != null && _timing.CurTime >= reproductive.GestationEndTime)
{
- birthQueue.Add(uid);
+ _birthQueue.Add(uid);
}
if (_timing.CurTime < reproductive.NextBreedAttempt)
TryReproduceNearby(uid, reproductive);
}
- foreach (var queued in birthQueue)
+ foreach (var queued in _birthQueue)
{
Birth(queued);
}
using JetBrains.Annotations;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Nutrition.EntitySystems
protected override void SplattedCreamPie(EntityUid uid, CreamPieComponent creamPie)
{
- _audio.Play(_audio.GetSound(creamPie.Sound), Filter.Pvs(uid), uid, false, new AudioParams().WithVariation(0.125f));
+ _audio.PlayPvs(_audio.GetSound(creamPie.Sound), uid, AudioParams.Default.WithVariation(0.125f));
if (EntityManager.TryGetComponent(uid, out FoodComponent? foodComp))
{
using Content.Shared.Throwing;
using Content.Shared.Verbs;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Content.Shared.Nutrition.Components;
using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Storage.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Timing;
namespace Content.Server.Nutrition.EntitySystems;
component.Processing = true;
_appearance.SetData(uid, FatExtractorVisuals.Processing, true);
- component.Stream = _audio.PlayPvs(component.ProcessSound, uid);
+ component.Stream = _audio.PlayPvs(component.ProcessSound, uid)?.Entity;
component.NextUpdate = _timing.CurTime + component.UpdateTime;
}
component.Processing = false;
_appearance.SetData(uid, FatExtractorVisuals.Processing, false);
- component.Stream?.Stop();
+ component.Stream = _audio.Stop(component.Stream);
}
public bool TryGetValidOccupant(EntityUid uid, [NotNullWhen(true)] out EntityUid? occupant, FatExtractorComponent? component = null, EntityStorageComponent? storage = null)
using Robust.Shared.Audio;
using Robust.Shared.Player;
using Robust.Shared.Utility;
+using Content.Shared.Tag;
+using Content.Shared.Storage;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Nutrition.EntitySystems;
_adminLogger.Add(LogType.Ingestion, LogImpact.Low, $"{ToPrettyString(args.User):target} ate {ToPrettyString(uid):food}");
}
- _audio.Play(component.UseSound, Filter.Pvs(args.Target.Value), args.Target.Value, true, AudioParams.Default.WithVolume(-1f));
+ _audio.PlayPvs(component.UseSound, args.Target.Value, AudioParams.Default.WithVolume(-1f));
// Try to break all used utensils
foreach (var utensil in utensils)
using Content.Shared.Nutrition.Components;
using Content.Shared.Popups;
using Content.Shared.Weapons.Melee.Events;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.GameObjects;
namespace Content.Server.Nutrition.EntitySystems;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Player;
namespace Content.Server.Nutrition.EntitySystems
{
- internal sealed class SliceableFoodSystem : EntitySystem
+ public sealed class SliceableFoodSystem : EntitySystem
{
[Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
- [Dependency] private readonly SharedHandsSystem _handsSystem = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly SharedContainerSystem _containerSystem = default!;
+ [Dependency] private readonly SharedHandsSystem _handsSystem = default!;
public override void Initialize()
{
xform.LocalRotation = 0;
}
- SoundSystem.Play(component.Sound.GetSound(), Filter.Pvs(uid),
- transform.Coordinates, AudioParams.Default.WithVolume(-2));
+ _audio.PlayPvs(component.Sound, transform.Coordinates, AudioParams.Default.WithVolume(-2));
// Decrease size of item based on count - Could implement in the future
// Bug with this currently is the size in a container is not updated
using Content.Server.Popups;
using Content.Shared.Interaction;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Random;
[Dependency] private readonly IRobustRandom _robustRandom = default!;
[Dependency] private readonly FoodSystem _foodSystem = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
public override void Initialize()
if (_robustRandom.Prob(component.BreakChance))
{
- SoundSystem.Play(component.BreakSound.GetSound(), Filter.Pvs(userUid), userUid, AudioParams.Default.WithVolume(-2f));
- EntityManager.DeleteEntity(component.Owner);
+ _audio.PlayPvs(component.BreakSound, userUid, AudioParams.Default.WithVolume(-2f));
+ EntityManager.DeleteEntity(uid);
}
}
}
using Robust.Shared.Random;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
+using System.Linq;
+using Robust.Server.Audio;
namespace Content.Server.PDA.Ringer
{
ringer.TimeElapsed -= NoteDelay;
var ringerXform = Transform(uid);
- _audio.Play(
+ _audio.PlayEntity(
GetSound(ringer.Ringtone[ringer.NoteCount]),
Filter.Empty().AddInRange(ringerXform.MapPosition, ringer.Range),
uid,
using Content.Shared.Tag;
using Robust.Server.GameObjects;
using Robust.Shared.Player;
+using Robust.Shared.Utility;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using static Content.Shared.Paper.SharedPaperComponent;
namespace Content.Server.Paper
using Content.Server.Administration.Managers;
using Content.Shared.CCVar;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Timing;
using Robust.Shared.Player;
[Dependency] private readonly IAdminManager _adminManager = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly IGameTiming _timing = default!;
+
private void InitializeControlBoxSystem()
{
SubscribeLocalEvent<ParticleAcceleratorControlBoxComponent, ComponentStartup>(OnComponentStartup);
using Content.Shared.Interaction.Events;
using Content.Shared.Pinpointer;
using Content.Shared.PowerCell;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Timing;
using Content.Shared.Audio;
using Content.Shared.Interaction;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Plants.Systems
{
public sealed class PottedPlantHideSystem : EntitySystem
{
- [Dependency] private readonly SecretStashSystem _stashSystem = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
+ [Dependency] private readonly SecretStashSystem _stashSystem = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
public override void Initialize()
{
if (!Resolve(uid, ref component))
return;
- SoundSystem.Play(component.RustleSound.GetSound(), Filter.Pvs(uid), uid, AudioHelpers.WithVariation(0.25f));
+ _audio.PlayPvs(component.RustleSound, uid, AudioParams.Default.WithVariation(0.25f));
}
}
}
private void OnStartup(EntityUid uid, PointManagerComponent component, ComponentStartup args)
{
- _pvsOverride.AddGlobalOverride(uid);
+ _pvsOverride.AddGlobalOverride(GetNetEntity(uid));
}
/// <summary>
using Content.Shared.Polymorph;
using Content.Shared.Popups;
using JetBrains.Annotations;
+using Robust.Server.Audio;
using Robust.Server.Containers;
using Robust.Server.GameObjects;
using Robust.Shared.Map;
using Content.Shared.Popups;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Timing;
namespace Content.Server.Power.EntitySystems;
using Content.Shared.Hands.Components;
using Content.Shared.Power;
using Content.Shared.Verbs;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Utility;
using Content.Shared.DoAfter;
using Content.Shared.Power.Generator;
using Content.Shared.Verbs;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Player;
using Robust.Shared.Random;
var clogged = _generator.GetIsClogged(uid);
var sound = empty ? component.StartSoundEmpty : component.StartSound;
- _audio.Play(sound, Filter.Pvs(uid), uid, true);
+ _audio.PlayEntity(sound, Filter.Pvs(uid), uid, true);
if (!clogged && !empty && _random.Prob(component.StartChance))
{
using Content.Shared.Power.Generator;
using Content.Shared.Timing;
using Content.Shared.Verbs;
-using Robust.Server.GameObjects;
-using Robust.Shared.Player;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Utility;
namespace Content.Server.Power.Generator;
/// <seealso cref="GeneratorSystem"/>
public sealed class PowerSwitchableSystem : SharedPowerSwitchableSystem
{
- [Dependency] private readonly AudioSystem _audio = default!;
[Dependency] private readonly NodeGroupSystem _nodeGroup = default!;
[Dependency] private readonly PopupSystem _popup = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly UseDelaySystem _useDelay = default!;
public override void Initialize()
using Content.Server.Station.Systems;
using Robust.Shared.Timing;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.PowerSink
{
using Content.Shared.Inventory.Events;
using Content.Shared.Radiation.Components;
using Content.Shared.Radiation.Systems;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Server.Player;
if (!Resolve(uid, ref component, false))
return;
- component.Stream?.Stop();
+ component.Stream = _audio.Stop(component.Stream);
if (!component.Sounds.TryGetValue(component.DangerLevel, out var sounds))
return;
var sound = _audio.GetSound(sounds);
var param = sounds.Params.WithLoop(true).WithVolume(-4f);
- component.Stream = _audio.PlayGlobal(sound, session, param);
+ component.Stream = _audio.PlayGlobal(sound, session, param)?.Entity;
}
public static GeigerDangerLevel RadsToLevel(float rads)
using Content.Server.UserInterface;
using Content.Shared.Research;
using Content.Shared.Research.Components;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
using Robust.Shared.Timing;
using Content.Shared.Database;
using Content.Shared.GameTicking;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
[Dependency] private readonly ChatSystem _chatSystem = default!;
[Dependency] private readonly GameTicker _gameTicker = default!;
[Dependency] private readonly EmergencyShuttleSystem _shuttle = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly StationSystem _stationSystem = default!;
public TimeSpan DefaultCooldownDuration { get; set; } = TimeSpan.FromSeconds(30);
null,
Color.Gold);
- SoundSystem.Play("/Audio/Announcements/shuttlecalled.ogg", Filter.Broadcast());
+ _audio.PlayGlobal("/Audio/Announcements/shuttlecalled.ogg", Filter.Broadcast(), true);
LastCountdownStart = _gameTiming.CurTime;
ExpectedCountdownEnd = _gameTiming.CurTime + countdownTime;
_chatSystem.DispatchGlobalAnnouncement(Loc.GetString("round-end-system-shuttle-recalled-announcement"),
Loc.GetString("Station"), false, colorOverride: Color.Gold);
- SoundSystem.Play("/Audio/Announcements/shuttlerecalled.ogg", Filter.Broadcast());
+ _audio.PlayGlobal("/Audio/Announcements/shuttlerecalled.ogg", Filter.Broadcast(), true);
LastCountdownStart = null;
ExpectedCountdownEnd = null;
/// <summary>
/// Countdown audio stream.
/// </summary>
- public IPlayingAudioStream? Stream = null;
+ public EntityUid? Stream = null;
/// <summary>
/// Sound that plays when the mission end is imminent.
private void OnExpeditionShutdown(EntityUid uid, SalvageExpeditionComponent component, ComponentShutdown args)
{
- component.Stream?.Stop();
+ component.Stream = _audio.Stop(component.Stream);
foreach (var (job, cancelToken) in _salvageJobs.ToArray())
{
else if (comp.Stage < ExpeditionStage.MusicCountdown && remaining < TimeSpan.FromMinutes(2))
{
// TODO: Some way to play audio attached to a map for players.
- comp.Stream = _audio.PlayGlobal(comp.Sound, Filter.BroadcastMap(Comp<MapComponent>(uid).MapId), true);
+ comp.Stream = _audio.PlayGlobal(comp.Sound, Filter.BroadcastMap(Comp<MapComponent>(uid).MapId), true).Value.Entity;
comp.Stage = ExpeditionStage.MusicCountdown;
Dirty(uid, comp);
Announce(uid, Loc.GetString("salvage-expedition-announcement-countdown-minutes", ("duration", TimeSpan.FromMinutes(2).Minutes)));
using Content.Shared.Random.Helpers;
using Content.Shared.Tools.Components;
using Robust.Server.Maps;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map.Components;
using Robust.Shared.Timing;
Params = AudioParams.Default.WithVolume(-3f).WithLoop(true)
};
- public IPlayingAudioStream? TravelStream;
+ public EntityUid? TravelStream;
}
using Content.Shared.Tiles;
using Robust.Server.GameObjects;
using Robust.Server.Maps;
+using Robust.Server.Player;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
component = AddComp<FTLComponent>(uid);
component.State = FTLState.Starting;
- // TODO: Need BroadcastGrid to not be bad.
- SoundSystem.Play(_startupSound.GetSound(), Filter.Empty().AddInRange(Transform(uid).MapPosition, GetSoundRange(uid)), _startupSound.Params);
+ _audio.PlayPvs(_startupSound, uid);
// Make sure the map is setup before we leave to avoid pop-in (e.g. parallax).
SetupHyperspace();
return true;
var ev = new FTLStartedEvent(uid, target, fromMapUid, fromMatrix, fromRotation);
RaiseLocalEvent(uid, ref ev, true);
- if (comp.TravelSound != null)
- {
- comp.TravelStream = SoundSystem.Play(comp.TravelSound.GetSound(),
- Filter.Pvs(uid, 4f, entityManager: EntityManager), comp.TravelSound.Params);
- }
+ comp.TravelStream = _audio.PlayPvs(comp.TravelSound, uid)?.Entity;
+
break;
// Arriving, play effects
case FTLState.Travelling:
_thruster.DisableLinearThrusters(shuttle);
}
- if (comp.TravelStream != null)
- {
- comp.TravelStream?.Stop();
- comp.TravelStream = null;
- }
-
- _audio.PlayGlobal(_arrivalSound, Filter.Empty().AddInRange(Transform(uid).MapPosition, GetSoundRange(uid)), true);
+ comp.TravelStream = _audio.Stop(comp.TravelStream);
+ _audio.PlayPvs(_arrivalSound, uid);
if (TryComp<FTLDestinationComponent>(uid, out var dest))
{
var volume = MathF.Min(10f, 1f * MathF.Pow(jungleDiff, 0.5f) - 5f);
var audioParams = AudioParams.Default.WithVariation(SharedContentAudioSystem.DefaultVariation).WithVolume(volume);
- _audio.Play(_shuttleImpactSound, Filter.Pvs(coordinates, rangeMultiplier: 4f, entityMan: EntityManager), coordinates, true, audioParams);
+ _audio.PlayPvs(_shuttleImpactSound, coordinates, audioParams);
}
}
using Content.Shared.Throwing;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Content.Shared.Stunnable;
using Content.Shared.Wires;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Toolshed;
using Content.Shared.Singularity.EntitySystems;
using Content.Shared.Singularity.Events;
using Robust.Server.GameStates;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.GameStates;
using Robust.Shared.Player;
using Robust.Shared.Timing;
MetaDataComponent? metaData = null;
if (Resolve(uid, ref metaData) && metaData.EntityLifeStage <= EntityLifeStage.Initializing)
- _audio.Play(comp.FormationSound, Filter.Pvs(uid), uid, true);
+ _audio.PlayPvs(comp.FormationSound, uid);
- comp.AmbientSoundStream = _audio.Play(comp.AmbientSound, Filter.Pvs(uid), uid, true);
+ comp.AmbientSoundStream = _audio.PlayPvs(comp.AmbientSound, uid)?.Entity;
UpdateSingularityLevel(uid, comp);
}
/// <param name="args">The event arguments.</param>
public void OnDistortionStartup(EntityUid uid, SingularityDistortionComponent comp, ComponentStartup args)
{
- _pvs.AddGlobalOverride(uid);
+ _pvs.AddGlobalOverride(GetNetEntity(uid));
}
/// <summary>
/// <param name="args">The event arguments.</param>
public void OnSingularityShutdown(EntityUid uid, SingularityComponent comp, ComponentShutdown args)
{
- comp.AmbientSoundStream?.Stop();
+ comp.AmbientSoundStream = _audio.Stop(comp.AmbientSoundStream);
MetaDataComponent? metaData = null;
if (Resolve(uid, ref metaData) && metaData.EntityLifeStage >= EntityLifeStage.Terminating)
- _audio.Play(comp.DissipationSound, Filter.Pvs(uid), uid, true);
+ {
+ var xform = Transform(uid);
+ var coordinates = xform.Coordinates;
+
+ // I feel like IsValid should be checking this or something idk.
+ if (!TerminatingOrDeleted(coordinates.EntityId))
+ _audio.PlayPvs(comp.DissipationSound, coordinates);
+ }
}
/// <summary>
using Content.Shared.Chat.Prototypes;
using Content.Shared.Humanoid;
using Content.Shared.Speech;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Content.Server.Chat;
using Content.Server.Chat.Systems;
using Content.Shared.Speech;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Timing;
[Dependency] private readonly IGameTiming _gameTiming = default!;
[Dependency] private readonly IPrototypeManager _protoManager = default!;
[Dependency] private readonly IRobustRandom _random = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
public override void Initialize()
{
var pitchedAudioParams = component.AudioParams.WithPitchScale(scale);
component.LastTimeSoundPlayed = currentTime;
- SoundSystem.Play(contextSound, Filter.Pvs(uid, entityManager: EntityManager), uid, pitchedAudioParams);
+ _audio.PlayPvs(contextSound, uid, pitchedAudioParams);
}
}
}
using Content.Shared.Interaction;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.SprayPainter;
using Content.Server.Station.Systems;
using Content.Server.StationEvents.Components;
using Content.Shared.Database;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Collections;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Audio;
using Robust.Shared.Player;
using Robust.Shared.Random;
+using System.Linq;
+using Content.Shared.Storage.Components;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Storage.EntitySystems;
{
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly EntityStorageSystem _entityStorage = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
public override void Initialize()
{
storage.Contents.Remove(entity);
_entityStorage.AddToContents(entity, lockerEnt);
}
- SoundSystem.Play(component.CursedSound.GetSound(), Filter.Pvs(uid), uid, AudioHelpers.WithVariation(0.125f, _random));
+
+ _audio.PlayPvs(component.CursedSound, uid, AudioHelpers.WithVariation(0.125f, _random));
}
}
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction.Events;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Player;
using Robust.Shared.Random;
[Dependency] private readonly IAdminLogManager _adminLogger = default!;
[Dependency] private readonly SharedHandsSystem _hands = default!;
[Dependency] private readonly PricingSystem _pricing = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
public override void Initialize()
{
}
if (component.Sound != null)
- SoundSystem.Play(component.Sound.GetSound(), Filter.Pvs(uid), uid);
+ {
+ _audio.PlayPvs(component.Sound, uid);
+ }
component.Uses--;
UpdateAppearance((uid, storageComp, null));
if (storageComp.StorageCloseSound is not null)
- Audio.Play(storageComp.StorageCloseSound, Filter.Pvs(uid, entityManager: EntityManager), uid, true, storageComp.StorageCloseSound.Params);
+ Audio.PlayEntity(storageComp.StorageCloseSound, Filter.Pvs(uid, entityManager: EntityManager), uid, true, storageComp.StorageCloseSound.Params);
}
}
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Store;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Store.Systems;
using Content.Shared.Toggleable;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
namespace Content.Server.Stunnable.Systems
[Dependency] private readonly RiggableSystem _riggableSystem = default!;
[Dependency] private readonly SharedPopupSystem _popup = default!;
[Dependency] private readonly BatterySystem _battery = default!;
- [Dependency] private readonly AudioSystem _audio = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
public override void Initialize()
{
private void TurnOn(EntityUid uid, StunbatonComponent comp, EntityUid user)
{
-
if (comp.Activated)
return;
using Content.Server.Chat.Systems;
using Content.Shared.Speech;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Robust.Shared.Timing;
using Content.Shared.Interaction.Events;
using Content.Shared.Teleportation.Components;
using Content.Shared.Teleportation.Systems;
+using Robust.Server.Audio;
using Robust.Server.GameObjects;
namespace Content.Server.Teleportation;
using Content.Shared.Tools.Components;
using Content.Shared.Verbs;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Random;
using SharedToolSystem = Content.Shared.Tools.Systems.SharedToolSystem;
using Content.Shared.Maps;
using Content.Shared.Tools;
using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using SharedToolSystem = Content.Shared.Tools.Systems.SharedToolSystem;
using Content.Shared.Popups;
using Content.Shared.Tag;
using Content.Shared.Weapons.Melee.Events;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Weapons.Melee.Balloon;
using Content.Shared.Weapons.Melee.Events;
using Content.Shared.Wieldable;
using Content.Shared.Wieldable.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Random;
if (comp.IsSharp)
RemComp<SharpComponent>(uid);
- _audio.Play(comp.DeActivateSound, Filter.Pvs(uid, entityManager: EntityManager), uid, true, comp.DeActivateSound.Params);
+ _audio.PlayEntity(comp.DeActivateSound, Filter.Pvs(uid, entityManager: EntityManager), uid, true, comp.DeActivateSound.Params);
comp.Activated = false;
}
malus.Malus += comp.LitDisarmMalus;
}
- _audio.Play(comp.ActivateSound, Filter.Pvs(uid, entityManager: EntityManager), uid, true, comp.ActivateSound.Params);
+ _audio.PlayEntity(comp.ActivateSound, Filter.Pvs(uid, entityManager: EntityManager), uid, true, comp.ActivateSound.Params);
comp.Activated = true;
}
using Content.Shared.Weapons.Melee.Events;
using Robust.Shared.Random;
using Content.Shared.Cluwne;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Weapons.Melee.WeaponRandom;
using Content.Shared.Tools.Components;
using Content.Shared.Wires;
using Robust.Server.GameObjects;
+using Robust.Server.Player;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Prototypes;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
using Content.Shared.CCVar;
using Content.Shared.Xenoarchaeology.XenoArtifacts;
using JetBrains.Annotations;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Random;
using Robust.Shared.Timing;
using Content.Server.Xenoarchaeology.XenoArtifacts.Events;
using Content.Shared.Humanoid;
using Content.Shared.Mobs.Systems;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Xenoarchaeology.XenoArtifacts.Effects.Systems;
using Content.Shared.Zombies;
using Robust.Shared.Audio;
using Content.Shared.Prying.Components;
+using Robust.Shared.Audio.Systems;
namespace Content.Server.Zombies
{
using Content.Shared.Interaction;
using Content.Shared.Inventory.Events;
using Content.Shared.Mind;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.GameStates;
using Robust.Shared.Map;
using Content.Shared.Interaction;
using Content.Shared.Popups;
using Content.Shared.Weapons.Melee.Events;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Network;
using Robust.Shared.Random;
using Robust.Shared.Timing;
ambience.Enabled = value;
QueueUpdate(uid, ambience);
- Dirty(ambience);
+ Dirty(uid, ambience);
}
public virtual void SetRange(EntityUid uid, float value, AmbientSoundComponent? ambience = null)
ambience.Range = value;
QueueUpdate(uid, ambience);
- Dirty(ambience);
+ Dirty(uid, ambience);
}
protected virtual void QueueUpdate(EntityUid uid, AmbientSoundComponent ambience)
return;
ambience.Volume = value;
- Dirty(ambience);
+ Dirty(uid, ambience);
}
public virtual void SetSound(EntityUid uid, SoundSpecifier sound, AmbientSoundComponent? ambience = null)
ambience.Sound = sound;
QueueUpdate(uid, ambience);
- Dirty(ambience);
+ Dirty(uid, ambience);
}
private void HandleCompState(EntityUid uid, AmbientSoundComponent component, ref ComponentHandleState args)
using Content.Shared.Physics;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Shared.Audio;
public abstract class SharedContentAudioSystem : EntitySystem
{
- [Dependency] private readonly SharedAudioSystem _audio = default!;
+ [Dependency] protected readonly SharedAudioSystem Audio = default!;
/// <summary>
/// Standard variation to use for sounds.
public override void Initialize()
{
base.Initialize();
- _audio.OcclusionCollisionMask = (int) CollisionGroup.Impassable;
+ Audio.OcclusionCollisionMask = (int) CollisionGroup.Impassable;
}
}
using Content.Shared.Damage;
using Content.Shared.Damage.Prototypes;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
namespace Content.Shared.Blocking;
if (blocking.IsBlocking)
{
- _audio.PlayPvs(blocking.BlockSound, uid, AudioParams.Default.WithVariation(0.2f));
+ _audio.PlayPvs(blocking.BlockSound, uid);
}
}
}
/// <summary>
/// The sound to be played when you get hit while actively blocking
/// </summary>
- [DataField("blockSound")]
- public SoundSpecifier BlockSound = new SoundPathSpecifier("/Audio/Weapons/block_metal1.ogg");
+ [DataField("blockSound")] public SoundSpecifier BlockSound =
+ new SoundPathSpecifier("/Audio/Weapons/block_metal1.ogg")
+ {
+ Params = AudioParams.Default.WithVariation(0.25f)
+ };
/// <summary>
/// Fraction of original damage shield will take instead of user
_joints.RefreshRelay(buckleUid);
Appearance.SetData(strapUid, StrapVisuals.State, strapComp.BuckledEntities.Count != 0);
- var audioSourceUid = userUid != buckleUid ? userUid : strapUid;
- _audio.PlayPredicted(strapComp.UnbuckleSound, strapUid, audioSourceUid);
+
+ // TODO: Buckle listening to moveevents is sussy anyway.
+ if (!TerminatingOrDeleted(strapUid))
+ _audio.PlayPredicted(strapComp.UnbuckleSound, strapUid, userUid);
var ev = new BuckleChangeEvent(strapUid, buckleUid, false);
RaiseLocalEvent(buckleUid, ref ev);
using Content.Shared.Popups;
using Content.Shared.Pulling;
using Content.Shared.Standing;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Network;
public static readonly CVarDef<float> AmbienceVolume =
CVarDef.Create("ambience.volume", 0.0f, CVar.ARCHIVE | CVar.CLIENTONLY);
+ public const float MasterMultiplier = 2f;
+
// Midi is on engine so deal
public const float MidiMultiplier = 3f;
using Content.Shared.Lock;
using Content.Shared.Verbs;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
return;
cabinet.Opened = !cabinet.Opened;
- Dirty(cabinet);
+ Dirty(uid, cabinet);
_itemSlots.SetLock(uid, cabinet.CabinetSlot, !cabinet.Opened);
if (_timing.IsFirstTimePredicted)
using Content.Shared.Buckle.Components;
using Content.Shared.Movement.Events;
using Content.Shared.StepTrigger.Systems;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Network;
using Robust.Shared.Physics.Components;
using Robust.Shared.Timing;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Database;
using Content.Shared.FixedPoint;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Prototypes;
namespace Content.Shared.Chemistry.Reaction
using Content.Shared.Interaction.Components;
using Content.Shared.Popups;
using Content.Shared.Stunnable;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Player;
using Robust.Shared.Serialization;
using Content.Shared.Popups;
using Content.Shared.Stunnable;
using Content.Shared.Verbs;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Collision.Shapes;
using Robust.Shared.Physics.Components;
using Content.Shared.Interaction.Events;
using Content.Shared.Popups;
using Content.Shared.Verbs;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.GameStates;
using Robust.Shared.Network;
using Content.Shared.Stunnable;
using Content.Shared.Verbs;
using Content.Shared.Weapons.Melee.Events;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Network;
using Robust.Shared.Player;
using Content.Shared.Damage.Components;
using Content.Shared.Effects;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Physics.Events;
using Robust.Shared.Player;
using Robust.Shared.Random;
using Content.Shared.Weapons.Melee.Events;
using JetBrains.Annotations;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Network;
using Robust.Shared.Player;
using Robust.Shared.Random;
using Content.Shared.Mobs;
using Content.Shared.Mobs.Components;
using Content.Shared.Popups;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Serialization;
using Content.Shared.Doors.Components;
using Content.Shared.Popups;
using Content.Shared.Prying.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Shared.Doors.Systems;
using Robust.Shared.Physics.Events;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Timing;
+using Content.Shared.Prying.Components;
+using Robust.Shared.Audio.Systems;
namespace Content.Shared.Doors.Systems;
using Content.Shared.Popups;
using Content.Shared.Strip.Components;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Network;
using Robust.Shared.Player;
[Dependency] private readonly MovementSpeedModifierSystem _movementSpeed = default!;
[Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
[Dependency] private readonly SharedItemSystem _item = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly SharedContainerSystem _containerSystem = default!;
[Dependency] private readonly SharedHandsSystem _handsSystem = default!;
[Dependency] private readonly IGameTiming _gameTiming = default!;
filter.RemoveWhereAttachedEntity(entity => entity == actor);
}
- SoundSystem.Play(clothing.EquipSound.GetSound(), filter, target, clothing.EquipSound.Params.WithVolume(-2f));
+ _audio.PlayPredicted(clothing.EquipSound, target, actor);
}
- inventory.Dirty();
+ Dirty(target, inventory);
_movementSpeed.RefreshMovementSpeedModifiers(target);
filter.RemoveWhereAttachedEntity(entity => entity == actor);
}
- SoundSystem.Play(clothing.UnequipSound.GetSound(), filter, target, clothing.UnequipSound.Params.WithVolume(-2f));
+ _audio.PlayPredicted(clothing.UnequipSound, target, actor);
}
Dirty(target, inventory);
+
_movementSpeed.RefreshMovementSpeedModifiers(target);
return true;
using Content.Shared.Item;
using Content.Shared.Light.Components;
using Content.Shared.Toggleable;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.GameStates;
namespace Content.Shared.Light;
/// The sound played when unlocked.
/// </summary>
[DataField("unlockingSound"), ViewVariables(VVAccess.ReadWrite)]
- public SoundSpecifier UnlockSound = new SoundPathSpecifier("/Audio/Machines/door_lock_off.ogg");
+ public SoundSpecifier UnlockSound = new SoundPathSpecifier("/Audio/Machines/door_lock_off.ogg")
+ {
+ Params = AudioParams.Default.WithVolume(-5f),
+ };
/// <summary>
/// The sound played when locked.
/// </summary>
[DataField("lockingSound"), ViewVariables(VVAccess.ReadWrite)]
- public SoundSpecifier LockSound = new SoundPathSpecifier("/Audio/Machines/door_lock_on.ogg");
+ public SoundSpecifier LockSound = new SoundPathSpecifier("/Audio/Machines/door_lock_on.ogg")
+ {
+ Params = AudioParams.Default.WithVolume(-5f)
+ };
/// <summary>
/// Whether or not an emag disables it.
using Content.Shared.Verbs;
using JetBrains.Annotations;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Utility;
namespace Content.Shared.Lock;
_sharedPopupSystem.PopupClient(Loc.GetString("lock-comp-do-lock-success",
("entityName", Identity.Name(uid, EntityManager))), uid, user);
- _audio.PlayPredicted(lockComp.LockSound, uid, user, AudioParams.Default.WithVolume(-5));
+ _audio.PlayPredicted(lockComp.LockSound, uid, user);
lockComp.Locked = true;
_appearanceSystem.SetData(uid, StorageVisuals.Locked, true);
- Dirty(lockComp);
+ Dirty(uid, lockComp);
var ev = new LockToggledEvent(true);
RaiseLocalEvent(uid, ref ev, true);
("entityName", Identity.Name(uid, EntityManager))), uid, user.Value);
}
- _audio.PlayPredicted(lockComp.UnlockSound, uid, user, AudioParams.Default.WithVolume(-5));
+ _audio.PlayPredicted(lockComp.UnlockSound, uid, user);
lockComp.Locked = false;
_appearanceSystem.SetData(uid, StorageVisuals.Locked, false);
- Dirty(lockComp);
+ Dirty(uid, lockComp);
var ev = new LockToggledEvent(false);
RaiseLocalEvent(uid, ref ev, true);
{
if (!component.Locked || !component.BreakOnEmag)
return;
- _audio.PlayPredicted(component.UnlockSound, uid, null, AudioParams.Default.WithVolume(-5));
+ _audio.PlayPredicted(component.UnlockSound, uid, null);
_appearanceSystem.SetData(uid, StorageVisuals.Locked, false);
RemComp<LockComponent>(uid); //Literally destroys the lock as a tell it was emagged
args.Handled = true;
[DataField]
public TimeSpan SoundCooldown = TimeSpan.FromSeconds(0.8f);
- public IPlayingAudioStream? Stream;
+ public EntityUid? Stream;
/// <summary>
/// A counter of how many items have been processed
using Content.Shared.Examine;
using Content.Shared.Mobs.Components;
using Content.Shared.Stacks;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Physics.Events;
using Robust.Shared.Timing;
private void OnShutdown(EntityUid uid, MaterialReclaimerComponent component, ComponentShutdown args)
{
- component.Stream?.Stop();
+ _audio.Stop(component.Stream);
}
private void OnUnpaused(EntityUid uid, MaterialReclaimerComponent component, ref EntityUnpausedEvent args)
if (Timing.CurTime > component.NextSound)
{
- component.Stream = _audio.PlayPredicted(component.Sound, uid, user);
-
+ component.Stream = _audio.PlayPredicted(component.Sound, uid, user)?.Entity;
component.NextSound = Timing.CurTime + component.SoundCooldown;
}
component.ItemsProcessed++;
if (component.CutOffSound)
- component.Stream?.Stop();
+ {
+ _audio.Stop(component.Stream);
+ }
- Dirty(component);
+ Dirty(uid, component);
}
/// <summary>
return;
component.Enabled = enabled;
AmbientSound.SetAmbience(uid, enabled && component.Powered);
- Dirty(component);
+ Dirty(uid, component);
}
/// <summary>
using Content.Shared.Timing;
using Robust.Shared.Audio;
using System.Linq;
+using Robust.Shared.Audio.Systems;
namespace Content.Shared.Mech.Equipment.Systems;
using Content.Shared.Pulling.Components;
using Content.Shared.Tag;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Configuration;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Content.Shared.Ninja.Components;
using Content.Shared.Physics;
using Content.Shared.Popups;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Timing;
namespace Content.Shared.Ninja.Systems;
using Content.Shared.Inventory.Events;
using Content.Shared.Ninja.Components;
using Content.Shared.Timing;
+using Robust.Shared.Audio.Systems;
namespace Content.Shared.Ninja.Systems;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction;
using Content.Shared.Throwing;
+using Content.Shared.Weapons.Ranged.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Network;
using Robust.Shared.Physics;
using System.Diagnostics.CodeAnalysis;
using Content.Shared.Interaction;
using Content.Shared.Popups;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using PryUnpoweredComponent = Content.Shared.Prying.Components.PryUnpoweredComponent;
namespace Content.Shared.Prying.Systems;
using Content.Shared.Tag;
using Content.Shared.Tiles;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Network;
/// Current stream of geiger counter audio.
/// Played only for current user.
/// </summary>
- public IPlayingAudioStream? Stream;
+ public EntityUid? Stream;
}
[Serializable, NetSerializable]
using Content.Shared.Tools;
using Content.Shared.Tools.Components;
using Content.Shared.Wires;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Network;
using Robust.Shared.Prototypes;
using Content.Shared.Random;
using Content.Shared.Random.Helpers;
using Content.Shared.Verbs;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Network;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Content.Shared.Mind;
using Content.Shared.Roles.Jobs;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Prototypes;
namespace Content.Shared.Roles;
using Content.Shared.Popups;
using Content.Shared.Stacks;
using Content.Shared.Verbs;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Prototypes;
/// <summary>
/// Sound to play when the bot has been emagged
/// </summary>
- [DataField("sparkSound")]
- public SoundSpecifier SparkSound = new SoundCollectionSpecifier("sparks");
+ [DataField("sparkSound")] public SoundSpecifier SparkSound = new SoundCollectionSpecifier("sparks")
+ {
+ Params = AudioParams.Default.WithVolume(8f),
+ };
}
using Content.Shared.Emag.Systems;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
namespace Content.Shared.Silicons.Bots;
if (!TryComp<MedibotComponent>(uid, out var medibot))
return;
- _audio.PlayPredicted(comp.SparkSound, uid, args.UserUid, AudioParams.Default.WithVolume(8));
+ _audio.PlayPredicted(comp.SparkSound, uid, args.UserUid);
medibot.StandardMed = comp.StandardMed;
medibot.StandardMedAmount = comp.StandardMedAmount;
/// The audio stream that plays the sound specified by <see cref="AmbientSound"/> on loop.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
- public IPlayingAudioStream? AmbientSoundStream = null;
+ public EntityUid? AmbientSoundStream = null;
/// <summary>
/// The sound that the singularity produces when it forms.
using Content.Shared.StepTrigger.Systems;
using Content.Shared.Stunnable;
using JetBrains.Annotations;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Systems;
using Content.Shared.Throwing;
using JetBrains.Annotations;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Network;
using Robust.Shared.Physics.Components;
public override void Initialize()
{
base.Initialize();
- SubscribeLocalEvent<EmitSoundOnSpawnComponent, ComponentInit>(OnEmitSpawnOnInit);
+ SubscribeLocalEvent<EmitSoundOnSpawnComponent, MapInitEvent>(OnEmitSpawnOnInit);
SubscribeLocalEvent<EmitSoundOnLandComponent, LandEvent>(OnEmitSoundOnLand);
SubscribeLocalEvent<EmitSoundOnUseComponent, UseInHandEvent>(OnEmitSoundOnUseInHand);
SubscribeLocalEvent<EmitSoundOnThrowComponent, ThrownEvent>(OnEmitSoundOnThrown);
SubscribeLocalEvent<EmitSoundOnCollideComponent, StartCollideEvent>(OnEmitSoundOnCollide);
}
- private void OnEmitSpawnOnInit(EntityUid uid, EmitSoundOnSpawnComponent component, ComponentInit args)
+ private void OnEmitSpawnOnInit(EntityUid uid, EmitSoundOnSpawnComponent component, MapInitEvent args)
{
TryEmitSound(uid, component, predict: false);
}
var fraction = MathF.Min(1f, (physics.LinearVelocity.Length() - component.MinimumVelocity) / MaxVolumeVelocity);
var volume = MinVolume + (MaxVolume - MinVolume) * fraction;
component.NextSound = _timing.CurTime + EmitSoundOnCollideComponent.CollideCooldown;
+ var sound = component.Sound;
- if (_netMan.IsServer)
- _audioSystem.PlayPvs(component.Sound, uid, AudioParams.Default.WithVolume(volume));
+ if (_netMan.IsServer && sound != null)
+ {
+ _audioSystem.PlayPvs(_audioSystem.GetSound(sound), uid, AudioParams.Default.WithVolume(volume));
+ }
}
}
using Content.Shared.Physics;
using Content.Shared.Rotation;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Systems;
if (playSound)
{
- _audio.PlayPredicted(standingState.DownSound, uid, uid, AudioParams.Default.WithVariation(0.25f));
+ _audio.PlayPredicted(standingState.DownSound, uid, uid);
}
return true;
using Content.Shared.Placeable;
using Content.Shared.Storage.Components;
using Content.Shared.Verbs;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Random;
using Robust.Shared.Utility;
using Content.Shared.Tools.Systems;
using Content.Shared.Verbs;
using Content.Shared.Wall;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.GameStates;
using Robust.Shared.Map;
using Content.Shared.Storage.Components;
using Content.Shared.Timing;
using Content.Shared.Verbs;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Prototypes;
using Content.Shared.StatusEffect;
using Content.Shared.Throwing;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.GameStates;
using Robust.Shared.Player;
using Content.Shared.Pulling.Components;
using Content.Shared.Teleportation.Components;
using Content.Shared.Verbs;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Network;
using Robust.Shared.Physics.Dynamics;
[DataField("outputs", customTypeSerializer: typeof(PrototypeIdListSerializer<ContentTileDefinition>))]
public List<string>? OutputTiles;
- [DataField("placeTileSound")]
- public SoundSpecifier PlaceTileSound = new SoundPathSpecifier("/Audio/Items/genhit.ogg");
+ [DataField("placeTileSound")] public SoundSpecifier PlaceTileSound =
+ new SoundPathSpecifier("/Audio/Items/genhit.ogg")
+ {
+ Params = AudioParams.Default.WithVariation(0.125f),
+ };
}
}
using Content.Shared.Popups;
using Content.Shared.Stacks;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Network;
var variant = (byte) (_timing.CurTick.Value % ((ContentTileDefinition) _tileDefinitionManager[tileId]).Variants);
mapGrid.SetTile(location.Offset(new Vector2(offset, offset)), new Tile(tileId, 0, variant));
- _audio.PlayPredicted(placeSound, location, user, AudioHelpers.WithVariation(0.125f, _random));
+ _audio.PlayPredicted(placeSound, location, user);
}
public bool CanPlaceTile(EntityUid gridUid, MapGridComponent component, [NotNullWhen(false)] out string? reason)
using Content.Shared.Interaction;
using Content.Shared.Maps;
using Content.Shared.Tools.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Network;
using Robust.Shared.Prototypes;
if (tool.UseSound == null)
return;
- _audioSystem.PlayPredicted(tool.UseSound, uid, user, tool.UseSound.Params.WithVariation(0.175f).AddVolume(-5f));
+ _audioSystem.PlayPredicted(tool.UseSound, uid, user);
}
/// <summary>
[DataField("timeBetweenIncidents", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
public TimeSpan NextIncidentTime;
- public IPlayingAudioStream? Stream;
+ public EntityUid? Stream;
}
};
[ViewVariables]
- public IPlayingAudioStream? HonkPlayingStream;
+ public EntityUid? HonkPlayingStream;
/// Use ambient sound component for the idle sound.
using Content.Shared.Popups;
using Content.Shared.Tag;
using Content.Shared.Vehicle.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Network;
using Robust.Shared.Physics.Systems;
// TODO: Need audio refactor maybe, just some way to null it when the stream is over.
// For now better to just not loop to keep the code much cleaner.
- vehicle.HonkPlayingStream?.Stop();
- vehicle.HonkPlayingStream = _audioSystem.PlayPredicted(vehicle.HornSound, uid, uid);
+ vehicle.HonkPlayingStream = _audioSystem.PlayPredicted(vehicle.HornSound, uid, uid)?.Entity;
args.Handled = true;
}
using Content.Shared.DoAfter;
using Content.Shared.Interaction;
using Content.Shared.Popups;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Network;
namespace Content.Shared.VendingMachines;
using Content.Shared.Damage;
using Content.Shared.Projectiles;
using Content.Shared.Weapons.Melee.Events;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Network;
using Robust.Shared.Physics.Events;
using Robust.Shared.Timing;
using Content.Shared.Weapons.Ranged.Events;
using Content.Shared.Weapons.Ranged.Systems;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Systems;
Params = AudioParams.Default.WithLoop(true).WithVolume(-8f),
};
- public IPlayingAudioStream? Stream;
+ public EntityUid? Stream;
}
using Content.Shared.Timing;
using Content.Shared.Weapons.Ranged.Components;
using Content.Shared.Weapons.Ranged.Systems;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Network;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
// At least show the visuals.
component.Projectile = shotUid.Value;
- Dirty(component);
+ Dirty(uid, component);
var visuals = EnsureComp<JointVisualsComponent>(shotUid.Value);
visuals.Sprite =
new SpriteSpecifier.Rsi(new ResPath("Objects/Weapons/Guns/Launchers/grappling_gun.rsi"), "rope");
visuals.OffsetA = new Vector2(0f, 0.5f);
visuals.Target = uid;
- Dirty(visuals);
+ Dirty(shotUid.Value, visuals);
}
TryComp<AppearanceComponent>(uid, out var appearance);
}
component.Projectile = null;
- Dirty(component);
+ Dirty(uid, component);
}
}
if (value)
{
if (Timing.IsFirstTimePredicted)
- component.Stream = _audio.PlayPredicted(component.ReelSound, uid, user);
+ component.Stream = _audio.PlayPredicted(component.ReelSound, uid, user)?.Entity;
}
else
{
if (Timing.IsFirstTimePredicted)
{
- component.Stream?.Stop();
- component.Stream = null;
+ component.Stream = _audio.Stop(component.Stream);
}
}
component.Reeling = value;
- Dirty(component);
+ Dirty(uid, component);
}
public override void Update(float frameTime)
if (Timing.IsFirstTimePredicted)
{
// Just in case.
- grappling.Stream?.Stop();
- grappling.Stream = null;
+ grappling.Stream = _audio.Stop(grappling.Stream);
}
continue;
_physics.WakeBody(jointComp.Relay.Value);
}
- Dirty(jointComp);
+ Dirty(uid, jointComp);
if (distance.MaxLength.Equals(distance.MinLength))
{
joint.MinLength = 0.35f;
// Setting velocity directly for mob movement fucks this so need to make them aware of it.
// joint.Breakpoint = 4000f;
- Dirty(jointComp);
+ Dirty(uid, jointComp);
}
[Serializable, NetSerializable]
using Content.Shared.Movement.Events;
using Content.Shared.Throwing;
using Content.Shared.Toggleable;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Network;
// Sad...
if (_netManager.IsServer && component.Stream == null)
- component.Stream = _audio.PlayPredicted(component.Sound, gunUid, null);
+ component.Stream = _audio.PlayPredicted(component.Sound, gunUid, null)?.Entity;
- Dirty(tethered);
- Dirty(component);
+ Dirty(target, tethered);
+ Dirty(gunUid, component);
}
protected virtual void StopTether(EntityUid gunUid, BaseForceGunComponent component, bool land = true, bool transfer = false)
if (!transfer)
{
- component.Stream?.Stop();
+ _audio.Stop(component.Stream);
component.Stream = null;
}
[ViewVariables(VVAccess.ReadWrite), DataField("cycleSound"), AutoNetworkedField]
public SoundSpecifier? CycleSound = new SoundPathSpecifier("/Audio/Weapons/Guns/MagIn/kinetic_reload.ogg");
- public IPlayingAudioStream? Stream;
+ public EntityUid? Stream;
}
using Content.Shared.Examine;
using Content.Shared.Weapons.Ranged.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Network;
using Robust.Shared.Player;
using Robust.Shared.Timing;
using Content.Shared.Weapons.Ranged.Components;
using Content.Shared.Weapons.Ranged.Events;
using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Network;
using Content.Shared.Projectiles;
using Content.Shared.Weapons.Ranged.Components;
using Content.Shared.Weapons.Ranged.Events;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Network;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Systems;
using Content.Shared.Maps;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
[Dependency] protected readonly IPrototypeManager ProtoMan = default!;
[Dependency] private readonly ITileDefinitionManager _tileDefManager = default!;
[Dependency] private readonly MetaDataSystem _metadata = default!;
-
- protected ISawmill Sawmill = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
public override void Initialize()
{
base.Initialize();
- Sawmill = Logger.GetSawmill("weather");
SubscribeLocalEvent<WeatherComponent, EntityUnpausedEvent>(OnWeatherUnpaused);
}
// Admin messed up or the likes.
if (!ProtoMan.TryIndex<WeatherPrototype>(proto, out var weatherProto))
{
- Sawmill.Error($"Unable to find weather prototype for {comp.Weather}, ending!");
+ Log.Error($"Unable to find weather prototype for {comp.Weather}, ending!");
EndWeather(uid, comp, proto);
continue;
}
/// </summary>
public void SetWeather(MapId mapId, WeatherPrototype? proto, TimeSpan? endTime)
{
- var weatherComp = EnsureComp<WeatherComponent>(MapManager.GetMapEntityId(mapId));
+ var mapUid = MapManager.GetMapEntityId(mapId);
+ var weatherComp = EnsureComp<WeatherComponent>(mapUid);
foreach (var (eProto, weather) in weatherComp.Weather)
{
if (weather.State == WeatherState.Ending)
weather.State = WeatherState.Running;
- Dirty(weatherComp);
+ Dirty(mapUid, weatherComp);
continue;
}
if (weather.EndTime == null || weather.EndTime > end)
{
weather.EndTime = end;
- Dirty(weatherComp);
+ Dirty(mapUid, weatherComp);
}
}
if (!component.Weather.TryGetValue(proto, out var data))
return;
- data.Stream?.Stop();
+ _audio.Stop(data.Stream);
data.Stream = null;
component.Weather.Remove(proto);
- Dirty(component);
+ Dirty(uid, component);
}
protected virtual bool SetState(WeatherState state, WeatherComponent component, WeatherData weather, WeatherPrototype weatherProto)
{
// Client audio stream.
[NonSerialized]
- public IPlayingAudioStream? Stream;
+ public EntityUid? Stream;
/// <summary>
/// When the weather started if relevant.
using Content.Shared.Weapons.Ranged.Components;
using Content.Shared.Weapons.Ranged.Systems;
using Content.Shared.Wieldable.Components;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Systems;
using Robust.Shared.Player;
using Content.Shared.Timing;
- pos: -11.5,-13.5
parent: 30
type: Transform
- - thresholds:
- - trigger: !type:DamageTrigger
- damage: 100
- triggersOnce: False
- triggered: True
- behaviors:
- - !type:DoActsBehavior
- acts: Breakage
- - !type:EjectVendorItems
- max: 3
- percent: 0.25
- - trigger: !type:DamageTrigger
- damage: 200
- triggersOnce: False
- triggered: False
- behaviors:
- - !type:SpawnEntitiesBehavior
- offset: 0.5
- spawn:
- SheetSteel1:
- max: 1
- min: 1
- transferForensics: False
- - !type:DoActsBehavior
- acts: Destruction
- - !type:PlaySoundBehavior
- sound: !type:SoundPathSpecifier
- params:
- variation: null
- playoffset: 0
- loop: False
- referenceDistance: 1
- rolloffFactor: 1
- maxdistance: 25
- busname: Master
- pitchscale: 1
- volume: 0
- attenuation: Default
- path: /Audio/Effects/metalbreak.ogg
- type: Destructible
- proto: VendingMachineVendomat
entities:
- uid: 5434
path: /Audio/Machines/Nuke/nuke_alarm.ogg
params:
volume: -5
- maxdistance: 10
+ maxDistance: 10
- type: EmitSoundOnActivate
sound:
path: /Audio/Machines/Nuke/nuke_alarm.ogg
params:
volume: -5
- maxdistance: 10
+ maxDistance: 10
- type: entity
parent: BasePlushie
path: /Audio/Items/Stamp/thick_stamp_sub.ogg
params:
volume: -2
- maxdistance: 5
+ maxDistance: 5
- type: Sprite
sprite: Objects/Misc/bureaucracy.rsi
state: stamp-mime
path: /Audio/Items/Stamp/automatic_stamp.ogg
params:
volume: -2
- maxdistance: 5
+ maxDistance: 5
- type: entity
name: captain's rubber stamp
beepSound:
path: "/Audio/Items/locator_beep.ogg"
params:
- maxdistance: 1
+ maxDistance: 1
volume: -8
- type: entity
- type: ItemSlots
slots:
cell_slot:
- name: power-cell-slot-component-slot-name-default
\ No newline at end of file
+ name: power-cell-slot-component-slot-name-default
path: /Audio/Machines/microwave_loop.ogg
params:
loop: true
- maxdistance: 5
+ maxDistance: 5
- type: Sprite
sprite: Structures/Machines/fat_sucker.rsi
snapCardinals: true
path: /Audio/Ambience/Objects/crushing.ogg
params:
volume: 5
- maxdistance: 5
+ maxDistance: 5
loop: true
- type: MaterialStorage
insertOnInteract: false
collection: Whistles
params:
variation: 0.125
- pitchscale: 0.75
+ pitch: 0.75
- type: emoteSounds
id: FemaleDwarf
collection: Whistles
params:
variation: 0.125
- pitchscale: 0.75
+ pitch: 0.75
- type: emoteSounds
id: UnisexMoth
- addview
- removeview
- hwid
+ - showaudio
- showpos
- showray
- showchunkbb
projects / space-station-14.git / commitdiff