Cómo reiniciar el entorno lua o reiniciar el motor

El primer paso: ver el punto de entrada inicial de cocos2dx llamando a lua:

[cpp] ver copia simple

bool AppDelegate::applicationDidFinishLaunching()

{< / p>

CCDirector *pDirector = CCDirector::sharedDirector();

pDirector->setOpenGLView(CCEGLView::sharedOpenGLView());

CCEGLView::sharedOpenGLView() - >setDesignResolutionSize(480, 320, kResolutionNoBorder);

pDirector->setDisplayStats(true);

pDirector->setAnimationInterval(1.0 / 60);

//Registrar motor lua

CCLuaEngine* pEngine = CCLuaEngine::defaultEngine( );//Iniciar el viaje lua desde aquí.

CCScriptEngineManager::sharedManager()->setScriptEngine(pEngine); // Guarda el nuevo objeto del motor lua recién creado para poder llamarlo en otro lugar.

std::string path = CCFileUtils::sharedFileUtils()->fullPathForFilename("hello.lua"); // La clase de herramienta CCFileUtils debe encapsular la ruta de búsqueda del archivo.

// A continuación, ejecute el script directamente y la oración de ejecución es el proyecto helloCpp, que debería ser similar aquí

//CCScene *pScene = HelloWorld::scene();

//pDirector->runWithScene(pScene);

// Ese código, pero no existe tal código aquí, puedes adivinarlo: se deben implementar funciones similares en hello.lua, y de hecho es necesario lograrlo.

// --- Debido a que todas estas cosas y otros nodos que deben agregarse a la escena son objetos de algunas clases de C++,

// Dado que hello.lua puede hacer todo Si funcionan, podemos implementar estas funciones en hello.lua. Lua puede completar todas estas tareas, por lo que Lua también debe tener la capacidad de acceder y operar estas clases y objetos.

// En otras palabras, debe haber un mecanismo para que C++ exponga interfaces para que Lua las llame. ,

// Es decir: lua puede acceder al contenido en cocos2dx y debe estar encapsulado de una manera que permita que se ejecute bien; de lo contrario, nadie lo usará.

pEngine->executeScriptFile(path.c_str());

return true;

}

Paso 2: Ver CCLuaEngine real; funcionalidad

[cpp] Ver copia pura

clase CCLuaEngine: público CCScriptEngineProtocol

{

público:

estático CCLuaEngine* defaultEngine(void);

virtual ~CCLuaEngine(void);

virtual ccScriptType getScriptType() {

return kScriptTypeLua;

};

CCLuaStack * getLuaStack(void) {

return m_stack;

}

//--- -- ------nuevo en mí 1

virtual void addSearchPath(const char* path);

//-----------nuevo en mí 2

virtual void addLuaLoader(lua_CFunction func);

//----------------------- -- ---heredar de CCScriptEngineProtocol------------------

//================ == =Estas funciones parecen ser puramente virtuales en la clase principal ===========================

// -- ------Las siguientes funciones básicamente llaman a CCScriptEngineProtocol. Varias funciones se implementan básicamente llamando a métodos miembro de CCLuaStack *m_stack;

virtual void removeScriptObjectByCCObject(CCObject* pObj); virtual void removeScriptHandler(int nHandler);

virtual int reallocateScriptHandler(int nHandler);

virtual int enableString(const char* códigos

virtual int enableScriptFile); (const char* nombre de archivo);

virtual int ejecutarGlobalFunction(const char* nombre de función);

//--------------------- ----- ------------------fin-------------------------- ------- -

virtual int ejecutarNodeEvent(CCNode* pNode, int nAction);

virtual int ejecutarMenuItemEvent(CCMenuItem* pMenuItem);

>

virtual int ejecutarNotificaciónEvent(CCNotificationCenter* pNotificationCenter, const char* pszName);

virtual int ejecutarCallFuncActionEvent(CCCallFunc* pAction, CCObject* pTarget = NULL);

virtual int ejecutarSchedule (int nHandler, float dt, CCNode* pNode = NULL);

virtual int ejecutarLayerTouchesEvent(CCLayer* pLayer, int eventType, CCSet *pTouches);

virtual int ejecutarLayerTouchEvent(CCLayer* pLayer, int eventType, CCTouch *pTouch);

virtual int ejecutarLayerKeypadEvent(CCLayer* pLayer, int eventType);

virtual int ejecutarAccelerometerEvent(CCLayer* pLayer, CCAcceleration* pAccelerationValue);

virtual int ejecutarEvent(int nHandler, const char* pEventName, CCObject* pEventSource = NULL, const char* pEventSourceClassName = NULL

int ejecutarTableViewEvent(int nEventType,cocos2d::extensión): :CCTableView* pTableView,void* pValue = NULL, CCArray* pResultArray = NULL);

virtual int ejecutarEventWithArgs(int nHandler, CCArray* pArgs);

virtual bool handleAssert( const char *msg);

virtual bool parseConfig(CCScriptEngineProtocol::ConfigType tipo, const std::string& str);

//---------- - - ---------------Heredado del final de CCScriptEngineProtocol--------------------------

privado:

CCLuaEngine(void)

: m_stack(NULL)

{}

bool init(void);

static CCLuaEngine* m_defaultEngine;

CCLuaStack *m_stack;

};

Tercer paso: la clase CCLuaEngine tiene una variable miembro de puntero m_stack , echemos un vistazo a su definición y prestemos atención. La diferencia entre CCLuaStack y CCLuaEngine

>

[cpp] ver copia simple

clase CCLuaStack: CCObject público

{

público:

CCLuaStack estático *create (void);

CCLuaStack estático *attach(lua_State *L);

lua_State* getLuaState(void) {

return m_state;

}

virtual void addSearchPath(const char* ruta);

virtual void addLuaLoader(lua_CFunction func);

virtual void removeScriptObjectByCCObject(CCObject* pObj) ;

virtual void removeScriptHandler(int nHandler);

virtual int realocateScriptHandler(int nHandler);

virtual int enableString(const char* códigos); p>

virtual int runScriptFile(const char* nombre de archivo);

virtual int runGlobalFunction(const char* nombre de función);

virtual void clean(void); p>

pushInt vacío virtual( int intValue);

pushFloat vacío virtual( float floatValue);

pushBoolean vacío virtual( bool boolValue

); virtual void pushString(const char* stringValue);

virtual void pushString(const char* stringValue, int length

virtual void pushNil(void); >virtual void pushCCObject(CCObject* objectValue, const char* typeName);

virtual void pushCCLuaValue(const CCLuaValue& valor).

virtual void pushCCLuaValue(const CCLuaValue& valor).

virtual void pushCCLuaValueDict(const CCLuaValueDict& dict);

virtual void pushCCLuaValueArray(const CCLuaValueArray&.array);

virtual bool pushFunctionByHandler(int nHandler);

virtual int ejecutarFunción(int numArgs);

<

p>virtual int ejecutarFunctionByHandler(int nHandler, int numArgs);

virtual int ejecutarFunctionReturnArray(int nHandler,int nNumArgs,int nNummResults,CCArray* pResultArray);

virtual bool handleAssert(const char *msg);

protegido:

CCLuaStack(void)

: m _state(NULL)

, m_callFromLua(0)

{}

bool init(void);

bool initWithLuaState(lua_State *L);

lua_State *m_ Estado;

int m_callFromLua;

};