Initial commit

.gitignore

@@ -0,0 +1,2 @@
+*.love
+.idea

.luacheckrc

@@ -0,0 +1,4 @@
+std = "lua54+love"
+stds.project = {
+   globals = {"tiny"},
+}

.luarc.json

@@ -0,0 +1,8 @@
+{
+    "runtime.special": {
+        "love.filesystem.load": "loadfile"
+    },
+    "workspace.library": [
+        "${3rd}/love2d/library"
+    ]
+}

.styluaignore

@@ -0,0 +1 @@
+generated/

ASSETS.license

@@ -0,0 +1 @@
+All image and music assets © 2025 by Sage Vaillancourt are licensed under CC BY 4.0. To view a copy of this license, visit https://creativecommons.org/licenses/by/4.0/

CODE.license

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sage Vaillancourt
+
+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.

Makefile

@@ -0,0 +1,15 @@
+preprocess:
+	find ./ -name '*.lua2p' | xargs -L1 -I %% lua lib/preprocess-cl.lua %%
+
+check: preprocess
+	stylua -c --indent-type Spaces ./
+	luacheck -d --globals tiny T Arr Maybe TextStyle --codes ./ --exclude-files ./test/ ./generated/
+
+test: check
+	find ./test -name '*.lua' | xargs -L1 -I %% lua %% -v
+
+lint:
+	stylua --indent-type Spaces ./
+
+build: preprocess
+	zip -r Game.love ./*

README.md

@@ -0,0 +1,3 @@
+# Game
+
+Built on Love 11.5

generated/all-systems.lua

@@ -0,0 +1,8 @@
+require("../systems/camera-pan")
+require("../systems/collision-detection")
+require("../systems/collision-resolution")
+require("../systems/decay")
+require("../systems/draw")
+require("../systems/gravity")
+require("../systems/input")
+require("../systems/velocity")

generated/all-systems.lua2p

@@ -0,0 +1,13 @@
+!(
+function getAllSystems()
+    local p = io.popen('find ./systems -iname "*.lua"  -maxdepth 1 -type f | sort -h')
+    local imports = ""
+    --Loop through all files
+    for file in p:lines() do
+        local varName = file:gsub(".*/(.*).lua", "%1")
+        file = file:gsub("%./", ""):gsub(".lua", "")
+        imports = imports .. 'require("../' .. file .. '")\n'
+    end
+    return imports:sub(1, #imports - 1)
+end
+)!!(getAllSystems())

generated/assets.lua

@@ -0,0 +1,13 @@
+-- GENERATED FILE - DO NOT EDIT
+-- Instead, edit the source file directly: assets.lua2p.
+
+
+
+
+-- luacheck: ignore
+---@type FontData
+EtBt7001Z0xa = function(fontSize)
+    return love.graphics.newFont("assets/fonts/EtBt7001Z0xa.ttf", fontSize)
+end
+
+

generated/assets.lua2p

@@ -0,0 +1,33 @@
+!(function dirLookup(dir, extension, newFunc, type, handle)
+    local indent = ""
+    local sep = "\n\n"
+    handle = handle ~= nil and handle or function(varName, nf, file)
+        return varName .. ' = ' .. nf .. '("' .. file .. '")'
+    end
+
+    local p = io.popen('find ./' .. dir .. '  -maxdepth 1 -type f | sort -h')
+
+    local assetCode = ""
+    --Loop through all files
+    for file in p:lines() do
+        if file:find(extension) then
+            local varName = file:gsub(".*/(.*)%." .. extension, "%1")
+            file = file:gsub("%./", "")
+            assetCode = assetCode .. indent .. '-- luacheck: ignore\n'
+            assetCode = assetCode .. indent .. '---@type ' .. type ..'\n'
+            assetCode = assetCode .. indent .. handle(varName, newFunc, file) .. sep
+        end
+    end
+    return assetCode
+end
+function generatedFileWarning()
+    -- Only in a function to make clear that THIS .lua2p is not the generated file!
+    return "-- GENERATED FILE - DO NOT EDIT\n-- Instead, edit the source file directly: assets.lua2p."
+end)!!(generatedFileWarning())
+
+!!(dirLookup('assets/images', 'png', 'love.graphics.newImage', 'Image'))
+!!(dirLookup('assets/sounds', 'wav', 'love.sound.newSoundData', 'SoundData'))
+!!(dirLookup('assets/music', 'wav', 'love.sound.newSoundData', 'SoundData'))
+!!(dirLookup('assets/fonts', 'ttf', 'love.graphics.newFont', 'FontData', function(varName, newFunc, file)
+    return varName .. ' = function(fontSize)\n    return ' .. newFunc .. '("' .. file .. '", fontSize)\nend'
+end))

generated/filter-types.lua

@@ -0,0 +1,73 @@
+-- GENERATED FILE - DO NOT EDIT
+-- Instead, edit the source file directly: filter-types.lua2p
+
+-- This file is composed of, essentially, "base types"
+
+local SOME_TABLE = {}
+
+---@alias AnyComponent any
+---@alias BitMask number
+---@alias ButtonState { receivedInputThisFrame: boolean, aJustPressed: boolean, bJustPressed: boolean, upJustPressed: boolean, downJustPressed: boolean, leftJustPressed: boolean, rightJustPressed: boolean }
+---@alias Collision { collisionBetween: Entity[] }
+---@alias CrankState { crankChange: number, changeInLastHalfSecond: number }
+---@alias Entity table
+---@alias InRelations Entity[]
+---@alias XyPair { x: number, y: number }
+
+T = {
+    bool = true,
+    number = 0,
+    numberArray = { 1, 2, 3 },
+    str = "",
+    marker = SOME_TABLE,
+    ---@type fun(self)
+    SelfFunction = function() end,
+    ---@type pd_image
+    pd_image = SOME_TABLE,
+    ---@type pd_font
+    pd_font = SOME_TABLE,
+
+    ---@type AnyComponent
+    AnyComponent = SOME_TABLE,
+
+    ---@type BitMask
+    BitMask = 0,
+
+    ---@type ButtonState
+    ButtonState = SOME_TABLE,
+
+    ---@type Collision
+    Collision = SOME_TABLE,
+
+    ---@type CrankState
+    CrankState = SOME_TABLE,
+
+    ---@type Entity
+    Entity = SOME_TABLE,
+
+    ---@type InRelations
+    InRelations = SOME_TABLE,
+
+    ---@type XyPair
+    XyPair = SOME_TABLE,
+}
+
+---@generic T
+---@param t T
+---@return nil | T
+function Maybe(t)
+    return { maybe = t }
+end
+
+---@generic T
+---@param t T
+---@return T[]
+function Arr(t)
+    return { arrOf = t }
+end
+
+TextStyle = {
+    Inverted = "INVERTED",
+    Bordered = "BORDERED",
+    None = "None",
+}

generated/filter-types.lua2p

@@ -0,0 +1,98 @@
+!(
+local types = {}
+function generatedFileWarning()
+    -- Only in a function to make clear that THIS .lua2p is not the generated file!
+    return "-- GENERATED FILE - DO NOT EDIT\n-- Instead, edit the source file directly: filter-types.lua2p"
+end
+
+function t(name, type, value)
+    if not value then
+        if type == "number" then
+            value = 0
+        elseif type == "string" then
+            value = ""
+        else
+            value = "SOME_TABLE"
+        end
+    end
+    types[#types + 1] = { name = name, type = type, value = value }
+    return "---@alias " .. name .. " " .. type
+end
+
+function tMany(tObj)
+    local ret = ""
+    local keyValues = {}
+    for k, v in pairs(tObj) do
+        keyValues[#keyValues + 1] = { key = k, value = v }
+    end
+    table.sort(keyValues, function(a, b)
+        return a.key < b.key
+    end)
+    for _, kv in ipairs(keyValues) do
+        local k, v = kv.key, kv.value
+        if type(v) == "string" then
+            ret = ret .. t(k, v) .. "\n"
+        else
+            ret = ret .. t(k, v[1], v[2]) .. "\n"
+        end
+    end
+    return ret
+end
+
+function dumpTypeObjects()
+    local ret = ""
+    for _, v in ipairs(types) do
+        local line = "\n\n    ---@type " .. v.name .. "\n    " .. v.name .. " = " .. v.value .. ","
+        ret = ret .. line
+    end
+    return ret
+end
+)!!(generatedFileWarning())
+
+-- This file is composed of, essentially, "base types"
+
+local SOME_TABLE = {}
+
+!!(tMany({
+    AnyComponent = "any",
+    Entity = "table",
+    XyPair = "{ x: number, y: number }",
+    Collision = "{ collisionBetween: Entity[] }",
+    BitMask = "number",
+    InRelations = "Entity[]",
+    ButtonState = "{ receivedInputThisFrame: boolean, aJustPressed: boolean, bJustPressed: boolean, upJustPressed: boolean, downJustPressed: boolean, leftJustPressed: boolean, rightJustPressed: boolean }",
+    CrankState = "{ crankChange: number, changeInLastHalfSecond: number }",
+}))
+T = {
+    bool = true,
+    number = 0,
+    numberArray = { 1, 2, 3 },
+    str = "",
+    marker = SOME_TABLE,
+    ---@type fun(self)
+    SelfFunction = function() end,
+    ---@type pd_image
+    pd_image = SOME_TABLE,
+    ---@type pd_font
+    pd_font = SOME_TABLE,!!(dumpTypeObjects())
+}
+
+---@generic T
+---@param t T
+---@return nil | T
+function Maybe(t)
+    return { maybe = t }
+end
+
+---@generic T
+---@param t T
+---@return T[]
+function Arr(t)
+    return { arrOf = t }
+end
+
+TextStyle = {
+    Inverted = "INVERTED",
+    Bordered = "BORDERED",
+    None = "None",
+}

lib/preprocess-cl.lua

@@ -0,0 +1,651 @@
+#!/bin/sh
+_=[[
+exec lua "$0" "$@"
+]]and nil
+--==============================================================
+--=
+--=  LuaPreprocess command line program
+--=  by Marcus 'ReFreezed' Thunström
+--=
+--=  Requires preprocess.lua to be in the same folder!
+--=
+--=  License: MIT (see the bottom of this file)
+--=  Website: http://refreezed.com/luapreprocess/
+--=  Documentation: http://refreezed.com/luapreprocess/docs/command-line/
+--=
+--=  Tested with Lua 5.1, 5.2, 5.3, 5.4 and LuaJIT.
+--=
+--==============================================================
+local help = [[
+
+Script usage:
+	lua preprocess-cl.lua               [options] [--] filepath1 [filepath2 ...]
+	OR
+	lua preprocess-cl.lua --outputpaths [options] [--] inputpath1 outputpath1 [inputpath2 outputpath2 ...]
+
+	File paths can be "-" for usage of stdin/stdout.
+
+Examples:
+	lua preprocess-cl.lua --saveinfo=logs/info.lua --silent src/main.lua2p src/network.lua2p
+	lua preprocess-cl.lua --debug src/main.lua2p src/network.lua2p
+	lua preprocess-cl.lua --outputpaths --linenumbers src/main.lua2p output/main.lua src/network.lua2p output/network.lua
+
+Options:
+	--backtickstrings
+		Enable the backtick (`) to be used as string literal delimiters.
+		Backtick strings don't interpret any escape sequences and can't
+		contain other backticks.
+
+	--data|-d="Any data."
+		A string with any data. If this option is present then the value
+		will be available through the global 'dataFromCommandLine' in the
+		processed files (and any message handler). Otherwise,
+		'dataFromCommandLine' is nil.
+
+	--faststrings
+		Force fast serialization of string values. (Non-ASCII characters
+		will look ugly.)
+
+	--handler|-h=pathToMessageHandler
+		Path to a Lua file that's expected to return a function or a
+		table of functions. If it returns a function then it will be
+		called with various messages as it's first argument. If it's
+		a table, the keys should be the message names and the values
+		should be functions to handle the respective message.
+		(See 'Handler messages' and tests/quickTestHandler*.lua)
+		The file shares the same environment as the processed files.
+
+	--help
+		Show this help.
+
+	--jitsyntax
+		Allow LuaJIT-specific syntax, specifically literals for 64-bit
+		integers, complex numbers and binary numbers.
+		(https://luajit.org/ext_ffi_api.html#literals)
+
+	--linenumbers
+		Add comments with line numbers to the output.
+
+	--loglevel=levelName
+		Set maximum log level for the @@LOG() macro. Can be "off",
+		"error", "warning", "info", "debug" or "trace". The default is
+		"trace", which enables all logging.
+
+	--macroprefix=prefix
+		String to prepend to macro names.
+
+	--macrosuffix=suffix
+		String to append to macro names.
+
+	--meta OR --meta=pathToSaveMetaprogramTo
+		Output the metaprogram to a temporary file (*.meta.lua). Useful if
+		an error happens when the metaprogram runs. This file is removed
+		if there's no error and --debug isn't enabled.
+
+	--nogc
+		Stop the garbage collector. This may speed up the preprocessing.
+
+	--nonil
+		Disallow !(expression) and outputValue() from outputting nil.
+
+	--nostrictmacroarguments
+		Disable checks that macro arguments are valid Lua expressions.
+
+	--novalidate
+		Disable validation of outputted Lua.
+
+	--outputextension=fileExtension
+		Specify what file extension generated files should have. The
+		default is "lua". If any input files end in .lua then you must
+		specify another file extension with this option. (It's suggested
+		that you use .lua2p (as in "Lua To Process") as extension for
+		unprocessed files.)
+
+	--outputpaths|-o
+		This flag makes every other specified path be the output path
+		for the previous path.
+
+	--release
+		Enable release mode. Currently only disables the @@ASSERT() macro.
+
+	--saveinfo|-i=pathToSaveProcessingInfoTo
+		Processing information includes what files had any preprocessor
+		code in them, and things like that. The format of the file is a
+		lua module that returns a table. Search this file for 'SavedInfo'
+		to see what information is saved.
+
+	--silent
+		Only print errors to the console. (This flag is automatically
+		enabled if an output path is stdout.)
+
+	--version
+		Print the version of LuaPreprocess to stdout and exit.
+
+	--debug
+		Enable some preprocessing debug features. Useful if you want
+		to inspect the generated metaprogram (*.meta.lua). (This also
+		enables the --meta option.)
+
+	--
+		Stop options from being parsed further. Needed if you have paths
+		starting with "-" (except for usage of stdin/stdout).
+
+Handler messages:
+	"init"
+		Sent before any other message.
+		Arguments:
+			inputPaths: Array of file paths to process. Paths can be added or removed freely.
+			outputPaths: If the --outputpaths option is present this is an array of output paths for the respective path in inputPaths, otherwise it's nil.
+
+	"insert"
+		Sent for each @insert"name" statement. The handler is expected to return a Lua code string.
+		Arguments:
+			path: The file being processed.
+			name: The name of the resource to be inserted (could be a file path or anything).
+
+	"beforemeta"
+		Sent before a file's metaprogram runs, if a metaprogram is generated.
+		Arguments:
+			path: The file being processed.
+			luaString: The generated metaprogram.
+
+	"aftermeta"
+		Sent after a file's metaprogram has produced output (before the output is written to a file).
+		Arguments:
+			path: The file being processed.
+			luaString: The produced Lua code. You can modify this and return the modified string.
+
+	"filedone"
+		Sent after a file has finished processing and the output written to file.
+		Arguments:
+			path: The file being processed.
+			outputPath: Where the output of the metaprogram was written.
+			info: Info about the processed file. (See 'ProcessInfo' in preprocess.lua)
+
+	"fileerror"
+		Sent if an error happens while processing a file (right before the program exits).
+		Arguments:
+			path: The file being processed.
+			error: The error message.
+
+	"alldone"
+		Sent after all other messages (right before the program exits).
+		Arguments:
+			(none)
+]]
+--==============================================================
+
+
+
+local startTime  = os.time()
+local startClock = os.clock()
+
+local args = arg
+
+if not args[0] then  error("Expected to run from the Lua interpreter.")  end
+local pp = dofile((args[0]:gsub("[^/\\]+$", "preprocess.lua")))
+
+-- From args:
+local addLineNumbers       = false
+local allowBacktickStrings = false
+local allowJitSyntax       = false
+local canOutputNil         = true
+local customData           = nil
+local fastStrings          = false
+local hasOutputExtension   = false
+local hasOutputPaths       = false
+local isDebug              = false
+local outputExtension      = "lua"
+local outputMeta           = false -- flag|path
+local processingInfoPath   = ""
+local silent               = false
+local validate             = true
+local macroPrefix          = ""
+local macroSuffix          = ""
+local releaseMode          = false
+local maxLogLevel          = "trace"
+local strictMacroArguments = true
+
+--==============================================================
+--= Local functions ============================================
+--==============================================================
+local F = string.format
+
+local function formatBytes(n)
+	if     n >= 1024*1024*1024 then
+		return F("%.2f GiB", n/(1024*1024*1024))
+	elseif n >= 1024*1024 then
+		return F("%.2f MiB", n/(1024*1024))
+	elseif n >= 1024 then
+		return F("%.2f KiB", n/(1024))
+	elseif n == 1 then
+		return F("1 byte", n)
+	else
+		return F("%d bytes", n)
+	end
+end
+
+local function printfNoise(s, ...)
+	print(s:format(...))
+end
+local function printError(s)
+	io.stderr:write(s, "\n")
+end
+local function printfError(s, ...)
+	io.stderr:write(s:format(...), "\n")
+end
+
+local function errorLine(err)
+	printError(pp.tryToFormatError(err))
+	os.exit(1)
+end
+
+local loadLuaFile = (
+	(_VERSION >= "Lua 5.2" or jit) and function(path, env)
+		return loadfile(path, "bt", env)
+	end
+	or function(path, env)
+		local chunk, err = loadfile(path)
+		if not chunk then  return nil, err  end
+
+		if env then  setfenv(chunk, env)  end
+
+		return chunk
+	end
+)
+
+--==============================================================
+--= Preprocessor script ========================================
+--==============================================================
+
+io.stdout:setvbuf("no")
+io.stderr:setvbuf("no")
+
+math.randomseed(os.time()) -- In case math.random() is used anywhere.
+math.random() -- Must kickstart...
+
+local processOptions     = true
+local messageHandlerPath = ""
+local pathsIn            = {}
+local pathsOut           = {}
+
+for _, arg in ipairs(args) do
+	if processOptions and (arg:find"^%-%-?help$" or arg == "/?" or arg:find"^/[Hh][Ee][Ll][Pp]$") then
+		print("LuaPreprocess v"..pp.VERSION)
+		print((help:gsub("\t", "    ")))
+		os.exit()
+
+	elseif not (processOptions and arg:find"^%-.") then
+		local paths = (hasOutputPaths and #pathsOut < #pathsIn) and pathsOut or pathsIn
+		table.insert(paths, arg)
+
+		if arg == "-" and (not hasOutputPaths or paths == pathsOut) then
+			silent = true
+		end
+
+	elseif arg == "--" then
+		processOptions = false
+
+	elseif arg:find"^%-%-data=" or arg:find"^%-d=" then
+		customData = arg:gsub("^.-=", "")
+
+	elseif arg == "--backtickstrings" then
+		allowBacktickStrings = true
+
+	elseif arg == "--debug" then
+		isDebug    = true
+		outputMeta = outputMeta or true
+
+	elseif arg:find"^%-%-handler=" or arg:find"^%-h=" then
+		messageHandlerPath = arg:gsub("^.-=", "")
+
+	elseif arg == "--jitsyntax" then
+		allowJitSyntax = true
+
+	elseif arg == "--linenumbers" then
+		addLineNumbers = true
+
+	elseif arg == "--meta" then
+		outputMeta = true
+	elseif arg:find"^%-%-meta=" then
+		outputMeta = arg:gsub("^.-=", "")
+
+	elseif arg == "--nonil" then
+		canOutputNil = false
+
+	elseif arg == "--novalidate" then
+		validate = false
+
+	elseif arg:find"^%-%-outputextension=" then
+		if hasOutputPaths then
+			errorLine("Cannot specify both --outputextension and --outputpaths")
+		end
+		hasOutputExtension = true
+		outputExtension    = arg:gsub("^.-=", "")
+
+	elseif arg == "--outputpaths" or arg == "-o" then
+		if hasOutputExtension then
+			errorLine("Cannot specify both --outputpaths and --outputextension")
+		elseif pathsIn[1] then
+			errorLine(arg.." must appear before any input path.")
+		end
+		hasOutputPaths = true
+
+	elseif arg:find"^%-%-saveinfo=" or arg:find"^%-i=" then
+		processingInfoPath = arg:gsub("^.-=", "")
+
+	elseif arg == "--silent" then
+		silent = true
+
+	elseif arg == "--faststrings" then
+		fastStrings = true
+
+	elseif arg == "--nogc" then
+		collectgarbage("stop")
+
+	elseif arg:find"^%-%-macroprefix=" then
+		macroPrefix = arg:gsub("^.-=", "")
+
+	elseif arg:find"^%-%-macrosuffix=" then
+		macroSuffix = arg:gsub("^.-=", "")
+
+	elseif arg == "--release" then
+		releaseMode = true
+
+	elseif arg:find"^%-%-loglevel=" then
+		maxLogLevel = arg:gsub("^.-=", "")
+
+	elseif arg == "--version" then
+		io.stdout:write(pp.VERSION)
+		os.exit()
+
+	elseif arg == "--nostrictmacroarguments" then
+		strictMacroArguments = false
+
+	else
+		errorLine("Unknown option '"..arg:gsub("=.*", "").."'.")
+	end
+end
+
+if silent then
+	printfNoise = function()end
+end
+
+local header = "= LuaPreprocess v"..pp.VERSION..os.date(", %Y-%m-%d %H:%M:%S =", startTime)
+printfNoise(("="):rep(#header))
+printfNoise("%s", header)
+printfNoise(("="):rep(#header))
+
+if hasOutputPaths and #pathsOut < #pathsIn then
+	errorLine("Missing output path for "..pathsIn[#pathsIn])
+end
+
+
+
+-- Prepare metaEnvironment.
+pp.metaEnvironment.dataFromCommandLine = customData -- May be nil.
+
+
+
+-- Load message handler.
+local messageHandler = nil
+
+local function hasMessageHandler(message)
+	if not messageHandler then
+		return false
+
+	elseif type(messageHandler) == "function" then
+		return true
+
+	elseif type(messageHandler) == "table" then
+		return messageHandler[message] ~= nil
+
+	else
+		assert(false)
+	end
+end
+
+local function sendMessage(message, ...)
+	if not messageHandler then
+		return
+
+	elseif type(messageHandler) == "function" then
+		local returnValues = pp.pack(messageHandler(message, ...))
+		return pp.unpack(returnValues, 1, returnValues.n)
+
+	elseif type(messageHandler) == "table" then
+		local _messageHandler = messageHandler[message]
+		if not _messageHandler then  return  end
+
+		local returnValues = pp.pack(_messageHandler(...))
+		return pp.unpack(returnValues, 1, returnValues.n)
+
+	else
+		assert(false)
+	end
+end
+
+if messageHandlerPath ~= "" then
+	-- Make the message handler and the metaprogram share the same environment.
+	-- This way the message handler can easily define globals that the metaprogram uses.
+	local mainChunk, err = loadLuaFile(messageHandlerPath, pp.metaEnvironment)
+	if not mainChunk then
+		errorLine("Could not load message handler...\n"..pp.tryToFormatError(err))
+	end
+
+	messageHandler = mainChunk()
+
+	if type(messageHandler) == "function" then
+		-- void
+	elseif type(messageHandler) == "table" then
+		for message, _messageHandler in pairs(messageHandler) do
+			if type(message) ~= "string" then
+				errorLine(messageHandlerPath..": Table of handlers must only contain messages as keys.")
+			elseif type(_messageHandler) ~= "function" then
+				errorLine(messageHandlerPath..": Table of handlers must only contain functions as values.")
+			end
+		end
+	else
+		errorLine(messageHandlerPath..": File did not return a table or a function.")
+	end
+end
+
+
+
+-- Init stuff.
+sendMessage("init", pathsIn, (hasOutputPaths and pathsOut or nil)) -- @Incomplete: Use pcall and format error message better?
+
+if not hasOutputPaths then
+	for i, pathIn in ipairs(pathsIn) do
+		pathsOut[i] = (pathIn == "-") and "-" or pathIn:gsub("%.%w+$", "").."."..outputExtension
+	end
+end
+
+if not pathsIn[1] then
+	errorLine("No path(s) specified.")
+elseif #pathsIn ~= #pathsOut then
+	errorLine(F("Number of input and output paths differ. (%d in, %d out)", #pathsIn, #pathsOut))
+end
+
+local pathsSetIn  = {}
+local pathsSetOut = {}
+
+for i = 1, #pathsIn do
+	if pathsSetIn [pathsIn [i]] then  errorLine("Duplicate input path: " ..pathsIn [i])  end
+	if pathsSetOut[pathsOut[i]] then  errorLine("Duplicate output path: "..pathsOut[i])  end
+
+	pathsSetIn [pathsIn [i]] = true
+	pathsSetOut[pathsOut[i]] = true
+
+	if pathsIn [i] ~= "-" and pathsSetOut[pathsIn [i]] then  errorLine("Path is both input and output: "..pathsIn [i])  end
+	if pathsOut[i] ~= "-" and pathsSetIn [pathsOut[i]] then  errorLine("Path is both input and output: "..pathsOut[i])  end
+end
+
+
+
+-- Process files.
+
+-- :SavedInfo
+local processingInfo = {
+	date  = os.date("%Y-%m-%d %H:%M:%S", startTime),
+	files = {},
+}
+
+local byteCount     = 0
+local lineCount     = 0
+local lineCountCode = 0
+local tokenCount    = 0
+
+for i, pathIn in ipairs(pathsIn) do
+	local startClockForPath = os.clock()
+	printfNoise("Processing '%s'...", pathIn)
+
+	local pathOut  = pathsOut[i]
+	local pathMeta = (type(outputMeta) == "string") and outputMeta or pathOut:gsub("%.%w+$", "")..".meta.lua"
+
+	if not outputMeta or pathOut == "-" then
+		pathMeta = nil
+	end
+
+	local info, err = pp.processFile{
+		pathIn               = pathIn,
+		pathMeta             = pathMeta,
+		pathOut              = pathOut,
+
+		debug                = isDebug,
+		addLineNumbers       = addLineNumbers,
+
+		backtickStrings      = allowBacktickStrings,
+		jitSyntax            = allowJitSyntax,
+		canOutputNil         = canOutputNil,
+		fastStrings          = fastStrings,
+		validate             = validate,
+		strictMacroArguments = strictMacroArguments,
+
+		macroPrefix          = macroPrefix,
+		macroSuffix          = macroSuffix,
+
+		release              = releaseMode,
+		logLevel             = maxLogLevel,
+
+		onInsert = (hasMessageHandler("insert") or nil) and function(name)
+			local lua = sendMessage("insert", pathIn, name)
+
+			-- onInsert() is expected to return a Lua code string and so is the message
+			-- handler. However, if the handler is a single catch-all function we allow
+			-- the message to not be handled and we fall back to the default behavior of
+			-- treating 'name' as a path to a file to be inserted. If we didn't allow this
+			-- then it would be required for the "insert" message to be handled. I think
+			-- it's better if the user can choose whether to handle a message or not!
+			--
+			if lua == nil and type(messageHandler) == "function" then
+				return assert(pp.readFile(name))
+			end
+
+			return lua
+		end,
+
+		onBeforeMeta = messageHandler and function(lua)
+			sendMessage("beforemeta", pathIn, lua)
+		end,
+
+		onAfterMeta = messageHandler and function(lua)
+			local luaModified = sendMessage("aftermeta", pathIn, lua)
+
+			if type(luaModified) == "string" then
+				lua = luaModified
+
+			elseif luaModified ~= nil then
+				error(F(
+					"%s: Message handler did not return a string for 'aftermeta'. (Got %s)",
+					messageHandlerPath, type(luaModified)
+				))
+			end
+
+			return lua
+		end,
+
+		onDone = messageHandler and function(info)
+			sendMessage("filedone", pathIn, pathOut, info)
+		end,
+
+		onError = function(err)
+			xpcall(function()
+				sendMessage("fileerror", pathIn, err)
+			end, function(err)
+				printfError("Additional error in 'fileerror' message handler...\n%s", pp.tryToFormatError(err))
+			end)
+			os.exit(1)
+		end,
+	}
+	assert(info, err) -- The onError() handler above should have been called and we should have exited already.
+
+	byteCount     = byteCount     + info.processedByteCount
+	lineCount     = lineCount     + info.lineCount
+	lineCountCode = lineCountCode + info.linesOfCode
+	tokenCount    = tokenCount    + info.tokenCount
+
+	if processingInfoPath ~= "" then
+
+		-- :SavedInfo
+		table.insert(processingInfo.files, info) -- See 'ProcessInfo' in preprocess.lua for what more 'info' contains.
+
+	end
+
+	printfNoise("Processing '%s' successful! (%.3fs)", pathIn, os.clock()-startClockForPath)
+	printfNoise(("-"):rep(#header))
+end
+
+
+
+-- Finalize stuff.
+if processingInfoPath ~= "" then
+	printfNoise("Saving processing info to '%s'.", processingInfoPath)
+
+	local luaParts = {"return"}
+	assert(pp.serialize(luaParts, processingInfo))
+	local lua = table.concat(luaParts)
+
+	local file = assert(io.open(processingInfoPath, "wb"))
+	file:write(lua)
+	file:close()
+end
+
+printfNoise(
+	"All done! (%.3fs, %.0f file%s, %.0f LOC, %.0f line%s, %.0f token%s, %s)",
+	os.clock()-startClock,
+	#pathsIn,   (#pathsIn   == 1) and "" or "s",
+	lineCountCode,
+	lineCount,  (lineCount  == 1) and "" or "s",
+	tokenCount, (tokenCount == 1) and "" or "s",
+	formatBytes(byteCount)
+)
+
+sendMessage("alldone") -- @Incomplete: Use pcall and format error message better?
+
+
+
+--[[!===========================================================
+
+Copyright © 2018-2022 Marcus 'ReFreezed' Thunström
+
+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.
+
+==============================================================]]
+

lib/tiny.lua

@@ -0,0 +1,935 @@
+--[[
+Copyright (c) 2016 Calvin Rose
+
+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.
+]]
+
+---@class World
+
+---@class System
+---@field world World field points to the World that the System belongs to. Useful for adding and removing Entities from the world dynamically via the System.
+---@field active boolean flag for whether or not the System is updated automatically. Inactive Systems should be updated manually or not at all via system:update(dt). Defaults to true.
+---@field entities table[] is an ordered list of Entities in the System. This list can be used to quickly iterate through all Entities in a System.
+---@field interval number is an optional field that makes Systems update at certain intervals using buffered time, regardless of World update frequency. For example, to make a System update once a second, set the System's interval to 1.
+---@field index number is the System's index in the World. Lower indexed Systems are processed before higher indices. The index is a read only field; to set the index, use tiny.setSystemIndex(world, system).
+---@field indices table<any, any> field is a table of Entity keys to their indices in the entities list. Most Systems can ignore this.
+---@field modified boolean indicator for if the System has been modified in the last update. If so, the onModify callback will be called on the System in the next update, if it has one. This is usually managed by tiny-ecs, so users should mostly ignore this, too.
+
+
+--- @module tiny-ecs
+-- @author Calvin Rose
+-- @license MIT
+-- @copyright 2016
+local tiny = {}
+
+-- Local versions of standard lua functions
+local tinsert = table.insert
+local tremove = table.remove
+local tsort = table.sort
+local setmetatable = setmetatable
+local type = type
+local select = select
+
+-- Local versions of the library functions
+local tiny_manageEntities
+local tiny_manageSystems
+local tiny_addEntity
+local tiny_addSystem
+local tiny_add
+local tiny_removeEntity
+local tiny_removeSystem
+
+--- Filter functions.
+-- A Filter is a function that selects which Entities apply to a System.
+-- Filters take two parameters, the System and the Entity, and return a boolean
+-- value indicating if the Entity should be processed by the System. A truthy
+-- value includes the entity, while a falsey (nil or false) value excludes the
+-- entity.
+--
+-- Filters must be added to Systems by setting the `filter` field of the System.
+-- Filter's returned by tiny-ecs's Filter functions are immutable and can be
+-- used by multiple Systems.
+--
+--    local f1 = tiny.requireAll("position", "velocity", "size")
+--    local f2 = tiny.requireAny("position", "velocity", "size")
+--
+--    local e1 = {
+--        position = {2, 3},
+--        velocity = {3, 3},
+--        size = {4, 4}
+--    }
+--
+--    local entity2 = {
+--        position = {4, 5},
+--        size = {4, 4}
+--    }
+--
+--    local e3 = {
+--        position = {2, 3},
+--        velocity = {3, 3}
+--    }
+--
+--    print(f1(nil, e1), f1(nil, e2), f1(nil, e3)) -- prints true, false, false
+--    print(f2(nil, e1), f2(nil, e2), f2(nil, e3)) -- prints true, true, true
+--
+-- Filters can also be passed as arguments to other Filter constructors. This is
+-- a powerful way to create complex, custom Filters that select a very specific
+-- set of Entities.
+--
+--    -- Selects Entities with an "image" Component, but not Entities with a
+--    -- "Player" or "Enemy" Component.
+--    filter = tiny.requireAll("image", tiny.rejectAny("Player", "Enemy"))
+--
+-- @section Filter
+
+-- A helper function to compile filters.
+local filterJoin
+
+-- A helper function to filters from string
+local filterBuildString
+
+
+local function filterJoinRaw(invert, joining_op, ...)
+    local _args = {...}
+
+    return function(system, e)
+        local acc
+        local args = _args
+        if joining_op == 'or' then
+            acc = false
+            for i = 1, #args do
+                local v = args[i]
+                if type(v) == "string" then
+                    acc = acc or (e[v] ~= nil)
+                elseif type(v) == "function" then
+                    acc = acc or v(system, e)
+                else
+                    error 'Filter token must be a string or a filter function.'
+                end
+            end
+        else
+            acc = true
+            for i = 1, #args do
+                local v = args[i]
+                if type(v) == "string" then
+                    acc = acc and (e[v] ~= nil)
+                elseif type(v) == "function" then
+                    acc = acc and v(system, e)
+                else
+                    error 'Filter token must be a string or a filter function.'
+                end
+            end
+        end
+
+        -- computes a simple xor
+        if invert then
+            return not acc
+        else
+            return acc
+        end
+    end
+end
+
+do
+
+    function filterJoin(...)
+        local state, value = pcall(filterJoinRaw, ...)
+        if state then return value else return nil, value end
+    end
+
+    local function buildPart(str)
+        local accum = {}
+        local subParts = {}
+        str = str:gsub('%b()', function(p)
+            subParts[#subParts + 1] = buildPart(p:sub(2, -2))
+            return ('\255%d'):format(#subParts)
+        end)
+        for invert, part, sep in str:gmatch('(%!?)([^%|%&%!]+)([%|%&]?)') do
+            if part:match('^\255%d+$') then
+                local partIndex = tonumber(part:match(part:sub(2)))
+                accum[#accum + 1] = ('%s(%s)')
+                    :format(invert == '' and '' or 'not', subParts[partIndex])
+            else
+                accum[#accum + 1] = ("(e[%s] %s nil)")
+                    :format(make_safe(part), invert == '' and '~=' or '==')
+            end
+            if sep ~= '' then
+                accum[#accum + 1] = (sep == '|' and ' or ' or ' and ')
+            end
+        end
+        return table.concat(accum)
+    end
+
+    function filterBuildString(str)
+        local source = ("return function(_, e) return %s end")
+            :format(buildPart(str))
+        local loader, err = loadstring(source)
+        if err then
+            error(err)
+        end
+        return loader()
+    end
+
+end
+
+--- Makes a Filter that selects Entities with all specified Components and
+-- Filters.
+function tiny.requireAll(...)
+    return filterJoin(false, 'and', ...)
+end
+
+--- Makes a Filter that selects Entities with at least one of the specified
+-- Components and Filters.
+function tiny.requireAny(...)
+    return filterJoin(false, 'or', ...)
+end
+
+--- Makes a Filter that rejects Entities with all specified Components and
+-- Filters, and selects all other Entities.
+function tiny.rejectAll(...)
+    return filterJoin(true, 'and', ...)
+end
+
+--- Makes a Filter that rejects Entities with at least one of the specified
+-- Components and Filters, and selects all other Entities.
+function tiny.rejectAny(...)
+    return filterJoin(true, 'or', ...)
+end
+
+--- Makes a Filter from a string. Syntax of `pattern` is as follows.
+--
+--   * Tokens are alphanumeric strings including underscores.
+--   * Tokens can be separated by |, &, or surrounded by parentheses.
+--   * Tokens can be prefixed with !, and are then inverted.
+--
+-- Examples are best:
+--    'a|b|c' - Matches entities with an 'a' OR 'b' OR 'c'.
+--    'a&!b&c' - Matches entities with an 'a' AND NOT 'b' AND 'c'.
+--    'a|(b&c&d)|e - Matches 'a' OR ('b' AND 'c' AND 'd') OR 'e'
+-- @param pattern
+function tiny.filter(pattern)
+    local state, value = pcall(filterBuildString, pattern)
+    if state then return value else return nil, value end
+end
+
+--- System functions.
+-- A System is a wrapper around function callbacks for manipulating Entities.
+-- Systems are implemented as tables that contain at least one method;
+-- an update function that takes parameters like so:
+--
+--   * `function system:update(dt)`.
+--
+-- There are also a few other optional callbacks:
+--
+--   * `function system:filter(entity)` - Returns true if this System should
+-- include this Entity, otherwise should return false. If this isn't specified,
+-- no Entities are included in the System.
+--   * `function system:onAdd(entity)` - Called when an Entity is added to the
+-- System.
+--   * `function system:onRemove(entity)` - Called when an Entity is removed
+-- from the System.
+--   * `function system:onModify(dt)` - Called when the System is modified by
+-- adding or removing Entities from the System.
+--   * `function system:onAddToWorld(world)` - Called when the System is added
+-- to the World, before any entities are added to the system.
+--   * `function system:onRemoveFromWorld(world)` - Called when the System is
+-- removed from the world, after all Entities are removed from the System.
+--   * `function system:preWrap(dt)` - Called on each system before update is
+-- called on any system.
+--   * `function system:postWrap(dt)` - Called on each system in reverse order
+-- after update is called on each system. The idea behind `preWrap` and
+-- `postWrap` is to allow for systems that modify the behavior of other systems.
+-- Say there is a DrawingSystem, which draws sprites to the screen, and a
+-- PostProcessingSystem, that adds some blur and bloom effects. In the preWrap
+-- method of the PostProcessingSystem, the System could set the drawing target
+-- for the DrawingSystem to a special buffer instead the screen. In the postWrap
+-- method, the PostProcessingSystem could then modify the buffer and render it
+-- to the screen. In this setup, the PostProcessingSystem would be added to the
+-- World after the drawingSystem (A similar but less flexible behavior could
+-- be accomplished with a single custom update function in the DrawingSystem).
+--
+-- For Filters, it is convenient to use `tiny.requireAll` or `tiny.requireAny`,
+-- but one can write their own filters as well. Set the Filter of a System like
+-- so:
+--    system.filter = tiny.requireAll("a", "b", "c")
+-- or
+--    function system:filter(entity)
+--        return entity.myRequiredComponentName ~= nil
+--    end
+--
+-- All Systems also have a few important fields that are initialized when the
+-- system is added to the World. A few are important, and few should be less
+-- commonly used.
+--
+--   * The `world` field points to the World that the System belongs to. Useful
+-- for adding and removing Entities from the world dynamically via the System.
+--   * The `active` flag is whether or not the System is updated automatically.
+-- Inactive Systems should be updated manually or not at all via
+-- `system:update(dt)`. Defaults to true.
+--   * The `entities` field is an ordered list of Entities in the System. This
+-- list can be used to quickly iterate through all Entities in a System.
+--   * The `interval` field is an optional field that makes Systems update at
+-- certain intervals using buffered time, regardless of World update frequency.
+-- For example, to make a System update once a second, set the System's interval
+-- to 1.
+--   * The `index` field is the System's index in the World. Lower indexed
+-- Systems are processed before higher indices. The `index` is a read only
+-- field; to set the `index`, use `tiny.setSystemIndex(world, system)`.
+--   * The `indices` field is a table of Entity keys to their indices in the
+-- `entities` list. Most Systems can ignore this.
+--   * The `modified` flag is an indicator if the System has been modified in
+-- the last update. If so, the `onModify` callback will be called on the System
+-- in the next update, if it has one. This is usually managed by tiny-ecs, so
+-- users should mostly ignore this, too.
+--
+-- There is another option to (hopefully) increase performance in systems that
+-- have items added to or removed from them often, and have lots of entities in
+-- them.  Setting the `nocache` field of the system might improve performance.
+-- It is still experimental. There are some restriction to systems without
+-- caching, however.
+--
+--   * There is no `entities` table.
+--   * Callbacks such onAdd, onRemove, and onModify will never be called
+--   * Noncached systems cannot be sorted (There is no entities list to sort).
+--
+-- @section System
+
+-- Use an empty table as a key for identifying Systems. Any table that contains
+-- this key is considered a System rather than an Entity.
+local systemTableKey = { "SYSTEM_TABLE_KEY" }
+tiny.SKIP_PROCESS = { "SKIP_PROCESS_KEY" }
+
+-- Checks if a table is a System.
+local function isSystem(table)
+    return table[systemTableKey]
+end
+
+-- Update function for all Processing Systems.
+local function processingSystemUpdate(system, dt)
+    local preProcess = system.preProcess
+    local process = system.process
+    local postProcess = system.postProcess
+
+    local shouldSkipSystemProcess
+    if preProcess then
+        shouldSkipSystemProcess = preProcess(system, dt)
+    end
+
+    if process and shouldSkipSystemProcess ~= tiny.SKIP_PROCESS then
+        if system.nocache then
+            local entities = system.world.entities
+            local filter = system.filter
+            if filter then
+                for i = 1, #entities do
+                    local entity = entities[i]
+                    if filter(system, entity) then
+                        process(system, entity, dt)
+                    end
+                end
+            end
+        else
+            local entities = system.entities
+            for i = 1, #entities do
+                process(system, entities[i], dt)
+            end
+        end
+    end
+
+    if postProcess and shouldSkipSystemProcess ~= tiny.SKIP_PROCESS then
+        postProcess(system, dt)
+    end
+end
+
+-- Sorts Systems by a function system.sortDelegate(entity1, entity2) on modify.
+local function sortedSystemOnModify(system)
+    local entities = system.entities
+    local indices = system.indices
+    local sortDelegate = system.sortDelegate
+    if not sortDelegate then
+        local compare = system.compare
+        sortDelegate = function(e1, e2)
+            return compare(system, e1, e2)
+        end
+        system.sortDelegate = sortDelegate
+    end
+    tsort(entities, sortDelegate)
+    for i = 1, #entities do
+        indices[entities[i]] = i
+    end
+end
+
+--- Creates a new System or System class from the supplied table. If `table` is
+-- nil, creates a new table.
+function tiny.system(table)
+    table = table or {}
+    table[systemTableKey] = true
+    return table
+end
+
+--- Creates a new Processing System or Processing System class. Processing
+-- Systems process each entity individual, and are usually what is needed.
+-- Processing Systems have three extra callbacks besides those inheritted from
+-- vanilla Systems.
+--
+--     function system:preProcess(dt) -- Called before iteration.
+--     function system:process(entity, dt) -- Process each entity.
+--     function system:postProcess(dt) -- Called after iteration.
+--
+-- Processing Systems have their own `update` method, so don't implement a
+-- a custom `update` callback for Processing Systems.
+-- @see system
+function tiny.processingSystem(table)
+    table = table or {}
+    table[systemTableKey] = true
+    table.update = processingSystemUpdate
+    return table
+end
+
+--- Creates a new Sorted System or Sorted System class. Sorted Systems sort
+-- their Entities according to a user-defined method, `system:compare(e1, e2)`,
+-- which should return true if `e1` should come before `e2` and false otherwise.
+-- Sorted Systems also override the default System's `onModify` callback, so be
+-- careful if defining a custom callback. However, for processing the sorted
+-- entities, consider `tiny.sortedProcessingSystem(table)`.
+-- @see system
+function tiny.sortedSystem(table)
+    table = table or {}
+    table[systemTableKey] = true
+    table.onModify = sortedSystemOnModify
+    return table
+end
+
+--- Creates a new Sorted Processing System or Sorted Processing System class.
+-- Sorted Processing Systems have both the aspects of Processing Systems and
+-- Sorted Systems.
+-- @see system
+-- @see processingSystem
+-- @see sortedSystem
+function tiny.sortedProcessingSystem(table)
+    table = table or {}
+    table[systemTableKey] = true
+    table.update = processingSystemUpdate
+    table.onModify = sortedSystemOnModify
+    return table
+end
+
+--- World functions.
+-- A World is a container that manages Entities and Systems. Typically, a
+-- program uses one World at a time.
+--
+-- For all World functions except `tiny.world(...)`, object-oriented syntax can
+-- be used instead of the documented syntax. For example,
+-- `tiny.add(world, e1, e2, e3)` is the same as `world:add(e1, e2, e3)`.
+-- @section World
+
+-- Forward declaration
+local worldMetaTable
+
+--- Creates a new World.
+-- Can optionally add default Systems and Entities. Returns the new World along
+-- with default Entities and Systems.
+---@return World
+function tiny.world(...)
+    local ret = setmetatable({
+
+        -- List of Entities to remove
+        entitiesToRemove = {},
+
+        -- List of Entities to change
+        entitiesToChange = {},
+
+        -- List of Entities to add
+        systemsToAdd = {},
+
+        -- List of Entities to remove
+        systemsToRemove = {},
+
+        -- Set of Entities
+        entities = {},
+
+        -- List of Systems
+        systems = {}
+
+    }, worldMetaTable)
+
+    tiny_add(ret, ...)
+    tiny_manageSystems(ret)
+    tiny_manageEntities(ret)
+
+    return ret, ...
+end
+
+--- Adds an Entity to the world.
+-- Also call this on Entities that have changed Components such that they
+-- match different Filters. Returns the Entity.
+-- TODO: Track entity age when debugging?
+-- TODO: Track debugName field when debugging?
+function tiny.addEntity(world, entity)
+    local e2c = world.entitiesToChange
+    e2c[#e2c + 1] = entity
+    return entity
+end
+tiny_addEntity = tiny.addEntity
+
+if tinyTrackEntityAges then
+    local wrapped = tiny.addEntity
+    function tiny.addEntity(world, entity)
+        local added = wrapped(world, entity)
+        added[ENTITY_INIT_MS] = getCurrentTimeMilliseconds()
+        return added
+    end
+    tiny_addEntity = tiny.addEntity
+end
+
+if tinyWarnWhenNonDataOnEntities then
+    local wrapped = tiny.addEntity
+    function tiny.addEntity(world, entity)
+        local added = wrapped(world, entity)
+        local nonDataType = checkForNonData(added)
+        if nonDataType then
+            print("Detected non-data type '" .. nonDataType .. "' on entity")
+        end
+        return added
+    end
+    tiny_addEntity = tiny.addEntity
+end
+
+--- Adds a System to the world. Returns the System.
+function tiny.addSystem(world, system)
+    if tinyLogSystemChanges then
+        print("addSystem '" .. (system.name or "unnamed") .. "'")
+    end
+    if system.world ~= nil then
+        error("System " .. system.name .. " already belongs to a World.")
+    end
+    local s2a = world.systemsToAdd
+    s2a[#s2a + 1] = system
+    system.world = world
+    return system
+end
+tiny_addSystem = tiny.addSystem
+
+--- Shortcut for adding multiple Entities and Systems to the World. Returns all
+-- added Entities and Systems.
+function tiny.add(world, ...)
+    for i = 1, select("#", ...) do
+        local obj = select(i, ...)
+        if obj then
+            if isSystem(obj) then
+                tiny_addSystem(world, obj)
+            else -- Assume obj is an Entity
+                tiny_addEntity(world, obj)
+            end
+        end
+    end
+    return ...
+end
+tiny_add = tiny.add
+
+--- Removes an Entity from the World. Returns the Entity.
+function tiny.removeEntity(world, entity)
+    local e2r = world.entitiesToRemove
+    e2r[#e2r + 1] = entity
+    return entity
+end
+tiny_removeEntity = tiny.removeEntity
+
+--- Removes a System from the world. Returns the System.
+function tiny.removeSystem(world, system)
+    if tinyLogSystemChanges then
+        print("removeSystem '" .. (system.name or "unnamed") .. "'")
+    end
+    if system.world ~= world then
+        error("System " .. system.name .. " does not belong to this World.")
+    end
+    local s2r = world.systemsToRemove
+    s2r[#s2r + 1] = system
+    return system
+end
+tiny_removeSystem = tiny.removeSystem
+
+--- Shortcut for removing multiple Entities and Systems from the World. Returns
+-- all removed Systems and Entities
+function tiny.remove(world, ...)
+    for i = 1, select("#", ...) do
+        local obj = select(i, ...)
+        if obj then
+            if isSystem(obj) then
+                tiny_removeSystem(world, obj)
+            else -- Assume obj is an Entity
+                tiny_removeEntity(world, obj)
+            end
+        end
+    end
+    return ...
+end
+
+-- Adds and removes Systems that have been marked from the World.
+function tiny_manageSystems(world)
+    local s2a, s2r = world.systemsToAdd, world.systemsToRemove
+
+    -- Early exit
+    if #s2a == 0 and #s2r == 0 then
+        return
+    end
+
+    world.systemsToAdd = {}
+    world.systemsToRemove = {}
+
+    local worldEntityList = world.entities
+    local systems = world.systems
+
+    -- Remove Systems
+    for i = 1, #s2r do
+        local system = s2r[i]
+        local index = system.index
+        local onRemove = system.onRemove
+        if onRemove and not system.nocache then
+            local entityList = system.entities
+            for j = 1, #entityList do
+                onRemove(system, entityList[j])
+            end
+        end
+        tremove(systems, index)
+        for j = index, #systems do
+            systems[j].index = j
+        end
+        local onRemoveFromWorld = system.onRemoveFromWorld
+        if onRemoveFromWorld then
+            onRemoveFromWorld(system, world)
+        end
+        s2r[i] = nil
+
+        -- Clean up System
+        if tinyLogSystemChanges then
+            print("Cleaning up system '" .. (system.name or "unnamed") .. "'")
+        end
+        system.world = nil
+        system.entities = nil
+        system.indices = nil
+        system.index = nil
+    end
+
+    -- Add Systems
+    for i = 1, #s2a do
+        local system = s2a[i]
+        if systems[system.index or 0] ~= system then
+            if not system.nocache then
+                system.entities = {}
+                system.indices = {}
+            end
+            if system.active == nil then
+                system.active = true
+            end
+            system.modified = true
+            system.world = world
+            local index = #systems + 1
+            system.index = index
+            systems[index] = system
+            local onAddToWorld = system.onAddToWorld
+            if onAddToWorld then
+                onAddToWorld(system, world)
+            end
+
+            -- Try to add Entities
+            if not system.nocache then
+                local entityList = system.entities
+                local entityIndices = system.indices
+                local onAdd = system.onAdd
+                local filter = system.filter
+                if filter then
+                    for j = 1, #worldEntityList do
+                        local entity = worldEntityList[j]
+                        if filter(system, entity) then
+                            local entityIndex = #entityList + 1
+                            entityList[entityIndex] = entity
+                            entityIndices[entity] = entityIndex
+                            if onAdd then
+                                onAdd(system, entity)
+                            end
+                        end
+                    end
+                end
+            end
+        end
+        s2a[i] = nil
+    end
+end
+
+-- Adds, removes, and changes Entities that have been marked.
+function tiny_manageEntities(world)
+
+    local e2r = world.entitiesToRemove
+    local e2c = world.entitiesToChange
+
+    -- Early exit
+    if #e2r == 0 and #e2c == 0 then
+        return
+    end
+
+    world.entitiesToChange = {}
+    world.entitiesToRemove = {}
+
+    local entities = world.entities
+    local systems = world.systems
+
+    -- Change Entities
+    for i = 1, #e2c do
+        local entity = e2c[i]
+        -- Add if needed
+        if not entities[entity] then
+            local index = #entities + 1
+            entities[entity] = index
+            entities[index] = entity
+        end
+        for j = 1, #systems do
+            local system = systems[j]
+            if not system.nocache then
+                local ses = system.entities
+                local seis = system.indices
+                local index = seis[entity]
+                local filter = system.filter
+                if filter and filter(system, entity) then
+                    if not index then
+                        system.modified = true
+                        index = #ses + 1
+                        ses[index] = entity
+                        seis[entity] = index
+                        local onAdd = system.onAdd
+                        if onAdd then
+                            onAdd(system, entity)
+                        end
+                    end
+                elseif index then
+                    system.modified = true
+                    local tmpEntity = ses[#ses]
+                    ses[index] = tmpEntity
+                    seis[tmpEntity] = index
+                    seis[entity] = nil
+                    ses[#ses] = nil
+                    local onRemove = system.onRemove
+                    if onRemove then
+                        onRemove(system, entity)
+                    end
+                end
+            end
+        end
+        e2c[i] = nil
+    end
+
+    -- Remove Entities
+    for i = 1, #e2r do
+        local entity = e2r[i]
+        e2r[i] = nil
+        local listIndex = entities[entity]
+        if listIndex then
+            -- Remove Entity from world state
+            local lastEntity = entities[#entities]
+            entities[lastEntity] = listIndex
+            entities[entity] = nil
+            entities[listIndex] = lastEntity
+            entities[#entities] = nil
+            -- Remove from cached systems
+            for j = 1, #systems do
+                local system = systems[j]
+                if not system.nocache then
+                    local ses = system.entities
+                    local seis = system.indices
+                    local index = seis[entity]
+                    if index then
+                        system.modified = true
+                        local tmpEntity = ses[#ses]
+                        ses[index] = tmpEntity
+                        seis[tmpEntity] = index
+                        seis[entity] = nil
+                        ses[#ses] = nil
+                        local onRemove = system.onRemove
+                        if onRemove then
+                            onRemove(system, entity)
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+
+--- Manages Entities and Systems marked for deletion or addition. Call this
+-- before modifying Systems and Entities outside of a call to `tiny.update`.
+-- Do not call this within a call to `tiny.update`.
+function tiny.refresh(world)
+    tiny_manageSystems(world)
+    tiny_manageEntities(world)
+    local systems = world.systems
+    for i = #systems, 1, -1 do
+        local system = systems[i]
+        if system.active then
+            local onModify = system.onModify
+            if onModify and system.modified then
+                onModify(system, 0)
+            end
+            system.modified = false
+        end
+    end
+end
+
+--- Updates the World by dt (delta time). Takes an optional parameter, `filter`,
+-- which is a Filter that selects Systems from the World, and updates only those
+-- Systems. If `filter` is not supplied, all Systems are updated. Put this
+-- function in your main loop.
+function tiny.update(world, dt, filter)
+
+    tiny_manageSystems(world)
+    tiny_manageEntities(world)
+
+    local systems = world.systems
+
+    -- Iterate through Systems IN REVERSE ORDER
+    for i = #systems, 1, -1 do
+        local system = systems[i]
+        if system.active then
+            -- Call the modify callback on Systems that have been modified.
+            local onModify = system.onModify
+            if onModify and system.modified then
+                onModify(system, dt)
+            end
+            local preWrap = system.preWrap
+            if preWrap and
+                ((not filter) or filter(world, system)) then
+                preWrap(system, dt)
+            end
+        end
+    end
+
+    local tinyLogSystemUpdateTime = tinyLogSystemUpdateTime
+    --  Iterate through Systems IN ORDER
+    for i = 1, #systems do
+        local system = systems[i]
+        if system.active and ((not filter) or filter(world, system)) then
+            -- Update Systems that have an update method (most Systems)
+            local update = system.update
+            if update then
+                local currentMs = tinyLogSystemUpdateTime and getCurrentTimeMilliseconds()
+                local interval = system.interval
+                if interval then
+                    local bufferedTime = (system.bufferedTime or 0) + dt
+                    while bufferedTime >= interval do
+                        bufferedTime = bufferedTime - interval
+                        update(system, interval)
+                    end
+                    system.bufferedTime = bufferedTime
+                else
+                    update(system, dt)
+                end
+                if tinyLogSystemUpdateTime then
+                    local endTimeMs = getCurrentTimeMilliseconds()
+                    print(tostring(endTimeMs - currentMs) .. "ms taken to update system '" .. system.name .. "'")
+                end
+            end
+
+            system.modified = false
+        end
+    end
+    if tinyLogSystemUpdateTime then
+        print("")
+    end
+
+    -- Iterate through Systems IN ORDER AGAIN
+    for i = 1, #systems do
+        local system = systems[i]
+        local postWrap = system.postWrap
+        if postWrap and system.active and
+            ((not filter) or filter(world, system)) then
+            postWrap(system, dt)
+        end
+    end
+
+end
+
+--- Removes all Entities from the World.
+function tiny.clearEntities(world)
+    local el = world.entities
+    for i = 1, #el do
+        tiny_removeEntity(world, el[i])
+    end
+end
+
+--- Removes all Systems from the World.
+function tiny.clearSystems(world)
+    local systems = world.systems
+    for i = #systems, 1, -1 do
+        tiny_removeSystem(world, systems[i])
+    end
+end
+
+--- Gets number of Entities in the World.
+function tiny.getEntityCount(world)
+    return #world.entities
+end
+
+--- Gets number of Systems in World.
+function tiny.getSystemCount(world)
+    return #world.systems
+end
+
+--- Sets the index of a System in the World, and returns the old index. Changes
+-- the order in which they Systems processed, because lower indexed Systems are
+-- processed first. Returns the old system.index.
+function tiny.setSystemIndex(world, system, index)
+    tiny_manageSystems(world)
+    local oldIndex = system.index
+    local systems = world.systems
+
+    if index < 0 then
+        index = tiny.getSystemCount(world) + 1 + index
+    end
+
+    tremove(systems, oldIndex)
+    tinsert(systems, index, system)
+
+    for i = oldIndex, index, index >= oldIndex and 1 or -1 do
+        systems[i].index = i
+    end
+
+    return oldIndex
+end
+
+-- Construct world metatable.
+worldMetaTable = {
+    __index = {
+        add = tiny.add,
+        addEntity = tiny.addEntity,
+        addSystem = tiny.addSystem,
+        remove = tiny.remove,
+        removeEntity = tiny.removeEntity,
+        removeSystem = tiny.removeSystem,
+        refresh = tiny.refresh,
+        update = tiny.update,
+        clearEntities = tiny.clearEntities,
+        clearSystems = tiny.clearSystems,
+        getEntityCount = tiny.getEntityCount,
+        getSystemCount = tiny.getSystemCount,
+        setSystemIndex = tiny.setSystemIndex
+    },
+    __tostring = function()
+        return "<tiny-ecs_World>"
+    end
+}
+
+_G.tiny = tiny
+return tiny

main.lua

@@ -0,0 +1,39 @@
+require("tiny-debug")
+tiny = require("lib/tiny")
+require("utils")
+require("tiny-tools")
+
+World = tiny.world()
+
+require("generated/filter-types")
+require("generated/assets")
+require("generated/all-systems")
+
+local scenarios = {
+    default = function()
+        -- TODO: Add default entities
+    end,
+    textTestScenario = function()
+        World:addEntity({
+            position = { x = 0, y = 600 },
+            drawAsText = {
+                text = "Hello, world!",
+                style = TextStyle.Inverted,
+            },
+            velocity = { x = 240, y = -500 },
+            mass = 1,
+            decayAfterSeconds = 10,
+        })
+    end,
+}
+
+scenarios.textTestScenario()
+
+function love.load()
+    love.graphics.setBackgroundColor(1, 1, 1)
+    love.graphics.setFont(EtBt7001Z0xa(32))
+end
+
+function love.draw()
+    World:update(love.timer.getDelta())
+end

systems/camera-pan.lua

@@ -0,0 +1,55 @@
+Camera = {
+    pan = {
+        x = 0,
+        y = 0,
+    },
+}
+
+expireBelowScreenSystem = filteredSystem("expireBelowScreen", { position = T.XyPair, expireBelowScreenBy = T.number })
+
+local focusPriority = {}
+
+cameraPanSystem = filteredSystem("cameraPan", { focusPriority = T.number, position = T.XyPair }, function(e, _)
+    if e.focusPriority >= focusPriority.priority then
+        focusPriority.position = e.position
+    end
+end)
+
+function cameraPanSystem.preProcess()
+    focusPriority.priority = 0
+    focusPriority.position = { x = 0, y = 0 }
+end
+
+function cameraPanSystem:postProcess()
+    Camera.pan.x = math.max(0, focusPriority.position.x - 200)
+    Camera.pan.y = math.min(0, focusPriority.position.y - 120)
+    -- TODO: set draw offset
+
+    for _, entity in pairs(expireBelowScreenSystem.entities) do
+        if entity.position.y - (Camera.pan.y + 240) > entity.expireBelowScreenBy then
+            self.world:removeEntity(entity)
+        end
+    end
+end
+
+local cameraTopIsh, cameraBottomIsh
+
+local enableNearCameraY = filteredSystem(
+    "enableNearCameraY",
+    { enableNearCameraY = Arr(T.Entity) },
+    function(e, _, system)
+        if e.position.y > cameraTopIsh and e.position.y < cameraBottomIsh then
+            for _, enable in ipairs(e.enableNearCameraY) do
+                enable.velocity = e.velocity
+                system.world:addEntity(enable)
+            end
+            system.world:removeEntity(e)
+        end
+    end
+)
+
+local within = 1000
+function enableNearCameraY:preProcess()
+    cameraTopIsh = Camera.pan.y - within
+    cameraBottomIsh = Camera.pan.y + 240 + within
+end

systems/collision-detection.lua

@@ -0,0 +1,39 @@
+collidingEntities = filteredSystem("collidingEntitites", {
+    velocity = T.XyPair,
+    position = T.XyPair,
+    size = T.XyPair,
+    canCollideWith = T.BitMask,
+    isSolid = Maybe(T.bool),
+})
+
+filteredSystem(
+    "collisionDetection",
+    { position = T.XyPair, size = T.XyPair, canBeCollidedBy = T.BitMask, isSolid = Maybe(T.bool) },
+    -- Here, the entity, e, refers to some entity that a moving object may be colliding *into*
+    function(e, _, system)
+        for _, collider in pairs(collidingEntities.entities) do
+            if
+                (e ~= collider)
+                and collider.canCollideWith
+                and e.canBeCollidedBy
+                and bit.band(collider.canCollideWith, e.canBeCollidedBy) ~= 0
+            then
+                local colliderTop = collider.position.y
+                local colliderBottom = collider.position.y + collider.size.y
+                local entityTop = e.position.y
+                local entityBottom = entityTop + e.size.y
+
+                local withinY = (entityTop > colliderTop and entityTop < colliderBottom)
+                    or (entityBottom > colliderTop and entityBottom < colliderBottom)
+
+                if
+                    withinY
+                    and collider.position.x < e.position.x + e.size.x
+                    and collider.position.x + collider.size.x > e.position.x
+                then
+                    system.world:addEntity({ collisionBetween = { e, collider } })
+                end
+            end
+        end
+    end
+)

systems/collision-resolution.lua

@@ -0,0 +1,4 @@
+filteredSystem("collisionResolution", { collisionBetween = T.Collision }, function(e, _, system)
+    local collidedInto, collider = e.collisionBetween[1], e.collisionBetween[2]
+    system.world:removeEntity(e)
+end)

systems/decay.lua

@@ -0,0 +1,6 @@
+filteredSystem("decay", { decayAfterSeconds = T.number }, function(e, dt, system)
+    e.decayAfterSeconds = e.decayAfterSeconds - dt
+    if e.decayAfterSeconds <= 0 then
+        system.world:removeEntity(e)
+    end
+end)

systems/draw.lua

@@ -0,0 +1,42 @@
+local gfx = love.graphics
+
+filteredSystem("drawRectangles", { position = T.XyPair, drawAsRectangle = { size = T.XyPair } }, function(e, _, _)
+    gfx.fillRect(e.position.x, e.position.y, e.drawAsRectangle.size.x, e.drawAsRectangle.size.y)
+end)
+
+filteredSystem("drawSprites", { position = T.XyPair, drawAsSprite = T.pd_image }, function(e)
+    if e.position.y < Camera.pan.y - 240 or e.position.y > Camera.pan.y + 480 then
+        return
+    end
+    e.drawAsSprite:draw(e.position.x, e.position.y)
+end)
+
+local margin = 8
+
+filteredSystem(
+    "drawText",
+    { position = T.XyPair, drawAsText = { text = T.str, style = Maybe(T.str), font = Maybe(T.pd_font) } },
+    function(e)
+        local font = gfx.getFont() -- e.drawAsText.font or AshevilleSans14Bold
+        local textHeight = font:getHeight()
+        local textWidth = font:getWidth(e.drawAsText.text)
+
+        local bgLeftEdge = e.position.x - margin - textWidth / 2
+        local bgTopEdge = e.position.y - 2
+        local bgWidth, bgHeight = textWidth + (margin * 2), textHeight + 2
+
+        if e.drawAsText.style == TextStyle.Inverted then
+            gfx.setColor(0, 0, 0)
+            gfx.rectangle("fill", bgLeftEdge, bgTopEdge, textWidth + margin, textHeight + 2)
+            gfx.setColor(1, 1, 1)
+        elseif e.drawAsText.style == TextStyle.Bordered then
+            gfx.setColor(1, 1, 1)
+            gfx.rectangle("fill", bgLeftEdge, bgTopEdge, bgWidth, bgHeight)
+
+            gfx.setColor(0, 0, 0)
+            gfx.drawRect("line", bgLeftEdge, bgTopEdge, bgWidth, bgHeight)
+        end
+
+        gfx.print(e.drawAsText.text, bgLeftEdge + margin, bgTopEdge + margin)
+    end
+)

systems/gravity.lua

@@ -0,0 +1,17 @@
+local min = math.min
+
+World:addEntity({ gravity = -300 })
+
+local gravities = filteredSystem("gravities", { gravity = T.number })
+
+filteredSystem("changeGravity", { changeGravityTo = T.number }, function(e, _, _)
+    for _, ge in pairs(gravities.entities) do
+        ge.gravity = e.changeGravityTo
+    end
+end)
+
+filteredSystem("fall", { velocity = T.XyPair, mass = T.number }, function(e, dt)
+    for _, ge in pairs(gravities.entities) do
+        e.velocity.y = min(400, e.velocity.y - (ge.gravity * dt * e.mass) - (0.5 * dt * dt))
+    end
+end)

systems/input.lua

@@ -0,0 +1,13 @@
+---@type ButtonState
+local buttonState = {}
+
+buttonInputSystem = filteredSystem("buttonInput", { canReceiveButtons = T.marker }, function(e, _, system)
+    e.buttonState = buttonState
+    system.world:addEntity(e)
+end)
+
+function buttonInputSystem:preProcess()
+    if #self.entities == 0 then
+        return
+    end
+end

systems/velocity.lua

@@ -0,0 +1,16 @@
+local sqrt = math.sqrt
+
+filteredSystem("velocity", { position = T.XyPair, velocity = T.XyPair }, function(e, dt, system)
+    if sqrt((e.velocity.x * e.velocity.x) + (e.velocity.y * e.velocity.y)) < 2 then
+        -- velocity = nil
+    else
+        e.position.x = e.position.x + (e.velocity.x * dt)
+        e.position.y = e.position.y + (e.velocity.y * dt)
+    end
+end)
+
+filteredSystem("drag", { velocity = T.XyPair, drag = T.number }, function(e, dt, system)
+    local currentDrag = e.drag * dt
+    e.velocity.x = e.velocity.x - (e.velocity.x * currentDrag * dt)
+    e.velocity.y = e.velocity.y - (e.velocity.y * currentDrag * dt)
+end)

tiny-debug.lua

@@ -0,0 +1,42 @@
+tinyTrackEntityAges = false
+tinyLogSystemUpdateTime = false
+tinyLogSystemChanges = false
+tinyWarnWhenNonDataOnEntities = false
+
+getCurrentTimeMilliseconds = function()
+    return love.timer.getTime() * 1000
+end
+
+ENTITY_INIT_MS = { "ENTITY_INIT_MS" }
+if tinyTrackEntityAges then
+    function tinyGetEntityAgeMs(entity)
+        return entity[ENTITY_INIT_MS]
+    end
+end
+
+if tinyWarnWhenNonDataOnEntities then
+    function checkForNonData(e, nested, tableCache)
+        nested = nested or false
+        tableCache = tableCache or {}
+
+        local valType = type(e)
+        if valType == "table" then
+            if tableCache[e] then
+                return
+            end
+            tableCache[e] = true
+            for k, v in pairs(e) do
+                local keyWarning = checkForNonData(k, true, tableCache)
+                if keyWarning then
+                    return keyWarning
+                end
+                local valueWarning = checkForNonData(v, true, tableCache)
+                if valueWarning then
+                    return valueWarning
+                end
+            end
+        elseif valType == "function" or valType == "thread" or valType == "userdata" then
+            return valType
+        end
+    end
+end

tiny-tools.lua

@@ -0,0 +1,34 @@
+---@generic T
+---@param shape T | fun()
+---@param process fun(entity: T, dt: number, system: System) | nil
+---@return System | { entities: T[] }
+function filteredSystem(name, shape, process)
+    assert(type(name) == "string")
+    assert(type(shape) == "table" or type(shape) == "function")
+    assert(process == nil or type(process) == "function")
+
+    local system = tiny.processingSystem()
+    system.name = name
+    if type(shape) == "table" then
+        local keys = {}
+        for key, value in pairs(shape) do
+            local isTable = type(value) == "table"
+            local isMaybe = isTable and value.maybe ~= nil
+
+            if not isMaybe then
+                -- ^ Don't require any Maybe types
+                keys[#keys + 1] = key
+            end
+        end
+        system.filter = tiny.requireAll(unpack(keys))
+    elseif type(shape) == "function" then
+        system.filter = shape
+    end
+    if not process then
+        return World:addSystem(system)
+    end
+    function system:process(e, dt)
+        process(e, dt, self)
+    end
+    return World:addSystem(system)
+end

tiny-types.lua

@@ -0,0 +1,31 @@
+---@meta
+
+---@class World
+World = {}
+
+function World:add(...) end
+
+function World:addEntity(entity) end
+
+function World:addSystem(system) end
+
+function World:remove(...) end
+
+function World:removeEntity(entity) end
+
+function World:removeSystem(system) end
+
+function World:refresh() end
+
+---@param dt number
+function World:update(dt) end
+
+function World:clearEntities() end
+
+function World:clearSystems() end
+
+function World:getEntityCount() end
+
+function World:getSystemCount() end
+
+function World:setSystemIndex() end

utils.lua

@@ -0,0 +1,74 @@
+Utils = {}
+
+--- Returns up to `n` random values from the given array. Will return fewer if `n > #fromArr`
+---@generic T
+---@param fromArr T[]
+---@param n number
+---@return T[]
+function Utils.getNDifferentValues(fromArr, n)
+    assert(n >= 0, "n must be a non-negative integer")
+    if n > #fromArr then
+        n = #fromArr
+    end
+    local found = 0
+    local indexes = {}
+    while found < n do
+        local randomIndex = math.random(#fromArr)
+        if not indexes[randomIndex] then
+            found = found + 1
+            indexes[randomIndex] = true
+        end
+    end
+
+    local randoms = {}
+    for i in pairs(indexes) do
+        randoms[#randoms + 1] = fromArr[i]
+    end
+    return randoms
+end
+
+--- Track the number of instances of a given element, instead of needing multiple copies.
+---@class CountSet
+---@field private data table<table, number>
+---@field private elementCount number
+CountSet = {}
+
+function CountSet.new()
+    return setmetatable({ data = {}, elementCount = 0 }, { __index = CountSet })
+end
+
+function CountSet:add(element)
+    local existing = self.data[element]
+    if existing then
+        self.data[element] = existing + 1
+    else
+        self.data[element] = 1
+    end
+    self.elementCount = self.elementCount + 1
+end
+
+function CountSet:balancedRandomPop()
+    if self.elementCount == 0 then
+        return
+    end
+    local toPop = math.random(self.elementCount)
+    for element, count in pairs(self.data) do
+        toPop = toPop - count
+        if toPop <= 0 then
+            local newCount = count - 1
+            if newCount == 0 then
+                self.data[element] = nil
+            else
+                self.data[element] = newCount
+            end
+            self.elementCount = self.elementCount - 1
+            return element
+        end
+    end
+end
+
+function CountSet:iterRandom()
+    return function()
+        return self:balancedRandomPop()
+    end
+end