[RELEASE] SiraUtil 2.3.1

SiraUtil/Attributes/SlogAttribute.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Diagnostics;
+
+namespace SiraUtil.Attributes
+{
+    /// <summary>
+    /// Allows SiraUtil to detect if plugins are built for release. : D
+    /// </summary>
+    [Conditional("DEBUG")]
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+    public sealed class SlogAttribute : Attribute
+    {
+        /// <summary>
+        /// An empty constructor.
+        /// </summary>
+        public SlogAttribute() { }
+    }
+}

SiraUtil/Converters/FileInfoConverter.cs

@@ -0,0 +1,37 @@
+using System.IO;
+using IPA.Config.Data;
+using IPA.Config.Stores;
+
+namespace SiraUtil.Converters
+{
+    /// <summary>
+    /// A config converter for BSIPA which can serialize and deserialize IO <see cref="FileInfo"/> values.
+    /// </summary>
+    public class FileInfoConverter : ValueConverter<FileInfo>
+    {
+        /// <summary>
+        /// Converts a config value to a <see cref="FileInfo"/> instance.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="parent"></param>
+        /// <returns></returns>
+        public override FileInfo FromValue(Value value, object parent)
+        {
+            return value is Text t
+                ? new FileInfo(t.Value)
+                : throw new System.ArgumentNullException("Value is not a valid IO Path", nameof(value));
+        }
+
+
+        /// <summary>
+        /// Converts a <see cref="FileInfo"/> instance into a string.
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <param name="parent"></param>
+        /// <returns></returns>
+        public override Value ToValue(FileInfo obj, object parent)
+        {
+            return Value.Text(obj.FullName);
+        }
+    }
+}

SiraUtil/Converters/VersionConverter.cs

@@ -19,7 +19,7 @@ public override Version FromValue(Value value, object parent)
         {
             return value is Text t
                 ? new Version(t.Value)
-                :         throw new System.ArgumentException("Value cnanot be parsed into a Semver Version", nameof(value));
+                :         throw new System.ArgumentException("Value cannot be parsed into a Semver Version", nameof(value));
         }
 
         /// <summary>

SiraUtil/Extensions.cs

@@ -68,11 +68,14 @@ public static Component Upgrade(this Component monoBehaviour, Type upgradingType
                 info.SetValue(upgradedDummyComponent, info.GetValue(monoBehaviour));
             }
             UnityEngine.Object.DestroyImmediate(monoBehaviour);
+            bool goState = gameObject.activeSelf;
+            gameObject.SetActive(false);
             var upgradedMonoBehaviour = gameObject.AddComponent(upgradingType);
             foreach (FieldInfo info in upgradingType.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic))
             {
                 info.SetValue(upgradedMonoBehaviour, info.GetValue(upgradedDummyComponent));
             }
+            gameObject.SetActive(goState);
             return upgradedMonoBehaviour;
         }
 

SiraUtil/Interfaces/IRegistrar.cs

@@ -0,0 +1,21 @@
+namespace SiraUtil.Interfaces
+{
+    /// <summary>
+    /// A generic interface which defines a registration.
+    /// </summary>
+    /// <typeparam name="T">The type to register.</typeparam>
+    public interface IRegistrar<T>
+    {
+        /// <summary>
+        /// Adds a registration to this registrar.
+        /// </summary>
+        /// <param name="value"></param>
+        void Add(T value);
+
+        /// <summary>
+        /// Removes a registration from this registrar.
+        /// </summary>
+        /// <param name="value"></param>
+        void Remove(T value);
+    }
+}

SiraUtil/Interfaces/IToggleable.cs

@@ -0,0 +1,13 @@
+namespace SiraUtil.Interfaces
+{
+    /// <summary>
+    /// Controls the state for something to be toggled.
+    /// </summary>
+    public interface IToggleable
+    {
+        /// <summary>
+        /// The toggleability.
+        /// </summary>
+        bool Status { get; set; }
+    }
+}

SiraUtil/Objects/ObjectState.cs

@@ -7,6 +7,11 @@ namespace SiraUtil.Objects
     /// </summary>
     public struct ObjectState
     {
+        /// <summary>
+        /// The activity of the object at a point in time.
+        /// </summary>
+        public readonly bool Active;
+
         /// <summary>
         /// The position and rotation of the object at a point in time.
         /// </summary>
@@ -34,6 +39,7 @@ public struct ObjectState
         public ObjectState(Transform transform)
         {
             pose = new Pose(transform.localPosition, transform.localRotation);
+            Active = transform.gameObject.activeInHierarchy;
             scale = transform.localScale;
             this.transform = transform;
             parent = transform.parent;
@@ -49,6 +55,7 @@ public void Revert()
             {
                 transform.SetParent(parent);
                 transform.localScale = scale;
+                transform.gameObject.SetActive(Active);
                 transform.localPosition = pose.position;
                 transform.localRotation = pose.rotation;
             }

SiraUtil/Plugin.cs

@@ -23,8 +23,8 @@ namespace SiraUtil
     [Plugin(RuntimeOptions.DynamicInit)]
     public class Plugin
     {
+        internal Harmony Harmony { get; set; }
         internal static IPALogger Log { get; set; }
-        internal static Harmony Harmony { get; set; }
 
         private readonly ZenjectManager _zenjectManager;
 
@@ -49,13 +49,13 @@ public Plugin(IPA.Config.Config conf, IPALogger logger, PluginMetadata metadata)
                 {
                     return prev;
                 }
-                var zen = new Zenjector(meta.Id);
+                var zen = new Zenjector(meta.Id, meta);
                 _zenjectManager.Add(zen);
                 return zen;
             });
 
             // Setup Own Zenject Stuff
-            var zenjector = new Zenjector("SiraUtil");
+            var zenjector = new Zenjector("SiraUtil", metadata);
             _zenjectManager.Add(zenjector);
 
             zenjector.OnApp<SiraInstaller>().WithParameters(config);

SiraUtil/Services/SiraLogManager.cs

@@ -1,36 +1,44 @@
 using IPA.Logging;
+using SiraUtil.Zenject;
 using System.Reflection;
 using System.Collections.Generic;
 
 namespace SiraUtil.Services
 {
     internal class SiraLogManager
     {
-        internal struct LoggerContext
-        {
-            public Logger logger;
-            public bool debugMode;
+        private readonly ZenjectManager _zenjectManager;
+        private readonly Dictionary<Assembly, LoggerContext> _loggerAssemblies = new Dictionary<Assembly, LoggerContext>();
 
-            public LoggerContext(Logger logger, bool defaultToDebugMode)
-            {
-                this.logger = logger;
-                debugMode  = defaultToDebugMode;
-            }
+        internal SiraLogManager(ZenjectManager zenjectManager)
+        {
+            _zenjectManager = zenjectManager;
         }
 
-        private readonly Dictionary<Assembly, LoggerContext> _loggerAssemblies = new Dictionary<Assembly, LoggerContext>();
-
         internal void AddLogger(Assembly assembly, Logger logger, bool defaultToDebugMode = false)
         {
             if (!_loggerAssemblies.ContainsKey(assembly))
             {
-                _loggerAssemblies.Add(assembly, new LoggerContext(logger, defaultToDebugMode));
+                var zen = _zenjectManager.GetZenjector(assembly);
+                _loggerAssemblies.Add(assembly, new LoggerContext(logger, zen.IsSlog || defaultToDebugMode));
             }
         }
 
         internal LoggerContext LoggerFromAssembly(Assembly assembly)
         {
             return _loggerAssemblies[assembly];
         }
+
+        internal struct LoggerContext
+        {
+            public Logger logger;
+            public bool debugMode;
+
+            public LoggerContext(Logger logger, bool defaultToDebugMode)
+            {
+                this.logger = logger;
+                debugMode = defaultToDebugMode;
+            }
+        }
     }
 }

SiraUtil/SiraUtil.csproj

@@ -71,6 +71,11 @@
       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\MediaLoader.dll</HintPath>
       <SpecificVersion>False</SpecificVersion>
     </Reference>
+    <Reference Include="Mono.Cecil, Version=0.10.4.0, Culture=neutral, PublicKeyToken=50cebf1cceb9d05e, processorArchitecture=MSIL">
+      <Private>False</Private>
+      <HintPath>$(BeatSaberDir)\Libs\Mono.Cecil.dll</HintPath>
+      <SpecificVersion>False</SpecificVersion>
+    </Reference>
     <Reference Include="Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <Private>False</Private>
       <HintPath>$(BeatSaberDir)\Libs\Newtonsoft.Json.dll</HintPath>
@@ -184,7 +189,9 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Accessors.cs" />
+    <Compile Include="Attributes\SlogAttribute.cs" />
     <Compile Include="Config.cs" />
+    <Compile Include="Converters\FileInfoConverter.cs" />
     <Compile Include="Converters\Vector2Converter.cs" />
     <Compile Include="Converters\Vector3Converter.cs" />
     <Compile Include="Converters\VersionConverter.cs" />
@@ -193,6 +200,8 @@
     <Compile Include="Interfaces\ILocalizer.cs" />
     <Compile Include="Interfaces\IModelProvider.cs" />
     <Compile Include="Interfaces\IPrefabProvider.cs" />
+    <Compile Include="Interfaces\IRegistrar.cs" />
+    <Compile Include="Interfaces\IToggleable.cs" />
     <Compile Include="Objects\BeatmapObjectRedecorator.cs" />
     <Compile Include="Objects\ObjectState.cs" />
     <Compile Include="Objects\ObjectStateContainer.cs" />

SiraUtil/Zenject/InstallBuilder.cs

@@ -3,6 +3,7 @@
 using ModestTree;
 using UnityEngine;
 using System.Collections.Generic;
+using UnityEngine.SceneManagement;
 
 namespace SiraUtil.Zenject
 {
@@ -19,7 +20,9 @@ public class InstallBuilder
         internal Action<DiContainer> Contextless { get; private set; } = null;
         internal HashSet<Type> Exposers { get; private set; } = new HashSet<Type>();
         internal Action<SceneContext, DiContainer> Resolved { get; private set; } = null;
+        internal Action<Context, DiContainer> SceneContextless { get; private set; } = null;
         internal HashSet<Tuple<Type, DelegateWrapper>> Mutators { get; private set; } = new HashSet<Tuple<Type, DelegateWrapper>>();
+        internal HashSet<Func<Scene, Context, DiContainer, bool>> OnFuncs { get; private set; } = new HashSet<Func<Scene, Context, DiContainer, bool>>();
         internal HashSet<Tuple<Type, Action<Context, DiContainer>>> Headers { get; private set; } = new HashSet<Tuple<Type, Action<Context, DiContainer>>>();
 
         internal InstallBuilder() { }
@@ -38,6 +41,17 @@ public InstallBuilder WithParameters(params object[] parameters)
             return this;
         }
 
+        /// <summary>
+        /// Install the installer at a destination via function.
+        /// </summary>
+        /// <param name="func"></param>
+        /// <returns></returns>
+        public InstallBuilder On(Func<Scene, Context, DiContainer, bool> func)
+        {
+            OnFuncs.Add(func);
+            return this;
+        } 
+
         /// <summary>
         /// Installs the installer at a destination.
         /// </summary>
@@ -190,6 +204,17 @@ public InstallBuilder Pseudo(Action<DiContainer> action)
             return this;
         }
 
+        /// <summary>
+        /// Install bindings with a pseudo action which acts like an installer 
+        /// </summary>
+        /// <param name="action"></param>
+        /// <returns></returns>
+        public InstallBuilder Pseudo(Action<Context, DiContainer> action)
+        {
+            SceneContextless = action;
+            return this;
+        }
+
         /// <summary>
         /// Mainly for prototyping.
         /// </summary>
@@ -213,7 +238,7 @@ public InstallBuilder When(Func<bool> when)
 
         internal void Validate()
         {
-            if (Contextless == null)
+            if (Contextless == null && SceneContextless == null)
             {
                 Assert.IsNotNull(Type, $"Contextful Zenject Registrations must have a type. {Utilities.ASSERTHIT}");
                 Assert.That(Type.DerivesFrom<IInstaller>(), $"Type must implement IInstaller {Utilities.ASSERTHIT}");