using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Reflection; using BepInEx.Bootstrap; using Mono.Cecil; namespace BepInEx { #region BaseUnityPlugin /// /// This attribute denotes that a class is a plugin, and specifies the required metadata. /// [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] public class BepInPlugin : Attribute { /// /// The unique identifier of the plugin. Should not change between plugin versions. /// public string GUID { get; protected set; } /// /// The user friendly name of the plugin. Is able to be changed between versions. /// public string Name { get; protected set; } /// /// The specific version of the plugin. /// public SemVer.Version Version { get; protected set; } /// The unique identifier of the plugin. Should not change between plugin versions. /// The user friendly name of the plugin. Is able to be changed between versions. /// The specific version of the plugin. public BepInPlugin(string GUID, string Name, string Version) { this.GUID = GUID; this.Name = Name; this.Version = TryParseLongVersion(Version); } private static SemVer.Version TryParseLongVersion(string version) { if (SemVer.Version.TryParse(version, out var v)) return v; // no System.Version.TryParse() on .NET 3.5 try { var longVersion = new System.Version(version); return new SemVer.Version(longVersion.Major, longVersion.Minor, longVersion.Build); } catch { } return null; } internal static BepInPlugin FromCecilType(TypeDefinition td) { var attr = MetadataHelper.GetCustomAttributes(td, false).FirstOrDefault(); if (attr == null) return null; return new BepInPlugin((string)attr.ConstructorArguments[0].Value, (string)attr.ConstructorArguments[1].Value, (string)attr.ConstructorArguments[2].Value); } } /// /// This attribute specifies any dependencies that this plugin has on other plugins. /// [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] public class BepInDependency : Attribute, ICacheable { /// /// Flags that are applied to a dependency /// [Flags] public enum DependencyFlags { /// /// The plugin has a hard dependency on the referenced plugin, and will not run without it. /// HardDependency = 1, /// /// This plugin has a soft dependency on the referenced plugin, and is able to run without it. /// SoftDependency = 2, } /// /// The GUID of the referenced plugin. /// public string DependencyGUID { get; protected set; } /// /// The flags associated with this dependency definition. /// public DependencyFlags Flags { get; protected set; } /// /// The version range of the referenced plugin. /// public SemVer.Range VersionRange { get; protected set; } /// /// Marks this as dependent on another plugin. The other plugin will be loaded before this one. /// If the other plugin doesn't exist, what happens depends on the parameter. /// /// The GUID of the referenced plugin. /// The flags associated with this dependency definition. public BepInDependency(string DependencyGUID, DependencyFlags Flags = DependencyFlags.HardDependency) { this.DependencyGUID = DependencyGUID; this.Flags = Flags; VersionRange = null; } /// /// Marks this as dependent on another plugin. The other plugin will be loaded before this one. /// If the other plugin doesn't exist or is of a version not satisfying , this plugin will not load and an error will be logged instead. /// /// The GUID of the referenced plugin. /// The version range of the referenced plugin. /// When version is supplied the dependency is always treated as HardDependency public BepInDependency(string guid, string version) : this(guid) { VersionRange = SemVer.Range.Parse(version); } internal static IEnumerable FromCecilType(TypeDefinition td) { var attrs = MetadataHelper.GetCustomAttributes(td, true); return attrs.Select(customAttribute => { var dependencyGuid = (string)customAttribute.ConstructorArguments[0].Value; var secondArg = customAttribute.ConstructorArguments[1].Value; if (secondArg is string minVersion) return new BepInDependency(dependencyGuid, minVersion); return new BepInDependency(dependencyGuid, (DependencyFlags)secondArg); }).ToList(); } void ICacheable.Save(BinaryWriter bw) { bw.Write(DependencyGUID); bw.Write((int)Flags); bw.Write(VersionRange.ToString()); } void ICacheable.Load(BinaryReader br) { DependencyGUID = br.ReadString(); Flags = (DependencyFlags)br.ReadInt32(); VersionRange = SemVer.Range.Parse(br.ReadString()); } } /// /// This attribute specifies other plugins that are incompatible with this plugin. /// [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] public class BepInIncompatibility : Attribute, ICacheable { /// /// The GUID of the referenced plugin. /// public string IncompatibilityGUID { get; protected set; } /// /// Marks this as incompatible with another plugin. /// If the other plugin exists, this plugin will not be loaded and a warning will be shown. /// /// The GUID of the referenced plugin. public BepInIncompatibility(string IncompatibilityGUID) { this.IncompatibilityGUID = IncompatibilityGUID; } internal static IEnumerable FromCecilType(TypeDefinition td) { var attrs = MetadataHelper.GetCustomAttributes(td, true); return attrs.Select(customAttribute => { var dependencyGuid = (string)customAttribute.ConstructorArguments[0].Value; return new BepInIncompatibility(dependencyGuid); }).ToList(); } void ICacheable.Save(BinaryWriter bw) { bw.Write(IncompatibilityGUID); } void ICacheable.Load(BinaryReader br) { IncompatibilityGUID = br.ReadString(); } } /// /// This attribute specifies which processes this plugin should be run for. Not specifying this attribute will load the plugin under every process. /// [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] public class BepInProcess : Attribute { /// /// The name of the process that this plugin will run under. /// public string ProcessName { get; protected set; } /// The name of the process that this plugin will run under. public BepInProcess(string ProcessName) { this.ProcessName = ProcessName; } internal static List FromCecilType(TypeDefinition td) { var attrs = MetadataHelper.GetCustomAttributes(td, true); return attrs.Select(customAttribute => new BepInProcess((string)customAttribute.ConstructorArguments[0].Value)).ToList(); } } #endregion #region MetadataHelper /// /// Helper class to use for retrieving metadata about a plugin, defined as attributes. /// public static class MetadataHelper { internal static IEnumerable GetCustomAttributes(TypeDefinition td, bool inherit) where T : Attribute { var result = new List(); var type = typeof(T); var currentType = td; do { result.AddRange(currentType.CustomAttributes.Where(ca => ca.AttributeType.FullName == type.FullName)); currentType = currentType.BaseType?.Resolve(); } while (inherit && currentType?.FullName != "System.Object"); return result; } /// /// Retrieves the BepInPlugin metadata from a plugin type. /// /// The plugin type. /// The BepInPlugin metadata of the plugin type. public static BepInPlugin GetMetadata(Type pluginType) { object[] attributes = pluginType.GetCustomAttributes(typeof(BepInPlugin), false); if (attributes.Length == 0) return null; return (BepInPlugin)attributes[0]; } /// /// Retrieves the BepInPlugin metadata from a plugin instance. /// /// The plugin instance. /// The BepInPlugin metadata of the plugin instance. public static BepInPlugin GetMetadata(object plugin) => GetMetadata(plugin.GetType()); /// /// Gets the specified attributes of a type, if they exist. /// /// The attribute type to retrieve. /// The plugin type. /// The attributes of the type, if existing. public static T[] GetAttributes(Type pluginType) where T : Attribute { return (T[])pluginType.GetCustomAttributes(typeof(T), true); } /// /// Gets the specified attributes of an assembly, if they exist. /// /// The assembly. /// The attribute type to retrieve. /// The attributes of the type, if existing. public static T[] GetAttributes(Assembly assembly) where T : Attribute { return (T[])assembly.GetCustomAttributes(typeof(T), true); } /// /// Gets the specified attributes of an instance, if they exist. /// /// The attribute type to retrieve. /// The plugin instance. /// The attributes of the instance, if existing. public static IEnumerable GetAttributes(object plugin) where T : Attribute => GetAttributes(plugin.GetType()); /// /// Retrieves the dependencies of the specified plugin type. /// /// The plugin type. /// A list of all plugin types that the specified plugin type depends upon. public static IEnumerable GetDependencies(Type plugin) { return plugin.GetCustomAttributes(typeof(BepInDependency), true).Cast(); } } #endregion }