Optimizations (from @wolfcomp)

Simulator/Actions/BaseAction.cs

@@ -7,23 +7,34 @@ public abstract class BaseAction
     // Non-instanced properties
 
     // Metadata
-    public abstract ActionCategory Category { get; }
-    public abstract int Level { get; }
+    public ActionCategory Category;
+
+    public int Level;
     // Doesn't matter from which class, we'll use the sheet to extrapolate the rest
-    public abstract uint ActionId { get; }
+    public uint ActionId;
     // Seconds
-    public virtual int MacroWaitTime => 3;
+    public int MacroWaitTime = 3;
 
     // Action properties
-    public virtual bool IncreasesProgress => false;
-    public virtual bool IncreasesQuality => false;
-    public virtual int DurabilityCost => 10;
-    public virtual bool IncreasesStepCount => true;
+    public bool IncreasesProgress;
+    public bool IncreasesQuality;
+    public int DurabilityCost = 10;
+    public bool IncreasesStepCount = true;
+    public int EfficiencyFactor;
+    public float SuccessRateFactor = 1;
 
     // Instanced properties
-    public abstract int CPCost(Simulator s);
-    public virtual int Efficiency(Simulator s) => 0;
-    public virtual float SuccessRate(Simulator s) => 1f;
+    public abstract void CPCost(Simulator s, ref int cost);
+
+    public virtual void Efficiency(Simulator s, ref int eff)
+    {
+        eff = EfficiencyFactor;
+    }
+
+    public virtual void SuccessRate(Simulator s, ref float success)
+    {
+        success = SuccessRateFactor;
+    }
 
     // Return true if it can be in the action pool now or in the future
     // e.g. if Heart and Soul is already used, it is impossible to use it again
@@ -33,18 +44,23 @@ public abstract class BaseAction
 
     // Return true if it can be used now
     // This already assumes that IsPossible returns true *at some point before*
-    public virtual bool CouldUse(Simulator s) =>
-        s.CP >= CPCost(s);
-
-    public bool CanUse(Simulator s) =>
-        IsPossible(s) && CouldUse(s);
-
-    public virtual void Use(Simulator s)
+    public virtual bool CouldUse(Simulator s, ref int cost)
     {
-        if (s.RollSuccess(SuccessRate(s)))
-            UseSuccess(s);
+        CPCost(s, ref cost);
+        return s.CP >= cost;
+    }
 
-        s.ReduceCP(CPCost(s));
+    public bool CanUse(Simulator s, ref int cost) =>
+        IsPossible(s) && CouldUse(s, ref cost);
+
+    public virtual void Use(Simulator s, ref int cost, ref float success, ref int eff)
+    {
+        SuccessRate(s, ref success);
+        if (s.RollSuccess(success))
+            UseSuccess(s, ref eff);
+        CPCost(s, ref cost);
+
+        s.ReduceCP(cost);
         s.ReduceDurability(DurabilityCost);
 
         if (s.Durability > 0)
@@ -63,38 +79,43 @@ public abstract class BaseAction
             s.ActiveEffects.DecrementDuration();
     }
 
-    public virtual void UseSuccess(Simulator s)
+    public virtual void UseSuccess(Simulator s, ref int eff)
     {
-        if (Efficiency(s) != 0f)
+        Efficiency(s, ref eff);
+        if (eff != 0)
         {
             if (IncreasesProgress)
-                s.IncreaseProgress(Efficiency(s));
+                s.IncreaseProgress(eff);
             if (IncreasesQuality)
-                s.IncreaseQuality(Efficiency(s));
+                s.IncreaseQuality(eff);
         }
     }
 
     public virtual string GetTooltip(Simulator s, bool addUsability)
     {
         var builder = new StringBuilder();
-        if (addUsability && !CanUse(s))
+        int cost = 0;
+        float success = 1f;
+        if (addUsability && !CanUse(s, ref cost))
             builder.AppendLine($"Cannot Use");
         builder.AppendLine($"Level {Level}");
-        if (CPCost(s) != 0)
-            builder.AppendLine($"-{s.CalculateCPCost(CPCost(s))} CP");
+        if (cost != 0)
+            builder.AppendLine($"-{s.CalculateCPCost(cost)} CP");
         if (DurabilityCost != 0)
             builder.AppendLine($"-{s.CalculateDurabilityCost(DurabilityCost)} Durability");
-        if (Efficiency(s) != 0)
+        Efficiency(s, ref cost);
+        if (cost != 0)
         {
             if (IncreasesProgress)
-                builder.AppendLine($"+{s.CalculateProgressGain(Efficiency(s))} Progress");
+                builder.AppendLine($"+{s.CalculateProgressGain(cost)} Progress");
             if (IncreasesQuality)
-                builder.AppendLine($"+{s.CalculateQualityGain(Efficiency(s))} Quality");
+                builder.AppendLine($"+{s.CalculateQualityGain(cost)} Quality");
         }
         if (!IncreasesStepCount)
             builder.AppendLine($"Does Not Increase Step Count");
-        if (SuccessRate(s) != 1f)
-            builder.AppendLine($"{s.CalculateSuccessRate(SuccessRate(s)) * 100:##}% Success Rate");
+        SuccessRate(s, ref success);
+        if (Math.Abs(success - 1f) > float.Epsilon)
+            builder.AppendLine($"{s.CalculateSuccessRate(success) * 100:##}% Success Rate");
         return builder.ToString();
     }
 }