Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fixed #632. Update the visual studio template for lua supported.

This commit is contained in:
natural-law 2011-07-27 14:28:22 +08:00
parent ef02190b47
commit d905e7d475
8 changed files with 12 additions and 970 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
template/msvc/CCAppWiz.win32/Scripts/1033/default.js
View File

@ -391,6 +391,12 @@ function GetTargetName(strName, strProjectName) {
strTarget = strName.substring(0, nIndex) + strProjectName + strName.substring(nIndex + 4, strName.length);
}
var strTemp = "../../../../../lua";
nIndex = strTarget.indexOf(strTemp);
if (nIndex >= 0) {
strTarget = "Classes" + strTarget.substring(nIndex + strTemp.length, strTarget.length);
}
return strTarget;
}
catch (e) {

1
template/msvc/CCAppWiz.win32/Templates/1033/Classes/cocos2dx_support/LuaCocos2d.cpp.REMOVED.git-id
View File

@ -1 +0,0 @@
54a38d739f4411e0a35373d2a846d001e133d677

46
template/msvc/CCAppWiz.win32/Templates/1033/Classes/cocos2dx_support/LuaCocos2d.h
View File

@ -1,46 +0,0 @@
/****************************************************************************
Copyright (c) 2011 cocos2d-x.org
Copyright (c) 2011 NetDragon.com
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#ifndef LUACOCOS2D_H
#define LUACOCOS2D_H
#include "cocos2d.h"
#include "tolua++.h"
#include <stdio.h>
#include "CCKeypadDispatcher.h"
#include "CCRibbon.h"
#include "CCParallaxNode.h"
#include "CCAutoreleasePool.h"
#include "CCIMEDispatcher.h"
#include "CCMutableArray.h"
//#define TOLUA_RELEASE
#if defined(_WIN32) && defined(_DEBUG)
#pragma warning (disable:4800)
#endif
int tolua_Cocos2d_open(lua_State* tolua_S);
#define TOLUA_RELEASE
#endif//LUACOCOS2D_H

83
template/msvc/CCAppWiz.win32/Templates/1033/Classes/cocos2dx_support/LuaEngine.cpp
View File

@ -1,83 +0,0 @@
/****************************************************************************
Copyright (c) 2011 cocos2d-x.org
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#include "LuaEngine.h"
#include "LuaEngineImpl.h"
using namespace cocos2d;
// functions for excute touch event
bool LuaEngine::executeTouchEvent(const char *pszFuncName, CCTouch *pTouch)
{
return CCLuaScriptModule::sharedLuaScriptModule()->executeTouch(pszFuncName, pTouch);
}
bool LuaEngine::executeTouchesEvent(const char *pszFuncName, CCSet *pTouches)
{
return CCLuaScriptModule::sharedLuaScriptModule()->executeTouchesEvent(pszFuncName, pTouches);
}
// functions for CCCallFuncX
bool LuaEngine::executeCallFunc(const char *pszFuncName)
{
return CCLuaScriptModule::sharedLuaScriptModule()->executeCallFunc(pszFuncName);
}
bool LuaEngine::executeCallFuncN(const char *pszFuncName, CCNode *pNode)
{
return CCLuaScriptModule::sharedLuaScriptModule()->executeCallFuncN(pszFuncName, pNode);
}
bool LuaEngine::executeCallFuncND(const char *pszFuncName, CCNode *pNode, void *pData)
{
return CCLuaScriptModule::sharedLuaScriptModule()->executeCallFuncND(pszFuncName, pNode, pData);
}
bool LuaEngine::executeCallFunc0(const char *pszFuncName, CCObject *pObject)
{
// use executeCallFuncN() to implement it
return CCLuaScriptModule::sharedLuaScriptModule()->executeCallFuncO(pszFuncName, pObject);
}
// excute a script function without params
int LuaEngine::executeFuction(const char *pszFuncName)
{
return CCLuaScriptModule::sharedLuaScriptModule()->executeScriptGlobal(pszFuncName);
}
// excute a script file
bool LuaEngine::executeScriptFile(const char* pszFileName)
{
return CCLuaScriptModule::sharedLuaScriptModule()->executeScriptFile(pszFileName);
}
// excute script from string
bool LuaEngine::executeString(const char* pszCodes)
{
return CCLuaScriptModule::sharedLuaScriptModule()->executeString(pszCodes);
}
bool LuaEngine::executeSchedule(const char* pszFuncName, ccTime t)
{
return CCLuaScriptModule::sharedLuaScriptModule()->executeSchedule(pszFuncName, t);
}

54
template/msvc/CCAppWiz.win32/Templates/1033/Classes/cocos2dx_support/LuaEngine.h
View File

@ -1,54 +0,0 @@
/****************************************************************************
Copyright (c) 2011 cocos2d-x.org
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#ifndef __LUA_ENGINE_H__
#define __LUA_ENGINE_H__
#include "CCScriptSupport.h"
#include "cocos2d.h"
class LuaEngine : public cocos2d::CCScriptEngineProtocol
{
public:
// functions for excute touch event
virtual bool executeTouchEvent(const char *pszFuncName, cocos2d::CCTouch *pTouch);
virtual bool executeTouchesEvent(const char *pszFuncName, cocos2d::CCSet *pTouches);
// functions for CCCallFuncX
virtual bool executeCallFunc(const char *pszFuncName);
virtual bool executeCallFuncN(const char *pszFuncName, cocos2d::CCNode *pNode);
virtual bool executeCallFuncND(const char *pszFuncName, cocos2d::CCNode *pNode, void *pData);
virtual bool executeCallFunc0(const char *pszFuncName, cocos2d::CCObject *pObject);
// excute a script function without params
virtual int executeFuction(const char *pszFuncName);
// excute a script file
virtual bool executeScriptFile(const char* pszFileName);
// excute script from string
virtual bool executeString(const char* pszCodes);
// execute a schedule function
virtual bool executeSchedule(const char* pszFuncName, cocos2d::ccTime t);
};
#endif // __LUA_ENGINE_H__

611
template/msvc/CCAppWiz.win32/Templates/1033/Classes/cocos2dx_support/LuaEngineImpl.cpp
View File

@ -1,611 +0,0 @@
/****************************************************************************
Copyright (c) 2011 cocos2d-x.org
Copyright (c) 2011 NetDragon.com
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#include "LuaEngineImpl.h"
extern "C" {
#include "lualib.h"
#include "lauxlib.h"
}
#include "tolua++.h"
#include "CCTouch.h"
#include "CCNode.h"
#include "CCObject.h"
#include "LuaCocos2d.h"
using namespace cocos2d;
CCLuaScriptModule* CCLuaScriptModule::s_luaScriptModule = NULL;
CCLuaScriptModule* CCLuaScriptModule::sharedLuaScriptModule(void)
{
if (s_luaScriptModule == NULL)
{
s_luaScriptModule = new CCLuaScriptModule();
}
return s_luaScriptModule;
}
void CCLuaScriptModule::purgeSharedLuaScriptModule()
{
s_luaScriptModule->release();
s_luaScriptModule = NULL;
}
/*************************************************************************
Constructor (creates Lua state)
*************************************************************************/
CCLuaScriptModule::CCLuaScriptModule()
{
d_ownsState = true;
d_state = lua_open();
luaL_openlibs(d_state);
int nOpen = tolua_Cocos2d_open(d_state);
CC_UNUSED_PARAM(nOpen);
// init all standard libraries
/*luaopen_base(d_state);
luaopen_io(d_state);
luaopen_string(d_state);
luaopen_table(d_state);
luaopen_math(d_state);
*/
//luaopen_debug(d_state);
}
/*************************************************************************
Constructor (uses given Lua state)
*************************************************************************/
CCLuaScriptModule::CCLuaScriptModule(lua_State* state)
{
// just use the given state
d_ownsState = false;
d_state = state;
}
/*************************************************************************
Destructor
*************************************************************************/
CCLuaScriptModule::~CCLuaScriptModule()
{
if ( d_ownsState && d_state )
{
lua_close( d_state );
}
s_luaScriptModule = NULL;
}
/*************************************************************************
Execute script file
*************************************************************************/
bool CCLuaScriptModule::executeScriptFile(const std::string& filename)
{
int nRet = luaL_dofile(d_state,filename.c_str());
if (nRet != 0)
{
CCLog("executeScriptFile Error nRet = %d", nRet);
// print the error msg
const char* strErrMsg = lua_tostring(d_state, -1);
CCLog("%s", strErrMsg);
return false;
}
return true;
}
/*************************************************************************
Execute global script function
*************************************************************************/
int CCLuaScriptModule::executeScriptGlobal(const std::string& function_name)
{
// get the function from lua
lua_getglobal(d_state, function_name.c_str());
// is it a function
if ( !lua_isfunction(d_state,-1) )
{
CCLog("name does not represent a Lua function");
lua_settop( d_state, 0 );
return 0;
}
// call it
int error = lua_pcall(d_state,0,1,0);
// handle errors
if ( error )
{
std::string msg = lua_tostring(d_state,-1);
lua_pop(d_state,1);
CCLog("%s", msg.c_str());
lua_settop( d_state, 0 );
return 0;
}
// get return value
if ( !lua_isnumber(d_state,-1) )
{
CCLog("return value is not a number %s", function_name.c_str());
lua_settop( d_state, 0 );
return 0;
}
int ret = (int)lua_tonumber(d_state,-1);
lua_pop(d_state,1);
// return it
return ret;
}
/*************************************************************************
Execute scripted event handler
*************************************************************************/
bool CCLuaScriptModule::executeSchedule(const std::string& handler_name, ccTime cc)
{
if (handler_name.size() == 0)
{
std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: handler_name == NULL\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// get the function from lua
lua_getglobal(d_state, handler_name.c_str());
// is it a function
if ( !lua_isfunction(d_state,-1) )
{
lua_settop( d_state, 0 );
std::string msg = handler_name + "\n" + "name does not represent a Lua function" + "\n";
CCLog("%s %d", msg.c_str(), __FILE__);
return false;
}
// push EventArgs as the first parameter
//tolua_pushusertype(d_state,(void*)&cc,"dFloat");
lua_pushfstring(d_state, "%f", cc);
// call it
int error = lua_pcall(d_state,1,0,0);
// handle errors
if ( error )
{
std::string msg = lua_tostring(d_state,-1);
lua_pop(d_state,1);
lua_settop( d_state, 0 );
std::string msgerror = handler_name + "\n\n" + msg + "\n";
CCLog("%s %d", msgerror.c_str(), __FILE__);
return false;
}
// return it
return true;
}
bool CCLuaScriptModule::executeCallFunc(const std::string& handler_name)
{
if (handler_name.size() == 0)
{
std::string msg = "(LuaScriptModule) Unable to execute scripted event handler:handler_name == NULL\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
lua_getglobal(d_state, handler_name.c_str());
// is it a function
if ( !lua_isfunction(d_state,-1) )
{
lua_settop( d_state, 0 );
std::string msg = handler_name + "name does not represent a Lua function" + "\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// push EventArgs as the first parameter
//tolua_pushusertype(d_state,(void*)&cc,"cocos2d::ccTime");
// call it
int error = lua_pcall(d_state,0,0,0);
// handle errors
if ( error )
{
std::string msg = lua_tostring(d_state,-1);
lua_pop(d_state,1);
lua_settop( d_state, 0 );
std::string msgerror = handler_name + msg + "\n";
CCLog("%s %s %d", __FILE__, msgerror.c_str(), __LINE__);
return false;
}
// return it
return true;
}
bool CCLuaScriptModule::executeCallFuncN(const std::string& handler_name, CCNode* pNode)
{
if (handler_name.size() == 0)
{
std::string msg = "(executeCallFuncN) Unable to execute scripted event handler: handler_name == NULL\n";
CCLog("%s %d ", msg.c_str(), __LINE__);
return false;
}
lua_getglobal(d_state, handler_name.c_str());
// is it a function
if ( !lua_isfunction(d_state,-1) )
{
lua_settop( d_state, 0 );
std::string msg = handler_name + "name does not represent a Lua function" + "\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// push EventArgs as the first parameter
tolua_pushusertype(d_state,(void*)pNode,"cocos2d::CCNode");
// call it
int error = lua_pcall(d_state,1,0,0);
// handle errors
if ( error )
{
std::string msg = lua_tostring(d_state,-1);
lua_pop(d_state,1);
lua_settop( d_state, 0 );
std::string msgerror = handler_name + msg + "\n";
CCLog("%s %s %d", __FILE__, msgerror.c_str(), __LINE__);
return false;
}
// return it
return true;
}
bool CCLuaScriptModule::executeCallFuncO(const std::string &handler_name, cocos2d::CCObject *pObject)
{
if (handler_name.size() == 0)
{
std::string msg = "(executeCallFuncO) Unable to execute scripted event handler: handler_name == NULL\n";
CCLog("%s %d ", msg.c_str(), __LINE__);
return false;
}
lua_getglobal(d_state, handler_name.c_str());
// is it a function
if ( !lua_isfunction(d_state,-1) )
{
lua_settop( d_state, 0 );
std::string msg = handler_name + "name does not represent a Lua function" + "\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// push EventArgs as the first parameter
tolua_pushusertype(d_state,(void*)pObject,"cocos2d::CCObject");
// call it
int error = lua_pcall(d_state,1,0,0);
// handle errors
if ( error )
{
std::string msg = lua_tostring(d_state,-1);
lua_pop(d_state,1);
lua_settop( d_state, 0 );
std::string msgerror = handler_name + msg + "\n";
CCLog("%s %s %d", __FILE__, msgerror.c_str(), __LINE__);
return false;
}
// return it
return true;
}
bool CCLuaScriptModule::executeCallFuncND(const std::string& handler_name, CCNode* pNode, void*pData)
{
if (handler_name.size() == 0)
{
std::string msg = "(executeCallFuncND) Unable to execute scripted event handler: handler_name == NULL\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// get the function from lua
lua_getglobal(d_state, handler_name.c_str());
// is it a function
if ( !lua_isfunction(d_state,-1) )
{
lua_settop( d_state, 0 );
std::string msg = handler_name + "name does not represent a Lua function" + "\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// push EventArgs as the first parameter
tolua_pushusertype(d_state,(void*)pNode,"cocos2d::CCNode");
tolua_pushusertype(d_state,(void*)pData,"void*");
// call it
int error = lua_pcall(d_state,2,0,0);
// handle errors
if ( error )
{
std::string msg = lua_tostring(d_state,-1);
lua_pop(d_state,1);
lua_settop( d_state, 0 );
std::string msgerror = handler_name + msg + "\n";
CCLog("%s %d", __FILE__, msgerror.c_str(), __LINE__);
return false;
}
// return it
return true;
}
bool CCLuaScriptModule::executeMenuHandler(const std::string& handler_name, CCObject* pobj)
{
if (handler_name.size() == 0)
{
std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: handler_name == NULL\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// get the function from lua
lua_getglobal(d_state, handler_name.c_str());
// is it a function
if ( !lua_isfunction(d_state,-1) )
{
lua_settop( d_state, 0 );
std::string msg = handler_name + "name does not represent a Lua function" + "\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// push EventArgs as the first parameter
tolua_pushusertype(d_state,(void*)pobj,"cocos2d::CCObject");
// call it
int error = lua_pcall(d_state,1,0,0);
// handle errors
if ( error )
{
std::string msg = lua_tostring(d_state,-1);
lua_pop(d_state,1);
std::string msgerror = handler_name + msg + "\n";
CCLog("%s %s %d", __FILE__, msgerror.c_str(), __LINE__);
return false;
}
// return it
return true;
}
bool CCLuaScriptModule::executeTouchesEvent(const std::string& handler_name, CCSet *pobj)
{
if (handler_name.size() == 0)
{
std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: handler_name == null\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// get the function from lua
lua_getglobal(d_state, handler_name.c_str());
// is it a function
if ( !lua_isfunction(d_state,-1) )
{
lua_settop( d_state, 0 );
std::string msg = handler_name+" does not represent a Lua function"+"\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// push array to lua
lua_createtable(d_state, pobj->count(), 0);
int newTable = lua_gettop(d_state);
int index = 1;
CCSetIterator iter = pobj->begin();
for (; iter != pobj->end(); iter++)
{
tolua_pushusertype(d_state,(void*)(*iter),"cocos2d::CCTouch");
lua_rawseti(d_state, newTable, index++);
}
// call it
int error = lua_pcall(d_state,1,0,0);
// handle errors
if ( error )
{
std::string msg = lua_tostring(d_state,-1);
lua_pop(d_state,1);
lua_settop( d_state, 0 );
std::string msgerror = handler_name + msg + "\n";
CCLog("%s %d", msgerror.c_str(), __LINE__);
return false;
}
// return it
return true;
}
bool CCLuaScriptModule::executeTouch(const std::string& handler_name, CCTouch *pobj)
{
if (handler_name.size() == 0)
{
std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: handler_name == null\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// get the function from lua
lua_getglobal(d_state, handler_name.c_str());
// is it a function
if ( !lua_isfunction(d_state,-1) )
{
lua_settop( d_state, 0 );
std::string msg = handler_name+"\n"+" does not represent a Lua function"+"\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// push EventArgs as the first parameter
tolua_pushusertype(d_state,(void*)pobj,"cocos2d::CCTouch");
// call it
int error = lua_pcall(d_state,1,0,0);
// handle errors
if ( error )
{
std::string msg = lua_tostring(d_state,-1);
lua_pop(d_state,1);
std::string msgerror = handler_name + "\n" + msg + "\n";
CCLog("%s %s %d", __FILE__, msgerror.c_str(), __LINE__);
return false;
}
// return it
return true;
}
bool CCLuaScriptModule::executeEventHandler(const std::string& handler_name, CCEvent* pEvent)
{
if (handler_name.size() == 0)
{
std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: handler_name == NULL\n";
CCLog("%s ", msg.c_str());
return false;
}
// get the function from lua
lua_getglobal(d_state, handler_name.c_str());
// is it a function
if ( !lua_isfunction(d_state,-1) )
{
lua_settop( d_state, 0 );
std::string msg = handler_name + "\n" + " does not represent a Lua function" + "\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// push EventArgs as the first parameter
tolua_pushusertype(d_state,(void*)pEvent,"cocos2d::CCEvent");
// call it
int error = lua_pcall(d_state,1,0,0);
// handle errors
if ( error )
{
std::string msg = lua_tostring(d_state,-1);
lua_pop(d_state,1);
lua_settop( d_state, 0 );
std::string msgerror = handler_name + "\n" + msg + "\n";
CCLog("%s %s %d", __FILE__, msgerror.c_str(), __LINE__);
return false;
}
// return it
return true;
}
bool CCLuaScriptModule::executeListItem(const std::string& handler_name, int index, CCObject* pobj)
{
if (handler_name.size() == 0)
{
std::string msg = "(CCLuaScriptModule) Unable to execute scripted event handler: handler_name == NULL\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// get the function from lua
lua_getglobal(d_state, handler_name.c_str());
// is it a function
if ( !lua_isfunction(d_state,-1) )
{
lua_settop( d_state, 0 );
std::string msg = handler_name + " does not represent a Lua function" + "\n";
CCLog("%s %d", msg.c_str(), __LINE__);
return false;
}
// push EventArgs as the first parameter
lua_pushfstring(d_state, "%d", index);
tolua_pushusertype(d_state,(void*)pobj,"cocos2d::CCObject");
// call it
int error = lua_pcall(d_state,2,0,0);
// handle errors
if ( error )
{
std::string msg = lua_tostring(d_state,-1);
lua_pop(d_state,1);
lua_settop( d_state, 0 );
std::string msgerror = handler_name + msg + "\n";
CCLog("%s %s %d", __FILE__, msgerror.c_str(), __LINE__);
return false;
}
// return it
return true;
}
/*************************************************************************
Execute script code string
*************************************************************************/
bool CCLuaScriptModule::executeString(const std::string& str)
{
// load code into lua and call it
int error = luaL_dostring(d_state, str.c_str());
// handle errors
if ( error )
{
CCLog("executeString %d", error);
return false;
}
return true;
}
/*************************************************************************
Create Lua bindings
*************************************************************************/
void CCLuaScriptModule::createBindings(void)
{
//tolua_Cocos2d_open(d_state);
}
/*************************************************************************
Destroy Lua bindings
*************************************************************************/
void CCLuaScriptModule::destroyBindings(void)
{
lua_pushnil(d_state);
lua_setglobal(d_state,"cocos2d");
}

169
template/msvc/CCAppWiz.win32/Templates/1033/Classes/cocos2dx_support/LuaEngineImpl.h
View File

@ -1,169 +0,0 @@
/****************************************************************************
Copyright (c) 2011 cocos2d-x.org
Copyright (c) 2011 NetDragon.com
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#ifndef _LUA_ENGINE_IMPL_H
#define _LUA_ENGINE_IMPL_H
#include <string>
#include "cocos2d.h"
// include Lua
extern "C" {
#include "lua.h"
}
/**
@brief invoke lua script from c++ code
*/
class CCLuaScriptModule : public cocos2d::CCObject
{
public:
/*************************************************************************
Construction and Destruction
*************************************************************************/
/**
@brief Constructor for LuaScriptModule class which create a lua_State
*/
CCLuaScriptModule();
/**
@brief Constructor for LuaScriptModule class which takes a lua_State
@param state Pointer to the lua_State that the script module should attach to.
*/
CCLuaScriptModule(lua_State* state);
/**
@brief Destructor for LuaScriptModule class.
*/
virtual ~CCLuaScriptModule();
/*************************************************************************
Script Execution Functions
*************************************************************************/
/**
@brief Execute a script file.
@param filename String object holding the filename of the script file that is to be executed
*/
bool executeScriptFile(const std::string& filename);
/**
@brief Execute a scripted global function.
@brief The function should not take any parameters and should return an integer.
@param function_name String object holding the name of the function, in the global script environment, that is to be executed.
@return The integer value returned from the script function.
*/
int executeScriptGlobal(const std::string& function_name);
/**
@brief Execute a scripted global 'event handler' function.
The function should take some kind of EventArgs like parameter
that the concrete implementation of this function can create from the passed EventArgs based object. The function
should not return anything.
@param handler_name String object holding the name of the scripted handler function.
@param e EventArgs based object that should be passed, by any appropriate means, to the scripted function.
@return true if the event was handled.
@return false if the event was not handled.
*/
bool executeSchedule(const std::string& handler_name, cocos2d::ccTime cc);
bool executeCallFunc(const std::string& handler_name);
bool executeCallFuncN(const std::string& handler_name, cocos2d::CCNode* pNode);
bool executeCallFuncND(const std::string& handler_name, cocos2d::CCNode* pNode, void*pData);
bool executeCallFuncO(const std::string& handler_name, cocos2d::CCObject* pObject);
bool executeMenuHandler(const std::string& handler_name, cocos2d::CCObject* pobj);
bool executeEventHandler(const std::string& handler_name, cocos2d::CCEvent* pEvent);
bool executeTouchesEvent(const std::string& handler_name, cocos2d::CCSet *pobj);
bool executeTouch(const std::string& handler_name, cocos2d::CCTouch *pobj);
bool executeListItem(const std::string& handler_name, int index, cocos2d::CCObject* pobj);
/**
@brief Execute script code contained in the given CEGUI::String object.
@param str String object holding the valid script code that should be executed.
@return true if the string is excuted correctly.
@return false if the string is excuted wrongly.
*/
bool executeString(const std::string& str);
/*************************************************************************
Bindings creation / destruction
*************************************************************************/
/**
@brief Method called during system initialisation, prior to running any scripts via the ScriptModule,
@brief to enable the ScriptModule to perform any operations required to complete initialisation or binding
@brief of the script language to the gui system objects.
@return Nothing.
*/
void createBindings(void);
/**
@brief Method called during system destruction, after all scripts have been run via the ScriptModule,
@brief to enable the ScriptModule to perform any operations required to cleanup bindings of the script
@brief language to the gui system objects, as set-up in the earlier createBindings call.
@return Nothing.
*/
void destroyBindings(void);
/*************************************************************************
Accessor type functions
*************************************************************************/
/**
@brief Method used to get a pointer to the lua_State that the script module is attached to.
@return A pointer to the lua_State that the script module is attached to.
*/
lua_State* getLuaState(void) const {return d_state;}
/**
@breif Get the instance of CCLuaScriptModule singleton
*/
static CCLuaScriptModule* sharedLuaScriptModule(void);
/**
@brief Purge and release the CCLuaScriptModule singleton
*/
static void purgeSharedLuaScriptModule();
private:
static CCLuaScriptModule* s_luaScriptModule;
/*************************************************************************
Implementation Data
*************************************************************************/
bool d_ownsState; //!< true when the attached lua_State was created by this script module
lua_State* d_state; //!< The lua_State that this script module uses.
};
#endif // end of guard _LUA_ENGINE_IMPL_H

12
template/msvc/CCAppWiz.win32/Templates/1033/Templates.inf
View File

@ -9,12 +9,12 @@ Classes/AppDelegate.h
Classes/AppDelegate.cpp
[! if CC_USE_LUA]
Classes/cocos2dx_support/LuaCocos2d.cpp
Classes/cocos2dx_support/LuaEngine.cpp
Classes/cocos2dx_support/LuaEngineImpl.cpp
Classes/cocos2dx_support/LuaCocos2d.h
Classes/cocos2dx_support/LuaEngine.h
Classes/cocos2dx_support/LuaEngineImpl.h
../../../../../lua/cocos2dx_support/LuaCocos2d.cpp
../../../../../lua/cocos2dx_support/LuaEngine.cpp
../../../../../lua/cocos2dx_support/LuaEngineImpl.cpp
../../../../../lua/cocos2dx_support/LuaCocos2d.h
../../../../../lua/cocos2dx_support/LuaEngine.h
../../../../../lua/cocos2dx_support/LuaEngineImpl.h
[! else]
Classes/HelloWorldScene.h
Classes/HelloWorldScene.cpp