fix fix

last commit

code/animation.lua

@@ -10,11 +10,17 @@ function Animation:new(anim_data,speed)
 	o.frame = 1
 	o.speed = speed or 1
 
+	o.was_updated = false
+
 	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
@@ -45,13 +51,17 @@ end
 
 -- to linearly animate
 function Animation:animate()
+	if self.was_updated then
+		self.was_updated = false
+	end
 	if self.frames[self.frame] ~= 0 then
 		-- try to animate
-		self.subframe = self.subframe + 1
+		self.subframe = self.subframe + self.speed
 
 		if self.subframe > self.frames[self.frame]*game.framerate then
 			self.subframe = self.subframe - self.frames[self.frame]*game.framerate
-			self.frame = self.frame + self.speed
+			self.frame = self.frame + 1
+			self.was_updated = true
 		end
 
 		-- cycle

code/camera.lua

@@ -1,36 +1,38 @@
 Camera = {
-	pos = {x = 0, y = 0},
+   pos = Point:new(0, 0),
-	width = 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:moveTowards(self:confineTo(room, pos))
-
-	self:confineTo(room)
 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/class.lua

@@ -0,0 +1,17 @@
+function class(super, self)
+	assert(super == nil or super.__index == super)
+	self = self or {}
+	self.__index = self
+	setmetatable(self, super)
+	return self
+end
+
+function getAncestors(self)
+	local family = self
+	local list = {}
+	while family ~= nil do
+		family = getmetatable(family)
+		table.insert(list,family)
+	end
+	return list
+end

code/collision.lua

@@ -1,4 +1,4 @@
-Collision = {}
+Collision = class()
 
 LoadedObjects.Collisions = {}
 LoadedObjects.Platforms = {}
@@ -48,7 +48,6 @@ function Collision:new(ox,oy,tx,ty)
 	end
 
 	setmetatable(o, self)
-	self.__index = self
 
 	return o
 end
@@ -88,3 +87,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/editor.lua

@@ -1,12 +1,37 @@
 assert(editor == nil)
 editor = {
+	active = false,
 	room_mode = false,
-	palette_mode = false
+	palette = {
+		active = false,
+		scroll = Point:new(0, 0),
+	},
+	multiselect = {
+		active = false,
+		sweeping = false,
+		box = nil,
+	},
+	pan = { fixed = false, speed = 3 },
 }
 
 function stepEditor()
-	editor.palette_mode = editor.palette_mode or false
+
 	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"
@@ -15,61 +40,33 @@ function stepEditor()
 		end
 		editor.room_points = {}
 	end
-
 	if Keybind:checkPressed(Keybind.editor.palette_mode) then
-		if editor.palette_mode then
+		editor.palette.active = not editor.palette.active
-			editor.palette_mode = false
-			palette_scroll_x = nil
-			palette_scroll_y = nil
-		else
-			editor.palette_mode = true
-			palette_scroll_x = 0
-			palette_scroll_y = 0
-		end
-	end
-
-	if Keybind:checkPressed(Keybind.editor.palette_mode) then
-		if editor.palette_mode then
-			editor.palette_mode = false
-			palette_scroll_x = nil
-			palette_scroll_y = nil
-		else
-			editor.palette_mode = true
-			palette_scroll_x = 0
-			palette_scroll_y = 0
-		end
 	end
 
 
-		if Keybind:checkPressed(Keybind.editor.palette_mode) then
+	local cvel = Point:new(0, 0)
-			if editor.palette_mode then
-				editor.palette_mode = false
-				palette_scroll_x = nil
-				palette_scroll_y = nil
-			else
-				editor.palette_mode = true
-				palette_scroll_x = 0
-				palette_scroll_y = 0
-			end
-		end
-
-	-- TODO:
-  -- i changed this but i dont know what was to do here.
-	-- - made specific action keybinds
 	if Keybind:checkDown(Keybind.editor.left) then
-		Camera.pos.x = Camera.pos.x - 3
+		cvel.x = -1
 	end
 	if Keybind:checkDown(Keybind.editor.right) then
-		Camera.pos.x = Camera.pos.x + 3
+		cvel.x = 1
 	end
 	if Keybind:checkDown(Keybind.editor.up) then
-		Camera.pos.y = Camera.pos.y - 3
+		cvel.y = -1
 	end
 	if Keybind:checkDown(Keybind.editor.down) then
-		Camera.pos.y = Camera.pos.y + 3
+		cvel.y = 1
 	end
 
-	if editor.palette_mode then
+	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
@@ -97,37 +94,32 @@ function stepEditor()
 
 	if Keybind:checkPressed(Keybind.editor.save) then
 		Prompt:new({
-			name = "level name",
+				name = "level name",
-			input = "unnamed",
+				input = "unnamed",
-			func = function(name_prompt)
+				func = function(name_prompt)
-				if name_prompt.canceled then return end
+					if name_prompt.canceled then return end
-				Prompt:new({
+					Prompt:new({
-					name = "filename",
+							name = "filename",
-					input = "level.lua",
+							input = "level.lua",
-					func = function(file_prompt)
+							func = function(file_prompt)
-						if file_prompt.canceled then return end
+								if file_prompt.canceled then return end
-						exportLevel(name_prompt.input, file_prompt.input)
+								exportLevel(name_prompt.input, file_prompt.input)
-					end,
+							end,
-				}):activate()
+					}):activate()
-			end,
+				end,
 		}):activate()
 	end
-
-	if Keybind:checkPressed(Keybind.debug.editor) then
-		editor_mode = not editor_mode
-		createTileObjects()
-	end
 end
 
 function scrollEditor(y)
-	if editor.palette_mode 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
@@ -138,14 +130,21 @@ function drawEditor()
 	drawGridDisplay()
 	drawGameworldForeground()
 	endGameworldDraw()
-	doEditorEdit()
 
 	drawEditorRooms()
+	drawSpawns()
+
+	doEditorEdit()
+
 	drawSelectingPaletteTile()
 
-	if editor.palette_mode 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()
@@ -169,8 +168,14 @@ function doEditorEdit()
 		 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))
+		drawTextBox(
-	love.graphics.print("> " .. level_width .. "(" .. expand_h .. "), " .. level_height .. "(".. expand_v .. ")", 0, 10)
+		 	"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 * tile_properties.width
@@ -194,27 +199,47 @@ function doEditorEdit()
 			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 editor.palette_mode 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)
+			if selecting_tile ~= nil then
-			and selecting_tile ~= nil
+				if Keybind:checkDown(Keybind.editor.tile_set) then
-			then
+					setTile(vertical,horizontal,selecting_tile)
-				setTile(vertical,horizontal,selecting_tile)
+				elseif Keybind:checkDown(Keybind.editor.tile_remove) then
-			elseif Keybind:checkDown(Keybind.generic.rclick) then
+					setTile(vertical,horizontal,0)
-				setTile(vertical,horizontal,0)
+				end
+				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
-			reloadLevelTiles()
-
 		elseif Keybind:checkPressed(Keybind.generic.lshift) then
 			expandLevelCanvas(math.sign(expand_h),math.sign(expand_v))
 			reloadLevelTiles()
@@ -245,27 +270,31 @@ function drawSelectingPaletteTile()
 end
 
 function doEditorPalette()
-
 	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) * (tile_properties.width+1),
+		(editor.palette.scroll.x + 1) * (tile_properties.width+1),
-		(palette_scroll_y + 1) * (tile_properties.height+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) * (tile_properties.width+1)
+		local tile_x = (editor.palette.scroll.x + position_x) * (tile_properties.width+1)
-		local tile_y = (palette_scroll_y + position_y) * (tile_properties.height+1)
+		local tile_y = (editor.palette.scroll.y + position_y) * (tile_properties.height+1)
 
 		love.graphics.draw(
 			LevelData.tileset,
@@ -276,18 +305,17 @@ 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
+		if 	mouse_x > (tile_x) * game.scale
-			and mouse_x < (tile_x + tile_properties.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) * game.scale
-			and mouse_y < (tile_y + tile_properties.height) * game.scale
+		and mouse_y < (tile_y + tile_properties.height) * game.scale
-			then
+		then
-				selecting_tile = position_x + ((position_y-1) * width)
+			hovering =  position_x + ((position_y-1) * width)
-
+			hov_x = tile_x
-				love.graphics.print(selecting_tile .. " | " .. tile_x .. ", " .. tile_y, 0, 20)
+			hov_y = tile_y
+			if Keybind:checkDown(Keybind.generic.lclick) then
+				selecting_tile = hovering
 			end
 		end
 
@@ -318,17 +346,47 @@ function doEditorPalette()
 
 	love.graphics.rectangle(
 		"line",
-		(palette_scroll_x + 1) * (tile_properties.width+1),
+		(editor.palette.scroll.x + 1) * (tile_properties.width+1),
-		(palette_scroll_y + 1) * (tile_properties.height+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.setColor(0,0,1,1)
-		love.graphics.rectangle("line",room.from.x-Camera.pos.x, room.from.y-Camera.pos.y, room.width, room.height)
+		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,5 +1,7 @@
-Arrow = Entity:new()
+Arrow = class(Entity, {
-Arrow.type = "Arrow"
+	type = "Arrow",
+	display = Animation:new(animation.kupo.arrow),
+})
 
 
 function Arrow:new(x,y,rotation,speed)
@@ -36,20 +38,30 @@ function Arrow:drawBackground()
 end
 
 function Arrow:doPhysics()
-	if not self:isCollidingAt(self.pos.x + self.vel.x, self.pos.y, LoadedObjects.Collisions) then
+	-- horizontal collision
-		self.pos.x = self.pos.x + self.vel.x
+	self:moveX(
-	else
+		self.vel.x,
-		self.stuck = true
+		function()
-	end
+			self.stuck = true
-	if not self:isCollidingAt(self.pos.x, self.pos.y + self.vel.y, LoadedObjects.Collisions) then
+		end
-		self.pos.y = self.pos.y + self.vel.y
+	)
-	else
+
-		self.stuck = true
+	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,5 +1,7 @@
-CursedBook = Entity:new()
+CursedBook = class(Entity, {
-CursedBook.type = "CursedBook"
+	type = "CursedBook",
+	display = Animation:new(animation.cursed_book.flying),
+})
 
 function CursedBook:new(x,y)
 	local o = Entity:new(x,y)
@@ -21,15 +23,18 @@ 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
+	local light_data = {}
-	o.light = Light:new(o.pos.x,o.pos.y,o.light_range,2,HEX2RGB("#fe00d1"))
+	light_data.radius = 500
-
+	light_data.shine_radius = 0
-	o:id()
+	light_data.flicker = nil
+	light_data.color = nil
+	o.light = Light:new(o.pos.x,o.pos.y,light_data)
 
 	setmetatable(o, self)
 	self.__index = self
@@ -37,18 +42,20 @@ function CursedBook:new(x,y)
 end
 
 function CursedBook:doLogic()
+	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
@@ -58,21 +65,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
+			self.body.speed = 1
-			local tint = 0.7 + 0.3 * (self.body.frame-1)/self.body.frames
+			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)
@@ -82,9 +97,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.body.speed = 1
-			self:centerOffset(self.body)
+			--self:centerOffset(self.body)
-			if self.body.frame == self.body.frames then
+			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)
@@ -96,15 +111,21 @@ function CursedBook:handleAnimation()
 end
 
 function CursedBook:doPhysics()
-	if self.isFlying then
+	-- horizontal collision
-		local random_x = math.random(-4, 4)/100
+	self:moveX(
-		local random_y = math.random(-4, 4)/100
+		self.vel.x,
-		self.vel.x = self.vel.x + random_x
+		function()
-		self.vel.y = self.vel.y + random_y
+			self.vel.x = 0
-	end
+		end
-	-- move
+	)
-
+	-- vertical collision
-	self:moveWithCollision()
+	self:moveY(
+		self.vel.y,
+		function()
+			self.vel.y = 0
+		end
+	)
+	-- final position
 	self:adjustLight()
 end
 
@@ -114,5 +135,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,22 +1,23 @@
-Decoration = Entity:new()
+Decoration = class(Entity, {
-Decoration.type = "Decoration"
+	type = "Decoration",
+	supertype = Entity.type,
+	display = Animation:new(animation.particle.simple),
+})
 
-function Decoration:new(x,y,animation,light_radius)
+function Decoration:new(x,y,animation,light_data)
 	local o = Entity:new(x,y)
 
 	o.pos = {x = x, y = y}
 
-	-- animations
+	if animation then
-	o.body = Animation:new(animation)
+		o.body = Animation:new(animation)
-	o:centerOffset(o.body)
+		o:centerOffset(o.body)
-	o:createBox(o.body)
+		o:createBox(o.body)
-
-	if light_radius ~= nil then
-		o.light_radius = light_radius
-		o.light = Light:new(o.pos.x,o.pos.y,o.light_radius)
 	end
 
-	o:id()
+	if light_data then
+		o.light = Light:new(o.pos.x,o.pos.y,light_data)
+	end
 
 	setmetatable(o, self)
 	self.__index = self
@@ -28,5 +29,4 @@ function Decoration:handleAnimation()
 	self:draw(self.body)
 end
 
-function Decoration:doPhysics()
+require "code/entities/decorations/candelabra"
-end

code/entities/decorations/candelabra.lua

@@ -0,0 +1,54 @@
+Candelabra = class(Decoration, {
+	type = "Candelabra",
+	display = Animation:new(animation.decoration.candelabra),
+})
+
+function Candelabra:new(x,y)
+	local light_data = {}
+	light_data.radius = 100
+	light_data.color = hex2rgb("#fed100")
+
+	local o =	Decoration:new(x,y,animation.decoration.candelabra,light_data)
+
+	o.particle_rate = 5
+	o.particle_count = 0
+
+	setmetatable(o, self)
+	self.__index = self
+	return o
+end
+
+function Candelabra:handleAnimation()
+	if self.body.was_updated then
+		self.particle_count = self.particle_count + 1
+		while self.particle_count >= self.particle_rate do
+			local pos = math.floor(math.random(1,3))-2
+
+			local particle_data = {}
+			particle_data.animation = animation.particle.simple
+			particle_data.sprite_tint = hex2rgb("#ffffff")
+			particle_data.sprite_alpha_fade = true
+			particle_data.direction = -math.rad(90)
+			particle_data.speed = 0.5 + math.random(2)*0.005
+			particle_data.time = 0.5+math.random(0.5)
+			particle_data.animation_speed = 1/particle_data.time
+
+			particle_data.func = function(self)
+				--COSINE WAVE FUNCTION
+				--init variables and constants
+				self.t = self.t or 0
+				self.phase = self.phase or math.random(2*math.pi)
+				local dt = 0.5
+				local amplitude = 0.5
+				local frequency = 0.5/game.framerate
+				--calc
+				self.t = self.t + dt
+				self:moveX(amplitude*math.cos(2*math.pi*frequency*self.t+self.phase))
+			end
+
+			Particle:new(self.pos.x+pos*5,self.pos.y-3,particle_data)
+			self.particle_count = self.particle_count - self.particle_rate
+		end
+	end
+	Decoration.handleAnimation(self)
+end

code/entities/fairy.lua

@@ -1,5 +1,7 @@
-Fairy = Entity:new()
+Fairy = class(Entity, {
-Fairy.type = "Fairy"
+	type = "Fairy",
+	display = Animation:new(animation.fairy.flying),
+})
 
 function Fairy:new(x,y)
 	local o = Entity:new(x,y)
@@ -10,7 +12,7 @@ function Fairy:new(x,y)
 	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)
@@ -18,22 +20,23 @@ function Fairy:new(x,y)
 	o:createBox(o.body)
 
 	-- light
-	o.light_radius = 80
+	local light_data = {}
-	o.light = Light:new(o.pos.x,o.pos.y,o.light_radius,nil,hex2rgb("#fed100"))
+	light_data.radius = 80
+	light_data.shine_radius = 80
+	light_data.flicker = nil
+	light_data.color = hex2rgb("#fed100")
+	o.light = Light:new(o.pos.x,o.pos.y,light_data)
 
 	-- timer
 	o.particle_timer = 0
 	o.particle_time = 5
 
-	o:id()
-
 	setmetatable(o, self)
 	self.__index = self
 	return o
 end
 
 function Fairy:doLogic()
-
 	if self:checkVisionLine(main_player,self.vision_range) then
 
 		self.target.x = main_player.pos.x + main_player.target_offset.x
@@ -41,8 +44,8 @@ function Fairy:doLogic()
 
 		local below = 1
 		while not isThereObjectAt(
-			self.target.x,
+			self.pos.x,
-			self.target.y + below * game.scale,
+			self.pos.y + below * game.scale,
 			LoadedObjects.Collisions
 		) do
 			below = below + 1
@@ -50,8 +53,8 @@ function Fairy:doLogic()
 		end
 		local top = 1
 		while not isThereObjectAt(
-			self.target.x,
+			self.pos.x,
-			self.target.y - top * game.scale,
+			self.pos.y - top * game.scale,
 			LoadedObjects.Collisions
 		) do
 			top = top + 1
@@ -62,31 +65,19 @@ 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
+		local random_x = math.random(-1, 1)
-		self.vel.y = self.vel.y * 0.9
+		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
+		local random_x = math.random(-6, 6)
-		self.vel.y = math.sin(angle)*self.speed
+		local random_y = math.random(-6, 6)
-	end
+		self.vel.x = math.cos(angle)*self.speed + random_x/10
-	self.particle_timer = self.particle_timer + 1
+		self.vel.y = math.sin(angle)*self.speed + random_y/10
-	if self.particle_timer >= self.particle_time then
-		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 = 0.8*(distance/50),
-			speed_increase = -0.01,
-			time = 0.75
-		}
-		Particle:new(self.pos.x,self.pos.y,particle_data)
 	end
 end
 
@@ -94,19 +85,45 @@ 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
 	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 = {}
+		particle_data.animation = animation.particle.simple
+		particle_data.animation_speed = 1
+		particle_data.sprite_tint = hex2rgb("#fed100")
+		particle_data.sprite_alpha_fade = true
+		particle_data.direction = angle-math.rad(180+math.random(60)-30)
+		particle_data.speed = 1
+		particle_data.time = 0.75
+		particle_data.func = function(self)
+				self.speed = self.speed - 0.01
+				self.vel.x = self.speed * math.cos(self.direction)
+				self.vel.y = self.speed * math.sin(self.direction)
+		end
+		Particle:new(self.pos.x,self.pos.y,particle_data)
+	end
 end
 
 function Fairy:doPhysics()
-	local random_x = math.random(-4, 4)/10
+	-- horizontal collision
-	local random_y = math.random(-4, 4)/10
+	self:moveX(
-
+		self.vel.x,
-	self.vel.x = self.vel.x + random_x
+		function()
-	self.vel.y = self.vel.y + random_y
+			self.vel.x = 0
-
+		end
-	self:moveWithCollision()
+	)
-	self.vel.x = 0
+	-- vertical collision
-	self.vel.y = 0
+	self:moveY(
-
+		self.vel.y,
+		function()
+			self.vel.y = 0
+		end
+	)
+	-- final position
 	self:adjustLight()
 end
 

code/entities/hook_anchor.lua

@@ -1,5 +1,7 @@
-HookAnchor = Entity:new()
+HookAnchor = class(Entity, {
-HookAnchor.type = "HookAnchor"
+	type = "HookAnchor",
+	display = Animation:new(animation.fairy.flying),
+})
 
 function HookAnchor:new(x,y,hook_distance)
 	local o = Entity:new(x,y)
@@ -12,8 +14,6 @@ function HookAnchor:new(x,y,hook_distance)
 	o:centerOffset(o.body)
 	o:createBox(o.body)
 
-	o:id()
-
 	setmetatable(o, self)
 	self.__index = self
 	return o
@@ -35,10 +35,6 @@ function HookAnchor:drawBackground()
 	)
 end
 
-function HookAnchor:doPhysics()
-end
-
-
 function Fairy:debug()
 	Entity.debug(self)
 end

code/entities/kupo.lua

@@ -1,5 +1,7 @@
-Kupo = Entity:new()
+Kupo = class(Entity, {
-Kupo.type = "Kupo"
+	type = "Kupo",
+	display = Animation:new(animation.kupo.body),
+})
 
 function Kupo:new(x,y)
 	local o = Entity:new(x,y)
@@ -26,10 +28,13 @@ function Kupo:new(x,y)
 	o.bow_aim_frames = 8
 	o.hostile = true
 
-	o.light_radius = o.range/2
+	-- light values
-	o.light = Light:new(o.pos.x,o.pos.y,o.light_radius)
+	local light_data = {}
-
+	light_data.radius = 100
-	o:id()
+	light_data.shine_radius = 20
+	light_data.flicker = nil
+	light_data.color = nil
+	o.light = Light:new(o.pos.x,o.pos.y,light_data)
 
 	setmetatable(o, self)
 	self.__index = self
@@ -43,8 +48,9 @@ function Kupo:doLogic()
 	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
@@ -152,7 +158,3 @@ function Kupo:handleAnimation()
 		)
 	end
 end
-
-function Kupo:doPhysics()
-	self:moveWithCollision()
-end

code/entities/particle.lua

@@ -1,7 +1,8 @@
 LoadedObjects.Particles = {}
-
+Particle = class(Entity, {
-Particle = Entity:new()
+	type = "Particle",
-Particle.type = "Particle"
+	display = Animation:new(animation.particle.simple),
+})
 
 function Particle:new(x,y,particle_data)
 	local o = Entity:new(x,y)
@@ -9,19 +10,26 @@ function Particle:new(x,y,particle_data)
 	o.pos = {x = x, y = y}
 
 	o.speed = particle_data.speed or 0
-	o.direction = particle_data.direction or o.direction
+	o.direction = particle_data.direction or 0
-	o.sprite_rotation = particle_data.sprite_rotation or o.sprite_rotation
+	o.sprite_rotation = particle_data.sprite_rotation or 0
-	o.sprite_offset = particle_data.sprite_offset or o.sprite_offset
+	o.sprite_offset = particle_data.sprite_offset or vector(0,0)
-	o.sprite_scale = particle_data.sprite_scale or o.sprite_scale
+	o.sprite_scale = particle_data.sprite_scale or vector(1,1)
-	o.sprite_tint = particle_data.sprite_tint or o.sprite_tint
+	o.sprite_tint = particle_data.sprite_tint or {1,1,1}
-	o.sprite_alpha = particle_data.sprite_alpha or o.sprite_alpha
+	o.sprite_alpha = particle_data.sprite_alpha or 1
 	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.sprite_flip = particle_data.sprite_flip or vector(1,1)
-
+	o.func = particle_data.func or nil
 	o.time = particle_data.time or nil
-	if o.time ~= nil then o.time = o.time * game.framerate end
 
+	if o.time 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 = {
@@ -29,44 +37,34 @@ function Particle:new(x,y,particle_data)
 		y = o.speed * math.sin(o.direction)
 	}
 
-	o.speed_increase = particle_data.speed_increase or 0
+	if particle_data.light then
-
+		local light_data = {}
-	if particle_data.light ~= nil then
+		light_data.radius = particle_data.light
-		o.light_range = particle_data.light
+		light_data.shine_radius = particle_data.light_shine or nil
-		local flicker = particle_data.light_flicker or nil
+		light_data.flicker = particle_data.light_flicer or nil
-		local color = particle_data.light_color or nil
+		light_data.color = particle_data.light_color or nil
-		o.light = Light:new(o.pos.x,o.pos.y,o.light_range,flicker,color)
+		o.light = Light:new(o.pos.x,o.pos.y,light_data)
 	end
 
 	-- animations
-	if particle_data.animation ~= nil then
+	if particle_data.animation then
 		o.body = Animation:new(particle_data.animation,particle_data.animation_speed)
 		o:centerOffset(o.body)
 		o:createBox(o.body)
 	end
 
-	-- particle id handled differently from other entities
+	table.remove(LoadedObjects.Entities,#LoadedObjects.Entities)
 	table.insert(LoadedObjects.Particles,o)
-	o.id = #LoadedObjects.Particles
-
 	setmetatable(o, self)
 	self.__index = self
 	return o
 end
 
 function Particle:kill()
-	if self.light ~= nil then
+	if self.light then
 		self.light:kill()
 	end
-	if self.id ~= nil then
+	self.dead = true
-		for _, e in pairs(LoadedObjects.Particles) do
-			if e.id > self.id then
-				e.id = e.id - 1
-			end
-		end
-		table.remove(LoadedObjects.Particles,self.id)
-	end
-	self = nil
 end
 
 function Particle:handleAnimation()
@@ -76,34 +74,59 @@ function Particle:handleAnimation()
 		self.sprite_alpha = self.sprite_alpha_base*(self.time-self.timer)/self.time
 	end
 
-	if self.body ~= nil then
+	if self.body then
 		self.body:animate()
 		self:draw(self.body)
 	end
 end
 
-function Particle:doPhysics()
+function Particle:doLogic()
-	-- adjust speed
+	if self.func then
-	if self.speed_increase ~= 0 then
+		self:func()
-		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.light ~= nil then
-		self:adjustLight()
-		self.light.range = self.light_range * self.sprite_alpha/2
 	end
 
-	if self.time ~= nil then
+	if self.time then
 		if self.timer >= self.time then self:kill() end
 	end
 end
 
+function cleanDeadParticles()
+	for i=1, #LoadedObjects.Particles do
+		part = LoadedObjects.Particles[i]
+		if part.kill then
+			table.remove(LoadedObjects.Particles,i)
+		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()
 	-- draw center CYAN
 	love.graphics.setColor(0,1,1)
 	love.graphics.circle("fill", -Camera.pos.x + self.pos.x, -Camera.pos.y + self.pos.y, 1)
 end
+
+---------------
+
+function cleanDeadParticles()
+	for i=1, #LoadedObjects.Particles do
+		part = LoadedObjects.Particles[i]
+		if part and part.dead then
+			table.remove(LoadedObjects.Particles,i)
+		end
+	end
+end
+
+---------------

code/entities/player.lua

@@ -1,5 +1,7 @@
-Player = Entity:new()
+Player = class(Entity, {
-Player.type = "Player"
+	type = "Player",
+	display = Animation:new(animation.nancy.idle),
+})
 
 function Player:new(x,y)
 	local o = Entity:new(x,y)
@@ -34,18 +36,12 @@ function Player:new(x,y)
 
 	-- hook values
 	o.hook_swing_speed = math.rad(0.05)
-	o.hook_anchor = {
+	o.hook_anchor = nil
-		x = nil,
-		y = nil
-	}
 
 	-- walljump values
 	o.walljump_nodrift_amount = 12
 	o.walljump_impulse = { x = 2.5, y = 3.5 }
 
-	-- light values
-	o.light_radius = 40 -- screen pixels
-
 	-- status
 	o.can_jump = true
 	o.can_fall = true
@@ -74,12 +70,15 @@ function Player:new(x,y)
 	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)
+	local light_data = {}
-
+	light_data.radius = 40
-	o:id()
+	light_data.shine_radius = 20
+	light_data.flicker = nil
+	light_data.color = nil
+	o.light = Light:new(o.pos.x,o.pos.y,light_data)
 
 	setmetatable(o, self)
 	self.__index = self
@@ -134,10 +133,13 @@ function Player:doLogic()
 		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.is_dashing = true
+			self.is_sliding = false
 			self.dash_count = self.dash_count - 1
 
 			-- get dash direction
@@ -154,7 +156,7 @@ function Player:doLogic()
 			end
 
 			-- set dash values
-			self.dashDirection = getAngleFromVector(horizontal, vertical)
+			self.dashDirection = getAngleFromVector(vector(horizontal, vertical))
 			self.dash_timer = math.floor(self.dash_time * game.framerate)
 		end
 	else
@@ -166,7 +168,7 @@ function Player:doLogic()
 		if self.is_hooked then
 			self:unhook()
 		else
-			local anchor = self:checkNearest("HookAnchor",self.hook_distance)
+			local anchor = self:checkNearest("HookAnchor","hook_specific")
 			if anchor then
 				self.is_hooked = true
 				self.hook_distance = anchor.hook_distance
@@ -231,10 +233,10 @@ function Player:doPhysics()
 	-- hook state
 	if self.is_hooked then
 		self.move_x = 0
-		local hook = vector(self.pos.x, self.pos.y, self.hook_anchor.x, self.hook_anchor.y)
+		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.hook_swing_speed
@@ -250,7 +252,8 @@ function Player:doPhysics()
 				animation_speed = 0,
 				sprite_tint = hex2rgb("#fed100"),
 				sprite_alpha = 0.5,
-				time = 0.05,
+				time = 4,
+				time_unit = "frames",
 				sprite_flip = {
 					x = self.sprite_flip.x,
 					y = self.sprite_flip.y
@@ -262,8 +265,13 @@ function Player:doPhysics()
 			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
 
 
@@ -274,24 +282,26 @@ function Player:doPhysics()
 	end
 
 	-- horizontal collision
-	if not self:isCollidingAt(self.pos.x + self.vel.x, self.pos.y, LoadedObjects.Collisions) then
+	self.wall_hit = 0
-		self.pos.x = self.pos.x + self.vel.x
+	self:moveX(
-		self.wall_hit = 0
+		self.vel.x,
-	else
+		function()
-		self.wall_hit = math.sign(self.vel.x)
+			self.wall_hit = math.sign(self.vel.x)
-		self.vel.x = 0
+			self.vel.x = 0
-	end
+		end
+	)
 
 	-- vertical collision
-	if not self:isCollidingAt(self.pos.x, self.pos.y + self.vel.y, LoadedObjects.Collisions) then
+	self:moveY(
-		self.pos.y = self.pos.y + self.vel.y
+		self.vel.y,
-	else
+		function()
-		if self.vel.y > 0 then
+			if self.vel.y > 0 then
-			self.is_on_ground = true
+				self.is_on_ground = true
-			self.dash_count = self.dash_amount
+				self.dash_count = self.dash_amount
+			end
+			self.vel.y = 0
 		end
-		self.vel.y = 0
+	)
-	end
 
 	-- if u collision w hazard, respawn
 	if self:isCollidingAt(self.pos.x, self.pos.y, LoadedObjects.Hazards) then
@@ -315,18 +325,20 @@ function Player:handleAnimation()
 	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.is_sliding 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.mask_type.fall)
 	elseif self.vel.y < 0 then
 		self.body = self.body:change(animation.nancy.jump)
 		self.mask = self.mask:change(self.mask_type.jump)
-	elseif self.vel.x + self.move_x ~= 0 then
+	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.mask_type.run)
-	else
+	elseif not self.is_hooked then
 		self.body = self.body:change(animation.nancy.idle)
 		self.mask = self.mask:change(self.mask_type.idle)
 	end
@@ -359,6 +371,7 @@ end
 function Player:unhook()
 	self.is_hooked = false
 	self.hook_anchor = nil
+	self.hook_distance = nil
 end
 
 function Player:debug()

code/entity.lua

@@ -1,10 +1,11 @@
-Entity = {class = "Entity"}
 LoadedObjects.Entities = {}
+Entity = class(nil, {type = "Entity"})
 
 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
@@ -22,63 +23,92 @@ function Entity:new(x,y)
 	o.sprite_tint = {1,1,1}
 	o.sprite_alpha = 1
 	o.sprite_flip = { x = 1, y = 1}
-	o.illuminated = false
 
+	table.insert(LoadedObjects.Entities,o)
 	setmetatable(o, self)
 	self.__index = self
-
 	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
 end
 
-function Entity:doLogic()
+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:move()
+function Entity:moveY(amount, func)
-	self.pos.x = self.pos.x + self.vel.x
+	self.move_remainder.y = self.move_remainder.y + amount
-	self.pos.y = self.pos.y + self.vel.y
+	local move = math.round(self.move_remainder.y)
-end
+  if move ~= 0 then
-
+    self.move_remainder.y = self.move_remainder.y - move
-function Entity:moveWithCollision()
+    local sign = math.sign(move)
-	local r = false
+ 		while math.round(move) ~= 0 do
-	if not self:isCollidingAt(self.pos.x + self.vel.x, self.pos.y, LoadedObjects.Collisions) then
+    	if not self:isCollidingAt(
-		self.pos.x = self.pos.x + self.vel.x
+				self.pos.x,
-	else
+				self.pos.y + sign,
-		self.vel.x = 0
+				LoadedObjects.Collisions
-		r = true
+			) then
+        self.pos.y = self.pos.y + sign
+				move = move - sign
+				if tostring(move) == "nan" then error() end
+      else
+        if func then
+          func()
+				end
+				break
+			end
+		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)
@@ -94,15 +124,7 @@ function Entity:kill()
 	if self.light ~= nil then
 		self.light:kill()
 	end
-	if self.id ~= nil then
+	self.dead = true
-		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
 
 function Entity:checkVisionLine(entity,range)
@@ -111,8 +133,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
@@ -134,6 +157,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(
@@ -147,6 +171,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
@@ -154,6 +179,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
@@ -215,8 +241,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
@@ -265,12 +292,31 @@ function Entity:debug()
 	end
 end
 
+function Entity:doLogic()
+end
+
+function Entity:doPhysics()
+end
+
 function Entity:handleAnimation()
 end
 
 function Entity:drawBackground()
 end
 
+---------------
+
+function cleanDeadEntities()
+	for i=1, #LoadedObjects.Entities do
+		enty = LoadedObjects.Entities[i]
+		if enty and enty.dead then
+			table.remove(LoadedObjects.Entities,i)
+		end
+	end
+end
+
+---------------
+
 require "code/entities/kupo"
 require "code/entities/arrow"
 require "code/entities/decoration"

code/game.lua

@@ -1,3 +1,14 @@
+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
@@ -33,13 +44,7 @@ function stepGame()
 	end
 
 	if Keybind:checkPressed(Keybind.debug.reposition) then
-		if not editor_mode then
+		restartGame()
-			main_player.pos.x, main_player.pos.y = 75,50
-		end
-		for _, entity in pairs(LoadedObjects.Entities) do
-			if entity.id ~= main_player.id then entity:kill() end
-		end
-		activateSpawns()
 	end
 
 	if Keybind:checkPressed(Keybind.debug.reload) then
@@ -48,10 +53,6 @@ function stepGame()
 			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 DemoRecording then
 			Demo:endRecord()
@@ -67,6 +68,10 @@ function stepGame()
 			Demo:startPlayback()
 		end
 	end
+
+	cleanDeadParticles()
+	cleanDeadEntities()
+	cleanDeadLights()
 end
 
 function drawGame()

code/gameworld.lua

@@ -79,19 +79,7 @@ function drawGameworldDarkness()
 	love.graphics.setBlendMode("replace")
 	love.graphics.setColor(0,0,0,0)
 	for _, light in pairs(LoadedObjects.Lights) do
-		if light.range ~= 0 then
+		light:drawClear()
-			local position = {
-				x = (light.pos.x - Camera.pos.x) / game.scale,
-				y = (light.pos.y - Camera.pos.y) / game.scale
-			}
-			local range = (light.range + light.flicker_value) / game.scale
-			love.graphics.circle(
-					"fill",
-					position.x,
-					position.y,
-					range
-				)
-		end
 	end
 	Canvas.Darkness:endDrawing()
 	Canvas.Darkness:draw()
@@ -99,23 +87,7 @@ end
 
 function drawGameworldLights()
 	for _, light in pairs(LoadedObjects.Lights) do
-		if light.range ~= 0 then
+		light:drawShine()
-			love.graphics.setColor(light.color[1],light.color[2],light.color[3],1)
-
-			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.circle_gradient)
-			love.graphics.circle(
-				"fill",
-				- Camera.pos.x + light.pos.x,
-				- Camera.pos.y + light.pos.y,
-				light.range
-			)
-			love.graphics.setShader()
-		end
 	end
 end
 

code/keybind.lua

@@ -17,6 +17,10 @@ Keybind.debug = {}
 Keybind.editor = {}
 Keybind.generic = {}
 
+function Keybind:isAvailable(action)
+	return not action.occupied
+end
+
 function Keybind:checkDown(action)
 	if DemoPlayback then
 		for _, demo_action in pairs(DemoAction[CurrentDemoFrame]) do
@@ -37,9 +41,11 @@ 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
@@ -123,11 +129,19 @@ function Keybind:default()
 	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
 

code/lights.lua

@@ -1,41 +1,30 @@
-Light = {}
+Light = class(nil, {
+	type = "Light"
+})
 LoadedObjects.Lights = {}
 
-function Light:new(x,y,range,flicker,color,lum)
+function Light:new(x,y,data)
 	local o = {}
 	o.pos = {
 		x = x,
 		y = y
 	}
-	o.range = range
+	o.radius = data.radius
-	o.lum = lum or 1
+	o.shine_radius = data.shine_radius or 0
-	o.color = color or {1,1,1}
+	o.lum = data.lum or 1
-	o.flicker_amount = flicker or 2
+	o.color = data.color or {1,1,1}
+	o.flicker_amount = data.flicker or 2
 	o.flicker_value = 0
 	o.dim = 0
 	o.flicker_time = 60/12
 	o.flicker_timer = 0
 
-	table.insert(LoadedObjects.Lights,o)
-	o.id = #LoadedObjects.Lights
-
 	setmetatable(o, self)
 	self.__index = self
+	table.insert(LoadedObjects.Lights,o)
 	return o
 end
 
-function Light:kill()
-	if self.id ~= nil then
-		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
-
 function Light:flicker()
 	self.flicker_timer = self.flicker_timer + 1
 
@@ -45,3 +34,56 @@ function Light:flicker()
 		self.flicker_value = math.min(math.max(self.flicker_value, -self.flicker_amount), self.flicker_amount)
 	end
 end
+
+function Light:drawClear()
+	if self.radius ~= 0 then
+		local position = {
+			x = (self.pos.x - Camera.pos.x) / game.scale,
+			y = (self.pos.y - Camera.pos.y) / game.scale
+		}
+		local radius = (self.radius + self.flicker_value) / game.scale
+		love.graphics.circle(
+				"fill",
+				position.x,
+				position.y,
+				radius
+			)
+	end
+end
+
+function Light:drawShine()
+	if self.radius ~= 0 then
+		love.graphics.setColor(self.color[1],self.color[2],self.color[3],1)
+
+		shader.circle_gradient:send("pos_x",- Camera.pos.x + self.pos.x)
+		shader.circle_gradient:send("pos_y",- Camera.pos.y + self.pos.y)
+		shader.circle_gradient:send("radius",self.shine_radius)
+		shader.circle_gradient:send("scale",game.scale)
+
+		love.graphics.setShader(shader.circle_gradient)
+		love.graphics.circle(
+			"fill",
+			- Camera.pos.x + self.pos.x,
+			- Camera.pos.y + self.pos.y,
+			self.radius
+		)
+		love.graphics.setShader()
+	end
+end
+
+function Light:kill()
+	self.dead = true
+end
+
+---------------
+
+function cleanDeadLights()
+	for i=1, #LoadedObjects.Lights do
+		light = LoadedObjects.Lights[i]
+		if light and light.dead then
+			table.remove(LoadedObjects.Lights,i)
+		end
+	end
+end
+
+---------------

code/math.lua

@@ -8,20 +8,22 @@ function math.sign(x)
 	end
 end
 
-function vector(init_x, init_y, final_x, final_y)
+function math.round(x)
-	local distance_x = final_x - init_x
+	return math.floor(x+0.5)
-	local distance_y = final_y - init_y
+end
-	return {distance_x, distance_y}
+
+function vector(x, y)
+	return {x = x, y = y}
 end
 
 function getVectorValue(vector)
-	return math.sqrt(vector[1] ^ 2 + vector[2] ^ 2)
+	return math.sqrt(vector.x ^ 2 + vector.y ^ 2)
 end
 
-function getAngleFromVector(x,y)
+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/objects.lua

@@ -25,10 +25,7 @@ function isThereObjectAt(x,y,objectType)
 	for _, object in pairs(objectType) do
 		if object.is_disabled then
 			-- Dont calculate if dissabled
-		elseif x >= object.from.x
+		elseif object:asRect():containsPoint(Point:new(x, y)) then
-		and x <= object.to.x
-		and y >= object.from.y
-		and y <= object.to.y then
 			object.is_colliding = true
 			return true
 		end
@@ -36,14 +33,6 @@ function isThereObjectAt(x,y,objectType)
 	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 = {

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/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,15 @@ require "data/sfx"
 require "code/locale"
 
 -- support functions
+require "code/class"
 require "code/math"
 require "code/draw"
 require "code/hex"
 require "code/in_out"
 
 -- classes
+require "code/point"
+require "code/rect"
 require "code/objects"
 require "code/level"
 require "code/camera"

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

@@ -10,6 +10,259 @@ end
 
 function activateSpawns()
 	for _, spawn in pairs(LoadedObjects.Spawns) do
-			spawn.archetype:new(unpack(spawn.args))
+		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("
+			local ancestors = getAncestors(spawn.archetype)
+			for i=1, #ancestors do
+				if i > 1 then text = text .. ", " end
+				text = text .. ancestors[i].type
+			end
+			text = text ..")\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

@@ -5,6 +5,40 @@ function addElement(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/prompt.lua

@@ -4,30 +4,35 @@ local function backspace(text)
 	local byteoffset = utf8.offset(text, -1)
 
 	if byteoffset then
-			-- remove the last UTF-8 character.
+		-- remove the last UTF-8 character.
-			-- string.sub operates on bytes rather than UTF-8 characters,
+		-- string.sub operates on bytes rather than UTF-8 characters,
-			-- so we couldn't do string.sub(text, 1, -2).
+		-- so we couldn't do string.sub(text, 1, -2).
-			return string.sub(text, 1, byteoffset - 1)
+		return string.sub(text, 1, byteoffset - 1)
 	end
-	
+
 	return ""
 end
 
-Prompt = {
+Prompt = class(nil, {
 	-- 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
 
@@ -44,7 +49,7 @@ function Prompt:keypressed(key, scancode, isrepeat)
 end
 
 function Prompt:update()
-	
+
 end
 
 function Prompt:textinput(text)
@@ -52,7 +57,15 @@ function Prompt:textinput(text)
 end
 
 function Prompt:draw()
-	love.graphics.print(self.name .. ": " .. self.input, self.pos.x, self.pos.y)
+	drawTextBox(
+		self.name .. ": " .. self.input,
+		self.pos.x,
+		self.pos.y,
+		{
+			color = self.color,
+			background_color = self.background_color
+		}
+	)
 end
 
 function Prompt:activate()
@@ -65,4 +78,3 @@ 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,
+		1/3,
-		0,
+		1/3,
-		0,
+		1/3,
-		0,
+		1/3,
-		0
+		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/levels/level1.lua

@@ -2,7 +2,7 @@ return {
 	name = "Dev Level",
 	tileset = tileset.library,
 	properties = {
-		darkness = false
+		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},
@@ -32,7 +32,8 @@ return {
 		spawns = {
 			{Fairy,{100,88}},
 			{HookAnchor,{200,89,100}},
-			{HookAnchor,{400,89,120}}
+			{HookAnchor,{400,89,120}},
+			{Candelabra,{328,297}}
 		},
 		rooms = {
 			{{96,64},{544,320}},

data/shaders.lua

@@ -2,7 +2,7 @@ shader = {}
 shader.circle_gradient = love.graphics.newShader[[
 	uniform float pos_x;
 	uniform float pos_y;
-	uniform float range;
+	uniform float radius;
 	uniform float scale;
 
 	vec4 effect(vec4 color, Image texture, vec2 texture_coords, vec2 screen_coords ){
@@ -12,11 +12,13 @@ shader.circle_gradient = love.graphics.newShader[[
 		float distance_x = pos_x - screen_coords.x / scale;
 		float distance_y = pos_y - screen_coords.y / scale;
 		float distance = sqrt( pow(distance_x,2) + pow(distance_y,2) ) ;
-		if (distance < range){
+		if (distance < radius){
-			float alpha = 1-(5*distance/range);
+			float alpha = 1-(5*distance/radius);
 			if (pixel.a > alpha){
 				pixel.a = alpha;
 			}
+		}	else {
+			pixel.a = 0;
 		}
 		return pixel * color * color;
 	}

main.lua

@@ -6,9 +6,10 @@ function love.load()
 	secs = 0
 
 	menu_type = "no"
+	-- FIXME: this overrides a standard library!
 	debug = false
 	debug_collision = false
-	editor_mode = false
+	--editor_mode = false
 
 	text_size = 1
 
@@ -103,6 +104,15 @@ function love.update(dt)
 		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",
@@ -127,7 +137,7 @@ function love.update(dt)
 	if menu_type ~= nil then stepMenu(menu_type) end
 
 	--editor
-	if editor_mode then
+	if editor.active then
 		stepEditor()
 	else
 		stepGame()
@@ -136,7 +146,7 @@ end
 
 
 function love.wheelmoved(_, y)
-	if editor_mode then
+	if editor.active then
 		scrollEditor(y)
 	end
 end
@@ -150,7 +160,7 @@ function love.draw()
 		game_resize = false
 	end
 
-	if editor_mode then
+	if editor.active then
 		drawEditor()
 	else
 		drawGame()