restructure

9 files changed, 70 insertions, 828 deletions

diff --git a/src/APL333.ttf b/src/APL333.ttf
deleted file mode 100644
index 37ad502..0000000
--- a/src/APL333.ttf
+++ /dev/null
diff --git a/src/bump.lua b/src/bump.lua
deleted file mode 100644
index 6dabca7..0000000
--- a/src/bump.lua
+++ /dev/null
@@ -1,773 +0,0 @@
-local bump = {
-  _VERSION     = 'bump v3.1.7',
-  _URL         = 'https://github.com/kikito/bump.lua',
-  _DESCRIPTION = 'A collision detection library for Lua',
-  _LICENSE     = [[
-    MIT LICENSE
-
-    Copyright (c) 2014 Enrique García Cota
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the
-    "Software"), to deal in the Software without restriction, including
-    without limitation the rights to use, copy, modify, merge, publish,
-    distribute, sublicense, and/or sell copies of the Software, and to
-    permit persons to whom the Software is furnished to do so, subject to
-    the following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-  ]]
-}
-
-------------------------------------------
--- Auxiliary functions
-------------------------------------------
-local DELTA = 1e-10 -- floating-point margin of error
-
-local abs, floor, ceil, min, max = math.abs, math.floor, math.ceil, math.min, math.max
-
-local function sign(x)
-  if x > 0 then return 1 end
-  if x == 0 then return 0 end
-  return -1
-end
-
-local function nearest(x, a, b)
-  if abs(a - x) < abs(b - x) then return a else return b end
-end
-
-local function assertType(desiredType, value, name)
-  if type(value) ~= desiredType then
-    error(name .. ' must be a ' .. desiredType .. ', but was ' .. tostring(value) .. '(a ' .. type(value) .. ')')
-  end
-end
-
-local function assertIsPositiveNumber(value, name)
-  if type(value) ~= 'number' or value <= 0 then
-    error(name .. ' must be a positive integer, but was ' .. tostring(value) .. '(' .. type(value) .. ')')
-  end
-end
-
-local function assertIsRect(x,y,w,h)
-  assertType('number', x, 'x')
-  assertType('number', y, 'y')
-  assertIsPositiveNumber(w, 'w')
-  assertIsPositiveNumber(h, 'h')
-end
-
-local defaultFilter = function()
-  return 'slide'
-end
-
-------------------------------------------
--- Rectangle functions
-------------------------------------------
-
-local function rect_getNearestCorner(x,y,w,h, px, py)
-  return nearest(px, x, x+w), nearest(py, y, y+h)
-end
-
--- This is a generalized implementation of the liang-barsky algorithm, which also returns
--- the normals of the sides where the segment intersects.
--- Returns nil if the segment never touches the rect
--- Notice that normals are only guaranteed to be accurate when initially ti1, ti2 == -math.huge, math.huge
-local function rect_getSegmentIntersectionIndices(x,y,w,h, x1,y1,x2,y2, ti1,ti2)
-  ti1, ti2 = ti1 or 0, ti2 or 1
-  local dx, dy = x2-x1, y2-y1
-  local nx, ny
-  local nx1, ny1, nx2, ny2 = 0,0,0,0
-  local p, q, r
-
-  for side = 1,4 do
-    if     side == 1 then nx,ny,p,q = -1,  0, -dx, x1 - x     -- left
-    elseif side == 2 then nx,ny,p,q =  1,  0,  dx, x + w - x1 -- right
-    elseif side == 3 then nx,ny,p,q =  0, -1, -dy, y1 - y     -- top
-    else                  nx,ny,p,q =  0,  1,  dy, y + h - y1 -- bottom
-    end
-
-    if p == 0 then
-      if q <= 0 then return nil end
-    else
-      r = q / p
-      if p < 0 then
-        if     r > ti2 then return nil
-        elseif r > ti1 then ti1,nx1,ny1 = r,nx,ny
-        end
-      else -- p > 0
-        if     r < ti1 then return nil
-        elseif r < ti2 then ti2,nx2,ny2 = r,nx,ny
-        end
-      end
-    end
-  end
-
-  return ti1,ti2, nx1,ny1, nx2,ny2
-end
-
--- Calculates the minkowsky difference between 2 rects, which is another rect
-local function rect_getDiff(x1,y1,w1,h1, x2,y2,w2,h2)
-  return x2 - x1 - w1,
-         y2 - y1 - h1,
-         w1 + w2,
-         h1 + h2
-end
-
-local function rect_containsPoint(x,y,w,h, px,py)
-  return px - x > DELTA      and py - y > DELTA and
-         x + w - px > DELTA  and y + h - py > DELTA
-end
-
-local function rect_isIntersecting(x1,y1,w1,h1, x2,y2,w2,h2)
-  return x1 < x2+w2 and x2 < x1+w1 and
-         y1 < y2+h2 and y2 < y1+h1
-end
-
-local function rect_getSquareDistance(x1,y1,w1,h1, x2,y2,w2,h2)
-  local dx = x1 - x2 + (w1 - w2)/2
-  local dy = y1 - y2 + (h1 - h2)/2
-  return dx*dx + dy*dy
-end
-
-local function rect_detectCollision(x1,y1,w1,h1, x2,y2,w2,h2, goalX, goalY)
-  goalX = goalX or x1
-  goalY = goalY or y1
-
-  local dx, dy      = goalX - x1, goalY - y1
-  local x,y,w,h     = rect_getDiff(x1,y1,w1,h1, x2,y2,w2,h2)
-
-  local overlaps, ti, nx, ny
-
-  if rect_containsPoint(x,y,w,h, 0,0) then -- item was intersecting other
-    local px, py    = rect_getNearestCorner(x,y,w,h, 0, 0)
-    local wi, hi    = min(w1, abs(px)), min(h1, abs(py)) -- area of intersection
-    ti              = -wi * hi -- ti is the negative area of intersection
-    overlaps = true
-  else
-    local ti1,ti2,nx1,ny1 = rect_getSegmentIntersectionIndices(x,y,w,h, 0,0,dx,dy, -math.huge, math.huge)
-
-    -- item tunnels into other
-    if ti1
-    and ti1 < 1
-    and (abs(ti1 - ti2) >= DELTA) -- special case for rect going through another rect's corner
-    and (0 < ti1 + DELTA
-      or 0 == ti1 and ti2 > 0)
-    then
-      ti, nx, ny = ti1, nx1, ny1
-      overlaps   = false
-    end
-  end
-
-  if not ti then return end
-
-  local tx, ty
-
-  if overlaps then
-    if dx == 0 and dy == 0 then
-      -- intersecting and not moving - use minimum displacement vector
-      local px, py = rect_getNearestCorner(x,y,w,h, 0,0)
-      if abs(px) < abs(py) then py = 0 else px = 0 end
-      nx, ny = sign(px), sign(py)
-      tx, ty = x1 + px, y1 + py
-    else
-      -- intersecting and moving - move in the opposite direction
-      local ti1, _
-      ti1,_,nx,ny = rect_getSegmentIntersectionIndices(x,y,w,h, 0,0,dx,dy, -math.huge, 1)
-      if not ti1 then return end
-      tx, ty = x1 + dx * ti1, y1 + dy * ti1
-    end
-  else -- tunnel
-    tx, ty = x1 + dx * ti, y1 + dy * ti
-  end
-
-  return {
-    overlaps  = overlaps,
-    ti        = ti,
-    move      = {x = dx, y = dy},
-    normal    = {x = nx, y = ny},
-    touch     = {x = tx, y = ty},
-    itemRect  = {x = x1, y = y1, w = w1, h = h1},
-    otherRect = {x = x2, y = y2, w = w2, h = h2}
-  }
-end
-
-------------------------------------------
--- Grid functions
-------------------------------------------
-
-local function grid_toWorld(cellSize, cx, cy)
-  return (cx - 1)*cellSize, (cy-1)*cellSize
-end
-
-local function grid_toCell(cellSize, x, y)
-  return floor(x / cellSize) + 1, floor(y / cellSize) + 1
-end
-
--- grid_traverse* functions are based on "A Fast Voxel Traversal Algorithm for Ray Tracing",
--- by John Amanides and Andrew Woo - http://www.cse.yorku.ca/~amana/research/grid.pdf
--- It has been modified to include both cells when the ray "touches a grid corner",
--- and with a different exit condition
-
-local function grid_traverse_initStep(cellSize, ct, t1, t2)
-  local v = t2 - t1
-  if     v > 0 then
-    return  1,  cellSize / v, ((ct + v) * cellSize - t1) / v
-  elseif v < 0 then
-    return -1, -cellSize / v, ((ct + v - 1) * cellSize - t1) / v
-  else
-    return 0, math.huge, math.huge
-  end
-end
-
-local function grid_traverse(cellSize, x1,y1,x2,y2, f)
-  local cx1,cy1        = grid_toCell(cellSize, x1,y1)
-  local cx2,cy2        = grid_toCell(cellSize, x2,y2)
-  local stepX, dx, tx  = grid_traverse_initStep(cellSize, cx1, x1, x2)
-  local stepY, dy, ty  = grid_traverse_initStep(cellSize, cy1, y1, y2)
-  local cx,cy          = cx1,cy1
-
-  f(cx, cy)
-
-  -- The default implementation had an infinite loop problem when
-  -- approaching the last cell in some occassions. We finish iterating
-  -- when we are *next* to the last cell
-  while abs(cx - cx2) + abs(cy - cy2) > 1 do
-    if tx < ty then
-      tx, cx = tx + dx, cx + stepX
-      f(cx, cy)
-    else
-      -- Addition: include both cells when going through corners
-      if tx == ty then f(cx + stepX, cy) end
-      ty, cy = ty + dy, cy + stepY
-      f(cx, cy)
-    end
-  end
-
-  -- If we have not arrived to the last cell, use it
-  if cx ~= cx2 or cy ~= cy2 then f(cx2, cy2) end
-
-end
-
-local function grid_toCellRect(cellSize, x,y,w,h)
-  local cx,cy = grid_toCell(cellSize, x, y)
-  local cr,cb = ceil((x+w) / cellSize), ceil((y+h) / cellSize)
-  return cx, cy, cr - cx + 1, cb - cy + 1
-end
-
-------------------------------------------
--- Responses
-------------------------------------------
-
-local touch = function(world, col, x,y,w,h, goalX, goalY, filter)
-  return col.touch.x, col.touch.y, {}, 0
-end
-
-local cross = function(world, col, x,y,w,h, goalX, goalY, filter)
-  local cols, len = world:project(col.item, x,y,w,h, goalX, goalY, filter)
-  return goalX, goalY, cols, len
-end
-
-local slide = function(world, col, x,y,w,h, goalX, goalY, filter)
-  goalX = goalX or x
-  goalY = goalY or y
-
-  local tch, move  = col.touch, col.move
-  if move.x ~= 0 or move.y ~= 0 then
-    if col.normal.x ~= 0 then
-      goalX = tch.x
-    else
-      goalY = tch.y
-    end
-  end
-
-  col.slide = {x = goalX, y = goalY}
-
-  x,y = tch.x, tch.y
-  local cols, len  = world:project(col.item, x,y,w,h, goalX, goalY, filter)
-  return goalX, goalY, cols, len
-end
-
-local bounce = function(world, col, x,y,w,h, goalX, goalY, filter)
-  goalX = goalX or x
-  goalY = goalY or y
-
-  local tch, move = col.touch, col.move
-  local tx, ty = tch.x, tch.y
-
-  local bx, by = tx, ty
-
-  if move.x ~= 0 or move.y ~= 0 then
-    local bnx, bny = goalX - tx, goalY - ty
-    if col.normal.x == 0 then bny = -bny else bnx = -bnx end
-    bx, by = tx + bnx, ty + bny
-  end
-
-  col.bounce   = {x = bx,  y = by}
-  x,y          = tch.x, tch.y
-  goalX, goalY = bx, by
-
-  local cols, len    = world:project(col.item, x,y,w,h, goalX, goalY, filter)
-  return goalX, goalY, cols, len
-end
-
-------------------------------------------
--- World
-------------------------------------------
-
-local World = {}
-local World_mt = {__index = World}
-
--- Private functions and methods
-
-local function sortByWeight(a,b) return a.weight < b.weight end
-
-local function sortByTiAndDistance(a,b)
-  if a.ti == b.ti then
-    local ir, ar, br = a.itemRect, a.otherRect, b.otherRect
-    local ad = rect_getSquareDistance(ir.x,ir.y,ir.w,ir.h, ar.x,ar.y,ar.w,ar.h)
-    local bd = rect_getSquareDistance(ir.x,ir.y,ir.w,ir.h, br.x,br.y,br.w,br.h)
-    return ad < bd
-  end
-  return a.ti < b.ti
-end
-
-local function addItemToCell(self, item, cx, cy)
-  self.rows[cy] = self.rows[cy] or setmetatable({}, {__mode = 'v'})
-  local row = self.rows[cy]
-  row[cx] = row[cx] or {itemCount = 0, x = cx, y = cy, items = setmetatable({}, {__mode = 'k'})}
-  local cell = row[cx]
-  self.nonEmptyCells[cell] = true
-  if not cell.items[item] then
-    cell.items[item] = true
-    cell.itemCount = cell.itemCount + 1
-  end
-end
-
-local function removeItemFromCell(self, item, cx, cy)
-  local row = self.rows[cy]
-  if not row or not row[cx] or not row[cx].items[item] then return false end
-
-  local cell = row[cx]
-  cell.items[item] = nil
-  cell.itemCount = cell.itemCount - 1
-  if cell.itemCount == 0 then
-    self.nonEmptyCells[cell] = nil
-  end
-  return true
-end
-
-local function getDictItemsInCellRect(self, cl,ct,cw,ch)
-  local items_dict = {}
-  for cy=ct,ct+ch-1 do
-    local row = self.rows[cy]
-    if row then
-      for cx=cl,cl+cw-1 do
-        local cell = row[cx]
-        if cell and cell.itemCount > 0 then -- no cell.itemCount > 1 because tunneling
-          for item,_ in pairs(cell.items) do
-            items_dict[item] = true
-          end
-        end
-      end
-    end
-  end
-
-  return items_dict
-end
-
-local function getCellsTouchedBySegment(self, x1,y1,x2,y2)
-
-  local cells, cellsLen, visited = {}, 0, {}
-
-  grid_traverse(self.cellSize, x1,y1,x2,y2, function(cx, cy)
-    local row  = self.rows[cy]
-    if not row then return end
-    local cell = row[cx]
-    if not cell or visited[cell] then return end
-
-    visited[cell] = true
-    cellsLen = cellsLen + 1
-    cells[cellsLen] = cell
-  end)
-
-  return cells, cellsLen
-end
-
-local function getInfoAboutItemsTouchedBySegment(self, x1,y1, x2,y2, filter)
-  local cells, len = getCellsTouchedBySegment(self, x1,y1,x2,y2)
-  local cell, rect, l,t,w,h, ti1,ti2, tii0,tii1
-  local visited, itemInfo, itemInfoLen = {},{},0
-  for i=1,len do
-    cell = cells[i]
-    for item in pairs(cell.items) do
-      if not visited[item] then
-        visited[item]  = true
-        if (not filter or filter(item)) then
-          rect           = self.rects[item]
-          l,t,w,h        = rect.x,rect.y,rect.w,rect.h
-
-          ti1,ti2 = rect_getSegmentIntersectionIndices(l,t,w,h, x1,y1, x2,y2, 0, 1)
-          if ti1 and ((0 < ti1 and ti1 < 1) or (0 < ti2 and ti2 < 1)) then
-            -- the sorting is according to the t of an infinite line, not the segment
-            tii0,tii1    = rect_getSegmentIntersectionIndices(l,t,w,h, x1,y1, x2,y2, -math.huge, math.huge)
-            itemInfoLen  = itemInfoLen + 1
-            itemInfo[itemInfoLen] = {item = item, ti1 = ti1, ti2 = ti2, weight = min(tii0,tii1)}
-          end
-        end
-      end
-    end
-  end
-  table.sort(itemInfo, sortByWeight)
-  return itemInfo, itemInfoLen
-end
-
-local function getResponseByName(self, name)
-  local response = self.responses[name]
-  if not response then
-    error(('Unknown collision type: %s (%s)'):format(name, type(name)))
-  end
-  return response
-end
-
-
--- Misc Public Methods
-
-function World:addResponse(name, response)
-  self.responses[name] = response
-end
-
-function World:project(item, x,y,w,h, goalX, goalY, filter)
-  assertIsRect(x,y,w,h)
-
-  goalX = goalX or x
-  goalY = goalY or y
-  filter  = filter  or defaultFilter
-
-  local collisions, len = {}, 0
-
-  local visited = {}
-  if item ~= nil then visited[item] = true end
-
-  -- This could probably be done with less cells using a polygon raster over the cells instead of a
-  -- bounding rect of the whole movement. Conditional to building a queryPolygon method
-  local tl, tt = min(goalX, x),       min(goalY, y)
-  local tr, tb = max(goalX + w, x+w), max(goalY + h, y+h)
-  local tw, th = tr-tl, tb-tt
-
-  local cl,ct,cw,ch = grid_toCellRect(self.cellSize, tl,tt,tw,th)
-
-  local dictItemsInCellRect = getDictItemsInCellRect(self, cl,ct,cw,ch)
-
-  for other,_ in pairs(dictItemsInCellRect) do
-    if not visited[other] then
-      visited[other] = true
-
-      local responseName = filter(item, other)
-      if responseName then
-        local ox,oy,ow,oh   = self:getRect(other)
-        local col           = rect_detectCollision(x,y,w,h, ox,oy,ow,oh, goalX, goalY)
-
-        if col then
-          col.other    = other
-          col.item     = item
-          col.type     = responseName
-
-          len = len + 1
-          collisions[len] = col
-        end
-      end
-    end
-  end
-
-  table.sort(collisions, sortByTiAndDistance)
-
-  return collisions, len
-end
-
-function World:countCells()
-  local count = 0
-  for _,row in pairs(self.rows) do
-    for _,_ in pairs(row) do
-      count = count + 1
-    end
-  end
-  return count
-end
-
-function World:hasItem(item)
-  return not not self.rects[item]
-end
-
-function World:getItems()
-  local items, len = {}, 0
-  for item,_ in pairs(self.rects) do
-    len = len + 1
-    items[len] = item
-  end
-  return items, len
-end
-
-function World:countItems()
-  local len = 0
-  for _ in pairs(self.rects) do len = len + 1 end
-  return len
-end
-
-function World:getRect(item)
-  local rect = self.rects[item]
-  if not rect then
-    error('Item ' .. tostring(item) .. ' must be added to the world before getting its rect. Use world:add(item, x,y,w,h) to add it first.')
-  end
-  return rect.x, rect.y, rect.w, rect.h
-end
-
-function World:toWorld(cx, cy)
-  return grid_toWorld(self.cellSize, cx, cy)
-end
-
-function World:toCell(x,y)
-  return grid_toCell(self.cellSize, x, y)
-end
-
-
---- Query methods
-
-function World:queryRect(x,y,w,h, filter)
-
-  assertIsRect(x,y,w,h)
-
-  local cl,ct,cw,ch = grid_toCellRect(self.cellSize, x,y,w,h)
-  local dictItemsInCellRect = getDictItemsInCellRect(self, cl,ct,cw,ch)
-
-  local items, len = {}, 0
-
-  local rect
-  for item,_ in pairs(dictItemsInCellRect) do
-    rect = self.rects[item]
-    if (not filter or filter(item))
-    and rect_isIntersecting(x,y,w,h, rect.x, rect.y, rect.w, rect.h)
-    then
-      len = len + 1
-      items[len] = item
-    end
-  end
-
-  return items, len
-end
-
-function World:queryPoint(x,y, filter)
-  local cx,cy = self:toCell(x,y)
-  local dictItemsInCellRect = getDictItemsInCellRect(self, cx,cy,1,1)
-
-  local items, len = {}, 0
-
-  local rect
-  for item,_ in pairs(dictItemsInCellRect) do
-    rect = self.rects[item]
-    if (not filter or filter(item))
-    and rect_containsPoint(rect.x, rect.y, rect.w, rect.h, x, y)
-    then
-      len = len + 1
-      items[len] = item
-    end
-  end
-
-  return items, len
-end
-
-function World:querySegment(x1, y1, x2, y2, filter)
-  local itemInfo, len = getInfoAboutItemsTouchedBySegment(self, x1, y1, x2, y2, filter)
-  local items = {}
-  for i=1, len do
-    items[i] = itemInfo[i].item
-  end
-  return items, len
-end
-
-function World:querySegmentWithCoords(x1, y1, x2, y2, filter)
-  local itemInfo, len = getInfoAboutItemsTouchedBySegment(self, x1, y1, x2, y2, filter)
-  local dx, dy        = x2-x1, y2-y1
-  local info, ti1, ti2
-  for i=1, len do
-    info  = itemInfo[i]
-    ti1   = info.ti1
-    ti2   = info.ti2
-
-    info.weight  = nil
-    info.x1      = x1 + dx * ti1
-    info.y1      = y1 + dy * ti1
-    info.x2      = x1 + dx * ti2
-    info.y2      = y1 + dy * ti2
-  end
-  return itemInfo, len
-end
-
-
---- Main methods
-
-function World:add(item, x,y,w,h)
-  local rect = self.rects[item]
-  if rect then
-    error('Item ' .. tostring(item) .. ' added to the world twice.')
-  end
-  assertIsRect(x,y,w,h)
-
-  self.rects[item] = {x=x,y=y,w=w,h=h}
-
-  local cl,ct,cw,ch = grid_toCellRect(self.cellSize, x,y,w,h)
-  for cy = ct, ct+ch-1 do
-    for cx = cl, cl+cw-1 do
-      addItemToCell(self, item, cx, cy)
-    end
-  end
-
-  return item
-end
-
-function World:remove(item)
-  local x,y,w,h = self:getRect(item)
-
-  self.rects[item] = nil
-  local cl,ct,cw,ch = grid_toCellRect(self.cellSize, x,y,w,h)
-  for cy = ct, ct+ch-1 do
-    for cx = cl, cl+cw-1 do
-      removeItemFromCell(self, item, cx, cy)
-    end
-  end
-end
-
-function World:update(item, x2,y2,w2,h2)
-  local x1,y1,w1,h1 = self:getRect(item)
-  w2,h2 = w2 or w1, h2 or h1
-  assertIsRect(x2,y2,w2,h2)
-
-  if x1 ~= x2 or y1 ~= y2 or w1 ~= w2 or h1 ~= h2 then
-
-    local cellSize = self.cellSize
-    local cl1,ct1,cw1,ch1 = grid_toCellRect(cellSize, x1,y1,w1,h1)
-    local cl2,ct2,cw2,ch2 = grid_toCellRect(cellSize, x2,y2,w2,h2)
-
-    if cl1 ~= cl2 or ct1 ~= ct2 or cw1 ~= cw2 or ch1 ~= ch2 then
-
-      local cr1, cb1 = cl1+cw1-1, ct1+ch1-1
-      local cr2, cb2 = cl2+cw2-1, ct2+ch2-1
-      local cyOut
-
-      for cy = ct1, cb1 do
-        cyOut = cy < ct2 or cy > cb2
-        for cx = cl1, cr1 do
-          if cyOut or cx < cl2 or cx > cr2 then
-            removeItemFromCell(self, item, cx, cy)
-          end
-        end
-      end
-
-      for cy = ct2, cb2 do
-        cyOut = cy < ct1 or cy > cb1
-        for cx = cl2, cr2 do
-          if cyOut or cx < cl1 or cx > cr1 then
-            addItemToCell(self, item, cx, cy)
-          end
-        end
-      end
-
-    end
-
-    local rect = self.rects[item]
-    rect.x, rect.y, rect.w, rect.h = x2,y2,w2,h2
-
-  end
-end
-
-function World:move(item, goalX, goalY, filter)
-  local actualX, actualY, cols, len = self:check(item, goalX, goalY, filter)
-
-  self:update(item, actualX, actualY)
-
-  return actualX, actualY, cols, len
-end
-
-function World:check(item, goalX, goalY, filter)
-  filter = filter or defaultFilter
-
-  local visited = {[item] = true}
-  local visitedFilter = function(itm, other)
-    if visited[other] then return false end
-    return filter(itm, other)
-  end
-
-  local cols, len = {}, 0
-
-  local x,y,w,h = self:getRect(item)
-
-  local projected_cols, projected_len = self:project(item, x,y,w,h, goalX,goalY, visitedFilter)
-
-  while projected_len > 0 do
-    local col = projected_cols[1]
-    len       = len + 1
-    cols[len] = col
-
-    visited[col.other] = true
-
-    local response = getResponseByName(self, col.type)
-
-    goalX, goalY, projected_cols, projected_len = response(
-      self,
-      col,
-      x, y, w, h,
-      goalX, goalY,
-      visitedFilter
-    )
-  end
-
-  return goalX, goalY, cols, len
-end
-
-
--- Public library functions
-
-bump.newWorld = function(cellSize)
-  cellSize = cellSize or 64
-  assertIsPositiveNumber(cellSize, 'cellSize')
-  local world = setmetatable({
-    cellSize       = cellSize,
-    rects          = {},
-    rows           = {},
-    nonEmptyCells  = {},
-    responses = {}
-  }, World_mt)
-
-  world:addResponse('touch', touch)
-  world:addResponse('cross', cross)
-  world:addResponse('slide', slide)
-  world:addResponse('bounce', bounce)
-
-  return world
-end
-
-bump.rect = {
-  getNearestCorner              = rect_getNearestCorner,
-  getSegmentIntersectionIndices = rect_getSegmentIntersectionIndices,
-  getDiff                       = rect_getDiff,
-  containsPoint                 = rect_containsPoint,
-  isIntersecting                = rect_isIntersecting,
-  getSquareDistance             = rect_getSquareDistance,
-  detectCollision               = rect_detectCollision
-}
-
-bump.responses = {
-  touch  = touch,
-  cross  = cross,
-  slide  = slide,
-  bounce = bounce
-}
-
-return bump
diff --git a/src/conf.lua b/src/conf.lua
deleted file mode 100644
index 98bf66d..0000000
--- a/src/conf.lua
+++ /dev/null
@@ -1,8 +0,0 @@
-function love.conf(t)
-	t.window.title = "the"
-	t.window.width=640
-	t.window.height=480
-	t.window.resizeable=true
-
-end
-
diff --git a/src/corridor.fnl b/src/corridor.fnl
new file mode 100644
index 0000000..8f1a6a0
--- /dev/null
+++ b/src/corridor.fnl
@@ -0,0 +1,24 @@
+;; corridor
+;; maybe make this generic enough to have multiple
+;; corridors with the same code, eventually
+
+(local player (require :src.player))
+
+(fn make [state]
+    (local font state.font)
+    (local title (love.graphics.newText font :corridor))
+    (local player (player.make))
+    (fn draw []
+        (love.graphics.setColor 0.8 0.8 0.8)
+        (love.graphics.setLineWidth 10)
+        (love.graphics.rectangle :line 30 80  580 370)
+        (love.graphics.draw title (- 610 (title:getWidth)) -10)
+        (player:draw))
+    
+    (fn update [dt]
+        (player:update dt))
+
+    {: draw
+     : update})
+
+{: make}
diff --git a/src/jerma.jpg b/src/jerma.jpg
deleted file mode 100644
index 46bff2d..0000000
--- a/src/jerma.jpg
+++ /dev/null
diff --git a/src/main.lua b/src/main.lua
deleted file mode 100644
index d62c956..0000000
--- a/src/main.lua
+++ /dev/null
@@ -1,32 +0,0 @@
-local fennel = require "fennel"
-table.insert(package.loaders or package.searchers, fennel.searcher)
-
-
-local player = require "player"
-local mansion = require "mansion"
-
-
-local current_room
-
-function love.load()
-	mansion.load()
-	current_room = mansion
-	-- this should go in load_room or something
-	current_room.world:add("player", player.x, player.y, 10,10)
-end
-
-
-
-
-function love.update(dt)
-	player:move(dt,current_room.world)
-end
-
-function love.draw()
-	love.graphics.clear(1,1,1)
-
-	mansion.draw()
-	player:draw()
-
-
-end
diff --git a/src/mansion.fnl b/src/mansion.fnl
index 067c679..1c11067 100644
--- a/src/mansion.fnl
+++ b/src/mansion.fnl
@@ -1,5 +1,5 @@
-(local bump (require :bump))
-(local player (require :player))
+(local bump (require :vendor.bump))
+(local player (require :src.player))
 
 (local world (bump.newWorld))
 
@@ -39,8 +39,8 @@
 	                  (love.graphics.setColor (if angry [1 0 0 0.8] [0.7 0 0.5 0.8]))
                       (love.graphics.rotate (/ (- theta) 1.618))
                       (love.graphics.polygon :line (- (/ tri-a 2)) (- (/ tri-h 3))
-                                                   (/ tri-a 2) (- (/ tri-h 3))
-                                                   0 (* 2 (/ tri-h 3))))
+                                                   (/ tri-a 2)     (- (/ tri-h 3))
+                                                   0               (* 2 (/ tri-h 3))))
                      
                      (love.graphics.setLineWidth 7)
                      (love.graphics.setColor 0.8 0.8 0 0.7)
@@ -55,9 +55,9 @@
 (var title nil)
 (var jerma nil)
 (fn theload []
-    (set font (love.graphics.newFont :APL333.ttf 72))
+    (set font (love.graphics.newFont :assets/APL333.ttf 72))
     (set title (love.graphics.newText font :mansion))
-    (set jerma (love.graphics.newImage :jerma.jpg))
+    (set jerma (love.graphics.newImage :assets/jerma.jpg))
     (world:add :jerma 30 400  400 50))
 
 (fn draw_jerma []
@@ -75,9 +75,9 @@
     (draw_thing)
     (draw_jerma))
 
-{ : world
-  : draw
-  :load theload }
+{: world
+ : draw
+ :load theload}
        
                      
 
diff --git a/src/player.fnl b/src/player.fnl
index a429282..68d4f27 100644
--- a/src/player.fnl
+++ b/src/player.fnl
@@ -1,9 +1,11 @@
-(local player { :x 250 :y 250 })
-
 (local SPEED 170)
 (local SPRINT-SPEED 280)
 
-(fn player.move [self dt world]
+(local C {})
+(set C.__index C)
+
+(fn C.update [self dt ?world]
+    (print ((. (require :vendor.fennel) :view) self))
     (let [speed (if (love.keyboard.isScancodeDown :lshift :rshift) 
                     SPRINT-SPEED SPEED)
           up    (if (love.keyboard.isScancodeDown :w :up) 1 0)
@@ -12,7 +14,9 @@
           right (if (love.keyboard.isScancodeDown :d :right) 1 0)
           vy (- down up)
           vx (- right left)
-          sf (math.sqrt (+ (* vx vx) (* vy vy)))]
+          sf (math.sqrt (+ (* vx vx) (* vy vy)))
+          world (if ?world ?world
+                    {:move (fn move [_2 tx ty] (values tx ty))})]
          (when (not= sf 0)
                (let [vx (/ vx sf)
                      vy (/ vy sf)
@@ -22,8 +26,13 @@
                     (tset self :x ax)
                     (tset self :y ay)))))
 
-(fn player.draw [self]
+(fn C.draw [self]
     (love.graphics.setColor 0.91 0.62 0)
     (love.graphics.rectangle :fill self.x self.y  10 10))
 
-player
+(fn make [] 
+    (let [s {:x 170 :y 150}]
+         (setmetatable s C)
+         s))
+         
+{: make}
diff --git a/src/rooms.fnl b/src/rooms.fnl
new file mode 100644
index 0000000..a343a79
--- /dev/null
+++ b/src/rooms.fnl
@@ -0,0 +1,22 @@
+(local corridor (require :src.corridor))
+(local fennel (require :vendor.fennel))
+
+(local state {})
+
+(fn theload []
+    (set state.font (love.graphics.newFont :assets/APL333.ttf 72))
+    (set state.cur-room (corridor.make state)))
+
+(fn update [dt]
+    (state.cur-room.update dt))
+
+(fn draw [...]
+    (local b [...])
+    (print (fennel.view b))
+    (state.cur-room.draw))
+
+{:load theload
+ : update
+ : draw}
+
+