void CScriptKeyBinds::Call ( CScriptKeyBind* pKeyBind )
{
if ( pKeyBind && !pKeyBind->IsBeingDeleted () )
{
switch ( pKeyBind->GetType () )
{
case SCRIPT_KEY_BIND_FUNCTION:
{
CScriptKeyFunctionBind* pBind = static_cast < CScriptKeyFunctionBind* > ( pKeyBind );
if ( pBind->luaMain && VERIFY_FUNCTION( pBind->m_iLuaFunction ) )
{
CLuaArguments Arguments;
Arguments.PushString ( pBind->boundKey->szKey );
Arguments.PushString ( ( pBind->bHitState ) ? "down" : "up" );
Arguments.PushArguments ( pBind->m_Arguments );
Arguments.Call ( pBind->luaMain, pBind->m_iLuaFunction );
}
break;
}
case SCRIPT_KEY_BIND_CONTROL_FUNCTION:
{
CScriptControlFunctionBind* pBind = static_cast < CScriptControlFunctionBind* > ( pKeyBind );
if ( pBind->luaMain && VERIFY_FUNCTION( pBind->m_iLuaFunction ) )
{
CLuaArguments Arguments;
Arguments.PushString ( pBind->boundControl->szControl );
Arguments.PushString ( ( pBind->bHitState ) ? "down" : "up" );
Arguments.PushArguments ( pBind->m_Arguments );
Arguments.Call ( pBind->luaMain, pBind->m_iLuaFunction );
}
break;
}
}
}
}
void CRemoteCall::ProgressCallback(double sizeJustDownloaded, double totalDownloaded, char * data, size_t dataLength, void * obj, bool complete, int error)
{
//printf("Progress: %s\n", data);
if ( complete )
{
CRemoteCall * call = (CRemoteCall*)obj;
if ( g_pGame->GetRemoteCalls()->CallExists(call) )
{
//printf("RECIEVED: %s\n", data);
CLuaArguments arguments;
arguments.ReadFromJSONString ( data );
arguments.Call ( call->m_VM, call->m_iFunction);
g_pGame->GetRemoteCalls()->Remove(call); // delete ourselves
}
}
else if ( error )
{
CRemoteCall * call = (CRemoteCall*)obj;
if ( g_pGame->GetRemoteCalls()->CallExists(call) )
{
CLuaArguments arguments;
arguments.PushString("ERROR");
arguments.PushNumber(error);
arguments.Call ( call->m_VM, call->m_iFunction);
g_pGame->GetRemoteCalls()->Remove(call); // delete ourselves
}
}
}
void CRegisteredCommands::CallCommandHandler ( CLuaMain* pLuaMain, const CLuaFunctionRef& iLuaFunction, const char* szKey, const char* szArguments )
{
assert ( pLuaMain );
assert ( szKey );
CLuaArguments Arguments;
Arguments.PushString ( szKey );
if ( szArguments )
{
// Create a copy and strtok modifies the string
char * szTempArguments = new char[strlen(szArguments) + 1];
strcpy ( szTempArguments, szArguments );
char * arg;
arg = strtok ( szTempArguments, " " );
while ( arg )
{
Arguments.PushString ( arg );
arg = strtok ( NULL, " " );
}
delete [] szTempArguments;
}
// Call the handler with the arguments we pushed
Arguments.Call ( pLuaMain, iLuaFunction );
}
bool CRemoteCall::ProgressCallback(double sizeJustDownloaded, double totalDownloaded, char * data, size_t dataLength, void * obj, bool complete, int error)
{
//printf("Progress: %s\n", data);
if ( complete )
{
CRemoteCall * call = (CRemoteCall*)obj;
if ( g_pGame->GetRemoteCalls()->CallExists(call) )
{
//printf("RECIEVED: %s\n", data);
CLuaArguments arguments;
if ( call->IsFetch () )
{
arguments.PushString ( std::string ( data, dataLength ) );
arguments.PushNumber ( 0 );
for ( uint i = 0 ; i < call->GetFetchArguments ().Count () ; i++ )
arguments.PushArgument ( *( call->GetFetchArguments ()[i] ) );
}
else
arguments.ReadFromJSONString ( data );
arguments.Call ( call->m_VM, call->m_iFunction);
g_pGame->GetRemoteCalls()->Remove(call); // delete ourselves
return true;
}
}
else if ( error )
{
CRemoteCall * call = (CRemoteCall*)obj;
if ( g_pGame->GetRemoteCalls()->CallExists(call) )
{
CLuaArguments arguments;
arguments.PushString("ERROR");
arguments.PushNumber(error);
if ( call->IsFetch () )
for ( uint i = 0 ; i < call->GetFetchArguments ().Count () ; i++ )
arguments.PushArgument ( *( call->GetFetchArguments ()[i] ) );
arguments.Call ( call->m_VM, call->m_iFunction);
g_pGame->GetRemoteCalls()->Remove(call); // delete ourselves
return true;
}
}
return false; // Possible problem
}
void CRemoteCall::DownloadFinishedCallback(const SHttpDownloadResult& result)
{
CRemoteCall* pCall = (CRemoteCall*)result.pObj;
if (!g_pClientGame->GetRemoteCalls()->CallExists(pCall))
return;
CLuaArguments arguments;
if (pCall->IsLegacy())
{
if (result.bSuccess)
{
if (pCall->IsFetch())
{
arguments.PushString(std::string(result.pData, result.dataSize));
arguments.PushNumber(0);
}
else
arguments.ReadFromJSONString(result.pData);
}
else
{
arguments.PushString("ERROR");
arguments.PushNumber(result.iErrorCode);
}
}
else
{
// Append response body
arguments.PushString(std::string(result.pData, result.dataSize));
// Append info table
CLuaArguments info;
info.PushString("success");
info.PushBoolean(result.iErrorCode >= 200 && result.iErrorCode <= 299);
info.PushString("statusCode");
info.PushNumber(result.iErrorCode);
// Headers as a subtable
CLuaArguments headers;
for (auto iter : result.headers )
{
headers.PushString(iter.first);
headers.PushString(iter.second);
}
info.PushString("headers");
info.PushTable(&headers);
arguments.PushTable(&info);
}
// Append stored arguments
if (pCall->IsFetch())
for (uint i = 0; i < pCall->GetFetchArguments().Count(); i++ )
arguments.PushArgument(*(pCall->GetFetchArguments()[i]));
arguments.Call(pCall->m_VM, pCall->m_iFunction);
g_pClientGame->GetRemoteCalls()->Remove(pCall);
}
void CMapEvent::Call ( const CLuaArguments& Arguments )
{
if ( m_pMain )
{
// Call our function with the given arguments
Arguments.Call ( m_pMain, m_iLuaFunction );
}
}
void CRegisteredCommands::CallCommandHandler(CLuaMain* pLuaMain, const CLuaFunctionRef& iLuaFunction, const char* szKey, const char* szArguments,
CClient* pClient)
{
assert(pLuaMain);
assert(szKey);
CLuaArguments Arguments;
// First, try to call a handler with the same number of arguments
if (pClient)
{
switch (pClient->GetClientType())
{
case CClient::CLIENT_PLAYER:
{
Arguments.PushElement(static_cast<CPlayer*>(pClient));
break;
}
case CClient::CLIENT_CONSOLE:
{
Arguments.PushElement(static_cast<CConsoleClient*>(pClient));
break;
}
default:
{
Arguments.PushBoolean(false);
break;
}
}
}
else
Arguments.PushBoolean(false);
Arguments.PushString(szKey);
if (szArguments)
{
// Create a copy and strtok modifies the string
char* szTempArguments = new char[strlen(szArguments) + 1];
strcpy(szTempArguments, szArguments);
char* arg;
arg = strtok(szTempArguments, " ");
while (arg)
{
Arguments.PushString(arg);
arg = strtok(NULL, " ");
}
delete[] szTempArguments;
}
// Call the handler with the arguments we pushed
Arguments.Call(pLuaMain, iLuaFunction);
}
int CLuaFunctionDefs::RequestBrowserDomains ( lua_State* luaVM )
{
// bool requestBrowserDomains ( table domains, bool isURL [, function callback ] )
std::vector<SString> pages; bool bIsURL; CLuaFunctionRef callbackFunction;
CScriptArgReader argStream ( luaVM );
argStream.ReadStringTable ( pages );
argStream.ReadBool ( bIsURL, false );
argStream.ReadFunction ( callbackFunction, LUA_REFNIL );
argStream.ReadFunctionComplete ();
if ( !argStream.HasErrors () )
{
// Convert to domains if we got a list of URLs
if ( bIsURL )
{
for ( auto& strURL : pages )
{
strURL = g_pCore->GetWebCore ()->GetDomainFromURL ( strURL );
}
}
WebRequestCallback callback = [=]( bool bAllow, const std::vector<SString>& domains ) {
// Test if luaVM is still available
if ( m_pLuaManager->IsLuaVMValid ( luaVM ) && VERIFY_FUNCTION ( callbackFunction ) )
{
CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
if ( !pLuaMain )
return;
CLuaArguments arguments;
arguments.PushBoolean ( bAllow );
CLuaArguments LuaTable;
int i = 0;
for ( const auto& domain : domains )
{
LuaTable.PushNumber ( ++i );
LuaTable.PushString ( domain );
}
arguments.PushTable ( &LuaTable );
arguments.Call ( pLuaMain, callbackFunction );
}
};
g_pCore->GetWebCore ()->RequestPages ( pages, VERIFY_FUNCTION ( callbackFunction ) ? &callback : nullptr );
lua_pushboolean ( luaVM, true );
return 1;
}
else
m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
lua_pushboolean ( luaVM, false );
return 1;
}
void CKeyBinds::Call ( CKeyBind* pKeyBind )
{
if ( pKeyBind && !pKeyBind->IsBeingDeleted () )
{
switch ( pKeyBind->GetType () )
{
case KEY_BIND_FUNCTION:
{
CKeyFunctionBind* pBind = static_cast < CKeyFunctionBind* > ( pKeyBind );
if ( pBind->luaMain && pBind->m_iLuaFunction != LUA_REFNIL )
{
CLuaArguments Arguments;
Arguments.PushElement ( m_pPlayer );
Arguments.PushString ( pBind->boundKey->szKey );
Arguments.PushString ( ( pBind->bHitState ) ? "down" : "up" );
Arguments.PushArguments ( pBind->m_Arguments );
Arguments.Call ( pBind->luaMain, pBind->m_iLuaFunction );
}
break;
}
case KEY_BIND_CONTROL_FUNCTION:
{
CControlFunctionBind* pBind = static_cast < CControlFunctionBind* > ( pKeyBind );
if ( pBind->luaMain && pBind->m_iLuaFunction != LUA_REFNIL )
{
CLuaArguments Arguments;
Arguments.PushElement ( m_pPlayer );
Arguments.PushString ( pBind->boundControl->szControl );
Arguments.PushString ( ( pBind->bHitState ) ? "down" : "up" );
Arguments.PushArguments ( pBind->m_Arguments );
Arguments.Call ( pBind->luaMain, pBind->m_iLuaFunction );
}
break;
}
default:
break;
}
}
}
void CSocket::TriggerEvent(const string eventName, const string arg1)
{
CLuaArguments args;
args.PushString(eventName.c_str());
lua_getglobal(m_pLuaVM, "root");
CLuaArgument RootElement(m_pLuaVM, -1);
args.PushUserData(RootElement.GetLightUserData());
args.PushUserData(m_pUserdata);
if (arg1.length() > 0)
args.PushString(arg1.c_str());
args.Call(m_pLuaVM, "triggerEvent");
}
int CLuaFunctionDefs::GetBrowserSource ( lua_State* luaVM )
{
// bool getBrowserSource ( function callback )
CClientWebBrowser* pWebBrowser; CLuaFunctionRef callbackFunction;
CScriptArgReader argStream ( luaVM );
argStream.ReadUserData ( pWebBrowser );
argStream.ReadFunction ( callbackFunction );
argStream.ReadFunctionComplete ();
if ( !argStream.HasErrors () )
{
CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
if ( pLuaMain && VERIFY_FUNCTION ( callbackFunction ) )
{
pWebBrowser->GetSourceCode ( [callbackFunction, pLuaMain]( const std::string& code ) {
/*
This function should not be called when the resource is about to stop as
stopping the resource destroys the browser element and thus cancels the
CefStringVisitor callback class (see CWebView::GetSourceCode::MyStringVisitor)
*/
if ( VERIFY_FUNCTION ( callbackFunction ) )
{
CLuaArguments arguments;
// TODO: Use SCharStringRef/direct string access instead of copying strings around
arguments.PushString ( code );
arguments.Call ( pLuaMain, callbackFunction );
}
});
lua_pushboolean ( luaVM, true );
return 1;
}
}
else
m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
lua_pushboolean ( luaVM, false );
return 1;
}
int CLuaFunctionDefs::Load( lua_State* luaVM )
{
// func,err load( callback callbackFunction[, string name] )
CLuaFunctionRef iLuaFunction; SString strName;
CScriptArgReader argStream( luaVM );
argStream.ReadFunction( iLuaFunction );
argStream.ReadString( strName, "=(load)" );
argStream.ReadFunctionComplete();
if ( !argStream.HasErrors() )
{
// Call supplied function to get all the bits
// Should apply some limit here?
SString strInput;
CLuaArguments callbackArguments;
CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine( luaVM );
while( pLuaMain )
{
CLuaArguments returnValues;
callbackArguments.Call( pLuaMain, iLuaFunction, &returnValues );
if ( returnValues.Count() )
{
CLuaArgument* returnedValue = *returnValues.IterBegin();
if ( returnedValue->GetType() == LUA_TSTRING )
{
strInput += returnedValue->GetString();
continue;
}
}
break;
}
const char* szChunkname = *strName;
const char* cpInBuffer = strInput;
uint uiInSize = strInput.length();
// Decrypt if required
const char* cpBuffer;
uint uiSize;
if ( !g_pNet->DecryptScript( cpInBuffer, uiInSize, &cpBuffer, &uiSize, m_pResourceManager->GetResourceName( luaVM ) + "/load" ) )
{
SString strMessage( "argument 2 is invalid. Please re-compile at http://luac.mtasa.com/", 0 );
argStream.SetCustomError( strMessage );
cpBuffer = NULL;
g_pCore->GetConsole()->Print( argStream.GetFullErrorMessage() );
g_pClientGame->TellServerSomethingImportant( 1005, argStream.GetFullErrorMessage(), true );
}
if ( !argStream.HasErrors() )
{
CLuaShared::CheckUTF8BOMAndUpdate ( &cpBuffer, &uiSize );
if ( !CLuaMain::LuaLoadBuffer( luaVM, cpBuffer, uiSize, szChunkname ) )
{
// Ok
return 1;
}
else
{
lua_pushnil( luaVM );
lua_insert( luaVM, -2 ); /* put before error message */
return 2; /* return nil plus error message */
}
}
}
if ( argStream.HasErrors() )
m_pScriptDebugging->LogCustom( luaVM, argStream.GetFullErrorMessage() );
lua_pushboolean( luaVM, false );
return 1;
}
int CLuaFunctionDefs::SetBrowserAjaxHandler ( lua_State* luaVM )
{
// bool setBrowserAjaxHandler ( browser browser, string URL[, function callback] )
CClientWebBrowser* pWebBrowser; SString strURL; CLuaFunctionRef callbackFunction;
CScriptArgReader argStream ( luaVM );
argStream.ReadUserData ( pWebBrowser );
argStream.ReadString ( strURL );
if ( argStream.NextIsNil () || argStream.NextIsNone () )
{
if ( !argStream.HasErrors () )
{
lua_pushboolean ( luaVM, pWebBrowser->RemoveAjaxHandler ( strURL ) );
return 1;
}
else
m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
}
else
{
argStream.ReadFunction ( callbackFunction );
argStream.ReadFunctionComplete ();
if ( !argStream.HasErrors () )
{
CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
if ( pLuaMain && VERIFY_FUNCTION ( callbackFunction ) )
{
CResource* pResource = pLuaMain->GetResource ();
CResourceManager * pResourceManager = m_pResourceManager;
auto netId = pResource->GetNetID ();
bool bResult = pWebBrowser->AddAjaxHandler ( strURL,
[=] ( std::vector<SString>& vecGet, std::vector<SString>& vecPost ) -> const SString
{
// Make sure the resource is still running
if ( !pResourceManager->Exists ( pResource ) || pResource->GetNetID() != netId )
{
return "";
}
// Make sure the function is valid
if ( VERIFY_FUNCTION ( callbackFunction ) )
{
CLuaArguments arguments;
CLuaArguments getArguments;
CLuaArguments postArguments;
for ( auto&& param : vecGet )
getArguments.PushString ( param );
for ( auto&& param : vecPost )
postArguments.PushString ( param );
arguments.PushTable ( &getArguments );
arguments.PushTable ( &postArguments );
CLuaArguments result;
arguments.Call ( pLuaMain, callbackFunction, &result );
if ( result.Count () == 0 )
return "";
CLuaArgument* returnedValue = *result.IterBegin ();
if ( returnedValue->GetType () == LUA_TSTRING )
return returnedValue->GetString ();
else
return "";
}
else
return "";
} );
lua_pushboolean ( luaVM, bResult );
return 1;
}
}
else
m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
}
lua_pushboolean ( luaVM, false );
return 1;
}
