void ScrollableGamePanel::_positionMap()
{
lua_State *L = getLua();
if(!L)
{
return;
}
lua_getglobal(L, "TheApp");
if(lua_isnil(L, -1))
{
lua_pop(L, 1);
return;
}
lua_getfield(L, -1, "ui");
if(lua_isnil(L, -1))
{
lua_pop(L, 2);
return;
}
lua_replace(L, -2);
lua_getfield(L, -1, "scrollMapTo");
lua_insert(L, -2);
lua_pushinteger(L, m_pMapScrollX->GetThumbPosition() - m_pMapScrollX->GetRange() / 2 + m_pMapScrollX->GetThumbSize() / 2);
lua_pushinteger(L, m_pMapScrollY->GetThumbPosition());
m_bShouldRespondToScroll = false;
lua_call(L, 3, 1);
m_bShouldRespondToScroll = true;
m_pGamePanel->Refresh(false);
}
int main(int argc, char *argv[]) {
auto kampf = Kampf(enumInitType::Basic);
auto lua = kampf.getLua();
lua->loadScript("kampf_render.lua");
return 0;
}
// *********************************************************************************************************
void CDisplayerLua::CToLua::executeHandler(const CLuaString &eventName, int numArgs)
{
CLuaState &ls = *getLua();
CLuaStackRestorer lsr(&ls, ls.getTop() - numArgs);
//
if (!_LuaTable.isValid()) return; // init failed
if (_LuaTable[eventName].isNil()) return; // event not handled
static volatile bool dumpStackWanted = false;
if (dumpStackWanted) ls.dumpStack();
_LuaTable[eventName].push();
if (dumpStackWanted) ls.dumpStack();
// put method before its args
ls.insert(- numArgs - 1);
if (dumpStackWanted) ls.dumpStack();
// this is a method call
_LuaTable.push();
if (dumpStackWanted) ls.dumpStack();
ls.insert(- numArgs - 1);
if (dumpStackWanted) ls.dumpStack();
// First arg always is the instance being displayed
if (getEnclosing())
getEnclosing()->getDisplayedInstance()->getLuaProjection().push();
ls.insert(- numArgs - 1);
if (dumpStackWanted) ls.dumpStack();
CLuaIHM::executeFunctionOnStack(*_LuaTable.getLuaState(), numArgs + 2, 0);
if (dumpStackWanted) ls.dumpStack();
}
void ShowStats(Serial *serial, unsigned int argc, char **argv){
serial->put_s("== Memory Info ==\r\n");
unsigned long heap = (unsigned long)_heap_address;
unsigned long lastPointer = getLastPointer();
serial->put_s("Heap address :");
put_uint(serial, heap);
put_crlf(serial);
serial->put_s("Last pointer address :");
put_uint(serial, lastPointer);
put_crlf(serial);
serial->put_s("Heap size :");
put_uint(serial, (unsigned int)&_CONFIG_HEAP_SIZE);
put_crlf(serial);
serial->put_s("Estimated Usage :");
put_uint(serial, lastPointer - heap);
put_crlf(serial);
serial->put_s("== Lua Info ==\r\n");
lua_State *L = getLua();
lua_gc(L,LUA_GCCOLLECT,0);
serial->put_s("Lua Top :");
put_int(serial, lua_gettop(L));
put_crlf(serial);
serial->put_s("Lua GC Count :");
put_int(serial, lua_gc(L,LUA_GCCOUNT,0));
put_crlf(serial);
serial->put_s("== Misc ==\r\n");
serial->put_s("sizeof LoggerConfig :");
put_int(serial, sizeof(LoggerConfig));
put_crlf(serial);
serial->put_s("sizeof SampleRecord :");
put_int(serial, sizeof(SampleRecord));
put_crlf(serial);
}
// *********************************************************************************************************
void CLuaEventForwarder::onSelect(bool selected)
{
//H_AUTO(R2_CLuaEventForwarder_onSelect)
CLuaState *ls = getLua();
if (!ls) return;
ls->push(selected);
executeHandler(LuaStr_onSelect, 1);
}
// *********************************************************************************************************
void CLuaEventForwarder::onFocus(bool focused)
{
//H_AUTO(R2_CLuaEventForwarder_onFocus)
CLuaState *ls = getLua();
if (!ls) return;
ls->push(focused);
executeHandler(LuaStr_onFocus, 1);
}
// *********************************************************************************************************
void CLuaEventForwarder::onTargetInstancePostHrcMove(const std::string &refMakerAttr, sint32 refMakerAttrIndex)
{
//H_AUTO(R2_CLuaEventForwarder_onTargetInstancePostHrcMove)
CLuaState *ls = getLua();
if (!ls) return;
ls->push(refMakerAttr);
ls->push((double) refMakerAttrIndex);
executeHandler(LuaStr_onTargetInstancePostHrcMove, 2);
}
// *********************************************************************************************************
void CLuaEventForwarder::onAttrModified(const std::string &attrName, sint32 index)
{
//H_AUTO(R2_CLuaEventForwarder_onAttrModified)
CLuaState *ls = getLua();
if (!ls) return;
ls->push(attrName);
ls->push((double) index);
executeHandler(LuaStr_onAttrModified, 2);
}
int main(int argc, char *argv[]) {
auto kampf = Kampf(enumInitType::Basic);
auto lua = kampf.getLua();
//include scripts folder from kampf
lua->addPath("../scripts/engine/?.lua");
lua->loadScript("pong.lua");
return 0;
}
// *********************************************************************************************************
void CLuaEventForwarder::onTargetInstanceAttrModified(const std::string &refMakerAttr, sint32 refMakerAttrIndex, const std::string &targetAttrName, sint32 targetAttrIndex)
{
//H_AUTO(R2_CLuaEventForwarder_onTargetInstanceAttrModified)
CLuaState *ls = getLua();
if (!ls) return;
ls->push(refMakerAttr);
ls->push((double) refMakerAttrIndex);
ls->push(targetAttrName);
ls->push((double) targetAttrIndex);
executeHandler(LuaStr_onTargetInstanceAttrModified, 4);
}
void ExecLuaInterpreter(Serial *serial, unsigned int argc, char **argv)
{
g_interactive_mode = 1;
serial->put_s("Entering Lua Interpreter. enter 'exit' to leave");
put_crlf(serial);
lua_State *L = getLua();
cmd_context *cmdContext = get_command_context();
char * luaLine = cmdContext->lineBuffer;
int result;
while(1) {
serial->put_s("> ");
interactive_read_line(serial, luaLine, cmdContext->lineBufferSize);
if (strcmp(luaLine,"exit") == 0) break;
lockLua();
lua_gc(L,LUA_GCCOLLECT,0);
result = luaL_loadbuffer(L, luaLine, strlen(luaLine), "");
if (0 != result) {
serial->put_s("error: (");
serial->put_s(lua_tostring(L,-1));
serial->put_s(")");
put_crlf(serial);
lua_pop(L,1);
} else {
lua_pushvalue(L,-1);
result = lua_pcall(L,0,0,0);
if (0 != result) {
serial->put_s("error: (");
serial->put_s(lua_tostring(L,-1));
serial->put_s(")");
put_crlf(serial);
lua_pop(L,1);
}
lua_pop(L,1);
}
unlockLua();
}
g_interactive_mode = 0;
}
void ShowStats(Serial *serial, unsigned int argc, char **argv)
{
// Memory Info
putHeader(serial, "Memory Info");
putDataRowHeader(serial, "Total Memory");
put_uint(serial, (unsigned int) &_CONFIG_HEAP_SIZE);
put_crlf(serial);
putDataRowHeader(serial, "Free Memory");
put_uint(serial, portGetFreeHeapSize());
put_crlf(serial);
// LUA Info
putHeader(serial, "Lua Info");
//TODO: this was done for unit testing. fix when Lua runtime is part of unit testing framework
lua_State *L = (lua_State *) getLua();
lua_gc(L, LUA_GCCOLLECT, 0);
putDataRowHeader(serial, "Lua Top");
put_int(serial, lua_gettop(L));
put_crlf(serial);
putDataRowHeader(serial, "Lua Memory Usage (KB)");
put_int(serial, lua_gc(L, LUA_GCCOUNT, 0));
put_crlf(serial);
// Misc Info
putHeader(serial, "Misc");
putDataRowHeader(serial, "Size of LoggerConfig");
put_int(serial, sizeof(LoggerConfig));
put_crlf(serial);
putDataRowHeader(serial, "Size of ChannelSample");
put_int(serial, sizeof(ChannelSample));
put_crlf(serial);
}
// *********************************************************************************************************
void CLuaEventForwarder::onPostHrcMove()
{
//H_AUTO(R2_CLuaEventForwarder_onPostHrcMove)
if (!getLua()) return;
executeHandler(LuaStr_onPostHrcMove, 0);
}
// *********************************************************************************************************
void CLuaEventForwarder::onErase()
{
//H_AUTO(R2_CLuaEventForwarder_onErase)
if (!getLua()) return;
executeHandler(LuaStr_onErase, 0);
}
// *********************************************************************************************************
void CLuaEventForwarder::onContinentChanged()
{
//H_AUTO(R2_CLuaEventForwarder_onContinentChanged)
if (!getLua()) return;
executeHandler(LuaStr_onContinentChanged, 0);
}
