-- title:   Pip's Peak (lesson 1)
-- author:  TIC-80 Platformer Course
-- desc:    Meet TIC-80: the game loop
-- script:  lua

-- == State ==
-- Variables declared up here (without `local`) are globals: they keep
-- their value from one frame to the next.
x = 120
y = 60
t = 0

-- == Game loop ==
-- TIC-80 calls TIC() 60 times every second. Each call is one frame:
-- read the buttons, update the state, then draw everything again.
function TIC()
  t = t + 1

  -- the arrow keys are buttons 0 (up), 1 (down), 2 (left) and 3 (right)
  if btn(0) then y = y - 1 end
  if btn(1) then y = y + 1 end
  if btn(2) then x = x - 1 end
  if btn(3) then x = x + 1 end

  cls(10)                        -- clear the screen to color 10 (sky blue)
  rect(0, 112, 240, 24, 6)       -- grass: x, y, width, height, color
  circ(x, y, 6, 4)               -- a yellow ball: center x, y, radius, color
  print("HELLO, TIC-80!", 78, 20, 12)
  print("frame " .. t, 4, 4, 0)
end

-- title:   Pip's Peak (lesson 2)
-- author:  TIC-80 Platformer Course
-- desc:    The sprite editor: drawing Pip
-- script:  lua

-- == Constants ==
-- TIC-80 has no names for its buttons, so we make our own.
local BTN_LEFT, BTN_RIGHT = 2, 3     -- 0 is up, 1 is down
local PIP = 256          -- sprite 256 is the first one on the SPRITES tab

-- == State ==
player = {x = 116, y = 104}

-- == Game loop ==
function TIC()
  if btn(BTN_LEFT) then
    player.x = player.x - 1
  end
  if btn(BTN_RIGHT) then
    player.x = player.x + 1
  end

  cls(10)
  rect(0, 112, 240, 24, 6)
  -- spr(id, x, y, colorkey): pixels of the colorkey color are see-through
  spr(PIP, player.x, player.y, 0)
end

-- title:   Pip's Peak (lesson 3)
-- author:  TIC-80 Platformer Course
-- desc:    Animation: making Pip walk
-- script:  lua

-- == Constants ==
local BTN_LEFT, BTN_RIGHT = 2, 3     -- 0 is up, 1 is down
-- animations are lists of sprite ids
local ANIM_IDLE = {256, 257}
local ANIM_RUN = {258, 259, 260, 261}

-- == State ==
player = {
  x = 116, y = 104, flip = 0,
  moving = false
}
t = 0   -- frame counter: animations use it as their clock

-- == Animation ==
-- The sprite to show now for an animation that changes every `speed` frames.
function anim_frame(frames, speed)
  return
    frames[(t // speed) % #frames + 1]
end

-- == Player ==
function update_player(p)
  p.moving = false
  if btn(BTN_LEFT) then
    p.x = p.x - 1
    p.flip = 1          -- the sprites face right; flip them to face left
    p.moving = true
  end
  if btn(BTN_RIGHT) then
    p.x = p.x + 1
    p.flip = 0
    p.moving = true
  end
end

function draw_player(p)
  local id
  if p.moving then
    id = anim_frame(ANIM_RUN, 6)
  else
    id = anim_frame(ANIM_IDLE, 30)
  end
  spr(id, p.x, p.y, 0, 1, p.flip)
end

-- == Game loop ==
function TIC()
  t = t + 1
  update_player(player)

  cls(10)
  rect(0, 112, 240, 24, 6)
  draw_player(player)
end

-- title:   Pip's Peak (lesson 4)
-- author:  TIC-80 Platformer Course
-- desc:    Palettes: day and night
-- script:  lua

-- == Constants ==
local BTN_LEFT = 2
local BTN_RIGHT = 3
local BTN_A = 4   -- A is the Z key
local ANIM_IDLE = {256, 257}
local ANIM_RUN = {258, 259, 260, 261}
local PALETTE_ADDR = 0x3FC0   -- 16 colors x 3 bytes (red, green, blue) in RAM

-- colors to change at night: palette index -> 0xRRGGBB
local NIGHT = {
  [10] = 0x29366f, [6] = 0x257179,
  [12] = 0xc8d8f0
}

-- == State ==
player = {
  x = 116, y = 104, flip = 0,
  moving = false
}
t = 0
night = false
day_colors = {}   -- the cart's own palette, saved in BOOT

-- == Palette ==
function get_color(i)
  local a = PALETTE_ADDR + i * 3
  return peek(a) << 16 | peek(a
      + 1) << 8 | peek(a + 2)
end

function set_color(i, rgb)
  local a = PALETTE_ADDR + i * 3
  poke(a, rgb >> 16 & 0xff)
  poke(a + 1, rgb >> 8 & 0xff)
  poke(a + 2, rgb & 0xff)
end

function apply_palette()
  for i = 0, 15 do
    set_color(i, day_colors[i])
  end
  if night then
    for i, rgb in pairs(NIGHT) do
      set_color(i, rgb)
    end
  end
end

-- == Animation ==
function anim_frame(frames, speed)
  return
    frames[(t // speed) % #frames + 1]
end

-- == Player ==
function update_player(p)
  p.moving = false
  if btn(BTN_LEFT) then
    p.x = p.x - 1
    p.flip = 1
    p.moving = true
  end
  if btn(BTN_RIGHT) then
    p.x = p.x + 1
    p.flip = 0
    p.moving = true
  end
end

function draw_player(p)
  local id
  if p.moving then
    id = anim_frame(ANIM_RUN, 6)
  else
    id = anim_frame(ANIM_IDLE, 30)
  end
  spr(id, p.x, p.y, 0, 1, p.flip)
end

-- == Game loop ==
function BOOT()
  for i = 0, 15 do
    day_colors[i] = get_color(i)
  end
end

function TIC()
  t = t + 1
  if btnp(BTN_A) then
    night = not night
    apply_palette()
  end
  update_player(player)

  cls(10)
  rect(0, 112, 240, 24, 6)
  if night then   -- moon or sun
    circ(200, 24, 8, 12)
  else
    circ(200, 24, 10, 4)
  end
  draw_player(player)
  print("Z: day/night", 4, 4, 12)
end

-- title:   Pip's Peak (lesson 5)
-- author:  TIC-80 Platformer Course
-- desc:    Gravity and jumping
-- script:  lua

-- == Constants ==
local BTN_LEFT = 2
local BTN_RIGHT = 3
local BTN_A = 4   -- A is the Z key
local ANIM_IDLE = {256, 257}
local ANIM_RUN = {258, 259, 260, 261}
local SPR_JUMP, SPR_FALL = 262, 263

local GROUND_Y = 104    -- Pip stands here (the grass starts at y = 112)
local GRAVITY = 0.25    -- added to vy every frame (pixels per frame per frame)
local JUMP_SPEED = -4   -- vy when a jump starts (negative is up)
local JUMP_CUT = -1.5   -- releasing the button early caps vy here
local MAX_FALL = 4      -- the fastest Pip can fall

-- == State ==
player = {
  x = 116, y = GROUND_Y, vy = 0,
  flip = 0, moving = false,
  ground = true, jumping = false
}
t = 0

-- == Animation ==
function anim_frame(frames, speed)
  return
    frames[(t // speed) % #frames + 1]
end

-- == Player ==
function update_player(p)
  p.moving = false
  if btn(BTN_LEFT) then
    p.x = p.x - 1
    p.flip = 1
    p.moving = true
  end
  if btn(BTN_RIGHT) then
    p.x = p.x + 1
    p.flip = 0
    p.moving = true
  end

  -- jump: btnp is true only on the frame the button goes down
  if btnp(BTN_A) and p.ground then
    p.vy = JUMP_SPEED
    p.ground = false
    p.jumping = true
  end
  -- let go early for a short hop (only a jump Pip started can be cut short)
  if p.jumping and not btn(BTN_A)
      and p.vy < JUMP_CUT then
    p.vy = JUMP_CUT
  end
  if p.vy >= 0 then
    p.jumping = false
  end

  -- gravity speeds the fall up, every frame
  p.vy =
    math.min(p.vy + GRAVITY, MAX_FALL)
  p.y = p.y + p.vy

  -- land on the ground
  if p.y >= GROUND_Y then
    p.y = GROUND_Y
    p.vy = 0
    p.ground = true
  end
end

function draw_player(p)
  local id
  if not p.ground then
    if p.vy < 0 then
      id = SPR_JUMP
    else
      id = SPR_FALL
    end
  elseif p.moving then
    id = anim_frame(ANIM_RUN, 6)
  else
    id = anim_frame(ANIM_IDLE, 30)
  end
  spr(id, p.x, p.y, 0, 1, p.flip)
end

-- == Game loop ==
function TIC()
  t = t + 1
  update_player(player)

  cls(10)
  rect(0, 112, 240, 24, 6)
  draw_player(player)
end

-- title:   Pip's Peak (lesson 6)
-- author:  TIC-80 Platformer Course
-- desc:    Tiles and the map editor
-- script:  lua

-- == Constants ==
local BTN_LEFT = 2
local BTN_RIGHT = 3
local BTN_A = 4   -- A is the Z key
local ANIM_IDLE = {256, 257}
local ANIM_RUN = {258, 259, 260, 261}
local SPR_JUMP, SPR_FALL = 262, 263

local GROUND_Y = 104    -- Pip stands on the map's grass (row 14 starts at y = 112)
local GRAVITY = 0.25    -- added to vy every frame (pixels per frame per frame)
local JUMP_SPEED = -4   -- vy when a jump starts (negative is up)
local JUMP_CUT = -1.5   -- releasing the button early caps vy here
local MAX_FALL = 4      -- the fastest Pip can fall

-- == State ==
player = {
  x = 116, y = GROUND_Y, vy = 0,
  flip = 0, moving = false,
  ground = true, jumping = false
}
t = 0

-- == Animation ==
function anim_frame(frames, speed)
  return
    frames[(t // speed) % #frames + 1]
end

-- == Player ==
function update_player(p)
  p.moving = false
  if btn(BTN_LEFT) then
    p.x = p.x - 1
    p.flip = 1
    p.moving = true
  end
  if btn(BTN_RIGHT) then
    p.x = p.x + 1
    p.flip = 0
    p.moving = true
  end

  -- jump: btnp is true only on the frame the button goes down
  if btnp(BTN_A) and p.ground then
    p.vy = JUMP_SPEED
    p.ground = false
    p.jumping = true
  end
  -- let go early for a short hop (only a jump Pip started can be cut short)
  if p.jumping and not btn(BTN_A)
      and p.vy < JUMP_CUT then
    p.vy = JUMP_CUT
  end
  if p.vy >= 0 then
    p.jumping = false
  end

  -- gravity speeds the fall up, every frame
  p.vy =
    math.min(p.vy + GRAVITY, MAX_FALL)
  p.y = p.y + p.vy

  -- land on the ground
  if p.y >= GROUND_Y then
    p.y = GROUND_Y
    p.vy = 0
    p.ground = true
  end
end

function draw_player(p)
  local id
  if not p.ground then
    if p.vy < 0 then
      id = SPR_JUMP
    else
      id = SPR_FALL
    end
  elseif p.moving then
    id = anim_frame(ANIM_RUN, 6)
  else
    id = anim_frame(ANIM_IDLE, 30)
  end
  spr(id, p.x, p.y, 0, 1, p.flip)
end

-- == Game loop ==
function TIC()
  t = t + 1
  update_player(player)

  cls(10)
  -- map(cell x, cell y, width, height, screen x, screen y, colorkey):
  -- draw the first screen of the map; color 0 lets the sky show through
  map(0, 0, 30, 17, 0, 0, 0)
  draw_player(player)
end

-- title:   Pip's Peak (lesson 7)
-- author:  TIC-80 Platformer Course
-- desc:    Tile collision
-- script:  lua

-- == Constants ==
local BTN_LEFT = 2
local BTN_RIGHT = 3
local BTN_A = 4   -- A is the Z key
local ANIM_IDLE = {256, 257}
local ANIM_RUN = {258, 259, 260, 261}
local SPR_JUMP, SPR_FALL = 262, 263

local F_SOLID = 0       -- sprite flag 0 marks tiles you can stand on

local GRAVITY = 0.25
local JUMP_SPEED = -4
local JUMP_CUT = -1.5
local MAX_FALL = 4
local START_X, START_Y = 16, 80

-- == State ==
-- x, y is the top-left corner of Pip's hitbox, a 6x8 box (the sprite is
-- drawn one pixel to the left so the box sits in the middle of it)
player = {
  x = START_X, y = START_Y, w = 6,
  h = 8, vy = 0, flip = 0,
  moving = false, ground = false,
  jumping = false
}
t = 0

-- == Collision ==
-- Is the map tile at cell (tx, ty) solid?
function solid_at(tx, ty)
  return fget(mget(tx, ty), F_SOLID)
end

-- Does a w x h box at pixel (x, y) overlap any solid tile?
function box_hits(x, y, w, h)
  for ty = y // 8, (y + h - 1) // 8 do
    for tx = x // 8,
        (x + w - 1) // 8 do
      if solid_at(tx, ty) then
        return true
      end
    end
  end
  return false
end

-- Move e sideways by dx; if that runs into a wall, push it back out.
-- Returns true when it hit something.
function move_x(e, dx)
  e.x = e.x + dx
  if not box_hits(e.x, e.y, e.w, e.h)
  then
    return false
  end
  if dx > 0 then
    e.x =
      (e.x + e.w - 1) // 8 * 8 - e.w   -- just left of the wall
  else
    e.x = e.x // 8 * 8 + 8                  -- just right of the wall
  end
  return true
end

-- Move e up or down by dy, the same way.
function move_y(e, dy)
  e.y = e.y + dy
  if not box_hits(e.x, e.y, e.w, e.h)
  then
    return false
  end
  if dy > 0 then
    e.y =
      (e.y + e.h - 1) // 8 * 8 - e.h   -- standing on the tile
  else
    e.y = e.y // 8 * 8 + 8                  -- head against the ceiling
  end
  return true
end

-- == Animation ==
function anim_frame(frames, speed)
  return
    frames[(t // speed) % #frames + 1]
end

-- == Player ==
function update_player(p)
  local dx = 0
  p.moving = false
  if btn(BTN_LEFT) then
    dx = -1
    p.flip = 1
    p.moving = true
  end
  if btn(BTN_RIGHT) then
    dx = 1
    p.flip = 0
    p.moving = true
  end
  move_x(p, dx)
  p.x = math.max(0,
      math.min(p.x, 240 - p.w))   -- stay on the screen

  if btnp(BTN_A) and p.ground then
    p.vy = JUMP_SPEED
    p.jumping = true
  end
  if p.jumping and not btn(BTN_A)
      and p.vy < JUMP_CUT then
    p.vy = JUMP_CUT
  end
  if p.vy >= 0 then
    p.jumping = false
  end

  -- move one axis at a time: sideways first (above), then up or down
  p.vy =
    math.min(p.vy + GRAVITY, MAX_FALL)
  if move_y(p, p.vy) then p.vy = 0 end
  -- standing on something? look one pixel below the feet
  p.ground =
    box_hits(p.x, p.y + 1, p.w, p.h)
  if p.ground and p.vy > 0 then
    p.vy = 0
    p.y = p.y // 1      -- drop the fraction gravity added
  end

  -- fell off the bottom of the screen: start again
  if p.y > 136 then
    p.x, p.y, p.vy =
      START_X, START_Y, 0
  end
end

function draw_player(p)
  local id
  if not p.ground then
    if p.vy < 0 then
      id = SPR_JUMP
    else
      id = SPR_FALL
    end
  elseif p.moving then
    id = anim_frame(ANIM_RUN, 6)
  else
    id = anim_frame(ANIM_IDLE, 30)
  end
  spr(id, p.x - 1, p.y, 0, 1, p.flip)
end

-- == Game loop ==
function TIC()
  t = t + 1
  update_player(player)

  cls(10)
  map(0, 0, 30, 17, 0, 0, 0)
  draw_player(player)
end

-- title:   Pip's Peak (lesson 8)
-- author:  TIC-80 Platformer Course
-- desc:    Game feel
-- script:  lua

-- == Constants ==
local BTN_LEFT = 2
local BTN_RIGHT = 3
local BTN_A = 4   -- A is the Z key
local ANIM_IDLE = {256, 257}
local ANIM_RUN = {258, 259, 260, 261}
local SPR_JUMP = 262
local SPR_FALL = 263
local SPR_SQUASH = 265

local F_SOLID = 0       -- sprite flag 0 marks tiles you can stand on

local START_X, START_Y = 16, 80

-- Everything that decides how Pip feels, in one place to tune.
-- Speeds are pixels per frame; accelerations are pixels per frame per frame.
local P = {
  run_speed = 1.5,   -- top running speed
  accel = 0.25,      -- speeding up on the ground
  air_accel = 0.15,  -- steering in the air
  friction = 0.3,    -- slowing down when no direction is held
  gravity = 0.25,
  jump_speed = -4,
  jump_cut = -1.5,
  max_fall = 4,
  coyote = 6,        -- frames you can still jump after running off a ledge
  buffer = 6,        -- frames a jump press is remembered before landing
}

-- == State ==
-- x, y is the top-left corner of Pip's hitbox, a 6x8 box (the sprite is
-- drawn one pixel to the left so the box sits in the middle of it)
player = {
  x = START_X, y = START_Y, w = 6,
  h = 8, vx = 0, vy = 0, flip = 0,
  moving = false, ground = false,
  jumping = false, coyote = 0,
  buffer = 0, squash = 0
}
t = 0

-- == Collision ==
-- Is the map tile at cell (tx, ty) solid?
function solid_at(tx, ty)
  return fget(mget(tx, ty), F_SOLID)
end

-- Does a w x h box at pixel (x, y) overlap any solid tile?
function box_hits(x, y, w, h)
  for ty = y // 8, (y + h - 1) // 8 do
    for tx = x // 8,
        (x + w - 1) // 8 do
      if solid_at(tx, ty) then
        return true
      end
    end
  end
  return false
end

-- Move e sideways by dx; if that runs into a wall, push it back out.
-- Returns true when it hit something.
function move_x(e, dx)
  e.x = e.x + dx
  if not box_hits(e.x, e.y, e.w, e.h)
  then
    return false
  end
  if dx > 0 then
    e.x =
      (e.x + e.w - 1) // 8 * 8 - e.w   -- just left of the wall
  else
    e.x = e.x // 8 * 8 + 8                  -- just right of the wall
  end
  return true
end

-- Move e up or down by dy, the same way.
function move_y(e, dy)
  e.y = e.y + dy
  if not box_hits(e.x, e.y, e.w, e.h)
  then
    return false
  end
  if dy > 0 then
    e.y =
      (e.y + e.h - 1) // 8 * 8 - e.h   -- standing on the tile
  else
    e.y = e.y // 8 * 8 + 8                  -- head against the ceiling
  end
  return true
end

-- == Helpers ==
-- Move v toward target by at most step.
function approach(v, target, step)
  if v < target then
    return math.min(v + step, target)
  end
  return math.max(v - step, target)
end

-- == Animation ==
function anim_frame(frames, speed)
  return
    frames[(t // speed) % #frames + 1]
end

-- == Player ==
function update_player(p)
  -- run: accelerate toward the top speed, or slide to a stop
  local dir = 0
  if btn(BTN_LEFT) then
    dir = dir - 1
  end
  if btn(BTN_RIGHT) then
    dir = dir + 1
  end
  if dir ~= 0 then
    p.flip = dir < 0 and 1 or 0
    p.vx = approach(p.vx,
        dir * P.run_speed, p.ground
        and P.accel or P.air_accel)
  else
    p.vx = approach(p.vx, 0, p.ground
        and P.friction or P.air_accel)
  end
  p.moving = p.vx ~= 0
  if move_x(p, p.vx) then p.vx = 0 end
  p.x = math.max(0,
      math.min(p.x, 240 - p.w))   -- stay on the screen

  -- coyote time: count down from the moment Pip leaves the ground
  if p.ground then
    p.coyote = P.coyote
  else
    p.coyote =
      math.max(0, p.coyote - 1)
  end
  -- jump buffer: remember a press for a few frames
  if btnp(BTN_A) then
    p.buffer = P.buffer
  else
    p.buffer =
      math.max(0, p.buffer - 1)
  end
  if p.buffer > 0
      and p.coyote > 0 then
    p.vy = P.jump_speed
    p.jumping = true
    p.buffer, p.coyote = 0, 0
  end
  -- let go early for a short hop (only a jump Pip started can be cut short)
  if p.jumping and not btn(BTN_A)
      and p.vy < P.jump_cut then
    p.vy = P.jump_cut
  end
  if p.vy >= 0 then
    p.jumping = false
  end

  p.vy = math.min(p.vy + P.gravity,
      P.max_fall)
  local fall_speed = p.vy
  if move_y(p, p.vy) then p.vy = 0 end
  local was_on_ground = p.ground
  p.ground =
    box_hits(p.x, p.y + 1, p.w, p.h)
  if p.ground and p.vy >= 0 then
    if not was_on_ground   -- a hard landing squashes Pip
        and fall_speed > 2 then
      p.squash = 6
    end
    p.vy = 0
    p.y = p.y // 1
  end
  p.squash = math.max(0, p.squash - 1)

  if p.y > 136 then
    p.x, p.y, p.vx, p.vy =
      START_X, START_Y, 0, 0
  end
end

function draw_player(p)
  local id
  if p.squash > 0 then
    id = SPR_SQUASH
  elseif not p.ground then
    if p.vy < 0 then
      id = SPR_JUMP
    else
      id = SPR_FALL
    end
  elseif p.moving then
    id = anim_frame(ANIM_RUN, 6)
  else
    id = anim_frame(ANIM_IDLE, 30)
  end
  spr(id, p.x - 1, p.y, 0, 1, p.flip)
end

-- == Game loop ==
function TIC()
  t = t + 1
  update_player(player)

  cls(10)
  map(0, 0, 30, 17, 0, 0, 0)
  draw_player(player)
end

-- title:   Pip's Peak (lesson 9)
-- author:  TIC-80 Platformer Course
-- desc:    The camera and scrolling
-- script:  lua

-- == Constants ==
local BTN_LEFT = 2
local BTN_RIGHT = 3
local BTN_A = 4   -- A is the Z key
local ANIM_IDLE = {256, 257}
local ANIM_RUN = {258, 259, 260, 261}
local SPR_JUMP = 262
local SPR_FALL = 263
local SPR_SQUASH = 265

local F_SOLID = 0       -- sprite flag 0 marks tiles you can stand on

local START_X, START_Y = 16, 80
-- the level's rectangle on the map, in cells (level 1 is 4 screens wide)
local LEVEL = {
  x = 0, y = 0, w = 120, h = 17
}
local SKY = 10

-- Everything that decides how Pip feels, in one place to tune.
-- Speeds are pixels per frame; accelerations are pixels per frame per frame.
local P = {
  run_speed = 1.5,   -- top running speed
  accel = 0.25,      -- speeding up on the ground
  air_accel = 0.15,  -- steering in the air
  friction = 0.3,    -- slowing down when no direction is held
  gravity = 0.25,
  jump_speed = -4,
  jump_cut = -1.5,
  max_fall = 4,
  coyote = 6,        -- frames you can still jump after running off a ledge
  buffer = 6,        -- frames a jump press is remembered before landing
}

-- == State ==
-- x, y is the top-left corner of Pip's hitbox, a 6x8 box (the sprite is
-- drawn one pixel to the left so the box sits in the middle of it)
player = {
  x = START_X, y = START_Y, w = 6,
  h = 8, vx = 0, vy = 0, flip = 0,
  moving = false, ground = false,
  jumping = false, coyote = 0,
  buffer = 0, squash = 0
}
t = 0
cam = {x = 0, y = 0}   -- the top-left corner of the screen, in level pixels

-- == Collision ==
-- Is the map tile at cell (tx, ty) solid? The level's left and right
-- edges count as walls, so Pip can't walk out of it.
function solid_at(tx, ty)
  if tx < LEVEL.x
      or tx >= LEVEL.x + LEVEL.w then
    return true
  end
  return fget(mget(tx, ty), F_SOLID)
end

-- Does a w x h box at pixel (x, y) overlap any solid tile?
function box_hits(x, y, w, h)
  for ty = y // 8, (y + h - 1) // 8 do
    for tx = x // 8,
        (x + w - 1) // 8 do
      if solid_at(tx, ty) then
        return true
      end
    end
  end
  return false
end

-- Move e sideways by dx; if that runs into a wall, push it back out.
-- Returns true when it hit something.
function move_x(e, dx)
  e.x = e.x + dx
  if not box_hits(e.x, e.y, e.w, e.h)
  then
    return false
  end
  if dx > 0 then
    e.x =
      (e.x + e.w - 1) // 8 * 8 - e.w   -- just left of the wall
  else
    e.x = e.x // 8 * 8 + 8                  -- just right of the wall
  end
  return true
end

-- Move e up or down by dy, the same way.
function move_y(e, dy)
  e.y = e.y + dy
  if not box_hits(e.x, e.y, e.w, e.h)
  then
    return false
  end
  if dy > 0 then
    e.y =
      (e.y + e.h - 1) // 8 * 8 - e.h   -- standing on the tile
  else
    e.y = e.y // 8 * 8 + 8                  -- head against the ceiling
  end
  return true
end

-- == Helpers ==
-- Move v toward target by at most step.
function approach(v, target, step)
  if v < target then
    return math.min(v + step, target)
  end
  return math.max(v - step, target)
end

-- == Animation ==
function anim_frame(frames, speed)
  return
    frames[(t // speed) % #frames + 1]
end

-- == Player ==
function update_player(p)
  -- run: accelerate toward the top speed, or slide to a stop
  local dir = 0
  if btn(BTN_LEFT) then
    dir = dir - 1
  end
  if btn(BTN_RIGHT) then
    dir = dir + 1
  end
  if dir ~= 0 then
    p.flip = dir < 0 and 1 or 0
    p.vx = approach(p.vx,
        dir * P.run_speed, p.ground
        and P.accel or P.air_accel)
  else
    p.vx = approach(p.vx, 0, p.ground
        and P.friction or P.air_accel)
  end
  p.moving = p.vx ~= 0
  if move_x(p, p.vx) then p.vx = 0 end

  -- coyote time: count down from the moment Pip leaves the ground
  if p.ground then
    p.coyote = P.coyote
  else
    p.coyote =
      math.max(0, p.coyote - 1)
  end
  -- jump buffer: remember a press for a few frames
  if btnp(BTN_A) then
    p.buffer = P.buffer
  else
    p.buffer =
      math.max(0, p.buffer - 1)
  end
  if p.buffer > 0
      and p.coyote > 0 then
    p.vy = P.jump_speed
    p.jumping = true
    p.buffer, p.coyote = 0, 0
  end
  -- let go early for a short hop (only a jump Pip started can be cut short)
  if p.jumping and not btn(BTN_A)
      and p.vy < P.jump_cut then
    p.vy = P.jump_cut
  end
  if p.vy >= 0 then
    p.jumping = false
  end

  p.vy = math.min(p.vy + P.gravity,
      P.max_fall)
  local fall_speed = p.vy
  if move_y(p, p.vy) then p.vy = 0 end
  local was_on_ground = p.ground
  p.ground =
    box_hits(p.x, p.y + 1, p.w, p.h)
  if p.ground and p.vy >= 0 then
    if not was_on_ground   -- a hard landing squashes Pip
        and fall_speed > 2 then
      p.squash = 6
    end
    p.vy = 0
    p.y = p.y // 1
  end
  p.squash = math.max(0, p.squash - 1)

  -- fell below the level: start again
  if p.y > (LEVEL.y + LEVEL.h)
      * 8 then
    p.x, p.y, p.vx, p.vy =
      START_X, START_Y, 0, 0
  end
end

function draw_player(p)
  local id
  if p.squash > 0 then
    id = SPR_SQUASH
  elseif not p.ground then
    if p.vy < 0 then
      id = SPR_JUMP
    else
      id = SPR_FALL
    end
  elseif p.moving then
    id = anim_frame(ANIM_RUN, 6)
  else
    id = anim_frame(ANIM_IDLE, 30)
  end
  -- everything in the level is drawn relative to the camera
  spr(id, p.x - 1 - cam.x,
      p.y - cam.y, 0, 1, p.flip)
end

-- == Camera ==
function clamp(v, lo, hi)
  return math.max(lo, math.min(v, hi))
end

-- Keep Pip in the middle of the screen, but never show outside the level.
function update_camera()
  local left, top =
    LEVEL.x * 8, LEVEL.y * 8
  local right, bottom = left + LEVEL.w
    * 8 - 240, top + LEVEL.h * 8 - 136
  cam.x = clamp(player.x + player.w
      // 2 - 120, left, right) // 1
  cam.y = clamp(player.y + player.h
      // 2 - 68, top, bottom) // 1
end

-- Far-away hills scroll slower than the level: that's parallax.
function draw_background()
  cls(SKY)
  clip(0, 0, 240, 112)          -- hills only above the ground line: pits show sky
  local far = cam.x * 0.25 // 1
  for i = 0, 3 do
    local hx = i * 96 - far % 96
    circ(hx, 140, 56, 13)        -- pale far hills
  end
  local near = cam.x * 0.5 // 1
  for i = 0, 4 do
    local hx = i * 64 - near % 64
    circ(hx + 32, 134, 30, 7)    -- darker, closer hills
  end
  clip()
end

-- == Game loop ==
function TIC()
  t = t + 1
  update_player(player)
  update_camera()

  draw_background()
  -- draw the 31x18 cells under the screen, shifted by what's left of the
  -- camera position after whole cells (so the map scrolls pixel by pixel)
  map(cam.x // 8, cam.y // 8, 31, 18,
      -(cam.x % 8), -(cam.y % 8), 0)
  draw_player(player)
end

-- title:   Pip's Peak (lesson 10)
-- author:  TIC-80 Platformer Course
-- desc:    Game states and the level loader
-- script:  lua

-- == Constants ==
local BTN_LEFT = 2
local BTN_RIGHT = 3
local BTN_A = 4   -- A is the Z key
local ANIM_IDLE = {256, 257}
local ANIM_RUN = {258, 259, 260, 261}
local SPR_JUMP = 262
local SPR_FALL = 263
local SPR_SQUASH = 265

local F_SOLID = 0       -- sprite flag 0 marks tiles you can stand on
local M_START = 50      -- marker tile: where Pip starts the level

-- Each level is a rectangle of the map, in cells.
local LEVELS = {
  {
    name = "GREEN MEADOW", x = 0,
    y = 0, w = 120, h = 17, sky = 10
  },
}

-- Everything that decides how Pip feels, in one place to tune.
-- Speeds are pixels per frame; accelerations are pixels per frame per frame.
local P = {
  run_speed = 1.5,   -- top running speed
  accel = 0.25,      -- speeding up on the ground
  air_accel = 0.15,  -- steering in the air
  friction = 0.3,    -- slowing down when no direction is held
  gravity = 0.25,
  jump_speed = -4,
  jump_cut = -1.5,
  max_fall = 4,
  coyote = 6,        -- frames you can still jump after running off a ledge
  buffer = 6,        -- frames a jump press is remembered before landing
}

-- == State ==
-- x, y is the top-left corner of Pip's hitbox, a 6x8 box (the sprite is
-- drawn one pixel to the left so the box sits in the middle of it)
player = {
  x = 0, y = 0, w = 6, h = 8, vx = 0,
  vy = 0, flip = 0, moving = false,
  ground = false, jumping = false,
  coyote = 0, buffer = 0, squash = 0
}
t = 0
cam = {x = 0, y = 0}   -- the top-left corner of the screen, in level pixels
state = "title"        -- "title" or "play"
level = 1              -- which level we're on
lvl = LEVELS[1]        -- that level's table
start_x, start_y = 0, 0
level_t = 0            -- frames since the level started

-- == Collision ==
-- Is the map tile at cell (tx, ty) solid? The level's left and right
-- edges count as walls, so Pip can't walk out of it.
function solid_at(tx, ty)
  if tx < lvl.x
      or tx >= lvl.x + lvl.w then
    return true
  end
  return fget(mget(tx, ty), F_SOLID)
end

-- Does a w x h box at pixel (x, y) overlap any solid tile?
function box_hits(x, y, w, h)
  for ty = y // 8, (y + h - 1) // 8 do
    for tx = x // 8,
        (x + w - 1) // 8 do
      if solid_at(tx, ty) then
        return true
      end
    end
  end
  return false
end

-- Move e sideways by dx; if that runs into a wall, push it back out.
-- Returns true when it hit something.
function move_x(e, dx)
  e.x = e.x + dx
  if not box_hits(e.x, e.y, e.w, e.h)
  then
    return false
  end
  if dx > 0 then
    e.x =
      (e.x + e.w - 1) // 8 * 8 - e.w   -- just left of the wall
  else
    e.x = e.x // 8 * 8 + 8                  -- just right of the wall
  end
  return true
end

-- Move e up or down by dy, the same way.
function move_y(e, dy)
  e.y = e.y + dy
  if not box_hits(e.x, e.y, e.w, e.h)
  then
    return false
  end
  if dy > 0 then
    e.y =
      (e.y + e.h - 1) // 8 * 8 - e.h   -- standing on the tile
  else
    e.y = e.y // 8 * 8 + 8                  -- head against the ceiling
  end
  return true
end

-- == Helpers ==
-- Move v toward target by at most step.
function approach(v, target, step)
  if v < target then
    return math.min(v + step, target)
  end
  return math.max(v - step, target)
end

-- == Animation ==
function anim_frame(frames, speed)
  return
    frames[(t // speed) % #frames + 1]
end

-- == Player ==
function update_player(p)
  -- run: accelerate toward the top speed, or slide to a stop
  local dir = 0
  if btn(BTN_LEFT) then
    dir = dir - 1
  end
  if btn(BTN_RIGHT) then
    dir = dir + 1
  end
  if dir ~= 0 then
    p.flip = dir < 0 and 1 or 0
    p.vx = approach(p.vx,
        dir * P.run_speed, p.ground
        and P.accel or P.air_accel)
  else
    p.vx = approach(p.vx, 0, p.ground
        and P.friction or P.air_accel)
  end
  p.moving = p.vx ~= 0
  if move_x(p, p.vx) then p.vx = 0 end

  -- coyote time: count down from the moment Pip leaves the ground
  if p.ground then
    p.coyote = P.coyote
  else
    p.coyote =
      math.max(0, p.coyote - 1)
  end
  -- jump buffer: remember a press for a few frames
  if btnp(BTN_A) then
    p.buffer = P.buffer
  else
    p.buffer =
      math.max(0, p.buffer - 1)
  end
  if p.buffer > 0
      and p.coyote > 0 then
    p.vy = P.jump_speed
    p.jumping = true
    p.buffer, p.coyote = 0, 0
  end
  -- let go early for a short hop (only a jump Pip started can be cut short)
  if p.jumping and not btn(BTN_A)
      and p.vy < P.jump_cut then
    p.vy = P.jump_cut
  end
  if p.vy >= 0 then
    p.jumping = false
  end

  p.vy = math.min(p.vy + P.gravity,
      P.max_fall)
  local fall_speed = p.vy
  if move_y(p, p.vy) then p.vy = 0 end
  local was_on_ground = p.ground
  p.ground =
    box_hits(p.x, p.y + 1, p.w, p.h)
  if p.ground and p.vy >= 0 then
    if not was_on_ground   -- a hard landing squashes Pip
        and fall_speed > 2 then
      p.squash = 6
    end
    p.vy = 0
    p.y = p.y // 1
  end
  p.squash = math.max(0, p.squash - 1)

  -- fell below the level: start again
  if p.y > (lvl.y + lvl.h) * 8 then
    reset_player()
  end
end

function draw_player(p)
  local id
  if p.squash > 0 then
    id = SPR_SQUASH
  elseif not p.ground then
    if p.vy < 0 then
      id = SPR_JUMP
    else
      id = SPR_FALL
    end
  elseif p.moving then
    id = anim_frame(ANIM_RUN, 6)
  else
    id = anim_frame(ANIM_IDLE, 30)
  end
  -- everything in the level is drawn relative to the camera
  spr(id, p.x - 1 - cam.x,
      p.y - cam.y, 0, 1, p.flip)
end

-- == Camera ==
function clamp(v, lo, hi)
  return math.max(lo, math.min(v, hi))
end

-- Keep Pip in the middle of the screen, but never show outside the level.
function update_camera()
  local left, top =
    lvl.x * 8, lvl.y * 8
  local right, bottom = left + lvl.w
    * 8 - 240, top + lvl.h * 8 - 136
  cam.x = clamp(player.x + player.w
      // 2 - 120, left, right) // 1
  cam.y = clamp(player.y + player.h
      // 2 - 68, top, bottom) // 1
end

-- Far-away hills scroll slower than the level: that's parallax.
function draw_background()
  cls(lvl.sky)
  clip(0, 0, 240, 112)          -- hills only above the ground line: pits show sky
  local far = cam.x * 0.25 // 1
  for i = 0, 3 do
    local hx = i * 96 - far % 96
    circ(hx, 140, 56, 13)        -- pale far hills
  end
  local near = cam.x * 0.5 // 1
  for i = 0, 4 do
    local hx = i * 64 - near % 64
    circ(hx + 32, 134, 30, 7)    -- darker, closer hills
  end
  clip()
end

-- == Levels ==
-- Marker tiles in the map say where things go. The loader replaces each
-- marker with an empty cell and calls its spawn function with the
-- marker's pixel position.
SPAWN = {
  [M_START] = function(x, y) start_x,
  start_y = x + 1, y end,
}

function reset_player()
  local p = player
  p.x, p.y, p.vx, p.vy =
    start_x, start_y, 0, 0
  p.flip, p.squash, p.coyote,
    p.buffer = 0, 0, 0, 0
end

function load_level(n)
  level, lvl = n, LEVELS[n]
  sync(4, 0, false)   -- copy the map from the cart back into RAM (4 = map), undoing old mset()s
  for ty = lvl.y, lvl.y + lvl.h - 1 do
    for tx = lvl.x,
        lvl.x + lvl.w - 1 do
      local spawn =
        SPAWN[mget(tx, ty)]
      if spawn then
        mset(tx, ty, 0)
        spawn(tx * 8, ty * 8)
      end
    end
  end
  reset_player()
  update_camera()
  level_t = 0
end

-- == States ==
function update_title()
  if btnp(BTN_A) then
    load_level(1)
    state = "play"
  end
end

-- Print text centered across the screen. print() returns the width of what
-- it drew, so measure the text off-screen first.
function print_centered(text, y,
      color, scale)
  scale = scale or 1
  local w = print(text, 0, -100,
      color, false, scale)
  print(text, (240 - w) // 2, y,
      color, false, scale)
end

function draw_title()
  cls(8)
  print("PIP'S PEAK", 41, 30, 0,
      false, 3)   -- shadow
  print("PIP'S PEAK", 39, 28, 4,
      false, 3)
  spr(anim_frame(ANIM_RUN, 6), 116,
      64, 0, 1, 0)
  if t // 30 % 2 == 0 then
    print_centered("PRESS Z TO START",
        96, 12)
  end
end

-- The level's name, for the first two seconds.
function draw_banner()
  if level_t > 120 then return end
  local w = print(lvl.name, 0, -16, 0,
      false, 2)   -- print returns the text width
  print(lvl.name, (240 - w) // 2 + 1,
      41, 0, false, 2)
  print(lvl.name, (240 - w) // 2, 40,
      12, false, 2)
end

function update_play()
  level_t = level_t + 1
  update_player(player)
  update_camera()
end

function draw_play()
  draw_background()
  -- draw the 31x18 cells under the screen, shifted by what's left of the
  -- camera position after whole cells (so the map scrolls pixel by pixel)
  map(cam.x // 8, cam.y // 8, 31, 18,
      -(cam.x % 8), -(cam.y % 8), 0)
  draw_player(player)
  draw_banner()
end

-- == Game loop ==
function TIC()
  t = t + 1
  if state == "title" then
    update_title()
    draw_title()
  elseif state == "play" then
    update_play()
    draw_play()
  end
end

-- title:   Pip's Peak (lesson 11)
-- author:  TIC-80 Platformer Course
-- desc:    Collectibles, entities and the HUD
-- script:  lua

-- == Constants ==
local BTN_LEFT = 2
local BTN_RIGHT = 3
local BTN_A = 4   -- A is the Z key
local ANIM_IDLE = {256, 257}
local ANIM_RUN = {258, 259, 260, 261}
local SPR_JUMP = 262
local SPR_FALL = 263
local SPR_SQUASH = 265
local ANIM_COIN = {288, 289, 290, 291}
local SPR_GEM = 292
local SPR_HUD_COIN = 354
local SPR_HUD_GEM = 355

local F_SOLID = 0       -- sprite flag 0 marks tiles you can stand on
local M_START = 50      -- marker tiles: where Pip starts the level,
local M_COIN, M_GEM = 48, 49   -- and where the coins and gems are

-- Each level is a rectangle of the map, in cells.
local LEVELS = {
  {
    name = "GREEN MEADOW", x = 0,
    y = 0, w = 120, h = 17, sky = 10
  },
}

-- Everything that decides how Pip feels, in one place to tune.
-- Speeds are pixels per frame; accelerations are pixels per frame per frame.
local P = {
  run_speed = 1.5,   -- top running speed
  accel = 0.25,      -- speeding up on the ground
  air_accel = 0.15,  -- steering in the air
  friction = 0.3,    -- slowing down when no direction is held
  gravity = 0.25,
  jump_speed = -4,
  jump_cut = -1.5,
  max_fall = 4,
  coyote = 6,        -- frames you can still jump after running off a ledge
  buffer = 6,        -- frames a jump press is remembered before landing
}

-- == State ==
-- x, y is the top-left corner of Pip's hitbox, a 6x8 box (the sprite is
-- drawn one pixel to the left so the box sits in the middle of it)
player = {
  x = 0, y = 0, w = 6, h = 8, vx = 0,
  vy = 0, flip = 0, moving = false,
  ground = false, jumping = false,
  coyote = 0, buffer = 0, squash = 0
}
t = 0
cam = {x = 0, y = 0}   -- the top-left corner of the screen, in level pixels
state = "title"        -- "title" or "play"
level = 1              -- which level we're on
lvl = LEVELS[1]        -- that level's table
start_x, start_y = 0, 0
level_t = 0            -- frames since the level started
score, coins, gems = 0, 0, 0
ents = {}    -- entities: everything in the level that moves or can be touched
parts = {}   -- particles: little dots that fly and fade

-- == Collision ==
-- Is the map tile at cell (tx, ty) solid? The level's left and right
-- edges count as walls, so Pip can't walk out of it.
function solid_at(tx, ty)
  if tx < lvl.x
      or tx >= lvl.x + lvl.w then
    return true
  end
  return fget(mget(tx, ty), F_SOLID)
end

-- Does a w x h box at pixel (x, y) overlap any solid tile?
function box_hits(x, y, w, h)
  for ty = y // 8, (y + h - 1) // 8 do
    for tx = x // 8,
        (x + w - 1) // 8 do
      if solid_at(tx, ty) then
        return true
      end
    end
  end
  return false
end

-- Move e sideways by dx; if that runs into a wall, push it back out.
-- Returns true when it hit something.
function move_x(e, dx)
  e.x = e.x + dx
  if not box_hits(e.x, e.y, e.w, e.h)
  then
    return false
  end
  if dx > 0 then
    e.x =
      (e.x + e.w - 1) // 8 * 8 - e.w   -- just left of the wall
  else
    e.x = e.x // 8 * 8 + 8                  -- just right of the wall
  end
  return true
end

-- Move e up or down by dy, the same way.
function move_y(e, dy)
  e.y = e.y + dy
  if not box_hits(e.x, e.y, e.w, e.h)
  then
    return false
  end
  if dy > 0 then
    e.y =
      (e.y + e.h - 1) // 8 * 8 - e.h   -- standing on the tile
  else
    e.y = e.y // 8 * 8 + 8                  -- head against the ceiling
  end
  return true
end

-- == Entities ==
-- An entity is a table with a box (x, y, w, h) and two functions:
-- update(e) runs every frame, draw(e) draws it. Setting e.dead = true
-- removes it.
function add_ent(e)
  ents[#ents + 1] = e
  return e
end

-- Do two boxes overlap?
function overlaps(a, b)
  return a.x < b.x + b.w
    and b.x < a.x + a.w and a.y < b.y
    + b.h and b.y < a.y + a.h
end

function update_ents()
  -- walk the list backwards so removing an entry doesn't skip the next one
  for i = #ents, 1, -1 do
    local e = ents[i]
    e.update(e)
    if e.dead then
      table.remove(ents, i)
    end
  end
end

function draw_ents()
  for _, e in ipairs(ents) do
    e.draw(e)
  end
end

-- == Particles ==
function burst(x, y, n, color)
  for _ = 1, n do
    parts[#parts + 1] = {
      x = x, y = y,
      vx = math.random() * 2 - 1,
      vy = math.random() * -2,
      life = 20 + math.random(10),
      color = color
    }
  end
end

function update_parts()
  for i = #parts, 1, -1 do
    local d = parts[i]
    d.x, d.y, d.vy = d.x + d.vx,
      d.y + d.vy, d.vy + 0.1
    d.life = d.life - 1
    if d.life <= 0 then
      table.remove(parts, i)
    end
  end
end

function draw_parts()
  for _, d in ipairs(parts) do
    pix(d.x - cam.x, d.y - cam.y,
        d.color)
  end
end

-- == Pickups ==
function new_coin(x, y)
  add_ent({
    x = x + 1, y = y + 1, w = 6,
    h = 6, update = update_pickup,
    draw = draw_coin, kind = "coin"
  })
end

function new_gem(x, y)
  add_ent({
    x = x + 1, y = y + 1, w = 6,
    h = 6, update = update_pickup,
    draw = draw_gem, kind = "gem"
  })
end

function update_pickup(e)
  if overlaps(player, e) then
    e.dead = true
    if e.kind == "coin" then
      coins = coins + 1
      score = score + 10
      burst(e.x + 3, e.y + 3, 6, 4)
    else
      gems = gems + 1
      score = score + 500
      burst(e.x + 3, e.y + 3, 12, 11)
    end
  end
end

function draw_coin(e)
  spr(anim_frame(ANIM_COIN, 8), e.x
      - 1 - cam.x, e.y - 1 - cam.y, 0)
end

function draw_gem(e)
  local bob =
    math.sin(t / 10) * 2 // 1   -- float up and down
  spr(SPR_GEM, e.x - 1 - cam.x,
      e.y - 1 - cam.y + bob, 0)
end

-- == HUD ==
function draw_hud()
  rect(0, 0, 240, 9, 0)
  print(string.format("%06d", score),
      4, 2, 12, true)
  spr(SPR_HUD_COIN, 46, 0, 0)
  print("x" .. coins, 55, 2, 12, true)
  spr(SPR_HUD_GEM, 80, 0, 0)
  print(gems .. "/3", 89, 2, 12, true)
end

-- == Helpers ==
-- Move v toward target by at most step.
function approach(v, target, step)
  if v < target then
    return math.min(v + step, target)
  end
  return math.max(v - step, target)
end

-- == Animation ==
function anim_frame(frames, speed)
  return
    frames[(t // speed) % #frames + 1]
end

-- == Player ==
function update_player(p)
  -- run: accelerate toward the top speed, or slide to a stop
  local dir = 0
  if btn(BTN_LEFT) then
    dir = dir - 1
  end
  if btn(BTN_RIGHT) then
    dir = dir + 1
  end
  if dir ~= 0 then
    p.flip = dir < 0 and 1 or 0
    p.vx = approach(p.vx,
        dir * P.run_speed, p.ground
        and P.accel or P.air_accel)
  else
    p.vx = approach(p.vx, 0, p.ground
        and P.friction or P.air_accel)
  end
  p.moving = p.vx ~= 0
  if move_x(p, p.vx) then p.vx = 0 end

  -- coyote time: count down from the moment Pip leaves the ground
  if p.ground then
    p.coyote = P.coyote
  else
    p.coyote =
      math.max(0, p.coyote - 1)
  end
  -- jump buffer: remember a press for a few frames
  if btnp(BTN_A) then
    p.buffer = P.buffer
  else
    p.buffer =
      math.max(0, p.buffer - 1)
  end
  if p.buffer > 0
      and p.coyote > 0 then
    p.vy = P.jump_speed
    p.jumping = true
    p.buffer, p.coyote = 0, 0
  end
  -- let go early for a short hop (only a jump Pip started can be cut short)
  if p.jumping and not btn(BTN_A)
      and p.vy < P.jump_cut then
    p.vy = P.jump_cut
  end
  if p.vy >= 0 then
    p.jumping = false
  end

  p.vy = math.min(p.vy + P.gravity,
      P.max_fall)
  local fall_speed = p.vy
  if move_y(p, p.vy) then p.vy = 0 end
  local was_on_ground = p.ground
  p.ground =
    box_hits(p.x, p.y + 1, p.w, p.h)
  if p.ground and p.vy >= 0 then
    if not was_on_ground   -- a hard landing squashes Pip
        and fall_speed > 2 then
      p.squash = 6
    end
    p.vy = 0
    p.y = p.y // 1
  end
  p.squash = math.max(0, p.squash - 1)

  -- fell below the level: start again
  if p.y > (lvl.y + lvl.h) * 8 then
    reset_player()
  end
end

function draw_player(p)
  local id
  if p.squash > 0 then
    id = SPR_SQUASH
  elseif not p.ground then
    if p.vy < 0 then
      id = SPR_JUMP
    else
      id = SPR_FALL
    end
  elseif p.moving then
    id = anim_frame(ANIM_RUN, 6)
  else
    id = anim_frame(ANIM_IDLE, 30)
  end
  -- everything in the level is drawn relative to the camera
  spr(id, p.x - 1 - cam.x,
      p.y - cam.y, 0, 1, p.flip)
end

-- == Camera ==
function clamp(v, lo, hi)
  return math.max(lo, math.min(v, hi))
end

-- Keep Pip in the middle of the screen, but never show outside the level.
function update_camera()
  local left, top =
    lvl.x * 8, lvl.y * 8
  local right, bottom = left + lvl.w
    * 8 - 240, top + lvl.h * 8 - 136
  cam.x = clamp(player.x + player.w
      // 2 - 120, left, right) // 1
  cam.y = clamp(player.y + player.h
      // 2 - 68, top, bottom) // 1
end

-- Far-away hills scroll slower than the level: that's parallax.
function draw_background()
  cls(lvl.sky)
  clip(0, 0, 240, 112)          -- hills only above the ground line: pits show sky
  local far = cam.x * 0.25 // 1
  for i = 0, 3 do
    local hx = i * 96 - far % 96
    circ(hx, 140, 56, 13)        -- pale far hills
  end
  local near = cam.x * 0.5 // 1
  for i = 0, 4 do
    local hx = i * 64 - near % 64
    circ(hx + 32, 134, 30, 7)    -- darker, closer hills
  end
  clip()
end

-- == Levels ==
-- Marker tiles in the map say where things go. The loader replaces each
-- marker with an empty cell and calls its spawn function with the
-- marker's pixel position.
SPAWN = {
  [M_START] = function(x, y) start_x,
  start_y = x + 1, y end,
  [M_COIN] = new_coin,
  [M_GEM] = new_gem,
}

function reset_player()
  local p = player
  p.x, p.y, p.vx, p.vy =
    start_x, start_y, 0, 0
  p.flip, p.squash, p.coyote,
    p.buffer = 0, 0, 0, 0
end

function load_level(n)
  level, lvl = n, LEVELS[n]
  ents, parts = {}, {}
  gems = 0            -- each level has its own three gems
  sync(4, 0, false)   -- copy the map from the cart back into RAM (4 = map), undoing old mset()s
  for ty = lvl.y, lvl.y + lvl.h - 1 do
    for tx = lvl.x,
        lvl.x + lvl.w - 1 do
      local spawn =
        SPAWN[mget(tx, ty)]
      if spawn then
        mset(tx, ty, 0)
        spawn(tx * 8, ty * 8)
      end
    end
  end
  reset_player()
  update_camera()
  level_t = 0
end

-- == States ==
function update_title()
  if btnp(BTN_A) then
    score, coins, gems = 0, 0, 0
    load_level(1)
    state = "play"
  end
end

-- Print text centered across the screen. print() returns the width of what
-- it drew, so measure the text off-screen first.
function print_centered(text, y,
      color, scale)
  scale = scale or 1
  local w = print(text, 0, -100,
      color, false, scale)
  print(text, (240 - w) // 2, y,
      color, false, scale)
end

function draw_title()
  cls(8)
  print("PIP'S PEAK", 41, 30, 0,
      false, 3)   -- shadow
  print("PIP'S PEAK", 39, 28, 4,
      false, 3)
  spr(anim_frame(ANIM_RUN, 6), 116,
      64, 0, 1, 0)
  if t // 30 % 2 == 0 then
    print_centered("PRESS Z TO START",
        96, 12)
  end
end

-- The level's name, for the first two seconds.
function draw_banner()
  if level_t > 120 then return end
  local w = print(lvl.name, 0, -16, 0,
      false, 2)   -- print returns the text width
  print(lvl.name, (240 - w) // 2 + 1,
      41, 0, false, 2)
  print(lvl.name, (240 - w) // 2, 40,
      12, false, 2)
end

function update_play()
  level_t = level_t + 1
  update_player(player)
  update_ents()
  update_parts()
  update_camera()
end

function draw_play()
  draw_background()
  -- draw the 31x18 cells under the screen, shifted by what's left of the
  -- camera position after whole cells (so the map scrolls pixel by pixel)
  map(cam.x // 8, cam.y // 8, 31, 18,
      -(cam.x % 8), -(cam.y % 8), 0)
  draw_ents()
  draw_player(player)
  draw_parts()
  draw_hud()
  draw_banner()
end

-- == Game loop ==
function TIC()
  t = t + 1
  if state == "title" then
    update_title()
    draw_title()
  elseif state == "play" then
    update_play()
    draw_play()
  end
end