using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using FrogDataLib.DataManagement;
using FrogDataLib.Patches;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using Newtonsoft.Json;
using UnityEngine;
using YAPYAP;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("dev.mamallama.frogdatalib")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.1.0")]
[assembly: AssemblyInformationalVersion("0.2.1+b2a32a4ee4d7395481f93ec68976e80c32452b63")]
[assembly: AssemblyProduct("dev.mamallama.frogdatalib")]
[assembly: AssemblyTitle("FrogDataLib")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace FrogDataLib
{
[BepInPlugin("dev.mamallama.frogdatalib", "FrogDataLib", "0.2.1")]
public class FrogDataPlugin : BaseUnityPlugin
{
public const string Id = "dev.mamallama.frogdatalib";
internal static ManualLogSource Log { get; private set; }
public static string Name => "FrogDataLib";
public static string Version => "0.2.1";
private void Awake()
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
if (!FrogDataManager.PersistentPath.Exists)
{
Log.LogMessage((object)"Creating persistent data path for FrogDataLib");
FrogDataManager.PersistentPath.Create();
}
Harmony val = new Harmony("dev.mamallama.frogdatalib");
val.PatchAll(typeof(MainMenuActionPatcher));
val.PatchAll(typeof(SaveManagerPatches));
Log.LogInfo((object)$"Patch count is {val.GetPatchedMethods().Count()}");
}
}
}
namespace FrogDataLib.Patches
{
internal static class MainMenuActionPatcher
{
internal static Action? orig;
[HarmonyPatch(typeof(UISettings), "SetMainMenuAction")]
[HarmonyPrefix]
internal static void Patch()
{
FrogDataPlugin.Log.LogMessage((object)"Taking over UISettings._mainMenuAction");
if (orig == null)
{
orig = UIManager.Instance.uiSettings._mainMenuAction;
}
UIManager.Instance.uiSettings._mainMenuAction = MenuActionListener;
}
internal static void MenuActionListener()
{
orig?.Invoke();
FrogDataManager.SessionEnded();
}
}
internal static class SaveManagerPatches
{
[HarmonyPatch(typeof(SaveManager), "LoadSlot")]
[HarmonyPostfix]
internal static void LoadSlotPostfix(int slot)
{
FrogDataManager.LoadFromSlot(slot);
}
[HarmonyPatch(typeof(SaveManager), "DeleteSlot")]
[HarmonyPostfix]
internal static void DeleteSlotPostfix(int slot)
{
FrogDataManager.DeleteSlot(slot);
}
[HarmonyPatch(typeof(SaveManager), "WriteSlot")]
[HarmonyPostfix]
internal static void WriteSlotPostfix(int slot)
{
FrogDataManager.SaveToSlot(slot);
}
}
}
namespace FrogDataLib.DataManagement
{
public readonly record struct AssetMUD
{
public readonly string Identifier;
public AssetMUD(NetworkBehaviour source)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
Vector3 input = default(Vector3);
Quaternion val = default(Quaternion);
((Component)source).gameObject.transform.GetPositionAndRotation(ref input, ref val);
Identifier = $"{source.netIdentity.assetId}::{Vector3Approximate(input)}::{Vector3Approximate(((Quaternion)(ref val)).eulerAngles)}";
}
public AssetMUD(string id)
{
Identifier = id;
}
public string GetDigest()
{
using SHA256 sHA = SHA256.Create();
byte[] bytes = Encoding.UTF8.GetBytes(Identifier);
byte[] array = sHA.ComputeHash(bytes);
StringBuilder stringBuilder = new StringBuilder();
byte[] array2 = array;
foreach (byte b in array2)
{
stringBuilder.Append(b.ToString("X2"));
}
return stringBuilder.ToString();
}
public static string Vector3Approximate(Vector3 input)
{
//IL_0005: 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_001b: Unknown result type (might be due to invalid IL or missing references)
return $"{input.x:F3},{input.y:F3},{input.z:F3}";
}
}
public class FrogDataContainer<TModel> where TModel : FrogDataModel, new()
{
public readonly string GUID;
public FrogDataContainer(string guid)
{
GUID = guid;
base..ctor();
}
public TModel GetModData()
{
if (FrogDataManager.TryGetModData<TModel>(GUID, out TModel value))
{
return value;
}
return new TModel();
}
public bool SaveModData(TModel data)
{
return FrogDataManager.TrySaveModData(GUID, data);
}
}
public class FrogDataContainerSimple<TModel> : FrogDataContainer<TModel> where TModel : FrogDataModel, new()
{
public TModel Data = new TModel();
public FrogDataContainerSimple(string guid)
: base(guid)
{
FrogDataManager.OnBeginSaving += OnSaveGame;
FrogDataManager.OnLoadCompleted += OnLoadGame;
FrogDataManager.OnSessionEnded += OnSessionEnd;
}
private void OnSaveGame()
{
SaveModData(Data);
}
private void OnLoadGame()
{
Data = GetModData();
}
private void OnSessionEnd()
{
Data = new TModel();
}
}
public static class FrogDataManager
{
internal static readonly DirectoryInfo PersistentPath = new DirectoryInfo(Path.Combine(Application.persistentDataPath, "FrogData"));
internal static JsonSerializerSettings SerialSettings = new JsonSerializerSettings
{
TypeNameHandling = (TypeNameHandling)4,
ObjectCreationHandling = (ObjectCreationHandling)2
};
private static Dictionary<string, string> MasterData = new Dictionary<string, string>();
public static event Action? OnBeginSaving;
public static event Action? OnLoadCompleted;
public static event Action? OnSessionEnded;
internal static void SaveToSlot(int slot)
{
FrogDataPlugin.Log.LogMessage((object)$"Saving slot {slot}");
FrogDataManager.OnBeginSaving?.Invoke();
FileInfo fileInfo = new FileInfo(Path.Combine(PersistentPath.FullName, $"slot_{slot}.dat"));
try
{
string value = JsonConvert.SerializeObject((object)MasterData);
using FileStream stream = new FileStream(fileInfo.FullName, FileMode.Create, FileAccess.Write);
using StreamWriter streamWriter = new StreamWriter(stream, Encoding.UTF8);
streamWriter.Write(value);
streamWriter.Flush();
}
catch (Exception ex)
{
FrogDataPlugin.Log.LogError((object)$"Unable to save data to slot {slot}\n\nFull Text: {ex.Message}");
}
}
internal static void LoadFromSlot(int slot)
{
FrogDataPlugin.Log.LogMessage((object)$"Loading slot {slot}");
FileInfo fileInfo = new FileInfo(Path.Combine(PersistentPath.FullName, $"slot_{slot}.dat"));
if (!fileInfo.Exists)
{
FrogDataPlugin.Log.LogInfo((object)$"Skipping slot {slot}, no data to load");
return;
}
try
{
using StreamReader streamReader = new StreamReader(fileInfo.FullName);
string text = streamReader.ReadToEnd();
Dictionary<string, string> dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(text);
if (dictionary == null)
{
MasterData = new Dictionary<string, string>();
}
else
{
MasterData = dictionary;
}
}
catch (Exception ex)
{
FrogDataPlugin.Log.LogError((object)$"Unable to load data from slot {slot}\n\nFull Text: {ex.Message}");
return;
}
FrogDataManager.OnLoadCompleted?.Invoke();
}
internal static void DeleteSlot(int slot)
{
FrogDataPlugin.Log.LogMessage((object)$"Deleting slot {slot}");
FileInfo fileInfo = new FileInfo(Path.Combine(PersistentPath.FullName, $"slot_{slot}.dat"));
if (fileInfo.Exists)
{
fileInfo.Delete();
}
}
internal static void SessionEnded()
{
FrogDataPlugin.Log.LogMessage((object)"The session has ended");
FrogDataManager.OnSessionEnded?.Invoke();
MasterData.Clear();
}
internal static bool TryGetModData<TModel>(string guid, [NotNullWhen(true)] out TModel? value) where TModel : FrogDataModel, new()
{
value = null;
if (!MasterData.TryGetValue(guid, out string value2))
{
return false;
}
try
{
TModel val = JsonConvert.DeserializeObject<TModel>(value2);
if (val == null)
{
FrogDataPlugin.Log.LogError((object)("Unable to deserialize model for " + guid + " because the response from Newtonsoft.JSON was null. Data may be invalid or corrupt."));
return false;
}
value = val;
value.OnAfterSerialize();
}
catch (Exception ex)
{
FrogDataPlugin.Log.LogError((object)("Failed to deserialize data for " + guid + ".\n\nFull Text: " + ex.Message));
return false;
}
return true;
}
internal static bool TrySaveModData<TModel>(string guid, TModel data) where TModel : FrogDataModel, new()
{
try
{
data.OnBeforeSerialize();
string value = JsonConvert.SerializeObject((object)data);
MasterData[guid] = value;
}
catch (Exception ex)
{
FrogDataPlugin.Log.LogError((object)("An error was encountered while trying to save a model from " + guid + "\n\nFull Text: " + ex.Message));
return false;
}
return true;
}
}
public abstract class FrogDataModel
{
[Obsolete("Legacy artifact of JsonUtility, not used for anything")]
[JsonProperty("_frogSentinel")]
private int FrogSentinel;
public bool ShouldSerializeFrogSentinel()
{
FrogDataPlugin.Log.LogMessage((object)"Should Serialize Callback for FrogSentinel");
return false;
}
public virtual void OnAfterSerialize()
{
}
public virtual void OnBeforeSerialize()
{
}
}
}
namespace System.Diagnostics.CodeAnalysis
{
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class ConstantExpectedAttribute : Attribute
{
public object? Min { get; set; }
public object? Max { get; set; }
}
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class ExperimentalAttribute : Attribute
{
public string DiagnosticId { get; }
public string? UrlFormat { get; set; }
public ExperimentalAttribute(string diagnosticId)
{
DiagnosticId = diagnosticId;
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
[ExcludeFromCodeCoverage]
internal sealed class MemberNotNullAttribute : Attribute
{
public string[] Members { get; }
public MemberNotNullAttribute(string member)
{
Members = new string[1] { member };
}
public MemberNotNullAttribute(params string[] members)
{
Members = members;
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
[ExcludeFromCodeCoverage]
internal sealed class MemberNotNullWhenAttribute : Attribute
{
public bool ReturnValue { get; }
public string[] Members { get; }
public MemberNotNullWhenAttribute(bool returnValue, string member)
{
ReturnValue = returnValue;
Members = new string[1] { member };
}
public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
{
ReturnValue = returnValue;
Members = members;
}
}
[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class SetsRequiredMembersAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class StringSyntaxAttribute : Attribute
{
public const string CompositeFormat = "CompositeFormat";
public const string DateOnlyFormat = "DateOnlyFormat";
public const string DateTimeFormat = "DateTimeFormat";
public const string EnumFormat = "EnumFormat";
public const string GuidFormat = "GuidFormat";
public const string Json = "Json";
public const string NumericFormat = "NumericFormat";
public const string Regex = "Regex";
public const string TimeOnlyFormat = "TimeOnlyFormat";
public const string TimeSpanFormat = "TimeSpanFormat";
public const string Uri = "Uri";
public const string Xml = "Xml";
public string Syntax { get; }
public object?[] Arguments { get; }
public StringSyntaxAttribute(string syntax)
{
Syntax = syntax;
Arguments = new object[0];
}
public StringSyntaxAttribute(string syntax, params object?[] arguments)
{
Syntax = syntax;
Arguments = arguments;
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class UnscopedRefAttribute : Attribute
{
}
}
namespace System.Runtime.Versioning
{
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class RequiresPreviewFeaturesAttribute : Attribute
{
public string? Message { get; }
public string? Url { get; set; }
public RequiresPreviewFeaturesAttribute()
{
}
public RequiresPreviewFeaturesAttribute(string? message)
{
Message = message;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
internal IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class CallerArgumentExpressionAttribute : Attribute
{
public string ParameterName { get; }
public CallerArgumentExpressionAttribute(string parameterName)
{
ParameterName = parameterName;
}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class CollectionBuilderAttribute : Attribute
{
public Type BuilderType { get; }
public string MethodName { get; }
public CollectionBuilderAttribute(Type builderType, string methodName)
{
BuilderType = builderType;
MethodName = methodName;
}
}
[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class CompilerFeatureRequiredAttribute : Attribute
{
public const string RefStructs = "RefStructs";
public const string RequiredMembers = "RequiredMembers";
public string FeatureName { get; }
public bool IsOptional { get; set; }
public CompilerFeatureRequiredAttribute(string featureName)
{
FeatureName = featureName;
}
}
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
{
public string[] Arguments { get; }
public InterpolatedStringHandlerArgumentAttribute(string argument)
{
Arguments = new string[1] { argument };
}
public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
{
Arguments = arguments;
}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class InterpolatedStringHandlerAttribute : Attribute
{
}
[EditorBrowsable(EditorBrowsableState.Never)]
[ExcludeFromCodeCoverage]
internal static class IsExternalInit
{
}
[AttributeUsage(AttributeTargets.Method, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class ModuleInitializerAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class OverloadResolutionPriorityAttribute : Attribute
{
public int Priority { get; }
public OverloadResolutionPriorityAttribute(int priority)
{
Priority = priority;
}
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
[ExcludeFromCodeCoverage]
internal sealed class ParamCollectionAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class RequiredMemberAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
[EditorBrowsable(EditorBrowsableState.Never)]
[ExcludeFromCodeCoverage]
internal sealed class RequiresLocationAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class SkipLocalsInitAttribute : Attribute
{
}
}
