using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Text;
using Microsoft.CodeAnalysis;
using PleadIgnorance.Core;
using PleadIgnorance.Utils;
using ProjectM;
using ProjectM.Network;
using Unity.Collections;
using Unity.Entities;
using VampireCommandFramework;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("PleadIgnorance")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0-release.1+6.Branch.release.Sha.88d3e9122dbed14c555f0dc5c64eef0b7ad8685d.88d3e9122dbed14c555f0dc5c64eef0b7ad8685d")]
[assembly: AssemblyProduct("PleadIgnorance")]
[assembly: AssemblyTitle("PleadIgnorance")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace PleadIgnorance
{
public class Commands
{
[Command("showmessageprompt", "src", null, "Show the message prompt", null, true)]
public void Test(ChatCommandContext ctx)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
Chat.SendFormattedMessage(ctx.User);
}
[Command("accept", null, null, "test", null, false)]
public void Accept(ChatCommandContext ctx)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
Plugin.Instance.AcceptedUsers.Add(ctx.User.PlatformId);
ctx.Reply("You may now leave the spawn area!");
}
}
[BepInPlugin("PleadIgnorance", "PleadIgnorance", "0.1.0-release.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BasePlugin
{
public readonly List<ulong> AcceptedUsers = new List<ulong>();
private static Harmony? _harmony;
internal static Plugin? Instance { get; private set; }
public override void Load()
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Expected O, but got Unknown
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
Instance = this;
Log.Initialize(((BasePlugin)this).Log);
Config.Initialize();
_harmony = new Harmony("PleadIgnorance");
_harmony.PatchAll(Assembly.GetExecutingAssembly());
CommandRegistry.RegisterAll();
ManualLogSource log = ((BasePlugin)this).Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(27, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Plugin ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("PleadIgnorance");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" version ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("0.1.0-release.1");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is loaded!");
}
log.LogInfo(val);
}
public override bool Unload()
{
Harmony? harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
return true;
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "PleadIgnorance";
public const string PLUGIN_NAME = "PleadIgnorance";
public const string PLUGIN_VERSION = "0.1.0-release.1";
}
}
namespace PleadIgnorance.Utils
{
public static class Chat
{
public static void SendFormattedMessage(User target)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
StringBuilder sb = new StringBuilder();
Encoding utf8 = Encoding.UTF8;
int flushCount = 0;
if (!string.IsNullOrWhiteSpace(Config.Header?.Value))
{
Accumulate(Config.Header.Value);
}
foreach (string messageLine in Config.MessageLines)
{
Accumulate(messageLine);
}
if (!string.IsNullOrWhiteSpace(Config.Footer?.Value))
{
Accumulate(Config.Footer.Value);
}
Flush();
int Accumulate(string line)
{
int byteCount = utf8.GetByteCount(line + "\n");
if (utf8.GetByteCount(sb.ToString()) + byteCount > 512)
{
Flush();
if (flushCount > 0)
{
sb.AppendLine();
}
}
sb.AppendLine(line);
return byteCount;
}
void Flush()
{
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
if (sb.Length != 0)
{
string text = sb.ToString();
if (utf8.GetByteCount(text) > 512)
{
text = TruncateToByteLimit(text, 512, utf8);
}
FixedString512Bytes val = default(FixedString512Bytes);
((FixedString512Bytes)(ref val))..ctor(text);
ServerChatUtils.SendSystemMessageToClient(VWorld.EntityManager, target, ref val);
sb.Clear();
flushCount++;
}
}
}
private static string TruncateToByteLimit(string input, int byteLimit, Encoding encoding)
{
int num = 0;
StringBuilder stringBuilder = new StringBuilder();
foreach (char c in input)
{
int byteCount = encoding.GetByteCount(new char[1] { c });
if (num + byteCount > byteLimit)
{
break;
}
stringBuilder.Append(c);
num += byteCount;
}
return stringBuilder.ToString();
}
}
}
namespace PleadIgnorance.Patch
{
[HarmonyPatch(typeof(TeleportationRequestSystem), "OnUpdate")]
public static class HandleTeleportationRequest
{
private static void Prefix(TeleportationRequestSystem __instance)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: 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_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: 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_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: 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_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: 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_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
EntityManager entityManager = ((ComponentSystemBase)__instance).EntityManager;
EntityQuery teleportRequestQuery = __instance._TeleportRequestQuery;
NativeArray<Entity> val = ((EntityQuery)(ref teleportRequestQuery)).ToEntityArray(AllocatorHandle.op_Implicit((Allocator)2));
Enumerator<Entity> enumerator = val.GetEnumerator();
while (enumerator.MoveNext())
{
Entity current = enumerator.Current;
TeleportationRequest val2 = current.Read<TeleportationRequest>();
int value = val2.CustomTravelBuffPrefab._Value;
User val3 = val2.PlayerEntity.Read<PlayerCharacter>().UserEntity.Read<User>();
if (value == 2033937156 && !Plugin.Instance.AcceptedUsers.Contains(val3.PlatformId))
{
if (Config.PreventCaveExit.Value.Equals(obj: true))
{
((EntityManager)(ref entityManager)).DestroyEntity(current);
}
Chat.SendFormattedMessage(val3);
}
}
val.Dispose();
}
}
}
namespace PleadIgnorance.Core
{
public static class Config
{
internal static List<string> MessageLines;
internal static ConfigEntry<string> Header;
internal static ConfigEntry<string> Footer;
internal static ConfigEntry<bool> PreventCaveExit;
internal static void Initialize()
{
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
string text = Path.Combine(Paths.ConfigPath, "PleadIgnorance", "config.cfg");
string path = Path.Combine(Paths.ConfigPath, "PleadIgnorance", "message.cfg");
if (!File.Exists(path))
{
Directory.CreateDirectory(Path.GetDirectoryName(path) ?? string.Empty);
File.WriteAllText(path, "<color=#ffffffff>Rule 1:</color> Dont be an asshole.\n<color=#ffffffff>Rule 2:</color> <b>You can</b>\n<color=#ffffffff>Rule 3:</color> <i>Also use</i>\n<color=#ffffffff>Rule 4:</color> <size=10>Rich text</size>\n<color=#ffffffff>Rule 5:</color> <size=15>Formatting in</size>\n<color=#ffffffff>Rule 6:</color> <size=20>The <color=#add8e6ff>Message</color></size>");
}
MessageLines = new List<string>(File.ReadAllLines(path));
Directory.CreateDirectory(Path.GetDirectoryName(text) ?? string.Empty);
ConfigFile val = new ConfigFile(text, true);
Header = val.Bind<string>("Text", "Header", "<color=#add8e6ff>Server Rules</color>", "Message header text");
Footer = val.Bind<string>("Text", "Footer", "Type <color=#ffff00ff><b>.accept</b></color> to continue", "Message footer text");
PreventCaveExit = val.Bind<bool>("Options", "PreventCaveExit", true, "Prevent cave exit until player accepts the rules.");
Log.Info("Config Initialized");
}
}
internal static class Extensions
{
private static EntityManager Em => VWorld.EntityManager;
public static T Read<T>(this Entity entity) where T : struct
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: 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)
EntityManager em = Em;
return ((EntityManager)(ref em)).GetComponentData<T>(entity);
}
public static void ExploreEntity(this Entity entity)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Expected O, but got Unknown
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
StringBuilder val = new StringBuilder();
EntityDebuggingUtility.DumpEntity(VWorld.Server, entity, true, val);
Log.Info(((Object)val).ToString());
}
}
public static class Log
{
private static ManualLogSource? LogSource { get; set; }
public static void Initialize(ManualLogSource? logSource)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Expected O, but got Unknown
LogSource = logSource;
ManualLogSource logSource2 = LogSource;
if (logSource2 != null)
{
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(24, 0, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Log] Source Initialized");
}
logSource2.LogInfo(val);
}
}
public static void Info(string message)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
ManualLogSource logSource = LogSource;
if (logSource != null)
{
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(0, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(message);
}
logSource.LogInfo(val);
}
}
public static void Message(string message)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
ManualLogSource logSource = LogSource;
if (logSource != null)
{
bool flag = default(bool);
BepInExMessageLogInterpolatedStringHandler val = new BepInExMessageLogInterpolatedStringHandler(0, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(message);
}
logSource.LogMessage(val);
}
}
public static void Warning(string message)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
ManualLogSource logSource = LogSource;
if (logSource != null)
{
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(0, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(message);
}
logSource.LogWarning(val);
}
}
public static void Error(string message)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
ManualLogSource logSource = LogSource;
if (logSource != null)
{
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(0, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(message);
}
logSource.LogError(val);
}
}
}
public static class VWorld
{
private static World? _serverWorld;
private static EntityManager? _entityManager;
public static World Server
{
get
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
if (_serverWorld != null && _serverWorld.IsCreated)
{
return _serverWorld;
}
_serverWorld = GetWorld("Server");
if (_serverWorld == null || !_serverWorld.IsCreated)
{
_entityManager = null;
throw new Exception("Server world is not available or not created.");
}
_entityManager = _serverWorld.EntityManager;
return _serverWorld;
}
}
public static EntityManager EntityManager
{
get
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
if (_entityManager.HasValue && _serverWorld != null && _serverWorld.IsCreated)
{
return _entityManager.Value;
}
return Server.EntityManager;
}
}
private static World? GetWorld(string name)
{
Enumerator<World> enumerator = World.s_AllWorlds.GetEnumerator();
while (enumerator.MoveNext())
{
World current = enumerator.Current;
if (current.Name == name)
{
return current;
}
}
return null;
}
}
}
