table = { [true] = "yes!", [false] = "no!" }

print(table[true])
-- output: yes!

table = { "lee", "la", "woo", "yo" }

table = { "lee", "la", "woo", "yo" }

function func(element)
  print(element)
end

foreach(table, func)
--[[
output:
lee
la
woo
yo
]]

table = { "lee", "la", "woo", "yo" }

del(table, "la")

foreach(table, print)
--[[
output:
lee
woo
yo
]]

if a then
  -- a is true
elseif b then
  -- a is false, and b is true
else
  -- a & b is both false
end

for variable = beginning, ending, step do

end

for i = 0, 10, 2 do
  print(i)
end
--[[
output:
0
2
4
6
8
10
]]

-- init
pl = {
    x = 12,
    y = 12
}

btn(n)

mget(cel_x, cel_y)

function check_map(x, y, w, h, m)
  mx = x / 8
  my = y / 8
  mx2 = (x + w - 1) / 8
  my2 = (y + h - 1) / 8
  
  if mget(mx, my) == m then
    return true
  end
  if mget(mx, my2) == m then
    return true
  end
  if mget(mx2, my) == m then
    return true
  end
  if mget(mx2, my2) == m then
    return true
  end
  
  return false
end

old_x = pl.x
old_y = pl.y

-- the input part omitted

if check_map(pl.x, pl.y, 8, 8, 1) then
  pl.x = old_x
  pl.y = old_y
end

camera([x, y])

function _init()
    pl = {
        x = 12,
        y = 12,
        xv = 0,
        yv = 0
    }
end

function _update()
    old_x = pl.x

    if (btn(0)) then
        pl.x -= 1;
    end
    if (btn(1)) then
        pl.x += 1;
    end

    if check_map(pl.x, pl.y, 8, 8, 1) then
    	pl.x = old_x
    end

    old_y = pl.y

    pl.y += 1

    if check_map(pl.x, pl.y, 8, 8, 1) then
    	pl.y = old_y
    end
end

function _draw()
    cls()
    map(0,0,0,0,128,64)
    spr(2, pl.x, pl.y)
end

function check_map(x, y, w, h, m)
    mx = x / 8
    my = y / 8
    mx2 = (x + w - 1) / 8
    my2 = (y + h - 1) / 8
    
    if mget(mx, my) == m then
        return true
    end
    if mget(mx, my2) == m then
        return true
    end
    if mget(mx2, my) == m then
        return true
    end
    if mget(mx2, my2) == m then
        return true
    end
    
    return false
end

v += a
x += v

function _init()
    pl = {
        x = 12,
        y = 12,
        xv = 0,
        yv = 0
    }
end

function _update()
    -- update player velocity
    if (btn(0)) then
        pl.xv -= 0.2
    end
    if (btn(1)) then
        pl.xv += 0.2
    end

    pl.yv += 0.2

    -- update player position
    for i = 1, 16 do
        old_x = pl.x

        pl.x += pl.xv / 16

        if check_map(pl.x, pl.y, 8, 8, 1) then
            pl.x = old_x
        end
    end

    for i = 1, 16 do
        old_y = pl.y

        pl.y += pl.yv / 16

        if check_map(pl.x, pl.y, 8, 8, 1) then
            pl.y = old_y
        end
    end
end

function _draw()
    cls()
    map(0,0,0,0,128,64)
    spr(2, pl.x, pl.y)
end

function check_map(x, y, w, h, m)
    mx = x / 8
    my = y / 8
    mx2 = (x + w - 1) / 8
    my2 = (y + h - 1) / 8
    
    if mget(mx, my) == m then
        return true
    end
    if mget(mx, my2) == m then
        return true
    end
    if mget(mx2, my) == m then
        return true
    end
    if mget(mx2, my2) == m then
        return true
    end
    
    return false
end

-- _init() 是 Pico-8 在遊戲開始時會呼叫的函數
-- 裡面放要初始化的變數等等
function _init()
  -- pl 變數是一個物件，代表我們的玩家
  -- 其中又有 x 座標、y 座標，x 方向速度 & y 方向速度
  pl = {
    x = 12,
    y = 12,
    xv = 0,
    yv = 0
  }
end

-- _update() 是 Pico-8 會在每一幀呼叫的函數
-- 每秒會執行 30 次
function _update()
  -----------------------------------------
  -- 首先先根據玩家的輸入 btn(id) 來改變速度
  -----------------------------------------

  -- 0 號按鈕是向左，1 號是向右
  -- 根據這兩個按鈕左右移動（改變 x 方向的速度）
  if (btn(0)) then
    pl.xv -= 0.5
  end
  if (btn(1)) then
    pl.xv += 0.5
  end

  -- x 方向的速度要有阻力，否則會無限滑走
  -- 假設阻力一直為速度的 20% 好了，那就要 * 80%
  pl.xv *= 0.8

  -- y 方向的速度就是一直遞增，畢竟在往下掉嘛
  pl.yv += 0.5

  ----------------------------------
  -- 接下來要根據速度來改變玩家的位置
  ----------------------------------

  -- 加一層 for 迴圈，就可以把很快的速度切割成很多段來更新，避免穿牆
  -- x 方向的更新：
  for i = 1, 16 do
    -- 把舊的位置存起來
    old_x = pl.x

    -- 把位置加上速度，記得 / 16 因為是切成 16 份的其中 1 份
    pl.x += pl.xv / 16

    -- 如果 check_map() 通過，代表有碰到牆（這是自己定義的函數，在最後面）
    if check_map(pl.x, pl.y, 8, 8, 0) then
      -- 那麼就回去剛才儲存的舊的位置
      pl.x = old_x
    end
  end

  -- y 方向也是一樣
  for i = 1, 16 do
    old_y = pl.y

    pl.y += pl.yv / 16

    if check_map(pl.x, pl.y, 8, 8, 0) then
      pl.y = old_y
      
      -- y 方向更新時碰到牆壁，代表是天花板或地板
      -- 判斷如果 y > 0 就是往下掉，意思就是碰到的是地板
      if (pl.yv > 0) then
        -- 那麼就重設 y 方向速度
        -- 否則之後到邊緣時會因為累積的速度而忽然高速下墜
        pl.yv = 0
      end
    end
  end
end

-- _draw() 函數是 Pico-8 會在每一幀更新後呼叫的函數
-- 這裡面寫的東西就是把更新好的東西畫出來到螢幕上
function _draw()
  -- 清空畫面，把上一次的東西清除
  cls()

  -- 畫出地圖
  -- 用法是 map(地圖上的 x, 地圖上的 y, 要畫到螢幕上的 x, 要畫到螢幕上的 y, 地圖上的寬度, 地圖上的高度)
  -- 地圖最大就是 128 * 64，所以這樣寫就會把整張地圖都畫出來
  map(0, 0, 0, 0, 128, 64)

  -- 畫出角色
  -- 用法是 spr(拼貼圖號碼, 要畫到螢幕上的 x, 要畫到螢幕上的 y)
  -- 所以這裡會把 2 號圖畫到 player 的位置
  -- 如果你使用其他塊作為玩家皮膚，記得改這裡
  spr(2, pl.x, pl.y)
end

-- 我們定義的函數，目的是確認玩家有沒有碰到牆壁（牆壁有 flag）
--[[
  傳入值是 check_map(
    x: 左上角 x 座標, 
    y: 左上角 y 座標,
    w: 寬度,
    h: 高度,
    flag: 要檢查碰的 flag
  )
]]
-- 所以如果呼叫 check_map(pl.x, pl.y, 8, 8, 0)
-- 就是檢查在玩家座標，大小 8 * 8 的碰撞箱有沒有碰到有 0 號 flag 的圖
-- 當然如果你不是用 0 號 flag 來當作牆壁的話，就要改掉這個 0
function check_map(x, y, w, h, flag)
  ---------------------------------------
  -- 因為地圖座標每格是 8 像素，所以要 / 8
  ---------------------------------------

  -- 左邊的 x
  mx_left = x / 8
  -- 上邊的 y
  my_top = y / 8
  -- 右邊的 x
  mx_right = (x + w - 1) / 8
  -- 底邊的 y
  my_bottom = (y + h - 1) / 8

  -- mget(地圖座標 x, 地圖座標 y) 會回傳該格地圖的編號
  -- fget(地圖編號, flag 編號) 會回傳該編號的地圖有沒有指定的 flag
  -- 所以要確認指定地方的地圖有沒有 flag 就要把這兩個串起來
  -- fget( mget(x, y), flag )
  
  -- 左上角
  if fget( mget(mx_left, my_top), flag ) then
    return true
  end
  -- 右上角
  if fget( mget(mx_right, my_top), flag ) then
    return true
  end
  -- 左下角
  if fget( mget(mx_left, my_bottom), flag ) then
    return true
  end
  -- 右下角
  if fget( mget(mx_right, my_bottom), flag ) then
    return true
  end
  
  -- 上面四個都沒通過，那就是沒有碰到了
  return false
end

-- 按 O 鍵就跳起來
if btn(4) then
  pl.yv = -3
end

-- y 方向也是一樣
for i = 1, 16 do
  old_y = pl.y

  pl.y += pl.yv / 16

  if check_map(pl.x, pl.y, 8, 8, 0) then
    pl.y = old_y
    
    -- y 方向更新時碰到牆壁，代表是天花板或地板
    -- 判斷如果 y > 0 就是往下掉，意思就是碰到的是地板
    if (pl.yv > 0) then
      -- 那麼就重設 y 方向速度
      -- 否則之後到邊緣時會因為累積的速度而忽然高速下墜
      pl.yv = 0
    end
  end
end

-- 先預設是沒碰到地板
pl.ground = false

for i = 1, 16 do
  old_y = pl.y

  pl.y += pl.yv / 16

  if check_map(pl.x, pl.y, 8, 8, 0) then
    pl.y = old_y
    
    -- y 方向更新時碰到牆壁，代表是天花板或地板
    -- 判斷如果 y > 0 就是往下掉，意思就是碰到的是地板
    if (pl.yv > 0) then
      -- 那麼就重設 y 方向速度
      -- 否則之後到邊緣時會因為累積的速度而忽然高速下墜
      pl.yv = 0
      
      -- 標記玩家是在地上
      -- 這樣下一幀玩家就可以跳了
      pl.ground = true
    end
  end
end

if time() - pl.last_ground_time < 0.3 and btn(4) then
  pl.yv = -4
  -- 記得一跳就重設
  pl.last_ground_time = -20
end

-- 還沒開始跳 & 與上次在地上的時間差 < 0.3 & 按了 O 鍵，就開始跳
if pl.jump_state == 0 and time() - pl.last_ground_time < 0.3 and btn(4) then
  -- 使用 jump_state 紀錄玩家已經開始跳了
  pl.jump_state = 1;

  -- 記得一跳就重設 last_ground_time
  pl.last_ground_time = -20
end

-- 已經跳完了 / 根本沒按 O 就直接結束
if pl.jump_state >= 5 or ( pl.jump_state >= 1 and not btn(4) ) then
  -- 結束跳躍時把速度減半才不會有向上的慣性太大的感覺
  pl.yv /= 2
  -- 重設 jump_state
  pl.jump_state = 0
end

-- 如果已經開始跳
if pl.jump_state > 0 then
  -- 往上一跳一小部分
  pl.yv -= 1.6

  -- 遞增
  pl.jump_state += 1
end

-- y 方向的速度不斷遞增，畢竟有重力
pl.yv += 0.5

-- 最大下墜速度
if pl.yv > 6 then
  pl.yv = 6
end

if check_map(pl.x, pl.y, 8, 8, 0) then
  pl.y = old_y
  
  if pl.yv > 0 then
    -- ...
  end

  -- 天花板
  if pl.yv < 0 then
    -- 設為一個極小，但會稍微往下掉的值
    pl.yv = 0.1
  end
end

for i = 1, 16 do
  old_y = pl.y

  pl.y += pl.yv / 16

  if check_map(pl.x, pl.y, 8, 8, 0) then
    pl.y = old_y
    
    -- y 方向更新時碰到牆壁，代表是天花板或地板
    -- 判斷如果 y > 0 就是往下掉，意思就是碰到的是地板
    if pl.yv > 0 then
      -- 那麼就重設 y 方向速度
      -- 否則之後到邊緣時會因為累積的速度而忽然高速下墜
      pl.yv = 0
      
      -- 儲存現在的時間到「最後在地上的時間」
      pl.last_ground_time = time()
    end
  end
end

for i = 1, 16 do
  -- 儲存在更新前有沒有碰到橋
  already_touched_bridge = check_map(pl.x, pl.y, 8, 8, 1)

  old_y = pl.y

  pl.y += pl.yv / 16

  if check_map(pl.x, pl.y, 8, 8, 0) then
    pl.y = old_y
    
    -- y 方向更新時碰到牆壁，代表是天花板或地板
    -- 判斷如果 y > 0 就是往下掉，意思就是碰到的是地板
    if pl.yv > 0 then
      -- 那麼就重設 y 方向速度
      -- 否則之後到邊緣時會因為累積的速度而忽然高速下墜
      pl.yv = 0
      
      -- 儲存現在的時間到「最後在地上的時間」
      pl.last_ground_time = time()
    end
  end

  -- 若是 原本沒有碰到 & 現在有碰到 & 正在往下掉
  if (not already_touched_bridge) 
    and check_map(pl.x, pl.y, 8, 8, 1) 
    and pl.yv > 0 
  then
    -- 一樣是有被地板阻擋，回去原本位置並重設 yv
    pl.y = old_y
    pl.yv = 0
    pl.last_ground_time = time()
  end
end

pl = {
  -- ...
  spawn = {
    x = 12,
    y = 12
  }
}

if check_map(pl.x + 1, pl.y + 1, 6, 6, 2) then
  pl.x = pl.spawn.x
  pl.y = pl.spawn.y
  pl.xv = 0
  pl.yv = 0
end

-- _init() 是 Pico-8 在遊戲開始時會呼叫的函數
-- 裡面放要初始化的變數等等
function _init()
  -- pl 變數是一個物件，代表我們的玩家
  pl = {
    -- x 座標、y 座標
    x = 12,
    y = 12,
    -- x 方向速度、y 方向速度
    xv = 0,
    yv = 0,
    -- 上次在地上的時間 & 跳躍的狀態
    last_ground_time = -20,
    jump_state = 0,

    -- 圖形參數
    width = 8,
    height = 8,
    skin = 1,

    -- 放所有會用到的常數，比較方便修改
    const = {
      walk_speed = 0.3,
      drag = 0.8,
      gravity = 0.1,  
      max_yv = 3,
      coyote_time = 0.17,
      jump = {
        start_velocity = -0.8,
        multiplier = 0.6,
        end_drag = 0.6,
        duration = 12
      },
      update_steps = 16,
      map_flags = {
        obstacle = 0,
        bridge = 1
      },
    }
  }
end

-- _update() 是 Pico-8 會在每一幀呼叫的函數
-- 每秒會執行 30 次
-- 若使用 _update60() 則是一秒 60 次
-- 不過這樣很多參數都要調整，否則會太快
function _update60()
  -----------------------------------------
  -- 首先先根據玩家的輸入 btn(id) 來改變速度
  -----------------------------------------

  -- 0 號按鈕是向左，1 號是向右
  -- 根據這兩個按鈕左右移動（改變 x 方向的速度）
  if btn(0) then
    pl.xv -= pl.const.walk_speed
  end
  if btn(1) then
    pl.xv += pl.const.walk_speed
  end

  -- x 方向的速度要有阻力，否則會無限滑走
  -- 假設阻力一直為速度的 20% 好了，那就要 * 80%
  pl.xv *= pl.const.drag

  -- y 方向的速度不斷遞增，畢竟有重力
  pl.yv += pl.const.gravity

  -- 最大下墜速度
  if pl.yv > pl.const.max_yv then
    pl.yv = pl.const.max_yv
  end

  -- 還沒開始跳 & 與上次在地上的時間差 < coyote_time & 按了 O 鍵，就開始跳
  if pl.jump_state == 0 
    and time() - pl.last_ground_time < pl.const.coyote_time 
    and btn(4)
  then
    -- 使用 jump_state 紀錄玩家已經開始跳了
    pl.jump_state = 1

    -- 記得一跳就重設 last_ground_time
    pl.last_ground_time = -20

    -- 初始的向上速度
    pl.yv = -0.8
  end

  -- 已經跳完了 / 根本沒按 O 就直接結束
  if pl.jump_state >= pl.const.jump.duration or ( pl.jump_state > 0 and not btn(4) ) then
    -- 結束跳躍時把速度減少許多，才不會有向上的慣性太大的感覺
    pl.yv *= pl.const.jump.end_drag
    -- 重設 jump_state
    pl.jump_state = 0
  end

  -- 如果已經開始跳
  if pl.jump_state > 0 then
    -- 往上一跳一小部分
    pl.yv -= pl.const.jump.multiplier / pl.jump_state

    -- 遞增
    pl.jump_state += 1
  end

  ----------------------------------
  -- 接下來要根據速度來改變玩家的位置
  ----------------------------------

  -- 加一層 for 迴圈，就可以把很快的速度切割成很多段來更新，避免穿牆
  -- x 方向的更新：
  for i = 1, pl.const.update_steps do
    -- 把舊的位置存起來
    old_x = pl.x

    -- 把位置加上速度，記得 / 16 因為是切成 16 份的其中 1 份
    pl.x += pl.xv / pl.const.update_steps

    -- 若 check_map() 通過，就代表有被阻擋（這是自己定義的函數，在最後面）
    if check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.obstacle) then
      -- 那麼就回去剛才儲存的舊的位置
      pl.x = old_x
    end
  end

  for i = 1, pl.const.update_steps do
    -- 儲存在更新前有沒有碰到橋
    already_touched_bridge = check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.bridge)

    old_y = pl.y

    pl.y += pl.yv / pl.const.update_steps

    if check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.obstacle) then
      pl.y = old_y
      
      -- y 方向更新時碰到牆壁，代表是天花板或地板
      -- 判斷如果 y > 0 就是往下掉，意思就是碰到的是地板
      if pl.yv > 0 then
        -- 那麼就重設 y 方向速度
        -- 否則之後到邊緣時會因為累積的速度而忽然高速下墜
        pl.yv = 0
        
        -- 儲存現在的時間到「最後在地上的時間」
        pl.last_ground_time = time()
      end

      -- 天花板
      if pl.yv < 0 then
        -- 設為一個極小，但會稍微往下掉的值
        pl.yv = 0.1
      end
    end

    -- 若是 原本沒有碰到 & 現在有碰到 & 正在往下掉
    if (not already_touched_bridge)
      and check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.bridge) 
      and pl.yv > 0 
    then
      -- 一樣是有被地板阻擋，回去原本位置並重設 yv
      pl.y = old_y
      pl.yv = 0
      pl.last_ground_time = time()
    end
  end
end

-- _draw() 函數是 Pico-8 會在每一幀更新後呼叫的函數
-- 這裡面寫的東西就是把更新好的東西畫出來到螢幕上
function _draw()
  -- 清空畫面，把上一次的東西清除
  cls()

  -- 畫出地圖
  -- 用法是 map(地圖上的 x, 地圖上的 y, 要畫到螢幕上的 x, 要畫到螢幕上的 y, 地圖上的寬度, 地圖上的高度)
  -- 地圖最大就是 128 * 64，所以這樣寫就會把整張地圖都畫出來
  map(0, 0, 0, 0, 128, 64)

  -- 畫出角色
  -- 用法是 spr(拼貼圖號碼, 要畫到螢幕上的 x, 要畫到螢幕上的 y)
  -- 所以這裡會把 2 號圖畫到 player 的位置
  -- 如果你使用其他塊作為玩家皮膚，記得改這裡
  spr(pl.skin, pl.x, pl.y)
end

-- 我們定義的函數，目的是確認玩家有沒有碰到牆壁（牆壁有 flag）
--[[
  傳入值是 check_map(
    x: 左上角 x 座標, 
    y: 左上角 y 座標,
    w: 寬度,
    h: 高度,
    flag: 要檢查碰的 flag
  )
]]
-- 所以如果呼叫 check_map(pl.x, pl.y, 8, 8, 0)
-- 就是檢查在玩家座標，大小 8 * 8 的碰撞箱有沒有碰到有 0 號 flag 的圖
-- 當然如果你不是用 0 號 flag 來當作牆壁的話，就要改掉這個 0
function check_map(x, y, w, h, flag)
  ---------------------------------------
  -- 因為地圖座標每格是 8 像素，所以要 / 8
  ---------------------------------------

  -- 左邊的 x
  mx_left = x / 8
  -- 上邊的 y
  my_top = y / 8
  -- 右邊的 x
  mx_right = (x + w - 1) / 8
  -- 底邊的 y
  my_bottom = (y + h - 1) / 8

  -- mget(地圖座標 x, 地圖座標 y) 會回傳該格地圖的編號
  -- fget(地圖編號, flag 編號) 會回傳該編號的地圖有沒有指定的 flag
  -- 所以要確認指定地方的地圖有沒有 flag 就要把這兩個串起來
  -- fget( mget(x, y), flag )
  
  -- 左上角
  if fget( mget(mx_left, my_top), flag ) then
    return true
  end
  -- 右上角
  if fget( mget(mx_right, my_top), flag ) then
    return true
  end
  -- 左下角
  if fget( mget(mx_left, my_bottom), flag ) then
    return true
  end
  -- 右下角
  if fget( mget(mx_right, my_bottom), flag ) then
    return true
  end
  
  -- 上面四個都沒通過，那就是沒有碰到了
  return false
end

function _init()
  pl = {
    x = 12,
    y = 12,
    xv = 0,
    yv = 0,
    last_ground_time = -20,
    jump_state = 0,

    width = 8,
    height = 8,
    skin = 1,

    const = {
      walk_speed = 0.3,
      drag = 0.8,
      gravity = 0.1,
      max_yv = 3,
      coyote_time = 0.17,
      jump = {
        start_velocity = -0.8,
        multiplier = 0.6,
        end_drag = 0.6,
        duration = 12
      },
      update_steps = 16,
      map_flags = {
        obstacle = 0,
        bridge = 1
      },
    }
  }
end

function _update60()
  if btn(0) then
    pl.xv -= pl.const.walk_speed
  end
  if btn(1) then
    pl.xv += pl.const.walk_speed
  end

  pl.xv *= pl.const.drag

  pl.yv += pl.const.gravity

  if pl.yv > pl.const.max_yv then
    pl.yv = pl.const.max_yv
  end

  if pl.jump_state == 0
    and time() - pl.last_ground_time < pl.const.coyote_time
    and btn(4)
  then
    pl.jump_state = 1

    pl.last_ground_time = -20

    pl.yv = -0.8
  end

  if pl.jump_state >= pl.const.jump.duration or ( pl.jump_state > 0 and not btn(4) ) then
    pl.yv *= pl.const.jump.end_drag
    pl.jump_state = 0
  end

  if pl.jump_state > 0 then
    pl.yv -= pl.const.jump.multiplier / pl.jump_state

    pl.jump_state += 1
  end


  for i = 1, pl.const.update_steps do
    old_x = pl.x

    pl.x += pl.xv / pl.const.update_steps

    if check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.obstacle) then
      pl.x = old_x
    end
  end

  for i = 1, pl.const.update_steps do
    already_touched_bridge = check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.bridge)

    old_y = pl.y

    pl.y += pl.yv / pl.const.update_steps

    if check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.obstacle) then
      pl.y = old_y

      if pl.yv > 0 then
        pl.yv = 0

        pl.last_ground_time = time()
      end

      if pl.yv < 0 then
        pl.yv = 0.1
      end
    end

    if (not already_touched_bridge)
      and check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.bridge)
      and pl.yv > 0
    then
      pl.y = old_y
      pl.yv = 0
      pl.last_ground_time = time()
    end
  end
end

function _draw()
  cls()
  map(0, 0, 0, 0, 128, 64)
  spr(pl.skin, pl.x, pl.y)
end

function check_map(x, y, w, h, flag)
  mx_left = x / 8
  my_top = y / 8
  mx_right = (x + w - 1) / 8
  my_bottom = (y + h - 1) / 8

  if fget( mget(mx_left, my_top), flag ) then
    return true
  end
  if fget( mget(mx_right, my_top), flag ) then
    return true
  end
  if fget( mget(mx_left, my_bottom), flag ) then
    return true
  end
  if fget( mget(mx_right, my_bottom), flag ) then
    return true
  end

  return false
end

-- 宣告攝影機物件
cam = {
  -- tx, ty 是目標座標
  tx = pl.x - 59,
  ty = pl.y- 59,
  -- x, y 是真正的座標
  x = pl.x - 59,
  y = pl.y - 59
}

-- 攝影機的目標就是 玩家位置 + 玩家的寬度的一半 - 螢幕的一半
  cam.tx = pl.x - 59
  cam.ty = pl.y - 59
  -- 攝影機慢慢追上目標
  cam.x = cam.x + 0.3 * (cam.tx - cam.x)
  cam.y = cam.y + 0.3 * (cam.ty - cam.y)

-- 使用 cam 作為攝影機座標
  camera(cam.x, cam.y)

-- 宣告攝影機物件
cam = {
  -- tx, ty 是目標座標
  tx = pl.x - 59,
  ty = pl.y- 59,
  -- x, y 是真正的座標
  x = pl.x - 59,
  y = pl.y - 59
}

-- 攝影機的目標就是 玩家位置 + 玩家的寬度的一半 - 螢幕的一半
  cam.tx = pl.x - 59
  cam.ty = pl.y - 59
  -- 攝影機慢慢追上目標
  cam.x = cam.x + 0.3 * (cam.tx - cam.x)
  cam.y = cam.y + 0.3 * (cam.ty - cam.y)

-- 使用 cam 作為攝影機座標
  camera(cam.x, cam.y)

-- 使用 cam 作為攝影機座標
  camera(cam.x, cam.y)

spr(n, x, y, [w, h], [flip_x], [flip_y])

-- lock color in editor
poke(0x5f2e, 1)
-- apoke: change palette A to B
function apoke(a, b)
  poke(0x5f10 + a, 128 + b - 16)
end

function _init() {
  init_player()
  init_camera()
}

-- _update, _draw ...

function init_player() {
  -- ...
}

-- update_player, draw_player ...

function init_camera() {
  -- ...
}

-- ...

function _update()
  if scene == "titlescreen" then
    update_titlescreen()
  end
  if scene == "playing" then
    update_player()
    update_camera()
  end
end

sfx(音樂片段編號)

music(合成後的音樂的編號)

save mygame.p8.png

pl = {
  -- ...

  left_wall = false,
  right_wall = false
}

-- 判斷牆壁
pl.left_wall = check_map(pl.x - 1, pl.y, 1, pl.height, pl.const.map_flags.obstacle)
pl.right_wall = check_map(pl.x + pl.width, pl.y, 1, pl.height, pl.const.map_flags.obstacle)

if btn(0) then
  pl.xv -= pl.const.walk_speed
  pl.mirror = true
  if pl.yv > 0 and pl.left_wall then
    pl.yv *= pl.const.wall_drag
  end
end
if btn(1) then
  pl.xv += pl.const.walk_speed
  pl.mirror = false
  if pl.yv > 0 and pl.right_wall then
    pl.yv *= pl.const.wall_drag
  end
end

pl = {
  -- ...
  wall_jump_state = 0,
  wall_jumo_direction = 1,
}

-- 踢牆跳
  if 
    btn(4) and pl.wall_jump_state == 0
    and pl.jump_state == 0 -- 判斷玩家不在地上
  then
    if pl.left_wall then
      pl.wall_jump_state = 1
      pl.wall_jump_direction = 1
    end
    if pl.right_wall then
      pl.wall_jump_state = 1
      pl.wall_jump_direction = -1
    end
  end

  if 
    pl.wall_jump_state >= pl.const.jump.duration 
    or ( pl.wall_jump_state > 0 and not btn(4) ) 
  then
    pl.wall_jump_state = 0
  end

  if pl.wall_jump_state > 0 then
    pl.yv = -1.4
    pl.xv += 0.5 * pl.wall_jump_direction
    
    pl.wall_jump_state += 1
  end

-- _init() 是 Pico-8 在遊戲開始時會呼叫的函數
-- 裡面放要初始化的變數等等
function _init()
  -- pl 變數是一個物件，代表我們的玩家
  pl = {
    -- x 座標、y 座標
    x = 0,
    y = 0,
    -- x 方向速度、y 方向速度
    xv = 0,
    yv = 0,
    -- 上次在地上的時間 & 跳躍的狀態
    last_ground_time = -20,
    jump_state = 0,
    -- 牆壁
    left_wall = false,
    right_wall = false,
    wall_jump_state = 0,
    wall_jumo_direction = 1,

    -- 圖形參數
    width = 6,
    height = 8,
    skin = 1,
    mirror = false,

    -- 重生點
    spawn = {
      x = 12,
      y = 12
    },

    -- 放所有會用到的常數，比較方便修改
    const = {
      walk_speed = 0.46,
      drag = 0.7122,
      wall_drag = 0.7854,
      gravity = 0.1,  
      max_yv = 3,
      coyote_time = 0.17,
      jump = {
        start_velocity = -0.5,
        multiplier = 0.54,
        end_drag = 0.6,
        duration = 12
      },
      update_steps = 16,
      map_flags = {
        obstacle = 0,
        bridge = 1,
        spike = 2
      }
    }
  }

  -- 一開始就傳送到重生點
  pl.x = pl.spawn.x
  pl.y = pl.spawn.y

  -- 宣告攝影機物件
  cam = {
    -- tx, ty 是目標座標
    tx = pl.x - 59,
    ty = pl.y- 59,
    -- x, y 是真正的座標
    x = pl.x - 59,
    y = pl.y - 59
  }
end

-- _update() 是 Pico-8 會在每一幀呼叫的函數
-- 每秒會執行 30 次
-- 若使用 _update60() 則是一秒 60 次
-- 不過這樣很多參數都要調整，否則會太快
function _update60()
  -----------------------------------------
  -- 首先先根據玩家的輸入 btn(id) 來改變速度
  -----------------------------------------

  -- 0 號按鈕是向左，1 號是向右
  -- 根據這兩個按鈕左右移動（改變 x 方向的速度）
  if pl.wall_jump_state == 0 then
    if btn(0) then
      pl.xv -= pl.const.walk_speed
      pl.mirror = true
      if pl.yv > 0 and pl.left_wall then
        pl.yv *= pl.const.wall_drag
      end
    end
    if btn(1) then
      pl.xv += pl.const.walk_speed
      pl.mirror = false
      if pl.yv > 0 and pl.right_wall then
        pl.yv *= pl.const.wall_drag
      end
    end
  end

  -- x 方向的速度要有阻力，否則會無限滑走
  -- 假設阻力一直為速度的 20% 好了，那就要 * 80%
  pl.xv *= pl.const.drag

  -- y 方向的速度不斷遞增，畢竟有重力
  pl.yv += pl.const.gravity

  -- 最大下墜速度
  if pl.yv > pl.const.max_yv then
    pl.yv = pl.const.max_yv
  end

  -- 還沒開始跳 & 與上次在地上的時間差 < coyote_time & 按了 O 鍵，就開始跳
  if pl.jump_state == 0 
    and time() - pl.last_ground_time < pl.const.coyote_time 
    and btn(4)
  then
    -- 使用 jump_state 紀錄玩家已經開始跳了
    pl.jump_state = 1

    -- 記得一跳就重設 last_ground_time
    pl.last_ground_time = -20

    -- 初始的向上速度
    pl.yv = -0.8
  end

  -- 已經跳完了 / 根本沒按 O 就直接結束
  if pl.jump_state >= pl.const.jump.duration or ( pl.jump_state > 0 and not btn(4) ) then
    -- 結束跳躍時把速度減少許多，才不會有向上的慣性太大的感覺
    pl.yv *= pl.const.jump.end_drag
    -- 重設 jump_state
    pl.jump_state = 0
  end

  -- 如果已經開始跳
  if pl.jump_state > 0 then
    -- 往上一跳一小部分
    pl.yv -= pl.const.jump.multiplier / pl.jump_state

    -- 遞增
    pl.jump_state += 1
  end

  -- 踢牆跳
  if 
    btn(4) and pl.wall_jump_state == 0
    and pl.jump_state == 0 -- 判斷玩家不在地上
  then
    if pl.left_wall then
      pl.wall_jump_state = 1
      pl.wall_jump_direction = 1
    end
    if pl.right_wall then
      pl.wall_jump_state = 1
      pl.wall_jump_direction = -1
    end
  end

  if pl.wall_jump_state >= pl.const.jump.duration or ( pl.wall_jump_state > 0 and not btn(4) ) then
    pl.wall_jump_state = 0
  end

  if pl.wall_jump_state > 0 then
    pl.yv = -1.4
    pl.xv += 0.5 * pl.wall_jump_direction
    
    pl.wall_jump_state += 1
  end

  ----------------------------------
  -- 接下來要根據速度來改變玩家的位置
  ----------------------------------

  -- 加一層 for 迴圈，就可以把很快的速度切割成很多段來更新，避免穿牆
  -- x 方向的更新：
  for i = 1, pl.const.update_steps do
    -- 把舊的位置存起來
    old_x = pl.x

    -- 把位置加上速度，記得 / 16 因為是切成 16 份的其中 1 份
    pl.x += pl.xv / pl.const.update_steps

    -- 若 check_map() 通過，就代表有被阻擋（這是自己定義的函數，在最後面）
    if check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.obstacle) then
      -- 那麼就回去剛才儲存的舊的位置
      pl.x = old_x
    end
  end

  for i = 1, pl.const.update_steps do
    -- 儲存在更新前有沒有碰到橋
    already_touched_bridge = check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.bridge)

    old_y = pl.y

    pl.y += pl.yv / pl.const.update_steps

    if check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.obstacle) then
      pl.y = old_y
      
      -- y 方向更新時碰到牆壁，代表是天花板或地板
      -- 判斷如果 y > 0 就是往下掉，意思就是碰到的是地板
      if pl.yv > 0 then
        -- 那麼就重設 y 方向速度
        -- 否則之後到邊緣時會因為累積的速度而忽然高速下墜
        pl.yv = 0
        
        -- 儲存現在的時間到「最後在地上的時間」
        pl.last_ground_time = time()
      end

      -- 天花板
      if pl.yv < 0 then
        -- 設為一個極小，但會稍微往下掉的值
        pl.yv = 0.1
      end
    end

    -- 若是 原本沒有碰到 & 現在有碰到 & 正在往下掉
    if (not already_touched_bridge)
      and check_map(pl.x, pl.y, pl.width, pl.height, pl.const.map_flags.bridge) 
      and pl.yv > 0 
    then
      -- 一樣是有被地板阻擋，回去原本位置並重設 yv
      pl.y = old_y
      pl.yv = 0
      pl.last_ground_time = time()
    end
  end

  -- 判斷牆壁
  pl.left_wall = check_map(pl.x - 1, pl.y, 1, pl.height, pl.const.map_flags.obstacle)
  pl.right_wall = check_map(pl.x + pl.width, pl.y, 1, pl.height, pl.const.map_flags.obstacle)

  -- 判斷尖刺
  if check_map(pl.x + 1, pl.y + 1, pl.width - 2, pl.height - 2, pl.const.map_flags.spike) then
    -- 回到重生點
    pl.x = pl.spawn.x
    pl.y = pl.spawn.y
    pl.xv = 0
    pl.yv = 0
  end

  -- 玩家動畫
  pl.skin = 1 + flr((time() * 10) % 4)

  -- 攝影機的目標就是 玩家位置 + 玩家的寬度的一半 - 螢幕的一半
  cam.tx = pl.x - 59
  cam.ty = pl.y - 59
  -- 攝影機慢慢追上目標
  cam.x = cam.x + 0.1658 * (cam.tx - cam.x)
  cam.y = cam.y + 0.1658 * (cam.ty - cam.y)
end

-- _draw() 函數是 Pico-8 會在每一幀更新後呼叫的函數
-- 這裡面寫的東西就是把更新好的東西畫出來到螢幕上
function _draw()
  -- 清空畫面，把上一次的東西清除
  cls()

  -- 使用 cam 作為攝影機座標
  camera( flr(cam.x + 0.5), flr(cam.y + 0.5) )

  -- 畫出地圖
  -- 用法是 map(地圖上的 x, 地圖上的 y, 要畫到螢幕上的 x, 要畫到螢幕上的 y, 地圖上的寬度, 地圖上的高度)
  -- 地圖最大就是 128 * 64，所以這樣寫就會把整張地圖都畫出來
  map(0, 0, 0, 0, 128, 64)

  -- 畫出角色
  -- 用法是 spr(拼貼圖號碼, 要畫到螢幕上的 x, 要畫到螢幕上的 y, Sprite 寬度, Sprite 高度, 水平翻轉, 垂直翻轉)
  -- 所以這裡會把 2 號圖畫到 player 的位置
  -- 如果你使用其他塊作為玩家皮膚，記得改這裡
  spr(pl.skin, pl.x - 1, pl.y, 1, 1, pl.mirror, false)
end

-- 我們定義的函數，目的是確認玩家有沒有碰到牆壁（牆壁有 flag）
--[[
  傳入值是 check_map(
    x: 左上角 x 座標, 
    y: 左上角 y 座標,
    w: 寬度,
    h: 高度,
    flag: 要檢查碰的 flag
  )
]]
-- 所以如果呼叫 check_map(pl.x, pl.y, 8, 8, 0)
-- 就是檢查在玩家座標，大小 8 * 8 的碰撞箱有沒有碰到有 0 號 flag 的圖
-- 當然如果你不是用 0 號 flag 來當作牆壁的話，就要改掉這個 0
function check_map(x, y, w, h, flag)
  ---------------------------------------
  -- 因為地圖座標每格是 8 像素，所以要 / 8
  ---------------------------------------

  -- 左邊的 x
  mx_left = x / 8
  -- 上邊的 y
  my_top = y / 8
  -- 右邊的 x
  mx_right = (x + w - 1) / 8
  -- 底邊的 y
  my_bottom = (y + h - 1) / 8

  -- mget(地圖座標 x, 地圖座標 y) 會回傳該格地圖的編號
  -- fget(地圖編號, flag 編號) 會回傳該編號的地圖有沒有指定的 flag
  -- 所以要確認指定地方的地圖有沒有 flag 就要把這兩個串起來
  -- fget( mget(x, y), flag )
  
  -- 左上角
  if fget( mget(mx_left, my_top), flag ) then
    return true
  end
  -- 右上角
  if fget( mget(mx_right, my_top), flag ) then
    return true
  end
  -- 左下角
  if fget( mget(mx_left, my_bottom), flag ) then
    return true
  end
  -- 右下角
  if fget( mget(mx_right, my_bottom), flag ) then
    return true
  end
  
  -- 上面四個都沒通過，那就是沒有碰到了
  return false
end

-- 一個簡單的 driver 程式

function _init()
  init_particles()
end

function _update60()
  -- 每幀隨便地新增一個隨機粒子
  add(particles, {
    x = rnd(128),
    y = rnd(128),
    size = 1 + rnd(4),
    xv = rnd(1.2) - 0.6,
    yv = rnd(1.2) - 0.6,
  })

  update_particles()
end

function _draw()
  cls(0)

  draw_particles()
end

-->8
-- particles 部分

function init_particles()
  particles = {}
end

function update_particles()
  foreach(particles, update_each_particle)
end

-- 自動傳入 p 當作 particles 中的單個粒子
function update_each_particle(p)
  p.x += p.xv
  p.y += p.yv

  p.size -= 0.1
  if p.size <= 0 then
    del(particles, p)
  end
end

function draw_particles()
  foreach(particles, draw_each_particle)
end

function draw_each_particle(p)
  circfill(p.x, p.y, p.size, 7)
end