init

libraries/anim8.lua

@@ -0,0 +1,305 @@
+local anim8 = {
+  _VERSION     = 'anim8 v2.3.1',
+  _DESCRIPTION = 'An animation library for LÖVE',
+  _URL         = 'https://github.com/kikito/anim8',
+  _LICENSE     = [[
+    MIT LICENSE
+
+    Copyright (c) 2011 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.
+  ]]
+}
+
+local Grid = {}
+
+local _frames = {}
+
+local function assertPositiveInteger(value, name)
+  if type(value) ~= 'number' then error(("%s should be a number, was %q"):format(name, tostring(value))) end
+  if value < 1 then error(("%s should be a positive number, was %d"):format(name, value)) end
+  if value ~= math.floor(value) then error(("%s should be an integer, was %f"):format(name, value)) end
+end
+
+local function createFrame(self, x, y)
+  local fw, fh = self.frameWidth, self.frameHeight
+  return love.graphics.newQuad(
+    self.left + (x - 1) * fw + x * self.border,
+    self.top + (y - 1) * fh + y * self.border,
+    fw,
+    fh,
+    self.imageWidth,
+    self.imageHeight
+  )
+end
+
+local function getGridKey(...)
+  return table.concat({ ... }, '-')
+end
+
+local function getOrCreateFrame(self, x, y)
+  if x < 1 or x > self.width or y < 1 or y > self.height then
+    error(("There is no frame for x=%d, y=%d"):format(x, y))
+  end
+  local key          = self._key
+  _frames[key]       = _frames[key] or {}
+  _frames[key][x]    = _frames[key][x] or {}
+  _frames[key][x][y] = _frames[key][x][y] or createFrame(self, x, y)
+  return _frames[key][x][y]
+end
+
+local function parseInterval(str)
+  if type(str) == "number" then return str, str, 1 end
+  str = str:gsub('%s', '') -- remove spaces
+  local min, max = str:match("^(%d+)-(%d+)$")
+  assert(min and max, ("Could not parse interval from %q"):format(str))
+  min, max = tonumber(min), tonumber(max)
+  local step = min <= max and 1 or -1
+  return min, max, step
+end
+
+function Grid:getFrames(...)
+  local result, args = {}, { ... }
+  local minx, maxx, stepx, miny, maxy, stepy
+
+  for i = 1, #args, 2 do
+    minx, maxx, stepx = parseInterval(args[i])
+    miny, maxy, stepy = parseInterval(args[i + 1])
+    for y = miny, maxy, stepy do
+      for x = minx, maxx, stepx do
+        result[#result + 1] = getOrCreateFrame(self, x, y)
+      end
+    end
+  end
+
+  return result
+end
+
+local Gridmt = {
+  __index = Grid,
+  __call  = Grid.getFrames
+}
+
+local function newGrid(frameWidth, frameHeight, imageWidth, imageHeight, left, top, border)
+  assertPositiveInteger(frameWidth, "frameWidth")
+  assertPositiveInteger(frameHeight, "frameHeight")
+  assertPositiveInteger(imageWidth, "imageWidth")
+  assertPositiveInteger(imageHeight, "imageHeight")
+
+  left       = left or 0
+  top        = top or 0
+  border     = border or 0
+
+  local key  = getGridKey(frameWidth, frameHeight, imageWidth, imageHeight, left, top, border)
+
+  local grid = setmetatable(
+    {
+      frameWidth  = frameWidth,
+      frameHeight = frameHeight,
+      imageWidth  = imageWidth,
+      imageHeight = imageHeight,
+      left        = left,
+      top         = top,
+      border      = border,
+      width       = math.floor(imageWidth / frameWidth),
+      height      = math.floor(imageHeight / frameHeight),
+      _key        = key
+    },
+    Gridmt
+  )
+  return grid
+end
+
+-----------------------------------------------------------
+
+local Animation = {}
+
+local function cloneArray(arr)
+  local result = {}
+  for i = 1, #arr do result[i] = arr[i] end
+  return result
+end
+
+local function parseDurations(durations, frameCount)
+  local result = {}
+  if type(durations) == 'number' then
+    for i = 1, frameCount do result[i] = durations end
+  else
+    local min, max, step
+    for key, duration in pairs(durations) do
+      assert(type(duration) == 'number', "The value [" .. tostring(duration) .. "] should be a number")
+      min, max, step = parseInterval(key)
+      for i = min, max, step do result[i] = duration end
+    end
+  end
+
+  if #result < frameCount then
+    error("The durations table has length of " .. tostring(#result) .. ", but it should be >= " .. tostring(frameCount))
+  end
+
+  return result
+end
+
+local function parseIntervals(durations)
+  local result, time = { 0 }, 0
+  for i = 1, #durations do
+    time = time + durations[i]
+    result[i + 1] = time
+  end
+  return result, time
+end
+
+local Animationmt = { __index = Animation }
+local nop = function() end
+
+local function newAnimation(frames, durations, onLoop)
+  local td = type(durations);
+  if (td ~= 'number' or durations <= 0) and td ~= 'table' then
+    error("durations must be a positive number. Was " .. tostring(durations))
+  end
+  onLoop = onLoop or nop
+  durations = parseDurations(durations, #frames)
+  local intervals, totalDuration = parseIntervals(durations)
+  return setmetatable({
+      frames        = cloneArray(frames),
+      durations     = durations,
+      intervals     = intervals,
+      totalDuration = totalDuration,
+      onLoop        = onLoop,
+      timer         = 0,
+      position      = 1,
+      status        = "playing",
+      flippedH      = false,
+      flippedV      = false
+    },
+    Animationmt
+  )
+end
+
+function Animation:clone()
+  local newAnim = newAnimation(self.frames, self.durations, self.onLoop)
+  newAnim.flippedH, newAnim.flippedV = self.flippedH, self.flippedV
+  return newAnim
+end
+
+function Animation:flipH()
+  self.flippedH = not self.flippedH
+  return self
+end
+
+function Animation:flipV()
+  self.flippedV = not self.flippedV
+  return self
+end
+
+local function seekFrameIndex(intervals, timer)
+  local high, low, i = #intervals - 1, 1, 1
+
+  while (low <= high) do
+    i = math.floor((low + high) / 2)
+    if timer >= intervals[i + 1] then
+      low = i + 1
+    elseif timer < intervals[i] then
+      high = i - 1
+    else
+      return i
+    end
+  end
+
+  return i
+end
+
+function Animation:update(dt)
+  if self.status ~= "playing" then return end
+
+  self.timer = self.timer + dt
+  local loops = math.floor(self.timer / self.totalDuration)
+  if loops ~= 0 then
+    self.timer = self.timer - self.totalDuration * loops
+    local f = type(self.onLoop) == 'function' and self.onLoop or self[self.onLoop]
+    f(self, loops)
+  end
+
+  self.position = seekFrameIndex(self.intervals, self.timer)
+end
+
+function Animation:pause()
+  self.status = "paused"
+end
+
+function Animation:gotoFrame(position)
+  self.position = position
+  self.timer = self.intervals[self.position]
+end
+
+function Animation:pauseAtEnd()
+  self.position = #self.frames
+  self.timer = self.totalDuration
+  self:pause()
+end
+
+function Animation:pauseAtStart()
+  self.position = 1
+  self.timer = 0
+  self:pause()
+end
+
+function Animation:resume()
+  self.status = "playing"
+end
+
+function Animation:draw(image, x, y, r, sx, sy, ox, oy, kx, ky)
+  love.graphics.draw(image, self:getFrameInfo(x, y, r, sx, sy, ox, oy, kx, ky))
+end
+
+function Animation:getFrameInfo(x, y, r, sx, sy, ox, oy, kx, ky)
+  local frame = self.frames[self.position]
+  if self.flippedH or self.flippedV then
+    r, sx, sy, ox, oy, kx, ky = r or 0, sx or 1, sy or 1, ox or 0, oy or 0, kx or 0, ky or 0
+    local _, _, w, h = frame:getViewport()
+
+    if self.flippedH then
+      sx = sx * -1
+      ox = w - ox
+      kx = kx * -1
+      ky = ky * -1
+    end
+
+    if self.flippedV then
+      sy = sy * -1
+      oy = h - oy
+      kx = kx * -1
+      ky = ky * -1
+    end
+  end
+  return frame, x, y, r, sx, sy, ox, oy, kx, ky
+end
+
+function Animation:getDimensions()
+  local _, _, w, h = self.frames[self.position]:getViewport()
+  return w, h
+end
+
+-----------------------------------------------------------
+
+anim8.newGrid      = newGrid
+anim8.newAnimation = newAnimation
+
+return anim8

libraries/sti/atlas.lua

@@ -0,0 +1,159 @@
+---- Texture atlas complement for the Simple Tiled Implementation
+-- @copyright 2022
+-- @author Eduardo Hernández coz.eduardo.hernandez@gmail.com
+-- @license MIT/X11
+
+local module = {}
+
+--- Create a texture atlas
+-- @param files Array with filenames
+-- @param sort If "size" will sort by size, or if "id" will sort by id
+-- @param ids Array with ids of each file
+-- @param pow2 If true, will force a power of 2 size
+function module.Atlas( files, sort, ids, pow2 )
+
+    local function Node(x, y, w, h)
+        return {x = x, y = y, w = w, h = h}
+    end
+
+    local function nextpow2( n )
+        local res = 1
+        while res <= n do
+            res = res * 2
+        end
+        return res
+    end
+
+    local function loadImgs()
+        local images = {}
+        for i = 1, #files do
+            images[i] = {}
+            --images[i].name = files[i]
+            if ids then images[i].id = ids[i] end
+            images[i].img = love.graphics.newImage( files[i] )
+            images[i].w = images[i].img:getWidth()
+            images[i].h = images[i].img:getHeight()
+            images[i].area = images[i].w * images[i].h
+        end
+        if sort == "size" or sort == "id" then
+            table.sort( images, function( a, b ) return ( a.area > b.area ) end )
+        end
+        return images
+    end
+
+    --TODO: understand this func
+    local function add(root, id, w, h)
+        if root.left or root.right then
+            if root.left then
+                local node = add(root.left, id, w, h)
+                if node then return node end
+            end
+            if root.right then
+                local node = add(root.right, id, w, h)
+                if node then return node end
+            end
+            return nil
+        end
+
+        if w > root.w or h > root.h then return nil end
+
+        local _w, _h = root.w - w, root.h - h
+
+        if _w <= _h then
+            root.left = Node(root.x + w, root.y, _w, h)
+            root.right = Node(root.x, root.y + h, root.w, _h)
+        else
+            root.left = Node(root.x, root.y + h, w, _h)
+            root.right = Node(root.x + w, root.y, _w, root.h)
+        end
+
+        root.w = w
+        root.h = h
+        root.id = id
+
+        return root
+    end
+
+    local function unmap(root)
+        if not root then return {} end
+
+        local tree = {}
+        if root.id then
+            tree[root.id] = {}
+            tree[root.id].x, tree[root.id].y = root.x, root.y
+        end
+
+        local left = unmap(root.left)
+        local right = unmap(root.right)
+
+        for k, v in pairs(left) do
+            tree[k] = {}
+            tree[k].x, tree[k].y = v.x, v.y
+        end
+        for k, v in pairs(right) do
+            tree[k] = {}
+            tree[k].x, tree[k].y = v.x, v.y
+        end
+
+        return tree
+    end
+
+    local function bake()
+        local images = loadImgs()
+
+        local root = {}
+        local w, h = images[1].w, images[1].h
+
+        if pow2 then
+            if w % 1 == 0 then w = nextpow2(w) end
+            if h % 1 == 0 then h = nextpow2(h) end
+        end
+
+        repeat
+            local node
+
+            root = Node(0, 0, w, h)
+
+            for i = 1, #images do
+                node = add(root, i, images[i].w, images[i].h)
+                if not node then break end
+            end
+
+            if not node then
+                if h <= w then
+                    if pow2 then h = h * 2 else h = h + 1 end
+                else
+                    if pow2 then w = w * 2 else w = w + 1 end
+                end
+            else
+                break
+            end
+        until false
+
+        local limits = love.graphics.getSystemLimits()
+        if w > limits.texturesize or h > limits.texturesize then
+            return "Resulting texture is too large for this system"
+        end
+
+        local coords = unmap(root)
+        local map = love.graphics.newCanvas(w, h)
+        love.graphics.setCanvas( map )
+--        love.graphics.clear()
+
+        for i = 1, #images do
+            love.graphics.draw(images[i].img, coords[i].x, coords[i].y)
+            if ids then coords[i].id = images[i].id end
+        end
+        love.graphics.setCanvas()
+
+        if sort == "ids" then
+            table.sort( coords, function( a, b ) return ( a.id < b.id ) end )
+        end
+
+        return { image = map, coords = coords }
+    end
+
+    return bake()
+end
+
+return module

libraries/sti/graphics.lua

@@ -0,0 +1,132 @@
+local lg       = _G.love.graphics
+local graphics = { isCreated = lg and true or false }
+
+function graphics.newSpriteBatch(...)
+	if graphics.isCreated then
+		return lg.newSpriteBatch(...)
+	end
+end
+
+function graphics.newCanvas(...)
+	if graphics.isCreated then
+		return lg.newCanvas(...)
+	end
+end
+
+function graphics.newImage(...)
+	if graphics.isCreated then
+		return lg.newImage(...)
+	end
+end
+
+function graphics.newQuad(...)
+	if graphics.isCreated then
+		return lg.newQuad(...)
+	end
+end
+
+function graphics.getCanvas(...)
+	if graphics.isCreated then
+		return lg.getCanvas(...)
+	end
+end
+
+function graphics.setCanvas(...)
+	if graphics.isCreated then
+		return lg.setCanvas(...)
+	end
+end
+
+function graphics.clear(...)
+	if graphics.isCreated then
+		return lg.clear(...)
+	end
+end
+
+function graphics.push(...)
+	if graphics.isCreated then
+		return lg.push(...)
+	end
+end
+
+function graphics.origin(...)
+	if graphics.isCreated then
+		return lg.origin(...)
+	end
+end
+
+function graphics.scale(...)
+	if graphics.isCreated then
+		return lg.scale(...)
+	end
+end
+
+function graphics.translate(...)
+	if graphics.isCreated then
+		return lg.translate(...)
+	end
+end
+
+function graphics.pop(...)
+	if graphics.isCreated then
+		return lg.pop(...)
+	end
+end
+
+function graphics.draw(...)
+	if graphics.isCreated then
+		return lg.draw(...)
+	end
+end
+
+function graphics.rectangle(...)
+	if graphics.isCreated then
+		return lg.rectangle(...)
+	end
+end
+
+function graphics.getColor(...)
+	if graphics.isCreated then
+		return lg.getColor(...)
+	end
+end
+
+function graphics.setColor(...)
+	if graphics.isCreated then
+		return lg.setColor(...)
+	end
+end
+
+function graphics.line(...)
+	if graphics.isCreated then
+		return lg.line(...)
+	end
+end
+
+function graphics.polygon(...)
+	if graphics.isCreated then
+		return lg.polygon(...)
+	end
+end
+
+function graphics.points(...)
+	if graphics.isCreated then
+		return lg.points(...)
+	end
+end
+
+function graphics.getWidth()
+	if graphics.isCreated then
+		return lg.getWidth()
+	end
+	return 0
+end
+
+function graphics.getHeight()
+	if graphics.isCreated then
+		return lg.getHeight()
+	end
+	return 0
+end
+
+return graphics

libraries/sti/plugins/box2d.lua

@@ -0,0 +1,323 @@
+--- Box2D plugin for STI
+-- @module box2d
+-- @author Landon Manning
+-- @copyright 2019
+-- @license MIT/X11
+
+local love  = _G.love
+local utils = require((...):gsub('plugins.box2d', 'utils'))
+local lg    = require((...):gsub('plugins.box2d', 'graphics'))
+
+return {
+	box2d_LICENSE     = "MIT/X11",
+	box2d_URL         = "https://github.com/karai17/Simple-Tiled-Implementation",
+	box2d_VERSION     = "2.3.2.7",
+	box2d_DESCRIPTION = "Box2D hooks for STI.",
+
+	--- Initialize Box2D physics world.
+	-- @param world The Box2D world to add objects to.
+	box2d_init = function(map, world)
+		assert(love.physics, "To use the Box2D plugin, please enable the love.physics module.")
+
+		local body      = love.physics.newBody(world, map.offsetx, map.offsety)
+		local collision = {
+			body = body,
+		}
+
+		local function addObjectToWorld(objshape, vertices, userdata, object)
+			local shape
+
+			if objshape == "polyline" then
+				if #vertices == 4 then
+					shape = love.physics.newEdgeShape(unpack(vertices))
+				else
+					shape = love.physics.newChainShape(false, unpack(vertices))
+				end
+			else
+				shape = love.physics.newPolygonShape(unpack(vertices))
+			end
+
+			local currentBody = body
+			--dynamic are objects/players etc.
+			if userdata.properties.dynamic == true then
+				currentBody = love.physics.newBody(world, map.offsetx, map.offsety, 'dynamic')
+			-- static means it shouldn't move. Things like walls/ground.
+			elseif userdata.properties.static == true then
+				currentBody = love.physics.newBody(world, map.offsetx, map.offsety, 'static')
+			-- kinematic means that the object is static in the game world but effects other bodies
+			elseif userdata.properties.kinematic == true then
+				currentBody = love.physics.newBody(world, map.offsetx, map.offsety, 'kinematic')			
+			end
+
+			local fixture = love.physics.newFixture(currentBody, shape)
+			fixture:setUserData(userdata)
+
+			-- Set some custom properties from userdata (or use default set by box2d)
+			fixture:setFriction(userdata.properties.friction       or 0.2)
+			fixture:setRestitution(userdata.properties.restitution or 0.0)
+			fixture:setSensor(userdata.properties.sensor           or false)
+			fixture:setFilterData(
+				userdata.properties.categories or 1,
+				userdata.properties.mask       or 65535,
+				userdata.properties.group      or 0
+			)
+
+			local obj = {
+				object  = object,
+				body    = currentBody,
+				shape   = shape,
+				fixture = fixture,
+			}
+
+			table.insert(collision, obj)
+		end
+
+		local function getPolygonVertices(object)
+			local vertices = {}
+			for _, vertex in ipairs(object.polygon) do
+				table.insert(vertices, vertex.x)
+				table.insert(vertices, vertex.y)
+			end
+
+			return vertices
+		end
+
+		local function calculateObjectPosition(object, tile)
+			local o = {
+				shape   = object.shape,
+				x       = (object.dx or object.x) + map.offsetx,
+				y       = (object.dy or object.y) + map.offsety,
+				w       = object.width,
+				h       = object.height,
+				polygon = object.polygon or object.polyline or object.ellipse or object.rectangle
+			}
+
+			local userdata = {
+				object     = o,
+				properties = object.properties
+			}
+
+			o.r = object.rotation or 0
+			if o.shape == "rectangle" then
+				local cos = math.cos(math.rad(o.r))
+				local sin = math.sin(math.rad(o.r))
+				local oy  = 0
+
+				if object.gid then
+					local tileset = map.tilesets[map.tiles[object.gid].tileset]
+					local lid     = object.gid - tileset.firstgid
+					local t       = {}
+
+					-- This fixes a height issue
+					 o.y = o.y + map.tiles[object.gid].offset.y
+					 oy  = o.h
+
+					for _, tt in ipairs(tileset.tiles) do
+						if tt.id == lid then
+							t = tt
+							break
+						end
+					end
+
+					if t.objectGroup then
+						for _, obj in ipairs(t.objectGroup.objects) do
+							-- Every object in the tile
+							calculateObjectPosition(obj, object)
+						end
+
+						return
+					else
+						o.w = map.tiles[object.gid].width
+						o.h = map.tiles[object.gid].height
+					end
+				end
+
+				o.polygon = {
+					{ x=o.x+0,   y=o.y+0   },
+					{ x=o.x+o.w, y=o.y+0   },
+					{ x=o.x+o.w, y=o.y+o.h },
+					{ x=o.x+0,   y=o.y+o.h }
+				}
+
+				for _, vertex in ipairs(o.polygon) do
+					vertex.x, vertex.y = utils.rotate_vertex(map, vertex, o.x, o.y, cos, sin, oy)
+				end
+
+				local vertices = getPolygonVertices(o)
+				addObjectToWorld(o.shape, vertices, userdata, tile or object)
+			elseif o.shape == "ellipse" then
+				if not o.polygon then
+					o.polygon = utils.convert_ellipse_to_polygon(o.x, o.y, o.w, o.h)
+				end
+				local vertices  = getPolygonVertices(o)
+				local triangles = love.math.triangulate(vertices)
+
+				for _, triangle in ipairs(triangles) do
+					addObjectToWorld(o.shape, triangle, userdata, tile or object)
+				end
+			elseif o.shape == "polygon" then
+				-- Recalculate collision polygons inside tiles
+				if tile then
+					local cos = math.cos(math.rad(o.r))
+					local sin = math.sin(math.rad(o.r))
+					for _, vertex in ipairs(o.polygon) do
+						vertex.x = vertex.x + o.x
+						vertex.y = vertex.y + o.y
+						vertex.x, vertex.y = utils.rotate_vertex(map, vertex, o.x, o.y, cos, sin)
+					end
+				end
+
+				local vertices  = getPolygonVertices(o)
+				local triangles = love.math.triangulate(vertices)
+
+				for _, triangle in ipairs(triangles) do
+					addObjectToWorld(o.shape, triangle, userdata, tile or object)
+				end
+			elseif o.shape == "polyline" then
+				local vertices = getPolygonVertices(o)
+				addObjectToWorld(o.shape, vertices, userdata, tile or object)
+			end
+		end
+
+		for _, tile in pairs(map.tiles) do
+			if map.tileInstances[tile.gid] then
+				for _, instance in ipairs(map.tileInstances[tile.gid]) do
+					-- Every object in every instance of a tile
+					if tile.objectGroup then
+						for _, object in ipairs(tile.objectGroup.objects) do
+							if object.properties.collidable == true then
+								object = utils.deepCopy(object)
+								object.dx = instance.x + object.x
+								object.dy = instance.y + object.y
+								calculateObjectPosition(object, instance)
+							end
+						end
+					end
+
+					-- Every instance of a tile
+					if tile.properties.collidable == true then
+						local object = {
+							shape      = "rectangle",
+							x          = instance.x,
+							y          = instance.y,
+							width      = map.tilewidth,
+							height     = map.tileheight,
+							properties = tile.properties
+						}
+
+						calculateObjectPosition(object, instance)
+					end
+				end
+			end
+		end
+
+		for _, layer in ipairs(map.layers) do
+			-- Entire layer
+			if layer.properties.collidable == true then
+				if layer.type == "tilelayer" then
+					for gid, tiles in pairs(map.tileInstances) do
+						local tile = map.tiles[gid]
+						local tileset = map.tilesets[tile.tileset]
+
+						for _, instance in ipairs(tiles) do
+							if instance.layer == layer then
+								local object = {
+									shape      = "rectangle",
+									x          = instance.x,
+									y          = instance.y,
+									width      = tileset.tilewidth,
+									height     = tileset.tileheight,
+									properties = tile.properties
+								}
+
+								calculateObjectPosition(object, instance)
+							end
+						end
+					end
+				elseif layer.type == "objectgroup" then
+					for _, object in ipairs(layer.objects) do
+						calculateObjectPosition(object)
+					end
+				elseif layer.type == "imagelayer" then
+					local object = {
+						shape      = "rectangle",
+						x          = layer.x or 0,
+						y          = layer.y or 0,
+						width      = layer.width,
+						height     = layer.height,
+						properties = layer.properties
+					}
+
+					calculateObjectPosition(object)
+				end
+			end
+
+			-- Individual objects
+			if layer.type == "objectgroup" then
+				for _, object in ipairs(layer.objects) do
+					if object.properties.collidable == true then
+						calculateObjectPosition(object)
+					end
+				end
+			end
+		end
+
+		map.box2d_collision = collision
+	end,
+
+	--- Remove Box2D fixtures and shapes from world.
+	-- @param index The index or name of the layer being removed
+	box2d_removeLayer = function(map, index)
+		local layer = assert(map.layers[index], "Layer not found: " .. index)
+		local collision = map.box2d_collision
+
+		-- Remove collision objects
+		for i = #collision, 1, -1 do
+			local obj = collision[i]
+
+			if obj.object.layer == layer then
+				obj.fixture:destroy()
+				table.remove(collision, i)
+			end
+		end
+	end,
+
+	--- Draw Box2D physics world.
+	-- @param tx Translate on X
+	-- @param ty Translate on Y
+	-- @param sx Scale on X
+	-- @param sy Scale on Y
+	box2d_draw = function(map, tx, ty, sx, sy)
+		local collision = map.box2d_collision
+
+		lg.push()
+		lg.scale(sx or 1, sy or sx or 1)
+		lg.translate(math.floor(tx or 0), math.floor(ty or 0))
+
+		for _, obj in ipairs(collision) do
+			local points = {obj.body:getWorldPoints(obj.shape:getPoints())}
+			local shape_type = obj.shape:getType()
+
+			if shape_type == "edge" or shape_type == "chain" then
+				love.graphics.line(points)
+			elseif shape_type == "polygon" then
+				love.graphics.polygon("line", points)
+			else
+				error("sti box2d plugin does not support "..shape_type.." shapes")
+			end
+		end
+
+		lg.pop()
+	end
+}
+
+--- Custom Properties in Tiled are used to tell this plugin what to do.
+-- @table Properties
+-- @field collidable set to true, can be used on any Layer, Tile, or Object
+-- @field sensor set to true, can be used on any Tile or Object that is also collidable
+-- @field dynamic set to true, can be used on any Tile or Object
+-- @field friction can be used to define the friction of any Object
+-- @field restitution can be used to define the restitution of any Object
+-- @field categories can be used to set the filter Category of any Object
+-- @field mask can be used to set the filter Mask of any Object
+-- @field group can be used to set the filter Group of any Object

libraries/sti/plugins/bump.lua

@@ -0,0 +1,193 @@
+--- Bump.lua plugin for STI
+-- @module bump.lua
+-- @author David Serrano (BobbyJones|FrenchFryLord)
+-- @copyright 2019
+-- @license MIT/X11
+
+local lg = require((...):gsub('plugins.bump', 'graphics'))
+
+return {
+	bump_LICENSE        = "MIT/X11",
+	bump_URL            = "https://github.com/karai17/Simple-Tiled-Implementation",
+	bump_VERSION        = "3.1.7.1",
+	bump_DESCRIPTION    = "Bump hooks for STI.",
+
+	--- Adds each collidable tile to the Bump world.
+	-- @param world The Bump world to add objects to.
+	-- @return collidables table containing the handles to the objects in the Bump world.
+	bump_init = function(map, world)
+		local collidables = {}
+
+		for _, tileset in ipairs(map.tilesets) do
+			for _, tile in ipairs(tileset.tiles) do
+				local gid = tileset.firstgid + tile.id
+
+				if map.tileInstances[gid] then
+					for _, instance in ipairs(map.tileInstances[gid]) do
+						-- Every object in every instance of a tile
+						if tile.objectGroup then
+							for _, object in ipairs(tile.objectGroup.objects) do
+								if object.properties.collidable == true then
+									local t = {
+										name       = object.name,
+										type       = object.type,
+										x          = instance.x + map.offsetx + object.x,
+										y          = instance.y + map.offsety + object.y,
+										width      = object.width,
+										height     = object.height,
+										layer      = instance.layer,
+										properties = object.properties
+
+									}
+
+									world:add(t, t.x, t.y, t.width, t.height)
+									table.insert(collidables, t)
+								end
+							end
+						end
+
+						-- Every instance of a tile
+						if tile.properties and tile.properties.collidable == true then
+							local t = {
+								x          = instance.x + map.offsetx,
+								y          = instance.y + map.offsety,
+								width      = map.tilewidth,
+								height     = map.tileheight,
+								layer      = instance.layer,
+								type       = tile.type,
+								properties = tile.properties
+							}
+
+							world:add(t, t.x, t.y, t.width, t.height)
+							table.insert(collidables, t)
+						end
+					end
+				end
+			end
+		end
+
+		for _, layer in ipairs(map.layers) do
+			-- Entire layer
+			if layer.properties.collidable == true then
+				if layer.type == "tilelayer" then
+					for y, tiles in ipairs(layer.data) do
+						for x, tile in pairs(tiles) do
+
+							if tile.objectGroup then
+								for _, object in ipairs(tile.objectGroup.objects) do
+									if object.properties.collidable == true then
+										local t = {
+											name       = object.name,
+											type       = object.type,
+											x          = ((x-1) * map.tilewidth  + tile.offset.x + map.offsetx) + object.x,
+											y          = ((y-1) * map.tileheight + tile.offset.y + map.offsety) + object.y,
+											width      = object.width,
+											height     = object.height,
+											layer      = layer,
+											properties = object.properties
+										}
+
+										world:add(t, t.x, t.y, t.width, t.height)
+										table.insert(collidables, t)
+									end
+								end
+							end
+
+
+							local t = {
+								x          = (x-1) * map.tilewidth  + tile.offset.x + map.offsetx,
+								y          = (y-1) * map.tileheight + tile.offset.y + map.offsety,
+								width      = tile.width,
+								height     = tile.height,
+								layer      = layer,
+								type       = tile.type,
+								properties = tile.properties
+							}
+
+							world:add(t, t.x, t.y, t.width, t.height)
+							table.insert(collidables, t)
+						end
+					end
+				elseif layer.type == "imagelayer" then
+					world:add(layer, layer.x, layer.y, layer.width, layer.height)
+					table.insert(collidables, layer)
+				end
+		  end
+
+			-- individual collidable objects in a layer that is not "collidable"
+			-- or whole collidable objects layer
+		  if layer.type == "objectgroup" then
+				for _, obj in ipairs(layer.objects) do
+					if layer.properties.collidable == true or obj.properties.collidable == true then
+						if obj.shape == "rectangle" then
+							local t = {
+								name       = obj.name,
+								type       = obj.type,
+								x          = obj.x + map.offsetx,
+								y          = obj.y + map.offsety,
+								width      = obj.width,
+								height     = obj.height,
+								layer      = layer,
+								properties = obj.properties
+							}
+
+							if obj.gid then
+								t.y = t.y - obj.height
+							end
+
+							world:add(t, t.x, t.y, t.width, t.height)
+							table.insert(collidables, t)
+						end -- TODO implement other object shapes?
+					end
+				end
+			end
+		end
+
+		map.bump_world       = world
+		map.bump_collidables = collidables
+	end,
+
+	--- Remove layer
+	-- @param index to layer to be removed
+	bump_removeLayer = function(map, index)
+		local layer = assert(map.layers[index], "Layer not found: " .. index)
+		local collidables = map.bump_collidables
+
+		-- Remove collision objects
+		for i = #collidables, 1, -1 do
+			local obj = collidables[i]
+
+			if obj.layer == layer
+			and (
+				layer.properties.collidable == true
+				or obj.properties.collidable == true
+			) then
+				map.bump_world:remove(obj)
+				table.remove(collidables, i)
+			end
+		end
+	end,
+
+	--- Draw bump collisions world.
+	-- @param world bump world holding the tiles geometry
+	-- @param tx Translate on X
+	-- @param ty Translate on Y
+	-- @param sx Scale on X
+	-- @param sy Scale on Y
+	bump_draw = function(map, tx, ty, sx, sy)
+		lg.push()
+		lg.scale(sx or 1, sy or sx or 1)
+		lg.translate(math.floor(tx or 0), math.floor(ty or 0))
+
+		local items = map.bump_world:getItems()
+		for _, item in ipairs(items) do
+			lg.rectangle("line", map.bump_world:getRect(item))
+		end
+
+		lg.pop()
+	end
+}
+
+--- Custom Properties in Tiled are used to tell this plugin what to do.
+-- @table Properties
+-- @field collidable set to true, can be used on any Layer, Tile, or Object

libraries/sti/utils.lua

@@ -0,0 +1,217 @@
+-- Some utility functions that shouldn't be exposed.
+local utils = {}
+
+-- https://github.com/stevedonovan/Penlight/blob/master/lua/pl/path.lua#L286
+function utils.format_path(path)
+	local np_gen1,np_gen2  = '[^SEP]+SEP%.%.SEP?','SEP+%.?SEP'
+	local np_pat1, np_pat2 = np_gen1:gsub('SEP','/'), np_gen2:gsub('SEP','/')
+	local k
+
+	repeat -- /./ -> /
+		path,k = path:gsub(np_pat2,'/',1)
+	until k == 0
+
+	repeat -- A/../ -> (empty)
+		path,k = path:gsub(np_pat1,'',1)
+	until k == 0
+
+	if path == '' then path = '.' end
+
+	return path
+end
+
+-- Compensation for scale/rotation shift
+function utils.compensate(tile, tileX, tileY, tileW, tileH)
+	local compx = 0
+	local compy = 0
+
+	if tile.sx < 0 then compx = tileW end
+	if tile.sy < 0 then compy = tileH end
+
+	if tile.r > 0 then
+		tileX = tileX + tileH - compy
+		tileY = tileY + tileH + compx - tileW
+	elseif tile.r < 0 then
+		tileX = tileX + compy
+		tileY = tileY - compx + tileH
+	else
+		tileX = tileX + compx
+		tileY = tileY + compy
+	end
+
+	return tileX, tileY
+end
+
+-- Cache images in main STI module
+function utils.cache_image(sti, path, image)
+	image = image or love.graphics.newImage(path)
+	image:setFilter("nearest", "nearest")
+	sti.cache[path] = image
+end
+
+-- We just don't know.
+function utils.get_tiles(imageW, tileW, margin, spacing)
+	imageW  = imageW - margin
+	local n = 0
+
+	while imageW >= tileW do
+		imageW = imageW - tileW
+		if n ~= 0 then imageW = imageW - spacing end
+		if imageW >= 0 then n  = n + 1 end
+	end
+
+	return n
+end
+
+-- Decompress tile layer data
+function utils.get_decompressed_data(data)
+	local ffi     = require "ffi"
+	local d       = {}
+	local decoded = ffi.cast("uint32_t*", data)
+
+	for i = 0, data:len() / ffi.sizeof("uint32_t") do
+		table.insert(d, tonumber(decoded[i]))
+	end
+
+	return d
+end
+
+-- Convert a Tiled ellipse object to a LOVE polygon
+function utils.convert_ellipse_to_polygon(x, y, w, h, max_segments)
+	local ceil = math.ceil
+	local cos  = math.cos
+	local sin  = math.sin
+
+	local function calc_segments(segments)
+		local function vdist(a, b)
+			local c = {
+				x = a.x - b.x,
+				y = a.y - b.y,
+			}
+
+			return c.x * c.x + c.y * c.y
+		end
+
+		segments = segments or 64
+		local vertices = {}
+
+		local v = { 1, 2, ceil(segments/4-1), ceil(segments/4) }
+
+		local m
+		if love and love.physics then
+			m = love.physics.getMeter()
+		else
+			m = 32
+		end
+
+		for _, i in ipairs(v) do
+			local angle = (i / segments) * math.pi * 2
+			local px    = x + w / 2 + cos(angle) * w / 2
+			local py    = y + h / 2 + sin(angle) * h / 2
+
+			table.insert(vertices, { x = px / m, y = py / m })
+		end
+
+		local dist1 = vdist(vertices[1], vertices[2])
+		local dist2 = vdist(vertices[3], vertices[4])
+
+		-- Box2D threshold
+		if dist1 < 0.0025 or dist2 < 0.0025 then
+			return calc_segments(segments-2)
+		end
+
+		return segments
+	end
+
+	local segments = calc_segments(max_segments)
+	local vertices = {}
+
+	table.insert(vertices, { x = x + w / 2, y = y + h / 2 })
+
+	for i = 0, segments do
+		local angle = (i / segments) * math.pi * 2
+		local px    = x + w / 2 + cos(angle) * w / 2
+		local py    = y + h / 2 + sin(angle) * h / 2
+
+		table.insert(vertices, { x = px, y = py })
+	end
+
+	return vertices
+end
+
+function utils.rotate_vertex(map, vertex, x, y, cos, sin, oy)
+	if map.orientation == "isometric" then
+		x, y               = utils.convert_isometric_to_screen(map, x, y)
+		vertex.x, vertex.y = utils.convert_isometric_to_screen(map, vertex.x, vertex.y)
+	end
+
+	vertex.x = vertex.x - x
+	vertex.y = vertex.y - y
+
+	return
+		x + cos * vertex.x - sin * vertex.y,
+		y + sin * vertex.x + cos * vertex.y - (oy or 0)
+end
+
+--- Project isometric position to cartesian position
+function utils.convert_isometric_to_screen(map, x, y)
+	local mapW    = map.width
+	local tileW   = map.tilewidth
+	local tileH   = map.tileheight
+	local tileX   = x / tileH
+	local tileY   = y / tileH
+	local offsetX = mapW * tileW / 2
+
+	return
+		(tileX - tileY) * tileW / 2 + offsetX,
+		(tileX + tileY) * tileH / 2
+end
+
+function utils.hex_to_color(hex)
+	if hex:sub(1, 1) == "#" then
+		hex = hex:sub(2)
+	end
+
+	return {
+		r = tonumber(hex:sub(1, 2), 16) / 255,
+		g = tonumber(hex:sub(3, 4), 16) / 255,
+		b = tonumber(hex:sub(5, 6), 16) / 255
+	}
+end
+
+function utils.pixel_function(_, _, r, g, b, a)
+	local mask = utils._TC
+
+	if r == mask.r and
+		g == mask.g and
+		b == mask.b then
+		return r, g, b, 0
+	end
+
+	return r, g, b, a
+end
+
+function utils.fix_transparent_color(tileset, path)
+	local image_data = love.image.newImageData(path)
+	tileset.image = love.graphics.newImage(image_data)
+
+	if tileset.transparentcolor then
+		utils._TC = utils.hex_to_color(tileset.transparentcolor)
+
+		image_data:mapPixel(utils.pixel_function)
+		tileset.image = love.graphics.newImage(image_data)
+	end
+end
+
+function utils.deepCopy(t)
+	local copy = {}
+	for k,v in pairs(t) do
+		if type(v) == "table" then
+			v = utils.deepCopy(v)
+		end
+		copy[k] = v
+	end
+	return copy
+end
+
+return utils