Added gas grid optimization, various despawn optimizations, new hauling optimizations utilizing events and regions, bugfixes for old patches and for vanilla functions too, as well as smaller additions. 1.3 files removed.

Source/PerformanceFish/Hediffs/HealthTrackerOptimization.cs

@@ -8,7 +8,7 @@ using PerformanceFish.Prepatching;
 
 namespace PerformanceFish.Hediffs;
 
-public class HealthTrackerOptimization : ClassWithFishPrepatches
+public sealed class HealthTrackerOptimization : ClassWithFishPrepatches
 {
 	public static void Initialize()
 	{
@@ -24,7 +24,7 @@ public class HealthTrackerOptimization : ClassWithFishPrepatches
 		}
 	}
 	
-	public class HealthTickPatch : FishPrepatch
+	public sealed class HealthTickPatch : FishPrepatch
 	{
 		public override MethodBase TargetMethodBase { get; }
 			= AccessTools.Method(typeof(Pawn_HealthTracker), nameof(Pawn_HealthTracker.HealthTick));

Source/PerformanceFish/Hediffs/HediffComp_PsychicHarmonizer_Bugfix.cs

@@ -3,18 +3,17 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-using System.Linq;
 using static System.Reflection.Emit.OpCodes;
 
 namespace PerformanceFish.Hediffs;
 
-public class HediffComp_PsychicHarmonizer_Bugfix : ClassWithFishPatches
+public sealed class HediffComp_PsychicHarmonizer_Bugfix : ClassWithFishPatches
 {
-	public class CompPostTick_Patch : FishPatch
+	public sealed class CompPostTick_Patch : FishPatch
 	{
 		public override string Description { get; }
 			= "Fixes a bug in the psychic harmonizer tick method that was causing it to recalculate results on 149 "
-				+ "out of 150 ticks instead of once every 150 ticks. Large impact.";
+			+ "out of 150 ticks instead of once every 150 ticks. Large impact.";
 
 		public override MethodBase TargetMethodInfo { get; }
 			= AccessTools.Method(typeof(HediffComp_PsychicHarmonizer),
@@ -22,29 +21,19 @@ public class HediffComp_PsychicHarmonizer_Bugfix : ClassWithFishPatches
 
 		public static CodeInstructions Transpiler(CodeInstructions codeInstructions)
 		{
-			var codes = codeInstructions.ToList();
+			var codes = codeInstructions.AsOrToList();
 			var pawn_int_IsHashIntervalTick = FishTranspiler.Call<Func<Thing, int, bool>>(Gen.IsHashIntervalTick);
 			var success = false;
+			
 			for (var i = 0; i < codes.Count; i++)
 			{
-				if (i + 2 < codes.Count
-					&& codes[i].opcode == Ldc_I4
-					&& codes[i + 1] == pawn_int_IsHashIntervalTick
-					&& codes[i + 2].opcode == Brfalse_S)
+				if (i - 2 >= 0
+					&& codes[i - 2].opcode == Ldc_I4
+					&& codes[i - 1] == pawn_int_IsHashIntervalTick
+					&& codes[i].opcode == Brfalse_S)
 				{
-					//codes[i].operand = 128;
-					yield return codes[i];
-					yield return codes[i + 1];
-
-					codes[i + 2].opcode = Brtrue_S;
-					yield return codes[i + 2];
-
+					codes[i].opcode = Brtrue_S;
 					success = true;
-					i += 2;
-				}
-				else
-				{
-					yield return codes[i];
 				}
 			}
 
@@ -55,6 +44,8 @@ public class HediffComp_PsychicHarmonizer_Bugfix : ClassWithFishPatches
 					+ "an actual failure to patch if settings were not toggled however, which would mean some other "
 					+ "patch or a vanilla change either messes with this or implements the same thing");
 			}
+
+			return codes;
 		}
 	}
 }

Source/PerformanceFish/Hediffs/HediffSetCaching.cs

@@ -18,9 +18,9 @@ using NotMissingPartsCache
 
 namespace PerformanceFish.Hediffs;
 
-public class HediffSetPrecaching : ClassWithFishPrepatches
+public sealed class HediffSetPrecaching : ClassWithFishPrepatches
 {
-	public class GetFirstHediffOfDef : FishPrepatch
+	public sealed class GetFirstHediffOfDef : FishPrepatch
 	{
 		public override string Description { get; }
 			= "Caches results of the HediffSet.GetFirstHediffOfDef method. Impact scales with hediff count.";
@@ -94,7 +94,7 @@ public class HediffSetPrecaching : ClassWithFishPrepatches
 		}
 	}
 
-	public class HasHediff : FishPrepatch
+	public sealed class HasHediff : FishPrepatch
 	{
 		public override string Description { get; }
 			= "Caches results of the HediffSet.HasHediff method. Impact scales with hediff count.";
@@ -111,7 +111,7 @@ public class HediffSetPrecaching : ClassWithFishPrepatches
 			=> __instance.GetFirstHediffOfDef(def, mustBeVisible) != null;
 	}
 	
-	public class GetNotMissingParts : FishPrepatch
+	public sealed class GetNotMissingParts : FishPrepatch
 	{
 		public override string? Description { get; }
 			= "Caches results of the HediffSet.GetNotMissingParts method. Impact scales with hediff count.";
@@ -156,9 +156,9 @@ public class HediffSetPrecaching : ClassWithFishPrepatches
 	}
 }
 
-public class HediffSetCaching : ClassWithFishPatches
+public sealed class HediffSetCaching : ClassWithFishPatches
 {
-	public class DirtyCache : FishPatch
+	public sealed class DirtyCache : FishPatch
 	{
 		public override string Description { get; }
 			= "Patched to trigger psylink cache clearing for the psychic entropy optimization.";
@@ -176,9 +176,9 @@ public class HediffSetCaching : ClassWithFishPatches
 	public record struct NotMissingPartsCacheValue
 	{
 		private int _version = -1;
-		private List<Hediff> _hediffsInSet = new();
+		private List<Hediff> _hediffsInSet = [];
 		private int _nextRefreshTick;
-		public List<BodyPartRecord> Parts = new();
+		public List<BodyPartRecord> Parts = [];
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public void Update(HediffSet set, ref IEnumerable<BodyPartRecord> result)
@@ -209,7 +209,7 @@ public class HediffSetCaching : ClassWithFishPatches
 	public record struct HediffCacheValue
 	{
 		private int _version = -1;
-		private List<Hediff> _hediffsInSet = new();
+		private List<Hediff> _hediffsInSet = [];
 		private int _nextRefreshTick;
 		public Hediff? Hediff;
 

Source/PerformanceFish/Hediffs/HediffWithCompsOptimization.cs

@@ -0,0 +1,99 @@
+// Copyright (c) 2023 bradson
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+#if useless
+
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+using PerformanceFish.Prepatching;
+
+namespace PerformanceFish.Hediffs;
+
+public sealed class HediffWithCompsOptimization : ClassWithFishPrepatches
+{
+	public sealed class ShouldRemovePatch : FishPrepatch
+	{
+		public override MethodBase TargetMethodBase { get; }
+			= AccessTools.DeclaredPropertyGetter(typeof(HediffWithComps), nameof(HediffWithComps.ShouldRemove));
+
+		public override void Transpiler(ILProcessor ilProcessor, ModuleDefinition module)
+			=> ilProcessor.ReplaceBodyWith(ReplacementBody);
+
+		public static unsafe bool ReplacementBody(HediffWithComps instance)
+		{
+			if (instance.comps is { } comps)
+			{
+				for (var i = 0; i < comps.Count; i++)
+				{
+					if (comps[i].CompShouldRemove)
+						return true;
+				}
+			}
+			
+			return BaseShouldRemove(instance);
+		}
+
+		public static unsafe delegate*<HediffWithComps, bool> BaseShouldRemove
+			= (delegate*<HediffWithComps, bool>)AccessTools
+				.DeclaredPropertyGetter(typeof(Hediff), nameof(Hediff.ShouldRemove)).GetFunctionPointer();
+	}
+
+	public sealed class VisiblePatch : FishPrepatch
+	{
+		public override MethodBase TargetMethodBase { get; }
+			= AccessTools.DeclaredPropertyGetter(typeof(HediffWithComps), nameof(HediffWithComps.Visible));
+
+		public override void Transpiler(ILProcessor ilProcessor, ModuleDefinition module)
+			=> ilProcessor.ReplaceBodyWith(ReplacementBody);
+
+		public static unsafe bool ReplacementBody(HediffWithComps instance)
+		{
+			if (instance.comps is { } comps)
+			{
+				for (var i = 0; i < comps.Count; i++)
+				{
+					if (comps[i].CompDisallowVisible())
+						return false;
+				}
+			}
+			
+			return BaseVisible(instance);
+		}
+
+		public static unsafe delegate*<HediffWithComps, bool> BaseVisible
+			= (delegate*<HediffWithComps, bool>)AccessTools
+				.DeclaredPropertyGetter(typeof(Hediff), nameof(Hediff.Visible)).GetFunctionPointer();
+	}
+
+	public sealed class PostTickPatch : FishPrepatch
+	{
+		public override MethodBase TargetMethodBase { get; }
+			= AccessTools.DeclaredMethod(typeof(HediffWithComps), nameof(HediffWithComps.PostTick));
+
+		public override void Transpiler(ILProcessor ilProcessor, ModuleDefinition module)
+			=> ilProcessor.ReplaceBodyWith(ReplacementBody);
+
+		public static unsafe void ReplacementBody(HediffWithComps instance)
+		{
+			BasePostTick(instance);
+
+			if (instance.comps is not { } comps)
+				return;
+
+			var severityAdjustment = 0f;
+			for (var i = 0; i < comps.Count; i++)
+				comps[i].CompPostTick(ref severityAdjustment);
+
+			if (severityAdjustment != 0f)
+				instance.Severity += severityAdjustment;
+		}
+
+		public static unsafe delegate*<HediffWithComps, void> BasePostTick
+			= (delegate*<HediffWithComps, void>)AccessTools.DeclaredMethod(typeof(Hediff), nameof(Hediff.PostTick))
+				.GetFunctionPointer();
+	}
+}
+
+#endif

Source/PerformanceFish/Hediffs/ImmunityHandlerCaching.cs

@@ -12,9 +12,9 @@ using ImmunityRecordExistsCache
 
 namespace PerformanceFish.Hediffs;
 
-public class ImmunityHandlerCaching : ClassWithFishPatches
+public sealed class ImmunityHandlerCaching : ClassWithFishPatches
 {
-	public class NeededImmunitiesNow : FirstPriorityFishPatch
+	public sealed class NeededImmunitiesNow : FirstPriorityFishPatch
 	{
 		public override string Description { get; }
 			= "Caches results of the ImmunityHandler.NeededImmunitiesNow method. Impact scales with hediff quantity.";
@@ -54,7 +54,7 @@ public class ImmunityHandlerCaching : ClassWithFishPatches
 				.Update(__instance.pawn.health.hediffSet, __result);
 	}
 
-	public class ImmunityRecordExists : FishPatch
+	public sealed class ImmunityRecordExists : FishPatch
 	{
 		public override string? Description { get; } = "Required by the TryAddImmunityRecord optimization.";
 
@@ -82,7 +82,7 @@ public class ImmunityHandlerCaching : ClassWithFishPatches
 		}
 	}
 
-	public class TryAddImmunityRecord : FishPatch
+	public sealed class TryAddImmunityRecord : FishPatch
 	{
 		public override string? Description { get; }
 			= "Optimization for this specific method to not run more checks than necessary.";
@@ -113,9 +113,9 @@ public class ImmunityHandlerCaching : ClassWithFishPatches
 	public record struct ImmunityInfoCacheValue
 	{
 		private int _version = -1;
-		private List<Hediff> _hediffsInSet = new();
+		private List<Hediff> _hediffsInSet = [];
 		private int _nextRefreshTick;
-		public List<ImmunityHandler.ImmunityInfo> Infos = new();
+		public List<ImmunityHandler.ImmunityInfo> Infos = [];
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public void Update(HediffSet set, List<ImmunityHandler.ImmunityInfo> infos)

Source/PerformanceFish/Hediffs/Pawn_PsychicEntropyTrackerOptimization.cs

@@ -5,9 +5,9 @@
 
 namespace PerformanceFish.Hediffs;
 
-public class Pawn_PsychicEntropyTrackerOptimization : ClassWithFishPatches
+public sealed class Pawn_PsychicEntropyTrackerOptimization : ClassWithFishPatches
 {
-	public class Psylink_Patch : FirstPriorityFishPatch
+	public sealed class Psylink_Patch : FirstPriorityFishPatch
 	{
 		public override string Description { get; } = "Caches/throttles the psylink method to only update every 32 ticks.";