using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using AtlyssCommandLib.API;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Mirror;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Guid("8f2a7c14-6b03-4d9e-a157-3c8b0e6d42f9")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyTitle("TundrasInstancer")]
[assembly: AssemblyProduct("TundrasInstancer")]
[assembly: AssemblyDescription("Private map instances on command.")]
[assembly: ComVisible(false)]
[assembly: AssemblyVersion("1.0.0.0")]
namespace tundras_instancer;
internal struct MapEntry
{
internal string ScenePath;
internal string Caption;
internal string SpawnTag;
}
internal static class MapCatalog
{
internal static List<MapEntry> Gather()
{
List<MapEntry> list = new List<MapEntry>();
Portal[] array = Resources.FindObjectsOfTypeAll<Portal>();
for (int i = 0; i < array.Length; i++)
{
ScenePortalData scenePortal = array[i]._scenePortal;
if (scenePortal != null)
{
Add(list, scenePortal._subScene, scenePortal._portalCaptionTitle, scenePortal._spawnPointTag);
}
}
ScriptableMapData[] array2 = Resources.FindObjectsOfTypeAll<ScriptableMapData>();
for (int j = 0; j < array2.Length; j++)
{
Add(list, array2[j]._subScene, array2[j]._mapCaptionTitle, array2[j]._spawnPointTag);
}
return list;
}
private static void Add(List<MapEntry> found, string scenePath, string caption, string spawnTag)
{
if (string.IsNullOrEmpty(scenePath))
{
return;
}
for (int i = 0; i < found.Count; i++)
{
if (found[i].ScenePath == scenePath)
{
return;
}
}
found.Add(new MapEntry
{
ScenePath = scenePath,
Caption = (string.IsNullOrEmpty(caption) ? Key(scenePath) : caption),
SpawnTag = (string.IsNullOrEmpty(spawnTag) ? "spawnPoint" : spawnTag)
});
}
internal static string Key(string scenePath)
{
if (string.IsNullOrEmpty(scenePath))
{
return "";
}
int num = scenePath.LastIndexOf('/');
string text = ((num < 0) ? scenePath : scenePath.Substring(num + 1));
if (text.EndsWith(".unity", StringComparison.OrdinalIgnoreCase))
{
text = text.Substring(0, text.Length - 6);
}
return text;
}
internal static bool IsVanilla(string scenePath)
{
return SceneUtility.GetBuildIndexByScenePath(scenePath) >= 0;
}
internal static bool Resolve(string wanted, out MapEntry match)
{
match = default(MapEntry);
if (string.IsNullOrEmpty(wanted))
{
return false;
}
string text = Flatten(wanted);
List<MapEntry> list = Gather();
for (int i = 0; i < list.Count; i++)
{
if (Flatten(Key(list[i].ScenePath)) == text || Flatten(list[i].Caption) == text)
{
match = list[i];
return true;
}
}
for (int j = 0; j < list.Count; j++)
{
if (Flatten(Key(list[j].ScenePath)).Contains(text) || Flatten(list[j].Caption).Contains(text))
{
match = list[j];
return true;
}
}
return false;
}
private static string Flatten(string value)
{
if (string.IsNullOrEmpty(value))
{
return "";
}
return value.Replace(" ", "").Replace("_", "").ToLowerInvariant();
}
}
internal static class InstanceCommands
{
private static readonly Color Notice = new Color(0.6f, 0.85f, 1f);
private static readonly Color Problem = new Color(1f, 0.55f, 0.5f);
internal static void Register()
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
//IL_0027: 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_003c: Expected O, but got Unknown
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Expected O, but got Unknown
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Expected O, but got Unknown
try
{
CommandProvider val = new CommandProvider("instance", "Private map instances");
val.RegisterCommand("go", "Open a private instance of a map and travel to it", "instance go <map name>", new CommandCallback(Go), (CommandOptions?)new CommandOptions((ChatCommandType)3));
val.RegisterCommand("maps", "List maps that can be instanced", new CommandCallback(Maps), (CommandOptions?)new CommandOptions((ChatCommandType)3));
val.RegisterCommand("list", "List the private instances that are open right now", new CommandCallback(ListOpen), (CommandOptions?)new CommandOptions((ChatCommandType)2));
val.RegisterCommand("leave", "Return to the hub from a private instance", new CommandCallback(Leave), (CommandOptions?)new CommandOptions((ChatCommandType)3));
val.RegisterCommand("close", "Give up the private instance you opened", new CommandCallback(Close), (CommandOptions?)new CommandOptions((ChatCommandType)3));
Utils.RegisterProvider(val);
Log.Info("registered /instance with go, maps, list, leave and close");
}
catch (Exception ex)
{
Log.Warn("could not register commands, " + ex.Message);
}
}
private static bool Go(Caller caller, string[] args)
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_017f: Unknown result type (might be due to invalid IL or missing references)
//IL_0196: 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_016d: Unknown result type (might be due to invalid IL or missing references)
//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
Player player = caller.player;
if (!NetworkServer.active || (Object)(object)player == (Object)null)
{
return true;
}
if (args == null || args.Length == 0)
{
return false;
}
if (TundrasInstancerConfig.HostOnly.Value && !((Caller)(ref caller)).isHost)
{
Utils.NotifyCaller(caller, "Only the host can open private instances here.", Problem);
return true;
}
string text = string.Join(" ", args);
if (!MapCatalog.Resolve(text, out var match))
{
Utils.NotifyCaller(caller, "No map called " + text + ". Try /instance maps.", Problem);
return true;
}
if (!TundrasInstancerConfig.AllowVanillaMaps.Value && MapCatalog.IsVanilla(match.ScenePath))
{
Utils.NotifyCaller(caller, match.Caption + " is a vanilla map and instancing it is disabled.", Problem);
return true;
}
MapInstancingManager current = MapInstancingManager._current;
if ((Object)(object)current == (Object)null)
{
Utils.NotifyCaller(caller, "The world is not ready yet, try again in a moment.", Problem);
return true;
}
MapInstance val = InstanceRegistry.FindAdmitting(match.ScenePath, player);
if ((Object)(object)val != (Object)null)
{
Utils.NotifyCaller(caller, "Rejoining your instance of " + match.Caption + ".", Notice);
}
else
{
InstanceClaim instanceClaim = InstanceRegistry.FindOwnedBy(player);
if (instanceClaim != null)
{
Utils.NotifyCaller(caller, "You already have " + MapCatalog.Key(instanceClaim.ScenePath) + " open. Use /instance close first, or /instance go " + MapCatalog.Key(instanceClaim.ScenePath) + " to return to it.", Problem);
return true;
}
InstanceRequests.Add(player);
Utils.NotifyCaller(caller, "Opening a private instance of " + match.Caption + ".", Notice);
}
Scene scene = ((Component)player).gameObject.scene;
current.Init_SendPeer_ToScene(player, ((Scene)(ref scene)).path, match.ScenePath, match.SpawnTag, (ZoneDifficulty)1);
return true;
}
private static int PeersInside(InstanceClaim claim)
{
if ((Object)(object)claim.Instance == (Object)null || claim.Instance._peersInInstance == null)
{
return 0;
}
return claim.Instance._peersInInstance.Count;
}
private static int OthersInside(InstanceClaim claim, Player except)
{
if ((Object)(object)claim.Instance == (Object)null || claim.Instance._peersInInstance == null)
{
return 0;
}
int num = 0;
List<Player> peersInInstance = claim.Instance._peersInInstance;
for (int i = 0; i < peersInInstance.Count; i++)
{
if ((Object)(object)peersInInstance[i] != (Object)null && (Object)(object)peersInInstance[i] != (Object)(object)except)
{
num++;
}
}
return num;
}
private static bool Maps(Caller caller, string[] args)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
List<MapEntry> list = MapCatalog.Gather();
if (list.Count == 0)
{
Utils.NotifyCaller(caller, "No maps found yet, load into the world first.", Problem);
return true;
}
for (int i = 0; i < list.Count; i++)
{
string text = (MapCatalog.IsVanilla(list[i].ScenePath) ? "" : " (modded)");
Utils.NotifyCaller(caller, MapCatalog.Key(list[i].ScenePath) + " - " + list[i].Caption + text, Notice);
}
return true;
}
private static bool ListOpen(Caller caller, string[] args)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: 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)
if (!((Caller)(ref caller)).isHost)
{
Utils.NotifyCaller(caller, "Only the host can see who has an instance open.", Problem);
return true;
}
IList<InstanceClaim> all = InstanceRegistry.All;
if (all.Count == 0)
{
Utils.NotifyCaller(caller, "No private instances are open.", Notice);
return true;
}
for (int i = 0; i < all.Count; i++)
{
Utils.NotifyCaller(caller, MapCatalog.Key(all[i].ScenePath) + " owner " + all[i].OwnerName() + " peers " + PeersInside(all[i]), Notice);
}
return true;
}
private static bool Close(Caller caller, string[] args)
{
//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)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
Player player = caller.player;
if (!NetworkServer.active || (Object)(object)player == (Object)null)
{
return true;
}
InstanceClaim instanceClaim = InstanceRegistry.FindOwnedBy(player);
if (instanceClaim == null)
{
Utils.NotifyCaller(caller, "You do not have an instance open.", Problem);
return true;
}
int num = OthersInside(instanceClaim, player);
string text = MapCatalog.Key(instanceClaim.ScenePath);
InstanceRegistry.Release(player);
if (num > 0)
{
Utils.NotifyCaller(caller, "Gave up " + text + ". " + num + " still inside, it closes when they leave.", Notice);
}
else
{
Utils.NotifyCaller(caller, "Gave up " + text + ". You can open another now.", Notice);
}
return true;
}
private static bool Leave(Caller caller, string[] args)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
Player player = caller.player;
if (!NetworkServer.active || (Object)(object)player == (Object)null)
{
return true;
}
MapInstancingManager current = MapInstancingManager._current;
if ((Object)(object)current == (Object)null)
{
return true;
}
Scene scene = ((Component)player).gameObject.scene;
current.Init_SendPeer_ToScene(player, ((Scene)(ref scene)).path, current._hubMap, current._hubMainSpawnPointTag, (ZoneDifficulty)1);
Utils.NotifyCaller(caller, "Returning to the hub.", Notice);
return true;
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("com.tundra.atlyss.tundrasinstancer", "Tundra's Instancer", "1.0.0")]
public class TundrasInstancerPlugin : BaseUnityPlugin
{
internal const string PluginGuid = "com.tundra.atlyss.tundrasinstancer";
private void Awake()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
Log.Init(((BaseUnityPlugin)this).Logger);
TundrasInstancerConfig.Init(((BaseUnityPlugin)this).Config);
InstanceCommands.Register();
InstancePatches.Apply(new Harmony("com.tundra.atlyss.tundrasinstancer"));
Log.Info("ready");
}
private void Update()
{
InstanceSleeper.Tick();
}
private void OnDestroy()
{
InstanceSleeper.WakeAll();
}
}
internal static class Log
{
private static ManualLogSource _source;
internal static void Init(ManualLogSource source)
{
_source = source;
}
internal static void Info(string message)
{
if (_source != null)
{
_source.LogInfo((object)message);
}
}
internal static void Warn(string message)
{
if (_source != null)
{
_source.LogWarning((object)message);
}
}
}
internal static class TundrasInstancerConfig
{
internal static ConfigEntry<bool> HostOnly;
internal static ConfigEntry<bool> AllowVanillaMaps;
internal static ConfigEntry<bool> SleepIdleInstances;
internal static ConfigEntry<bool> SleepCreepVisuals;
internal static void Init(ConfigFile config)
{
HostOnly = config.Bind<bool>("Access", "HostOnly", false, "When true only the host may open a private instance.");
AllowVanillaMaps = config.Bind<bool>("Access", "AllowVanillaMaps", true, "When false only maps added by MapLoader may be instanced, leaving the vanilla world alone.");
SleepIdleInstances = config.Bind<bool>("Performance", "SleepIdleInstances", true, "On the host, stops drawing props, lights, cameras and particles in instances you are not standing in.");
SleepCreepVisuals = config.Bind<bool>("Performance", "SleepCreepVisuals", true, "Also stops drawing and animating monsters in those instances. Only affects your own screen, other players still see them.");
}
}
internal sealed class InstanceClaim
{
internal MapInstance Instance;
internal string ScenePath;
internal PartyObjectBehavior Party;
internal Player Owner;
internal string OwnerId;
internal string OwnerLabel;
internal bool Admits(Player player)
{
if ((Object)(object)player == (Object)null)
{
return false;
}
if (InstanceRegistry.SameOwner(this, player))
{
return true;
}
if ((Object)(object)Owner != (Object)null)
{
Party = Owner.Network_partyObject;
}
if ((Object)(object)Party != (Object)null)
{
return (Object)(object)player.Network_partyObject == (Object)(object)Party;
}
return false;
}
internal string OwnerName()
{
if ((Object)(object)Owner != (Object)null && !string.IsNullOrEmpty(Owner._nickname))
{
return Owner._nickname;
}
if (!string.IsNullOrEmpty(OwnerLabel))
{
return OwnerLabel;
}
return "someone who left";
}
}
internal static class InstanceRegistry
{
private static readonly List<InstanceClaim> Claims = new List<InstanceClaim>();
internal static IList<InstanceClaim> All
{
get
{
Prune();
return Claims;
}
}
internal static void Prune()
{
for (int num = Claims.Count - 1; num >= 0; num--)
{
if ((Object)(object)Claims[num].Instance == (Object)null)
{
Log.Info("private instance of " + Claims[num].ScenePath + " was unloaded");
Claims.RemoveAt(num);
}
}
}
internal static string IdentityOf(Player player)
{
if ((Object)(object)player == (Object)null)
{
return null;
}
string steamID = player._steamID;
if (!string.IsNullOrEmpty(steamID))
{
return steamID;
}
return null;
}
internal static bool SameOwner(InstanceClaim claim, Player player)
{
if (claim == null || (Object)(object)player == (Object)null)
{
return false;
}
string text = IdentityOf(player);
if (text != null && text == claim.OwnerId)
{
return true;
}
return (Object)(object)claim.Owner == (Object)(object)player;
}
internal static InstanceClaim FindOwnedBy(Player owner)
{
if ((Object)(object)owner == (Object)null)
{
return null;
}
Prune();
foreach (InstanceClaim claim in Claims)
{
if (SameOwner(claim, owner))
{
return claim;
}
}
return null;
}
internal static bool Release(Player owner)
{
InstanceClaim instanceClaim = FindOwnedBy(owner);
if (instanceClaim == null)
{
return false;
}
Claims.Remove(instanceClaim);
Log.Info("released the private instance of " + instanceClaim.ScenePath + " owned by " + instanceClaim.OwnerName());
return true;
}
internal static void Add(MapInstance instance, string scenePath, Player owner)
{
InstanceClaim instanceClaim = FindOwnedBy(owner);
if (instanceClaim != null)
{
Log.Warn(instanceClaim.OwnerName() + " already owns an instance of " + instanceClaim.ScenePath + ", not claiming another");
return;
}
InstanceClaim instanceClaim2 = new InstanceClaim();
instanceClaim2.Instance = instance;
instanceClaim2.ScenePath = scenePath;
instanceClaim2.Owner = owner;
instanceClaim2.OwnerId = IdentityOf(owner);
instanceClaim2.OwnerLabel = (((Object)(object)owner == (Object)null) ? null : owner._nickname);
instanceClaim2.Party = (((Object)(object)owner == (Object)null) ? null : owner.Network_partyObject);
Claims.Add(instanceClaim2);
Log.Info("claimed a private instance of " + scenePath + " for " + instanceClaim2.OwnerName());
}
internal static bool HasAnyFor(string scenePath)
{
Prune();
foreach (InstanceClaim claim in Claims)
{
if (claim.ScenePath == scenePath)
{
return true;
}
}
return false;
}
internal static bool IsPrivate(MapInstance instance)
{
Prune();
foreach (InstanceClaim claim in Claims)
{
if ((Object)(object)claim.Instance == (Object)(object)instance)
{
return true;
}
}
return false;
}
internal static MapInstance FindAdmitting(string scenePath, Player player)
{
Prune();
foreach (InstanceClaim claim in Claims)
{
if (claim.ScenePath == scenePath && claim.Admits(player))
{
return claim.Instance;
}
}
return null;
}
}
internal static class InstanceRequests
{
private static readonly List<Player> Pending = new List<Player>();
internal static void Add(Player player)
{
for (int num = Pending.Count - 1; num >= 0; num--)
{
if ((Object)(object)Pending[num] == (Object)null)
{
Pending.RemoveAt(num);
}
}
if ((Object)(object)player != (Object)null && !Pending.Contains(player))
{
Pending.Add(player);
}
}
internal static bool Consume(Player player)
{
if ((Object)(object)player != (Object)null)
{
return Pending.Remove(player);
}
return false;
}
}
internal sealed class SleptInstance
{
internal MapInstance Instance;
internal List<Renderer> Renderers = new List<Renderer>();
internal List<Behaviour> Behaviours = new List<Behaviour>();
internal List<ParticleSystem> Particles = new List<ParticleSystem>();
internal List<AudioSource> Audio = new List<AudioSource>();
internal List<Animator> Animators = new List<Animator>();
}
internal static class InstanceSleeper
{
private static readonly List<SleptInstance> Slept = new List<SleptInstance>();
private static bool _describedAoi;
internal static void Tick()
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
if (!TundrasInstancerConfig.SleepIdleInstances.Value || !NetworkServer.active)
{
return;
}
Player mainPlayer = Player._mainPlayer;
MapInstancingManager current = MapInstancingManager._current;
if ((Object)(object)mainPlayer == (Object)null || (Object)(object)current == (Object)null)
{
return;
}
DescribeAoiOnce();
Scene scene = ((Component)mainPlayer).gameObject.scene;
for (int num = Slept.Count - 1; num >= 0; num--)
{
SleptInstance sleptInstance = Slept[num];
if ((Object)(object)sleptInstance.Instance == (Object)null)
{
Slept.RemoveAt(num);
}
else if (sleptInstance.Instance._loadedScene == scene)
{
Wake(sleptInstance);
Slept.RemoveAt(num);
}
}
foreach (MapInstance loadedInstance in current._loadedInstances)
{
if (!((Object)(object)loadedInstance == (Object)null) && !(loadedInstance._loadedScene == scene) && ((Scene)(ref loadedInstance._loadedScene)).IsValid() && !IsSlept(loadedInstance))
{
Sleep(loadedInstance);
}
}
}
internal static void WakeAll()
{
foreach (SleptInstance item in Slept)
{
if ((Object)(object)item.Instance != (Object)null)
{
Wake(item);
}
}
Slept.Clear();
}
private static bool IsSlept(MapInstance instance)
{
foreach (SleptInstance item in Slept)
{
if ((Object)(object)item.Instance == (Object)(object)instance)
{
return true;
}
}
return false;
}
private static void Sleep(MapInstance instance)
{
SleptInstance sleptInstance = new SleptInstance();
sleptInstance.Instance = instance;
Transform environment = (((Object)(object)instance._environmentGroup == (Object)null) ? null : instance._environmentGroup.transform);
GameObject[] rootGameObjects = ((Scene)(ref instance._loadedScene)).GetRootGameObjects();
foreach (GameObject val in rootGameObjects)
{
Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>(true);
foreach (Renderer val2 in componentsInChildren)
{
if (val2.enabled && !Skip(((Component)val2).transform, environment))
{
val2.enabled = false;
sleptInstance.Renderers.Add(val2);
}
}
Light[] componentsInChildren2 = val.GetComponentsInChildren<Light>(true);
foreach (Light val3 in componentsInChildren2)
{
if (((Behaviour)val3).enabled && !Skip(((Component)val3).transform, environment))
{
((Behaviour)val3).enabled = false;
sleptInstance.Behaviours.Add((Behaviour)(object)val3);
}
}
Camera[] componentsInChildren3 = val.GetComponentsInChildren<Camera>(true);
foreach (Camera val4 in componentsInChildren3)
{
if (((Behaviour)val4).enabled && !Skip(((Component)val4).transform, null))
{
((Behaviour)val4).enabled = false;
sleptInstance.Behaviours.Add((Behaviour)(object)val4);
}
}
ReflectionProbe[] componentsInChildren4 = val.GetComponentsInChildren<ReflectionProbe>(true);
foreach (ReflectionProbe val5 in componentsInChildren4)
{
if (((Behaviour)val5).enabled)
{
((Behaviour)val5).enabled = false;
sleptInstance.Behaviours.Add((Behaviour)(object)val5);
}
}
ParticleSystem[] componentsInChildren5 = val.GetComponentsInChildren<ParticleSystem>(true);
foreach (ParticleSystem val6 in componentsInChildren5)
{
if (val6.isPlaying && !Skip(((Component)val6).transform, null))
{
val6.Pause(false);
sleptInstance.Particles.Add(val6);
}
}
AudioSource[] componentsInChildren6 = val.GetComponentsInChildren<AudioSource>(true);
foreach (AudioSource val7 in componentsInChildren6)
{
if (val7.isPlaying && !Skip(((Component)val7).transform, null))
{
val7.Pause();
sleptInstance.Audio.Add(val7);
}
}
Animator[] componentsInChildren7 = val.GetComponentsInChildren<Animator>(true);
foreach (Animator val8 in componentsInChildren7)
{
if (((Behaviour)val8).enabled && !Skip(((Component)val8).transform, null))
{
((Behaviour)val8).enabled = false;
sleptInstance.Animators.Add(val8);
}
}
}
Slept.Add(sleptInstance);
Log.Info("slept " + instance._mapName + ": " + sleptInstance.Renderers.Count + " renderers, " + sleptInstance.Behaviours.Count + " lights/cameras/probes, " + sleptInstance.Particles.Count + " particle systems, " + sleptInstance.Audio.Count + " audio sources, " + sleptInstance.Animators.Count + " animators");
}
private static void Wake(SleptInstance slept)
{
foreach (Renderer renderer in slept.Renderers)
{
if ((Object)(object)renderer != (Object)null)
{
renderer.enabled = true;
}
}
foreach (Behaviour behaviour in slept.Behaviours)
{
if ((Object)(object)behaviour != (Object)null)
{
behaviour.enabled = true;
}
}
foreach (ParticleSystem particle in slept.Particles)
{
if ((Object)(object)particle != (Object)null)
{
particle.Play(false);
}
}
foreach (AudioSource item in slept.Audio)
{
if ((Object)(object)item != (Object)null)
{
item.UnPause();
}
}
foreach (Animator animator in slept.Animators)
{
if ((Object)(object)animator != (Object)null)
{
((Behaviour)animator).enabled = true;
}
}
Log.Info("woke " + slept.Instance._mapName);
}
private static bool Skip(Transform transform, Transform environment)
{
if ((Object)(object)environment != (Object)null && transform.IsChildOf(environment))
{
return true;
}
if ((Object)(object)((Component)transform).GetComponentInParent<Player>() != (Object)null)
{
return true;
}
if (TundrasInstancerConfig.SleepCreepVisuals.Value)
{
return false;
}
return (Object)(object)((Component)transform).GetComponentInParent<NetworkIdentity>() != (Object)null;
}
private static void DescribeAoiOnce()
{
if (!_describedAoi)
{
_describedAoi = true;
InterestManagementBase aoi = NetworkServer.aoi;
Log.Info("interest management: " + (((Object)(object)aoi == (Object)null) ? "none, every client receives every instance" : ((object)aoi).GetType().Name));
}
}
}
internal static class InstancePatches
{
internal static void Apply(Harmony harmony)
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Expected O, but got Unknown
MethodInfo methodInfo = AccessTools.Method(typeof(MapInstancingManager), "Init_SendPeer_ToScene", (Type[])null, (Type[])null);
if (methodInfo == null)
{
Log.Warn("MapInstancingManager.Init_SendPeer_ToScene is gone, private instances cannot work");
return;
}
try
{
harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(InstancePatches), "Prefix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
catch (Exception ex)
{
Log.Warn("could not patch the instancing manager, " + ex.Message);
}
}
private static bool Prefix(Player _player, string _old, string _new, string _spawnTag, ZoneDifficulty _difficulty)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkServer.active || (Object)(object)_player == (Object)null || string.IsNullOrEmpty(_new))
{
return true;
}
bool flag = InstanceRequests.Consume(_player);
if (!flag && !InstanceRegistry.HasAnyFor(_new))
{
return true;
}
InstanceTransport.Begin(_player, _old, _new, _spawnTag, _difficulty, flag);
return false;
}
}
internal static class InstanceTransport
{
private const float FindTimeout = 20f;
private const float ReadyTimeout = 30f;
private const float GateTimeout = 60f;
private static readonly Dictionary<string, int> QueueHolds = new Dictionary<string, int>();
private static bool _loadInFlight;
private static float _loadStarted;
private static MapInstancingManager _bound;
private static void Bind(MapInstancingManager manager)
{
if (!((Object)(object)_bound == (Object)(object)manager))
{
_bound = manager;
_loadInFlight = false;
QueueHolds.Clear();
}
}
private static bool LoadStillInFlight()
{
if (!_loadInFlight)
{
return false;
}
if (Time.realtimeSinceStartup - _loadStarted <= 60f)
{
return true;
}
Log.Warn("a previous instance load never finished, clearing the gate");
_loadInFlight = false;
return false;
}
internal static void Begin(Player player, string oldScene, string newScene, string spawnTag, ZoneDifficulty difficulty, bool forcePrivate)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
MapInstancingManager current = MapInstancingManager._current;
if ((Object)(object)current == (Object)null)
{
Log.Warn("no instancing manager, the transport was dropped");
}
else
{
((MonoBehaviour)current).StartCoroutine(Run(current, player, oldScene, newScene, spawnTag, difficulty, forcePrivate));
}
}
private static IEnumerator Run(MapInstancingManager manager, Player player, string oldScene, string newScene, string spawnTag, ZoneDifficulty difficulty, bool forcePrivate)
{
if ((Object)(object)manager == (Object)null || (Object)(object)player == (Object)null)
{
yield break;
}
Bind(manager);
string who = player._nickname;
Log.Info("transport start, " + who + " to " + newScene + (forcePrivate ? " (private)" : ""));
player.Network_currentGameCondition = (GameCondition)0;
yield return (object)new WaitForSeconds(1.25f);
if ((Object)(object)player == (Object)null)
{
yield break;
}
MapInstance target = (forcePrivate ? null : InstanceRegistry.FindAdmitting(newScene, player));
if ((Object)(object)target == (Object)null && !forcePrivate)
{
target = FindPublic(manager, newScene, player);
}
bool weLoaded = false;
if ((Object)(object)target == (Object)null)
{
float gateWaited = 0f;
while (LoadStillInFlight() && gateWaited < 60f)
{
gateWaited += Time.deltaTime;
yield return null;
}
if (LoadStillInFlight())
{
Restore(player, "another instance is still loading, try again in a moment");
yield break;
}
_loadInFlight = true;
_loadStarted = Time.realtimeSinceStartup;
HoldQueue(manager, newScene);
weLoaded = true;
HashSet<int> before = HandlesFor(newScene);
Log.Info("loading a copy of " + newScene + ", " + before.Count + " already open");
IEnumerator load = LoadCopy(newScene);
while (load.MoveNext())
{
yield return load.Current;
}
Scene loaded = NewSceneFor(newScene, before);
_loadInFlight = false;
if (!((Scene)(ref loaded)).IsValid())
{
ReleaseQueue(manager, newScene);
Restore(player, newScene + " did not load");
yield break;
}
float waited = 0f;
while (waited < 20f)
{
target = FindInScene(manager, loaded);
if ((Object)(object)target != (Object)null)
{
break;
}
waited += Time.deltaTime;
yield return null;
}
if ((Object)(object)target == (Object)null)
{
ReleaseQueue(manager, newScene);
Restore(player, newScene + " loaded but never registered a MapInstance");
yield break;
}
Log.Info("instance ready, " + target._mapName + " handle " + ((Scene)(ref loaded)).handle);
if (forcePrivate)
{
InstanceRegistry.Add(target, newScene, player);
}
}
if ((Object)(object)player == (Object)null)
{
if (weLoaded)
{
ReleaseQueue(manager, newScene);
}
yield break;
}
if (player._isHostPlayer)
{
DropHostColliders(manager, ((Component)player).gameObject.scene);
}
SceneManager.MoveGameObjectToScene(((Component)player).gameObject, SceneManager.GetActiveScene());
yield return (object)new WaitForSeconds(0.45f);
if ((Object)(object)player == (Object)null || (Object)(object)target == (Object)null)
{
if (weLoaded)
{
ReleaseQueue(manager, newScene);
}
yield break;
}
SceneManager.MoveGameObjectToScene(((Component)player).gameObject, target._loadedScene);
((Component)player).transform.SetAsLastSibling();
if (!target._peersInInstance.Contains(player))
{
target._peersInInstance.Add(player);
}
target.SendPeer_ToSpawnPoint(((Component)player).gameObject, spawnTag);
if ((int)target._zoneType != 0)
{
player._statusEntity.Replenish_All();
}
NetworkConnectionToClient conn = ((NetworkBehaviour)player).connectionToClient;
if (conn != null)
{
((NetworkConnection)conn).Send<SceneMessage>(new SceneMessage
{
sceneName = newScene,
sceneOperation = (SceneOperation)1
}, 0);
float readyWaited = 0f;
while (!((NetworkConnection)conn).isReady && readyWaited < 30f)
{
readyWaited += Time.deltaTime;
yield return null;
}
if (!((NetworkConnection)conn).isReady)
{
Log.Warn(who + " never reported ready, continuing anyway");
}
if (!string.IsNullOrEmpty(oldScene) && oldScene != newScene)
{
((NetworkConnection)conn).Send<SceneMessage>(new SceneMessage
{
sceneName = oldScene,
sceneOperation = (SceneOperation)2
}, 0);
}
}
yield return (object)new WaitForSeconds(0.85f);
if ((Object)(object)player != (Object)null && (Object)(object)target != (Object)null)
{
if ((Object)(object)Player._mainPlayer == (Object)(object)player && player._isHostPlayer)
{
target.Spawn_HostCameraColliders();
}
player.Network_playerZoneType = target._zoneType;
player.Network_currentGameCondition = (GameCondition)1;
player.Network_currentPlayerCondition = (PlayerCondition)2;
player._lastSpawnPoint = spawnTag;
Log.Info("transport done, " + who + " is in " + target._mapName);
}
if (weLoaded)
{
ReleaseQueue(manager, newScene);
}
}
private static IEnumerator LoadCopy(string scenePath)
{
AsyncOperation op = null;
try
{
op = SceneManager.LoadSceneAsync(scenePath, new LoadSceneParameters((LoadSceneMode)1, (LocalPhysicsMode)2));
}
catch (Exception ex)
{
Log.Warn("could not start loading " + scenePath + ", " + ex.Message);
}
if (op != null)
{
while (!op.isDone)
{
yield return null;
}
}
}
private static HashSet<int> HandlesFor(string scenePath)
{
//IL_000b: 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)
HashSet<int> hashSet = new HashSet<int>();
for (int i = 0; i < SceneManager.sceneCount; i++)
{
Scene sceneAt = SceneManager.GetSceneAt(i);
if (((Scene)(ref sceneAt)).path == scenePath)
{
hashSet.Add(((Scene)(ref sceneAt)).handle);
}
}
return hashSet;
}
private static Scene NewSceneFor(string scenePath, HashSet<int> before)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < SceneManager.sceneCount; i++)
{
Scene sceneAt = SceneManager.GetSceneAt(i);
if (((Scene)(ref sceneAt)).path == scenePath && !before.Contains(((Scene)(ref sceneAt)).handle))
{
return sceneAt;
}
}
return default(Scene);
}
private static MapInstance FindPublic(MapInstancingManager manager, string scenePath, Player player)
{
for (int i = 0; i < manager._loadedInstances.Count; i++)
{
MapInstance val = manager._loadedInstances[i];
if ((Object)(object)val == (Object)null || ((Scene)(ref val._loadedScene)).path != scenePath || InstanceRegistry.IsPrivate(val))
{
continue;
}
PatternInstanceManager patternInstance = val._patternInstance;
if ((Object)(object)patternInstance != (Object)null)
{
PartyObjectBehavior network_instanceParty = patternInstance.Network_instanceParty;
if ((Object)(object)network_instanceParty != (Object)null && (Object)(object)player.Network_partyObject != (Object)(object)network_instanceParty)
{
continue;
}
}
return val;
}
return null;
}
private static void DropHostColliders(MapInstancingManager manager, Scene leaving)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < manager._loadedInstances.Count; i++)
{
MapInstance val = manager._loadedInstances[i];
if ((Object)(object)val != (Object)null && val._loadedScene == leaving)
{
val.Destroy_HostCameraColliders();
}
}
}
private static MapInstance FindInScene(MapInstancingManager manager, Scene scene)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < manager._loadedInstances.Count; i++)
{
MapInstance val = manager._loadedInstances[i];
if ((Object)(object)val != (Object)null)
{
Scene scene2 = ((Component)val).gameObject.scene;
if (((Scene)(ref scene2)).handle == ((Scene)(ref scene)).handle)
{
return val;
}
}
}
return null;
}
private static void HoldQueue(MapInstancingManager manager, string scenePath)
{
QueueHolds.TryGetValue(scenePath, out var value);
QueueHolds[scenePath] = value + 1;
if (!manager._instanceQueue.Contains(scenePath))
{
manager._instanceQueue.Add(scenePath);
}
}
private static void ReleaseQueue(MapInstancingManager manager, string scenePath)
{
if (QueueHolds.TryGetValue(scenePath, out var value))
{
value--;
if (value > 0)
{
QueueHolds[scenePath] = value;
return;
}
QueueHolds.Remove(scenePath);
manager._instanceQueue.Remove(scenePath);
}
}
private static void Restore(Player player, string reason)
{
Log.Warn("transport aborted, " + reason);
if (!((Object)(object)player == (Object)null))
{
player.Network_currentGameCondition = (GameCondition)1;
player.Network_currentPlayerCondition = (PlayerCondition)2;
}
}
}
