LÖVE

Code: Select all

Rect = {}
Rect.__index = Rect

function Rect.new(width, height, ...)
  local self = setmetatable({}, Rect)
  self.x, self.y = 0, 0
  self.width = width
  self.height = height
  if ... then self:setPoint(...) end
  return self
end

function Rect:getPoint(nx, ny, ox, oy)
  local x = self.x + self.width * nx + (ox or 0)
  local y = self.y + self.height * ny + (oy or 0)
  return x, y
end

function Rect:setPoint(nx, ny, x, y)
  self.x = x - self.width * nx
  self.y = y - self.height * ny
end

Code: Select all

-- create a rect representing the screen
screen = Rect(love.graphics.getDimensions())

-- create a floor, position its bottom middle to the screen's bottom middle, and offset it by 10 pixels up
floor = Rect(800, 50, 0.5, 1, screen:getPoint(0.5, 1, 0, -10))

-- create a player, position its bottom middle to the floor's top middle
player = Rect(80, 80, 0.5, 1, floor:getPoint(0.5, 0))

Code: Select all

Rect = {}
Rect.__index = Rect

local new(width, height, ...)
  local self = setmetatable({}, Rect)
  -- Dimensions
  self.width = width
  self.height = height
  if ... then
    self:setPoint(...)
  else
    -- Do try to set defaults for the topleft of the rectangle, so getPoint doesn't error.
    self.setPoint(0, 0)
  end
  return self
end

function Rect:copy()
  return new(self.width, self.height, 0, 0, self.x, self.y)
end

function Rect:getPoint(nx, ny, ox, oy)
  local x = self.x + self.width * nx + (ox or 0)
  local y = self.y + self.height * ny + (oy or 0)
  return x, y
end

function Rect:setPoint(nx, ny, x, y)
  self.x = (x or 0) - self.width * nx
  self.y = (y or 0) - self.height * ny
end

-- Do note that these do not create new rectangles since that'd be wasting resources,
-- all of them operate 'in place'.

function Rect:translate(tx, ty) -- move_ip
  self.x = self.x + (tx or 0)
  self.y = self.y + (tx or 0)
end

function Rect:scale(sx,sy,x,y)
  self.width  = self.width  * sx + x
  self.height = self.height * sy + y
end

function Rect:scaleCentered(sx,sy,ox,oy) -- inflate_ip, except gives multipliers as well
  local w,h = self.width  * sx + x, self.height * sy + y
  self.x = self.x + self.width  / 2 - w / 2
  self.y = self.y - self.height / 2 - h / 2
  self.width, self.height = w, h
end

function Rect:clamp(rect) -- clamp_ip
  -- Move self so it's inside rect, unless self is bigger than rect, in case, center only (per-axis).
  if self.width > rect.width then
    self.x = rect.x + rect.width / 2 - self.width / 2
  else
    math.max(math.min(self.x, rect.width), rect.x)
  end
  if self.height > rect.height then
    self.y = rect.y + rect.height / 2 - self.height / 2
  else
    math.max(math.min(self.y, rect.height), rect.y)
  end
end

function Rect:clip(rect) -- clip_ip (doesn't seem to exist)
  -- Test for totally-separatedness
  if self.x > rect.x + rect.width or
     self.x + self.width < rect.x or
     self.y > rect.y + rect.height or
     self.y + self.height < rect.y
  then
    self.x = 0
    self.y = 0
    self.width  = 0
    self.height = 0
  else
    -- Unorthodox method, but should work
    local x = {self.x, rect.x, self.x+self.width, rect.x+rect.width}
    local y = {self.y, rect.y, self.y+self.height, rect.y+rect.height}
    table.sort(x); table.sort(y)
    self.x, self.y, self.width, self.height = x[2], y[2], x[3]-x[2], y[3]-y[2]
end

function Rect:union(...) -- union(all)_ip
  -- take the min of x,y and the max of width,height of all given rects
  local infx, infy, supw, suph = math.huge, math.huge, 0, 0
  for i,v in ipairs(...) do
    infx = math.min(infx, v.x)
    infy = math.min(infy, v.y)
    supw = math.max(supw, v.width)
    suph = math.max(suph, v.height)
  end
  self.x = math.min(self.x, infx)
  self.y = math.min(self.y, infy)
  self.width  = math.max(self.width,  supw)
  self.height = math.max(self.height, suph)
end

function Rect:fit(rect) -- fit_ip (doesn't seem to exist)
  -- Make it so our rectangle fits inside another
  self.x = math.max(self.x, rect.x)
  self.y = math.max(self.y, rect.y)
  self.width  = math.min(self.width,  rect.width)
  self.height = math.min(self.height, rect.height)
end

-- Normalize doesn't exist since we don't allow negative width or heights.
-- (In other words, x and y will always be the top-left coords of a rect.)

function Rect:contains(rect) -- contains
  -- Test whether self is inside rect.
  return self.x >= rect.x and self.y >= rect.y and self.width <= rect.width and self.height <= rect.height
end

function Rect:intersects(rect) -- colliderect
  return (self.x >= rect.x and self.x <= rect.width) or (self.y >= rect.y and self.y <= rect.height)
end

-- Everything else can be implemented with the above two functions (in terms of collision checking)

-----------
return new