void SceneObjectImplementation::setObjectMenuComponent(const String& name) {
objectMenuComponent = ComponentManager::instance()->getComponent<ObjectMenuComponent*>(name);
if (objectMenuComponent == NULL) {
Lua* lua = DirectorManager::instance()->getLuaInstance();
LuaObject test = lua->getGlobalObject(name);
if (test.isValidTable()) {
objectMenuComponent = new LuaObjectMenuComponent(name);
info("New Lua ObjectMenuComponent created: '" + name + "' for " + templateObject->getFullTemplateString());
ComponentManager::instance()->putComponent(name, objectMenuComponent);
} else {
error("ObjectMenuComponent not found: '" + name + "' for " + templateObject->getFullTemplateString());
}
test.pop();
}
}
int LS_VirtualDrive_ProcessFileList(LuaState* state, LuaStackObject* args)
{
VirtualDrive* drive = VirtualDriveFromLua(state, args[1]);
if (args[2].IsTable())
{
VirtualDrive::FileOrderInfoArray fileOrder;
VirtualDrive::FileOrderInfo info;
LuaObject tableObj = args[2];
int index = 1;
while (true)
{
LuaObject entryNameObj = tableObj[index++];
if (!entryNameObj.IsString())
break;
info.entryName = entryNameObj.GetString();
LuaObject srcPathObj = tableObj[index++];
if (srcPathObj.IsNil())
break;
info.srcPath = srcPathObj.GetString();
info.compressionMethod = 8;
LuaObject compressionMethodObj = tableObj[index];
if (compressionMethodObj.IsNumber())
{
info.compressionMethod = compressionMethodObj.GetInteger();
index++;
}
fileOrder.Add(info);
}
bool ret = drive->ProcessFileList(fileOrder);
state->PushBoolean(ret);
if (!ret)
{
state->PushString(drive->errorString);
return 2;
}
return 1;
}
if (args[2].IsString())
{
state->PushBoolean(drive->ProcessFileList(args[2].GetString()) != 0);
return 1;
}
return 0;
}
void VendorManager::loadLuaVendors() {
info("Loading Vendor Options...");
Lua* lua = new Lua();
lua->init();
lua->runFile("scripts/managers/vendor_manager.lua");
LuaObject menu = lua->getGlobalObject("VendorMenu");
rootNode = new VendorSelectionNode();
rootNode->parseFromLua(menu);
menu.pop();
delete lua;
lua = NULL;
}
int LuaState::DoString( const char *str, LuaObject& fenvObj )
{
lua_State* L = LuaState_to_lua_State(this);
int status = luaL_loadbuffer(L, str, strlen(str), str);
if (status != 0)
return status;
fenvObj.Push();
SetFEnv(-2);
return lua_pcall(L, 0, LUA_MULTRET, 0);
}
int LuaState::DoFile( const char *filename, LuaObject& fenvObj )
{
lua_State* L = LuaState_to_lua_State(this);
int status = luaL_loadfile(L, filename);
if (status != 0)
return status;
fenvObj.Push();
SetFEnv(-2);
return lua_pcall(L, 0, LUA_MULTRET, 0);
}
int LuaState::DoBuffer( const char *buff, size_t size, const char *name, LuaObject& fenvObj )
{
lua_State* L = LuaState_to_lua_State(this);
int status = luaL_loadbuffer(L, buff, size, name);
if (status != 0)
return status;
fenvObj.Push();
SetFEnv(-2);
return lua_pcall(L, 0, LUA_MULTRET, 0);
}
LuaObject::LuaObject( const LuaObject& obj )
: m_state( obj.m_state )
{
// 引用
if( obj.isvalid() )
{
lua_getref( m_state, obj.m_luaobject );
m_luaobject = luaL_ref( m_state, LUA_REGISTRYINDEX );
}
}
int LuaState::DoString( const char *str, LuaObject& fenvObj )
{
int status = luaL_loadbuffer(m_state, str, strlen(str), str);
if (status == 0)
{
fenvObj.Push();
SetFEnv(-2);
}
return aux_do(m_state, status);
}
int LuaState::DoFile( const char *filename, LuaObject& fenvObj )
{
int status = luaL_loadfile(m_state, filename);
if (status == 0)
{
fenvObj.Push();
SetFEnv(-2);
}
return aux_do(m_state, status);
}
int LuaState::DoBuffer( const char *buff, size_t size, const char *name, LuaObject& fenvObj )
{
int status = luaL_loadbuffer(m_state, buff, size, name);
if (status == 0)
{
fenvObj.Push();
SetFEnv(-2);
}
return aux_do(m_state, status);
}
shared_ptr<CCLuaValueDict> LuaObject::loadLuaTableFromFile(const char* scriptName) {
LuaObject* obj = LuaObject::create(scriptName);
shared_ptr<CCLuaValueDict> dict;
string path = CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(scriptName);
obj->getLuaEngine()->executeScriptFile(path.c_str());
lua_State* L = obj->getLuaEngine()->getLuaState();
if (lua_istable(L, -1)) {
dict = obj->recursivelyLoadTable(-1);
//LOG_EXPR(dict);
} else {
string error = lua_tostring(L, -1);
cout << "\n\nERROR in loadLuaTableFromFile: " << error << "\n\n";
}
lua_pop(L, 1);
return dict;
}
void
registerMissionFunctions(LuaState* state)
{
LuaObject globals = state->GetGlobals();
globals.Register("mission_get_credits", &mission_get_credits);
globals.Register("mission_set_credits", &mission_set_credits);
globals.Register("mission_credit_transaction", &mission_credit_transaction);
globals.Register("mission_is_solvent", &mission_is_solvent);
globals.Register("mission_enable_module", &mission_enable_module);
globals.Register("mission_disable_module", &mission_disable_module);
globals.Register("mission_is_module_enabled", &mission_is_module_enabled);
globals.Register("mission_enable_all_modules", &mission_enable_all_modules);
globals.Register("mission_set_time", &mission_set_time);
globals.Register("mission_complete", &mission_complete);
}
CRemoteLuaDebuggerDoc::CRemoteLuaDebuggerDoc()
{
m_state = LuaState::Create();
LuaObject globalsObj = m_state->GetGlobals();
globalsObj.Register("DebugSendFile", Script_DebugSendFile);
globalsObj.Register("DebugSetLocation", Script_DebugSetLocation);
globalsObj.Register("DebugUpdateLocals", Script_DebugUpdateLocals);
globalsObj.Register("DebugUpdateWatch", LS_DebugUpdateWatch );
globalsObj.Register("DebugUpdateCallStack", Script_DebugUpdateCallStack);
globalsObj.Register("DebugOutput", Script_DebugOutput);
globalsObj.Register("LuaServerConnect", Script_LuaServerConnect);
globalsObj.Register("LuaDebuggerConnect", Script_LuaDebuggerConnect);
const DWORD LUA_DEBUGGER_PORT = 3536;
theApp.GetNetworkClient().Open("LuaDebugger", CStringA(theApp.m_pszRegistryKey), m_state->GetCState(), NULL, LUA_DEBUGGER_PORT);
}
void ScriptFunctionsRegister(struct lua_State* L)
{
LuaState* state = lua_State_To_LuaState(L);
LuaObject globalsObj = state->GetGlobals();
globalsObj.Register("GetTickCount", LS_GetTickCount);
#if defined(_MSC_VER) && defined(WIN32) && !defined(_XBOX) && !defined(_XBOX_VER) && !defined(PLATFORM_PS3)
#elif defined(__APPLE__)
char modulePath[MAXPATHLEN + 1];
unsigned int path_len = MAXPATHLEN;
_NSGetExecutablePath(modulePath, &path_len);
char* slashPtr = strrchr(modulePath, '/');
slashPtr++;
*slashPtr = 0;
#endif // _MSC_VER
state->GetGlobals().Register("LuaDumpGlobals", LS_LuaDumpGlobals);
state->GetGlobals().Register("LuaDumpObject", LS_LuaDumpObject);
state->GetGlobals().Register("LuaDumpFile", LS_LuaDumpFile);
}
void AEngineFramework::Desc::deserialize(lua::State* luaState, const LuaPlus::LuaObject& src){
// Logging
LuaObject loggingTable = src.Get("logging");
if(loggingTable.IsTable()){
luaConv(loggingTable.Get("filePath"), logging.filePath);
luaConv(loggingTable.Get("enabled"), logging.enabled);
}
// Layout
LuaObject windowTable = src.Get("window");
window.deserialize(luaState, windowTable);
// File system
LuaObject fileSysTable = src.Get("file_system");
fileSystem.deserialize(luaState, fileSysTable);
// Misc
luaConv(src.Get("home_dir"), homeDir);
luaConv(src.Get("main_loop_step"), mainLoopStep);
}
INT MissionReply::EnumItem(LuaPlus::LuaState* state)
{
LuaStack args(state);
//检查参数
if (!(args[2].IsInteger()))
{
KLThrow("LUA: MissionReply::EnumItem Wrong Param2");
}
INT nIndex = args[2].GetInteger();
if(nIndex>=0 && nIndex<=3)
{
tActionItem* pActionItem = CActionSystem::GetMe()->EnumAction(nIndex, NAMETYPE_MISSIONREFER);
if(pActionItem)
{
LuaObject objReturn = state->BoxPointer(pActionItem);
objReturn.SetMetaTable(*CActionItem::s_pMetaTable);
objReturn.PushStack();
return 1;
}
}
//非法ActionItem
LuaObject objReturn = state->BoxPointer(&(CActionItem::s_InvalidAction));
objReturn.SetMetaTable(*CActionItem::s_pMetaTable);
objReturn.PushStack();
return 1;
}
SceneObject::SceneObject(LuaObject* templateData) : Logger("SceneObject") {
parent = NULL;
objectID = 0;
slottedObjects.setNullValue(NULL);
objectName.setStringId(String(templateData->getStringField("objectName")));
detailedDescription.setStringId(String(templateData->getStringField("detailedDescription")));
containerType = templateData->getIntField("containerType");
containerVolumeLimit = templateData->getIntField("containerVolumeLimit");
gameObjectType = templateData->getIntField("gameObjectType");
objectCRC = templateData->getIntField("clientObjectCRC");
LuaObject arrangements = templateData->getObjectField("arrangementDescriptors");
for (int i = 1; i <= arrangements.getTableSize(); ++i) {
arrangementDescriptors.add(arrangements.getStringAt(i));
}
arrangements.pop();
LuaObject slots = templateData->getObjectField("slotDescriptors");
for (int i = 1; i <= slots.getTableSize(); ++i) {
slotDescriptors.add(slots.getStringAt(i));
}
slots.pop();
containmentType = 4;
initializePosition(0.f, 0.f, 0.f);
movementCounter = 0;
setGlobalLogging(true);
setLogging(false);
String fullPath;
objectName.getFullPath(fullPath);
client = NULL;
zone = NULL;
info("created " + fullPath);
}
extern "C" LUAMODULE_API int luaopen_bit(lua_State* L)
{
LuaState* state = LuaState::CastState(L);
LuaObject obj = state->GetGlobals().CreateTable( "bit" );
obj.Register("bnot", int_bnot);
obj.Register("band", int_band);
obj.Register("bor", int_bor);
obj.Register("bxor", int_bxor);
obj.Register("lshift", int_lshift);
obj.Register("rshift", int_rshift);
obj.Register("arshift", int_arshift);
obj.Register("mod", int_mod);
obj.Register("help", LS_help);
return 0;
}
void AEngineFramework::Desc::serialize(lua::State* luaState, LuaPlus::LuaObject& dst) const{
// Logging
LuaObject loggingTable = luaState->newTable();
loggingTable.Set("filePath", logging.filePath.c_str());
loggingTable.Set("enabled", logging.enabled);
dst.Set("logging", loggingTable);
// Layout
LuaObject windowTable = luaState->newTable();
window.serialize(luaState, windowTable);
dst.Set("window", windowTable);
// File System
LuaObject fileSysTable = luaState->newTable();
fileSystem.serialize(luaState, fileSysTable);
dst.Set("file_system", fileSysTable);
// Misc
dst.Set("home_dir", homeDir.c_str());
dst.Set("main_loop_step", mainLoopStep);
// TODO physics debugging
}
bool CraftingManagerImplementation::loadBioSkillMods() {
Reference<Lua* > lua = new Lua();
lua->init();
if (!lua->runFile("scripts/managers/crafting/bio_skill_mods.lua")) {
return false;
}
LuaObject bioModsTable = lua->getGlobalObject("bioSkillMods");
if (!bioModsTable.isValidTable())
return false;
for (int i = 1; i <= bioModsTable.getTableSize(); ++i) {
String mod = bioModsTable.getStringAt(i);
bioMods.put(mod);
}
bioModsTable.pop();
return true;
}
//添加一次性的脚本定时
unsigned int ScriptTimerMgr::AddTimerOnce_Lua(LuaObject func, float fInterval)
{
if (!func.IsFunction())
{
return 0;
}
OBJID nId = getNextGuid();
m_mapHandler.insert(make_pair(TimerID(nId, true), TimerHandler(func)));
m_pkTimerMgr->SetTimer(this, nId, fInterval);
return nId;
}
void
registerStationFunctions(LuaState* state)
{
LuaObject globals = state->GetGlobals();
globals.Register("station_get_name", &station_get_name);
globals.Register("station_set_name", &station_set_name);
globals.Register("station_add_module", &station_add_module);
globals.Register("station_count_modules", &station_count_modules);
globals.Register("station_get_modules", &station_get_modules);
globals.Register("station_save_as_group", &station_save_as_group);
globals.Register("station_save_group", &station_save_group);
globals.Register("station_load_group", &station_load_group);
}
int
mission_set_time(LuaState* state)
{
LuaObject lMonth = state->Stack(1);
LuaObject lYear = state->Stack(2);
if(!(lMonth.IsNumber() && lYear.IsNumber())) return 0;
int month = lMonth.GetInteger();
int year = lYear.GetInteger();
rMain()->getMission()->setTime(month, year);
return 0;
}
extern "C" LUAMODULE_API int luaopen_dotnet(lua_State* L)
{
LuaState* state = LuaState::CastState(L);
LuaObject obj = state->GetGlobals()["dotnet"];
if (obj.IsTable())
return 0;
obj = state->GetGlobals().CreateTable( "dotnet" );
char path[ _MAX_PATH ];
#ifdef _DEBUG
const char* dllName = "ldotnet.dlld";
#else !_DEBUG
const char* dllName = "ldotnet.dll";
#endif _DEBUG
GetModuleFileName(GetModuleHandle(dllName), path, _MAX_PATH);
char* slashPtr = strrchr( path, '\\' );
slashPtr++;
*slashPtr = 0;
#ifdef _DEBUG
strcat(path, "Debug\\");
#endif _DEBUG
strcat(path, "dotnetinterface.dll");
Assembly* assembly = Assembly::LoadFrom(path);
Type* type = assembly->GetType("LuaInterface.Lua");
Object* parms[] = new Object*[1];
parms[0] = __box((IntPtr)state->GetCState());
Object* lua = Activator::CreateInstance(type, parms);
LuaObject metaTableObj;
metaTableObj.AssignNewTable(state);
metaTableObj.Register("__gc", GCHandle_gc);
LuaObject dotNetObj = state->NewUserDataBox((void*)(GCHandle::op_Explicit(GCHandle::Alloc(lua))).ToInt32());
dotNetObj.SetMetaTable(metaTableObj);
obj.SetObject("__dotNetUserData", dotNetObj);
return 0;
}
void LuaObject::SetSeq(int n, LuaObject& value) const{
if (value.IsTable()){
auto newTable = SetSeqTable(n);;
newTable.AppendTable(value);
}
else if (value.IsBool()){
SetSeq(n, value.GetBoolWithDef());
}
else if (value.IsNumber()){
SetSeq(n, value.GetDouble());
}
else if (value.IsString()){
SetSeq(n, value.GetString().c_str());
}
else{
assert(0);
}
}
void LuaObject::SetField(const char* fieldName, LuaObject& value) const{
if (value.IsTable()){
auto newTable = SetFieldTable(fieldName);
newTable.AppendTable(value);
}
else if (value.IsBool()){
SetField(fieldName, value.GetBoolWithDef());
}
else if (value.IsNumber()){
SetField(fieldName, value.GetDouble());
}
else if (value.IsString()){
SetField(fieldName, value.GetString().c_str());
}
else{
assert(0);
}
}
CStringW DebugBasicSerialize( LuaObject& obj )
{
if ( obj.Type() == LUA_TNUMBER )
{
CStringW str;
str.Format( L"%.16g", obj.GetNumber() );
return str;
}
else if ( obj.Type() == LUA_TBOOLEAN )
{
return obj.GetBoolean() ? L"true" : L"false";
}
else if (obj.Type() == LUA_TSTRING)
{
CString str = obj.GetString();
if ( str == "!!!NIL!!!" )
return L"nil";
else if ( str == "!!!FUNCTION!!!" )
return L"{function}";
else if ( str == "!!!CFUNCTION!!!" )
return L"{cfunction}";
else if ( str == "!!!USERDATA!!!" )
return L"{userdata}";
else if ( str == "!!!TABLE!!!" )
return L"{table}";
return CStringW(str);
}
#if LUA_WIDESTRING
else if (obj.Type() == LUA_TWSTRING)
{
return CStringW((wchar_t*)obj.GetWString());
}
#endif // LUA_WIDESTRING
else
return _T("Unknown");
}
void VendorOutfitManager::loadLuaOutfits() {
info("Loading Outfits...");
String outfitName;
Lua* lua = new Lua();
lua->init();
lua->runFile("scripts/mobile/wearables/outfits.lua");
LuaObject Luaoutfits = lua->getGlobalObject("Outfits");
for (int i = 1; i < Luaoutfits.getTableSize() + 1; ++i) {
lua_State* L = Luaoutfits.getLuaState();
lua_rawgeti(L, -1, i);
LuaObject outfit(L);
outfitName = outfit.getStringField("outfitName");
//info("Loaded " + outfit.getStringField("outfitName"), true); // OutfitName
LuaObject clothing = outfit.getObjectField("clothing"); // Clothing Object
Reference<Outfit*> oFit = new Outfit();
for (int j = 1; j <= clothing.getTableSize(); ++j) {
//info("Added " + clothing.getStringAt(j), true);
oFit->addClothingCRC(clothing.getStringAt(j).hashCode());
}
outfits.put(outfitName, oFit);
clothing.pop();
outfit.pop();
}
info("Loaded " + String::valueOf(outfits.size()) + " unique outfits", true);
Luaoutfits.pop();
}
//==============================================================================
//注册tileMap地图事件：【路径】点击事件
int RegTileMapCallBack(LuaState* pkLuaState)
{
WriteCon("[TileMapNotify] RegTileMapCallBack()\r\n");
NDTileMapNotify& kTarget = NDTileMapNotifyObj;
LuaStack kArgs(pkLuaState);
LuaObject kObjType = kArgs[1];
LuaObject kObjFunction = kArgs[2];
if (kObjType.IsString() && (kObjFunction.IsFunction() || kObjFunction.IsNil()))
{
const char* pszType = kObjType.GetString();
if (pszType && *pszType)
{
if (stricmp(pszType, "click_empty") == 0)
{
kTarget.m_kLuaClickEmpty = kObjFunction;
}
else if (stricmp(pszType, "click_obj") == 0)
{
kTarget.m_kLuaClickObj = kObjFunction;
}
else if (stricmp(pszType, "loadmap_begin") == 0)
{
kTarget.m_kLuaLoadMapBegin = kObjFunction;
}
else if (stricmp(pszType, "loadmap_end") == 0)
{
kTarget.m_kLuaLoadMapEnd = kObjFunction;
}
else if (stricmp(pszType, "player_jump_done") == 0)
{
kTarget.m_kLuaPlayerJumpDone = kObjFunction;
}
pkLuaState->PushBoolean(true);
}
}
else
{
pkLuaState->PushBoolean(false);
}
return 1;
}
bool CameraObjectParams::VInit( LuaObject srcData, TErrorMessageList & errorMessages )
{
if ( false == ActorParams::VInit( srcData, errorMessages ) )
{
return false;
}
m_Type = AT_Camera;
m_Mat = MatIdentity();
LuaObject matObj = srcData[ "Mat" ];
if ( matObj.IsTable() )
{
const int tableCount = matObj.GetTableCount();
if ( 16 != tableCount )
{
const std::string err( "Incorrect number of parameters in the 'Mat' member." );
errorMessages.push_back( err );
return false;
}
else
{
char name[4] = "_00";
for( int i = 1; i <= 4; ++i )
{
name[1] = '0' + i;
for( int j = 1; j <= 4; ++j )
{
name[2] = '0' + j;
LuaObject entry = matObj[ name ];
if( entry.IsNumber() )
{
m_Mat.GetStorage().m[i - 1][j - 1] = entry.GetFloat();
}
}
}
}
}
return true;
}
