// Academy.jsx — 學院：分級課程（取代原本的「車體圖解」與「技術手冊」）
// 課程內容寫死在 ACADEMY_LEVELS：改文字、增刪投影片、加一課，都只要改這個陣列。
//
// 等級 → 課 → 投影片。不放測驗：每課的 quiz 會出現在最後一步的講稿裡（按 N），給老師口頭問。
// 畫面是一個 3D 世界：每一課落在一座平台（place）上，每張投影片是繞著展品的一個視角。
// 投影片種類（kind）：
//   lead    開場：eyebrow / title / body
//   stats   數字：stats: [{ label, value, unit, text }]
//   formula 公式：expr / where: [[符號, 說明]] / body
//   chart   圖表：chart（目前有 "motor"）/ body
//   text    說明：body，可加 quote: { text, src }
//   draw    動手畫：body 是題目，按鈕切換 3D 上的參考答案
// 每張都可以加：
//   shot     { view, show, focus }：view＝展品的視角名稱，show＝要顯示哪一組箭頭／尺寸（見 AcademyWorld.jsx 各展品）
//            L2 的課都在「一整台車」平台；focus 標亮哪一組（輪胎／車體／空力／煞車／動力／電池／懸吊），沒寫就用該課的 focus
//   controls 互動滑桿（ACADEMY_CONTROLS 的名稱）
//   note     講稿，按 N 才顯示
// 進度存在這台裝置的瀏覽器（localStorage），換裝置不會同步。

const ACADEMY_LEVELS = [
  {
    id: "L1", title: "汽車基礎", sub: "車怎麼動起來",
    lessons: [
      {
        id: "l1-wheel", title: "一個輪子", place: "wheel",
        summary: "車子所有的力，都從輪胎和地面之間來",
        slides: [
          { kind: "lead", eyebrow: "L1 · 01", title: "一個輪子", shot: { view: "hero", show: "plain" },
            body: "加速、煞車、轉彎，全靠同一個地方。",
            note: "先問全班：車子靠什麼前進？多數人會答引擎或馬達。先不公布答案，往下一張走。" },
          { kind: "text", title: "接地面只有手掌大", shot: { view: "patch", show: "patch" },
            body: "輪胎碰到地面的，只有手掌大的一塊。\n\n車子所有的力，都從這裡過。",
            note: "現在是側視圖：輪子的圓，加上底下橘色那一塊。請學生伸出手掌比一下：整台車加車手，所有的力都要通過四塊這麼大的橡皮。這就是第一張的答案：車子靠輪胎推地前進，馬達只是把輪子轉起來。（FSAE 賽車胎的接地面大約寬十幾到二十公分、長十公分上下，會隨重量和胎壓變，這裡是示意。）" },
          { kind: "formula", title: "這塊橡皮能出多少力", shot: { view: "side", show: "load" }, controls: "wheelLoad",
            expr: "F = μ × N", where: "F 最大摩擦力\nμ 摩擦係數（橡皮和地面有多黏）\nN 垂直力（輪胎被壓在地上的力）",
            body: "接地面能出的力有上限。\n\n加速、煞車、轉彎，都不能超過它。",
            note: "現場拉兩條滑桿。先拉垂直力：壓越重，箭頭越長。再拉摩擦係數：濕地約 0.5，一般胎約 0.9，熱的賽車胎可到 1.5。重點：這個上限決定車子最多能多猛地加速、煞車、過彎。μ = 1.5 大約就是 1.5 g（示意，還沒算空力下壓力）。問：想要更大的摩擦力，只有哪兩條路？" },
          { kind: "text", title: "三種力，搶同一個上限", shot: { view: "sideUp", show: "forces" },
            body: "驅動、煞車、轉彎，共用這塊接地面。\n\n一邊用多，另一邊就少。",
            note: "鏡頭從側面抬高，前後（驅動、煞車）和左右（轉彎）的箭頭都看得到。這張是 L2「摩擦圓」的伏筆，不用講細節。舉例：全力煞車的時候打方向盤，車子不太轉，因為抓地力已經被煞車用完了。" },
          { kind: "text", title: "從正面看：胎寬", shot: { view: "front", show: "width" },
            body: "胎面多寬，接地面就多寬。",
            note: "現在是正視圖（從車頭方向看）：上面量的是胎寬，底下橘色是接地面的寬。接地面的面積大約等於「壓在輪子上的重量 ÷ 胎壓」：同樣的重量，胎越寬，接地面就越寬、越短；胎壓放低，面積就變大。為什麼大一點比較好？F = μ × N 裡的 μ 其實不是定值：橡膠被壓得越緊（單位面積的壓力越大），μ 會往下掉。把同樣的重量攤在更大的面積上，μ 掉得少，總抓地力就多一些；熱也比較分散，不容易過熱。" },
          { kind: "stats", title: "要更多力的車，用更寬的胎", shot: { view: "front", show: "wide" },
            stats: [
              { label: "腳踏車（公路車）", value: "25", unit: "mm", text: "人加車不到 100 kg。" },
              { label: "一般轎車", value: "205", unit: "mm", text: "1.3 噸，但開得溫和。" },
              { label: "FSAE 賽車", value: "190", unit: "mm", text: "只有 300 kg，但要 1.5 g 過彎。" },
              { label: "F1（後輪）", value: "405", unit: "mm", text: "重、馬力大、下壓力大。" },
            ],
            note: "數字是常見規格的約略胎寬（示意）：公路車 23–28 mm；轎車常見 205/55R16；FSAE 常見 Hoosier 7.5 吋寬；F1 前 305、後 405 mm。規則：車越重、越有力、要越快過彎，需要的力越大，就用越寬的胎。FSAE 比轎車輕很多，胎卻差不多寬，因為它要過彎的 g 數大很多。代價也要講：胎越寬，滾動阻力和空氣阻力越大、輪子越重（加速時要轉動的質量多）、而且要更多熱才能進到工作溫度，冷的寬胎反而不抓。所以轎車要省油、安靜、冬天也要抓，就不會用很寬的胎。" },
        ],
        quiz: [
          { q: "車子加速、煞車、轉彎的力，最後都從哪裡來？",
            options: ["馬達", "輪胎和地面之間的摩擦力", "車架"], answer: 1,
            why: "馬達只負責把輪子轉起來，真正推動車子的是接地面的摩擦力。" },
          { q: "依照 F = μ × N，哪一個做法可以讓最大摩擦力變大？",
            options: ["把輪胎壓得更重", "把車身漆成紅色", "把方向盤換小"], answer: 0,
            why: "垂直力 N 變大，最大摩擦力就跟著變大。" },
          { q: "全力煞車時再轉方向盤，車子為什麼不太轉？",
            options: ["方向盤壞了", "抓地力已經被煞車用掉了", "車速太慢"], answer: 1,
            why: "煞車和轉彎共用同一塊接地面的抓地力。" },
          { q: "哪一種車最需要更寬的胎？",
            options: ["很輕、慢慢騎的腳踏車", "又重、又有力、要高速過彎的賽車", "停在車庫裡的車"], answer: 1,
            why: "需要的力越大，接地面就要越大；但寬胎也有滾動阻力大、要更多熱的代價。" },
        ],
      },
      {
        id: "l1-chassis", title: "四個輪子，一個車架", place: "chassis",
        summary: "軸距、輪距、重心，決定每個輪子扛多少重量",
        slides: [
          { kind: "lead", eyebrow: "L1 · 02", title: "四個輪子", shot: { view: "hero", show: "wheels" },
            body: "一個輪子站不住。放四個，車子才能站穩、能轉彎。",
            note: "承接上一課：每個輪子有一塊手掌大的接地面，現在有四塊。這一課的問題是：四塊各分到多少重量？" },
          { kind: "text", title: "車架把四個輪子連起來", shot: { view: "frame", show: "frame" },
            body: "車架是骨架。車手、電池、馬達都掛在它上面。",
            note: "車架的工作只有兩個：把四個輪子固定在對的位置，還有保護車手。懸吊和轉向留到後面的課。" },
          { kind: "stats", title: "兩個基本尺寸", shot: { view: "top", show: "dims" },
            stats: [
              { label: "軸距：前輪中心到後輪中心", value: "1270", unit: "mm", text: "我們這台車。" },
              { label: "輪距：左輪中心到右輪中心", value: "1190", unit: "mm", text: "我們這台車。" },
            ],
            note: "數字是 tools/envelope.html 的預設值，改了設計記得回來對一下。軸距短，車子靈活；輪距寬，過彎比較穩。這兩個數字是設計一台車最先決定的東西。" },
          { kind: "text", title: "重心", shot: { view: "cg", show: "cg" },
            body: "整台車的重量，想成集中在一個點。",
            note: "拿一支筆放在手指上找平衡點，那個點就是重心。車子的重心在車架中間的空中。現在是側視圖（從路線這側看，車頭朝右），下一張用同一個角度算前後輪各扛多少。" },
          { kind: "formula", title: "前軸扛多少", shot: { view: "side", show: "formula" },
            expr: "前軸重量 = M × b ÷ L", where: "M 整車重量\nb 重心到後軸的距離\nL 軸距",
            note: "帶數字：M = 300 kg，L = 1270 mm，重心離後軸 572 mm。前軸 = 300 × 572 ÷ 1270 ≈ 135 kg，後軸 165 kg，配重 45 : 55。重心越靠近哪一軸，那一軸扛得越多。下一張把它畫成柱子。" },
          { kind: "text", title: "重心在哪，重量就在哪", shot: { view: "loads", show: "loads" }, controls: "cg",
            body: "柱子越高，那個輪子扛得越重。",
            note: "按 ↑↓ 移動重心（數字鍵 1、2 切換前後／左右）。重心往後，後輪的柱子變高。問：電池很重，放前面還是後面？" },
          { kind: "text", title: "加速：重量往後跑", shot: { view: "accel", show: "accel" }, controls: "accel",
            body: "後輪推地，車頭抬起。\n\n重量跑到後輪。",
            note: "按 ↑↓ 改加速度。0.6 g 時後軸多扛約 40 kg。這就是為什麼後輪驅動：加速時後輪被壓得最重，抓得最緊。煞車剛好反過來，重量往前跑。" },
          { kind: "text", title: "轉彎：重量往外跑", shot: { view: "corner", show: "corner" }, controls: "corner",
            body: "四個輪胎往內推，車身往外倒。\n\n重量跑到外側輪。",
            note: "鏡頭轉到右後方，看得到左右兩邊的柱子和車身側傾。按 ↑↓ 改側向 g。左轉時右邊（外側）的柱子變高。接回第一課：外側輪被壓得重，抓得緊；內側輪變輕，最先打滑。" },
        ],
        quiz: [
          { q: "軸距是哪兩點之間的距離？",
            options: ["左輪到右輪", "前輪中心到後輪中心", "車頭到車尾"], answer: 1,
            why: "前後輪中心的距離是軸距；左右輪中心的距離是輪距。" },
          { q: "把重心往後移，會發生什麼事？",
            options: ["後輪扛的重量變多", "前輪扛的重量變多", "四輪重量不變"], answer: 0,
            why: "重心靠近哪一軸，那一軸分到的重量就多。" },
          { q: "整車 300 kg、軸距 1600 mm、重心離後軸 800 mm，前軸扛多少？",
            options: ["100 kg", "150 kg", "200 kg"], answer: 1,
            why: "300 × 800 ÷ 1600 = 150 kg，重心剛好在前後軸正中間。" },
        ],
      },
      {
        id: "l1-steering", title: "轉向", place: "steering",
        summary: "方向盤怎麼讓輪子轉：從手到輪子的一整條機構",
        slides: [
          { kind: "lead", eyebrow: "L1 · 03", title: "轉向", shot: { view: "hero", show: "plain", steer: 0 },
            body: "手轉方向盤，輪子怎麼跟著轉？",
            note: "這一站講：方向盤到輪子，中間是哪些零件。先讓學生猜。" },
          { kind: "text", title: "從手到輪子", shot: { view: "mech", show: "parts", steer: 0 },
            body: "方向盤 → 轉向柱 → 小齒輪＋齒條 → 拉桿 → 轉向臂 → 前輪。\n\n全部是機械連接。",
            note: "零件會照順序一個一個亮起來，跟著唸一次。規則要求方向盤用機械方式連到前輪，不能線控。" },
          { kind: "text", title: "方向盤帶著轉向柱轉", shot: { view: "column", show: "column", steer: 15 }, controls: "steerMech",
            body: "轉向柱是一根軸，把方向盤的轉動往下傳。",
            note: "按 ↑↓ 轉方向盤。畫面上方向盤轉的角度是前輪的 4 倍，只是示意；實際比例看小齒輪多大。" },
          { kind: "text", title: "小齒輪推齒條", shot: { view: "rack", show: "rack", steer: 15 }, controls: "steerMech",
            body: "轉動變成左右移動。",
            note: "按 ↑↓。柱子底下的小齒輪一轉，齒條就往左或往右滑，畫面上會顯示滑了幾 mm。小齒輪越小，方向盤要轉越多圈，但手越輕。" },
          { kind: "text", title: "拉桿拉轉向臂，輪子就轉", shot: { view: "arm", show: "arm", steer: 15 }, controls: "steerMech",
            body: "齒條兩端各一根拉桿，拉著輪子上的轉向臂。",
            note: "按 ↑↓。輪胎先變半透明，才看得到藏在輪圈內側的轉向臂；地上的橘色箭頭是輪子指的方向，灰線是正前方。轉向臂往內斜，所以內側輪會轉得比較多，這叫阿克曼。斜多少，在 tools/envelope.html 的「阿克曼 %」調。" },
          { kind: "text", title: "整套一起動", shot: { view: "rear", show: "all", steer: 15 }, controls: "steerMech",
            body: "從車尾看：兩個前輪一起轉。\n\n左右都能轉。",
            note: "鏡頭換到車尾後上方，畫面的左右就是車的左右。橘色箭頭是前輪指的方向，灰線是正前方，張開的角度就是轉角。按 ↑↓ 從右轉打到左轉，看兩支箭頭一起擺；內側輪的角度會比外側大一點，下一張就講為什麼。問：拉桿如果斷掉，那一邊的輪子會怎樣？" },
          { kind: "text", title: "內側的輪子要轉比較多", shot: { view: "top", show: "ackermann", steer: 20 }, controls: "steerAck",
            body: "過彎時，四個輪子繞著同一個圓心。\n\n內側輪子走的圓比較小，所以要轉得比較多。",
            note: "鏡頭升到正上方，畫面上方是車頭。兩條橘線各垂直於一個前輪，灰線是後軸的延長線，三條交在同一點，那一點就是轉彎中心。按 ↑↓：彎越急，中心越靠近車子，左右輪的角度差越大。這個設計叫阿克曼轉向，靠的就是上一張那兩支往內斜的轉向臂。" },
          { kind: "formula", title: "兩個輪子各轉幾度", shot: { view: "top", show: "ackermann", steer: 20 }, controls: "steerAck",
            expr: "tan δ = L ÷ r",
            where: [["δ", "輪子的轉角"], ["L", "軸距"], ["r", "這個輪子到轉彎中心的橫向距離"]],
            body: "內輪的 r 比較小，所以 δ 比較大。",
            note: "帶一個數字：軸距 1270 mm、輪距 1190 mm，車身中線繞半徑 4.5 m 的彎。內輪 r = 4.5 − 0.6 = 3.9 m，δ ≈ 18°；外輪 r = 5.1 m，δ ≈ 14°。差了 4 度。後輪不會轉，所以轉彎中心一定在後軸的延長線上。" },
        ],
        quiz: [
          { q: "方向盤的轉動，是靠哪個零件變成左右移動？",
            options: ["拉桿", "小齒輪和齒條", "輪圈"], answer: 1,
            why: "轉向柱底下的小齒輪轉動，推著齒條左右移動。" },
          { q: "齒條兩端接的是什麼？",
            options: ["拉桿", "避震器", "方向盤"], answer: 0,
            why: "齒條兩端各接一根拉桿，拉桿再拉輪子上的轉向臂。" },
          { q: "轉向柱連在哪兩個零件之間？",
            options: ["方向盤和小齒輪", "齒條和輪子", "車架和輪子"], answer: 0,
            why: "轉向柱上端是方向盤，下端是小齒輪。" },
          { q: "左轉時，哪一個前輪轉的角度比較大？",
            options: ["左前輪（內側）", "右前輪（外側）", "兩個一樣"], answer: 0,
            why: "內側輪子走的圓比較小，所以要轉得比較多（阿克曼）。" },
          { q: "轉彎中心在哪一條線上？",
            options: ["前軸的延長線", "後軸的延長線", "車身中線"], answer: 1,
            why: "後輪不會轉，所以圓心一定在後軸的延長線上。" },
        ],
      },
      {
        id: "l1-suspension", title: "懸吊", place: "suspension",
        summary: "彈簧、避震器、A 臂：讓輪子一直貼著地面",
        slides: [
          { kind: "lead", eyebrow: "L1 · 04", title: "懸吊", shot: { view: "hero", show: "plain" },
            body: "讓輪子一直貼著地面。",
            note: "接回第一課：所有的力都從接地面來，輪子離地，抓地力就是零。先問：輪子直接鎖死在車架上會怎樣？" },
          { kind: "text", title: "一個車角，五個零件", shot: { view: "parts", show: "parts" },
            body: "上 A 臂、下 A 臂、立柱、彈簧、避震器。",
            note: "這是我們車的右前角，藍色是 A 臂，橘色是避震器（彈簧套在上面）。四個角各一組。可以拖畫面繞一圈看。" },
          { kind: "text", title: "輪子上去，車身不動", shot: { view: "front", show: "bump", bump: 35 }, controls: "bump",
            body: "路面凸起，A 臂往上擺，彈簧被壓短。",
            note: "鏡頭走到車頭正前方，接下來四張都從這裡看。按 ↑↓ 改凸起高度：輪子和 A 臂往上，車架不動。往負的方向是路面凹下去，彈簧把輪子往下推，輪子還是貼著地。" },
          { kind: "formula", title: "彈簧：壓多少，頂回多少", shot: { view: "front", show: "spring", bump: 35 }, controls: "bump",
            expr: "F = k × x", where: "F 彈簧多出來的力\nk 彈簧硬度（每壓 1 mm 多幾牛頓）\nx 壓縮了多少",
            note: "這裡用 k = 30 N/mm 示範：壓 35 mm 就多 1050 N。問：太軟會怎樣（晃很大、容易觸底）？太硬呢（輪子彈離地面）？" },
          { kind: "text", title: "避震器：把彈跳停下來", shot: { view: "front", show: "damper" }, controls: "damper",
            body: "沒有避震器，壓一下會彈很多下。",
            note: "按 ↑↓ 改阻尼。最小：彈很久；0.7 左右：一下就穩住；再大：回得很慢。避震器把彈跳的能量變成熱。" },
          { kind: "text", title: "上 A 臂比較短，是故意的", shot: { view: "front", show: "camber", bump: 35 }, controls: "bump",
            body: "輪子往上時，上緣被往內拉。",
            note: "從正前方看最清楚：上 A 臂短、下 A 臂長，輪子往上時上臂畫的弧比較小，把輪子上緣往內拉。看外傾角讀數：輪子越往上，負得越多。過彎車身外傾時，外側輪胎才能平貼地面。細節留給懸吊組。" },
          { kind: "text", title: "安裝點怎麼選", shot: { view: "mount", show: "mount" }, controls: "shockAt",
            body: "A 臂的樞軸鎖在車架管的節點上。\n\n避震器接得越外面，彈簧感覺越硬。",
            note: "橘色小球是八個硬點。按 ↑↓ 把避震器下端沿下 A 臂往內、往外移，看槓桿比：輪子走 1 mm，避震器走幾 mm。輪上剛性是彈簧乘上槓桿比的平方，所以差一點點，感覺差很多。" },
          { kind: "text", title: "另一種：推桿＋搖臂", shot: { view: "push", show: "pushrod", bump: 35 }, controls: "bump",
            body: "推桿把輪子的上下傳到車架上方的搖臂。\n\n避震器橫躺在車架上，不在輪子旁邊。",
            note: "按 ↑↓ 看輪子上去時，推桿頂搖臂、搖臂壓彈簧。好處：彈簧不在輪子旁邊，空氣比較乾淨，也好調整；搖臂的長短還能改槓桿比。代價：零件多、比較重。這一張是示意，我們的車目前是第一種。" },
          { kind: "stats", title: "規則怎麼說", shot: { view: "hero", show: "plain" },
            stats: [
              { label: "可用輪行程（車手坐在車上）", value: "≥ 50", unit: "mm", text: "FSAE 規則。前後都要有避震器，而且要真的會動。" },
            ],
            note: "裁判有權把「看起來沒有認真做懸吊」的車取消資格。賽道很平，所以學生方程式的懸吊行程很短、彈簧很硬，但不能沒有。" },
        ],
        quiz: [
          { q: "懸吊最主要的工作是什麼？",
            options: ["讓車手坐得舒服", "讓輪胎一直貼著地面", "讓車子看起來比較低"], answer: 1,
            why: "輪胎離開地面就沒有抓地力，懸吊要讓接地面一直被壓在地上。" },
          { q: "彈簧硬度 30 N/mm，被多壓了 20 mm，多出多少力？",
            options: ["50 N", "600 N", "1500 N"], answer: 1,
            why: "F = k × x = 30 × 20 = 600 N。" },
          { q: "避震器的作用是什麼？",
            options: ["撐住車子的重量", "讓彈跳很快停下來", "讓輪子轉向"], answer: 1,
            why: "撐重量的是彈簧；避震器把彈跳的能量變成熱。" },
        ],
      },
      {
        id: "l1-drivetrain", title: "煞車與動力", place: "brake",
        summary: "兩個踏板各自接到哪裡：油壓到卡鉗，電池到後輪",
        slides: [
          { kind: "lead", eyebrow: "L1 · 05", title: "煞車與動力", shot: { view: "hero", show: "plain" },
            body: "右腳只做兩件事：快一點，或慢一點。",
            note: "這一課把前四課接起來：輪胎有抓地力、車架撐住、能轉向、輪子貼地。現在要讓它動起來、停下來。畫面上藍色是煞車，橘色是動力。" },
          { kind: "text", title: "煞車：用油傳力", shot: { view: "brake", show: "brake" },
            body: "踏板 → 主缸 → 油管 → 卡鉗。\n\n踩一下，四輪同時夾住。",
            note: "照順序指：踏板推主缸裡的活塞，把煞車油擠進油管；油不能被壓縮，所以壓力原封不動傳到四個卡鉗。問：為什麼用油，不用鋼索？（油可以同時、平均地分到四個輪子。）" },
          { kind: "text", title: "卡鉗夾住碟盤", shot: { view: "caliper", show: "caliper" }, controls: "brake",
            body: "油壓把來令片推向碟盤，輪子慢下來。\n\n動能變成碟盤上的熱。",
            note: "現場拉滑桿。橘色的來令片往中間夾，輪子變慢，碟盤開始發紅。踩越重、車越快，越紅。L2 的煞車課會算一次煞車有多少能量。" },
          { kind: "stats", title: "規則：煞車不能壞", shot: { view: "brake", show: "brake" },
            stats: [
              { label: "獨立的油壓迴路", value: "2", unit: "組", text: "一組漏油，另一組還能煞住至少兩個輪子。" },
              { label: "煞車測試要鎖死的輪子", value: "4", unit: "個", text: "車檢時全力踩，四個輪子都要鎖死才算過。" },
            ],
            note: "這兩條是 FSAE 規則。煞車測試沒過就不能上場跑動態項目，所以煞車是整台車最不能出錯的系統。" },
          { kind: "text", title: "動力：從電池到後輪", shot: { view: "power", show: "power" },
            body: "電池 → 控制器 → 馬達 → 鏈條 → 後輪。\n\n橘色粗線是高壓電。",
            note: "照順序指。電池存能量；控制器決定送多少電；馬達把電變成轉動；鏈條和差速器把轉動送到左右後輪。高壓線在實車上規定用橘色，看到橘色的線不要碰。" },
          { kind: "text", title: "油門只是訊號", shot: { view: "power", show: "throttle" }, controls: "throttle",
            body: "踏板不接機械，只告訴控制器要多少力。\n\n控制器決定送多少電給馬達。",
            note: "現場拉滑桿。看細細的灰線從踏板接到控制器，那是訊號線。光點是電流，踩越深流得越快，後輪轉得越快。這跟煞車完全不同：煞車是腳的力氣真的傳到輪子上。" },
          { kind: "formula", title: "齒比：用轉速換力氣", shot: { view: "chain", show: "gear" }, controls: "throttle",
            expr: "輪上扭力 = 馬達扭力 × 齒比", where: "齒比 = 大齒盤齒數 ÷ 小齒盤齒數\n\n小齒盤轉好幾圈，大齒盤才轉一圈\n轉速變慢，力氣變大",
            note: "看兩個齒盤上的記號：小的轉得快，大的轉得慢。帶一個數字：馬達扭力 100 N·m、齒比 4，輪上就有 400 N·m，但轉速只剩四分之一。問：齒比太大會怎樣（起步很猛，但極速很低）？" },
          { kind: "text", title: "馬達也能煞車", shot: { view: "power", show: "regen" },
            body: "放開油門，輪子帶馬達發電。\n\n動能充回電池，不變成熱。",
            note: "看光點方向反過來了，從馬達流回電池。這叫動能回充，是電動車才有的。規則允許煞車踏板前 90% 的行程用來回充，但車速在 5 km/h 以下不能回充。" },
          { kind: "stats", title: "規則：電動車的上限", shot: { view: "power", show: "power" },
            stats: [
              { label: "最大功率", value: "80", unit: "kW", text: "超過就是違規。大家的上限都一樣。" },
              { label: "最高電壓", value: "600", unit: "V DC", text: "足以致命。高壓系統有另外一整套安全規定。" },
            ],
            note: "80 kW 大約 107 匹馬力，車重才兩百多公斤，動力其實很夠。所以比的不是誰馬力大，而是誰能把動力穩定地用出來。高壓安全之後有專門的電動車課程。" },
        ],
        quiz: [
          { q: "煞車時，車子的動能主要變成什麼？",
            options: ["聲音", "碟盤上的熱", "電池裡的電"], answer: 1,
            why: "來令片和碟盤摩擦，把動能變成熱。" },
          { q: "電動賽車的油門踏板接到哪裡？",
            options: ["用鋼索接到馬達", "用訊號線接到馬達控制器", "用油管接到後輪"], answer: 1,
            why: "踏板只送訊號，由控制器決定送多少電給馬達。" },
          { q: "馬達扭力 80 N·m、齒比 4，輪上扭力是多少？",
            options: ["20 N·m", "84 N·m", "320 N·m"], answer: 2,
            why: "輪上扭力 = 80 × 4 = 320 N·m。" },
        ],
      },
    ],
  },
  {
    id: "L2", title: "賽車知識", sub: "怎麼跑得快",
    lessons: [
      {
        id: "l2-system", title: "把賽車當成系統", focus: null,
        summary: "圈速是整台車的輸出，不是單一零件的成績",
        slides: [
          { kind: "lead", eyebrow: "L2 · 導論", title: "把賽車當成系統", shot: { view: "hero", show: "plain" },
            body: "圈速不是某個零件的成績，是整台車的輸出。每個環節的上限，決定下一個環節能發揮多少。",
            note: "L1 把零件一個一個拼起來，這一級把它們放回同一台車上看。這台車是電動的：電池在座椅後面，馬達在後軸前面。" },
          { kind: "text", title: "五個系統，一台車", shot: { view: "hero", show: "cycle" },
            body: "輪胎、車體、空力、煞車、動力。\n\n改一個地方，其他四個都會跟著變。",
            note: "畫面會輪流標亮每個系統。舉一個連鎖反應：電池多帶一點 → 車變重 → 輪胎每一彎要扛更多 → 煞車要吸收更多熱 → 馬達要出更多力才能加速。沒有一個決定是單獨的。" },
          { kind: "text", title: "這一級的順序", shot: { view: "hero", show: "plain" },
            body: "輪胎 → 重量 → 空力 → 煞車 → 動力 → 能量。\n\n動力排在後面，因為它是放大器：抓地力不夠，再多動力也傳不到地面。",
            note: "先懂輪胎，因為所有的力都從那裡出去。能量放最後，因為它決定能不能跑完耐久賽。" },
        ],
        quiz: [
          { q: "為什麼說圈速是「系統的輸出」？",
            options: ["因為只要馬達夠強，圈速就會快", "因為每個子系統的上限會限制其他子系統能發揮多少", "因為圈速只看車手技術"],
            answer: 1, why: "例如輪胎抓地力不夠，煞車和動力再強也用不出來。" },
          { q: "這一級為什麼把「動力」排在後面？",
            options: ["因為動力不重要", "因為動力是放大器，前面的環節沒做好就傳不到地面", "因為動力最難學"],
            answer: 1, why: "動力要透過輪胎才能變成推力，前面的環節決定它能用掉多少。" },
        ],
      },
      {
        id: "l2-tire", title: "輪胎：抓地力先於一切", focus: "輪胎",
        summary: "摩擦圓、工作溫度、負荷敏感度",
        slides: [
          { kind: "lead", eyebrow: "L2 · 01 輪胎", title: "抓地力先於一切", shot: { view: "chase", show: "run" },
            body: "轉向、煞車、加速，所有的力都要從這四塊橡膠出去。輪胎不工作，其他設計全部無效。",
            note: "接回 L1 第一課：每個輪胎和地面只有一個手掌大的接地面。地面的短線往後流、輪子在滾，代表車正在往前跑。這一課的鏡頭都在車尾或正上方（車頭朝畫面上方），畫面的左右就是車的左右。" },
          { kind: "stats", title: "輪胎要熱才會抓", shot: { view: "rearHigh", show: "tiretemp" },
            stats: [{ label: "賽車胎的工作溫度", value: "70–95", unit: "°C",
                      text: "太冷，橡膠太硬抓不住；太熱，表面開始剝落。" }],
            note: "畫面上的輪胎顏色就是胎溫：藍＝太冷、綠＝工作溫度、黃紅＝太熱，跟 F1 轉播的胎溫圖一樣。一開始四顆都是藍的，跑幾秒才變綠。車子輪流直線、左彎、直線、右彎：看前輪往哪邊轉，另一邊（外側）的輪胎最熱；過彎時地面短線流得慢一點。溫度是示意，範圍是常見熱熔賽車胎的大約值，實際以你們用的輪胎型號為準。所以比賽前會先繞圈熱胎。" },
          { kind: "formula", title: "一顆輪胎，一份預算", shot: { view: "budgetTop", show: "friction" }, controls: "friction",
            expr: "√(Fx² + Fy²) ≤ μ × Fz",
            where: [["Fx", "前後方向的力（煞車、加速）"], ["Fy", "左右方向的力（左彎、右彎）"], ["μ × Fz", "這顆輪胎最多能出的力"]],
            body: "煞車和轉彎共用同一份抓地力。煞車用掉越多，能轉彎的就越少。",
            note: "俯視右前輪：畫面上方是車頭，畫面左右就是車的左右。只加速：箭頭朝上（指向車頭），地面短線變快。只煞車：箭頭朝下（地面把輪胎往後拉），短線變慢。轉彎：負的是左彎、正的是右彎，前輪會跟著轉過去，箭頭指向彎心。兩個一起拉到大，箭頭就碰到圓圈外面，輪胎打滑。好車手的技巧，就是讓箭頭一直貼著圓圈邊緣走。" },
          { kind: "text", title: "壓得越重，越不划算", shot: { view: "budgetTop", show: "sensitivity" }, controls: "tireLoad",
            body: "壓兩倍的重量，抓地力不到兩倍。\n\n所以四顆輪胎平均分擔，總抓地力最大。",
            note: "這叫負荷敏感度：μ 會隨垂直力變大而下降。調「這顆輪胎扛的重量」：藍色圈是實際的抓地力，灰色圈是「如果 μ 不變」應該有的。從 70 kg 加到 140 kg，抓地力只從約 107 kg 變成約 189 kg（μ 不變的話應該是 214 kg）。模型是示意：μ = 1.7 − 0.0025 × 負荷（kg），只為了讓趨勢看得出來，真正的曲線要看輪胎廠的測試資料。這就是下一課要算重量轉移的原因。" },
        ],
        quiz: [
          { q: "車子一邊過彎、一邊重踩煞車，依摩擦圓會發生什麼？",
            options: ["過彎能用的抓地力變少", "過彎能用的抓地力變多", "兩者互不影響"],
            answer: 0, why: "煞車（Fx）和過彎（Fy）共用同一份預算 μ·Fz。" },
          { q: "把更多重量壓到某一顆輪胎上，它的抓地力會？",
            options: ["等比例增加", "增加，但增加得越來越少", "完全消失"], answer: 1,
            why: "這就是負荷敏感度：μ 隨 Fz 增加而下降。" },
        ],
      },
      {
        id: "l2-weight", title: "重量：每一克都是決策", focus: null,
        summary: "減重、配重比例、重心高度",
        slides: [
          { kind: "lead", eyebrow: "L2 · 02 重量", title: "每一克都是決策", shot: { view: "loads", show: "plain" },
            body: "L1 看過：重心在哪，重量就在哪。\n\n這一課算代價：多一公斤要付多少、重量該放哪裡。",
            note: "這一課接續 L1-02（四個輪子，一個車架）。重心是什麼、前後配重、加速和轉彎時重量往後、往外跑，L1 都看過了，這裡不重講。L2 只問三件事：重量每一圈要付多少時間、重量轉移為什麼會讓總抓地力變少、最重的電池該放哪裡。" },
          { kind: "stats", title: "重量的代價", shot: { view: "battery", show: "plain", focus: "電池" },
            stats: [
              { label: "每多 1 kg，每圈大約慢", value: "0.03", unit: "秒" },
              { label: "多 20 kg 跑完耐久賽", value: "~13", unit: "秒" },
            ],
            note: "這兩個是常見的經驗估計，不是精確值。重點是：重量的代價每一圈都在付，因為每一次加速、煞車、轉彎都要推動這些質量。畫面標亮的是電池，全車最重的單一零件。" },
          { kind: "formula", title: "轉移多少，看重心多高", shot: { view: "loadsRear", show: "loads" }, controls: "weight",
            expr: "ΔW = M × a × h ÷ t",
            where: [["ΔW", "從內側輪搬到外側輪的重量"], ["M", "整車重量（含車手）"], ["a", "側向加速度（g）"], ["h", "重心高度"], ["t", "輪距"]],
            body: "右彎時，重量從右邊搬到左邊。\n\n重心越高、彎越急，搬得越多。",
            note: "接續 L1-02 的「轉彎：重量往外跑」，這裡把「多少」算出來。帶數字（示意）：M = 280 kg、a = 1.2 g、h = 0.28 m、t = 1.24 m，ΔW = 280 × 1.2 × 0.28 ÷ 1.24 ≈ 76 kg，前後軸依配重分攤（這台示意車前軸 47％）。調「重心高度」和「側向 g」看柱子變化。重點：轉移的比例 ΔW ÷ M = a × h ÷ t，跟車重無關，只跟重心高度和輪距有關。" },
          { kind: "text", title: "轉移越多，總抓地力越少", shot: { view: "loadsRear", show: "grip" }, controls: "weight",
            body: "外側輪多扛的重量，換不回內側輪少掉的抓地力。\n\n轉移越多，四顆加起來越少。",
            note: "接回上一課的負荷敏感度：壓兩倍重，抓地力不到兩倍。畫面上的百分比是「四顆輪胎總抓地力 ÷ 完全不轉移時的總抓地力」。把重心高度從 280 拉到 450 mm，總抓地力會再掉幾個百分點；重心 450 mm 再加上側向 g 1.6，內側前輪會直接離地（0 kg）。輪胎模型是示意：μ = 1.7 − 0.0025 × 負荷（kg）。" },
          { kind: "text", title: "先降重心，再減重", shot: { view: "battery", show: "plain", focus: "電池" },
            body: "降重心：直接減少轉移，每一彎都多抓一點。\n\n減重：每一次加速、煞車、轉彎都少推一點。",
            note: "兩件事都要做，順序是先降重心：轉移比例只跟重心高度有關，而且把零件裝低一點通常不用花錢；減重要換材料、重新設計，比較貴。電池是最好的工具：它最重，放得越低，整台車的重心就降得越多。" },
          { kind: "text", title: "電池放哪裡", shot: { view: "batteryLoads", show: "battery", focus: "電池" }, controls: "battery",
            body: "放低：重心降下來，轉移變少。\n\n前後位置：決定前後輪各扛多少。",
            note: "調「電池高度」和「電池前後」，看電池、重心球和四根柱子怎麼動（以 1.2 g 右彎計算）。示意數字：電池 60 kg；其他部分（含車手）220 kg、重心高 0.29 m、前軸 48％；軸距 1.27 m。電池往前，前軸配重變大，轉向比較靈敏；往後，後驅車出彎時後輪多扛一點，比較不會打滑。常見做法是放在座椅後面、盡量貼地，再用前後位置微調配重。還要顧到碰撞保護、散熱、維修拆裝，這些規則都有要求。" },
        ],
        quiz: [
          { q: "過彎時重量從內側輪轉移到外側輪，四顆輪胎的總抓地力會？",
            options: ["變多", "變少", "不變"], answer: 1,
            why: "負荷敏感度：外側輪多扛的重量，換不回內側輪少掉的抓地力。" },
          { q: "重心越高，過彎時會怎樣？",
            options: ["轉移到外側的重量越多", "轉移到外側的重量越少", "沒有影響"], answer: 0,
            why: "ΔW = M × a × h ÷ t，轉移量和重心高度成正比。" },
          { q: "電池是全車最重的單一零件，放置的首要原則是？",
            options: ["放越高越好，比較好維修", "放低、靠近車子中間", "放在車頭最前面"], answer: 1,
            why: "放低可以降低重心、減少轉移；靠中間讓前後配重不會太偏。" },
        ],
      },
      {
        id: "l2-aero", title: "空力：下壓力不計入慣性", focus: "空力",
        summary: "下壓力公式、速度平方、升阻比",
        slides: [
          { kind: "lead", eyebrow: "L2 · 03 空力", title: "下壓力不計入慣性", shot: { view: "aero", show: "plain" },
            body: "翼片把車往下壓，輪胎抓得更緊，車卻沒有變重。",
            note: "前一課說重量越大，要推動的質量越大。下壓力剛好相反：輪胎負荷變大，質量不變。" },
          { kind: "text", title: "翼片怎麼把車壓住", shot: { view: "wingside", show: "foil" },
            body: "翼片是倒過來的飛機翼，彎的那面朝下。\n\n下面壓力低、上面壓力高，壓力差把車往下壓。",
            note: "這張把尾翼左右兩片端板淡化，讓三片翼片的剖面露出來：越後面的翼片翹得越高。下表面那一側氣流比較快、壓力比較低，上下的壓力差就是下壓力；代價是空氣被往上甩，同時產生阻力。端板本身的工作是擋住翼尖，讓下面的低壓不要從側邊漏掉。" },
          { kind: "formula", title: "速度翻倍，下壓力四倍", shot: { view: "aero", show: "downforce" }, controls: "speed",
            expr: "F = ½ × ρ × V² × S × CL",
            where: [["ρ", "空氣密度，約 1.225 kg/m³"], ["V", "車速（m/s）"], ["S × CL", "翼面積 × 升力係數"]],
            body: "拉車速，看前翼和尾翼的下壓力。",
            note: "從 40 拉到 80：下壓力變四倍。這個示範用 S × CL = 3.0 m²，是 FSAE 有做空力套件的常見量級，前四後六分配。S 是翼面積：從正上方看，翼片投影的面積。箭頭長度和數字成正比（三支箭頭同一個比例）。" },
          { kind: "formula", title: "阻力也跟著來", shot: { view: "dragArea", show: "drag" }, controls: "speed",
            expr: "D = ½ × ρ × V² × A × CD",
            where: [["A", "迎風面積：從正前方看，車擋住空氣的面積（橘色那塊）"], ["CD", "阻力係數：形狀多會擋風"], ["ρ、V", "跟下壓力一樣"]],
            body: "面積越大、車速越快，阻力越大。\n\n電動車的電池有限，阻力會直接吃掉耐久賽的電。",
            note: "示範用 A = 1.0 m²、CD = 1.2（含空力套件，示意），A × CD = 1.2 m²，剛好是下壓力的 S × CL = 3.0 m² 除以升阻比 2.5。把車速拉到 80 帶數字：80 km/h = 22.2 m/s，D = 0.5 × 1.225 × 22.2² × 1.2 ≈ 363 N。阻力和下壓力一樣跟 V² 成正比。注意 CD 要配它定義時用的面積：整車用迎風面積 A，單看翼片時用翼面積 S，兩種不能混用。能量課會再算一次。" },
          { kind: "stats", title: "低速場，空力要算清楚", shot: { view: "aero", show: "downforce", speed: 52 },
            stats: [
              { label: "耐久賽平均車速", value: "48–57", unit: "km/h", text: "FSAE 規則對賽道的設計值。" },
              { label: "升阻比目標", value: "2–3", unit: "L/D", text: "每 1 N 下壓力，只付 0.3 到 0.5 N 的阻力。" },
            ],
            note: "畫面停在 52 km/h：箭頭明顯比 80 km/h 時短。速度低，下壓力就小，但翼片的重量和阻力一直都在。第一台車可以先不做空力，把重量和可靠度做好。" },
        ],
        quiz: [
          { q: "車速從 40 km/h 提高到 80 km/h，下壓力大約變成幾倍？",
            options: ["2 倍", "4 倍", "8 倍"], answer: 1, why: "下壓力和 V² 成正比。" },
          { q: "為什麼說下壓力「不計入慣性」？",
            options: ["它讓馬達功率變大", "它增加輪胎負荷，卻不增加車的質量", "它讓車變輕"], answer: 1,
            why: "抓地力變大，但要推動的質量沒變。" },
        ],
      },
      {
        id: "l2-brake", title: "煞車：其實是熱管理", focus: "煞車",
        summary: "動能變熱能、前後配比、熱衰退",
        slides: [
          { kind: "lead", eyebrow: "L2 · 04 煞車", title: "煞車是熱管理題", shot: { view: "brakes", show: "plain" },
            body: "讓車減速的是輪胎。煞車真正在做的，是把動能變成碟盤上的熱。",
            note: "接回 L1：卡鉗夾住碟盤。這一課問的是：那些熱有多少，要去哪裡。" },
          { kind: "stats", title: "一次煞車有多少能量", shot: { view: "brakes", show: "brakeheat", speed: 100 },
            stats: [
              { label: "280 kg，100 → 0 km/h", value: "108", unit: "kJ", text: "½ × 280 × 27.8² ≈ 108,000 J，兩三秒內變成熱。" },
              { label: "前後制動配比", value: "65 : 35", text: "煞車時重量往前移，前輪扛得多，能出的煞車力也多。" },
            ],
            note: "108 kJ 大約是把一杯水從室溫加熱到 70 度。前後配比是常見的起點，實際要看重心和軸距。" },
          { kind: "text", title: "車速越快，熱越多", shot: { view: "brakes", show: "brakeheat" }, controls: "speedBrake",
            body: "拉起始車速，看碟盤變多紅。\n\n能量跟車速平方成正比：快一倍，熱四倍。",
            note: "前碟盤比較紅，因為它分到六成五。電動車可以用馬達回充分擔一部分，碟盤就沒那麼熱。" },
          { kind: "text", title: "熱太多會怎樣", shot: { view: "brakes", show: "brakeheat", speed: 115 },
            body: "煞車油沸騰起泡，踏板變軟；來令片過熱，摩擦力下降。\n\n所以碟盤怎麼散熱，比卡鉗夾多緊更重要。",
            note: "前者叫氣阻，後者叫熱衰退。耐久賽 22 公里要煞很多次，散熱不夠的車到後半段就煞不住。" },
        ],
        quiz: [
          { q: "煞車系統本質上把車的動能轉換成什麼？",
            options: ["電能", "熱能", "位能"], answer: 1, why: "摩擦把動能變成碟盤和來令片的熱。" },
          { q: "280 kg 的車從 100 km/h 煞停，大約要吸收多少能量？",
            options: ["10.8 kJ", "108 kJ", "1080 kJ"], answer: 1, why: "½mv² = ½ × 280 × 27.8² ≈ 108 kJ。" },
        ],
      },
      {
        id: "l2-power", title: "動力：80 kW 怎麼用", focus: "動力",
        summary: "功率上限、馬達扭力、齒比",
        slides: [
          { kind: "lead", eyebrow: "L2 · 05 動力", title: "動力是放大器", shot: { view: "rear", show: "plain" },
            body: "電動車的動力，每一隊的上限都一樣。差別在於你能把多少動力，穩定地送到地面。",
            note: "L1 最後一課看過電池到後輪的路線。這一課回答：馬達和齒比該怎麼選。先提醒：動力排在輪胎、重量、空力、煞車之後，因為抓地力不夠，動力再多也沒用。" },
          { kind: "stats", title: "電動馬達跟引擎哪裡不一樣", shot: { view: "rear", show: "plain" },
            stats: [
              { label: "規則功率上限", value: "80", unit: "kW", text: "由車上的能量計量器監測，超過就違規。" },
              { label: "最大扭力出現在", value: "0", unit: "rpm", text: "一起步就有全部的扭力，不用等轉速上來。" },
              { label: "檔位", value: "1", unit: "個", text: "不用換檔，驅動力不會中斷。" },
            ],
            note: "汽油引擎要拉高轉速才有力，還要換檔。電動馬達從靜止就有最大扭力，所以多數電動賽車只用一組固定齒比。這讓車手比較好控制，也少一個會壞的東西。" },
          { kind: "formula", title: "扭力、轉速、功率", shot: { view: "rear", show: "plain" },
            expr: "P = T × ω",
            where: [["P", "功率（W）"], ["T", "扭力（N·m）"], ["ω", "轉速（rad/s）"]],
            body: "功率被限制在 80 kW。轉速越高，馬達能給的扭力就越小。",
            note: "這是下一張圖的關鍵：低速時馬達給得出最大扭力；到某個轉速之後，T × ω 碰到 80 kW，扭力只能往下掉。帶一個數字：80 kW、3000 rpm（314 rad/s）時，扭力最多 255 N·m；6000 rpm 時只剩 127 N·m。" },
          { kind: "chart", chart: "motor", title: "推力曲線", shot: { view: "rear", show: "plain" }, controls: "motor",
            body: "藍線是輪胎抓得住的上限。超過的推力，只會讓輪胎打滑。",
            note: "先把齒比拉到最大：起步推力很高，但超過藍線的部分只會讓輪胎打滑，極速還變得很低。再拉到最小：極速很高，起步卻沒力。請學生找出 75 m 加速最快的組合，再問：為什麼不是扭力最大、齒比最大的那一組？" },
          { kind: "text", title: "齒比怎麼選", shot: { view: "rear", show: "plain" },
            body: "齒比太大，低速多出來的推力輪胎接不住，極速又不夠。齒比太小，出彎沒力。\n\n耐久賽的最高車速大約 105 km/h。齒比選到極速略高於這個數字就夠了。",
            note: "105 km/h 和平均 48 到 57 km/h 是規則對耐久賽道的設計值。學生方程式大部分時間都在出彎加速，所以中低速的推力比極速重要。" },
        ],
        quiz: [
          { q: "FSAE 電動車的功率上限是多少？",
            options: ["60 kW", "80 kW", "沒有限制"], answer: 1, why: "規則規定能量計量器量到的功率不能超過 80 kW。" },
          { q: "功率固定在 80 kW 時，轉速越高，馬達能給的扭力會怎樣？",
            options: ["越大", "不變", "越小"], answer: 2, why: "P = T × ω。功率固定，轉速變大，扭力就得變小。" },
          { q: "齒比選得太大，會發生什麼事？",
            options: ["起步推力超過抓地力而打滑，極速也變低", "極速變高", "電池變重"], answer: 0,
            why: "多出來的推力輪胎接不住，馬達也更早轉到頂。" },
        ],
      },
      {
        id: "l2-energy", title: "能量：電池要撐完耐久賽", focus: "電池",
        summary: "22 公里、電池容量、省電的方法",
        slides: [
          { kind: "lead", eyebrow: "L2 · 06 能量", title: "電池帶多少才夠", shot: { view: "battery", show: "plain" },
            body: "帶太少，耐久賽跑不完。帶太多，整場比賽都揹著多餘的重量。",
            note: "汽油車加油很快，油也很輕。電動車的電池是全車最重的零件之一，所以「帶多少電」是設計一開始就要決定的事。" },
          { kind: "stats", title: "耐久賽有多重要", shot: { view: "battery", show: "plain" },
            stats: [
              { label: "耐久賽距離", value: "22", unit: "km", text: "中途換一次車手，一口氣跑完。" },
              { label: "耐久加效率的配分", value: "375", unit: "分", text: "耐久 275 分、效率 100 分。動態項目總共 675 分。" },
            ],
            note: "375 除以 675，超過一半。沒跑完耐久賽，這兩項幾乎都拿不到分。所以整台車最重要的目標不是最快，而是穩定跑完 22 公里。" },
          { kind: "formula", title: "要帶多少電", shot: { view: "battery", show: "energy" },
            expr: "能量 = 功率 × 時間",
            where: [["功率", "kW"], ["時間", "小時"], ["能量", "kWh"]],
            body: "耐久賽大約跑 25 分鐘。如果平均用 12 kW，就需要 5 kWh。",
            note: "25 分鐘是 22 公里除以平均時速約 53 km/h。平均 12 kW 是示範用的估計值，實際要看車重、車手和賽道，通常落在 4 到 7 kWh 之間。雖然上限是 80 kW，但大部分時間都在過彎，用不到那麼多。" },
          { kind: "text", title: "三種省電的方法", shot: { view: "battery", show: "plain", focus: null },
            body: "減重：車越輕，每次加速用的電越少。\n\n回充：煞車時讓馬達發電，把動能收回來。\n\n車手：提早放開油門滑行，少踩一次全力煞車。",
            note: "三個方法剛好對應前面的課：重量課、煞車課、L1 的動能回充。效率項目有 100 分，而且回充收回來的能量完全算數。" },
          { kind: "text", title: "電池不是越大越好", shot: { view: "battery", show: "energy" },
            body: "每多帶 1 kWh，電池箱大約多 6 到 8 公斤。\n\n重量課算過：每多 1 公斤，每圈慢 0.03 秒。",
            note: "6 到 8 公斤是整個電池箱的粗估值，含外殼、線材、電池管理系統。所以設計目標是「剛好跑完再多一點餘裕」。第一年建議餘裕抓大一點，先求跑完。" },
        ],
        quiz: [
          { q: "耐久賽大約要跑多遠？",
            options: ["5 公里", "22 公里", "100 公里"], answer: 1, why: "規則規定耐久賽總距離約 22 公里。" },
          { q: "平均功率 12 kW，跑 0.5 小時，需要多少能量？",
            options: ["6 kWh", "12 kWh", "24 kWh"], answer: 0, why: "能量 = 12 × 0.5 = 6 kWh。" },
          { q: "為什麼電池不是帶越多越好？",
            options: ["規則不允許", "電池很重，整場比賽都會拖慢圈速", "電池會漏電"], answer: 1,
            why: "多帶的電池是多餘的重量，每一圈都要付出代價。" },
        ],
      },
    ],
  },
  {
    id: "L3", title: "FSAE 比賽規則", sub: "怎麼拿分、怎麼過車檢",
    planned: [
      { title: "FSAE 比賽規則", place: "rules", summary: "賽事配分、靜態與動態項目、車檢流程、安全規定。" },
    ],
  },
];

// ── 進度（這台裝置） ─────────────────────────────────────
const ACADEMY_STORE = "academyProgress";
function readAcademyProgress() {
  try { return JSON.parse(localStorage.getItem(ACADEMY_STORE)) || {}; } catch { return {}; }
}
function useAcademyProgress() {
  const [done, setDone] = React.useState(readAcademyProgress);
  const markDone = React.useCallback((id) => {
    setDone(prev => {
      if (prev[id]) return prev;
      const next = { ...prev, [id]: true };
      try { localStorage.setItem(ACADEMY_STORE, JSON.stringify(next)); } catch {}
      return next;
    });
  }, []);
  return [done, markDone];
}

// 路線上的停靠點：0 是起點，之後每一課一站；還沒寫的課是「準備中」的站。
// 每一站都落在某個平台（place，見 AcademyWorld.jsx 的 ACADEMY_PLACES）；
// 同一個平台可以連續講好幾課（L2 六課都繞著同一台車）。
const ACADEMY_STOPS = [
  { kind: "cover", id: "cover", place: "start", title: "觀念建立",
    summary: "一站一個零件，沿著路線走完一台車。" },
  ...ACADEMY_LEVELS.flatMap(level => [
    ...(level.lessons || []).map(l => ({
      kind: "lesson", id: l.id, level, place: l.place || "car", title: l.title, summary: l.summary,
      lesson: { ...l, level },
      steps: l.slides,
    })),
    ...(level.planned || []).map(p => ({
      kind: "planned", id: `${level.id}-${p.place}`, level, place: p.place, title: p.title,
      summary: p.summary || "這一站還在準備中。",
    })),
  ]),
];
ACADEMY_STOPS.forEach(st => {
  if (st.steps) return;
  st.steps = [{
    kind: "lead", title: st.title, body: st.summary,
    eyebrow: st.kind === "cover" ? "NKUST Racing 學院" : `${st.level.id} ${st.level.title} · 準備中`,
  }];
});
const ACADEMY_PLACE_TITLES = { start: "起點", car: "一整台車" };

const ACADEMY_POS = "academyPos2";
function readAcademyPos() {
  try {
    const p = JSON.parse(localStorage.getItem(ACADEMY_POS));
    const st = ACADEMY_STOPS[p?.s];
    if (!st) return { s: 0, j: 0 };
    return { s: p.s, j: Math.max(0, Math.min(st.steps.length - 1, p.j || 0)) };
  } catch { return { s: 0, j: 0 }; }
}

// ── 頁面 ─────────────────────────────────────────────────
// 整個畫面是一個 3D 世界（AcademyWorld.jsx）。「下一步」不是換頁，
// 而是鏡頭在同一個展品周圍換視角；一站講完，鏡頭沿路線走到下一座平台。
// 第 0 站（觀念建立）就是整條路線的俯視圖；按空白鍵降落到第一站。
// 鍵盤：→ 空白鍵 PageDown 下一步｜← PageUp 上一步｜↑ ↓ 調目前的滑桿｜1–9 選第幾條滑桿｜N 講稿
function Academy() {
  const [done, markDone] = useAcademyProgress();
  const [pos, setPos] = React.useState(readAcademyPos);
  const [reveal, setReveal] = React.useState(false);     // 「動手畫」的參考答案
  const [params, setParams] = React.useState({});        // 互動滑桿的值
  const [showNote, setShowNote] = React.useState(false);
  const [slider, setSlider] = React.useState(0);       // ↑↓ 調的是第幾條滑桿
  const [status, setStatus] = React.useState("loading");
  const [narrow, setNarrow] = React.useState(() => window.innerWidth < 768);
  const canvasRef = React.useRef(null);
  const labelRef = React.useRef(null);
  const worldRef = React.useRef(null);
  const wheelLock = React.useRef(0);

  const stop = ACADEMY_STOPS[pos.s];
  const step = stop.steps[pos.j];
  const overview = stop.kind === "cover";
  const lastStop = ACADEMY_STOPS.length - 1;
  const atEnd = pos.s === lastStop && pos.j === stop.steps.length - 1;
  const atStart = pos.s === 0 && pos.j === 0;
  const wideCopy = step.kind === "chart";
  const lastOfLesson = stop.kind === "lesson" && pos.j === stop.steps.length - 1;

  const goTo = React.useCallback((s, j = 0) => setPos({ s, j }), []);
  const next = React.useCallback(() => setPos(p => {
    if (p.j < ACADEMY_STOPS[p.s].steps.length - 1) return { s: p.s, j: p.j + 1 };
    return p.s < lastStop ? { s: p.s + 1, j: 0 } : p;
  }), [lastStop]);
  const prev = React.useCallback(() => setPos(p => {
    if (p.j > 0) return { s: p.s, j: p.j - 1 };
    return p.s > 0 ? { s: p.s - 1, j: ACADEMY_STOPS[p.s - 1].steps.length - 1 } : p;
  }), []);

  React.useEffect(() => {
    const onResize = () => setNarrow(window.innerWidth < 768);
    window.addEventListener("resize", onResize);
    return () => window.removeEventListener("resize", onResize);
  }, []);

  // 建立 3D 世界（只做一次）
  React.useEffect(() => {
    let dead = false;
    createAcademyWorld({
      canvas: canvasRef.current, labelLayer: labelRef.current,
      onPickPlace: (placeId) => {
        const s = ACADEMY_STOPS.findIndex(st => st.place === placeId);
        if (s >= 0) goTo(s);
      },
    }).then(world => {
      if (dead) { world.dispose(); return; }
      worldRef.current = world;
      const seen = new Set();
      world.setPlaceLabels(ACADEMY_STOPS.filter(st => !seen.has(st.place) && seen.add(st.place)).map(st => ({
        place: st.place, planned: st.kind === "planned",
        no: String(ACADEMY_STOPS.indexOf(st)).padStart(2, "0"),
        title: ACADEMY_PLACE_TITLES[st.place] || st.title,
      })));
      setStatus("ready");
    }).catch(err => {
      console.error("[Academy] 3D 世界建立失敗:", err);
      if (!dead) setStatus("error");
    });
    return () => { dead = true; worldRef.current?.dispose(); worldRef.current = null; };
  }, [goTo]);

  React.useEffect(() => {
    setReveal(false); setParams({}); setSlider(0);
    try { localStorage.setItem(ACADEMY_POS, JSON.stringify(pos)); } catch {}
  }, [pos]);

  // 講到一課的最後一步，就算這課完成
  React.useEffect(() => { if (lastOfLesson) markDone(stop.id); }, [lastOfLesson, stop, markDone]);

  // 把目前這一步告訴 3D 世界：哪個平台、哪個視角、顯示什麼
  React.useEffect(() => {
    const world = worldRef.current;
    if (!world) return;
    const shot = { view: "hero", show: "plain", focus: stop.lesson?.focus ?? null, ...step.shot };
    if (narrow) world.setFraming(0, 0.2, 1.55);
    else world.setFraming(wideCopy ? 0.21 : 0.16, 0, wideCopy ? 1.15 : 1);
    world.setOverview(overview);
    world.go(stop.place, shot, { params, reveal });
  }, [status, pos, stop, step, params, reveal, overview, narrow, wideCopy]);

  React.useEffect(() => {
    const onKey = (e) => {
      const tag = e.target?.tagName;
      if (tag === "INPUT" || tag === "TEXTAREA" || e.target?.isContentEditable) return;
      if (e.metaKey || e.ctrlKey || e.altKey) return;
      const k = e.key;
      // 焦點在旋鈕上時，↑↓ 由旋鈕自己處理（避免全域再加一次）
      if ((k === "ArrowUp" || k === "ArrowDown") && e.target?.closest?.('[role="slider"]')) return;
      const ctrls = ACADEMY_CONTROLS[step.controls] || [];
      if (k === "ArrowRight" || k === " " || k === "PageDown") { e.preventDefault(); next(); }
      else if (k === "ArrowLeft" || k === "PageUp") { e.preventDefault(); prev(); }
      else if (k === "ArrowUp" || k === "ArrowDown") {
        e.preventDefault();
        const c = ctrls[Math.min(slider, ctrls.length - 1)];
        if (!c) return;
        // 一下走 1/10 的範圍（至少一格），按住會連續走
        const inc = Math.max(c.step, Math.round((c.max - c.min) / 10 / c.step) * c.step) * (k === "ArrowUp" ? 1 : -1);
        setParams(p => {
          const v = Math.max(c.min, Math.min(c.max, (p[c.key] ?? c.init) + inc));
          return { ...p, [c.key]: Math.round(v * 100) / 100 };
        });
      }
      else if (/^[1-9]$/.test(k) && ctrls.length > 1) { const i = +k - 1; if (i < ctrls.length) setSlider(i); }
      else if (k === "n" || k === "N") { e.preventDefault(); setShowNote(v => !v); }
    };
    window.addEventListener("keydown", onKey);
    return () => window.removeEventListener("keydown", onKey);
  }, [next, prev, step, slider]);

  // 滾輪：滾一下走一步；在可捲動的文字區裡不搶。
  const onWheel = (e) => {
    const scroller = e.target.closest?.(".aw-copy");
    if (scroller && scroller.scrollHeight > scroller.clientHeight + 1) return;
    const d = Math.abs(e.deltaY) > Math.abs(e.deltaX) ? e.deltaY : e.deltaX;
    if (Math.abs(d) < 24) return;
    const now = Date.now();
    if (now < wheelLock.current) return;
    wheelLock.current = now + 800;
    d > 0 ? next() : prev();
  };

  const stopNo = (k) => String(k).padStart(2, "0");
  let lastLevel = null;

  return (
    <div className={`aw-root${overview ? " is-overview" : ""}${wideCopy ? " is-wide" : ""}`} onWheel={onWheel}>
      <canvas ref={canvasRef} className="aw-canvas"/>
      <div ref={labelRef} className="aw-labels"/>
      {status !== "ready" && (
        <div className="aw-status">{status === "error" ? "3D 場景載入失敗，請重新整理。" : "載入 3D 場景…"}</div>
      )}

      {/* 左上：現在在哪 */}
      <div className="aw-crumb">
        <span className="aw-crumb-no">{stopNo(pos.s)}</span>
        <span className="aw-crumb-title">{stop.title}</span>
        {!overview && stop.level && <span className="aw-crumb-level">{stop.level.id} {stop.level.title}</span>}
      </div>

      {/* 右上：工具 */}
      <div className="aw-tools">
        <button type="button" className={`aw-tool${showNote ? " is-on" : ""}`} aria-pressed={showNote}
          onClick={() => setShowNote(v => !v)} title="講稿（N）">講稿</button>
      </div>

      {/* 左側：路線地圖，一個點一站 */}
      <nav className="aw-rail" aria-label="路線">
        {ACADEMY_STOPS.map((st, k) => {
          const levelId = st.level?.id || null;
          const head = levelId && levelId !== lastLevel ? levelId : null;
          lastLevel = levelId;
          return (
            <React.Fragment key={st.id}>
              {head && <span className="aw-rail-level">{head}</span>}
              <button type="button" onClick={() => goTo(k)}
                className={`aw-rail-stop${k === pos.s ? " is-current" : ""}${done[st.id] ? " is-done" : ""}${st.kind === "planned" ? " is-planned" : ""}`}
                aria-label={`第 ${k} 站：${st.title}`} aria-current={k === pos.s ? "step" : undefined}>
                <span className="aw-rail-dot"/>
                <span className="aw-rail-title">{st.title}</span>
              </button>
            </React.Fragment>
          );
        })}
      </nav>

      {/* 右側：這一步的文字 */}
      {(
        <div className={`aw-copy${overview ? " aw-copy--cover" : ""}`} key={`${pos.s}-${pos.j}`}>
          <AcademyCopy step={step} params={params} reveal={reveal} onReveal={() => setReveal(v => !v)}/>
          {step.controls && <AcademyControls kind={step.controls} params={params} onChange={setParams} active={slider} onActive={setSlider}/>}
          {showNote && (step.note || (lastOfLesson && stop.lesson.quiz)) && (
            <aside className="awc-note">
              {step.note && <><div className="awc-note-label">講稿</div><p>{step.note}</p></>}
              {lastOfLesson && stop.lesson.quiz?.length > 0 && (
                <>
                  <div className="awc-note-label awc-note-label--gap">課堂提問（口頭問全班）</div>
                  <ol>
                    {stop.lesson.quiz.map((q, i) => (
                      <li key={i}><strong>{q.q}</strong><br/>答：{q.options[q.answer]}。{q.why}</li>
                    ))}
                  </ol>
                </>
              )}
            </aside>
          )}
        </div>
      )}
      {/* 第 0 站：提示按空白鍵出發 */}
      {overview && (
        <button type="button" className="aw-space" onClick={next} aria-label="按空白鍵開始">
          <span className="aw-space-key">space</span>
          <span className="aw-space-text">開始</span>
        </button>
      )}

      {/* 下方：這一站走到第幾步 */}
      {!overview && (
        <div className="aw-dock">
          <button type="button" className="aw-dock-arrow" onClick={prev} disabled={atStart} aria-label="上一步">
            <span className="aw-chev aw-chev--left"/>
          </button>
          <div className="aw-dock-steps" role="tablist" aria-label="這一站的步驟">
            {stop.steps.map((s, j) => (
              <button key={j} type="button" role="tab" aria-selected={j === pos.j}
                className={`aw-seg${j === pos.j ? " is-current" : j < pos.j ? " is-past" : ""}`}
                onClick={() => goTo(pos.s, j)} aria-label={`第 ${j + 1} 步：${s.title}`} title={s.title}/>
            ))}
          </div>
          <button type="button" className="aw-dock-arrow aw-dock-arrow--next" onClick={next} disabled={atEnd} aria-label="下一步">
            <span className="aw-chev"/>
          </button>
        </div>
      )}
    </div>
  );
}

// 互動滑桿：改的是 3D 展品的參數（箭頭長度、重心位置），或右邊的圖表
const ACADEMY_CONTROLS = {
  wheelLoad: [
    { key: "n",  label: "垂直力", min: 300, max: 1500, step: 50, init: 750, unit: "N" },
    { key: "mu", label: "摩擦係數 μ", min: 0.4, max: 1.5, step: 0.1, init: 1 },
  ],
  steer: [
    { key: "steer", label: "前輪轉角", min: -30, max: 30, step: 1, init: 18, unit: "°" },
  ],
  steerMech: [
    { key: "steer", label: "前輪轉角", min: -24, max: 24, step: 1, init: 15, unit: "°" },
  ],
  steerAck: [
    { key: "steer", label: "前輪轉角", min: 8, max: 24, step: 1, init: 20, unit: "°" },
  ],
  steerLeft: [
    { key: "steer", label: "前輪轉角", min: 14, max: 32, step: 1, init: 20, unit: "°" },
  ],
  bump: [
    { key: "bump", label: "路面高低", min: -25, max: 60, step: 5, init: 35, unit: "mm" },
  ],
  shockAt: [
    { key: "shockAt", label: "避震下端位置", min: 40, max: 90, step: 5, init: 75, unit: "%" },
  ],
  damper: [
    { key: "zeta", label: "阻尼", min: 0.05, max: 1.2, step: 0.05, init: 0.1 },
  ],
  brake: [
    { key: "brake", label: "踩煞車", min: 0, max: 100, step: 5, init: 40, unit: "%" },
  ],
  throttle: [
    { key: "throttle", label: "踩油門", min: 0, max: 100, step: 5, init: 40, unit: "%" },
  ],
  cg: [
    { key: "front", label: "重心往前", min: 30, max: 70, step: 1, init: 45, unit: "%" },
    { key: "left",  label: "重心往左", min: 30, max: 70, step: 1, init: 50, unit: "%" },
  ],
  accel: [
    { key: "ax", label: "加速度", min: 0, max: 1.2, step: 0.1, init: 0.6, unit: "g" },
  ],
  corner: [
    { key: "ay", label: "側向 g", min: 0, max: 1.5, step: 0.1, init: 0.8, unit: "g" },
  ],
  friction: [
    { key: "fx", label: "煞車 ↔ 加速", min: -100, max: 100, step: 5, init: -60, unit: "%" },
    { key: "fy", label: "左彎 ↔ 右彎", min: -100, max: 100, step: 5, init: 60, unit: "%" },
  ],
  tireLoad: [
    { key: "load", label: "這顆輪胎扛的重量", min: 20, max: 160, step: 10, init: 70, unit: "kg" },
  ],
  weight: [
    { key: "cgh", label: "重心高度", min: 200, max: 450, step: 10, init: 280, unit: "mm" },
    { key: "g", label: "側向 g", min: 0, max: 1.6, step: 0.1, init: 1.2, unit: "g" },
  ],
  battery: [
    { key: "bh", label: "電池高度", min: 15, max: 55, step: 5, init: 30, unit: "cm" },
    { key: "bpos", label: "電池前後", min: -30, max: 30, step: 5, init: 0, unit: "cm" },
  ],
  speed: [
    { key: "speed", label: "車速", min: 0, max: 120, step: 5, init: 60, unit: "km/h" },
  ],
  speedBrake: [
    { key: "speed", label: "起始車速", min: 20, max: 120, step: 5, init: 80, unit: "km/h" },
  ],
  motor: [
    { key: "torque", label: "馬達扭力", min: 60, max: 230, step: 10, init: 200, unit: "N·m" },
    { key: "ratio", label: "齒比", min: 2.5, max: 6, step: 0.25, init: 4.5, unit: ": 1" },
  ],
};
// 旋鈕：270° 刻度盤（-135° 到 +135°，缺口朝下）。
// 拖曳：從刻度環上按下 → 指針跟著游標的角度走（點刻度直接跳、繞圈拖）；從中央旋鈕帽按下 → 上下拖（上增下減）。
// 滾輪、↑↓／Home／End、− ＋ 按鈕都吸附到 step。
function AcademyKnob({ c, value, active, solo, index, count, onSet, onActive }) {
  const dialRef = React.useRef(null);
  const dragRef = React.useRef(null);
  const live = React.useRef({});
  live.current = { c, value, onSet };
  const span = c.max - c.min;
  const snap = (raw, cc = c) => {
    const n = Math.round((raw - cc.min) / cc.step);
    const v = Math.max(cc.min, Math.min(cc.max, cc.min + n * cc.step));
    return Math.round(v * 100) / 100;
  };
  const set = (v) => { const L = live.current; const s = snap(v, L.c); if (s !== L.value) L.onSet(L.c.key, s); };
  const frac = Math.max(0, Math.min(1, (value - c.min) / span));
  const ang = -135 + 270 * frac;
  const pt = (r, deg) => [60 + r * Math.sin(deg * Math.PI / 180), 60 - r * Math.cos(deg * Math.PI / 180)];
  const arc = (r) => { const [x1, y1] = pt(r, -135), [x2, y2] = pt(r, 135); return `M${x1} ${y1} A${r} ${r} 0 1 1 ${x2} ${y2}`; };
  const nTicks = Math.min(Math.round(span / c.step), 24);
  const ticks = Array.from({ length: nTicks + 1 }, (_, i) => i / nTicks);
  const [dx, dy] = pt(30, ang);

  const angleValue = (e) => {
    const r = dialRef.current.getBoundingClientRect();
    let a = Math.atan2(e.clientX - (r.left + r.width / 2), -(e.clientY - (r.top + r.height / 2))) * 180 / Math.PI;
    if (a > 135) a = 135; else if (a < -135) a = -135;
    return live.current.c.min + (a + 135) / 270 * (live.current.c.max - live.current.c.min);
  };
  const onDown = (e) => {
    if (e.button != null && e.button > 0) return;
    onActive?.(index);
    const r = dialRef.current.getBoundingClientRect();
    const dist = Math.hypot(e.clientX - (r.left + r.width / 2), e.clientY - (r.top + r.height / 2)) / (r.width / 2);
    const mode = dist > 0.52 ? "angle" : "vert";
    dragRef.current = { mode, y: e.clientY, v: live.current.value };
    e.currentTarget.setPointerCapture?.(e.pointerId);
    e.currentTarget.focus?.({ preventScroll: true });
    if (mode === "angle") set(angleValue(e));
    e.preventDefault();
  };
  const onMove = (e) => {
    const d = dragRef.current;
    if (!d) return;
    if (d.mode === "angle") set(angleValue(e));
    else set(d.v + (d.y - e.clientY) / 140 * (live.current.c.max - live.current.c.min));
  };
  const onUp = (e) => { dragRef.current = null; e.currentTarget.releasePointerCapture?.(e.pointerId); };

  // 滾輪要 passive:false 才能擋掉頁面的「滾一下換一步」
  React.useEffect(() => {
    const el = dialRef.current;
    if (!el) return;
    const wheel = (e) => {
      e.preventDefault(); e.stopPropagation();
      const L = live.current;
      const d = e.deltaY !== 0 ? e.deltaY : e.deltaX;
      if (d === 0) return;
      onActive?.(index);
      const s = L.c.step * (e.shiftKey ? 5 : 1);
      set(L.value + (d < 0 ? s : -s));
    };
    el.addEventListener("wheel", wheel, { passive: false });
    return () => el.removeEventListener("wheel", wheel);
  }, [index]);

  const onKey = (e) => {
    const k = e.key;
    let nv = null;
    if (k === "ArrowUp") nv = value + c.step * (e.shiftKey ? 5 : 1);
    else if (k === "ArrowDown") nv = value - c.step * (e.shiftKey ? 5 : 1);
    else if (k === "Home") nv = c.min;
    else if (k === "End") nv = c.max;
    if (nv == null) return;
    e.preventDefault(); e.stopPropagation();
    set(nv);
  };
  const bump = (dir) => (e) => { e.preventDefault(); e.stopPropagation(); onActive?.(index); set(value + dir * c.step); };

  return (
    <div className={`aw-knob${active ? " is-active" : ""}${solo ? " is-solo" : ""}`} onPointerDown={() => onActive?.(index)}>
      <div className="aw-knob-label">{count > 1 && <kbd>{index + 1}</kbd>}{c.label}</div>
      <div className="aw-knob-row">
        <button type="button" className="aw-knob-step" tabIndex={-1} aria-label={`${c.label} 減一格`}
          disabled={value <= c.min} onPointerDown={e => e.stopPropagation()} onClick={bump(-1)}>−</button>
        <div className="aw-knob-dial" ref={dialRef} role="slider" tabIndex={0}
          aria-label={c.label} aria-valuemin={c.min} aria-valuemax={c.max} aria-valuenow={value}
          aria-valuetext={`${value}${c.unit ? " " + c.unit : ""}`} aria-orientation="vertical"
          onPointerDown={onDown} onPointerMove={onMove} onPointerUp={onUp} onPointerCancel={onUp}
          onKeyDown={onKey} onFocus={() => onActive?.(index)}>
          <svg viewBox="0 0 120 120" aria-hidden="true">
            <path className="aw-knob-track" d={arc(46)} pathLength="100" />
            <path className="aw-knob-fill" d={arc(46)} pathLength="100" strokeDasharray={`${frac * 100} 100`} style={{ opacity: frac > 0 ? 1 : 0 }} />
            {ticks.map((f, i) => {
              const a = -135 + 270 * f, [x1, y1] = pt(52, a), [x2, y2] = pt(i % 5 === 0 || nTicks <= 10 ? 58 : 56, a);
              return <line key={i} className={`aw-knob-tick${f <= frac + 1e-6 ? " is-on" : ""}`} x1={x1} y1={y1} x2={x2} y2={y2} />;
            })}
            <circle className="aw-knob-cap" cx="60" cy="60" r="37" />
            <circle className="aw-knob-dot" cx={dx} cy={dy} r="3.4" />
          </svg>
          <div className="aw-knob-value"><b>{value}</b>{c.unit && <small>{c.unit}</small>}</div>
        </div>
        <button type="button" className="aw-knob-step" tabIndex={-1} aria-label={`${c.label} 加一格`}
          disabled={value >= c.max} onPointerDown={e => e.stopPropagation()} onClick={bump(1)}>＋</button>
      </div>
    </div>
  );
}

function AcademyControls({ kind, params, onChange, active = 0, onActive }) {
  const list = ACADEMY_CONTROLS[kind] || [];
  const setOne = (key, v) => onChange({ ...params, [key]: v });
  return (
    <div className={`aw-sliders aw-knobs${list.length === 1 ? " is-solo" : ""}`}>
      <div className="aw-knob-grid">
        {list.map((c, i) => (
          <AcademyKnob key={c.key} c={c} value={params[c.key] ?? c.init} index={i} count={list.length}
            solo={list.length === 1} active={i === Math.min(active, list.length - 1)}
            onSet={setOne} onActive={onActive}/>
        ))}
      </div>
      <div className="aw-slider-hint">拖曳旋鈕或滾輪、<kbd>↑</kbd><kbd>↓</kbd> 調整，點刻度直接跳{list.length > 1 ? `；數字鍵選第幾顆` : ""}</div>
    </div>
  );
}

// 一步的文字：沒有底色，直接放在展品旁邊（字的外框用背景色描邊，壓在 3D 上也讀得到）
function AcademyCopy({ step, params, reveal, onReveal }) {
  const paras = (text) => (text || "").split("\n\n").map((t, i) => <p key={i}>{t}</p>);
  const where = Array.isArray(step.where) ? step.where
    : (step.where || "").split("\n").filter(Boolean).map(line => {
        const k = line.indexOf(" ");
        return k > 0 ? [line.slice(0, k), line.slice(k + 1)] : ["", line];
      });
  const body = step.body ? <div className="awc-body">{paras(step.body)}</div> : null;
  switch (step.kind) {
    case "lead":
      return (
        <div className="awc awc--lead">
          {step.eyebrow && <div className="awc-kicker">{step.eyebrow}</div>}
          <h1 className="awc-title">{step.title}</h1>
          {body}
        </div>
      );
    case "stats":
      return (
        <div className="awc">
          <h2 className="awc-title">{step.title}</h2>
          <div className="awc-stats">
            {step.stats.map(s => (
              <div key={s.label}>
                <div className="awc-stat-value">{s.value}{s.unit && <span className="awc-stat-unit">{s.unit}</span>}</div>
                <div className="awc-stat-label">{s.label}</div>
                {s.text && <p className="awc-stat-text">{s.text}</p>}
              </div>
            ))}
          </div>
        </div>
      );
    case "formula":
      return (
        <div className="awc">
          <h2 className="awc-title">{step.title}</h2>
          <div className="awc-expr">{step.expr}</div>
          {where.length > 0 && (
            <dl className="awc-where">
              {where.map(([k, v], i) => <React.Fragment key={i}><dt>{k}</dt><dd>{v}</dd></React.Fragment>)}
            </dl>
          )}
          {body}
        </div>
      );
    case "chart":
      return (
        <div className="awc">
          <h2 className="awc-title">{step.title}</h2>
          {body}
          {step.chart === "motor" && <AcademyMotorChart params={params}/>}
        </div>
      );
    case "draw":
      return (
        <div className="awc">
          <div className="awc-kicker">動手畫</div>
          <h2 className="awc-title">{step.title}</h2>
          {body}
          <button type="button" className="awc-reveal" onClick={onReveal}>{reveal ? "收起參考答案" : "看參考答案"}</button>
        </div>
      );
    default:
      return (
        <div className="awc">
          <h2 className="awc-title">{step.title}</h2>
          {body}
          {step.quote && (
            <blockquote className="awc-quote">
              <p>{step.quote.text}</p>
              <cite>{step.quote.src}</cite>
            </blockquote>
          )}
        </div>
      );
  }
}

// 推力曲線：馬達扭力 × 齒比 → 後輪推力，80 kW 之後沿功率線往下掉；藍線是後輪抓得住的上限。
// 數字都是示範用：280 kg（含車手）、後軸 60%、μ 1.4、輪胎半徑 0.23 m、馬達最高 6500 rpm、CdA 1.2。
const AM = { P: 80000, RPM: 6500, R: 0.23, M: 280, CDA: 1.2 };
AM.GRIP = 1.4 * AM.M * 9.81 * 0.6;
function academyMotor(torque, ratio) {
  const vMax = AM.RPM * 2 * Math.PI / 60 * AM.R / ratio;                  // m/s，轉到頂
  const force = (v) => {
    if (v >= vMax) return 0;
    const w = Math.max(1, v / AM.R * ratio);                               // 馬達 rad/s
    return Math.min(torque, AM.P / w) * ratio / AM.R;
  };
  const drag = (v) => 0.5 * 1.225 * AM.CDA * v * v;
  let v = 0, x = 0, t = 0;
  while (x < 75 && t < 20) {
    const f = Math.min(force(v), AM.GRIP) - drag(v);
    v = Math.max(0, Math.min(vMax, v + f / AM.M * 0.005));
    x += v * 0.005; t += 0.005;
  }
  return { vMax, force, t };
}
function AcademyMotorChart({ params }) {
  const torque = params.torque ?? 200, ratio = params.ratio ?? 4.5;
  const { vMax, force, t } = academyMotor(torque, ratio);
  const W = 440, H = 200, X0 = 34, Y0 = H - 22, VX = 140, FY = 6000;
  const sx = (kmh) => X0 + kmh / VX * (W - X0 - 6);
  const sy = (n) => Y0 - Math.min(n, FY) / FY * (Y0 - 8);
  const pts = [], use = [];
  const top = vMax * 3.6;
  const end = Math.min(VX, top - 0.01);                                     // 曲線畫到馬達轉到頂為止
  for (let k = 0; k <= end + 1; k += 1) {
    const kmh = Math.min(k, end), f = force(kmh / 3.6);
    pts.push(`${sx(kmh).toFixed(1)},${sy(f).toFixed(1)}`);
    use.push(`${sx(kmh).toFixed(1)},${sy(Math.min(f, AM.GRIP)).toFixed(1)}`);
  }
  return (
    <div className="awc-chart">
      <div className="awc-chart-read">
        <div>極速<strong>{Math.round(top)}<small>km/h</small></strong></div>
        <div>75 m 加速<strong>{t >= 20 ? "—" : t.toFixed(2)}<small>秒</small></strong></div>
      </div>
      <svg viewBox={`0 0 ${W} ${H}`} role="img" aria-label="後輪推力對車速">
        {[0, 2000, 4000, 6000].map(n => (
          <g key={n}>
            <line x1={X0} x2={W - 6} y1={sy(n)} y2={sy(n)} stroke="var(--separator)" strokeWidth="0.5"/>
            <text x={X0 - 6} y={sy(n) + 4} textAnchor="end" fontSize="10" fill="var(--label-tertiary)">{n / 1000}k</text>
          </g>
        ))}
        {[0, 40, 80, 120].map(k => (
          <text key={k} x={sx(k)} y={H - 6} textAnchor="middle" fontSize="10" fill="var(--label-tertiary)">{k}</text>
        ))}
        <text x={W - 6} y={H - 6} textAnchor="end" fontSize="10" fill="var(--label-tertiary)">km/h</text>
        <polyline points={pts.join(" ")} fill="none" stroke="var(--orange)" strokeWidth="1.5" strokeDasharray="3 4" opacity="0.55"/>
        <polyline points={use.join(" ")} fill="none" stroke="var(--orange)" strokeWidth="2.5" strokeLinejoin="round"/>
        <line x1={X0} x2={W - 6} y1={sy(AM.GRIP)} y2={sy(AM.GRIP)} stroke="var(--blue, #0a84ff)" strokeWidth="1.5"/>
        <text x={W - 6} y={sy(AM.GRIP) - 6} textAnchor="end" fontSize="11" fill="var(--blue, #0a84ff)">抓地力上限</text>
        <line x1={sx(Math.min(top, VX))} x2={sx(Math.min(top, VX))} y1={Y0} y2={8} stroke="var(--label-tertiary)" strokeWidth="0.75" strokeDasharray="2 3"/>
      </svg>
    </div>
  );
}

Object.assign(window, { Academy, ACADEMY_LEVELS });
