API tools faq
paste
Advertisement
jackpoz

ArcEmu LuaEngine LHA fix

jackpoz
Aug 6th, 2011
258
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Diff 8.59 KB | None | 0 0
raw download clone embed print report
  1. Index: src/scripts/src/LuaEngine/LUAEngine.cpp
  2. ===================================================================
  3. --- src/scripts/src/LuaEngine/LUAEngine.cpp (revision 4445)
  4. +++ src/scripts/src/LuaEngine/LUAEngine.cpp (working copy)
  5. @@ -280,9 +280,9 @@
  6.     if(unit != NULL && unit->IsUnit())
  7.         pUnit = TO_UNIT(unit);
  8.     if(L == NULL)
  9. -       ArcLuna<Unit>::push(lu, pUnit);
  10. +       ArcSole<Unit>::push(lu, pUnit);
  11.     else
  12. -       ArcLuna<Unit>::push(L, pUnit);
  13. +       ArcSole<Unit>::push(L, pUnit);
  14.  }
  15.  void LuaEngine::PushGo(Object* go, lua_State* L)
  16.  {
  17. @@ -290,9 +290,9 @@
  18.     if(go != NULL && go->IsGameObject())
  19.         pGo = TO< GameObject* >(go);
  20.     if(L == NULL)
  21. -       ArcLuna<GameObject>::push(lu, pGo);
  22. +       ArcSole<GameObject>::push(lu, pGo);
  23.     else
  24. -       ArcLuna<GameObject>::push(L, pGo);
  25. +       ArcSole<GameObject>::push(L, pGo);
  26.  }
  27.  void LuaEngine::PushItem(Object* item, lua_State* L)
  28.  {
  29. @@ -586,9 +586,9 @@
  30.  
  31.     RegisterGlobalFunctions(lu);
  32.  
  33. -   ArcLuna<Unit>::Register(lu);
  34. +   ArcSole<Unit>::Register(lu);
  35.     ArcLuna<Item>::Register(lu);
  36. -   ArcLuna<GameObject>::Register(lu);
  37. +   ArcSole<GameObject>::Register(lu);
  38.     ArcLuna<WorldPacket>::Register(lu);
  39.     ArcLuna<TaxiPath>::Register(lu);
  40.     ArcLuna<Spell>::Register(lu);
  41. Index: src/scripts/src/LuaEngine/LUAEngine.h
  42. ===================================================================
  43. --- src/scripts/src/LuaEngine/LUAEngine.h   (revision 4445)
  44. +++ src/scripts/src/LuaEngine/LUAEngine.h   (working copy)
  45. @@ -301,13 +301,13 @@
  46.         //Wrappers
  47.         ARCEMU_INLINE Unit* CheckUnit(lua_State* L, int narg)
  48.         {
  49. -           if(L == NULL) return ArcLuna<Unit>::check(lu, narg);
  50. -           else return ArcLuna<Unit>::check(L, narg);
  51. +           if(L == NULL) return ArcSole<Unit>::check(lu, narg);
  52. +           else return ArcSole<Unit>::check(L, narg);
  53.         }
  54.         ARCEMU_INLINE GameObject* CheckGo(lua_State* L, int narg)
  55.         {
  56. -           if(L == NULL) return ArcLuna<GameObject>::check(lu, narg);
  57. -           else return ArcLuna<GameObject>::check(L, narg);
  58. +           if(L == NULL) return ArcSole<GameObject>::check(lu, narg);
  59. +           else return ArcSole<GameObject>::check(L, narg);
  60.         }
  61.         ARCEMU_INLINE Item* CheckItem(lua_State* L, int narg)
  62.         {
  63. @@ -326,8 +326,8 @@
  64.         }
  65.         ARCEMU_INLINE Object* CheckObject(lua_State* L, int narg)
  66.         {
  67. -           if(L == NULL) return ArcLuna<Object>::check(lu, narg);
  68. -           else return ArcLuna<Object>::check(L, narg);
  69. +           if(L == NULL) return ArcSole<Object>::check(lu, narg);
  70. +           else return ArcSole<Object>::check(L, narg);
  71.         }
  72.         ARCEMU_INLINE TaxiPath* CheckTaxiPath(lua_State* L, int narg)
  73.         {
  74. @@ -775,6 +775,205 @@
  75.                     return 1;
  76.                 }
  77.         };
  78. +
  79. +       //As opposed to ArcLuna, this is meant to bring some light to this Lua Engine plagued by crashes since r1, caused by pushing on the stack Object*
  80. +       //references that could point to free'd memory. It will push object* (and derived types) as guid + mapid + instanceid.
  81. +       template <typename T>
  82. +       class ArcSole
  83. +       {
  84. +           private:
  85. +               uint64 guid;
  86. +               uint32 mapId;
  87. +               int32 instanceId;
  88. +
  89. +               T* Get()
  90. +               {
  91. +                   Object* object = NULL;
  92. +                   MapMgr* mapMgr = sInstanceMgr.GetMapMgr(mapId);
  93. +                   if(mapMgr == NULL)
  94. +                   {
  95. +                       //if mapMgr is NULL then it's probably an instance
  96. +                       Instance * instance = sInstanceMgr.GetInstanceByIds(mapId, instanceId);
  97. +                       if(instance != NULL)
  98. +                           object = instance->m_mapMgr->_GetObject(guid);
  99. +                   }
  100. +                   else
  101. +                       object = mapMgr->_GetObject(guid);
  102. +                   return TO<T*>(object);
  103. +               }
  104. +           public:
  105. +               typedef int (*mfp)(lua_State *L, T* ptr);
  106. +               typedef struct { const char *name; mfp mfunc; } RegType;
  107. +
  108. +               static void Register(lua_State *L)
  109. +               {
  110. +                   lua_newtable(L);
  111. +                   int methods = lua_gettop(L);
  112. +
  113. +                   luaL_newmetatable(L, GetTClassName<T>());
  114. +                   int metatable = lua_gettop(L);
  115. +
  116. +                   luaL_newmetatable(L,"DO NOT TRASH");
  117. +                   lua_pop(L,1);
  118. +
  119. +                   // store method table in globals so that
  120. +                   // scripts can add functions written in Lua.
  121. +                   lua_pushvalue(L, methods);
  122. +                   lua_setglobal(L,GetTClassName<T>());
  123. +
  124. +                   // hide metatable from Lua getmetatable()
  125. +                   lua_pushvalue(L, methods);
  126. +                   lua_setfield(L, metatable, "__metatable");
  127. +
  128. +                   lua_pushcfunction(L,index);
  129. +                   lua_setfield(L, metatable, "__index");
  130. +
  131. +                   lua_pushcfunction(L, tostring_T);
  132. +                   lua_setfield(L, metatable, "__tostring");
  133. +
  134. +                   //nil gc method because world will take care of created Objects
  135. +                   lua_pushnil(L);
  136. +                   lua_setfield(L, metatable, "__gc");
  137. +
  138. +                   lua_newtable(L);                // mt for method table
  139. +                   lua_setmetatable(L, methods);
  140. +
  141. +                   // fill method table with methods from class T
  142. +                   for (RegType *l = ((RegType*)GetMethodTable<T>()); l->name; l++)
  143. +                   {
  144. +                       lua_pushstring(L, l->name);
  145. +                       lua_pushlightuserdata(L, (void*)l);
  146. +                       lua_pushcclosure(L, thunk, 1);
  147. +                       lua_settable(L, methods);
  148. +                   }
  149. +                   lua_pop(L, 2);  // drop metatable and method table
  150. +               }
  151. +
  152. +               // push onto the Lua stack a userdata containing a pointer to T object
  153. +               static int push(lua_State *L, T *obj, bool gc=false)
  154. +               {
  155. +                   if(obj == NULL)
  156. +                   {
  157. +                       lua_pushnil(L);
  158. +                       return lua_gettop(L);
  159. +                   }
  160. +
  161. +                   luaL_getmetatable(L, GetTClassName<T>());  // lookup metatable in Lua registry
  162. +                   if (lua_isnil(L, -1)) luaL_error(L, "%s missing metatable", GetTClassName<T>());
  163. +                   int mt = lua_gettop(L);
  164. +                   ArcSole* holder = TO<ArcSole*>(lua_newuserdata(L,sizeof(ArcSole)));
  165. +                   int ud = lua_gettop(L);
  166. +                   if(holder != NULL)
  167. +                   {
  168. +                       holder->guid = obj->GetGUID();
  169. +                       holder->mapId = obj->GetMapId();
  170. +                       holder->instanceId = obj->GetInstanceID();
  171. +
  172. +                       lua_pushvalue(L, mt);
  173. +                       lua_setmetatable(L, -2);
  174. +                       char name[32];
  175. +                       tostring(name,obj);
  176. +                       lua_getfield(L,LUA_REGISTRYINDEX,"DO NOT TRASH");
  177. +                       if(lua_isnil(L,-1) )
  178. +                       {
  179. +                           luaL_newmetatable(L,"DO NOT TRASH");
  180. +                           lua_pop(L,1);
  181. +                       }
  182. +                       lua_getfield(L,LUA_REGISTRYINDEX,"DO NOT TRASH");
  183. +                       if(gc == false)
  184. +                       {
  185. +                           lua_pushboolean(L,1);
  186. +                           lua_setfield(L,-2,name);
  187. +                       }
  188. +                       lua_pop(L,1);
  189. +                   }
  190. +                   lua_settop(L,ud);
  191. +                   lua_replace(L, mt);
  192. +                   lua_settop(L, mt);
  193. +                   return mt;  // index of userdata containing pointer to T object
  194. +               }
  195. +
  196. +               // get userdata from Lua stack and return pointer to T object
  197. +               static T *check(lua_State *L, int narg)
  198. +               {
  199. +                   ArcSole* holder = TO<ArcSole*>(lua_touserdata(L,narg));
  200. +                   if(holder == NULL)
  201. +                       return NULL;
  202. +                   return holder->Get();
  203. +               }
  204. +
  205. +           private:
  206. +               // member function dispatcher
  207. +               static int thunk(lua_State *L)
  208. +               {
  209. +                   // stack has userdata, followed by method args
  210. +                   T *obj = check(L, 1);  // get 'self', or if you prefer, 'this'
  211. +                   lua_remove(L, 1);  // remove self so member function args start at index 1
  212. +                   // get member function from upvalue
  213. +                   RegType *l = static_cast<RegType*>(lua_touserdata(L, lua_upvalueindex(1)));
  214. +                   //return (obj->*(l->mfunc))(L);  // call member function
  215. +                   return l->mfunc(L,obj);
  216. +               }
  217. +
  218. +               static int tostring_T (lua_State *L)
  219. +               {
  220. +                   char buff[32];
  221. +                   T ** ptrHold = (T**)lua_touserdata(L,1);
  222. +                   T *obj = *ptrHold;
  223. +                   sprintf(buff, "%p", obj);
  224. +                   lua_pushfstring(L, "%s (%s)", GetTClassName<T>(), buff);
  225. +                   return 1;
  226. +               }
  227. +               ARCEMU_INLINE static void tostring(char * buff,void * obj)
  228. +               {
  229. +                   sprintf(buff,"%p",obj);
  230. +               }
  231. +               static int index(lua_State * L)
  232. +               {
  233. +                   /*Paroxysm : the table obj and the missing key are currently on the stack(index 1 & 2) */
  234. +                   lua_getglobal(L,GetTClassName<T>());
  235. +                   // string form of the key.
  236. +                   const char * key = lua_tostring(L,2);
  237. +                   if(lua_istable(L,-1) )
  238. +                   {
  239. +                       lua_pushvalue(L,2);
  240. +                       lua_rawget(L,-2);
  241. +                       //If the key were looking for is not in the table, retrieve its' metatables' index value.
  242. +                       if(lua_isnil(L,-1))
  243. +                       {
  244. +                           lua_getmetatable(L,-2);
  245. +                           if(lua_istable(L,-1) )
  246. +                           {
  247. +                               lua_getfield(L,-1,"__index");
  248. +                               if(lua_isfunction(L,-1) )
  249. +                               {
  250. +                                   lua_pushvalue(L,1);
  251. +                                   lua_pushvalue(L,2);
  252. +                                   lua_pcall(L,2,1,0);
  253. +                               }
  254. +                               else if(lua_istable(L,-1) )
  255. +                                   lua_getfield(L,-1,key);
  256. +                               else
  257. +                                   lua_pushnil(L);
  258. +                           }
  259. +                           else
  260. +                               lua_pushnil(L);
  261. +                       }
  262. +                       else if(lua_istable(L,-1) )
  263. +                       {
  264. +                           lua_pushvalue(L,2);
  265. +                           lua_rawget(L,-2);
  266. +                       }
  267. +                   }
  268. +                   else
  269. +                       lua_pushnil(L);
  270. +
  271. +                   lua_insert(L,1);
  272. +                   lua_settop(L,1);
  273. +                   return 1;
  274. +               }
  275. +       };
  276. +
  277.         class GUID_MGR
  278.         {
  279.                 static const char* GetName() { return "WoWGUID"; }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!