using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security.Permissions;
using System.Threading;
using <StartupCode$MirageRevive>.$Mirage.Revive.Domain;
using <StartupCode$MirageRevive>.$Mirage.Revive.Hook;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FSharpPlus;
using FSharpPlus.Control;
using FSharpx.Control;
using GameNetcodeStuff;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using Microsoft.FSharp.Collections;
using Microsoft.FSharp.Control;
using Microsoft.FSharp.Core;
using Microsoft.FSharp.Core.CompilerServices;
using Mirage.Revive.Domain;
using Mirage.Revive.Hook;
using Mirage.Revive.Unity;
using MirageRevive.NetcodePatcher;
using On;
using On.GameNetcodeStuff;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
[assembly: FSharpInterfaceDataVersion(2, 0, 0)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: AssemblyCompany("MirageRevive")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+45f19fcd3d93c13ee168b6f161535a281504197d")]
[assembly: AssemblyProduct("MirageRevive")]
[assembly: AssemblyTitle("MirageRevive")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: NetcodePatchedAssembly]
internal class <Module>
{
static <Module>()
{
}
}
namespace Mirage.Revive
{
[Serializable]
[BepInPlugin("qwbarch.MirageRevive", "MirageRevive", "1.0.0")]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
public void Awake()
{
ConfigFile config = ((BaseUnityPlugin)this).Config;
Mirage.Revive.Domain.Config.localConfig = FSharpOption<Mirage.Revive.Domain.Config.LocalConfig>.Some(new Mirage.Revive.Domain.Config.LocalConfig(config));
Mirage.Revive.Domain.Netcode.initNetcodePatcher();
Compatibility.initLobbyCompatibility();
Mirage.Revive.Hook.Config.syncConfig();
Mirage.Revive.Hook.MaskedPlayerEnemy.revivePlayersOnDeath();
}
}
}
namespace <StartupCode$MirageRevive>
{
internal static class $Plugin
{
}
}
namespace Mirage.Revive.Hook
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public static class MaskedPlayerEnemy
{
[Serializable]
[SpecialName]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static class revivePlayersOnDeath@62
{
internal static void Invoke(orig_Awake orig, PlayerControllerB self)
{
orig.Invoke(self);
BodyDeactivator.BodyDeactivator bodyDeactivator = ((Component)self).gameObject.AddComponent<BodyDeactivator.BodyDeactivator>();
}
}
[Serializable]
[SpecialName]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static class revivePlayersOnDeath@68-1
{
internal static void Invoke(orig_Start orig, GameNetworkManager self)
{
orig.Invoke(self);
List<NetworkPrefab> prefabs = ((Component)self).GetComponent<NetworkManager>().NetworkConfig.Prefabs.m_Prefabs;
foreach (NetworkPrefab item in prefabs)
{
HauntedMaskItem component = item.Prefab.gameObject.GetComponent<HauntedMaskItem>();
if (component != null)
{
maskItem = component;
}
}
if (maskItem == null)
{
Mirage.Revive.Domain.Logger.logWarning.Invoke("HauntedMaskItem prefab is missing. Another mod is messing with this prefab when they shouldn't be.");
}
}
}
[Serializable]
[SpecialName]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static class revivePlayersOnDeath@79-2
{
internal static void Invoke(orig_StartGame orig, StartOfRound self)
{
orig.Invoke(self);
killedPlayers.Clear();
}
}
[Serializable]
[SpecialName]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static class revivePlayersOnDeath@85-3
{
internal static void Invoke(orig_KillPlayerServerRpc orig, PlayerControllerB self, int playerId, bool spawnBody, Vector3 bodyVelocity, int causeOfDeath, int deathAnimation, Vector3 positionOffset)
{
//IL_0004: 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_0017: Unknown result type (might be due to invalid IL or missing references)
orig.Invoke(self, playerId, spawnBody, bodyVelocity, causeOfDeath, deathAnimation, positionOffset);
spawnMaskedEnemy<Vector3>(self, causeOfDeath, deathAnimation, spawnBody, bodyVelocity);
}
}
[Serializable]
[SpecialName]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static class revivePlayersOnDeath@89-4
{
internal static void Invoke(orig_KillPlayer orig, PlayerControllerB self, Vector3 bodyVelocity, bool spawnBody, CauseOfDeath causeOfDeath, int deathAnimation, Vector3 positionOffset)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: 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_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected I4, but got Unknown
orig.Invoke(self, bodyVelocity, spawnBody, causeOfDeath, deathAnimation, positionOffset);
spawnMaskedEnemy<Vector3>(self, (int)causeOfDeath, deathAnimation, spawnBody, bodyVelocity);
}
}
[Serializable]
[SpecialName]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal sealed class revivePlayersOnDeath@99-6 : GeneratedSequenceBase<IEnumerator>
{
public orig_EndOfGame orig;
public StartOfRound self;
public int bodiesEnsured;
public int connectedPlayersOnServer;
public int scrapCollected;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public IEnumerator<PlayerControllerB> @enum;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public int pc;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public IEnumerator current;
public revivePlayersOnDeath@99-6(orig_EndOfGame orig, StartOfRound self, int bodiesEnsured, int connectedPlayersOnServer, int scrapCollected, IEnumerator<PlayerControllerB> @enum, int pc, IEnumerator current)
{
this.orig = orig;
this.self = self;
this.bodiesEnsured = bodiesEnsured;
this.connectedPlayersOnServer = connectedPlayersOnServer;
this.scrapCollected = scrapCollected;
this.@enum = @enum;
this.pc = pc;
this.current = current;
base..ctor();
}
public override int GenerateNext(ref IEnumerable<IEnumerator> next)
{
switch (pc)
{
default:
pc = 1;
current = orig.Invoke(self, bodiesEnsured, connectedPlayersOnServer, scrapCollected);
return 1;
case 1:
@enum = ((IEnumerable<PlayerControllerB>)self.allPlayerScripts).GetEnumerator();
pc = 2;
while (@enum.MoveNext())
{
PlayerControllerB val = @enum.Current;
val.deadBody = null;
}
goto case 2;
case 2:
pc = 3;
IntrinsicFunctions.Dispose<IEnumerator<PlayerControllerB>>(@enum);
@enum = null;
pc = 3;
break;
case 3:
break;
}
current = null;
return 0;
}
public override void Close()
{
Exception ex = default(Exception);
while (true)
{
switch (pc)
{
case 3:
if (ex != null)
{
throw ex;
}
return;
}
try
{
switch (pc)
{
default:
pc = 3;
IntrinsicFunctions.Dispose<IEnumerator<PlayerControllerB>>(@enum);
break;
case 0:
case 1:
case 3:
break;
}
pc = 3;
current = null;
}
catch (object obj)
{
Exception ex2 = (Exception)obj;
ex = ex2;
}
}
}
public override bool get_CheckClose()
{
switch (pc)
{
default:
return true;
case 1:
return false;
case 0:
case 3:
return false;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
public override IEnumerator get_LastGenerated()
{
return current;
}
[CompilerGenerated]
[DebuggerNonUserCode]
public override IEnumerator<IEnumerator> GetFreshEnumerator()
{
return (IEnumerator<IEnumerator>)(object)new revivePlayersOnDeath@99-6(orig, self, bodiesEnsured, connectedPlayersOnServer, scrapCollected, null, 0, null);
}
}
[Serializable]
[SpecialName]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static class revivePlayersOnDeath@97-5
{
internal static IEnumerator Invoke(orig_EndOfGame orig, StartOfRound self, int bodiesEnsured, int connectedPlayersOnServer, int scrapCollected)
{
return (IEnumerator)(object)new revivePlayersOnDeath@99-6(orig, self, bodiesEnsured, connectedPlayersOnServer, scrapCollected, null, 0, null);
}
}
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static Random random => <StartupCode$MirageRevive>.$Mirage.Revive.Hook.MaskedPlayerEnemy.random@14;
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static HashSet<ulong> killedPlayers => <StartupCode$MirageRevive>.$Mirage.Revive.Hook.MaskedPlayerEnemy.killedPlayers@17;
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static HauntedMaskItem maskItem
{
get
{
return <StartupCode$MirageRevive>.$Mirage.Revive.Hook.MaskedPlayerEnemy.maskItem@20;
}
set
{
<StartupCode$MirageRevive>.$Mirage.Revive.Hook.MaskedPlayerEnemy.maskItem@20 = value;
}
}
[CompilationArgumentCounts(new int[] { 1, 1, 1, 1, 1 })]
internal static void spawnMaskedEnemy<a>(PlayerControllerB player, int causeOfDeath, int deathAnimation, bool spawnBody, a bodyVelocity)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: 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_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_015f: Unknown result type (might be due to invalid IL or missing references)
//IL_0164: Unknown result type (might be due to invalid IL or missing references)
if (killedPlayers.Add(player.playerClientId))
{
Vector3 position = ((Component)player).transform.position;
NavMeshHit val = default(NavMeshHit);
bool flag = NavMesh.SamplePosition(position, ref val, 1f, -1) && Mathf.Approximately(position.x, ((NavMeshHit)(ref val)).position.x) && Mathf.Approximately(position.z, ((NavMeshHit)(ref val)).position.z);
int num;
if (causeOfDeath == 5 && spawnBody)
{
a val2 = bodyVelocity;
num = (val2.Equals(Vector3.zero) ? 1 : 0);
}
else
{
num = 0;
}
bool flag2 = (byte)num != 0;
bool flag3 = causeOfDeath == 4 && deathAnimation == 4;
Mirage.Revive.Domain.Config.SyncedConfig config = Mirage.Revive.Domain.Config.getConfig();
bool flag4 = !config.reviveOnlyWhenPlayerAlone@ || player.isPlayerAlone;
if ((flag || (player.isInHangarShipRoom && StartOfRound.Instance.shipHasLanded)) && !flag2 && !flag3 && spawnBody && flag4 && random.Next(1, 101) <= config.reviveChance@)
{
float y = ((Component)player).transform.eulerAngles.y;
GameObject val3 = Object.Instantiate<GameObject>(maskItem.mimicEnemy.enemyPrefab, ((Component)player).transform.position, Quaternion.Euler(new Vector3(0f, y, 0f)));
MaskedPlayerEnemy component = val3.GetComponent<MaskedPlayerEnemy>();
component.mimickingPlayer = player;
val3.GetComponentInChildren<NetworkObject>().Spawn(true);
((Component)player).GetComponent<BodyDeactivator.BodyDeactivator>().DeactivateBody((EnemyAI)(object)component);
}
}
}
public static void revivePlayersOnDeath()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Expected O, but got Unknown
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Expected O, but got Unknown
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Expected O, but got Unknown
PlayerControllerB.Awake += new hook_Awake(revivePlayersOnDeath@62.Invoke);
GameNetworkManager.Start += new hook_Start(revivePlayersOnDeath@68-1.Invoke);
StartOfRound.StartGame += new hook_StartGame(revivePlayersOnDeath@79-2.Invoke);
PlayerControllerB.KillPlayerServerRpc += new hook_KillPlayerServerRpc(revivePlayersOnDeath@85-3.Invoke);
PlayerControllerB.KillPlayer += new hook_KillPlayer(revivePlayersOnDeath@89-4.Invoke);
StartOfRound.EndOfGame += new hook_EndOfGame(revivePlayersOnDeath@97-5.Invoke);
}
}
}
namespace <StartupCode$MirageRevive>.$Mirage.Revive.Hook
{
internal static class MaskedPlayerEnemy
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static readonly Random random@14;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static readonly HashSet<ulong> killedPlayers@17;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static HauntedMaskItem maskItem@20;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
internal static int init@;
static MaskedPlayerEnemy()
{
random@14 = new Random();
killedPlayers@17 = new HashSet<ulong>();
maskItem@20 = null;
}
}
}
namespace Mirage.Revive.Unity
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public static class BodyDeactivator
{
[Serializable]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public class BodyDeactivator : NetworkBehaviour
{
public void DeactivateBody(EnemyAI enemy)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB component = ((Component)this).GetComponent<PlayerControllerB>();
if (component.deadBody != null)
{
component.redirectToEnemy = enemy;
component.deadBody.DeactivateBody(false);
if (((NetworkBehaviour)this).IsHost)
{
DeactivateBodyClientRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)this).NetworkObject));
}
}
}
[ClientRpc]
public void DeactivateBodyClientRpc(NetworkObjectReference reference)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Invalid comparison between Unknown and I4
//IL_005f: 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)
//IL_006d: 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_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(727223059u, val, (RpcDelivery)0);
((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref reference, default(ForNetworkSerializable));
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 727223059u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !((NetworkBehaviour)this).IsHost)
{
NetworkObject val3 = null;
if (((NetworkObjectReference)(ref reference)).TryGet(ref val3, (NetworkManager)null))
{
DeactivateBody(((Component)val3).GetComponent<EnemyAI>());
}
else
{
Mirage.Revive.Domain.Logger.logError.Invoke("DeactivateBodyClientRpc received an invalid network object reference.");
}
}
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_BodyDeactivator()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
NetworkManager.__rpc_func_table.Add(727223059u, new RpcReceiveHandler(__rpc_handler_727223059));
}
private static void __rpc_handler_727223059(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: 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_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
NetworkObjectReference reference = default(NetworkObjectReference);
((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref reference, default(ForNetworkSerializable));
target.__rpc_exec_stage = (__RpcExecStage)2;
((BodyDeactivator)(object)target).DeactivateBodyClientRpc(reference);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
protected internal override string __getTypeName()
{
return "BodyDeactivator";
}
}
}
}
namespace <StartupCode$MirageRevive>.$Mirage.Revive.Unity
{
internal static class BodyDeactivator
{
}
}
namespace Mirage.Revive.Hook
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public static class Config
{
[Serializable]
[SpecialName]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static class syncConfig@7
{
internal static void Invoke(orig_ConnectClientToPlayerObject orig, PlayerControllerB self)
{
orig.Invoke(self);
if (NetworkManager.Singleton.IsHost)
{
Mirage.Revive.Domain.Config.registerHandler(Mirage.Revive.Domain.Config.SyncAction.RequestSync);
return;
}
Mirage.Revive.Domain.Config.registerHandler(Mirage.Revive.Domain.Config.SyncAction.ReceiveSync);
Mirage.Revive.Domain.Config.requestSync();
}
}
[Serializable]
[SpecialName]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static class syncConfig@16-1
{
internal static void Invoke(orig_StartDisconnect orig, GameNetworkManager self)
{
orig.Invoke(self);
Mirage.Revive.Domain.Config.syncedConfig = null;
}
}
public static void syncConfig()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
PlayerControllerB.ConnectClientToPlayerObject += new hook_ConnectClientToPlayerObject(syncConfig@7.Invoke);
GameNetworkManager.StartDisconnect += new hook_StartDisconnect(syncConfig@16-1.Invoke);
}
}
}
namespace <StartupCode$MirageRevive>.$Mirage.Revive.Hook
{
internal static class Config
{
}
}
namespace Mirage.Revive.Domain
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public static class Config
{
[Serializable]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public class LocalConfig
{
internal ConfigEntry<int> ReviveChance@;
internal ConfigEntry<bool> ReviveOnlyWhenPlayerAlone@;
public ConfigEntry<int> ReviveChance
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return ReviveChance@;
}
}
public ConfigEntry<bool> ReviveOnlyWhenPlayerAlone
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return ReviveOnlyWhenPlayerAlone@;
}
}
public LocalConfig(ConfigFile config)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
ReviveChance@ = config.Bind<int>("Revive", "Revive chance", 10, new ConfigDescription("The chance a player will revive as a masked enemy, on player death.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
ReviveOnlyWhenPlayerAlone@ = config.Bind<bool>("Revive", "Revive only when alone", false, "If enabled, revivals only happen when the player dies alone (where others will almost never see the masked enemy come to life from your body)." + "If disabled, revivals will always happen based on the configured chance, which means players that are near you can see the masked enemy coming back to life.");
}
}
[Serializable]
[Serializable]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public sealed class SyncedConfig : IEquatable<SyncedConfig>, IStructuralEquatable, IComparable<SyncedConfig>, IComparable, IStructuralComparable
{
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal int reviveChance@;
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal bool reviveOnlyWhenPlayerAlone@;
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public int reviveChance
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return reviveChance@;
}
}
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public bool reviveOnlyWhenPlayerAlone
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return reviveOnlyWhenPlayerAlone@;
}
}
[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(SyncedConfig))]
public SyncedConfig(int reviveChance, bool reviveOnlyWhenPlayerAlone)
{
reviveChance@ = reviveChance;
reviveOnlyWhenPlayerAlone@ = reviveOnlyWhenPlayerAlone;
}
[CompilerGenerated]
public override string ToString()
{
return ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<SyncedConfig, string>>((PrintfFormat<FSharpFunc<SyncedConfig, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<SyncedConfig, string>, Unit, string, string, SyncedConfig>("%+A")).Invoke(this);
}
[CompilerGenerated]
public sealed int CompareTo(SyncedConfig obj)
{
if (this != null)
{
if (obj != null)
{
IComparer genericComparer = LanguagePrimitives.GenericComparer;
int num = reviveChance@;
int num2 = obj.reviveChance@;
int num3 = ((num > num2) ? 1 : 0) - ((num < num2) ? 1 : 0);
if (num3 < 0)
{
return num3;
}
if (num3 > 0)
{
return num3;
}
genericComparer = LanguagePrimitives.GenericComparer;
bool flag = reviveOnlyWhenPlayerAlone@;
bool flag2 = obj.reviveOnlyWhenPlayerAlone@;
return (flag ? 1 : 0) - (flag2 ? 1 : 0);
}
return 1;
}
if (obj != null)
{
return -1;
}
return 0;
}
[CompilerGenerated]
public sealed int CompareTo(object obj)
{
return CompareTo((SyncedConfig)obj);
}
[CompilerGenerated]
public sealed int CompareTo(object obj, IComparer comp)
{
SyncedConfig syncedConfig = (SyncedConfig)obj;
if (this != null)
{
if ((SyncedConfig)obj != null)
{
int num = reviveChance@;
int num2 = syncedConfig.reviveChance@;
int num3 = ((num > num2) ? 1 : 0) - ((num < num2) ? 1 : 0);
if (num3 < 0)
{
return num3;
}
if (num3 > 0)
{
return num3;
}
bool flag = reviveOnlyWhenPlayerAlone@;
bool flag2 = syncedConfig.reviveOnlyWhenPlayerAlone@;
return (flag ? 1 : 0) - (flag2 ? 1 : 0);
}
return 1;
}
if ((SyncedConfig)obj != null)
{
return -1;
}
return 0;
}
[CompilerGenerated]
public sealed int GetHashCode(IEqualityComparer comp)
{
if (this != null)
{
int num = 0;
num = -1640531527 + ((reviveOnlyWhenPlayerAlone@ ? 1 : 0) + ((num << 6) + (num >> 2)));
return -1640531527 + (reviveChance@ + ((num << 6) + (num >> 2)));
}
return 0;
}
[CompilerGenerated]
public sealed override int GetHashCode()
{
return GetHashCode(LanguagePrimitives.GenericEqualityComparer);
}
[CompilerGenerated]
public sealed bool Equals(object obj, IEqualityComparer comp)
{
if (this != null)
{
if (obj is SyncedConfig syncedConfig)
{
if (reviveChance@ == syncedConfig.reviveChance@)
{
return reviveOnlyWhenPlayerAlone@ == syncedConfig.reviveOnlyWhenPlayerAlone@;
}
return false;
}
return false;
}
return obj == null;
}
[CompilerGenerated]
public sealed bool Equals(SyncedConfig obj)
{
if (this != null)
{
if (obj != null)
{
if (reviveChance@ == obj.reviveChance@)
{
return reviveOnlyWhenPlayerAlone@ == obj.reviveOnlyWhenPlayerAlone@;
}
return false;
}
return false;
}
return obj == null;
}
[CompilerGenerated]
public sealed override bool Equals(object obj)
{
if (obj is SyncedConfig obj2)
{
return Equals(obj2);
}
return false;
}
}
[Serializable]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[DebuggerDisplay("{__DebugDisplay(),nq}")]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public sealed class SyncAction : IEquatable<SyncAction>, IStructuralEquatable, IComparable<SyncAction>, IComparable, IStructuralComparable
{
public static class Tags
{
public const int RequestSync = 0;
public const int ReceiveSync = 1;
}
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
internal static readonly SyncAction _unique_RequestSync = new SyncAction(0);
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
internal static readonly SyncAction _unique_ReceiveSync = new SyncAction(1);
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[field: DebuggerNonUserCode]
public int Tag
{
[DebuggerNonUserCode]
get;
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public static SyncAction RequestSync
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
get
{
return _unique_RequestSync;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public bool IsRequestSync
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return Tag == 0;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public static SyncAction ReceiveSync
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
get
{
return _unique_ReceiveSync;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public bool IsReceiveSync
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return Tag == 1;
}
}
[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(SyncAction))]
[CompilerGenerated]
[DebuggerNonUserCode]
internal SyncAction(int _tag)
{
this._tag = _tag;
}
[SpecialName]
[CompilerGenerated]
[DebuggerNonUserCode]
internal object __DebugDisplay()
{
return ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<SyncAction, string>>((PrintfFormat<FSharpFunc<SyncAction, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<SyncAction, string>, Unit, string, string, string>("%+0.8A")).Invoke(this);
}
[CompilerGenerated]
public override string ToString()
{
return ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<SyncAction, string>>((PrintfFormat<FSharpFunc<SyncAction, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<SyncAction, string>, Unit, string, string, SyncAction>("%+A")).Invoke(this);
}
[CompilerGenerated]
public sealed int CompareTo(SyncAction obj)
{
if (this != null)
{
if (obj != null)
{
int tag = _tag;
int tag2 = obj._tag;
if (tag == tag2)
{
return 0;
}
return tag - tag2;
}
return 1;
}
if (obj != null)
{
return -1;
}
return 0;
}
[CompilerGenerated]
public sealed int CompareTo(object obj)
{
return CompareTo((SyncAction)obj);
}
[CompilerGenerated]
public sealed int CompareTo(object obj, IComparer comp)
{
SyncAction syncAction = (SyncAction)obj;
if (this != null)
{
if ((SyncAction)obj != null)
{
int tag = _tag;
int tag2 = syncAction._tag;
if (tag == tag2)
{
return 0;
}
return tag - tag2;
}
return 1;
}
if ((SyncAction)obj != null)
{
return -1;
}
return 0;
}
[CompilerGenerated]
public sealed int GetHashCode(IEqualityComparer comp)
{
return this?._tag ?? 0;
}
[CompilerGenerated]
public sealed override int GetHashCode()
{
return GetHashCode(LanguagePrimitives.GenericEqualityComparer);
}
[CompilerGenerated]
public sealed bool Equals(object obj, IEqualityComparer comp)
{
if (this != null)
{
if (obj is SyncAction syncAction)
{
int tag = _tag;
int tag2 = syncAction._tag;
return tag == tag2;
}
return false;
}
return obj == null;
}
[CompilerGenerated]
public sealed bool Equals(SyncAction obj)
{
if (this != null)
{
if (obj != null)
{
int tag = _tag;
int tag2 = obj._tag;
return tag == tag2;
}
return false;
}
return obj == null;
}
[CompilerGenerated]
public sealed override bool Equals(object obj)
{
if (obj is SyncAction obj2)
{
return Equals(obj2);
}
return false;
}
}
[Serializable]
internal sealed class getConfig@65 : FSharpFunc<Unit, SyncedConfig>
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public SyncedConfig k;
[CompilerGenerated]
[DebuggerNonUserCode]
internal getConfig@65(SyncedConfig k)
{
this.k = k;
}
public override SyncedConfig Invoke(Unit _arg1)
{
return k;
}
}
[Serializable]
internal sealed class onReceiveSync@116 : FSharpFunc<Tuple<Return, FSharpResult<Unit, string>>, FSharpFunc<Unit, FSharpResult<Unit, string>>>
{
internal static readonly onReceiveSync@116 @_instance = new onReceiveSync@116();
[CompilerGenerated]
[DebuggerNonUserCode]
internal onReceiveSync@116()
{
}
public override FSharpFunc<Unit, FSharpResult<Unit, string>> Invoke(Tuple<Return, FSharpResult<Unit, string>> tupledArg)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return Return.Return<Unit, string>(tupledArg.Item2, tupledArg.Item1);
}
}
[Serializable]
internal sealed class onReceiveSync@120-1 : FSharpFunc<Tuple<Return, FSharpResult<Unit, string>>, FSharpFunc<Unit, FSharpResult<Unit, string>>>
{
internal static readonly onReceiveSync@120-1 @_instance = new onReceiveSync@120-1();
[CompilerGenerated]
[DebuggerNonUserCode]
internal onReceiveSync@120-1()
{
}
public override FSharpFunc<Unit, FSharpResult<Unit, string>> Invoke(Tuple<Return, FSharpResult<Unit, string>> tupledArg)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return Return.Return<Unit, string>(tupledArg.Item2, tupledArg.Item1);
}
}
[Serializable]
internal sealed class onReceiveSync@124-2 : FSharpFunc<Tuple<Return, FSharpResult<Unit, string>>, FSharpFunc<Unit, FSharpResult<Unit, string>>>
{
internal static readonly onReceiveSync@124-2 @_instance = new onReceiveSync@124-2();
[CompilerGenerated]
[DebuggerNonUserCode]
internal onReceiveSync@124-2()
{
}
public override FSharpFunc<Unit, FSharpResult<Unit, string>> Invoke(Tuple<Return, FSharpResult<Unit, string>> tupledArg)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return Return.Return<Unit, string>(tupledArg.Item2, tupledArg.Item1);
}
}
[Serializable]
internal sealed class callback@135 : FSharpFunc<ulong, FastBufferReader, Unit>
{
internal static readonly callback@135 @_instance = new callback@135();
[CompilerGenerated]
[DebuggerNonUserCode]
internal callback@135()
{
}
public override Unit Invoke(ulong clientId, FastBufferReader arg10@)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
onRequestSync<FastBufferReader>(clientId, arg10@);
return null;
}
}
[Serializable]
internal sealed class callback@136-1 : FSharpFunc<ulong, FastBufferReader, Unit>
{
internal static readonly callback@136-1 @_instance = new callback@136-1();
[CompilerGenerated]
[DebuggerNonUserCode]
internal callback@136-1()
{
}
public override Unit Invoke(ulong arg00@, FastBufferReader reader)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
onReceiveSync(arg00@, reader);
return null;
}
}
[Serializable]
[SpecialName]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal sealed class registerHandler@137
{
public FSharpFunc<ulong, FSharpFunc<FastBufferReader, Unit>> callback;
public registerHandler@137(FSharpFunc<ulong, FSharpFunc<FastBufferReader, Unit>> callback)
{
this.callback = callback;
base..ctor();
}
internal void Invoke(ulong delegateArg0, FastBufferReader delegateArg1)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
FSharpFunc<ulong, FastBufferReader>.InvokeFast<Unit>(callback, delegateArg0, delegateArg1);
}
}
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static FSharpOption<LocalConfig> localConfig
{
get
{
return <StartupCode$MirageRevive>.$Mirage.Revive.Domain.Config.localConfig@45;
}
set
{
<StartupCode$MirageRevive>.$Mirage.Revive.Domain.Config.localConfig@45 = value;
}
}
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static FSharpOption<SyncedConfig> syncedConfig
{
get
{
return <StartupCode$MirageRevive>.$Mirage.Revive.Domain.Config.syncedConfig@46;
}
set
{
<StartupCode$MirageRevive>.$Mirage.Revive.Domain.Config.syncedConfig@46 = value;
}
}
internal static SyncedConfig toSyncedConfig()
{
return new SyncedConfig(localConfig.Value.ReviveChance@.Value, localConfig.Value.ReviveOnlyWhenPlayerAlone@.Value);
}
internal static string toNamedMessage(SyncAction _arg1)
{
if (_arg1.Tag != 1)
{
return PrintfModule.PrintFormatToStringThen<string>((PrintfFormat<string, Unit, string, string>)(object)new PrintfFormat<string, Unit, string, string, string>("%P()_OnRequestConfigSync", new object[1] { "qwbarch.MirageRevive" }, (Type[])null));
}
return PrintfModule.PrintFormatToStringThen<string>((PrintfFormat<string, Unit, string, string>)(object)new PrintfFormat<string, Unit, string, string, string>("%P()_OnReceiveConfigSync", new object[1] { "qwbarch.MirageRevive" }, (Type[])null));
}
internal static CustomMessagingManager messageManager()
{
return NetworkManager.Singleton.CustomMessagingManager;
}
internal static bool isClient()
{
return NetworkManager.Singleton.IsClient;
}
internal static bool isHost()
{
return NetworkManager.Singleton.IsHost;
}
internal static void initConfig(ConfigFile configFile)
{
localConfig = FSharpOption<LocalConfig>.Some(new LocalConfig(configFile));
}
public static SyncedConfig getConfig()
{
SyncedConfig k = toSyncedConfig();
FSharpFunc<Unit, SyncedConfig> val = new getConfig@65(k);
FSharpOption<SyncedConfig> val2 = syncedConfig;
if (val2 == null)
{
return val.Invoke((Unit)null);
}
return val2.Value;
}
internal static byte[] serializeToBytes<A>(A value)
{
DataContractSerializer dataContractSerializer = new DataContractSerializer(typeof(A));
using MemoryStream memoryStream = new MemoryStream();
try
{
dataContractSerializer.WriteObject(memoryStream, value);
return memoryStream.ToArray();
}
catch (object obj)
{
Exception ex = (Exception)obj;
Logger.logError.Invoke(PrintfModule.PrintFormatToStringThen<string>((PrintfFormat<string, Unit, string, string>)(object)new PrintfFormat<string, Unit, string, string, Exception>("Failed to serialize value: %P()", new object[1] { ex }, (Type[])null)));
return null;
}
}
internal static A deserializeFromBytes<A>(byte[] data)
{
DataContractSerializer dataContractSerializer = new DataContractSerializer(typeof(A));
using MemoryStream stream = new MemoryStream(data);
try
{
return IntrinsicFunctions.UnboxGeneric<A>(dataContractSerializer.ReadObject(stream));
}
catch (object obj)
{
Exception ex = (Exception)obj;
Logger.logError.Invoke(PrintfModule.PrintFormatToStringThen<string>((PrintfFormat<string, Unit, string, string>)(object)new PrintfFormat<string, Unit, string, string, Exception>("Failed to deserialize bytes: %P()", new object[1] { ex }, (Type[])null)));
A result = default(A);
return result;
}
}
[CompilationArgumentCounts(new int[] { 1, 1, 1 })]
internal static void sendMessage(SyncAction action, ulong clientId, FastBufferWriter stream)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: 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)
NetworkDelivery val = (NetworkDelivery)((((FastBufferWriter)(ref stream)).Capacity <= 1300) ? 2 : 4);
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage(toNamedMessage(action), clientId, stream, val);
}
internal static void revertSync()
{
syncedConfig = null;
}
internal unsafe static void requestSync()
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
if (NetworkManager.Singleton.IsClient)
{
FastBufferWriter stream = new FastBufferWriter(sizeof(int), (Allocator)2, -1);
try
{
sendMessage(SyncAction.RequestSync, 0uL, stream);
}
finally
{
((IDisposable)(FastBufferWriter)(ref stream)).Dispose();
}
}
}
[CompilationArgumentCounts(new int[] { 1, 1 })]
internal unsafe static void onRequestSync<a>(ulong clientId, a _arg1)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkManager.Singleton.IsHost)
{
return;
}
byte[] array = serializeToBytes(getConfig());
int num = array.Length;
FastBufferWriter stream = new FastBufferWriter(num + sizeof(int), (Allocator)2, -1);
try
{
ForPrimitives val = default(ForPrimitives);
((FastBufferWriter)(ref stream)).WriteValueSafe<int>(ref num, val);
((FastBufferWriter)(ref stream)).WriteBytesSafe(array, -1, 0);
sendMessage(SyncAction.ReceiveSync, clientId, stream);
}
catch (object obj)
{
Exception ex = (Exception)obj;
Logger.logError.Invoke(PrintfModule.PrintFormatToStringThen<string>((PrintfFormat<string, Unit, string, string>)(object)new PrintfFormat<string, Unit, string, string, Exception>("Failed during onRequestSync: %P()", new object[1] { ex }, (Type[])null)));
}
finally
{
((IDisposable)(FastBufferWriter)(ref stream)).Dispose();
}
}
[CompilerGenerated]
internal static FSharpResult<Unit, string> f@1-1(FastBufferReader reader, FSharpRef<int> bytesLength, Unit unitVar0)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
byte[] array = ArrayModule.ZeroCreate<byte>(bytesLength.contents);
((FastBufferReader)(ref reader)).ReadBytesSafe(ref new FSharpRef<byte[]>(array).contents@, bytesLength.contents, 0);
syncedConfig = FSharpOption<SyncedConfig>.Some(deserializeFromBytes<SyncedConfig>(array));
FSharpResult<Unit, string> item = default(FSharpResult<Unit, string>);
return FSharpFunc<Tuple<Return, FSharpResult<Unit, string>>, Unit>.InvokeFast<FSharpResult<Unit, string>>((FSharpFunc<Tuple<Return, FSharpResult<Unit, string>>, FSharpFunc<Unit, FSharpResult<Unit, string>>>)onReceiveSync@124-2.@_instance, new Tuple<Return, FSharpResult<Unit, string>>(null, item), (Unit)null);
}
[CompilerGenerated]
internal static FSharpResult<Unit, string> f@1(FastBufferReader reader, Unit unitVar0)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: 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_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
FSharpRef<int> val = new FSharpRef<int>(0);
ForPrimitives val2 = default(ForPrimitives);
((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref val.contents@, val2);
FSharpResult<Unit, string> item = default(FSharpResult<Unit, string>);
FSharpResult<Unit, string> val3 = (((FastBufferReader)(ref reader)).TryBeginRead(val.contents) ? FSharpFunc<Tuple<Return, FSharpResult<Unit, string>>, Unit>.InvokeFast<FSharpResult<Unit, string>>((FSharpFunc<Tuple<Return, FSharpResult<Unit, string>>, FSharpFunc<Unit, FSharpResult<Unit, string>>>)onReceiveSync@120-1.@_instance, new Tuple<Return, FSharpResult<Unit, string>>(null, item), (Unit)null) : FSharpResult<Unit, string>.NewError("onReceiveSync failed. Host could not synchronize config."));
Bind val4 = null;
FSharpResult<Unit, string> val5 = default(FSharpResult<Unit, string>);
item = val5;
if (val3.Tag != 0)
{
return FSharpResult<Unit, string>.NewError(val3.ErrorValue);
}
return f@1-1(reader, val, val3.ResultValue);
}
[CompilationArgumentCounts(new int[] { 1, 1 })]
internal unsafe static void onReceiveSync<a>(a _arg1, FastBufferReader reader)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: 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_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkManager.Singleton.IsHost)
{
MonadFxStrictBuilder<FSharpResult<Unit, string>> val = new MonadFxStrictBuilder<FSharpResult<Unit, string>>();
FSharpResult<Unit, string> item = default(FSharpResult<Unit, string>);
FSharpResult<Unit, string> val2 = (((FastBufferReader)(ref reader)).TryBeginRead(sizeof(int)) ? FSharpFunc<Tuple<Return, FSharpResult<Unit, string>>, Unit>.InvokeFast<FSharpResult<Unit, string>>((FSharpFunc<Tuple<Return, FSharpResult<Unit, string>>, FSharpFunc<Unit, FSharpResult<Unit, string>>>)onReceiveSync@116.@_instance, new Tuple<Return, FSharpResult<Unit, string>>(null, item), (Unit)null) : FSharpResult<Unit, string>.NewError("onReceiveSync failed while reading beginning of buffer."));
Bind val3 = null;
FSharpResult<Unit, string> val4 = default(FSharpResult<Unit, string>);
item = val4;
FSharpResult<Unit, string> val5 = ((val2.Tag == 0) ? f@1(reader, val2.ResultValue) : FSharpResult<Unit, string>.NewError(val2.ErrorValue));
if (val5.Tag == 1)
{
Logger.logError.Invoke(val5.ErrorValue);
}
}
}
internal static void registerHandler(SyncAction action)
{
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected O, but got Unknown
string text = toNamedMessage(action);
object @_instance;
if (action.Tag != 1)
{
syncedConfig = FSharpOption<SyncedConfig>.Some(toSyncedConfig());
@_instance = callback@135.@_instance;
}
else
{
@_instance = callback@136-1.@_instance;
}
FSharpFunc<ulong, FSharpFunc<FastBufferReader, Unit>> callback = (FSharpFunc<ulong, FSharpFunc<FastBufferReader, Unit>>)@_instance;
HandleNamedMessageDelegate val = new HandleNamedMessageDelegate(new registerHandler@137(callback).Invoke);
NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler(text, val);
}
}
}
namespace <StartupCode$MirageRevive>.$Mirage.Revive.Domain
{
internal static class Config
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static FSharpOption<Mirage.Revive.Domain.Config.LocalConfig> localConfig@45;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static FSharpOption<Mirage.Revive.Domain.Config.SyncedConfig> syncedConfig@46;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
internal static int init@;
static Config()
{
localConfig@45 = null;
syncedConfig@46 = null;
}
}
}
namespace Mirage.Revive.Domain
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public static class Logger
{
[Serializable]
[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
[DebuggerDisplay("{__DebugDisplay(),nq}")]
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal sealed class LogType : IEquatable<LogType>, IStructuralEquatable, IComparable<LogType>, IComparable, IStructuralComparable
{
internal static class Tags
{
public const int LogInfo = 0;
public const int LogDebug = 1;
public const int LogWarning = 2;
public const int LogError = 3;
}
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
internal static readonly LogType _unique_LogInfo = new LogType(0);
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
internal static readonly LogType _unique_LogDebug = new LogType(1);
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
internal static readonly LogType _unique_LogWarning = new LogType(2);
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
internal static readonly LogType _unique_LogError = new LogType(3);
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[field: DebuggerNonUserCode]
internal int Tag
{
[DebuggerNonUserCode]
get;
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static LogType LogInfo
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
get
{
return _unique_LogInfo;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal bool IsLogInfo
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return Tag == 0;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static LogType LogDebug
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
get
{
return _unique_LogDebug;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal bool IsLogDebug
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return Tag == 1;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static LogType LogWarning
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
get
{
return _unique_LogWarning;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal bool IsLogWarning
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return Tag == 2;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static LogType LogError
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
get
{
return _unique_LogError;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal bool IsLogError
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return Tag == 3;
}
}
[DynamicDependency(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties, typeof(LogType))]
[CompilerGenerated]
[DebuggerNonUserCode]
internal LogType(int _tag)
{
this._tag = _tag;
}
[SpecialName]
[CompilerGenerated]
[DebuggerNonUserCode]
internal object __DebugDisplay()
{
return ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<LogType, string>>((PrintfFormat<FSharpFunc<LogType, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<LogType, string>, Unit, string, string, string>("%+0.8A")).Invoke(this);
}
[CompilerGenerated]
public override string ToString()
{
return ExtraTopLevelOperators.PrintFormatToString<FSharpFunc<LogType, string>>((PrintfFormat<FSharpFunc<LogType, string>, Unit, string, string>)(object)new PrintfFormat<FSharpFunc<LogType, string>, Unit, string, string, LogType>("%+A")).Invoke(this);
}
[CompilerGenerated]
public sealed int CompareTo(LogType obj)
{
if (this != null)
{
if (obj != null)
{
int tag = _tag;
int tag2 = obj._tag;
if (tag == tag2)
{
return 0;
}
return tag - tag2;
}
return 1;
}
if (obj != null)
{
return -1;
}
return 0;
}
[CompilerGenerated]
public sealed int CompareTo(object obj)
{
return CompareTo((LogType)obj);
}
[CompilerGenerated]
public sealed int CompareTo(object obj, IComparer comp)
{
LogType logType = (LogType)obj;
if (this != null)
{
if ((LogType)obj != null)
{
int tag = _tag;
int tag2 = logType._tag;
if (tag == tag2)
{
return 0;
}
return tag - tag2;
}
return 1;
}
if ((LogType)obj != null)
{
return -1;
}
return 0;
}
[CompilerGenerated]
public sealed int GetHashCode(IEqualityComparer comp)
{
return this?._tag ?? 0;
}
[CompilerGenerated]
public sealed override int GetHashCode()
{
return GetHashCode(LanguagePrimitives.GenericEqualityComparer);
}
[CompilerGenerated]
public sealed bool Equals(object obj, IEqualityComparer comp)
{
if (this != null)
{
if (obj is LogType logType)
{
int tag = _tag;
int tag2 = logType._tag;
return tag == tag2;
}
return false;
}
return obj == null;
}
[CompilerGenerated]
public sealed bool Equals(LogType obj)
{
if (this != null)
{
if (obj != null)
{
int tag = _tag;
int tag2 = obj._tag;
return tag == tag2;
}
return false;
}
return obj == null;
}
[CompilerGenerated]
public sealed override bool Equals(object obj)
{
if (obj is LogType obj2)
{
return Equals(obj2);
}
return false;
}
}
[Serializable]
internal sealed class channel@21-4 : FSharpFunc<string, Unit>
{
public ManualLogSource logger;
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@21-4(ManualLogSource logger)
{
this.logger = logger;
}
public override Unit Invoke(string data)
{
logger.LogInfo((object)data);
return null;
}
}
[Serializable]
internal sealed class channel@22-5 : FSharpFunc<string, Unit>
{
public ManualLogSource logger;
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@22-5(ManualLogSource logger)
{
this.logger = logger;
}
public override Unit Invoke(string data)
{
logger.LogDebug((object)data);
return null;
}
}
[Serializable]
internal sealed class channel@23-6 : FSharpFunc<string, Unit>
{
public ManualLogSource logger;
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@23-6(ManualLogSource logger)
{
this.logger = logger;
}
public override Unit Invoke(string data)
{
logger.LogWarning((object)data);
return null;
}
}
[Serializable]
internal sealed class channel@24-7 : FSharpFunc<string, Unit>
{
public ManualLogSource logger;
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@24-7(ManualLogSource logger)
{
this.logger = logger;
}
public override Unit Invoke(string data)
{
logger.LogError((object)data);
return null;
}
}
[Serializable]
internal sealed class channel@26-9 : FSharpFunc<AsyncActivation<Unit>, AsyncReturn>
{
internal static readonly channel@26-9 @_instance = new channel@26-9();
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@26-9()
{
}
public override AsyncReturn Invoke(AsyncActivation<Unit> ctxt)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
return AsyncActivation<Unit>.Success(ctxt, (Unit)null);
}
}
[Serializable]
internal sealed class channel@26-8 : FSharpFunc<Unit, FSharpAsync<Unit>>
{
internal static readonly channel@26-8 @_instance = new channel@26-8();
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@26-8()
{
}
public override FSharpAsync<Unit> Invoke(Unit _arg2)
{
return AsyncPrimitives.MakeAsync<Unit>((FSharpFunc<AsyncActivation<Unit>, AsyncReturn>)channel@26-9.@_instance);
}
}
[Serializable]
internal sealed class channel@26-10 : FSharpFunc<AsyncActivation<Unit>, AsyncReturn>
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public FSharpAsync<Unit> computation;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public FSharpFunc<Unit, FSharpAsync<Unit>> binder;
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@26-10(FSharpAsync<Unit> computation, FSharpFunc<Unit, FSharpAsync<Unit>> binder)
{
this.computation = computation;
this.binder = binder;
}
public override AsyncReturn Invoke(AsyncActivation<Unit> ctxt)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
return AsyncPrimitives.Bind<Unit, Unit>(ctxt, computation, binder);
}
}
[Serializable]
internal sealed class channel@19-3 : FSharpFunc<(LogType, string), FSharpAsync<Unit>>
{
public ManualLogSource logger;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public Lazy<FSharpAsync<Unit>> consumer;
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@19-3(ManualLogSource logger, Lazy<FSharpAsync<Unit>> consumer)
{
this.logger = logger;
this.consumer = consumer;
}
public override FSharpAsync<Unit> Invoke((LogType, string) _arg1)
{
string item = _arg1.Item2;
var (logType, _) = _arg1;
((FSharpFunc<string, Unit>)(logType.Tag switch
{
1 => new channel@22-5(logger),
2 => new channel@23-6(logger),
3 => new channel@24-7(logger),
_ => new channel@21-4(logger),
})).Invoke(item);
FSharpAsync<Unit> value = consumer.Value;
FSharpFunc<Unit, FSharpAsync<Unit>> @_instance;
@_instance = channel@26-8.@_instance;
return AsyncPrimitives.MakeAsync<Unit>((FSharpFunc<AsyncActivation<Unit>, AsyncReturn>)new channel@26-10(value, @_instance));
}
}
[Serializable]
internal sealed class channel@18-11 : FSharpFunc<AsyncActivation<Unit>, AsyncReturn>
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public FSharpAsync<(LogType, string)> computation;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public FSharpFunc<(LogType, string), FSharpAsync<Unit>> binder;
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@18-11(FSharpAsync<(LogType, string)> computation, FSharpFunc<(LogType, string), FSharpAsync<Unit>> binder)
{
this.computation = computation;
this.binder = binder;
}
public override AsyncReturn Invoke(AsyncActivation<Unit> ctxt)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
return AsyncPrimitives.Bind<Unit, (LogType, string)>(ctxt, computation, binder);
}
}
[Serializable]
internal sealed class channel@18-2 : FSharpFunc<Unit, FSharpAsync<Unit>>
{
public ManualLogSource logger;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public Lazy<FSharpAsync<Unit>> consumer;
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@18-2(ManualLogSource logger, Lazy<FSharpAsync<Unit>> consumer)
{
this.logger = logger;
this.consumer = consumer;
}
public override FSharpAsync<Unit> Invoke(Unit unitVar)
{
FSharpAsync<(LogType, string)> computation = self@13.AsyncGet((FSharpOption<int>)null);
FSharpFunc<(LogType, string), FSharpAsync<Unit>> binder = new channel@19-3(logger, consumer);
return AsyncPrimitives.MakeAsync<Unit>((FSharpFunc<AsyncActivation<Unit>, AsyncReturn>)new channel@18-11(computation, binder));
}
}
[Serializable]
internal sealed class channel@16-1 : FSharpFunc<Unit, FSharpAsync<Unit>>
{
public ManualLogSource logger;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public Lazy<FSharpAsync<Unit>> consumer;
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@16-1(ManualLogSource logger, Lazy<FSharpAsync<Unit>> consumer)
{
this.logger = logger;
this.consumer = consumer;
}
public override FSharpAsync<Unit> Invoke(Unit unitVar)
{
return ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<Unit>((FSharpFunc<Unit, FSharpAsync<Unit>>)new channel@18-2(logger, consumer));
}
}
[Serializable]
internal sealed class channel@15 : FSharpFunc<Unit, FSharpAsync<Unit>>
{
internal static readonly channel@15 @_instance = new channel@15();
[CompilerGenerated]
[DebuggerNonUserCode]
internal channel@15()
{
}
public override FSharpAsync<Unit> Invoke(Unit unitVar)
{
ManualLogSource logger = Logger.CreateLogSource("qwbarch.MirageRevive");
Lazy<FSharpAsync<Unit>> consumer = default(Lazy<FSharpAsync<Unit>>);
FSharpFunc<Unit, FSharpAsync<Unit>> val = new channel@16-1(logger, consumer);
consumer = LazyExtensions.Create<FSharpAsync<Unit>>(val);
((channel@16-1)val).consumer = consumer;
FSharpAsync<Unit> value = consumer.Value;
FSharpAsync.StartImmediate(value, (FSharpOption<CancellationToken>)null);
return ExtraTopLevelOperators.DefaultAsyncBuilder.Zero();
}
}
[Serializable]
internal sealed class logInfo@35 : FSharpFunc<string, Unit>
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public LogType logType;
[CompilerGenerated]
[DebuggerNonUserCode]
internal logInfo@35(LogType logType)
{
this.logType = logType;
}
public override Unit Invoke(string message)
{
logMessage(logType, message);
return null;
}
}
[Serializable]
internal sealed class logDebug@36 : FSharpFunc<string, Unit>
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public LogType logType;
[CompilerGenerated]
[DebuggerNonUserCode]
internal logDebug@36(LogType logType)
{
this.logType = logType;
}
public override Unit Invoke(string message)
{
logMessage(logType, message);
return null;
}
}
[Serializable]
internal sealed class logWarning@37 : FSharpFunc<string, Unit>
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public LogType logType;
[CompilerGenerated]
[DebuggerNonUserCode]
internal logWarning@37(LogType logType)
{
this.logType = logType;
}
public override Unit Invoke(string message)
{
logMessage(logType, message);
return null;
}
}
[Serializable]
internal sealed class logError@38 : FSharpFunc<string, Unit>
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
public LogType logType;
[CompilerGenerated]
[DebuggerNonUserCode]
internal logError@38(LogType logType)
{
this.logType = logType;
}
public override Unit Invoke(string message)
{
logMessage(logType, message);
return null;
}
}
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static BlockingQueueAgent<(LogType, string)> channel => <StartupCode$MirageRevive>.$Mirage.Revive.Domain.Logger.channel@12;
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static BlockingQueueAgent<(LogType, string)> self@13 => <StartupCode$MirageRevive>.$Mirage.Revive.Domain.Logger.self@13;
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static FSharpAsync<Unit> arg1@1 => <StartupCode$MirageRevive>.$Mirage.Revive.Domain.Logger.arg1@1;
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static FSharpFunc<string, Unit> logInfo => <StartupCode$MirageRevive>.$Mirage.Revive.Domain.Logger.logInfo@35;
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static FSharpFunc<string, Unit> logDebug => <StartupCode$MirageRevive>.$Mirage.Revive.Domain.Logger.logDebug@36;
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static FSharpFunc<string, Unit> logWarning => <StartupCode$MirageRevive>.$Mirage.Revive.Domain.Logger.logWarning@37;
[CompilationMapping(/*Could not decode attribute arguments.*/)]
internal static FSharpFunc<string, Unit> logError => <StartupCode$MirageRevive>.$Mirage.Revive.Domain.Logger.logError@38;
[CompilationArgumentCounts(new int[] { 1, 1 })]
internal static void logMessage(LogType logType, string message)
{
(LogType, string) tuple = (logType, message);
FSharpAsync<Unit> val = channel.AsyncAdd(tuple, (FSharpOption<int>)null);
FSharpAsync.StartImmediate(val, (FSharpOption<CancellationToken>)null);
}
}
}
namespace <StartupCode$MirageRevive>.$Mirage.Revive.Domain
{
internal static class Logger
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static readonly BlockingQueueAgent<(Mirage.Revive.Domain.Logger.LogType, string)> channel@12;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static readonly BlockingQueueAgent<(Mirage.Revive.Domain.Logger.LogType, string)> self@13;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static readonly FSharpAsync<Unit> arg1@1;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static readonly FSharpFunc<string, Unit> logInfo@35;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static readonly FSharpFunc<string, Unit> logDebug@36;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static readonly FSharpFunc<string, Unit> logWarning@37;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal static readonly FSharpFunc<string, Unit> logError@38;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
[CompilerGenerated]
[DebuggerNonUserCode]
internal static int init@;
static Logger()
{
self@13 = new BlockingQueueAgent<(Mirage.Revive.Domain.Logger.LogType, string)>(int.MaxValue);
arg1@1 = ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<Unit>((FSharpFunc<Unit, FSharpAsync<Unit>>)Mirage.Revive.Domain.Logger.channel@15.@_instance);
FSharpAsync.Start(Mirage.Revive.Domain.Logger.arg1@1, (FSharpOption<CancellationToken>)null);
channel@12 = Mirage.Revive.Domain.Logger.self@13;
Mirage.Revive.Domain.Logger.LogType logInfo = Mirage.Revive.Domain.Logger.LogType.LogInfo;
logInfo@35 = new Mirage.Revive.Domain.Logger.logInfo@35(logInfo);
logInfo = Mirage.Revive.Domain.Logger.LogType.LogDebug;
logDebug@36 = new Mirage.Revive.Domain.Logger.logDebug@36(logInfo);
logInfo = Mirage.Revive.Domain.Logger.LogType.LogWarning;
logWarning@37 = new Mirage.Revive.Domain.Logger.logWarning@37(logInfo);
logInfo = Mirage.Revive.Domain.Logger.LogType.LogError;
logError@38 = new Mirage.Revive.Domain.Logger.logError@38(logInfo);
}
}
}
namespace Mirage.Revive.Domain
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public static class Netcode
{
[Serializable]
internal sealed class initNetcodePatcher@41 : FSharpFunc<Type, MethodInfo[]>
{
internal static readonly initNetcodePatcher@41 @_instance = new initNetcodePatcher@41();
[CompilerGenerated]
[DebuggerNonUserCode]
internal initNetcodePatcher@41()
{
}
public override MethodInfo[] Invoke(Type _arg1)
{
return _arg1.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
}
}
[Serializable]
internal sealed class initNetcodePatcher@41-1 : FSharpFunc<MethodInfo, Unit>
{
internal static readonly initNetcodePatcher@41-1 @_instance = new initNetcodePatcher@41-1();
[CompilerGenerated]
[DebuggerNonUserCode]
internal initNetcodePatcher@41-1()
{
}
public override Unit Invoke(MethodInfo method)
{
invokeMethod(method);
return null;
}
}
[Literal]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
internal const BindingFlags flags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic;
internal static void invokeMethod(MethodInfo method)
{
object[] customAttributes = method.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length > 0)
{
object obj = method.Invoke(null, null);
}
}
public static void initNetcodePatcher()
{
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
FSharpFunc<Type, MethodInfo[]> @_instance;
@_instance = initNetcodePatcher@41.@_instance;
Bind val = null;
MethodInfo[] array = null;
MethodInfo[] array2 = ArrayModule.Collect<Type, MethodInfo>(@_instance, types);
Iterate val2 = null;
Iterate.Iterate<MethodInfo>(array2, (FSharpFunc<MethodInfo, Unit>)initNetcodePatcher@41-1.@_instance);
}
}
}
namespace <StartupCode$MirageRevive>.$Mirage.Revive.Domain
{
internal static class Netcode
{
}
}
namespace Mirage.Revive
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public static class Compatibility
{
[Serializable]
internal sealed class initLobbyCompatibility@14 : FSharpFunc<Unit, FSharpAsync<Unit>>
{
internal static readonly initLobbyCompatibility@14 @_instance = new initLobbyCompatibility@14();
[CompilerGenerated]
[DebuggerNonUserCode]
internal initLobbyCompatibility@14()
{
}
public override FSharpAsync<Unit> Invoke(Unit unitVar)
{
PluginHelper.RegisterPlugin("MirageRevive", Version.Parse("1.0.0"), (CompatibilityLevel)2, (VersionStrictness)2);
return ExtraTopLevelOperators.DefaultAsyncBuilder.Zero();
}
}
public static void initLobbyCompatibility()
{
if (Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility"))
{
FSharpAsync<Unit> val = ExtraTopLevelOperators.DefaultAsyncBuilder.Delay<Unit>((FSharpFunc<Unit, FSharpAsync<Unit>>)initLobbyCompatibility@14.@_instance);
FSharpAsync.RunSynchronously<Unit>(val, (FSharpOption<int>)null, (FSharpOption<CancellationToken>)null);
}
}
}
}
namespace <StartupCode$MirageRevive>.$Mirage.Revive
{
internal static class Compatibility
{
}
}
namespace Mirage.Revive
{
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public static class PluginInfo
{
[Literal]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public const string pluginName = "MirageRevive";
[Literal]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public const string pluginId = "qwbarch.MirageRevive";
[Literal]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public const string pluginVersion = "1.0.0";
}
}
namespace <StartupCode$MirageRevive>.$Mirage.Revive
{
internal static class PluginInfo
{
}
}
[CompilationMapping(/*Could not decode attribute arguments.*/)]
public static class AssemblyInfo
{
}
namespace <StartupCode$MirageRevive>
{
internal static class $AssemblyInfo
{
}
}
namespace <StartupCode$MirageRevive>.$MirageRevive
{
internal static class AssemblyInfo
{
}
}
namespace <StartupCode$MirageRevive>.$.NETStandard,Version=v2.1
{
internal static class AssemblyAttributes
{
}
}
namespace System.Diagnostics.CodeAnalysis
{
[Serializable]
[Flags]
[CompilerGenerated]
[DebuggerNonUserCode]
internal enum DynamicallyAccessedMemberTypes
{
All = -1,
None = 0,
PublicParameterlessConstructor = 1,
PublicConstructors = 3,
NonPublicConstructors = 4,
PublicMethods = 8,
NonPublicMethods = 0x10,
PublicFields = 0x20,
NonPublicFields = 0x40,
PublicNestedTypes = 0x80,
NonPublicNestedTypes = 0x100,
PublicProperties = 0x200,
NonPublicProperties = 0x400,
PublicEvents = 0x800,
NonPublicEvents = 0x1000,
Interfaces = 0x2000
}
[CompilerGenerated]
internal class DynamicDependencyAttribute : Attribute
{
[CompilerGenerated]
[DebuggerNonUserCode]
private DynamicallyAccessedMemberTypes MemberType@;
[CompilerGenerated]
[DebuggerNonUserCode]
private Type Type@;
[CompilerGenerated]
[DebuggerNonUserCode]
public DynamicallyAccessedMemberTypes MemberType
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return MemberType@;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
public Type Type
{
[CompilerGenerated]
[DebuggerNonUserCode]
get
{
return Type@;
}
}
[CompilerGenerated]
[DebuggerNonUserCode]
public DynamicDependencyAttribute(DynamicallyAccessedMemberTypes MemberType, Type Type)
{
MemberType@ = MemberType;
Type@ = Type;
}
}
}
namespace MirageRevive.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
