From 595f877a76a32ef10d260d36922a71d836acb1d9 Mon Sep 17 00:00:00 2001 From: Lobster Date: Wed, 12 Nov 2025 17:55:14 -0500 Subject: [PATCH] Add project files and library for Tiled support --- main/assets/tiles.png | Bin 0 -> 23606 bytes main/libraries/sti/atlas.lua | 159 +++ main/libraries/sti/graphics.lua | 132 ++ main/libraries/sti/init.lua | 1748 ++++++++++++++++++++++++++ main/libraries/sti/plugins/box2d.lua | 323 +++++ main/libraries/sti/plugins/bump.lua | 193 +++ main/libraries/sti/utils.lua | 217 ++++ main/main.lua | 7 +- main/maps/debug_map.tmx | 72 ++ main/maps/sumeriangame.tiled-project | 14 + main/maps/tileset.tsx | 4 + 11 files changed, 2867 insertions(+), 2 deletions(-) create mode 100644 main/assets/tiles.png create mode 100644 main/libraries/sti/atlas.lua create mode 100644 main/libraries/sti/graphics.lua create mode 100644 main/libraries/sti/init.lua create mode 100644 main/libraries/sti/plugins/box2d.lua create mode 100644 main/libraries/sti/plugins/bump.lua create mode 100644 main/libraries/sti/utils.lua create mode 100644 main/maps/debug_map.tmx create mode 100644 main/maps/sumeriangame.tiled-project create mode 100644 main/maps/tileset.tsx diff --git a/main/assets/tiles.png b/main/assets/tiles.png new file mode 100644 index 0000000000000000000000000000000000000000..a7a8237e573ba765db12bc7835cfd78c90232cb7 GIT binary patch literal 23606 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 bf5xQ`XE-j{%k`Xrfq}u()z4*}Q$iB})%IuM literal 0 HcmV?d00001 diff --git a/main/libraries/sti/atlas.lua b/main/libraries/sti/atlas.lua new file mode 100644 index 0000000..302b332 --- /dev/null +++ b/main/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 diff --git a/main/libraries/sti/graphics.lua b/main/libraries/sti/graphics.lua new file mode 100644 index 0000000..6acf8d6 --- /dev/null +++ b/main/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 diff --git a/main/libraries/sti/init.lua b/main/libraries/sti/init.lua new file mode 100644 index 0000000..646a224 --- /dev/null +++ b/main/libraries/sti/init.lua @@ -0,0 +1,1748 @@ +--- Simple and fast Tiled map loader and renderer. +-- @module sti +-- @author Landon Manning +-- @copyright 2019 +-- @license MIT/X11 + +local STI = { + _LICENSE = "MIT/X11", + _URL = "https://github.com/karai17/Simple-Tiled-Implementation", + _VERSION = "1.2.3.0", + _DESCRIPTION = "Simple Tiled Implementation is a Tiled Map Editor library designed for the *awesome* LÖVE framework.", + cache = {} +} +STI.__index = STI + +local love = _G.love +local cwd = (...):gsub('%.init$', '') .. "." +local utils = require(cwd .. "utils") +local ceil = math.ceil +local floor = math.floor +local lg = require(cwd .. "graphics") +local atlas = require(cwd .. "atlas") +local Map = {} +Map.__index = Map + +local function new(map, plugins, ox, oy) + local dir = "" + + if type(map) == "table" then + map = setmetatable(map, Map) + else + -- Check for valid map type + local ext = map:sub(-4, -1) + assert(ext == ".lua", string.format( + "Invalid file type: %s. File must be of type: lua.", + ext + )) + + -- Get directory of map + dir = map:reverse():find("[/\\]") or "" + if dir ~= "" then + dir = map:sub(1, 1 + (#map - dir)) + end + + -- Load map + map = setmetatable(assert(love.filesystem.load(map))(), Map) + end + + map:init(dir, plugins, ox, oy) + + return map +end + +--- Instance a new map. +-- @param map Path to the map file or the map table itself +-- @param plugins A list of plugins to load +-- @param ox Offset of map on the X axis (in pixels) +-- @param oy Offset of map on the Y axis (in pixels) +-- @return table The loaded Map +function STI.__call(_, map, plugins, ox, oy) + return new(map, plugins, ox, oy) +end + +--- Flush image cache. +function STI:flush() + self.cache = {} +end + +--- Map object + +--- Instance a new map +-- @param path Path to the map file +-- @param plugins A list of plugins to load +-- @param ox Offset of map on the X axis (in pixels) +-- @param oy Offset of map on the Y axis (in pixels) +function Map:init(path, plugins, ox, oy) + if type(plugins) == "table" then + self:loadPlugins(plugins) + end + + self:resize() + self.objects = {} + self.tiles = {} + self.tileInstances = {} + self.offsetx = ox or 0 + self.offsety = oy or 0 + + self.freeBatchSprites = {} + setmetatable(self.freeBatchSprites, { __mode = 'k' }) + + -- Set tiles, images + local gid = 1 + for i, tileset in ipairs(self.tilesets) do + assert(not tileset.filename, "STI does not support external Tilesets.\nYou need to embed all Tilesets.") + + if tileset.image then + -- Cache images + if lg.isCreated then + local formatted_path = utils.format_path(path .. tileset.image) + + if not STI.cache[formatted_path] then + utils.fix_transparent_color(tileset, formatted_path) + utils.cache_image(STI, formatted_path, tileset.image) + else + tileset.image = STI.cache[formatted_path] + end + end + + gid = self:setTiles(i, tileset, gid) + elseif tileset.tilecount > 0 then + -- Build atlas for image collection + local files, ids = {}, {} + for j = 1, #tileset.tiles do + files[ j ] = utils.format_path(path .. tileset.tiles[j].image) + ids[ j ] = tileset.tiles[j].id + end + + local map = atlas.Atlas( files, "ids", ids ) + + if lg.isCreated then + local formatted_path = utils.format_path(path .. tileset.name) + + if not STI.cache[formatted_path] then + -- No need to fix transparency color for collections + utils.cache_image(STI, formatted_path, map.image) + tileset.image = map.image + else + tileset.image = STI.cache[formatted_path] + end + end + + gid = self:setAtlasTiles(i, tileset, map.coords, gid) + end + end + + local layers = {} + for _, layer in ipairs(self.layers) do + self:groupAppendToList(layers, layer) + end + self.layers = layers + + -- Set layers + for _, layer in ipairs(self.layers) do + self:setLayer(layer, path) + end +end + +--- Layers from the group are added to the list +-- @param layers List of layers +-- @param layer Layer data +function Map:groupAppendToList(layers, layer) + if layer.type == "group" then + for _, groupLayer in pairs(layer.layers) do + groupLayer.name = layer.name .. "." .. groupLayer.name + groupLayer.visible = layer.visible + groupLayer.opacity = layer.opacity * groupLayer.opacity + groupLayer.offsetx = layer.offsetx + groupLayer.offsetx + groupLayer.offsety = layer.offsety + groupLayer.offsety + + for key, property in pairs(layer.properties) do + if groupLayer.properties[key] == nil then + groupLayer.properties[key] = property + end + end + + self:groupAppendToList(layers, groupLayer) + end + else + table.insert(layers, layer) + end +end + +--- Load plugins +-- @param plugins A list of plugins to load +function Map:loadPlugins(plugins) + for _, plugin in ipairs(plugins) do + local pluginModulePath = cwd .. 'plugins.' .. plugin + local ok, pluginModule = pcall(require, pluginModulePath) + if ok then + for k, func in pairs(pluginModule) do + if not self[k] then + self[k] = func + end + end + end + end +end + +--- Create Tiles based on a single tileset image +-- @param index Index of the Tileset +-- @param tileset Tileset data +-- @param gid First Global ID in Tileset +-- @return number Next Tileset's first Global ID +function Map:setTiles(index, tileset, gid) + local quad = lg.newQuad + local imageW = tileset.imagewidth + local imageH = tileset.imageheight + local tileW = tileset.tilewidth + local tileH = tileset.tileheight + local margin = tileset.margin + local spacing = tileset.spacing + local w = utils.get_tiles(imageW, tileW, margin, spacing) + local h = utils.get_tiles(imageH, tileH, margin, spacing) + + for y = 1, h do + for x = 1, w do + local id = gid - tileset.firstgid + local quadX = (x - 1) * tileW + margin + (x - 1) * spacing + local quadY = (y - 1) * tileH + margin + (y - 1) * spacing + local type = "" + local properties, terrain, animation, objectGroup + + for _, tile in pairs(tileset.tiles) do + if tile.id == id then + properties = tile.properties + animation = tile.animation + objectGroup = tile.objectGroup + type = tile.type + + if tile.terrain then + terrain = {} + + for i = 1, #tile.terrain do + terrain[i] = tileset.terrains[tile.terrain[i] + 1] + end + end + end + end + + local tile = { + id = id, + gid = gid, + tileset = index, + type = type, + quad = quad( + quadX, quadY, + tileW, tileH, + imageW, imageH + ), + properties = properties or {}, + terrain = terrain, + animation = animation, + objectGroup = objectGroup, + frame = 1, + time = 0, + width = tileW, + height = tileH, + sx = 1, + sy = 1, + r = 0, + offset = tileset.tileoffset, + } + + self.tiles[gid] = tile + gid = gid + 1 + end + end + + return gid +end + +--- Create Tiles based on a texture atlas +-- @param index Index of the Tileset +-- @param tileset Tileset data +-- @param coords Tile XY location in the atlas +-- @param gid First Global ID in Tileset +-- @return number Next Tileset's first Global ID +function Map:setAtlasTiles(index, tileset, coords, gid) + local quad = lg.newQuad + local imageW = tileset.image:getWidth() + local imageH = tileset.image:getHeight() + + local firstgid = tileset.firstgid + for i = 1, #tileset.tiles do + local tile = tileset.tiles[i] + if tile.terrain then + terrain = {} + + for j = 1, #tile.terrain do + terrain[j] = tileset.terrains[tile.terrain[j] + 1] + end + end + + local tile = { + id = tile.id, + gid = firstgid + tile.id, + tileset = index, + class = tile.class, + quad = quad( + coords[i].x, coords[i].y, + tile.width, tile.height, + imageW, imageH + ), + properties = tile.properties or {}, + terrain = terrain, + animation = tile.animation, + objectGroup = tile.objectGroup, + frame = 1, + time = 0, + width = tile.width, + height = tile.height, + sx = 1, + sy = 1, + r = 0, + offset = tileset.tileoffset, + } + + -- Be aware that in collections self.tiles can be a sparse array + self.tiles[tile.gid] = tile + end + + return gid + #tileset.tiles +end + +--- Create Layers +-- @param layer Layer data +-- @param path (Optional) Path to an Image Layer's image +function Map:setLayer(layer, path) + if layer.encoding then + if layer.encoding == "base64" then + assert(require "ffi", "Compressed maps require LuaJIT FFI.\nPlease Switch your interperator to LuaJIT or your Tile Layer Format to \"CSV\".") + local fd = love.data.decode("string", "base64", layer.data) + + if not layer.compression then + layer.data = utils.get_decompressed_data(fd) + else + assert(love.data.decompress, "zlib and gzip compression require LOVE 11.0+.\nPlease set your Tile Layer Format to \"Base64 (uncompressed)\" or \"CSV\".") + + if layer.compression == "zlib" then + local data = love.data.decompress("string", "zlib", fd) + layer.data = utils.get_decompressed_data(data) + end + + if layer.compression == "gzip" then + local data = love.data.decompress("string", "gzip", fd) + layer.data = utils.get_decompressed_data(data) + end + end + end + end + + layer.x = (layer.x or 0) + layer.offsetx + self.offsetx + layer.y = (layer.y or 0) + layer.offsety + self.offsety + layer.update = function() end + + if layer.type == "tilelayer" then + self:setTileData(layer) + self:setSpriteBatches(layer) + layer.draw = function() self:drawTileLayer(layer) end + elseif layer.type == "objectgroup" then + self:setObjectData(layer) + self:setObjectCoordinates(layer) + self:setObjectSpriteBatches(layer) + layer.draw = function() self:drawObjectLayer(layer) end + elseif layer.type == "imagelayer" then + layer.draw = function() self:drawImageLayer(layer) end + + if layer.image ~= "" then + local formatted_path = utils.format_path(path .. layer.image) + if not STI.cache[formatted_path] then + utils.cache_image(STI, formatted_path) + end + + layer.image = STI.cache[formatted_path] + layer.width = layer.image:getWidth() + layer.height = layer.image:getHeight() + end + end + + self.layers[layer.name] = layer +end + +--- Add Tiles to Tile Layer +-- @param layer The Tile Layer +function Map:setTileData(layer) + if layer.chunks then + for _, chunk in ipairs(layer.chunks) do + self:setTileData(chunk) + end + return + end + + local i = 1 + local map = {} + + for y = 1, layer.height do + map[y] = {} + for x = 1, layer.width do + local gid = layer.data[i] + + -- NOTE: Empty tiles have a GID of 0 + if gid > 0 then + map[y][x] = self.tiles[gid] or self:setFlippedGID(gid) + end + + i = i + 1 + end + end + + layer.data = map +end + +--- Add Objects to Layer +-- @param layer The Object Layer +function Map:setObjectData(layer) + for _, object in ipairs(layer.objects) do + object.layer = layer + self.objects[object.id] = object + end +end + +--- Correct position and orientation of Objects in an Object Layer +-- @param layer The Object Layer +function Map:setObjectCoordinates(layer) + for _, object in ipairs(layer.objects) do + local x = layer.x + object.x + local y = layer.y + object.y + local w = object.width + local h = object.height + local cos = math.cos(math.rad(object.rotation)) + local sin = math.sin(math.rad(object.rotation)) + + if object.shape == "rectangle" and not object.gid then + object.rectangle = {} + + local vertices = { + { x=x, y=y }, + { x=x + w, y=y }, + { x=x + w, y=y + h }, + { x=x, y=y + h }, + } + + for _, vertex in ipairs(vertices) do + vertex.x, vertex.y = utils.rotate_vertex(self, vertex, x, y, cos, sin) + table.insert(object.rectangle, { x = vertex.x, y = vertex.y }) + end + elseif object.shape == "ellipse" then + object.ellipse = {} + local vertices = utils.convert_ellipse_to_polygon(x, y, w, h) + + for _, vertex in ipairs(vertices) do + vertex.x, vertex.y = utils.rotate_vertex(self, vertex, x, y, cos, sin) + table.insert(object.ellipse, { x = vertex.x, y = vertex.y }) + end + elseif object.shape == "polygon" then + for _, vertex in ipairs(object.polygon) do + vertex.x = vertex.x + x + vertex.y = vertex.y + y + vertex.x, vertex.y = utils.rotate_vertex(self, vertex, x, y, cos, sin) + end + elseif object.shape == "polyline" then + for _, vertex in ipairs(object.polyline) do + vertex.x = vertex.x + x + vertex.y = vertex.y + y + vertex.x, vertex.y = utils.rotate_vertex(self, vertex, x, y, cos, sin) + end + end + end +end + +--- Convert tile location to tile instance location +-- @param layer Tile layer +-- @param tile Tile +-- @param x Tile location on X axis (in tiles) +-- @param y Tile location on Y axis (in tiles) +-- @return number Tile instance location on X axis (in pixels) +-- @return number Tile instance location on Y axis (in pixels) +function Map:getLayerTilePosition(layer, tile, x, y) + local tileW = self.tilewidth + local tileH = self.tileheight + local tileX, tileY + + if self.orientation == "orthogonal" then + tileX = (x - 1) * tileW + tile.offset.x + tileY = (y - 0) * tileH + tile.offset.y - tile.height + tileX, tileY = utils.compensate(tile, tileX, tileY, tileW, tileH) + elseif self.orientation == "isometric" then + tileX = (x - y) * (tileW / 2) + tile.offset.x + layer.width * tileW / 2 - self.tilewidth / 2 + tileY = (x + y - 2) * (tileH / 2) + tile.offset.y + else + local sideLen = self.hexsidelength or 0 + if self.staggeraxis == "y" then + if self.staggerindex == "odd" then + if y % 2 == 0 then + tileX = (x - 1) * tileW + tileW / 2 + tile.offset.x + else + tileX = (x - 1) * tileW + tile.offset.x + end + else + if y % 2 == 0 then + tileX = (x - 1) * tileW + tile.offset.x + else + tileX = (x - 1) * tileW + tileW / 2 + tile.offset.x + end + end + + local rowH = tileH - (tileH - sideLen) / 2 + tileY = (y - 1) * rowH + tile.offset.y + else + if self.staggerindex == "odd" then + if x % 2 == 0 then + tileY = (y - 1) * tileH + tileH / 2 + tile.offset.y + else + tileY = (y - 1) * tileH + tile.offset.y + end + else + if x % 2 == 0 then + tileY = (y - 1) * tileH + tile.offset.y + else + tileY = (y - 1) * tileH + tileH / 2 + tile.offset.y + end + end + + local colW = tileW - (tileW - sideLen) / 2 + tileX = (x - 1) * colW + tile.offset.x + end + end + + return tileX, tileY +end + +--- Place new tile instance +-- @param layer Tile layer +-- @param chunk Layer chunk +-- @param tile Tile +-- @param number Tile location on X axis (in tiles) +-- @param number Tile location on Y axis (in tiles) +function Map:addNewLayerTile(layer, chunk, tile, x, y) + local tileset = tile.tileset + local image = self.tilesets[tile.tileset].image + local batches + local size + + if chunk then + batches = chunk.batches + size = chunk.width * chunk.height + else + batches = layer.batches + size = layer.width * layer.height + end + + batches[tileset] = batches[tileset] or lg.newSpriteBatch(image, size) + + local batch = batches[tileset] + local tileX, tileY = self:getLayerTilePosition(layer, tile, x, y) + + local instance = { + layer = layer, + chunk = chunk, + gid = tile.gid, + x = tileX, + y = tileY, + r = tile.r, + oy = 0 + } + + -- NOTE: STI can run headless so it is not guaranteed that a batch exists. + if batch then + instance.batch = batch + instance.id = batch:add(tile.quad, tileX, tileY, tile.r, tile.sx, tile.sy) + end + + self.tileInstances[tile.gid] = self.tileInstances[tile.gid] or {} + table.insert(self.tileInstances[tile.gid], instance) +end + +function Map:set_batches(layer, chunk) + if chunk then + chunk.batches = {} + else + layer.batches = {} + end + + if self.orientation == "orthogonal" or self.orientation == "isometric" then + local offsetX = chunk and chunk.x or 0 + local offsetY = chunk and chunk.y or 0 + + local startX = 1 + local startY = 1 + local endX = chunk and chunk.width or layer.width + local endY = chunk and chunk.height or layer.height + local incrementX = 1 + local incrementY = 1 + + -- Determine order to add tiles to sprite batch + -- Defaults to right-down + if self.renderorder == "right-up" then + startY, endY, incrementY = endY, startY, -1 + elseif self.renderorder == "left-down" then + startX, endX, incrementX = endX, startX, -1 + elseif self.renderorder == "left-up" then + startX, endX, incrementX = endX, startX, -1 + startY, endY, incrementY = endY, startY, -1 + end + + for y = startY, endY, incrementY do + for x = startX, endX, incrementX do + -- NOTE: Cannot short circuit this since it is valid for tile to be assigned nil + local tile + if chunk then + tile = chunk.data[y][x] + else + tile = layer.data[y][x] + end + + if tile then + self:addNewLayerTile(layer, chunk, tile, x + offsetX, y + offsetY) + end + end + end + else + if self.staggeraxis == "y" then + for y = 1, (chunk and chunk.height or layer.height) do + for x = 1, (chunk and chunk.width or layer.width) do + -- NOTE: Cannot short circuit this since it is valid for tile to be assigned nil + local tile + if chunk then + tile = chunk.data[y][x] + else + tile = layer.data[y][x] + end + + if tile then + self:addNewLayerTile(layer, chunk, tile, x, y) + end + end + end + else + local i = 0 + local _x + + if self.staggerindex == "odd" then + _x = 1 + else + _x = 2 + end + + while i < (chunk and chunk.width * chunk.height or layer.width * layer.height) do + for _y = 1, (chunk and chunk.height or layer.height) + 0.5, 0.5 do + local y = floor(_y) + + for x = _x, (chunk and chunk.width or layer.width), 2 do + i = i + 1 + + -- NOTE: Cannot short circuit this since it is valid for tile to be assigned nil + local tile + if chunk then + tile = chunk.data[y][x] + else + tile = layer.data[y][x] + end + + if tile then + self:addNewLayerTile(layer, chunk, tile, x, y) + end + end + + if _x == 1 then + _x = 2 + else + _x = 1 + end + end + end + end + end +end + +--- Batch Tiles in Tile Layer for improved draw speed +-- @param layer The Tile Layer +function Map:setSpriteBatches(layer) + if layer.chunks then + for _, chunk in ipairs(layer.chunks) do + self:set_batches(layer, chunk) + end + return + end + + self:set_batches(layer) +end + +--- Batch Tiles in Object Layer for improved draw speed +-- @param layer The Object Layer +function Map:setObjectSpriteBatches(layer) + local newBatch = lg.newSpriteBatch + local batches = {} + + if layer.draworder == "topdown" then + table.sort(layer.objects, function(a, b) + return a.y + a.height < b.y + b.height + end) + end + + for _, object in ipairs(layer.objects) do + if object.gid then + local tile = self.tiles[object.gid] or self:setFlippedGID(object.gid) + local tileset = tile.tileset + local image = self.tilesets[tileset].image + + batches[tileset] = batches[tileset] or newBatch(image) + + local sx = object.width / tile.width + local sy = object.height / tile.height + + -- Tiled rotates around bottom left corner, where love2D rotates around top left corner + local ox = 0 + local oy = tile.height + + local batch = batches[tileset] + local tileX = object.x + tile.offset.x + local tileY = object.y + tile.offset.y + local tileR = math.rad(object.rotation) + + -- Compensation for scale/rotation shift + if tile.sx == -1 then + tileX = tileX + object.width + + if tileR ~= 0 then + tileX = tileX - object.width + ox = ox + tile.width + end + end + + if tile.sy == -1 then + tileY = tileY - object.height + + if tileR ~= 0 then + tileY = tileY + object.width + oy = oy - tile.width + end + end + + local instance = { + id = batch:add(tile.quad, tileX, tileY, tileR, tile.sx * sx, tile.sy * sy, ox, oy), + batch = batch, + layer = layer, + gid = tile.gid, + x = tileX, + y = tileY - oy, + r = tileR, + oy = oy + } + + self.tileInstances[tile.gid] = self.tileInstances[tile.gid] or {} + table.insert(self.tileInstances[tile.gid], instance) + end + end + + layer.batches = batches +end + +--- Create a Custom Layer to place userdata in (such as player sprites) +-- @param name Name of Custom Layer +-- @param index Draw order within Layer stack +-- @return table Custom Layer +function Map:addCustomLayer(name, index) + index = index or #self.layers + 1 + local layer = { + type = "customlayer", + name = name, + visible = true, + opacity = 1, + properties = {}, + } + + function layer.draw() end + function layer.update() end + + table.insert(self.layers, index, layer) + self.layers[name] = self.layers[index] + + return layer +end + +--- Convert another Layer into a Custom Layer +-- @param index Index or name of Layer to convert +-- @return table Custom Layer +function Map:convertToCustomLayer(index) + local layer = assert(self.layers[index], "Layer not found: " .. index) + + layer.type = "customlayer" + layer.x = nil + layer.y = nil + layer.width = nil + layer.height = nil + layer.encoding = nil + layer.data = nil + layer.chunks = nil + layer.objects = nil + layer.image = nil + + function layer.draw() end + function layer.update() end + + return layer +end + +--- Remove a Layer from the Layer stack +-- @param index Index or name of Layer to remove +function Map:removeLayer(index) + local layer = assert(self.layers[index], "Layer not found: " .. index) + + if type(index) == "string" then + for i, l in ipairs(self.layers) do + if l.name == index then + table.remove(self.layers, i) + self.layers[index] = nil + break + end + end + else + local name = self.layers[index].name + table.remove(self.layers, index) + self.layers[name] = nil + end + + -- Remove layer batches + if layer.batches then + for _, batch in pairs(layer.batches) do + self.freeBatchSprites[batch] = nil + end + end + + -- Remove chunk batches + if layer.chunks then + for _, chunk in ipairs(layer.chunks) do + for _, batch in pairs(chunk.batches) do + self.freeBatchSprites[batch] = nil + end + end + end + + -- Remove tile instances + if layer.type == "tilelayer" then + for _, tiles in pairs(self.tileInstances) do + for i = #tiles, 1, -1 do + local tile = tiles[i] + if tile.layer == layer then + table.remove(tiles, i) + end + end + end + end + + -- Remove objects + if layer.objects then + for i, object in pairs(self.objects) do + if object.layer == layer then + self.objects[i] = nil + end + end + end +end + +--- Animate Tiles and update every Layer +-- @param dt Delta Time +function Map:update(dt) + for _, tile in pairs(self.tiles) do + local update = false + + if tile.animation then + tile.time = tile.time + dt * 1000 + + while tile.time > tonumber(tile.animation[tile.frame].duration) do + update = true + tile.time = tile.time - tonumber(tile.animation[tile.frame].duration) + tile.frame = tile.frame + 1 + + if tile.frame > #tile.animation then tile.frame = 1 end + end + + if update and self.tileInstances[tile.gid] then + for _, j in pairs(self.tileInstances[tile.gid]) do + local t = self.tiles[tonumber(tile.animation[tile.frame].tileid) + self.tilesets[tile.tileset].firstgid] + j.batch:set(j.id, t.quad, j.x, j.y, j.r, tile.sx, tile.sy, 0, j.oy) + end + end + end + end + + for _, layer in ipairs(self.layers) do + layer:update(dt) + end +end + +--- Draw every Layer +-- @param tx Translate on X +-- @param ty Translate on Y +-- @param sx Scale on X +-- @param sy Scale on Y +function Map:draw(tx, ty, sx, sy) + local current_canvas = lg.getCanvas() + lg.setCanvas(self.canvas) + lg.clear() + + -- Scale map to 1.0 to draw onto canvas, this fixes tearing issues + -- Map is translated to correct position so the right section is drawn + lg.push() + lg.origin() + + --[[ + This snippet comes from 'monolifed' on the Love2D forums, + however it was more or less exactly the same code I was already writing + to implement the same parallax scrolling. I found his before + testing and polishing mine + https://love2d.org/forums/viewtopic.php?p=238378#p238378 + + previous code commented below the new. + + ]] + + tx, ty = tx or 0, ty or 0 + + for _, layer in ipairs(self.layers) do + if layer.visible and layer.opacity > 0 then + local px, py = layer.parallaxx or 1, layer.parallaxy or 1 + px, py = math.floor(tx * px), math.floor(ty * py) + lg.translate(px, py) + self:drawLayer(layer) + lg.translate(-px, -py) + end + end + + --[[ + lg.translate(math.floor(tx or 0), math.floor(ty or 0)) + + for _, layer in ipairs(self.layers) do + if layer.visible and layer.opacity > 0 then + self:drawLayer(layer) + end + end + ]] + + lg.pop() + + -- Draw canvas at 0,0; this fixes scissoring issues + -- Map is scaled to correct scale so the right section is shown + lg.push() + lg.origin() + lg.scale(sx or 1, sy or sx or 1) + + lg.setCanvas(current_canvas) + lg.draw(self.canvas) + + lg.pop() +end + +--- Draw an individual Layer +-- @param layer The Layer to draw +function Map.drawLayer(_, layer) + local r,g,b,a = lg.getColor() + -- if the layer has a tintcolor set + if layer.tintcolor then + r, g, b, a = unpack(layer.tintcolor) + a = a or 255 -- alpha may not be specified + lg.setColor(r/255, g/255, b/255, a/255) -- Tiled uses 0-255 + -- if a tintcolor is not given just use the current color + else + lg.setColor(r, g, b, a * layer.opacity) + end + layer:draw() + lg.setColor(r,g,b,a) +end + +--- Default draw function for Tile Layers +-- @param layer The Tile Layer to draw +function Map:drawTileLayer(layer) + if type(layer) == "string" or type(layer) == "number" then + layer = self.layers[layer] + end + + assert(layer.type == "tilelayer", "Invalid layer type: " .. layer.type .. ". Layer must be of type: tilelayer") + + -- NOTE: This does not take into account any sort of draw range clipping and will always draw every chunk + if layer.chunks then + for _, chunk in ipairs(layer.chunks) do + for _, batch in pairs(chunk.batches) do + lg.draw(batch, 0, 0) + end + end + + return + end + + for _, batch in pairs(layer.batches) do + lg.draw(batch, floor(layer.x), floor(layer.y)) + end +end + +--- Default draw function for Object Layers +-- @param layer The Object Layer to draw +function Map:drawObjectLayer(layer) + if type(layer) == "string" or type(layer) == "number" then + layer = self.layers[layer] + end + + assert(layer.type == "objectgroup", "Invalid layer type: " .. layer.type .. ". Layer must be of type: objectgroup") + + local line = { 160, 160, 160, 255 * layer.opacity } + local fill = { 160, 160, 160, 255 * layer.opacity * 0.5 } + local r,g,b,a = lg.getColor() + local reset = { r, g, b, a * layer.opacity } + + local function sortVertices(obj) + local vertex = {} + + for _, v in ipairs(obj) do + table.insert(vertex, v.x) + table.insert(vertex, v.y) + end + + return vertex + end + + local function drawShape(obj, shape) + local vertex = sortVertices(obj) + + if shape == "polyline" then + lg.setColor(line) + lg.line(vertex) + return + elseif shape == "polygon" then + lg.setColor(fill) + if not love.math.isConvex(vertex) then + local triangles = love.math.triangulate(vertex) + for _, triangle in ipairs(triangles) do + lg.polygon("fill", triangle) + end + else + lg.polygon("fill", vertex) + end + else + lg.setColor(fill) + lg.polygon("fill", vertex) + end + + lg.setColor(line) + lg.polygon("line", vertex) + end + + for _, object in ipairs(layer.objects) do + if object.visible then + if object.shape == "rectangle" and not object.gid then + drawShape(object.rectangle, "rectangle") + elseif object.shape == "ellipse" then + drawShape(object.ellipse, "ellipse") + elseif object.shape == "polygon" then + drawShape(object.polygon, "polygon") + elseif object.shape == "polyline" then + drawShape(object.polyline, "polyline") + elseif object.shape == "point" then + lg.points(object.x, object.y) + end + end + end + + lg.setColor(reset) + for _, batch in pairs(layer.batches) do + lg.draw(batch, 0, 0) + end + lg.setColor(r,g,b,a) +end + +--- Default draw function for Image Layers +-- @param layer The Image Layer to draw +function Map:drawImageLayer(layer) + if type(layer) == "string" or type(layer) == "number" then + layer = self.layers[layer] + end + + assert(layer.type == "imagelayer", "Invalid layer type: " .. layer.type .. ". Layer must be of type: imagelayer") + + if layer.image ~= "" then + lg.draw(layer.image, layer.x, layer.y) + -- we need pixel sizes for drawing + local imagewidth, imageheight = layer.image:getDimensions() + -- if we're repeating on the Y axis... + if layer.repeaty then + local x = imagewidth + local y = imageheight + while y < self.height * self.tileheight do + lg.draw(layer.image, x, y) + -- if we are *also* repeating on X + if layer.repeatx then + x = x + imagewidth + while x < self.width * self.tilewidth do + lg.draw(layer.image, x, y) + x = x + imagewidth + end + end + y = y + imageheight + end + -- if we're repeating on X alone... + elseif layer.repeatx then + local x = imagewidth + while x < self.width * self.tilewidth do + lg.draw(layer.image, x, layer.y) + x = x + imagewidth + end + end + end +end + +--- Resize the drawable area of the Map +-- @param w The new width of the drawable area (in pixels) +-- @param h The new Height of the drawable area (in pixels) +function Map:resize(w, h) + if lg.isCreated then + w = w or lg.getWidth() + h = h or lg.getHeight() + + self.canvas = lg.newCanvas(w, h) + self.canvas:setFilter("nearest", "nearest") + end +end + +--- Create flipped or rotated Tiles based on bitop flags +-- @param gid The flagged Global ID +-- @return table Flipped Tile +function Map:setFlippedGID(gid) + local bit31 = 2147483648 + local bit30 = 1073741824 + local bit29 = 536870912 + local flipX = false + local flipY = false + local flipD = false + local realgid = gid + + if realgid >= bit31 then + realgid = realgid - bit31 + flipX = not flipX + end + + if realgid >= bit30 then + realgid = realgid - bit30 + flipY = not flipY + end + + if realgid >= bit29 then + realgid = realgid - bit29 + flipD = not flipD + end + + local tile = self.tiles[realgid] + local data = { + id = tile.id, + gid = gid, + tileset = tile.tileset, + frame = tile.frame, + time = tile.time, + width = tile.width, + height = tile.height, + offset = tile.offset, + quad = tile.quad, + properties = tile.properties, + terrain = tile.terrain, + animation = tile.animation, + sx = tile.sx, + sy = tile.sy, + r = tile.r, + } + + if flipX then + if flipY and flipD then + data.r = math.rad(-90) + data.sy = -1 + elseif flipY then + data.sx = -1 + data.sy = -1 + elseif flipD then + data.r = math.rad(90) + else + data.sx = -1 + end + elseif flipY then + if flipD then + data.r = math.rad(-90) + else + data.sy = -1 + end + elseif flipD then + data.r = math.rad(90) + data.sy = -1 + end + + self.tiles[gid] = data + + return self.tiles[gid] +end + +--- Get custom properties from Layer +-- @param layer The Layer +-- @return table List of properties +function Map:getLayerProperties(layer) + local l = self.layers[layer] + + if not l then + return {} + end + + return l.properties +end + +--- Get custom properties from Tile +-- @param layer The Layer that the Tile belongs to +-- @param x The X axis location of the Tile (in tiles) +-- @param y The Y axis location of the Tile (in tiles) +-- @return table List of properties +function Map:getTileProperties(layer, x, y) + local tile = self.layers[layer].data[y][x] + + if not tile then + return {} + end + + return tile.properties +end + +--- Get custom properties from Object +-- @param layer The Layer that the Object belongs to +-- @param object The index or name of the Object +-- @return table List of properties +function Map:getObjectProperties(layer, object) + local o = self.layers[layer].objects + + if type(object) == "number" then + o = o[object] + else + for _, v in ipairs(o) do + if v.name == object then + o = v + break + end + end + end + + if not o then + return {} + end + + return o.properties +end + +--- Change a tile in a layer to another tile +-- @param layer The Layer that the Tile belongs to +-- @param x The X axis location of the Tile (in tiles) +-- @param y The Y axis location of the Tile (in tiles) +-- @param gid The gid of the new tile +function Map:setLayerTile(layer, x, y, gid) + layer = self.layers[layer] + + layer.data[y] = layer.data[y] or {} + local tile = layer.data[y][x] + local instance + if tile then + local tileX, tileY = self:getLayerTilePosition(layer, tile, x, y) + for _, inst in pairs(self.tileInstances[tile.gid]) do + if inst.x == tileX and inst.y == tileY then + instance = inst + break + end + end + end + + if tile == self.tiles[gid] then + return + end + + tile = self.tiles[gid] + + if instance then + self:swapTile(instance, tile) + else + self:addNewLayerTile(layer, tile, x, y) + end + layer.data[y][x] = tile +end + +--- Swap a tile in a spritebatch +-- @param instance The current Instance object we want to replace +-- @param tile The Tile object we want to use +-- @return none +function Map:swapTile(instance, tile) + -- Update sprite batch + if instance.batch then + if tile then + instance.batch:set( + instance.id, + tile.quad, + instance.x, + instance.y, + tile.r, + tile.sx, + tile.sy + ) + else + instance.batch:set( + instance.id, + instance.x, + instance.y, + 0, + 0) + + self.freeBatchSprites[instance.batch] = self.freeBatchSprites[instance.batch] or {} + table.insert(self.freeBatchSprites[instance.batch], instance) + end + end + + -- Remove old tile instance + for i, ins in ipairs(self.tileInstances[instance.gid]) do + if ins.batch == instance.batch and ins.id == instance.id then + table.remove(self.tileInstances[instance.gid], i) + break + end + end + + -- Add new tile instance + if tile then + self.tileInstances[tile.gid] = self.tileInstances[tile.gid] or {} + + local freeBatchSprites = self.freeBatchSprites[instance.batch] + local newInstance + if freeBatchSprites and #freeBatchSprites > 0 then + newInstance = freeBatchSprites[#freeBatchSprites] + freeBatchSprites[#freeBatchSprites] = nil + else + newInstance = {} + end + + newInstance.layer = instance.layer + newInstance.batch = instance.batch + newInstance.id = instance.id + newInstance.gid = tile.gid or 0 + newInstance.x = instance.x + newInstance.y = instance.y + newInstance.r = tile.r or 0 + newInstance.oy = tile.r ~= 0 and tile.height or 0 + table.insert(self.tileInstances[tile.gid], newInstance) + end +end + +--- Convert tile location to pixel location +-- @param x The X axis location of the point (in tiles) +-- @param y The Y axis location of the point (in tiles) +-- @return number The X axis location of the point (in pixels) +-- @return number The Y axis location of the point (in pixels) +function Map:convertTileToPixel(x,y) + if self.orientation == "orthogonal" then + local tileW = self.tilewidth + local tileH = self.tileheight + return + x * tileW, + y * tileH + elseif self.orientation == "isometric" then + local mapH = self.height + local tileW = self.tilewidth + local tileH = self.tileheight + local offsetX = mapH * tileW / 2 + return + (x - y) * tileW / 2 + offsetX, + (x + y) * tileH / 2 + elseif self.orientation == "staggered" or + self.orientation == "hexagonal" then + local tileW = self.tilewidth + local tileH = self.tileheight + local sideLen = self.hexsidelength or 0 + + if self.staggeraxis == "x" then + return + x * tileW, + ceil(y) * (tileH + sideLen) + (ceil(y) % 2 == 0 and tileH or 0) + else + return + ceil(x) * (tileW + sideLen) + (ceil(x) % 2 == 0 and tileW or 0), + y * tileH + end + end +end + +--- Convert pixel location to tile location +-- @param x The X axis location of the point (in pixels) +-- @param y The Y axis location of the point (in pixels) +-- @return number The X axis location of the point (in tiles) +-- @return number The Y axis location of the point (in tiles) +function Map:convertPixelToTile(x, y) + if self.orientation == "orthogonal" then + local tileW = self.tilewidth + local tileH = self.tileheight + return + x / tileW, + y / tileH + elseif self.orientation == "isometric" then + local mapH = self.height + local tileW = self.tilewidth + local tileH = self.tileheight + local offsetX = mapH * tileW / 2 + return + y / tileH + (x - offsetX) / tileW, + y / tileH - (x - offsetX) / tileW + elseif self.orientation == "staggered" then + local staggerX = self.staggeraxis == "x" + local even = self.staggerindex == "even" + + local function topLeft(x, y) + if staggerX then + if ceil(x) % 2 == 1 and even then + return x - 1, y + else + return x - 1, y - 1 + end + else + if ceil(y) % 2 == 1 and even then + return x, y - 1 + else + return x - 1, y - 1 + end + end + end + + local function topRight(x, y) + if staggerX then + if ceil(x) % 2 == 1 and even then + return x + 1, y + else + return x + 1, y - 1 + end + else + if ceil(y) % 2 == 1 and even then + return x + 1, y - 1 + else + return x, y - 1 + end + end + end + + local function bottomLeft(x, y) + if staggerX then + if ceil(x) % 2 == 1 and even then + return x - 1, y + 1 + else + return x - 1, y + end + else + if ceil(y) % 2 == 1 and even then + return x, y + 1 + else + return x - 1, y + 1 + end + end + end + + local function bottomRight(x, y) + if staggerX then + if ceil(x) % 2 == 1 and even then + return x + 1, y + 1 + else + return x + 1, y + end + else + if ceil(y) % 2 == 1 and even then + return x + 1, y + 1 + else + return x, y + 1 + end + end + end + + local tileW = self.tilewidth + local tileH = self.tileheight + + if staggerX then + x = x - (even and tileW / 2 or 0) + else + y = y - (even and tileH / 2 or 0) + end + + local halfH = tileH / 2 + local ratio = tileH / tileW + local referenceX = ceil(x / tileW) + local referenceY = ceil(y / tileH) + local relativeX = x - referenceX * tileW + local relativeY = y - referenceY * tileH + + if (halfH - relativeX * ratio > relativeY) then + return topLeft(referenceX, referenceY) + elseif (-halfH + relativeX * ratio > relativeY) then + return topRight(referenceX, referenceY) + elseif (halfH + relativeX * ratio < relativeY) then + return bottomLeft(referenceX, referenceY) + elseif (halfH * 3 - relativeX * ratio < relativeY) then + return bottomRight(referenceX, referenceY) + end + + return referenceX, referenceY + elseif self.orientation == "hexagonal" then + local staggerX = self.staggeraxis == "x" + local even = self.staggerindex == "even" + local tileW = self.tilewidth + local tileH = self.tileheight + local sideLenX = 0 + local sideLenY = 0 + + local colW = tileW / 2 + local rowH = tileH / 2 + if staggerX then + sideLenX = self.hexsidelength + x = x - (even and tileW or (tileW - sideLenX) / 2) + colW = colW - (colW - sideLenX / 2) / 2 + else + sideLenY = self.hexsidelength + y = y - (even and tileH or (tileH - sideLenY) / 2) + rowH = rowH - (rowH - sideLenY / 2) / 2 + end + + local referenceX = ceil(x) / (colW * 2) + local referenceY = ceil(y) / (rowH * 2) + + -- If in staggered line, then shift reference by 0.5 of other axes + if staggerX then + if (floor(referenceX) % 2 == 0) == even then + referenceY = referenceY - 0.5 + end + else + if (floor(referenceY) % 2 == 0) == even then + referenceX = referenceX - 0.5 + end + end + + local relativeX = x - referenceX * colW * 2 + local relativeY = y - referenceY * rowH * 2 + local centers + + if staggerX then + local left = sideLenX / 2 + local centerX = left + colW + local centerY = tileH / 2 + + centers = { + { x = left, y = centerY }, + { x = centerX, y = centerY - rowH }, + { x = centerX, y = centerY + rowH }, + { x = centerX + colW, y = centerY }, + } + else + local top = sideLenY / 2 + local centerX = tileW / 2 + local centerY = top + rowH + + centers = { + { x = centerX, y = top }, + { x = centerX - colW, y = centerY }, + { x = centerX + colW, y = centerY }, + { x = centerX, y = centerY + rowH } + } + end + + local nearest = 0 + local minDist = math.huge + + local function len2(ax, ay) + return ax * ax + ay * ay + end + + for i = 1, 4 do + local dc = len2(centers[i].x - relativeX, centers[i].y - relativeY) + + if dc < minDist then + minDist = dc + nearest = i + end + end + + local offsetsStaggerX = { + { x = 1, y = 1 }, + { x = 2, y = 0 }, + { x = 2, y = 1 }, + { x = 3, y = 1 }, + } + + local offsetsStaggerY = { + { x = 1, y = 1 }, + { x = 0, y = 2 }, + { x = 1, y = 2 }, + { x = 1, y = 3 }, + } + + local offsets = staggerX and offsetsStaggerX or offsetsStaggerY + + return + referenceX + offsets[nearest].x, + referenceY + offsets[nearest].y + end +end + +--- A list of individual layers indexed both by draw order and name +-- @table Map.layers +-- @see TileLayer +-- @see ObjectLayer +-- @see ImageLayer +-- @see CustomLayer + +--- A list of individual tiles indexed by Global ID +-- @table Map.tiles +-- @see Tile +-- @see Map.tileInstances + +--- A list of tile instances indexed by Global ID +-- @table Map.tileInstances +-- @see TileInstance +-- @see Tile +-- @see Map.tiles + +--- A list of no-longer-used batch sprites, indexed by batch +--@table Map.freeBatchSprites + +--- A list of individual objects indexed by Global ID +-- @table Map.objects +-- @see Object + +--- @table TileLayer +-- @field name The name of the layer +-- @field x Position on the X axis (in pixels) +-- @field y Position on the Y axis (in pixels) +-- @field width Width of layer (in tiles) +-- @field height Height of layer (in tiles) +-- @field visible Toggle if layer is visible or hidden +-- @field opacity Opacity of layer +-- @field properties Custom properties +-- @field data A tileWo dimensional table filled with individual tiles indexed by [y][x] (in tiles) +-- @field update Update function +-- @field draw Draw function +-- @see Map.layers +-- @see Tile + +--- @table ObjectLayer +-- @field name The name of the layer +-- @field x Position on the X axis (in pixels) +-- @field y Position on the Y axis (in pixels) +-- @field visible Toggle if layer is visible or hidden +-- @field opacity Opacity of layer +-- @field properties Custom properties +-- @field objects List of objects indexed by draw order +-- @field update Update function +-- @field draw Draw function +-- @see Map.layers +-- @see Object + +--- @table ImageLayer +-- @field name The name of the layer +-- @field x Position on the X axis (in pixels) +-- @field y Position on the Y axis (in pixels) +-- @field visible Toggle if layer is visible or hidden +-- @field opacity Opacity of layer +-- @field properties Custom properties +-- @field image Image to be drawn +-- @field update Update function +-- @field draw Draw function +-- @see Map.layers + +--- Custom Layers are used to place userdata such as sprites within the draw order of the map. +-- @table CustomLayer +-- @field name The name of the layer +-- @field x Position on the X axis (in pixels) +-- @field y Position on the Y axis (in pixels) +-- @field visible Toggle if layer is visible or hidden +-- @field opacity Opacity of layer +-- @field properties Custom properties +-- @field update Update function +-- @field draw Draw function +-- @see Map.layers +-- @usage +-- -- Create a Custom Layer +-- local spriteLayer = map:addCustomLayer("Sprite Layer", 3) +-- +-- -- Add data to Custom Layer +-- spriteLayer.sprites = { +-- player = { +-- image = lg.newImage("assets/sprites/player.png"), +-- x = 64, +-- y = 64, +-- r = 0, +-- } +-- } +-- +-- -- Update callback for Custom Layer +-- function spriteLayer:update(dt) +-- for _, sprite in pairs(self.sprites) do +-- sprite.r = sprite.r + math.rad(90 * dt) +-- end +-- end +-- +-- -- Draw callback for Custom Layer +-- function spriteLayer:draw() +-- for _, sprite in pairs(self.sprites) do +-- local x = math.floor(sprite.x) +-- local y = math.floor(sprite.y) +-- local r = sprite.r +-- lg.draw(sprite.image, x, y, r) +-- end +-- end + +--- @table Tile +-- @field id Local ID within Tileset +-- @field gid Global ID +-- @field tileset Tileset ID +-- @field quad Quad object +-- @field properties Custom properties +-- @field terrain Terrain data +-- @field animation Animation data +-- @field frame Current animation frame +-- @field time Time spent on current animation frame +-- @field width Width of tile +-- @field height Height of tile +-- @field sx Scale value on the X axis +-- @field sy Scale value on the Y axis +-- @field r Rotation of tile (in radians) +-- @field offset Offset drawing position +-- @field offset.x Offset value on the X axis +-- @field offset.y Offset value on the Y axis +-- @see Map.tiles + +--- @table TileInstance +-- @field batch Spritebatch the Tile Instance belongs to +-- @field id ID within the spritebatch +-- @field gid Global ID +-- @field x Position on the X axis (in pixels) +-- @field y Position on the Y axis (in pixels) +-- @see Map.tileInstances +-- @see Tile + +--- @table Object +-- @field id Global ID +-- @field name Name of object (non-unique) +-- @field shape Shape of object +-- @field x Position of object on X axis (in pixels) +-- @field y Position of object on Y axis (in pixels) +-- @field width Width of object (in pixels) +-- @field height Heigh tof object (in pixels) +-- @field rotation Rotation of object (in radians) +-- @field visible Toggle if object is visible or hidden +-- @field properties Custom properties +-- @field ellipse List of verticies of specific shape +-- @field rectangle List of verticies of specific shape +-- @field polygon List of verticies of specific shape +-- @field polyline List of verticies of specific shape +-- @see Map.objects + +return setmetatable({}, STI) diff --git a/main/libraries/sti/plugins/box2d.lua b/main/libraries/sti/plugins/box2d.lua new file mode 100644 index 0000000..c6d4148 --- /dev/null +++ b/main/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 diff --git a/main/libraries/sti/plugins/bump.lua b/main/libraries/sti/plugins/bump.lua new file mode 100644 index 0000000..1d4b828 --- /dev/null +++ b/main/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 diff --git a/main/libraries/sti/utils.lua b/main/libraries/sti/utils.lua new file mode 100644 index 0000000..95e857a --- /dev/null +++ b/main/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 diff --git a/main/main.lua b/main/main.lua index 883cbce..7c4848d 100644 --- a/main/main.lua +++ b/main/main.lua @@ -4,8 +4,11 @@ local conf = require('conf') local assets = require('assets') function love.load() - love.graphics.setFont(assets.get_font('Cuneiform36')) - love.audio.play(assets.get_source("intro")) + + sti = require' libraries/sti' + + love.graphics.setFont(assets.get_font('Cuneiform36')) + love.audio.play(assets.get_source("intro")) end function love.update(delta_time) diff --git a/main/maps/debug_map.tmx b/main/maps/debug_map.tmx new file mode 100644 index 0000000..d3d85ce --- /dev/null +++ b/main/maps/debug_map.tmx @@ -0,0 +1,72 @@ + + + + + +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 + + + + +844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,844,844,844,844,844,844,844,844,844,0,0,844,844,844,844,844,844,844,844,844,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,844, +844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844,844 + + + diff --git a/main/maps/sumeriangame.tiled-project b/main/maps/sumeriangame.tiled-project new file mode 100644 index 0000000..d0eb592 --- /dev/null +++ b/main/maps/sumeriangame.tiled-project @@ -0,0 +1,14 @@ +{ + "automappingRulesFile": "", + "commands": [ + ], + "compatibilityVersion": 1100, + "extensionsPath": "extensions", + "folders": [ + "." + ], + "properties": [ + ], + "propertyTypes": [ + ] +} diff --git a/main/maps/tileset.tsx b/main/maps/tileset.tsx new file mode 100644 index 0000000..0d1e92a --- /dev/null +++ b/main/maps/tileset.tsx @@ -0,0 +1,4 @@ + + + + -- 2.56.0