なぜ box が動き、カメラが追いかけ、背景が流れるのか

// 追従仕様: deadzone = 不感帯の幅, k = 1秒あたりの寄せ率
pub def follow(): CameraRig.Follow =
    { deadzone = 0.0, k = 5.0 }                2

pub def step(input, dt, world): World =
    let nx = world#x + input#x * speed() * dt;   1
    let ny = world#y + input#y * speed() * dt;
    let cam = world#cam;
    { x = nx, y = ny,
      cam = { x = cam#x + CameraRig.followDelta(  3
                    follow(), dt, nx, cam#x),
              y = cam#y + CameraRig.followDelta(
                    follow(), dt, ny, cam#y) }
      | world }

// エンジン側（CameraRig.followDelta）。deadzone=0 なら実質:
//   (target − current) × min(1, k×dt)   ← lerp そのもの

// Main.flix — App にカメラを1行で繋ぐ
App.makeWith(World.initial)
    |> App.addSystem(Controls.step)
    |> App.withView(View.frame)
    |> App.withCamera(View.cameraCenter)      1
    |> App.launch

// View.flix — 変換コードは無い。world 座標で組むだけ。
// ctx（App.ViewCtx）から「見えている範囲」も貰える
pub def cameraCenter(world): Vec2.Vec2 = world#cam

pub def frame(ctx: App.ViewCtx, world): List[Render.PlacedItem] = 2
    background(ctx#visible) ::: player(world) :: Nil

// エンジン側（CameraRig.centerOn）。やっていることは:
//   screen = world − cam + 画面サイズ/2      3

// 「見えている矩形」は frame が ctx#visible として受け取り、
// そのまま渡ってくる。cam も design もこの関数は知らない
def background(visible: Rect2.Rect2): List[Render.PlacedItem] =
    let ts = tileSize();  // 32px。tileIndex ≒ floor（切り下げて整数のタイル番号に）
    let col0 = tileIndex(visible#position#x / ts);          1
    let row0 = tileIndex(visible#position#y / ts);
    let cols = tileIndex(visible#size#x / ts) + 2;      2
    let rows = tileIndex(visible#size#y / ts) + 2;
    // List はモナドなので forM がリスト内包として使える（行×列の総当たり）
    forM (r <- List.range(0, rows); c <- List.range(0, cols))
        yield tile(col0 + c, row0 + r)

// 市松の1枚（タイル番号 → world 座標の PlacedItem）
def tile(col: Int32, row: Int32): Render.PlacedItem =
    let ts = tileSize();
    let color = if (Int32.modulo(col + row, 2) == 0)     3
                    tileColorA() else tileColorB();
    { at = { x = Int32.toFloat64(col) * ts, … },            4
      item = Render.box(…) }

// Controls.flix — クリック判定。エンジンの Frame には
// cursor（screen 座標）と mouseClicked（押した瞬間だけ true）が焼かれている
pub def zoomButtons(frame, world) =
    let overPlus = Hud.inCircle(                    1
        Hud.plusCenter(frame#viewport), frame#cursor);
    ...
    if (frame#mouseClicked and overPlus)             2
        World.zoomIn(hovered) ...

// World.flix — ボタンは目標値を1段変えるだけ
pub def zoomIn(world) =
    { zoomTarget = clamp(world#zoomTarget * 1.25) | world }

// World.step — 現在値が目標へ lerp（追従カメラと同じ）
zoom = world#zoom + (world#zoomTarget - world#zoom)    3
            * min(1.0, 8.0 * dt)

// Main.flix — エンジンへは宣言1行ずつ
|> App.withZoom(w -> w#zoom)
|> App.withHudView(View.hud)   // +/− ボタンの絵（画面固定）

// エンジン側（composeScene）。その2の式に ×zoom が入るだけ:
//   screen = (world − cam) × zoom + 画面サイズ/2   4
//   大きさも × zoom、見えている範囲は design / zoom

// Main.flix — 3行足すだけ
|> App.withCameraBounds(_ -> World.cameraBounds()) 1
|> App.addParallaxLayer(0.25, View.farStars)
|> App.addParallaxLayer(0.55, View.nearStars)     2

// World.flix — 映してよい範囲 = アリーナ + 星空の余白
pub def cameraBounds(): Rect2.Rect2 =
    let a = arena();
    let m = 128.0;  // ← 余白ゼロだと星が一生映らない 3
    { position = { x = a#position#x - m, … },
      size = { x = a#size#x + 2.0 * m, … } }

// View.flix — 星はセル番号のハッシュで「決定的に」撒く
def starAt(col, row, …): Option[Render.PlacedItem] =
    let idx = col * 92821 + row * 31 + salt;
    if (Hash01.at(idx, 0) > 0.5) None            4
    else Some(セル内の位置・明るさもハッシュで決めた星)

// エンジン側の芯（どちらも純関数）:
//   clampCenter: 視界(design/zoom)が bounds を出ない位置へ center を収める
//   parallaxCenter: lerp(画面中央, center, factor) — 遠いほど動きが小さい

// 窓: 画面右下 96×64。0.2倍 → world 480×320 が見える
def pipScale(): Float64 = 0.2

// PiP 一式 = 下地（額縁）+ 窓で切り抜いた中身
def pip(design, world): List[Render.PlacedItem] =
    let r = pipRect(design);  // 右下の窓の矩形
    let backdrop = 虚空色の箱 |> Render.outline(…);  4
    backdrop :: Render.clippedAll(r, pipContent(r, world)) 3

// 中身: 同じ部品の列に、もう一度別の変換を掛ける
def pipContent(r, world): List[Render.PlacedItem] =
    let s = pipScale();
    let winCenter = 窓の中心;
    let playerPos = { x = world#x, y = world#y };
    let items = background(worldView)                1
                    ::: rim() :: player(world) :: Nil;
    items |> List.map(p ->
        { at = Vec2.add(winCenter,                     2
                  Vec2.mul(Vec2.sub(p#at, playerPos), s)),
          item = p#item |> Render.scaled(s)
                        |> Render.raiseZ(pipLift()) })

// その2の式:  screen = (world − cam)    × zoom + 画面中央
// PiP の式:   screen = (world − player) × 0.2  + 窓の中心
//             — 中心とずらし先が違うだけの、同じ変換