Vector2I

public Vector2I(int x, int y);

Записывает x и y без округления, нормализации или ограничения диапазона. Каждая компонента — int; default(Vector2I) имеет (0, 0). Это структура: присваивание копирует значение.

public static Vector2I Down { get; }

(0, 1). Вниз в 2D, то есть положительное направление Y. Возвращается копия значения: изменение локальной копии не меняет константу.

public int this[int index] { get; set; }

Индекс 0 читает или меняет X, индекс 1 — Y. Любой другой индекс в getter и setter выбрасывает ArgumentOutOfRangeException. Изменяется именно эта переменная структуры; ранее присвоенная копия не меняется.

public static Vector2I Left { get; }

(-1, 0). Отрицательное направление X. Возвращается копия значения: изменение локальной копии не меняет константу.

public static Vector2I MaxValue { get; }

(int.MaxValue, int.MaxValue). Конечные максимальные int, а не бесконечность. Арифметика с ними может переполниться. Возвращается копия значения: изменение локальной копии не меняет константу.

public static Vector2I MinValue { get; }

(int.MinValue, int.MinValue). Конечные минимальные int, а не отрицательная бесконечность. Abs() этого значения выбрасывает OverflowException. Возвращается копия значения: изменение локальной копии не меняет константу.

public static Vector2I One { get; }

(1, 1). Обе компоненты равны единице; это не единичная длина. Возвращается копия значения: изменение локальной копии не меняет константу.

public static Vector2I Right { get; }

(1, 0). Положительное направление X. Возвращается копия значения: изменение локальной копии не меняет константу.

public static Vector2I Up { get; }

(0, -1). Вверх в 2D, то есть отрицательное направление Y. Возвращается копия значения: изменение локальной копии не меняет константу.

public static Vector2I Zero { get; }

(0, 0). Нулевой вектор, равный default(Vector2I). Возвращается копия значения: изменение локальной копии не меняет константу.

public Vector2I Abs();

Возвращает новую структуру с Math.Abs для каждой компоненты; исходное значение не меняется. Для int.MinValue положительный результат не помещается в int, поэтому выбрасывается OverflowException.

public float Aspect();

Делит X на Y как float, не как целые числа. (3, 2) даёт 1.5. При Y == 0 получается Infinity с соответствующим знаком или NaN для (0, 0), а не DivideByZeroException. Для больших int преобразование во float теряет точность.

public Vector2I Clamp(Vector2I min, Vector2I max);

Возвращает копию с покомпонентным ограничением включительными границами. У каждой оси свои min и max. Если любая нижняя граница выше верхней, выбрасывается ArgumentException; границы не переставляются.

public Vector2I Clamp(int min, int max);

Возвращает копию с покомпонентным ограничением включительными границами. Одни min и max применяются к обеим осям. Если любая нижняя граница выше верхней, выбрасывается ArgumentException; границы не переставляются.

public void Deconstruct(out int x, out int y);

Копирует X и Y в выходные аргументы, позволяя записать var (x, y) = vector. Вектор не меняется.

public int DistanceSquaredTo(Vector2I to);

Вычисляет (to - this).LengthSquared() в int. Переполнение возможно уже при вычитании, затем при возведении в квадрат и сложении; результат может быть отрицательным или ошибочно малым. Не используйте для больших координат без проверки диапазона. Для широкого диапазона переводите компоненты в double до вычитания — пример приведён у DistanceTo.

public float DistanceTo(Vector2I to);

Вычисляет (to - this).Length(). Возврат float не защищает от переполнения int при вычитании и возведении в квадрат. Между (int.MinValue, 0) и (int.MaxValue, 0) текущий SDK возвращает 1 вместо 4294967295.

WideDistance переводит компоненты в double до вычитания. CellAt использует Floor: позиция (-1, 33) при размере клетки 16 даёт (-1, 2). Обычное приведение к Vector2I округляет к нулю и для отрицательных координат клетки не подходит.

using System;
using Reckfell;

public static class IntegerGridExamples
{
    public static Vector2I CellAt(Vector2 position, int cellSize)
    {
        if (cellSize <= 0) throw new ArgumentOutOfRangeException(nameof(cellSize));
        Vector2 cell = (position / cellSize).Floor();
        if (!cell.IsFinite() || (double)cell.X < int.MinValue || (double)cell.X > int.MaxValue
            || (double)cell.Y < int.MinValue || (double)cell.Y > int.MaxValue)
            throw new ArgumentOutOfRangeException(nameof(position));
        return (Vector2I)cell;
    }

    public static double WideDistance(Vector2I from, Vector2I to)
    {
        double dx = (double)to.X - from.X;
        double dy = (double)to.Y - from.Y;
        return Math.Sqrt(dx * dx + dy * dy);
    }
}

public bool Equals(Vector2I other);

Точно сравнивает X и Y. Приближённого сравнения и сравнения длин нет.

public override bool Equals(object? obj);

Точно сравнивает X и Y. object должен содержать Vector2I: Vector2 с теми же координатами, null и другие типы дают false.

public override int GetHashCode();

Использует HashCode.Combine(X, Y). Равные векторы имеют одинаковый хеш, но совпадение хеша не доказывает равенство. Подходит для ключей Dictionary<Vector2I, T>; не сохраняйте хеш как постоянный идентификатор между запусками.

public float Length();

Вычисляет XX и YY, затем их сумму в int, и только после этого извлекает float-корень. Для (3, -4) возвращает 5. Для (50000, 0) в текущем SDK результат NaN, а для (65536, 0) — 0 из-за переполнения. Для широкого диапазона используйте Math.Sqrt((double)X * X + (double)Y * Y).

public int LengthSquared();

Вычисляет XX + YY в int без корня. Квадрат и сумма могут переполниться: (50000, 0) даёт отрицательный результат, (65536, 0) — 0. Это не безопасная замена Length для любых int. Для широкого диапазона переводите операнды в double до умножения.

public Vector2I Max(Vector2I with);

Большая из двух величин выбирается отдельно для X и Y; возвращается копия. Аргумент задаёт отдельные значения по осям. Это не выбор одного целого вектора по операторам < или >.

public Vector2I Max(int with);

Большая из двух величин выбирается отдельно для X и Y; возвращается копия. Одно значение сравнивается с обеими компонентами. Это не выбор одного целого вектора по операторам < или >.

public Vector2I.Axis MaxAxisIndex();

Выбирает ось с большей знаковой компонентой, не с большей абсолютной величиной. При X == Y возвращает Axis.X. Например, (-9, 2) даёт Axis.Y.

public Vector2I Min(Vector2I with);

Меньшая из двух величин выбирается отдельно для X и Y; возвращается копия. Аргумент задаёт отдельные значения по осям. Это не выбор одного целого вектора по операторам < или >.

public Vector2I Min(int with);

Меньшая из двух величин выбирается отдельно для X и Y; возвращается копия. Одно значение сравнивается с обеими компонентами. Это не выбор одного целого вектора по операторам < или >.

public Vector2I.Axis MinAxisIndex();

Выбирает ось с меньшей знаковой компонентой, не с меньшей абсолютной величиной. При X == Y возвращает Axis.Y. Например, (-9, 2) даёт Axis.X.

public Vector2I Sign();

Возвращает новую структуру: отрицательная компонента становится -1, нулевая — 0, положительная — 1. int.MinValue даёт -1 без взятия абсолютной величины. Это не нормализация длины: (1, 1) остаётся (1, 1).

public Vector2I Snapped(Vector2I step);

Привязывает каждую компоненту к шагу через double-формулу floor(value / step + 0.5) * step с последующим приведением к int. Положительный шаг округляет половины к большему значению: (6, -6).Snapped(4) даёт (8, -4). Нулевой шаг сохраняет компоненту; отрицательный меняет правило половин, поэтому используйте положительный шаг. Результат должен помещаться в int; ограничение диапазона не выполняется.

public Vector2I Snapped(int step);

Привязывает каждую компоненту к шагу через double-формулу floor(value / step + 0.5) * step с последующим приведением к int. Положительный шаг округляет половины к большему значению: (6, -6).Snapped(4) даёт (8, -4). Нулевой шаг сохраняет компоненту; отрицательный меняет правило половин, поэтому используйте положительный шаг. Результат должен помещаться в int; ограничение диапазона не выполняется.

public override string ToString();

Возвращает "(X, Y)" с CultureInfo.InvariantCulture независимо от текущей культуры. Эквивалентно ToString(null).

public string ToString(string? format);

Возвращает "(X, Y)" с CultureInfo.InvariantCulture независимо от текущей культуры. format применяется отдельно к каждому int: (3, -4) с "D4" даёт "(0003, -0004)". Неверный формат вызывает FormatException.

public static Vector2I operator +(Vector2I left, Vector2I right);

Возвращает (left.X + right.X, left.Y + right.Y) как новую структуру. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор. Для -int.MinValue остаётся int.MinValue.

public static Vector2I operator /(Vector2I vec, Vector2I divisorv);

Целочисленно делит каждую компоненту с усечением к нулю: (-7, 7) / 2 даёт (-3, 3). Нулевой делитель вызывает DivideByZeroException. Сочетание int.MinValue и -1 для соответствующей компоненты в установленном SDK вызывает OverflowException. Делители заданы отдельно по осям.

public static Vector2I operator /(Vector2I vec, int divisor);

Целочисленно делит каждую компоненту с усечением к нулю: (-7, 7) / 2 даёт (-3, 3). Нулевой делитель вызывает DivideByZeroException. Сочетание int.MinValue и -1 для соответствующей компоненты в установленном SDK вызывает OverflowException. Один делитель применяется к обеим осям.

public static bool operator ==(Vector2I left, Vector2I right);

Точно сравнивает обе целочисленные компоненты. Значения не сравниваются по длине; приближённый допуск не используется.

public static explicit operator Vector2I(Vector2 value);

Приводит компоненты Vector2 к int с усечением дробной части к нулю: (-1.9, 1.9) даёт (-1, 1), а не (-2, 1). Для клеток с отрицательными координатами сначала используйте Floor. До приведения проверьте конечность и диапазон int; не рассчитывайте на переносимый результат для NaN, Infinity или значений вне диапазона.

public static bool operator >(Vector2I left, Vector2I right);

Лексикографическое сравнение: сначала X, при равенстве X — Y. Это не покомпонентная проверка границ и не сравнение длин. Например, (1, 100) < (2, -100) — true. Для проверки прямоугольной области сравнивайте оси явно или используйте Rect2I.HasPoint.

public static bool operator >=(Vector2I left, Vector2I right);

Лексикографическое сравнение: сначала X, при равенстве X — Y. Это не покомпонентная проверка границ и не сравнение длин. Например, (1, 100) < (2, -100) — true. Для проверки прямоугольной области сравнивайте оси явно или используйте Rect2I.HasPoint.

public static implicit operator Vector2(Vector2I value);

Преобразует каждую int-компоненту во float-компоненту Vector2 установленного SDK. Большие целые могут потерять точность: 16777217 превращается в 16777216. Для точной арифметики сетки сохраняйте Vector2I до этапа отображения.

public static bool operator !=(Vector2I left, Vector2I right);

Отрицает ==. Значения не сравниваются по длине; приближённый допуск не используется.

public static bool operator <(Vector2I left, Vector2I right);

Лексикографическое сравнение: сначала X, при равенстве X — Y. Это не покомпонентная проверка границ и не сравнение длин. Например, (1, 100) < (2, -100) — true. Для проверки прямоугольной области сравнивайте оси явно или используйте Rect2I.HasPoint.

public static bool operator <=(Vector2I left, Vector2I right);

Лексикографическое сравнение: сначала X, при равенстве X — Y. Это не покомпонентная проверка границ и не сравнение длин. Например, (1, 100) < (2, -100) — true. Для проверки прямоугольной области сравнивайте оси явно или используйте Rect2I.HasPoint.

public static Vector2I operator %(Vector2I vec, Vector2I divisorv);

Вычисляет остатки C# от усечённого деления: (10, -20) % 7 даёт (3, -6). Это не положительное циклическое оборачивание; для него используйте Mathf.PosMod с положительным модулем. Нулевой делитель вызывает DivideByZeroException. Сочетание int.MinValue и -1 для соответствующей компоненты в установленном SDK вызывает OverflowException. Делители заданы отдельно по осям.

public static Vector2I operator %(Vector2I vec, int divisor);

Вычисляет остатки C# от усечённого деления: (10, -20) % 7 даёт (3, -6). Это не положительное циклическое оборачивание; для него используйте Mathf.PosMod с положительным модулем. Нулевой делитель вызывает DivideByZeroException. Сочетание int.MinValue и -1 для соответствующей компоненты в установленном SDK вызывает OverflowException. Один делитель применяется к обеим осям.

public static Vector2I operator *(Vector2I left, Vector2I right);

Возвращает (left.X * right.X, left.Y * right.Y) как новую структуру. Для int используется один множитель обеих осей; два вектора умножаются покомпонентно, не как скалярное произведение. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор. Для -int.MinValue остаётся int.MinValue.

public static Vector2I operator *(Vector2I vec, int scale);

Возвращает (vec.X * scale, vec.Y * scale) как новую структуру. Для int используется один множитель обеих осей; два вектора умножаются покомпонентно, не как скалярное произведение. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор. Для -int.MinValue остаётся int.MinValue.

public static Vector2I operator *(int scale, Vector2I vec);

Возвращает (vec.X * scale, vec.Y * scale) как новую структуру. Для int используется один множитель обеих осей; два вектора умножаются покомпонентно, не как скалярное произведение. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор. Для -int.MinValue остаётся int.MinValue.

public static Vector2I operator -(Vector2I left, Vector2I right);

Возвращает (left.X - right.X, left.Y - right.Y) как новую структуру. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор. Для -int.MinValue остаётся int.MinValue.

public static Vector2I operator -(Vector2I vec);

Возвращает (-X, -Y) как новую структуру. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор. Для -int.MinValue остаётся int.MinValue.

public static Vector2I operator +(Vector2I vec);

Возвращает (X, Y) как новую структуру. Унарный плюс не меняет значение.

public int X;

Изменяемая знаковая 32-битная компонента X, также доступная через [0]. Присваивание не ограничивает координату и не меняет Y.

public int Y;

Изменяемая знаковая 32-битная компонента Y, также доступная через [1]. В обычных 2D-координатах экрана положительное направление Y идёт вниз.