Vector math for games

Introduction

Coordinate system

When using trig function like sine or cosine, we have to start with a few assumptions:

1. the y-axis points North
2. angles are measured in radians where Pi = 180 degrees = 3.14159 radians
3. an angle of 0 points East and it rotates counter-clockwise as its value increases

Degrees to radians

radians = math.rad(degrees)
degrees = math.deg(radians)

radians = degrees*(math.pi/180)
degrees = radians*(180/math.pi)

Vectors and points

Angles and rotation

Vector angle

function vpolar(a, d)
  d = d or 1
  local x = math.cos(a)*d
  local y = math.sin(a)*d
  return x, y
end

What if we already have an existing vector and want to find its angle? This is where the atan2 function comes into play. Just remember that atan2 assumes that the y-axis points up and rotates counter-clockwise.

function vangle(x, y)
  return math.atan2(y, x)
end

positive = radians%(math.pi*2)

Angle between two points

function angle(x, y, x2, y2)
  return math.atan2(y - y2, x - x2)
end

Rotating vectors

x, y = -y, x -- 90 degrees counterclockwise
x, y = y, -x -- 90 degrees clockwise
x, y = -x, -y -- 180 degrees

function rotate(x, y, a)
  local c = math.cos(a)
  local s = math.sin(a)
  return c*x - s*y, s*x + c*y
end

Angle between two vectors

One approach to finding the angle between vectors is using the arcsine function. The tricky part in the code involves checking the cross product (x*y2 - y*x2) to see if we should negate the angle. This is necessary because arcsine always returns a positive number.

function vangle(x, y, x2, y2)
  local arc = (x*x + y*y)*(x2*x2 + y2*y2)
  arc = sqrt(arc)
  if arc > 0 then
    arc = math.acos((x*x2 + y*y2)/arc)
    if x*y2 - y*x2 < 0 then
      arc = -arc
    end
  end
  return arc
end

Another way of calculating the angle between two vectors is by using math.atan2. Then, we can use the modulo operator ("%") to clamp the resulting angle. This method works when dealing strictly with angles too. The only requirement is that both vectors have non-zero length.

function vangle2(x, y, x2, y2)
  local a = math.atan2(y2, x2) - math.atan2(y, x)
  return (a + math.pi)%(math.pi*2) - math.pi
end

Another common problem is rounding an angle to the nearest cardinal direction. This operation is useful if you want to restrict the movement of an agent or projectile.

function cardinal(angle, steps)
  steps = steps or 8
  return math.floor(steps*angle/(2*math.pi) + steps + 0.5)%steps
end

Distance and length

Vector length

function length(x, y)
  return math.sqrt(x*x + y*y)
end

Distance between two points

function distance(x, y, x2, y2)
  local dx, dy = x2 - x, y2 - y
  return math.sqrt(dx*dx + dy*dy)
end

Normalizing and scaling vectors

function normalize(x, y)
  local d = math.sqrt(x*x + y*y)
  assert(d > 0)
  return x/d, y/d
end

Scaling a vector means multiplying its x and y components by a number. The result is another vector with the same heading, but different length.

function scale(x, y, s)
  return x*s, y*s
end

Products and projection

Dot product

function dot(x, y, x2, y2)
  return x*x2 + y*y2
end

cos(R) = dot(ax, ay, bx, by)
R = math.acos(dot(ax, ay, bx, by)

L = length(ax, ay)*length(bx, by)
cos(R) = dot(ax, ay, bx, by)/L
R = math.acos(dot(ax, ay, bx, by)/L)

Suppose that we have a moving car P with a heading of h. Using the dot product, we can find if the car is facing a target point T. When the dot product of the h and d is positive (where: d = T - P), point T is in front the moving car and when negative it must be behind it. If the dot product is zero, the car's heading is perpendicular to point T.

We can take this example one step further by rotating the heading vector by 90 degrees before calculating the dot product. In that case, the sign of the dot product shows us if the target is on the left or right hand side of the car. When the dot product is 0, the heading vector must be pointing directly at the target point T.

Cross product

function cross(x, y, x2, y2)
  return x*y2 - y*x2
end

Vector projection

an = normalize(a)
bp = an*dot(an, b)

a = P1 - P0
b = P2 - P0
an = normalize(a)
bp = an*dot(an, b)
P3 = bp + P0

Real-time applications

Moving to target

local sprite = { x = 0, y = 0, speed = 100 }

function sprite.updatePosition(dt)
  -- vector from sprite to target
  local mx, my = love.mouse.getPosition()
  local dx = mx - sprite.x
  local dy = my - sprite.y
  local dist = math.sqrt(dx*dx + dy*dy)
  local step = sprite.speed*dt
  if dist <= step then
    -- we have arrived
    sprite.x = mx
    sprite.y = my
  else
    -- normalize vector (between the target and sprite)
    local nx = dx/dist
    local ny = dy/dist
    -- keep moving
    sprite.x = sprite.x + nx*step
    sprite.y = sprite.y + ny*step
  end
end

Rotating to target

angle = (target - heading + pi)%(2*pi) - pi

local sprite = { x = 0, y = 0, angle = 0, turnrate = math.pi }

function sprite.updateAngle(dt)
  -- angle from sprite to target
  local mx, my = love.mouse.getPosition()
  local dx = mx - sprite.x
  local dy = my - sprite.y
  local target = math.atan2(my - dy, mx - dx)
  -- arc between heading and target
  local dist = target - sprite.angle
  dist = (dist + math.pi)%(math.pi*2) - math.pi
  local step = sprite.turnrate*dt
  if math.abs(dist) <= step then
    -- target angle reached
    sprite.angle = target
  else
    -- keep rotating
    if dist < 0 then
      step = -step
    end
    sprite.angle = sprite.angle + step
  end
end

References

• N Tutorial by Raigan Burns and Mare Sheppard
• Programming Game AI by Example by Matt Buckland
• Wolfram Alpha