using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using Bifrost.Cooked;
using HarmonyLib;
using JoinAnytime;
using JoinAnytime.Enums;
using JoinAnytime.Helpers;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using ReluProtocol;
using ReluProtocol.C2S;
using ReluProtocol.Enum;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(JoinAnytimeMod), "JoinAnytime", "0.1.0", "Shlygly", null)]
[assembly: MelonGame("ReLUGames", "MIMESIS")]
[assembly: MelonColor(255, 0, 128, 255)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Shlygly")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("JoinAnytime")]
[assembly: AssemblyTitle("JoinAnytime")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.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;
}
}
}
namespace JoinAnytime
{
public class JoinAnytimeMod : MelonMod
{
public static LateJoinRedirectState RedirectState = LateJoinRedirectState.None;
public static string PendingSceneName = "";
public static JoinAnytimeMod Instance { get; private set; }
public override void OnInitializeMelon()
{
Instance = this;
((MelonBase)this).LoggerInstance.Msg("Reading settings...");
Preferences.Init();
(bool, string)[] array = new(bool, string)[4]
{
(Preferences.AllowPreGame.Value, "pre-game tramway"),
(Preferences.AllowOnPlaying.Value, "dungeon"),
(Preferences.AllowEndGame.Value, "end game tramway"),
(Preferences.AllowDeathMatch.Value, "final deathmatch")
};
for (int i = 0; i < array.Length; i++)
{
var (flag, text) = array[i];
if (flag)
{
((MelonBase)this).LoggerInstance.Msg("Players are allowed to join during " + text + ".");
}
else
{
((MelonBase)this).LoggerInstance.Msg("Players won't be able to join during " + text + ".");
}
}
((MelonBase)this).LoggerInstance.Msg("Initialized !");
}
public static void Log(string message)
{
if (Preferences.Verbose.Value)
{
((MelonBase)Instance).LoggerInstance.Msg(message);
}
}
}
internal static class LateJoinManager
{
[CompilerGenerated]
private sealed class <<EnsureVoiceConnected>g__connectDelayed|8_0>d : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public VoiceManager voice;
private PersistentData <pdata>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <<EnsureVoiceConnected>g__connectDelayed|8_0>d(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<pdata>5__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Expected O, but got Unknown
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
voiceCheckRunning = true;
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<pdata>5__1 = ReflectionTools.GetFieldOrProperty<PersistentData>(Hub.s, "pdata");
if (<pdata>5__1 != null && (Object)(object)voice != (Object)null && !voice.IsConnected())
{
voice.TryRecoverMicrophone();
voice.ConnectVoiceChat(<pdata>5__1.GameServerAddressOrSteamId, <pdata>5__1.WithRelay);
}
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
voiceCheckRunning = false;
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 static bool voiceCheckRunning;
public static bool IsStateAllowed(VGameSessionState state)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Invalid comparison between Unknown and I4
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Invalid comparison between Unknown and I4
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Invalid comparison between Unknown and I4
return ((int)state == 3 && Preferences.AllowPreGame.Value) || ((int)state == 4 && Preferences.AllowOnPlaying.Value) || ((int)state == 6 && Preferences.AllowEndGame.Value) || ((int)state == 7 && Preferences.AllowDeathMatch.Value);
}
public static void OnServerLogin(SessionContext context)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Invalid comparison between Unknown and I4
PersistentData fieldOrProperty = ReflectionTools.GetFieldOrProperty<PersistentData>(Hub.s, "pdata");
if (fieldOrProperty != null && (int)fieldOrProperty.ClientMode <= 0)
{
GameMainBase main = fieldOrProperty.main;
GamePlayScene val = (GamePlayScene)(object)((main is GamePlayScene) ? main : null);
if (val != null && IsStateAllowed((VGameSessionState)4))
{
JoinAnytimeMod.Log($"Login while OnPlaying: uid={context.GetPlayerUID()} dungeon={val.DungeonMasterID} seed={val.RandDungeonSeed}");
NetworkTools.SendOnPlayingStateToClient(context);
}
}
}
public static void OnServerPlayerCreated(VPlayer player)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Invalid comparison between Unknown and I4
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Expected O, but got Unknown
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
PersistentData fieldOrProperty = ReflectionTools.GetFieldOrProperty<PersistentData>(Hub.s, "pdata");
if (fieldOrProperty != null && (int)fieldOrProperty.ClientMode <= 0 && !player.IsHost)
{
JoinAnytimeMod.Log($"VPlayer ctor: UID={((VActor)player).UID} room={((object)((VActor)player).VRoom)?.GetType().Name} main={((object)fieldOrProperty.main)?.GetType().Name}");
if (fieldOrProperty.main is InTramWaitingScene && ((VActor)player).VRoom is MaintenanceRoom && IsStateAllowed((VGameSessionState)3))
{
JoinAnytimeMod.Log($"Join PreGame detected, sending EnableWaitingRoomSig to UID={((VActor)player).UID}");
((VActor)player).SendToMe((IMsg)new EnableWaitingRoomSig());
}
else if (fieldOrProperty.main is GamePlayScene && ((VActor)player).VRoom is MaintenanceRoom && IsStateAllowed((VGameSessionState)4))
{
NetworkTools.SendOnPlayingStateToClient(player);
}
}
}
public static bool OnClientPacket(IMsg msg)
{
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Invalid comparison between Unknown and I4
//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
//IL_01c8: Invalid comparison between Unknown and I4
PersistentData fieldOrProperty = ReflectionTools.GetFieldOrProperty<PersistentData>(Hub.s, "pdata");
AllMemberEnterRoomSig val = (AllMemberEnterRoomSig)(object)((msg is AllMemberEnterRoomSig) ? msg : null);
if (val == null)
{
if (!(msg is EnableWaitingRoomSig))
{
StartGameSig val2 = (StartGameSig)(object)((msg is StartGameSig) ? msg : null);
if (val2 == null)
{
CompleteMakingRoomSig val3 = (CompleteMakingRoomSig)(object)((msg is CompleteMakingRoomSig) ? msg : null);
if (val3 != null)
{
fieldOrProperty.completeMakingRoomSig = val3;
if (val3.nextRoomInfo.roomMasterID != 0)
{
fieldOrProperty.dungeonMasterID = val3.nextRoomInfo.roomMasterID;
}
string sceneNameFromDungeon = RoomTools.GetSceneNameFromDungeon(fieldOrProperty.dungeonMasterID);
JoinAnytimeMod.Log(string.Format("CompleteMakingRoomSig: roomUID={0}, scene={1}, main={2}", val3.nextRoomInfo.roomUID, sceneNameFromDungeon, ((object)fieldOrProperty.main)?.GetType().Name ?? "null"));
JoinAnytimeMod.PendingSceneName = sceneNameFromDungeon;
if ((int)fieldOrProperty.ClientMode == 1)
{
if (fieldOrProperty.main is MaintenanceScene && !string.IsNullOrEmpty(sceneNameFromDungeon))
{
JoinAnytimeMod.Log("Redirect now -> " + sceneNameFromDungeon);
JoinAnytimeMod.RedirectState = LateJoinRedirectState.EnteringDungeon;
Hub.LoadScene(sceneNameFromDungeon);
}
else
{
JoinAnytimeMod.RedirectState = LateJoinRedirectState.PendingDungeonRedirect;
}
}
}
}
else
{
fieldOrProperty.dungeonMasterID = val2.selectedDungeonMasterID;
fieldOrProperty.randDungeonSeed = val2.randDungeonSeed;
JoinAnytimeMod.Log($"StartGameSig: dungeon={fieldOrProperty.dungeonMasterID} seed={fieldOrProperty.randDungeonSeed}");
}
}
else
{
if (fieldOrProperty == null || (int)fieldOrProperty.ClientMode != 1)
{
return true;
}
JoinAnytimeMod.Log("PreGame signal received. main=" + (((object)fieldOrProperty.main)?.GetType().Name ?? "null"));
JoinAnytimeMod.RedirectState = LateJoinRedirectState.PendingWaitingRoomRedirect;
JoinAnytimeMod.PendingSceneName = "InTramWaitingScene";
if (fieldOrProperty.main is MaintenanceScene)
{
JoinAnytimeMod.RedirectState = LateJoinRedirectState.None;
Hub.LoadScene("InTramWaitingScene");
}
}
}
else if (ShouldIgnoreEarlyGameAllMemberEnterRoomSig(fieldOrProperty, val))
{
return false;
}
return true;
}
private static bool ShouldIgnoreEarlyGameAllMemberEnterRoomSig(PersistentData pdata, AllMemberEnterRoomSig sig)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Invalid comparison between Unknown and I4
if (pdata == null || (int)pdata.ClientMode != 1)
{
return false;
}
if (!(pdata.main is GamePlayScene))
{
return false;
}
if (ReflectionTools.GetFieldOrProperty<bool>(pdata.main, "EnteringCompleteAll"))
{
return false;
}
if (JoinAnytimeMod.RedirectState != LateJoinRedirectState.EnteringDungeon)
{
return false;
}
if (sig.enterCutsceneNames != null && sig.enterCutsceneNames.Contains("ArriveCutScene"))
{
JoinAnytimeMod.RedirectState = LateJoinRedirectState.None;
JoinAnytimeMod.PendingSceneName = "";
return false;
}
JoinAnytimeMod.Log("Ignoring early AllMemberEnterRoomSig names=" + string.Join(",", sig.enterCutsceneNames ?? new List<string>()));
return true;
}
public static void OnLoadScene(string sceneName)
{
if (JoinAnytimeMod.RedirectState != 0 && (JoinAnytimeMod.RedirectState != LateJoinRedirectState.EnteringDungeon || !(sceneName == JoinAnytimeMod.PendingSceneName)) && sceneName != JoinAnytimeMod.PendingSceneName)
{
JoinAnytimeMod.RedirectState = LateJoinRedirectState.None;
JoinAnytimeMod.PendingSceneName = "";
}
}
public static void OnMaintenanceSceneStart()
{
PersistentData fieldOrProperty = ReflectionTools.GetFieldOrProperty<PersistentData>(Hub.s, "pdata");
if (fieldOrProperty != null)
{
if (JoinAnytimeMod.RedirectState == LateJoinRedirectState.PendingWaitingRoomRedirect)
{
JoinAnytimeMod.Log("Pending PreGame redirect -> InTramWaitingScene");
JoinAnytimeMod.RedirectState = LateJoinRedirectState.None;
Hub.LoadScene("InTramWaitingScene");
}
else if (JoinAnytimeMod.RedirectState == LateJoinRedirectState.PendingDungeonRedirect && !string.IsNullOrEmpty(JoinAnytimeMod.PendingSceneName))
{
JoinAnytimeMod.Log("Pending in-game redirect -> " + JoinAnytimeMod.PendingSceneName);
JoinAnytimeMod.RedirectState = LateJoinRedirectState.EnteringDungeon;
Hub.LoadScene(JoinAnytimeMod.PendingSceneName);
}
}
}
public static void EnsureVoiceConnected(VoiceManager voiceManager, VoiceMode mode)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Invalid comparison between Unknown and I4
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Invalid comparison between Unknown and I4
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Invalid comparison between Unknown and I4
if (voiceCheckRunning)
{
return;
}
PersistentData fieldOrProperty = ReflectionTools.GetFieldOrProperty<PersistentData>(Hub.s, "pdata");
if (fieldOrProperty == null)
{
return;
}
if (1 == 0)
{
}
bool flag = (((int)mode == 1) ? (Preferences.AllowPreGame.Value || Preferences.AllowEndGame.Value) : ((int)mode == 2 && (Preferences.AllowOnPlaying.Value || Preferences.AllowDeathMatch.Value)));
if (1 == 0)
{
}
if (flag && (int)fieldOrProperty.ClientMode == 1)
{
GameMainBase main = fieldOrProperty.main;
if (1 == 0)
{
}
flag = ((main is InTramWaitingScene) ? (Preferences.AllowPreGame.Value || Preferences.AllowEndGame.Value) : ((main is GamePlayScene) ? Preferences.AllowOnPlaying.Value : (main is DeathMatchScene && Preferences.AllowDeathMatch.Value)));
if (1 == 0)
{
}
if (flag && !voiceManager.IsConnected())
{
JoinAnytimeMod.Log($"Voice connect fix: addr={fieldOrProperty.GameServerAddressOrSteamId} relay={fieldOrProperty.WithRelay}");
((MonoBehaviour)voiceManager).StartCoroutine(connectDelayed(voiceManager));
}
}
[IteratorStateMachine(typeof(<<EnsureVoiceConnected>g__connectDelayed|8_0>d))]
static IEnumerator connectDelayed(VoiceManager voice)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <<EnsureVoiceConnected>g__connectDelayed|8_0>d(0)
{
voice = voice
};
}
}
public static void OnServerEnterWaitingRoom(SessionContext context)
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Invalid comparison between Unknown and I4
if (context != null && context.ExistPlayer())
{
PersistentData fieldOrProperty = ReflectionTools.GetFieldOrProperty<PersistentData>(Hub.s, "pdata");
if ((int)context.GetVRoomType() == 3 && fieldOrProperty?.main is InTramWaitingScene)
{
JoinAnytimeMod.Log("Moving player snapshot Maintenance -> Waiting");
RoomTools.MoveCurrentPlayerToSnapshot(context);
}
}
}
public static void OnServerEnterDungeon(SessionContext context, long roomUID)
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Invalid comparison between Unknown and I4
if (context != null && context.ExistPlayer())
{
PersistentData fieldOrProperty = ReflectionTools.GetFieldOrProperty<PersistentData>(Hub.s, "pdata");
if ((int)context.GetVRoomType() == 3 && fieldOrProperty?.main is GamePlayScene)
{
JoinAnytimeMod.Log($"Moving player snapshot Maintenance -> Dungeon, roomUID={roomUID}");
RoomTools.MoveCurrentPlayerToSnapshot(context);
}
}
}
}
public static class Preferences
{
public static MelonPreferences_Entry<bool> Verbose { get; private set; }
public static MelonPreferences_Entry<bool> AllowPreGame { get; private set; }
public static MelonPreferences_Entry<bool> AllowOnPlaying { get; private set; }
public static MelonPreferences_Entry<bool> AllowEndGame { get; private set; }
public static MelonPreferences_Entry<bool> AllowDeathMatch { get; private set; }
public static void Init()
{
MelonPreferences_Category val = MelonPreferences.CreateCategory("Join Anytime");
Verbose = val.CreateEntry<bool>("Verbose logging", false, "Verbose logging", "Activate verbose logging.", false, false, (ValueValidator)null, (string)null);
AllowPreGame = val.CreateEntry<bool>("Join during pre-game", true, "Join during pre-game", "Activate to allow players to join during pre-game.", false, false, (ValueValidator)null, (string)null);
AllowOnPlaying = val.CreateEntry<bool>("Join when playing", true, "Join when playing", "Activate to allow players to join during a dungeon.", false, false, (ValueValidator)null, (string)null);
AllowEndGame = val.CreateEntry<bool>("Join during end game", true, "Join during end game", "Activate to allow players to join for the end game.", false, false, (ValueValidator)null, (string)null);
AllowDeathMatch = val.CreateEntry<bool>("Join during deathmatch", false, "Join during deathmatch", "Activate to allow players to join for the final deathmatch.", false, false, (ValueValidator)null, (string)null);
}
}
}
namespace JoinAnytime.Patches
{
[HarmonyPatch(typeof(Hub), "LoadScene", new Type[] { typeof(string) })]
internal static class Hub_LoadScene
{
private static void Prefix(string sceneName)
{
LateJoinManager.OnLoadScene(sceneName);
}
}
[HarmonyPatch(typeof(SessionContext), "Login")]
internal static class SessionContext_Login
{
private static void Postfix(SessionContext __instance)
{
LateJoinManager.OnServerLogin(__instance);
}
}
[HarmonyPatch(typeof(GameSessionInfo), "CanEnterSession")]
internal static class GameSessionInfo_CanEnterSession
{
private static bool Prefix(ref GameSessionInfo __instance, ref bool __result)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
VGameSessionState gameSessionState = __instance.GameSessionState;
if (LateJoinManager.IsStateAllowed(gameSessionState))
{
__result = true;
return false;
}
return true;
}
}
[HarmonyPatch(typeof(MaintenanceScene), "Start")]
internal static class MaintenanceScene_Start
{
private static void Postfix()
{
LateJoinManager.OnMaintenanceSceneStart();
}
}
[HarmonyPatch(typeof(NetworkManagerV2), "OnRecvPacket", new Type[] { typeof(IMsg) })]
internal static class NetworkManagerV2_OnRecvPacket
{
private static bool Prefix(IMsg msg)
{
return LateJoinManager.OnClientPacket(msg);
}
}
[HarmonyPatch(typeof(VoiceManager), "SetVoiceMode")]
internal static class VoiceManager_SetVoiceMode
{
private static void Postfix(VoiceManager __instance, VoiceMode voiceMode)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
LateJoinManager.EnsureVoiceConnected(__instance, voiceMode);
}
}
[HarmonyPatch]
internal static class VPlayer_Ctor
{
private static MethodBase TargetMethod()
{
return AccessTools.Constructor(typeof(VPlayer), new Type[10]
{
typeof(SessionContext),
typeof(int),
typeof(int),
typeof(bool),
typeof(string),
typeof(string),
typeof(PosWithRot),
typeof(bool),
typeof(IVroom),
typeof(ReasonOfSpawn)
}, false);
}
private static void Postfix(VPlayer __instance)
{
LateJoinManager.OnServerPlayerCreated(__instance);
}
}
[HarmonyPatch(typeof(VRoomManager), "EnterWaitingRoom")]
internal static class VRoomManager_EnterWaitingRoom
{
private static void Prefix(SessionContext context, int hashCode)
{
LateJoinManager.OnServerEnterWaitingRoom(context);
}
}
[HarmonyPatch(typeof(VRoomManager), "EnterDungeon")]
internal static class VRoomManager_EnterDungeon
{
private static void Prefix(SessionContext context, int hashCode, long roomUID)
{
LateJoinManager.OnServerEnterDungeon(context, roomUID);
}
}
}
namespace JoinAnytime.Helpers
{
internal static class NetworkTools
{
public static void SendOnPlayingStateToClient(VPlayer player)
{
SendOnPlayingState(((VActor)player).UID, delegate(IMsg msg)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
((VActor)player).SendToMe(msg);
});
}
public static void SendOnPlayingStateToClient(SessionContext context)
{
SendOnPlayingState(context.GetPlayerUID(), delegate(IMsg msg)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
context.Send(msg);
});
}
private static void SendOnPlayingState(long uid, Action<IMsg> send)
{
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Expected O, but got Unknown
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00f6: Expected O, but got Unknown
//IL_00fc: Expected O, but got Unknown
GameMainBase obj = ReflectionTools.GetFieldOrProperty<PersistentData>(Hub.s, "pdata")?.main;
GamePlayScene val = (GamePlayScene)(object)((obj is GamePlayScene) ? obj : null);
if (val != null)
{
IVroom activeDungeonRoom = RoomTools.GetActiveDungeonRoom();
if (activeDungeonRoom == null)
{
JoinAnytimeMod.Log("SendOnPlayingStateToClient failed: no active DungeonRoom.");
return;
}
JoinAnytimeMod.Log($"Sending OnPlaying state to UID={uid}: dungeon={val.DungeonMasterID}, seed={val.RandDungeonSeed}, roomUID={activeDungeonRoom.RoomID}");
send((IMsg)new StartGameSig
{
selectedDungeonMasterID = val.DungeonMasterID,
randDungeonSeed = val.RandDungeonSeed
});
send((IMsg)new CompleteMakingRoomSig
{
nextRoomInfo = new RoomInfo
{
roomType = (VRoomType)2,
roomMasterID = val.DungeonMasterID,
roomUID = activeDungeonRoom.RoomID
}
});
}
}
}
internal static class RoomTools
{
public static void MoveCurrentPlayerToSnapshot(SessionContext context)
{
VPlayer fieldOrProperty = ReflectionTools.GetFieldOrProperty<VPlayer>(context, "_vPlayer");
if (fieldOrProperty != null)
{
IVroom vRoom = ((VActor)fieldOrProperty).VRoom;
int objectID = ((VActor)fieldOrProperty).ObjectID;
JoinAnytimeMod.Log($"Removing old player actor={objectID} room={((object)vRoom)?.GetType().Name}");
if (vRoom != null)
{
vRoom.PendRemovePlayer(objectID, false, false);
}
context.CreatePlayerSnapshot(true);
}
}
public static string GetSceneNameFromDungeon(int dungeonMasterID)
{
DataManager fieldOrProperty = ReflectionTools.GetFieldOrProperty<DataManager>(Hub.s, "dataman");
DungeonMasterInfo dungeonInfo = fieldOrProperty.ExcelDataManager.GetDungeonInfo(dungeonMasterID);
if (dungeonInfo == null)
{
return "";
}
MapMasterInfo mapInfo = fieldOrProperty.ExcelDataManager.GetMapInfo(dungeonInfo.MapID);
return ((mapInfo != null) ? mapInfo.SceneName : null) ?? "";
}
public static IVroom GetActiveDungeonRoom()
{
VRoomManager vRoomManager = ReflectionTools.GetFieldOrProperty<VWorld>(Hub.s, "vworld").VRoomManager;
return ((IEnumerable<IVroom>)ReflectionTools.GetFieldOrProperty<Dictionary<long, IVroom>>(vRoomManager, "_vrooms").Values).FirstOrDefault((Func<IVroom, bool>)((IVroom room) => room is DungeonRoom));
}
}
internal static class ReflectionTools
{
public static object GetFieldOrProperty(object instance, string name)
{
Type type = instance.GetType();
FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
return field.GetValue(instance);
}
PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null)
{
return property.GetValue(instance);
}
throw new Exception("Field/property '" + name + "' not found on " + type.FullName);
}
public static T GetFieldOrProperty<T>(object instance, string name)
{
return (T)GetFieldOrProperty(instance, name);
}
public static void SetFieldOrProperty(object instance, string name, object value)
{
Type type = instance.GetType();
FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
field.SetValue(instance, value);
return;
}
PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null)
{
property.SetValue(instance, value);
return;
}
throw new Exception("Field/property '" + name + "' not found on " + type.FullName);
}
}
}
namespace JoinAnytime.Enums
{
public enum LateJoinRedirectState
{
None,
PendingWaitingRoomRedirect,
PendingDungeonRedirect,
EnteringDungeon
}
}
