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.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("EnderGuy77")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("EnderGuy77")]
[assembly: AssemblyTitle("Chained_Together")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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.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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace Chained_Together
{
[BepInPlugin("EnderGuy77-SeparationTracker", "Separation Tracker (Photon-aware)", "1.9.1")]
public class SeparationTracker : BaseUnityPlugin
{
private enum PlayerState
{
Alive,
Dead,
PassedOut,
LoggedOff,
Rejoining
}
[CompilerGenerated]
private sealed class <CountSeparationWithDelay>d__22 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public SeparationTracker <>4__this;
public (Transform, Transform) pair;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CountSeparationWithDelay>d__22(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Expected O, but got Unknown
//IL_004a: 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)
int num = <>1__state;
SeparationTracker separationTracker = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(separationTracker.separationDelay);
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
float num2 = Vector3.Distance(pair.Item1.position, pair.Item2.position);
if (num2 > 70f)
{
separationTracker.separatedPairs.Add(pair);
separationTracker.separationCount++;
string text = $"Separation detected between {((Object)pair.Item1).name} and {((Object)pair.Item2).name} | Total: {separationTracker.separationCount}";
((BaseUnityPlugin)separationTracker).Logger.LogInfo((object)text);
File.AppendAllText(separationTracker.logFilePath, $"[{DateTime.Now:HH:mm:ss.fff}] {text}\n");
}
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 float distanceThreshold = 70f;
private float separationCooldown = 1.5f;
private float separationDelay = 2.5f;
private bool showGUI = true;
private bool inGame;
private List<(Transform, Transform)> separatedPairs = new List<(Transform, Transform)>();
private List<Transform> players = new List<Transform>();
private int separationCount;
private float separationTimer;
private string logFilePath = "";
private Dictionary<int, Transform> actorToTransform = new Dictionary<int, Transform>();
private HashSet<int> activeActors = new HashSet<int>();
private HashSet<int> rejoiningActors = new HashSet<int>();
private HashSet<int> prevActorNumbers = new HashSet<int>();
private PlayerState playerState;
private void Awake()
{
SceneManager.activeSceneChanged += OnSceneChanged;
CreateNewSessionFile();
UpdateNetworkPlayers();
}
private void Update()
{
if (Input.GetKeyDown((KeyCode)291))
{
showGUI = !showGUI;
}
if (Input.GetKeyDown((KeyCode)278) && !inGame)
{
SaveLogFile();
}
UpdateNetworkPlayers();
UpdatePlayerState();
if (playerState == PlayerState.LoggedOff || playerState == PlayerState.PassedOut || playerState == PlayerState.Dead)
{
return;
}
if (playerState == PlayerState.Rejoining)
{
if (!CheckIfLocalPlayerCloseToActive())
{
return;
}
playerState = PlayerState.Alive;
}
ActivateRejoiningRemotePlayers();
separationTimer += Time.deltaTime;
if (separationTimer >= separationCooldown)
{
CheckSeparations();
separationTimer = 0f;
}
}
private void UpdateNetworkPlayers()
{
try
{
Player[] playerList = PhotonNetwork.PlayerList;
HashSet<int> hashSet = new HashSet<int>(playerList.Select((Player p) => p.ActorNumber));
foreach (int item in prevActorNumbers.Except(hashSet))
{
if (actorToTransform.TryGetValue(item, out Transform t))
{
RemovePairsWithTransform(t);
actorToTransform.Remove(item);
players.RemoveAll((Transform x) => (Object)(object)x == (Object)(object)t);
}
activeActors.Remove(item);
rejoiningActors.Remove(item);
}
foreach (int item2 in hashSet.Except(prevActorNumbers))
{
MapActorsToTransforms();
rejoiningActors.Add(item2);
activeActors.Remove(item2);
}
MapActorsToTransforms();
prevActorNumbers = hashSet;
}
catch (Exception arg)
{
((BaseUnityPlugin)this).Logger.LogError((object)$"UpdateNetworkPlayers error: {arg}");
}
}
private void MapActorsToTransforms()
{
PhotonView[] array = Object.FindObjectsByType<PhotonView>((FindObjectsSortMode)0);
PhotonView[] array2 = array;
foreach (PhotonView val in array2)
{
if (val.OwnerActorNr <= 0)
{
continue;
}
Transform transform = ((Component)val).transform;
Transform val2 = transform.Find("Scout/Misc/CharacterLight");
if ((Object)(object)val2 == (Object)null)
{
continue;
}
int ownerActorNr = val.OwnerActorNr;
if (!actorToTransform.ContainsKey(ownerActorNr) || (Object)(object)actorToTransform[ownerActorNr] == (Object)null)
{
actorToTransform[ownerActorNr] = val2;
if (!players.Contains(val2))
{
players.Add(val2);
}
}
}
List<int> list = (from kv in actorToTransform
where (Object)(object)kv.Value == (Object)null
select kv.Key).ToList();
foreach (int item in list)
{
actorToTransform.Remove(item);
activeActors.Remove(item);
rejoiningActors.Remove(item);
}
}
private void ActivateRejoiningRemotePlayers()
{
//IL_00bd: 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_0116: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
if (rejoiningActors.Count == 0)
{
return;
}
List<Transform> list = (from a in activeActors
where actorToTransform.ContainsKey(a)
select actorToTransform[a] into t
where (Object)(object)t != (Object)null
select t).ToList();
foreach (int item in rejoiningActors.ToList())
{
if (!actorToTransform.TryGetValue(item, out Transform value) || (Object)(object)value == (Object)null)
{
continue;
}
bool flag = false;
if (list.Count > 0)
{
foreach (Transform item2 in list)
{
if (Vector3.Distance(value.position, item2.position) < 70f)
{
flag = true;
break;
}
}
}
else
{
foreach (Transform player in players)
{
if ((Object)(object)player != (Object)(object)value && Vector3.Distance(value.position, player.position) < 70f)
{
flag = true;
break;
}
}
}
if (flag)
{
rejoiningActors.Remove(item);
activeActors.Add(item);
}
}
}
private void CheckSeparations()
{
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
players = actorToTransform.Values.Where((Transform t) => (Object)(object)t != (Object)null).ToList();
for (int i = 0; i < players.Count; i++)
{
for (int j = i + 1; j < players.Count; j++)
{
Transform p1 = players[i];
Transform p2 = players[j];
if ((Object)(object)p1 == (Object)null || (Object)(object)p2 == (Object)null)
{
continue;
}
int key = actorToTransform.FirstOrDefault<KeyValuePair<int, Transform>>((KeyValuePair<int, Transform> kv) => (Object)(object)kv.Value == (Object)(object)p1).Key;
int key2 = actorToTransform.FirstOrDefault<KeyValuePair<int, Transform>>((KeyValuePair<int, Transform> kv) => (Object)(object)kv.Value == (Object)(object)p2).Key;
if (!rejoiningActors.Contains(key) && !rejoiningActors.Contains(key2))
{
float num = Vector3.Distance(p1.position, p2.position);
(Transform, Transform) tuple = (p1, p2);
(Transform, Transform) item = (p2, p1);
if (num > 70f && !separatedPairs.Contains(tuple) && !separatedPairs.Contains(item))
{
((MonoBehaviour)this).StartCoroutine(CountSeparationWithDelay(tuple));
}
if (num < 70f && (separatedPairs.Contains(tuple) || separatedPairs.Contains(item)))
{
separatedPairs.Remove(tuple);
separatedPairs.Remove(item);
}
}
}
}
}
[IteratorStateMachine(typeof(<CountSeparationWithDelay>d__22))]
private IEnumerator CountSeparationWithDelay((Transform, Transform) pair)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CountSeparationWithDelay>d__22(0)
{
<>4__this = this,
pair = pair
};
}
private void RemovePairsWithTransform(Transform t)
{
Transform t2 = t;
separatedPairs.RemoveAll(((Transform, Transform) p) => (Object)(object)p.Item1 == (Object)(object)t2 || (Object)(object)p.Item2 == (Object)(object)t2);
}
private bool CheckIfLocalPlayerCloseToActive()
{
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
try
{
Character localCharacter = Character.localCharacter;
Transform local = ((localCharacter != null) ? ((Component)localCharacter).transform : null);
if ((Object)(object)local == (Object)null)
{
return false;
}
List<Transform> list = (from a in activeActors
where actorToTransform.ContainsKey(a)
select actorToTransform[a] into t
where (Object)(object)t != (Object)null && (Object)(object)t != (Object)(object)local
select t).ToList();
foreach (Transform item in list)
{
if (Vector3.Distance(local.position, item.position) < 70f)
{
return true;
}
}
List<Transform> list2 = players.Where((Transform p) => (Object)(object)p != (Object)null && (Object)(object)p != (Object)(object)local).ToList();
foreach (Transform item2 in list2)
{
if (Vector3.Distance(local.position, item2.position) < 70f)
{
return true;
}
}
}
catch
{
}
return false;
}
private void UpdatePlayerState()
{
try
{
if (!PhotonNetwork.IsConnected)
{
playerState = PlayerState.LoggedOff;
return;
}
Character localCharacter = Character.localCharacter;
if ((Object)(object)localCharacter == (Object)null)
{
playerState = PlayerState.LoggedOff;
return;
}
CharacterData data = localCharacter.data;
if (playerState == PlayerState.LoggedOff && PhotonNetwork.LocalPlayer != null)
{
playerState = PlayerState.Rejoining;
int actorNumber = PhotonNetwork.LocalPlayer.ActorNumber;
rejoiningActors.Add(actorNumber);
activeActors.Remove(actorNumber);
}
if (data.dead)
{
playerState = PlayerState.Dead;
}
else if (data.passedOut)
{
playerState = PlayerState.PassedOut;
}
else if (playerState != PlayerState.Rejoining)
{
playerState = PlayerState.Alive;
}
}
catch
{
playerState = PlayerState.LoggedOff;
}
}
private void OnGUI()
{
//IL_0030: 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)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
if (showGUI)
{
float num = 350f;
float num2 = ((float)Screen.width - num / 2f) / 2f;
GUI.Label(new Rect(num2, 30f, num, 25f), $"Total Separations: {separationCount}");
GUI.Label(new Rect(num2, 45f, num, 25f), "To hide this UI use F10");
GUI.Label(new Rect(num2, 60f, num, 25f), "To save logs use Home");
}
}
private string ComputeHash(string input)
{
using SHA256 sHA = SHA256.Create();
byte[] bytes = Encoding.UTF8.GetBytes(input);
byte[] inArray = sHA.ComputeHash(bytes);
return Convert.ToBase64String(inArray);
}
private void OnSceneChanged(Scene newScene, Scene oldScene)
{
inGame = ((Scene)(ref newScene)).name != "Title";
}
private void SaveLogFile()
{
try
{
string text = $"--- Separation Log ({DateTime.Now}) ---\n";
text += $"Total Separations: {separationCount}\n";
string text2 = ComputeHash(text);
text = text + "Hash: " + text2 + "\n\n";
Directory.CreateDirectory(Path.GetDirectoryName(logFilePath));
File.AppendAllText(logFilePath, text);
((BaseUnityPlugin)this).Logger.LogInfo((object)"Separation data manually saved (F9).");
separationCount = 0;
separatedPairs.Clear();
}
catch (Exception arg)
{
((BaseUnityPlugin)this).Logger.LogError((object)$"Failed to save log file: {arg}");
}
}
private void CreateNewSessionFile()
{
string path = "SeparationLog.txt";
logFilePath = Path.Combine(Paths.BepInExRootPath, path);
File.WriteAllText(logFilePath, $"Session started at {DateTime.Now}\n");
((BaseUnityPlugin)this).Logger.LogInfo((object)("Created new session log file: " + logFilePath));
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
