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.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using FrogDataLib.DataManagement;
using FrogDataLib.Patches;
using HarmonyLib;
using Microsoft.CodeAnalysis;
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.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+d503e2c8b90ae6805cd37ff785be447c3488ccbf")]
[assembly: AssemblyProduct("dev.mamallama.frogdatalib")]
[assembly: AssemblyTitle("FrogDataLib")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.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.1.0")]
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.1.0";
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 sealed 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);
}
}
[Serializable]
public class FrogDataFile : FrogDataModel
{
[SerializeField]
public string[] Keys = input.Keys.ToArray();
[SerializeField]
public string[] Values = input.Values.ToArray();
public FrogDataFile(Dictionary<string, string> input)
{
}
public bool TryParse([NotNullWhen(true)] out Dictionary<string, string>? value)
{
value = null;
if (Keys.Length != Values.Length)
{
return false;
}
value = new Dictionary<string, string>();
for (int i = 0; i < Keys.Length; i++)
{
value[Keys[i]] = Values[i];
}
return true;
}
}
public static class FrogDataManager
{
internal static readonly DirectoryInfo PersistentPath = new DirectoryInfo(Path.Combine(Application.persistentDataPath, "FrogData"));
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"));
FrogDataFile frogDataFile = new FrogDataFile(MasterData);
try
{
string value = JsonUtility.ToJson((object)frogDataFile);
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();
FrogDataFile frogDataFile = JsonUtility.FromJson<FrogDataFile>(text);
if (frogDataFile._frogSentinel == 0 || !frogDataFile.TryParse(out Dictionary<string, string> value))
{
FrogDataPlugin.Log.LogError((object)("Failed to deserialize data file from " + fileInfo.FullName + " file may be corrupt or damaged"));
return;
}
MasterData = value;
}
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
{
value = JsonUtility.FromJson<TModel>(value2);
}
catch (Exception ex)
{
FrogDataPlugin.Log.LogError((object)("Failed to deserialize data for " + guid + ".\n\nFull Text: " + ex.Message));
return false;
}
if (value._frogSentinel == 0)
{
string name = typeof(TModel).Name;
FrogDataPlugin.Log.LogError((object)("Failed to deserialize data for " + guid + " due to a sentinel failure, likely causes:\n 1. Class '" + name + "' may not be marked [Serializable]\n 2. The save data for " + guid + " may have been corrupted, damaged or from a different/incompatible version"));
value = null;
return false;
}
return true;
}
internal static bool TrySaveModData<TModel>(string guid, TModel data) where TModel : FrogDataModel, new()
{
if (data._frogSentinel == 0)
{
FrogDataPlugin.Log.LogWarning((object)("Ignoring an invalid save model from " + guid + " due to a sentinel failure. This is likely a broken object, save data will not be updated!"));
return false;
}
if (!typeof(TModel).IsSerializable)
{
FrogDataPlugin.Log.LogWarning((object)("Ignoring an invalid save model from " + guid + "!\n The class '" + typeof(TModel).Name + "' is not marked as serializable and will never save correctly!\n Please reference the FrogDataLib documentation @ https://github.com/RobynLlama/FrogDataLib for more information on structuring your save data"));
return false;
}
data._frogSentinel = 8675309;
try
{
string value = JsonUtility.ToJson((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;
}
}
[Serializable]
public abstract class FrogDataModel
{
[SerializeField]
public int _frogSentinel = 8675309;
}
}
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
{
}
}
