public static bool HasMethodCallWithName(this MethodInfo m, string txt)
        {
            foreach (var instance in XrefScanner.XrefScan(m))
            {
                try
                {
                    if (instance.Type == XrefType.Method && instance.TryResolve() != null)
                    {
                        try
                        {
                            if (instance.TryResolve().Name.Contains(txt))
                            {
                                return(true);
                            }
                        }
                        catch (Exception e)
                        {
                            MelonLogger.Warning(e);
                        }
                    }
                }
                catch
                {
                }
            }

            return(false);
        }
Exemple #2
0
        internal static void XrefDump(this MethodBase methodBase)
        {
            MelonLogger.Msg("Scanning Method: " + methodBase.Name);
            foreach (XrefInstance instance in XrefScanner.XrefScan(methodBase))
            {
                switch (instance.Type)
                {
                case XrefType.Global:
                    MelonLogger.Msg($"\tGlobal Instance: {instance.ReadAsObject()?.ToString()}");
                    break;

                case XrefType.Method:
                    var resolved = instance.TryResolve();
                    if (resolved == null)
                    {
                        MelonLogger.Msg("\tNull Method Instance");
                    }
                    else
                    {
                        MelonLogger.Msg($"\tMethod Instance: {resolved.DeclaringType?.Name} {resolved.Name}");
                    }
                    break;

                default:
                    break;
                }
            }
            MelonLogger.Msg("");
        }
        public static bool HasMethodWithDeclaringType(this MethodInfo m, Type declaringType)
        {
            foreach (var instance in XrefScanner.XrefScan(m))
            {
                try
                {
                    if (instance.Type == XrefType.Method && instance.TryResolve() != null)
                    {
                        try
                        {
                            if (declaringType == instance.TryResolve().DeclaringType)
                            {
                                return(true);
                            }
                        }
                        catch (Exception e)
                        {
                            MelonLogger.Warning(e);
                        }
                    }
                }
                catch
                {
                }
            }

            return(false);
        }
        public static void Refresh(this SimpleAvatarPedestal pedestal, ApiAvatar avatar)
        {
            if (ourPedestalRefreshDelegate == null)
            {
                var target = typeof(SimpleAvatarPedestal)
                             .GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance).Single(
                    it =>
                {
                    if (it.ReturnType != typeof(void))
                    {
                        return(false);
                    }
                    var parameters = it.GetParameters();
                    if (parameters.Length != 1 || parameters[0].ParameterType != typeof(ApiAvatar))
                    {
                        return(false);
                    }

                    return(XrefScanner.XrefScan(it).Any(jt =>
                                                        jt.Type == XrefType.Global && jt.ReadAsObject()?.ToString() == "local"));
                });

                ourPedestalRefreshDelegate =
                    (PedestalRefreshDelegate)Delegate.CreateDelegate(typeof(PedestalRefreshDelegate), target);
            }

            ourPedestalRefreshDelegate(pedestal, avatar);
        }
Exemple #5
0
        public override void OnApplicationStart()
        {
            MelonPrefs.RegisterCategory(SettingsCategory, "Friends+ Home");
            MelonPrefs.RegisterString(SettingsCategory, SettingStartupName, nameof(ApiWorldInstance.AccessType.FriendsOfGuests), "Startup instance type");
            MelonPrefs.RegisterString(SettingsCategory, SettingButtonName, nameof(ApiWorldInstance.AccessType.FriendsOfGuests), "\"Go Home\" instance type");

            if (MelonHandler.Mods.Any(it => it.Info.Name == "UI Expansion Kit" && !it.Info.Version.StartsWith("0.1.")))
            {
                RegisterUix2Extension();
            }

            foreach (var methodInfo in typeof(VRCFlowManagerVRC).GetMethods())
            {
                if (methodInfo.ReturnType != typeof(void) || methodInfo.GetParameters().Length != 0)
                {
                    continue;
                }

                if (!XrefScanner.XrefScan(methodInfo).Any(it => it.Type == XrefType.Global && it.ReadAsObject()?.ToString() == "Going to Home Location: "))
                {
                    continue;
                }

                MelonLogger.Log($"Patched {methodInfo.Name}");
                harmonyInstance.Patch(methodInfo, postfix: new HarmonyMethod(AccessTools.Method(typeof(FriendsPlusHomeMod), nameof(GoHomePatch))));
            }
        }
        public static void DisplayErrorAvatar(this SimpleAvatarPedestal @this)
        {
            if (ourDisplayErrorAvatarDelegate == null)
            {
                var target = typeof(SimpleAvatarPedestal)
                             .GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance).Single(
                    it =>
                {
                    if (it.ReturnType != typeof(void) || it.Name.Contains("_PDM_"))
                    {
                        return(false);
                    }
                    var parameters = it.GetParameters();
                    if (parameters.Length != 0)
                    {
                        return(false);
                    }

                    return(XrefScanner.XrefScan(it).Any(jt =>
                                                        jt.Type == XrefType.Global && jt.ReadAsObject()?.ToString() == "local"));
                });

                ourDisplayErrorAvatarDelegate =
                    (DisplayErrorAvatarDelegate)Delegate.CreateDelegate(typeof(DisplayErrorAvatarDelegate), target);
            }

            ourDisplayErrorAvatarDelegate(@this);
        }
Exemple #7
0
        public static void HookVrIkInit(HarmonyInstance harmony)
        {
            var vrikInitMethod = typeof(VRCVrIkController).GetMethod(nameof(VRCVrIkController
                                                                            .Method_Public_Virtual_Final_New_Boolean_VRC_AnimationController_Animator_VRCPlayer_Boolean_0));

            harmony.Patch(vrikInitMethod,
                          postfix: new HarmonyMethod(AccessTools.Method(typeof(VrIkHandling), nameof(VrikInitPatch))));

            var canSupportHipTracking = XrefScanner.XrefScan(typeof(VRCVrIkController)
                                                             .GetMethods(BindingFlags.Public | BindingFlags.Instance |
                                                                         BindingFlags.DeclaredOnly).Single(it =>
                                                                                                           XrefScanner.XrefScan(it).Any(jt =>
                                                                                                                                        jt.Type == XrefType.Global && "Hip Tracking: Hip tracker found. tracking enabled." ==
                                                                                                                                        jt.ReadAsObject()?.ToString()))).Single(it =>
            {
                if (it.Type != XrefType.Method)
                {
                    return(false);
                }
                var resolved = it.TryResolve();
                if (resolved == null || !resolved.IsStatic)
                {
                    return(false);
                }
                return(resolved.DeclaringType == typeof(VRCTrackingManager) && resolved is MethodInfo mi && mi.ReturnType == typeof(bool) && resolved.GetParameters().Length == 0);
            }).TryResolve();

            harmony.Patch(canSupportHipTracking, new HarmonyMethod(AccessTools.Method(typeof(VrIkHandling), nameof(SupportsHipTrackingPatch))));
        }
Exemple #8
0
        internal static void HookFullBodyController(HarmonyInstance harmony)
        {
            var fbbIkInit = typeof(VRCFbbIkController).GetMethod(nameof(VRCFbbIkController.Method_Public_Virtual_Final_New_Boolean_VRC_AnimationController_Animator_VRCPlayer_Boolean_0));

            harmony.Patch(fbbIkInit, new HarmonyMethod(typeof(FullBodyHandling), nameof(FbbIkInitPrefix)),
                          new HarmonyMethod(typeof(FullBodyHandling), nameof(FbbIkInitPostfix)));

            harmony.Patch(AccessTools.Method(typeof(FullBodyBipedIK), nameof(FullBodyBipedIK.LateUpdate)),
                          new HarmonyMethod(typeof(FullBodyHandling), nameof(LateUpdatePrefix)));
            harmony.Patch(AccessTools.Method(typeof(FullBodyBipedIK), nameof(FullBodyBipedIK.Update)),
                          new HarmonyMethod(typeof(FullBodyHandling), nameof(UpdatePrefix)));
            harmony.Patch(AccessTools.Method(typeof(FullBodyBipedIK), nameof(FullBodyBipedIK.FixedUpdate)),
                          new HarmonyMethod(typeof(FullBodyHandling), nameof(FixedUpdatePrefix)));

            harmony.Patch(AccessTools.Method(typeof(VRCTrackingManager), nameof(VRCTrackingManager.Method_Public_Static_Boolean_String_0)),
                          new HarmonyMethod(typeof(FullBodyHandling), nameof(IsCalibratedForAvatarPrefix)));

            var userOfHfts = typeof(VRCFbbIkController)
                             .GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).Single(it =>
                                                                                                                         XrefScanner.XrefScan(it).Any(jt => jt.Type == XrefType.Global && jt.ReadAsObject()?.ToString() ==
                                                                                                                                                      "Hip+Feet Tracking: 3 trackers found, tracking enabled."));
            var hipAndFeetTrackingSupported = (MethodInfo)XrefScanner.XrefScan(userOfHfts).Single(it =>
            {
                if (it.Type != XrefType.Method)
                {
                    return(false);
                }
                var resolved = it.TryResolve() as MethodInfo;
                return(resolved != null && resolved.DeclaringType == typeof(VRCTrackingManager) && resolved.IsStatic &&
                       resolved.GetParameters().Length == 0 && resolved.ReturnType == typeof(bool));
            }).TryResolve();

            harmony.Patch(hipAndFeetTrackingSupported, new HarmonyMethod(typeof(FullBodyHandling), nameof(PatchHipAndFeetTracking)));
            ourIsFbtSupported = (Func <bool>)Delegate.CreateDelegate(typeof(Func <bool>), hipAndFeetTrackingSupported);
        }
Exemple #9
0
        public override void OnApplicationStart()
        {
            var category = MelonPreferences.CreateCategory(SettingsCategory, "Friends+ Home");

            StartupName = category.CreateEntry(SettingStartupName, nameof(InstanceAccessType.FriendsOfGuests), "Startup instance type");
            ButtonName  = category.CreateEntry(SettingButtonName, nameof(InstanceAccessType.FriendsOfGuests), "\"Go Home\" instance type");

            if (MelonHandler.Mods.Any(it => it.Info.Name == "UI Expansion Kit" && !it.Info.Version.StartsWith("0.1.")))
            {
                RegisterUix2Extension();
            }

            foreach (var methodInfo in typeof(VRCFlowManager).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly))
            {
                if (methodInfo.ReturnType != typeof(void) || methodInfo.GetParameters().Length != 0)
                {
                    continue;
                }

                if (!XrefScanner.XrefScan(methodInfo).Any(it => it.Type == XrefType.Global && it.ReadAsObject()?.ToString() == "Going to Home Location: "))
                {
                    continue;
                }

                MelonLogger.Msg($"Patched {methodInfo.Name}");
                HarmonyInstance.Patch(methodInfo, postfix: new HarmonyMethod(AccessTools.Method(typeof(FriendsPlusHomeMod), nameof(GoHomePatch))));
            }

            DoAfterUiManagerInit(OnUiManagerInit);
        }
        public static bool SameClassMethodCallCount(this MethodInfo m, int calls)
        {
            var count = 0;

            foreach (var instance in XrefScanner.XrefScan(m))
            {
                try
                {
                    if (instance.Type == XrefType.Method && instance.TryResolve() != null)
                    {
                        try
                        {
                            if (m.DeclaringType == instance.TryResolve().DeclaringType)
                            {
                                count++;
                            }
                        }
                        catch (Exception e)
                        {
                            MelonLogger.Warning(e);
                        }
                    }
                }
                catch
                {
                }
            }

            return(count == calls);
        }
Exemple #11
0
        // Yoinked with love from https://github.com/BenjaminZehowlt/DynamicBonesSafety/blob/master/DynamicBonesSafetyMod.cs
        // or well, the current alternative https://github.com/loukylor/VRC-Mods/blob/main/PlayerList/Utilities/Xref.cs

        public static bool CheckMethod(MethodInfo method, string match)
        {
            try
            {
                return(XrefScanner.XrefScan(method)
                       .Where(instance => instance.Type == XrefType.Global && instance.ReadAsObject().ToString().Contains(match)).Any());
            }
            catch { }
            return(false);
        }
Exemple #12
0
 /// <summary>
 /// Checks the methods the given method uses.
 /// Note: the methods passed into the predicate may be false.
 /// </summary>
 /// <param name="method">The method to check</param>
 /// <param name="predicate">The predicate to check the methods against</param>
 /// <returns>true if the predicate returned true any times, otherwise false</returns>
 public static bool CheckUsing(MethodBase method, Func <MethodBase, bool> predicate)
 {
     foreach (XrefInstance instance in XrefScanner.XrefScan(method))
     {
         if (instance.Type == XrefType.Method && predicate.Invoke(instance.TryResolve()))
         {
             return(true);
         }
     }
     return(false);
 }
Exemple #13
0
 /// <summary>
 /// Checks the strings in the given method's body.
 /// </summary>
 /// <param name="method">The method to check</param>
 /// <param name="predicate">The predicate to check the strings against</param>
 /// <returns>true if the predicate returned true any times, otherwise false</returns>
 public static bool CheckStrings(MethodInfo method, Func <string, bool> predicate)
 {
     foreach (XrefInstance instance in XrefScanner.XrefScan(method))
     {
         if (instance.Type == XrefType.Global && predicate.Invoke(instance.ReadAsObject().ToString()))
         {
             return(true);
         }
     }
     return(false);
 }
Exemple #14
0
        private static bool checkXref(MethodBase m, string match)
        {
            try
            {
                return(XrefScanner.XrefScan(m).Any(
                           instance => instance.Type == XrefType.Global && instance.ReadAsObject() != null && instance.ReadAsObject().ToString()
                           .Equals(match, StringComparison.OrdinalIgnoreCase)));
            }
            catch { } // ignored

            return(false);
        }
Exemple #15
0
        public static void ScanMethod(MethodInfo m)
        {
            MelonLogger.Msg($"Scanning: {m.FullDescription()}");
            foreach (var instance in XrefScanner.XrefScan(m))
            {
                try
                {
                    if (instance.Type == XrefType.Global && instance.ReadAsObject() != null)
                    {
                        try
                        {
                            MelonLogger.Msg($"   Found String: {instance.ReadAsObject().ToString()}");
                        }
                        catch
                        {
                        }
                    }
                    else if (instance.Type == XrefType.Method && instance.TryResolve() != null)
                    {
                        try
                        {
                            MelonLogger.Msg($"   Found Method: {instance.TryResolve().FullDescription()}");
                        }
                        catch
                        {
                        }
                    }
                }
                catch
                {
                }
            }

            foreach (var instance in XrefScanner.UsedBy(m))
            {
                try
                {
                    if (instance.Type == XrefType.Method && instance.TryResolve() != null)
                    {
                        try
                        {
                            MelonLogger.Msg($"   Found Used By Method: {instance.TryResolve().FullDescription()}");
                        }
                        catch
                        {
                        }
                    }
                }
                catch
                {
                }
            }
        }
Exemple #16
0
        /// <summary>
        /// Dumps the Xref information on a method.
        /// This is for DEBUG PURPOSES ONLY.
        /// </summary>
        /// <param name="method">The method to dump information on</param>
        public static void DumpXrefInfo(MethodBase method)
        {
            try
            {
                MelonLogger.Msg(ConsoleColor.Yellow, $"Scanning {method.Name}");

                MelonLogger.Msg(ConsoleColor.Yellow, $"Checking UsedBy");
                DumpScan(XrefScanner.UsedBy(method));

                MelonLogger.Msg(ConsoleColor.Green, "Checking Using");
                DumpScan(XrefScanner.XrefScan(method));
            }
            catch (Exception ex)
            {
                MelonLogger.Error($"Failed while dumping {method.Name}:\n{ex}");
            }
        }
Exemple #17
0
 private static bool checkXrefNoStrings(MethodBase m)
 {
     try
     {
         foreach (XrefInstance instance in XrefScanner.XrefScan(m))
         {
             if (instance.Type != XrefType.Global || instance.ReadAsObject() == null)
             {
                 continue;
             }
             return(false);
         }
         return(true);
     }
     catch (Exception e) { MelonLogger.Log("For loop failed:" + e); }
     return(false);
 }
Exemple #18
0
 public static bool CheckXrefStrings(MethodBase m, List <string> keywords)
 {
     try
     {
         foreach (string keyword in keywords)
         {
             if (!XrefScanner.XrefScan(m).Any(
                     instance => instance.Type == XrefType.Global && instance.ReadAsObject() != null && instance.ReadAsObject().ToString()
                     .Equals(keyword, StringComparison.OrdinalIgnoreCase)))
             {
                 return(false);
             }
         }
         return(true);
     }
     catch { }
     return(false);
 }
        public static bool HasStringLiterals(this MethodInfo m)
        {
            foreach (var instance in XrefScanner.XrefScan(m))
            {
                try
                {
                    if (instance.Type == XrefType.Global && instance.ReadAsObject() != null)
                    {
                        return(true);
                    }
                }
                catch
                {
                }
            }

            return(false);
        }
Exemple #20
0
 public static bool CheckUsing(MethodInfo method, string match, Type type)
 {
     foreach (XrefInstance instance in XrefScanner.XrefScan(method))
     {
         if (instance.Type == XrefType.Method)
         {
             try
             {
                 if (instance.TryResolve().DeclaringType == type && instance.TryResolve().Name.Contains(match))
                 {
                     return(true);
                 }
             }
             catch
             {
             }
         }
     }
     return(false);
 }
        public static bool CheckStringsCount(this MethodInfo m, int count)
        {
            var total = 0;

            foreach (var instance in XrefScanner.XrefScan(m))
            {
                try
                {
                    if (instance.Type == XrefType.Global && instance.ReadAsObject() != null)
                    {
                        total++;
                    }
                }
                catch
                {
                }
            }

            return(total == count);
        }
Exemple #22
0
        private static bool XRefScanForMethod(this MethodBase methodBase, string methodName = null, string reflectedType = null)
        {
            var found = false;

            foreach (XrefInstance xref in XrefScanner.XrefScan(methodBase))
            {
                if (xref.Type != XrefType.Method)
                {
                    continue;
                }

                MethodBase resolved = xref.TryResolve();
                if (resolved == null)
                {
                    continue;
                }

                if (!string.IsNullOrEmpty(methodName))
                {
                    found = !string.IsNullOrEmpty(resolved.Name) && resolved.Name.IndexOf(methodName, StringComparison.OrdinalIgnoreCase) >= 0;
                }


                if (!string.IsNullOrEmpty(reflectedType))
                {
                    found = !string.IsNullOrEmpty(resolved.ReflectedType?.Name) &&
                            resolved.ReflectedType.Name.IndexOf(reflectedType, StringComparison.OrdinalIgnoreCase) >= 0;
                }

                if (found)
                {
                    return(true);
                }
            }

            return(false);
        }
        public override void OnApplicationStart()
        {
            AdvancedSafetySettings.RegisterSettings();

            var matchingMethods = typeof(AssetManagement)
                                  .GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly).Where(it =>
                                                                                                                           it.Name.StartsWith("Method_Public_Static_Object_Object_Vector3_Quaternion_Boolean_Boolean_Boolean_") && it.GetParameters().Length == 6).ToList();

            MethodBase patchTarget = null;

            foreach (var methodInfo in typeof(AssetManagement).GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly))
            {
                foreach (var it in XrefScanner.XrefScan(methodInfo))
                {
                    if (it.Type != XrefType.Method)
                    {
                        continue;
                    }
                    var methodBase = it.TryResolve();
                    if (methodBase == null)
                    {
                        continue;
                    }
                    if (matchingMethods.Contains(methodBase))
                    {
                        patchTarget = methodBase;
                        goto haveTarget;
                    }
                }
            }

haveTarget:
            if (patchTarget != null)
            {
                unsafe
                {
                    var originalMethodPointer = *(IntPtr *)(IntPtr)UnhollowerUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod(patchTarget).GetValue(null);

                    Imports.Hook((IntPtr)(&originalMethodPointer),
                                 typeof(AdvancedSafetyMod).GetMethod(nameof(ObjectInstantiatePatch),
                                                                     BindingFlags.Static | BindingFlags.NonPublic) !.MethodHandle.GetFunctionPointer());

                    ourOriginalInstantiate =
                        Marshal.GetDelegateForFunctionPointer <ObjectInstantiateDelegate>(originalMethodPointer);
                }
            }
            else
            {
                MelonLogger.LogError("Patch target for object instantiation not found, avatar filtering will not work");
            }

            unsafe
            {
                var originalMethodPointer = *(IntPtr *)(IntPtr)UnhollowerUtils
                                            .GetIl2CppMethodInfoPointerFieldForGeneratedMethod(typeof(AMEnumA).GetMethod(
                                                                                                   nameof(AMEnumA.MoveNext)))
                                            .GetValue(null);

                Imports.Hook((IntPtr)(&originalMethodPointer), typeof(AdvancedSafetyMod).GetMethod(nameof(MoveNextPatchA), BindingFlags.Static | BindingFlags.NonPublic) !.MethodHandle.GetFunctionPointer());

                ourMoveNextA = originalMethodPointer;
            }

            unsafe
            {
                var originalMethodPointer = *(IntPtr *)(IntPtr)UnhollowerUtils
                                            .GetIl2CppMethodInfoPointerFieldForGeneratedMethod(typeof(AMEnumB).GetMethod(
                                                                                                   nameof(AMEnumB.MoveNext)))
                                            .GetValue(null);

                Imports.Hook((IntPtr)(&originalMethodPointer), typeof(AdvancedSafetyMod).GetMethod(nameof(MoveNextPatchB), BindingFlags.Static | BindingFlags.NonPublic) !.MethodHandle.GetFunctionPointer());

                ourMoveNextB = originalMethodPointer;
            }

            unsafe
            {
                var originalMethodInfo = (Il2CppMethodInfo *)(IntPtr)UnhollowerUtils
                                         .GetIl2CppMethodInfoPointerFieldForGeneratedMethod(typeof(AMEnumB).GetMethod(
                                                                                                nameof(AMEnumB.MoveNext)))
                                         .GetValue(null);

                var methodInfoCopy = (Il2CppMethodInfo *)Marshal.AllocHGlobal(Marshal.SizeOf <Il2CppMethodInfo>());
                *   methodInfoCopy = *originalMethodInfo;

                ourInvokeMethodInfo = (IntPtr)methodInfoCopy;
            }

            PortalHiding.OnApplicationStart();
            AvatarHiding.OnApplicationStart();

            if (MelonHandler.Mods.Any(it => it.Info.SystemType.Name == nameof(UiExpansionKitMod)))
            {
                typeof(UiExpansionKitSupport).GetMethod(nameof(UiExpansionKitSupport.OnApplicationStart), BindingFlags.Static | BindingFlags.Public) !.Invoke(null, new object[0]);
            }
        }
Exemple #24
0
 //Gracefully taken from Advanced Invites https://github.com/Psychloor/AdvancedInvites/blob/master/AdvancedInvites/Utilities.cs#L356
 public static bool XRefScanFor(this MethodBase methodBase, string searchTerm)
 {
     return(XrefScanner.XrefScan(methodBase).Any(
                xref => xref.Type == XrefType.Global && xref.ReadAsObject()?.ToString().IndexOf(searchTerm, StringComparison.OrdinalIgnoreCase) >= 0));
 }
Exemple #25
0
        static MethodInfo ms_applyStoredCalibration = null; // IKTweaks

        public static void ResolveMethods()
        {
            // void VRCTrackingManager.PrepareForCalibration()
            if (ms_prepareForCalibration == null)
            {
                var l_methods = typeof(VRCTrackingManager).GetMethods().Where(m =>
                                                                              m.Name.StartsWith("Method_Public_Static_Void_") && (m.ReturnType == typeof(void)) && !m.GetParameters().Any() &&
                                                                              XrefScanner.XrefScan(m).Where(x => (x.Type == XrefType.Global) && x.ReadAsObject().ToString().Contains("trying to calibrate")).Any() &&
                                                                              XrefScanner.UsedBy(m).Where(x => (x.Type == XrefType.Method) && (x.TryResolve()?.DeclaringType == typeof(VRCFbbIkController))).Any()
                                                                              );

                if (l_methods.Any())
                {
                    ms_prepareForCalibration = l_methods.First();
                    Main.Logger.Msg("VRCTrackingManager.PrepareForCalibration -> VRCTrackingManager." + ms_prepareForCalibration.Name);
                }
                else
                {
                    Main.Logger.Warning("Can't resolve VRCTrackingManager.PrepareForCalibration");
                }
            }

            // void VRCTracking.RestoreTrackingAfterCalibration()
            if (ms_restoreTrackingAfterCalibration == null)
            {
                var l_methods = typeof(VRCTrackingManager).GetMethods().Where(m =>
                                                                              m.Name.StartsWith("Method_Public_Static_Void_") && (m.Name != ms_prepareForCalibration?.Name) && (m.ReturnType == typeof(void)) && !m.GetParameters().Any() &&
                                                                              XrefScanner.UsedBy(m).Where(x => (x.Type == XrefType.Method) && (x.TryResolve()?.DeclaringType == typeof(VRCFbbIkController))).Any()
                                                                              );

                if (l_methods.Any())
                {
                    ms_restoreTrackingAfterCalibration = l_methods.First();
                    Main.Logger.Msg("VRCTrackingManager.RestoreTrackingAfterCalibration -> VRCTrackingManager." + ms_restoreTrackingAfterCalibration.Name);
                }
                else
                {
                    Main.Logger.Warning("Can't resolve VRCTrackingManager.RestoreTrackingAfterCalibration");
                }
            }

            // void IKTweaks.CalibrationManager.Calibrate(GameObject avatarRoot)
            if (ms_calibrate == null)
            {
                foreach (MelonLoader.MelonMod l_mod in MelonLoader.MelonHandler.Mods)
                {
                    if (l_mod.Info.Name == "IKTweaks")
                    {
                        Type l_cbType = null;
                        l_mod.Assembly.GetTypes().DoIf(t => t.Name == "CalibrationManager", t => l_cbType = t);
                        if (l_cbType != null)
                        {
                            ms_calibrate = l_cbType.GetMethod("Calibrate");
                            Main.Logger.Msg("IKTweaks.CalibrationManager.Calibrate " + ((ms_calibrate != null) ? "found" : "not found"));
                        }
                        break;
                    }
                }
            }

            // Task IKTweaks.CalibrationManager.ApplyStoredCalibration(GameObject avatarRoot, string avatarId)
            if (ms_applyStoredCalibration == null)
            {
                foreach (MelonLoader.MelonMod l_mod in MelonLoader.MelonHandler.Mods)
                {
                    if (l_mod.Info.Name == "IKTweaks")
                    {
                        Type l_cbType = null;
                        l_mod.Assembly.GetTypes().DoIf(t => t.Name == "CalibrationManager", t => l_cbType = t);
                        if (l_cbType != null)
                        {
                            ms_applyStoredCalibration = l_cbType.GetMethod("ApplyStoredCalibration", BindingFlags.NonPublic | BindingFlags.Static);
                            Main.Logger.Msg("IKTweaks.CalibrationManager.ApplyStoredCalibration " + ((ms_applyStoredCalibration != null) ? "found" : "not found"));
                        }
                        break;
                    }
                }
            }
        }
Exemple #26
0
        public override void OnApplicationStart()
        {
            var cat = MelonPreferences.CreateCategory("ogtrustranks", "OGTrustRanks");

            _enabledPref = cat.CreateEntry("enabled", true, "Enabled");

            _knownColorRPref = cat.CreateEntry("KnownColorR", 255, "Red component of the Known color");
            _knownColorGPref = cat.CreateEntry("KnownColorG", 122, "Green component of the Known color");
            _knownColorBPref = cat.CreateEntry("KnownColorB", 66, "Blue component of the Known color");

            _trustedColorRPref = cat.CreateEntry("TrustedColorR", 130, "Red component of the Trusted color");
            _trustedColorGPref = cat.CreateEntry("TrustedColorG", 66, "Green component of the Trusted color");
            _trustedColorBPref = cat.CreateEntry("TrustedColorB", 230, "Blue component of the Trusted color");

            _veteranColorRPref = cat.CreateEntry("VeteranColorR", 171, "Red component of the Veteran color");
            _veteranColorGPref = cat.CreateEntry("VeteranColorG", 205, "Green component of the Veteran color");
            _veteranColorBPref = cat.CreateEntry("VeteranColorB", 239, "Blue component of the Veteran color");

            _legendaryColorRPref = cat.CreateEntry("LegendaryColorR", 255, "Red component of the Legendary color");
            _legendaryColorGPref = cat.CreateEntry("LegendaryColorG", 105, "Green component of the Legendary color");
            _legendaryColorBPref = cat.CreateEntry("LegendaryColorB", 180, "Blue component of the Legendary color");

            _reloadAvatar = cat.CreateEntry("ReloadAvatar", false,
                                            "Reload avatars when fetched rank to update colors for BTKANameplateMod");

            UpdateColors();

            var harmony = new HarmonyLib.Harmony("OGTrustRanks");

            foreach (var method in typeof(VRCPlayer).GetMethods())
            {
                if (!method.Name.StartsWith("Method_Public_Static_String_APIUser_") || method.Name.Length != 37)
                {
                    continue;
                }

                if (_showSocialRankMethod == null)
                {
                    var xrefInstance = XrefScanner.XrefScan(method).FirstOrDefault(x =>
                    {
                        if (x.Type != XrefType.Method)
                        {
                            return(false);
                        }

                        var m = x.TryResolve();
                        if (m == null || !m.IsStatic || m.DeclaringType != typeof(VRCPlayer))
                        {
                            return(false);
                        }

                        var asInfo = m as MethodInfo;
                        if (asInfo == null || asInfo.ReturnType != typeof(bool))
                        {
                            return(false);
                        }

                        if (m.GetParameters().Length != 1 && m.GetParameters()[0].ParameterType != typeof(APIUser))
                        {
                            return(false);
                        }

                        return(XrefScanner.XrefScan(m).Count() > 1);
                    });
                    if (xrefInstance.Type == XrefType.Method)
                    {
                        _showSocialRankMethod = xrefInstance.TryResolve();
                    }
                }

                harmony.Patch(method, new HarmonyMethod(typeof(OGTrustRanks).GetMethod(nameof(GetFriendlyDetailedNameForSocialRank), BindingFlags.NonPublic | BindingFlags.Static)));
            }

            var colorForRankTargetMethods = typeof(VRCPlayer).GetMethods().Where(it => it.ReturnType.ToString().Equals("UnityEngine.Color") && it.GetParameters().Length == 1 && it.GetParameters()[0].ParameterType.ToString().Equals("VRC.Core.APIUser")).ToList();

            colorForRankTargetMethods.ForEach(it =>
                                              harmony.Patch(it, new HarmonyMethod(typeof(OGTrustRanks).GetMethod(nameof(GetColorForSocialRank), BindingFlags.NonPublic | BindingFlags.Static)))
                                              );

            // Thanks loukylor
            _reloadAvatarMethod = typeof(VRCPlayer).GetMethods().First(mi =>
                                                                       mi.Name.StartsWith("Method_Private_Void_Boolean_") && mi.Name.Length < 31 &&
                                                                       mi.GetParameters().Any(pi => pi.IsOptional));


            MelonCoroutines.Start(InitializeNetworkHooks());
            MelonCoroutines.Start(FetchAPIUsers());
        }
Exemple #27
0
        private static void SetTrackerVisibility(bool visible)
        {
            if (ourSetVisibilityDelegate == null)
            {
                var method = typeof(VRCTrackingSteam)
                             .GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).Single(it =>
                                                                                                                         it.ReturnType == typeof(void) && it.GetParameters().Length == 1 &&
                                                                                                                         it.GetParameters()[0].ParameterType == typeof(bool) && XrefScanner.XrefScan(it)
                                                                                                                         .Any(jt => jt.Type == XrefType.Global && jt.ReadAsObject()?.ToString() == "Model"));

                ourSetVisibilityDelegate = (Action <VRCTrackingSteam, bool>)Delegate.CreateDelegate(typeof(Action <VRCTrackingSteam, bool>), method);
            }

            foreach (var vrcTracking in VRCTrackingManager.field_Private_Static_VRCTrackingManager_0.field_Private_List_1_VRCTracking_0)
            {
                var vrcTrackingSteam = vrcTracking.TryCast <VRCTrackingSteam>();
                if (vrcTrackingSteam == null)
                {
                    continue;
                }

                ourSetVisibilityDelegate(vrcTrackingSteam, visible);
                return;
            }
        }
        public static void DisplayWorldInfoPage(ApiWorld world)
        {
            if (ourShowWorldInfoPageDelegate == null)
            {
                var target = typeof(UiWorldList)
                             .GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Static).Single(it =>
                                                                                                                       it.Name.StartsWith("Method_Public_Static_Void_ApiWorld") &&
                                                                                                                       XrefScanner.XrefScan(it).Any(jt =>
                                                                                                                                                    jt.Type == XrefType.Global && jt.ReadAsObject()?.ToString() ==
                                                                                                                                                    "UserInterface/MenuContent/Screens/WorldInfo"));

                ourShowWorldInfoPageDelegate = (Action <ApiWorld>)Delegate.CreateDelegate(typeof(Action <ApiWorld>), target);
            }

            ourShowWorldInfoPageDelegate(world);
        }
Exemple #29
0
        public void OnUiManagerInit()
        {
            VRCUiPageAuthentication authPage = GetAuthPage();

            Button doneButton = authPage.transform.Find("ButtonDone (1)").GetComponent <Button>();

            Button.ButtonClickedEvent doneButton_onClick = doneButton.onClick;
            doneButton.onClick = new Button.ButtonClickedEvent();
            doneButton.onClick.AddListener(new Action(() =>
            {
                SavePlayerPrefs();
                doneButton_onClick.Invoke();
            }));

            GameObject.Find("UserInterface/MenuContent/Screens/Authentication/Login2FA/BoxLogin2FA/ButtonBack").GetComponent <Button>().onClick.AddListener(new Action(LoadPlayerPrefs));

            Transform popupcheckboxtrans = GameObject.Find("UserInterface/MenuContent/Popups/PerformanceSettingsPopup").GetComponent <PopupPerformanceOptions>().dynamicBoneOptionsPage.transform.Find("Checkboxes/LimitDynamicBoneUsage");

            GameObject newcheckbox = GameObject.Instantiate(popupcheckboxtrans.gameObject, authPage.field_Public_UiInputField_0.transform.parent);

            newcheckbox.name = "RememberMe";
            GameObject.Destroy(newcheckbox.transform.GetChild(2).gameObject);
            GameObject.Destroy(newcheckbox.transform.GetChild(3).gameObject);
            GameObject.Destroy(newcheckbox.transform.GetChild(4).gameObject);
            GameObject.Destroy(newcheckbox.transform.GetChild(5).gameObject);

            Transform newcheckbox_desc_trans = newcheckbox.transform.Find("Description");

            newcheckbox_desc_trans.GetComponent <Text>().text = "Remember Me";

            Toggle newcheckbox_toggle = newcheckbox.GetComponent <Toggle>();

            newcheckbox_toggle.isOn           = SecurePlayerPrefs.HasKey(ToggleKey);
            newcheckbox_toggle.onValueChanged = new Toggle.ToggleEvent();
            newcheckbox_toggle.onValueChanged.AddListener(new Action <bool>((newvalue) =>
            {
                if (!newvalue)
                {
                    SecurePlayerPrefs.DeleteKey(ToggleKey);
                }
                else
                {
                    SecurePlayerPrefs.SetString(ToggleKey, "true", SecurePlayerPrefsPassword);
                }
            }));

            newcheckbox.transform.localPosition = new Vector3((authPage.field_Public_UiInputField_1.transform.localPosition.x - 130), (authPage.field_Public_UiInputField_1.transform.localPosition.y - 45), authPage.field_Public_UiInputField_1.transform.localPosition.z);
            authPage.field_Public_UiInputField_0.transform.localPosition = new Vector3(authPage.field_Public_UiInputField_0.transform.localPosition.x, (authPage.field_Public_UiInputField_0.transform.localPosition.y + 30), authPage.field_Public_UiInputField_0.transform.localPosition.z);
            authPage.field_Public_UiInputField_1.transform.localPosition = new Vector3(authPage.field_Public_UiInputField_1.transform.localPosition.x, (authPage.field_Public_UiInputField_1.transform.localPosition.y + 30), authPage.field_Public_UiInputField_1.transform.localPosition.z);

            ValidateTextTargetMethod = typeof(InputFieldValidator).GetMethods(BindingFlags.Instance | BindingFlags.Public)
                                       .Single(it => it.GetParameters().Length == 1 && XrefScanner.XrefScan(it).Any(jt => jt.Type == XrefType.Global && jt.ReadAsObject()?.ToString() == "^([\\w\\.\\-\\+]+)@([\\w\\-]+)((\\.(\\w){2,3})+)$"));

            LoadPlayerPrefs();

            VRCUiManager uiManager = GetVRCUiManager();

            uiManager.field_Private_Action_1_VRCUiPage_0 = (
                (uiManager.field_Private_Action_1_VRCUiPage_0 == null)
                ? new Action <VRCUiPage>(OnPageShown)
                : Il2CppSystem.Delegate.Combine(uiManager.field_Private_Action_1_VRCUiPage_0, (Il2CppSystem.Action <VRCUiPage>) new Action <VRCUiPage>(OnPageShown)).Cast <Il2CppSystem.Action <VRCUiPage> >()
                );
        }
Exemple #30
0
        public override void OnApplicationStart()
        {
            FolderPath = string.Format("{0}/VRChat", new object[] { Environment.GetFolderPath(Environment.SpecialFolder.MyPictures) });
            if (Directory.Exists(FolderPath))
            {
                string[] filepaths = Directory.GetFiles(FolderPath, "VRChat_*.png", SearchOption.TopDirectoryOnly);
                if (filepaths.Length > 0)
                {
                    foreach (string file in filepaths)
                    {
                        DateTime fileinfo       = File.GetLastWriteTime(file);
                        string   filefolderpath = string.Format("{0}/{1}", new object[] { FolderPath, fileinfo.ToString("yyyy-MM-dd") });
                        if (!Directory.Exists(filefolderpath))
                        {
                            Directory.CreateDirectory(filefolderpath);
                        }
                        string newfile = string.Format("{0}/{1}.png", new object[] { filefolderpath, fileinfo.ToString("HH-mm-ss.fff") });
                        if (!File.Exists(newfile))
                        {
                            File.Move(file, newfile);
                        }
                    }
                }
            }
            var             TargetMethod    = typeof(ObjectPublicCaUnique).GetMethods(BindingFlags.Static | BindingFlags.Public).Single(it => it.GetParameters().Length == 2 && XrefScanner.XrefScan(it).Any(jt => jt.Type == XrefType.Global && jt.ReadAsObject()?.ToString() == "{0}/VRChat/VRChat_{1}x{2}_{3}.png"));
            HarmonyInstance harmonyInstance = HarmonyInstance.Create("PhotoOrganization");

            harmonyInstance.Patch(TargetMethod, new HarmonyMethod(typeof(PhotoOrganization).GetMethod("CameraFolderOrganize", BindingFlags.Static | BindingFlags.NonPublic)));
        }