idle-starship/scripts/Helpers.cs

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);
    }
}