public static bool GetAbility(uint id, out Il2CppSystem.Type ability) { try { if (ExploderConfigDictionary.ContainsKey(id)) { ability = Il2CppType.Of <ExploderAbility>(); return(true); } if (EMPConfigDictionary.ContainsKey(id)) { ability = Il2CppType.Of <EMPAbility>(); return(true); } if (ImmortalConfigDictionary.ContainsKey(id)) { ability = Il2CppType.Of <ImmortalAbility>(); return(true); } } catch { ability = null; return(false); } ability = null; return(false); }
public static IntPtr GetNestedTypeViaReflection(IntPtr enclosingClass, string nestedTypeName) { var reflectionType = Type.internal_from_handle(IL2CPP.il2cpp_class_get_type(enclosingClass)); var nestedType = reflectionType.GetNestedType(nestedTypeName, BindingFlags.Public | BindingFlags.NonPublic); return(nestedType != null?IL2CPP.il2cpp_class_from_system_type(nestedType.Pointer) : IntPtr.Zero); }
public static Type GetMonoType(CppType cppType) { if (Il2CppToMonoType.ContainsKey(cppType)) { return(Il2CppToMonoType[cppType]); } var getType = Type.GetType(cppType.AssemblyQualifiedName); if (getType != null) { Il2CppToMonoType.Add(cppType, getType); return(getType); } else { string baseName = cppType.FullName; string baseAssembly = cppType.Assembly.GetName().name; Type unhollowedType = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.GetName().Name == baseAssembly)?.GetTypes().FirstOrDefault(t => t.CustomAttributes.Any(ca => ca.AttributeType.Name == "ObfuscatedNameAttribute" && (string)ca.ConstructorArguments[0].Value == baseName)); Il2CppToMonoType.Add(cppType, unhollowedType); return(unhollowedType); } }
internal ResourceLoadedParameters(string path, Il2CppSystem.Type type, ResourceLoadType loadType) #endif { Path = path; Type = type; LoadType = loadType; }
public bool GetString(out string text, StringNames stringId, Il2CppReferenceArray <Il2CppSystem.Object> parts) { string key = Enum.GetName(typeof(StringNames), stringId); if (Strings.TryGetValue(key, out text)) { if (parts.Length != 0) { List <object> parameters = new List <object>(); foreach (Il2CppSystem.Object obj in parts) { Il2CppSystem.Type t = obj.GetIl2CppType(); //BetterLanguagesPlugin.log.LogInfo("hey :" + t.ToString()); if (Il2CppSystem.Type.IsIntegerType(t)) { parameters.Add(obj.Unbox <System.Int32>()); } else { parameters.Add(obj.ToString()); } } text = string.Format(text, parameters.ToArray()); } return(true); } return(false); }
internal AssetLoadedParameters(string name, Il2CppSystem.Type type, AssetLoadType loadType) #endif { Name = name; Type = type; LoadType = loadType; }
// ReSharper disable once InconsistentNaming // ReSharper disable once RedundantAssignment public static bool Prefix(ref Object __result, string path, Il2CppSystem.Type systemTypeInstance) { MelonDebug.Msg($"Resources::Load({path}, {systemTypeInstance.Name})"); var exist = GoCache.TryGet(path, out __result); return(!exist); }
private static bool Prefix(Il2CppSystem.Type panelType, ref bool __result) { if (panelType == UnhollowerRuntimeLib.Il2CppType.Of <Panel_CustomXPSetup>()) { __result = false; return(false); } return(true); }
public AssetBundleCreateRequest LoadAssetWithSubAssetsAsync(string name, Il2CppSystem.Type type) { if (type == null) { throw new System.NullReferenceException("The input type cannot be null."); } System.IntPtr intptr = LoadAssetWithSubAssetsAsync(name, type.Pointer); return((intptr != System.IntPtr.Zero) ? new AssetBundleCreateRequest(intptr) : null); }
public Il2CppReferenceArray <Object> LoadAssetWithSubAssets(string name, Il2CppSystem.Type type) { if (type == null) { throw new System.NullReferenceException("The input type cannot be null."); } System.IntPtr intptr = LoadAssetWithSubAssets(name, type.Pointer); return((intptr != System.IntPtr.Zero) ? new Il2CppReferenceArray <Object>(intptr) : null); }
public static bool Prefix(Type t, int controlID, out Object __result) { if (!s_StateCache.TryGetValue(controlID, out __result) || __result.GetIl2CppType() != t) { s_StateCache[controlID] = __result = t.GetConstructor(new Il2CppReferenceArray <Type>(0)).Invoke(null, new Il2CppReferenceArray <Object>(0)); } return(false); }
public Il2CppReferenceArray <Object> LoadAllAssets(Il2CppSystem.Type type) { if (type == null) { throw new NullReferenceException("The input type cannot be null."); } IntPtr intptr = LoadAllAssets(type.Pointer); return((intptr != IntPtr.Zero) ? new Il2CppReferenceArray <Object>(intptr) : null); }
public Il2CppAssetBundleRequest LoadAssetAsync(string name, Il2CppSystem.Type type) { if (type == null) { throw new NullReferenceException("The input type cannot be null."); } IntPtr intptr = LoadAssetAsync(name, type.Pointer); return((intptr != IntPtr.Zero) ? new Il2CppAssetBundleRequest(intptr) : null); }
public Object LoadAsset(string name, Il2CppSystem.Type type) { if (type == null) { throw new NullReferenceException("The input type cannot be null."); } IntPtr intptr = LoadAsset(name, type.Pointer); return((intptr != IntPtr.Zero) ? new Object(intptr) : null); }
public static bool InheritsFromMonobehaviour(Il2CppSystem.Type type) { if (type is null) { return(false); } else { return(type.IsSubclassOf(UnhollowerRuntimeLib.Il2CppType.Of <UnityEngine.MonoBehaviour>())); } }
public Il2CppReferenceArray <Object> LoadAssetWithSubAssets(string name, Il2CppSystem.Type type) { if (type == null) { throw new ArgumentNullException(nameof(type)); } IntPtr ptr = LoadAssetWithSubAssets(name, type.Pointer); return(ptr != IntPtr.Zero ? new Il2CppReferenceArray <Object>(ptr) : null); }
public static Il2CppSystem.Object DynamicCast(this Il2CppSystem.Object obj, Il2CppSystem.Type type) { var mi = obj.GetIl2CppType().GetMethod("Cast"); var genericArg = new Il2CppReferenceArray <Il2CppSystem.Type>(1); genericArg[0] = type; var fooRef = mi.MakeGenericMethod(genericArg); return(fooRef.Invoke(obj, null)); }
public static Type GetMonoType(CppType cppType) { if (Il2CppToMonoType.ContainsKey(cppType)) { return(Il2CppToMonoType[cppType]); } var getType = Type.GetType(cppType.AssemblyQualifiedName); Il2CppToMonoType.Add(cppType, getType); return(getType); }
public static bool DoesTextMeshProSupportRichText(object ui, Type clrType, Il2CppSystem.Type unityType) #endif { if (UnityTypes.TMP_Text != null) { return(UnityTypes.TMP_Text.IsAssignableFrom(unityType) && Equals(clrType.CachedProperty(RichTextPropertyName)?.Get(ui), true)); } else { return((UnityTypes.TextMeshPro?.IsAssignableFrom(unityType) == true && Equals(clrType.CachedProperty(RichTextPropertyName)?.Get(ui), true)) || (UnityTypes.TextMeshProUGUI?.IsAssignableFrom(unityType) == true && Equals(clrType.CachedProperty(RichTextPropertyName)?.Get(ui), true))); } }
public static bool IsKnownTextMeshProType(Il2CppSystem.Type type) #endif { if (UnityTypes.TMP_Text != null) { return(UnityTypes.TMP_Text.IsAssignableFrom(type)); } else { return(UnityTypes.TextMeshProUGUI?.IsAssignableFrom(type) == true || UnityTypes.TextMeshPro?.IsAssignableFrom(type) == true); } }
public unsafe static IntPtr GetBuiltinResource(Il2CppSystem.Type type, string path) { void **ptr = stackalloc void *[2]; ptr[0] = (void *)UnityInternals.ObjectBaseToPtr(type); ptr[1] = (void *)UnityInternals.ManagedStringToInternal(path); IntPtr returnedException = default; MelonDebug.Msg("Calling runtime_invoke for GetBuiltinResource"); IntPtr objectPointer = UnityInternals.runtime_invoke(m_GetBuiltinResource, IntPtr.Zero, ptr, ref returnedException); MelonDebug.Msg("returnedException: " + returnedException + ", objectPointer: " + objectPointer); Il2CppException.RaiseExceptionIfNecessary(returnedException); return(objectPointer); }
private static Il2CppSystem.Object GetStateObject(Il2CppSystem.Type type, int controlID) { Il2CppSystem.Object obj; if (StateCache.ContainsKey(controlID)) { obj = StateCache[controlID]; } else { obj = Il2CppSystem.Activator.CreateInstance(type); StateCache.Add(controlID, obj); } return(obj); }
public static UnityEngine.Object[] FindObjectsOfTypeAll(Il2CppSystem.Type type) { var arrayPtr = ICallHelper.GetICall <d_FindObjectsOfTypeAll>("UnityEngine.Resources::FindObjectsOfTypeAll") .Invoke(type.Pointer); var array = new Il2CppReferenceArray <UnityEngine.Object>(arrayPtr); var ret = new UnityEngine.Object[array.Length]; for (int i = 0; i < array.Length; i++) { ret[i] = array[i]; } return(ret); }
public static Type GetUnhollowedType(CppType cppType) { var fullname = cppType.FullName; if (DeobfuscatedTypes.TryGetValue(fullname, out Type deob)) { return(deob); } if (fullname.StartsWith("System.")) { fullname = $"Il2Cpp{fullname}"; } AllTypes.TryGetValue(fullname, out Type monoType); return(monoType); }
public static void CopyFieldsIl2Cpp <T>(T copyTo, T copyFrom) where T : Il2CppSystem.Object { Il2CppSystem.Type typeOfT = UnhollowerRuntimeLib.Il2CppType.Of <T>(); Il2CppSystem.Reflection.FieldInfo[] fieldInfos = typeOfT.GetFields(); foreach (Il2CppSystem.Reflection.FieldInfo fieldInfo in fieldInfos) { if (fieldInfo.IsInitOnly || fieldInfo.IsLiteral) { continue; } fieldInfo.SetValue(copyTo, fieldInfo.GetValue(copyFrom)); } if (fieldInfos.Length == 0) { MelonLoader.MelonLogger.LogError("There were no fields to copy!"); } }
public void Start() { try { Il2CppSystem.Type behaviourType = TypeResolver.ResolveIl2Cpp(BehaviourName, true); this.gameObject.AddComponent(behaviourType); } catch (System.Exception e) { Logger.LogError("Could not load behaviour '" + BehaviourName + "': " + e.Message); if (FailOnError) { throw e; } } }
public override bool IsReflectionSupported(Type type) { try { var gArgs = type.GetGenericArguments(); if (!gArgs.Any()) { return(true); } foreach (var gType in gArgs) { if (!Supported(gType)) { return(false); } } return(true); bool Supported(Type t) { if (!typeof(Il2CppSystem.Object).IsAssignableFrom(t)) { return(true); } if (!Il2CppTypeNotNull(t, out IntPtr ptr)) { return(false); } return(CppType.internal_from_handle(IL2CPP.il2cpp_class_get_type(ptr)) is CppType); } } catch { return(false); } }
/// <summary> /// Try to get the Mono (Unhollowed) Type representation of the provided <see cref="Il2CppSystem.Type"/>. /// </summary> /// <param name="cppType">The Cpp Type you want to convert to Mono.</param> /// <returns>The Mono Type if found, otherwise null.</returns> public static Type GetMonoType(CppType cppType) { string name = cppType.AssemblyQualifiedName; if (Il2CppToMonoType.ContainsKey(name)) { return(Il2CppToMonoType[name]); } Type ret = Type.GetType(name); // Thanks to Slaynash for this deobfuscation snippet! if (ret == null) { string baseName = cppType.FullName; string baseAssembly = cppType.Assembly.GetName().name; ret = AppDomain.CurrentDomain .GetAssemblies() .FirstOrDefault(a => a.GetName().Name == baseAssembly)? .TryGetTypes() .FirstOrDefault(t => t.CustomAttributes.Any(ca => ca.AttributeType.Name == "ObfuscatedNameAttribute" && (string)ca.ConstructorArguments[0].Value == baseName)); if (ret != null) { // deobfuscated type was found, add to cache. s_deobfuscatedTypeNames.Add(cppType.FullName, ret.FullName); } } Il2CppToMonoType.Add(name, ret); return(ret); }
public static Component GetFirstComponentInSelfOrAncestor(this GameObject go, Il2CppSystem.Type type)
public Il2CppReferenceArray <Object> LoadAll(Il2CppSystem.Type type) => LoadAllAssets(type);