Example #1
0
        static RestrictedStorage()
        {
            var harmony = new HarmonyLib.Harmony("net.littlewhitemouse.RimWorld.RestrictedStorage");

            harmony.PatchAll();
            // Add ITab and Comp to proper storage buildings:
            //   Add to all Building_Storage but not ones in Production (hoppers?)
            // This should be slightly faster than xpath xml patching.
            var desigProduction = DefDatabase <DesignationCategoryDef> .GetNamed("Production");

            var itabResolved = InspectTabManager.GetSharedInstance(typeof(ITab_RestrictedStorage));

            foreach (var b in DefDatabase <ThingDef> .AllDefs
                     .Where(d => (d?.thingClass != null &&
                                  (d.thingClass == typeof(Building_Storage) ||
                                   d.thingClass.IsSubclassOf(typeof(Building_Storage)))))
                     .Where(d => d.designationCategory != desigProduction))
            {
                // This should be the equivalent of
                //   <comps>
                //     <li>
                //       <compClass>CompRestrictedStorage</compClass>etc
                if (b.comps != null)
                {
                    b.comps.Add(new CompProperties {
                        compClass = typeof(CompRestrictedStorage)
                    });
                }
                else
                {
                    Log.Message("LWM.Restricted Storage: " + b + " does not have comps");
                    continue;
                }
                // but....we don't actually want to add this comp to EVERYTHING - I mean, why
                // bother?  It's not going to be used in the majority of cases.  Except...
                // the game won't load save-game-data unless the comp is already there.  Yes...
                // So we do add it to everything.
                //
                // On the other hand, we DO want to use the ITab for all storage buildings:
                // This mirrors ThingDef's resolve references - I didn't want to take the time
                //   to do a ResolveReferences for every single ThingDef, but if anything
                //   breaks, that's always an option...
                if (b.inspectorTabs != null)
                {
                    b.inspectorTabs.Add(typeof(ITab_RestrictedStorage));
                    if (b.inspectorTabsResolved != null)
                    {
                        b.inspectorTabsResolved.Add(itabResolved);
                    }
                    else
                    {
                        Log.Message("LWM.Restricted Storage: " + b + " does not have inspectorTabsResolved");
                    }
                }
                else
                {
                    Log.Message("LWM.Restricted Storage: " + b + " does not have inspectorTabs");
                }
            }
        }
Example #2
0
        public Module(ModContentPack content) : base(content)
        {
            Log.Message("Frontier Developments Shields :: Loading Crash Landing support");

            var harmony = new HarmonyLib.Harmony("FrontierDevelopment.Shields.CrashLanding");

            harmony.PatchAll(Assembly.GetExecutingAssembly());

            Harmony_Projectile.BlacklistType(typeof(CrashPod));

            // var baseType = Type.GetType("CrashLanding.CrashPod, CrashLanding");
            // var types = baseType.AllSubclassesNonAbstract();
            // var blockingTypes = "";
            //
            // foreach (var current in types)
            // {
            //     blockingTypes += current.Name + " ";
            //
            //     if (current.Name.Contains("_part"))
            //     {
            //         harmony.Patch(
            //             current.GetMethod("Impact", BindingFlags.NonPublic | BindingFlags.Instance),
            //             new HarmonyMethod(typeof(CrashPodHandler).GetMethod(nameof(CrashPodHandler.CrashPod_Part_Impact_Prefix))));
            //     }
            //     else
            //     {
            //         harmony.Patch(
            //             current.GetMethod("Impact", BindingFlags.NonPublic | BindingFlags.Instance),
            //             new HarmonyMethod(typeof(CrashPodHandler).GetMethod(nameof(CrashPodHandler.CrashPod_Impact_Prefix))));
            //     }
            // }
        }
Example #3
0
        public static HarmonyLib.Harmony instance;              //Lt. Bob: 1.1

        static HarmonyMain()
        {
            //instance = HarmonyInstance.Create("DrCarlLuo.Rimworld.PreemptiveStrike");	//Lt. Bob: 1.1 - Replaced with below
            instance = new HarmonyLib.Harmony("DrCarlLuo.Rimworld.PreemptiveStrike");               //Lt. Bob: 1.1
            instance.PatchAll(Assembly.GetExecutingAssembly());
            ManualPatchings();
        }
        static MeatShieldPatcher()
        {
            var          tp    = typeof(CoverUtils);
            BindingFlags attrs = BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public;

            FillageMethodReplacer = tp.GetMethod(nameof(CoverUtils.GetFillage), attrs);

            FillPercentageReplacer  = tp.GetMethod(nameof(CoverUtils.GetFillPercentage), attrs);
            FillPercentageTarget    = typeof(ThingDef).GetField(nameof(ThingDef.fillPercent), attrs);
            BaseBlockChanceReplacer = typeof(CoverUtils).GetMethod(nameof(CoverUtils.BaseBlockChance));
            BaseBlockChanceTarget   =
                typeof(CoverUtility).GetMethod(nameof(CoverUtility.BaseBlockChance), new Type[] { typeof(ThingDef) });
            FillageTarget = typeof(ThingDef)
                            .GetProperty(nameof(ThingDef.Fillage),
                                         attrs)
                            .GetGetMethod();

            ThingDefField = typeof(Thing).GetField(nameof(Thing.def));

            TranspilerMI = typeof(MeatShieldPatcher).GetMethod(nameof(Transpiler), attrs);

            var harmony = new HarmonyLib.Harmony(MeatShieldMod.MOD_ID);


            harmony.PatchAll();
            MassPatch(harmony);
        }
Example #5
0
        public Module(ModContentPack content) : base(content)
        {
            Log.Message("Frontier Developments Shields :: Loading Centralized Climate Control (Continued) support");

            var harmony = new HarmonyLib.Harmony("FrontierDevelopment.Shields.ClimateControl");

            harmony.PatchAll(Assembly.GetExecutingAssembly());
        }
        public Module(ModContentPack content) : base(content)
        {
            Log.Message("Frontier Developments Shields :: Loading Dubs Bad Hygiene support");

            var harmony = new HarmonyLib.Harmony("FrontierDevelopment.Shields.BadHygiene");

            harmony.PatchAll(Assembly.GetExecutingAssembly());
        }
Example #7
0
        static PatchLoader()
        {
            var instance = new HarmonyLib.Harmony("trader_costs");

            instance.PatchAll(Assembly.GetExecutingAssembly());

            //FileLog.Log("Harmony Loaded");
        }
Example #8
0
 public static void asdf(Engine engine)
 {
     //string compatibilityHash = "z1mXkIlayLh4CfmTTUbRJw==";
     //var t = typeof(Engine);
     //t.GetProperty("CompatibilityHash").SetValue(engine, compatibilityHash, null);
     NeosVersionHelpers.OverrideHash(engine);
     Harmony.PatchAll();
 }
Example #9
0
 public static HarmonyLib.Harmony PatchAll(Type type, HarmonyLib.Harmony harmonyInstance = null)
 {
     if (harmonyInstance == null)
     {
         return(HarmonyLib.Harmony.CreateAndPatchAll(type));
     }
     harmonyInstance.PatchAll(type);
     return(harmonyInstance);
 }
        public ModLootBoxes(ModContentPack content) : base(content)
        {
            Settings = GetSettings <ModSettingsLootBoxes>();

#if V10
            var harmony = HarmonyInstance.Create("rimworld.lanilor.lootboxes");
#else
            var harmony = new HarmonyLib.Harmony("rimworld.lanilor.lootboxes");
#endif
            harmony.PatchAll(Assembly.GetExecutingAssembly());
        }
Example #11
0
 internal void Awake()
 {
     try
     {
         var harmony = new HarmonyLib.Harmony(ID);
         harmony.PatchAll();
         MyLogger.LogDebug("Awaken");
     }
     catch (Exception ex)
     {
         MyLogger.LogError(ex.Message);
     }
 }
Example #12
0
 /// <summary>
 /// Attempts to apply all the Harmony patches in this assembly.
 /// </summary>
 internal static void ApplyHarmonyPatches()
 {
     try
     {
         Plugin.Log?.Debug("Applying Harmony patches.");
         harmony.PatchAll(Assembly.GetExecutingAssembly());
     }
     catch (Exception ex)
     {
         Plugin.Log?.Error("Error applying Harmony patches: " + ex.Message);
         Plugin.Log?.Debug(ex);
     }
 }
Example #13
0
        public static HarmonyLib.Harmony CreateAndPatchAll(Type type)
        {
            var harmony = new HarmonyLib.Harmony(Guid.NewGuid().ToString());

            harmony.PatchAll(type);

            foreach (var method in type.GetMethods(AccessTools.all))
            {
                foreach (var attr in method.GetCustomAttributes <HarmonyPatchExtAttribute>(false))
                {
                    attr.Patch(harmony, method);
                }
            }

            return(harmony);
        }
Example #14
0
        public override void OnEnabled()
        {
            try
            {
                Instance = this;

                Harmony = new HarmonyLib.Harmony("rptoolkit.instance");

                Harmony.PatchAll();

                EventHandlers = new EventHandlers();

                if (!Directory.Exists(Config.RPToolkitRootPath))
                {
                    Directory.CreateDirectory(Config.RPToolkitRootPath);
                }

                if (!File.Exists(Config.NamesPath))
                {
                    StreamWriter sw = File.CreateText(Config.NamesPath);
                    sw.Write(Config.Names);
                    sw.Close();
                }
                if (!File.Exists(Config.SurnamesPath))
                {
                    StreamWriter sw = File.CreateText(Config.SurnamesPath);
                    sw.Write(Config.Surnames);
                    sw.Close();
                }

                Util.Init();

                Handlers.Server.RoundStarted += EventHandlers.OnRoundStart;
                Handlers.Server.RoundEnded   += EventHandlers.OnRoundEnd;

                Handlers.Player.ChangingRole  += EventHandlers.OnRoleChange;
                Handlers.Player.PickingUpItem += EventHandlers.OnItemPickup;
                Handlers.Player.ChangingItem  += EventHandlers.OnChangingItem;

                Log.Info($"RPToolkit plugin loaded. @gamehunt");
            }
            catch (Exception e)
            {
                Log.Error($"There was an error loading the plugin: {e}");
            }
        }
Example #15
0
        static Patcher()
        {
            var harmony = new HarmonyLib.Harmony("TGPAcher.Rimworld.Spotted");

            harmony.PatchAll(Assembly.GetExecutingAssembly());

            // Patch incidents which do not have special "patch"
            var listOfIncidents = (from domainAssembly in AppDomain.CurrentDomain.GetAssemblies()
                                   from assemblyType in domainAssembly.GetTypes()
                                   where typeof(IncidentWorker).IsAssignableFrom(assemblyType)
                                   select assemblyType).ToArray();

            foreach (var incident in listOfIncidents)
            {
                if (ConfigDefOf.IncidentConfig.GetArgs().Contains(incident.FullName))
                {
                    harmony.Patch(AccessTools.Method(AccessTools.TypeByName(incident.FullName), "TryExecuteWorker"),
                                  new HarmonyMethod(
                                      typeof(IncidentWorker_TryExecuteWorker)
                                      .GetMethod(nameof(IncidentWorker_TryExecuteWorker.Prefix))));
                }
            }
        }
        static HarmonyPatchesFS()
        {
            HarmonyLib.Harmony harmony = new HarmonyLib.Harmony("rimworld.facialstuff.mod");
            // HarmonyLib.Harmony.DEBUG = true;
            harmony.PatchAll(Assembly.GetExecutingAssembly());


            harmony.Patch(
                AccessTools.Method(typeof(Page_ConfigureStartingPawns), "DrawPortraitArea"),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(AddFaceEditButton)));

            harmony.Patch(
                AccessTools.Method(typeof(PawnGraphicSet), nameof(PawnGraphicSet.ResolveAllGraphics)),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(ResolveAllGraphics_Postfix)));

            harmony.Patch(
                AccessTools.Method(typeof(PawnGraphicSet), nameof(PawnGraphicSet.ResolveApparelGraphics)),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(ResolveApparelGraphics_Postfix)));

            harmony.Patch(
                AccessTools.Method(typeof(PawnRenderer), nameof(PawnRenderer.DrawEquipmentAiming)),
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(DrawEquipmentAiming_Prefix)),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS),
                                  nameof(DrawEquipmentAiming_Transpiler)));

            harmony.Patch(
                AccessTools.Method(typeof(PawnRenderer), nameof(PawnRenderer.RenderPawnAt),
                                   new[] { typeof(Vector3), typeof(RotDrawMode), typeof(bool), typeof(bool) }),

                // new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(HarmonyPatchesFS.RenderPawnAt)),
                null,
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(RenderPawnAt_Transpiler))
                );

            harmony.Patch(
                AccessTools.Method(typeof(HediffSet), nameof(HediffSet.DirtyCache)),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(DirtyCache_Postfix)));

            harmony.Patch(
                AccessTools.Method(typeof(GraphicDatabaseHeadRecords),
                                   nameof(GraphicDatabaseHeadRecords.Reset)),
                null,
                new HarmonyMethod(
                    typeof(GraphicDatabaseHeadRecordsModded),
                    nameof(GraphicDatabaseHeadRecordsModded.Reset)));

            harmony.Patch(
                AccessTools.Method(typeof(PawnHairChooser), nameof(PawnHairChooser.RandomHairDefFor)),
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(RandomHairDefFor_PreFix)),
                null);

            harmony.Patch(
                AccessTools.Method(typeof(PawnSkinColors), "GetSkinDataIndexOfMelanin"),
                new HarmonyMethod(
                    typeof(PawnSkinColors_FS),
                    nameof(PawnSkinColors_FS.GetSkinDataIndexOfMelanin_Prefix)),
                null);

            harmony.Patch(
                AccessTools.Method(typeof(PawnSkinColors), nameof(PawnSkinColors.GetSkinColor)),
                new HarmonyMethod(typeof(PawnSkinColors_FS), nameof(PawnSkinColors_FS.GetSkinColor_Prefix)),
                null);

            harmony.Patch(
                AccessTools.Method(typeof(PawnSkinColors), nameof(PawnSkinColors.RandomMelanin)),
                new HarmonyMethod(typeof(PawnSkinColors_FS), nameof(PawnSkinColors_FS.RandomMelanin_Prefix)),
                null);

            harmony.Patch(
                AccessTools.Method(typeof(PawnSkinColors),
                                   nameof(PawnSkinColors.GetMelaninCommonalityFactor)),
                new HarmonyMethod(
                    typeof(PawnSkinColors_FS),
                    nameof(PawnSkinColors_FS.GetMelaninCommonalityFactor_Prefix)),
                null);

            harmony.Patch(
                AccessTools.Method(typeof(Pawn_InteractionsTracker),
                                   nameof(Pawn_InteractionsTracker.TryInteractWith)),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(TryInteractWith_Postfix)));


            Log.Message(
                "Facial Stuff successfully completed " + harmony.GetPatchedMethods().Count()
                + " patches with harmony.");

            foreach (ThingDef def in DefDatabase <ThingDef> .AllDefsListForReading.Where(
                         td => td.category ==
                         ThingCategory.Pawn &&
                         td.race.Humanlike))
            {
                if (def.inspectorTabs == null || def.inspectorTabs.Count == 0)
                {
                    def.inspectorTabs         = new List <Type>();
                    def.inspectorTabsResolved = new List <InspectTabBase>();
                }

                if (def.inspectorTabs.Contains(typeof(ITab_Pawn_Weapons)))
                {
                    return;
                }

                def.inspectorTabs.Add(typeof(ITab_Pawn_Weapons));
                def.inspectorTabsResolved.Add(InspectTabManager.GetSharedInstance(typeof(ITab_Pawn_Weapons)));

                def.inspectorTabs.Add(typeof(ITab_Pawn_Face));
                def.inspectorTabsResolved.Add(InspectTabManager.GetSharedInstance(typeof(ITab_Pawn_Face)));
            }

            List <HairDef> beardyHairList =
                DefDatabase <HairDef> .AllDefsListForReading.Where(x => x.IsBeardNotHair()).ToList();

            for (int i = 0; i < beardyHairList.Count(); i++)
            {
                HairDef beardy = beardyHairList[i];
                if (beardy.label.Contains("shaven"))
                {
                    continue;
                }
                BeardDef beardDef = new BeardDef
                {
                    defName    = beardy.defName,
                    label      = "_VHE_" + beardy.label,
                    hairGender = beardy.hairGender,
                    texPath    = beardy.texPath.Replace("Things/Pawn/Humanlike/Beards/", ""),
                    hairTags   = beardy.hairTags,
                    beardType  = BeardType.FullBeard
                };
                if (beardDef.label.Contains("stubble") || beardDef.label.Contains("goatee") || beardDef.label.Contains("lincoln"))
                {
                    beardDef.drawMouth = true;
                }
                DefDatabase <BeardDef> .Add(beardDef);
            }
            Dialog_FaceStyling.FullBeardDefs = DefDatabase <BeardDef> .AllDefsListForReading.Where(x => x.beardType == BeardType.FullBeard)
                                               .ToList();

            Dialog_FaceStyling.LowerBeardDefs = DefDatabase <BeardDef> .AllDefsListForReading.Where(x => x.beardType != BeardType.FullBeard)
                                                .ToList();

            Dialog_FaceStyling.MoustacheDefs = DefDatabase <MoustacheDef> .AllDefsListForReading;

            CheckAllInjected();
        }
Example #17
0
        static SnowshoesHarmonyPatcher()
        {
            Harmony Harmony = new HarmonyLib.Harmony("udal.rimworld.snowshoes");

            Harmony.PatchAll();
        }
        static ZonesAndStorageModStartup()
        {
            var harmony = new HarmonyLib.Harmony("net.littlewhitemouse.RimWorld.ZonesAndStorage");

            harmony.PatchAll();
        }
Example #19
0
        public Main(ModContentPack content) : base(content)
        {
            var harmony = new HarmonyLib.Harmony("BloodTypes.Harmony");

            harmony.PatchAll(Assembly.GetExecutingAssembly());
        }