Enhance model loading and improve mouse handling

- Added `ClassesUpdated` event in `ModelManager.cs`.
- Renamed `LastAntiRecoilClickTime` to `LastAntiRecoilClickTick` in `MouseManager.cs` and changed its type for performance.
- Refactored methods in `MovementPaths.cs` for clarity and efficiency, including updates to `Exponential`, `Adaptive`, and `PerlinNoise`.
- Simplified `Fade` and `Lerp` methods using expression-bodied syntax.

Author: TaylorIsBlue

Aimmy2/AILogic/ModelManager.cs

@@ -33,8 +33,6 @@ public class ModelManager
 
         public bool isModelLoaded => onnxModel != null && outputNames != null && outputNames.Count > 0;
 
-
-
         public async Task LoadModelAsync(string modelPath, int IMAGE_SIZE, bool failure = false) // default value for failure is false, obviously
         {
             try

Aimmy2/InputLogic/MouseManager.cs

@@ -15,7 +15,7 @@ internal class MouseManager
         private static readonly double ScreenHeight = WinAPICaller.ScreenHeight;
 
         private static DateTime LastClickTime = DateTime.MinValue;
-        private static int LastAntiRecoilClickTime = 0;
+        private static int LastAntiRecoilClickTick = Environment.TickCount; 
         private static bool isSpraying = false;
 
         private const uint MOUSEEVENTF_LEFTDOWN = 0x0002;
@@ -140,9 +140,12 @@ public static void ResetSprayState()
             }
         }
         #endregion
+
         public static void DoAntiRecoil()
         {
-            int timeSinceLastClick = Math.Abs(DateTime.UtcNow.Millisecond - LastAntiRecoilClickTime);
+            int now = Environment.TickCount;
+            int timeSinceLastClick = now - LastAntiRecoilClickTick;
+
 
             if (timeSinceLastClick < Dictionary.AntiRecoilSettings["Fire Rate"])
             {
@@ -175,7 +178,7 @@ public static void DoAntiRecoil()
                     break;
             }
 
-            LastAntiRecoilClickTime = DateTime.UtcNow.Millisecond;
+            LastAntiRecoilClickTick = now;
         }
 
         public static void MoveCrosshair(int detectedX, int detectedY)

Aimmy2/InputLogic/MovementPaths.cs

@@ -25,41 +25,51 @@ internal static Point Lerp(Point start, Point end, double t)
             return new Point(x, y);
         }
 
+
         internal static Point Exponential(Point start, Point end, double t, double exponent = 2.0)
         {
-            double x = start.X + (end.X - start.X) * Math.Pow(t, exponent);
-            double y = start.Y + (end.Y - start.Y) * Math.Pow(t, exponent);
-            return new Point((int)x, (int)y);
+            double factor = Math.Pow(t, exponent);
+            double x = start.X + (end.X - start.X) * factor;
+            double y = start.Y + (end.Y - start.Y) * factor;
+            return new Point((int) x, (int) y);
         }
 
         internal static Point Adaptive(Point start, Point end, double t, double threshold = 100.0)
         {
-            double distance = Math.Sqrt(Math.Pow(end.X - start.X, 2) + Math.Pow(end.Y - start.Y, 2));
-            if (distance < threshold)
+            int dx = end.X - start.X;
+            int dy = end.Y - start.Y;
+            double distanceSq = dx * dx + dy * dy;
+
+            //double distance = Math.Sqrt(Math.Pow(end.X - start.X, 2) + Math.Pow(end.Y - start.Y, 2));
+            if (distanceSq < threshold * threshold)
             {
                 return Lerp(start, end, t);
             }
             else
             {
-                Point control1 = new Point(start.X + (end.X - start.X) / 3, start.Y + (end.Y - start.Y) / 3);
-                Point control2 = new Point(start.X + 2 * (end.X - start.X) / 3, start.Y + 2 * (end.Y - start.Y) / 3);
+                Point control1 = new Point(start.X + dx / 3, start.Y + dy / 3);
+                Point control2 = new Point(start.X + 2 * dx / 3, start.Y + 2 * dy / 3);
+
                 return CubicBezier(start, end, control1, control2, t);
             }
         }
 
         internal static Point PerlinNoise(Point start, Point end, double t, double amplitude = 10.0, double frequency = 0.1)
         {
-            double baseX = start.X + (end.X - start.X) * t;
-            double baseY = start.Y + (end.Y - start.Y) * t;
+            double dx = end.X - start.X;
+            double dy = end.Y - start.Y;
+
+            double baseX = start.X + dx * t;
+            double baseY = start.Y + dy * t;
 
             double noiseX = Noise(t * frequency, 0) * amplitude;
             double noiseY = Noise(t * frequency, 100) * amplitude;
 
-            double perpX = -(end.Y - start.Y);
-            double perpY = end.X - start.X;
+            double perpX = -dy;
+            double perpY = dx;
             double perpLength = Math.Sqrt(perpX * perpX + perpY * perpY);
 
-            if (perpLength > 0)
+            if (perpLength > 1e-6)
             {
                 perpX /= perpLength;
                 perpY /= perpLength;
@@ -71,15 +81,9 @@ internal static Point PerlinNoise(Point start, Point end, double t, double ampli
             return new Point((int)finalX, (int)finalY);
         }
 
-        private static double Fade(double t)
-        {
-            return t * t * t * (t * (t * 6 - 15) + 10);
-        }
+        private static double Fade(double t) => t * t * t * (t * (t * 6 - 15) + 10);
 
-        private static double Lerp(double a, double b, double t)
-        {
-            return a + t * (b - a);
-        }
+        private static double Lerp(double a, double b, double t) => a + t * (b - a);
 
         private static double Grad(int hash, double x, double y)
         {