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.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using ShuffleShift.ActiveObject;
using ShuffleShift.Configurations;
using ShuffleShift.Patches;
using StaticNetcodeLib;
using TheWeavers.ShuffleShift.NetcodePatcher;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("TheWeavers.ShuffleShift")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1+6fc5b0ca20f1073d721b78dfbdf58d0d7ef2ae39")]
[assembly: AssemblyProduct("ShuffleShift")]
[assembly: AssemblyTitle("TheWeavers.ShuffleShift")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
static <Module>()
{
}
}
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[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;
}
}
}
namespace ShuffleShift
{
[BepInPlugin("TheWeavers.ShuffleShift", "ShuffleShift", "1.0.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Logger;
public static AssetBundle? ModAssets;
private readonly Harmony harmony = new Harmony("TheWeavers.ShuffleShift");
public static Config ShuffleShiftConfig { get; internal set; }
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
ShuffleShiftConfig = new Config(((BaseUnityPlugin)this).Config);
Logger.LogInfo((object)"Loading : TheWeavers.ShuffleShift Version : 1.0.1");
harmony.PatchAll(typeof(ConfigurationsPatch));
harmony.PatchAll(typeof(StartOfRoundPatch));
Logger.LogInfo((object)"Patch applied and ready to play!");
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "TheWeavers.ShuffleShift";
public const string PLUGIN_NAME = "ShuffleShift";
public const string PLUGIN_VERSION = "1.0.1";
}
}
namespace ShuffleShift.Patches
{
[HarmonyPatch(typeof(RoundManager))]
internal class RoundManagerPatch
{
[HarmonyPatch("UnloadSceneObjectsEarly")]
[HarmonyPostfix]
private static void UnloadSceneObjectEarly(RoundManager __instance)
{
SwapPositionHandler[] array = Object.FindObjectsOfType<SwapPositionHandler>();
foreach (SwapPositionHandler swapPositionHandler in array)
{
if ((Object)(object)swapPositionHandler != (Object)null)
{
if (swapPositionHandler.swapCoroutine != null)
{
((MonoBehaviour)swapPositionHandler).StopCoroutine(swapPositionHandler.swapCoroutine);
}
Object.Destroy((Object)(object)((Component)swapPositionHandler).gameObject);
}
}
}
[HarmonyPatch("StartGame")]
[HarmonyPostfix]
private static void PostfixSpawn()
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Expected O, but got Unknown
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
SwapPositionHandler[] array = Object.FindObjectsOfType<SwapPositionHandler>();
foreach (SwapPositionHandler swapPositionHandler in array)
{
if ((Object)(object)swapPositionHandler != (Object)null)
{
if (swapPositionHandler.swapCoroutine != null)
{
((MonoBehaviour)swapPositionHandler).StopCoroutine(swapPositionHandler.swapCoroutine);
}
Object.Destroy((Object)(object)((Component)swapPositionHandler).gameObject);
}
}
if (!((NetworkBehaviour)RoundManager.Instance).IsHost)
{
return;
}
Scene sceneByName = SceneManager.GetSceneByName("SampleSceneRelay");
if (!((Scene)(ref sceneByName)).IsValid() || !((Scene)(ref sceneByName)).isLoaded)
{
return;
}
GameObject[] rootGameObjects = ((Scene)(ref sceneByName)).GetRootGameObjects();
bool flag = false;
GameObject[] array2 = rootGameObjects;
foreach (GameObject val in array2)
{
if (((Object)val).name == "ShuffleSwapHandler")
{
flag = true;
break;
}
}
if ((Object)(object)SwapPositionHandler.Instance == (Object)null && !flag)
{
GameObject val2 = new GameObject("ShuffleSwapHandler");
val2.AddComponent<SwapPositionHandler>();
SceneManager.MoveGameObjectToScene(val2, sceneByName);
}
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal class StartOfRoundPatch
{
[HarmonyPatch("EndGameServerRpc")]
[HarmonyPostfix]
private static void UnloadSceneObjectEarly(RoundManager __instance)
{
if ((Object)(object)SwapPositionHandler.Instance != (Object)null)
{
SwapPositionHandler.Instance.DestroyManager();
}
}
[HarmonyPatch("StartGame")]
[HarmonyPostfix]
private static void PostfixSpawn()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
if ((Object)(object)SwapPositionHandler.Instance == (Object)null)
{
GameObject val = new GameObject("ShuffleSwapHandler");
val.AddComponent<SwapPositionHandler>();
}
}
}
}
namespace ShuffleShift.Configurations
{
[Serializable]
public class Config : SyncedInstance<Config>
{
public ConfigEntry<bool> ENABLE_POSITION_SWAP { get; private set; }
public ConfigEntry<float> TIME_BETWEEN_SWAP { get; private set; }
public ConfigEntry<float> TIME_BEFORE_FIRST_SWAP { get; private set; }
public ConfigEntry<int> CHANCE_FOR_SWAP_TO_HAPPEN { get; private set; }
public ConfigEntry<bool> ENABLE_SCREEN_SHAKE { get; private set; }
public Config(ConfigFile cfg)
{
InitInstance(this);
ENABLE_POSITION_SWAP = cfg.Bind<bool>("Position Swap", "Enable position swap", true, "Set to true if you want the position swap to possibly happen");
TIME_BETWEEN_SWAP = cfg.Bind<float>("Position Swap", "Time Between each swap", 45f, "How much time between each position swap of the players!");
TIME_BEFORE_FIRST_SWAP = cfg.Bind<float>("Position Swap", "Time before the first swap", 30f, "Time before the first swap occurs");
CHANCE_FOR_SWAP_TO_HAPPEN = cfg.Bind<int>("Position Swap", "Chance of the swap happening", 100, "Chance in percentage for the position swap to happen. Must not be lower than 0");
ENABLE_SCREEN_SHAKE = cfg.Bind<bool>("Position Swap", "Make the screen shake when teleporting", false, "true the screen shake will be, false, it will not");
}
public static void RequestSync()
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
if (!SyncedInstance<Config>.IsClient)
{
return;
}
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(SyncedInstance<Config>.IntSize, (Allocator)2, -1);
try
{
SyncedInstance<Config>.MessageManager.SendNamedMessage("Xilef992SwapShift_OnRequestConfigSync", 0uL, val, (NetworkDelivery)3);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
public static void OnRequestSync(ulong clientId, FastBufferReader _)
{
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
if (!SyncedInstance<Config>.IsHost)
{
return;
}
Plugin.Logger.LogInfo((object)$"Config sync request received from client: {clientId}");
byte[] array = SyncedInstance<Config>.SerializeToBytes(SyncedInstance<Config>.Instance);
int num = array.Length;
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(num + SyncedInstance<Config>.IntSize, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
SyncedInstance<Config>.MessageManager.SendNamedMessage("Xilef992SwapShift_OnReceiveConfigSync", clientId, val, (NetworkDelivery)3);
}
catch (Exception arg)
{
Plugin.Logger.LogInfo((object)$"Error occurred syncing config with client: {clientId}\n{arg}");
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
public static void OnReceiveSync(ulong _, FastBufferReader reader)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
if (!((FastBufferReader)(ref reader)).TryBeginRead(SyncedInstance<Config>.IntSize))
{
Plugin.Logger.LogError((object)"Config sync error: Could not begin reading buffer.");
return;
}
int num = default(int);
((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
{
Plugin.Logger.LogError((object)"Config sync error: Host could not sync.");
return;
}
byte[] data = new byte[num];
((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
SyncedInstance<Config>.SyncInstance(data);
Plugin.Logger.LogInfo((object)"Successfully synced config with host.");
}
}
public static class ConfigurationsPatch
{
[CompilerGenerated]
private static class <>O
{
public static HandleNamedMessageDelegate <0>__OnRequestSync;
public static HandleNamedMessageDelegate <1>__OnReceiveSync;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
public static void InitializeLocalPlayer()
{
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Expected O, but got Unknown
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
if (((NetworkBehaviour)RoundManager.Instance).IsHost)
{
CustomMessagingManager messageManager = SyncedInstance<Config>.MessageManager;
object obj = <>O.<0>__OnRequestSync;
if (obj == null)
{
HandleNamedMessageDelegate val = Config.OnRequestSync;
<>O.<0>__OnRequestSync = val;
obj = (object)val;
}
messageManager.RegisterNamedMessageHandler("SwapShift_OnRequestConfigSync", (HandleNamedMessageDelegate)obj);
SyncedInstance<Config>.Synced = true;
return;
}
SyncedInstance<Config>.Synced = false;
CustomMessagingManager messageManager2 = SyncedInstance<Config>.MessageManager;
object obj2 = <>O.<1>__OnReceiveSync;
if (obj2 == null)
{
HandleNamedMessageDelegate val2 = Config.OnReceiveSync;
<>O.<1>__OnReceiveSync = val2;
obj2 = (object)val2;
}
messageManager2.RegisterNamedMessageHandler("SwapShift_OnReceiveConfigSync", (HandleNamedMessageDelegate)obj2);
Config.RequestSync();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
public static void PlayerLeave()
{
SyncedInstance<Config>.RevertSync();
}
}
public class SyncedInstance<T>
{
[NonSerialized]
protected static int IntSize = 4;
internal static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;
internal static bool IsClient => NetworkManager.Singleton.IsClient;
internal static bool IsHost => NetworkManager.Singleton.IsHost;
public static T Default { get; private set; }
public static T Instance { get; private set; }
public static bool Synced { get; internal set; }
protected void InitInstance(T instance)
{
Default = instance;
Instance = instance;
IntSize = 4;
}
internal static void SyncInstance(byte[] data)
{
Instance = DeserializeFromBytes(data);
Synced = true;
}
internal static void RevertSync()
{
Instance = Default;
Synced = false;
}
public static byte[] SerializeToBytes(T val)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
using MemoryStream memoryStream = new MemoryStream();
try
{
binaryFormatter.Serialize(memoryStream, val);
return memoryStream.ToArray();
}
catch (Exception arg)
{
Debug.Log((object)$"Error serializing instance: {arg}");
return null;
}
}
public static T DeserializeFromBytes(byte[] data)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
using MemoryStream serializationStream = new MemoryStream(data);
try
{
return (T)binaryFormatter.Deserialize(serializationStream);
}
catch (Exception arg)
{
Debug.Log((object)$"Error deserializing instance: {arg}");
return default(T);
}
}
}
}
namespace ShuffleShift.ActiveObject
{
public class SwapPositionHandler : MonoBehaviour
{
private static SwapPositionHandler _instance;
private int indexOfPick;
private bool isInsideFactory;
private bool isInHangarShipRoom;
public Coroutine swapCoroutine;
public static SwapPositionHandler Instance => _instance;
private IEnumerator ActivationCoroutine()
{
while (true)
{
yield return (object)new WaitForSeconds(Plugin.ShuffleShiftConfig.TIME_BETWEEN_SWAP.Value);
ActivateSwap();
}
}
private void Awake()
{
if ((Object)(object)_instance != (Object)null && (Object)(object)_instance != (Object)(object)this)
{
Object.Destroy((Object)(object)((Component)this).gameObject);
}
else
{
_instance = this;
}
}
private void Start()
{
if (Plugin.ShuffleShiftConfig.ENABLE_POSITION_SWAP.Value && ((NetworkBehaviour)RoundManager.Instance).IsHost)
{
swapCoroutine = ((MonoBehaviour)this).StartCoroutine(ActivationCoroutine());
}
}
public void ActivateSwap()
{
if (RandomNumberGenerator.GetInt32(0, 100) <= Plugin.ShuffleShiftConfig.CHANCE_FOR_SWAP_TO_HAPPEN.Value)
{
PositionHandler.ShufflePlayerTransforms();
}
else
{
Plugin.Logger.LogInfo((object)"Teleport was a miss!");
}
}
public void OnDestroy()
{
((MonoBehaviour)this).StopCoroutine(swapCoroutine);
}
public void DestroyManager()
{
((Behaviour)this).enabled = false;
((MonoBehaviour)this).StopCoroutine(swapCoroutine);
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
[StaticNetcode]
public static class PositionHandler
{
private static bool isInsideFactory;
private static bool isInHangarShipRoom;
private static int indexOfPick;
private const float Y_OFFSET = 1f;
public static void ShufflePlayerTransforms()
{
List<PlayerControllerB> allPlayer = GetAllPlayer();
Plugin.Logger.LogInfo((object)("SWAPPING POSITION OF " + allPlayer.Count + " players !"));
int[] array = Enumerable.Range(0, allPlayer.Count).ToArray();
Shuffle(array);
List<Vector3> list = allPlayer.Select((PlayerControllerB player) => ((Component)player).transform.position).ToList();
List<Quaternion> list2 = allPlayer.Select((PlayerControllerB player) => ((Component)player).transform.rotation).ToList();
FinalizeTeleportClientRpc(array, list.ToArray(), list2.ToArray());
}
[ClientRpc]
private static void FinalizeTeleportClientRpc(int[] indexes, Vector3[] positions, Quaternion[] rotations)
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB[] allPlayerScripts = RoundManager.Instance.playersManager.allPlayerScripts;
for (int i = 0; i < indexes.Length; i++)
{
int num = indexes[i];
PlayerControllerB val = allPlayerScripts[num];
if (val.isPlayerControlled && !val.isPlayerDead)
{
Transform transform = ((Component)val).transform;
positions[i].y += 1f;
transform.position = positions[i];
transform.rotation = rotations[i];
val.isInHangarShipRoom = isInsideFactory;
val.isInHangarShipRoom = isInHangarShipRoom;
}
}
if (Plugin.ShuffleShiftConfig.ENABLE_SCREEN_SHAKE.Value)
{
HUDManager.Instance.DisplayTip("SWAP", $"{indexes.Length} players position got swapped!", false, false, "LC_Tip1");
}
}
private static List<PlayerControllerB> GetAllPlayer()
{
return RoundManager.Instance.playersManager.allPlayerScripts.Where((PlayerControllerB player) => player.isPlayerControlled && !player.isPlayerDead && !player.isClimbingLadder && !player.inTerminalMenu).ToList();
}
private static void Shuffle(int[] array)
{
Random random = new Random();
int num = array.Length;
while (num > 1)
{
num--;
int num2 = random.Next(num + 1);
int num3 = array[num2];
array[num2] = array[num];
array[num] = num3;
}
}
}
}
namespace TheWeavers.ShuffleShift.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
