Game Maths Cheat Sheet

Formula: √((x₂−x₁)² + (y₂−y₁)²)

Drag the dots to explore.

// 2D
float dist = Vector2.Distance(a, b);

// 3D
float dist = Vector3.Distance(a, b);

Formula: atan2(y₂−y₁, x₂−x₁)

Drag the target point to change the angle. Canvas Y is inverted, so the angle is measured from the positive X axis.

float dx = target.x - origin.x;
float dy = target.y - origin.y;
float angle = Mathf.Atan2(dy, dx) * Mathf.Rad2Deg;

Formula: position + direction × speed × deltaTime

Drag the target. The mover chases it at a fixed speed.

transform.position = Vector3.MoveTowards(
    transform.position,
    target.position,
    speed * Time.deltaTime
);

Formula: a + (b − a) × t

When t=0 the result is A, when t=1 the result is B. Values in between blend smoothly.

float val = Mathf.Lerp(a, b, t);
Vector3 pos = Vector3.Lerp(a, b, t);
Color col = Color.Lerp(a, b, t);

Formula: a.x×b.x + a.y×b.y (using normalised vectors)

Positive = same direction. Zero = perpendicular. Negative = opposite.

float dot = Vector3.Dot(a.normalized, b.normalized);
// 1 = same dir, 0 = perpendicular, -1 = opposite

Formula: (a.y×b.z − a.z×b.y, a.z×b.x − a.x×b.z, a.x×b.y − a.y×b.x)

Result is perpendicular to both input vectors. Magnitude equals the area of the parallelogram they form.

Vector3 cross = Vector3.Cross(a, b);

Formula: v / |v|

A normalised vector keeps its direction but has a magnitude of 1. The dashed circle represents unit length.

Vector3 dir = vector.normalized;
// dir has magnitude 1

Formula: d − 2(d·n)n

Drag the source of the incoming vector. The reflected vector mirrors across the surface normal.

Vector3 reflected = Vector3.Reflect(direction, normal);

Formula: distance(point, centre) ≤ radius

Drag the point. It turns green when inside the circle, red when outside.

bool inside = Vector3.Distance(point, centre) <= radius;

Formula: point.x ≥ min.x && point.x ≤ max.x && point.y ≥ min.y && point.y ≤ max.y

Drag the point to test axis-aligned bounding box containment.

bool inside = bounds.Contains(point);

Formula: amplitude × sin(frequency × time + phase)

Adjust the sliders to see how amplitude, frequency, and phase affect the wave.

float y = Mathf.Sin(frequency * Time.time + phase) * amplitude;
transform.position = new Vector3(
    transform.position.x,
    y,
    transform.position.z
);

Formula: centre + Random.insideUnitCircle × radius

Uses uniform distribution (sqrt of random radius) so points do not cluster at the centre.

Vector2 point = (Vector2)transform.position
    + Random.insideUnitCircle * radius;

Critically damped spring: smoothly follows a moving target without overshooting.

Drag the green target. The blue follower chases it using SmoothDamp. The pink arrow shows current velocity. Lower smooth time means faster response; max speed caps the velocity.

private Vector3 velocity = Vector3.zero;

void LateUpdate()
{
    Vector3 target = targetTransform.position;
    transform.position = Vector3.SmoothDamp(
        transform.position,
        target,
        ref velocity,
        smoothTime,    // 0.30f
        maxSpeed       // 50f
    );
}

Formula: Lerp(outMin, outMax, InverseLerp(inMin, inMax, value))

Drag the blue point on the input line. The green point on the output line shows the remapped value. Edit the range inputs to change both scales.

// Remap a value from one range to another
float t = Mathf.InverseLerp(inMin, inMax, value);
float result = Mathf.Lerp(outMin, outMax, t);

// Common example: map health (0-100) to bar fill (0-1)
float fill = Mathf.InverseLerp(0f, maxHealth, currentHealth);
healthBar.fillAmount = fill;

// Remap utility function
public static float Remap(float value,
    float inMin, float inMax, float outMin, float outMax)
{
    float t = Mathf.InverseLerp(inMin, inMax, value);
    return Mathf.Lerp(outMin, outMax, t);
}