698 lines
21 KiB
Lua
698 lines
21 KiB
Lua
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}
|
||
local game_mode = gamemodes.normal
|
||
|
||
-- ------------------------------------------------------------------
|
||
-- 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
|
||
-- ⌜^⌝
|
||
-- <o>
|
||
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
|
||
-- ⌜^
|
||
-- <o
|
||
-- ⌞v
|
||
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, direction = directions.left})
|
||
|
||
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})
|
||
elseif player_direction == directions.down then
|
||
-- <o>
|
||
-- ⌞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
|
||
-- <x>
|
||
-- 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
|
||
-- ^
|
||
-- <x>
|
||
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
|
||
-- ^
|
||
-- <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
|
||
else
|
||
error("Player facing an impossible direction")
|
||
end
|
||
end
|
||
|
||
function stepVisibilityMapGeneration(queue)
|
||
-- Do a modified floodfill, where each cell will only expand in its given direction, not
|
||
-- every direction like in a normal floodfill
|
||
local new_queue = {}
|
||
|
||
for i, item in ipairs(queue) do
|
||
if item.direction == directions.up then
|
||
visibility_map[item.x][item.y] = true
|
||
if passable(item.x, item.y) then
|
||
table.insert(new_queue, {x = item.x, y = item.y - 1, direction = directions.up})
|
||
end
|
||
elseif item.direction == directions.left then
|
||
visibility_map[item.x][item.y] = true
|
||
if passable(item.x, item.y) then
|
||
table.insert(new_queue, {x = item.x - 1, y = item.y, direction = directions.left})
|
||
end
|
||
elseif item.direction == directions.down then
|
||
visibility_map[item.x][item.y] = true
|
||
if passable(item.x, item.y) then
|
||
table.insert(new_queue, {x = item.x, y = item.y + 1, direction = directions.down})
|
||
end
|
||
elseif item.direction == directions.right then
|
||
visibility_map[item.x][item.y] = true
|
||
if passable(item.x, item.y) then
|
||
table.insert(new_queue, {x = item.x + 1, y = item.y, direction = directions.right})
|
||
end
|
||
elseif item.direction == directions.upleft then
|
||
-- Check that we could have gotten here also by moving only 4-ways
|
||
--
|
||
-- The possible cases are:
|
||
-- (o represents old position, x is new, and # is a wall)
|
||
--
|
||
-- x x# x x#
|
||
-- o o #o #o
|
||
--
|
||
-- In the first three, the movement is possible, but in the last one
|
||
-- it is not. We can therefore check whether the movement is valid
|
||
-- by testing if either the cell to our right or below us (the
|
||
-- directions opposite to the ones in an up.left movement) is empty
|
||
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 - 1, y = item.y - 1, direction = directions.upleft})
|
||
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, direction = directions.left})
|
||
end
|
||
end
|
||
elseif item.direction == directions.downleft 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
|
||
-- ⌞v
|
||
table.insert(new_queue, {x = item.x - 1, y = item.y, direction = directions.left})
|
||
table.insert(new_queue, {x = item.x - 1, y = item.y + 1, direction = directions.downleft})
|
||
table.insert(new_queue, {x = item.x, y = item.y + 1, direction = directions.down})
|
||
end
|
||
end
|
||
elseif item.direction == directions.downright 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>
|
||
-- 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
|
||
|
||
-- ------------------------------------------------------------------
|
||
-- Callbacks
|
||
-- ------------------------------------------------------------------
|
||
|
||
function love.load()
|
||
math.randomseed(os.time())
|
||
|
||
newGame()
|
||
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)
|
||
last_key_pressed = key
|
||
if key == 'r' then
|
||
newGame()
|
||
elseif key == 'i' then
|
||
step(directions.up)
|
||
elseif key == 'j' then
|
||
step(directions.left)
|
||
elseif key == 'k' then
|
||
step(directions.down)
|
||
elseif key == 'l' then
|
||
step(directions.right)
|
||
elseif key == 'u' then
|
||
step(directions.upleft)
|
||
elseif key == 'm' then
|
||
step(directions.downleft)
|
||
elseif key == '.' then
|
||
step(directions.downright)
|
||
elseif key == 'o' then
|
||
step(directions.upright)
|
||
elseif key == 'q' then
|
||
love.event.quit()
|
||
elseif key == 'printscreen' then
|
||
debug = true
|
||
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()
|
||
local x_scale = love.graphics.getWidth() / cavern.width
|
||
local y_scale = love.graphics.getHeight() / cavern.height
|
||
|
||
-- Draw the cavern
|
||
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
|
||
|
||
-- Draw the player
|
||
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.2, 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
|