using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalNetworkAPI;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Networking;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
public class CarPatch
{
[CompilerGenerated]
private sealed class <AudioSourceListener>d__7 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public AudioSource radio;
public VehicleController instance;
private AudioClip <clip>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <AudioSourceListener>d__7(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<clip>5__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
if ((Object)(object)<clip>5__1 != (Object)(object)radio.clip)
{
if (CruiserTunesMod.GoodQuality.Value)
{
radio.volume = 1f;
instance.radioInterference.volume = 0f;
}
if ((Object)(object)CruiserTunesMod.instance != (Object)null)
{
((MonoBehaviour)CruiserTunesMod.instance).StartCoroutine(PlayNotification(instance));
}
}
<clip>5__1 = null;
break;
}
if ((Object)(object)radio != (Object)null && (Object)(object)instance != (Object)null)
{
<clip>5__1 = radio.clip;
instance.radioAudio.loop = CruiserTunesMod.DoLoop.Value;
<>2__current = null;
<>1__state = 1;
return true;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <EnsureClipReadyAndPlay>d__10 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public AudioSource audio;
private float <timeout>5__1;
private float <start>5__2;
private float <max>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <EnsureClipReadyAndPlay>d__10(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<timeout>5__1 = 5f;
<start>5__2 = Time.time;
break;
case 1:
<>1__state = -1;
break;
}
if (((Object)(object)audio == (Object)null || (Object)(object)audio.clip == (Object)null || audio.clip.length <= 0f || !audio.clip.isReadyToPlay) && !(Time.time - <start>5__2 > <timeout>5__1))
{
<>2__current = null;
<>1__state = 1;
return true;
}
if ((Object)(object)audio == (Object)null || (Object)(object)audio.clip == (Object)null || audio.clip.length <= 0f)
{
return false;
}
if (!audio.isPlaying)
{
audio.Play();
}
if (CruiserTunesMod.DoRandomTime != null && CruiserTunesMod.DoRandomTime.Value)
{
<max>5__3 = Mathf.Max(0.01f, audio.clip.length - 0.1f);
audio.time = Random.Range(0.01f, <max>5__3);
}
else
{
audio.time = 0f;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <PlayNotification>d__8 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public VehicleController instance;
private AudioClip <clip>5__1;
private PlayerControllerB <localPlayer>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <PlayNotification>d__8(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<clip>5__1 = null;
<localPlayer>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected O, but got Unknown
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if (CruiserTunesMod.DoMessage.Value)
{
<clip>5__1 = instance.radioAudio.clip;
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 1;
return true;
}
break;
case 1:
<>1__state = -1;
if ((Object)(object)<clip>5__1 == (Object)(object)instance.radioAudio.clip)
{
<localPlayer>5__2 = StartOfRound.Instance.localPlayerController;
if ((Object)(object)<localPlayer>5__2 != (Object)null && (Object)(object)instance != (Object)null && Vector3.Distance(((Component)<localPlayer>5__2).transform.position, ((Component)instance).transform.position) < 10f)
{
HUDManager.Instance.DisplayTip("Now Playing:", ((Object)<clip>5__1).name.Replace("Radio_", "") + " - " + FormatLength(<clip>5__1.length), false, false, "LC_Tip1");
}
<localPlayer>5__2 = null;
}
<clip>5__1 = null;
break;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[HarmonyPatch(typeof(VehicleController), "Awake")]
[HarmonyPostfix]
public static void AwakePatch(VehicleController __instance)
{
if (CruiserTunesMod.HasSongs)
{
AudioClip[] source = ((!CruiserTunesMod.IncludeOriginal.Value) ? CruiserTunesMod.CustomSongs : __instance.radioClips.Concat(CruiserTunesMod.CustomSongs).ToArray());
source = source.OrderByDescending((AudioClip str) => GetAsciiSum(((Object)str).name)).ToArray();
__instance.radioClips = source;
__instance.radioAudio.loop = CruiserTunesMod.DoLoop.Value;
if ((Object)(object)CruiserTunesMod.instance != (Object)null)
{
((MonoBehaviour)CruiserTunesMod.instance).StartCoroutine(AudioSourceListener(__instance.radioAudio, __instance));
}
}
static int GetAsciiSum(string str)
{
return str.Sum((char c) => c);
}
}
public static void UpdateLooping(object sender, EventArgs e)
{
Object val = Object.FindObjectOfType(typeof(VehicleController));
VehicleController val2 = (VehicleController)(object)((val is VehicleController) ? val : null);
if (val2 != null)
{
val2.radioAudio.loop = CruiserTunesMod.DoLoop.Value;
}
}
public static void ChangeVolume(object sender, EventArgs e)
{
Object val = Object.FindObjectOfType(typeof(VehicleController));
VehicleController val2 = (VehicleController)(object)((val is VehicleController) ? val : null);
if (val2 != null)
{
val2.radioAudio.volume = Mathf.Clamp(CruiserTunesMod.Volume.Value, 0f, 1.25f);
}
}
[HarmonyPatch(typeof(VehicleController), "ChangeRadioStation")]
[HarmonyPostfix]
public static void ChangeRadioStationPatch(VehicleController __instance)
{
float playbackTime = 0f;
if (CruiserTunesMod.DoRandomTime != null && CruiserTunesMod.DoRandomTime.Value && (Object)(object)__instance.radioAudio != (Object)null && (Object)(object)__instance.radioAudio.clip != (Object)null && __instance.radioAudio.clip.length > 0f)
{
float num = Math.Max(0.01f, __instance.radioAudio.clip.length - 0.1f);
playbackTime = Random.Range(0.01f, num);
}
if (CruiserTunesMod.SyncPlaybackTimeMessage != null)
{
FieldInfo field = ((object)__instance).GetType().GetField("currentRadioClip", BindingFlags.Instance | BindingFlags.NonPublic);
int station = ((field != null) ? ((int)field.GetValue(__instance)) : 0);
CruiserTunesMod.RadioSyncData radioSyncData = default(CruiserTunesMod.RadioSyncData);
radioSyncData.Station = station;
radioSyncData.PlaybackTime = playbackTime;
CruiserTunesMod.RadioSyncData radioSyncData2 = radioSyncData;
CruiserTunesMod.PendingSyncData = radioSyncData2;
CruiserTunesMod.SyncPlaybackTimeMessage.SendClients(radioSyncData2);
}
}
[HarmonyPatch(typeof(VehicleController), "SetRadioOnLocalClient")]
[HarmonyPrefix]
public static void SetOnClientPatch(VehicleController __instance)
{
Type type = ((object)__instance).GetType();
FieldInfo field = type.GetField("currentRadioClip", BindingFlags.Instance | BindingFlags.NonPublic);
field.SetValue(__instance, (int)field.GetValue(__instance) % __instance.radioClips.Length);
}
[HarmonyPatch(typeof(VehicleController), "SetRadioValues")]
[HarmonyPrefix]
public static void SetRadioValuesPatch(VehicleController __instance)
{
if (CruiserTunesMod.GoodQuality.Value)
{
__instance.radioAudio.volume = 1f;
__instance.radioInterference.volume = 0f;
}
}
[HarmonyPatch(typeof(VehicleController), "SwitchRadio")]
[HarmonyPrefix]
public static void SwitchRadioPatch(VehicleController __instance)
{
}
[IteratorStateMachine(typeof(<AudioSourceListener>d__7))]
public static IEnumerator AudioSourceListener(AudioSource radio, VehicleController instance)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <AudioSourceListener>d__7(0)
{
radio = radio,
instance = instance
};
}
[IteratorStateMachine(typeof(<PlayNotification>d__8))]
public static IEnumerator PlayNotification(VehicleController instance)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <PlayNotification>d__8(0)
{
instance = instance
};
}
public static string FormatLength(float lengthInSeconds)
{
int num = Mathf.FloorToInt(lengthInSeconds / 3600f);
int num2 = Mathf.FloorToInt(lengthInSeconds % 3600f / 60f);
int num3 = Mathf.FloorToInt(lengthInSeconds % 60f);
return $"{num:00}:{num2:00}:{num3:00}";
}
[IteratorStateMachine(typeof(<EnsureClipReadyAndPlay>d__10))]
public static IEnumerator EnsureClipReadyAndPlay(AudioSource audio)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <EnsureClipReadyAndPlay>d__10(0)
{
audio = audio
};
}
public static void ChangeRadioStationWithoutServer(VehicleController instance)
{
Type type = ((object)instance).GetType();
FieldInfo field = type.GetField("radioSignalDecreaseThreshold", BindingFlags.Instance | BindingFlags.NonPublic);
FieldInfo field2 = type.GetField("radioSignalQuality", BindingFlags.Instance | BindingFlags.NonPublic);
FieldInfo field3 = type.GetField("currentRadioClip", BindingFlags.Instance | BindingFlags.NonPublic);
int num = ((int)field3.GetValue(instance) + 1) % instance.radioClips.Length;
field3.SetValue(instance, num);
instance.radioAudio.clip = instance.radioClips[num];
if ((Object)(object)CruiserTunesMod.instance != (Object)null)
{
((MonoBehaviour)CruiserTunesMod.instance).StartCoroutine(EnsureClipReadyAndPlay(instance.radioAudio));
}
else
{
if (CruiserTunesMod.DoRandomTime.Value && (Object)(object)instance.radioAudio.clip != (Object)null && instance.radioAudio.clip.length > 0f)
{
float num2 = Math.Max(0.01f, instance.radioAudio.clip.length - 0.1f);
instance.radioAudio.time = Random.Range(0.01f, num2);
}
else
{
instance.radioAudio.time = 0f;
}
instance.radioAudio.Play();
}
float num3 = 10f;
float num4 = (float)field2.GetValue(instance);
switch ((int)Mathf.Round(num4))
{
case 3:
num4 = 1f;
num3 = 10f;
break;
case 0:
num4 = 3f;
num3 = 90f;
break;
case 1:
num4 = 2f;
num3 = 70f;
break;
case 2:
num4 = 1f;
num3 = 30f;
break;
}
field2.SetValue(instance, num4);
field.SetValue(instance, num3);
ChangeRadioStationPatch(instance);
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("Mellowdy.CruiserTunes", "CruiserTunes", "1.3.0")]
public class CruiserTunesMod : BaseUnityPlugin
{
[Serializable]
public struct RadioSyncData
{
public int Station;
public float PlaybackTime;
}
[CompilerGenerated]
private sealed class <EndOfPatch>d__23 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
private bool <finishedLoading>5__1;
private bool[] <array>5__2;
private int <i>5__3;
private string <currentDirectory>5__4;
private string <path>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <EndOfPatch>d__23(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<array>5__2 = null;
<currentDirectory>5__4 = null;
<path>5__5 = null;
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
goto IL_00ea;
}
<>1__state = -1;
mls.LogInfo((object)("Loading " + instance.loadingList.Length + " songs"));
<finishedLoading>5__1 = false;
goto IL_00f2;
IL_00ea:
<array>5__2 = null;
goto IL_00f2;
IL_00f2:
if (!<finishedLoading>5__1)
{
<finishedLoading>5__1 = true;
<array>5__2 = instance.loadingList;
<i>5__3 = 0;
while (<i>5__3 < <array>5__2.Length)
{
if (!<array>5__2[<i>5__3])
{
<finishedLoading>5__1 = false;
break;
}
<i>5__3++;
}
if (!<finishedLoading>5__1)
{
<>2__current = null;
<>1__state = 1;
return true;
}
goto IL_00ea;
}
instance.loadingList = null;
mls.LogInfo((object)("Finished loading songs, final song count at:" + instance.SongList.Count));
if (instance.SongList.Count == 0)
{
<currentDirectory>5__4 = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
<path>5__5 = Path.Combine(<currentDirectory>5__4, instance.folderName).Replace("\\", "/");
mls.LogError((object)"No songs found in folder");
mls.LogError((object)("Make sure to add any .mp3 or .wav or .ogg files you want as songs to: '" + <path>5__5 + "'"));
<currentDirectory>5__4 = null;
<path>5__5 = null;
}
CustomSongs = instance.SongList.ToArray();
instance.SongList.Clear();
HasSongs = CustomSongs.Length != 0 || IncludeOriginal.Value;
mls.LogInfo((object)"CruiserTunes has been loaded with loleo's fix");
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <EnsureClipReadyAndPlay>d__31 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public AudioSource audio;
private float <timeout>5__1;
private float <start>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <EnsureClipReadyAndPlay>d__31(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<timeout>5__1 = 5f;
<start>5__2 = Time.time;
break;
case 1:
<>1__state = -1;
break;
}
if (((Object)(object)audio == (Object)null || (Object)(object)audio.clip == (Object)null || audio.clip.length <= 0f || !audio.clip.isReadyToPlay) && !(Time.time - <start>5__2 > <timeout>5__1))
{
<>2__current = null;
<>1__state = 1;
return true;
}
if ((Object)(object)audio == (Object)null || (Object)(object)audio.clip == (Object)null || audio.clip.length <= 0f)
{
return false;
}
if (!audio.isPlaying)
{
audio.Play();
}
audio.time = Mathf.Clamp(audio.time, 0.01f, audio.clip.length - 0.1f);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <EnsureClipReadyAndPlayAt>d__30 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public AudioSource audio;
public float timeToSet;
private float <timeout>5__1;
private float <start>5__2;
private float <clampedTime>5__3;
private float <guardEnd>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <EnsureClipReadyAndPlayAt>d__30(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<timeout>5__1 = 5f;
<start>5__2 = Time.time;
goto IL_0079;
case 1:
<>1__state = -1;
goto IL_0079;
case 2:
{
<>1__state = -1;
break;
}
IL_0079:
if (((Object)(object)audio == (Object)null || (Object)(object)audio.clip == (Object)null || audio.clip.length <= 0f || !audio.clip.isReadyToPlay) && !(Time.time - <start>5__2 > <timeout>5__1))
{
<>2__current = null;
<>1__state = 1;
return true;
}
if ((Object)(object)audio == (Object)null || (Object)(object)audio.clip == (Object)null || audio.clip.length <= 0f)
{
return false;
}
<clampedTime>5__3 = Mathf.Clamp(timeToSet, 0.01f, audio.clip.length - 0.1f);
if (!audio.isPlaying)
{
audio.Play();
}
audio.time = <clampedTime>5__3;
<guardEnd>5__4 = Time.time + 0.5f;
break;
}
if (Time.time < <guardEnd>5__4)
{
if ((Object)(object)audio == (Object)null || (Object)(object)audio.clip == (Object)null)
{
return false;
}
if (Mathf.Abs(audio.time - <clampedTime>5__3) > 0.5f)
{
audio.time = <clampedTime>5__3;
}
<>2__current = null;
<>1__state = 2;
return true;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <LoadAudioClip>d__24 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public string filePath;
public int index;
public string fileType;
private float <loadingTime>5__1;
private float <maxLoading>5__2;
private string <fileName>5__3;
private AudioType <audioType>5__4;
private UnityWebRequest <loader>5__5;
private AudioClip <content>5__6;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LoadAudioClip>d__24(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 1)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<fileName>5__3 = null;
<loader>5__5 = null;
<content>5__6 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
bool result;
try
{
switch (<>1__state)
{
default:
result = false;
goto end_IL_0000;
case 0:
<>1__state = -1;
<loadingTime>5__1 = Time.time;
<maxLoading>5__2 = 5f;
<fileName>5__3 = Path.GetFileName(filePath);
mls.LogInfo((object)("Loading " + <fileName>5__3));
<audioType>5__4 = GetAudioType(fileType);
<loader>5__5 = UnityWebRequestMultimedia.GetAudioClip(filePath, <audioType>5__4);
<>1__state = -3;
<loader>5__5.SendWebRequest();
break;
case 1:
<>1__state = -3;
break;
}
if (!<loader>5__5.isDone)
{
if (<loadingTime>5__1 + <maxLoading>5__2 < Time.time)
{
mls.LogError((object)("Error loading clip from path: " + <fileName>5__3));
instance.loadingList[index] = true;
result = false;
goto IL_01c7;
}
<>2__current = null;
<>1__state = 1;
result = true;
}
else
{
instance.loadingList[index] = true;
if (<loader>5__5.error != null)
{
mls.LogError((object)("Error loading clip from path: " + <fileName>5__3 + "\n" + <loader>5__5.error));
result = false;
goto IL_01c7;
}
<content>5__6 = DownloadHandlerAudioClip.GetContent(<loader>5__5);
((Object)<content>5__6).name = <fileName>5__3;
instance.SongList.Add(<content>5__6);
<content>5__6 = null;
<>m__Finally1();
result = false;
}
goto end_IL_0000;
IL_01c7:
<>m__Finally1();
end_IL_0000:;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
return result;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
((IDisposable)<loader>5__5)?.Dispose();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <WaitForSyncThenPlay>d__29 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public AudioSource audio;
public int expectedStation;
private float <timeout>5__1;
private float <start>5__2;
private float <timeToApply>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForSyncThenPlay>d__29(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<timeout>5__1 = 0.5f;
<start>5__2 = Time.time;
goto IL_0082;
case 1:
<>1__state = -1;
goto IL_0082;
case 2:
<>1__state = -1;
break;
case 3:
{
<>1__state = -1;
break;
}
IL_0082:
if ((!PendingSyncData.HasValue || PendingSyncData.Value.Station != expectedStation) && !(Time.time - <start>5__2 > <timeout>5__1))
{
<>2__current = null;
<>1__state = 1;
return true;
}
if (PendingSyncData.HasValue && PendingSyncData.Value.Station == expectedStation)
{
<timeToApply>5__3 = PendingSyncData.Value.PlaybackTime;
PendingSyncData = null;
<>2__current = EnsureClipReadyAndPlayAt(audio, <timeToApply>5__3);
<>1__state = 2;
return true;
}
PendingSyncData = null;
<>2__current = EnsureClipReadyAndPlay(audio);
<>1__state = 3;
return true;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private const string modGUID = "Mellowdy.CruiserTunes";
private const string modName = "CruiserTunes";
private const string modVersion = "1.3.0";
private readonly Harmony harmony = new Harmony("Mellowdy.CruiserTunes");
public static ManualLogSource mls;
public static CruiserTunesMod instance;
public static ConfigEntry<bool> IncludeOriginal;
public static ConfigEntry<bool> DoMessage;
public static ConfigEntry<bool> DoLoop;
public static ConfigEntry<bool> DoRandomTime;
public static ConfigEntry<bool> GoodQuality;
public static ConfigEntry<float> Volume;
public static bool HasSongs;
public static AudioClip[] CustomSongs;
public static LNetworkMessage<RadioSyncData> SyncPlaybackTimeMessage;
public static RadioSyncData? PendingSyncData;
private const string supportedAudioFileTypes = ".mp3 or .wav or .ogg";
private string folderName = "CustomSongs";
private string altFolderName = "Custom Songs";
private List<AudioClip> SongList = new List<AudioClip>();
private bool[] loadingList;
private void Awake()
{
if ((Object)(object)instance == (Object)null)
{
instance = this;
}
mls = ((BaseUnityPlugin)this).Logger;
mls.LogInfo((object)"Loading...");
Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
IncludeOriginal = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "Include Original Songs", true, "The radio is able to play the orignal songs");
DoMessage = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "Notify When New Song", true, "The radio notifies nearby players what song is now playing");
DoLoop = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "Loop", false, "The radio loops songs upon completion");
DoLoop.SettingChanged += CarPatch.UpdateLooping;
DoRandomTime = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "Random Start Time", false, "The randomly picks a point in the song to start playing when switching channels");
GoodQuality = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "Always have good quality", true, "When switching between channels the quality will remain good");
Volume = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "Volume", 0.75f, "Volume of the radio (does not require restart)");
Volume.SettingChanged += CarPatch.ChangeVolume;
SyncPlaybackTimeMessage = LNetworkMessage<RadioSyncData>.Connect("CruiserTunes_SyncTime", (Action<RadioSyncData, ulong>)null, (Action<RadioSyncData>)OnSyncDataReceived, (Action<RadioSyncData, ulong>)null);
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string text = Path.Combine(directoryName, folderName);
List<string> list = new List<string>();
List<string> list2 = new List<string>();
string text2 = Path.Combine(Directory.GetParent(directoryName).FullName, folderName);
string text3 = Path.Combine(Directory.GetParent(directoryName).FullName, altFolderName);
if (Directory.Exists(text2))
{
list.Add(text2);
}
else if (Directory.Exists(text3))
{
list.Add(text3);
}
string text4 = Path.Combine(Directory.GetParent(directoryName).Parent.FullName, altFolderName);
if (Directory.Exists(text4))
{
list.Add(text4);
}
string[] directories = Directory.GetDirectories(Directory.GetParent(directoryName).FullName);
string[] array = directories;
foreach (string path in array)
{
string text5 = Path.Combine(path, folderName);
if (Directory.Exists(text5))
{
list.Add(text5);
}
}
if (list.Count == 0)
{
Directory.CreateDirectory(text);
mls.LogWarning((object)("Folder not found. One has been created at: '" + text + "'"));
return;
}
foreach (string item in list)
{
list2.AddRange(Directory.GetFiles(item));
}
list2 = RemoveDuplicateFiles(list2);
bool flag = false;
loadingList = new bool[list2.Count];
for (int j = 0; j < list2.Count; j++)
{
string text6 = list2[j];
loadingList[j] = false;
string fileName = Path.GetFileName(text6);
string text7 = Path.GetExtension(text6).ToLower();
if (text7 == ".mp3" || text7 == ".wav" || text7 == ".ogg")
{
((MonoBehaviour)this).StartCoroutine(LoadAudioClip(text6, j, text7));
continue;
}
loadingList[j] = true;
if (text7 != ".old")
{
mls.LogWarning((object)(fileName + " is of invalid extention. Must be a .mp3 or .wav or .ogg file or .old file"));
if (!flag)
{
mls.LogWarning((object)".old files ignore this message being printed.");
}
flag = true;
}
}
if (loadingList.Length == 0)
{
mls.LogError((object)"No songs found");
}
harmony.PatchAll(typeof(CruiserTunesMod));
harmony.PatchAll(typeof(CarPatch));
((MonoBehaviour)this).StartCoroutine(EndOfPatch());
}
[IteratorStateMachine(typeof(<EndOfPatch>d__23))]
private static IEnumerator EndOfPatch()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <EndOfPatch>d__23(0);
}
[IteratorStateMachine(typeof(<LoadAudioClip>d__24))]
private static IEnumerator LoadAudioClip(string filePath, int index, string fileType)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LoadAudioClip>d__24(0)
{
filePath = filePath,
index = index,
fileType = fileType
};
}
public static AudioType GetAudioType(string fileType)
{
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
if (1 == 0)
{
}
int num = fileType switch
{
".mp3" => 13,
".wav" => 20,
".ogg" => 14,
_ => 13,
};
if (1 == 0)
{
}
return (AudioType)num;
}
public static List<string> RemoveDuplicateFiles(List<string> filePaths)
{
HashSet<string> hashSet = new HashSet<string>();
List<string> list = new List<string>();
foreach (string filePath in filePaths)
{
string fileName = Path.GetFileName(filePath);
if (!hashSet.Contains(fileName))
{
hashSet.Add(fileName);
list.Add(filePath);
}
}
return list;
}
private static void OnSyncDataReceived(RadioSyncData data)
{
PendingSyncData = data;
VehicleController val = Object.FindObjectOfType<VehicleController>();
if ((Object)(object)val != (Object)null && (Object)(object)val.radioAudio != (Object)null && (Object)(object)val.radioAudio.clip != (Object)null && data.Station >= 0 && data.Station < val.radioClips.Length && (Object)(object)val.radioAudio.clip == (Object)(object)val.radioClips[data.Station] && data.PlaybackTime > 0f)
{
val.radioAudio.time = Mathf.Clamp(data.PlaybackTime, 0.01f, val.radioAudio.clip.length - 0.1f);
PendingSyncData = null;
}
}
[HarmonyPatch(typeof(VehicleController), "SetRadioStationClientRpc")]
[HarmonyPostfix]
public static void SetRadioStationPatch(ref int radioStation, VehicleController __instance)
{
if (radioStation < 0 || radioStation >= __instance.radioClips.Length)
{
return;
}
__instance.radioAudio.clip = __instance.radioClips[radioStation];
if (PendingSyncData.HasValue && PendingSyncData.Value.Station == radioStation)
{
float playbackTime = PendingSyncData.Value.PlaybackTime;
PendingSyncData = null;
if ((Object)(object)instance != (Object)null)
{
((MonoBehaviour)instance).StartCoroutine(EnsureClipReadyAndPlayAt(__instance.radioAudio, playbackTime));
return;
}
if (!__instance.radioAudio.isPlaying)
{
__instance.radioAudio.Play();
}
__instance.radioAudio.time = playbackTime;
}
else if ((Object)(object)instance != (Object)null)
{
((MonoBehaviour)instance).StartCoroutine(WaitForSyncThenPlay(__instance.radioAudio, radioStation));
}
else
{
__instance.radioAudio.Play();
}
}
[IteratorStateMachine(typeof(<WaitForSyncThenPlay>d__29))]
private static IEnumerator WaitForSyncThenPlay(AudioSource audio, int expectedStation)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForSyncThenPlay>d__29(0)
{
audio = audio,
expectedStation = expectedStation
};
}
[IteratorStateMachine(typeof(<EnsureClipReadyAndPlayAt>d__30))]
public static IEnumerator EnsureClipReadyAndPlayAt(AudioSource audio, float timeToSet)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <EnsureClipReadyAndPlayAt>d__30(0)
{
audio = audio,
timeToSet = timeToSet
};
}
[IteratorStateMachine(typeof(<EnsureClipReadyAndPlay>d__31))]
public static IEnumerator EnsureClipReadyAndPlay(AudioSource audio)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <EnsureClipReadyAndPlay>d__31(0)
{
audio = audio
};
}
}
