Source/Scripting/AngelScript/CoreScripts/Math.fos - master - Mr.Stalin/FOnline-Engine

Source/Scripting/AngelScript/CoreScripts/Math.fos
205 строк4 KB
cvet
Add AngleDelta and AngleBisect functions for angle calculations
19 июл 2026, 17:16
19 июл 2026, 17:166307c71
namespace Math
{

int Pow2(int x)
{
    return x * x;
}

float Pow2F(float x)
{
    return x * x;
}

int Pow3(int x)
{
    return x * x * x;
}

float Pow3F(float x)
{
    return x * x * x;
}

int Min(int x, int y)
{
    return x < y ? x : y;
}

float MinF(float x, float y)
{
    return x < y ? x : y;
}

int Max(int x, int y)
{
    return x > y ? x : y;
}

float MaxF(float x, float y)
{
    return x > y ? x : y;
}

int Clamp(int x, int min, int max)
{
    return x > max ? max : (x < min ? min : x);
}

float ClampF(float x, float min, float max)
{
    return x > max ? max : (x < min ? min : x);
}

int Abs(int x)
{
    return x > 0 ? x : -x;
}

float AbsF(float x)
{
    return x > 0 ? x : -x;
}

int Distance(int x, int y)
{
    return RoundToInt(math::sqrt(Pow2(x) + Pow2(y)));
}

int Distance(int x1, int y1, int x2, int y2)
{
    return RoundToInt(math::sqrt(Pow2(x1 - x2) + Pow2(y1 - y2)));
}

int Distance(ipos pos1, ipos pos2)
{
    return RoundToInt(math::sqrt(Pow2(pos1.x - pos2.x) + Pow2(pos1.y - pos2.y)));
}

float DistanceF(float x, float y)
{
    return float(math::sqrt(Pow2F(x) + Pow2F(y)));
}

float DistanceF(float x1, float y1, float x2, float y2)
{
    return float(math::sqrt(Pow2F(x1 - x2) + Pow2F(y1 - y2)));
}

float Distance(fpos pos1, fpos pos2)
{
    return RoundToInt(math::sqrt(Pow2F(pos1.x - pos2.x) + Pow2F(pos1.y - pos2.y)));
}

bool IsCollision(int x1, int y1, int x2, int y2, int w, int h)
{
    return x1 >= x2 && x1 < x2 + w && y1 >= y2 && y1 < y2 + h;
}

bool IsCollision(ipos pos1, ipos pos2, isize size)
{
    return pos1.x >= pos2.x && pos1.x < pos2.x + size.width && pos1.y >= pos2.y && pos1.y < pos2.y + size.height;
}

int LbsToGramm(int lbs)
{
    return lbs * 453;
}

int NumericalNumber(int num)
{
    return num % 2 != 0 ? num * num / 2 + 1 : num * num / 2 + num / 2;
}

int RoundToInt(float x)
{
    return math::fraction(x) >= 0.5f ? int(x) + 1 : int(x);
}

int Fib(int n)
{
    int x = 1;
    int y = 0;

    for (int i = 1; i < n; i++) {
        x += y;
        y = x - y;
    }

    return y;
}

int Lerp(int v1, int v2, float t)
{
    return (t <= 0.0) ? v1 : ((t >= 1.0) ? v2 : v1 + int((v2 - v1) * t));
}

float LerpF(float v1, float v2, float t)
{
    return (t <= 0.0) ? v1 : ((t >= 1.0) ? v2 : v1 + (v2 - v1) * t);
}

ipos Lerp(ipos v1, ipos v2, float t)
{
    return ipos(Lerp(v1.x, v2.x, t), Lerp(v1.y, v2.y, t));
}

fpos Lerp(fpos v1, fpos v2, float t)
{
    return fpos(LerpF(v1.x, v2.x, t), LerpF(v1.y, v2.y, t));
}

// Signed shortest difference between two directions in degrees, wrapped to [-180, 180]
float AngleDelta(float from, float to)
{
    float delta = to - from;

    while (delta > 180.0) {
        delta -= 360.0;
    }
    while (delta < -180.0) {
        delta += 360.0;
    }

    return delta;
}

// Middle of the smaller arc between two directions in degrees
float AngleBisect(float a, float b)
{
    return a + AngleDelta(a, b) * 0.5;
}

float MoveTowards(float current, float target, float step)
{
    float delta = target - current;

    if (math::abs(delta) <= step) {
        return target;
    }

    return current + (delta > 0 ? step : -step);
}

fpos MoveTowards(fpos v1, fpos v2, float step)
{
    float dx = v2.x - v1.x;
    float dy = v2.y - v1.y;
    float distance = math::sqrt(dx * dx + dy * dy);

    if (distance == 0 || step >= distance) {
        return v2;
    }
    else {
        return fpos(v1.x + (dx / distance) * step, v1.y + (dy / distance) * step);
    }
}

int DistanceToRect(ipos p, irect r)
{
    float dx = MaxF(MaxF(r.x - p.x, p.x - (r.x + r.width)), 0.0);
    float dy = MaxF(MaxF(r.y - p.y, p.y - (r.y + r.height)), 0.0);
    return RoundToInt(math::sqrt(dx * dx + dy * dy));
}

}