local debug = false local cavern = {} local tiletypes = {unknown = 0, empty = 1, wall = 2, orb = 3} local visibility_map = {} local remembered_cavern = {} local spawn_x = nil local spawn_y = nil local directions = {up = 0, upleft = 1, left = 2, downleft = 3, down = 4, downright = 5, right = 6, upright = 7} local player_x = nil local player_y = nil local player_direction = nil local last_key_pressed = nil local last_direction_moved = nil local move_repeat_counter = nil local gamemodes = {normal = 0, won = 1, config = 2} local game_mode = gamemodes.normal local configuration_steps = {quit = -3, restart = -2, configure = -1} local configuration_step = nil local direction_keys = {} direction_keys['i'] = directions.up direction_keys['u'] = directions.upleft direction_keys['j'] = directions.left direction_keys['m'] = directions.downleft direction_keys['k'] = directions.down direction_keys['.'] = directions.downright direction_keys['l'] = directions.right direction_keys['o'] = directions.upright local control_keys = {quit = 'q', restart = 'r', configure = 'c'} local win_image = nil -- ------------------------------------------------------------------ -- Cavern generation -- ------------------------------------------------------------------ function generateCavern() repeat cavern = {} cavern.width = 80 cavern.height = 60 -- Create a cavern.width × cavern.height array filled with tiletypes.unknown for x = 1, cavern.width do local list = {} for y = 1, cavern.height do table.insert(list, tiletypes.unknown) end table.insert(cavern, list) end -- Fill top and bottom edges with walls for x = 1, cavern.width do cavern[x][1] = tiletypes.wall cavern[x][cavern.height] = tiletypes.wall end -- Fill the left and right edges with walls for y = 1, cavern.height do cavern[1][y] = tiletypes.wall cavern[cavern.width][y] = tiletypes.wall end local queue = {} local size = 1 -- Limit spawn to locations not on the edge walls spawn_x = math.random(2, cavern.width - 1) spawn_y = math.random(2, cavern.height - 1) cavern[spawn_x][spawn_y] = tiletypes.empty table.insert(queue, {x = spawn_x, y = spawn_y - 1}) table.insert(queue, {x = spawn_x, y = spawn_y + 1}) table.insert(queue, {x = spawn_x - 1, y = spawn_y}) table.insert(queue, {x = spawn_x + 1, y = spawn_y}) repeat queue, size = stepCavernGeneration(queue, size) until #queue == 0 until size > 200 end function stepCavernGeneration(queue, size) -- Tuning this parameter will change how open and cavernous vs. closed and corridory the -- cavern will be local spread_probability = 0.6 local new_queue = {} local new_size = size for i, location in ipairs(queue) do if cavern[location.x][location.y] == tiletypes.unknown then -- We haven't covered this tile yet if math.random() < spread_probability then -- Empty cavern[location.x][location.y] = tiletypes.empty size = size + 1 -- Up if location.y - 1 >= 1 then table.insert(new_queue, {x = location.x, y = location.y - 1}) end -- Down if location.y + 1 <= cavern.height then table.insert(new_queue, {x = location.x, y = location.y + 1}) end -- Left if location.x - 1 >= 1 then table.insert(new_queue, {x = location.x - 1, y = location.y}) end -- Right if location.x + 1 <= cavern.width then table.insert(new_queue, {x = location.x + 1, y = location.y}) end else -- Wall cavern[location.x][location.y] = tiletypes.wall end end end return new_queue, size end -- ------------------------------------------------------------------ -- Spawning objects -- ------------------------------------------------------------------ function spawnPlayer() player_x = spawn_x player_y = spawn_y -- Check what direction we can spawn the player if passable(player_x, player_y + 1) then -- There's space under, spawn facing up player_direction = directions.up elseif passable(player_x + 1, player_y) then -- There's space to the right, spawn facing left player_direction = directions.left elseif passable(player_x - 1, player_y) then -- There's space to the left, spawn facing right player_direction = directions.right elseif passable(player_x, player_y - 1) then -- There's space above, spawn facing down player_direction = directions.down else error("Cavern is weirdly generated and player cannot spawn") end end function spawnOrb() local orb_x = nil local orb_y = nil repeat orb_x = math.random(2, cavern.width - 1) orb_y = math.random(2, cavern.height - 1) until passable(orb_x, orb_y) cavern[orb_x][orb_y] = tiletypes.orb end -- ------------------------------------------------------------------ -- Visibility -- ------------------------------------------------------------------ function generateVisibilityMap() -- Start by creating a new visibility map (since we'll have to recompute everything anyways) visibility_map = {} for x = 1, cavern.width do local list = {} for y = 1, cavern.height do table.insert(list, false) end table.insert(visibility_map, list) end -- Handle visibility from the head local queue = {} visibility_map[player_x][player_y] = true if player_direction == directions.up then -- ⌜^⌝ -- table.insert(queue, {x = player_x - 1, y = player_y - 1, direction = directions.upleft}) table.insert(queue, {x = player_x, y = player_y - 1, direction = directions.up}) table.insert(queue, {x = player_x + 1, y = player_y - 1, direction = directions.upright}) table.insert(queue, {x = player_x - 1, y = player_y, direction = directions.left}) table.insert(queue, {x = player_x + 1, y = player_y, direction = directions.right}) elseif player_direction == directions.left then -- ⌜^ -- -- ⌞v⌟ table.insert(queue, {x = player_x - 1, y = player_y, direction = directions.left}) table.insert(queue, {x = player_x + 1, y = player_y, direction = directions.right}) table.insert(queue, {x = player_x - 1, y = player_y + 1, direction = directions.downleft}) table.insert(queue, {x = player_x, y = player_y + 1, direction = directions.down}) table.insert(queue, {x = player_x + 1, y = player_y + 1, direction = directions.downright}) elseif player_direction == directions.right then -- ^⌝ -- o> -- v⌟ table.insert(queue, {x = player_x, y = player_y - 1, direction = directions.up}) table.insert(queue, {x = player_x + 1, y = player_y - 1, direction = directions.upright}) table.insert(queue, {x = player_x + 1, y = player_y, direction = directions.right}) table.insert(queue, {x = player_x, y = player_y + 1, direction = directions.down}) table.insert(queue, {x = player_x + 1, y = player_y + 1, direction = directions.downright}) else error("Player facing an impossible direction") end repeat queue = stepVisibilityMapGeneration(queue) until #queue == 0 -- Handle "visibility" from the feet local body_x, body_y = getBodyLocation() visibility_map[body_x][body_y] = true if player_direction == directions.up then -- -- v visibility_map[body_x - 1][body_y] = true visibility_map[body_x + 1][body_y] = true visibility_map[body_x][body_y + 1] = true elseif player_direction == directions.left then -- ^ -- x> -- v visibility_map[body_x][body_y - 1] = true visibility_map[body_x + 1][body_y] = true visibility_map[body_x][body_y + 1] = true elseif player_direction == directions.down then -- ^ -- visibility_map[body_x][body_y - 1] = true visibility_map[body_x - 1][body_y] = true visibility_map[body_x + 1][body_y] = true elseif player_direction == directions.right then -- ^ -- -- v⌟ table.insert(new_queue, {x = item.x + 1, y = item.y, direction = directions.right}) table.insert(new_queue, {x = item.x, y = item.y + 1, direction = directions.down}) table.insert(new_queue, {x = item.x + 1, y = item.y + 1, direction = directions.downright}) end end elseif item.direction == directions.upright then -- See under item.direction == directions.upleft if passable(item.x - 1, item.y) or passable(item.x, item.y + 1) then visibility_map[item.x][item.y] = true if passable(item.x, item.y) then -- ^⌝ -- ⌝ x> table.insert(new_queue, {x = item.x, y = item.y - 1, direction = directions.up}) table.insert(new_queue, {x = item.x + 1, y = item.y - 1, direction = directions.upright}) table.insert(new_queue, {x = item.x + 1, y = item.y, direction = directions.right}) end end else error("Visibility floodfill item travelling in an impossible direction") end end return new_queue end function initializeRememberedCavern() remembered_cavern = {} for x = 1, cavern.width do local list = {} for y = 1, cavern.height do table.insert(list, nil) end table.insert(remembered_cavern, list) end end function rememberVisible() for x, list in ipairs(visibility_map) do for y, visible in ipairs(list) do if visible then remembered_cavern[x][y] = cavern[x][y] end end end end -- ------------------------------------------------------------------ -- Collision -- ------------------------------------------------------------------ function passable(x, y) return cavern[x][y] == tiletypes.empty or cavern[x][y] == tiletypes.orb end function collidedPlayerOrb() local body_x, body_y = getBodyLocation() return cavern[player_x][player_y] == tiletypes.orb or cavern[body_x][body_y] == tiletypes.orb end -- ------------------------------------------------------------------ -- Player helper functions -- ------------------------------------------------------------------ function getBodyLocation(x, y, facing) if x == nil then x = player_x end if y == nil then y = player_y end if facing == nil then facing = player_direction end if facing == directions.up then -- Facing up, body is down return x, y + 1 elseif facing == directions.left then -- Facing left, body is right return x + 1, y elseif facing == directions.down then -- Facing down, body is up return x, y - 1 elseif facing == directions.right then -- Facing right, body is left return x - 1, y else error("Player facing an impossible direction") end end function movePlayer(direction) local dx = 0 local dy = 0 local new_direction = direction -- If we are moving backwards, keep the old direction of facing if player_direction == directions.up and direction == directions.down or player_direction == directions.down and direction == directions.up or player_direction == directions.left and direction == directions.right or player_direction == directions.right and direction == directions.left then new_direction = player_direction end if direction == directions.up then dy = -1 elseif direction == directions.down then dy = 1 elseif direction == directions.left then dx = -1 elseif direction == directions.right then dx = 1 elseif direction == directions.upleft then if player_direction == directions.up then dx = -1 new_direction = directions.left elseif player_direction == directions.left then dy = -1 new_direction = directions.up elseif player_direction == directions.down then -- ## ## -- x# xo# -- #o# # # dy = -1 new_direction = directions.right elseif player_direction == directions.right then -- # # #x# -- #xo #o -- ## ## dx = -1 new_direction = directions.down else error("Player facing an impossible direction") end elseif direction == directions.downleft then if player_direction == directions.up then -- #o# # # -- x# xo# -- ## ## dy = 1 new_direction = directions.right elseif player_direction == directions.left then dy = 1 new_direction = directions.down elseif player_direction == directions.down then dx = -1 new_direction = directions.left elseif player_direction == directions.right then -- ## ## -- #xo #o -- # # #x# dx = -1 new_direction = directions.up else error("Player facing an impossible direction") end elseif direction == directions.downright then if player_direction == directions.up then -- #o# # # -- #x #ox -- ## ## dy = 1 new_direction = directions.left elseif player_direction == directions.left then -- ## ## -- ox# o# -- # # #x# dx = 1 new_direction = directions.up elseif player_direction == directions.down then dx = 1 new_direction = directions.right elseif player_direction == directions.right then dy = 1 new_direction = directions.down else error("Player facing an impossible direction") end elseif direction == directions.upright then if player_direction == directions.up then dx = 1 new_direction = directions.right elseif player_direction == directions.left then -- # # #x# -- ox# o# -- ## ## dx = 1 new_direction = directions.down elseif player_direction == directions.down then -- ## ## -- #x #ox -- #o# # # dy = -1 new_direction = directions.left elseif player_direction == directions.right then dy = -1 new_direction = directions.up else error("Player facing an impossible direction") end else error("Player moving in an impossible direction") end local body_x, body_y = getBodyLocation(player_x + dx, player_y + dy, new_direction) if passable(player_x + dx, player_y + dy) and passable(body_x, body_y) then player_x = player_x + dx player_y = player_y + dy player_direction = new_direction end end -- ------------------------------------------------------------------ -- Gameloop functions -- ------------------------------------------------------------------ function newGame() game_mode = gamemodes.normal generateCavern() spawnPlayer() spawnOrb() generateVisibilityMap() initializeRememberedCavern() if collidedPlayerOrb() then game_mode = gamemodes.won end end function step(direction) if game_mode == gamemodes.normal then if last_direction_moved == direction then -- Repeat faster after the initial threshold for repetition has been met move_repeat_counter = 0.1 else last_direction_moved = direction move_repeat_counter = 0.3 end rememberVisible() movePlayer(direction) generateVisibilityMap() if collidedPlayerOrb() then game_mode = gamemodes.won end end end -- ------------------------------------------------------------------ -- Drawing -- ------------------------------------------------------------------ function drawCavern() local x_scale = love.graphics.getWidth() / cavern.width local y_scale = love.graphics.getHeight() / cavern.height for tile_x, list in ipairs(visibility_map) do local x = (tile_x - 1) * x_scale for tile_y, visible in ipairs(list) do local y = (tile_y - 1) * y_scale if visible or debug then tile = cavern[tile_x][tile_y] if tile == tiletypes.empty then love.graphics.setColor(0, 0, 0) love.graphics.rectangle('fill', x, y, x_scale, y_scale) elseif tile == tiletypes.wall then love.graphics.setColor(1, 1, 1) love.graphics.rectangle('fill', x, y, x_scale, y_scale) elseif tile == tiletypes.orb then love.graphics.setColor(0.5, 0.3, 0.3) love.graphics.rectangle('fill', x, y, x_scale, y_scale) love.graphics.setColor(0, 1, 0) love.graphics.ellipse('fill', x + 0.5 * x_scale, y + 0.5 * y_scale, 0.7 * x_scale/2, 0.7 * y_scale/2) else love.graphics.setColor(1, 0.5, 0.5) love.graphics.rectangle('fill', x, y, x_scale, y_scale) end else tile = remembered_cavern[tile_x][tile_y] if tile == tiletypes.empty then love.graphics.setColor(0.2, 0.2, 0.2) love.graphics.rectangle('fill', x, y, x_scale, y_scale) elseif tile == tiletypes.wall then love.graphics.setColor(0.9, 0.9, 0.9) love.graphics.rectangle('fill', x, y, x_scale, y_scale) elseif tile == tiletypes.orb then love.graphics.setColor(0.4, 0.4, 0.4) love.graphics.rectangle('fill', x, y, x_scale, y_scale) love.graphics.setColor(0.2, 0.7, 0.2) love.graphics.ellipse('fill', x + 0.5 * x_scale, y + 0.5 * y_scale, 0.7 * x_scale/2, 0.7 * y_scale/2) else love.graphics.setColor(0.5, 0.5, 0.5) love.graphics.rectangle('fill', x, y, x_scale, y_scale) end end end end end function drawPlayer() local x_scale = love.graphics.getWidth() / cavern.width local y_scale = love.graphics.getHeight() / cavern.height local player_head_center_x = (player_x - 1) * x_scale + 0.5 * x_scale local player_head_center_y = (player_y - 1) * y_scale + 0.5 * y_scale love.graphics.setColor(0.6, 0.3, 0.2) love.graphics.ellipse('fill', player_head_center_x, player_head_center_y, x_scale/2, y_scale/2) local player_body_x, player_body_y = getBodyLocation() local player_body_x = (player_body_x - 1) * x_scale local player_body_y = (player_body_y - 1) * y_scale love.graphics.setColor(0, 0, 1) love.graphics.rectangle('fill', player_body_x, player_body_y, x_scale, y_scale) end function drawWin() local img_width, img_height = win_image:getDimensions() local screen_width = love.graphics.getWidth() local screen_height = love.graphics.getHeight() local width_scale = screen_width / img_width local height_scale = screen_height / img_height local scale = math.min(width_scale, height_scale) local left_border = (screen_width - img_width * scale) / 2 local up_border = (screen_height - img_height * scale) / 2 love.graphics.setColor(1, 1, 1) love.graphics.draw(win_image, left_border, up_border, 0, scale, scale) end function drawConfig() local text = nil if configuration_step == configuration_steps.quit then text = "Quit" elseif configuration_step == configuration_steps.restart then text = "Restart" elseif configuration_step == configuration_steps.configure then text = "Button configuration" elseif configuration_step == directions.up then text = "Up" elseif configuration_step == directions.upleft then text = "Up-Left" elseif configuration_step == directions.left then text = "Left" elseif configuration_step == directions.downleft then text = "Down-Left" elseif configuration_step == directions.down then text = "Down" elseif configuration_step == directions.downright then text = "Down-Right" elseif configuration_step == directions.right then text = "Right" elseif configuration_step == directions.upright then text = "Up-Right" else error("Impossible configuration step") end love.graphics.setColor(1, 1, 1) love.graphics.print(text) end -- ------------------------------------------------------------------ -- Callbacks -- ------------------------------------------------------------------ function love.load() math.randomseed(os.time()) newGame() win_image = love.graphics.newImage("win_image.png") end function love.update(dt) if move_repeat_counter ~= nil and move_repeat_counter > 0 then move_repeat_counter = move_repeat_counter - dt if move_repeat_counter <= 0 then step(last_direction_moved) end end end function love.keypressed(key) if game_mode == gamemodes.config then -- This is a hack. Each "enum value" corresponds to an integer, and we are iterating -- through them. -3 to -1 are control keys, and 0 to 7 are direction keys if configuration_step >= directions.up and configuration_step <= directions.upright then direction_keys[key] = configuration_step elseif configuration_step == configuration_steps.quit then control_keys.quit = key elseif configuration_step == configuration_steps.restart then control_keys.restart = key elseif configuration_step == configuration_steps.configure then control_keys.configure = key end configuration_step = configuration_step + 1 if configuration_step > directions.upright then game_mode = gamemodes.normal end else last_key_pressed = key if key == control_keys.configure and game_mode == gamemodes.normal then game_mode = gamemodes.config configuration_step = configuration_steps.quit elseif key == control_keys.quit then love.event.quit() elseif key == control_keys.restart then newGame() elseif direction_keys[key] ~= nil then step(direction_keys[key]) elseif key == 'printscreen' then debug = true end end end function love.keyreleased(key) if last_key_pressed == key then last_direction_moved = nil move_repeat_counter = nil end end function love.draw() if game_mode == gamemodes.normal then drawCavern() drawPlayer() elseif game_mode == gamemodes.won then drawWin() elseif game_mode == gamemodes.config then drawConfig() else error("Impossible game mode") end end