added level in new format to repo

made math.round()
changed vector() and fixed accordingly

code/animation.lua

@@ -1,6 +1,6 @@
 Animation = {}
 
-function Animation:new(anim_data)
+function Animation:new(anim_data,speed)
 	local o = {}
 
 	o.path = anim_data.path
@@ -8,12 +8,17 @@ function Animation:new(anim_data)
 	o.imgs = anim_data.imgs
 	o.subframe = 0
 	o.frame = 1
+	o.speed = speed or 1
 
 	setmetatable(o, self)
 	self.__index = self
 	return o
 end
 
+function Animation:getCenteredOffset()
+	return self.imgs[1]:getWidth()/2, self.imgs[1]:getHeight()/2
+end
+
 function Animation:change(anim_data)
 	if anim_data.path == self.path
 	then
@@ -46,10 +51,10 @@ end
 function Animation:animate()
 	if self.frames[self.frame] ~= 0 then
 		-- try to animate
-		self.subframe = self.subframe + current_dt
+		self.subframe = self.subframe + self.speed
 
-		if self.subframe > self.frames[self.frame] then
-			self.subframe = self.subframe - self.frames[self.frame]
+		if self.subframe > self.frames[self.frame]*game.framerate then
+			self.subframe = self.subframe - self.frames[self.frame]*game.framerate
 			self.frame = self.frame + 1
 		end
 

code/camera.lua

@@ -1,36 +1,38 @@
 Camera = {
-	pos = {x = 0, y = 0},
+   pos = Point:new(0, 0),
    width = 0,
-	height = 0
+   height = 0,
+   speed = 4,
 }
 
 function Camera:followPlayer(player)
-	local pos = player.pos
+	-- make sure we have the Point metatable	self:moveTowards(pos)
+	local pos = Point.copy(player.pos)
 	local room = player:getCollidingAt(pos.x,pos.y,LoadedObjects.Rooms)
 
-	self:positionCenterAt(pos.x, pos.y)
-
-	self:confineTo(room)
+	self:moveTowards(self:confineTo(room, pos))
 end
 
-function Camera:confineTo(box)
+function Camera:confineTo(box, pos)
 	if box == nil then
 		--frameDebug("not in a room")
-		return
+		return pos
 	end
 	--frameDebug("in a room")
 
 	local w = self.width/game.scale
 	local h = self.height/game.scale
+	local npos = pos - self:centerOffset()
 
 	-- bottom edge
-	self.pos.y = math.min(self.pos.y+h, box.to.y)-h
+	npos.y = math.min(npos.y+h, box.to.y)-h
 	-- right edge
-	self.pos.x = math.min(self.pos.x+w, box.to.x)-w
+	npos.x = math.min(npos.x+w, box.to.x)-w
 	-- top edge
-	self.pos.y = math.max(self.pos.y, box.from.y)
+	npos.y = math.max(npos.y, box.from.y)
 	-- left edge
-	self.pos.x = math.max(self.pos.x, box.from.x)
+	npos.x = math.max(npos.x, box.from.x)
+	return npos + self:centerOffset()
 end
 
 function Camera:confineToLevel()
@@ -38,6 +40,32 @@ function Camera:confineToLevel()
 	self.pos.y = math.max(0,math.min(self.pos.y,LevelData.Height-self.height/game.scale))
 end
 
+function Camera:moveTowards(pt)
+   --local pt = Point:new(x,y)
+   local diff = pt - self:center()
+   local dist = diff:abs()
+   local npos
+   if dist < self.speed then
+	  npos = pt
+   else
+	   frameDebug("camera at speed limit")
+	   npos = self:center() + diff * (self.speed/dist)
+	   frameDebug("dist = "..dist..", npos = "..tostring(npos))
+   end
+   self:positionCenterAt(npos.x, npos.y)
+end
+
+function Camera:size()
+	return Point:new(self.width, self.height)
+end
+
+function Camera:centerOffset()
+	return self:size()/game.scale/2
+end
+
+function Camera:center()
+	return self.pos + self:centerOffset()
+end
 function Camera:positionCenterAt(x,y)
 	self.pos.x = x-self.width/game.scale/2
 	self.pos.y = y-self.height/game.scale/2
@@ -48,3 +76,17 @@ function Camera:positionAt(x,y)
 	self.pos.x = math.floor((x/self.width)*self.width)
 	self.pos.y = math.floor((y/self.height)*self.height)
 end
+
+-- translate screen coordinates to game coordinates
+function Camera:ptScreenToGame(pt)
+	return self.pos + pt
+end
+
+function Camera:mouseScreenPos()
+	return Point:new(love.mouse.getX(),love.mouse.getY()) / game.scale
+end
+
+-- return the mouse position as game coordinates
+function Camera:mouseGamePos()
+	return self:ptScreenToGame(self:mouseScreenPos())
+end

code/chunk.lua

@@ -0,0 +1,51 @@
+-- pieces of levels
+
+Chunk = {all = {}}
+Chunk.__index = Chunk
+
+-- CLASS METHODS
+
+-- box == nil for global chunks
+function Chunk:new(filename, box)
+	local o = { filename = filename, box = box }
+	setmetatable(o, self)
+	self.all[o] = true
+end
+
+function Chunk:getExportList()
+	local r = {}
+	for chunk in pairs(self.all) do
+		table.insert(r, {chunk.filename, chunk.box})
+	end
+	return r
+end
+
+-- INSTANCE METHODS
+
+function Chunk:containsPoint(pt)
+	return self.box == nil or self.box:containsPoint(pt)
+end
+
+function Chunk:load()
+	if self.loaded then
+		return
+	end
+	logPrint("loading chunk "..self.filename)
+	self.data = dofile(level_current.."/chunks/"..self.filename)
+	self.loaded = { rooms = {}, collisions = {} }
+	LevelTiles = self.data.tiles
+	indexLevelTiles()
+	optimizeTileObjects(self.loaded.collisions)
+
+	for _, v in ipairs(self.data.rooms or {}) do
+		local room = Collision:new(v[1],v[2],v[3],v[4])
+		table.insert(self.data.rooms, room)
+		table.insert(LoadedObjects.Rooms, room)
+	end
+	logPrint("loaded chunk with "..#self.loaded.collisions.." collisions")
+end
+
+function Chunk:save(chunkdir)
+	return love.filesystem.write(chunkdir.."/"..self.filename, "return "..serialize_lua_value(self.data))
+end
+

code/collision.lua

@@ -10,10 +10,10 @@ LoadedObjects.Rooms = {}
 --[[
 	Collision
 
-	[bool flag] isDisabled
+	[bool flag] is_disabled
 		> if true used for collision
 
-	[bool flag] isColliding
+	[bool flag] is_colliding
 		> if true, this collision is colliding
 
 	[vec2 position] from - x, y
@@ -31,7 +31,7 @@ LoadedObjects.Rooms = {}
 
 -- can also be called with only ox and oy, where they become the width and height instead
 function Collision:new(ox,oy,tx,ty)
-	local o = {isColliding = false, isDisabled = false}
+	local o = {is_colliding = false, is_disabled = false}
 
 	if tx ~= nil and ty ~= nil then
 		o.from = {x = ox, y = oy}
@@ -77,7 +77,7 @@ function Collision:containsPoint(x, y)
 end
 
 function Collision:draw(color)
-	if self.isColliding == true then
+	if self.is_colliding == true then
 		love.graphics.setColor(0,1,0,0.5)
 	elseif color == 1 then
 		love.graphics.setColor(1,0,0,0.5)
@@ -88,3 +88,7 @@ function Collision:draw(color)
 	love.graphics.setColor(0,1,90,0.5)
 	love.graphics.rectangle("line",self.from.x-Camera.pos.x, self.from.y-Camera.pos.y, self.width, self.height)
 end
+
+function Collision:asRect()
+	return Rect:fromCoords(self.from.x, self.from.y, self.to.x, self.to.y)
+end

code/debug.lua

@@ -8,21 +8,19 @@ function debugUI()
 		love.graphics.print(light.pos.x,light.pos.x,light.pos.y+40)
 	end
 
-	love.graphics.print("time: ".. tostring(math.floor(100*game.secondsSinceStart)/100) .." fps: "..fps_current, 10*textScale, 0*textScale, 0, textScale)
-	love.graphics.print(--[["CPUtime: "..checkCPUTime("total")..", CPU: "..(math.floor(checkCPUTime("get")*10000)/100).."%,]] "memoryUsage: "..memoryUsage.."kB", 10*textScale, 20*textScale, 0, textScale)
+	love.graphics.print("time: ".. tostring(math.floor(100*game.seconds_since_start)/100) .." fps: "..fps_current, 10*text_size, 0*text_size, 0, text_size)
+	love.graphics.print(--[["CPUtime: "..checkCPUTime("total")..", CPU: "..(math.floor(checkCPUTime("get")*10000)/100).."%,]] "memory_usage: "..memory_usage.."kB", 10*text_size, 20*text_size, 0, text_size)
 
 	love.graphics.setColor(1,1,1)
 	-- lots of variables
-	love.graphics.print("LoadedObjects",10*textScale,40*textScale, 0, textScale)
+	love.graphics.print("LoadedObjects",10*text_size,40*text_size, 0, text_size)
 	local i = 1
 	for k, v in pairs(LoadedObjects) do
 		if type(v) == "table" then
-			love.graphics.print("<"..k.."> ".. #v,10*textScale,(40+(10*i))*textScale, 0, textScale)
+			love.graphics.print("<"..k.."> ".. #v,10*text_size,(40+(10*i))*text_size, 0, text_size)
 			i = i + 1
 		end
 	end
-	-- player isOnGroundCheck
-	--love.graphics.main_Player
 	love.graphics.setColor(1,0,0)
 end
 
@@ -34,7 +32,7 @@ end
 
 function debugEntities()
 	love.graphics.setScale(game.scale)
-	for _, particle in pairs(LoadedParticles) do
+	for _, particle in pairs(LoadedObjects.Particles) do
 		particle:debug()
 	end
 	for _, enty in pairs(LoadedObjects.Entities) do

code/demo.lua

@@ -37,8 +37,8 @@ function Demo:startRecord()
 		os.execute( "mkdir \"./demos\"" )
 		DemoFile = io.open("demos/play_demo.lua", "w+")
 		--DemoFile = io.open("demo/mothbackDemo_"..os.date("%Y-%m-%d_%H-%M-%S")..".lua", "w+")
-		DemoFile:write("main_Player.pos.x = "..main_Player.pos.x.."\n")
-		DemoFile:write("main_Player.pos.y = "..main_Player.pos.y.."\n")
+		DemoFile:write("main_player.pos.x = "..main_player.pos.x.."\n")
+		DemoFile:write("main_player.pos.y = "..main_player.pos.y.."\n")
 		DemoFile:write("DemoAction = {\n")
 		DemoRecording = true
 		CurrentDemoFrame = 1

code/editor.lua

@@ -1,10 +1,38 @@
 assert(editor == nil)
-editor = { room_mode = false }
+editor = {
+	active = false,
+	room_mode = false,
+	palette = {
+		active = false,
+		scroll = Point:new(0, 0),
+	},
+	multiselect = {
+		active = false,
+		sweeping = false,
+		box = nil,
+	},
+	pan = { fixed = false, speed = 3 },
+}
 
 function stepEditor()
-	palette = palette or false
-	AnimateTiles()
-	if Keybind:CheckPressed(Keybind.editor.room_mode) then
+
+	animateTiles()
+
+	local osweep = editor.multiselect.sweeping
+	editor.multiselect.sweeping = Keybind:checkDown(Keybind.editor.entity_select)
+	frameDebug("sweeping: "..tostring(editor.multiselect.sweeping))
+	if editor.multiselect.sweeping and not editor.multiselect.active then
+		print("multiselect enabled")
+		editor.multiselect.active = true
+	end
+	if not osweep and osweep ~= editor.multiselect.sweeping then
+		editor.multiselect.box = nil
+	end
+	if editor.multiselect.active then
+		doEditorMultiselect()
+	end
+
+	if Keybind:checkPressed(Keybind.editor.room_mode) then
 		if love.keyboard.isDown("lshift") then
 			editor.room_mode = "delete"
 		else
@@ -12,34 +40,34 @@ function stepEditor()
 		end
 		editor.room_points = {}
 	end
-
-	if Keybind:CheckPressed(Keybind.editor.palette) then
-		if palette then
-			palette = false
-			palette_scroll_x = nil
-			palette_scroll_y = nil
-		else
-			palette = true
-			palette_scroll_x = 0
-			palette_scroll_y = 0
-		end
-	end
-	-- TODO:
-	if love.keyboard.isDown('a',"left") then
-		Camera.pos.x = Camera.pos.x - 3/game.scale
-	end
-	if love.keyboard.isDown('d',"right") then
-		Camera.pos.x = Camera.pos.x + 3/game.scale
-	end
-	if love.keyboard.isDown("up", "w") then
-		Camera.pos.y = Camera.pos.y - 3/game.scale
-	end
-	if love.keyboard.isDown("down", "s") then
-		Camera.pos.y = Camera.pos.y + 3/game.scale
+	if Keybind:checkPressed(Keybind.editor.palette_mode) then
+		editor.palette.active = not editor.palette.active
 	end
 
-	if palette then
-		if Keybind:CheckPressed(Keybind.debug.debug) then
+
+	local cvel = Point:new(0, 0)
+	if Keybind:checkDown(Keybind.editor.left) then
+		cvel.x = -1
+	end
+	if Keybind:checkDown(Keybind.editor.right) then
+		cvel.x = 1
+	end
+	if Keybind:checkDown(Keybind.editor.up) then
+		cvel.y = -1
+	end
+	if Keybind:checkDown(Keybind.editor.down) then
+		cvel.y = 1
+	end
+
+	cvel = cvel * editor.pan.speed
+	if not editor.pan.fixed then
+		cvel = cvel / game.scale
+	end
+
+	Camera.pos = Camera.pos + cvel
+
+	if editor.palette.active then
+		if Keybind:checkPressed(Keybind.editor.palette_change) then
 			local next = false
 			local export = nil
 			for k, v in pairs(tileset) do
@@ -59,30 +87,39 @@ function stepEditor()
 			if next then
 				LevelData.tileset = export
 			end
-			LevelGetTileData()
-			LevelIndexTiles()
+			getLevelTileData()
+			indexLevelTiles()
 		end
 	end
 
-	if Keybind:CheckPressed(Keybind.debug.reload) then
-		ExportLevel("test")
-	end
-
-	if Keybind:CheckPressed(Keybind.debug.editor) then
-		editor_mode = false
-		TileCreateObjects()
+	if Keybind:checkPressed(Keybind.editor.save) then
+		Prompt:new({
+				name = "level name",
+				input = "unnamed",
+				func = function(name_prompt)
+					if name_prompt.canceled then return end
+					Prompt:new({
+							name = "filename",
+							input = "unnamed_level",
+							func = function(file_prompt)
+								if file_prompt.canceled then return end
+								exportLevel(name_prompt.input, file_prompt.input)
+							end,
+					}):activate()
+				end,
+		}):activate()
 	end
 end
 
 function scrollEditor(y)
-	if palette then
+	if editor.palette.active then
+		local scr = editor.palette.scroll
 		if love.keyboard.isDown("lshift") then
-			palette_scroll_y = palette_scroll_y + y
+			scr.y = scr.y + y
 		else
-			palette_scroll_x = palette_scroll_x + y
+			scr.x = scr.x + y
 		end
 	else
-		local oscale = game.scale
 	 	game.scale = math.max(0.1,game.scale + y/16)
 	end
 end
@@ -93,47 +130,60 @@ function drawEditor()
 	drawGridDisplay()
 	drawGameworldForeground()
 	endGameworldDraw()
-	doEditorEdit()
 
 	drawEditorRooms()
+	drawSpawns()
+
+	doEditorEdit()
+
 	drawSelectingPaletteTile()
 
-	if palette then
+	if editor.palette.active then
 		doEditorPalette()
 	end
+	if editor.multiselect.box ~= nil then
+		frameDebug("drawing multiselect "..tostring(editor.multiselect.box))
+		drawEditorMultiselect()
+	end
 end
 
 function doEditorEdit()
 	local mouse_x = love.mouse.getX()
 	local mouse_y = love.mouse.getY()
-	local horizontal = 1+math.floor(((mouse_x/game.scale) / tileProperties.width) + (Camera.pos.x / tileProperties.width))
-	local vertical = 1+math.floor(((mouse_y/game.scale) / tileProperties.height) + (Camera.pos.y / tileProperties.height))
+	local horizontal = 1+math.floor(((mouse_x/game.scale) / tile_properties.width) + (Camera.pos.x / tile_properties.width))
+	local vertical = 1+math.floor(((mouse_y/game.scale) / tile_properties.height) + (Camera.pos.y / tile_properties.height))
 	local expand_h = 0
 	local expand_v = 0
-	local LevelWidth = LevelGetTileWidth()
-	local LevelHeight = LevelGetTileHeight()
+	local level_width = getLevelTileWidth()
+	local level_height = getLevelTileHeight()
 
-	if horizontal > LevelWidth then
-		 expand_h = horizontal-LevelWidth
+	if horizontal > level_width then
+		 expand_h = horizontal-level_width
 	elseif horizontal < 0 then
 		 expand_h = horizontal
 	end
-	if vertical > LevelHeight then
-		 expand_v = vertical-LevelHeight
+	if vertical > level_height then
+		 expand_v = vertical-level_height
 	elseif vertical < 0 then
 		 expand_v = vertical
 	end
 	love.graphics.setColor(100, 100, 100, 0.8)
-	love.graphics.print("> " .. horizontal .. ", " .. vertical .. "; " .. math.floor(mouse_x / game.scale + Camera.pos.x) .. ", " .. math.floor(mouse_y / game.scale + Camera.pos.y))
-	love.graphics.print("> " .. LevelWidth .. "(" .. expand_h .. "), " .. LevelHeight .. "(".. expand_v .. ")", 0, 10)
+		drawTextBox(
+		 	"Coords: [" ..
+			horizontal .. "," .. vertical .. "] (tile)\t[" ..
+			math.floor(mouse_x / game.scale + Camera.pos.x) .. "," .. math.floor(mouse_y / game.scale + Camera.pos.y).."] (pixel)\n" ..
+			 "Level size: [" ..	level_width .. ", " .. level_height .. "] +(" .. expand_h .. "," .. expand_v .. ")",
+			0,
+			0
+		)
 
 	if editor.room_mode then
-		local rx = horizontal * tileProperties.width
-		local ry = vertical * tileProperties.height
+		local rx = horizontal * tile_properties.width
+		local ry = vertical * tile_properties.height
 		local r = editor.room_points
-		if Keybind:CheckPressed(Keybind.generic.rclick) then
+		if Keybind:checkPressed(Keybind.generic.rclick) then
 			editor.room_points = {}
-		elseif Keybind:CheckPressed(Keybind.generic.lclick) then
+		elseif Keybind:checkPressed(Keybind.generic.lclick) then
 			if editor.room_mode == "delete" then
 				for i, room in ipairs(LoadedObjects.Rooms) do
 					if room:containsPoint(rx, ry) then
@@ -145,37 +195,57 @@ function doEditorEdit()
 			end
 		end
 		if #editor.room_points == 2 then
-			table.insert(LoadedObjects.Rooms, Collision:new(r[1].x,r[1].y,r[2].x,r[2].y))
+			table.insert(LoadedObjects.Rooms, Collision:new(r[1].x-tile_properties.width,r[1].y-tile_properties.height,r[2].x,r[2].y))
 			editor.room_points = {}
 		end
 		if editor.room_mode == "delete" then
-			love.graphics.print("Select room to delete", 0, 20)
+			drawTextBox("Select room to delete", 0, 20)
 		elseif #editor.room_points == 0 then
-			love.graphics.print("Select top left of new room", 0, 20)
+			drawTextBox("Select top left of new room", 0, 20)
 		else
-			love.graphics.print("Select bottom right of new room", 0, 20)
+			drawTextBox("Select bottom right of new room", 0, 20)
 		end
-	elseif not palette then
+	elseif not editor.palette.active then
 		if 	LevelTiles[vertical] ~= nil
 		and LevelTiles[vertical][horizontal] ~= nil
 		and love.keyboard.isDown("lshift") ~= true
 		and love.keyboard.isDown("lctrl") ~= true
 		then
-			if Keybind:CheckDown(Keybind.generic.lclick)
-			and selecting_tile ~= nil
-			then
-				SetTile(vertical,horizontal,selecting_tile)
-			elseif Keybind:CheckDown(Keybind.generic.rclick) then
-				SetTile(vertical,horizontal,0)
+			if selecting_tile ~= nil then
+				if Keybind:checkDown(Keybind.editor.tile_set) then
+					setTile(vertical,horizontal,selecting_tile)
+				elseif Keybind:checkDown(Keybind.editor.tile_remove) then
+					setTile(vertical,horizontal,0)
 				end
-			LevelReloadTiles()
-
-		elseif Keybind:CheckPressed(Keybind.generic.lshift) then
-			LevelExpandCanvas(math.sign(expand_h),math.sign(expand_v))
-			LevelReloadTiles()
-		elseif Keybind:CheckPressed(Keybind.generic.lctrl) then
-			LevelReduceCanvas(math.sign(expand_h),math.sign(expand_v))
-			LevelReloadTiles()
+				reloadLevelTiles()
+			else
+				if Keybind:checkDown(Keybind.editor.entity_select) then
+					deselectSpawns()
+					if editor.multiselect.box then
+						selectSpawns(editor.multiselect.box)
+					end
+				end
+				if Keybind:checkDown(Keybind.editor.entity_move) then
+					moveSpawns(mouse_x,mouse_y)
+				end
+				if Prompt.active_prompt == nil then
+					if Keybind:checkDown(Keybind.editor.entity_modify_archetype) then
+						promptSpawnArchetype()
+					elseif Keybind:checkDown(Keybind.editor.entity_modify_data) then
+						promptSpawnArgs()
+					elseif Keybind:checkDown(Keybind.editor.entity_remove) then
+						deleteSpawn()
+					elseif Keybind:checkDown(Keybind.editor.entity_new) then
+						promptSpawnNew()
+					end
+				end
+			end
+		elseif Keybind:checkPressed(Keybind.generic.lshift) then
+			expandLevelCanvas(math.sign(expand_h),math.sign(expand_v))
+			reloadLevelTiles()
+		elseif Keybind:checkPressed(Keybind.generic.lctrl) then
+			reduceLevelCanvas(math.sign(expand_h),math.sign(expand_v))
+			reloadLevelTiles()
 		end
 	end
 end
@@ -185,10 +255,10 @@ function drawSelectingPaletteTile()
 
 		local mouse_x = love.mouse.getX()
 		local mouse_y = love.mouse.getY()
-		local horizontal = math.floor(((mouse_x/game.scale) / tileProperties.width) + (Camera.pos.x / tileProperties.width))
-		local vertical = math.floor(((mouse_y/game.scale) / tileProperties.height) + (Camera.pos.y / tileProperties.height))
-		local draw_x = tileProperties.width * horizontal - Camera.pos.x
-		local draw_y = tileProperties.height * vertical - Camera.pos.y
+		local horizontal = math.floor(((mouse_x/game.scale) / tile_properties.width) + (Camera.pos.x / tile_properties.width))
+		local vertical = math.floor(((mouse_y/game.scale) / tile_properties.height) + (Camera.pos.y / tile_properties.height))
+		local draw_x = tile_properties.width * horizontal - Camera.pos.x
+		local draw_y = tile_properties.height * vertical - Camera.pos.y
 
 		love.graphics.draw(
 			LevelData.tileset,
@@ -200,27 +270,31 @@ function drawSelectingPaletteTile()
 end
 
 function doEditorPalette()
-
-	local width = LevelData.tileset:getPixelWidth()/tileProperties.width
-	local height = LevelData.tileset:getPixelHeight()/tileProperties.height
+	local width = LevelData.tileset:getPixelWidth()/tile_properties.width
+	local height = LevelData.tileset:getPixelHeight()/tile_properties.height
+	local mouse_x = love.mouse.getX()
+	local mouse_y = love.mouse.getY()
+	local hovering = nil
+	local hov_x = nil
+	local hov_y = nil
+	local output = ""
 
 	love.graphics.setColor(0,0,0,1)
 	love.graphics.rectangle(
 		"fill",
-		(palette_scroll_x + 1) * (tileProperties.width+1),
-		(palette_scroll_y + 1) * (tileProperties.height+1),
-		1 + LevelData.tileset:getPixelWidth() * ((tileProperties.width+1) / tileProperties.width),
-		1 + LevelData.tileset:getPixelHeight()* ((tileProperties.height+1) / tileProperties.height)
+		(editor.palette.scroll.x + 1) * (tile_properties.width+1),
+		(editor.palette.scroll.y + 1) * (tile_properties.height+1),
+		1 + LevelData.tileset:getPixelWidth() * ((tile_properties.width+1) / tile_properties.width),
+		1 + LevelData.tileset:getPixelHeight()* ((tile_properties.height+1) / tile_properties.height)
 	)
-
-
 	love.graphics.setColor(1,1,1,1)
+
 	local position_x = 1
 	local position_y = 1
 	for i = 1, #TileIndex-width-1 do
 
-		local tile_x = (palette_scroll_x + position_x) * (tileProperties.width+1)
-		local tile_y = (palette_scroll_y + position_y) * (tileProperties.height+1)
+		local tile_x = (editor.palette.scroll.x + position_x) * (tile_properties.width+1)
+		local tile_y = (editor.palette.scroll.y + position_y) * (tile_properties.height+1)
 
 		love.graphics.draw(
 			LevelData.tileset,
@@ -231,22 +305,21 @@ function doEditorPalette()
 			1,
 			1
 		)
-		if Keybind:CheckDown(Keybind.generic.lclick) then
-			local mouse_x = love.mouse.getX()
-			local mouse_y = love.mouse.getY()
 
 		if 	mouse_x > (tile_x) * game.scale
-			and mouse_x < (tile_x + tileProperties.width) * game.scale
+		and mouse_x < (tile_x + tile_properties.width) * game.scale
 		and mouse_y > (tile_y) * game.scale
-			and mouse_y < (tile_y + tileProperties.height) * game.scale
+		and mouse_y < (tile_y + tile_properties.height) * game.scale
 		then
-				selecting_tile = position_x + ((position_y-1) * width)
-
-				love.graphics.print(selecting_tile .. " | " .. tile_x .. ", " .. tile_y, 0, 20)
+			hovering =  position_x + ((position_y-1) * width)
+			hov_x = tile_x
+			hov_y = tile_y
+			if Keybind:checkDown(Keybind.generic.lclick) then
+				selecting_tile = hovering
 			end
 		end
 
-		if Keybind:CheckDown(Keybind.generic.rclick) then
+		if Keybind:checkDown(Keybind.generic.rclick) then
 			selecting_tile = nil
 		end
 
@@ -256,8 +329,8 @@ function doEditorPalette()
 				"line",
 				tile_x,
 				tile_y,
-				tileProperties.width,
-				tileProperties.height
+				tile_properties.width,
+				tile_properties.height
 			)
 			love.graphics.setColor(1,1,1,1)
 		end
@@ -273,17 +346,47 @@ function doEditorPalette()
 
 	love.graphics.rectangle(
 		"line",
-		(palette_scroll_x + 1) * (tileProperties.width+1),
-		(palette_scroll_y + 1) * (tileProperties.height+1),
-		1 + LevelData.tileset:getPixelWidth() * ((tileProperties.width+1) / tileProperties.width),
-		1 + LevelData.tileset:getPixelHeight()* ((tileProperties.height+1) / tileProperties.height)
+		(editor.palette.scroll.x + 1) * (tile_properties.width+1),
+		(editor.palette.scroll.y + 1) * (tile_properties.height+1),
+		1 + LevelData.tileset:getPixelWidth() * ((tile_properties.width+1) / tile_properties.width),
+		1 + LevelData.tileset:getPixelHeight()* ((tile_properties.height+1) / tile_properties.height)
+	)
+
+	local tile = "none"
+	if selecting_tile ~= nil then
+		tile = "#"..selecting_tile
+	end
+	output = output .. "Selected: " .. tile
+
+	if hovering ~= nil then
+		output = output .. " \nHovering: #".. hovering .. "\nImage coords: " .. hov_x .. ", " .. hov_y
+	end
+
+	drawTextBox(
+		output,
+		(editor.palette.scroll.x + 1+width) * (tile_properties.width+1),
+		(editor.palette.scroll.y + 1) * (tile_properties.height+1)
 	)
 end
 
 
 function drawEditorRooms()
 	for _, room in pairs(LoadedObjects.Rooms) do
-		love.graphics.setColor(0,0,100,1)
-		love.graphics.rectangle("line",room.from.x-Camera.pos.x, room.from.y-Camera.pos.y, room.width, room.height)
+		love.graphics.setColor(0,0,1,1)
+		room:asRect():draw("line")
+	end
+end
+
+function drawEditorMultiselect()
+	love.graphics.setColor(0,1,1,1)
+	editor.multiselect.box:draw("line")
+end
+
+function doEditorMultiselect()
+	local mousept = Camera:mouseGamePos()
+	if editor.multiselect.box == nil then
+		editor.multiselect.box = Rect:fromPoints(mousept, mousept)
+	elseif editor.multiselect.sweeping then
+		editor.multiselect.box.max = mousept
 	end
 end

code/entities/arrow.lua

@@ -1,10 +1,10 @@
 Arrow = Entity:new()
+Arrow.type = "Arrow"
+
 
 function Arrow:new(x,y,rotation,speed)
 	local o = Entity:new(x,y)
 
-	o.type = "arrow"
-
 	o.pos = {x = x, y = y}
 	o.speed = speed or 10
 	o.sprite_rotation = rotation or 0
@@ -24,8 +24,7 @@ function Arrow:new(x,y,rotation,speed)
 		to = {x = 0.5, y = 0.5} -- gameworld pixels
 	}
 
-	table.insert(LoadedObjects.Entities,o)
-	o.id = #LoadedObjects.Entities
+	o:id()
 
 	setmetatable(o, self)
 	self.__index = self
@@ -37,20 +36,30 @@ function Arrow:drawBackground()
 end
 
 function Arrow:doPhysics()
-	if not self:isCollidingAt(self.pos.x + self.vel.x, self.pos.y, LoadedObjects.Collisions) then
-		self.pos.x = self.pos.x + self.vel.x
-	else
+	-- horizontal collision
+	self:moveX(
+		self.vel.x,
+		function()
 			self.stuck = true
 		end
-	if not self:isCollidingAt(self.pos.x, self.pos.y + self.vel.y, LoadedObjects.Collisions) then
-		self.pos.y = self.pos.y + self.vel.y
-	else
+	)
+
+	if not self.stuck then
+		-- vertical collision
+		self:moveY(
+			self.vel.y,
+			function()
 				self.stuck = true
 			end
+		)
+	end
+
 	if self.stuck then
 		self.pos.x = self.pos.x + self.vel.x * (2/3)
 		self.pos.y = self.pos.y + self.vel.y * (2/3)
 		self.vel.x = 0
 		self.vel.y = 0
 	end
+
+	self:adjustLight()
 end

code/entities/cursed_book.lua

@@ -1,9 +1,10 @@
 CursedBook = Entity:new()
+CursedBook.type = "CursedBook"
+CursedBook.display = Animation:new(animation.cursed_book.flying)
 
 function CursedBook:new(x,y)
 	local o = Entity:new(x,y)
 
-	o.type = "cursed_book"
 	-- behaviour
 	o.pos = {x = x, y = y}
 	o.speed = 0.01
@@ -21,16 +22,16 @@ function CursedBook:new(x,y)
 
 	-- animations
 	o.body = Animation:new(animation.cursed_book.spawn)
+	o.body.speed = 0
 	o.sprite_tint = {0.7,0.7,0.7}
 	o:centerOffset(o.body)
 	o:createBox(o.body)
 
 	-- light
 	o.light_range = 500
-	o.light = Light:new(o.pos.x,o.pos.y,o.light_range,2,HEX2RGB("#fe00d1"))
+	--o.light = Light:new(o.pos.x,o.pos.y,o.light_range,2,hex2rgb("#fe00d1"))
 
-	table.insert(LoadedObjects.Entities,o)
-	o.id = #LoadedObjects.Entities
+	o:id()
 
 	setmetatable(o, self)
 	self.__index = self
@@ -38,18 +39,20 @@ function CursedBook:new(x,y)
 end
 
 function CursedBook:doLogic()
-	self.target.x = main_Player.pos.x - main_Player.target_offset.x
-	self.target.y = main_Player.pos.y - main_Player.target_offset.y
+	print(self.status)
+	self.target.x = main_player.pos.x - main_player.target_offset.x
+	self.target.y = main_player.pos.y - main_player.target_offset.y
+
 	local distance_x = self.target.x - self.pos.x
 	local distance_y = self.target.y - self.pos.y
-	local angle = GetAngleFromVector(distance_x,distance_y)
+	local angle = getAngleFromVector(distance_x,distance_y)
 	local distance = math.sqrt(distance_x ^ 2 + distance_y ^ 2)
 
 	if self.status == 0 then
 		if distance < self.spawn_range then
 			self.status = 1
 		end
-	elseif self.status == -1 then
+	elseif self.status == 2 then
 		if distance < self.range then
 			self.vel.x = 0
 			self.vel.y = 0
@@ -59,21 +62,29 @@ function CursedBook:doLogic()
 		end
 	elseif self.status == 2 then
 		if distance < self.attack_range then
-			self.status = 3
+			--self.status = 3
 		end
 	elseif self.status == 4 then
 
 	end
+
+	if self.isFlying then
+		local random_x = math.random(-4, 4)/100
+		local random_y = math.random(-4, 4)/100
+		self.vel.x = self.vel.x + random_x
+		self.vel.y = self.vel.y + random_y
+	end
 end
 
 function CursedBook:handleAnimation()
 	if self.status == 1 then
 		if self.body.path == "assets/entities/cursed_book/spawn" then
-			self.body.speed = 1/3
-			local tint = 0.7 + 0.3 * (self.body.frame-1)/self.body.frames
+			self.body.speed = 1
+			local tint = 0.7 + 0.3 * (self.body.frame-1)/#self.body.frames
 			self.sprite_tint = {tint,tint,tint}
-			if self.body.frame == self.body.frames then
+			if self.body.frame == #self.body.frames then
 				self.status = 2
+				self.isFlying = true
 				self.body = self.body:change(animation.cursed_book.flying)
 				self.sprite_tint = {1,1,1}
 				--self:getBoundingBox(self.body,2,2,-2,-2)
@@ -83,9 +94,9 @@ function CursedBook:handleAnimation()
 	elseif self.status == 3 then
 		if self.body.path == "assets/entities/cursed_book/flying" then
 			self.body = self.body:change(animation.cursed_book.attack_transition)
-			self.body.speed = 1/3
-			self:centerOffset(self.body)
-			if self.body.frame == self.body.frames then
+			self.body.speed = 1
+			--self:centerOffset(self.body)
+			if self.body.frame == #self.body.frames then
 				self.status = 4
 				self.body = self.body:change(animation.cursed_book.attack_loop)
 				self:centerOffset(self.body)
@@ -97,15 +108,21 @@ function CursedBook:handleAnimation()
 end
 
 function CursedBook:doPhysics()
-	if self.isFlying then
-		local random_x = math.random(-4, 4)/100
-		local random_y = math.random(-4, 4)/100
-		self.vel.x = self.vel.x + random_x
-		self.vel.y = self.vel.y + random_y
+	-- horizontal collision
+	self:moveX(
+		self.vel.x,
+		function()
+			self.vel.x = 0
 		end
-	-- move
-
-	self:moveWithCollision()
+	)
+	-- vertical collision
+	self:moveY(
+		self.vel.y,
+		function()
+			self.vel.y = 0
+		end
+	)
+	-- final position
 	self:adjustLight()
 end
 
@@ -115,5 +132,5 @@ function CursedBook:debug()
 	love.graphics.circle("line", -Camera.pos.x + self.pos.x, -Camera.pos.y + self.pos.y, self.spawn_range)
 	love.graphics.setColor(1,0,0)
 	love.graphics.circle("line", -Camera.pos.x + self.pos.x, -Camera.pos.y + self.pos.y, self.attack_range)
-	Entity.Debug(self)
+	Entity.debug(self)
 end

code/entities/decoration.lua

@@ -1,10 +1,10 @@
 Decoration = Entity:new()
+Decoration.type = "Decoration"
+Decoration.display = nil
 
 function Decoration:new(x,y,animation,light_radius)
 	local o = Entity:new(x,y)
 
-	o.type = "decoration"
-
 	o.pos = {x = x, y = y}
 
 	-- animations
@@ -17,8 +17,7 @@ function Decoration:new(x,y,animation,light_radius)
 		o.light = Light:new(o.pos.x,o.pos.y,o.light_radius)
 	end
 
-	table.insert(LoadedObjects.Entities,o)
-	o.id = #LoadedObjects.Entities
+	o:id()
 
 	setmetatable(o, self)
 	self.__index = self

code/entities/fairy.lua

@@ -1,17 +1,17 @@
 Fairy = Entity:new()
+Fairy.type = "Fairy"
+Fairy.display = Animation:new(animation.fairy.flying)
 
 function Fairy:new(x,y)
 	local o = Entity:new(x,y)
 
-	o.type = "fairy"
-
 	-- behaviour
 	o.pos = {x = x, y = y}
 	o.speed = 1.4
 	o.range = 20
 	o.vision_range = 120
 	o.target = {x = x, y = y}
-	o.hover_distance = 60
+	o.hover_distance = 40
 
 	-- animations
 	o.body = Animation:new(animation.fairy.flying)
@@ -20,14 +20,13 @@ function Fairy:new(x,y)
 
 	-- light
 	o.light_radius = 80
-	o.light = Light:new(o.pos.x,o.pos.y,o.light_radius,nil,HEX2RGB("#fed100"))
+	o.light = Light:new(o.pos.x,o.pos.y,o.light_radius,nil,hex2rgb("#fed100"))
 
 	-- timer
 	o.particle_timer = 0
 	o.particle_time = 5
 
-	table.insert(LoadedObjects.Entities,o)
-	o.id = #LoadedObjects.Entities
+	o:id()
 
 	setmetatable(o, self)
 	self.__index = self
@@ -35,16 +34,15 @@ function Fairy:new(x,y)
 end
 
 function Fairy:doLogic()
+	if self:checkVisionLine(main_player,self.vision_range) then
 
-	if self:checkVisionLine(main_Player,self.vision_range) then
-
-		self.target.x = main_Player.pos.x + main_Player.target_offset.x
-		self.target.y = main_Player.pos.y + main_Player.target_offset.y
+		self.target.x = main_player.pos.x + main_player.target_offset.x
+		self.target.y = main_player.pos.y + main_player.target_offset.y
 
 		local below = 1
 		while not isThereObjectAt(
-			self.target.x,
-			self.target.y + below * game.scale,
+			self.pos.x,
+			self.pos.y + below * game.scale,
 			LoadedObjects.Collisions
 		) do
 			below = below + 1
@@ -52,8 +50,8 @@ function Fairy:doLogic()
 		end
 		local top = 1
 		while not isThereObjectAt(
-			self.target.x,
-			self.target.y - top * game.scale,
+			self.pos.x,
+			self.pos.y - top * game.scale,
 			LoadedObjects.Collisions
 		) do
 			top = top + 1
@@ -64,52 +62,66 @@ function Fairy:doLogic()
 
 	local distance_x = self.target.x - self.pos.x
 	local distance_y = self.target.y - self.pos.y
-	local angle = GetAngleFromVector(distance_x,distance_y)
+	local angle = getAngleFromVector(vector(distance_x,distance_y))
 	local distance = math.sqrt(distance_x ^ 2 + distance_y ^ 2)
 
 	if distance < self.range then
-		self.vel.x = self.vel.x * 0.9
-		self.vel.y = self.vel.y * 0.9
+		local random_x = math.random(-1, 1)
+		local random_y = math.random(-1, 1)
+		self.vel.x = self.vel.x * 0.9 + random_x/10
+		self.vel.y = self.vel.y * 0.9 + random_y/10
 	else
-		self.vel.x = math.cos(angle)*self.speed
-		self.vel.y = math.sin(angle)*self.speed
-	end
-	self.particle_timer = self.particle_timer + 1
-	if self.particle_timer >= self.particle_time then
-		self.particle_timer = 0
-
-		local particle_data = {
-			animation = animation.particle.simple,
-			sprite_tint = HEX2RGB("#fed100"),
-			direction = angle-math.rad(180+math.random(60)-30),
-			speed = 0.8*(distance/50),
-			speed_increase = -0.01,
-		}
-		Particle:new(self.pos.x,self.pos.y,particle_data)
+		local random_x = math.random(-6, 6)
+		local random_y = math.random(-6, 6)
+		self.vel.x = math.cos(angle)*self.speed + random_x/10
+		self.vel.y = math.sin(angle)*self.speed + random_y/10
 	end
 end
 
 function Fairy:handleAnimation()
 	self.body:animate()
-	--if self:isCollidingWith(main_Player) then self.sprite_tint = {1,0,0} else self.sprite_tint = {1,1,1} end
+	--if self:isCollidingWith(main_player) then self.sprite_tint = {1,0,0} else self.sprite_tint = {1,1,1} end
 	self:draw(self.body)
+
+	self.particle_timer = self.particle_timer + 1
+	if self.particle_timer >= self.particle_time then
+		local vector = vector(self.vel.x,self.vel.y)
+		local angle = getAngleFromVector(vector)
+		self.particle_timer = 0
+		local particle_data = {
+			animation = animation.particle.simple,
+			animation_speed = 1,
+			sprite_tint = hex2rgb("#fed100"),
+			sprite_alpha_fade = true,
+			direction = angle-math.rad(180+math.random(60)-30),
+			speed = 1,
+			speed_increase = -0.01,
+			time = 0.75
+		}
+		Particle:new(self.pos.x,self.pos.y,particle_data)
+	end
 end
 
 function Fairy:doPhysics()
-	local random_x = math.random(-4, 4)/10
-	local random_y = math.random(-4, 4)/10
-
-	self.vel.x = self.vel.x + random_x
-	self.vel.y = self.vel.y + random_y
-
-	self:moveWithCollision()
+	-- horizontal collision
+	self:moveX(
+		self.vel.x,
+		function()
 			self.vel.x = 0
+		end
+	)
+	-- vertical collision
+	self:moveY(
+		self.vel.y,
+		function()
 			self.vel.y = 0
-
+		end
+	)
+	-- final position
 	self:adjustLight()
 end
 
 function Fairy:debug()
 	Entity.debug(self)
-	self:checkVisionLineDebug(main_Player,self.vision_range)
+	self:checkVisionLineDebug(main_player,self.vision_range)
 end

code/entities/hook_anchor.lua

@@ -1,20 +1,19 @@
 HookAnchor = Entity:new()
+HookAnchor.type = "HookAnchor"
+HookAnchor.display = Animation:new(animation.fairy.flying)
 
-function HookAnchor:new(x,y,hookDistance)
+function HookAnchor:new(x,y,hook_distance)
 	local o = Entity:new(x,y)
 
-	o.type = "hook_anchor"
 
 	o.pos = {x = x, y = y}
-	o.hookDistance = hookDistance or 100
+	o.hook_distance = hook_distance or 100
 	-- animations
 	o.body = Animation:new(animation.fairy.flying)
 	o:centerOffset(o.body)
 	o:createBox(o.body)
 
-
-	table.insert(LoadedObjects.Entities,o)
-	o.id = #LoadedObjects.Entities
+	o:id()
 
 	setmetatable(o, self)
 	self.__index = self
@@ -33,14 +32,10 @@ function HookAnchor:drawBackground()
 		"fill",
 		-Camera.pos.x + self.pos.x,
 		-Camera.pos.y + self.pos.y,
-		self.hookDistance
+		self.hook_distance
 	)
 end
 
-function HookAnchor:doPhysics()
-end
-
-
 function Fairy:debug()
 	Entity.debug(self)
 end

code/entities/kupo.lua

@@ -1,10 +1,10 @@
 Kupo = Entity:new()
+Kupo.type = "Kupo"
+Kupo.display = Animation:new(animation.kupo.body)
 
 function Kupo:new(x,y)
 	local o = Entity:new(x,y)
 
-	o.type = "kupo"
-
 	o.pos = {x = x, y = y}
 	o.speed = 20
 	o.range = 200
@@ -30,8 +30,7 @@ function Kupo:new(x,y)
 	o.light_radius = o.range/2
 	o.light = Light:new(o.pos.x,o.pos.y,o.light_radius)
 
-	table.insert(LoadedObjects.Entities,o)
-	o.id = #LoadedObjects.Entities
+	o:id()
 
 	setmetatable(o, self)
 	self.__index = self
@@ -41,12 +40,13 @@ end
 function Kupo:doLogic()
 	self:adjustLight(self.target_offset.x,self.target_offset.y)
 
-	self.target.x = main_Player.pos.x - main_Player.target_offset.x
-	self.target.y = main_Player.pos.y - main_Player.target_offset.y
+	self.target.x = main_player.pos.x - main_player.target_offset.x
+	self.target.y = main_player.pos.y - main_player.target_offset.y
 	local distance_x = self.target.x - self.pos.x
 	local distance_y = self.target.y - self.pos.y
+
 	local distance = math.sqrt(distance_x ^ 2 + distance_y ^ 2)
-	local angle = GetAngleFromVector(distance_x,distance_y)
+	local angle = getAngleFromVector(vector(distance_x,distance_y))
 	self.draw_bow = false
 	if distance <= self.range then
 		if self.hostile == true then
@@ -143,7 +143,7 @@ function Kupo:handleAnimation()
 	if self.vel.x ~= 0 then self.sprite_flip.x = math.sign(self.vel.x) end
 
 	self.body:animate()
-	self:Draw(self.body)
+	self:draw(self.body)
 
 	if self.draw_bow == true then
 		self.bow:drawFrame(
@@ -154,7 +154,3 @@ function Kupo:handleAnimation()
 		)
 	end
 end
-
-function Kupo:doPhysics()
-	self:moveWithCollision()
-end

code/entities/particle.lua

@@ -1,6 +1,9 @@
-Particle = Entity:new()
 LoadedObjects.Particles = {}
 
+Particle = Entity:new()
+Particle.type = "Particle"
+Particle.display = Animation:new(animation.particle.simple)
+
 function Particle:new(x,y,particle_data)
 	local o = Entity:new(x,y)
 
@@ -13,12 +16,19 @@ function Particle:new(x,y,particle_data)
 	o.sprite_scale = particle_data.sprite_scale or o.sprite_scale
 	o.sprite_tint = particle_data.sprite_tint or o.sprite_tint
 	o.sprite_alpha = particle_data.sprite_alpha or o.sprite_alpha
+	o.sprite_alpha_fade = particle_data.sprite_alpha_fade or false
 	o.sprite_alpha_base = o.sprite_alpha
-
 	o.sprite_flip = particle_data.sprite_flip or o.sprite_flip
-	o.animation_active = particle_data.animation_active or false
 
-	o.time = 0.5
+	o.time = particle_data.time or nil
+	if o.time ~= nil then
+		if particle_data.time_unit ~= nil
+		and particle_data.time_unit == "frames" then
+			o.time = o.time
+		else
+			o.time = o.time * game.framerate
+		end
+	end
 	o.timer = 0
 
 	o.vel = {
@@ -37,14 +47,12 @@ function Particle:new(x,y,particle_data)
 
 	-- animations
 	if particle_data.animation ~= nil then
-		o.body = Animation:new(particle_data.animation)
+		o.body = Animation:new(particle_data.animation,particle_data.animation_speed)
 		o:centerOffset(o.body)
 		o:createBox(o.body)
-		if not o.animation_active then
-			o.body.speed = 0
-		end
 	end
 
+	-- particle id handled differently from other entities
 	table.insert(LoadedObjects.Particles,o)
 	o.id = #LoadedObjects.Particles
 
@@ -69,28 +77,42 @@ function Particle:kill()
 end
 
 function Particle:handleAnimation()
-	self.timer = self.timer + current_dt
+	self.timer = self.timer + 1
+
+	if self.sprite_alpha_fade ~= false then
 		self.sprite_alpha = self.sprite_alpha_base*(self.time-self.timer)/self.time
-	if self.light ~= nil then
-		self:adjustLight()
-		self.light.range = self.light_range * self.sprite_alpha/2
 	end
-	if self.sprite_alpha < 0 then self:kill() end
+
 	if self.body ~= nil then
 		self.body:animate()
 		self:draw(self.body)
 	end
 end
 
-function Particle:doPhysics()
+function Particle:doLogic()
 	-- adjust speed
 	if self.speed_increase ~= 0 then
 		self.speed = self.speed + self.speed_increase
 		self.vel.x = self.speed * math.cos(self.direction)
 		self.vel.y = self.speed * math.sin(self.direction)
 	end
-	-- move
-	self:moveWithCollision()
+
+	if self.time ~= nil then
+		if self.timer >= self.time then self:kill() end
+	end
+end
+
+function Particle:doPhysics()
+	-- horizontal collision
+	self:moveX(
+			self.vel.x
+	)
+	-- vertical collision
+	self:moveY(
+		self.vel.y
+	)
+	-- final position
+	self:adjustLight()
 end
 
 function Particle:debug()

code/entities/player.lua

@@ -1,68 +1,67 @@
 Player = Entity:new()
+Player.type = "Player"
+Player.display = Animation:new(animation.nancy.idle)
 
 function Player:new(x,y)
 	local o = Entity:new(x,y)
 
-	o.type = "player"
 	-- physics
-	o.moveSpeed = 1.3 -- gameworld pixels
-	o.zeroSpeed = 0.01 -- gameworld pixels
+	o.zero_speed = 0.01 -- gameworld pixels
 
 	o.move_x = 0 -- gameworld pixels
-	o.noDriftFrames = 0 -- frames
+	o.move_speed = 1.3 -- gameworld pixels
 
-	o.airFriction = 0.01 -- gameworld pixels
-	o.groundFriction = 0.3 -- gameworld pixels
+	o.nodrift_frames = 0 -- frames
 
-	o.jumpImpulse = 3.5 -- gameworld pixels
+	o.air_friction = 0.01 -- gameworld pixels
+	o.ground_friction = 0.3 -- gameworld pixels
+	o.wall_friction = 0.3 -- gameworld pixels
 
-	o.coyoteValue = 5 -- frames
-	o.coyoteAmount = 5 -- int
+	o.jump_impulse = 3.5 -- gameworld pixels
+
+	o.coyote_value = 5 -- frames
+	o.coyote_amount = 5 -- int
 
-	o.dashCooldownTime = 0.1 -- seconds
-	o.dashCooldownTimer = 0 -- seconds
 
 	-- dash values
-	o.dashTimer = 0 -- seconds
-	o.dashTime = 0.15 -- seconds
-	o.dashDistance = 40 -- gameworld pixels
-	o.dashSpeed = o.dashDistance / (o.dashTime*60) -- pixels
-	o.dashCount = 1 -- int
-	o.dashAmount = 10 -- int
+	o.dash_timer = 0 -- seconds
+	o.dash_time = 0.15 -- seconds
+	o.dash_distance = 40 -- gameworld pixels
+	o.dash_speed = o.dash_distance / (o.dash_time*60) -- pixels
+	o.dash_count = 1 -- int
+	o.dash_amount = 10 -- int
+	o.dash_cooldown_time = 0.1 -- seconds
+	o.dash_cooldown_timer = 0 -- seconds
 
 	-- hook values
-	o.hookSwingSpeed = math.rad(0.05)
-	o.hookAnchor = {
-		x = nil,
-		y = nil
-	}
+	o.hook_swing_speed = math.rad(0.05)
+	o.hook_anchor = nil
 
 	-- walljump values
-	o.walljumpNoDriftAmount = 12
-	o.walljumpImpulse = { x = 2.5, y = 3.5 }
-	o.walljumpFriction = 0.3 -- gameworld pixels
+	o.walljump_nodrift_amount = 12
+	o.walljump_impulse = { x = 2.5, y = 3.5 }
 
 	-- light values
 	o.light_radius = 40 -- screen pixels
 
 	-- status
-	o.canJump = true
-	o.canFall = true
-	o.canFriction = true
-	o.canHook = true
-	o.canWalljump = true
+	o.can_jump = true
+	o.can_fall = true
+	o.can_friction = true
+	o.can_hook = true
+	o.can_walljump = true
 
-	o.isDashing = false
-	o.isHooked = false
-	o.isSliding = false
-	o.isJumping = false
-	o.isOnGround = false
-	o.isOnLadder = false
+	o.is_dashing = false
+	o.is_hooked = false
+	o.is_sliding = false
+	o.is_jumping = false
+	o.is_on_ground = false
+	o.is_on_ladder = false
 
-	o.maskType = animation.moth_mask
-	o.wallHit = 0
+	o.mask_type = animation.moth_mask
+	o.wall_hit = 0
 
-	o.anchorRespawn = {
+	o.respawn_anchor = {
 		x = o.pos.x,
 		y = o.pos.y
 	}
@@ -71,14 +70,14 @@ function Player:new(x,y)
 	o.target_offset = {x = 0, y = 0}
 	o.body = Animation:new(animation.nancy.idle)
 	o.mask = Animation:new(animation.moth_mask.idle)
+
 	o:centerOffset(o.body)
-	o:createBox(o.body,0,3,-1,-3)
+	o:createBox(o.body,0,4,-1,-5)
 
 	-- lights
 	o.light = Light:new(o.pos.x,o.pos.y,o.light_radius)
 
-	table.insert(LoadedObjects.Entities,o)
-	o.id = #LoadedObjects.Entities
+	o:id()
 
 	setmetatable(o, self)
 	self.__index = self
@@ -86,67 +85,69 @@ function Player:new(x,y)
 end
 
 function Player:doLogic()
-	self:adjustLight(self.target_offset.x,self.target_offset.y)
 
-	-- reset coyoteValue
-	if self.isOnGround then
-		self.coyoteValue = self.coyoteAmount
-	elseif self.coyoteValue > 0 then
-		self.coyoteValue = self.coyoteValue - 1
+	-- reset coyote_value
+	if self.is_on_ground then
+		self.coyote_value = self.coyote_amount
+	elseif self.coyote_value > 0 then
+		self.coyote_value = self.coyote_value - 1
 	end
 
 	-- not dashing, normal movment
-	if self.dashTimer <= 0 then
+	if self.dash_timer <= 0 then
 		-- horizontal movement
-		if not self.isHooked then
-			if self.noDriftFrames > 0 then
+		if not self.is_hooked then
+			if self.nodrift_frames > 0 then
 				self.move_x = 0
-			elseif Keybind:CheckDown(Keybind.move.left) then
+			elseif Keybind:checkDown(Keybind.move.left) then
 				self.move_x = -1
-				self.vel.x = math.min(self.vel.x, -self.moveSpeed)
-			elseif Keybind:CheckDown(Keybind.move.right) then
+				self.vel.x = math.min(self.vel.x, -self.move_speed)
+			elseif Keybind:checkDown(Keybind.move.right) then
 				self.move_x = 1
-				self.vel.x = math.max(self.vel.x, self.moveSpeed)
+				self.vel.x = math.max(self.vel.x, self.move_speed)
 			end
 		end
 
 		-- jump if on ground (coyotevalue) or if 0
-		if self.canJump and Keybind:CheckPressed(Keybind.move.jump) then
-			if self.canWalljump and self.wallHit ~= 0 then
-				self.isSliding = false
-				self.vel.y = -self.walljumpImpulse.y
-				self.vel.x = -self.walljumpImpulse.x * self.wallHit
+		if self.can_jump and Keybind:checkPressed(Keybind.move.jump) then
+			if self.can_walljump and self.wall_hit ~= 0 then
+				self.is_sliding = false
+				self.vel.y = -self.walljump_impulse.y
+				self.vel.x = -self.walljump_impulse.x * self.wall_hit
 				self.move_x = 0
 				self.sprite_flip.x = -self.sprite_flip.x
-				self.noDriftFrames = self.walljumpNoDriftAmount
-			elseif self.coyoteValue > 0 then
-				self.vel.y = -self.jumpImpulse
-				self.coyoteValue = 0
+				self.nodrift_frames = self.walljump_nodrift_amount
+			elseif self.coyote_value > 0 then
+				self.vel.y = -self.jump_impulse
+				self.coyote_value = 0
 			end
 		end
 	end
 
 	-- dash timer
-	self.dashCooldownTimer = math.max(0,self.dashCooldownTimer - current_dt)
+	self.dash_cooldown_timer = math.max(0,self.dash_cooldown_timer - current_dt)
 
 	-- try to dash
-	if Keybind:CheckDown(Keybind.move.dash) then
-		if self.dashCooldownTimer == 0
-		and not self.isDashing
-		and self.dashCount > 0 then
+	if Keybind:checkDown(Keybind.move.dash) then
+		if self.dash_cooldown_timer == 0
+		and not self.is_dashing
+		and self.dash_count > 0 then
+
 			self:unhook()
+			self.nodrift_frames = 0
 
 			-- state player
-			self.isDashing = true
-			self.dashCount = self.dashCount - 1
+			self.is_dashing = true
+			self.is_sliding = false
+			self.dash_count = self.dash_count - 1
 
 			-- get dash direction
 			local vertical = 0
-			if Keybind:CheckDown(Keybind.move.down) then vertical = vertical + 1 end
-			if Keybind:CheckDown(Keybind.move.up) then vertical = vertical - 1 end
+			if Keybind:checkDown(Keybind.move.down) then vertical = vertical + 1 end
+			if Keybind:checkDown(Keybind.move.up) then vertical = vertical - 1 end
 			local horizontal = 0
-			if Keybind:CheckDown(Keybind.move.right) then horizontal = horizontal + 1 end
-			if Keybind:CheckDown(Keybind.move.left) then horizontal = horizontal - 1 end
+			if Keybind:checkDown(Keybind.move.right) then horizontal = horizontal + 1 end
+			if Keybind:checkDown(Keybind.move.left) then horizontal = horizontal - 1 end
 
 			-- if no direction, then dash forward
 			if horizontal == 0 and vertical == 0 then
@@ -154,23 +155,23 @@ function Player:doLogic()
 			end
 
 			-- set dash values
-			self.dashDirection = GetAngleFromVector(horizontal, vertical)
-			self.dashTimer = math.floor(self.dashTime * game.framerate)
+			self.dashDirection = getAngleFromVector(vector(horizontal, vertical))
+			self.dash_timer = math.floor(self.dash_time * game.framerate)
 		end
 	else
 		-- not dashing!
-		self.isDashing = false
+		self.is_dashing = false
 	end
 
-	if self.canHook and Keybind:CheckPressed(Keybind.move.hook) then
-		if self.isHooked then
+	if self.can_hook and Keybind:checkPressed(Keybind.move.hook) then
+		if self.is_hooked then
 			self:unhook()
 		else
-			local anchor = self:checkNearest("hook_anchor",self.hookDistance)
+			local anchor = self:checkNearest("HookAnchor","hook_specific")
 			if anchor then
-				self.isHooked = true
-				self.hookDistance = anchor.hookDistance
-				self.hookAnchor = {
+				self.is_hooked = true
+				self.hook_distance = anchor.hook_distance
+				self.hook_anchor = {
 					x = anchor.pos.x,
 					y = anchor.pos.y
 				}
@@ -180,73 +181,78 @@ function Player:doLogic()
 end
 
 function Player:doPhysics()
-	if self.dashTimer <= 0 then
-		if self.isOnGround then
-			self.vel.x = self.vel.x * (1-self.groundFriction)
+	if self.dash_timer <= 0 then
+		if self.is_on_ground then
+			self.vel.x = self.vel.x * (1-self.ground_friction)
 		else
-			self.vel.x = self.vel.x * (1-self.airFriction)
+			self.vel.x = self.vel.x * (1-self.air_friction)
 		end
 
-		self.isSliding = false
-		if self.wallHit == 0 then
-			self.vel.y = self.vel.y * (1-self.airFriction)
-		elseif self.noDriftFrames ~= self.walljumpNoDriftAmount then
-			self.isSliding = true
-			self.vel.y = self.vel.y * (1-self.walljumpFriction)
+		self.is_sliding = false
+		if self.wall_hit == 0 then
+			self.vel.y = self.vel.y * (1-self.air_friction)
+		elseif self.nodrift_frames ~= self.walljump_nodrift_amount then
+			self.is_sliding = true
+			self.vel.y = self.vel.y * (1-self.wall_friction)
 		end
 
-		if math.abs(self.vel.x) < self.zeroSpeed then self.vel.x = 0 end
+		if math.abs(self.vel.x) < self.zero_speed then self.vel.x = 0 end
 	end
 
 	-- reset state
-	self.canFall = true
-	self.isOnGround = false
+	self.can_fall = true
+	self.is_on_ground = false
 
 	-- adjust timers
-	self.dashTimer = self.dashTimer - 1
-	self.noDriftFrames = self.noDriftFrames - 1
+	self.dash_timer = self.dash_timer - 1
+	self.nodrift_frames = self.nodrift_frames - 1
 
 	-- DASH STATE
-	if self.dashTimer > 0 then
-		self.canFall = false
+	if self.dash_timer > 0 then
+		self.can_fall = false
 		-- dash particle
 		local particle_data = {
 			animation = self.body,
-			sprite_tint = HEX2RGB("#fed100"),
+			animation_speed = 0,
+			sprite_tint = hex2rgb("#fed100"),
 			sprite_alpha = 0.5,
+			time = 0.2,
 			sprite_flip = {
 				x = self.sprite_flip.x,
 				y = self.sprite_flip.y
 			}
 		}
 		Particle:new(self.pos.x,self.pos.y,particle_data)
-		self.dashCooldownTimer = self.dashCooldownTime
+		self.dash_cooldown_timer = self.dash_cooldown_time
 		-- dash movement
-		self.vel.x = self.dashSpeed * math.cos(self.dashDirection)
-		self.vel.y = self.dashSpeed * math.sin(self.dashDirection)
+		self.vel.x = self.dash_speed * math.cos(self.dashDirection)
+		self.vel.y = self.dash_speed * math.sin(self.dashDirection)
 	end
 
 	-- hook state
-	if self.isHooked then
+	if self.is_hooked then
 		self.move_x = 0
-		local hook = Vector(self.pos.x, self.pos.y, self.hookAnchor.x, self.hookAnchor.y)
-		local dist =  math.min(GetVectorValue(hook), self.hookDistance)
+		local hook = vector(self.hook_anchor.x - self.pos.x, self.hook_anchor.y -  self.pos.y)
+		local dist =  math.min(getVectorValue(hook), self.hook_distance)
 
-			local hook_angle = GetAngleFromVector(hook[1],hook[2])-math.rad(180)
+			local hook_angle = getAngleFromVector(hook)-math.rad(180)
 
-			if Keybind:CheckDown(Keybind.move.right) then
-				hook_angle = hook_angle - self.hookSwingSpeed
+			if Keybind:checkDown(Keybind.move.right) then
+				hook_angle = hook_angle - self.hook_swing_speed
 			end
 
-			if Keybind:CheckDown(Keybind.move.left) then
-				hook_angle = hook_angle + self.hookSwingSpeed
+			if Keybind:checkDown(Keybind.move.left) then
+				hook_angle = hook_angle + self.hook_swing_speed
 
 			end
 
 			local particle_data = {
 				animation = self.body,
-				sprite_tint = HEX2RGB("#fed100"),
+				animation_speed = 0,
+				sprite_tint = hex2rgb("#fed100"),
 				sprite_alpha = 0.5,
+				time = 4,
+				time_unit = "frames",
 				sprite_flip = {
 					x = self.sprite_flip.x,
 					y = self.sprite_flip.y
@@ -254,75 +260,86 @@ function Player:doPhysics()
 			}
 			Particle:new(self.pos.x,self.pos.y,particle_data)
 
-			local pos_x = self.hookAnchor.x + dist * math.cos(hook_angle)
-			local pos_y = self.hookAnchor.y + dist * math.sin(hook_angle)
+			local pos_x = self.hook_anchor.x + dist * math.cos(hook_angle)
+			local pos_y = self.hook_anchor.y + dist * math.sin(hook_angle)
 			self.vel.x = self.vel.x + pos_x - self.pos.x
 			self.vel.y = self.vel.y + pos_y - self.pos.y
-			self.pos.x = pos_x
-			self.pos.y = pos_y
+
+			self:moveX(
+				pos_x - self.pos.x
+			)
+			self:moveY(
+				pos_y - self.pos.y
+			)
 	end
 
 
-	if self.canFall then
+	if self.can_fall then
 		-- not in dash
-		self.dashTimer = 0
+		self.dash_timer = 0
 		self.vel.y = self.vel.y + gravity
 	end
 
 	-- horizontal collision
-	if not self:isCollidingAt(self.pos.x + self.vel.x, self.pos.y, LoadedObjects.Collisions) then
-		self.pos.x = self.pos.x + self.vel.x
-		self.wallHit = 0
-	else
-		self.wallHit = math.sign(self.vel.x)
+	self.wall_hit = 0
+	self:moveX(
+		self.vel.x,
+		function()
+			self.wall_hit = math.sign(self.vel.x)
 			self.vel.x = 0
 		end
+	)
 
 	-- vertical collision
-	if not self:isCollidingAt(self.pos.x, self.pos.y + self.vel.y, LoadedObjects.Collisions) then
-		self.pos.y = self.pos.y + self.vel.y
-	else
+	self:moveY(
+		self.vel.y,
+		function()
 			if self.vel.y > 0 then
-			self.isOnGround = true
-			self.dashCount = self.dashAmount
+				self.is_on_ground = true
+				self.dash_count = self.dash_amount
 			end
 			self.vel.y = 0
 		end
+	)
 
 	-- if u collision w hazard, respawn
 	if self:isCollidingAt(self.pos.x, self.pos.y, LoadedObjects.Hazards) then
 		self:respawn()
 	end
+
+	self:adjustLight(self.target_offset.x,self.target_offset.y)
 end
 
 function Player:respawn()
-	self.pos.x = self.anchorRespawn.x
-	self.pos.y = self.anchorRespawn.y
+	self.pos.x = self.respawn_anchor.x
+	self.pos.y = self.respawn_anchor.y
 end
 
 function Player:handleAnimation()
 	-- flip sprite to look in the direction is moving
-	if self.isHooked then
+	if self.is_hooked then
 		if self.vel.x ~= 0 then
 			self.sprite_flip.x = math.sign(self.vel.x)
 		end
 	elseif self.move_x ~= 0 then
 		self.sprite_flip.x = math.sign(self.move_x)
 	end
-
 	-- animation priority
-	if self.vel.y > 1.25 or self.isSliding then
+	if self.is_sliding then
+		self.body = self.body:change(animation.nancy.slide)
+		self.mask = self.mask:change(self.mask_type.slide)
+	elseif self.vel.y > 1.25 then
 		self.body = self.body:change(animation.nancy.fall)
-		self.mask = self.mask:change(self.maskType.fall)
+		self.mask = self.mask:change(self.mask_type.fall)
 	elseif self.vel.y < 0 then
 		self.body = self.body:change(animation.nancy.jump)
-		self.mask = self.mask:change(self.maskType.jump)
-	elseif self.vel.x + self.move_x ~= 0 then
+		self.mask = self.mask:change(self.mask_type.jump)
+	elseif self.vel.x + self.move_x ~= 0 and not self.is_hooked then
 		self.body = self.body:change(animation.nancy.run)
-		self.mask = self.mask:change(self.maskType.run)
-	else
+		self.mask = self.mask:change(self.mask_type.run)
+	elseif not self.is_hooked then
 		self.body = self.body:change(animation.nancy.idle)
-		self.mask = self.mask:change(self.maskType.idle)
+		self.mask = self.mask:change(self.mask_type.idle)
 	end
 
 	-- special case: idle animation gets slower by time
@@ -332,30 +349,31 @@ function Player:handleAnimation()
 		end
 	end
 
-	if self.isHooked then
+	if self.is_hooked then
 		love.graphics.line(
 			-Camera.pos.x + self.pos.x,
 			-Camera.pos.y + self.pos.y,
-			-Camera.pos.x + self.hookAnchor.x,
-			-Camera.pos.y + self.hookAnchor.y
+			-Camera.pos.x + self.hook_anchor.x,
+			-Camera.pos.y + self.hook_anchor.y
 		)
 	end
 
 	self.body:animate()
 	self:draw(self.body)
 
-	if self.dashCount > 0 then
+	if self.dash_count > 0 then
 		self:draw(self.mask)
 	end
 	self.move_x = 0
 end
 
 function Player:unhook()
-	self.isHooked = false
-	self.hookAnchor = nil
+	self.is_hooked = false
+	self.hook_anchor = nil
+	self.hook_distance = nil
 end
 
 function Player:debug()
 	Entity.debug(self)
-	love.graphics.print("wallHit: "..self.wallHit)
+	love.graphics.print("wall_hit: "..self.wall_hit)
 end

code/entity.lua

@@ -5,6 +5,7 @@ function Entity:new(x,y)
 	local o = {}
 
 	o.pos = {x = x, y = y}
+	o.move_remainder = {x = 0, y = 0}
 	o.vel = {x = 0, y = 0}
 
 	o.direction = 0
@@ -30,22 +31,37 @@ function Entity:new(x,y)
 	return o
 end
 
+function Entity:id()
+	table.insert(LoadedObjects.Entities,self)
+	self.id = #LoadedObjects.Entities
+end
+
 function Entity:checkNearest(type,maxdistance)
 	local return_entity = nil
 	local shortest = -1
+	local flag_variable_distance = false
+
+	if maxdistance == "hook_specific" then
+		flag_variable_distance = true
+	end
+
 	for _, entity in pairs(LoadedObjects.Entities) do
 		if not type or entity.type == type then
 			local distance_x = entity.pos.x - self.pos.x
 			local distance_y = entity.pos.y - self.pos.y
 			local distance = math.sqrt(distance_x ^ 2 + distance_y ^ 2)
 
+			if flag_variable_distance then
+				maxdistance = entity.hook_distance
+			end
+
 			if not maxdistance or distance < maxdistance then
 				if shortest == -1 or distance < shortest then
 					shortest = distance
 					return_entity = entity
 				end
+				print(shortest,maxdistance,distance)
 			end
-
 		end
 	end
 	return return_entity
@@ -54,26 +70,54 @@ end
 function Entity:doLogic()
 end
 
-function Entity:move()
-	self.pos.x = self.pos.x + self.vel.x
-	self.pos.y = self.pos.y + self.vel.y
+function Entity:moveX(amount, func)
+	self.move_remainder.x = self.move_remainder.x + amount
+	local move = math.round(self.move_remainder.x)
+  if move ~= 0 then
+    self.move_remainder.x = self.move_remainder.x - move
+    local sign = math.sign(move)
+ 		while math.round(move) ~= 0 do
+    	if not self:isCollidingAt(
+				self.pos.x + sign,
+				self.pos.y,
+				LoadedObjects.Collisions
+			) then
+        self.pos.x = self.pos.x + sign
+				move = move - sign
+				if tostring(move) == "nan" then error() end
+      else
+        if func then
+          func()
+				end
+				break
+			end
+		end
+	end
 end
 
-function Entity:moveWithCollision()
-	local r = false
-	if not self:isCollidingAt(self.pos.x + self.vel.x, self.pos.y, LoadedObjects.Collisions) then
-		self.pos.x = self.pos.x + self.vel.x
+function Entity:moveY(amount, func)
+	self.move_remainder.y = self.move_remainder.y + amount
+	local move = math.round(self.move_remainder.y)
+  if move ~= 0 then
+    self.move_remainder.y = self.move_remainder.y - move
+    local sign = math.sign(move)
+ 		while math.round(move) ~= 0 do
+    	if not self:isCollidingAt(
+				self.pos.x,
+				self.pos.y + sign,
+				LoadedObjects.Collisions
+			) then
+        self.pos.y = self.pos.y + sign
+				move = move - sign
+				if tostring(move) == "nan" then error() end
       else
-		self.vel.x = 0
-		r = true
+        if func then
+          func()
+				end
+				break
+			end
 		end
-	if not self:isCollidingAt(self.pos.x, self.pos.y + self.vel.y, LoadedObjects.Collisions) then
-		self.pos.y = self.pos.y + self.vel.y
-	else
-		self.vel.y = 0
-		r = true
 	end
-	return r
 end
 
 function Entity:adjustLight(x,y)
@@ -90,12 +134,12 @@ function Entity:kill()
 		self.light:kill()
 	end
 	if self.id ~= nil then
+		table.remove(LoadedObjects.Entities,self.id)
 		for _, e in pairs(LoadedObjects.Entities) do
 			if e.id > self.id then
 				e.id = e.id - 1
 			end
 		end
-		table.remove(LoadedObjects.Entities,self.id)
 	end
 	self = nil
 end
@@ -106,8 +150,9 @@ function Entity:checkVisionLine(entity,range)
 
 	local distance_x = target_x - self.pos.x
 	local distance_y = target_y - self.pos.y
+	local distance = vector(distance_x,distance_y)
 
-	local angle = GetAngleFromVector(distance_x,distance_y)
+	local angle = getAngleFromVector(distance)
 	local distance = math.sqrt(distance_x ^ 2 + distance_y ^ 2)
 
 	local is_colliding = true
@@ -129,6 +174,7 @@ function Entity:checkVisionLine(entity,range)
 end
 
 function Entity:draw(animation)
+	if animation == nil then return end
 	local c1, c2, c3, a = love.graphics.getColor()
 	love.graphics.setColor(self.sprite_tint[1],self.sprite_tint[2],self.sprite_tint[3],self.sprite_alpha)
 	animation:draw(
@@ -142,6 +188,7 @@ function Entity:draw(animation)
 end
 
 function Entity:centerOffset(animation,x,y)
+	if animation == nil then return end
 	local x = x or 0
 	local y = y or 0
 	self.sprite_offset.x = animation.imgs[1]:getWidth()/2 + x
@@ -149,6 +196,7 @@ function Entity:centerOffset(animation,x,y)
 end
 
 function Entity:createBox(animation,top,left,bottom,right)
+	if animation == nil then return end
 	local left = left or 0
 	local right = right or 0
 	local top = top or 0
@@ -174,7 +222,7 @@ function Entity:getCollidingAt(x,y,object)
 		and y + self.box.from.y < collision.to.y
 		and y + self.box.to.y > collision.from.y
 		then
-			collision.isColliding = true
+			collision.is_colliding = true
 			return collision
 		end
 	end
@@ -210,8 +258,9 @@ function Entity:checkVisionLineDebug(entity,range)
 
 	local distance_x = target_x - self.pos.x
 	local distance_y = target_y - self.pos.y
+	local distance = vector(distance_x,distance_y)
 
-	local angle = GetAngleFromVector(distance_x,distance_y)
+	local angle = getAngleFromVector(distance)
 	local distance = math.sqrt(distance_x ^ 2 + distance_y ^ 2)
 
 	if distance < range then
@@ -260,6 +309,9 @@ function Entity:debug()
 	end
 end
 
+function Entity:doPhysics()
+end
+
 function Entity:handleAnimation()
 end
 

code/game.lua

@@ -1,7 +1,18 @@
+function restartGame()
+	for _, entity in ipairs(LoadedObjects.Entities) do
+		if entity.light ~= nil then entity.light:kill() end
+		entity = nil
+	end
+	LoadedObjects.Entities = {}
+	LoadedObjects.Particles = {}
+	main_player = Player:new(75,50)
+	activateSpawns()
+end
+
 function stepGame()
 	setCollisionFlags()
 	if menu_type == "no" then
-		for _, particle in pairs(LoadedParticles) do
+		for _, particle in pairs(LoadedObjects.Particles) do
 			particle:doLogic()
 		end
 		for _, enty in pairs(LoadedObjects.Entities) do
@@ -16,12 +27,12 @@ function stepGame()
 		enty:doPhysics()
 	end
 
-	AnimateTiles()
-	Camera:followPlayer(main_Player)
-	--Camera:positionCenterAt(main_Player.pos.x, main_Player.pos.y)
-	--camera:positionAt(main_Player.pos.x, main_Player.pos.y,game.width,game.height)
+	animateTiles()
+	Camera:followPlayer(main_player)
+	--Camera:positionCenterAt(main_player.pos.x, main_player.pos.y)
+	--camera:positionAt(main_player.pos.x, main_player.pos.y,game.width,game.height)
 
-	if Keybind:CheckPressed(Keybind.debug.debug) then
+	if Keybind:checkPressed(Keybind.debug.debug) then
 		if debug then
 			debug = false
 			debug_collision = true
@@ -32,23 +43,17 @@ function stepGame()
 		end
 	end
 
-	if Keybind:CheckPressed(Keybind.debug.reposition) then
-		if not editor_mode then
-			main_Player.pos.x, main_Player.pos.y = 16,-10
-		end
+	if Keybind:checkPressed(Keybind.debug.reposition) then
+		restartGame()
 	end
 
-	if Keybind:CheckPressed(Keybind.debug.reload) then
-			MenuClear()
+	if Keybind:checkPressed(Keybind.debug.reload) then
+			clearMenu()
 			menu_type = "dialog"
-			MenuInit("dialog",DialogSequence.Example)
+			initMenu("dialog",dialog_sequence.example)
 	end
 
-	if Keybind:CheckPressed(Keybind.debug.editor) then
-		editor_mode = true
-	end
-
-	if Keybind:CheckPressed(Keybind.debug.recording) then
+	if Keybind:checkPressed(Keybind.debug.recording) then
 		if DemoRecording then
 			Demo:endRecord()
 		else
@@ -56,7 +61,7 @@ function stepGame()
 		end
 	end
 
-	if Keybind:CheckPressed(Keybind.debug.playback) then
+	if Keybind:checkPressed(Keybind.debug.playback) then
 		if DemoPlayback then
 			Demo:endPlayback()
 		else
@@ -88,7 +93,7 @@ function drawGame()
 	endGameworldDraw()
 
 	-- hud
-	textScale = 1
+	text_size = 1
 
 	-- debug
 	if debug then debugUI() end

code/gameworld.lua

@@ -20,12 +20,11 @@ function drawGameworldBackground()
 	for i = 1, #LevelTiles do
 		for j = 1, #LevelTiles[i] do
 			if LevelTiles[i][j].id ~= 0 then
-
 				local depth = TileData[LevelTiles[i][j].id].depth
-				DrawTile(
+				drawTile(
 					LevelTiles[i][j],
-					tileProperties.scale * j * tileProperties.width	+ tileProperties.scale * (levelProperties.offset.x - tileProperties.width)	- Camera.pos.x,
-					tileProperties.scale * i * tileProperties.height + tileProperties.scale * (levelProperties.offset.y - tileProperties.height) - Camera.pos.y,
+					tile_properties.scale * j * tile_properties.width	+ tile_properties.scale * (level_properties.offset.x - tile_properties.width)	- Camera.pos.x,
+					tile_properties.scale * i * tile_properties.height + tile_properties.scale * (level_properties.offset.y - tile_properties.height) - Camera.pos.y,
 					"background"
 				)
 
@@ -61,10 +60,10 @@ function drawGameworldForeground()
 			if LevelTiles[i][j].id ~= 0 then
 
 				local depth = TileData[LevelTiles[i][j].id].depth
-				DrawTile(
+				drawTile(
 					LevelTiles[i][j],
-					tileProperties.scale * j * tileProperties.width	+ tileProperties.scale * (levelProperties.offset.x - tileProperties.width)	- Camera.pos.x,
-					tileProperties.scale * i * tileProperties.height + tileProperties.scale * (levelProperties.offset.y - tileProperties.height) - Camera.pos.y,
+					tile_properties.scale * j * tile_properties.width	+ tile_properties.scale * (level_properties.offset.x - tile_properties.width)	- Camera.pos.x,
+					tile_properties.scale * i * tile_properties.height + tile_properties.scale * (level_properties.offset.y - tile_properties.height) - Camera.pos.y,
 					"foreground"
 				)
 
@@ -102,12 +101,12 @@ function drawGameworldLights()
 		if light.range ~= 0 then
 			love.graphics.setColor(light.color[1],light.color[2],light.color[3],1)
 
-			Shader.RadiusGradient:send("pos_x",- Camera.pos.x + light.pos.x)
-			Shader.RadiusGradient:send("pos_y",- Camera.pos.y + light.pos.y)
-			Shader.RadiusGradient:send("range",light.range)
-			Shader.RadiusGradient:send("scale",game.scale)
+			shader.circle_gradient:send("pos_x",- Camera.pos.x + light.pos.x)
+			shader.circle_gradient:send("pos_y",- Camera.pos.y + light.pos.y)
+			shader.circle_gradient:send("range",light.range)
+			shader.circle_gradient:send("scale",game.scale)
 
-			love.graphics.setShader(Shader.RadiusGradient)
+			love.graphics.setShader(shader.circle_gradient)
 			love.graphics.circle(
 				"fill",
 				- Camera.pos.x + light.pos.x,

code/hex.lua

@@ -1,15 +1,15 @@
-function HEX2RGB(color)
-	local r1 = HEX2DEX(color:sub(2,2))
-	local r2 = HEX2DEX(color:sub(3,3))
-	local g1 = HEX2DEX(color:sub(4,4))
-	local g2 = HEX2DEX(color:sub(5,5))
-	local b1 = HEX2DEX(color:sub(6,6))
-	local b2 = HEX2DEX(color:sub(7,7))
+function hex2rgb(color)
+	local r1 = hex2dec(color:sub(2,2))
+	local r2 = hex2dec(color:sub(3,3))
+	local g1 = hex2dec(color:sub(4,4))
+	local g2 = hex2dec(color:sub(5,5))
+	local b1 = hex2dec(color:sub(6,6))
+	local b2 = hex2dec(color:sub(7,7))
 
 	return {(r1*16 + r2)/255, (g1*16 + g2)/255, (b1*16 + b2)/255}
 end
 
-function HEX2DEX(hex)
+function hex2dec(hex)
 	if		 hex == "0" then return 0
 	elseif hex == "1"	then return 1
 	elseif hex == "2"	then return 2

code/in_out.lua

@@ -1,53 +1,51 @@
-function ExportLevel(levelname, filename)
-	os.execute( "mkdir \"./export\"" )
-	filename = filename or "output.lua"
-	filename = "export/"..filename
-	exportFile = io.open(filename, "w+")
+function exportLevel(levelname, dirname)
+	dirname = "export/"..dirname
+
+	if love.filesystem.exists(dirname) then
+		-- TODO: prompt to overwrite
+		error("file already exists")
+	end
+	
+	local ok = love.filesystem.createDirectory(dirname)
+	if not ok then
+		logPrint("error creating directory")
+	end
+
 
-	if exportFile then
 	logPrint("Exporting level \"".. levelname .. "\"...")
-		exportFile:write("return {")
+	local exportTable = {}
+	exportTable.name = levelname
+	exportTable.tileset = "library"
+	exportTable.properties = LevelData.properties
+	--exportTable.tiles = LevelTiles
+	--logPrint("- objects")
+	--exportTable.objects = { spawns = {}, rooms = {} }
+	--logPrint(" - spawns")
+	--for i, v in ipairs(LoadedObjects.Spawns) do
+		--exportTable.objects.spawns = {v.archetype.name,{},v.args}
+	--end
 	
-		logPrint("- level name")
-		exportFile:write("\n	name = \"" .. levelname .. "\",")
+	--logPrint(" - rooms")
 		
-		logPrint("- tileset")
-		for k, v in pairs(tileset) do
-			if v == LevelData.tileset then
-				exportFile:write("\n	tileset = tileset." .. k .. ",")
-			end
-		end
+	--for i, room in ipairs(LoadedObjects.Rooms) do
+	---	table.insert(exportTable.objects.rooms,{room:asRect():getCoords()})
+	--end
+	exportTable.chunks = Chunk:getExportList()
+	logPrint("Writing to file...")
+	local ok, err = love.filesystem.write(dirname.."/level.lua", "return "..serialize_lua_value(exportTable))
 	
-		logPrint("- properties")
-		exportFile:write("\n	properties = {")
-		exportFile:write("\n		darkness = true")
-		exportFile:write("\n	},")
-
-		logPrint("- tiles")
-		exportFile:write("\n	tiles = {")
-		local rows = #LevelTiles
-		for i = 1, #LevelTiles do
-			exportFile:write("\n		{ ")
-			for j = 1, #LevelTiles[i] do
-				if j ~= 1 then
-					exportFile:write(", ")
+	if ok then
+		logPrint("Saving chunks...")
+		local chunkdir = dirname.."/chunks"
+		love.filesystem.createDirectory(chunkdir)
+		for chunk in pairs(Chunk.all) do
+			local ok, err = chunk:save(chunkdir)
+			if not ok then error(err) end
 		end
-				exportFile:write(tostring(LevelTiles[i][j].id))
-			end
-			exportFile:write("}")
-			if i ~= #LevelTiles then
-					exportFile:write(", ")
-			end
-			logPrint(" - Row "..i.."/"..rows.." "..math.floor(100*((i-1)*100/rows))/100 .."%")
-		end
-		exportFile:write("\n	},")
-
-		logPrint("- objects")
-		exportFile:write("\n	objects = {}")
-
 		logPrint("Exporting complete.")
-		exportFile:write("\n}")
-		exportFile:close()
+	else
+		-- TODO: clean up created files
+		logPrint("Exporting failed: "..err)
 	end
 end
 
@@ -63,22 +61,6 @@ function scandir(directory)
 		return t
 end
 
---[[
-return {
-	name = "level1",
-	tileset = tileset.library,
-	tiles = {
-		{13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13},
-		{ 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, 5,25,26, 6,25,26, 7, 0, 5,25,26, 7, 0, 0, 0, 0, 0, 0},
-		{ 0, 0, 0, 0, 0, 0, 5,37,38, 6,37,38, 7, 0, 5,37,38, 7, 0, 0, 0, 0, 0, 0},
-		{ 0, 0, 0, 0, 0, 0, 5,37,38, 6,37,38, 7, 0, 5,37,38, 7, 0, 0, 0, 0, 0, 0},
-		{ 0, 0, 0, 0, 0, 0, 5,49,50, 6,49,50, 7, 0, 5,49,50, 7, 0, 0, 0, 0, 0, 0},
-		{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
-	},
-	objects = {}
-}
-]]
 if logging then
 	-- Make log stuff
 	os.execute( "mkdir \"./logs\"" )

code/keybind.lua

@@ -17,7 +17,11 @@ Keybind.debug = {}
 Keybind.editor = {}
 Keybind.generic = {}
 
-function Keybind:CheckDown(action)
+function Keybind:isAvailable(action)
+	return not action.occupied
+end
+
+function Keybind:checkDown(action)
 	if DemoPlayback then
 		for _, demo_action in pairs(DemoAction[CurrentDemoFrame]) do
 			if demo_action == action.demo then
@@ -37,15 +41,18 @@ function Keybind:CheckDown(action)
 				if action.demo ~= nil then
 					Demo:recordAction(action.demo)
 				end
+				action.occupied = true
 				return true
 			end
 		end
+		action.occupied = false
 		return false
 	end
 end
 
-function Keybind:CheckPressed(action)
-	if Keybind:CheckDown(action) then
+-- relies on being called exactly once per frame to be accurate.
+function Keybind:checkPressed(action)
+	if Keybind:checkDown(action) then
 		if not action.pressed then
 			action.pressed = true
 			return true
@@ -56,7 +63,7 @@ function Keybind:CheckPressed(action)
 	return false
 end
 
-function Keybind:CheckCollision(cat, key)
+function Keybind:checkCollision(cat, key)
 	for _, action in pairs(cat) do
 		for _, keyname in pairs(action.keys) do
 			if key == keyname then return true end
@@ -65,19 +72,30 @@ function Keybind:CheckCollision(cat, key)
 	return false
 end
 
-function Keybind:AddKey(action, key)
+function Keybind:addKey(action, key)
 	table.insert(action.keys, key)
 end
 
-function Keybind:ChangeKey(action, position, key)
+function Keybind:changeKey(action, position, key)
 	action.keys[position] = key
 end
 
-function Keybind:RemoveKeys(action)
+function Keybind:removeKeys(action)
 	action.keys = {}
 end
 
-function Keybind:Default()
+-- this prolly should be used by Prompt:keypressed()
+function Keybind:hasKey(action, key)
+	for _, v in pairs(action.keys) do
+		if v == key then
+			return true
+		end
+	end
+
+	return false
+end
+
+function Keybind:default()
 	--Menu
 	Keybind.menu.pause.keys = {"escape"}
 	Keybind.menu.confirm.keys = {"z", "space", 1}
@@ -98,17 +116,34 @@ function Keybind:Default()
 	Keybind.debug.editor = { keys = {"f4"}}
 	Keybind.debug.recording = { keys = {"f5"}}
 	Keybind.debug.playback = { keys = {"f6"}}
+	Keybind.debug.respawn = { keys = {"f8"}}
 
 	-- Editor
-	Keybind.editor.palette = { keys = {"tab"}}
+	Keybind.editor.palette_mode = { keys = {"tab"}}
 	Keybind.editor.room_mode = { keys = {"r"}}
-
+	Keybind.editor.entity_mode = { keys = {"e"}}
+	Keybind.editor.properties_mode = { keys = {"p"}}
+	Keybind.editor.left = { keys = {"left", "a"}}
+	Keybind.editor.right = { keys = {"right", "d"}}
+	Keybind.editor.up = { keys = {"up", "w"}}
+	Keybind.editor.down = { keys = {"down", "s"}}
+	Keybind.editor.palette_change = { keys = {"f1"}}
+	Keybind.editor.save = { keys = {"f3"}}
+	Keybind.editor.tile_set = { keys = {1}}
+	Keybind.editor.tile_remove = { keys = {2}}
+	Keybind.editor.entity_select = { keys = {1}}
+	Keybind.editor.entity_move = { keys = {2}}
+	Keybind.editor.entity_modify_archetype = { keys = {"t"}}
+	Keybind.editor.entity_modify_data = { keys = {"g"}}
+	Keybind.editor.entity_remove = { keys = {"delete"}}
+	Keybind.editor.entity_new = { keys = {"n"}}
 	-- Generic
 	Keybind.generic.lclick = { keys = {1}}
 	Keybind.generic.rclick = { keys = {2}}
 	Keybind.generic.lshift = { keys = {"lshift"}}
+	Keybind.generic.alt = { keys = {"alt"}}
 	Keybind.generic.lctrl = { keys = {"lctrl"}}
 end
 
 -- Set default values at start
-Keybind:Default()
+Keybind:default()

code/level.lua

@@ -1,7 +1,25 @@
-function LevelLoadTiles()
+function loadLevelTiles()
 	math.randomseed(3)
-	LevelData = dofile("data/levels/"..currLevel)
+	level_current = "data/levels/level1"
+	LevelData = dofile(level_current.."/level.lua")
+	LoadedObjects.Collisions = {}
+	LoadedObjects.Platforms = {}
+	LoadedObjects.Ladders = {}
+	LoadedObjects.Hazards = {}
+	if type(LevelData.tileset) == "string" then
+		LevelData.tileset_name = LevelData.tileset
+	end
+	LevelData.tileset = tileset[LevelData.tileset_name]
 
+	getLevelTileData()
+	
+	for _, v in ipairs(LevelData.chunks) do
+		Chunk:new(v[1], v[2])
+	end
+	local global_chunk = next(Chunk.all)
+	global_chunk:load()
+	LoadedObjects.Collisions = global_chunk.loaded.collisions
+	LevelTiles = global_chunk.data.tiles
 	--[[
 		on level format:
 
@@ -12,19 +30,34 @@ function LevelLoadTiles()
 		overlay_depth = foreground/background overlay depth
 		type = collision type
 	]]
-	LevelGetTileData()
-	LevelTiles = LevelData.tiles
-	LevelUpdateDimensions()
-	LevelIndexTiles()
-	TileCreateObjects()
+	
+	
+	updateLevelDimensions()
+	--
+	--createTileObjects()
+	--createRoomObjects()
+	--getSpawns()
 end
 
+function createRoomObjects()
+	LoadedObjects.Rooms = {}
+	for _, v in pairs(LevelData.objects.rooms) do
+		table.insert(LoadedObjects.Rooms, Collision:new(v[1],v[2],v[3],v[4]))
+	end
+end
 
-function LevelExpandCanvas(horizontal,vertical)
+function getSpawns()
+	LoadedObjects.Spawns = {}
+	for _, v in pairs(LevelData.objects.spawns) do
+		--addSpawn(v[1],unpack(v[2]))
+	end
+end
+
+function expandLevelCanvas(horizontal,vertical)
 	local horizontal = horizontal or 0
 	local vertical = vertical or 0
-	local h = LevelGetTileWidth()
-	local v = LevelGetTileHeight()
+	local h = getLevelTileWidth()
+	local v = getLevelTileHeight()
 
 	-- get new canvas size
 	local newCanvasH = h + math.abs(horizontal)
@@ -35,7 +68,7 @@ function LevelExpandCanvas(horizontal,vertical)
 	for i = 1, newCanvasV do
 		ExpandedLevel[i] = {}
 		for j = 1, newCanvasH do
-			ExpandedLevel[i][j] = InstanceTile(0)
+			ExpandedLevel[i][j] = instanceTile(0)
 		end
 	end
 
@@ -53,7 +86,7 @@ function LevelExpandCanvas(horizontal,vertical)
 	-- get data from old canvas to new canvas
 	for i = 1, #LevelTiles do
 		for j = 1, #LevelTiles[i] do
-			ExpandedLevel[i+expand_v][j+expand_h] = InstanceTile(LevelTiles[i][j].id)
+			ExpandedLevel[i+expand_v][j+expand_h] = instanceTile(LevelTiles[i][j].id)
 		end
 	end
 
@@ -62,11 +95,11 @@ function LevelExpandCanvas(horizontal,vertical)
 end
 
 
-function LevelReduceCanvas(horizontal,vertical)
+function reduceLevelCanvas(horizontal,vertical)
 	local horizontal = horizontal or 0
 	local vertical = vertical or 0
-	local h = LevelGetTileWidth()
-	local v = LevelGetTileHeight()
+	local h = getLevelTileWidth()
+	local v = getLevelTileHeight()
 
 	-- get new canvas size
 	local newCanvasH = h - math.abs(horizontal)
@@ -77,7 +110,7 @@ function LevelReduceCanvas(horizontal,vertical)
 	for i = 1, newCanvasV do
 		ExpandedLevel[i] = {}
 		for j = 1, newCanvasH do
-			ExpandedLevel[i][j] = InstanceTile(0)
+			ExpandedLevel[i][j] = instanceTile(0)
 		end
 	end
 
@@ -95,38 +128,35 @@ function LevelReduceCanvas(horizontal,vertical)
 	-- get data from old canvas to new canvas
 	for i = 1, #ExpandedLevel do
 		for j = 1, #ExpandedLevel[i] do
-			ExpandedLevel[i][j] = InstanceTile(LevelTiles[i+expand_v][j+expand_h].id)
+			ExpandedLevel[i][j] = instanceTile(LevelTiles[i+expand_v][j+expand_h].id)
 		end
 	end
 
 	-- use new canvas
 	LevelTiles = ExpandedLevel
 
-	LevelExpandCanvas()
+	expandLevelCanvas()
 end
 
-function LevelGetTileData()
-	for k, v in pairs(tileset) do
-		if v == LevelData.tileset then
-			TileData = dofile("data/tileset/"..k..".lua")
-		end
-	end
+function getLevelTileData()
+	TileData = dofile("data/tileset/"..LevelData.tileset_name..".lua")
+	
 end
 
-function LevelReloadTiles()
-	LevelUpdateDimensions()
+function reloadLevelTiles()
+	updateLevelDimensions()
 end
 
-function LevelUpdateDimensions()
-	LevelData.Width = LevelGetWidth()
-	LevelData.Height = LevelGetHeight()
+function updateLevelDimensions()
+	LevelData.Width = getLevelWidth()
+	LevelData.Height = getLevelHeight()
 end
 
-function LevelGetTileHeight()
+function getLevelTileHeight()
 	return #LevelTiles
 end
 
-function LevelGetTileWidth()
+function getLevelTileWidth()
 	local width = 0
 	for i = 1, #LevelTiles do
 		if width < #LevelTiles[i] then width = #LevelTiles[i] end
@@ -134,42 +164,42 @@ function LevelGetTileWidth()
 	return width
 end
 
-function LevelGetHeight()
-	return LevelGetTileHeight() * tileProperties.height
+function getLevelHeight()
+	return getLevelTileHeight() * tile_properties.height
 end
 
-function LevelGetWidth()
-	return LevelGetTileWidth() * tileProperties.width
+function getLevelWidth()
+	return getLevelTileWidth() * tile_properties.width
 end
 
-function LevelIndexTiles()
+function indexLevelTiles()
 	TileIndex = {}
-
+	local this_tileset = LevelData.tileset
 	-- index from tileset
-	local width = LevelData.tileset:getPixelWidth()/tileProperties.width
-	local height = LevelData.tileset:getPixelHeight()/tileProperties.height
+	local width = this_tileset:getPixelWidth()/tile_properties.width
+	local height = this_tileset:getPixelHeight()/tile_properties.height
 	for i = 0, height do
 		for j = 0, width do
 			TileIndex[i*width+j+1] = love.graphics.newQuad(
-														j*tileProperties.width,
-														i*tileProperties.height,
-														tileProperties.width,
-														tileProperties.height,
-														LevelData.tileset:getDimensions()
+														j*tile_properties.width,
+														i*tile_properties.height,
+														tile_properties.width,
+														tile_properties.height,
+														this_tileset:getDimensions()
 													)
 		end
 	end
-	TileDataInitialize()
+	initTileData()
 
 -- instance level tiles according to the Properties
 	for i = 1, #LevelTiles do
 		for j = 1, #LevelTiles[i] do
-			SetTile(i,j,LevelTiles[i][j])
+			setTile(i,j,LevelTiles[i][j])
 		end
 	end
 end
 
-function TileDataInitialize()
+function initTileData()
 	for _, Properties in pairs(TileData) do
 		if Properties.animation ~= nil then
 			Properties.tileset = love.graphics.newImage("assets/terrain/"..Properties.animation..".png")
@@ -178,18 +208,18 @@ function TileDataInitialize()
 			Properties.current_subimage = 1
 
 			local tileset = Properties.tileset
-			local width = tileset:getPixelWidth()/tileProperties.width
-			local height = tileset:getPixelHeight()/tileProperties.height
+			local width = tileset:getPixelWidth()/tile_properties.width
+			local height = tileset:getPixelHeight()/tile_properties.height
 			local image_count = 0
 
 			for i = 0, height-1 do
 				for j = 0, width-1 do
 					local quad =
 						love.graphics.newQuad(
-							j*tileProperties.width,
-							i*tileProperties.height,
-							tileProperties.width,
-							tileProperties.height,
+							j*tile_properties.width,
+							i*tile_properties.height,
+							tile_properties.width,
+							tile_properties.height,
 							tileset:getDimensions()
 						)
 					image_count = image_count + 1
@@ -202,9 +232,12 @@ function TileDataInitialize()
 	end
 end
 
-function InstanceTile(id)
+function instanceTile(id)
 	local tile = {}
 
+	if type(id) == "table" then
+		id = id.id
+	end
 	tile.id = id
 	local Properties = TileData[tile.id]
 
@@ -225,8 +258,8 @@ function InstanceTile(id)
 	return tile
 end
 
-function SetTile(i,j,id)
-	LevelTiles[i][j] = InstanceTile(id)
+function setTile(i,j,id)
+	LevelTiles[i][j] = instanceTile(id)
 end
 
 function drawGridDisplay()
@@ -234,16 +267,16 @@ function drawGridDisplay()
 		for j = 1, #LevelTiles[i] do
 			love.graphics.rectangle(
 				"line",
-				tileProperties.scale * (j * tileProperties.width + (levelProperties.offset.x - tileProperties.width)) - Camera.pos.x,
-				tileProperties.scale * (i * tileProperties.height + (levelProperties.offset.y - tileProperties.height)) - Camera.pos.y,
-				tileProperties.scale * tileProperties.width,
-				tileProperties.scale * tileProperties.height
+				tile_properties.scale * (j * tile_properties.width + (level_properties.offset.x - tile_properties.width)) - Camera.pos.x,
+				tile_properties.scale * (i * tile_properties.height + (level_properties.offset.y - tile_properties.height)) - Camera.pos.y,
+				tile_properties.scale * tile_properties.width,
+				tile_properties.scale * tile_properties.height
 			)
 		end
 	end
 end
 
-function TileOptimizeObjects()
+function optimizeTileObjects(dest)
 	logPrint("Optimizing Objects...")
 	local unoptimized = 0
 	local isTileOptimized = {}
@@ -255,8 +288,9 @@ function TileOptimizeObjects()
 	end
 	for i = 1, #LevelTiles do
 		for j = 1, #LevelTiles[i] do
-			if LevelTiles[i][j].id ~= 0 then
-				local type = TileData[LevelTiles[i][j].id].type
+			if LevelTiles[i][j].id ~= 0 and TileData[LevelTiles[i][j].id] then
+				local tile_dat =  TileData[LevelTiles[i][j].id]
+				local type = tile_dat.type
 				if type == "whole" and not isTileOptimized[i][j] then
 					isTileOptimized[i][j] = true
 					local n = 1
@@ -313,105 +347,106 @@ function TileOptimizeObjects()
 
 					logPrint("- Group size: "..m.."x"..n)
 					unoptimized = unoptimized + m * n
-					local base_x = tileProperties.scale * j * tileProperties.width + tileProperties.scale * (levelProperties.offset.x - tileProperties.height)
-					local base_y = tileProperties.scale * i * tileProperties.height + tileProperties.scale * (levelProperties.offset.y - tileProperties.height)
+					local base_x = tile_properties.scale * j * tile_properties.width + tile_properties.scale * (level_properties.offset.x - tile_properties.height)
+					local base_y = tile_properties.scale * i * tile_properties.height + tile_properties.scale * (level_properties.offset.y - tile_properties.height)
 
 					local col = Collision:new(
 						base_x,
 						base_y,
-						base_x + tileProperties.width * tileProperties.scale * n,
-						base_y + tileProperties.height * tileProperties.scale * m
+						base_x + tile_properties.width * tile_properties.scale * n,
+						base_y + tile_properties.height * tile_properties.scale * m
 					)
-					table.insert(LoadedObjects.Collisions,col)
+					table.insert(dest,col)
 				end
 			end
 		end
 	end
 
-	logPrint("collisions optimized from " .. unoptimized .. " to " .. #LoadedObjects.Collisions)
+	--logPrint("collisions optimized from " .. unoptimized .. " to " .. #LoadedObjects.Collisions)
 end
 
-function TileCreateObjects()
-	LoadedObjects.Collisions = {}
-	LoadedObjects.Platforms = {}
-	LoadedObjects.Ladders = {}
-	LoadedObjects.Hazards = {}
+-- currently broken
+function createTileObjects(dest)
 
-	TileOptimizeObjects()
+
+	optimizeTileObjects(dest.collisions)
 
 	for i = 1, #LevelTiles do
 		for j = 1, #LevelTiles[i] do
 			if LevelTiles[i][j].id ~= 0 then
-
-				local type = TileData[LevelTiles[i][j].id].type
-				local light = TileData[LevelTiles[i][j].id].light
-				local base_x = tileProperties.scale * j * tileProperties.width + tileProperties.scale * (levelProperties.offset.x - tileProperties.height)
-				local base_y = tileProperties.scale * i * tileProperties.height + tileProperties.scale * (levelProperties.offset.y - tileProperties.height)
+				local tile_dat = TileData[LevelTiles[i][j].id] or {}
+				local type = tile_dat.type
+				local light = tile_dat.light
+				local base_x = tile_properties.scale * j * tile_properties.width + tile_properties.scale * (level_properties.offset.x - tile_properties.height)
+				local base_y = tile_properties.scale * i * tile_properties.height + tile_properties.scale * (level_properties.offset.y - tile_properties.height)
 
 
 				if light ~= 0 and light ~= nil then
 					CreateLight(
-						base_x + tileProperties.width/2 * tileProperties.scale,
-						base_y + tileProperties.height/2 * tileProperties.scale,
+						base_x + tile_properties.width/2 * tile_properties.scale,
+						base_y + tile_properties.height/2 * tile_properties.scale,
 						light
 					)
 				end
 
+				local col
+				local list = dest.collisions
+
 				-- wholes are handled in optimization now
 				--[[if type == "whole" then
 					local col = Collision:new(
 						base_x,
 						base_y,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height * tileProperties.scale
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height * tile_properties.scale
 					)
 					table.insert(LoadedObjects.Collisions,col)
 				else]]if type == "half_bottom" then
 
-					local col = Collision:new(
+					col = Collision:new(
 						base_x,
-						base_y + tileProperties.height/2 * tileProperties.scale,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height * tileProperties.scale
+						base_y + tile_properties.height/2 * tile_properties.scale,
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height * tile_properties.scale
 					)
-					table.insert(LoadedObjects.Collisions,col)
+					
 
 				elseif type == "half_top" then
 
-					local col = Collision:new(
+					col = Collision:new(
 						base_x,
 						base_y ,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height/2 * tileProperties.scale
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height/2 * tile_properties.scale
 					)
-					table.insert(LoadedObjects.Collisions,col)
+					
 
 				elseif type == "half_right" then
 
-					local col = Collision:new(
-						base_x + tileProperties.height/2 * tileProperties.scale,
+					col = Collision:new(
+						base_x + tile_properties.height/2 * tile_properties.scale,
 						base_y,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height * tileProperties.scale
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height * tile_properties.scale
 					)
-					table.insert(LoadedObjects.Collisions,col)
+					
 
 				elseif type == "half_left" then
 
 					local col = Collision:new(
 						base_x,
 						base_y,
-						base_x + tileProperties.height/2 * tileProperties.scale,
-						base_y + tileProperties.height * tileProperties.scale
+						base_x + tile_properties.height/2 * tile_properties.scale,
+						base_y + tile_properties.height * tile_properties.scale
 					)
 					table.insert(LoadedObjects.Collisions,col)
 
 				elseif type == "platform" then
 					local plat = Collision:new(
 						base_x,
-						base_y + tileProperties.scale * 2,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height/4 * tileProperties.scale + tileProperties.scale * 2
+						base_y + tile_properties.scale * 2,
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height/4 * tile_properties.scale + tile_properties.scale * 2
 					)
 					table.insert(LoadedObjects.Platforms,plat)
 
@@ -420,9 +455,9 @@ function TileCreateObjects()
 					-- do ramp owo
 						local slope = Collision:new(
 							base_x,
-							base_y + k * tileProperties.scale - tileProperties.scale,
-							base_x + k * 2 * tileProperties.scale,
-							base_y + k * tileProperties.scale
+							base_y + k * tile_properties.scale - tile_properties.scale,
+							base_x + k * 2 * tile_properties.scale,
+							base_y + k * tile_properties.scale
 						)
 						table.insert(LoadedObjects.Collisions,slope)
 
@@ -430,9 +465,9 @@ function TileCreateObjects()
 					-- fill lower half
 					local col = Collision:new(
 						base_x,
-						base_y + tileProperties.height/2 * tileProperties.scale,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height * tileProperties.scale
+						base_y + tile_properties.height/2 * tile_properties.scale,
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height * tile_properties.scale
 					)
 					table.insert(LoadedObjects.Collisions,col)
 
@@ -441,9 +476,9 @@ function TileCreateObjects()
 					-- do ramp owo
 						local slope = Collision:new(
 							base_x,
-							base_y + tileProperties.height/2 * tileProperties.scale + k * tileProperties.scale - tileProperties.scale,
-							base_x + k * 2 * tileProperties.scale,
-							base_y + tileProperties.height/2 * tileProperties.scale + k * tileProperties.scale
+							base_y + tile_properties.height/2 * tile_properties.scale + k * tile_properties.scale - tile_properties.scale,
+							base_x + k * 2 * tile_properties.scale,
+							base_y + tile_properties.height/2 * tile_properties.scale + k * tile_properties.scale
 						)
 						table.insert(LoadedObjects.Collisions,slope)
 
@@ -454,9 +489,9 @@ function TileCreateObjects()
 					-- do ramp owo
 						local slope = Collision:new(
 							base_x,
-							base_y + tileProperties.height/2 * tileProperties.scale - tileProperties.scale + k * tileProperties.scale,
-							base_x + tileProperties.width * tileProperties.scale - (k-1) * 2 * tileProperties.scale,
-							base_y + tileProperties.height/2 * tileProperties.scale - tileProperties.scale + k * tileProperties.scale + tileProperties.scale
+							base_y + tile_properties.height/2 * tile_properties.scale - tile_properties.scale + k * tile_properties.scale,
+							base_x + tile_properties.width * tile_properties.scale - (k-1) * 2 * tile_properties.scale,
+							base_y + tile_properties.height/2 * tile_properties.scale - tile_properties.scale + k * tile_properties.scale + tile_properties.scale
 						)
 						table.insert(LoadedObjects.Collisions,slope)
 
@@ -465,8 +500,8 @@ function TileCreateObjects()
 					local col = Collision:new(
 						base_x,
 						base_y,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height/2 * tileProperties.scale
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height/2 * tile_properties.scale
 					)
 					table.insert(LoadedObjects.Collisions,col)
 
@@ -475,9 +510,9 @@ function TileCreateObjects()
 					-- do ramp owo
 						local slope = Collision:new(
 							base_x,
-							base_y - tileProperties.scale + k * tileProperties.scale,
-							base_x + tileProperties.width * tileProperties.scale - (k-1) * 2 * tileProperties.scale,
-							base_y - tileProperties.scale + k * tileProperties.scale + tileProperties.scale
+							base_y - tile_properties.scale + k * tile_properties.scale,
+							base_x + tile_properties.width * tile_properties.scale - (k-1) * 2 * tile_properties.scale,
+							base_y - tile_properties.scale + k * tile_properties.scale + tile_properties.scale
 						)
 						table.insert(LoadedObjects.Collisions,slope)
 
@@ -487,10 +522,10 @@ function TileCreateObjects()
 					for k = 1, 8 do
 					-- do ramp owo
 						local slope = Collision:new(
-							base_x + (k-8) * -2 * tileProperties.scale,
-							base_y - tileProperties.scale + k * tileProperties.scale,
-							base_x + tileProperties.width * tileProperties.scale,
-							base_y - tileProperties.scale + k * tileProperties.scale + tileProperties.scale
+							base_x + (k-8) * -2 * tile_properties.scale,
+							base_y - tile_properties.scale + k * tile_properties.scale,
+							base_x + tile_properties.width * tile_properties.scale,
+							base_y - tile_properties.scale + k * tile_properties.scale + tile_properties.scale
 						)
 						table.insert(LoadedObjects.Collisions,slope)
 
@@ -498,9 +533,9 @@ function TileCreateObjects()
 					-- fill lower half
 					local col = Collision:new(
 						base_x,
-						base_y + tileProperties.height/2 * tileProperties.scale,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height * tileProperties.scale
+						base_y + tile_properties.height/2 * tile_properties.scale,
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height * tile_properties.scale
 					)
 					table.insert(LoadedObjects.Collisions,col)
 
@@ -508,10 +543,10 @@ function TileCreateObjects()
 					for k = 1, 8 do
 					-- do ramp owo
 						local slope = Collision:new(
-							base_x + (k-8) * -2 * tileProperties.scale,
-							base_y + tileProperties.height/2 * tileProperties.scale - tileProperties.scale + k * tileProperties.scale,
-							base_x + tileProperties.width * tileProperties.scale,
-							base_y + tileProperties.height/2 * tileProperties.scale - tileProperties.scale + k * tileProperties.scale + tileProperties.scale
+							base_x + (k-8) * -2 * tile_properties.scale,
+							base_y + tile_properties.height/2 * tile_properties.scale - tile_properties.scale + k * tile_properties.scale,
+							base_x + tile_properties.width * tile_properties.scale,
+							base_y + tile_properties.height/2 * tile_properties.scale - tile_properties.scale + k * tile_properties.scale + tile_properties.scale
 						)
 						table.insert(LoadedObjects.Collisions,slope)
 
@@ -521,10 +556,10 @@ function TileCreateObjects()
 					for k = 1, 8 do
 					-- do ramp owo
 						local slope = Collision:new(
-							base_x + (k-8) * -2 * tileProperties.scale,
-							base_y + tileProperties.height/2 * tileProperties.scale - k * tileProperties.scale,
-							base_x + tileProperties.width * tileProperties.scale,
-							base_y + tileProperties.height/2 * tileProperties.scale - k * tileProperties.scale + tileProperties.scale
+							base_x + (k-8) * -2 * tile_properties.scale,
+							base_y + tile_properties.height/2 * tile_properties.scale - k * tile_properties.scale,
+							base_x + tile_properties.width * tile_properties.scale,
+							base_y + tile_properties.height/2 * tile_properties.scale - k * tile_properties.scale + tile_properties.scale
 						)
 						table.insert(LoadedObjects.Collisions,slope)
 
@@ -534,10 +569,10 @@ function TileCreateObjects()
 					for k = 1, 8 do
 					-- do ramp owo
 						local slope = Collision:new(
-							base_x + (k-8) * -2 * tileProperties.scale,
-							base_y + tileProperties.height/2 * tileProperties.scale + tileProperties.height/2 * tileProperties.scale - k * tileProperties.scale,
-							base_x + tileProperties.width * tileProperties.scale,
-							base_y + tileProperties.height/2 * tileProperties.scale + tileProperties.height/2 * tileProperties.scale - k * tileProperties.scale + tileProperties.scale
+							base_x + (k-8) * -2 * tile_properties.scale,
+							base_y + tile_properties.height/2 * tile_properties.scale + tile_properties.height/2 * tile_properties.scale - k * tile_properties.scale,
+							base_x + tile_properties.width * tile_properties.scale,
+							base_y + tile_properties.height/2 * tile_properties.scale + tile_properties.height/2 * tile_properties.scale - k * tile_properties.scale + tile_properties.scale
 						)
 						table.insert(LoadedObjects.Collisions,slope)
 
@@ -546,8 +581,8 @@ function TileCreateObjects()
 					local col = Collision:new(
 						base_x,
 						base_y,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height/2 * tileProperties.scale
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height/2 * tile_properties.scale
 					)
 					table.insert(LoadedObjects.Collisions,col)
 
@@ -557,39 +592,40 @@ function TileCreateObjects()
 					-- do ramp owo
 						local slope = Collision:new(
 							base_x,
-							base_y + k * tileProperties.scale - tileProperties.scale,
-							base_x + k * tileProperties.scale,
-							base_y + k * tileProperties.scale
+							base_y + k * tile_properties.scale - tile_properties.scale,
+							base_x + k * tile_properties.scale,
+							base_y + k * tile_properties.scale
 						)
 						table.insert(LoadedObjects.Collisions,slope)
 
 					end
 
-				elseif type == "ladder_right" then
+					-- TODO: fix ladders
+				--[[elseif type == "ladder_right" then
 
 					local ladder = Collision:new(
-						base_x + (tileProperties.width-4)* tileProperties.scale,
+						base_x + (tile_properties.width-4)* tile_properties.scale,
 						base_y,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height * tileProperties.scale
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height * tile_properties.scale
 					)
 					table.insert(LoadedObjects.Ladders,ladder)
 
 				elseif type == "ladder_platform_right" then
 
 					local ladder = Collision:new(
-						base_x + (tileProperties.width-4)* tileProperties.scale,
-						base_y + tileProperties.scale * 2,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height * tileProperties.scale
+						base_x + (tile_properties.width-4)* tile_properties.scale,
+						base_y + tile_properties.scale * 2,
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height * tile_properties.scale
 					)
 					table.insert(LoadedObjects.Ladders,ladder)
 
 					local plat = Collision:new(
 						base_x,
-						base_y + tileProperties.scale * 2,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height/4 * tileProperties.scale + tileProperties.scale * 2
+						base_y + tile_properties.scale * 2,
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height/4 * tile_properties.scale + tile_properties.scale * 2
 					)
 					table.insert(LoadedObjects.Platforms,plat)
 
@@ -599,8 +635,8 @@ function TileCreateObjects()
 					local ladder = Collision:new(
 						base_x,
 						base_y,
-						base_x + tileProperties.scale * 4,
-						base_y + tileProperties.height * tileProperties.scale
+						base_x + tile_properties.scale * 4,
+						base_y + tile_properties.height * tile_properties.scale
 					)
 					table.insert(LoadedObjects.Ladders,ladder)
 
@@ -609,39 +645,40 @@ function TileCreateObjects()
 
 					local ladder = Collision:new(
 						base_x,
-						base_y + tileProperties.scale * 2,
-						base_x + tileProperties.scale * 4,
-						base_y + tileProperties.height * tileProperties.scale
+						base_y + tile_properties.scale * 2,
+						base_x + tile_properties.scale * 4,
+						base_y + tile_properties.height * tile_properties.scale
 					)
 					table.insert(LoadedObjects.Ladders,ladder)
 
 					local plat = Collision:new(
 						base_x,
-						base_y + tileProperties.scale * 2,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height/4 * tileProperties.scale + tileProperties.scale * 2
+						base_y + tile_properties.scale * 2,
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height/4 * tile_properties.scale + tile_properties.scale * 2
 					)
 					table.insert(LoadedObjects.Platforms,plat)
 
-				elseif type == "bottom_hazard" then
+				]]elseif type == "bottom_hazard" then
 
 
 					local hazard = Collision:new(
 						base_x,
-						base_y + tileProperties.height * 12/16 * tileProperties.scale,
-						base_x + tileProperties.width * tileProperties.scale,
-						base_y + tileProperties.height * tileProperties.scale
+						base_y + tile_properties.height * 12/16 * tile_properties.scale,
+						base_x + tile_properties.width * tile_properties.scale,
+						base_y + tile_properties.height * tile_properties.scale
 					)
-					table.insert(LoadedObjects.Hazards,hazard)
+					list = dest.hazards
 
 				end
+				table.insert(list, col)
 			end
 		end
 	end
 	--CreateCollisionTable()
 end
 
-function AnimateTiles()
+function animateTiles()
 	for _, Properties in pairs(TileData) do
 		if Properties ~= nil then
 			if Properties.animation ~= nil then
@@ -661,40 +698,7 @@ function AnimateTiles()
 	end
 end
 
-function CreateCollisionTable()
-	-- init table
-	CollisionTable = {}
-	for j=0, 16*LevelGetTileHeight()-1 do
-		CollisionTable[j] = {}
-		for i=0, 16*LevelGetTileWidth()-1 do
-			CollisionTable[j][i] = false
-		end
-	end
-
-	for _, collision in pairs(LoadedObjects.Collisions) do
-		for ci=0, math.floor(collision.width)-1 do
-			for cj=0, math.floor(collision.height)-1 do
-				print(ci..","..cj)
-				CollisionTable[collision.from.y+cj][collision.from.x+ci] = true
-			end
-		end
-	end
-end
-
-function DrawColisionTable()
-	for j=1, #CollisionTable do
-		for i=1, #CollisionTable[j] do
-			if CollisionTable[j][i] then
-				love.graphics.setColor(0,1,0,1)
-			else
-				love.graphics.setColor(1,0,0,1)
-			end
-			love.graphics.points(i,j)
-		end
-	end
-end
-
-function DrawTile(tile,x,y,depth)
+function drawTile(tile,x,y,depth)
 	local Properties = TileData[tile.id]
 
 	if Properties ~= nil then
@@ -707,8 +711,8 @@ function DrawTile(tile,x,y,depth)
 				x,
 				y,
 				0,
-				tileProperties.scale,
-				tileProperties.scale
+				tile_properties.scale,
+				tile_properties.scale
 			)
 			end
 		elseif Properties.depth == depth then
@@ -720,8 +724,8 @@ function DrawTile(tile,x,y,depth)
 					x,
 					y,
 					0,
-					tileProperties.scale,
-					tileProperties.scale
+					tile_properties.scale,
+					tile_properties.scale
 				)
 				end
 			else
@@ -731,8 +735,8 @@ function DrawTile(tile,x,y,depth)
 					x,
 					y,
 					0,
-					tileProperties.scale,
-					tileProperties.scale
+					tile_properties.scale,
+					tile_properties.scale
 				)
 			end
 		end
@@ -747,8 +751,8 @@ function DrawTile(tile,x,y,depth)
 						x,
 						y,
 						0,
-						tileProperties.scale,
-						tileProperties.scale
+						tile_properties.scale,
+						tile_properties.scale
 					)
 				else
 					love.graphics.draw(
@@ -757,8 +761,8 @@ function DrawTile(tile,x,y,depth)
 						x,
 						y,
 						0,
-						tileProperties.scale,
-						tileProperties.scale
+						tile_properties.scale,
+						tile_properties.scale
 					)
 				end
 			end

code/lights.lua

@@ -26,12 +26,12 @@ end
 
 function Light:kill()
 	if self.id ~= nil then
+		table.remove(LoadedObjects.Lights,self.id)
 		for _, e in pairs(LoadedObjects.Lights) do
 			if e.id > self.id then
 				e.id = e.id - 1
 			end
 		end
-		table.remove(LoadedObjects.Lights,self.id)
 	end
 	self = nil
 end

code/locale.lua

@@ -1,4 +1,4 @@
-function LocaleLoad(ISO639)
+function loadLocale(ISO639)
 	local ISO639 = ISO639 or "ENG"
 	dofile("data/locale/"..ISO639..".lua")
 	dofile("data/dialog_sequences.lua")

code/math.lua

@@ -8,20 +8,22 @@ function math.sign(x)
 	end
 end
 
-function Vector(init_x, init_y, final_x, final_y)
-	local distance_x = final_x - init_x
-	local distance_y = final_y - init_y
-	return {distance_x, distance_y}
+function math.round(x)
+	return math.floor(x+0.5)
 end
 
-function GetVectorValue(vector)
-	return math.sqrt(vector[1] ^ 2 + vector[2] ^ 2)
+function vector(x, y)
+	return {x = x, y = y}
 end
 
-function GetAngleFromVector(x,y)
+function getVectorValue(vector)
+	return math.sqrt(vector.x ^ 2 + vector.y ^ 2)
+end
+
+function getAngleFromVector(vector)
 	local reduce = 0
-	if x < 0 then
+	if vector.x < 0 then
 		reduce = math.rad(180)
 	end
-	return math.atan(y/x) - reduce
+	return math.atan(vector.y/vector.x) - reduce
 end

code/menu.lua

@@ -1,24 +1,24 @@
-function MenuDraw(menu)
+function drawMenu(menu)
 	local font = love.graphics.getFont()
-	love.graphics.setFont(LocaleFont)
+	love.graphics.setFont(locale_font)
 
 	-- reset scale
 	love.graphics.setScale()
 
 	if menu == "pause" then
-		MenuDrawPauseScreen()
+		drawMenuPauseScreen()
 	elseif menu == "dialog" then
-		MenuDrawDialog()
+		drawMenuDialog()
 	end
 
 	for _, element in pairs(UIElement) do
-		element:Draw()
+		element:draw()
 	end
 
 	love.graphics.setFont(font)
 end
 
-function MenuDrawPauseScreen()
+function drawMenuPauseScreen()
 	-- Parameters
 	local pauseWidth = 640
 	local pauseHeight = 480
@@ -32,10 +32,10 @@ function MenuDrawPauseScreen()
 	love.graphics.rectangle("fill", pauseX, pauseY, pauseWidth, pauseHeight)
 end
 
-function MenuDrawDialog()
+function drawMenuDialog()
 end
 
-function MenuStep(menu)
+function stepMenu(menu)
 	-- first get mouse
 	local mouse_x, mouse_y = love.mouse.getPosition()
 	for _, element in pairs(UIElement) do
@@ -47,98 +47,98 @@ function MenuStep(menu)
 	end
 	if menu == 0 then
 	elseif menu == "pause" then
-		MenuStepPauseScreen()
+		stepMenuPauseScreen()
 	elseif menu == "dialog" then
-		MenuStepDialog()
+		stepMenuDialog()
 	end
 end
 
-function MenuStepPauseScreen()
-	if PauseResume:getVariable() == true then
-		PauseResume = nil
-		PauseOptions = nil
-		PauseExit = nil
-		MenuExit()
-	elseif PauseExit:getVariable() == true then
+function stepMenuPauseScreen()
+	if pause_resume:getVariable() == true then
+		pause_resume = nil
+		pause_options = nil
+		pause_exit = nil
+		exitMenu()
+	elseif pause_exit:getVariable() == true then
 		love.event.quit()
 	end
 end
 
-function MenuStepDialog()
-	if DialogContainer.value >= DialogContainer.target_value then
-		DialogContainer = nil
-		MenuExit()
+function stepMenuDialog()
+	if dialog_container.value >= dialog_container.target_value then
+		dialog_container = nil
+		exitMenu()
 	end
 end
 
-function MenuClear()
+function clearMenu()
 	for _, element in pairs(UIElement) do
 		element = nil
 	end
 	UIElement = {}
 end
 
-function MenuExit(to)
-	MenuClear()
+function exitMenu(to)
+	clearMenu()
 	local to = to or "no"
 	menu_type = to
 end
 
-function MenuInit(menu,parameter)
+function initMenu(menu,parameter)
 	-- main menu
 	if menu == "pause" then
-		MenuInitPauseScreen()
+		initMenuPauseScreen()
 	elseif menu == "dialog" then
 		if parameter == nil then
-			parameter = DialogSequence.Example
+			parameter = dialog_sequence.Example
 		end
-		MenuInitDialog(parameter)
+		initMenuDialog(parameter)
 	end
 end
 
-function MenuInitDialog(parameter)
-	DialogContainer = interfaceDialog:new()
-	DialogContainer:loadSequence(parameter)
+function initMenuDialog(parameter)
+	dialog_container = InterfaceDialog:new()
+	dialog_container:loadSequence(parameter)
 end
 
-function MenuInitPauseScreen()
-	local buttonStandard = {width = 200, height = 30, separation = 10}
+function initMenuPauseScreen()
+	local button_standard = {width = 200, height = 30, separation = 10}
 	-- elements
-	PauseResume = interfaceButton:new(
+	pause_resume = InterfaceButton:new(
 		game.width/2,
-		game.height/2-buttonStandard.height-buttonStandard.separation,
-		buttonStandard.width,
-		buttonStandard.height,
+		game.height/2-button_standard.height-button_standard.separation,
+		button_standard.width,
+		button_standard.height,
 		{false,true},
 		1,
 		{
-			text = Locale.ui.pause_screen_resume,
+			text = locale.ui.pause_screen_resume,
 			color = {0,0,0.5},
 			color2 = {1,1,1}
 		}
 	)
-	PauseOptions = interfaceButton:new(
+	pause_options = InterfaceButton:new(
 		game.width/2,
 		game.height/2,
-		buttonStandard.width,
-		buttonStandard.height,
+		button_standard.width,
+		button_standard.height,
 		{false,true},
 		1,
 		{
-			text = Locale.ui.pause_screen_options,
+			text = locale.ui.pause_screen_options,
 			color = {0,0,0.5},
 			color2 = {1,1,1}
 		}
 	)
-	PauseExit = interfaceButton:new(
+	pause_exit = InterfaceButton:new(
 		game.width/2,
-		game.height/2+buttonStandard.height+buttonStandard.separation,
-		buttonStandard.width,
-		buttonStandard.height,
+		game.height/2+button_standard.height+button_standard.separation,
+		button_standard.width,
+		button_standard.height,
 		{false,true},
 		1,
 		{
-			text = Locale.ui.pause_screen_exit,
+			text = locale.ui.pause_screen_exit,
 			color = {0,0,0.5},
 			color2 = {1,1,1}
 		}

code/objects.lua

@@ -7,8 +7,8 @@ function LoadedObjects.drawCollisions()
 	end
 
 	for _, platform in pairs(LoadedObjects.Platforms) do
-		if platform.disable == true then platform:Draw(2) end
-		if platform.disable == false then platform:Draw(1) end
+		if platform.is_disabled == true then platform:Draw(2) end
+		if platform.is_disabled == false then platform:Draw(1) end
 	end
 
 	for _, ladder in pairs(LoadedObjects.Ladders) do
@@ -23,27 +23,16 @@ end
 -- returns true if theres a collision at that point
 function isThereObjectAt(x,y,objectType)
 	for _, object in pairs(objectType) do
-		if object.disable then
+		if object.is_disabled then
 			-- Dont calculate if dissabled
-		elseif x >= object.from.x
-		and x <= object.to.x
-		and y >= object.from.y
-		and y <= object.to.y then
-			object.isColliding = true
+		elseif object:asRect():containsPoint(Point:new(x, y)) then
+			object.is_colliding = true
 			return true
 		end
 	end
 	return false
 end
 
-function isThereCollisionAt(x,y)
-	if	x >= 0 and x < #CollisionTable
-	and y >= 0 and y < #CollisionTable[0] then
-		return CollisionTable[math.floor(y)][math.floor(x)]
-	end
-	return false
-end
-
 -- flags
 function setCollisionFlags()
 	local Check = {
@@ -54,21 +43,21 @@ function setCollisionFlags()
 	}
 	for _, type in pairs(Check) do
 		for _, object in pairs(type) do
-			object.isColliding = false
+			object.is_colliding = false
 		end
 	end
 	for _, platform in pairs(LoadedObjects.Platforms) do
-		if main_Player.pos.y < platform.from.y then
-			platform.disable = false
+		if main_player.pos.y < platform.from.y then
+			platform.is_disabled = false
 		else
-			platform.disable = true
+			platform.is_disabled = true
 		end
 	end
 	for _, platform in pairs(LoadedObjects.Hazards) do
-		if main_Player.isOnGround then
-			platform.disable = true
+		if main_player.isOnGround then
+			platform.is_disabled = true
 		else
-			platform.disable = false
+			platform.is_disabled = false
 		end
 	end
 end

code/point.lua

@@ -0,0 +1,37 @@
+Point = {}
+Point.__index = Point
+
+function Point:new(x, y)
+   local o = { x = x or 0, y = y or 0 }
+   setmetatable(o, self)
+   return o
+end
+
+function Point:__add(other)
+   return Point:new(self.x+other.x, self.y+other.y)
+end
+
+function Point:__sub(other)
+   return Point:new(self.x-other.x, self.y-other.y)
+end
+
+function Point:__mul(n)
+   return Point:new(self.x*n, self.y*n)
+end
+
+function Point:__div(n)
+   return Point:new(self.x/n, self.y/n)
+end
+
+-- absolute value, or the distance from the origin
+function Point:abs()
+   return math.sqrt(self.x ^ 2 + self.y ^ 2)
+end
+
+function Point:__tostring()
+    return "("..self.x..","..self.y..")"
+end
+
+function Point:copy()
+    return Point:new(self.x, self.y)
+end

code/queue.lua

@@ -8,7 +8,7 @@ function Queue:new()
 	return o
 end
 
-function Queue:Enqueue(item)
+function Queue:enqueue(item)
 	local elem = {item  = item}
 	if self.head == nil then
 		self.head = elem
@@ -22,12 +22,12 @@ function Queue:Enqueue(item)
 	return
 end
 
-function Queue:Empty()
+function Queue:empty()
 	return self.tail == nil
 end
 
-function Queue:Dequeue()
-	if self:Empty() then
+function Queue:dequeue()
+	if self:empty() then
 		return nil
 	end
 
@@ -41,9 +41,9 @@ function Queue:Dequeue()
 end
 
 local tq1 = Queue:new()
-tq1:Enqueue(5)
+tq1:enqueue(5)
 assert(tq1.head.item == 5)
-assert(tq1:Dequeue() == 5)
+assert(tq1:dequeue() == 5)
 
 -- queue that keeps a rolling tally of its arguments
 AvgQueue = {}
@@ -58,7 +58,7 @@ function AvgQueue:new(n, initial)
 
 	local x = initial / n
 	for _ = 1,n do
-		o.queue:Enqueue(x)
+		o.queue:enqueue(x)
 	end
 
 	setmetatable(o, self)
@@ -66,9 +66,9 @@ function AvgQueue:new(n, initial)
 	return o
 end
 
-function AvgQueue:Push(item)
+function AvgQueue:push(item)
 	local x = item/self.n
-	self.avg = self.avg + x - self.queue:Dequeue()
-	self.queue:Enqueue(x)
+	self.avg = self.avg + x - self.queue:dequeue()
+	self.queue:enqueue(x)
 	return self.avg
 end

code/rect.lua

@@ -0,0 +1,86 @@
+-- based of of plan9's Rectangle struct
+-- rect.max is not counted as "in" the rectangle
+Rect = {}
+Rect.__index = Rect
+
+function Rect:fromPoints(pt1, pt2)
+	local o = { min = pt1, max = pt2 }
+	setmetatable(o, self)
+	return o
+end
+
+function Rect:getPoints()
+	return self.min, self.max
+end
+
+
+function Rect:fromCoords(x1, y1, x2, y2)
+	return Rect:fromPoints(Point:new(x1, y1), Point:new(x2, y2))
+end
+
+function Rect:getCoords()
+	return self.min.x, self.min.y, self.max.x, self.max.y
+end
+
+-- clone refers to a deep copy
+function Rect:clone()
+	return Rect:fromCoords(self.min.x, self.min.y, self.max.x, self.max.y)
+end
+
+-- make sure min and max refer to the correct corners
+-- acts in place, returns self
+function Rect:fix()
+	if self.min.x > self.max.x then
+		self.min.x, self.max.x = self.max.x, self.min.x
+	end
+	if self.min.y > self.max.y then
+		self.min.y, self.max.y = self.max.y, self.min.y
+	end
+end
+
+function Rect:width()
+	return self.max.x - self.min.x
+end
+
+function Rect:height()
+	return self.max.y - self.min.y
+end
+
+function Rect:size()
+	return Point:new(self:width(), self:height())
+end
+
+function Rect:__add(pt)
+	return Rect:fromPoints(self.min + pt, self.max + pt)
+end
+
+function Rect:corners()
+	return {
+		self.min:copy(), -- top left
+		Point:new(self.max.x, self.min.y), -- top right
+		Point:new(self.min.x, self.max.y), -- bottom left
+		self.max:copy(), -- bottom right
+	}
+end
+
+function Rect:containsPoint(pt)
+	return pt.x >= self.min.x
+	and pt.y >= self.min.y
+	and pt.x <= self.max.x
+	and	pt.y <= self.max.y
+end
+
+function Rect:overlapsRect(other)
+	return self.min.x	<	other.max.x
+	and self.max.x		>	other.min.x
+	and self.min.y		<	other.max.y
+	and self.max.y		>	other.min.y
+end
+
+function Rect:draw(style)
+	love.graphics.rectangle(style, self.min.x - Camera.pos.x, self.min.y - Camera.pos.y, self:width(), self:height())
+end
+
+function Rect:__tostring()
+	return "Rect["..tostring(self.min).." "..tostring(self.max).."]"
+end

code/require.lua

@@ -7,12 +7,16 @@ require "data/sfx"
 require "code/locale"
 
 -- support functions
+require "code/serialize"
 require "code/math"
 require "code/draw"
 require "code/hex"
 require "code/in_out"
 
 -- classes
+require "code/point"
+require "code/rect"
+require "code/chunk"
 require "code/objects"
 require "code/level"
 require "code/camera"
@@ -22,6 +26,7 @@ require "code/queue"
 
 -- objects
 require "code/entity"
+require "code/spawn"
 require "code/canvas"
 require "code/collision"
 require "code/lights"

code/serialize.lua

@@ -0,0 +1,31 @@
+local function quote(str, lvl)
+	--lvl = lvl or 
+	local rp = "]"..(lvl or "").."]"
+	if string.match(str, rp) then
+		return quote(str, (lvl or "") .. "=")
+	end
+
+	return "["..(lvl or "").."["..str..rp
+end
+
+function serialize_lua_value(val)
+	if type(val) == "number" then
+		return tostring(val)
+	elseif type(val) == "string" then
+		-- TODO: use different quotes if ']]' appears in the value
+		return quote(val)
+	elseif type(val) == "table" then
+		local r = "{"
+		for k, v in pairs(val) do
+			r = r .. "[ "..serialize_lua_value(k).." ]="..serialize_lua_value(v)..","
+		end
+		return r .. "}"
+	elseif val == nil then
+		return "nil"
+	elseif val == false then
+		return "false"
+	elseif val == true then
+		return "true"
+	end
+	error("serialization failed")
+end

code/spawn.lua

@@ -0,0 +1,262 @@
+LoadedObjects.Spawns = {}
+
+function addSpawn(archetype, ...)
+	local o = {
+		archetype = archetype,
+		args = {...}
+	}
+	table.insert(LoadedObjects.Spawns, o)
+end
+
+function activateSpawns()
+	for _, spawn in pairs(LoadedObjects.Spawns) do
+		spawn.archetype:new(unpack(spawn.args))
+	end
+end
+
+function deselectSpawns()
+	for _, spawn in pairs(LoadedObjects.Spawns) do
+		spawn.selected = nil
+	end
+end
+
+function selectSpawns(rect)
+	local x, y = rect:getPoints()
+	local select_rect = Rect:fromPoints(x-{x=Camera.pos.x,y=Camera.pos.y},y-{x=Camera.pos.x,y=Camera.pos.y})
+	select_rect:fix()
+	
+	for _, spawn in pairs(LoadedObjects.Spawns) do
+
+		local offset_x, offset_y = spawn.archetype.display:getCenteredOffset()
+		local left = spawn.args[1] - Camera.pos.x - offset_x
+		local top = spawn.args[2] - Camera.pos.y - offset_y
+		local right = spawn.args[1] - Camera.pos.x + offset_x
+		local bottom = spawn.args[2] - Camera.pos.y + offset_y
+
+		local spawn_rect = Rect:fromCoords(left, top, right, bottom)
+		if spawn_rect:overlapsRect(select_rect) then
+			spawn.selected = true
+		end
+
+		if spawn.selected then
+			love.graphics.setColor(0,1,1,1)
+		else
+			love.graphics.setColor(0,1,0,1)
+		end
+
+		love.graphics.rectangle("fill",left-2,top-2,4,4)
+		love.graphics.rectangle("fill",right-2,bottom-2,4,4)
+		love.graphics.setColor(1,1,1,1)
+	end
+end
+
+function moveSpawns(x,y)
+	local move_x = nil
+	local move_y = nil
+	for _, spawn in pairs(LoadedObjects.Spawns) do
+		if spawn.selected then
+			local difference_x = math.floor((x/game.scale)+Camera.pos.x) - spawn.args[1]
+			local difference_y = math.floor((y/game.scale)+Camera.pos.y) - spawn.args[2]
+			if move_x == nil or Point.abs({x=difference_x,y=difference_y}) < Point.abs({x=move_x,y=move_y}) then
+				move_x = difference_x
+				move_y = difference_y
+			end
+		end
+	end
+	for _, spawn in pairs(LoadedObjects.Spawns) do
+		if spawn.selected then
+			spawn.args[1] = spawn.args[1] + move_x
+			spawn.args[2] = spawn.args[2] + move_y
+		end
+	end
+end
+
+
+function promptSpawnNew()
+	Prompt:cancelActive()
+	local text = ""
+	local prompt = Prompt:new({
+		name = "new spawn",
+		input = text,
+		func = function(prompt)
+			local f = loadstring("return {"..prompt.input.."}")
+			if f ~= nil then
+				local succ, result = pcall(f)
+				local arch = result[1]
+				local args = {}
+				if #result > 1 then
+					for i=2, #result+1 do
+						print("arg #"..i-1)
+						args[i-1] = result[i]
+						if i < 4 then
+							args[i-1] = math.floor(args[i-1])
+						end
+					end
+				else
+					args = {0,0}
+				end
+
+				print("new entity spawn --",succ)
+				if not succ
+				or checkArchetypeInvalid(arch)
+				then
+					print("invalid input for prompt "..prompt.name)
+				else
+					print("archetype: ",arch.type)
+					print("args:      ",unpack(args))
+					addSpawn(arch, unpack(args))
+				end
+			else
+				print("invalid input for prompt "..prompt.name)
+			end
+		end,
+	})
+	prompt.pos.x = 0
+	prompt.pos.y = 10
+	prompt:activate()
+end
+
+function deleteSpawn()
+	for i=1, #LoadedObjects.Spawns do
+		if LoadedObjects.Spawns[i]
+		and LoadedObjects.Spawns[i].selected then
+			table.remove(LoadedObjects.Spawns,i)
+			break
+		end
+	end
+end
+
+function checkArchetypeInvalid(arch)
+	return type(arch) ~= "table" or type(arch.type) ~= "string"
+end
+
+function promptSpawnArchetype()
+	Prompt:cancelActive()
+	for _, spawn in pairs(LoadedObjects.Spawns) do
+		if spawn.selected then
+			local offset_x, offset_y = spawn.archetype.display:getCenteredOffset()
+			local text = ""
+			for i=1, #spawn.args do
+				if i > 1 then text = text .. ", " end
+				text = text .. tostring(spawn.args[i])
+			end
+			local prompt = Prompt:new({
+				name = "archetype",
+				input = spawn.archetype.type,
+				spawn = spawn,
+				func = function(prompt)
+					print("return "..prompt.input)
+					local f = loadstring("return "..prompt.input)
+					if f ~= nil then
+						local succ, arch = pcall(f)
+						print("archetype changed --",succ)
+						print("from: ", spawn.archetype.type)
+						if not succ
+						or checkArchetypeInvalid(arch)
+						then
+							arch = spawn.archetype
+						end
+						print("to: ", arch.type)
+						spawn.archetype = arch
+					else
+						print("invalid input for prompt "..prompt.name)
+					end
+				end,
+			})
+			prompt.pos.x = (spawn.args[1]-4)*game.scale - Camera.pos.x - offset_x
+			prompt.pos.y = (spawn.args[2]-20)*game.scale - Camera.pos.y - offset_y
+			prompt:activate()
+		end
+	end
+end
+
+function checkArgsInvalid(args)
+	for _, arg in pairs(args) do
+		-- this is checking the args are not nil variables
+		if arg == nil
+		or arg == ""
+		then
+			return true
+		end
+	end
+end
+
+function promptSpawnArgs()
+	Prompt:cancelActive()
+	for _, spawn in pairs(LoadedObjects.Spawns) do
+		if spawn.selected then
+			local offset_x, offset_y = spawn.archetype.display:getCenteredOffset()
+			local text = ""
+			for i=1, #spawn.args do
+				if i > 1 then text = text .. ", " end
+				text = text .. tostring(spawn.args[i])
+			end
+			local prompt = Prompt:new({
+				name = "args",
+				input = text,
+				func = function(prompt)
+					local f = loadstring("return {"..prompt.input.."}")
+					if f ~= nil then
+						local succ, args = pcall(f)
+						print("args changed --",succ)
+						print("from: ", unpack(args))
+						if not succ
+						or checkArgsInvalid(args)
+						then
+							args = spawn.args
+						end
+						print("to: ", unpack(args))
+						spawn.args = args
+					else
+						print("invalid input for prompt "..prompt.name)
+					end
+				end,
+			})
+			prompt.pos.x = (spawn.args[1]-4)*game.scale - Camera.pos.x - offset_x
+			prompt.pos.y = (spawn.args[2]-4)*game.scale - Camera.pos.y - offset_y
+			prompt:activate()
+		end
+	end
+end
+
+function drawSpawns()
+	for _, spawn in pairs(LoadedObjects.Spawns) do
+		local offset_x, offset_y = spawn.archetype.display:getCenteredOffset()
+		love.graphics.setColor(1,1,1,1)
+		spawn.archetype.display:draw(
+			spawn.args[1] - Camera.pos.x - offset_x,
+			spawn.args[2] - Camera.pos.y - offset_y
+		)
+
+
+		if spawn.selected then
+			love.graphics.setColor(0,1,1,1)
+		else
+			love.graphics.setColor(0,1,0,1)
+		end
+
+		love.graphics.rectangle(
+			"line",
+			spawn.args[1] - Camera.pos.x - offset_x,
+			spawn.args[2] - Camera.pos.y - offset_y,
+			spawn.args[1] - Camera.pos.x + offset_x - (spawn.args[1] - Camera.pos.x - offset_x),
+			spawn.args[2] - Camera.pos.y + offset_y - (spawn.args[2] - Camera.pos.y - offset_y)
+		)
+
+		if spawn.selected then
+			local text = spawn.archetype.type.."\n---\nPosition\n["..spawn.args[1]..","..spawn.args[2].."]"
+			if #spawn.args > 2 then
+				text = text .. "\n---\nData:\n"
+				for i=3, #spawn.args do
+					if i > 3 then text = text .. ", " end
+					text = text .. tostring(spawn.args[i])
+				end
+			end
+			drawTextBox(
+				text,
+				spawn.args[1] - Camera.pos.x + 20,
+				spawn.args[2] - Camera.pos.y
+			)
+		end
+	end
+end

code/ui.lua

@@ -1,9 +1,44 @@
 UIElement = {}
 
-function AddElement(self)
+function addElement(self)
 	table.insert(UIElement,self)
 	self.id = #UIElement
 end
 
+function drawTextBox(text,x,y,style)
+	local style = style or {}
+	local c1, c2, c3, a = love.graphics.getColor()
+	local width = locale_font:getWidth(text)
+	local height = locale_font:getHeight(text)
+
+	local color = style.color or {1,1,1,1}
+	local background_color = style.background_color or {0,0,0,1}
+	local margin = style.margin or 5
+
+	local lines = 1
+	for i in text:gmatch("\n") do
+		lines = lines + 1
+	end
+
+	love.graphics.setColor(unpack(color))
+	love.graphics.rectangle("fill",
+		x-1,
+		y-1,
+		width+margin*2+2,
+		height*lines+margin*2+2
+	)
+	love.graphics.setColor(unpack(background_color))
+	love.graphics.rectangle("fill",
+		x,
+		y,
+		width+margin*2,
+		height*lines+margin*2
+	)
+	love.graphics.setColor(unpack(color))
+	love.graphics.print(text, x+margin, y+margin)
+	love.graphics.setColor(c1,c2,c3,a)
+end
+
 require "code/ui/button"
 require "code/ui/dialog"
+require "code/ui/prompt"

code/ui/button.lua

@@ -39,7 +39,7 @@ function InterfaceButton:new(x,y,w,h,table_values,value,style)
 		scale_proportion = 1.5
 	}
 
-	AddElement(o)
+	addElement(o)
 
 	setmetatable(o, self)
 	self.__index = self
@@ -71,7 +71,7 @@ function InterfaceButton:checkMouse(mouse_x, mouse_y)
 	end
 end
 
-function InterfaceButton:Draw()
+function InterfaceButton:draw()
 	local c1, c2, c3, a = love.graphics.getColor()
 
 	love.graphics.setColor(self.style.color[1],self.style.color[2],self.style.color[3],self.style.alpha)

code/ui/dialog.lua

@@ -29,7 +29,7 @@ function InterfaceDialog:new(style)
 		scale_proportion = 1
 	}
 
-	AddElement(o)
+	addElement(o)
 
 	setmetatable(o, self)
 	self.__index = self
@@ -65,7 +65,7 @@ function InterfaceDialog:checkConfirm()
 	end
 end
 
-function InterfaceDialog:Draw()
+function InterfaceDialog:draw()
 	local c1, c2, c3, a = love.graphics.getColor()
 
 	love.graphics.setColor(self.style.color[1],self.style.color[2],self.style.color[3],self.style.alpha)

code/ui/prompt.lua

@@ -0,0 +1,81 @@
+local utf8 = require("utf8")
+
+local function backspace(text)
+	local byteoffset = utf8.offset(text, -1)
+
+	if byteoffset then
+		-- remove the last UTF-8 character.
+		-- string.sub operates on bytes rather than UTF-8 characters,
+		-- so we couldn't do string.sub(text, 1, -2).
+		return string.sub(text, 1, byteoffset - 1)
+	end
+
+	return ""
+end
+
+Prompt = {
+	-- defaults for instance variables
+	pos = { x = 10, y = 10 },
+	input = "",
+	name = "input",
+	canceled = false,
+	closing = false,
+	color = {1,1,1,1},
+	background_color = {0,0,0,1},
+	active_prompt = nil,
+}
+function Prompt:cancelActive()
+	if Prompt.active_prompt then
+		Prompt.active_prompt.canceled = true
+	end
+end
+
+function Prompt:new(o)
+	o = o or {}
+	setmetatable(o, self)
+	self.__index = self
+	return o
+end
+
+function Prompt:keypressed(key, scancode, isrepeat)
+	if key == "backspace" then
+		self.input = backspace(self.input)
+	elseif key == "return" or key == "kpenter" or key == "escape" then
+		if key == "escape" then
+			self.canceled = true
+		end
+		self.closing = true
+		self:func()
+	end
+end
+
+function Prompt:update()
+
+end
+
+function Prompt:textinput(text)
+	self.input = self.input .. text
+end
+
+function Prompt:draw()
+	drawTextBox(
+		self.name .. ": " .. self.input,
+		self.pos.x,
+		self.pos.y,
+		{
+			color = self.color,
+			background_color = self.background_color
+		}
+	)
+end
+
+function Prompt:activate()
+	Prompt.active_prompt = self
+	love.keyboard.setTextInput(true)
+end
+
+-- demonstration of how default values work
+local test_prompt = Prompt:new()
+assert(test_prompt.name == "input")
+test_prompt.name = "foobar"
+assert(Prompt.name == "input")

data/animations.lua

@@ -35,11 +35,11 @@ animation.cursed_book.flying = {
 animation.cursed_book.spawn = {
 	path = "assets/entities/cursed_book/spawn",
 	frames = {
-		0,
-		0,
-		0,
-		0,
-		0
+		1/3,
+		1/3,
+		1/3,
+		1/3,
+		1/3
 	}
 }
 
@@ -140,6 +140,15 @@ animation.moth_mask.fall = {
 		1/8
 	}
 }
+
+animation.moth_mask.slide = {
+	path = "assets/entities/nancy/moth_mask/slide",
+	frames = {
+		1/8,
+		1/8,
+		1/8
+	}
+}
 animation.moth_mask.jump = {
 	path = "assets/entities/nancy/moth_mask/jump",
 	frames = {
@@ -179,6 +188,14 @@ animation.nancy.fall = {
 		1/8
 	}
 }
+animation.nancy.slide = {
+	path = "assets/entities/nancy/slide",
+	frames = {
+		1/8,
+		1/8,
+		1/8
+	}
+}
 animation.nancy.jump = {
 	path = "assets/entities/nancy/jump",
 	frames = {

data/dialog_sequences.lua

@@ -1,7 +1,7 @@
-DialogSequence = {}
+dialog_sequence = {}
 
-DialogSequence.Example = {
-	{Locale.dialogue.example[1],Locale.name.fairy},
-	{Locale.dialogue.example[2],Locale.name.chaos},
-	{Locale.dialogue.example[3],Locale.name.life}
+dialog_sequence.example = {
+	{locale.dialogue.example[1],locale.name.fairy},
+	{locale.dialogue.example[2],locale.name.chaos},
+	{locale.dialogue.example[3],locale.name.life}
 }

data/levels/level1.lua

@@ -1,32 +0,0 @@
-return {
-	name = "test",
-	tileset = tileset.library,
-	properties = {
-		darkness = true
-	},
-	tiles = {
-		{ 1, 4, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
-		{ 1, 4, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
-		{ 1, 4, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
-		{ 1, 4, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
-		{ 1, 4, 0, 0, 0, 2, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14},
-		{ 1, 4, 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},
-		{ 1, 4, 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},
-		{ 1, 4, 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},
-		{ 1, 4, 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},
-		{ 1, 4, 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},
-		{ 1, 13, 13, 13, 13, 13, 13, 4, 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},
-		{ 1, 1, 1, 1, 1, 1, 1, 4, 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},
-		{ 1, 1, 1, 1, 1, 1, 1, 4, 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},
-		{ 1, 1, 1, 1, 1, 1, 1, 4, 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},
-		{ 1, 1, 1, 1, 1, 1, 1, 4, 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},
-		{ 1, 1, 1, 1, 1, 1, 1, 4, 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},
-		{ 1, 1, 1, 1, 1, 1, 1, 4, 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},
-		{ 1, 1, 1, 1, 1, 1, 1, 4, 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},
-		{ 1, 1, 1, 1, 1, 1, 1, 4, 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},
-		{ 1, 1, 1, 1, 1, 1, 1, 4, 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},
-		{ 1, 1, 1, 1, 1, 1, 1, 4, 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},
-		{ 1, 1, 1, 1, 1, 1, 1, 4, 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}
-	},
-	objects = {}
-}

data/levels/level1/level.lua

@@ -0,0 +1 @@
+return {[ [[tileset]] ]=[[library]],[ [[chunks]] ]={[ 1 ]={[ 1 ]=[[global.lua]],},},[ [[name]] ]=[[unnamed]],[ [[properties]] ]={[ [[darkness]] ]=false,},}

data/locale/ENG.lua

@@ -1,16 +1,16 @@
-LocaleFont = love.graphics.getFont()
+locale_font = love.graphics.getFont()
 
-Locale = {}
+locale = {}
 
-Locale.ui = {}
-Locale.ui.pause_screen_resume = "Resume"
-Locale.ui.pause_screen_options = "Options"
-Locale.ui.pause_screen_exit = "Exit"
+locale.ui = {}
+locale.ui.pause_screen_resume = "Resume"
+locale.ui.pause_screen_options = "Options"
+locale.ui.pause_screen_exit = "Exit"
 
-Locale.name = {}
-Locale.name.fairy = "Ozy"
-Locale.name.chaos = "Aelato"
-Locale.name.life = "Olidia"
+locale.name = {}
+locale.name.fairy = "Ozy"
+locale.name.chaos = "Aelato"
+locale.name.life = "Olidia"
 
-Locale.dialogue = {}
-Locale.dialogue.example = {"Hello!","Duh.","Lol"}
+locale.dialogue = {}
+locale.dialogue.example = {"Hello!","Duh.","Lol"}

data/locale/HEON.lua

@@ -1,16 +1,16 @@
-LocaleFont = love.graphics.newFont("assets/ui/fonts/heon.ttf",18)
+locale_font = love.graphics.newFont("assets/ui/fonts/heon.ttf",18)
 
-Locale = {}
+locale = {}
 
-Locale.ui = {}
-Locale.ui.pause_screen_resume = ""
-Locale.ui.pause_screen_options = ""
-Locale.ui.pause_screen_exit = ""
+locale.ui = {}
+locale.ui.pause_screen_resume = ""
+locale.ui.pause_screen_options = ""
+locale.ui.pause_screen_exit = ""
 
-Locale.name = {}
-Locale.name.fairy = ""
-Locale.name.chaos = ""
-Locale.name.life = ""
+locale.name = {}
+locale.name.fairy = ""
+locale.name.chaos = ""
+locale.name.life = ""
 
-Locale.dialogue = {}
-Locale.dialogue.example = {"","",""}
+locale.dialogue = {}
+locale.dialogue.example = {"","",""}

data/shaders.lua

@@ -1,5 +1,5 @@
-Shader = {}
-Shader.RadiusGradient = love.graphics.newShader[[
+shader = {}
+shader.circle_gradient = love.graphics.newShader[[
 	uniform float pos_x;
 	uniform float pos_y;
 	uniform float range;

data/tiledata.lua

@@ -1,4 +1,4 @@
-levelProperties = {
+level_properties = {
 	pos = {
 		x = 0,
 		y = 0
@@ -15,7 +15,7 @@ tileset = {
 	library = love.graphics.newImage("assets/tileset/library.png")
 }
 
-tileProperties = {
+tile_properties = {
 	width = 16,
 	height = 16,
 	scale = 1,

main.lua

@@ -1,15 +1,17 @@
 function love.load()
 	logging = true
-	loveMemUsage = collectgarbage("count")
-	loveInitLog = "love: "..loveMemUsage.." kB, time: "..os.clock().." seconds"
-	arrow = 0
+	local love_mem_usage = collectgarbage("count")
+	local love_init_log = "love: "..love_mem_usage.." kB, time: "..os.clock().." seconds"
+
+	secs = 0
 
 	menu_type = "no"
+	-- FIXME: this overrides a standard library!
 	debug = false
 	debug_collision = false
-	editor_mode = false
+	--editor_mode = false
 
-	textScale = 1
+	text_size = 1
 
 
 	love.graphics.setColor(1,1,1)
@@ -17,7 +19,7 @@ function love.load()
 	love.graphics.setDefaultFilter("nearest") -- good pixel
 
 	game = {
-		secondsSinceStart = 0,
+		seconds_since_start = 0,
 		scale = 2,
 		width = love.graphics.getWidth(),
 		height = love.graphics.getHeight(),
@@ -29,77 +31,113 @@ function love.load()
 	fps_history = AvgQueue:new(30,60)
 
 
-	logPrint(loveInitLog)
-	loveInitLog = nil
+	logPrint(love_init_log)
+	love_init_log = nil
 
 	Camera.width = game.width
 	Camera.height = game.height
 
-	levelList = scandir("./data/levels")
-	levelNum = 1
-	currLevel = levelList[levelNum]
-	logPrint("currLevel: "..currLevel)
-	LoadedParticles = {}
-	LevelLoadTiles()
+	level_list = scandir("./data/levels")
+	level_current_num = 1
+	level_current = level_list[level_current_num]
+	logPrint("level_current: "..level_current)
+
+	loadLevelTiles()
 
 	language = "ENG"
-	LocaleLoad(language)
+	loadLocale(language)
 
 	gravity = 0.14
 	-- Debug and log stuff
-	memoryUsage, dtcount = 0, 0
+	memory_usage, dtcount = 0, 0
 	logPrint("mothback: "..collectgarbage("count").." kB, Loading time: "..os.clock().." seconds")
 
-	main_Player = Player:new(75,50)
-
-	--Kupo:new(100,150)
-	--Kupo:new(300,150)
-	HookAnchor:new(200,89)
-	HookAnchor:new(400,89)
-	Fairy:new(200,88)
-	--CursedBook:new(180,68)
+	main_player = Player:new(75,50)
 
+	activateSpawns()
 	--love.audio.play(music.placeholder)
 end
 
+function love.textinput(text)
+	if Prompt.active_prompt then
+		Prompt.active_prompt:textinput(text)
+	end
+end
+
+function love.keypressed(...)
+	if Prompt.active_prompt then
+		Prompt.active_prompt:keypressed(...)
+	end
+end
+
 function love.update(dt)
 	-- audio update
 	love.audio.update()
 	-- fps counter
-	fps_current = fps_history:Push(1/dt)
+	fps_current = fps_history:push(1/dt)
 
 	current_dt = dt
-	game.secondsSinceStart = game.secondsSinceStart + dt
+	game.seconds_since_start = game.seconds_since_start + dt
 
 	if DemoRecording or DemoPlayback then Demo:step()	end
 
 	-- things per second
 	dtcount = dtcount + dt
+	game.seconds_since_start = game.seconds_since_start + dt
 	if dtcount >= 1 then
-		if secs == nil then secs = 0 end
 		secs = secs + 1
 		dtcount = dtcount - 1
 		if debug or logging then
-			memoryUsage = math.floor(collectgarbage("count"))
+			memory_usage = math.floor(collectgarbage("count"))
 		end
-		logWrite("Second "..secs..": "..memoryUsage.." kB")
+		logWrite("Second "..secs..": "..memory_usage.." kB")
+	end
+
+	if Prompt.active_prompt then
+		-- try to stop the keypress that closed the menu from spilling into the rest of the game
+		Keybind:checkPressed(Keybind.menu.pause)
+		if Prompt.active_prompt.closing then
+			Prompt.active_prompt = nil
+		else
+			Prompt.active_prompt:update()
+		end
+		return
+	end
+
+	if Keybind:checkPressed(Keybind.debug.editor) then
+		if editor.active then
+			deselectSpawns()
+			createTileObjects()
+			restartGame()
+		end
+		editor.active = not editor.active
+	end
+
+	if love.keyboard.isDown("f7") then
+		local test_prompt = Prompt:new({
+			name = "test prompt",
+			func = function(prompt)
+				print("test prompt got input: "..prompt.input)
+			end,
+		})
+		test_prompt:activate()
 	end
 
 	--keypressed
-	if Keybind:CheckPressed(Keybind.menu.pause) then
+	if Keybind:checkPressed(Keybind.menu.pause) then
 		if do_pause then
 			do_pause = false
 		else
 			menu_type = "pause"
-			MenuInit(menu_type)
+			initMenu(menu_type)
 		end
 	end
 
 	--MenuStep
-	if menu_type ~= nil then MenuStep(menu_type) end
+	if menu_type ~= nil then stepMenu(menu_type) end
 
 	--editor
-	if editor_mode then
+	if editor.active then
 		stepEditor()
 	else
 		stepGame()
@@ -108,7 +146,7 @@ end
 
 
 function love.wheelmoved(_, y)
-	if editor_mode then
+	if editor.active then
 		scrollEditor(y)
 	end
 end
@@ -122,17 +160,21 @@ function love.draw()
 		game_resize = false
 	end
 
-	if editor_mode then
+	if editor.active then
 		drawEditor()
 	else
 		drawGame()
 	end
 
-	if menu_type ~= nil then MenuDraw(menu_type) end
+	if menu_type ~= nil then drawMenu(menu_type) end
 
 	love.graphics.print(game.scale,10,40)
 
 	if DemoRecording or DemoPlayback then Demo:draw() end
 
+	if Prompt.active_prompt then
+		Prompt.active_prompt:draw()
+	end
+
 	frameDebugFlush()
 end