dmsolpp

#ifndef __OBJECT_H_INCLUDE__
#define __OBJECT_H_INCLUDE__

#include <stdint.h>

class CObject
{
public:
// export_begin
    CObject(): m_objID(0){}
    virtual ~CObject(){}
    uint64_t GetObjID(){ return m_objID;}
    void SetObjID(uint64_t id){ m_objID = id;}
// export_end
private:
    uint64_t m_objID;
};

#endif // __OBJECT_H_INCLUDE__

dmsolpp --PKG=interface.pkg

interface.sol.cc
interface.sol.h

oDMLuaEngine.AddModule(require_interface);
``````cpp
#include "gtest.h"
#include <cstddef>
#include "interface.sol.h"
#include "player.h"
#include "dmsolpp.h"
```TEST(DoSolpp, DoSolpp)
{
    CDMLuaEngine oDMLuaEngine;

    std::string strScriptRootPath = DMGetRootPath();
    oDMLuaEngine.SetRootPath(strScriptRootPath + PATH_DELIMITER_STR + ".." + PATH_DELIMITER_STR + "script");

    // Загрузка автоматически сгенерированного кода модуля, если у вас есть несколько модулей, их нужно добавить здесь
    oDMLuaEngine.AddModule(require_interface);

    // Использование dmlua для загрузки, так как он может автоматически загружать все файлы из указанной директории. Сам движок sol этого не поддерживает.
    if (!oDMLuaEngine.ReloadScript())
    {
        ASSERT_TRUE(0);
        return;
    }

    oDMLuaEngine.DoString(R"(
        function add(a, b)
            return a + b
        end
        )");

    oDMLuaEngine.DoString(R"(
        function addplayer(player)
            print("[addplayer]: " .. player:GetName())
            return 1
        end
        )");

    // Получение движка sol
    auto state = oDMLuaEngine.GetSol();

    int num = state["add"](1, 2);

    CPlayer oPlayer(5, "zhangsan");
    int ret = state["test"]["main"]["dowork"](&oPlayer);

    int ret2 = state["addplayer"](oPlayer);

    // Использование объектного менеджера из lua-скрипта для создания объектов, управление жизненным циклом объектов осуществляется lua, после перезагрузки данные теряются
    auto script_result = state.safe_script(R"(
        local interface = require("interface")
        local player_mgr = require("player")
        local player = player_mgr.create_player()
        local p = player_mgr.find_player(player:GetObjID())
    )");
```        p:Init()
        p:NotChange()
        p.OnChange = function (self) print("Изменение в lua") end
        p:OnChange()
        print(MAX_NAME_LEN)
        print("[1]" .. interface.GNextID())
        print("[2]" .. p.NextID())
        p:SetObjID(interface.GNextID())
        print("[3]" .. p:GetObjID())
        p:SetHP(interface.GNextID())
        print("[4]" .. p:GetHP())
        print("[5]" .. interface.CPlayer.NextID())
        player_mgr.release_player(p)
        print("в sol2.lua player_mgr.create_player");
        )", sol::script_throw_on_error)
    ASSERT_TRUE(script_result.valid())```markdown
    // Использование импортированного C++ объектного менеджера для создания объектов, управление жизненным циклом объектов осуществляется C++, после перезагрузки данные сохраняются
    auto script_result2 = state.safe_script(R"(
        local interface = require("interface")
        local player = interface.create_player()
        local p = interface.find_player(player:GetObjID())
        p:Init()
        p:NotChange()
        p.OnChange = function (self) print("OnChange в lua") end
        p:OnChange()

        interface.release_player(player:GetObjID())
        print("в sol2.cpp player_mgr.create_player")
        )", sol::script_throw_on_error);
    ASSERT_TRUE(script_result2.valid());
}

/********************************************************************
**       Этот файл C++ сгенерирован программой,                     **
**            Пожалуйста, не изменяйте его напрямую.               **
**                   Автор: brinkqiang                             **
********************************************************************/
// источник: interface.pkg

#include "interface.sol.h"
#include <limits>

#include "object.h"

#include "creature.h"

#include "player.h"

#include "playermgr.h"

#include "common/types.h"

#include "common/enum.h"

#include "common/macros.h"

#include "common/struct.h"

#include "common/template.h"


#include "sol/sol.hpp"
```namespace lua_module_interface
 {
     static sol::table require_api(sol::this_state L)
     {
         sol::state_view lua(L);
         sol::table модуль = lua.create_table();
         модуль.new_usertype<CObject>(
             "CObject",
             sol::constructors<CObject()>(),
             sol::meta_function::garbage_collect, sol::destructor([](CObject& temp) { temp.~CObject(); }),
             sol::base_classes, sol::bases<>()
             "GetObjID", sol::make_reference<sol::function>(lua.lua_state(), &CObject::GetObjID),
             "SetObjID", sol::make_reference<sol::function>(lua.lua_state(), &CObject::SetObjID)
         );
         модуль.new_usertype<CCreature>(
             "CCreature",
             sol::constructors<CCreature()>(),
             sol::meta_function::garbage_collect, sol::destructor([](CCreature& temp) { temp.~CCreature(); }),
             sol::base_classes, sol::bases<CObject>(),
             "SetHP", sol::make_reference<sol::function>(lua.lua_state(), &CCreature::SetHP),
             "SetMP", sol::make_reference<sol::function>(lua.lua_state(), &CCreature::SetMP),
             "GetHP", sol::make_reference<sol::function>(lua.lua_state(), &CCreature::GetHP),
             "GetMP", sol::make_reference<sol::function>(lua.lua_state(), &CCreature::GetMP)
         );
         модуль.set_function("GNextID", &GNextID);
         модуль.new_usertype<CPlayer>(
             "CPlayer",
             sol::constructors<CPlayer(), CPlayer(int, const std::string&), CPlayer(const std::string&)>(),
             sol::meta_function::garbage_collect, sol::destructor([](CPlayer& temp) { temp.~CPlayer(); }),
             sol::base_classes, sol::bases<CCreature, CObject>(),
             "DoAction", sol::make_reference<sol::function>(lua.lua_state(), &CPlayer::DoAction),
             "Init", sol::make_reference<sol::function>(lua.lua_state(), &CPlayer::Init),
             "OnChange", sol::make_reference<sol::function>(lua.lua_state(), &CPlayer::OnChange),
             "NotChange", sol::make_reference<sol::function>(lua.lua_state(), &CPlayer::NotChange),
             "SystemChange", sol::make_reference<sol::function>(lua.lua_state(), &CPlayer::SystemChange),
             "LoadFromDB", sol::make_reference<sol::function>(lua.lua_state(), &CPlayer::LoadFromDB),
             "SaveDB", sol::make_reference<sol::function>(lua.lua_state(), &CPlayer::SaveDB)
         );
     }
 }```markdown
lua_state(), &CPlayer::SaveDB)
              , "GetName", sol::make_reference<sol::function>(lua.lua_state(), &CPlayer::GetName)
              , "NextID", sol::make_reference<sol::function>(lua.lua_state(), &CPlayer::NextID)
               );
          module.set_function("create_player", &create_player);
 module.set_function("find_player", &find_player);
 module.set_function("release_player", &release_player);
 module.new_usertype<CPlayerMgr>(
     "CPlayerMgr"
     , sol::constructors<>()
     , sol::base_classes, sol::bases<>()
     , "create_player", sol::make_reference<sol::function>(lua.lua_state(), &CPlayerMgr::create_player)
     , "find_player", sol::make_reference<sol::function>(lua.lua_state(), &CPlayerMgr::find_player)
     , "release_player", sol::make_reference<sol::function>(lua.lua_state(), &CPlayerMgr::release_player)
 );
 module.new_usertype<STaskInfo>(
     "STaskInfo"
     , sol::constructors<STaskInfo()>()
     , sol::meta_function::garbage_collect, sol::destructor([](STaskInfo& temp) { temp.~STaskInfo(); })
     , sol::base_classes, sol::bases<>()
     , "nTaskID", &STaskInfo::nTaskID
     , "nTaskState", &STaskInfo::nTaskState
     , "nTaskCondition", &STaskInfo::nTaskCondition
 );
 module.new_usertype<SPos>(
     "SPos"
     , sol::constructors<SPos(),SPos(int,int,int)>()
     , sol::meta_function::garbage_collect, sol::destructor([](SPos& temp) { temp.~SPos(); })
     , sol::base_classes, sol::bases<>()
     , "x", &SPos::x
     , "y", &SPos::y
     , "z", &SPos::z
 );
 return module;
 }

LUA_API int luaopen_interface(lua_State* L)
{
    return sol::stack::call_lua(L, 1, lua_module_interface::require_api);
}
```LUA_API int require_interface(lua_State* L)
{
    luaL_requiref(L, "interface", luaopen_interface, 0);
    printf("lua модуль: require interface\n");
    return 1;
}