Update: Update PearlCalculatorLib.PearlCalculationLib to latest version

whats2000 · Aug 30, 2024 · df8745e · df8745e
1 parent 8ce11da
commit df8745e
Show file tree

Hide file tree

Showing 19 changed files with 501 additions and 378 deletions.
diff --git a/Components/GeneralFTLComponents/GeneralFTL_General.razor.cs b/Components/GeneralFTLComponents/GeneralFTL_General.razor.cs
@@ -91,7 +91,7 @@ protected override void OnInitialized()
         {
             EventManager.Instance.AddListener<SetRTCountArgs>("tntAmountSetRTCount", (sender, args) =>
             {
-                Direction = Data.Pearl.Position.Direction(Data.Pearl.Position.WorldAngle(Data.Destination));
+                Direction = DirectionUtils.GetDirection(Data.Pearl.Position.WorldAngle(Data.Destination));
                 RedTNT = (uint)args.Red;
                 BlueTNT = (uint)args.Blue;
                 StateHasChanged();

diff --git a/Components/ResultView.razor.cs b/Components/ResultView.razor.cs
@@ -46,7 +46,7 @@ public static void ShowDirectionResult(Space3D pearlPos, Space3D destination)
             if (angle == 370)
                 return;
 
-            ResultDirection = pearlPos.Direction(angle).ToString();
+            ResultDirection = DirectionUtils.GetDirection(angle).ToString();
 
             ResultAngle = angle.ToString();
         }

diff --git a/PearlCalculatorLib/General/Calculation.cs b/PearlCalculatorLib/General/Calculation.cs
diff --git a/PearlCalculatorLib/General/Data.cs b/PearlCalculatorLib/General/Data.cs
@@ -1,8 +1,5 @@
 using System.Collections.Generic;
-using System.Text;
-using PearlCalculatorLib.PearlCalculationLib.MathLib;
 using PearlCalculatorLib.Result;
-using PearlCalculatorLib.PearlCalculationLib;
 using PearlCalculatorLib.PearlCalculationLib.World;
 using PearlCalculatorLib.PearlCalculationLib.Entity;
 
@@ -54,7 +51,7 @@ public static class Data
         /// <para>Note : X and Z should be the gobal coordinate of the lava pool center</para>
         /// <para>Required for All Calculation in <see cref="Calculation"/></para>
         /// </summary>
-        public static PearlEntity Pearl = new PearlEntity().WithPosition(0 , 170.34722638929412, 0).WithVector(0 , 0.2716278719434352 , 0);
+        public static PearlEntity Pearl = new PearlEntity().WithPosition(0 , 170.34722638929412, 0).WithMotion(0 , 0.2716278719434352 , 0);
 
 
 

diff --git a/PearlCalculatorLib/PearlCalculationLib/AABB/AABBBox.cs b/PearlCalculatorLib/PearlCalculationLib/AABB/AABBBox.cs
@@ -0,0 +1,84 @@
+using System;
+using PearlCalculatorLib.PearlCalculationLib.MathLib;
+using PearlCalculatorLib.PearlCalculationLib.World;
+
+namespace PearlCalculatorLib.PearlCalculationLib.AABB
+{
+    [Serializable]
+    public class AABBBox : IEquatable<AABBBox>
+    {
+        public Space3D Min;
+        public Space3D Max;
+
+        public Space3D Extents => Max - Min;
+
+        public Space3D Center => (Min + Max) * 0.5;
+
+        public AABBBox()
+        {
+
+        }
+
+        public AABBBox(double x2 , double y2 , double z2)
+        {
+            Min = Space3D.Zero;
+            Max = new Space3D(x2 , y2 , z2);
+        }
+
+        public AABBBox(double x1 , double y1 , double z1 , double x2 , double y2 , double z2)
+        {
+            Min = new Space3D(x1 , y1 , z1);
+            Max = new Space3D(x2 , y2 , z2);
+        }
+
+        public AABBBox(Space3D min , Space3D max)
+        {
+            Min = min;
+            Max = max;
+        }
+
+        public AABBBox(Space3D max) : this(Space3D.Zero , max) { }
+
+        public AABBBox ReSize(Space3D min , Space3D max)
+        {
+            Min = min;
+            Max = max;
+            return this;
+        }
+
+        public bool Contains(Space3D point)
+        {
+            return MathHelper.IsInside(Min.X , Max.X , point.X) &&
+                MathHelper.IsInside(Min.Y , Max.Y , point.Y) &&
+                MathHelper.IsInside(Min.Z , Max.Z , point.Z);
+        }
+
+        public bool Intersects(AABBBox bounds)
+        {
+            return Equals(bounds) || (
+                Max.X >= bounds.Min.X &&
+                Max.Y >= bounds.Min.Y &&
+                Max.Z >= bounds.Min.Z &&
+                Min.X <= bounds.Max.X &&
+                Min.Y <= bounds.Max.Y &&
+                Min.Z <= bounds.Max.Z);
+        }
+
+        public override bool Equals(object obj) => obj is AABBBox s && Equals(s);
+
+        public bool Equals(AABBBox other)
+        {
+            if(other is null)
+                return false;
+            if(ReferenceEquals(this , other))
+                return true;
+            return Min == other.Min && Max == other.Max;
+        }
+
+        public static bool operator ==(AABBBox left , AABBBox right) => left is { } && left.Equals(right);
+
+        public static bool operator !=(AABBBox left , AABBBox right) => left is { } && !left.Equals(right);
+
+        public override int GetHashCode() => Min.GetHashCode() ^ Max.GetHashCode();
+    }
+}
diff --git a/PearlCalculatorLib/PearlCalculationLib/Entity/Entity.cs b/PearlCalculatorLib/PearlCalculationLib/Entity/Entity.cs
@@ -1,8 +1,6 @@
-using PearlCalculatorLib.PearlCalculationLib.MathLib;
-using PearlCalculatorLib.PearlCalculationLib.World;
+using PearlCalculatorLib.PearlCalculationLib.World;
+using PearlCalculatorLib.PearlCalculationLib.AABB;
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace PearlCalculatorLib.PearlCalculationLib.Entity
 {
@@ -11,9 +9,45 @@ public abstract class Entity
     {
         public Space3D Motion;
         public Space3D Position;
+        private AABBBox _aabb = new AABBBox();
+
+        public abstract void Tick();
 
         public abstract Space3D Size { get; }
 
-        public abstract void Tick();
+        public virtual AABBBox AABB => _aabb.ReSize(Position, Position + Size);
+    }
+
+    public static class EntityExtension
+    {
+        public static T WithPosition<T>(this T entity, double x, double y, double z) where T : Entity
+        {
+            entity.Position = new Space3D(x, y, z);
+            return entity;
+        }
+
+        public static T WithMotion<T>(this T entity, double x, double y, double z) where T : Entity
+        {
+            entity.Motion = new Space3D(x, y, z);
+            return entity;
+        }
+
+        public static T AddPosition<T>(this T entity, Space3D postion) where T : Entity
+        {
+            entity.Position += postion;
+            return entity;
+        }
+
+        public static T AddPosition<T>(this T entity, Surface2D postion) where T : Entity
+        {
+            entity.Position += postion.ToSpace3D();
+            return entity;
+        }
+
+        public static T AddMotion<T>(this T entity, Space3D motion) where T : Entity
+        {
+            entity.Motion += motion;
+            return entity;
+        }
     }
 }
diff --git a/PearlCalculatorLib/PearlCalculationLib/Entity/PearlEntity.cs b/PearlCalculatorLib/PearlCalculationLib/Entity/PearlEntity.cs
@@ -1,58 +1,39 @@
-using PearlCalculatorLib.PearlCalculationLib.MathLib;
-using PearlCalculatorLib.PearlCalculationLib.World;
+using PearlCalculatorLib.PearlCalculationLib.World;
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace PearlCalculatorLib.PearlCalculationLib.Entity
 {
     [Serializable]
-    public class PearlEntity : Entity, ICloneable
+    public class PearlEntity : Entity, IDeepCloneable<PearlEntity>
     {
-        public override Space3D Size => new Space3D(0.25 , 0.25 , 0.25);
+        public override Space3D Size => new Space3D(0.25, 0.25, 0.25);
 
-
-
-        public PearlEntity(Space3D momemtum , Space3D position)
+        public PearlEntity(Space3D momemtum, Space3D position)
         {
             Motion = momemtum;
             Position = position;
         }
 
-        public PearlEntity(PearlEntity pearl) : this(pearl.Motion , pearl.Position) { }
+        public PearlEntity(PearlEntity pearl) : this(pearl.Motion, pearl.Position) { }
 
         public PearlEntity()
         {
 
         }
 
-        public PearlEntity WithPosition(double x , double y , double z)
-        {
-            Position = new Space3D(x , y , z);
-            return this;
-        }
-
-        public PearlEntity WithVector(double x , double y , double z)
-        {
-            Motion = new Space3D(x , y , z);
-            return this;
-        }
-
         public override void Tick()
         {
             Position += Motion;
             Motion *= 0.99;
             Motion.Y -= 0.03;
         }
 
-        public object Clone()
+        public PearlEntity DeepClone() => new PearlEntity
         {
-            PearlEntity pearl = new PearlEntity
-            {
-                Position = Position ,
-                Motion = Motion
-            };
-            return pearl;
-        }
+            Position = Position,
+            Motion = Motion
+        };
+
+        object IDeepCloneable.DeepClone() => DeepClone();
     }
 }
diff --git a/PearlCalculatorLib/PearlCalculationLib/Entity/TNTEntity.cs b/PearlCalculatorLib/PearlCalculationLib/Entity/TNTEntity.cs
@@ -1,15 +1,12 @@
-using PearlCalculatorLib.PearlCalculationLib.MathLib;
-using PearlCalculatorLib.PearlCalculationLib.World;
+using PearlCalculatorLib.PearlCalculationLib.World;
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace PearlCalculatorLib.PearlCalculationLib.Entity
 {
     [Serializable]
     public class TNTEntity : Entity
     {
-        public override Space3D Size => new Space3D(0.98 , 0.98 , 0.98);
+        public override Space3D Size => new Space3D(0.98, 0.98, 0.98);
 
         public override void Tick() => throw new NotImplementedException();
     }

diff --git a/PearlCalculatorLib/PearlCalculationLib/IDeepCloneable.cs b/PearlCalculatorLib/PearlCalculationLib/IDeepCloneable.cs
@@ -0,0 +1,12 @@
+namespace PearlCalculatorLib.PearlCalculationLib
+{
+    public interface IDeepCloneable
+    {
+        object DeepClone();
+    }
+
+    public interface IDeepCloneable<T> : IDeepCloneable
+    {
+        new T DeepClone();
+    }
+}
diff --git a/PearlCalculatorLib/PearlCalculationLib/MathLib/MathHelper.cs b/PearlCalculatorLib/PearlCalculationLib/MathLib/MathHelper.cs
@@ -1,11 +1,11 @@
 using System;
-using System.Collections.Generic;
-using System.Numerics;
-using System.Security.Cryptography.X509Certificates;
-using System.Text;
 
 namespace PearlCalculatorLib.PearlCalculationLib.MathLib
 {
+    /// <summary>
+    /// Ask Mojang for it's weird API
+    /// <para>I have No clue about it</para>
+    /// </summary>
     public static class MathHelper
     {
         public static float Sqrt(double value) => (float)Math.Sqrt(value);
@@ -14,9 +14,9 @@ public static class MathHelper
 
         public static double RadiantToDegree(double radiant) => radiant * 180 / Math.PI;
 
-        public static bool IsInside(double border1 , double border2 , double num)
+        public static bool IsInside(double border1, double border2, double num)
         {
-            return num <= Math.Max(border1 , border2) && num >= Math.Min(border1 , border2);
+            return num <= Math.Max(border1, border2) && num >= Math.Min(border1, border2);
         }
     }
 }
diff --git a/PearlCalculatorLib/PearlCalculationLib/Result/TNTCalculationResult.cs b/PearlCalculatorLib/PearlCalculationLib/Result/TNTCalculationResult.cs
@@ -1,9 +1,5 @@
 using PearlCalculatorLib.PearlCalculationLib.Entity;
-using PearlCalculatorLib.PearlCalculationLib.MathLib;
-using PearlCalculatorLib.PearlCalculationLib.World;
-using System;
 using System.Collections.Generic;
-using System.Text;
 
 namespace PearlCalculatorLib.Result
 {
@@ -21,7 +17,7 @@ public struct TNTCalculationResult
 
     public static class TNTCalculationResultExtension
     {
-        public static void SortByWeightedDistance(this List<TNTCalculationResult> results , TNTResultSortByWeightedArgs args)
+        public static void SortByWeightedDistance(this List<TNTCalculationResult> results, TNTResultSortByWeightedArgs args)
         {
             results.Sort(new TNTCalculationResultSortComparerByWeighted(args).ByDistance);
         }
@@ -41,10 +37,9 @@ public static void SortByTotal(this List<TNTCalculationResult> results)
             results.Sort(TNTCalculationResultSortComparer.ByTotal);
         }
 
-        public static void SortByWeightedTotal(this List<TNTCalculationResult> results , TNTResultSortByWeightedArgs args)
+        public static void SortByWeightedTotal(this List<TNTCalculationResult> results, TNTResultSortByWeightedArgs args)
         {
             results.Sort(new TNTCalculationResultSortComparerByWeighted(args).ByTotal);
         }
-
     }
 }
diff --git a/PearlCalculatorLib/PearlCalculationLib/Result/TNTCalculationResultSortComparer.cs b/PearlCalculatorLib/PearlCalculationLib/Result/TNTCalculationResultSortComparer.cs
@@ -1,34 +1,30 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace PearlCalculatorLib.Result
+namespace PearlCalculatorLib.Result
 {
     static class TNTCalculationResultSortComparer
     {
-        public static int ByTick(TNTCalculationResult r1 , TNTCalculationResult r2)
+        public static int ByTick(TNTCalculationResult r1, TNTCalculationResult r2)
         {
-            if(r1.Tick < r2.Tick)
+            if (r1.Tick < r2.Tick)
                 return -1;
-            else if(r1.Tick > r2.Tick)
+            else if (r1.Tick > r2.Tick)
                 return 1;
-            return ByDefault(r1 , r2);
+            return ByDefault(r1, r2);
         }
 
-        public static int ByTotal(TNTCalculationResult r1 , TNTCalculationResult r2)
+        public static int ByTotal(TNTCalculationResult r1, TNTCalculationResult r2)
         {
-            if(r1.TotalTNT < r2.TotalTNT)
+            if (r1.TotalTNT < r2.TotalTNT)
                 return -1;
-            else if(r1.TotalTNT > r2.TotalTNT)
+            else if (r1.TotalTNT > r2.TotalTNT)
                 return 1;
-            return ByDefault(r1 , r2);
+            return ByDefault(r1, r2);
         }
 
-        public static int ByDefault(TNTCalculationResult r1 , TNTCalculationResult r2)
+        public static int ByDefault(TNTCalculationResult r1, TNTCalculationResult r2)
         {
-            if(r1.Distance < r2.Distance)
+            if (r1.Distance < r2.Distance)
                 return -1;
-            else if(r1.Distance > r2.Distance)
+            else if (r1.Distance > r2.Distance)
                 return 1;
             return 0;
         }