dreyndev/JD2022-TU1
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
JD2022-TU1/main/extern/Camcam/LIBS/Mixer/SCENE_LUA.cpp

4306 lines
105 KiB
C++
Raw Blame History

#include "Scene.h"
#ifndef SKIMMED_NET
#include "lsluasocket.h"
#endif
#ifdef ONLINE_MODE
#include "account.h"
#include "json-c/json.h"
#endif
#include <string>
bool debuggingLua = false;
bool updateEvent = false;
int UpdateEvents(lua_State *L);
extern WORLD *TheScene;
#ifdef ONLINE_MODE
extern CCamCamAccount Account;
#include <map>
std::map<int, CHttpClient> HttpClientChannels;
#endif
void FillScriptInfo(lua_State *L, int paramNum, int isError);
void SaveDBGInfo(char *text);
#ifndef USER_MODE
void MyDebug(lua_State *L, int i = 0);
static void MyDebug(lua_State *L, int i) {
FillScriptInfo(L, 0, 0);
return;
}
#else
#define MyDebug(L, i)
#define MyDebug(L)
#endif
typedef struct MouseInfo_
{
int x;
int y;
u32 keys;
int value;
} MouseInfo;
void getStack(lua_State *L, int index)
{
char * luatype = NULL, *luaval = NULL;
luatype = (char *)lua_typename(L, lua_type(L, index));
if (luatype)
luaval = (char *)lua_tostring(L, index);
return;
}
void SetStrFieldFloat(lua_State *L, const char *index, float value);
void SetStrFieldString(lua_State *L, const char *index, char * value);
int PopColor(lua_State *L, u32 *colorPtr, int luaParam = 0);
int PopPoint(lua_State *L, POINT *vectorPtr, int luaParam = 0);
void PushBool(lua_State *L, BOOL value);
void PushInt(lua_State *L, int value);
void PushFloat(lua_State *L, float value);
void PushString(lua_State *L, char *string);
void PushColor(lua_State *L, DWORD color);
void PushRectangle(lua_State *L, RECT *rectPtr);
void PushTableInt(lua_State *L, int *tabList, int nbElmts);
void PushTableFloat(lua_State *L, float *tabList, int nbElmts);
void PushPoint(lua_State *L, POINT *pointPtr);
void PushPoint(lua_State *L, int x, int y);
void PushMouseInfo(lua_State *L, int x, int y, u32 code);
void PushMatrix(lua_State *L, MATRIX *matrixPtr);
void PushIntEvent(lua_State *L, int value, float time);
void PushFloatEvent(lua_State *L, float value, float time);
void PushStringEvent(lua_State *L, char * value, float time);
Vector *PopVectorPtr(lua_State *L, int luaParam = 0);
int PopVector(lua_State *L, Vector *vectorPtr, int luaParam = 0);
void PushVector(lua_State *L, Vector *vectorPtr);
void PushVectorPtr(lua_State *L, Vector *vectorPtr);
int Vector_Clone(lua_State *L);
int Vector_Add(lua_State *L);
int Vector_Sub(lua_State *L);
int Vector_Mul(lua_State *L);
int Vector_Pow(lua_State *L);
int Vector_SqrNorm(lua_State *L);
int Vector_Norm(lua_State *L);
int Vector_Normalize(lua_State *L);
void Vector_Register(lua_State *L);
void VectorPtr_Register(lua_State *L);
Quat *PopQuatPtr(lua_State *L, int luaParam = 0);
int PopQuat(lua_State *L, Quat *quatPtr, int luaParam = 0);
void PushQuat(lua_State *L, Vector *vectorPtr);
int Quat_Clone(lua_State *L);
int Quat_Add(lua_State *L);
int Quat_Sub(lua_State *L);
int Quat_Mul(lua_State *L);
int Quat_Pow(lua_State *L);
int Quat_Normalize(lua_State *L);
int Quat_NormalizeW(lua_State *L);
void Quat_Register(lua_State *L);
int PopMatrix(lua_State *L, MATRIX *matrixPtr, int luaParam = 0);
MATRIX *PopMatrixPtr(lua_State *L, int luaParam = 0);
int Matrix_Clone(lua_State *L);
int Matrix_Mul(lua_State *L);
void Matrix_Register(lua_State *L);
inline void ComputeReturn(lua_State *L, int returnDone)
{
if (returnDone <= 1) return;
if (returnDone == 2)
{
lua_newtable(L);
lua_pushinteger(L, 1);
lua_pushvalue(L, -4);
lua_settable(L, -3);
lua_pushinteger(L, 2);
lua_pushvalue(L, -3);
lua_settable(L, -3);
lua_remove(L, -2);
lua_remove(L, -2);
return;
}
lua_pushinteger(L, returnDone);
lua_pushvalue(L, -2);
lua_remove(L, -3);
lua_settable(L, -3);
}
/*********************** POP FUNCTIONS ***********************/
int PopFloatInTable(lua_State *L, char *name, float *val)
{
int returnVal = 0;
lua_pushstring(L, name);
lua_gettable(L, -2);
if (lua_isnumber(L, -1))
{
*val = (float)lua_tonumber(L, -1);
returnVal = 1;
}
lua_pop(L,1);
return returnVal;
}
int PopIntInTable(lua_State *L, char *name, int *val)
{
int returnVal = 0;
lua_pushstring(L, name);
lua_gettable(L, -2);
if (lua_isnumber(L, -1))
{
*val = (int)lua_tonumber(L, -1);
returnVal = 1;
}
lua_pop(L,1);
return returnVal;
}
int PopColor(lua_State *L, u32 *colorPtr, int luaParam)
{
int result = 1;
if (luaParam > 0)
lua_pushvalue(L, luaParam);
*colorPtr = 0;
if (lua_type(L, -1) == LUA_TSTRING)
{
char *color = (char *)lua_tostring(L, -1);
int colorLen = strlen(color);
int colorIdx = 0;
for (; colorIdx < colorLen &&
(('0' <= color[colorIdx] && color[colorIdx] <= '9') ||
('A' <= color[colorIdx] && color[colorIdx] <= 'F') ||
('a' <= color[colorIdx] && color[colorIdx] <= 'f')); colorIdx++);
if (colorIdx == colorLen)
{
if (colorLen == 8)
*colorPtr = (u32)((((IsHex(*(color + 0))-1)*16 + (IsHex(*(color + 1))-1)) << 24) +
((( IsHex(*(color + 2))-1)*16 + (IsHex(*(color + 3))-1)) << 16) +
((( IsHex(*(color + 4))-1)*16 + (IsHex(*(color + 5))-1)) << 8) +
((( IsHex(*(color + 6))-1)*16 + (IsHex(*(color + 7))-1)) ));
else if (colorLen == 6)
*colorPtr = (u32)(( 255 << 24) +
((( IsHex(*(color + 0))-1)*16 + (IsHex(*(color + 1))-1)) << 16) +
((( IsHex(*(color + 2))-1)*16 + (IsHex(*(color + 3))-1)) << 8) +
((( IsHex(*(color + 4))-1)*16 + (IsHex(*(color + 5))-1)) ));
else
result = 0;
} else
result = 0;
} else if (lua_istable(L, -1))
{
int R,G,B,A;
if (!result || !PopIntInTable(L, "R", &R)) result = 0;
if (!result || !PopIntInTable(L, "G", &G)) result = 0;
if (!result || !PopIntInTable(L, "B", &B)) result = 0;
if (!result || !PopIntInTable(L, "A", &A)) A = 255;
if (result)
*colorPtr = (A << 24) + (R << 16) + (G << 8) + B;
} else if (luaParam > 0)
{
int RGBA[4];
int curParam = luaParam;
RGBA[3] = 255;
for (int c=0; result && c<4; c++, curParam++)
{
if (lua_type(L, curParam) == LUA_TNUMBER)
{
lua_pop(L,1);
lua_pushvalue(L, curParam);
RGBA[c] = lua_tonumber(L, -1);
if (c) result++;
} else if (c < 3) result = 0;
}
if (result)
*colorPtr = (RGBA[3] << 24) + (RGBA[0] << 16) + (RGBA[1] << 8) + RGBA[2];
}
if (luaParam > 0)
lua_pop(L,1);
return result;
}
int PopPoint(lua_State *L, POINT *pointPtr, int luaParam)
{
BOOL result = 1;
if (luaParam > 0)
{
lua_pushvalue(L, luaParam);
luaL_checktype(L, luaParam, LUA_TTABLE);
} else
luaL_checktype(L, -1, LUA_TTABLE);
int pointParam;
if (!result || !PopIntInTable(L, "x", &pointParam)) result = 0;
pointPtr->x = pointParam;
if (!result || !PopIntInTable(L, "y", &pointParam)) result = 0;
pointPtr->y = pointParam;
if (luaParam > 0)
lua_pop(L,1);
return result;
}
/*** USER MATRIX POP ***/
int PopListInt(lua_State *L, int *resultList, int *nbElmts, int luaParam)
{
luaL_checktype(L, luaParam, LUA_TTABLE);
lua_pushvalue(L, luaParam);
*nbElmts = lua_objlen(L, -1);
for (int i=0; i<*nbElmts; i++)
{
lua_pushnumber(L, i+1);
lua_gettable(L, -2);
if (lua_isnumber(L, -1))
{
resultList[i] = (int)lua_tonumber(L, -1);
}
lua_pop(L,1);
}
lua_pop(L,1);
return *nbElmts;
}
int PopListFloat(lua_State *L, float *resultList, int *nbElmts, int luaParam)
{
luaL_checktype(L, luaParam, LUA_TTABLE);
lua_pushvalue(L, luaParam);
*nbElmts = lua_objlen(L, -1);
for (int i=0; i<*nbElmts; i++)
{
lua_pushnumber(L, i+1);
lua_gettable(L, -2);
if (lua_isnumber(L, -1))
{
resultList[i] = (float)lua_tonumber(L, -1);
}
lua_pop(L,1);
}
lua_pop(L,1);
return *nbElmts;
}
int PopListPoint(lua_State *L, POINT *resultList, int *nbElmts, int luaParam)
{
luaL_checktype(L, luaParam, LUA_TTABLE);
lua_pushvalue(L, luaParam);
*nbElmts = lua_objlen(L, -1);
for (int i=0; i<*nbElmts; i++)
{
lua_pushnumber(L, i+1);
lua_gettable(L, -2);
PopPoint(L, &resultList[i]);
lua_pop(L,1);
}
lua_pop(L,1);
return *nbElmts;
}
int PopListVector(lua_State *L, Vector *resultList, int *nbElmts, int luaParam)
{
luaL_checktype(L, luaParam, LUA_TTABLE);
lua_pushvalue(L, luaParam);
*nbElmts = lua_objlen(L, -1);
for (int i=0; i<*nbElmts; i++)
{
lua_pushnumber(L, i+1);
lua_gettable(L, -2);
PopVector(L, &resultList[i],-1);
lua_pop(L,1);
}
lua_pop(L,1);
return *nbElmts;
}
int PopListColor(lua_State *L, u32 *resultList, int *nbElmts, int luaParam)
{
luaL_checktype(L, luaParam, LUA_TTABLE);
lua_pushvalue(L, luaParam);
*nbElmts = lua_objlen(L, -1);
for (int i=0; i<*nbElmts; i++)
{
lua_pushnumber(L, i+1);
lua_gettable(L, -2);
PopColor(L, &resultList[i],-1);
lua_pop(L,1);
}
lua_pop(L,1);
return *nbElmts;
}
/*********************** POP FUNCTIONS ***********************/
/*********************** PUSH FUNCTIONS ***********************/
void SetStrFieldFloat(lua_State *L, const char *index, float value) {
lua_pushstring(L, index);
lua_pushnumber(L, (double)value);
//lua_settable(L, -3);
lua_rawset(L, -3);
}
void SetStrFieldInteger(lua_State *L, const char *index, int value) {
lua_pushstring(L, index);
lua_pushinteger(L, value);
//lua_settable(L, -3);
lua_rawset(L, -3);
}
void SetStrFieldString(lua_State *L, const char *index, char * value) {
lua_pushstring(L, index);
lua_pushstring(L, value);
//lua_settable(L, -3);
lua_rawset(L, -3);
}
void SetStrFieldFunction(lua_State *L, const char *index, lua_CFunction function) {
lua_pushstring(L, index);
lua_pushcfunction(L, function);
//lua_settable(L, -3);
lua_rawset(L, -3);
}
void SetStrFieldBoolean(lua_State *L, const char *index, bool value) {
lua_pushstring(L, index);
lua_pushboolean(L, value);
//lua_settable(L, -3);
lua_rawset(L, -3);
}
void PushBool(lua_State *L, BOOL value)
{
lua_pushboolean(L, value);
}
void PushInt(lua_State *L, int value)
{
lua_pushinteger(L, (double)value);
}
void PushFloat(lua_State *L, float value)
{
lua_pushnumber(L, (double)value);
}
void PushString(lua_State *L, char *string)
{
lua_pushstring(L, string);
}
void PushColor(lua_State *L, DWORD color)
{
//lua_newtable(L);
lua_createtable(L,0,4);
SetStrFieldFloat(L, "A", (float)((color & 0xFF000000) >> 24));
SetStrFieldFloat(L, "R", (float)((color & 0x00FF0000) >> 16));
SetStrFieldFloat(L, "G", (float)((color & 0x0000FF00) >> 8 ));
SetStrFieldFloat(L, "B", (float)((color & 0x000000FF) ));
}
void PushRectangle(lua_State *L, RECT *rectPtr)
{
//lua_newtable(L);
lua_createtable(L,0,4);
SetStrFieldFloat(L, "x", (float)rectPtr->left);
SetStrFieldFloat(L, "y", (float)rectPtr->top);
SetStrFieldFloat(L, "sx", (float)(rectPtr->right - rectPtr->left));
SetStrFieldFloat(L, "sy", (float)(rectPtr->bottom - rectPtr->top));
}
void PushTableInt(lua_State *L, int *tabList, int nbElmts)
{
//lua_newtable(L);
lua_createtable(L, nbElmts, 0);
for (int i=0; i<nbElmts; i++)
{
//lua_pushnumber(L, i+1);
//lua_pushnumber(L, (double)tabList[i]);
//lua_settable(L, -3);
lua_pushnumber(L, (double)tabList[i]);
lua_rawseti(L, -2, i+1);
}
}
void PushTableFloat(lua_State *L, float *tabList, int nbElmts)
{
//lua_newtable(L);
lua_createtable(L, nbElmts, 0);
for (int i=0; i<nbElmts; i++)
{
//lua_pushnumber(L, i+1);
//lua_pushnumber(L, (double)tabList[i]);
//lua_settable(L, -3);
lua_pushnumber(L, (double)tabList[i]);
lua_rawseti(L, -2, i+1);
}
}
void PushPoint(lua_State *L, POINT *pointPtr)
{
PushPoint(L, pointPtr->x, pointPtr->y);
}
void PushPoint(lua_State *L, float x, float y)
{
//lua_newtable(L);
lua_createtable(L, 0, 2);
SetStrFieldFloat(L, "x", x);
SetStrFieldFloat(L, "y", y);
}
void PushPoint(lua_State *L, int x, int y)
{
PushPoint(L, (float)x, (float)y);
}
void PushMouseInfo(lua_State *L, MouseInfo *mouseInfo)
{
//lua_newtable(L);
lua_createtable(L, 0, 4);
SetStrFieldFloat(L, "x", mouseInfo->x);
SetStrFieldFloat(L, "y", mouseInfo->y);
lua_pushstring(L, "keys");
lua_newtable(L);
if (mouseInfo->keys & MK_CONTROL)
SetStrFieldFloat(L, "control", 1);
if (mouseInfo->keys & MK_LBUTTON)
SetStrFieldFloat(L, "lbutton", 1);
if (mouseInfo->keys & MK_MBUTTON)
SetStrFieldFloat(L, "mbutton", 1);
if (mouseInfo->keys & MK_RBUTTON)
SetStrFieldFloat(L, "rbutton", 1);
if (mouseInfo->keys & MK_SHIFT)
SetStrFieldFloat(L, "shift", 1);
lua_settable(L, -3);
SetStrFieldFloat(L, "value", mouseInfo->value);
}
void PushIntEvent(lua_State *L, int value, float time)
{
//lua_newtable(L);
lua_createtable(L, 0, 2);
SetStrFieldFloat(L, "data", value);
SetStrFieldFloat(L, "time", time);
}
void PushFloatEvent(lua_State *L, float value, float time)
{
//lua_newtable(L);
lua_createtable(L, 0, 2);
SetStrFieldFloat(L, "data", value);
SetStrFieldFloat(L, "time", time);
}
void PushStringEvent(lua_State *L, char * value, float time)
{
//lua_newtable(L);
lua_createtable(L, 0, 2);
SetStrFieldString(L, "data", value);
SetStrFieldFloat(L, "time", time);
}
/*********************** PUSH FUNCTIONS ***********************/
/*********************** CLASS DEFINITIONS ***********************/
/*********************** VECTOR ***********************/
Vector *PopVectorPtr(lua_State *L, int luaParam)
{
int top = lua_gettop(L);
void *p = lua_touserdata(L, luaParam);
Vector *vPtr = NULL;
if (p == NULL) return NULL;
if (!lua_getmetatable(L, luaParam)) return NULL;
lua_getfield(L, LUA_REGISTRYINDEX, "VECTOR");
if (lua_rawequal(L, -1, -2))
vPtr = (Vector *)p;
else
{
lua_pop(L, 1);
lua_getfield(L, LUA_REGISTRYINDEX, "VECTOR_PTR");
if (lua_rawequal(L, -1, -2))
vPtr = *((Vector **)p);
}
lua_pop(L, 2);
return vPtr;
}
int PopVector(lua_State *L, Vector *vectorPtr, int luaParam)
{
Vector *vPtr = PopVectorPtr(L, luaParam);
if (vPtr == NULL) return 0;
memcpy(vectorPtr, vPtr, sizeof(Vector)); return 1;
}
void PushVector(lua_State *L, Vector *vectorPtr)
{
void *VectorUser = lua_newuserdata(L, sizeof(Vector));
if (!VectorUser) return;
memcpy(VectorUser, vectorPtr, sizeof(Vector));
luaL_getmetatable(L, "VECTOR");
lua_setmetatable (L, -2);
}
void PushVector(lua_State *L, char *vectorString)
{
Vector *vectorPtr = (Vector*)ZeroAlloc(sizeof(Vector));
if(sscanf(vectorString,"{x=%f,y=%f,z=%f}", &vectorPtr->x, &vectorPtr->y, &vectorPtr->z)==3)
PushVector(L,vectorPtr);
}
void PushVectorPtr(lua_State *L, Vector *vectorPtr)
{
void *VectorUserPtr = lua_newuserdata(L, sizeof(Vector *));
if (!VectorUserPtr) return;
*((Vector **)VectorUserPtr) = vectorPtr;
luaL_getmetatable(L, "VECTOR_PTR");
lua_setmetatable (L, -2);
}
int Vector_Index(lua_State *L)
{
Vector *vPtr;
if (!(vPtr = PopVectorPtr(L, 1)))
return 0;
const char *tableStr = luaL_checkstring(L, 2);
if (tableStr[1] == 0)
{
switch (*tableStr)
{
case 'x': lua_pushnumber(L, vPtr->x); return 1;
case 'y': lua_pushnumber(L, vPtr->y); return 1;
case 'z': lua_pushnumber(L, vPtr->z); return 1;
}
return 0;
}
if (!strcmp(tableStr, "Norm"))
{
lua_pushcfunction(L, Vector_Norm);
return 1;
}
if (!strcmp(tableStr, "SqrNorm"))
{
lua_pushcfunction(L, Vector_SqrNorm);
return 1;
}
if (!strcmp(tableStr, "Normalize"))
{
lua_pushcfunction(L, Vector_Normalize);
return 1;
}
if (!strcmp(tableStr, "Clone"))
{
lua_pushcfunction(L, Vector_Clone);
return 1;
}
return 0;
}
int Vector_NewIndex(lua_State *L)
{
Vector *vPtr;
if (!(vPtr = PopVectorPtr(L, 1)))
return 0;
const char *tableStr = luaL_checkstring(L, 2);
float number = luaL_checknumber(L, 3);
if (tableStr[1] != 0) return 0;
switch (*tableStr)
{
case 'x': vPtr->x = number; return 1;
case 'y': vPtr->y = number; return 1;
case 'z': vPtr->z = number; return 1;
}
return 0;
}
int Vector_Clone(lua_State *L)
{
Vector *vPtr;
if (!(vPtr = PopVectorPtr(L, 1))) return 0;
PushVector(L, vPtr);
return 1;
}
int Vector_ToString(lua_State *L)
{
Vector *vPtr;
char vStr[256];
if (!(vPtr = PopVectorPtr(L, 1))) return 0;
sprintf(vStr, "{x=%.2f,y=%.2f,z=%.2f}",
vPtr->x, vPtr->y, vPtr->z);
lua_pushstring(L, vStr); return 1;
}
int Vector_Add(lua_State *L)
{
Vector v1, *v2Ptr = NULL;
if (!PopVector(L, &v1, 1)) return 0;
if (lua_isnumber(L, 2))
{
v1 += lua_tonumber(L, -1);
PushVector(L, &v1); return 1;
}
if ((v2Ptr = PopVectorPtr(L, 2)) != NULL)
{
v1 = v1+*v2Ptr;
PushVector(L, &v1); return 1;
}
return 0;
}
int Vector_Sub(lua_State *L)
{
Vector v1, *v2Ptr = NULL;
if (!PopVector(L, &v1, 1)) return 0;
if (lua_isnumber(L, 2))
{
v1 += -lua_tonumber(L, -1);
PushVector(L, &v1); return 1;
} else if ((v2Ptr = PopVectorPtr(L, 2)) != NULL)
{
v1 = v1-*v2Ptr;
PushVector(L, &v1); return 1;
}
return 0;
}
int Vector_Mul(lua_State *L)
{
Vector v1, *v2Ptr = NULL;
if (!PopVector(L, &v1, 1)) return 0;
if (lua_isnumber(L, 2))
{
v1 = v1*lua_tonumber(L, -1);
PushVector(L, &v1); return 1;
} else if ((v2Ptr = PopVectorPtr(L, 2)) != NULL)
{
lua_pushnumber(L, v1**v2Ptr); return 1;
}
return 0;
}
int Vector_Pow(lua_State *L)
{
Vector v1, *v2Ptr = NULL;
if (!PopVector(L, &v1, 1) ||
!(v2Ptr = PopVectorPtr(L, 2))) return 0;
v1 = v1^(*v2Ptr);
PushVector(L, &v1); return 1;
}
int Vector_SqrNorm(lua_State *L)
{
Vector *v1Ptr;
if (!(v1Ptr = PopVectorPtr(L, 1))) return 0;
lua_pushnumber(L, v1Ptr->SqrNorm());
return 1;
}
int Vector_Norm(lua_State *L)
{
Vector *v1Ptr;
if (!(v1Ptr = PopVectorPtr(L, 1))) return 0;
lua_pushnumber(L, v1Ptr->Norm()); return 1;
}
int Vector_Normalize(lua_State *L)
{
Vector *v1Ptr = NULL;
if (!(v1Ptr = PopVectorPtr(L, 1))) return 0;
if (lua_gettop(L) > 1 && lua_toboolean(L, 2))
{
Vector v2 = *v1Ptr;
v2.Normalize();
PushVector(L, &v2);
} else
{
v1Ptr->Normalize();
PushVectorPtr(L, v1Ptr);
}
return 1;
}
static const luaL_reg Vector_meta[] = {
{"__index", Vector_Index},
{"__newindex", Vector_NewIndex},
{"__tostring", Vector_ToString},
{"__add", Vector_Add},
{"__sub", Vector_Sub},
{"__mul", Vector_Mul},
{"__pow", Vector_Pow},
{0, 0}
};
void Vector_Register(lua_State *L)
{
luaL_newmetatable(L, "VECTOR"); /* create metatable for Foo,
and add it to the Lua registry */
luaL_openlib(L, 0, Vector_meta, 0); /* fill metatable */
lua_pushliteral(L, "__metatable");
lua_pushvalue(L, -3); /* dup methods table*/
lua_rawset(L, -3); /* hide metatable:
metatable.__metatable = methods */
lua_pop(L, 1); /* drop metatable */
}
void VectorPtr_Register(lua_State *L)
{
luaL_newmetatable(L, "VECTOR_PTR"); /* create metatable for Foo,
and add it to the Lua registry */
luaL_openlib(L, 0, Vector_meta, 0); /* fill metatable */
lua_pushliteral(L, "__metatable");
lua_pushvalue(L, -3); /* dup methods table*/
lua_rawset(L, -3); /* hide metatable:
metatable.__metatable = methods */
lua_pop(L, 1); /* drop metatable */
}
/*********************** QUAT ***********************/
Quat *PopQuatPtr(lua_State *L, int luaParam)
{
int top = lua_gettop(L);
Quat *qPtr = NULL;
if (luaParam > 0)
{
lua_pushvalue(L, luaParam);
luaL_checktype(L, luaParam, LUA_TUSERDATA);
qPtr = (Quat *)luaL_checkudata(L, luaParam, "QUAT");
} else
{
luaL_checktype(L, -1, LUA_TUSERDATA);
qPtr = (Quat *)luaL_checkudata(L, luaParam, "QUAT");
}
if (qPtr == NULL) luaL_typerror(L, luaParam, "QUAT");
return qPtr;
}
int PopQuat(lua_State *L, Quat *quatPtr, int luaParam)
{
Quat *qPtr = PopQuatPtr(L, luaParam);
if (qPtr == NULL) return 0;
memcpy(quatPtr, qPtr, sizeof(Quat));
return 1;
}
void PushQuat(lua_State *L, Quat *quatPtr)
{
void *QuatUser = lua_newuserdata(L, sizeof(Quat));
if (!QuatUser) return;
memcpy(QuatUser, quatPtr, sizeof(Quat));
luaL_getmetatable(L, "QUAT");
lua_setmetatable (L, -2);
}
void PushQuat(lua_State *L, char *qStr)
{
Quat *qPtr = (Quat*)ZeroAlloc(sizeof(Quat));
if(4==sscanf(qStr, "{x=%f,y=%f,z=%f,w=%f}",
&qPtr->x, &qPtr->y, &qPtr->z, &qPtr->w))
{
PushQuat(L, qPtr);
}
}
int Quat_Clone(lua_State *L)
{
Quat *qPtr;
if (!(qPtr = PopQuatPtr(L, 1))) return 0;
PushQuat(L, qPtr);
return 1;
}
int Quat_Index(lua_State *L)
{
Quat *qPtr;
if (!(qPtr = PopQuatPtr(L, 1)))
return 0;
const char *tableStr = luaL_checkstring(L, 2);
if (tableStr[1] == 0)
{
switch (*tableStr)
{
case 'x': lua_pushnumber(L, qPtr->x); return 1;
case 'y': lua_pushnumber(L, qPtr->y); return 1;
case 'z': lua_pushnumber(L, qPtr->z); return 1;
case 'w': lua_pushnumber(L, qPtr->w); return 1;
}
return 0;
}
if (!strcmp(tableStr, "Normalize"))
{
lua_pushcfunction(L, Quat_Normalize);
return 1;
}
if (!strcmp(tableStr, "NormalizeW"))
{
lua_pushcfunction(L, Quat_NormalizeW);
return 1;
}
if (!strcmp(tableStr, "Clone"))
{
lua_pushcfunction(L, Quat_Clone);
return 1;
}
return 0;
}
int Quat_NewIndex(lua_State *L)
{
Quat *qPtr;
if (!(qPtr = PopQuatPtr(L, 1)))
return 0;
const char *tableStr = luaL_checkstring(L, 2);
float number = luaL_checknumber(L, 3);
if (tableStr[1] != 0) return 0;
switch (*tableStr)
{
case 'x': qPtr->x = number; return 1;
case 'y': qPtr->y = number; return 1;
case 'z': qPtr->z = number; return 1;
case 'w': qPtr->w = number; return 1;
}
return 0;
}
int Quat_ToString(lua_State *L)
{
Quat *qPtr;
char qStr[256];
if (!(qPtr = PopQuatPtr(L, 1))) return 0;
sprintf(qStr, "{x=%.2f,y=%.2f,z=%.2f,w=%.2f}",
qPtr->x, qPtr->y, qPtr->z, qPtr->w);
lua_pushstring(L, qStr); return 1;
}
int Quat_Add(lua_State *L)
{
Quat q1, *q2Ptr = NULL;
if (!PopQuat(L, &q1, 1) ||
!(q2Ptr = PopQuatPtr(L, 2))) return 0;
q1 = q1+*q2Ptr;
PushQuat(L, &q1);
return 1;
}
int Quat_Mul(lua_State *L)
{
Quat q1, *q2Ptr = NULL;
if (!PopQuat(L, &q1, 1)) return 0;
if (lua_isnumber(L, 2))
{
q1 = q1*lua_tonumber(L, 2);
PushQuat(L, &q1); return 1;
} else if ((q2Ptr = PopQuatPtr(L, 2)) != NULL)
{
q1 *= *q2Ptr;
PushQuat(L, &q1); return 1;
}
return 0;
}
int Quat_Normalize(lua_State *L)
{
Quat *q1Ptr = NULL;
if (!(q1Ptr = PopQuatPtr(L, 1))) return 0;
q1Ptr->Normalize();
PushQuat(L, q1Ptr); return 1;
}
int Quat_NormalizeW(lua_State *L)
{
Quat *q1Ptr = NULL;
if (!(q1Ptr = PopQuatPtr(L, 1))) return 0;
q1Ptr->NormalizeW();
PushQuat(L, q1Ptr); return 1;
}
static const luaL_reg Quat_meta[] = {
{"__index", Quat_Index},
{"__newindex", Quat_NewIndex},
{"__tostring", Quat_ToString},
{"__add", Quat_Add},
{"__mul", Quat_Mul},
{0, 0}
};
void Quat_Register(lua_State *L)
{
luaL_newmetatable(L, "QUAT"); /* create metatable for Foo,
and add it to the Lua registry */
luaL_openlib(L, 0, Quat_meta, 0); /* fill metatable */
lua_pushliteral(L, "__metatable");
lua_pushvalue(L, -3); /* dup methods table*/
lua_rawset(L, -3); /* hide metatable:
metatable.__metatable = methods */
lua_pop(L, 1); /* drop metatable */
}
/*********************** MATRIX **************************/
MATRIX *PopMatrixPtr(lua_State *L, int luaParam)
{
int top = lua_gettop(L);
MATRIX *mPtr = NULL;
if (luaParam > 0)
{
lua_pushvalue(L, luaParam);
luaL_checktype(L, luaParam, LUA_TUSERDATA);
mPtr = (MATRIX *)luaL_checkudata(L, luaParam, "MATRIX");
} else
{
luaL_checktype(L, -1, LUA_TUSERDATA);
mPtr = (MATRIX *)luaL_checkudata(L, luaParam, "MATRIX");
}
if (mPtr == NULL) luaL_typerror(L, luaParam, "MATRIX");
return mPtr;
}
int PopMatrix(lua_State *L, MATRIX *matrixPtr, int luaParam)
{
MATRIX *mPtr = PopMatrixPtr(L, luaParam);
if (mPtr == NULL)
return 0;
memcpy(matrixPtr, mPtr, sizeof(MATRIX));
return 1;
}
void PushMatrix(lua_State *L, MATRIX *matrixPtr)
{
void *MatrixUser = lua_newuserdata(L, sizeof(MATRIX));
if (!MatrixUser) return;
memcpy(MatrixUser, matrixPtr, sizeof(MATRIX));
luaL_getmetatable(L, "MATRIX");
//lua_getglobal(L, "MATRIX");
lua_setmetatable (L, -2);
}
void PushMatrix(lua_State *L, char *matrixString)
{
MATRIX *mPtr = (MATRIX*)ZeroAlloc(sizeof(MATRIX));
if(12==sscanf(matrixString, "{I={x=%f,y=%f,z=%f},J={x=%f,y=%f,z=%f},K={x=%f,y=%f,z=%f},T={x=%f,y=%f,z=%f}}",
&mPtr->I.x, &mPtr->I.y, &mPtr->I.z,
&mPtr->J.x, &mPtr->J.y, &mPtr->J.z,
&mPtr->K.x, &mPtr->K.y, &mPtr->K.z,
&mPtr->T.x, &mPtr->T.y, &mPtr->T.z))
{
PushMatrix(L, mPtr);
}
}
int Matrix_Clone(lua_State *L)
{
MATRIX *mPtr;
if (!(mPtr = PopMatrixPtr(L, 1))) return 0;
PushMatrix(L, mPtr);
return 1;
}
#define MATRIX_FLOAT_SETGET(Vct,Wct) \
int Matrix_Set##Vct##Wct(lua_State *L) \
{ \
MATRIX *mPtr = NULL; \
float number= 0; \
if (!(mPtr = PopMatrixPtr(L, 1))) return 0; \
number = luaL_checknumber(L, 2); \
mPtr->Vct.Wct = number; return 1; \
} \
int Matrix_Get##Vct##Wct(lua_State *L) \
{ \
MATRIX *mPtr = NULL; \
if (!(mPtr = PopMatrixPtr(L, 1))) return 0; \
lua_pushnumber(L, mPtr->Vct.Wct); return 1; \
}
#define PUSH_SETGET(Vct, Wct) \
if (tableStr[0] == 'S' && tableStr[3] == *#Vct && tableStr[4] == *#Wct) \
{ lua_pushcfunction(L, Matrix_Set##Vct##Wct); return 1; } \
if (tableStr[0] == 'G' && tableStr[3] == *#Vct && tableStr[4] == *#Wct) \
{ lua_pushcfunction(L, Matrix_Get##Vct##Wct); return 1; }
MATRIX_FLOAT_SETGET(I,x)
MATRIX_FLOAT_SETGET(I,y)
MATRIX_FLOAT_SETGET(I,z)
MATRIX_FLOAT_SETGET(J,x)
MATRIX_FLOAT_SETGET(J,y)
MATRIX_FLOAT_SETGET(J,z)
MATRIX_FLOAT_SETGET(K,x)
MATRIX_FLOAT_SETGET(K,y)
MATRIX_FLOAT_SETGET(K,z)
MATRIX_FLOAT_SETGET(T,x)
MATRIX_FLOAT_SETGET(T,y)
MATRIX_FLOAT_SETGET(T,z)
int Matrix_Index(lua_State *L)
{
MATRIX *mPtr;
if (!(mPtr = PopMatrixPtr(L, 1)))
return 0;
const char *tableStr = luaL_checkstring(L, 2);
if (tableStr[1] == 0)
{
switch (*tableStr)
{
case 'I': PushVectorPtr(L, &mPtr->I); return 1;
case 'J': PushVectorPtr(L, &mPtr->J); return 1;
case 'K': PushVectorPtr(L, &mPtr->K); return 1;
case 'T': PushVectorPtr(L, &mPtr->T); return 1;
}
return 0;
}
if (!strcmp(tableStr, "Clone"))
{
lua_pushcfunction(L, Matrix_Clone);
return 1;
}
if (strlen(tableStr) == 5)
{
PUSH_SETGET(I,x)
PUSH_SETGET(I,y)
PUSH_SETGET(I,z)
PUSH_SETGET(J,x)
PUSH_SETGET(J,y)
PUSH_SETGET(J,z)
PUSH_SETGET(K,x)
PUSH_SETGET(K,y)
PUSH_SETGET(K,z)
PUSH_SETGET(T,x)
PUSH_SETGET(T,y)
PUSH_SETGET(T,z)
}
return 0;
}
int Matrix_NewIndex(lua_State *L)
{
MATRIX *mPtr = PopMatrixPtr(L, 1);
if (!mPtr) return 0;
const char *tableStr = luaL_checkstring(L, 2);
if (tableStr[1] != 0) return 0;
Vector *vPtr = PopVectorPtr(L, 3);
if (!vPtr) return 0;
switch (*tableStr)
{
case 'I': mPtr->I = *vPtr; return 1;
case 'J': mPtr->J = *vPtr; return 1;
case 'K': mPtr->K = *vPtr; return 1;
case 'T': mPtr->T = *vPtr; return 1;
}
return 0;
}
int Matrix_ToString(lua_State *L)
{
MATRIX *mPtr;
char mStr[512];
if (!(mPtr = PopMatrixPtr(L, 1))) return 0;
sprintf(mStr, "{I={x=%.2f,y=%.2f,z=%.2f},J={x=%.2f,y=%.2f,z=%.2f},K={x=%.2f,y=%.2f,z=%.2f},T={x=%.2f,y=%.2f,z=%.2f}}",
mPtr->I.x, mPtr->I.y, mPtr->I.z, mPtr->J.x, mPtr->J.y, mPtr->J.z, mPtr->K.x, mPtr->K.y, mPtr->K.z, mPtr->T.x, mPtr->T.y, mPtr->T.z);
lua_pushstring(L, mStr); return 1;
}
int Matrix_Mul(lua_State *L)
{
MATRIX m1, *m2Ptr;
Vector v1;
if (!PopMatrix(L, &m1, 1)) return 0;
if (PopVector(L, &v1, 2))
{
v1 = m1*v1;
PushVector(L, &v1);
return 1;
}
if ((m2Ptr = PopMatrixPtr(L, 2)) != NULL)
{
m1 *= *m2Ptr;
PushMatrix(L, &m1);
return 1;
}
return 0;
}
#define MATRIX_VECTOR_SETGET(Vct) \
int Matrix_Set##Vct(lua_State *L) \
{ \
MATRIX * mPtr = NULL; \
Vector * vPtr = NULL; \
if (!(mPtr = PopMatrixPtr(L, 1)) || !(vPtr = PopVectorPtr(L, 2))) return 0; \
mPtr->Vct = *vPtr; return 1; \
} \
int Matrix_Get##Vct(lua_State *L) \
{ \
MATRIX * mPtr = NULL; \
if (!(mPtr = PopMatrixPtr(L, 1))) return 0; \
PushVector(L, &mPtr->Vct); return 1; \
} \
int Matrix_GetPtr##Vct(lua_State *L) \
{ \
MATRIX * mPtr = NULL; \
if (!(mPtr = PopMatrixPtr(L, 1))) return 0; \
PushVectorPtr(L, &mPtr->Vct); return 1; \
}
#define MATRIX_VECTOR_DECLARE(Vct) \
{"Set"#Vct, Matrix_Set##Vct}, \
{"Get"#Vct, Matrix_Get##Vct}, \
{"GetPtr"#Vct, Matrix_GetPtr##Vct},
#define MATRIX_FLOAT_DECLARE(Vct,Wct) \
{"Set"#Vct#Wct, Matrix_Set##Vct##Wct}, \
{"Get"#Vct#Wct, Matrix_Get##Vct##Wct},
static const luaL_reg Matrix_meta[] = {
{"__mul", Matrix_Mul},
{"__index", Matrix_Index},
{"__newindex", Matrix_NewIndex},
{"__tostring", Matrix_ToString},
{0, 0}
};
void Matrix_Register(lua_State *L)
{
luaL_newmetatable(L, "MATRIX");
luaL_openlib(L, 0, Matrix_meta, 0); /* fill metatable */
lua_pushliteral(L, "__metatable");
lua_pushvalue(L, -3); /* dup methods table*/
lua_rawset(L, -3); /* hide metatable:
metatable.__metatable = methods */
lua_pop(L, 1); /* drop metatable */
}
/*********************** CLASS DEFINITIONS ***********************/
/*********************** CONVERSTION FUNCTIONS ***********************/
BOOL IsTableBase(lua_State *L)
{
BOOL isBase = true;
int index = 1;
lua_pushnil(L); /* first key */
while (isBase && lua_next(L, -2) != 0)
{
isBase = lua_isnumber(L, -2) && lua_tonumber(L, -2) == index;
index++;
lua_pop(L, 1);
}
if (!isBase)
lua_pop(L, 1);
return isBase;
}
static int curLevel;
static int maxLevel = 512;
static void **levelsPtr = NULL;
//#define EVENT_CONFLICT
#ifdef EVENT_CONFLICT
static char **levelsCharsPtr = NULL;
#endif
char *TableToStringRec(lua_State *L, char *bufferPtr, bool isTableBase, int precision, int *remaningLen)
{
BOOL isFirst = true;
BOOL isNumber;
char *tmpBufferPtr;
static char tmpBuffer[2048];
static void *tmpLevels[512];
if (curLevel >= 512)
return bufferPtr;
tmpLevels[curLevel] = (void *)lua_topointer(L, -1);
for (int lvlIdx=0; lvlIdx<curLevel; lvlIdx++)
{
if (tmpLevels[lvlIdx] == tmpLevels[curLevel])
{
tmpLevels[curLevel] = NULL;
break;
}
}
if (tmpLevels[curLevel] == NULL)
{
if ((*remaningLen) > strlen("rec_val"))
{
(*remaningLen) -= strlen("rec_val");
strcpy(bufferPtr, "rec_val");
bufferPtr += strlen(bufferPtr);
} else *remaningLen = 0;
lua_pop(L, 1);
return bufferPtr;
} else
{
curLevel++;
}
lua_pushnil(L); /* first key */
while (lua_next(L, -2) != 0 && *remaningLen > 0 ) {
/* uses 'key' (at index -2) and 'value' (at index -1) */
if (lua_isfunction(L, -1))
{
lua_pop(L, 1);
continue;
}
if (isFirst) isFirst = false;
else {
if (*remaningLen > strlen(","))
{
strcpy(bufferPtr, ","); (*remaningLen)-= strlen(","); bufferPtr += strlen(bufferPtr);
} else *remaningLen = 0;
}
if (!isTableBase)
{
lua_pushvalue(L, -2);
if ((*remaningLen) > strlen(lua_tostring(L, -1)))
{
(*remaningLen) -= strlen(lua_tostring(L, -1)) + 1;
sprintf(bufferPtr, "%s=", lua_tostring(L, -1));
bufferPtr += strlen(bufferPtr);
} else *remaningLen = 0;
lua_pop(L, 1);
}
if (lua_istable(L, -1))
{
if (*remaningLen > strlen("{"))
{
strcpy(bufferPtr, "{"); *remaningLen -= strlen(bufferPtr); bufferPtr += strlen(bufferPtr);
} else *remaningLen = 0;
bufferPtr = TableToStringRec(L, bufferPtr, IsTableBase(L), precision, remaningLen);
if (*remaningLen > strlen("}"))
{
strcpy(bufferPtr, "}"); *remaningLen -= strlen(bufferPtr); bufferPtr += strlen(bufferPtr);
} else *remaningLen = 0;
} else
{
float number = 0;
tmpBufferPtr = tmpBuffer;
if (precision >= 0 && lua_isnumber(L, -1))
{
number = lua_tonumber(L, -1);
if (number == (float)((int)number))
number = 0;
}
if (number)
{
char precisionStr[64];
sprintf(precisionStr, "%%.%if", precision);
sprintf(tmpBuffer, precisionStr, number);
} else
{
if (luaL_callmeta(L, -1, "__tostring"))
{
strcpy(tmpBuffer, lua_tostring(L, -1));
lua_pop(L, 1);
} else {
switch (lua_type(L, -1)) {
case LUA_TNUMBER:
strcpy(tmpBuffer, lua_tostring(L, -1));
break;
case LUA_TSTRING:
strcpy(tmpBuffer, lua_tostring(L, -1));
break;
case LUA_TBOOLEAN:
strcpy(tmpBuffer, (lua_toboolean(L, -1) ? "true" : "false"));
break;
case LUA_TNIL:
strcpy(tmpBuffer, "nil");
break;
default:
sprintf(tmpBuffer, "%s: %p", luaL_typename(L, -1), lua_topointer(L, -1));
break;
}
}
}
if (*remaningLen > strlen(tmpBufferPtr))
{
strcpy(bufferPtr, tmpBufferPtr);
*remaningLen -= strlen(tmpBufferPtr);
bufferPtr += strlen(bufferPtr);
} else *remaningLen = 0;
lua_pop(L, 1);
}
}
lua_pop(L, 1);
return bufferPtr;
}
int TableToString(lua_State *L, int tableIndex)
{
static char buffer[4096];
int remaningLen = 1920;
char *bufferPtr = buffer;
int precision = -1;
if (!lua_istable(L, tableIndex))
{
if (luaL_callmeta(L, tableIndex, "__tostring"))
return 1;
switch (lua_type(L, tableIndex)) {
case LUA_TNUMBER:
lua_pushstring(L, lua_tostring(L, tableIndex));
break;
case LUA_TSTRING:
lua_pushvalue(L, tableIndex);
break;
case LUA_TBOOLEAN:
lua_pushstring(L, (lua_toboolean(L, tableIndex) ? "true" : "false"));
break;
case LUA_TNIL:
lua_pushliteral(L, "nil");
break;
default:
lua_pushfstring(L, "%s: %p", luaL_typename(L, tableIndex), lua_topointer(L, 1));
break;
}
return 1;
}
if (tableIndex == -2 || lua_gettop(L) == 2)
{
precision = luaL_checknumber(L, -1);
lua_pop(L, 1);
}
strcpy(bufferPtr, "{"); bufferPtr += strlen(bufferPtr);
curLevel = 0;
bufferPtr = TableToStringRec(L, bufferPtr, IsTableBase(L), precision, &remaningLen);
if (remaningLen <= 0)
{
strcpy(bufferPtr, "...");
precision = strlen(buffer);
}
else
strcpy(bufferPtr, "}");
lua_pushstring(L, buffer);
return 1;
}
int TableToString(lua_State *L)
{
return TableToString(L, 1);
}
/**********************************************************************************************/
/***** FILE SEARCH ****************************************************************************/
/**********************************************************************************************/
int PushSystemTime(lua_State *L, SYSTEMTIME sysTime);
int PushFileTime(lua_State *L, FILETIME time)
{
SYSTEMTIME sysTime;
FileTimeToSystemTime(&time, &sysTime);
return PushSystemTime(L, sysTime);
}
int PushSystemTime(lua_State *L, SYSTEMTIME sysTime)
{
lua_newtable(L);
lua_pushstring(L, "year");
lua_pushnumber(L, sysTime.wYear);
lua_settable(L, -3);
lua_pushstring(L, "month");
lua_pushnumber(L, sysTime.wMonth);
lua_settable(L, -3);
lua_pushstring(L, "day");
lua_pushnumber(L, sysTime.wDay);
lua_settable(L, -3);
lua_pushstring(L, "hour");
lua_pushnumber(L, sysTime.wHour);
lua_settable(L, -3);
lua_pushstring(L, "minute");
lua_pushnumber(L, sysTime.wMinute);
lua_settable(L, -3);
lua_pushstring(L, "second");
lua_pushnumber(L, sysTime.wSecond);
lua_settable(L, -3);
lua_pushstring(L, "milliseconds");
lua_pushnumber(L, sysTime.wMilliseconds);
lua_settable(L, -3);
return 1;
}
bool CheckFocus()
{
#ifdef ONLINE_MODE
// return ((GetFocus() == TheScene->OwnerHwnd) || Account.logInPageHasFocus() || Account.shopHasFocus() || Account.youupPugPageHasFocus() /*|| Account.uploadBrowserHasFocus()*/);
bool focusTestOld = (GetFocus() == TheScene->OwnerHwnd) || Account.logInPageHasFocus() || Account.shopHasFocus() || Account.youupPugPageHasFocus() /*|| Account.uploadBrowserHasFocus()*/;
bool focusTestNew = GetForegroundWindow() == TheScene->OwnerHwnd;
if (focusTestNew && !focusTestOld)
SetFocus(TheScene->OwnerHwnd);
return focusTestNew;
#else
return (GetFocus() == TheScene->OwnerHwnd);
#endif
}
int EnumFilesRec(lua_State *L, char *dirname, char *ext, BOOL recursiv, BOOL fullInfo)
{
char dirSearch[1024];
char fileExt[64];
HANDLE fileFind;
WIN32_FIND_DATA fileData;
sprintf(dirSearch, "%s\\*.*", dirname);
fileFind = FindFirstFile(dirSearch, &fileData);
if (fileFind == INVALID_HANDLE_VALUE) return 0;
int index = 1;
do {
if (fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
if (recursiv && strcmp(".", fileData.cFileName) && strcmp("..", fileData.cFileName))
{
char dirNameIn[1024];
sprintf(dirNameIn, "%s\\%s", dirname, fileData.cFileName);
lua_pushstring(L, fileData.cFileName);
lua_newtable(L);
EnumFilesRec(L, dirNameIn, ext, recursiv, fullInfo);
lua_settable(L, -3);
}
} else
{
if (ext)
{
strcpy(fileExt, fileData.cFileName + strlen(fileData.cFileName) - strlen(ext));
strlwr(fileExt);
if (strcmp(fileExt, ext))
continue;
}
lua_pushinteger(L, index++);
if (fullInfo)
{
lua_newtable(L);
lua_pushfstring(L, "name");
lua_pushfstring(L, fileData.cFileName);
lua_settable(L, -3);
lua_pushfstring(L, "creationTime");
PushFileTime(L, fileData.ftCreationTime);
lua_settable(L, -3);
lua_pushfstring(L, "writeTime");
PushFileTime(L, fileData.ftLastWriteTime);
lua_settable(L, -3);
lua_pushfstring(L, "size");
lua_pushnumber(L, fileData.nFileSizeLow);
lua_settable(L, -3);
} else
{
lua_pushfstring(L, fileData.cFileName);
}
lua_settable(L, -3);
}
} while (FindNextFile(fileFind, &fileData));
return 1;
}
int EnumFiles(lua_State *L)
{
if (lua_gettop(L) < 1 || !lua_tostring(L, 1))
return 0;
char *dirname = (char *)lua_tostring(L, 1);
char extData[128];
char *ext = NULL;
int recursiv = 0;
int fullInfo = 0;
if (lua_gettop(L) > 1)
recursiv = (int)lua_tonumber(L, 2);
if (lua_gettop(L) > 2 && lua_tostring(L, 3) && *lua_tostring(L, 3))
{
strcpy(extData, lua_tostring(L, 3));
strlwr(extData);
ext = extData;
}
if (lua_gettop(L) > 3)
fullInfo = lua_tonumber(L, 4);
lua_newtable(L);
EnumFilesRec(L, dirname, ext, recursiv, fullInfo);
return 1;
}
/**********************************************************************************************/
/***** INI VALUE ******************************************************************************/
/**********************************************************************************************/
extern char CamcamCCM[];
int IniLoad(lua_State *L)
{
int nbArgs = lua_gettop(L);
int saveRet;
switch (nbArgs)
{
case 0 :
saveRet = TheScene->LoadIniFile(CamcamCCM);
lua_pushboolean(L, saveRet >= 0);
return 1;
break;
default :
if(lua_isstring(L,1))
{
char destFile[2048] = "";
strcpy(destFile, lua_tostring(L, 1));
destFile[strlen(lua_tostring(L, 1))] = 0;
if(strlen(destFile)<4 || strcmp(".ccm", strlwr(destFile+strlen(destFile)-4))!=0)
{
strcpy(destFile, lua_tostring(L, 1));
destFile[strlen(lua_tostring(L, 1))] = 0;
strcat(destFile, ".ccm");
destFile[4+strlen(lua_tostring(L, 1))] = 0;
}
else
{
strcpy(destFile, lua_tostring(L, 1));
destFile[strlen(lua_tostring(L, 1))] = 0;
}
saveRet = TheScene->LoadIniFile(destFile);
lua_pushboolean(L, saveRet >= 0);
return 1;
}
else
{
lua_pushboolean(L, false);
return 1;
}
break;
}
}
int IniSave(lua_State *L)
{
int nbArgs = lua_gettop(L);
int saveRet;
switch (nbArgs)
{
case 0 :
saveRet = TheScene->SaveIniFile(CamcamCCM);
lua_pushboolean(L, saveRet >= 0);
return 1;
break;
default :
if(lua_isstring(L,1))
{
char destFile[2048] = "";
strcpy(destFile, lua_tostring(L, 1));
destFile[strlen(lua_tostring(L, 1))] = 0;
if(strlen(destFile)<4 || strcmp(".ccm", strlwr(destFile+strlen(destFile)-4))!=0)
{
strcpy(destFile, lua_tostring(L, 1));
destFile[strlen(lua_tostring(L, 1))] = 0;
strcat(destFile, ".ccm");
destFile[4+strlen(lua_tostring(L, 1))] = 0;
}
else
{
strcpy(destFile, lua_tostring(L, 1));
destFile[strlen(lua_tostring(L, 1))] = 0;
}
saveRet = TheScene->SaveIniFile(destFile);
lua_pushboolean(L, saveRet >= 0);
return 1;
}
else
{
lua_pushboolean(L, false);
return 1;
}
break;
}
}
int IniDestroy(lua_State *L)
{
int nbArgs = lua_gettop(L);
int saveRet;
switch (nbArgs)
{
case 0 :
saveRet = TheScene->DestroyIniFile(CamcamCCM);
lua_pushboolean(L, saveRet >= 0);
return 1;
default :
saveRet = TheScene->DestroyIniFile((char *)luaL_checkstring(L,1));
lua_pushboolean(L, saveRet >= 0);
return 1;
}
return 0;
}
int IniValueDel(lua_State *L)
{
char iniFile[2048];
strcpy(iniFile, CamcamCCM);
if(lua_gettop(L)==0 || (lua_gettop(L)>0 && !lua_isstring(L,1))) return false;
char completedVarname[2048] = ".";
if(lua_tostring(L,1)[0]!='.')
{
strcat(completedVarname, lua_tostring(L,1));
completedVarname[strlen(lua_tostring(L,1))+1] = 0;
}
else
{
strcpy(completedVarname, lua_tostring(L,1));
}
if(lua_gettop(L)==2)
{
if(!lua_isstring(L,2)) return false;
strcpy(iniFile, lua_tostring(L, 2));
iniFile[strlen(lua_tostring(L, 2))] = 0;
if(strlen(iniFile)<4 || strcmp(".ccm", strlwr(iniFile+strlen(iniFile)-4))!=0)
{
strcpy(iniFile, lua_tostring(L, 2));
iniFile[strlen(lua_tostring(L, 2))] = 0;
strcat(iniFile, ".ccm");
iniFile[4+strlen(lua_tostring(L, 2))] = 0;
}
else
{
strcpy(iniFile, lua_tostring(L, 2));
iniFile[strlen(lua_tostring(L, 2))] = 0;
}
}
if (TheScene->IniFileDico.IsExist(iniFile) == -1 && TheScene->LoadIniFile(iniFile) == -1)
return false;
u32 ID;
UnicID mUID;
TheScene->IniFileDico.GetUnic(&mUID,iniFile);
ID = TheScene->IniFileDico.mpst_Dico[mUID].AssociatedValue;
INIFILE* inifile = &(TheScene->IniFiles[ID]);
if(inifile->variableDico.IsExist(completedVarname)!=-1)
{
inifile->delVariable(completedVarname);
return true;
}
if(strcmp(completedVarname,".")==0)
{
u32 currentChild = inifile->root;
u32 nextChild = -1;
while(currentChild!=-1)
{
nextChild = inifile->variables[currentChild].next;
inifile->delVariable(inifile->variables[currentChild].name);
currentChild = nextChild;
}
return true;
}
return false;
}
int IniValueDelOld(lua_State *L)
{
char iniFile[2048] = "Camcam.ini";
if(lua_gettop(L)==0 || (lua_gettop(L)>0 && !lua_isstring(L,1))) return false;
char completedVarname[2048] = ".";
if(lua_tostring(L,1)[0]!='.')
{
strcat(completedVarname, lua_tostring(L,1));
completedVarname[strlen(lua_tostring(L,1))+1] = 0;
}
else
{
strcpy(completedVarname, lua_tostring(L,1));
}
if(lua_gettop(L)==2)
{
if(!lua_isstring(L,2)) return false;
strcpy(iniFile, lua_tostring(L, 2));
iniFile[strlen(lua_tostring(L, 2))] = 0;
if(strlen(iniFile)<4 || strcmp(".ini", strlwr(iniFile+strlen(iniFile)-4))!=0)
{
strcpy(iniFile, lua_tostring(L, 2));
iniFile[strlen(lua_tostring(L, 2))] = 0;
strcat(iniFile, ".ini");
iniFile[4+strlen(lua_tostring(L, 2))] = 0;
}
else
{
strcpy(iniFile, lua_tostring(L, 2));
iniFile[strlen(lua_tostring(L, 2))] = 0;
}
}
if (TheScene->IniFileDico.IsExist(iniFile) == -1 && TheScene->LoadIniFile(iniFile) == -1)
return false;
u32 ID;
UnicID mUID;
TheScene->IniFileDico.GetUnic(&mUID,iniFile);
ID = TheScene->IniFileDico.mpst_Dico[mUID].AssociatedValue;
INIFILE* inifile = &(TheScene->IniFiles[ID]);
if(inifile->variableDico.IsExist(completedVarname)!=-1)
{
inifile->delVariable(completedVarname);
return true;
}
if(strcmp(completedVarname,".")==0)
{
u32 currentChild = inifile->root;
while(currentChild!=-1)
{
inifile->delVariable(inifile->variables[currentChild].name);
currentChild = inifile->variables[currentChild].next;
}
return true;
}
return false;
}
void IniValueGetRec(lua_State *L, INI_VARIABLE* variables, u32 ID)
{
if(variables[ID].child==-1)
{
bool knownFound = false;
if(strlen(variables[ID].value)>=3)
{
if(strcmp(" #s", variables[ID].value+strlen(variables[ID].value)-3)==0)
{
char value[2048];
strcpy(value, variables[ID].value);
value[strlen(variables[ID].value)-3] = 0;
PushString(L, value);
knownFound = true;
}
if(strcmp(" #b", variables[ID].value+strlen(variables[ID].value)-3)==0)
{
if(strcmp("true #b", variables[ID].value)==0)
{
PushBool(L, true);
}
else
{
PushBool(L, false);
}
knownFound = true;
}
if(strcmp(" #n", variables[ID].value+strlen(variables[ID].value)-3)==0)
{
char value[2048];
strcpy(value, variables[ID].value);
value[strlen(variables[ID].value)-3] = 0;
lua_pushnumber(L, (double)atof(value));
knownFound = true;
}
if(strcmp(" #v", variables[ID].value+strlen(variables[ID].value)-3)==0)
{
char value[2048];
strcpy(value, variables[ID].value);
value[strlen(variables[ID].value)-3] = 0;
PushVector(L, value);
knownFound = true;
}
if(strcmp(" #m", variables[ID].value+strlen(variables[ID].value)-3)==0)
{
char value[2048];
strcpy(value, variables[ID].value);
value[strlen(variables[ID].value)-3] = 0;
PushMatrix(L, value);
knownFound = true;
}
if(strcmp(" #q", variables[ID].value+strlen(variables[ID].value)-3)==0)
{
char value[2048];
strcpy(value, variables[ID].value);
value[strlen(variables[ID].value)-3] = 0;
PushQuat(L, value);
knownFound = true;
}
if(strcmp("nil #0", variables[ID].value)==0)
{
lua_pushnil(L);
knownFound = true;
}
if(strcmp("{} #0", variables[ID].value)==0)
{
lua_newtable(L);
knownFound = true;
}
}
if(!knownFound)
{
char value[2048];
strcpy(value, variables[ID].value);
PushString(L, value);
}
}
else
{
lua_newtable(L);
u32 currentChild = variables[ID].child;
do
{
char key[2048] = "";
strcpy(key, strrchr(variables[currentChild].name, '.')+1);
if(key[strlen(key)-1]=='#')
{
key[strlen(key)-1] = 0;
lua_pushnumber(L, atoi(key));
}
else
{
PushString(L, key);
}
IniValueGetRec(L, variables, currentChild);
lua_settable(L,-3);
currentChild = variables[currentChild].next;
}
while(currentChild!=-1);
}
}
int DoIniValueGet(lua_State *L/*, bool fromServer*/)
{
char iniFile[2048];
strcpy(iniFile, CamcamCCM);
if(lua_gettop(L)==0 || (lua_gettop(L)>0 && !lua_isstring(L,1))) return false;
char completedVarname[2048] = ".";
if(lua_tostring(L,1)[0]!='.')
{
strcat(completedVarname, lua_tostring(L,1));
completedVarname[strlen(lua_tostring(L,1))+1] = 0;
}
else
{
strcpy(completedVarname, lua_tostring(L,1));
}
if(lua_gettop(L)==3)
{
if(!lua_isstring(L,3)) return false;
strcpy(iniFile, lua_tostring(L, 3));
iniFile[strlen(lua_tostring(L, 3))] = 0;
if(strlen(iniFile)<4 || strcmp(".ccm", strlwr(iniFile+strlen(iniFile)-4))!=0)
{
strcpy(iniFile, lua_tostring(L, 3));
iniFile[strlen(lua_tostring(L, 3))] = 0;
strcat(iniFile, ".ccm");
iniFile[4+strlen(lua_tostring(L, 3))] = 0;
}
else
{
strcpy(iniFile, lua_tostring(L, 3));
iniFile[strlen(lua_tostring(L, 3))] = 0;
}
}
if (TheScene->IniFileDico.IsExist(iniFile) == -1 && TheScene->LoadIniFile(iniFile) == -1)
{
if(lua_gettop(L)==1) lua_pushnil(L);
else lua_pushvalue(L, 2);
return true;
}
u32 ID;
UnicID mUID;
TheScene->IniFileDico.GetUnic(&mUID,iniFile);
ID = TheScene->IniFileDico.mpst_Dico[mUID].AssociatedValue;
INIFILE* inifile = &(TheScene->IniFiles[ID]);
if(inifile->variableDico.IsExist(completedVarname)!=-1)
{
inifile->variableDico.GetUnic(&mUID,completedVarname);
ID = inifile->variableDico.mpst_Dico[mUID].AssociatedValue;
IniValueGetRec(L, inifile->variables, ID);
return true;
}
if (strcmp(completedVarname,".")==0)
{
lua_newtable(L);
u32 currentChild = inifile->root;
while(currentChild!=-1)
{
char key[2048] = "";
strcpy(key, strrchr(inifile->variables[currentChild].name, '.')+1);
if(key[strlen(key)-1]=='#')
{
key[strlen(key)-1] = 0;
lua_pushnumber(L, atoi(key));
}
else
{
PushString(L, key);
}
IniValueGetRec(L, inifile->variables, currentChild);
lua_settable(L,-3);
currentChild = inifile->variables[currentChild].next;
}
return true;
}
if(lua_gettop(L)==1) lua_pushnil(L);
else lua_pushvalue(L, 2);
return true;
}
int IniValueGet(lua_State *L)
{
return DoIniValueGet(L/*, false*/);
}
//int IniValueGetFromServer(lua_State *L)
//{
// return DoIniValueGet(L, true);
//}
int IniValueGetOld(lua_State *L)
{
char iniFile[2048] = "Camcam.ini";
if(lua_gettop(L)==0 || (lua_gettop(L)>0 && !lua_isstring(L,1))) return false;
char completedVarname[2048] = ".";
if(lua_tostring(L,1)[0]!='.')
{
strcat(completedVarname, lua_tostring(L,1));
completedVarname[strlen(lua_tostring(L,1))+1] = 0;
}
else
{
strcpy(completedVarname, lua_tostring(L,1));
}
if(lua_gettop(L)==3)
{
if(!lua_isstring(L,3)) return false;
strcpy(iniFile, lua_tostring(L, 3));
iniFile[strlen(lua_tostring(L, 3))] = 0;
if(strlen(iniFile)<4 || strcmp(".ini", strlwr(iniFile+strlen(iniFile)-4))!=0)
{
strcpy(iniFile, lua_tostring(L, 3));
iniFile[strlen(lua_tostring(L, 3))] = 0;
strcat(iniFile, ".ini");
iniFile[4+strlen(lua_tostring(L, 3))] = 0;
}
else
{
strcpy(iniFile, lua_tostring(L, 3));
iniFile[strlen(lua_tostring(L, 3))] = 0;
}
}
if (TheScene->IniFileDico.IsExist(iniFile) == -1 && TheScene->LoadIniFile(iniFile) == -1)
return false;
u32 ID;
UnicID mUID;
TheScene->IniFileDico.GetUnic(&mUID,iniFile);
ID = TheScene->IniFileDico.mpst_Dico[mUID].AssociatedValue;
INIFILE* inifile = &(TheScene->IniFiles[ID]);
if(inifile->variableDico.IsExist(completedVarname)!=-1)
{
inifile->variableDico.GetUnic(&mUID,completedVarname);
ID = inifile->variableDico.mpst_Dico[mUID].AssociatedValue;
IniValueGetRec(L, inifile->variables, ID);
return true;
}
if(lua_gettop(L)==1) lua_pushnil(L);
else lua_pushvalue(L, 2);
return true;
}
void IniValueSetRec(lua_State *L, char* parentName, char* inifile)
{
if(!lua_istable(L,-1))
{
char* iniVarname = (char*)ZeroAlloc(strlen(parentName)+1+1);
strcpy(iniVarname,parentName);
strcat(iniVarname, ".");
if(lua_type(L, -2)==LUA_TSTRING)
{
iniVarname = (char*)CC_realloc(iniVarname, 1+strlen(parentName)+1+strlen(lua_tostring(L,-2)));
strcat(iniVarname, lua_tostring(L,-2));
iniVarname[strlen(parentName)+1+strlen(lua_tostring(L,-2))] = 0;
}
else
{
lua_pushvalue(L,-2);
iniVarname = (char*)CC_realloc(iniVarname, 1+1+strlen(parentName)+1+strlen(lua_tostring(L,-1)));
strcat(iniVarname, lua_tostring(L,-1));
strcat(iniVarname, "#");
iniVarname[1+strlen(parentName)+1+strlen(lua_tostring(L,-1))] = 0;
lua_pop(L,1);
}
char* value = 0;
switch (lua_type(L,-1))
{
case LUA_TNUMBER:
{
value = (char*)ZeroAlloc(3+strlen(lua_tostring(L,-1))+1);
lua_pushvalue(L,-1);
strcpy(value, lua_tostring(L,-1));
strcat(value, " #n");
value[3+strlen(lua_tostring(L,-1))] = 0;
lua_pop(L,1);
TheScene->SetIniValue(inifile, iniVarname, value);
}
break;
case LUA_TSTRING:
{
value = (char*)ZeroAlloc(3+strlen(lua_tostring(L,-1))+1);
strcpy(value, lua_tostring(L,-1));
//strcat(value, " #s");
value[3+strlen(lua_tostring(L,-1))] = 0;
TheScene->SetIniValue(inifile, iniVarname, value);
}
break;
case LUA_TBOOLEAN:
{
value = (char*)ZeroAlloc(3+strlen((lua_toboolean(L, -1) ? "true" : "false"))+1);
strcpy(value, (lua_toboolean(L, -1) ? "true" : "false"));
strcat(value, " #b");
value[3+strlen((lua_toboolean(L, -1) ? "true" : "false"))] = 0;
TheScene->SetIniValue(inifile, iniVarname, value);
}
break;
case LUA_TNIL:
{
value = (char*)ZeroAlloc(strlen("nil #0")+1);
strcpy(value, "nil #0");
value[6] = 0;
TheScene->SetIniValue(inifile, iniVarname, value);
}
break;
default:
{
void *p = lua_touserdata(L, -1);
if (p != NULL)
{
if (lua_getmetatable(L, -1))
{
lua_getfield(L, LUA_REGISTRYINDEX, "VECTOR");
if (lua_rawequal(L, -1, -2))
{
lua_pop(L, 2);
luaL_callmeta(L, -1, "__tostring");
value = (char*)ZeroAlloc(strlen(lua_tostring(L, -1))+3+1);
strcpy(value, lua_tostring(L, -1));
strcat(value, " #v\0");
TheScene->SetIniValue(inifile, iniVarname, value);
lua_pop(L,1);
}
else
{
lua_pop(L, 2);
}
}
if (lua_getmetatable(L, -1))
{
lua_getfield(L, LUA_REGISTRYINDEX, "MATRIX");
if (lua_rawequal(L, -1, -2))
{
lua_pop(L, 2);
luaL_callmeta(L, -1, "__tostring");
value = (char*)ZeroAlloc(strlen(lua_tostring(L, -1))+3+1);
strcpy(value, lua_tostring(L, -1));
strcat(value, " #m\0");
TheScene->SetIniValue(inifile, iniVarname, value);
lua_pop(L,1);
}
else
{
lua_pop(L, 2);
}
}
if (lua_getmetatable(L, -1))
{
lua_getfield(L, LUA_REGISTRYINDEX, "QUAT");
if (lua_rawequal(L, -1, -2))
{
lua_pop(L, 2);
luaL_callmeta(L, -1, "__tostring");
value = (char*)ZeroAlloc(strlen(lua_tostring(L, -1))+3+1);
strcpy(value, lua_tostring(L, -1));
strcat(value, " #q\0");
TheScene->SetIniValue(inifile, iniVarname, value);
lua_pop(L,1);
}
else
{
lua_pop(L, 2);
}
}
}
}
break;
}
if (value) CC_free(value);
if (iniVarname) CC_free(iniVarname);
}
else
{
char* iniVarname = (char*)ZeroAlloc(1+strlen(parentName)+1);
strcpy(iniVarname,parentName);
strcat(iniVarname, ".");
lua_pushvalue(L,-2);
if(lua_type(L, -1)==LUA_TSTRING)
{
iniVarname = (char*)CC_realloc(iniVarname, 1+strlen(parentName)+1+strlen(lua_tostring(L,-1))+1);
strcat(iniVarname, lua_tostring(L,-1));
iniVarname[strlen(parentName)+1+strlen(lua_tostring(L,-1))] = 0;
}
else
{
iniVarname = (char*)CC_realloc(iniVarname, 1+strlen(parentName)+1+strlen(lua_tostring(L,-1))+1);
strcat(iniVarname, lua_tostring(L,-1));
strcat(iniVarname, "#");
iniVarname[1+strlen(parentName)+1+strlen(lua_tostring(L,-1))] = 0;
}
lua_pop(L,1);
TheScene->SetIniValue(inifile, iniVarname, ""); //iniVarname = prochain parent
lua_pushnil(L);
bool atLeastOne = false;
while (lua_next(L, -2) != 0)
{
atLeastOne = true;
IniValueSetRec(L, iniVarname, inifile);
}
if(!atLeastOne) TheScene->SetIniValue(inifile, iniVarname, "{} #0");
CC_free(iniVarname);
}
lua_pop(L,1);
}
int IniValueSet(lua_State *L)
{
char iniFile[1024];
strcpy(iniFile, CamcamCCM);
int s = lua_gettop(L);
if(lua_gettop(L)==0 || (lua_gettop(L)>0 && !lua_isstring(L,1))) return false;
char* completedVarname = (char*)ZeroAlloc(2048);
strcpy(completedVarname, ".");
if(lua_tostring(L,1)[0]!='.')
{
if (strlen(lua_tostring(L,1))+strlen(completedVarname)+1 > 2048)
{
completedVarname = (char*)CC_realloc(completedVarname, strlen(lua_tostring(L,1))+strlen(completedVarname))+1;
}
strcat(completedVarname, lua_tostring(L,1));
completedVarname[strlen(lua_tostring(L,1))+1] = 0;
}
else
{
if (strlen(lua_tostring(L,1))+1 > 2048)
{
completedVarname = (char*)CC_realloc(completedVarname, strlen(lua_tostring(L,1))+1);
}
strcpy(completedVarname, lua_tostring(L,1));
}
char* posPtr = strrchr(completedVarname, '.');
int pos = posPtr-completedVarname;
char* parent = (char*)ZeroAlloc(pos+1);
strncpy(parent, completedVarname, pos);
parent[pos] = 0;
char* varName = (char*)ZeroAlloc(strlen(completedVarname)-pos+1);
strncpy(varName, completedVarname+pos+1, strlen(completedVarname)-pos);
if(lua_gettop(L)==3)
{
if(!lua_isstring(L,3)) return false;
strcpy(iniFile, lua_tostring(L, 3));
if(strlen(iniFile)<4 || strcmp(".ccm", strlwr(iniFile+strlen(iniFile)-4))!=0)
{
strcpy(iniFile, lua_tostring(L, 3));
iniFile[strlen(lua_tostring(L, 3))] = 0;
strcat(iniFile, ".ccm");
iniFile[4+strlen(lua_tostring(L, 3))] = 0;
}
}
if (*varName)
{
if(lua_gettop(L)==1)
{
lua_pushstring(L, varName);
lua_pushstring(L, "1");
}
else
{
lua_pushstring(L, varName);
lua_pushvalue(L, 2);
}
IniValueSetRec(L, parent, iniFile);
CC_free(completedVarname);
CC_free(parent);
CC_free(varName);
return false;
}
else
{
if(lua_gettop(L)!=1 && (lua_istable(L,2)))
{
lua_pushnil(L);
while (lua_next(L, 2) != 0)
{
IniValueSetRec(L, parent, iniFile);
}
CC_free(completedVarname);
CC_free(parent);
CC_free(varName);
return false;
}
else
{
CC_free(completedVarname);
CC_free(parent);
CC_free(varName);
return true;
}
}
}
int IniValueSetOld(lua_State *L)
{
char iniFile[2048] = "Camcam.ini";
if(lua_gettop(L)==0 || (lua_gettop(L)>0 && !lua_isstring(L,1))) return false;
char completedVarname[2048] = ".";
if(lua_tostring(L,1)[0]!='.')
{
strcat(completedVarname, lua_tostring(L,1));
completedVarname[strlen(lua_tostring(L,1))+1] = 0;
}
else
{
strcpy(completedVarname, lua_tostring(L,1));
}
char* posPtr = strrchr(completedVarname, '.');
int pos = posPtr-completedVarname;
char parent[2048] = "";
strncpy(parent, completedVarname, pos);
parent[pos] = 0;
char varName[2048] = "";
strncpy(varName, completedVarname+pos+1, strlen(completedVarname)-pos);
if(lua_gettop(L)==3)
{
if(!lua_isstring(L,3)) return false;
strcpy(iniFile, lua_tostring(L, 3));
iniFile[strlen(lua_tostring(L, 3))] = 0;
if(strlen(iniFile)<4 || strcmp(".ini", strlwr(iniFile+strlen(iniFile)-4))!=0)
{
strcpy(iniFile, lua_tostring(L, 3));
iniFile[strlen(lua_tostring(L, 3))] = 0;
strcat(iniFile, ".ini");
iniFile[4+strlen(lua_tostring(L, 3))] = 0;
}
else
{
strcpy(iniFile, lua_tostring(L, 3));
iniFile[strlen(lua_tostring(L, 3))] = 0;
}
}
if(lua_gettop(L)==1)
{
lua_pushstring(L, varName);
lua_pushstring(L, "1");
}
else
{
lua_pushstring(L, varName);
lua_pushvalue(L, 2);
}
char value[2048];
strcpy(value, lua_tostring(L,-1));
TheScene->SetIniValue(iniFile, varName, value);
TheScene->SaveIniFile(iniFile);
return false;
}
/****************************************************/
// Note: returns an empty string in case of error; max len of string : 2047.
std::string GetRegistryValueStr(HKEY rootKey, const char *subKey, const char *name)
{
HKEY key;
if (RegOpenKeyEx(rootKey, subKey, 0, KEY_READ, &key) != ERROR_SUCCESS)
return std::string();
char str[2048] = "";
DWORD strType = NULL;
DWORD strLen = 2048;
DWORD error = RegQueryValueEx(key, name, 0, &strType, (BYTE *)str, &strLen);
/************************ DEBUG BEGINS HERE *************************/
/*
char info[2048] = "";
sprintf(info, "error=%u", error);
MessageBox(NULL, info, "Info", MB_OK);
//*/
/*
if (error!=ERROR_SUCCESS)
{
char info[2048] = "";
wchar_t Winfo[2048];
DWORD err = error; //GetLastError();
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err,
LANG_NEUTRAL, info, sizeof(Winfo)/sizeof(wchar_t), NULL);
wcstombs(info,Winfo,2048-1);
strcat(info, " : ");
strcat(info, str);
MessageBox(NULL, info, "Info", MB_OK);
}
//*/
/************************* DEBUG ENDS HERE **************************/
RegCloseKey(key);
return std::string(str);
}
/****************************************************/
bool GetDemoBranchFlagFromRegistry()
{
/*static volatile*/ short int DemoState = -1; // no cache
//if (DemoState == -1)
DemoState = (GetRegistryValueStr(HKEY_LOCAL_MACHINE, (std::string(CAMCAM_REG_KEY)+std::string(GAME_UPDATE_SUBKEY)).c_str(),
"branch") == "demo") ? 1 : 0;
return (DemoState == 1);
}
static const char *OC_KEY_CAMCAM = "OnceConnected";
/****************************************************/
bool GetFirstRunFlag()
{
return (GetRegistryValueStr(HKEY_CURRENT_USER, CAMCAM_REG_KEY, OC_KEY_CAMCAM) != "1");
}
/****************************************************/
bool SetFirstRunFlag()
{
HKEY newKey;
if (RegCreateKey(HKEY_CURRENT_USER, CAMCAM_REG_KEY, &newKey) != ERROR_SUCCESS)
return false;
const char *frvalue = "1";
bool ret = (RegSetValueEx(newKey, OC_KEY_CAMCAM, 0, REG_EXPAND_SZ, (BYTE *)frvalue, strlen(frvalue)+1) == ERROR_SUCCESS);
RegCloseKey(newKey);
return ret;
}
/****************************************************/
// dst: max 2047 chars
/*void GetCamCamValueFromRegistry(char *dst, char *item, bool fromHKCU)
{
std::string value;
if (fromHKCU)
value = GetRegistryValueStr(HKEY_CURRENT_USER, CAMCAM_REG_KEY, item);
else
value = GetRegistryValueStr(HKEY_LOCAL_MACHINE, (std::string(CAMCAM_REG_KEY)+std::string(GAME_UPDATE_SUBKEY).c_str(), item);
strncpy(dst, value, 2047);
}*/
/****************************************************/
// dst: max 2 chars
void GetInstalledLanguageCode(char *dst)
{
strncpy(dst, GetRegistryValueStr(HKEY_LOCAL_MACHINE, (std::string(CAMCAM_REG_KEY)+std::string(GAME_UPDATE_SUBKEY)).c_str(),
"language").c_str(), 2);
}
///****************************************************/
//bool SetRegistryValueStr(HKEY rootKey, const char *key, const char *name, const char *value)
//{
// HKEY hkey;
// if (RegOpenKeyEx(rootKey, key, 0, KEY_ALL_ACCESS, &hkey) != ERROR_SUCCESS)
// return false;
// bool ret = RegSetValueEx(hkey, name, 0, REG_EXPAND_SZ, (BYTE *)value, strlen(value)+1);
// RegCloseKey(hkey);
// return ret;
//}
//
///****************************************************/
//bool SetBranch(const char *branch, const char *newGameId)
//{
// const char *BRANCH_KEY_CAMCAM = "branch";
// const char *GAMEID_KEY_CAMCAM = "info";
// bool res = SetRegistryValueStr(HKEY_LOCAL_MACHINE, CAMCAM_REG_KEY, BRANCH_KEY_CAMCAM, branch);
// if (!res)
// return false;
// return SetRegistryValueStr(HKEY_LOCAL_MACHINE, CAMCAM_REG_KEY, GAMEID_KEY_CAMCAM, newGameId);
//}
//
///****************************************************/
//bool SwitchToBetaBranch()
//{
//#ifdef ONLINE_MODE
// if (Account.sameCurrentDemoAndBeta())
// return SetBranch("beta", Account.getBetaGameId().c_str());
// else
// return false; // user must download a new beta installer
//#endif
// return false;
//}
/****************************************************/
int GetAccountInfo(lua_State *L)
{
lua_newtable(L);
lua_pushstring(L, "v");
#ifdef ONLINE_MODE
lua_pushnumber(L, Account.getProtocolNum());
#else
lua_pushnumber(L, 0);
#endif
lua_settable(L, -3);
lua_pushstring(L, "ia");
#ifdef ONLINE_MODE
lua_pushnumber(L, Account.getIdAccount());
#else
lua_pushnumber(L, 0);
#endif
lua_settable(L, -3);
return true;
}
#ifdef ONLINE_MODE
/****************************************************/
int lua_push_json_object(lua_State *L, json_object *jo, bool freeJO=false)
{
if (!jo)
return 0;
switch(json_object_get_type(jo))
{
case json_type_boolean:
lua_pushboolean(L, json_object_get_boolean(jo));
break;
case json_type_double:
lua_pushnumber(L, json_object_get_double(jo));
break;
case json_type_int:
lua_pushnumber(L, (double)json_object_get_int(jo));
break;
case json_type_object:
lua_newtable(L);
json_object_object_foreach(jo, key, val)
{
lua_pushstring(L, key);
lua_push_json_object(L, val);
lua_settable(L, -3);
}
break;
case json_type_array:
{
lua_newtable(L);
int len = json_object_array_length(jo);
for (int i=0; i!=len; ++i)
{
lua_pushnumber(L, i+1); // wants index starting at 1
lua_push_json_object(L, json_object_array_get_idx(jo, i));
lua_settable(L, -3);
}
}
break;
case json_type_string:
lua_pushstring(L, json_object_get_string(jo));
break;
default:
lua_pushboolean(L, false); // avoid corrupting the table in case something went really wrong
return 0;
}
if (freeJO)
json_object_put(jo);
return 1;
}
#endif
/****************************************************/
int JSONToTable(lua_State *L)
{
if(lua_gettop(L)<1) return false;
#ifdef ONLINE_MODE
json_object *jo = json_tokener_parse(const_cast<char*>(lua_tostring(L, 1)));
if (is_error(jo))
lua_newtable(L);
else
lua_push_json_object(L, jo, true);
#else
lua_newtable(L);
#endif
return true;
}
/****************************************************/
int AddCredits(lua_State *L)
{
if(lua_gettop(L)<1) return false;
#ifdef ONLINE_MODE
//lua_pushboolean(L, Account.addCredits(lua_tonumber(L, 1)));
MessageBox(NULL, "Deprecated", "AddCredits", MB_ICONWARNING);
lua_pushboolean(L, true);
#else
lua_pushboolean(L, true);
#endif
return true;
}
extern HWND hWnd;
/****************************************************/
int OpenExternalBrowser(lua_State *L)
{
if(lua_gettop(L)<1) return false;
// Prevent from spawning an exe...
char url[2048];
strncpy(url, lua_tostring(L, 1), 2047);
#ifdef ONLINE_MODE
if (!*url)
{
// If first arg is empty, auto-log-in to web page, using arg 2 index
CCamCamAccount::WebPage page = CCamCamAccount::Profile;
if (lua_gettop(L)>1)
{
if (lua_tointeger(L, 2) >= CCamCamAccount::NbWebPages)
{
lua_pushboolean(L, false);
return true;
}
page = (CCamCamAccount::WebPage)lua_tointeger(L, 2);
}
if(CCamCamAccount::CNT_NORMAL != Account.getConnectionMode())
{
// If account is not a normal connection, we cant auto-log-in
lua_pushboolean(L, Account.callGuestPage(Account.getPage(page)));
return true;
}
strncpy(url, Account.getLoggedProfileURL(page).c_str(), 2047);
}
// Launch
lua_pushboolean(L, Account.openExternalWebBrowser(url));
#else
if ((strncmp(url, "http://", 7) == 0) || (strncmp(url, "https://", 8) == 0))
{
HINSTANCE r = ShellExecute(NULL, "open", url, NULL, NULL, SW_SHOWNORMAL);
lua_pushboolean(L, ((int)r)>32);
}
else
lua_pushboolean(L, false);
#endif
return true;
}
std::string getNextToken(char const**ppSrc, char delimiter)
{
const char *pStart = *ppSrc;
const char *pEnd = strchr(pStart, delimiter);
if (pEnd != NULL)
{
*ppSrc = pEnd+1;
return std::string(pStart, pEnd-pStart);
}
else
{
*ppSrc = NULL;
return std::string(pStart);
}
}
#ifdef ONLINE_MODE
/****************************************************/
void releaseLuaHTTPClients()
{
for (std::map<int,CHttpClient>::iterator it=HttpClientChannels.begin(); it!=HttpClientChannels.end(); ++it)
{
it->second.release();
}
HttpClientChannels.clear();
}
#endif
/****************************************************/
//int GetHTTPProxy(lua_State *L)
//{
//#ifdef ONLINE_MODE
// const char *proxy = Account.getHttpClient().getProxy();
// if (proxy)
// lua_pushstring(L, proxy);
// else
// lua_pushnil(L);
//#else
// lua_pushnil(L);
//#endif
// return true;
//}
//
///****************************************************/
//int SetRecommendedHTTPProxy(lua_State *L)
//{
// if (lua_gettop(L) < 1) return false;
//#ifdef ONLINE_MODE
// Account.setProxy(lua_tostring(L, 1));
//#endif
// return true;
//}
/****************************************************/
#ifdef ONLINE_MODE
bool hasChannelClient(int channel)
{
if (channel == -1)
return true;
return (HttpClientChannels.find(channel) != HttpClientChannels.end());
}
CHttpClient *getChannelClient(int channel)
{
if (channel < 0)
{
if (channel == -1)
return &Account._HttpClient;
else
return &HttpClientChannels[channel]; // TODO
}
else
return &HttpClientChannels[channel];
}
#endif
/****************************************************/
int HTTPRequest(lua_State *L, int channel, bool isPostRequest, bool isMultipart=false)
{
// Get URL
if(lua_gettop(L)<1) return false;
const char *url = lua_tostring(L,1);
const char *urlParams;
if (isPostRequest)
{
urlParams = lua_tostring(L,2);
}
else
{
urlParams = strchr(url, '?');
char blankParams [1] = "";
char pageURL [1024];
strncpy(pageURL, url, min(1024, urlParams ? (urlParams-url) : 1024));
pageURL[min(1023, urlParams ? (urlParams-url) : 1023)] = 0;
strncpy(pageURL, url, min(1024, urlParams ? (urlParams-url) : 1024));
url = pageURL;
urlParams = urlParams ? urlParams+1 : blankParams; // skip separator
}
int paramDelta = (isPostRequest ? 1 : 0);
// Get optional destination file
const char *destFile = (lua_gettop(L)>1+paramDelta) ? lua_tostring(L,2+paramDelta) : NULL;
// Get optional verbose param
bool verbose = ((lua_gettop(L)>2+paramDelta) && lua_toboolean(L,2+paramDelta));
#ifdef ONLINE_MODE
// Quick config
bool isNewClient = !hasChannelClient(channel);
CHttpClient *httpClient = getChannelClient(channel);
if (isNewClient && channel >= 0)
{
httpClient->init();
httpClient->setCurrentPacMethod(CHttpClient::PacmManual);
httpClient->setProxy(Account.getHttpClient().getProxy());
}
bool res;
bool canTryOtherProxy = false;
if (isPostRequest && isMultipart)
{
const char *bufPos = urlParams;
while (bufPos)
{
std::string field = getNextToken(&bufPos, '=');
std::string value = (bufPos ? getNextToken(&bufPos, '&') : "");
if (value[0] == '@')
httpClient->addMultipartParam(field.c_str(), CHttpClient::MultipartParam(value.substr(1).c_str(), CHttpClient::ParamLoadFile));
else
httpClient->addMultipartParam(field.c_str(), value.c_str());
}
do
{
// Do request, and reconfigure proxy if needed
res = httpClient->sendMultipartRequest(url, false, verbose);
if (!res && httpClient->mayRetryAfterProxyAutoConfig())
canTryOtherProxy = httpClient->nextTryAutoConfigureProxy(url); // needs XP SP1 or newer
}
while (!res && canTryOtherProxy);
}
else
{
if (channel == -1)
{
if (!Account.isLoggedIn())
res = false;
else
res = Account.doRequest(url, urlParams, FAILED_SCRIPT_REQUEST, __FUNCTION__, "", true);
}
else
{
do
{
// Do request, and reconfigure proxy if needed
res = httpClient->sendRequest(url, urlParams, isPostRequest, false, verbose);
if (!res && httpClient->mayRetryAfterProxyAutoConfig())
canTryOtherProxy = httpClient->nextTryAutoConfigureProxy(url); // needs XP SP1 or newer
}
while (!res && canTryOtherProxy);
}
}
if (destFile && *destFile)
{
if (!res)
lua_pushboolean(L, false);
else
{
if (fileExists(const_cast<char*>(destFile)))
{
lua_pushboolean(L, false);
return true;
}
FILE *f = CC_fopen(destFile, "wb");
if (f)
{
fwrite(httpClient->getResponsePage().data(), 1, httpClient->getResponsePage().size(), f);
CC_fclose(f);
lua_pushboolean(L, true);
}
else
lua_pushboolean(L, false);
}
}
else
{
lua_pushstring(L, httpClient->getResponsePage().c_str());
}
#else
lua_pushstring(L, "");
#endif // ONLINE_MODE
return true;
}
/****************************************************/
int HTTPGet(lua_State *L)
{
int channel = (lua_gettop(L)>=4) ? lua_tonumber(L, 4) : 0;
return HTTPRequest(L, channel, false);
}
/****************************************************/
int HTTPPost(lua_State *L)
{
int channel = (lua_gettop(L)>=5) ? lua_tonumber(L, 5) : 0;
return HTTPRequest(L, channel, true, false);
}
/****************************************************/
int HTTPPostMultipart(lua_State *L)
{
int channel = (lua_gettop(L)>=5) ? lua_tonumber(L, 5) : 0;
return HTTPRequest(L, channel, true, true);
}
/*********************** Get Object List *****************************/
int GetObjectList(lua_State *L)
{
if (lua_gettop(L) == 0 ||
(lua_gettop(L)>0 && !lua_isstring(L,1))) return 0;
char *sceneName = (char *)lua_tostring(L,1);
SmallScene *SmSc = TheScene->SmallNameToScene(sceneName);
_3D_Object **pObj;
int onlyMesh = 0;
if (lua_gettop(L) > 1 && lua_isnumber(L, 2))
onlyMesh = lua_tonumber(L, 2);
if (!SmSc) return 0;
pObj = SmSc->ObjectsPtrs;
lua_newtable(L);
int nbInTable = 0;
for (int counter = 0; counter < SmSc->ulNumberOfObjects; counter++,pObj++)
{
if (onlyMesh && (*pObj)->MeshIndex == -1) continue;
lua_pushnumber(L, ++nbInTable);
lua_newtable(L);
lua_pushstring(L, "name");
lua_pushstring(L, (char *)(*pObj)->pObjectName);
lua_settable(L, -3);
lua_pushstring(L, "father");
lua_pushnumber(L, (*pObj)->FatherIndex + 1);
lua_settable(L, -3);
lua_settable(L, -3);
}
return 1;
}
/*********************** Get Material List *****************************/
static int matEnumIndex;
void MatEnumProcess(char *String,void *UserParam)
{
int len;
lua_State *L = (lua_State *)UserParam;
lua_pushnumber(L, ++matEnumIndex);
lua_pushstring(L, (char *)String);
lua_settable(L, -3);
}
int GetMatList(lua_State *L)
{
if (lua_gettop(L) == 0 ||
(lua_gettop(L)>0 && !lua_isstring(L,1))) return 0;
char *sceneName = (char *)lua_tostring(L,1);
SmallScene *SmSc = TheScene->SmallNameToScene(sceneName);
if (!SmSc) return 0;
lua_newtable(L);
matEnumIndex = 0;
SmSc->MaterialNameDico.EnumWords(MatEnumProcess,L);
return 1;
}
/*********************** Get Material List *****************************/
int GetMediaList(lua_State *L)
{
if (lua_gettop(L) == 0 ||
(lua_gettop(L)>0 && !lua_isstring(L,1))) return 0;
char *sceneName = (char *)lua_tostring(L,1);
SmallScene *SmSc = TheScene->SmallNameToScene(sceneName);
int mediaEnumIndex = 0;
if (!SmSc) return 0;
lua_newtable(L);
for (int i=0; i<SmSc->ulNumberOfMaterials; i++)
{
for (int j=0; j<SmSc->MaterialsPtrs[i]->NumberOfLayers; j++)
{
u32 textureIndex = SmSc->MaterialsPtrs[i]->Layers[j].TextureMediaIndex;
if (textureIndex != -1)
textureIndex = TheScene->MediaDico.mpst_Dico[textureIndex].AssociatedValue;
if (textureIndex != -1 && TheScene->ID_MEDIA[textureIndex])
{
lua_pushnumber(L, ++mediaEnumIndex);
lua_pushstring(L, (char *)TheScene->ID_MEDIA[textureIndex]->MediaName);
lua_settable(L, -3);
}
}
}
return 1;
}
/*********************** CONVERSTION FUNCTIONS ***********************/
int ProcessTableRec(lua_State *L, char *strPtr, int nbElmts)
{
// Set Variable
char inBuffer[256];
char *inBufferPtr;
int keyIndex = 1;
lua_newtable(L);
while (nbElmts > 0)
{
memset(inBuffer, 0, sizeof(inBuffer));
for (;nbElmts > 0 && *strPtr <= 32; strPtr++, nbElmts--);
for (inBufferPtr=inBuffer;nbElmts > 0 && *strPtr != '=' && *strPtr != '{'; strPtr++, inBufferPtr++, nbElmts--)
*inBufferPtr = *strPtr;
if (*inBuffer)
{
lua_pushstring(L, inBuffer);
strPtr++; nbElmts--;
} else
{
lua_pushnumber(L, keyIndex++);
}
for (;nbElmts > 0 && *strPtr <= 32; strPtr++, nbElmts--);
if (*strPtr == '{')
{
int level = 1;
int nbElmtsIn = 0;
strPtr++; nbElmts--;
while (level != 0 && nbElmts > 0)
{
if (*strPtr == '{') level++;
if (*strPtr == '}') level--;
strPtr++; nbElmts--;
nbElmtsIn++;
}
ProcessTableRec(L, strPtr-nbElmtsIn, nbElmtsIn-1);
} else
{
BOOL isNumber = true;
memset(inBuffer, 0, sizeof(inBuffer));
inBufferPtr = inBuffer;
for (inBufferPtr = inBuffer; nbElmts > 0 && *strPtr != ','; strPtr++, inBufferPtr++, nbElmts--)
{
if (*strPtr <= 32) continue;
if ((*strPtr < '0' || *strPtr > '9') &&
*strPtr != '+' && *strPtr != '-' && *strPtr != '.' ) isNumber = false;
*inBufferPtr = *strPtr;
}
*inBufferPtr = 0;
if (isNumber)
lua_pushnumber(L, (double)atof(inBuffer));
else
lua_pushstring(L, inBuffer);
}
for (;*strPtr <= 32 && nbElmts > 0; strPtr++, nbElmts--);
if (nbElmts > 0 && *strPtr == ',' )
{ strPtr++; nbElmts--; }
lua_settable(L, -3);
}
return 1;
}
int StringToTable(lua_State *L)
{
char *strPtr = (char *)lua_tostring(L, -1);
int strLen = strlen(strPtr);
if (*strPtr != '{' && strPtr[strLen-1] != '}') return 0;
strPtr++;
ProcessTableRec(L, strPtr, strLen-2);
return 1;
}
/*********************** EVENT FUNCTIONS ***********************/
typedef struct {
char name[512];
DWORD mode;
int nbObject;
int maxObject;
ObjectEventInfo *object;
} EventInfo;
#define BASE_MAX_OBJECT 8
static BOOL IsEventListGlobal = 1;
static BOOL IsEventListEmpty[MAX_SCRIPTS];
static EventInfo EventList[MAX_SCRIPTS][MAX_EVENT];
#define MAX_EVENT_EXEC 1024
static int nbEventsExec = 0;
static int currentEvent = 0;
static ObjectEventDatas EventsExec[MAX_EVENT_EXEC];
static UNIC_Dico objEventDico;
void LuaEventAdd(EventInfo *EventListPtr, int eventNum, char* eventName, DWORD mode)
{
strcpy(EventListPtr[eventNum].name, eventName);
EventListPtr[eventNum].mode = mode;
EventListPtr[eventNum].nbObject = 0;
EventListPtr[eventNum].maxObject = BASE_MAX_OBJECT;
EventListPtr[eventNum].object = (ObjectEventInfo *)CC_malloc(EventListPtr[eventNum].maxObject*sizeof(ObjectEventInfo));
memset(EventListPtr[eventNum].object, 0, EventListPtr[eventNum].maxObject*sizeof(ObjectEventInfo));
}
void LuaAddAllEvents(lua_State *L, EventInfo *EventListPtr)
{
#define LUA_EVENT_SET(a,m) LuaEventAdd(EventListPtr, EVT_##a, #a, m);
#include "LuaEvents.h"
}
inline void LuaEventAddObject(EventInfo *EventListPtr, int eventNum, char *function, int *levels, int nbLevels)
{
if (!function) return;
EventInfo *eventPtr = EventListPtr + eventNum;
ObjectEventInfo *objectPtr;
int functionLen;
if (eventPtr->nbObject >= eventPtr->maxObject)
{
while (eventPtr->maxObject <= eventPtr->nbObject)
eventPtr->maxObject *= 2;
eventPtr->object = (ObjectEventInfo *)CC_realloc(eventPtr->object,
eventPtr->maxObject*sizeof(ObjectEventInfo));
memset(eventPtr->object + eventPtr->nbObject, 0, (eventPtr->maxObject-eventPtr->nbObject)*sizeof(ObjectEventInfo));
}
objectPtr = eventPtr->object + eventPtr->nbObject++;
objectPtr->nbLevels = nbLevels;
UnicID id;
for (int i=0; i<=nbLevels; i++)
{
id = objEventDico.IsExist(function + levels[i]);
if (id == -1)
objEventDico.GetUnic(&id, function + levels[i]);
objectPtr->objID[i] = id;
}
memcpy(objectPtr->levels, levels, (nbLevels+1)*sizeof(int));
memcpy(objectPtr->luaFunction, function, objectPtr->levels[objectPtr->nbLevels]);
}
void adressToString(u32 adress, char *buffer)
{
buffer[0] = ((adress >> 28) & 0xf) + 'A';
buffer[1] = ((adress >> 24) & 0xf) + 'A';
buffer[2] = ((adress >> 20) & 0xf) + 'A';
buffer[3] = ((adress >> 16) & 0xf) + 'A';
buffer[4] = ((adress >> 12) & 0xf) + 'A';
buffer[5] = ((adress >> 8) & 0xf) + 'A';
buffer[6] = ((adress >> 4) & 0xf) + 'A';
buffer[7] = ((adress >> 0) & 0xf) + 'A';
buffer[8] = 0;
}
void LuaPreProcessEvent(lua_State *L, EventInfo *EventListPtr, int nbLevels, int *levels, char *functionName, int len, char *name)
{
if (!L) return;
static UNIC_Dico levelsDico;
char adressStr[16];
if (nbLevels < 0)
{
char nameBuffer[1024];
*functionName = 0;
if (name == NULL)
strcpy(nameBuffer, "UI");
else
strcpy(nameBuffer, name);
lua_getglobal(L, nameBuffer);
curLevel = 0;
levelsDico.Init();
levelsDico.IsCaseSensitive = 1;
LuaPreProcessEvent(L, EventListPtr, 0, levels, functionName, 0, nameBuffer);
levelsDico.Destroy();
lua_pop(L, 1);
return;
}
if (!lua_istable(L,-1)) return;
adressToString((u32)lua_topointer(L, -1), adressStr);
if (levelsDico.IsExist(adressStr) != -1)
return;
levelsDico.AddWord(adressStr);
/*
// Verify if event already done
if (curLevel >= maxLevel)
{
maxLevel *= 2;
levelsPtr = (void **)CC_realloc(levelsPtr, maxLevel*sizeof(void *));
#ifdef EVENT_CONFLICT
levelsCharsPtr = (char **)CC_realloc(levelsCharsPtr, maxLevel*sizeof(char *));
#endif
}
levelsPtr[curLevel] = (void *)lua_topointer(L, -1);
#ifdef EVENT_CONFLICT
char buffer[1024];
memset(buffer, 0, sizeof(buffer));
memcpy(buffer, functionName, len);
for (int i=0; i<len; i++)
if (buffer[i] == 0) buffer[i] = '.';
strcat(buffer, name);
#endif
for (int lvlIdx=0; lvlIdx<curLevel; lvlIdx++)
{
if (levelsPtr[lvlIdx] == levelsPtr[curLevel])
{
levelsPtr[curLevel] = NULL;
#ifdef EVENT_CONFLICT
char log[2048];
sprintf(log, "Same ptr %s <> %s", levelsCharsPtr[lvlIdx], buffer);
SaveDBGInfo(log);
#endif
break;
}
}
if (levelsPtr[curLevel] == NULL)
return;
else
curLevel++;
#ifdef EVENT_CONFLICT
levelsCharsPtr[curLevel-1] = strdup(buffer);
#endif
*/
levels[nbLevels] = len;
strcpy(functionName + len, name);
len += strlen(functionName + len) + 1;
nbLevels++;
lua_pushnil(L); /* first key */
while (lua_next(L, -2) != 0) {
/* uses 'key' (at index -2) and 'value' (at index -1) */
if (lua_isnumber(L, -2))
{
lua_pop(L, 1);
continue;
}
lua_pushvalue(L, -2);
strcpy(name, (char *)lua_tostring(L,-1));
lua_pop(L, 1);
LuaPreProcessEvent(L, EventListPtr, nbLevels, levels, functionName, len, name);
lua_pop(L, 1);
}
for (int eventIdx=0; eventIdx<MAX_EVENT; eventIdx++)
{
lua_pushstring(L, EventListPtr[eventIdx].name);
lua_gettable(L, -2);
if (lua_isfunction(L, -1))
{
int lastLevel = nbLevels;
levels[lastLevel++] = len;
strcpy(functionName + len, EventListPtr[eventIdx].name);
levels[lastLevel] = len + strlen(functionName + len) + 1;
LuaEventAddObject(EventListPtr, eventIdx, functionName, levels, lastLevel);
}
lua_pop(L, 1);
}
}
inline void AddEventExec(ObjectEventDatas *datas)
{
if (nbEventsExec >= MAX_EVENT_EXEC)
return;
EventsExec[nbEventsExec++] = *datas;
}
inline BOOL PushLuaParents(lua_State *L, ObjectEventInfo *event)
{
int nbPtsIn = 0;
lua_getglobal(L, event->luaFunction);
if (lua_isnil(L, -1))
return false;
for (int lev=1; lev<event->nbLevels; lev++)
{
lua_pushstring(L, event->luaFunction+event->levels[lev]);
lua_gettable(L, -2);
if (lua_isnil(L, -1))
return false;
}
nbPtsIn = event->nbLevels;
while (nbPtsIn > 1)
{
lua_insert (L, -nbPtsIn--);
}
return true;
}
void WORLD::LuaEventsExec()
{
ObjectEventInfo *lastObject = NULL;
ObjectEventInfo *objPtr;
BOOL result = false;
lua_State *luaScriptPtr = luaScriptTable[currentScript];
if (!luaScriptPtr)
{
nbEventsExec = 0;
return;
}
START_RASTER(LUA_CALLS);
if (WAIT_OBJECT_0 == WaitForSingleObject(ScriptAccesMutex, INFINITE))
{
LUA_DEBUG_RASTER_STOP();
for (currentEvent=0; currentEvent<nbEventsExec; currentEvent++)
{
objPtr = EventsExec[currentEvent].infoPtr;
if (objPtr->nbLevels == 0) continue;
if (result &&
strcmp( lastObject->luaFunction + lastObject->levels[lastObject->nbLevels-1],
objPtr->luaFunction + objPtr->levels[objPtr->nbLevels-1]))
result = 0;
if (result &&
(lastObject->levels[lastObject->nbLevels-1] > objPtr->levels[objPtr->nbLevels-1]) &&
!memcmp(lastObject->luaFunction, objPtr->luaFunction, objPtr->levels[objPtr->nbLevels-1]))
continue;
if (!PushLuaParents(luaScriptPtr, objPtr))
continue;
#ifndef USER_MODE
extern int mainThread;
if (mainThread != GetCurrentThreadId()) MessageBox(NULL, "Bad Threard Access 6!", "YouUp", MB_OK | MB_ICONERROR);
#endif
if(debuggingLua)
{
lua_call(luaScriptPtr,objPtr->nbLevels-1,1);
}
else
{
if (lua_pcall(luaScriptPtr,objPtr->nbLevels-1,1,0) != 0)
{
char * luaRes = (char *)lua_tostring(luaScriptPtr, -1);
if (luaRes) strcpy(LuaErrors, luaRes);
else strcpy(LuaErrors, "LUA Unknown error (set debuggingLua to 1 in camcam.ccm !!)");
lua_pop(luaScriptPtr, 1);
SaveDBGInfo(LuaErrors);
STOP_RASTER(LUA_CALLS)
ReleaseMutex(ScriptAccesMutex);
nbEventsExec = 0;
return;
}
}
if (lua_isboolean(luaScriptPtr, -1))
{
result = lua_toboolean(luaScriptPtr, -1);
if (result)
lastObject = objPtr;
} else
result = false;
lua_pop(luaScriptPtr, 1);
}
LUA_DEBUG_RASTER_STOP();
STOP_RASTER(LUA_CALLS);
ReleaseMutex(ScriptAccesMutex);
nbEventsExec = 0;
}
if (updateEvent)
{
UpdateEvents(NULL);
updateEvent = false;
}
}
static char inScriptError[2048];
void FillScriptInfo(lua_State *L, int paramNum, int isError)
{
lua_Debug ar[64];
int nbLevels = 1;
char *inScriptErrorPtr = inScriptError;
lua_getstack(L, 0, &ar[0]);
lua_getinfo(L, "n", &ar[0]);
for (; nbLevels < 64 && lua_getstack(L, nbLevels, &ar[nbLevels]); nbLevels++)
lua_getinfo(L, "lS", &ar[nbLevels]);
for (nbLevels--; nbLevels > 1; nbLevels--)
{
sprintf(inScriptErrorPtr, "%s:%i\n", ar[nbLevels].short_src, ar[nbLevels].currentline);
inScriptErrorPtr += strlen(inScriptErrorPtr);
}
if (isError)
sprintf(inScriptErrorPtr, "%s:%i: bad argument #%i to '%s\'", ar[1].short_src, ar[1].currentline, paramNum, ar[0].name);
else
sprintf(inScriptErrorPtr, "%s:%i: function '%s\'", ar[1].short_src, ar[1].currentline, ar[0].name);
}
void HandleError(lua_State *L, int paramNum)
{
FillScriptInfo(L, paramNum, 1);
lua_pushstring(L, inScriptError);
lua_error(L);
}
bool PopBoolean(lua_State *L, int narg)
{
if (!lua_isboolean(L, narg))
HandleError(L, narg);
return lua_toboolean(L, narg);
}
int PopInteger(lua_State *L, int narg)
{
lua_Integer d = lua_tointeger(L, narg);
if (d == 0 && !lua_isnumber(L, narg)) /* avoid extra test when d is not 0 */
HandleError(L, narg);
return d;
}
double PopNumber(lua_State *L, int narg)
{
lua_Number d = lua_tonumber(L, narg);
if (d == 0 && !lua_isnumber(L, narg)) /* avoid extra test when d is not 0 */
HandleError(L, narg);
return d;
}
const char *PopString(lua_State *L, int narg)
{
const char *s = lua_tolstring(L, narg, NULL);
if (!s) HandleError(L, narg);
return s;
}
//FillScriptInfo(L, 0, 0); \
/*
#define DEFINE_SCRIPT_SPECIAL(scriptName, functionName, parameters, helpString)
#define DEFINE_SCRIPT(a,params,Help,b) \
int WORLD::WSCRIPT_##a(lua_State *L) {int ParamsOk=1; int luaParam=1; int returnDone = 0; int luaArgs = lua_gettop(L); params; \
if (!ParamsOk) { HandleError(L, luaParam); return 0; } \
b; \
if (!returnDone) lua_pushnil(L); \
else if (returnDone > 1) \
{ lua_newtable(L); for (int idx=0; idx<returnDone; idx++) \
{lua_pushinteger(L,idx+1); lua_pushvalue(L, idx-returnDone-2); lua_settable(L, -3); lua_remove(L,idx-returnDone-1); \
} } return 1; } \
int SCRIPT_##a(lua_State *L) { return TheScene->WSCRIPT_##a(L); }
#define DEFINE_SCRIPT_REN(n,a,params,Help,b) \
DEFINE_SCRIPT(n,params,Help,b)
#include "Script_Commands.h"
*/
#define DEFINE_SCRIPT_SPECIAL(scriptName, functionName, parameters, helpString)
#define DEFINE_SCRIPT(a,params,Help,b) \
int WORLD::WSCRIPT_##a(lua_State *L) {START_RASTER(LUA_SUB_CALLS); int ParamsOk=1; int luaParam=1; int returnDone = 0; int luaArgs = lua_gettop(L); params; \
if (!ParamsOk) { HandleError(L, luaParam); STOP_RASTER(LUA_SUB_CALLS); return 0; } \
b; \
if (!returnDone) lua_pushnil(L); STOP_RASTER(LUA_SUB_CALLS);\
return 1; } \
int SCRIPT_##a(lua_State *L) { return TheScene->WSCRIPT_##a(L); }
#define DEFINE_SCRIPT_REN(n,a,params,Help,b) \
DEFINE_SCRIPT(n,params,Help,b)
#ifdef ONLINE_MODE
#define DEFINE_SCRIPT_ONLINE(a,params,Help,b,c) \
DEFINE_SCRIPT(a,params,Help,b)
#else
#define DEFINE_SCRIPT_ONLINE(a,params,Help,b,c) \
DEFINE_SCRIPT(a,params,Help,c)
#endif
#include "Script_Commands.h"
int SCRIPT_SmallSceneNewMultiMaterial(lua_State *L)
{
return TheScene->SmallSceneNewMultiMaterial(L);
}
/************************ LUA SPECIFUC GENERIC ***********************************/
int SCRIPT_Xml2Lua(lua_State *L)
{
return TheScene->Xml2Lua(L, (char *)lua_tostring(L, 1));
}
int SCRIPT_XmlFile2Lua(lua_State *L)
{
int result = 0;
FILE * file = fopen(lua_tostring(L, 1), "rt");
if (file)
{
fseek(file, 0, SEEK_END);
int size = ftell(file);
fseek(file, 0, SEEK_SET);
char *buffer = (char *)CC_malloc(size+1);
if (buffer)
{
fread(buffer, size, 1, file);
buffer[size] = 0;
result = TheScene->Xml2Lua(L, buffer);
CC_free(buffer);
}
fclose(file);
}
return result;
}
#ifndef SKIMMED_NET
int SCRIPT_SendFlash(lua_State *L)
{
if (!lua_isstring(L, -1))
return 0;
TheScene->FlashCom_Send((char *)lua_tostring(L, -1));
return 1;
}
#endif
int SCRIPT_DoFile(lua_State *L)
{
char *filename = (char *)lua_tostring(L, -1);
#ifdef USER_MODE
char filenameX[1024];
sprintf(filenameX, "%sx", filename);
filename = filenameX;
BOOL IsFileAllowed(char *filename, bool fromLua);
void displayIntegrityError(int num);
/*// Check integrity of caller, if it is a registered file
lua_Debug ar;
lua_getstack(L, 1, &ar);
lua_getinfo(L, "lS", &ar);
if (!IsFileAllowed((char *)ar.source, 1))
{
displayIntegrityError(2);
lua_pushboolean(L, false);
return 1;
}*/
// New: check integrity of called file, if it is a registered file
if (!IsFileAllowed(filename, 1))
{
displayIntegrityError(3);
lua_pushboolean(L, false);
return 1;
}
#endif //USER_MODE
FILE *fileF = CC_fopen(filename, "r");
UnicID ID;
if (fileF)
{
CC_fclose(fileF);
TheScene->luaLoaddedFilesDICO.GetUnic(&ID,(char *)lua_tostring(L, -1));
if (luaL_loadfile(L, (char *)lua_tostring(L, -1)) != 0)
lua_error(L);
lua_call(L, 0, LUA_MULTRET);
lua_pushboolean(L, true);
} else
{
lua_pushboolean(L, false);
}
return 1;
}
void FreeEvents(int scriptIndex)
{
if (IsEventListGlobal)
{
for (int evIdx=0; evIdx<MAX_SCRIPTS; evIdx++)
IsEventListEmpty[evIdx] = 1;
IsEventListGlobal = 0;
}
if (!IsEventListEmpty[scriptIndex])
{
for (int eventIdx = 0; eventIdx<MAX_EVENT; eventIdx++)
{
if (EventList[scriptIndex][eventIdx].object)
CC_free(EventList[scriptIndex][eventIdx].object);
}
IsEventListEmpty[scriptIndex] = 1;
}
memset(EventList[scriptIndex], 0, sizeof(EventList[scriptIndex]));
}
int UpdateEvents(lua_State *L)
{
char luaFunction[512];
int levels[32];
if (L != NULL)
{
updateEvent = true;
return 1;
}
FreeEvents(TheScene->currentScript);
LuaAddAllEvents(TheScene->luaScriptTable[TheScene->currentScript], EventList[TheScene->currentScript]);
IsEventListEmpty[TheScene->currentScript] = 0;
levelsPtr = (void **)CC_malloc(maxLevel*sizeof(void *));
#ifdef EVENT_CONFLICT
levelsCharsPtr = (char **)CC_malloc(maxLevel*sizeof(char *));
#endif
objEventDico.Init();
LuaPreProcessEvent( TheScene->luaScriptTable[TheScene->currentScript],
EventList[TheScene->currentScript],
-1, levels, luaFunction, 0, NULL);
CC_free(levelsPtr);
#ifdef EVENT_CONFLICT
for (int i=0; i<curLevel; i++)
free(levelsCharsPtr[i]);
CC_free(levelsCharsPtr);
#endif
levelsPtr = NULL;
return 1;
}
int AddToEvents(lua_State *L)
{
char *eventName = (char *)lua_tostring(L, 1);
char *UIName = (char *)lua_tostring(L, 2);
char eventNameLocal[2048];
char UINameLocal[1024];
char *eventFunction = eventName;
int eventLevelsTab[128];
int eventLevels = 0;
if (!eventName)
return 0;
//while (strchr(eventFunction, '.'))
// eventFunction = strchr(eventFunction, '.') + 1;
if (UIName == NULL)
strcpy(UINameLocal, "UI");
else
strcpy(UINameLocal, UIName);
memset(eventNameLocal, 0, sizeof(eventNameLocal));
sprintf(eventNameLocal, "%s.%s", UINameLocal, eventName);
lua_getglobal(L, UINameLocal);
eventFunction = eventNameLocal;
eventLevelsTab[eventLevels++] = 0;
while (strchr(eventFunction, '.'))
{
eventLevelsTab[eventLevels++] = (strchr(eventFunction, '.') - eventNameLocal)+1;
*strchr(eventFunction, '.') = 0;
if (eventFunction != eventNameLocal)
{
lua_pushstring(L, eventFunction);
lua_gettable(L, -2);
if (lua_isnil(L, -1))
{
HandleError(L, 0);
return 0;
}
}
eventFunction = eventFunction + strlen(eventFunction) + 1;
}
eventLevelsTab[eventLevels] = (eventFunction - eventNameLocal)+strlen(eventFunction)+1;
lua_pushstring(L, eventFunction);
lua_gettable(L, -2);
if (lua_isfunction(L, -1))
{
int eventIndex = -1;
if (!*EventList[TheScene->currentScript][0].name)
LuaAddAllEvents(L, EventList[TheScene->currentScript]);
for (int Idx = 0; Idx<MAX_EVENT; Idx++)
{
if (!strcmp(EventList[TheScene->currentScript][Idx].name, eventFunction))
{
eventIndex = Idx;
break;
}
}
if (eventIndex == -1)
{
HandleError(L, 0);
return 0;
}
LuaEventAddObject(EventList[TheScene->currentScript], eventIndex, eventNameLocal, eventLevelsTab, eventLevels);
}
lua_pop(L, 1);
return 1;
}
int GetEventsData(lua_State *L)
{
if (currentEvent < nbEventsExec)
{
switch (EventsExec[currentEvent].type)
{
case EVENT_TYPE_MOUSE:
PushMouseInfo(L, (MouseInfo *)EventsExec[currentEvent].data);
break;
case EVENT_TYPE_KEY:
PushInt(L, *((int *)EventsExec[currentEvent].data));
break;
case EVENT_TYPE_STRING:
PushString(L, EventsExec[currentEvent].data);
break;
case EVENT_TYPE_SIZE:
PushPoint(L, (POINT *)EventsExec[currentEvent].data);
break;
}
}
return 1;
}
BOOL WORLD::LuaSetLevel(int changeLevel)
{
nbEventsExec = 0;
if (changeLevel < 0)
{
int newLevel = currentScript + changeLevel;
if (newLevel >= 0)
{
for (int luaIdx = currentScript; luaIdx>newLevel; luaIdx--)
{
if (luaScriptTable[luaIdx])
{
lua_State *luaScriptPtr = luaScriptTable[luaIdx];
luaScriptTable[luaIdx] = NULL;
FreeEvents(luaIdx);
lua_close(luaScriptPtr);
}
}
currentScript = newLevel;
return true;
}
return false;
}
if (changeLevel == 0)
{
for (int luaIdx=MAX_SCRIPTS-1; luaIdx >= 0; luaIdx--)
{
if (luaScriptTable[luaIdx])
{
lua_State *luaScriptPtr = luaScriptTable[luaIdx];
luaScriptTable[luaIdx] = NULL;
FreeEvents(luaIdx);
lua_close(luaScriptPtr);
}
}
currentScript = 0;
return true;
}
if (changeLevel == 1)
{
if ((currentScript+1) < MAX_SCRIPTS)
{
currentScript++;
if (luaScriptTable[currentScript])
{
lua_State *luaScriptPtr = luaScriptTable[currentScript];
luaScriptTable[currentScript] = NULL;
FreeEvents(currentScript);
lua_close(luaScriptPtr);
}
return true;
}
return false;
}
return false;
}
int WORLD::LoadLua(char *filename, BOOL clearParams)
{
LUA_DEBUG_CLEAN();
if (WAIT_OBJECT_0 == WaitForSingleObject(ScriptAccesMutex, INFINITE))
{
lua_State * lua_L;
luaLoaddedFilesDICO.Destroy();
luaLoaddedFilesDICO.Init();
memset(LuaErrors, 0, sizeof(LuaErrors));
SceneScript_DESTROY(&SceneScript_Loop);
if (clearParams == 1 || (currentScript == 0 && clearParams != 2))
{
#ifdef ONLINE_MODE
Account.logOut();
#endif
LuaSetLevel(0);
DestroyAllSMSC();
DestroyAllPGenerator();
DestroyAllMedia();
DestroyAllAnim();
DestroyTrackeur();
if (WSPC) WSPC_Destroy(WSPC);
WSPC = NULL;
u32 Counter = MAX_INIFILES;
while (Counter--)
IniFiles[Counter].Destroy();
IniFileDico.Destroy();
ulFullRefresh = true;
} else if (luaScriptTable[currentScript] != NULL)
{
lua_close(luaScriptTable[currentScript]);
luaScriptTable[currentScript] = NULL;
}
if (currentScript == 0)
VirtuallyDestroyAllMedia();
nbEventsExec = 0;
lua_L = lua_open();
luaL_openlibs(lua_L);
#ifndef SKIMMED_NET
luaopen_socket_core(lua_L); // socket register
#endif
Vector_Register(lua_L);
VectorPtr_Register(lua_L);
Quat_Register(lua_L);
Matrix_Register(lua_L);
#define DEFINE_SCRIPT_SPECIAL(scriptName, functionName, parameters, helpString) \
lua_register(lua_L,#scriptName,functionName);
#define DEFINE_SCRIPT(a,params,Help,b) \
lua_register(lua_L,#a,SCRIPT_##a);
#define DEFINE_SCRIPT_REN(n,a,params,Help,b) \
lua_register(lua_L,#a,SCRIPT_##n); \
lua_register(lua_L,#n,SCRIPT_##n);
#define DEFINE_SCRIPT_ONLINE(a,params,Help,b,c) \
lua_register(lua_L,#a,SCRIPT_##a);
#include "Script_Commands.h"
#ifndef USER_MODE
extern int mainThread;
if (mainThread != GetCurrentThreadId()) MessageBox(NULL, "Bad Threard Access 7!", "YouUp", MB_OK | MB_ICONERROR);
#endif
if(debuggingLua)
{
luaScriptTable[currentScript] = lua_L;
if(!luaL_loadfile(lua_L, filename))
lua_call(lua_L, 0, LUA_MULTRET);
}
else
{
luaScriptTable[currentScript] = lua_L;
if(luaL_loadfile(lua_L, filename) || lua_pcall(lua_L, 0, LUA_MULTRET, 0))
{
if (lua_tostring(lua_L, -1) != NULL)
strcpy(LuaErrors, (char *)lua_tostring(lua_L, -1));
else
strcpy(LuaErrors, "Error Openning LUA File");
SaveDBGInfo(LuaErrors);
lua_close(lua_L);
ReleaseMutex(ScriptAccesMutex);
luaScriptTable[currentScript] = NULL;
return 0;
}
}
luaScriptTable[currentScript] = lua_L;
UpdateEvents(NULL);
ReleaseMutex(ScriptAccesMutex);
}
return 1;
}
int WORLD::LuaHandle(UINT message, WPARAM wParam, LPARAM lParam)
{
BOOL result = 0;
ObjectEventDatas datas;
if (luaScriptTable[currentScript] == NULL) return 0;
if (bManualBoot && !oldManualBoot) return 0;
switch (message)
{
case WM_MOUSEMOVE:
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_LBUTTONDBLCLK:
case 0x020A:
datas.type = EVENT_TYPE_MOUSE;
((MouseInfo *)datas.data)->x = (INT16)LOWORD(lParam);
((MouseInfo *)datas.data)->y = (INT16)HIWORD(lParam);
((MouseInfo *)datas.data)->keys = (INT16)LOWORD(wParam);
((MouseInfo *)datas.data)->value = (INT16)HIWORD(wParam);
break;
case WM_KEYUP:
case WM_KEYDOWN:
datas.type = EVENT_TYPE_KEY;
*((int *)datas.data) = (int) wParam;
break;
case WM_DROPFILES:
{
HDROP hDropFiles = (HDROP)wParam;
int nChar = 1 + DragQueryFile(hDropFiles,0,NULL,0);
datas.type = EVENT_TYPE_STRING;
if (nChar < 256)
DragQueryFile(hDropFiles,0,datas.data,nChar);
else
*datas.data = 0;
//DragFinish(hDropFiles);
}
break;
case WM_SIZE:
datas.type = EVENT_TYPE_SIZE;
((POINT *)datas.data)->x = (INT16)LOWORD(lParam);
((POINT *)datas.data)->y = (INT16)HIWORD(lParam);
break;
case WM_SIZING:
datas.type = EVENT_TYPE_SIZE;
((POINT *)datas.data)->x = ((RECT *)lParam)->right - ((RECT *)lParam)->left;
((POINT *)datas.data)->y = ((RECT *)lParam)->bottom - ((RECT *)lParam)->top;
break;
}
switch (message)
{
case WM_MOUSEMOVE:
result = LuaProcessEventDatas(EVT_onMouseMove, &datas);
break;
case WM_LBUTTONDOWN:
result = LuaProcessEventDatas(EVT_onPressOut, &datas) ||
LuaProcessEventDatas(EVT_onPress, &datas);
PickReportClick = PickReportFinal;
break;
case WM_LBUTTONUP:
result = LuaProcessEventDatas(EVT_onReleaseIn, &datas) ||
LuaProcessEventDatas(EVT_onReleaseOut, &datas) ||
LuaProcessEventDatas(EVT_onRelease, &datas);
memset(&PickReportClick, 0, sizeof(PickReportClick));
break;
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
memset(&PickReportClick, 0, sizeof(PickReportClick));
break;
case WM_LBUTTONDBLCLK:
LuaProcessEventDatas(EVT_onDoubleClick, &datas);
result = 1;
break;
case 0x020A:
if ((int) wParam < 0)
result = LuaProcessEventDatas(EVT_onMouseWheelDown, &datas);
else
result = LuaProcessEventDatas(EVT_onMouseWheelUp, &datas);
result = result || LuaProcessEventDatas(EVT_onMouseWheel, &datas);
break;
case WM_KEYDOWN:
result = LuaProcessEventDatas(EVT_onKeyDown, &datas);
break;
case WM_KEYUP:
result = LuaProcessEventDatas(EVT_onKeyUp, &datas);
break;
case WM_DROPFILES:
result = LuaProcessEventDatas(EVT_onDropFiles, &datas);
break;
case WM_SIZE:
case WM_SIZING:
result = LuaProcessEventDatas(EVT_onWndSize, &datas);
break;
case WM_CLOSE:
case WM_DESTROY:
result = LuaProcessEventDatas(EVT_onExit, &datas);
break;
}
return result;
}
inline int PickingClass(char *str, char *pickingStr, DWORD currentMask)
{
char *pickPtr;
int maskPos = 0;
int strLen = strlen(str);
while ((pickPtr = strchr(pickingStr, '.')) != NULL)
{
if (!(currentMask & (1<<maskPos)) &&
(pickPtr - pickingStr == strLen) &&
!strncmp(str, pickingStr, strLen))
return maskPos;
maskPos++;
pickingStr = pickPtr + 1;
}
if (!(currentMask & (1<<maskPos)) &&
!(strcmp(str, pickingStr)))
return maskPos;
return -1;
}
inline BOOL IsFunctionOnPick(ObjectEventInfo *event, PickingReport *report, INPUT_IO *mediaPtr)
{
DWORD mask[6];
int maskIndex;
BOOL objFound;
char *currentStr;
memset(mask, 0, sizeof(mask));
//1<<0 PickingClass
//1<<1 CollidedSmallSceneName
//1<<2 CollidedSmallSceneGameObjectName
//1<<3 CollidedSmallMaterialName
//1<<4 CollidedMediaName
//1<<5 CollidedMediaNickname
for (int lev=1; lev<event->nbLevels-1; lev++)
{
currentStr = event->luaFunction + event->levels[lev];
if ((maskIndex = PickingClass(currentStr, report->PickingClass, mask[0])) != -1)
{ mask[0] |= (1<<maskIndex); continue; }
if ((maskIndex = PickingClass(currentStr, report->CollidedSmallSceneName, mask[1])) != -1)
{ mask[1] |= (1<<maskIndex); continue; }
if ((maskIndex = PickingClass(currentStr, report->CollidedSmallSceneGameObjectName, mask[2])) != -1)
{ mask[2] |= (1<<maskIndex); continue; }
if ((maskIndex = PickingClass(currentStr, report->CollidedSmallMaterialName, mask[3])) != -1)
{ mask[3] |= (1<<maskIndex); continue; }
if (mediaPtr != NULL && (maskIndex = PickingClass(currentStr, (char *)mediaPtr->MediaName, mask[4])) != -1)
{ mask[4] |= (1<<maskIndex); continue; }
if (mediaPtr != NULL && (maskIndex = PickingClass(currentStr, (char *)mediaPtr->Nickname, mask[5])) != -1)
{ mask[5] |= (1<<maskIndex); continue; }
return false;
}
return true;
}
int WORLD::LuaProcessEvent(int eventNum)
{
ObjectEventDatas datas;
datas.type = EVENT_DATA_NONE;
*datas.data = 0;
return LuaProcessEventDatas(eventNum, &datas);
}
typedef struct PickingReportUId_
{
int PickingClassNb;
UnicID PickingClassId[32];
int CollidedSmallSceneNameNb;
UnicID CollidedSmallSceneNameId[32];
int CollidedSmallSceneGameObjectNameNb;
UnicID CollidedSmallSceneGameObjectNameId[32];
int CollidedSmallMaterialNameNb;
UnicID CollidedSmallMaterialNameId[32];
int MediaNameNb;
UnicID MediaNameId[32];
int NicknameNb;
UnicID NicknameId[32];
} PickingReportUId;
int FillUIDString(char *str, UnicID *idList)
{
char word[512];
char *posPtr;
int posLen;
UnicID id;
int curPos = 0;
while (posPtr = strchr(str, '.'))
{
posLen = posPtr - str;
strncpy(word, str, posLen);
word[posLen] = 0;
id = objEventDico.IsExist(word);
if (id == -1)
return curPos;
idList[curPos++] = id;
str = posPtr + 1;
}
id = objEventDico.IsExist(str);
if (id == -1)
return curPos;
idList[curPos++] = id;
return curPos;
}
void FillPickReportID(PickingReport *PR, PickingReportUId *PRID, INPUT_IO *mediaPtr)
{
PRID->PickingClassNb = FillUIDString(PR->PickingClass, PRID->PickingClassId);
PRID->CollidedSmallSceneNameNb = FillUIDString(PR->CollidedSmallSceneName, PRID->CollidedSmallSceneNameId);
PRID->CollidedSmallSceneGameObjectNameNb= FillUIDString(PR->CollidedSmallSceneGameObjectName, PRID->CollidedSmallSceneGameObjectNameId);
PRID->CollidedSmallMaterialNameNb = FillUIDString(PR->CollidedSmallMaterialName, PRID->CollidedSmallMaterialNameId);
if (mediaPtr)
{
PRID->MediaNameNb = FillUIDString((char *)mediaPtr->MediaName, PRID->MediaNameId);
PRID->NicknameNb = FillUIDString((char *)mediaPtr->Nickname, PRID->NicknameId);
} else
{
PRID->MediaNameNb = -1;
PRID->NicknameNb = -1;
}
}
inline BOOL IsFunctionOnPickID(ObjectEventInfo *event, PickingReportUId *PRID)
{
UnicID *objID = event->objID+1;
int testLvl = event->nbLevels - 2;
int compSize= testLvl*sizeof(UnicID);
if (PRID->PickingClassNb >= testLvl && !memcmp(PRID->PickingClassId, objID, compSize)) return true;
if (PRID->CollidedSmallSceneNameNb >= testLvl && !memcmp(PRID->CollidedSmallSceneNameId, objID, compSize)) return true;
if (PRID->CollidedSmallSceneGameObjectNameNb >= testLvl && !memcmp(PRID->CollidedSmallSceneGameObjectNameId, objID, compSize)) return true;
if (PRID->CollidedSmallMaterialNameNb >= testLvl && !memcmp(PRID->CollidedSmallMaterialNameId, objID, compSize)) return true;
if (PRID->MediaNameNb >= testLvl && !memcmp(PRID->MediaNameId, objID, compSize)) return true;
if (PRID->NicknameNb >= testLvl && !memcmp(PRID->PickingClassId, objID, compSize)) return true;
return false;
}
int WORLD::LuaProcessEventDatas(int eventNum, ObjectEventDatas *dataPtr)
{
DWORD mode = EventList[currentScript][eventNum].mode;
BOOL verifyEqual = (mode >> LUA_MODE_DEC) & 1;
BOOL mainTest = !((mode >> LUA_MAIN_TEST_DEC) & 1);
BOOL process;
ObjectEventInfo *objPtr;
PickingReport *mainReport;
PickingReportUId mainReportID;
PickingReport *compReport;
PickingReportUId compReportID;
START_RASTER(Events);
objPtr = EventList[currentScript][eventNum].object;
switch(mode & 255)
{
case LUA_RESULT_PICK: mainReport = &PickReportResult; break;
case LUA_FINAL_PICK: mainReport = &PickReportFinal; break;
case LUA_PRESSED_PICK: mainReport = &PickReportClick; break;
case LUA_TOWATCH_PICK: mainReport = &PickReportToWatch; break;
default: mainReport = NULL;
}
switch((mode>>LUA_SRC_DEC) & 255)
{
case LUA_RESULT_PICK: compReport = &PickReportResult; break;
case LUA_FINAL_PICK: compReport = &PickReportFinal; break;
case LUA_PRESSED_PICK: compReport = &PickReportClick; break;
case LUA_TOWATCH_PICK: compReport = &PickReportToWatch; break;
default: compReport = NULL;
}
if (mainReport)
FillPickReportID(mainReport, &mainReportID, GetMediaFromImage(mainReport->CollidedMap));
if (compReport)
FillPickReportID(compReport, &compReportID, GetMediaFromImage(compReport->CollidedMap));
for (int objIdx=0; objIdx<EventList[currentScript][eventNum].nbObject; objIdx++, objPtr++)
{
process = !mode || (objPtr->nbLevels <= 2);
if (!process)
{
//for (int idx=0; idx<objPtr->nbLevels; idx++)
//{
// if (!strcmp(objPtr->luaFunction+objPtr->levels[idx], "item3"))
// {
// int BreackPoint = 0;
// }
//}
if (!mainReport) continue;
//if (mainTest == IsFunctionOnPick(objPtr, mainReport, GetMediaFromImage(mainReport->CollidedMap)))
if (mainTest == IsFunctionOnPickID(objPtr, &mainReportID))
{
if (compReport)
{
//process = IsFunctionOnPick(objPtr, compReport, GetMediaFromImage(compReport->CollidedMap)) == verifyEqual;
process = IsFunctionOnPickID(objPtr, &compReportID) == verifyEqual;
} else process = 1;
}
}
if (!process) continue;
dataPtr->infoPtr = objPtr;
AddEventExec(dataPtr);
}
STOP_RASTER(Events);
return 0;
}
/***************************** XML LUA Parse **************************************/
#include "tinyxml.h"
void XmlElmtCreate(lua_State *L, TiXmlElement *xmlElmt)
{
TiXmlAttribute *xmlAttr;
TiXmlNode *xmlChildNode;
int curIndex;
lua_newtable(L); // xml node
if (xmlElmt == NULL)
return;
lua_pushstring(L, "tag");// elmt name
lua_pushstring(L, xmlElmt->Value());
lua_settable(L, -3);
lua_pushstring(L, "attr");// elmt attr
lua_newtable(L);
for (xmlAttr = xmlElmt->FirstAttribute(), curIndex = 1;
xmlAttr; xmlAttr = xmlAttr->Next())
{
lua_pushnumber(L, curIndex++);
lua_pushstring(L, xmlAttr->Name());
lua_settable(L, -3);
lua_pushstring(L, xmlAttr->Name());
lua_pushstring(L, xmlAttr->Value());
lua_settable(L, -3);
}
lua_settable(L, -3);
for (xmlChildNode = xmlElmt->FirstChild(), curIndex = 1;
xmlChildNode; xmlChildNode = xmlChildNode->NextSibling())
{
if (xmlChildNode->Type() == TiXmlNode::TEXT)
{
lua_pushnumber(L, curIndex++);
lua_pushstring(L, xmlChildNode->Value());
lua_settable(L, -3);
} else if (xmlChildNode->Type() == TiXmlNode::ELEMENT)
{
lua_pushnumber(L, curIndex++);
XmlElmtCreate(L, (TiXmlElement *)xmlChildNode);
lua_settable(L, -3);
}
}
}
BOOL XmlCreate(lua_State *L, char *xmlStr)
{
TiXmlDocument xmlDoc;
TiXmlElement *xmlElmt;
if (!xmlStr) return 0;
xmlDoc.Parse(xmlStr);
xmlElmt = xmlDoc.RootElement();
if (xmlElmt == NULL)
return 0;
XmlElmtCreate(L, xmlElmt);
return 1;
}
BOOL WORLD::Xml2Lua(lua_State *L, char *buffer)
{
if (L && buffer)
{
char *xmlStr = (char *)buffer;
if (XmlCreate(L, xmlStr))
return 1;
}
lua_pushnil(L);
return 0;
}
Reference in a new issue View git blame Copy permalink