766 lines
18 KiB
Lua
766 lines
18 KiB
Lua
local lvgl = require("lvgl")
|
||
|
||
local MOVE_SPEED = 480 / 8000 -- 8s for 480 pixel, pixel per ms
|
||
local PIXEL_PER_METER = 80
|
||
local TOP_Y = 20
|
||
local BOTTOM_Y = 480 - 112
|
||
local PIPE_COUNT = 5
|
||
local PIPE_GAP = 100
|
||
local PIPE_SPACE = 120
|
||
|
||
-- SCRIPT_PATH is set in simulator/main.c, used to get the abs path of first
|
||
-- lua script lua get called. In this example, SCRIPT_PATH is set to
|
||
-- path of `examples.lua`, flappyBird.lua is called when button is clicked.
|
||
|
||
local IMAGE_PATH = SCRIPT_PATH
|
||
if not IMAGE_PATH then
|
||
IMAGE_PATH = "/"
|
||
print("Note image root path is set to: ", IMAGE_PATH)
|
||
end
|
||
|
||
IMAGE_PATH = IMAGE_PATH .. "/flappyBird/"
|
||
print("IMAGE_PATH:", IMAGE_PATH)
|
||
|
||
local function randomY()
|
||
return math.random(TOP_Y + 30, BOTTOM_Y - 50 - 50)
|
||
end
|
||
|
||
local function screenCreate(parent)
|
||
local property = {
|
||
w = 480,
|
||
h = 480,
|
||
bg_opa = 0,
|
||
border_width = 0,
|
||
pad_all = 0
|
||
}
|
||
|
||
local scr
|
||
if parent then
|
||
scr = parent:Object{
|
||
w = 480,
|
||
h = 480,
|
||
bg_opa = 0,
|
||
border_width = 0,
|
||
pad_all = 0
|
||
}
|
||
else
|
||
scr = lvgl.Object(nil, property)
|
||
end
|
||
scr:clear_flag(lvgl.FLAG.SCROLLABLE)
|
||
scr:clear_flag(lvgl.FLAG.CLICKABLE)
|
||
return scr
|
||
end
|
||
|
||
local function Image(parent, src)
|
||
local img = {}
|
||
img.widget = parent:Image{
|
||
src = src
|
||
}
|
||
|
||
img.w, img.h = img.widget:get_img_size()
|
||
if not img.w or not img.h then
|
||
error("failed to load image: " .. src)
|
||
end
|
||
return img
|
||
end
|
||
|
||
local function ImageScroll(root, src, animSpeed, y)
|
||
-- image on right
|
||
local right = Image(root, src).widget
|
||
right:set{
|
||
src = src,
|
||
x = 480,
|
||
y = y,
|
||
pad_all = 0
|
||
}
|
||
|
||
local img = Image(root, src).widget
|
||
img:set{
|
||
x = 0,
|
||
y = y,
|
||
src = src,
|
||
pad_all = 0
|
||
}
|
||
|
||
img:Anim{
|
||
run = true,
|
||
start_value = 0,
|
||
end_value = -480,
|
||
time = 480 / animSpeed,
|
||
repeat_count = lvgl.ANIM_REPEAT_INFINITE,
|
||
path = "linear",
|
||
exec_cb = function(obj, value)
|
||
img:set{
|
||
x = value
|
||
}
|
||
|
||
right:set{
|
||
x = value + 480
|
||
}
|
||
end
|
||
}
|
||
|
||
img:clear_flag(lvgl.FLAG.CLICKABLE)
|
||
|
||
return img
|
||
end
|
||
|
||
local function Frames(parent, src, fps)
|
||
local frame = Image(parent, src[1])
|
||
fps = fps ~= 0 and fps or 25
|
||
|
||
frame.src = src
|
||
frame.len = #src
|
||
frame.i = 0
|
||
|
||
frame.timer = lvgl.Timer {
|
||
period = 1000 / fps,
|
||
cb = function(t)
|
||
frame.widget:set{
|
||
src = frame.src[frame.i]
|
||
}
|
||
|
||
frame.i = frame.i + 1
|
||
if frame.i == frame.len then
|
||
frame.i = 1
|
||
end
|
||
end
|
||
}
|
||
|
||
frame.start = function(self)
|
||
self.timer:resume()
|
||
end
|
||
|
||
frame.pause = function(self)
|
||
self.timer:pause()
|
||
end
|
||
|
||
return frame
|
||
end
|
||
|
||
local function Pipe(parent)
|
||
local up = Image(parent, IMAGE_PATH .. "pipe_up.png")
|
||
local down = Image(parent, IMAGE_PATH .. "pipe_down.png")
|
||
local pipe = {
|
||
up = up.widget,
|
||
down = down.widget,
|
||
w = up.w,
|
||
h = up.h,
|
||
x = 0,
|
||
y = 0
|
||
}
|
||
|
||
function pipe:updatePipePos()
|
||
self.up:set{
|
||
x = self.x,
|
||
y = self.y - up.h
|
||
}
|
||
|
||
self.down:set{
|
||
x = self.x,
|
||
y = self.y + PIPE_GAP
|
||
}
|
||
end
|
||
|
||
pipe:updatePipePos()
|
||
return pipe
|
||
end
|
||
|
||
local function ObjInfo(x, y, w, h)
|
||
return {
|
||
x = x,
|
||
y = y,
|
||
w = w,
|
||
h = h
|
||
}
|
||
end
|
||
|
||
local function Pipes(parent)
|
||
local pipes = {}
|
||
|
||
-- add initial pipe
|
||
for i = 1, PIPE_COUNT do
|
||
pipes[i] = Pipe(parent)
|
||
if i == 1 then
|
||
pipes.w = pipes[i].w -- record pipe size
|
||
pipes.h = pipes[i].h
|
||
end
|
||
end
|
||
|
||
local function pipesPosinit()
|
||
local x = 480;
|
||
local y = randomY()
|
||
|
||
for i = 1, PIPE_COUNT do
|
||
local pipe = pipes[i]
|
||
pipe.x = x
|
||
pipe.y = y
|
||
pipe:updatePipePos()
|
||
pipes[i] = pipe
|
||
x = x + PIPE_SPACE + pipe.w
|
||
y = randomY()
|
||
end
|
||
end
|
||
|
||
pipesPosinit()
|
||
|
||
pipes.score = 0
|
||
pipes.last = PIPE_COUNT -- first pipe index in pipes.pipes
|
||
pipes.totalWidth = (PIPE_COUNT) * (PIPE_SPACE + pipes.w)
|
||
pipes.birdInfo = ObjInfo(0, 0, 0, 0)
|
||
pipes.gapInfo = ObjInfo(0, 0, 0, 0)
|
||
|
||
function pipes:setObjInfo(x, y, w, h)
|
||
self.birdInfo.x = x
|
||
self.birdInfo.y = y
|
||
if w then
|
||
self.birdInfo.w = w
|
||
end
|
||
if h then
|
||
self.birdInfo.h = h
|
||
end
|
||
end
|
||
|
||
local function setGapInfo(x, y, w, h)
|
||
pipes.gapInfo.x = x
|
||
pipes.gapInfo.y = y
|
||
pipes.gapInfo.w = w
|
||
pipes.gapInfo.h = h
|
||
end
|
||
|
||
pipes.objPassing = -1
|
||
|
||
local function isBirdCollision()
|
||
local bird = pipes.birdInfo
|
||
local gap = pipes.gapInfo
|
||
|
||
-- far left
|
||
if bird.x + bird.w < gap.x then
|
||
return false
|
||
end
|
||
|
||
-- far right
|
||
if bird.x > gap.x + gap.w then
|
||
return false
|
||
end
|
||
|
||
-- in middle
|
||
|
||
if (bird.y > gap.y) and (bird.y + bird.h < gap.y + gap.h) then
|
||
return false
|
||
end
|
||
return true
|
||
end
|
||
|
||
local function moveVirtualX(dx)
|
||
for i = 1, PIPE_COUNT do
|
||
local pipe = pipes[i]
|
||
local newX = pipe.x + dx
|
||
|
||
if newX + pipes.w < 0 then
|
||
newX = newX + pipes.totalWidth
|
||
pipe.y = randomY()
|
||
pipes.last = i
|
||
end
|
||
|
||
pipe.x = newX
|
||
pipe.updatePipePos(pipe)
|
||
end
|
||
end
|
||
|
||
local function checkScore(i)
|
||
local pipe = pipes[i]
|
||
|
||
local bird = pipes.birdInfo
|
||
local gap = pipes.gapInfo
|
||
local passing = pipes.objPassing
|
||
|
||
-- far left or right
|
||
if bird.x + bird.w < gap.x or bird.x > gap.x + gap.w then
|
||
if passing > 0 and i == passing then
|
||
pipes.score = pipes.score + 1
|
||
passing = -1
|
||
pipes.scoreUpdateCB(pipes.score)
|
||
end
|
||
else
|
||
if passing < 0 then
|
||
passing = i
|
||
end
|
||
end
|
||
|
||
pipes.objPassing = passing
|
||
end
|
||
|
||
--- Detect if obj has collision with pipes
|
||
local function collisionDetect()
|
||
local first = (pipes.last % PIPE_COUNT) + 1
|
||
for idx = 0, PIPE_COUNT - 1 do
|
||
local i = (first + idx - 1) % PIPE_COUNT + 1
|
||
local pipe = pipes[i]
|
||
setGapInfo(pipe.x, pipe.y, pipe.w, PIPE_GAP)
|
||
|
||
if isBirdCollision() then
|
||
local bird = pipes.birdInfo
|
||
if pipes.collisionCB then
|
||
pipes.collisionCB()
|
||
end
|
||
end
|
||
|
||
checkScore(i)
|
||
end
|
||
end
|
||
|
||
pipes.preValue = 0
|
||
pipes.anim = pipes[1].up:Anim{
|
||
run = false,
|
||
start_value = 0,
|
||
end_value = 480,
|
||
time = 480 / MOVE_SPEED, -- MOVE_SPEED
|
||
repeat_count = lvgl.ANIM_REPEAT_INFINITE,
|
||
path = "linear",
|
||
exec_cb = function(obj, value)
|
||
local x = pipes.preValue
|
||
local d
|
||
if value < x then
|
||
d = value + 480 - x
|
||
else
|
||
d = value - x
|
||
end
|
||
pipes.preValue = value
|
||
moveVirtualX(-d)
|
||
collisionDetect()
|
||
end
|
||
}
|
||
|
||
function pipes:start()
|
||
self.anim:start()
|
||
end
|
||
|
||
function pipes:stop()
|
||
self.anim:stop()
|
||
end
|
||
|
||
function pipes:reset()
|
||
pipesPosinit()
|
||
pipes.score = 0
|
||
pipes.preValue = 0
|
||
pipes.objPassing = -1
|
||
end
|
||
|
||
function pipes:setCollisionCB(collisionCB)
|
||
self.collisionCB = collisionCB
|
||
end
|
||
|
||
function pipes:setScoreUpdateCB(cb)
|
||
self.scoreUpdateCB = cb
|
||
end
|
||
|
||
return pipes
|
||
end
|
||
|
||
local function Bird(parent, birdMovedCB)
|
||
-- create bird Frame(sprite) in 5FPS
|
||
local bird = Frames(parent,
|
||
{IMAGE_PATH .. "bird1.png", IMAGE_PATH .. "bird2.png", IMAGE_PATH .. "bird3.png"}, 5)
|
||
|
||
local function birdVarInit()
|
||
bird.x = 240 - bird.w / 2
|
||
bird.y = 240 - bird.h / 2
|
||
bird.widget:set{
|
||
x = bird.x,
|
||
y = bird.y
|
||
}
|
||
|
||
bird.head = 0
|
||
bird.force = 0 -- in unit of m/s^2 rather than N
|
||
bird.velocity = 0 -- vertical verlocity
|
||
bird.time = 0 -- time stamp when it updates
|
||
bird.moving = false
|
||
end
|
||
|
||
birdVarInit()
|
||
|
||
bird.setY = function(self)
|
||
bird.widget:set{
|
||
y = bird.y
|
||
}
|
||
end
|
||
|
||
bird.setHead = function(self)
|
||
bird.widget:set{
|
||
angle = self.head
|
||
}
|
||
end
|
||
|
||
bird.applyForce = function(self, force)
|
||
self.force = force
|
||
if bird.moving then
|
||
return
|
||
end
|
||
|
||
bird.moving = true
|
||
self.y_anim:start()
|
||
end
|
||
|
||
bird.pressed = function(self)
|
||
bird:applyForce(-13)
|
||
bird.velocity = 0
|
||
end
|
||
|
||
bird.released = function(self)
|
||
bird:applyForce(9.8)
|
||
bird.velocity = 0
|
||
end
|
||
|
||
local function velocity2HeadAngle(v)
|
||
-- -9.8 ~ 9.8：90 ~ -90
|
||
return v * 60
|
||
end
|
||
|
||
-- y moving anim, in time.
|
||
bird.y_anim = bird.widget:Anim{
|
||
run = false,
|
||
start_value = 0,
|
||
end_value = 1000,
|
||
time = 1000, -- 1000 ms
|
||
repeat_count = lvgl.ANIM_REPEAT_INFINITE,
|
||
path = "linear",
|
||
exec_cb = function(obj, tNow)
|
||
-- we use anim to get current time, can calculate position based on force/velocity
|
||
if tNow < bird.time then
|
||
tNow = tNow + 1000
|
||
end
|
||
local y = bird.y
|
||
local preT = bird.time
|
||
local v = bird.velocity
|
||
local t = tNow < preT and tNow + 1000 - preT or tNow - preT
|
||
t = t * 0.001 -- ms to s
|
||
|
||
v = bird.force * t + v
|
||
if v > 10 then
|
||
v = 10
|
||
end
|
||
|
||
if v < -10 then
|
||
v = -10
|
||
end
|
||
|
||
y = y + v * t * PIXEL_PER_METER
|
||
if y > BOTTOM_Y - 30 then
|
||
y = BOTTOM_Y - 30
|
||
v = 0
|
||
end
|
||
if y < TOP_Y then
|
||
y = TOP_Y
|
||
v = 0
|
||
end
|
||
|
||
bird.y = y
|
||
bird.time = tNow
|
||
bird.velocity = v
|
||
bird.head = velocity2HeadAngle(v)
|
||
|
||
birdMovedCB(bird.x, bird.y)
|
||
-- set y
|
||
bird:setY()
|
||
bird:setHead()
|
||
end
|
||
}
|
||
|
||
function bird:stop()
|
||
bird.y_anim:stop()
|
||
end
|
||
|
||
function bird:gameOver()
|
||
-- like it's released forever
|
||
bird.released()
|
||
end
|
||
|
||
function bird:start()
|
||
bird.y_anim:start()
|
||
end
|
||
|
||
function bird:reset()
|
||
bird.stop()
|
||
birdVarInit()
|
||
end
|
||
|
||
return bird;
|
||
end
|
||
|
||
local function Background(root, bgEventCB)
|
||
local bgLayer = screenCreate(root) -- background layer
|
||
bgLayer:add_flag(lvgl.FLAG.CLICKABLE) -- we accept event here
|
||
|
||
local bg = ImageScroll(bgLayer, IMAGE_PATH .. "bg_day.png", MOVE_SPEED * 0.4, 0)
|
||
local pipes = Pipes(bgLayer)
|
||
local land = ImageScroll(bgLayer, IMAGE_PATH .. "land.png", MOVE_SPEED, BOTTOM_Y)
|
||
|
||
bgLayer:onevent(lvgl.EVENT.PRESSED, function(obj, code)
|
||
bgEventCB(lvgl.EVENT.PRESSED)
|
||
end)
|
||
|
||
bgLayer:onevent(lvgl.EVENT.RELEASED, function(obj, code)
|
||
bgEventCB(lvgl.EVENT.RELEASED)
|
||
end)
|
||
|
||
return {
|
||
pipes = pipes
|
||
}
|
||
end
|
||
|
||
local function SysLayer(root)
|
||
local sysLayer = screenCreate(root) -- upper layer
|
||
return sysLayer
|
||
end
|
||
|
||
local function createPlayBtn(sysLayer, onEvent)
|
||
local playBtn = Image(sysLayer, IMAGE_PATH .. "button_play.png").widget
|
||
playBtn:add_flag(lvgl.FLAG.CLICKABLE)
|
||
playBtn:set{
|
||
align = {
|
||
type = lvgl.ALIGN.CENTER,
|
||
y_ofs = 80
|
||
}
|
||
}
|
||
|
||
playBtn:onevent(lvgl.EVENT.PRESSED, onEvent)
|
||
|
||
return playBtn
|
||
end
|
||
|
||
local function entry()
|
||
local scr = screenCreate()
|
||
local bgLayer
|
||
local mainLayer
|
||
local sysLayer
|
||
local bird
|
||
local pipes
|
||
local bgEventCB -- background layer pressed/released event
|
||
local birdMovedCB -- callback when bird position updates
|
||
local collisionCB -- callback when collision happends
|
||
local flagRunning = false
|
||
local gameStart -- API to start game
|
||
local gameOver -- API to stop game
|
||
local scoreLabel
|
||
local scoreBest = 0
|
||
local scoreNow = 0
|
||
local debouncing = false
|
||
-- global event process
|
||
|
||
local scoreUpdateCB = function(score)
|
||
scoreLabel:set{
|
||
text = string.format("%03d", score)
|
||
}
|
||
scoreNow = score
|
||
end
|
||
|
||
print("font:", lvgl.BUILTIN_FONT.MONTSERRAT_26)
|
||
gameStart = function()
|
||
if flagRunning then
|
||
return
|
||
end
|
||
|
||
bird:reset()
|
||
pipes:reset()
|
||
pipes:start()
|
||
bird:start()
|
||
flagRunning = true
|
||
scoreNow = 0
|
||
if scoreLabel then
|
||
scoreLabel:set{
|
||
text = string.format("%03d", 0)
|
||
}
|
||
end
|
||
end
|
||
|
||
gameOver = function()
|
||
if not flagRunning then
|
||
return
|
||
end
|
||
|
||
debouncing = true
|
||
flagRunning = false
|
||
|
||
pipes:stop()
|
||
bird:gameOver()
|
||
if scoreNow > scoreBest then
|
||
scoreBest = scoreNow
|
||
end
|
||
|
||
local gameoverImg = Image(sysLayer, IMAGE_PATH .. "text_game_over.png").widget
|
||
gameoverImg:set{
|
||
align = {
|
||
type = lvgl.ALIGN.TOP_MID,
|
||
y_ofs = 100
|
||
}
|
||
}
|
||
|
||
gameoverImg:Anim{
|
||
run = true,
|
||
start_value = 0,
|
||
end_value = 3600,
|
||
time = 2000,
|
||
repeat_count = 2,
|
||
path = "bounce",
|
||
exec_cb = function(obj, value)
|
||
obj:set{
|
||
angle = value
|
||
}
|
||
end
|
||
}
|
||
|
||
local scoreImg = Image(sysLayer, IMAGE_PATH .. "score.png").widget
|
||
scoreImg:set{
|
||
align = {
|
||
type = lvgl.ALIGN.CENTER,
|
||
y_ofs = -20,
|
||
x_ofs = 0
|
||
}
|
||
}
|
||
scoreImg:Anim{
|
||
run = true,
|
||
start_value = 480,
|
||
end_value = 0,
|
||
time = 1000,
|
||
repeat_count = 1,
|
||
path = "ease_in",
|
||
exec_cb = function(obj, value)
|
||
obj:set{
|
||
align = {
|
||
type = lvgl.ALIGN.CENTER,
|
||
x_ofs = value,
|
||
y_ofs = -20
|
||
}
|
||
}
|
||
end
|
||
}
|
||
|
||
local scoreResultLabel = scoreImg:Label{
|
||
text = string.format("%03d", scoreNow),
|
||
text_font = lvgl.BUILTIN_FONT.MONTSERRAT_22,
|
||
align = {
|
||
type = lvgl.ALIGN.TOP_MID,
|
||
x_ofs = 0,
|
||
y_ofs = 25
|
||
}
|
||
}
|
||
|
||
local scoreBestLabel = scoreImg:Label{
|
||
text = string.format("%03d", scoreBest),
|
||
text_font = lvgl.BUILTIN_FONT.MONTSERRAT_22,
|
||
align = {
|
||
type = lvgl.ALIGN.BOTTOM_MID,
|
||
x_ofs = 0,
|
||
y_ofs = -5
|
||
}
|
||
}
|
||
scoreNow = 0
|
||
|
||
local playBtn;
|
||
playBtn = createPlayBtn(sysLayer, function(obj, code)
|
||
if debouncing then
|
||
return
|
||
end
|
||
|
||
gameStart()
|
||
playBtn:delete()
|
||
playBtn = nil
|
||
gameoverImg:delete()
|
||
gameoverImg = nil
|
||
scoreImg:delete()
|
||
scoreImg = nil
|
||
end)
|
||
|
||
lvgl.Timer {
|
||
period = 1000,
|
||
cb = function(t)
|
||
t:delete()
|
||
debouncing = false
|
||
end
|
||
}
|
||
end
|
||
|
||
bgEventCB = function(event)
|
||
if not flagRunning then
|
||
return
|
||
end
|
||
|
||
if event == lvgl.EVENT.PRESSED then
|
||
bird:pressed()
|
||
else
|
||
bird:released()
|
||
end
|
||
end
|
||
|
||
local birdMovedCB = function(x, y)
|
||
pipes:setObjInfo(bird.x, bird.y) -- set intial bird position.
|
||
end
|
||
|
||
local collisionCB = function()
|
||
print("bird collision, stop game")
|
||
-- call later
|
||
lvgl.Timer {
|
||
period = 10,
|
||
cb = function(t)
|
||
t:delete()
|
||
gameOver()
|
||
end
|
||
}
|
||
|
||
end
|
||
|
||
-- background layer, including sky, then pipes and land above
|
||
bgLayer = Background(scr, bgEventCB) -- background layer
|
||
pipes = bgLayer.pipes -- get pipes from bg layer for set bird info etc.
|
||
pipes:setCollisionCB(collisionCB)
|
||
pipes:setScoreUpdateCB(scoreUpdateCB)
|
||
|
||
-- main layer, the bird
|
||
mainLayer = screenCreate(scr) -- main layer
|
||
bird = Bird(mainLayer, birdMovedCB)
|
||
pipes:setObjInfo(bird.x, bird.y, bird.w, bird.h)
|
||
-- system layer, score etc.
|
||
sysLayer = SysLayer(scr)
|
||
|
||
local title = Image(sysLayer, IMAGE_PATH .. "title.png").widget
|
||
title:set{
|
||
align = {
|
||
type = lvgl.ALIGN.TOP_MID,
|
||
y_ofs = 80
|
||
}
|
||
}
|
||
|
||
local playBtn;
|
||
playBtn = createPlayBtn(sysLayer, function()
|
||
print("pressed")
|
||
gameStart()
|
||
playBtn:delete()
|
||
playBtn = nil
|
||
title:delete()
|
||
title = nil
|
||
|
||
local medal = Image(sysLayer, IMAGE_PATH .. "medals.png").widget
|
||
medal:set{
|
||
align = {
|
||
type = lvgl.ALIGN.TOP_MID,
|
||
y_ofs = 10,
|
||
x_ofs = -50
|
||
}
|
||
}
|
||
scoreLabel = sysLayer:Label{
|
||
text = " 000",
|
||
text_font = lvgl.BUILTIN_FONT.MONTSERRAT_28,
|
||
align = {
|
||
type = lvgl.ALIGN.TOP_MID,
|
||
x_ofs = 10,
|
||
y_ofs = 20
|
||
}
|
||
}
|
||
end)
|
||
end
|
||
|
||
entry()
|
||
|
||
-- bird = Bird(, nil)
|