Math & Vectors

Mathematical utility functions for 2D game development

The mathematical constant pi

Linear interpolation between two values

Returns a value between a and b based on parameter t (0.0 to 1.0)

t=0 returns a, t=1 returns b, t=0.5 returns midpoint

Smooth damping interpolation using exponential decay

Useful for camera following and smooth movement - gives frame-rate independent smoothing

Higher lambda values = faster convergence (try values like 5.0 to 20.0)

Returns the minimum of two values

Returns the maximum of two values

Returns the arctangent of y/x in radians

Inverse linear interpolation - returns t such that lerp(a, b, t) = v

Remaps a value from one range to another

Converts degrees to radians

Converts radians to degrees

Modulo operation that always returns positive results

Floating-point modulo operation

Clamps a value between min (f) and max (t)

Spherical linear interpolation for angles

Vector spherical linear interpolation

Returns the shortest angular distance between two angles

Smooth damping for angles (spherical)

Quadratic Bezier curve interpolation

Cubic Bezier curve interpolation

Catmull-Rom spline interpolation

Utility functions for bitwise operations and bit flags

Turns on a specific bit flag

Turns off a specific bit flag

Checks if all bits in 'bit' are set in 'flags'

Checks if any bits overlap between two flags

2D vector class for position, velocity, and direction calculations

Supports standard vector operations: addition, subtraction, scaling, dot product, cross product, rotation

Creates a zero vector (0, 0)

Creates a vector with the given x and y components

Gets the x component

Gets the y component

Sets the x component

Sets the y component

Adds two vectors

Negates the vector

Subtracts two vectors

Multiplies vector by a scalar

Divides vector by a scalar

Checks if two vectors are equal

Checks if two vectors are not equal

Gets the length of the vector

Gets the squared length of the vector (faster than magnitude)

Returns a normalized copy of the vector (length = 1)

Normalizes this vector in place

Computes the dot product with another vector

Returns a scalar: positive if vectors point same direction, negative if opposite, 0 if perpendicular

Computes the 2D cross product (returns scalar)

Returns the z-component of the 3D cross product - useful for determining rotation direction

Rotates this vector by angle a (in radians) in place

Returns a rotated copy of this vector

Returns a perpendicular vector rotated 90 degrees counter-clockwise

Useful for calculating normals and perpendicular directions

Sets the vector to (0, 0)

Returns the angle of this vector in radians

Clamps this vector's components between min and max

Returns a string representation of this vector

Serializes the vector to a list

Creates a vector from serialized data

Computes the distance between two vectors

Computes the squared distance between two vectors (faster than distance)

Returns a random unit direction vector

Reflects an incident vector off a surface with the given normal vector

The normal should be normalized (unit length) for correct results

Projects vector a onto vector b

Geometric utility functions

Computes the distance from a line segment (a to b) to a point c

Based on https://stackoverflow.com/questions/1073336/circle-line-segment-collision-detection-algorithm

RGBA color class with utility functions

Color components are integers from 0-255

Supports arithmetic operations and conversion to/from 32-bit integers

Creates a color with RGBA components (0-255)

Creates a color with RGB components (alpha defaults to 255)

Gets the alpha component

Gets the red component

Gets the green component

Gets the blue component

Sets the alpha component

Sets the red component

Sets the green component

Sets the blue component

Adds two colors component-wise

Subtracts two colors component-wise

Multiplies color by another color or scalar

Converts the color to a 32-bit integer (0xRRGGBBAA format)

Creates a color from a 32-bit integer

Adds two colors represented as 32-bit integers (including alpha channel)

Multiplies two colors represented as 32-bit integers (including alpha channel)

Returns a string representation of this color