Add initial game code

scripts/Helpers.cs

@@ -0,0 +1,234 @@
+using System;
+
+public static partial class Helpers
+{
+    public static Random RNG = new Random();
+
+    public static bool GetChance(float percentage)
+    {
+        return RNG.NextSingle() < percentage / 100;
+    }
+
+    public static long GetRandomNumber(long min, long max)
+    {
+        return RNG.NextInt64(min, max);
+    }
+
+    public static double GetRandomNumber(double min, double max)
+    {
+        double diff = max - min;
+
+        return RNG.NextDouble() * diff + min;
+    }
+
+    public static decimal GetRandomNumber(decimal min, decimal max)
+    {
+        decimal diff = max - min;
+
+        return (decimal)RNG.NextDouble() * diff + min;
+    }
+
+    public static int[] GetDeconstructedDecimal(decimal value)
+    {
+        return decimal.GetBits(value);
+    }
+
+    public static decimal GetConstructedDecimal(int[] bits)
+    {
+        return new decimal(bits);
+    }
+
+    public static decimal GetCoordinateFromKM(decimal coordinate)
+    {
+        return coordinate * Constants.KM_M;
+    }
+
+    public static decimal GetCoordinateFromAU(decimal coordinate)
+    {
+        return coordinate * Constants.AU_M;
+    }
+
+    public static decimal GetCoordinateFromLY(decimal coordinate)
+    {
+        return coordinate * Constants.LY_M;
+    }
+
+    public static decimal GetCoordinateInKM(decimal coordinate)
+    {
+        return coordinate / Constants.KM_M;
+    }
+
+    public static decimal GetCoordinateInAU(decimal coordinate)
+    {
+        return coordinate / Constants.AU_M;
+    }
+
+    public static decimal GetCoordinateInLY(decimal coordinate)
+    {
+        return coordinate / Constants.LY_M;
+    }
+
+    public static decimal GetRandomCoordinate(decimal min, decimal max, decimal multiplier = 1)
+    {
+        decimal diff = max - min;
+
+        return GetRandomNumber(min, max) * multiplier;
+    }
+
+    public static decimal GetRandomCoordinateFromKM(decimal min, decimal max, decimal multiplier = 1)
+    {
+        return GetRandomCoordinate(min, max, multiplier * Constants.KM_M);
+    }
+
+    public static decimal GetRandomCoordinateFromAU(decimal min, decimal max, decimal multiplier = 1)
+    {
+        return GetRandomCoordinate(min, max, multiplier * Constants.AU_M);
+    }
+
+    public static decimal GetRandomCoordinateFromLY(decimal min, decimal max, decimal multiplier = 1)
+    {
+        return GetRandomCoordinate(min, max, multiplier * Constants.LY_M);
+    }
+
+    public static CoordinateVector GetRandomCoordinates(decimal minX, decimal maxX, decimal minY, decimal maxY, decimal multiplier = 1)
+    {
+        decimal diffX = maxX - minX;
+        decimal diffY = maxY - minY;
+
+        decimal coordinateX = GetRandomCoordinate(minX, maxX, multiplier);
+        decimal coordinateY = GetRandomCoordinate(minY, maxY, multiplier);
+
+        return new CoordinateVector(coordinateX, coordinateY);
+    }
+
+    public static CoordinateVector GetRandomCoordinatesFromKM(decimal minX, decimal maxX, decimal minY, decimal maxY, decimal multiplier = 1)
+    {
+        return GetRandomCoordinates(minX, maxX, minY, maxY, multiplier * Constants.KM_M);
+    }
+
+    public static CoordinateVector GetRandomCoordinatesFromAU(decimal minX, decimal maxX, decimal minY, decimal maxY, decimal multiplier = 1)
+    {
+        return GetRandomCoordinates(minX, maxX, minY, maxY, multiplier * Constants.AU_M);
+    }
+
+    public static CoordinateVector GetRandomCoordinatesFromLY(decimal minX, decimal maxX, decimal minY, decimal maxY, decimal multiplier = 1)
+    {
+        return GetRandomCoordinates(minX, maxX, minY, maxY, multiplier * Constants.LY_M);
+    }
+
+    public static double CalculateDistance(CoordinateVector coordinates1, CoordinateVector coordinates2)
+    {
+        CoordinateVector delta = CalculateDeltaCoordinates(coordinates1, coordinates2);
+
+        return Math.Sqrt(
+            Math.Pow((double)delta.X, 2) +
+            Math.Pow((double)delta.Y, 2)
+        );
+    }
+
+    public static double CalculateDistance(Structure structure1, Structure structure2)
+    {
+        return CalculateDistance(structure1.Position, structure2.Position);
+    }
+
+    public static CoordinateVector AddCoordinates(CoordinateVector coordinates1, CoordinateVector coordinates2)
+    {
+        return new CoordinateVector(coordinates1.X + coordinates2.X, coordinates1.Y + coordinates2.Y);
+    }
+
+    public static CoordinateVector SubtractCoordinates(CoordinateVector coordinates1, CoordinateVector coordinates2)
+    {
+        return new CoordinateVector(coordinates1.X - coordinates2.X, coordinates1.Y - coordinates2.Y);
+    }
+
+    public static CoordinateVector MultiplyCoordinates(CoordinateVector coordinates1, CoordinateVector coordinates2)
+    {
+        return new CoordinateVector(coordinates1.X * coordinates2.X, coordinates1.Y * coordinates2.Y);
+    }
+
+    public static CoordinateVector DivideCoordinates(CoordinateVector coordinates1, CoordinateVector coordinates2)
+    {
+        return new CoordinateVector(coordinates1.X / coordinates2.X, coordinates1.Y / coordinates2.Y);
+    }
+
+    public static bool CompareCoordinates(CoordinateVector coordinates1, CoordinateVector coordinates2)
+    {
+        if (coordinates1.X != coordinates2.X)
+        {
+            return false;
+        }
+        if (coordinates1.Y != coordinates2.Y)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    public static CoordinateVector CalculateDeltaCoordinates(CoordinateVector coordinates1, CoordinateVector coordinates2)
+    {
+        decimal diffX = Math.Abs(coordinates1.X - coordinates2.X);
+        decimal diffY = Math.Abs(coordinates1.Y - coordinates2.Y);
+
+        return new CoordinateVector(diffX, diffY);
+    }
+
+    public static CoordinateVector CalculateDeltaCoordinates(Structure structure, CoordinateVector coordinates)
+    {
+        return CalculateDeltaCoordinates(structure.Position, coordinates);
+    }
+
+    public static CoordinateVector CalculateNewCoordinates(CoordinateVector coordinates1, CoordinateVector coordinates2)
+    {
+        decimal diffX = coordinates1.X + coordinates2.X;
+        decimal diffY = coordinates1.Y + coordinates2.Y;
+
+        return new CoordinateVector(diffX, diffY);
+    }
+
+    public static CoordinateVector CalculateNewCoordinates(Structure structure, CoordinateVector deltaCoordinates)
+    {
+        return CalculateNewCoordinates(structure.Position, deltaCoordinates);
+    }
+
+    public static CoordinateVector CalculateMoveCoordinates(CoordinateVector startCoordinates, CoordinateVector endCoordinates, decimal speed)
+    {
+        decimal distance = (decimal)CalculateDistance(startCoordinates, endCoordinates);
+
+        if (speed >= distance)
+        {
+            return SubtractCoordinates(endCoordinates, startCoordinates);
+        }
+
+        CoordinateVector deltaCoordinates = CalculateDeltaCoordinates(startCoordinates, endCoordinates);
+
+        decimal fractionCrossed = speed / distance;
+
+        decimal moveCoordinateX = deltaCoordinates.X * fractionCrossed;
+        decimal moveCoordinateY = deltaCoordinates.Y * fractionCrossed;
+
+        return new CoordinateVector(moveCoordinateX, moveCoordinateY);
+    }
+
+    public static CoordinateVector CalculateMovedCoordinates(CoordinateVector startCoordinates, CoordinateVector endCoordinates, decimal speed)
+    {
+        CoordinateVector moveCoordinates = CalculateMoveCoordinates(startCoordinates, endCoordinates, speed);
+
+        return AddCoordinates(startCoordinates, moveCoordinates);
+    }
+
+    public static decimal GetLocalCoordinatesX(GameObject target)
+    {
+        return target.Position.X - target.Parent.Position.X;
+    }
+
+    public static decimal GetLocalCoordinatesY(GameObject target)
+    {
+        return target.Position.Y - target.Parent.Position.Y;
+    }
+
+    public static CoordinateVector GetLocalCoordinates(GameObject target)
+    {
+        return SubtractCoordinates(target.Position, target.Parent.Position);
+    }
+}