using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using BepInEx;
using BepInEx.Logging;
using FishNet;
using FishNet.Broadcast;
using FishNet.Connection;
using FishNet.Managing.Object;
using FishNet.Object;
using FishNet.Serializing;
using FishNet.Transporting;
using UnityEngine;
using UnityEngine.Networking;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("HowToFishCustomRadio")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("HowToFishCustomRadio")]
[assembly: AssemblyTitle("HowToFishCustomRadio")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace CustomRadioFramework;
public struct MusicChunkBroadcast : IBroadcast
{
public int trackId;
public int chunkIndex;
public int totalChunks;
public byte[] data;
}
public struct MusicControlBroadcast : IBroadcast
{
public bool isPaused;
public float timePosition;
}
public struct MusicVolumeBroadcast : IBroadcast
{
public float volume;
}
public static class CustomSerializers
{
public static void WriteMusicChunkBroadcast(this Writer writer, MusicChunkBroadcast msg)
{
writer.Write<int>(msg.trackId);
writer.Write<int>(msg.chunkIndex);
writer.Write<int>(msg.totalChunks);
writer.Write<byte[]>(msg.data);
}
public static MusicChunkBroadcast ReadMusicChunkBroadcast(this Reader reader)
{
return new MusicChunkBroadcast
{
trackId = reader.Read<int>(),
chunkIndex = reader.Read<int>(),
totalChunks = reader.Read<int>(),
data = reader.Read<byte[]>()
};
}
public static void WriteMusicControlBroadcast(this Writer writer, MusicControlBroadcast msg)
{
writer.Write<bool>(msg.isPaused);
writer.Write<float>(msg.timePosition);
}
public static MusicControlBroadcast ReadMusicControlBroadcast(this Reader reader)
{
return new MusicControlBroadcast
{
isPaused = reader.Read<bool>(),
timePosition = reader.Read<float>()
};
}
public static void WriteMusicVolumeBroadcast(this Writer writer, MusicVolumeBroadcast msg)
{
writer.Write<float>(msg.volume);
}
public static MusicVolumeBroadcast ReadMusicVolumeBroadcast(this Reader reader)
{
return new MusicVolumeBroadcast
{
volume = reader.Read<float>()
};
}
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public class OpenFileName
{
public int structSize;
public IntPtr hwndOwner = IntPtr.Zero;
public IntPtr hInstance = IntPtr.Zero;
public string filter;
public string customFilter;
public int maxCustFilter;
public int filterIndex;
public string file;
public int maxFile;
public string fileTitle;
public int maxFileTitle;
public string initialDir;
public string title;
public int flags;
public short fileOffset;
public short fileExtension;
public string defExt;
public IntPtr custData = IntPtr.Zero;
public IntPtr hook = IntPtr.Zero;
public string templateName;
public IntPtr reservedPtr = IntPtr.Zero;
public int reservedInt;
public int flagsEx;
}
public class LocalDialog
{
[DllImport("Comdlg32.dll", CharSet = CharSet.Auto, SetLastError = true, ThrowOnUnmappableChar = true)]
public static extern bool GetOpenFileName([In][Out] OpenFileName ofn);
}
[BepInPlugin("com.customradio.howtofish", "Custom Radio Framework", "0.1.2")]
public class Plugin : BaseUnityPlugin
{
public static ManualLogSource Log;
public static float LocalIgnoreNetworkTime;
private CustomRadioNetworkService networkService;
private CustomRadioAudioController audioController;
private CustomRadioUI uiManager;
private void Awake()
{
Log = ((BaseUnityPlugin)this).Logger;
Log.LogInfo((object)"Custom Radio v0.1.2 (Standard) загружен. Защита Steamworks включена.");
CleanupOldTempFiles();
audioController = new CustomRadioAudioController(this);
networkService = new CustomRadioNetworkService(this, audioController);
uiManager = new CustomRadioUI(this, networkService, audioController);
((MonoBehaviour)this).StartCoroutine(WaitForNetwork());
}
private IEnumerator WaitForNetwork()
{
while ((Object)(object)InstanceFinder.NetworkManager == (Object)null || (Object)(object)InstanceFinder.ClientManager == (Object)null)
{
yield return null;
}
networkService.RegisterCallbacks();
}
private void Update()
{
uiManager.HandleInput();
networkService.ProcessTimeouts();
}
private void OnGUI()
{
uiManager.DrawUI();
}
private void OnDestroy()
{
networkService?.UnregisterCallbacks();
audioController?.Dispose();
CleanupOldTempFiles();
}
private void CleanupOldTempFiles()
{
try
{
string[] files = Directory.GetFiles(Application.temporaryCachePath, "radio_sync_*.mp3");
for (int i = 0; i < files.Length; i++)
{
File.Delete(files[i]);
}
}
catch
{
}
}
}
public class CustomRadioAudioController : IDisposable
{
private Plugin plugin;
public AudioSource Source { get; private set; }
public bool IsPaused { get; private set; }
public float CurrentVolume { get; set; } = 1f;
public CustomRadioAudioController(Plugin plugin)
{
this.plugin = plugin;
}
public void EnsureRadioExists()
{
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)Source != (Object)null)
{
return;
}
GameObject val = null;
GameObject val2 = GameObject.Find("LocalPlayer");
float num = float.MaxValue;
if ((Object)(object)InstanceFinder.ClientManager != (Object)null)
{
foreach (NetworkObject value in ((ManagedObjects)InstanceFinder.ClientManager.Objects).Spawned.Values)
{
if (((Object)((Component)value).gameObject).name.IndexOf("Radio", StringComparison.OrdinalIgnoreCase) >= 0)
{
if (!((Object)(object)val2 != (Object)null))
{
val = ((Component)value).gameObject;
break;
}
float num2 = Vector3.Distance(val2.transform.position, ((Component)value).transform.position);
if (num2 < num)
{
num = num2;
val = ((Component)value).gameObject;
}
}
}
}
if ((Object)(object)val == (Object)null && (Object)(object)val2 != (Object)null)
{
val = val2;
}
if ((Object)(object)val != (Object)null)
{
Transform val3 = val.transform.Find("CustomRadioSource");
GameObject val4 = (GameObject)(((Object)(object)val3 != (Object)null) ? ((object)((Component)val3).gameObject) : ((object)new GameObject("CustomRadioSource")));
val4.transform.SetParent(val.transform);
val4.transform.localPosition = Vector3.zero;
Source = val4.GetComponent<AudioSource>() ?? val4.AddComponent<AudioSource>();
Source.spatialBlend = 1f;
Source.minDistance = 3f;
Source.maxDistance = 40f;
Source.rolloffMode = (AudioRolloffMode)1;
Source.volume = CurrentVolume;
}
}
public void PlayLocalFile(string path)
{
((MonoBehaviour)plugin).StartCoroutine(LoadAndPlayAudio("file:///" + path.Replace("\\", "/")));
}
private IEnumerator LoadAndPlayAudio(string url)
{
UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(url, (AudioType)13);
try
{
yield return www.SendWebRequest();
if ((Object)(object)Source == (Object)null)
{
yield break;
}
if ((int)www.result == 1)
{
AudioClip content = DownloadHandlerAudioClip.GetContent(www);
if ((Object)(object)Source.clip != (Object)null)
{
Object.Destroy((Object)(object)Source.clip);
}
Source.clip = content;
IsPaused = false;
Source.Play();
}
}
finally
{
((IDisposable)www)?.Dispose();
}
}
public void ApplyControlState(bool pauseState, float timePosition)
{
if (!((Object)(object)Source == (Object)null))
{
IsPaused = pauseState;
Source.time = timePosition;
if (IsPaused)
{
Source.Pause();
}
else
{
Source.Play();
}
}
}
public void ApplyVolume(float vol)
{
CurrentVolume = vol;
if ((Object)(object)Source != (Object)null)
{
Source.volume = CurrentVolume;
}
}
public void Dispose()
{
if ((Object)(object)Source != (Object)null && (Object)(object)Source.clip != (Object)null)
{
Object.Destroy((Object)(object)Source.clip);
}
}
}
public class CustomRadioNetworkService
{
private class DownloadContext
{
public FileStream Stream;
public int ExpectedChunks;
public HashSet<int> ReceivedChunks;
public float LastActivityTime;
public string TempPath;
}
public const int CHUNK_SIZE = 8192;
private const int MAX_FILE_SIZE = 15728640;
private const float DOWNLOAD_TIMEOUT = 120f;
private Plugin plugin;
private CustomRadioAudioController audio;
private bool isRegistered;
private Dictionary<int, DownloadContext> activeDownloads = new Dictionary<int, DownloadContext>();
public CustomRadioNetworkService(Plugin plugin, CustomRadioAudioController audio)
{
this.plugin = plugin;
this.audio = audio;
}
public void RegisterCallbacks()
{
if (!isRegistered)
{
GenericWriter<MusicChunkBroadcast>.SetWrite((Action<Writer, MusicChunkBroadcast>)CustomSerializers.WriteMusicChunkBroadcast);
GenericReader<MusicChunkBroadcast>.SetRead((Func<Reader, MusicChunkBroadcast>)CustomSerializers.ReadMusicChunkBroadcast);
GenericWriter<MusicControlBroadcast>.SetWrite((Action<Writer, MusicControlBroadcast>)CustomSerializers.WriteMusicControlBroadcast);
GenericReader<MusicControlBroadcast>.SetRead((Func<Reader, MusicControlBroadcast>)CustomSerializers.ReadMusicControlBroadcast);
GenericWriter<MusicVolumeBroadcast>.SetWrite((Action<Writer, MusicVolumeBroadcast>)CustomSerializers.WriteMusicVolumeBroadcast);
GenericReader<MusicVolumeBroadcast>.SetRead((Func<Reader, MusicVolumeBroadcast>)CustomSerializers.ReadMusicVolumeBroadcast);
InstanceFinder.ClientManager.RegisterBroadcast<MusicChunkBroadcast>((Action<MusicChunkBroadcast, Channel>)OnClientReceiveChunk);
InstanceFinder.ServerManager.RegisterBroadcast<MusicChunkBroadcast>((Action<NetworkConnection, MusicChunkBroadcast, Channel>)OnServerReceiveChunk, true);
InstanceFinder.ClientManager.RegisterBroadcast<MusicControlBroadcast>((Action<MusicControlBroadcast, Channel>)OnClientReceiveControl);
InstanceFinder.ServerManager.RegisterBroadcast<MusicControlBroadcast>((Action<NetworkConnection, MusicControlBroadcast, Channel>)OnServerReceiveControl, true);
InstanceFinder.ClientManager.RegisterBroadcast<MusicVolumeBroadcast>((Action<MusicVolumeBroadcast, Channel>)OnClientReceiveVolume);
InstanceFinder.ServerManager.RegisterBroadcast<MusicVolumeBroadcast>((Action<NetworkConnection, MusicVolumeBroadcast, Channel>)OnServerReceiveVolume, true);
isRegistered = true;
}
}
public void UnregisterCallbacks()
{
if (!isRegistered)
{
return;
}
if ((Object)(object)InstanceFinder.ClientManager != (Object)null)
{
InstanceFinder.ClientManager.UnregisterBroadcast<MusicChunkBroadcast>((Action<MusicChunkBroadcast, Channel>)OnClientReceiveChunk);
InstanceFinder.ClientManager.UnregisterBroadcast<MusicControlBroadcast>((Action<MusicControlBroadcast, Channel>)OnClientReceiveControl);
InstanceFinder.ClientManager.UnregisterBroadcast<MusicVolumeBroadcast>((Action<MusicVolumeBroadcast, Channel>)OnClientReceiveVolume);
}
if ((Object)(object)InstanceFinder.ServerManager != (Object)null)
{
InstanceFinder.ServerManager.UnregisterBroadcast<MusicChunkBroadcast>((Action<NetworkConnection, MusicChunkBroadcast, Channel>)OnServerReceiveChunk);
InstanceFinder.ServerManager.UnregisterBroadcast<MusicControlBroadcast>((Action<NetworkConnection, MusicControlBroadcast, Channel>)OnServerReceiveControl);
InstanceFinder.ServerManager.UnregisterBroadcast<MusicVolumeBroadcast>((Action<NetworkConnection, MusicVolumeBroadcast, Channel>)OnServerReceiveVolume);
}
foreach (DownloadContext value in activeDownloads.Values)
{
value.Stream.Dispose();
if (File.Exists(value.TempPath))
{
File.Delete(value.TempPath);
}
}
activeDownloads.Clear();
}
public void SendFile(string path)
{
((MonoBehaviour)plugin).StartCoroutine(StreamFileCoroutine(path));
}
private IEnumerator StreamFileCoroutine(string path)
{
if ((Object)(object)InstanceFinder.ClientManager == (Object)null)
{
yield break;
}
FileInfo fileInfo = new FileInfo(path);
if (fileInfo.Length > 15728640)
{
yield break;
}
int trackId = Random.Range(1000, 999999);
int totalChunks = Mathf.CeilToInt((float)fileInfo.Length / 8192f);
using FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read);
byte[] buffer = new byte[8192];
int chunkIndex = 0;
int num;
while ((num = fs.Read(buffer, 0, buffer.Length)) > 0)
{
byte[] array;
if (num < 8192)
{
array = new byte[num];
Buffer.BlockCopy(buffer, 0, array, 0, num);
}
else
{
array = buffer;
}
InstanceFinder.ClientManager.Broadcast<MusicChunkBroadcast>(new MusicChunkBroadcast
{
trackId = trackId,
chunkIndex = chunkIndex,
totalChunks = totalChunks,
data = array
}, (Channel)0);
chunkIndex++;
yield return (object)new WaitForSeconds(0.03f);
}
}
public void SendControl(bool isPaused, float time)
{
if ((Object)(object)InstanceFinder.ClientManager != (Object)null)
{
InstanceFinder.ClientManager.Broadcast<MusicControlBroadcast>(new MusicControlBroadcast
{
isPaused = isPaused,
timePosition = time
}, (Channel)0);
}
}
public void SendVolume(float vol)
{
if ((Object)(object)InstanceFinder.ClientManager != (Object)null)
{
InstanceFinder.ClientManager.Broadcast<MusicVolumeBroadcast>(new MusicVolumeBroadcast
{
volume = vol
}, (Channel)0);
}
}
private void OnServerReceiveChunk(NetworkConnection conn, MusicChunkBroadcast msg, Channel channel)
{
if (msg.data != null && msg.data.Length <= 9216)
{
InstanceFinder.ServerManager.Broadcast<MusicChunkBroadcast>(msg, true, (Channel)0);
}
}
private void OnServerReceiveControl(NetworkConnection conn, MusicControlBroadcast msg, Channel channel)
{
InstanceFinder.ServerManager.Broadcast<MusicControlBroadcast>(msg, true, (Channel)0);
}
private void OnServerReceiveVolume(NetworkConnection conn, MusicVolumeBroadcast msg, Channel channel)
{
InstanceFinder.ServerManager.Broadcast<MusicVolumeBroadcast>(msg, true, (Channel)0);
}
private void OnClientReceiveChunk(MusicChunkBroadcast msg, Channel channel)
{
if (!activeDownloads.TryGetValue(msg.trackId, out var value))
{
string text = Path.Combine(Application.temporaryCachePath, $"radio_sync_{msg.trackId}.mp3");
value = new DownloadContext
{
TempPath = text,
Stream = new FileStream(text, FileMode.Create, FileAccess.Write, FileShare.None),
ExpectedChunks = msg.totalChunks,
ReceivedChunks = new HashSet<int>(),
LastActivityTime = Time.realtimeSinceStartup
};
activeDownloads[msg.trackId] = value;
}
value.Stream.Seek((long)msg.chunkIndex * 8192L, SeekOrigin.Begin);
value.Stream.Write(msg.data, 0, msg.data.Length);
value.ReceivedChunks.Add(msg.chunkIndex);
value.LastActivityTime = Time.realtimeSinceStartup;
if (value.ReceivedChunks.Count >= value.ExpectedChunks)
{
value.Stream.Dispose();
activeDownloads.Remove(msg.trackId);
audio.PlayLocalFile(value.TempPath);
}
}
private void OnClientReceiveControl(MusicControlBroadcast msg, Channel channel)
{
if (!(Time.realtimeSinceStartup - Plugin.LocalIgnoreNetworkTime < 0.8f))
{
audio.ApplyControlState(msg.isPaused, msg.timePosition);
}
}
private void OnClientReceiveVolume(MusicVolumeBroadcast msg, Channel channel)
{
if (!(Time.realtimeSinceStartup - Plugin.LocalIgnoreNetworkTime < 0.8f))
{
audio.ApplyVolume(msg.volume);
}
}
public void ProcessTimeouts()
{
if (activeDownloads.Count == 0)
{
return;
}
List<int> list = null;
float realtimeSinceStartup = Time.realtimeSinceStartup;
foreach (KeyValuePair<int, DownloadContext> activeDownload in activeDownloads)
{
if (realtimeSinceStartup - activeDownload.Value.LastActivityTime > 120f)
{
if (list == null)
{
list = new List<int>();
}
list.Add(activeDownload.Key);
}
}
if (list == null)
{
return;
}
foreach (int item in list)
{
DownloadContext downloadContext = activeDownloads[item];
downloadContext.Stream.Dispose();
if (File.Exists(downloadContext.TempPath))
{
File.Delete(downloadContext.TempPath);
}
activeDownloads.Remove(item);
}
}
}
public class CustomRadioUI
{
private Plugin plugin;
private CustomRadioNetworkService network;
private CustomRadioAudioController audio;
private bool showUI;
private bool isDialogOpen;
private ConcurrentQueue<string> pendingFiles = new ConcurrentQueue<string>();
private float lastSeekSendTime;
private float lastVolumeSendTime;
private GUIStyle windowStyle;
private GUIStyle btnStyle;
private GUIStyle labelStyle;
private GUIStyle sliderTrackStyle;
private GUIStyle sliderThumbStyle;
private bool stylesInitialized;
public CustomRadioUI(Plugin plugin, CustomRadioNetworkService network, CustomRadioAudioController audio)
{
this.plugin = plugin;
this.network = network;
this.audio = audio;
}
private void InitStyles()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Expected O, but got Unknown
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: Unknown result type (might be due to invalid IL or missing references)
//IL_0167: Expected O, but got Unknown
//IL_0186: Unknown result type (might be due to invalid IL or missing references)
//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
//IL_01be: Expected O, but got Unknown
//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
//IL_020a: Unknown result type (might be due to invalid IL or missing references)
//IL_0214: Expected O, but got Unknown
//IL_0236: Unknown result type (might be due to invalid IL or missing references)
//IL_0253: Unknown result type (might be due to invalid IL or missing references)
if (!stylesInitialized)
{
windowStyle = new GUIStyle(GUI.skin.box);
windowStyle.normal.background = MakeTex(2, 2, new Color(0.08f, 0.08f, 0.08f, 0.95f));
windowStyle.normal.textColor = Color.white;
windowStyle.alignment = (TextAnchor)1;
windowStyle.fontStyle = (FontStyle)1;
windowStyle.fontSize = 14;
btnStyle = new GUIStyle(GUI.skin.button);
btnStyle.normal.background = MakeTex(2, 2, new Color(0.18f, 0.18f, 0.18f, 1f));
btnStyle.hover.background = MakeTex(2, 2, new Color(0.35f, 0.35f, 0.35f, 1f));
btnStyle.active.background = MakeTex(2, 2, new Color(0.5f, 0.5f, 0.5f, 1f));
btnStyle.normal.textColor = Color.white;
btnStyle.fontStyle = (FontStyle)1;
labelStyle = new GUIStyle(GUI.skin.label);
labelStyle.normal.textColor = new Color(0.85f, 0.85f, 0.85f, 1f);
labelStyle.alignment = (TextAnchor)4;
labelStyle.fontSize = 13;
sliderTrackStyle = new GUIStyle(GUI.skin.horizontalSlider);
sliderTrackStyle.normal.background = MakeTex(2, 2, new Color(0.2f, 0.2f, 0.2f, 1f));
sliderTrackStyle.fixedHeight = 6f;
sliderThumbStyle = new GUIStyle(GUI.skin.horizontalSliderThumb);
sliderThumbStyle.normal.background = MakeTex(2, 2, new Color(0.8f, 0.8f, 0.8f, 1f));
sliderThumbStyle.hover.background = MakeTex(2, 2, Color.white);
sliderThumbStyle.fixedWidth = 14f;
sliderThumbStyle.fixedHeight = 14f;
stylesInitialized = true;
}
}
private Texture2D MakeTex(int width, int height, Color col)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
Color[] array = (Color[])(object)new Color[width * height];
for (int i = 0; i < array.Length; i++)
{
array[i] = col;
}
Texture2D val = new Texture2D(width, height);
val.SetPixels(array);
val.Apply();
return val;
}
public void HandleInput()
{
if (Input.GetKeyDown((KeyCode)121))
{
showUI = !showUI;
audio.EnsureRadioExists();
}
if (pendingFiles.TryDequeue(out var result))
{
network.SendFile(result);
}
}
public void DrawUI()
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0187: Unknown result type (might be due to invalid IL or missing references)
//IL_020e: Unknown result type (might be due to invalid IL or missing references)
//IL_0275: Unknown result type (might be due to invalid IL or missing references)
//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
//IL_0337: Unknown result type (might be due to invalid IL or missing references)
if (!showUI)
{
return;
}
InitStyles();
GUI.Box(new Rect(20f, 20f, 320f, 200f), "\nC U S T O M R A D I O", windowStyle);
if (GUI.Button(new Rect(40f, 55f, 280f, 25f), "Загрузить MP3", btnStyle))
{
OpenWindowsExplorerSafe();
}
AudioSource source = audio.Source;
if (!((Object)(object)source != (Object)null) || !((Object)(object)source.clip != (Object)null))
{
return;
}
string text = FormatTime(source.time) + " / " + FormatTime(source.clip.length);
GUI.Label(new Rect(40f, 85f, 280f, 20f), text, labelStyle);
GUI.changed = false;
float time = GUI.HorizontalSlider(new Rect(40f, 105f, 280f, 15f), source.time, 0f, source.clip.length, sliderTrackStyle, sliderThumbStyle);
if (GUI.changed)
{
source.time = time;
Plugin.LocalIgnoreNetworkTime = Time.realtimeSinceStartup;
if (Time.realtimeSinceStartup - lastSeekSendTime > 0.1f)
{
lastSeekSendTime = Time.realtimeSinceStartup;
network.SendControl(audio.IsPaused, time);
}
}
if (GUI.Button(new Rect(100f, 130f, 45f, 25f), "<<", btnStyle))
{
float time2 = (source.time = Mathf.Max(0f, source.time - 15f));
Plugin.LocalIgnoreNetworkTime = Time.realtimeSinceStartup;
network.SendControl(audio.IsPaused, time2);
}
string text2 = (audio.IsPaused ? "Play" : "Pause");
if (GUI.Button(new Rect(155f, 130f, 50f, 25f), text2, btnStyle))
{
bool flag = !audio.IsPaused;
audio.ApplyControlState(flag, source.time);
Plugin.LocalIgnoreNetworkTime = Time.realtimeSinceStartup;
network.SendControl(flag, source.time);
}
if (GUI.Button(new Rect(215f, 130f, 45f, 25f), ">>", btnStyle))
{
float time3 = (source.time = Mathf.Min(source.clip.length, source.time + 15f));
Plugin.LocalIgnoreNetworkTime = Time.realtimeSinceStartup;
network.SendControl(audio.IsPaused, time3);
}
GUI.Label(new Rect(40f, 165f, 70f, 20f), $"Vol: {Mathf.RoundToInt(audio.CurrentVolume * 100f)}%", labelStyle);
GUI.changed = false;
float vol = GUI.HorizontalSlider(new Rect(110f, 170f, 210f, 15f), audio.CurrentVolume, 0f, 1f, sliderTrackStyle, sliderThumbStyle);
if (GUI.changed)
{
audio.ApplyVolume(vol);
Plugin.LocalIgnoreNetworkTime = Time.realtimeSinceStartup;
if (Time.realtimeSinceStartup - lastVolumeSendTime > 0.1f)
{
lastVolumeSendTime = Time.realtimeSinceStartup;
network.SendVolume(vol);
}
}
}
private string FormatTime(float timeInSeconds)
{
int num = Mathf.FloorToInt(timeInSeconds / 60f);
int num2 = Mathf.FloorToInt(timeInSeconds % 60f);
return $"{num:00}:{num2:00}";
}
private void OpenWindowsExplorerSafe()
{
if (isDialogOpen)
{
return;
}
isDialogOpen = true;
new Thread((ThreadStart)delegate
{
OpenFileName openFileName = new OpenFileName();
openFileName.structSize = Marshal.SizeOf(openFileName);
openFileName.filter = "MP3 Files (*.mp3)\0*.mp3\0";
openFileName.file = new string(new char[1024]);
openFileName.maxFile = openFileName.file.Length;
openFileName.title = "Выберите песню для радио";
openFileName.flags = 528392;
if (LocalDialog.GetOpenFileName(openFileName))
{
pendingFiles.Enqueue(openFileName.file.TrimEnd(new char[1]));
}
isDialogOpen = false;
}).Start();
}
}
