308 lines
9.4 KiB
Lua
308 lines
9.4 KiB
Lua
local sti = require("sti")
|
|
local inspect = require("inspect")
|
|
|
|
love.graphics.setDefaultFilter("nearest", "nearest")
|
|
|
|
local game = {
|
|
SCREEN_WIDTH=320,
|
|
SCREEN_HEIGHT=200,
|
|
TILE_SIZE=16,
|
|
-- NOTE: playfield dimensions in tiles
|
|
PLAYFIELD_OFFSET_TOP=1.5,
|
|
PLAYFIELD_WIDTH=20,
|
|
PLAYFIELD_HEIGHT=10,
|
|
playFieldTiles={},
|
|
map=sti("map.lua"),
|
|
entities={
|
|
vehicles={},
|
|
floatdevs={},
|
|
},
|
|
default_speeds={
|
|
floatdev=8,
|
|
vehicle=10,
|
|
},
|
|
hazards={},
|
|
drawGrid=false,
|
|
winState=false,
|
|
big_font=love.graphics.newFont(48, "mono"),
|
|
font=love.graphics.newFont(12, "mono"),
|
|
}
|
|
|
|
function t2p(tileDim)
|
|
return tileDim*game.TILE_SIZE
|
|
end
|
|
|
|
function tilePos2Pixels(tilePos)
|
|
return t2p(tilePos.x - 1), t2p(tilePos.y - 1)
|
|
end
|
|
|
|
function screenPixelToTilePos(pixelPos)
|
|
return {
|
|
x=math.floor(pixelPos.x/game.TILE_SIZE + 1),
|
|
y=math.floor((pixelPos.y + t2p(game.PLAYFIELD_OFFSET_TOP))/game.TILE_SIZE)
|
|
}
|
|
end
|
|
|
|
|
|
local player = {
|
|
pos={x=t2p(0), y=t2p(0)},
|
|
turtlePos={x=t2p(0), y=t2p(1)},
|
|
turtleHit=false,
|
|
lives=3,
|
|
turtles=3,
|
|
dead=false,
|
|
deadTimer=2,
|
|
float_speed=0,
|
|
}
|
|
|
|
function resetPlayer()
|
|
player.pos = {x=t2p(0), y=t2p(0)}
|
|
player.dead = false
|
|
player.turtleHit = false
|
|
player.turtlePos = {x=t2p(0), y=t2p(1)}
|
|
end
|
|
|
|
function love.load()
|
|
local desktop_width, desktop_height = love.window.getDesktopDimensions()
|
|
game.scaleW = desktop_width / game.SCREEN_WIDTH
|
|
game.scaleH = desktop_height / game.SCREEN_HEIGHT
|
|
for i, layer in ipairs(game.map.layers) do
|
|
if layer.objects then
|
|
layer.visible = false
|
|
for j, mapObj in ipairs(layer.objects) do
|
|
mapObj.visible = false
|
|
local typekey = mapObj.type.."s"
|
|
if game.entities[typekey] == nil then
|
|
game.entities[typekey] = {}
|
|
end
|
|
local entity = {
|
|
x=mapObj.x,
|
|
y=mapObj.y,
|
|
w=mapObj.width,
|
|
h=mapObj.height,
|
|
type=mapObj.type,
|
|
gid=mapObj.gid,
|
|
}
|
|
if mapObj.type == "vehicle" or mapObj.type == "floatdev" then
|
|
local tile = game.map.tiles[mapObj.gid] or game.map.tiles[game.map:setFlippedGID(mapObj.gid)]
|
|
entity.collider = tile.objectGroup.objects[1]
|
|
entity.speed = mapObj.properties.speed or game.default_speeds[mapObj.type]
|
|
end
|
|
table.insert(game.entities[typekey], entity)
|
|
end
|
|
end
|
|
end
|
|
player.sprites = love.graphics.newImage("player-sprites.png")
|
|
player.quads = {
|
|
dude=love.graphics.newQuad(17, 9, 15, 23, player.sprites),
|
|
turtle=love.graphics.newQuad(0, 23, 17, 9, player.sprites),
|
|
}
|
|
end
|
|
|
|
|
|
function love.keyreleased(key)
|
|
if player.dead or player.turtleHit then
|
|
return
|
|
end
|
|
if game.winState then
|
|
if key == "space" or key == "return" then
|
|
game.winState = false
|
|
resetPlayer()
|
|
end
|
|
return
|
|
end
|
|
local newPos = screenPixelToTilePos(player.pos)
|
|
local oldPos = screenPixelToTilePos(player.pos)
|
|
if key == "up" or key == "w" then
|
|
newPos.y = newPos.y - 1
|
|
end
|
|
if key == "down" or key == "s" then
|
|
newPos.y = newPos.y + 1
|
|
end
|
|
if key == "right" or key == "d" then
|
|
newPos.x = newPos.x + 1
|
|
end
|
|
if key == "left" or key == "a" then
|
|
newPos.x = newPos.x - 1
|
|
end
|
|
player.turtlePos.x = t2p(oldPos.x - 1)
|
|
player.turtlePos.y = t2p(oldPos.y - 1)
|
|
if newPos.x < 1 then
|
|
newPos.x = 1
|
|
end
|
|
if newPos.x > game.PLAYFIELD_WIDTH then
|
|
newPos.x = game.PLAYFIELD_WIDTH
|
|
end
|
|
if newPos.y < 1 then
|
|
newPos.y = 1
|
|
end
|
|
if newPos.y > game.PLAYFIELD_HEIGHT then
|
|
newPos.y = game.PLAYFIELD_HEIGHT
|
|
end
|
|
player.pos.x = t2p(newPos.x - 1)
|
|
player.pos.y = t2p(newPos.y - 1)
|
|
end
|
|
|
|
function tilePos2Rect(tilePos)
|
|
return {
|
|
x=t2p(tilePos.x - 1),
|
|
y=t2p(tilePos.y - 1),
|
|
w=game.TILE_SIZE,
|
|
h=game.TILE_SIZE,
|
|
}
|
|
end
|
|
|
|
function rectanglesIntersect(rect1, rect2)
|
|
return (rect1.x < rect2.x + rect2.w and
|
|
rect1.x + rect1.w > rect2.x and
|
|
rect1.y < rect2.y + rect2.h and
|
|
rect1.y + rect1.h > rect2.y)
|
|
end
|
|
|
|
function love.update(dt)
|
|
if player.dead or player.turtleHit then
|
|
player.deadTimer = player.deadTimer - dt
|
|
if player.deadTimer <= 0 then
|
|
player.deadTimer = 2
|
|
resetPlayer()
|
|
end
|
|
elseif not game.winState then
|
|
if screenPixelToTilePos(player.turtlePos).x == game.PLAYFIELD_WIDTH then
|
|
game.winState = true
|
|
end
|
|
local playerRect = tilePos2Rect(screenPixelToTilePos(player.pos))
|
|
local turtleRect = tilePos2Rect(screenPixelToTilePos(player.turtlePos))
|
|
if player.float_speed ~= 0 then
|
|
player.pos.y = player.pos.y + player.float_speed*dt
|
|
player.turtlePos.y = player.turtlePos.y + player.float_speed*dt
|
|
|
|
if playerRect.y > t2p(game.PLAYFIELD_HEIGHT) or playerRect.y + playerRect.h< t2p(0) then
|
|
player.dead = true
|
|
end
|
|
if turtleRect.y > t2p(game.PLAYFIELD_HEIGHT) or turtleRect.y + turtleRect.h< t2p(0) then
|
|
player.turtleHit = true
|
|
end
|
|
end
|
|
for i, vehicle in ipairs(game.entities.vehicles) do
|
|
local colliderRect = {x=vehicle.x + vehicle.collider.x, y=vehicle.y + vehicle.collider.y, w=vehicle.collider.width, h=vehicle.collider.height}
|
|
if rectanglesIntersect(playerRect, colliderRect) then
|
|
player.dead = true
|
|
player.lives = player.lives - 1
|
|
end
|
|
if rectanglesIntersect(turtleRect, colliderRect) then
|
|
player.turtleHit = true
|
|
end
|
|
|
|
vehicle.y = vehicle.y + vehicle.speed*dt
|
|
if vehicle.y > t2p(game.PLAYFIELD_HEIGHT) then
|
|
vehicle.y = -vehicle.h
|
|
end
|
|
if vehicle.y + vehicle.h < t2p(0) then
|
|
vehicle.y = t2p(game.PLAYFIELD_HEIGHT)
|
|
end
|
|
end
|
|
local was_floating = player.float_speed ~= 0
|
|
player.float_speed = 0
|
|
for i, floatdev in ipairs(game.entities.floatdevs) do
|
|
local colliderRect = {x=floatdev.x + floatdev.collider.x, y=floatdev.y + floatdev.collider.y, w=floatdev.collider.width, h=floatdev.collider.height}
|
|
if player.float_speed == 0 and rectanglesIntersect(playerRect, colliderRect) then
|
|
if not was_floating then
|
|
if math.abs(player.pos.y - colliderRect.y) > math.abs(player.pos.y - (colliderRect.y + colliderRect.h)) then
|
|
player.pos.y = colliderRect.y
|
|
player.turtlePos.y = player.pos.y + game.TILE_SIZE*2
|
|
else
|
|
player.pos.y = colliderRect.y + colliderRect.h - game.TILE_SIZE
|
|
player.turtlePos.y = player.pos.y - game.TILE_SIZE
|
|
end
|
|
end
|
|
player.turtlePos.x = player.pos.x
|
|
player.float_speed = floatdev.speed
|
|
end
|
|
floatdev.y = floatdev.y + floatdev.speed*dt
|
|
if floatdev.y > t2p(game.PLAYFIELD_HEIGHT) then
|
|
floatdev.y = -floatdev.h
|
|
end
|
|
if floatdev.y + floatdev.h < t2p(0) then
|
|
floatdev.y = t2p(game.PLAYFIELD_HEIGHT)
|
|
end
|
|
end
|
|
if player.float_speed == 0 then
|
|
for i, water in ipairs(game.entities.waters) do
|
|
if not player.dead and rectanglesIntersect(playerRect, water) then
|
|
player.dead = true
|
|
player.lives = player.lives - 1
|
|
end
|
|
end
|
|
if not player.dead and was_floating then
|
|
player.turtlePos.x = player.pos.x
|
|
player.turtlePos.y = player.pos.y - game.TILE_SIZE
|
|
if player.turtlePos.y < t2p(0) then
|
|
player.turtlePos.y = player.pos.y + game.TILE_SIZE
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function love.draw()
|
|
love.graphics.setColor(1, 1, 1)
|
|
game.map:draw(0, t2p(game.PLAYFIELD_OFFSET_TOP), game.scaleW, game.scaleH)
|
|
love.graphics.push()
|
|
-- <playfield>
|
|
love.graphics.scale(game.scaleW, game.scaleH)
|
|
love.graphics.translate(0, t2p(game.PLAYFIELD_OFFSET_TOP))
|
|
if game.drawGrid then
|
|
love.graphics.setColor(0.4, 0.3, 0.1)
|
|
for i=0, game.PLAYFIELD_WIDTH do
|
|
love.graphics.line(t2p(i), 0, t2p(i), t2p(game.PLAYFIELD_HEIGHT))
|
|
end
|
|
for i=0, game.PLAYFIELD_HEIGHT do
|
|
love.graphics.line(0, t2p(i), t2p(game.PLAYFIELD_WIDTH), t2p(i))
|
|
end
|
|
end
|
|
for i, vehicle in ipairs(game.entities.vehicles) do
|
|
local tile = game.map.tiles[vehicle.gid] or game.map:setFlippedGID(vehicle.gid)
|
|
local tileset = game.map.tilesets[tile.tileset]
|
|
local image = tileset.image
|
|
love.graphics.setColor(1, 1, 1)
|
|
love.graphics.draw(image, tile.quad, vehicle.x, vehicle.y)
|
|
love.graphics.setColor(0.9, 0.1, 0)
|
|
-- love.graphics.rectangle("line", vehicle.x + vehicle.collider.x, vehicle.y + vehicle.collider.y, vehicle.collider.width, vehicle.collider.height)
|
|
end
|
|
for i, floatdev in ipairs(game.entities.floatdevs) do
|
|
local tile = game.map.tiles[floatdev.gid] or game.map:setFlippedGID(floatdev.gid)
|
|
local tileset = game.map.tilesets[tile.tileset]
|
|
local image = tileset.image
|
|
love.graphics.setColor(1, 1, 1)
|
|
love.graphics.draw(image, tile.quad, floatdev.x, floatdev.y)
|
|
love.graphics.setColor(0.9, 0.1, 0)
|
|
end
|
|
if player.dead then
|
|
love.graphics.setColor(0.8, 0.1, 0)
|
|
else
|
|
love.graphics.setColor(1, 1, 1)
|
|
end
|
|
love.graphics.setColor(0, 0, 0)
|
|
love.graphics.rectangle("fill", 16, -t2p(game.PLAYFIELD_OFFSET_TOP), game.SCREEN_WIDTH, t2p(game.PLAYFIELD_OFFSET_TOP))
|
|
love.graphics.rectangle("fill", 0, game.SCREEN_HEIGHT - 40, game.SCREEN_WIDTH, 48)
|
|
love.graphics.setColor(1, 1, 1)
|
|
local x, y = player.pos.x, player.pos.y
|
|
love.graphics.draw(player.sprites, player.quads.dude, x, y - 8)
|
|
x, y = player.turtlePos.x, player.turtlePos.y
|
|
if player.turtleHit then
|
|
love.graphics.setColor(0.8, 0.1, 0)
|
|
else
|
|
love.graphics.setColor(1, 1, 1)
|
|
end
|
|
love.graphics.draw(player.sprites, player.quads.turtle, x, y + 4)
|
|
if game.winState then
|
|
love.graphics.setColor(0, 0, 0, 0.8)
|
|
love.graphics.rectangle("fill", 0, -32, game.SCREEN_WIDTH, game.SCREEN_HEIGHT)
|
|
love.graphics.setColor(0, 1, 0.2)
|
|
love.graphics.printf("MADE IT!", game.big_font, 64, 12, 200, "center")
|
|
love.graphics.printf("press return to play again", game.font, 64, 128, 200, "center")
|
|
end
|
|
-- </playfield>
|
|
love.graphics.pop()
|
|
end
|