引擎归 C++，玩法归 Lua：一个打砖块游戏的分层写法

int main(int argc, char* argv[])
{
    edge::GameParams params{
        .screenWidth = 256,
        .screenHeight = 240,
        .screenScale = 3,
        .windowTitle = "SDL Breakout",
    };

    edge::Game game;
    game.start(params);
    return 0;
}

local class = require 'lib.middleclass'
local Game = class("Game")

function Game:initialize() end
function Game:update(dt) end
function Game:draw() end

return Game:new()

// update：把逻辑交给 Lua
luautil::safeSelfCall(luaGame, "update", dt);

// render：把画面交给 Lua
luautil::safeSelfCall(luaGame, "draw");

template<typename... T>
void safeSelfCall(sol::table& t, const char* name, T&&... args)
{
    sol::protected_function f = t[name];
    sol::protected_function_result result = f(t, std::forward<T>(args)...);
    if (!result.valid()) {
        sol::error err = result;
        std::cout << err.what();
    }
}

  C++ 引擎 (Game::loop)                    Lua 玩法 (game.lua)
  ─────────────────────                    ────────────────────
        │
        │  poll SDL events (退出/键盘)
        │
        │  safeSelfCall(luaGame,"update") ──▶  Game:update(dt)
        │                                        读输入、算碰撞、动小球
        │  ◀───────────────────────────────     （中途会回调 C++ 能力，见下节）
        │
        │  safeSelfCall(luaGame,"draw")   ──▶  Game:draw()
        │                                        sprite:draw() / drawRect()...
        │  ◀───────────────────────────────
        │
        │  SDL_RenderPresent (上屏)
        │
        └──▶ 下一帧

sol::table edge = lua["edge"].force();

// 递一个函数：Lua 里 edge.isKeyPressed(...) 就能用
edge["isKeyPressed"] = isKeyPressed;

// 递几个常量：Lua 里 edge.KEY_LEFT 就是 SDL 的扫描码
edge["KEY_UP"]    = SDL_SCANCODE_UP;
edge["KEY_LEFT"]  = SDL_SCANCODE_LEFT;
edge["KEY_RIGHT"] = SDL_SCANCODE_RIGHT;

struct Sprite {
    Sprite(Texture* texture) : texture(texture) { /* ... */ }
    void draw(double x, double y) const { /* SDL_RenderCopy... */ }
    void setTextureRect(int x, int y, int w, int h);
    // ...
};

auto su = edge.new_usertype<Sprite>("Sprite");
su["setTextureRect"] = &Sprite::setTextureRect;
su["draw"]           = &Sprite::draw;

// 给 Lua 一个工厂函数来造 Sprite
edge["newSprite"] = [&lua](Texture* texture) {
    return sol::object(lua, sol::in_place_type<Sprite>, texture);
};

local sprite = edge.newSprite(texture)
sprite:setTextureRect(0, 0, 16, 16)
sprite:draw(100, 120)

struct Texture {
    void destroy()  // 交给 Lua GC 调用
    {
        assert(texture);
        SDL_DestroyTexture(texture);
        texture = nullptr;
    }
    SDL_Texture* texture = nullptr;
    int width = 0, height = 0;
};

void registerTexture(sol::state& lua, sol::table& edge)
{
    auto dsu = edge.new_usertype<Texture>("Texture");
    // 关键这一行：Lua GC 回收这个对象时，自动调 destroy()
    dsu[sol::meta_function::garbage_collect] = &Texture::destroy;

    edge["loadTexture"] = loadTexture;
}

function Game:updateGame(dt)
  local ball = self.ball
  local border = self.border
  local paddle = self.paddle

  if logic.checkBallLost(ball, border) then
    self.soundCache:playSound("ball_fall")
    self:showMenu(menu.State.GameOver)
    do return end
  end

  if logic.checkGameWin(self.blocks) then
    self:showMenu(menu.State.Win)
    do return end
  end

  -- 处理各种碰撞，撞到了就播对应音效
  if logic.handleBallPaddleCollision(ball, paddle) then
    self.soundCache:playSound("ball_collision_paddle")
  end
  if logic.handleBallBorderCollision(ball, border) then
    self.soundCache:playSound("ball_collision")
  end
  if logic.handleBallBlocksCollision(ball, self.blocks) then
    self.soundCache:playSound("ball_collision")
  end

  -- 按速度推进小球位置
  ball.pos.x = ball.pos.x + ball.vel.x * dt
  ball.pos.y = ball.pos.y + ball.vel.y * dt
end

ball.speed = em.Vec2:new(90, 90)

// 原代码：依赖 Linux 特有的 /proc
if (std::filesystem::exists("/proc/self/exe")) {
    return std::filesystem::read_symlink("/proc/self/exe").parent_path();
}
return std::filesystem::path();

// 改后：用 SDL 的跨平台 API，顺手用 unique_ptr 管住它返回的 C 字符串
std::unique_ptr<char, decltype(&SDL_free)> basePath(SDL_GetBasePath(), SDL_free);
if (!basePath) {
    fprintf(stderr, "Unable to determine executable directory: %s\n", SDL_GetError());
    std::exit(1);
}
return std::filesystem::path(basePath.get());

std::filesystem::current_path(getExecutableDir());

std::error_code pathError;
std::filesystem::current_path(getExecutableDir(), pathError);
if (pathError) {
    fprintf(stderr, "Unable to use executable directory: %s\n",
            pathError.message().c_str());
    std::exit(1);
}

luaGame = sol::nil;

luaGame = sol::lua_nil;

@startmindmap
<style>
mindmapDiagram {
  node {
    BackgroundColor #F8F9FA
    RoundCorner 10
    Padding 10
    FontSize 13
  }
  :depth(0) {
    BackgroundColor #1E3A5F
    FontColor white
    FontSize 18
    FontStyle bold
  }
  :depth(1) {
    FontSize 15
    FontStyle bold
  }
  :depth(2) {
    FontSize 13
  }
}
</style>

* 引擎归 C++\n玩法归 Lua
** 为什么分层
*** 改玩法不该等编译
*** 按"变化频率"划层
*** 同一引擎换脚本即换游戏
** 一帧怎么跑
*** C++ loop 回调 update/draw
*** protected_function 兜住 Lua 报错
*** 双向交棒
** sol2 这座桥
*** 递函数/常量
*** usertype 包装 C++ 对象
*** __gc 接管 SDL 资源
** 玩法留在 Lua
*** updateGame 读起来像自然语言
*** 改速度/布局 存盘即生效
** macOS 三个坑
*** SDL_GetBasePath 替代 /proc
*** current_path 用 error_code
*** sol::nil 改 sol::lua_nil
@endmindmap