feat: Exiled 10 Update

EXILED/EXILED.props

@@ -7,7 +7,7 @@
 
   <PropertyGroup Condition="$(BuildProperties) == '' OR $(BuildProperties) == 'true'">
     <TargetFramework>net48</TargetFramework>
-    <LangVersion>13.0</LangVersion>
+    <LangVersion>14.0</LangVersion>
     <PlatformTarget>x64</PlatformTarget>
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
     <OutputPath>$(MSBuildThisFileDirectory)\bin\$(Configuration)\</OutputPath>
@@ -19,7 +19,7 @@
     <!-- Enables public beta warning via the PUBLIC_BETA constant -->
     <PublicBeta>false</PublicBeta>
 
-    <HarmonyVersion>2.2.2</HarmonyVersion>
+    <HarmonyVersion>2.4.2</HarmonyVersion>
     <StyleCopVersion>1.1.118</StyleCopVersion>
     <SemanticVersioningVersion>2.0.2</SemanticVersioningVersion>
 

EXILED/Exiled.API/Enums/EffectType.cs

@@ -44,9 +44,9 @@ public enum EffectType
         Bleeding,
 
         /// <summary>
-        /// Blurs the player's screen.
+        /// Make the player screen darker.
         /// </summary>
-        Blinded,
+        Blindness,
 
         /// <summary>
         /// Increases damage the player receives. Does not apply any standalone damage.
@@ -256,7 +256,7 @@ public enum EffectType
         PitDeath,
 
         /// <summary>
-        /// <see cref="CustomPlayerEffects.Blurred"/>.
+        /// Blurs the player's screen.
         /// </summary>
         Blurred,
 

EXILED/Exiled.API/Enums/PrefabType.cs

@@ -12,6 +12,7 @@ namespace Exiled.API.Enums
     /// <summary>
     /// Type of prefab.
     /// </summary>
+    /// <seealso cref="Features.PrefabHelper"/>
     public enum PrefabType
     {
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member

EXILED/Exiled.API/Enums/SpeakerPlayMode.cs

@@ -0,0 +1,35 @@
+// -----------------------------------------------------------------------
+// <copyright file="SpeakerPlayMode.cs" company="ExMod Team">
+// Copyright (c) ExMod Team. All rights reserved.
+// Licensed under the CC BY-SA 3.0 license.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Exiled.API.Enums
+{
+    /// <summary>
+    /// Specifies the available modes for playing audio through a speaker.
+    /// </summary>
+    public enum SpeakerPlayMode : byte
+    {
+        /// <summary>
+        /// Play audio globally to all players.
+        /// </summary>
+        Global = 0,
+
+        /// <summary>
+        /// Play audio to a specific player.
+        /// </summary>
+        Player = 1,
+
+        /// <summary>
+        /// Play audio to a specific list of players.
+        /// </summary>
+        PlayerList = 2,
+
+        /// <summary>
+        /// Play audio to players matching a predicate.
+        /// </summary>
+        Predicate = 3,
+    }
+}

EXILED/Exiled.API/Enums/WarheadStatus.cs

@@ -7,30 +7,38 @@
 
 namespace Exiled.API.Enums
 {
+    using System;
+
     /// <summary>
     /// All the available warhead statuses.
     /// </summary>
     /// <seealso cref="Features.Warhead.Status"/>
+    [Flags]
     public enum WarheadStatus
     {
         /// <summary>
         /// The warhead is not armed.
         /// </summary>
-        NotArmed,
+        NotArmed = 0,
 
         /// <summary>
         /// The warhead is armed.
         /// </summary>
-        Armed,
+        Armed = 1,
 
         /// <summary>
         /// The warhead detonation is in progress.
         /// </summary>
-        InProgress,
+        InProgress = 2,
 
         /// <summary>
         /// The warhead has detonated.
         /// </summary>
-        Detonated,
+        Detonated = 4,
+
+        /// <summary>
+        /// The warhead is on cooldown.
+        /// </summary>
+        OnCooldown = 8,
     }
 }

EXILED/Exiled.API/Exiled.API.csproj

@@ -40,6 +40,7 @@
         <Reference Include="UnityEngine.PhysicsModule" HintPath="$(EXILED_REFERENCES)\UnityEngine.PhysicsModule.dll" Private="false" />
         <Reference Include="UnityEngine.AudioModule" HintPath="$(EXILED_REFERENCES)\UnityEngine.AudioModule.dll" Private="false" />
         <Reference Include="UnityEngine.UI" HintPath="$(EXILED_REFERENCES)\UnityEngine.UI.dll" Private="false" />
+        <Reference Include="UnityEngine.UnityWebRequestModule" HintPath="$(EXILED_REFERENCES)\UnityEngine.UnityWebRequestModule.dll" Private="false" />
         <Reference Include="YamlDotNet" HintPath="$(EXILED_REFERENCES)\YamlDotNet.dll" Private="false" />
         <Reference Include="mscorlib" HintPath="$(EXILED_REFERENCES)\mscorlib.dll" Private="false" />
         <Reference Include="System" HintPath="$(EXILED_REFERENCES)\System.dll" Private="false" />

EXILED/Exiled.API/Extensions/EffectTypeExtension.cs

@@ -34,7 +34,7 @@ public static class EffectTypeExtension
             { EffectType.AmnesiaVision, typeof(AmnesiaVision) },
             { EffectType.Asphyxiated, typeof(Asphyxiated) },
             { EffectType.Bleeding, typeof(Bleeding) },
-            { EffectType.Blinded, typeof(Blindness) },
+            { EffectType.Blindness, typeof(Blindness) },
             { EffectType.BodyshotReduction, typeof(BodyshotReduction) },
             { EffectType.Burned, typeof(Burned) },
             { EffectType.CardiacArrest, typeof(CardiacArrest) },
@@ -194,7 +194,7 @@ or EffectType.Corroding or EffectType.Decontaminating or EffectType.Hemorrhage o
         /// <returns>Whether the effect is a negative effect.</returns>
         /// <seealso cref="IsHarmful(EffectType)"/>
         public static bool IsNegative(this EffectType effect) => IsHarmful(effect) || effect is EffectType.AmnesiaItems
-            or EffectType.AmnesiaVision or EffectType.Blinded or EffectType.Burned or EffectType.Concussed or EffectType.Deafened
+            or EffectType.AmnesiaVision or EffectType.Blindness or EffectType.Burned or EffectType.Concussed or EffectType.Deafened
             or EffectType.Disabled or EffectType.Ensnared or EffectType.Exhausted or EffectType.Flashed or EffectType.SinkHole
             or EffectType.Stained or EffectType.InsufficientLighting or EffectType.SoundtrackMute or EffectType.Scanned or EffectType.Slowness;
 

EXILED/Exiled.API/Extensions/MirrorExtensions.cs

@@ -56,9 +56,6 @@ public static class MirrorExtensions
         private static readonly ReadOnlyDictionary<Type, MethodInfo> ReadOnlyWriterExtensionsValue = new(WriterExtensionsValue);
         private static readonly ReadOnlyDictionary<string, ulong> ReadOnlySyncVarDirtyBitsValue = new(SyncVarDirtyBitsValue);
         private static readonly ReadOnlyDictionary<string, string> ReadOnlyRpcFullNamesValue = new(RpcFullNamesValue);
-        private static MethodInfo setDirtyBitsMethodInfoValue;
-        private static MethodInfo sendSpawnMessageMethodInfoValue;
-        private static string[] adminToyBaseSyncVarsValue;
 
         /// <summary>
         /// Gets <see cref="MethodInfo"/> corresponding to <see cref="Type"/>.
@@ -153,17 +150,17 @@ public static ReadOnlyDictionary<string, string> RpcFullNames
         /// <summary>
         /// Gets a <see cref="NetworkBehaviour.SetSyncVarDirtyBit(ulong)"/>'s <see cref="MethodInfo"/>.
         /// </summary>
-        public static MethodInfo SetDirtyBitsMethodInfo => setDirtyBitsMethodInfoValue ??= typeof(NetworkBehaviour).GetMethod(nameof(NetworkBehaviour.SetSyncVarDirtyBit));
+        public static MethodInfo SetDirtyBitsMethodInfo => field ??= typeof(NetworkBehaviour).GetMethod(nameof(NetworkBehaviour.SetSyncVarDirtyBit));
 
         /// <summary>
         /// Gets a NetworkServer.SendSpawnMessage's <see cref="MethodInfo"/>.
         /// </summary>
-        public static MethodInfo SendSpawnMessageMethodInfo => sendSpawnMessageMethodInfoValue ??= typeof(NetworkServer).GetMethod("SendSpawnMessage", BindingFlags.NonPublic | BindingFlags.Static);
+        public static MethodInfo SendSpawnMessageMethodInfo => field ??= typeof(NetworkServer).GetMethod("SendSpawnMessage", BindingFlags.NonPublic | BindingFlags.Static);
 
         /// <summary>
         /// Gets all <see cref="AdminToyBase"/> sync var names.
         /// </summary>
-        public static string[] AdminToyBaseSyncVars => adminToyBaseSyncVarsValue ??= typeof(AdminToyBase).GetProperties().Where(property => property.Name.Contains("Network")).Select(property => property.Name).ToArray();
+        public static string[] AdminToyBaseSyncVars => field ??= typeof(AdminToyBase).GetProperties().Where(property => property.Name.Contains("Network")).Select(property => property.Name).ToArray();
 
         /// <summary>
         /// Plays a beep sound that only the target <paramref name="player"/> can hear.

EXILED/Exiled.API/Features/Audio/AudioDataStorage.cs

@@ -0,0 +1,213 @@
+// -----------------------------------------------------------------------
+// <copyright file="AudioDataStorage.cs" company="ExMod Team">
+// Copyright (c) ExMod Team. All rights reserved.
+// Licensed under the CC BY-SA 3.0 license.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Exiled.API.Features.Audio
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.IO;
+
+    using Exiled.API.Structs.Audio;
+
+    using MEC;
+
+    using RoundRestarting;
+
+    using UnityEngine.Networking;
+
+    /// <summary>
+    /// Manages a global in-memory storage of decoded PCM audio data. Once stored, audio can be played using <see cref="PcmSources.CachedPcmSource"/>.
+    /// </summary>
+    public static class AudioDataStorage
+    {
+        static AudioDataStorage()
+        {
+            AudioStorage = new();
+            RoundRestart.OnRestartTriggered += OnRoundRestart;
+        }
+
+        /// <summary>
+        /// Gets the underlying storage, keyed by name.
+        /// </summary>
+        public static Dictionary<string, AudioData> AudioStorage { get; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the storage is automatically cleared when a round restart is triggered.
+        /// </summary>
+        public static bool ClearOnRoundRestart { get; set; } = true;
+
+        /// <summary>
+        /// Loads and stores a local .wav file under the specified name.
+        /// </summary>
+        /// <param name="name">The unique storage key to assign to this audio.</param>
+        /// <param name="path">The absolute path to the local .wav file.</param>
+        /// <returns><c>true</c> if the file was successfully loaded and stored; otherwise, <c>false</c>.</returns>
+        public static bool AddWav(string name, string path)
+        {
+            if (!ValidateName(name))
+                return false;
+
+            if (AudioStorage.ContainsKey(name))
+            {
+                Log.Warn($"[AudioDataStorage] An entry with the key '{name}' already exists. Skipping add.");
+                return false;
+            }
+
+            if (path.StartsWith("http"))
+            {
+                Log.Error($"[AudioDataStorage] '{path}' is a URL. Use AudioDataStorage.AddUrl() for web sources.");
+                return false;
+            }
+
+            if (!File.Exists(path))
+            {
+                Log.Error($"[AudioDataStorage] Local file not found: '{path}'");
+                return false;
+            }
+
+            try
+            {
+                AudioData parsed = WavUtility.WavToPcm(path);
+                return AudioStorage.TryAdd(name, parsed);
+            }
+            catch (Exception ex)
+            {
+                Log.Error($"[AudioDataStorage] Failed to load '{path}' into storage:\n{ex}");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Stores raw PCM audio samples under the specified name.
+        /// </summary>
+        /// <param name="name">The unique storage key to assign.</param>
+        /// <param name="pcm">The raw PCM float array to store.</param>
+        /// <returns><c>true</c> if successfully added; otherwise, <c>false</c>.</returns>
+        public static bool Add(string name, float[] pcm)
+        {
+            if (pcm == null)
+            {
+                Log.Error($"[AudioDataStorage] Cannot store null array for key '{name}'.");
+                return false;
+            }
+
+            TrackData trackInfo = new()
+            {
+                Title = name,
+                Duration = (double)pcm.Length / VoiceChat.VoiceChatSettings.SampleRate,
+            };
+
+            return Add(name, new AudioData(pcm, trackInfo));
+        }
+
+        /// <summary>
+        /// Stores a fully constructed <see cref="AudioData"/> under the specified name.
+        /// </summary>
+        /// <param name="name">The unique storage key to assign.</param>
+        /// <param name="audioData">The <see cref="AudioData"/> to store.</param>
+        /// <returns><c>true</c> if successfully added; otherwise, <c>false</c>.</returns>
+        public static bool Add(string name, AudioData audioData)
+        {
+            if (!ValidateName(name))
+                return false;
+
+            if (audioData.Pcm == null || audioData.Pcm.Length == 0)
+            {
+                Log.Error($"[AudioDataStorage] AudioData for key '{name}' has null or empty PCM.");
+                return false;
+            }
+
+            if (AudioStorage.ContainsKey(name))
+            {
+                Log.Warn($"[AudioDataStorage] An entry with the key '{name}' already exists. Skipping add.");
+                return false;
+            }
+
+            return AudioStorage.TryAdd(name, audioData);
+        }
+
+        /// <summary>
+        /// Starts an asynchronous download of a .wav file from the specified URL and adds it to the  storage.
+        /// </summary>
+        /// <param name="name">The unique storage key to assign.</param>
+        /// <param name="url">The HTTP or HTTPS URL pointing to a valid .wav file.</param>
+        /// <returns>A <see cref="CoroutineHandle"/> for the running download coroutine.</returns>
+        public static CoroutineHandle AddWavUrl(string name, string url) => Timing.RunCoroutine(AddUrlCoroutine(name, url));
+
+        /// <summary>
+        /// Starts an asynchronous download of a .wav file from the specified URL and adds it to the storage.
+        /// </summary>
+        /// <param name="name">The unique storage key to assign.</param>
+        /// <param name="url">The HTTP or HTTPS URL pointing to a valid .wav file.</param>
+        /// <returns>A MEC-compatible <see cref="IEnumerator{T}"/> of <see cref="float"/>.</returns>
+        public static IEnumerator<float> AddUrlCoroutine(string name, string url)
+        {
+            if (!ValidateName(name))
+                yield break;
+
+            if (string.IsNullOrEmpty(url) || !url.StartsWith("http"))
+            {
+                Log.Error($"[AudioDataStorage] Invalid URL for key '{name}': '{url}'. Must start with http/https.");
+                yield break;
+            }
+
+            if (AudioStorage.ContainsKey(name))
+            {
+                Log.Warn($"[AudioDataStorage] An entry with the key '{name}' already exists. Skipping download.");
+                yield break;
+            }
+
+            using UnityWebRequest www = UnityWebRequest.Get(url);
+            yield return Timing.WaitUntilDone(www.SendWebRequest());
+
+            if (www.result != UnityWebRequest.Result.Success)
+            {
+                Log.Error($"[AudioDataStorage] Download failed for '{url}': {www.error}");
+                yield break;
+            }
+
+            try
+            {
+                AudioData parsed = WavUtility.WavToPcm(www.downloadHandler.data);
+                parsed.TrackInfo.Path = url;
+                AudioStorage.TryAdd(name, parsed);
+            }
+            catch (Exception ex)
+            {
+                Log.Error($"[AudioDataStorage] Failed to parse downloaded WAV from '{url}':\n{ex}");
+            }
+        }
+
+        /// <summary>
+        /// Removes a stored audio entry by name.
+        /// </summary>
+        /// <param name="name">The storage name/key to remove.</param>
+        /// <returns><c>true</c> if the entry was found and removed; otherwise, <c>false</c>.</returns>
+        public static bool Remove(string name) => AudioStorage.Remove(name, out _);
+
+        /// <summary>
+        /// Clears all entries from the audio storage, freeing all associated memory.
+        /// </summary>
+        public static void Clear() => AudioStorage.Clear();
+
+        private static bool ValidateName(string name)
+        {
+            if (!string.IsNullOrEmpty(name))
+                return true;
+
+            Log.Error("[AudioDataStorage] Storage name (key) cannot be null or empty.");
+            return false;
+        }
+
+        private static void OnRoundRestart()
+        {
+            if (ClearOnRoundRestart)
+                Clear();
+        }
+    }
+}