一、引言

當(dāng)你想做一個簡單的手機(jī)游戲 ， 比如 Flappy Bird、2048、貪吃蛇——你的第一反應(yīng)可能是打開 Unity 或者 Godot。但你有沒有想過：對于一個只需要畫幾個矩形和圓的游戲，你真的需要一個完整的游戲引擎嗎？

引擎內(nèi)部數(shù)十萬行的 C++ 代碼 帶來的不只是便利， 或許還有冗余 。如果我們換一種思路 ： 不用引擎，不依賴運行時，直接用一門現(xiàn)代語言編寫游戲邏輯，編譯為原生機(jī)器碼，再搭配一個極簡的圖形庫 ， 結(jié)果會怎樣？

這正是本文要探討的命題 ： 使用 MoonBit （一門編譯到原生代碼的現(xiàn)代語言）和 Raylib （一個僅提供最基本圖形能力的 C 庫），從零構(gòu)建一個可以在 Android 手機(jī)上運行的 Flappy Bird。

在這個過程中，你會看到：一個完整的移動游戲，可以只有幾百行代碼、幾 MB 的 APK，以及零引擎依賴。

Web 游戲試玩鏈接：

https://moonbit-community.github.io/tonyfettes-raylib-android-games

Android 游戲 APK 下載鏈接：

https://moonbit-community.github.io/tonyfettes-raylib-android-games/

二、移動游戲開發(fā)的技術(shù)選型 演進(jìn)

2015年前后，手機(jī)游戲開發(fā)主要依賴三大技術(shù)路線：

1. 引擎時代（Unity/Godot）：提供一站式開發(fā)環(huán)境，大幅降低門檻，但存在包體臃腫、底層黑箱、版本更新風(fēng)險等問題。Godot 雖開源，思路仍類似。

2. 跨平臺框架（React Native/Flutter）：承諾一套代碼多端運行，適合 UI 應(yīng)用。但在游戲中暴露出額外抽象層、GC 停頓、非為高頻渲染優(yōu)化等性能瓶頸。

3. 原生 NDK（C/C++）：性能最優(yōu)，無中間開銷，但開發(fā)體驗差，手動內(nèi)存管理易引發(fā)段錯誤等 bug，對業(yè)余項目成本過高。

有沒有一種方案，既能獲得原生性能，又能享受現(xiàn)代語言的開發(fā)體驗？

這正是 MoonBit 和 Raylib 的組合所提供的。

MoonBit 是一門為性能而設(shè)計的現(xiàn)代編程語言。它擁有強(qiáng)類型系統(tǒng)、模式匹配、類型推導(dǎo)，編寫體驗接近 Rust 或 OCaml，但編譯目標(biāo)是 C——這意味著它可以直接對接 Android NDK 的工具鏈，最終生成和手寫 C 一樣高效的原生代碼。

Raylib 則是游戲圖形庫的極簡主義代表。它不是引擎，不幫你管理場景，不提供編輯器——它只做四件事： 開窗口、畫圖形、讀輸入、放聲音 。用戶面對的核心 API 集中在一個頭文件 raylib.h 中，沒有復(fù)雜的依賴關(guān)系，沒有狀態(tài)機(jī)，沒有回調(diào)地獄。

把它們組合在一起，你得到的是：

這不是說 MoonBit + Raylib 適合所有場景——如果你在做一款需要物理引擎、粒子系統(tǒng)、骨骼動畫的大型游戲，Unity 仍然是更合理的選擇。但如果你的目標(biāo)是一款邏輯清晰的 2D 游戲，這套"極簡主義"方案可能是最干凈的路徑。

讓我們來看看它是怎么工作的。

三、理解構(gòu)建鏈路：從源碼到 APK

在動手寫代碼之前，有一個問題值得想清楚： 你寫的 MoonBit 代碼，是如何變成手機(jī)上可以運行的 APK 的？

理解構(gòu)建鏈路不是為了背誦流程——而是為了在出問題時，知道該往哪里看。

1、 構(gòu)建鏈路

整個過程可以用一條鏈來描述：

讓我們逐步拆解。

第一步：MoonBit → C 。MoonBit 編譯器將你的 `.mbt` 源文件編譯為標(biāo)準(zhǔn) C 代碼。MoonBit 的強(qiáng)類型系統(tǒng)在編譯期就排除了大量常見錯誤，生成的 C 代碼是高效的、確定性的。你可以把它理解為：MoonBit 幫你寫了人類不太愿意手寫的那種高質(zhì)量 C 代碼。

第二步：C → .so 。Android NDK 中的交叉編譯器（通常是 clang）接手，將 C 代碼連同 Raylib 的源碼一起編譯為目標(biāo)架構(gòu)的共享庫（`.so` 文件）。這一步和你用 NDK 編譯任何 C/C++ 項目一樣。

第三步：打包成 APK 。Gradle 構(gòu)建系統(tǒng)將 .so 文件打包進(jìn) APK。同時，那個極輕量的 Kotlin 入口點（僅僅是加載庫和隱藏系統(tǒng) UI）會經(jīng)過標(biāo)準(zhǔn)的 Android 編譯流程：Kotlin 編譯器將其編譯為 JVM 字節(jié)碼，再由 D8 工具轉(zhuǎn)換為 Android 運行時使用的 classes.dex 。最終的 APK 結(jié)構(gòu)非常簡單：

APK
├── classes.dex          ← 極小的 Kotlin 膠水代碼
├── lib/
│   ├── arm64-v8a/
│   │   └── libflappybird.so   ← 你的游戲 + Raylib
│   └── armeabi-v7a/
│       └── libflappybird.so
└── AndroidManifest.xml

如果用一個類比：傳統(tǒng)引擎方案就像你寫了一封信，然后把它裝進(jìn)一個帶有自動翻譯器、排版引擎和朗讀功能的智能信封里寄出去。而 MoonBit + Raylib 的方案就像你直接把信折好，塞進(jìn)一個普通信封——信的內(nèi)容沒有變，但信封輕了十倍。

2、 腳手架：一鍵搭建項目

理解了鏈路之后，實際操作反而很簡單。MoonBit 生態(tài)提供了一個腳手架工具，可以一鍵生成上述所有構(gòu)建配置：

moon install tonyfettes/create-moonbit-raylib-android-app
create-moonbit-raylib-android-app MyFlappyBird

生成的項目結(jié)構(gòu)看起來像這樣：

MyFlappyBird/
├── gradlew                          # Gradle 構(gòu)建包裝器
├── app/
│   ├── build.gradle.kts             # Android 構(gòu)建配置 (NDK, ABI 目標(biāo))
│   ├── src/main/
│   │   ├── AndroidManifest.xml      # 應(yīng)用清單 (NativeActivity)
│   │   ├── java/.../MainActivity.kt # 輕量 Kotlin 入口點
│   │   ├── moonbit/                 # 你的游戲代碼存放處
│   │   │   ├── main.mbt            # 游戲代碼
│   │   │   ├── moon.mod.json       # MoonBit 模塊配置
│   │   │   └── moon.pkg            # 包聲明
│   │   └── cpp/
│   │       └── CMakeLists.txt       # 構(gòu)建管道膠水代碼
│   └── ...
└── gradle/

這里關(guān)鍵的只有一個目錄： app/src/main/moonbit/ ——你的所有游戲邏輯都寫在這里。其余的 Gradle 配置、CMake 文件、Kotlin 入口點，腳手架已經(jīng)幫你處理好了。

模塊配置（ moon.mod.json ）聲明了對 Raylib 綁定的依賴：

{
  "name": "username/myflappybird",
  "version": "0.1.0",
  "deps": {
    "tonyfettes/raylib": "0.2.2"
  },
  "preferred-target": "native"
}

構(gòu)建和部署也是一行命令：

cd MyFlappyBird
./gradlew assembleDebug --no-daemon

第一次構(gòu)建需要幾分鐘（它會從源碼編譯 Raylib），之后的增量構(gòu)建會快得多。你也可以在 Android Studio 中打開項目，點擊 Run 按鈕一鍵編譯部署。

在運行時，輕量的 MainActivity 加載 .so 庫，NDK 膠水代碼啟動原生端，Raylib 初始化 OpenGL ES 上下文，然后調(diào)用 main() ——也就是你用 MoonBit 寫的那個 fn main 。

基礎(chǔ)設(shè)施講完了?，F(xiàn)在讓我們進(jìn)入真正有趣的部分：游戲邏輯。

四、構(gòu)建 Flappy Bird

1、游戲循環(huán)

從《超級馬里奧》到《原神》，所有實時游戲在最底層都共享同一個結(jié)構(gòu)——初始化（Init）、循環(huán)執(zhí)行更新（Update）與繪制（Draw）、最后清理（Cleanup）：

這就是 游戲循環(huán)（Game Loop） 。它揭示了實時游戲的本質(zhì)： 游戲不是一系列事件的響應(yīng)，而是一幀又一幀的持續(xù)模擬 。和 Web 應(yīng)用的事件驅(qū)動模型不同，游戲代碼每秒執(zhí)行 60 次，無論用戶是否操作——用戶輸入不是觸發(fā)器，而是被每一幀"采樣"的信號。

一個良好的游戲架構(gòu)應(yīng)該將 狀態(tài)更新（update） 和 畫面繪制（draw） 嚴(yán)格分離：update 只修改數(shù)據(jù)，draw 只讀取數(shù)據(jù)，不存在交叉副作用。讓我們用這個原則來構(gòu)建 Flappy Bird。

2、定義游戲世界

首先，用結(jié)構(gòu)體描述游戲中的所有對象：

///|
privstructBird {
muty : Float
mutvelocity : Float
}

 ///|
privstructPipe {
mutx : Float
mutgap_y : Float
mutscored : Bool
}

 ///|
privstructGame {
sw : Float
sh : Float
bird_x : Float
bird : Bird
bird_radius : Float
gravity : Float
jump_force : Float
pipes : Array[Pipe]
pipe_width : Float
gap_size : Float
pipe_speed : Float
pipe_spacing : Float
  mut score : Int
  mut game_over : Bool
}

Bird 只保存 每幀變化 的值（位置和速度），而 不變的屬性 （水平位置、半徑）由 Game 持有—— 可變狀態(tài)越少，bug 越少 。每個 Pipe 記錄水平位置 x 、空隙中心點 gap_y （開口的垂直中點）和計分標(biāo)志 `scored`。

另一個值得關(guān)注的細(xì)節(jié)：所有大小都從屏幕尺寸（ sw 、 sh ）派生——鳥的半徑是 sh / 25.0 ，重力加速度是 sh * 1.5 。這意味著游戲在任何分辨率的設(shè)備上都能保持相同的視覺比例和手感，不需要額外的適配邏輯。

3、游戲邏輯

update 函數(shù)處理所有狀態(tài)變化——物理模擬、水管移動、碰撞檢測和計分：

///|
fn update(game : Game, dt : Float) -> Unit {
if game.game_over {
    if@raylib.is_gesture_detected(@raylib.GestureTap) {
      reset(game)
    }
    return
  }

 if@raylib.is_gesture_detected(@raylib.GestureTap) {
    game.bird.velocity = game.jump_force
  }

   game.bird.velocity += game.gravity * dt
  game.bird.y += game.bird.velocity * dt

 // 限制在屏幕邊緣內(nèi)
if game.bird.y < game.bird_radius {
    game.bird.y = game.bird_radius
    game.bird.velocity = 0.0
  }
if game.bird.y > game.sh - game.bird_radius {
    game.bird.y = game.sh - game.bird_radius
    game.bird.velocity = 0.0
  }

 for pipe in game.pipes {
    pipe.x -= game.pipe_speed * dt
    // 水管滾出左邊緣后回收到右側(cè)
    if pipe.x < -game.pipe_width {
      pipe.x += Float::from_int(game.pipes.length()) * game.pipe_spacing
      pipe.gap_y = random_gap_y(game)
      pipe.scored = false
    }

     // AABB 碰撞檢測
    if game.bird_x + game.bird_radius > pipe.x &&
      game.bird_x - game.bird_radius < pipe.x + game.pipe_width {
      if game.bird.y - game.bird_radius < pipe.gap_y - game.gap_size / 2.0 ||
        game.bird.y + game.bird_radius > pipe.gap_y + game.gap_size / 2.0 {
        game.game_over = true
      }
    }

     // 飛過水管時計分
    if not(pipe.scored) && pipe.x + game.pipe_width < game.bird_x {
      game.score += 1
      pipe.scored = true
    }
  }
}

這段代碼有幾個值得注意的設(shè)計決策：

• 幀率無關(guān)性 ：所有涉及"隨時間變化"的量都乘以 `dt`（自上一幀經(jīng)過的秒數(shù)）。`game.bird.velocity += game.gravity * dt` 意味著"每秒增加 `gravity` 這么多速度"——無論設(shè)備是 60fps 還是 30fps，物理效果一致。

• 對象回收 ：整個游戲只有 4 個水管對象。當(dāng)一根水管滾出左邊緣，直接把 `x` 坐標(biāo)加上偏移量"傳送"到最右邊，重新隨機(jī)空隙位置。不需要對象池框架——一個 `if` 和一次坐標(biāo)重置就夠了。

• AABB 碰撞檢測 ：將圓形小鳥近似為外接矩形，檢測它與水管矩形是否重疊——先查水平方向重疊，再查小鳥是否在空隙之外。不是像素級精確，但對休閑游戲完全足夠。

• 游戲結(jié)束檢查 ：`update` 頂部的 `game_over` 檢查攔截一切后續(xù)邏輯，讓游戲"凍結(jié)"在撞擊瞬間，只允許點擊重啟。

draw 函數(shù)只負(fù)責(zé)將當(dāng)前狀態(tài)繪制到屏幕：

///|
fn draw(game : Game) -> Unit {
@raylib.begin_drawing()
@raylib.clear_background(@raylib.skyblue)
for pipe in game.pipes {
    let px = pipe.x.to_int()
    let pw = game.pipe_width.to_int()
    let gap_top = (pipe.gap_y - game.gap_size / 2.0).to_int()
    let gap_bottom = (pipe.gap_y + game.gap_size / 2.0).to_int()
    @raylib.draw_rectangle(px, 0, pw, gap_top, @raylib.darkgreen)
    @raylib.draw_rectangle(
      px,
      gap_bottom,
      pw,
      @raylib.get_screen_height() - gap_bottom,
      @raylib.darkgreen,
    )
  }
@raylib.draw_circle_v(
    @raylib.Vector2::new(game.bird_x, game.bird.y),
    game.bird_radius,
    @raylib.yellow,
  )
@raylib.end_drawing()
}

先畫水管再畫小鳥，確保小鳥總在最上層。所有繪圖調(diào)用必須在 begin_drawing() 和 end_drawing() 之間。

輔助函數(shù)和初始化邏輯：

///|
fn random_gap_y(game : Game) -> Float {
  Float::from_int(
    @raylib.get_random_value(
      (game.gap_size / 2.0 + 50.0).to_int(),
      (game.sh - game.gap_size / 2.0 - 50.0).to_int(),
    ),
  )
}


 ///|
fn reset(game : Game) -> Unit {
  game.bird.y = game.sh / 2.0
  game.bird.velocity = 0.0
  game.score = 0
  game.game_over = false
for i in 0.. 
 
 
 
     game.pipes[i].x = game.sw + Float::from_int(i) * game.pipe_spacing 
 
 
     game.pipes[i].gap_y = random_gap_y(game) 
 
 
     game.pipes[i].scored =  
 false 
 
 
   } 
 
 
 } 
 

最后， main 將一切連接起來：

///|
fn main {
  @raylib.init_window(0, 0, "Flappy Bird")
  @raylib.set_target_fps(60)
  @raylib.set_exit_key(0)
letsw = Float::from_int(@raylib.get_screen_width())
letsh = Float::from_int(@raylib.get_screen_height())

 let game : Game = {
    sw,
    sh,
    bird_x: sw * 0.2,
    bird: { y: 0.0, velocity: 0.0 },
    bird_radius:sh / 25.0,
    gravity: sh * 1.5,
    jump_force: sh * -0.65,
    pipes: Array::make(4, fn() { { x: 0.0, gap_y: 0.0, scored: false } }),
    pipe_width: sw / 8.0,
    gap_size: sh / 4.0,
    pipe_speed: sw * 0.4,
    pipe_spacing:sw / 2.5,
    score: 0,
    game_over: false,
  }
  reset(game)

 while not(@raylib.window_should_close()) {
    let dt = @raylib.get_frame_time()
    update(game, dt)
    draw(game)
  }
  @raylib.close_window()
}

init_window(0, 0, ...) 表示使用屏幕全尺寸——在 Android 上就是全屏。游戲循環(huán)本身只有三行：獲取 dt、更新、繪制。 is_gesture_detected(GestureTap) 同時響應(yīng)觸屏和鼠標(biāo)點擊，可以在桌面開發(fā)測試后無縫部署到手機(jī)。

構(gòu)建并部署：

cd MyFlappyBird
./gradlew assembleDebug --no-daemon
adb install -r app/build/outputs/apk/debug/app-debug.apk

重力、水管、碰撞檢測、計分、游戲結(jié)束和重啟——全在一個文件、約 200 行代碼里。沒有引擎，沒有運行時，沒有框架。

五 、總結(jié)與展望

讓我們回顧一下整個技術(shù)脈絡(luò)。

我們從一個簡單的問題出發(fā)： 一個休閑小游戲，真的需要一個完整的游戲引擎嗎？ 然后沿著"從重到輕"的路徑，審視了移動游戲開發(fā)的幾種技術(shù)選型——從引擎（Unity/Godot）到跨平臺框架，再到原生 NDK，最終到達(dá) MoonBit + Raylib 這個極簡組合。

在構(gòu)建鏈路層面，我們看到 MoonBit 編譯到 C、C 通過 NDK 編譯到 .so 、 .so 打包進(jìn) APK 的清晰路徑——每一步都是確定性的，沒有黑箱。

在游戲架構(gòu)層面，我們理解了游戲循環(huán)這個"所有游戲的共同骨架"，以及為什么 update/draw 分離、幀率無關(guān)的物理模擬是重要的設(shè)計原則。

在具體實現(xiàn)層面，我們用約 200 行代碼構(gòu)建了一個完整的 Flappy Bird，其中涉及了對象回收（窮人版對象池）和 AABB 碰撞檢測等實用技巧。

這套方案不是萬能的。如果你需要 3D 渲染管線、物理引擎、骨骼動畫、熱更新——使用 Unity 或 Godot 仍然是更務(wù)實的選擇。但如果你的目標(biāo)是一款輕量的 2D 游戲，追求的是 小包體、高性能、完全可控的代碼 ，那么"做減法"的思路值得一試。

這里有一些可以繼續(xù)探索的方向：

• tonyfettes/raylib —— MoonBit 的 Raylib 綁定庫，涵蓋圖形、紋理、音頻、3D 模型、著色器等完整功能

• selene —— 一個用 MoonBit 編寫的實驗性游戲引擎，支持 WebGPU 和 Raylib 后端，專為網(wǎng)頁和原生游戲設(shè)計

• MoonBit 文檔 —— 語言詳細(xì)文檔

另外值得注意一點的是，本文中所有示例代碼均由 AI 生成，甚至包括 Raylib 綁定庫本身。我們利用 AI Agent 的 Subagent 并行化地在桌面、Web 和 Android 平臺上產(chǎn)出了超過 150 款游戲。更多詳情可參見 tonyfettes/raylib 下的 examples/ 目錄。

從 Unity 的"給你一切"到 MoonBit + Raylib 的"只給你需要的"，這不僅是技術(shù)選型的變化，更是一種開發(fā)哲學(xué)的轉(zhuǎn)變—— 最好的代碼不是寫出來的，而是不需要寫的 。