Vector2I

public Vector2I(int x, int y);

Stores x and y without rounding, normalization or clamping. Each component is int; default(Vector2I) is (0, 0). This is a struct: assignment copies the value.

public static Vector2I Down { get; }

(0, 1). Down in 2D: positive Y. Returns a value copy: changing a local copy does not change the constant.

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

Index 0 reads or writes X; index 1 reads or writes Y. Any other index throws ArgumentOutOfRangeException in both getter and setter. Mutates this struct variable; a previously assigned copy remains unchanged.

public static Vector2I Left { get; }

(-1, 0). Negative X. Returns a value copy: changing a local copy does not change the constant.

public static Vector2I MaxValue { get; }

(int.MaxValue, int.MaxValue). Finite maximum ints, not infinity. Arithmetic using them can overflow. Returns a value copy: changing a local copy does not change the constant.

public static Vector2I MinValue { get; }

(int.MinValue, int.MinValue). Finite minimum ints, not negative infinity. Abs() on this value throws OverflowException. Returns a value copy: changing a local copy does not change the constant.

public static Vector2I One { get; }

(1, 1). Both components are one; this is not unit length. Returns a value copy: changing a local copy does not change the constant.

public static Vector2I Right { get; }

(1, 0). Positive X. Returns a value copy: changing a local copy does not change the constant.

public static Vector2I Up { get; }

(0, -1). Up in 2D: negative Y. Returns a value copy: changing a local copy does not change the constant.

public static Vector2I Zero { get; }

(0, 0). Zero vector, equal to default(Vector2I). Returns a value copy: changing a local copy does not change the constant.

public Vector2I Abs();

Returns a new struct with Math.Abs applied to each component, leaving the source unchanged. int.MinValue has no positive int counterpart and throws OverflowException.

public float Aspect();

Divides X by Y as float, not as integer division. (3, 2) gives 1.5. Y == 0 produces signed Infinity, or NaN for (0, 0), rather than DivideByZeroException. Large int values lose precision when converted to float.

public Vector2I Clamp(Vector2I min, Vector2I max);

Returns a copy with components clamped to inclusive bounds. Each axis has its own min and max. Throws ArgumentException if any lower bound exceeds its upper bound; bounds are not swapped.

public Vector2I Clamp(int min, int max);

Returns a copy with components clamped to inclusive bounds. The same min and max apply to both axes. Throws ArgumentException if any lower bound exceeds its upper bound; bounds are not swapped.

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

Copies X and Y into the output arguments, enabling var (x, y) = vector. Leaves the vector unchanged.

public int DistanceSquaredTo(Vector2I to);

Computes (to - this).LengthSquared() using int. Overflow can occur in subtraction and then in squaring or addition; the result can be negative or misleadingly small. Do not use for large coordinates without range checks. For a wide range, convert components to double before subtraction; see the DistanceTo example.

public float DistanceTo(Vector2I to);

Computes (to - this).Length(). A float return type does not prevent int overflow during subtraction or squaring. Between (int.MinValue, 0) and (int.MaxValue, 0), the current SDK returns 1 instead of 4294967295.

WideDistance converts components to double before subtraction. CellAt uses Floor: position (-1, 33) with cell size 16 gives (-1, 2). A plain Vector2I cast truncates toward zero and is unsuitable for negative cell coordinates.

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

Compares X and Y exactly. Does not compare approximately or compare lengths.

public override bool Equals(object? obj);

Compares X and Y exactly. The object must contain a Vector2I: Vector2 with matching coordinates, null and other types return false.

public override int GetHashCode();

Uses HashCode.Combine(X, Y). Equal vectors have equal hashes, but a matching hash does not prove equality. Suitable for Dictionary<Vector2I, T> keys; do not persist the hash as an identifier across runs.

public float Length();

Computes XX and YY and their sum as int before taking a float square root. (3, -4) yields 5. In the current SDK, (50000, 0) yields NaN and (65536, 0) yields 0 due to overflow. For a wide range, use Math.Sqrt((double)X * X + (double)Y * Y).

public int LengthSquared();

Computes XX + YY as int without a square root. Both squaring and addition can overflow: (50000, 0) yields a negative result and (65536, 0) yields 0. This is not a safe Length alternative for arbitrary ints. For a wide range, promote operands to double before multiplication.

public Vector2I Max(Vector2I with);

Larger values are selected separately for X and Y, returning a copy. The argument supplies per-axis values. This does not select an entire vector using < or > ordering.

public Vector2I Max(int with);

Larger values are selected separately for X and Y, returning a copy. One value is compared with both components. This does not select an entire vector using < or > ordering.

public Vector2I.Axis MaxAxisIndex();

Selects the axis of the larger signed component, not the larger magnitude. Returns Axis.X when X == Y. For example, (-9, 2) yields Axis.Y.

public Vector2I Min(Vector2I with);

Smaller values are selected separately for X and Y, returning a copy. The argument supplies per-axis values. This does not select an entire vector using < or > ordering.

public Vector2I Min(int with);

Smaller values are selected separately for X and Y, returning a copy. One value is compared with both components. This does not select an entire vector using < or > ordering.

public Vector2I.Axis MinAxisIndex();

Selects the axis of the smaller signed component, not the smaller magnitude. Returns Axis.Y when X == Y. For example, (-9, 2) yields Axis.X.

public Vector2I Sign();

Returns a new struct with each negative component replaced by -1, zero by 0 and each positive component by 1. int.MinValue yields -1 without taking its absolute value. This does not normalize length: (1, 1) stays (1, 1).

public Vector2I Snapped(Vector2I step);

Snaps each component using the double formula floor(value / step + 0.5) * step, then casts to int. A positive step rounds half ties toward the larger value: (6, -6).Snapped(4) gives (8, -4). A zero step preserves the component; a negative step changes half ties, so use a positive step. The result must fit int; range clamping is not performed.

public Vector2I Snapped(int step);

Snaps each component using the double formula floor(value / step + 0.5) * step, then casts to int. A positive step rounds half ties toward the larger value: (6, -6).Snapped(4) gives (8, -4). A zero step preserves the component; a negative step changes half ties, so use a positive step. The result must fit int; range clamping is not performed.

public override string ToString();

Returns "(X, Y)" using CultureInfo.InvariantCulture regardless of the current culture. Equivalent to ToString(null).

public string ToString(string? format);

Returns "(X, Y)" using CultureInfo.InvariantCulture regardless of the current culture. Applies format to each int separately: (3, -4) with "D4" yields "(0003, -0004)". Invalid formatting throws FormatException.

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

Returns (left.X + right.X, left.Y + right.Y) as a new struct. In the installed SDK, int overflow wraps without saturation; checked around the call does not change the compiled operator. Negating int.MinValue leaves int.MinValue.

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

Divides each integer component, truncating toward zero: (-7, 7) / 2 gives (-3, 3). A zero divisor throws DivideByZeroException. A component containing int.MinValue with divisor -1 throws OverflowException in the installed SDK. Divisors are supplied per axis.

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

Divides each integer component, truncating toward zero: (-7, 7) / 2 gives (-3, 3). A zero divisor throws DivideByZeroException. A component containing int.MinValue with divisor -1 throws OverflowException in the installed SDK. One divisor applies to both axes.

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

Compares both integer components exactly. Does not compare lengths or use approximate tolerance.

public static explicit operator Vector2I(Vector2 value);

Casts Vector2 components to int by truncating fractions toward zero: (-1.9, 1.9) gives (-1, 1), not (-2, 1). For cells with negative coordinates, use Floor first. Check finiteness and int range before casting; do not rely on portable results for NaN, Infinity or out-of-range values.

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

Lexicographic comparison: X first, then Y when X matches. This is neither a component-wise bounds test nor a length comparison. For example, (1, 100) < (2, -100) is true. For rectangular bounds, compare axes explicitly or use Rect2I.HasPoint.

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

Lexicographic comparison: X first, then Y when X matches. This is neither a component-wise bounds test nor a length comparison. For example, (1, 100) < (2, -100) is true. For rectangular bounds, compare axes explicitly or use Rect2I.HasPoint.

public static implicit operator Vector2(Vector2I value);

Converts each int component to the installed SDK’s float Vector2 component. Large integers can lose precision: 16777217 becomes 16777216. Keep Vector2I for exact grid arithmetic until the presentation step.

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

Negates ==. Does not compare lengths or use approximate tolerance.

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

Lexicographic comparison: X first, then Y when X matches. This is neither a component-wise bounds test nor a length comparison. For example, (1, 100) < (2, -100) is true. For rectangular bounds, compare axes explicitly or use Rect2I.HasPoint.

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

Lexicographic comparison: X first, then Y when X matches. This is neither a component-wise bounds test nor a length comparison. For example, (1, 100) < (2, -100) is true. For rectangular bounds, compare axes explicitly or use Rect2I.HasPoint.

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

Computes C# remainders from truncated division: (10, -20) % 7 gives (3, -6). This is not positive cyclic wrapping; use Mathf.PosMod with a positive modulus for that. A zero divisor throws DivideByZeroException. A component containing int.MinValue with divisor -1 throws OverflowException in the installed SDK. Divisors are supplied per axis.

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

Computes C# remainders from truncated division: (10, -20) % 7 gives (3, -6). This is not positive cyclic wrapping; use Mathf.PosMod with a positive modulus for that. A zero divisor throws DivideByZeroException. A component containing int.MinValue with divisor -1 throws OverflowException in the installed SDK. One divisor applies to both axes.

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

Returns (left.X * right.X, left.Y * right.Y) as a new struct. An int scales both axes; two vectors multiply component-wise, not as a dot product. In the installed SDK, int overflow wraps without saturation; checked around the call does not change the compiled operator. Negating int.MinValue leaves int.MinValue.

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

Returns (vec.X * scale, vec.Y * scale) as a new struct. An int scales both axes; two vectors multiply component-wise, not as a dot product. In the installed SDK, int overflow wraps without saturation; checked around the call does not change the compiled operator. Negating int.MinValue leaves int.MinValue.

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

Returns (vec.X * scale, vec.Y * scale) as a new struct. An int scales both axes; two vectors multiply component-wise, not as a dot product. In the installed SDK, int overflow wraps without saturation; checked around the call does not change the compiled operator. Negating int.MinValue leaves int.MinValue.

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

Returns (left.X - right.X, left.Y - right.Y) as a new struct. In the installed SDK, int overflow wraps without saturation; checked around the call does not change the compiled operator. Negating int.MinValue leaves int.MinValue.

public static Vector2I operator -(Vector2I vec);

Returns (-X, -Y) as a new struct. In the installed SDK, int overflow wraps without saturation; checked around the call does not change the compiled operator. Negating int.MinValue leaves int.MinValue.

public static Vector2I operator +(Vector2I vec);

Returns (X, Y) as a new struct. Unary plus leaves the value unchanged.

public int X;

Mutable signed 32-bit X component, also accessible through [0]. Assignment does not clamp the coordinate or change Y.

public int Y;

Mutable signed 32-bit Y component, also accessible through [1]. In conventional 2D screen coordinates, positive Y points down.