Vector Math

function setup()
    bullets = {}
    origin  = vec2(WIDTH/2, HEIGHT/2)
end

function draw()
    background(20, 25, 35)

    -- Move and draw each bullet
    for i = #bullets, 1, -1 do
        local b = bullets[i]
        b.pos = b.pos + b.vel * DeltaTime

        fill(255, 220, 50)
        ellipse(b.pos.x, b.pos.y, 8, 8)

        -- Remove once off-screen
        if b.pos.x < 0 or b.pos.x > WIDTH or
           b.pos.y < 0 or b.pos.y > HEIGHT then
            table.remove(bullets, i)
        end
    end

    -- Draw turret
    fill(100, 180, 255)
    ellipse(origin.x, origin.y, 28, 28)
end

function touched(touch)
    if touch.state == BEGAN then
        local dir = (vec2(touch.x, touch.y) - origin):normalized()
        table.insert(bullets, {
            pos = vec2(origin.x, origin.y),
            vel = dir * 600  -- 600 pixels per second
        })
    end
end

function setup()
    center = vec2(WIDTH/2, HEIGHT/2)
    moons  = {
        { offset = vec2(140, 0), speed = 1.2, size = 18, r = 255, g = 100, b = 100 },
        { offset = vec2(220, 0), speed = 0.7, size = 24, r = 100, g = 180, b = 255 },
        { offset = vec2( 80, 0), speed = 2.4, size = 12, r = 120, g = 255, b = 140 },
    }
end

function draw()
    background(10, 12, 20)

    -- Central body
    fill(255, 200, 80)
    ellipse(center.x, center.y, 40, 40)

    for _, moon in ipairs(moons) do
        moon.offset = moon.offset:rotate(moon.speed * DeltaTime)
        local pos = center + moon.offset

        -- Draw orbit ring
        stroke(60, 65, 80)
        strokeWidth(1)
        noFill()
        ellipse(center.x, center.y, moon.offset:length() * 2, moon.offset:length() * 2)

        -- Draw moon
        noStroke()
        fill(moon.r, moon.g, moon.b)
        ellipse(pos.x, pos.y, moon.size, moon.size)
    end
end

function setup()
    guardPos = vec2(WIDTH/2, HEIGHT/2)
    guardDir = vec2(0, 1)     -- facing up
    fovCos   = math.cos(math.pi / 3)  -- 60° half-angle → 120° total FOV
    sightDist = 220
end

function draw()
    background(25, 30, 40)

    -- Guard slowly rotates
    guardDir = guardDir:rotate(0.6 * DeltaTime)

    local touchPos = vec2(CurrentTouch.x, CurrentTouch.y)
    local toTouch  = touchPos - guardPos
    local dist     = toTouch:length()

    -- Dot product test: within range AND within cone?
    local spotted = dist < sightDist and dist > 1 and
                    guardDir:dot(toTouch / dist) >= fovCos

    -- Draw sight cone (two edge lines)
    local left  = guardDir:rotate( math.pi/3) * sightDist
    local right = guardDir:rotate(-math.pi/3) * sightDist
    stroke(spotted and color(255, 80, 80, 120) or color(80, 200, 80, 80))
    strokeWidth(1)
    fill(spotted and color(255, 80, 80, 30) or color(80, 200, 80, 20))
    -- draw the cone as two lines from guard
    line(guardPos.x, guardPos.y, guardPos.x + left.x,  guardPos.y + left.y)
    line(guardPos.x, guardPos.y, guardPos.x + right.x, guardPos.y + right.y)

    -- Draw guard
    noStroke()
    fill(150, 190, 255)
    ellipse(guardPos.x, guardPos.y, 28, 28)

    -- Draw touch target
    fill(spotted and color(255, 80, 80) or color(80, 255, 80))
    ellipse(touchPos.x, touchPos.y, 20, 20)

    fill(255)
    fontSize(20)
    text(spotted and "SPOTTED!" or "hidden", WIDTH/2, 50)
end

function setup()
    playerPos = vec2(WIDTH/2, HEIGHT/2)
    cameraPos = vec2(WIDTH/2, HEIGHT/2)
end

function draw()
    -- Player snaps to touch
    if CurrentTouch.state ~= ENDED then
        playerPos = playerPos:lerp(
            vec2(CurrentTouch.x, CurrentTouch.y), 12 * DeltaTime)
    end

    -- Camera lazily follows
    cameraPos = cameraPos:lerp(playerPos, 4 * DeltaTime)

    background(20, 28, 38)

    -- World grid, offset by camera
    local offset = vec2(WIDTH/2, HEIGHT/2) - cameraPos
    stroke(45, 55, 70)
    strokeWidth(1)
    for gx = -8, 8 do
        for gy = -8, 8 do
            local wx = gx * 70 + offset.x
            local wy = gy * 70 + offset.y
            line(wx - 6, wy, wx + 6, wy)
            line(wx, wy - 6, wx, wy + 6)
        end
    end

    -- Player is always drawn at the screen center (the camera follows them)
    noStroke()
    fill(100, 220, 110)
    ellipse(WIDTH/2, HEIGHT/2, 26, 26)
end

function setup()
    pos    = vec2(WIDTH/2, HEIGHT/2)
    vel    = vec2(280, 350)
    radius = 22
end

function draw()
    background(18, 22, 32)

    pos = pos + vel * DeltaTime

    -- Bounce off left/right
    if pos.x - radius < 0 then
        pos.x = radius
        vel   = vel:reflect(vec2(1, 0))
    elseif pos.x + radius > WIDTH then
        pos.x = WIDTH - radius
        vel   = vel:reflect(vec2(-1, 0))
    end

    -- Bounce off bottom/top
    if pos.y - radius < 0 then
        pos.y = radius
        vel   = vel:reflect(vec2(0, 1))
    elseif pos.y + radius > HEIGHT then
        pos.y = HEIGHT - radius
        vel   = vel:reflect(vec2(0, -1))
    end

    -- Draw shadow
    fill(0, 0, 0, 60)
    ellipse(pos.x + 6, pos.y - 6, radius * 2, radius * 2)

    -- Draw ball
    fill(255, 100, 60)
    ellipse(pos.x, pos.y, radius * 2, radius * 2)
end

function setup()
    playerPos = vec2(WIDTH/2, HEIGHT/2)
    coins     = {}
    for i = 1, 12 do
        table.insert(coins, vec2(
            math.random(60, WIDTH  - 60),
            math.random(60, HEIGHT - 60)))
    end
    score = 0
end

function draw()
    background(22, 28, 38)

    -- Player follows touch
    if CurrentTouch.state ~= ENDED then
        playerPos = playerPos:lerp(
            vec2(CurrentTouch.x, CurrentTouch.y), 10 * DeltaTime)
    end

    -- Collect any coin within range
    for i = #coins, 1, -1 do
        if playerPos:distance(coins[i]) < 38 then
            table.remove(coins, i)
            score = score + 1
        end
    end

    -- Draw coins
    fill(255, 200, 40)
    for _, c in ipairs(coins) do
        ellipse(c.x, c.y, 22, 22)
    end

    -- Draw player
    fill(80, 160, 255)
    ellipse(playerPos.x, playerPos.y, 30, 30)

    fill(255)
    fontSize(22)
    text("Score: " .. score, WIDTH/2, HEIGHT - 40)

    if #coins == 0 then
        fontSize(36)
        text("All collected!", WIDTH/2, HEIGHT/2)
    end
end