ChronosXYZ/mta-mono
1
0
Fork 0
mirror of https://github.com/ChronosX88/mta-mono.git synced 2024-11-24 11:12:20 +00:00
Code Issues Projects Releases Wiki Activity

Refactoring of CLuaArgument, CLuaArguments and CLuaFunctionDefinitions.

Browse Source 
Fixed memory leaks.
Fixed some performance issues.
Fixed CMonoFunctions::Element::GetByType.
This commit is contained in:
Kernell 2015-12-27 19:41:07 +03:00
parent 9809a54479
commit f395553923
13 changed files with 1137 additions and 1087 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
mta-mono/src/CMonoDomain.h
View File

@ -60,36 +60,46 @@ public:
MonoString* NewString ( const char* szText );
MonoString* NewString ( string strText );
template <class T, int LuaType>
MonoArray* NewArray ( MonoClass* pMonoClass, CLuaArguments* pLuaArguments = NULL )
template <class T, int iLuaType>
MonoArray* NewArray ( MonoClass* pMonoClass, CLuaArgumentsVector* pLuaArguments = nullptr )
{
MonoArray* pArray = mono_array_new( this->m_pDomain, pMonoClass, pLuaArguments ? pLuaArguments->Count() : 0 );
MonoArray* pArray = mono_array_new( this->m_pDomain, pMonoClass, pLuaArguments ? pLuaArguments->size() : 0 );
if( pLuaArguments )
{
int i = 0;
for( auto iter : pLuaArguments->GetArguments() )
for( const auto& pArgument : *pLuaArguments )
{
if( LuaType == LUA_TBOOLEAN )
switch( iLuaType )
{
mono_array_set( pArray, T, i++, (T)( iter->GetBoolean() ) );
}
else if( LuaType == LUA_TLIGHTUSERDATA )
{
mono_array_set( pArray, T, i++, (T)( iter->GetLightUserData() ) );
}
else if( LuaType == LUA_TNUMBER )
{
mono_array_set( pArray, T, i++, iter->GetNumber< T >() );
}
else if( LuaType == LUA_TSTRING )
{
mono_array_set( pArray, T, i++, (T)( iter->GetString() ) );
}
else if( LuaType == LUA_TUSERDATA )
{
mono_array_set( pArray, T, i++, (T)( iter->GetLightUserData() ) );
case LUA_TBOOLEAN:
{
mono_array_set( pArray, T, i++, (T)( pArgument.GetBoolean() ) );
break;
}
case LUA_TNUMBER:
{
mono_array_set( pArray, T, i++, pArgument.GetNumber< T >() );
break;
}
case LUA_TSTRING:
{
MonoString* msValue = this->NewString( pArgument.GetString() );
mono_array_set( pArray, MonoString*, i++, msValue );
break;
}
case LUA_TLIGHTUSERDATA:
case LUA_TUSERDATA:
{
mono_array_set( pArray, T, i++, reinterpret_cast< T >( pArgument.GetLightUserData() ) );
break;
}
}
}
}

30
mta-mono/src/CMonoFunctions.cpp
View File

@ -815,22 +815,22 @@ MonoObject* CMonoFunctions::Server::GetVersion( void )
{
if( RESOURCE )
{
LuaTable pLuaTable = CLuaFunctionDefinitions::GetVersion( RESOURCE->GetLua() );
CLuaArgumentsMap pLuaTable = CLuaFunctionDefinitions::GetVersion( RESOURCE->GetLua() );
if( !pLuaTable.empty() )
if( pLuaTable.size() >= 8 )
{
unsigned long ulNumber = pLuaTable[ "number" ]->GetNumber< unsigned long >();
const char* szString = pLuaTable[ "mta" ]->GetString();
const char* szName = pLuaTable[ "name" ]->GetString();
const char* szBuildType = pLuaTable[ "type" ]->GetString();
unsigned long ulNetcode = pLuaTable[ "netcode" ]->GetNumber< unsigned long >();
const char* szOS = pLuaTable[ "os" ]->GetString();
const char* szBuildTag = pLuaTable[ "tag" ]->GetString();
const char* szSortable = pLuaTable[ "sortable" ]->GetString();
unsigned long ulNumber = pLuaTable[ "number" ].GetNumber< unsigned long >();
const char* szString = pLuaTable[ "mta" ].GetString();
const char* szName = pLuaTable[ "name" ].GetString();
const char* szBuildType = pLuaTable[ "type" ].GetString();
unsigned long ulNetcode = pLuaTable[ "netcode" ].GetNumber< unsigned long >();
const char* szOS = pLuaTable[ "os" ].GetString();
const char* szBuildTag = pLuaTable[ "tag" ].GetString();
const char* szSortable = pLuaTable[ "sortable" ].GetString();
CMonoCorlib* pLib = RESOURCE->GetDomain()->GetCorlib();
PVOID* args = new PVOID[ 8 ];
PVOID* args = new PVOID[ pLuaTable.size() ];
MonoObject* pNumber = pLib->Class[ "uint64" ]->Box( &ulNumber );
MonoString* pString = RESOURCE->GetDomain()->NewString( szString );
@ -850,11 +850,15 @@ MonoObject* CMonoFunctions::Server::GetVersion( void )
args[ 6 ] = pBuildTag;
args[ 7 ] = pSortable;
return RESOURCE->GetDomain()->GetMTALib()->GetClass( "ServerVersion" )->New( args, 8 );
MonoObject* pObject = RESOURCE->GetDomain()->GetMTALib()->GetClass( "ServerVersion" )->New( args, pLuaTable.size() );
delete [] args;
return pObject;
}
}
return NULL;
return nullptr;
}
MonoString* CMonoFunctions::Game::GetType( void )

7
mta-mono/src/CMonoFunctions_Account.cpp
View File

@ -31,9 +31,12 @@ MonoArray* CMonoFunctions::Account::GetAll( void )
{
if( RESOURCE )
{
CLuaArguments* pLuaTable = CLuaFunctionDefinitions::GetAccounts( RESOURCE->GetLua() );
CLuaArgumentsVector pLuaTable = CLuaFunctionDefinitions::GetAccounts( RESOURCE->GetLua() );
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), pLuaTable );
if( pLuaTable.size() > 0 )
{
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), &pLuaTable );
}
}
return nullptr;

13
mta-mono/src/CMonoFunctions_Element.cpp
View File

@ -66,9 +66,12 @@ MonoArray* CMonoFunctions::Element::GetByType( MonoString* msType, DWORD pStartE
{
const char* szType = mono_string_to_utf8( msType );
CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetElementsByType( RESOURCE->GetLua(), szType, (void*)pStartElement );
CLuaArgumentsVector pLuaArguments = CLuaFunctionDefinitions::GetElementsByType( RESOURCE->GetLua(), szType, (PVOID)pStartElement );
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), pLuaArguments );
if( pLuaArguments.size() )
{
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), &pLuaArguments );
}
}
return nullptr;
@ -454,11 +457,11 @@ DWORD CMonoFunctions::Element::GetLowLod( DWORD pUserData )
{
if( RESOURCE )
{
void* pUserData;
PVOID pLODUserData;
if( CLuaFunctionDefinitions::GetLowLodElement( RESOURCE->GetLua(), (void*)pUserData, pUserData ) )
if( CLuaFunctionDefinitions::GetLowLodElement( RESOURCE->GetLua(), (PVOID)pUserData, pLODUserData ) )
{
return (DWORD)pUserData;
return (DWORD)pLODUserData;
}
}

42
mta-mono/src/CMonoFunctions_Player.cpp
View File

@ -124,20 +124,11 @@ MonoArray* CMonoFunctions::Player::GetAlivePlayers( void )
{
if( RESOURCE )
{
CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetAlivePlayers( RESOURCE->GetLua() );
CLuaArgumentsVector pLuaArguments = CLuaFunctionDefinitions::GetAlivePlayers( RESOURCE->GetLua() );
if( pLuaArguments )
if( pLuaArguments.size() > 0 )
{
MonoArray* pArray = mono_array_new( RESOURCE->GetDomain()->GetMonoPtr(), mono_get_uint32_class(), pLuaArguments->Count() );
vector< CLuaArgument* >::const_iterator iter = pLuaArguments->IterBegin();
for( unsigned int i = 0; iter != pLuaArguments->IterEnd(); iter++, i++ )
{
mono_array_set( pArray, DWORD, i, (DWORD)( *iter )->GetLightUserData() );
}
return pArray;
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), &pLuaArguments );
}
}
@ -148,20 +139,11 @@ MonoArray* CMonoFunctions::Player::GetDeadPlayers( void )
{
if( RESOURCE )
{
CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetDeadPlayers( RESOURCE->GetLua() );
CLuaArgumentsVector pLuaArguments = CLuaFunctionDefinitions::GetDeadPlayers( RESOURCE->GetLua() );
if( pLuaArguments )
if( pLuaArguments.size() > 0 )
{
MonoArray* pArray = mono_array_new( RESOURCE->GetDomain()->GetMonoPtr(), mono_get_uint32_class(), pLuaArguments->Count() );
vector< CLuaArgument* >::const_iterator iter = pLuaArguments->IterBegin();
for( unsigned int i = 0; iter != pLuaArguments->IterEnd(); iter++, i++ )
{
mono_array_set( pArray, DWORD, i, (DWORD)( *iter )->GetLightUserData() );
}
return pArray;
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), &pLuaArguments );
}
}
@ -337,15 +319,15 @@ MonoObject* CMonoFunctions::Player::GetACInfo( DWORD pUserData )
{
if( RESOURCE )
{
LuaTable pLuaTable = CLuaFunctionDefinitions::GetPlayerACInfo( RESOURCE->GetLua(), (void*)pUserData );
CLuaArgumentsMap* pLuaTable = CLuaFunctionDefinitions::GetPlayerACInfo( RESOURCE->GetLua(), (PVOID)pUserData );
if( !pLuaTable.empty() )
if( pLuaTable )
{
MonoString* msDetectedAC = RESOURCE->GetDomain()->NewString( pLuaTable[ "DetectedAC" ]->GetString() );
MonoString* msD3D9MD5 = RESOURCE->GetDomain()->NewString( pLuaTable[ "d3d9MD5" ]->GetString() );
MonoString* msD3D9SHA256 = RESOURCE->GetDomain()->NewString( pLuaTable[ "d3d9SHA256" ]->GetString() );
MonoString* msDetectedAC = RESOURCE->GetDomain()->NewString( (*pLuaTable)[ "DetectedAC" ].GetString() );
MonoString* msD3D9MD5 = RESOURCE->GetDomain()->NewString( (*pLuaTable)[ "d3d9MD5" ].GetString() );
MonoString* msD3D9SHA256 = RESOURCE->GetDomain()->NewString( (*pLuaTable)[ "d3d9SHA256" ].GetString() );
unsigned int iD3D9Size = pLuaTable[ "d3d9Size" ]->GetNumber< unsigned int >();
unsigned int iD3D9Size = (*pLuaTable)[ "d3d9Size" ].GetNumber< unsigned int >();
void *args[] =
{

7
mta-mono/src/CMonoFunctions_Resource.cpp
View File

@ -177,9 +177,12 @@ MonoArray* CMonoFunctions::Resource::GetResources( void )
{
if( RESOURCE )
{
CLuaArguments* pLuaTable = CLuaFunctionDefinitions::GetResources( RESOURCE->GetLua() );
CLuaArgumentsVector pLuaTable = CLuaFunctionDefinitions::GetResources( RESOURCE->GetLua() );
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), pLuaTable );
if( pLuaTable.size() > 0 )
{
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), &pLuaTable );
}
}
return NULL;

34
mta-mono/src/CMonoFunctions_Vehicle.cpp
View File

@ -30,7 +30,7 @@ DWORD CMonoFunctions::Vehicle::Create( int model, MonoObject* position, MonoObje
if( numberplate && mono_string_length( numberplate ) > 0 )
{
sNumberplate = string( mono_string_to_utf8( numberplate ) );
sNumberplate = mono_string_to_utf8( numberplate );
}
return (DWORD)CLuaFunctionDefinitions::CreateVehicle( RESOURCE->GetLua(), model, fX, fY, fZ, fRX, fRY, fRZ, sNumberplate, direction, variant1, variant2 );
@ -198,12 +198,15 @@ MonoArray* CMonoFunctions::Vehicle::GetOccupants( DWORD pUserData )
{
if( RESOURCE )
{
CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetVehicleOccupants( RESOURCE->GetLua(), (void*)pUserData );
CLuaArgumentsVector pLuaArguments = CLuaFunctionDefinitions::GetVehicleOccupants( RESOURCE->GetLua(), (PVOID)pUserData );
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), pLuaArguments );
if( pLuaArguments.size() > 0 )
{
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), &pLuaArguments );
}
}
return NULL;
return nullptr;
}
DWORD CMonoFunctions::Vehicle::GetController( DWORD pUserData )
@ -280,9 +283,12 @@ MonoArray* CMonoFunctions::Vehicle::GetOfType( unsigned int uiModel )
{
if( RESOURCE )
{
CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetVehiclesOfType( RESOURCE->GetLua(), uiModel );
CLuaArgumentsVector pLuaArguments = CLuaFunctionDefinitions::GetVehiclesOfType( RESOURCE->GetLua(), uiModel );
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), pLuaArguments );
if( pLuaArguments.size() > 0 )
{
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TLIGHTUSERDATA>( mono_get_uint32_class(), &pLuaArguments );
}
}
return NULL;
@ -307,9 +313,12 @@ MonoArray* CMonoFunctions::Vehicle::GetUpgrades( DWORD pUserData )
{
if( RESOURCE )
{
CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetVehicleUpgrades( RESOURCE->GetLua(), (void*)pUserData );
CLuaArgumentsVector pLuaArguments = CLuaFunctionDefinitions::GetVehicleUpgrades( RESOURCE->GetLua(), (void*)pUserData );
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TNUMBER>( mono_get_uint32_class(), pLuaArguments );
if( pLuaArguments.size() > 0 )
{
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TNUMBER>( mono_get_uint32_class(), &pLuaArguments );
}
}
return NULL;
@ -334,12 +343,15 @@ MonoArray* CMonoFunctions::Vehicle::GetCompatibleUpgrades( DWORD pUserData )
{
if( RESOURCE )
{
CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetVehicleCompatibleUpgrades( RESOURCE->GetLua(), (void*)pUserData );
CLuaArgumentsVector pLuaArguments = CLuaFunctionDefinitions::GetVehicleCompatibleUpgrades( RESOURCE->GetLua(), (void*)pUserData );
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TNUMBER>( mono_get_uint32_class(), pLuaArguments );
if( pLuaArguments.size() > 0 )
{
return RESOURCE->GetDomain()->NewArray<DWORD, LUA_TNUMBER>( mono_get_uint32_class(), &pLuaArguments );
}
}
return NULL;
return nullptr;
}
unsigned char CMonoFunctions::Vehicle::GetDoorState( DWORD pUserData, unsigned char ucDoor )

515
mta-mono/src/extra/CLuaArgument.cpp
View File

@ -2,7 +2,7 @@
*
* Multi Theft Auto: San Andreas - Deathmatch
*
* Squirrel 3, External lua add-on module
* External lua add-on module
*
* Copyright © 2003-2008 MTA. All Rights Reserved.
*
@ -23,256 +23,264 @@
using namespace std;
CLuaArgument::CLuaArgument ( void )
CLuaArgument::CLuaArgument( void )
{
m_szString = NULL;
m_iType = LUA_TNIL;
this->m_iType = LUA_TNIL;
this->m_szString = nullptr;
this->m_pLightUserData = nullptr;
this->m_Function = nullptr;
this->m_bBoolean = false;
this->m_Number = 0;
}
CLuaArgument::CLuaArgument ( bool bBool )
CLuaArgument::CLuaArgument( bool bBool ) : CLuaArgument()
{
m_szString = NULL;
m_iType = LUA_TBOOLEAN;
m_bBoolean = bBool;
this->m_iType = LUA_TBOOLEAN;
this->m_bBoolean = bBool;
}
CLuaArgument::CLuaArgument ( double dNumber )
CLuaArgument::CLuaArgument( double dNumber ) : CLuaArgument()
{
m_szString = NULL;
m_iType = LUA_TNUMBER;
m_Number = dNumber;
this->m_iType = LUA_TNUMBER;
this->m_Number = dNumber;
}
CLuaArgument::CLuaArgument ( const char* szString )
CLuaArgument::CLuaArgument( const char* szString ) : CLuaArgument()
{
assert ( szString );
assert( szString );
m_iType = LUA_TSTRING;
m_szString = new char [strlen ( szString ) + 1];
strcpy ( m_szString, szString );
this->m_iType = LUA_TSTRING;
this->m_szString = new char[ strlen( szString ) + 1 ];
strcpy( this->m_szString, szString );
}
CLuaArgument::CLuaArgument ( void* pUserData )
CLuaArgument::CLuaArgument( void* pUserData ) : CLuaArgument()
{
m_szString = NULL;
m_iType = LUA_TLIGHTUSERDATA;
m_pLightUserData = pUserData;
this->m_iType = LUA_TLIGHTUSERDATA;
this->m_pLightUserData = pUserData;
}
CLuaArgument::CLuaArgument( lua_CFunction Function )
CLuaArgument::CLuaArgument( lua_CFunction Function ) : CLuaArgument()
{
m_szString = NULL;
m_iType = LUA_TFUNCTION;
m_Function = Function;
this->m_szString = NULL;
this->m_iType = LUA_TFUNCTION;
this->m_Function = Function;
}
CLuaArgument::CLuaArgument ( const CLuaArgument& Argument )
CLuaArgument::CLuaArgument( const CLuaArgument& Argument ) : CLuaArgument()
{
// Initialize and call our = on the argument
m_szString = NULL;
operator= ( Argument );
operator = ( Argument );
}
CLuaArgument::CLuaArgument ( lua_State* luaVM, unsigned int uiArgument )
CLuaArgument::CLuaArgument( lua_State* luaVM, unsigned int uiArgument ) : CLuaArgument()
{
// Read the argument out of the lua VM
m_szString = NULL;
Read ( luaVM, uiArgument );
this->Read( luaVM, uiArgument );
}
CLuaArgument::~CLuaArgument ( void )
CLuaArgument::~CLuaArgument( void )
{
// Eventually destroy our string
if ( m_szString )
{
delete [] m_szString;
}
}
if( this->m_szString )
{
delete[] this->m_szString;
}
this->m_pArray.clear();
this->m_pTable.clear();
}
const CLuaArgument& CLuaArgument::operator = ( const CLuaArgument& Argument )
{
// Destroy our old string if neccessary
if ( m_szString )
{
delete [] m_szString;
m_szString = NULL;
}
if( this->m_szString )
{
delete[] this->m_szString;
this->m_szString = nullptr;
}
// Set our variable equally to the copy class
m_iType = Argument.m_iType;
switch ( m_iType )
{
case LUA_TBOOLEAN:
{
m_bBoolean = Argument.m_bBoolean;
break;
}
this->m_pArray.clear();
this->m_pTable.clear();
case LUA_TLIGHTUSERDATA:
{
m_pLightUserData = Argument.m_pLightUserData;
break;
}
this->m_iType = Argument.m_iType;
case LUA_TNUMBER:
{
m_Number = Argument.m_Number;
break;
}
switch( this->m_iType )
{
case LUA_TBOOLEAN:
{
this->m_bBoolean = Argument.m_bBoolean;
case LUA_TSTRING:
{
if ( Argument.m_szString )
{
m_szString = new char [strlen ( Argument.m_szString ) + 1];
strcpy ( m_szString, Argument.m_szString );
}
break;
}
case LUA_TLIGHTUSERDATA:
{
this->m_pLightUserData = Argument.m_pLightUserData;
break;
}
break;
}
case LUA_TNUMBER:
{
this->m_Number = Argument.m_Number;
break;
}
case LUA_TSTRING:
{
if( Argument.m_szString )
{
this->m_szString = new char[ strlen( Argument.m_szString ) + 1 ];
strcpy( this->m_szString, Argument.m_szString );
}
break;
}
case LUA_TFUNCTION:
{
m_Function = Argument.m_Function;
this->m_Function = Argument.m_Function;
break;
}
case LUA_TTABLE:
{
if( Argument.m_pArray.size() > 0 )
{
for( const auto& _item : Argument.m_pArray )
{
CLuaArgument* item = new CLuaArgument( _item );
this->m_pArray.push_back( item );
}
}
if( Argument.m_pTable.size() > 0 )
{
for( const auto& iter : Argument.m_pTable )
{
this->m_pTable[ iter.first ] = iter.second;
}
}
break;
}
default: break;
}
default: break;
}
// Return the given class allowing for chaining
return Argument;
return Argument;
}
bool CLuaArgument::operator == ( const CLuaArgument& Argument )
{
// If the types differ, they're not matching
if ( Argument.m_iType != m_iType )
return false;
// Compare the variables depending on the type
switch ( m_iType )
{
case LUA_TBOOLEAN:
{
return m_bBoolean == Argument.m_bBoolean;
}
case LUA_TLIGHTUSERDATA:
{
return m_pLightUserData == Argument.m_pLightUserData;
}
case LUA_TNUMBER:
{
return m_Number == Argument.m_Number;
}
case LUA_TSTRING:
{
if ( m_szString )
{
if ( Argument.m_szString )
return strcmp ( m_szString, Argument.m_szString ) == 0;
else
return false;
}
else
{
return Argument.m_szString == NULL;
}
}
if( Argument.m_iType != this->m_iType )
{
return false;
}
switch( this->m_iType )
{
case LUA_TBOOLEAN:
{
return this->m_bBoolean == Argument.m_bBoolean;
}
case LUA_TLIGHTUSERDATA:
{
return this->m_pLightUserData == Argument.m_pLightUserData;
}
case LUA_TNUMBER:
{
return this->m_Number == Argument.m_Number;
}
case LUA_TSTRING:
{
if( this->m_szString )
{
if( Argument.m_szString )
{
return strcmp( this->m_szString, Argument.m_szString ) == 0;
}
else
{
return false;
}
}
else
{
return Argument.m_szString == NULL;
}
}
case LUA_TFUNCTION:
{
return m_Function == Argument.m_Function;
return this->m_Function == Argument.m_Function;
}
}
}
return true;
return true;
}
bool CLuaArgument::operator != ( const CLuaArgument& Argument )
{
return !( operator == ( Argument ) );
return !( operator == ( Argument ) );
}
void CLuaArgument::Read ( lua_State* luaVM, signed int uiArgument )
void CLuaArgument::Read( lua_State* luaVM, signed int uiArgument )
{
// Eventually delete our previous string
if ( m_szString )
{
delete [] m_szString;
m_szString = NULL;
}
if( this->m_szString )
{
delete [] this->m_szString;
}
// Grab the argument type
m_iType = lua_type ( luaVM, uiArgument );
this->m_szString = nullptr;
this->m_pLightUserData = nullptr;
this->m_Function = nullptr;
if ( m_iType != LUA_TNONE )
{
// Read out the content depending on the type
switch ( m_iType )
{
case LUA_TNIL:
break;
this->m_pArray.clear();
this->m_pTable.clear();
case LUA_TBOOLEAN:
{
m_bBoolean = lua_toboolean ( luaVM, uiArgument ) ? true:false;
break;
}
this->m_iType = lua_type( luaVM, uiArgument );
case LUA_TLIGHTUSERDATA:
{
m_pLightUserData = lua_touserdata ( luaVM, uiArgument );
break;
}
case LUA_TNUMBER:
{
m_Number = lua_tonumber ( luaVM, uiArgument );
break;
}
case LUA_TSTRING:
{
// Grab the lua string and its size
const char* szLuaString = lua_tostring ( luaVM, uiArgument );
size_t sizeLuaString = strlen ( szLuaString );
// Allocate our buffer
m_szString = new char [sizeLuaString + 1];
strcpy ( m_szString, szLuaString );
break;
}
case LUA_TFUNCTION:
if( this->m_iType != LUA_TNONE )
{
switch( this->m_iType )
{
case LUA_TNIL:
{
m_Function = lua_tocfunction( luaVM, uiArgument );
break;
}
case LUA_TBOOLEAN:
{
this->m_bBoolean = lua_toboolean( luaVM, uiArgument ) != 0;
break;
}
case LUA_TLIGHTUSERDATA:
{
this->m_pLightUserData = lua_touserdata( luaVM, uiArgument );
break;
}
case LUA_TNUMBER:
{
this->m_Number = lua_tonumber( luaVM, uiArgument );
break;
}
case LUA_TSTRING:
{
const char* szLuaString = lua_tostring( luaVM, uiArgument );
this->m_szString = new char[ strlen( szLuaString ) + 1 ];
strcpy( this->m_szString, szLuaString );
break;
}
case LUA_TFUNCTION:
{
this->m_Function = lua_tocfunction( luaVM, uiArgument );
break;
}
case LUA_TTABLE:
{
m_pTable.clear();
m_pArray = new CLuaArguments();
lua_pushnil( luaVM );
uiArgument--;
@ -280,84 +288,99 @@ void CLuaArgument::Read ( lua_State* luaVM, signed int uiArgument )
while( lua_next( luaVM, uiArgument ) != 0 )
{
CLuaArgument pKey( luaVM, -2 );
CLuaArgument* pValue = new CLuaArgument( luaVM, -1 );
CLuaArgument pValue( luaVM, -1 );
if( pKey.GetType() == LUA_TSTRING )
{
m_pTable[ string( pKey.GetString() ) ] = pValue;
this->m_pTable[ pKey.GetString() ] = pValue;
}
m_pArray->PushArgument( pValue );
this->m_pArray.push_back( pValue );
lua_pop( luaVM, 1 );
}
break;
}
default:
{
m_iType = LUA_TNONE;
break;
}
}
}
}
void CLuaArgument::Push ( lua_State* luaVM ) const
{
// Got any type?
if ( m_iType != LUA_TNONE )
{
// Push it depending on the type
switch ( m_iType )
{
case LUA_TNIL:
{
lua_pushnil ( luaVM );
break;
}
case LUA_TBOOLEAN:
{
lua_pushboolean ( luaVM, m_bBoolean );
break;
}
case LUA_TLIGHTUSERDATA:
{
lua_pushlightuserdata ( luaVM, m_pLightUserData );
break;
}
case LUA_TNUMBER:
{
lua_pushnumber ( luaVM, m_Number );
break;
}
case LUA_TSTRING:
{
// Push the string if we got any
if ( m_szString )
{
lua_pushstring ( luaVM, m_szString );
}
else
{
lua_pushstring ( luaVM, "" );
}
break;
}
case LUA_TFUNCTION:
default:
{
lua_pushcfunction( luaVM, m_Function );
this->m_iType = LUA_TNONE;
break;
}
}
}
}
}
}
void CLuaArgument::Push( lua_State* luaVM ) const
{
if( this->m_iType != LUA_TNONE )
{
switch( this->m_iType )
{
case LUA_TNIL:
{
lua_pushnil( luaVM );
break;
}
case LUA_TBOOLEAN:
{
lua_pushboolean( luaVM, this->m_bBoolean );
break;
}
case LUA_TLIGHTUSERDATA:
{
lua_pushlightuserdata( luaVM, this->m_pLightUserData );
break;
}
case LUA_TNUMBER:
{
lua_pushnumber( luaVM, this->m_Number );
break;
}
case LUA_TSTRING:
{
lua_pushstring( luaVM, this->m_szString ? this->m_szString : "" );
break;
}
case LUA_TFUNCTION:
{
lua_pushcfunction( luaVM, this->m_Function );
break;
}
}
}
}
CLuaArgumentsVector CLuaArgument::GetArray( void ) const
{
CLuaArgumentsVector pArray;
for( const auto& arg : this->m_pArray )
{
CLuaArgument pArgument( arg );
pArray.push_back( pArgument );
}
return pArray;
}
CLuaArgumentsMap CLuaArgument::GetTable( void ) const
{
CLuaArgumentsMap pMap;
for( const auto& iter : this->m_pTable )
{
CLuaArgument pArgument( iter.second );
pMap[ iter.first.c_str() ] = pArgument;
}
return pMap;
}

69
mta-mono/src/extra/CLuaArgument.h
View File

@ -2,7 +2,7 @@
*
* Multi Theft Auto: San Andreas - Deathmatch
*
* Squirrel 3, External lua add-on module
* External lua add-on module
*
* Copyright © 2003-2008 MTA. All Rights Reserved.
*
@ -26,55 +26,56 @@ extern "C"
#include <lua.h>
}
#include "CReferenceCounter.h"
#include "CLuaArguments.h"
#include <string>
#include <map>
typedef std::map<std::string, CLuaArgument*> LuaTable;
typedef vector< CLuaArgument > CLuaArgumentsVector;
typedef map< string, CLuaArgument > CLuaArgumentsMap;
class CLuaArgument
{
public:
CLuaArgument ( void );
CLuaArgument ( bool bBool );
CLuaArgument ( double dNumber );
CLuaArgument ( const char* szString );
CLuaArgument ( void* pUserData );
CLuaArgument ( lua_CFunction Function );
CLuaArgument ( const CLuaArgument& Argument );
CLuaArgument ( lua_State* luaVM, unsigned int uiArgument );
~CLuaArgument ( void );
CLuaArgument ( void );
CLuaArgument ( bool bBool );
CLuaArgument ( double dNumber );
CLuaArgument ( const char* szString );
CLuaArgument ( void* pUserData );
CLuaArgument ( lua_CFunction Function );
CLuaArgument ( const CLuaArgument& Argument );
CLuaArgument ( lua_State* luaVM, unsigned int uiArgument );
~CLuaArgument ( void );
const CLuaArgument& operator = ( const CLuaArgument& Argument );
bool operator == ( const CLuaArgument& Argument );
bool operator != ( const CLuaArgument& Argument );
const CLuaArgument& operator = ( const CLuaArgument& Argument );
bool operator == ( const CLuaArgument& Argument );
bool operator != ( const CLuaArgument& Argument );
void Read ( lua_State* luaVM, signed int uiArgument );
void Push ( lua_State* luaVM ) const;
void Read ( lua_State* luaVM, signed int uiArgument );
void Push ( lua_State* luaVM ) const;
inline int GetType ( void ) const { return m_iType; };
inline int GetType ( void ) const { return m_iType; };
inline bool GetBoolean ( void ) const { return m_bBoolean; };
inline lua_Number GetNumber ( void ) const { return m_Number; };
inline const char* GetString ( void ) const { return m_szString; };
inline void* GetLightUserData ( void ) const { return m_pLightUserData; };
inline CLuaArguments* GetArray ( void ) const { return m_pArray; };
inline LuaTable GetTable ( void ) const { return m_pTable; };
inline bool GetBoolean ( void ) const { return m_bBoolean; };
inline lua_Number GetNumber ( void ) const { return m_Number; };
inline const char* GetString ( void ) const { return m_szString; };
inline PVOID GetLightUserData ( void ) const { return m_pLightUserData; };
template <class T> T GetNumber()
CLuaArgumentsVector GetArray ( void ) const;
CLuaArgumentsMap GetTable ( void ) const;
template <class T> T GetNumber() const
{
return static_cast< T >( m_Number );
}
private:
int m_iType;
bool m_bBoolean;
lua_Number m_Number;
char* m_szString;
void* m_pLightUserData;
lua_CFunction m_Function;
CLuaArguments* m_pArray;
LuaTable m_pTable;
int m_iType;
bool m_bBoolean;
lua_Number m_Number;
char* m_szString;
PVOID m_pLightUserData;
lua_CFunction m_Function;
CLuaArgumentsVector m_pArray;
CLuaArgumentsMap m_pTable;
};
#endif

200
mta-mono/src/extra/CLuaArguments.cpp
View File

@ -2,7 +2,7 @@
*
* Multi Theft Auto: San Andreas - Deathmatch
*
* Squirrel 3, External lua add-on module
* External lua add-on module
*
* Copyright © 2003-2008 MTA. All Rights Reserved.
*
@ -20,162 +20,144 @@
#include "CLuaArguments.h"
#include <assert.h>
CLuaArguments::CLuaArguments ( const CLuaArguments& Arguments )
CLuaArguments::CLuaArguments( const CLuaArguments& Arguments )
{
// Copy all the arguments
vector < CLuaArgument* > ::const_iterator iter = Arguments.m_Arguments.begin ();
for ( ; iter != Arguments.m_Arguments.end (); iter++ )
{
CLuaArgument* pArgument = new CLuaArgument ( **iter );
m_Arguments.push_back ( pArgument );
}
}
for( const auto& iter : Arguments.m_Arguments )
{
CLuaArgument* pArgument = new CLuaArgument( *iter );
this->m_Arguments.push_back( pArgument );
}
}
const CLuaArguments& CLuaArguments::operator = ( const CLuaArguments& Arguments )
{
// Clear our previous list if any
DeleteArguments ();
this->DeleteArguments();
// Copy all the arguments
vector < CLuaArgument* > ::const_iterator iter = Arguments.m_Arguments.begin ();
for ( ; iter != Arguments.m_Arguments.end (); iter++ )
{
CLuaArgument* pArgument = new CLuaArgument ( **iter );
m_Arguments.push_back ( pArgument );
}
for( const auto& iter : Arguments.m_Arguments )
{
CLuaArgument* pArgument = new CLuaArgument( *iter );
// Return the given reference allowing for chaining
return Arguments;
this->m_Arguments.push_back( pArgument );
}
return Arguments;
}
void CLuaArguments::ReadArguments ( lua_State* luaVM, unsigned int uiIndexBegin )
void CLuaArguments::ReadArguments( lua_State* luaVM, unsigned int uiIndexBegin )
{
// Delete the previous arguments if any
DeleteArguments ();
this->DeleteArguments();
// Start reading arguments until there are none left
while ( lua_type ( luaVM, uiIndexBegin ) != LUA_TNONE )
{
// Create an argument, let it read out the argument and add it to our vector
CLuaArgument* pArgument = new CLuaArgument ( luaVM, uiIndexBegin++ );
m_Arguments.push_back ( pArgument );
}
while( lua_type( luaVM, uiIndexBegin ) != LUA_TNONE )
{
CLuaArgument* pArgument = new CLuaArgument( luaVM, uiIndexBegin++ );
this->m_Arguments.push_back( pArgument );
}
}
void CLuaArguments::PushArguments ( lua_State* luaVM ) const
void CLuaArguments::PushArguments( lua_State* luaVM ) const
{
// Push all our arguments
vector < CLuaArgument* > ::const_iterator iter = m_Arguments.begin ();
for ( ; iter != m_Arguments.end (); iter++ )
{
(*iter)->Push ( luaVM );
}
for( const auto& pArg : this->m_Arguments )
{
pArg->Push( luaVM );
}
}
void CLuaArguments::PushArguments ( CLuaArguments& Arguments )
void CLuaArguments::PushArguments( CLuaArguments& Arguments )
{
vector < CLuaArgument* > ::const_iterator iter = Arguments.IterBegin ();
for ( ; iter != Arguments.IterEnd (); iter++ )
{
CLuaArgument* pArgument = new CLuaArgument ( **iter );
m_Arguments.push_back ( pArgument );
}
for( const auto& iter : Arguments.m_Arguments )
{
CLuaArgument* pArgument = new CLuaArgument( *iter );
this->m_Arguments.push_back( pArgument );
}
}
bool CLuaArguments::Call ( lua_State* luaVM, const char* szFunction, int iResults, int iErrorFunc ) const
bool CLuaArguments::Call( lua_State* luaVM, const char* szFunction, int iResults, int iErrorFunc ) const
{
assert ( szFunction );
assert( szFunction );
assert( luaVM );
// Add the function name to the stack and get the event from the table
assert ( luaVM );
lua_pushstring( luaVM, szFunction );
lua_gettable( luaVM, LUA_GLOBALSINDEX );
lua_pushstring ( luaVM, szFunction );
lua_gettable ( luaVM, LUA_GLOBALSINDEX );
this->PushArguments( luaVM );
// Push our arguments onto the stack
PushArguments ( luaVM );
int iret = lua_pcall( luaVM, m_Arguments.size(), iResults, iErrorFunc );
int iret = lua_pcall ( luaVM, m_Arguments.size(), iResults, iErrorFunc );
if ( iret == LUA_ERRRUN || iret == LUA_ERRMEM )
{
return false; // the function call failed
}
return true;
return iret != LUA_ERRRUN && iret != LUA_ERRMEM;
}
CLuaArgument* CLuaArguments::PushNil ( void )
CLuaArgument* CLuaArguments::PushNil( void )
{
CLuaArgument* pArgument = new CLuaArgument;
m_Arguments.push_back ( pArgument );
return pArgument;
CLuaArgument* pArgument = new CLuaArgument;
this->m_Arguments.push_back( pArgument );
return pArgument;
}
CLuaArgument* CLuaArguments::PushBoolean ( bool bBool )
CLuaArgument* CLuaArguments::PushBoolean( bool bBool )
{
CLuaArgument* pArgument = new CLuaArgument ( bBool );
m_Arguments.push_back ( pArgument );
return pArgument;
CLuaArgument* pArgument = new CLuaArgument( bBool );
this->m_Arguments.push_back( pArgument );
return pArgument;
}
CLuaArgument* CLuaArguments::PushNumber ( double dNumber )
CLuaArgument* CLuaArguments::PushNumber( double dNumber )
{
CLuaArgument* pArgument = new CLuaArgument ( dNumber );
m_Arguments.push_back ( pArgument );
return pArgument;
CLuaArgument* pArgument = new CLuaArgument( dNumber );
this->m_Arguments.push_back( pArgument );
return pArgument;
}
CLuaArgument* CLuaArguments::PushString ( const char* szString )
CLuaArgument* CLuaArguments::PushString( const char* szString )
{
CLuaArgument* pArgument = new CLuaArgument ( szString );
m_Arguments.push_back ( pArgument );
return pArgument;
CLuaArgument* pArgument = new CLuaArgument( szString );
this->m_Arguments.push_back( pArgument );
return pArgument;
}
CLuaArgument* CLuaArguments::PushUserData ( void* pUserData )
CLuaArgument* CLuaArguments::PushUserData( void* pUserData )
{
CLuaArgument* pArgument = new CLuaArgument ( pUserData );
m_Arguments.push_back ( pArgument );
return pArgument;
}
CLuaArgument* pArgument = new CLuaArgument( pUserData );
this->m_Arguments.push_back( pArgument );
return pArgument;
}
CLuaArgument* CLuaArguments::PushFunction( lua_CFunction iFunction )
{
CLuaArgument* pArgument = new CLuaArgument ( iFunction );
m_Arguments.push_back ( pArgument );
return pArgument;
CLuaArgument* pArgument = new CLuaArgument( iFunction );
this->m_Arguments.push_back( pArgument );
return pArgument;
}
CLuaArgument* CLuaArguments::PushArgument ( const CLuaArgument & argument )
CLuaArgument* CLuaArguments::PushArgument( const CLuaArgument& argument )
{
CLuaArgument* pArgument = new CLuaArgument (argument); // create a copy
m_Arguments.push_back ( pArgument );
return pArgument;
CLuaArgument* pArgument = new CLuaArgument( argument ); // create a copy
this->m_Arguments.push_back( pArgument );
return pArgument;
}
void CLuaArguments::DeleteArguments ( void )
void CLuaArguments::DeleteArguments( void )
{
// Delete each item
vector < CLuaArgument* > ::iterator iter = m_Arguments.begin ();
for ( ; iter != m_Arguments.end (); iter++ )
{
delete *iter;
}
for( auto pArg : this->m_Arguments )
{
delete pArg;
}
// Clear the vector
m_Arguments.clear ();
this->m_Arguments.clear();
}

2
mta-mono/src/extra/CLuaArguments.h
View File

@ -2,7 +2,7 @@
*
* Multi Theft Auto: San Andreas - Deathmatch
*
* Squirrel 3, External lua add-on module
* External lua add-on module
*
* Copyright © 2003-2008 MTA. All Rights Reserved.
*

371
mta-mono/src/lua/CLuaFunctionDefinitions.cpp
View File

@ -496,8 +496,9 @@ PVOID CLuaFunctionDefinitions::CloneElement( lua_State* pLuaVM, PVOID pUserData,
// Element get funcs
CLuaArguments* CLuaFunctionDefinitions::GetElementsByType( lua_State* pLuaVM, const char* szTypeName, PVOID pUserData )
CLuaArgumentsVector CLuaFunctionDefinitions::GetElementsByType( lua_State* pLuaVM, const char* szTypeName, PVOID pUserData )
{
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
pLuaArguments.PushString( szTypeName );
@ -509,12 +510,10 @@ CLuaArguments* CLuaFunctionDefinitions::GetElementsByType( lua_State* pLuaVM, co
if( pLuaArguments.Call( pLuaVM, "getElementsByType", 1 ) )
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
return pLuaArgument.GetArray();
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument.GetArray();
}
bool CLuaFunctionDefinitions::IsElement( lua_State* pLuaVM, PVOID pUserData )
@ -647,8 +646,9 @@ string CLuaFunctionDefinitions::GetElementID( lua_State* pLuaVM, PVOID pUserData
return string();
}
CLuaArgument* CLuaFunctionDefinitions::GetElementData( lua_State* pLuaVM, PVOID pUserData, string sKey, bool bInherit )
CLuaArgument CLuaFunctionDefinitions::GetElementData( lua_State* pLuaVM, PVOID pUserData, string sKey, bool bInherit )
{
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
pLuaArguments.PushUserData( pUserData );
@ -657,13 +657,13 @@ CLuaArgument* CLuaFunctionDefinitions::GetElementData( lua_State* pLuaVM, PVOID
if( pLuaArguments.Call( pLuaVM, "getElementData", 1 ) )
{
return new CLuaArgument( pLuaVM, -1 );
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument;
}
CLuaArguments* CLuaFunctionDefinitions::GetAllElementData( lua_State* pLuaVM, PVOID pUserData )
CLuaArguments CLuaFunctionDefinitions::GetAllElementData( lua_State* pLuaVM, PVOID pUserData )
{
CLuaArguments pLuaArguments;
@ -671,14 +671,14 @@ CLuaArguments* CLuaFunctionDefinitions::GetAllElementData( lua_State* pLuaVM, PV
if( pLuaArguments.Call( pLuaVM, "getAllElementData", 1 ) )
{
CLuaArguments *pLuaArguments = new CLuaArguments();
pLuaArguments->ReadArguments( pLuaVM );
return pLuaArguments;
pLuaArguments.ReadArguments( pLuaVM );
}
else
{
pLuaArguments.DeleteArguments();
}
return nullptr;
return pLuaArguments;
}
PVOID CLuaFunctionDefinitions::GetElementParent( lua_State* pLuaVM, PVOID pUserData )
@ -708,9 +708,9 @@ bool CLuaFunctionDefinitions::GetElementPosition( lua_State* pLuaVM, PVOID pUser
if( pLuaArguments.Call( pLuaVM, "getElementPosition", 3 ) )
{
vecPosition.fX = static_cast< float >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
vecPosition.fY = static_cast< float >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
vecPosition.fZ = static_cast< float >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
vecPosition.fX = static_cast< float >( CLuaArgument( pLuaVM, -3 ).GetNumber() );
vecPosition.fY = static_cast< float >( CLuaArgument( pLuaVM, -2 ).GetNumber() );
vecPosition.fZ = static_cast< float >( CLuaArgument( pLuaVM, -1 ).GetNumber() );
return true;
}
@ -726,9 +726,9 @@ bool CLuaFunctionDefinitions::GetElementRotation( lua_State* pLuaVM, PVOID pUser
if( pLuaArguments.Call( pLuaVM, "getElementRotation", 3 ) )
{
vecRotation.fX = static_cast< float >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
vecRotation.fY = static_cast< float >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
vecRotation.fZ = static_cast< float >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
vecRotation.fX = static_cast< float >( CLuaArgument( pLuaVM, -3 ).GetNumber() );
vecRotation.fY = static_cast< float >( CLuaArgument( pLuaVM, -2 ).GetNumber() );
vecRotation.fZ = static_cast< float >( CLuaArgument( pLuaVM, -1 ).GetNumber() );
return true;
}
@ -745,9 +745,9 @@ bool CLuaFunctionDefinitions::GetElementVelocity( lua_State* pLuaVM, PVOID pUser
if( pLuaArguments.Call( pLuaVM, "getElementVelocity", 3 ) )
{
vecVelocity.fX = static_cast< float >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
vecVelocity.fY = static_cast< float >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
vecVelocity.fZ = static_cast< float >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
vecVelocity.fX = static_cast< float >( CLuaArgument( pLuaVM, -3 ).GetNumber() );
vecVelocity.fY = static_cast< float >( CLuaArgument( pLuaVM, -2 ).GetNumber() );
vecVelocity.fZ = static_cast< float >( CLuaArgument( pLuaVM, -1 ).GetNumber() );
return true;
}
@ -997,12 +997,12 @@ bool CLuaFunctionDefinitions::GetElementAttachedOffsets( lua_State* pLuaVM, PVOI
if( pLuaArguments.Call( pLuaVM, "getElementAttachedOffsets", 6 ) )
{
vecPosition.fX = static_cast< float >( ( new CLuaArgument( pLuaVM, -6 ) )->GetNumber() );
vecPosition.fY = static_cast< float >( ( new CLuaArgument( pLuaVM, -5 ) )->GetNumber() );
vecPosition.fZ = static_cast< float >( ( new CLuaArgument( pLuaVM, -4 ) )->GetNumber() );
vecRotation.fX = static_cast< float >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
vecRotation.fY = static_cast< float >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
vecRotation.fZ = static_cast< float >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
vecPosition.fX = static_cast< float >( CLuaArgument( pLuaVM, -6 ).GetNumber() );
vecPosition.fY = static_cast< float >( CLuaArgument( pLuaVM, -5 ).GetNumber() );
vecPosition.fZ = static_cast< float >( CLuaArgument( pLuaVM, -4 ).GetNumber() );
vecRotation.fX = static_cast< float >( CLuaArgument( pLuaVM, -3 ).GetNumber() );
vecRotation.fY = static_cast< float >( CLuaArgument( pLuaVM, -2 ).GetNumber() );
vecRotation.fZ = static_cast< float >( CLuaArgument( pLuaVM, -1 ).GetNumber() );
return true;
}
@ -1634,28 +1634,30 @@ bool CLuaFunctionDefinitions::GetPlayerWantedLevel( lua_State* pLuaVM, PVOID pUs
return false;
}
CLuaArguments* CLuaFunctionDefinitions::GetAlivePlayers( lua_State* pLuaVM )
CLuaArgumentsVector CLuaFunctionDefinitions::GetAlivePlayers( lua_State* pLuaVM )
{
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
if( pLuaArguments.Call( pLuaVM, "getAlivePlayers", 1 ) )
{
return CLuaArgument( pLuaVM, -1 ).GetArray();
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument.GetArray();
}
CLuaArguments* CLuaFunctionDefinitions::GetDeadPlayers( lua_State* pLuaVM )
CLuaArgumentsVector CLuaFunctionDefinitions::GetDeadPlayers( lua_State* pLuaVM )
{
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
if( pLuaArguments.Call( pLuaVM, "getDeadPlayers", 1 ) )
{
return CLuaArgument( pLuaVM, -1 ).GetArray();
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument.GetArray();
}
bool CLuaFunctionDefinitions::GetPlayerIdleTime( lua_State* pLuaVM, PVOID pUserData, unsigned int& uiIdleTime )
@ -1853,20 +1855,23 @@ string CLuaFunctionDefinitions::GetPlayerVersion( lua_State* pLuaVM, PVOID pUser
return string();
}
LuaTable CLuaFunctionDefinitions::GetPlayerACInfo( lua_State* pLuaVM, PVOID pUserData )
CLuaArgumentsMap* CLuaFunctionDefinitions::GetPlayerACInfo( lua_State* pLuaVM, PVOID pUserData )
{
map<string, CLuaArgument*> pLuaTable;
CLuaArguments pLuaArguments;
pLuaArguments.PushUserData( pUserData );
if( pLuaArguments.Call( pLuaVM, "getPlayerACInfo", 1 ) )
{
pLuaTable = CLuaArgument( pLuaVM, -1 ).GetTable();
CLuaArgument pLuaArgument( pLuaVM, -1 );
if( pLuaArgument.GetType() == LUA_TTABLE )
{
return &pLuaArgument.GetTable();
}
}
return pLuaTable;
return nullptr;
}
// Player set functions
@ -2313,8 +2318,8 @@ bool CLuaFunctionDefinitions::GetPedClothes( lua_State* pLuaVM, PVOID pUserData,
if( pLuaArguments.Call( pLuaVM, "getPedClothes", 2 ) )
{
strOutTexture = string( ( new CLuaArgument( pLuaVM, -2 ) )->GetString() );
strOutModel = string( ( new CLuaArgument( pLuaVM, -1 ) )->GetString() );
strOutTexture = CLuaArgument( pLuaVM, -2 ).GetString();
strOutModel = CLuaArgument( pLuaVM, -1 ).GetString();
return true;
}
@ -3037,8 +3042,8 @@ bool CLuaFunctionDefinitions::GetVehicleVariant( lua_State* pLuaVM, PVOID pUserD
if( pLuaArguments.Call( pLuaVM, "getVehicleVariant", 2 ) )
{
ucVariant = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
ucVariant2 = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
ucVariant = static_cast< unsigned char >( CLuaArgument( pLuaVM, -2 ).GetNumber() );
ucVariant2 = static_cast< unsigned char >( CLuaArgument( pLuaVM, -1 ).GetNumber() );
return true;
}
@ -3138,7 +3143,12 @@ bool CLuaFunctionDefinitions::GetVehicleName( lua_State* pLuaVM, PVOID pUserData
if( pLuaArguments.Call( pLuaVM, "getVehicleName", 1 ) )
{
strOutName = string( CLuaArgument( pLuaVM, -1 ).GetString() );
CLuaArgument pLuaArgument( pLuaVM, -1 );
if( pLuaArgument.GetType() == LUA_TSTRING )
{
strOutName = pLuaArgument.GetString();
}
return true;
}
@ -3154,7 +3164,12 @@ bool CLuaFunctionDefinitions::GetVehicleNameFromModel( lua_State* pLuaVM, unsign
if( pLuaArguments.Call( pLuaVM, "getVehicleNameFromModel", 1 ) )
{
strOutName = string( CLuaArgument( pLuaVM, -1 ).GetString() );
CLuaArgument pLuaArgument( pLuaVM, -1 );
if( pLuaArgument.GetType() == LUA_TSTRING )
{
strOutName = pLuaArgument.GetString();
}
return true;
}
@ -3182,18 +3197,19 @@ PVOID CLuaFunctionDefinitions::GetVehicleOccupant( lua_State* pLuaVM, PVOID pUse
return nullptr;
}
CLuaArguments* CLuaFunctionDefinitions::GetVehicleOccupants( lua_State* pLuaVM, PVOID pUserData )
CLuaArgumentsVector CLuaFunctionDefinitions::GetVehicleOccupants( lua_State* pLuaVM, PVOID pUserData )
{
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
pLuaArguments.PushUserData( pUserData );
if( pLuaArguments.Call( pLuaVM, "getVehicleOccupants", 1 ) )
{
return CLuaArgument( pLuaVM, -1 ).GetArray();
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument.GetArray();
}
PVOID CLuaFunctionDefinitions::GetVehicleController( lua_State* pLuaVM, PVOID pUserData )
@ -3223,9 +3239,14 @@ bool CLuaFunctionDefinitions::GetVehicleSirensOn( lua_State* pLuaVM, PVOID pUser
if( pLuaArguments.Call( pLuaVM, "getVehicleSirensOn", 1 ) )
{
bSirensOn = CLuaArgument( pLuaVM, -1 ).GetBoolean();
CLuaArgument pLuaArgument( pLuaVM, -1 );
return true;
if( pLuaArgument.GetType() == LUA_TBOOLEAN )
{
bSirensOn = pLuaArgument.GetBoolean();
return true;
}
}
return false;
@ -3282,18 +3303,19 @@ bool CLuaFunctionDefinitions::IsVehicleLocked( lua_State* pLuaVM, PVOID pUserDat
return false;
}
CLuaArguments* CLuaFunctionDefinitions::GetVehiclesOfType( lua_State* pLuaVM, unsigned int uiModel )
CLuaArgumentsVector CLuaFunctionDefinitions::GetVehiclesOfType( lua_State* pLuaVM, unsigned int uiModel )
{
CLuaArguments* pLuaArguments = new CLuaArguments();
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
pLuaArguments->PushNumber( uiModel );
pLuaArguments.PushNumber( uiModel );
if( pLuaArguments->Call( pLuaVM, "getVehiclesOfType", 1 ) )
if( pLuaArguments.Call( pLuaVM, "getVehiclesOfType", 1 ) )
{
return CLuaArgument( pLuaVM, -1 ).GetArray();
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument.GetArray();
}
bool CLuaFunctionDefinitions::GetVehicleUpgradeOnSlot( lua_State* pLuaVM, PVOID pUserData, unsigned char ucSlot, unsigned short& usUpgrade )
@ -3305,26 +3327,32 @@ bool CLuaFunctionDefinitions::GetVehicleUpgradeOnSlot( lua_State* pLuaVM, PVOID
if( pLuaArguments.Call( pLuaVM, "getVehicleUpgradeOnSlot", 1 ) )
{
usUpgrade = CLuaArgument( pLuaVM, -1 ).GetNumber< unsigned short >();
CLuaArgument pLuaArgument( pLuaVM, -1 );
return true;
if( pLuaArgument.GetType() == LUA_TNUMBER )
{
usUpgrade = pLuaArgument.GetNumber< unsigned short >();
return true;
}
}
return false;
}
CLuaArguments* CLuaFunctionDefinitions::GetVehicleUpgrades( lua_State* pLuaVM, PVOID pUserData )
CLuaArgumentsVector CLuaFunctionDefinitions::GetVehicleUpgrades( lua_State* pLuaVM, PVOID pUserData )
{
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
pLuaArguments.PushUserData( pUserData );
if( pLuaArguments.Call( pLuaVM, "getVehicleUpgrades", 1 ) )
{
return CLuaArgument( pLuaVM, -1 ).GetArray();
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument.GetArray();
}
bool CLuaFunctionDefinitions::GetVehicleUpgradeSlotName( lua_State* pLuaVM, unsigned char ucSlot, string& strOutName )
@ -3335,7 +3363,7 @@ bool CLuaFunctionDefinitions::GetVehicleUpgradeSlotName( lua_State* pLuaVM, unsi
if( pLuaArguments.Call( pLuaVM, "getVehicleUpgradeSlotName", 1 ) )
{
strOutName = string( CLuaArgument( pLuaVM, -1 ).GetString() );
strOutName = CLuaArgument( pLuaVM, -1 ).GetString();
return true;
}
@ -3351,7 +3379,7 @@ bool CLuaFunctionDefinitions::GetVehicleUpgradeSlotName( lua_State* pLuaVM, unsi
if( pLuaArguments.Call( pLuaVM, "getVehicleUpgradeSlotName", 1 ) )
{
strOutName = string( CLuaArgument( pLuaVM, -1 ).GetString() );
strOutName = CLuaArgument( pLuaVM, -1 ).GetString();
return true;
}
@ -3359,18 +3387,19 @@ bool CLuaFunctionDefinitions::GetVehicleUpgradeSlotName( lua_State* pLuaVM, unsi
return false;
}
CLuaArguments* CLuaFunctionDefinitions::GetVehicleCompatibleUpgrades( lua_State* pLuaVM, PVOID pUserData )
CLuaArgumentsVector CLuaFunctionDefinitions::GetVehicleCompatibleUpgrades( lua_State* pLuaVM, PVOID pUserData )
{
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
pLuaArguments.PushUserData( pUserData );
if( pLuaArguments.Call( pLuaVM, "getVehicleCompatibleUpgrades", 1 ) )
{
return CLuaArgument( pLuaVM, -1 ).GetArray();
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument.GetArray();
}
bool CLuaFunctionDefinitions::GetVehicleDoorState( lua_State* pLuaVM, PVOID pUserData, unsigned char ucDoor, unsigned char& ucState )
@ -3398,10 +3427,10 @@ bool CLuaFunctionDefinitions::GetVehicleWheelStates( lua_State* pLuaVM, PVOID pU
if( pLuaArguments.Call( pLuaVM, "getVehicleWheelStates", 4 ) )
{
ucFrontLeft = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -4 ) )->GetNumber() );
ucRearLeft = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
ucFrontRight = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
ucRearRight = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
ucFrontLeft = static_cast< unsigned char >( CLuaArgument( pLuaVM, -4 ).GetNumber() );
ucRearLeft = static_cast< unsigned char >( CLuaArgument( pLuaVM, -3 ).GetNumber() );
ucFrontRight = static_cast< unsigned char >( CLuaArgument( pLuaVM, -2 ).GetNumber() );
ucRearRight = static_cast< unsigned char >( CLuaArgument( pLuaVM, -1 ).GetNumber() );
return true;
}
@ -4655,10 +4684,10 @@ bool CLuaFunctionDefinitions::GetMarkerColor( lua_State* pLuaVM, PVOID pUserData
if( pLuaArguments.Call( pLuaVM, "getMarkerColor", 4 ) )
{
outColor.R = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -4 ) )->GetNumber() );
outColor.G = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
outColor.B = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
outColor.A = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
outColor.R = static_cast< unsigned char >( CLuaArgument( pLuaVM, -4 ).GetNumber() );
outColor.G = static_cast< unsigned char >( CLuaArgument( pLuaVM, -3 ).GetNumber() );
outColor.B = static_cast< unsigned char >( CLuaArgument( pLuaVM, -2 ).GetNumber() );
outColor.A = static_cast< unsigned char >( CLuaArgument( pLuaVM, -1 ).GetNumber() );
return true;
}
@ -4674,9 +4703,9 @@ bool CLuaFunctionDefinitions::GetMarkerTarget( lua_State* pLuaVM, PVOID pUserDat
if( pLuaArguments.Call( pLuaVM, "getMarkerTarget", 3 ) )
{
vecTarget.fX = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
vecTarget.fY = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
vecTarget.fZ = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
vecTarget.fX = static_cast< unsigned char >( CLuaArgument( pLuaVM, -3 ).GetNumber() );
vecTarget.fY = static_cast< unsigned char >( CLuaArgument( pLuaVM, -2 ).GetNumber() );
vecTarget.fZ = static_cast< unsigned char >( CLuaArgument( pLuaVM, -1 ).GetNumber() );
return true;
}
@ -4908,10 +4937,10 @@ bool CLuaFunctionDefinitions::GetBlipColor( lua_State* pLuaVM, PVOID pUserData,
if( pLuaArguments.Call( pLuaVM, "getBlipColor", 4 ) )
{
outColor.R = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -4 ) )->GetNumber() );
outColor.G = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
outColor.B = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
outColor.A = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
outColor.R = static_cast< unsigned char >( CLuaArgument( pLuaVM, -4 ).GetNumber() );
outColor.G = static_cast< unsigned char >( CLuaArgument( pLuaVM, -3 ).GetNumber() );
outColor.B = static_cast< unsigned char >( CLuaArgument( pLuaVM, -2 ).GetNumber() );
outColor.A = static_cast< unsigned char >( CLuaArgument( pLuaVM, -1 ).GetNumber() );
return true;
}
@ -5084,9 +5113,9 @@ bool CLuaFunctionDefinitions::GetObjectScale( lua_State* pLuaVM, PVOID pUserData
if( pLuaArguments.Call( pLuaVM, "getObjectScale", 3 ) )
{
vecScale.fX = static_cast< float >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
vecScale.fY = static_cast< float >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
vecScale.fZ = static_cast< float >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
vecScale.fX = static_cast< float >( CLuaArgument( pLuaVM, -3 ).GetNumber() );
vecScale.fY = static_cast< float >( CLuaArgument( pLuaVM, -2 ).GetNumber() );
vecScale.fZ = static_cast< float >( CLuaArgument( pLuaVM, -1 ).GetNumber() );
return true;
}
@ -5204,8 +5233,8 @@ bool CLuaFunctionDefinitions::GetRadarAreaSize( lua_State* pLuaVM, PVOID pUserDa
if( pLuaArguments.Call( pLuaVM, "getRadarAreaSize", 2 ) )
{
vecSize.fX = static_cast< float >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
vecSize.fY = static_cast< float >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
vecSize.fX = CLuaArgument( pLuaVM, -2 ).GetNumber< float >();
vecSize.fY = CLuaArgument( pLuaVM, -1 ).GetNumber< float >();
return true;
}
@ -5221,10 +5250,10 @@ bool CLuaFunctionDefinitions::GetRadarAreaColor( lua_State* pLuaVM, PVOID pUserD
if( pLuaArguments.Call( pLuaVM, "getRadarAreaColor", 4 ) )
{
outColor.R = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -4 ) )->GetNumber() );
outColor.G = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
outColor.B = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
outColor.A = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
outColor.R = CLuaArgument( pLuaVM, -4 ).GetNumber< unsigned char >();
outColor.G = CLuaArgument( pLuaVM, -3 ).GetNumber< unsigned char >();
outColor.B = CLuaArgument( pLuaVM, -2 ).GetNumber< unsigned char >();
outColor.A = CLuaArgument( pLuaVM, -1 ).GetNumber< unsigned char >();
return true;
}
@ -5781,8 +5810,8 @@ bool CLuaFunctionDefinitions::GetTypeIndexFromClothes( lua_State* pLuaVM, const
if( pLuaArguments.Call( pLuaVM, "getTypeIndexFromClothes", 2 ) )
{
ucTypeReturn = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
ucIndexReturn = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
ucTypeReturn = CLuaArgument( pLuaVM, -2 ).GetNumber< unsigned char >();
ucIndexReturn = CLuaArgument( pLuaVM, -1 ).GetNumber< unsigned char >();
return true;
}
@ -6015,9 +6044,9 @@ bool CLuaFunctionDefinitions::GetTeamColor( lua_State* pLuaVM, PVOID pTeam, unsi
if( pLuaArguments.Call( pLuaVM, "getTeamColor", 3 ) )
{
ucRed = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
ucGreen = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
ucBlue = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
ucRed = CLuaArgument( pLuaVM, -3 ).GetNumber< unsigned char >();
ucGreen = CLuaArgument( pLuaVM, -2 ).GetNumber< unsigned char >();
ucBlue = CLuaArgument( pLuaVM, -1 ).GetNumber< unsigned char >();
return true;
}
@ -6246,9 +6275,9 @@ bool CLuaFunctionDefinitions::GetWaterVertexPosition( lua_State* pLuaVM, PVOID p
if( pLuaArguments.Call( pLuaVM, "getWaterVertexPosition", 3 ) )
{
vecPosition.fX = static_cast< float >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
vecPosition.fY = static_cast< float >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
vecPosition.fZ = static_cast< float >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
vecPosition.fX = CLuaArgument( pLuaVM, -3 ).GetNumber< float >();
vecPosition.fY = CLuaArgument( pLuaVM, -2 ).GetNumber< float >();
vecPosition.fZ = CLuaArgument( pLuaVM, -1 ).GetNumber< float >();
return true;
}
@ -6282,10 +6311,10 @@ bool CLuaFunctionDefinitions::GetWaterColor( lua_State* pLuaVM, unsigned char& u
if( pLuaArguments.Call( pLuaVM, "getWaterColor", 4 ) )
{
ucRed = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -4 ) )->GetNumber() );
ucGreen = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
ucBlue = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
ucAlpha = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
ucRed = CLuaArgument( pLuaVM, -4 ).GetNumber< unsigned char >();
ucGreen = CLuaArgument( pLuaVM, -3 ).GetNumber< unsigned char >();
ucBlue = CLuaArgument( pLuaVM, -2 ).GetNumber< unsigned char >();
ucAlpha = CLuaArgument( pLuaVM, -1 ).GetNumber< unsigned char >();
return true;
}
@ -6429,8 +6458,8 @@ bool CLuaFunctionDefinitions::GetTime( lua_State* pLuaVM, unsigned char& ucHour,
if( pLuaArguments.Call( pLuaVM, "getTime", 2 ) )
{
ucHour = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
ucMinute = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
ucHour = CLuaArgument( pLuaVM, -2 ).GetNumber< unsigned char >();
ucMinute = CLuaArgument( pLuaVM, -1 ).GetNumber< unsigned char >();
return true;
}
@ -6444,8 +6473,8 @@ bool CLuaFunctionDefinitions::GetWeather( lua_State* pLuaVM, unsigned char& ucWe
if( pLuaArguments.Call( pLuaVM, "getWeather", 2 ) )
{
ucWeather = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
ucWeatherBlendingTo = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
ucWeather = CLuaArgument( pLuaVM, -2 ).GetNumber< unsigned char >();
ucWeatherBlendingTo = CLuaArgument( pLuaVM, -1 ).GetNumber< unsigned char >();
return true;
}
@ -6483,7 +6512,7 @@ bool CLuaFunctionDefinitions::GetGravity( lua_State* pLuaVM, float& fGravity )
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
fGravity = static_cast< float >( pLuaArgument.GetNumber() );
fGravity = pLuaArgument.GetNumber< float >();
return true;
}
@ -6499,7 +6528,7 @@ bool CLuaFunctionDefinitions::GetGameSpeed( lua_State* pLuaVM, float& fSpeed )
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
fSpeed = static_cast< float >( pLuaArgument.GetNumber() );
fSpeed = pLuaArgument.GetNumber< float >();
return true;
}
@ -6515,7 +6544,7 @@ bool CLuaFunctionDefinitions::GetWaveHeight( lua_State* pLuaVM, float& fHeight )
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
fHeight = static_cast< float >( pLuaArgument.GetNumber() );
fHeight = pLuaArgument.GetNumber< float >();
return true;
}
@ -6531,7 +6560,7 @@ bool CLuaFunctionDefinitions::GetFPSLimit( lua_State* pLuaVM, unsigned short& us
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
usLimit = static_cast< unsigned short >( pLuaArgument.GetNumber() );
usLimit = pLuaArgument.GetNumber< unsigned short >();
return true;
}
@ -6547,7 +6576,7 @@ bool CLuaFunctionDefinitions::GetMinuteDuration( lua_State* pLuaVM, unsigned lon
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
ulDuration = static_cast< unsigned long >( pLuaArgument.GetNumber() );
ulDuration = pLuaArgument.GetNumber< unsigned long >();
return true;
}
@ -6579,7 +6608,7 @@ bool CLuaFunctionDefinitions::GetTrafficLightState( lua_State* pLuaVM, unsigned
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
ucState = static_cast< unsigned char >( pLuaArgument.GetNumber() );
ucState = pLuaArgument.GetNumber< unsigned char >();
return true;
}
@ -6611,7 +6640,7 @@ bool CLuaFunctionDefinitions::GetJetpackMaxHeight( lua_State* pLuaVM, float& fMa
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
fMaxHeight = static_cast< float >( pLuaArgument.GetNumber() );
fMaxHeight = pLuaArgument.GetNumber< float >();
return true;
}
@ -6627,7 +6656,7 @@ bool CLuaFunctionDefinitions::GetAircraftMaxVelocity( lua_State* pLuaVM, float&
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
fVelocity = static_cast< float >( pLuaArgument.GetNumber() );
fVelocity = pLuaArgument.GetNumber< float >();
return true;
}
@ -6659,7 +6688,7 @@ bool CLuaFunctionDefinitions::GetRainLevel( lua_State* pLuaVM, float& fRainLevel
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
fRainLevel = static_cast< float >( pLuaArgument.GetNumber() );
fRainLevel = pLuaArgument.GetNumber< float >();
return true;
}
@ -6675,7 +6704,7 @@ bool CLuaFunctionDefinitions::GetSunSize( lua_State* pLuaVM, float& fSunSize )
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
fSunSize = static_cast< float >( pLuaArgument.GetNumber() );
fSunSize = pLuaArgument.GetNumber< float >();
return true;
}
@ -6689,13 +6718,13 @@ bool CLuaFunctionDefinitions::GetSunColor( lua_State* pLuaVM, unsigned char& ucC
if( pLuaArguments.Call( pLuaVM, "getSunColor", 6 ) )
{
ucCoreR = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -6 ) )->GetNumber() );
ucCoreG = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -5 ) )->GetNumber() );
ucCoreB = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -4 ) )->GetNumber() );
ucCoreR = CLuaArgument( pLuaVM, -6 ).GetNumber< unsigned char >();
ucCoreG = CLuaArgument( pLuaVM, -5 ).GetNumber< unsigned char >();
ucCoreB = CLuaArgument( pLuaVM, -4 ).GetNumber< unsigned char >();
ucCoronaR = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
ucCoronaG = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
ucCoronaB = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
ucCoronaR = CLuaArgument( pLuaVM, -3 ).GetNumber< unsigned char >();
ucCoronaG = CLuaArgument( pLuaVM, -2 ).GetNumber< unsigned char >();
ucCoronaB = CLuaArgument( pLuaVM, -1 ).GetNumber< unsigned char >();
return true;
}
@ -6709,9 +6738,9 @@ bool CLuaFunctionDefinitions::GetWindVelocity( lua_State* pLuaVM, float& fVelX,
if( pLuaArguments.Call( pLuaVM, "getWindVelocity", 3 ) )
{
fVelX = static_cast< float >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
fVelY = static_cast< float >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
fVelZ = static_cast< float >( ( new CLuaArgument( pLuaVM, -1 ) )->GetNumber() );
fVelX = CLuaArgument( pLuaVM, -3 ).GetNumber< float >();
fVelY = CLuaArgument( pLuaVM, -2 ).GetNumber< float >();
fVelZ = CLuaArgument( pLuaVM, -1 ).GetNumber< float >();
return true;
}
@ -6727,7 +6756,7 @@ bool CLuaFunctionDefinitions::GetFarClipDistance( lua_State* pLuaVM, float& fFar
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
fFarClip = static_cast< float >( pLuaArgument.GetNumber() );
fFarClip = pLuaArgument.GetNumber< float >();
return true;
}
@ -6743,7 +6772,7 @@ bool CLuaFunctionDefinitions::GetFogDistance( lua_State* pLuaVM, float& fFogDist
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
fFogDist = static_cast< float >( pLuaArgument.GetNumber() );
fFogDist = pLuaArgument.GetNumber< float >();
return true;
}
@ -6759,7 +6788,7 @@ bool CLuaFunctionDefinitions::GetAircraftMaxHeight( lua_State* pLuaVM, float& fM
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
fMaxHeight = static_cast< float >( pLuaArgument.GetNumber() );
fMaxHeight = pLuaArgument.GetNumber< float >();
return true;
}
@ -6791,7 +6820,7 @@ bool CLuaFunctionDefinitions::GetMoonSize( lua_State* pLuaVM, int& iSize )
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
iSize = static_cast< int >( pLuaArgument.GetNumber() );
iSize = pLuaArgument.GetNumber< int >();
return true;
}
@ -6904,13 +6933,13 @@ bool CLuaFunctionDefinitions::GetSkyGradient( lua_State* pLuaVM, unsigned char&
if( pLuaArguments.Call( pLuaVM, "getSkyGradient", 6 ) )
{
ucTopRed = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -6 ) )->GetBoolean() );
ucTopGreen = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -5 ) )->GetBoolean() );
ucTopBlue = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -4 ) )->GetBoolean() );
ucTopRed = CLuaArgument( pLuaVM, -6 ).GetNumber< unsigned char >();
ucTopGreen = CLuaArgument( pLuaVM, -5 ).GetNumber< unsigned char >();
ucTopBlue = CLuaArgument( pLuaVM, -4 ).GetNumber< unsigned char >();
ucBottomRed = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -3 ) )->GetBoolean() );
ucBottomGreen = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -2 ) )->GetBoolean() );
ucBottomBlue = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -1 ) )->GetBoolean() );
ucBottomRed = CLuaArgument( pLuaVM, -3 ).GetNumber< unsigned char >();
ucBottomGreen = CLuaArgument( pLuaVM, -2 ).GetNumber< unsigned char >();
ucBottomBlue = CLuaArgument( pLuaVM, -1 ).GetNumber< unsigned char >();
return true;
}
@ -6960,15 +6989,15 @@ bool CLuaFunctionDefinitions::GetHeatHaze( lua_State* pLuaVM, SHeatHazeSettings&
if( pLuaArguments.Call( pLuaVM, "getHeatHaze", 9 ) )
{
heatHazeSettings.ucIntensity = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -9 ) )->GetNumber() );
heatHazeSettings.ucRandomShift = static_cast< unsigned char >( ( new CLuaArgument( pLuaVM, -8 ) )->GetNumber() );
heatHazeSettings.usSpeedMin = static_cast< unsigned short >( ( new CLuaArgument( pLuaVM, -7 ) )->GetNumber() );
heatHazeSettings.usSpeedMax = static_cast< unsigned short >( ( new CLuaArgument( pLuaVM, -6 ) )->GetNumber() );
heatHazeSettings.sScanSizeX = static_cast< short >( ( new CLuaArgument( pLuaVM, -5 ) )->GetNumber() );
heatHazeSettings.sScanSizeY = static_cast< short >( ( new CLuaArgument( pLuaVM, -4 ) )->GetNumber() );
heatHazeSettings.usRenderSizeX = static_cast< unsigned short >( ( new CLuaArgument( pLuaVM, -3 ) )->GetNumber() );
heatHazeSettings.usRenderSizeY = static_cast< unsigned short >( ( new CLuaArgument( pLuaVM, -2 ) )->GetNumber() );
heatHazeSettings.bInsideBuilding = ( new CLuaArgument( pLuaVM, -1 ) )->GetBoolean();
heatHazeSettings.ucIntensity = CLuaArgument( pLuaVM, -9 ).GetNumber< unsigned char >();
heatHazeSettings.ucRandomShift = CLuaArgument( pLuaVM, -8 ).GetNumber< unsigned char >();
heatHazeSettings.usSpeedMin = CLuaArgument( pLuaVM, -7 ).GetNumber< unsigned short >();
heatHazeSettings.usSpeedMax = CLuaArgument( pLuaVM, -6 ).GetNumber< unsigned short >();
heatHazeSettings.sScanSizeX = CLuaArgument( pLuaVM, -5 ).GetNumber< short >();
heatHazeSettings.sScanSizeY = CLuaArgument( pLuaVM, -4 ).GetNumber< short >();
heatHazeSettings.usRenderSizeX = CLuaArgument( pLuaVM, -3 ).GetNumber< unsigned short >();
heatHazeSettings.usRenderSizeY = CLuaArgument( pLuaVM, -2 ).GetNumber< unsigned short >();
heatHazeSettings.bInsideBuilding = CLuaArgument( pLuaVM, -1 ).GetBoolean();
return true;
}
@ -7640,18 +7669,17 @@ PVOID CLuaFunctionDefinitions::GetAccount( lua_State* pLuaVM, const char* szName
return nullptr;
}
CLuaArguments* CLuaFunctionDefinitions::GetAccounts( lua_State* pLuaVM )
CLuaArgumentsVector CLuaFunctionDefinitions::GetAccounts( lua_State* pLuaVM )
{
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
if( pLuaArguments.Call( pLuaVM, "getAccounts", 1 ) )
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
return pLuaArgument.GetArray();
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument.GetArray();
}
PVOID CLuaFunctionDefinitions::GetAccountPlayer( lua_State* pLuaVM, PVOID pAccount )
@ -7691,8 +7719,9 @@ bool CLuaFunctionDefinitions::IsGuestAccount( lua_State* pLuaVM, PVOID pAccount,
return false;
}
CLuaArgument* CLuaFunctionDefinitions::GetAccountData( lua_State* pLuaVM, PVOID pAccount, const char* szKey )
CLuaArgument CLuaFunctionDefinitions::GetAccountData( lua_State* pLuaVM, PVOID pAccount, const char* szKey )
{
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
pLuaArguments.PushUserData( pAccount );
@ -7700,10 +7729,10 @@ CLuaArgument* CLuaFunctionDefinitions::GetAccountData( lua_State* pLuaVM, PVOID
if( pLuaArguments.Call( pLuaVM, "getAccountData", 1 ) )
{
return new CLuaArgument( pLuaVM, -1 );
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument;
}
bool CLuaFunctionDefinitions::GetAllAccountData( lua_State* pLuaVM, PVOID pAccount )
@ -8370,20 +8399,19 @@ bool CLuaFunctionDefinitions::RemoveResourceFile( lua_State* pLuaVM, PVOID pReso
return false;
}
CLuaArguments* CLuaFunctionDefinitions::GetResourceExportedFunctions( lua_State* pLuaVM, PVOID pResource )
CLuaArgumentsVector CLuaFunctionDefinitions::GetResourceExportedFunctions( lua_State* pLuaVM, PVOID pResource )
{
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
pLuaArguments.PushUserData( pResource );
if( pLuaArguments.Call( pLuaVM, "getResourceExportedFunctions", 1 ) )
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
return pLuaArgument.GetArray();
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument.GetArray();
}
PVOID CLuaFunctionDefinitions::GetResourceFromName( lua_State* pLuaVM, const char* szResourceName )
@ -8496,18 +8524,17 @@ bool CLuaFunctionDefinitions::GetResourceName( lua_State* pLuaVM, PVOID pResourc
return false;
}
CLuaArguments* CLuaFunctionDefinitions::GetResources( lua_State* pLuaVM )
CLuaArgumentsVector CLuaFunctionDefinitions::GetResources( lua_State* pLuaVM )
{
CLuaArgument pLuaArgument;
CLuaArguments pLuaArguments;
if( pLuaArguments.Call( pLuaVM, "getResources", 1 ) )
{
CLuaArgument pLuaArgument( pLuaVM, -1 );
return pLuaArgument.GetArray();
pLuaArgument.Read( pLuaVM, -1 );
}
return nullptr;
return pLuaArgument.GetArray();
}
bool CLuaFunctionDefinitions::GetResourceState( lua_State* pLuaVM, PVOID pResource, string& strState )
@ -8762,16 +8789,16 @@ bool CLuaFunctionDefinitions::UpdateResourceACLRequest( lua_State* pLuaVM, PVOID
// Version funcs
LuaTable CLuaFunctionDefinitions::GetVersion( lua_State* pLuaVM )
CLuaArgumentsMap CLuaFunctionDefinitions::GetVersion( lua_State* pLuaVM )
{
LuaTable pLuaTable;
CLuaArgument pLuaArgument;
if( CLuaArguments().Call( pLuaVM, "getVersion", 1 ) )
{
pLuaTable = CLuaArgument( pLuaVM, -1 ).GetTable();
pLuaArgument.Read( pLuaVM, -1 );
}
return pLuaTable;
return pLuaArgument.GetTable();
}
// Camera get functions
@ -8979,7 +9006,7 @@ bool CLuaFunctionDefinitions::GiveWeapon( lua_State* pLuaVM, PVOID pElement, uns
if( pLuaArguments.Call( pLuaVM, "giveWeapon", 1 ) )
{
return ( new CLuaArgument( pLuaVM, -1 ) )->GetBoolean();
return CLuaArgument( pLuaVM, -1 ).GetBoolean();
}
return false;
@ -8995,7 +9022,7 @@ bool CLuaFunctionDefinitions::TakeWeapon( lua_State* pLuaVM, PVOID pElement, uns
if( pLuaArguments.Call( pLuaVM, "takeWeapon", 1 ) )
{
return ( new CLuaArgument( pLuaVM, -1 ) )->GetBoolean();
return CLuaArgument( pLuaVM, -1 ).GetBoolean();
}
return false;
@ -9009,7 +9036,7 @@ bool CLuaFunctionDefinitions::TakeAllWeapons( lua_State* pLuaVM, PVOID pElement
if( pLuaArguments.Call( pLuaVM, "takeAllWeapons", 1 ) )
{
return ( new CLuaArgument( pLuaVM, -1 ) )->GetBoolean();
return CLuaArgument( pLuaVM, -1 ).GetBoolean();
}
return false;
@ -9026,7 +9053,7 @@ bool CLuaFunctionDefinitions::SetWeaponAmmo( lua_State* pLuaVM, PVOID pElement,
if( pLuaArguments.Call( pLuaVM, "setWeaponAmmo", 1 ) )
{
return ( new CLuaArgument( pLuaVM, -1 ) )->GetBoolean();
return CLuaArgument( pLuaVM, -1 ).GetBoolean();
}
return false;

780
mta-mono/src/lua/CLuaFunctionDefinitions.h
View File

@ -29,8 +29,8 @@ public:
static string GetRuleValue ( lua_State* pLuaVM, const char* szKey );
static bool SetRuleValue ( lua_State* pLuaVM, const char* szKey, const char* szValue );
static bool RemoveRuleValue ( lua_State* pLuaVM, const char* szKey );
static string GetPlayerAnnounceValue ( lua_State* pLuaVM, void* pElement, const char* szKey );
static bool SetPlayerAnnounceValue ( lua_State* pLuaVM, void* pElement, const char* szKey, const char* szValue );
static string GetPlayerAnnounceValue ( lua_State* pLuaVM, PVOID pElement, const char* szKey );
static bool SetPlayerAnnounceValue ( lua_State* pLuaVM, PVOID pElement, const char* szKey, const char* szValue );
static string Get ( lua_State* pLuaVM, const char* szKey );
static bool Set ( lua_State* pLuaVM, const char* szKey, const char* szValue );
@ -38,7 +38,7 @@ public:
static string GetMapName ( lua_State* pLuaVM );
static bool AddCommandHandler ( lua_State* pLuaVM, const char* szCommand, lua_CFunction iLuaFunction, bool bRestricted = false, bool bCaseSensitive = true );
static bool ExecuteCommandHandler ( lua_State* pLuaVM, const char* szCommand, void* pUserData, const char* szArgs );
static bool ExecuteCommandHandler ( lua_State* pLuaVM, const char* szCommand, PVOID pUserData, const char* szArgs );
static bool RemoveCommandHandler ( lua_State* pLuaVM, const char* szCommand, lua_CFunction iLuaFunction );
// static int CallRemote ( lua_State* luaVM );
@ -46,176 +46,176 @@ public:
// Event functions
static bool AddEvent ( lua_State* pLuaVM, const char* szName, bool bAllowRemoteTrigger );
static bool AddEventHandler ( lua_State* pLuaVM, const char* szName, void* pUserData, lua_CFunction iLuaFunction, bool bPropagated, const char* szEventPriority );
static bool RemoveEventHandler ( lua_State* pLuaVM, const char* szName, void* pUserData, lua_CFunction iLuaFunction );
static bool AddEventHandler ( lua_State* pLuaVM, const char* szName, PVOID pUserData, lua_CFunction iLuaFunction, bool bPropagated, const char* szEventPriority );
static bool RemoveEventHandler ( lua_State* pLuaVM, const char* szName, PVOID pUserData, lua_CFunction iLuaFunction );
// static bool GetEventHandlers ( lua_State* pLuaVM, const char* szName );
static bool TriggerEvent ( lua_State* pLuaVM, const char* szName, void* pUserData, CLuaArguments& Arguments );
static bool TriggerEvent ( lua_State* pLuaVM, const char* szName, PVOID pUserData, CLuaArguments& Arguments );
static bool CancelEvent ( lua_State* pLuaVM, bool bCancel, const char* szReason );
static bool WasEventCancelled ( lua_State* pLuaVM );
static string GetCancelReason ( lua_State* pLuaVM );
static bool TriggerClientEvent ( lua_State* pLuaVM, void* pSendTo, const char* szName, void* pSource, CLuaArguments& Arguments );
static bool TriggerClientEvent ( lua_State* pLuaVM, PVOID pSendTo, const char* szName, PVOID pSource, CLuaArguments& Arguments );
// static int TriggerLatentClientEvent ( lua_State* pLuaVM );
// static int GetLatentEventHandles ( lua_State* pLuaVM );
// static int GetLatentEventStatus ( lua_State* pLuaVM );
// static int CancelLatentEvent ( lua_State* pLuaVM );
// Element create/destroy
static void* CreateElement ( lua_State* pLuaVM, const char* szTypeName, const char* szID );
static bool DestroyElement ( lua_State* pLuaVM, void* pUserData );
static void* CloneElement ( lua_State* pLuaVM, void* pUserData, const Vector3& vecPosition, bool bCloneElement );
static PVOID CreateElement ( lua_State* pLuaVM, const char* szTypeName, const char* szID );
static bool DestroyElement ( lua_State* pLuaVM, PVOID pUserData );
static PVOID CloneElement ( lua_State* pLuaVM, PVOID pUserData, const Vector3& vecPosition, bool bCloneElement );
// Element get funcs
static CLuaArguments* GetElementsByType ( lua_State* pLuaVM, const char* szTypeName, void* pUserData = NULL );
static bool IsElement ( lua_State* pLuaVM, void* pUserData );
static string GetElementType ( lua_State* pLuaVM, void* pUserData );
static void* GetElementByID ( lua_State* pLuaVM, const char* szID, unsigned int uiIndex );
static void* GetElementByIndex ( lua_State* pLuaVM, int iIndex );
static void* GetElementChild ( lua_State* pLuaVM, void* pUserData, int iIndex );
static int GetElementChildrenCount ( lua_State* pLuaVM, void* pUserData );
static string GetElementID ( lua_State* pLuaVM, void* pUserData );
static CLuaArgument* GetElementData ( lua_State* pLuaVM, void* pUserData, string sKey, bool bInherit = true );
static CLuaArguments* GetAllElementData ( lua_State* pLuaVM, void* pUserData );
static void* GetElementParent ( lua_State* pLuaVM, void* pUserData );
static bool GetElementPosition ( lua_State* pLuaVM, void* pUserData, Vector3& vecPosition );
static bool GetElementRotation ( lua_State* pLuaVM, void* pUserData, Vector3& vecRotation );
static bool GetElementVelocity ( lua_State* pLuaVM, void* pUserData, Vector3& vecVelocity );
static bool GetElementInterior ( lua_State* pLuaVM, void* pUserData, unsigned char& ucInterior );
static bool IsElementWithinColShape ( lua_State* pLuaVM, void* pUserData, bool& bWithin );
static bool IsElementWithinMarker ( lua_State* pLuaVM, void* pUserData, bool& bWithin );
static bool GetElementDimension ( lua_State* pLuaVM, void* pUserData, unsigned short& usDimension );
static bool GetElementZoneName ( lua_State* pLuaVM, void* pUserData, string& strOutName, bool bCitiesOnly = false );
static bool IsElementAttached ( lua_State* pLuaVM, void* pUserData );
static void* GetElementAttachedTo ( lua_State* pLuaVM, void* pUserData );
static void* GetElementColShape ( lua_State* pLuaVM, void* pUserData );
static bool GetElementAlpha ( lua_State* pLuaVM, void* pUserData, unsigned char& ucAlpha );
static bool IsElementDoubleSided ( lua_State* pLuaVM, void* pUserData, bool& bDoubleSided );
static bool GetElementHealth ( lua_State* pLuaVM, void* pUserData, float& fHealth );
static bool GetElementModel ( lua_State* pLuaVM, void* pUserData, unsigned short& usModel );
static bool IsElementInWater ( lua_State* pLuaVM, void* pUserData, bool& bInWater );
static bool GetElementAttachedOffsets ( lua_State* pLuaVM, void* pUserData, Vector3& vecPosition, Vector3& vecRotation );
static void* GetElementSyncer ( lua_State* pLuaVM, void* pUserData );
static bool GetElementCollisionsEnabled ( lua_State* pLuaVM, void* pUserData );
static bool IsElementFrozen ( lua_State* pLuaVM, void* pUserData, bool& bFrozen );
static bool GetLowLodElement ( lua_State* pLuaVM, void* pUserData, void*& pOutLowLodElement );
static bool IsElementLowLod ( lua_State* pLuaVM, void* pUserData, bool& bOutLowLod );
static CLuaArgumentsVector GetElementsByType ( lua_State* pLuaVM, const char* szTypeName, PVOID pUserData = nullptr );
static bool IsElement ( lua_State* pLuaVM, PVOID pUserData );
static string GetElementType ( lua_State* pLuaVM, PVOID pUserData );
static PVOID GetElementByID ( lua_State* pLuaVM, const char* szID, unsigned int uiIndex );
static PVOID GetElementByIndex ( lua_State* pLuaVM, int iIndex );
static PVOID GetElementChild ( lua_State* pLuaVM, PVOID pUserData, int iIndex );
static int GetElementChildrenCount ( lua_State* pLuaVM, PVOID pUserData );
static string GetElementID ( lua_State* pLuaVM, PVOID pUserData );
static CLuaArgument GetElementData ( lua_State* pLuaVM, PVOID pUserData, string sKey, bool bInherit = true );
static CLuaArguments GetAllElementData ( lua_State* pLuaVM, PVOID pUserData );
static PVOID GetElementParent ( lua_State* pLuaVM, PVOID pUserData );
static bool GetElementPosition ( lua_State* pLuaVM, PVOID pUserData, Vector3& vecPosition );
static bool GetElementRotation ( lua_State* pLuaVM, PVOID pUserData, Vector3& vecRotation );
static bool GetElementVelocity ( lua_State* pLuaVM, PVOID pUserData, Vector3& vecVelocity );
static bool GetElementInterior ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucInterior );
static bool IsElementWithinColShape ( lua_State* pLuaVM, PVOID pUserData, bool& bWithin );
static bool IsElementWithinMarker ( lua_State* pLuaVM, PVOID pUserData, bool& bWithin );
static bool GetElementDimension ( lua_State* pLuaVM, PVOID pUserData, unsigned short& usDimension );
static bool GetElementZoneName ( lua_State* pLuaVM, PVOID pUserData, string& strOutName, bool bCitiesOnly = false );
static bool IsElementAttached ( lua_State* pLuaVM, PVOID pUserData );
static PVOID GetElementAttachedTo ( lua_State* pLuaVM, PVOID pUserData );
static PVOID GetElementColShape ( lua_State* pLuaVM, PVOID pUserData );
static bool GetElementAlpha ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucAlpha );
static bool IsElementDoubleSided ( lua_State* pLuaVM, PVOID pUserData, bool& bDoubleSided );
static bool GetElementHealth ( lua_State* pLuaVM, PVOID pUserData, float& fHealth );
static bool GetElementModel ( lua_State* pLuaVM, PVOID pUserData, unsigned short& usModel );
static bool IsElementInWater ( lua_State* pLuaVM, PVOID pUserData, bool& bInWater );
static bool GetElementAttachedOffsets ( lua_State* pLuaVM, PVOID pUserData, Vector3& vecPosition, Vector3& vecRotation );
static PVOID GetElementSyncer ( lua_State* pLuaVM, PVOID pUserData );
static bool GetElementCollisionsEnabled ( lua_State* pLuaVM, PVOID pUserData );
static bool IsElementFrozen ( lua_State* pLuaVM, PVOID pUserData, bool& bFrozen );
static bool GetLowLodElement ( lua_State* pLuaVM, PVOID pUserData, PVOID& pOutLowLodElement );
static bool IsElementLowLod ( lua_State* pLuaVM, PVOID pUserData, bool& bOutLowLod );
// Element set funcs
static bool ClearElementVisibleTo ( lua_State* pLuaVM, void* pUserData );
static bool SetElementID ( lua_State* pLuaVM, void* pUserData, string sID );
static bool SetElementData ( lua_State* pLuaVM, void* pUserData, string sKey, const CLuaArgument& Variable );
static bool RemoveElementData ( lua_State* pLuaVM, void* pUserData, string sKey );
static bool SetElementParent ( lua_State* pLuaVM, void* pUserData, void* pTarget );
static bool SetElementPosition ( lua_State* pLuaVM, void* pUserData, const Vector3& vecPosition, bool bWarp = true );
static bool SetElementRotation ( lua_State* pLuaVM, void* pUserData, const Vector3& vecRotation, const char* szRotationOrder = "default", bool bNewWay = false );
static bool SetElementVelocity ( lua_State* pLuaVM, void* pUserData, const Vector3& vecVelocity );
static bool SetElementVisibleTo ( lua_State* pLuaVM, void* pUserData, void* pTarget, bool bVisible );
static bool SetElementInterior ( lua_State* pLuaVM, void* pUserData, int iInterior );
static bool SetElementDimension ( lua_State* pLuaVM, void* pUserData, int iDimension );
static bool AttachElements ( lua_State* pLuaVM, void* pUserData, void* pTarget, Vector3& vecPosition, Vector3& vecRotation );
static bool DetachElements ( lua_State* pLuaVM, void* pUserData, void* pTarget = NULL );
static bool SetElementAlpha ( lua_State* pLuaVM, void* pUserData, int iAlpha );
static bool SetElementDoubleSided ( lua_State* pLuaVM, void* pUserData, bool bDoubleSided );
static bool SetElementHealth ( lua_State* pLuaVM, void* pUserData, float fHealth );
static bool SetElementModel ( lua_State* pLuaVM, void* pUserData, int iModel );
static bool SetElementAttachedOffsets ( lua_State* pLuaVM, void* pUserData, Vector3& vecPosition, Vector3& vecRotation );
static bool SetElementSyncer ( lua_State* pLuaVM, void* pUserData, void* pPlayer );
static bool SetElementCollisionsEnabled ( lua_State* pLuaVM, void* pUserData, bool bEnabled );
static bool SetElementFrozen ( lua_State* pLuaVM, void* pUserData, bool bFrozen );
static bool SetLowLodElement ( lua_State* pLuaVM, void* pUserData, bool bEnabled );
static bool ClearElementVisibleTo ( lua_State* pLuaVM, PVOID pUserData );
static bool SetElementID ( lua_State* pLuaVM, PVOID pUserData, string sID );
static bool SetElementData ( lua_State* pLuaVM, PVOID pUserData, string sKey, const CLuaArgument& Variable );
static bool RemoveElementData ( lua_State* pLuaVM, PVOID pUserData, string sKey );
static bool SetElementParent ( lua_State* pLuaVM, PVOID pUserData, PVOID pTarget );
static bool SetElementPosition ( lua_State* pLuaVM, PVOID pUserData, const Vector3& vecPosition, bool bWarp = true );
static bool SetElementRotation ( lua_State* pLuaVM, PVOID pUserData, const Vector3& vecRotation, const char* szRotationOrder = "default", bool bNewWay = false );
static bool SetElementVelocity ( lua_State* pLuaVM, PVOID pUserData, const Vector3& vecVelocity );
static bool SetElementVisibleTo ( lua_State* pLuaVM, PVOID pUserData, PVOID pTarget, bool bVisible );
static bool SetElementInterior ( lua_State* pLuaVM, PVOID pUserData, int iInterior );
static bool SetElementDimension ( lua_State* pLuaVM, PVOID pUserData, int iDimension );
static bool AttachElements ( lua_State* pLuaVM, PVOID pUserData, PVOID pTarget, Vector3& vecPosition, Vector3& vecRotation );
static bool DetachElements ( lua_State* pLuaVM, PVOID pUserData, PVOID pTarget = NULL );
static bool SetElementAlpha ( lua_State* pLuaVM, PVOID pUserData, int iAlpha );
static bool SetElementDoubleSided ( lua_State* pLuaVM, PVOID pUserData, bool bDoubleSided );
static bool SetElementHealth ( lua_State* pLuaVM, PVOID pUserData, float fHealth );
static bool SetElementModel ( lua_State* pLuaVM, PVOID pUserData, int iModel );
static bool SetElementAttachedOffsets ( lua_State* pLuaVM, PVOID pUserData, Vector3& vecPosition, Vector3& vecRotation );
static bool SetElementSyncer ( lua_State* pLuaVM, PVOID pUserData, PVOID pPlayer );
static bool SetElementCollisionsEnabled ( lua_State* pLuaVM, PVOID pUserData, bool bEnabled );
static bool SetElementFrozen ( lua_State* pLuaVM, PVOID pUserData, bool bFrozen );
static bool SetLowLodElement ( lua_State* pLuaVM, PVOID pUserData, bool bEnabled );
// Player get functions
static unsigned int GetPlayerCount ( lua_State* pLuaVM );
static void* GetPlayerFromName ( lua_State* pLuaVM, const char* szNick );
static bool GetPlayerPing ( lua_State* pLuaVM, void* pUserData, unsigned int& uiPing );
static bool GetPlayerMoney ( lua_State* pLuaVM, void* pUserData, long& lMoney );
static void* GetRandomPlayer ( lua_State* pLuaVM );
static bool IsPlayerMuted ( lua_State* pLuaVM, void* pUserData, bool& bMuted );
static void* GetPlayerTeam ( lua_State* pLuaVM, void* pUserData );
static bool GetPlayerWantedLevel ( lua_State* pLuaVM, void* pUserData, unsigned int& uiWantedLevel );
static CLuaArguments* GetAlivePlayers ( lua_State* pLuaVM );
static CLuaArguments* GetDeadPlayers ( lua_State* pLuaVM );
static bool GetPlayerIdleTime ( lua_State* pLuaVM, void* pUserData, unsigned int& uiIdleTime );
static bool IsPlayerMapForced ( lua_State* pLuaVM, void* pUserData, bool& bForced );
static bool GetPlayerNametagText ( lua_State* pLuaVM, void* pUserData, string& strOutText );
static bool GetPlayerNametagColor ( lua_State* pLuaVM, void* pUserData, unsigned char& ucR, unsigned char& ucG, unsigned char& ucB );
static bool IsPlayerNametagShowing ( lua_State* pLuaVM, void* pUserData, bool& bShowing );
static string GetPlayerSerial ( lua_State* pLuaVM, void* pUserData );
static string GetPlayerUserName ( lua_State* pLuaVM, void* pUserData );
static bool GetPlayerBlurLevel ( lua_State* pLuaVM, void* pUserData, unsigned char& ucLevel );
static bool GetPlayerName ( lua_State* pLuaVM, void* pUserData, string& strOutName );
static bool GetPlayerIP ( lua_State* pLuaVM, void* pUserData, string& strOutIP );
static void* GetPlayerAccount ( lua_State* pLuaVM, void* pUserData );
static string GetPlayerVersion ( lua_State* pLuaVM, void* pUserData );
static LuaTable GetPlayerACInfo ( lua_State* pLuaVM, void* pUserData );
static PVOID GetPlayerFromName ( lua_State* pLuaVM, const char* szNick );
static bool GetPlayerPing ( lua_State* pLuaVM, PVOID pUserData, unsigned int& uiPing );
static bool GetPlayerMoney ( lua_State* pLuaVM, PVOID pUserData, long& lMoney );
static PVOID GetRandomPlayer ( lua_State* pLuaVM );
static bool IsPlayerMuted ( lua_State* pLuaVM, PVOID pUserData, bool& bMuted );
static PVOID GetPlayerTeam ( lua_State* pLuaVM, PVOID pUserData );
static bool GetPlayerWantedLevel ( lua_State* pLuaVM, PVOID pUserData, unsigned int& uiWantedLevel );
static CLuaArgumentsVector GetAlivePlayers ( lua_State* pLuaVM );
static CLuaArgumentsVector GetDeadPlayers ( lua_State* pLuaVM );
static bool GetPlayerIdleTime ( lua_State* pLuaVM, PVOID pUserData, unsigned int& uiIdleTime );
static bool IsPlayerMapForced ( lua_State* pLuaVM, PVOID pUserData, bool& bForced );
static bool GetPlayerNametagText ( lua_State* pLuaVM, PVOID pUserData, string& strOutText );
static bool GetPlayerNametagColor ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucR, unsigned char& ucG, unsigned char& ucB );
static bool IsPlayerNametagShowing ( lua_State* pLuaVM, PVOID pUserData, bool& bShowing );
static string GetPlayerSerial ( lua_State* pLuaVM, PVOID pUserData );
static string GetPlayerUserName ( lua_State* pLuaVM, PVOID pUserData );
static bool GetPlayerBlurLevel ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucLevel );
static bool GetPlayerName ( lua_State* pLuaVM, PVOID pUserData, string& strOutName );
static bool GetPlayerIP ( lua_State* pLuaVM, PVOID pUserData, string& strOutIP );
static PVOID GetPlayerAccount ( lua_State* pLuaVM, PVOID pUserData );
static string GetPlayerVersion ( lua_State* pLuaVM, PVOID pUserData );
static CLuaArgumentsMap* GetPlayerACInfo ( lua_State* pLuaVM, PVOID pUserData );
// Player set functions
static bool SetPlayerMoney ( lua_State* pLuaVM, void* pUserData, int iAmount, bool bInstant = false );
static bool GivePlayerMoney ( lua_State* pLuaVM, void* pUserData, int iAmount );
static bool TakePlayerMoney ( lua_State* pLuaVM, void* pUserData, int iAmount );
static bool SpawnPlayer ( lua_State* pLuaVM, void* pUserData, Vector3& vecPosition, int iRotation = 0, int iSkinID = 0, int iInterior = 0, int iDimension = 0, void* theTeam = NULL );
static bool ShowPlayerHudComponent ( lua_State* pLuaVM, void* pUserData, string sComponent, bool bShow );
static bool SetPlayerWantedLevel ( lua_State* pLuaVM, void* pUserData, int iLevel );
static bool ForcePlayerMap ( lua_State* pLuaVM, void* pUserData, bool bForceOn );
static bool SetPlayerNametagText ( lua_State* pLuaVM, void* pUserData, string sText );
static bool SetPlayerNametagColor ( lua_State* pLuaVM, void* pUserData, int iRed = 0, int iGreen = 0, int iBlue = 0 );
static bool SetPlayerNametagShowing ( lua_State* pLuaVM, void* pUserData, bool bShowing );
static bool SetPlayerMuted ( lua_State* pLuaVM, void* pUserData, bool bMuted );
static bool SetPlayerBlurLevel ( lua_State* pLuaVM, void* pUserData, int iLevel );
static bool RedirectPlayer ( lua_State* pLuaVM, void* pUserData, const char* szServerIP, int iServerPort, const char* szServerPassword );
static bool SetPlayerName ( lua_State* pLuaVM, void* pUserData, string sName );
static bool DetonateSatchels ( lua_State* pLuaVM, void* pUserData );
static bool TakePlayerScreenShot ( lua_State* pLuaVM, void* pUserData, int iWidth, int iHeight, string sTag = "", int iQuality = 30, int iMaxBandwith = 5000 );
static bool SetPlayerMoney ( lua_State* pLuaVM, PVOID pUserData, int iAmount, bool bInstant = false );
static bool GivePlayerMoney ( lua_State* pLuaVM, PVOID pUserData, int iAmount );
static bool TakePlayerMoney ( lua_State* pLuaVM, PVOID pUserData, int iAmount );
static bool SpawnPlayer ( lua_State* pLuaVM, PVOID pUserData, Vector3& vecPosition, int iRotation = 0, int iSkinID = 0, int iInterior = 0, int iDimension = 0, PVOID theTeam = NULL );
static bool ShowPlayerHudComponent ( lua_State* pLuaVM, PVOID pUserData, string sComponent, bool bShow );
static bool SetPlayerWantedLevel ( lua_State* pLuaVM, PVOID pUserData, int iLevel );
static bool ForcePlayerMap ( lua_State* pLuaVM, PVOID pUserData, bool bForceOn );
static bool SetPlayerNametagText ( lua_State* pLuaVM, PVOID pUserData, string sText );
static bool SetPlayerNametagColor ( lua_State* pLuaVM, PVOID pUserData, int iRed = 0, int iGreen = 0, int iBlue = 0 );
static bool SetPlayerNametagShowing ( lua_State* pLuaVM, PVOID pUserData, bool bShowing );
static bool SetPlayerMuted ( lua_State* pLuaVM, PVOID pUserData, bool bMuted );
static bool SetPlayerBlurLevel ( lua_State* pLuaVM, PVOID pUserData, int iLevel );
static bool RedirectPlayer ( lua_State* pLuaVM, PVOID pUserData, const char* szServerIP, int iServerPort, const char* szServerPassword );
static bool SetPlayerName ( lua_State* pLuaVM, PVOID pUserData, string sName );
static bool DetonateSatchels ( lua_State* pLuaVM, PVOID pUserData );
static bool TakePlayerScreenShot ( lua_State* pLuaVM, PVOID pUserData, int iWidth, int iHeight, string sTag = "", int iQuality = 30, int iMaxBandwith = 5000 );
// Ped get functions
static void* CreatePed ( lua_State* pLuaVM, int iModelid, const Vector3& vecPosition, float fRot = 0.0, bool bSynced = true );
static bool GetPedArmor ( lua_State* pLuaVM, void* pUserData, float& fArmor );
static bool IsPedChoking ( lua_State* pLuaVM, void* pUserData, bool& bIsChoking );
static bool IsPedDead ( lua_State* pLuaVM, void* pUserData, bool& bDead );
static bool IsPedDucked ( lua_State* pLuaVM, void* pUserData, bool& bDucked );
static bool GetPedStat ( lua_State* pLuaVM, void* pUserData, unsigned short usStat, float& fValue );
static void* GetPedTarget ( lua_State* pLuaVM, void* pUserData );
static int GetPedWeapon ( lua_State* pLuaVM, void* pUserData, int iWeaponSlot = -1 );
static bool GetPedClothes ( lua_State* pLuaVM, void* pUserData, unsigned char ucType, string& strOutTexture, string& strOutModel );
static bool DoesPedHaveJetPack ( lua_State* pLuaVM, void* pUserData, bool& bHasJetPack );
static bool IsPedOnGround ( lua_State* pLuaVM, void* pUserData, bool& bOnGround );
static bool GetPedFightingStyle ( lua_State* pLuaVM, void* pUserData, unsigned char& ucStyle );
static bool GetPedMoveAnim ( lua_State* pLuaVM, void* pUserData, unsigned int& iMoveAnim );
static bool GetPedGravity ( lua_State* pLuaVM, void* pUserData, float& fGravity );
static void* GetPedContactElement ( lua_State* pLuaVM, void* pUserData );
static bool GetPedWeaponSlot ( lua_State* pLuaVM, void* pUserData, unsigned char& ucWeaponSlot );
static bool IsPedDoingGangDriveby ( lua_State* pLuaVM, void* pUserData, bool & bDoingGangDriveby );
static bool IsPedOnFire ( lua_State* pLuaVM, void* pUserData, bool & bIsOnFire );
static bool IsPedHeadless ( lua_State* pLuaVM, void* pUserData, bool & bIsHeadless );
static bool IsPedFrozen ( lua_State* pLuaVM, void* pUserData, bool & bIsFrozen );
static void* GetPedOccupiedVehicle ( lua_State* pLuaVM, void* pUserData );
static bool GetPedOccupiedVehicleSeat ( lua_State* pLuaVM, void* pUserData, unsigned int& uiSeat );
static bool IsPedInVehicle ( lua_State* pLuaVM, void* pUserData, bool & bIsInVehicle );
static PVOID CreatePed ( lua_State* pLuaVM, int iModelid, const Vector3& vecPosition, float fRot = 0.0, bool bSynced = true );
static bool GetPedArmor ( lua_State* pLuaVM, PVOID pUserData, float& fArmor );
static bool IsPedChoking ( lua_State* pLuaVM, PVOID pUserData, bool& bIsChoking );
static bool IsPedDead ( lua_State* pLuaVM, PVOID pUserData, bool& bDead );
static bool IsPedDucked ( lua_State* pLuaVM, PVOID pUserData, bool& bDucked );
static bool GetPedStat ( lua_State* pLuaVM, PVOID pUserData, unsigned short usStat, float& fValue );
static PVOID GetPedTarget ( lua_State* pLuaVM, PVOID pUserData );
static int GetPedWeapon ( lua_State* pLuaVM, PVOID pUserData, int iWeaponSlot = -1 );
static bool GetPedClothes ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucType, string& strOutTexture, string& strOutModel );
static bool DoesPedHaveJetPack ( lua_State* pLuaVM, PVOID pUserData, bool& bHasJetPack );
static bool IsPedOnGround ( lua_State* pLuaVM, PVOID pUserData, bool& bOnGround );
static bool GetPedFightingStyle ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucStyle );
static bool GetPedMoveAnim ( lua_State* pLuaVM, PVOID pUserData, unsigned int& iMoveAnim );
static bool GetPedGravity ( lua_State* pLuaVM, PVOID pUserData, float& fGravity );
static PVOID GetPedContactElement ( lua_State* pLuaVM, PVOID pUserData );
static bool GetPedWeaponSlot ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucWeaponSlot );
static bool IsPedDoingGangDriveby ( lua_State* pLuaVM, PVOID pUserData, bool & bDoingGangDriveby );
static bool IsPedOnFire ( lua_State* pLuaVM, PVOID pUserData, bool & bIsOnFire );
static bool IsPedHeadless ( lua_State* pLuaVM, PVOID pUserData, bool & bIsHeadless );
static bool IsPedFrozen ( lua_State* pLuaVM, PVOID pUserData, bool & bIsFrozen );
static PVOID GetPedOccupiedVehicle ( lua_State* pLuaVM, PVOID pUserData );
static bool GetPedOccupiedVehicleSeat ( lua_State* pLuaVM, PVOID pUserData, unsigned int& uiSeat );
static bool IsPedInVehicle ( lua_State* pLuaVM, PVOID pUserData, bool & bIsInVehicle );
static bool GetWeaponProperty ( lua_State* pLuaVM, unsigned char ucWeaponID, const char* szWeaponSkill, const char* szProperty, short& uData );
static bool GetOriginalWeaponProperty ( lua_State* pLuaVM, unsigned char ucWeaponID, const char *szWeaponSkill, const char* szProperty, short& uData );
// Ped set functions
static bool SetPedArmor ( lua_State* pLuaVM, void* pUserData, float fArmor );
static bool KillPed ( lua_State* pLuaVM, void* pUserData, void* pKiller = NULL, unsigned char ucKillerWeapon = 0xFF, unsigned char ucBodyPart = 0xFF, bool bStealth = false );
static bool SetPedStat ( lua_State* pLuaVM, void* pUserData, unsigned short usStat, float fValue );
static bool AddPedClothes ( lua_State* pLuaVM, void* pUserData, const char* szTexture, const char* szModel, unsigned char ucType );
static bool RemovePedClothes ( lua_State* pLuaVM, void* pUserData, unsigned char ucType, const char* szTexture = NULL, const char* szModel = NULL );
static bool GivePedJetPack ( lua_State* pLuaVM, void* pUserData );
static bool RemovePedJetPack ( lua_State* pLuaVM, void* pUserData );
static bool SetPedFightingStyle ( lua_State* pLuaVM, void* pUserData, unsigned char ucStyle );
static bool SetPedMoveAnim ( lua_State* pLuaVM, void* pUserData, unsigned int iMoveAnim );
static bool SetPedGravity ( lua_State* pLuaVM, void* pUserData, float fGravity );
static bool SetPedChoking ( lua_State* pLuaVM, void* pUserData, bool bChoking );
static bool SetPedWeaponSlot ( lua_State* pLuaVM, void* pUserData, unsigned char ucWeaponSlot );
static bool WarpPedIntoVehicle ( lua_State* pLuaVM, void* pUserData, void* pVehicle, unsigned int uiSeat = 0 );
static bool RemovePedFromVehicle ( lua_State* pLuaVM, void* pUserData );
static bool SetPedDoingGangDriveby ( lua_State* pLuaVM, void* pUserData, bool bGangDriveby );
static bool SetPedAnimation ( lua_State* pLuaVM, void* pUserData, const char * szBlockName, const char * szAnimName, int iTime, bool bLoop, bool bUpdatePosition, bool bInterruptable, bool bFreezeLastFrame );
static bool SetPedAnimationProgress ( lua_State* pLuaVM, void* pUserData, const char * szAnimName, float fProgress );
static bool SetPedOnFire ( lua_State* pLuaVM, void* pUserData, bool bIsOnFire );
static bool SetPedHeadless ( lua_State* pLuaVM, void* pUserData, bool bIsHeadless );
static bool SetPedFrozen ( lua_State* pLuaVM, void* pUserData, bool bIsFrozen );
static bool ReloadPedWeapon ( lua_State* pLuaVM, void* pUserData );
static bool SetPedArmor ( lua_State* pLuaVM, PVOID pUserData, float fArmor );
static bool KillPed ( lua_State* pLuaVM, PVOID pUserData, PVOID pKiller = NULL, unsigned char ucKillerWeapon = 0xFF, unsigned char ucBodyPart = 0xFF, bool bStealth = false );
static bool SetPedStat ( lua_State* pLuaVM, PVOID pUserData, unsigned short usStat, float fValue );
static bool AddPedClothes ( lua_State* pLuaVM, PVOID pUserData, const char* szTexture, const char* szModel, unsigned char ucType );
static bool RemovePedClothes ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucType, const char* szTexture = NULL, const char* szModel = NULL );
static bool GivePedJetPack ( lua_State* pLuaVM, PVOID pUserData );
static bool RemovePedJetPack ( lua_State* pLuaVM, PVOID pUserData );
static bool SetPedFightingStyle ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucStyle );
static bool SetPedMoveAnim ( lua_State* pLuaVM, PVOID pUserData, unsigned int iMoveAnim );
static bool SetPedGravity ( lua_State* pLuaVM, PVOID pUserData, float fGravity );
static bool SetPedChoking ( lua_State* pLuaVM, PVOID pUserData, bool bChoking );
static bool SetPedWeaponSlot ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucWeaponSlot );
static bool WarpPedIntoVehicle ( lua_State* pLuaVM, PVOID pUserData, PVOID pVehicle, unsigned int uiSeat = 0 );
static bool RemovePedFromVehicle ( lua_State* pLuaVM, PVOID pUserData );
static bool SetPedDoingGangDriveby ( lua_State* pLuaVM, PVOID pUserData, bool bGangDriveby );
static bool SetPedAnimation ( lua_State* pLuaVM, PVOID pUserData, const char * szBlockName, const char * szAnimName, int iTime, bool bLoop, bool bUpdatePosition, bool bInterruptable, bool bFreezeLastFrame );
static bool SetPedAnimationProgress ( lua_State* pLuaVM, PVOID pUserData, const char * szAnimName, float fProgress );
static bool SetPedOnFire ( lua_State* pLuaVM, PVOID pUserData, bool bIsOnFire );
static bool SetPedHeadless ( lua_State* pLuaVM, PVOID pUserData, bool bIsHeadless );
static bool SetPedFrozen ( lua_State* pLuaVM, PVOID pUserData, bool bIsFrozen );
static bool ReloadPedWeapon ( lua_State* pLuaVM, PVOID pUserData );
static bool SetWeaponProperty ( lua_State* pLuaVM, unsigned char ucWeaponID, const char *szWeaponSkill, const char* szProperty, short uData );
// Weapon give/take functions
@ -226,195 +226,195 @@ public:
// static int GetSlotFromWeapon ( lua_State* pLuaVM );
// Vehicle create/destroy functions
static void* CreateVehicle ( lua_State* pLuaVM, int model, float fX, float fY, float fZ, float fRX, float fRY, float fRZ, string numberplate, bool direction = false, int variant1 = 255, int variant2 = 255 );
static PVOID CreateVehicle ( lua_State* pLuaVM, int model, float fX, float fY, float fZ, float fRX, float fRY, float fRZ, string numberplate, bool direction = false, int variant1 = 255, int variant2 = 255 );
// Vehicle get functions
static bool GetVehicleType ( lua_State* pLuaVM, void* pUserData, string& strType );
static bool GetVehicleVariant ( lua_State* pLuaVM, void* pUserData, unsigned char& ucVariant, unsigned char& ucVariant2 );
static bool GetVehicleColor ( lua_State* pLuaVM, void* pUserData, CVehicleColor& color );
static bool GetVehicleType ( lua_State* pLuaVM, PVOID pUserData, string& strType );
static bool GetVehicleVariant ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucVariant, unsigned char& ucVariant2 );
static bool GetVehicleColor ( lua_State* pLuaVM, PVOID pUserData, CVehicleColor& color );
static bool GetVehicleModelFromName ( lua_State* pLuaVM, const char* szName, unsigned short& usID );
static bool GetVehicleLandingGearDown ( lua_State* pLuaVM, void* pUserData, bool& bGearDown );
static bool GetVehicleMaxPassengers ( lua_State* pLuaVM, void* pUserData, unsigned char& ucMaxPassengers );
static bool GetVehicleName ( lua_State* pLuaVM, void* pUserData, string& strOutName );
static bool GetVehicleLandingGearDown ( lua_State* pLuaVM, PVOID pUserData, bool& bGearDown );
static bool GetVehicleMaxPassengers ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucMaxPassengers );
static bool GetVehicleName ( lua_State* pLuaVM, PVOID pUserData, string& strOutName );
static bool GetVehicleNameFromModel ( lua_State* pLuaVM, unsigned short usModel, string& strOutName );
static void* GetVehicleOccupant ( lua_State* pLuaVM, void* pUserData, unsigned int uiSeat );
static CLuaArguments* GetVehicleOccupants ( lua_State* pLuaVM, void* pUserData );
static void* GetVehicleController ( lua_State* pLuaVM, void* pUserData );
static bool GetVehicleSirensOn ( lua_State* pLuaVM, void* pUserData, bool& bSirensOn );
static bool GetVehicleTurnVelocity ( lua_State* pLuaVM, void* pUserData, Vector3& vecTurnVelocity );
static bool GetVehicleTurretPosition ( lua_State* pLuaVM, void* pUserData, Vector2& vecPosition );
static bool IsVehicleLocked ( lua_State* pLuaVM, void* pUserData, bool& bLocked );
static CLuaArguments* GetVehiclesOfType ( lua_State* pLuaVM, unsigned int uiModel );
static bool GetVehicleUpgradeOnSlot ( lua_State* pLuaVM, void* pUserData, unsigned char ucSlot, unsigned short& usUpgrade );
static CLuaArguments* GetVehicleUpgrades ( lua_State* pLuaVM, void* pUserData );
static PVOID GetVehicleOccupant ( lua_State* pLuaVM, PVOID pUserData, unsigned int uiSeat );
static CLuaArgumentsVector GetVehicleOccupants ( lua_State* pLuaVM, PVOID pUserData );
static PVOID GetVehicleController ( lua_State* pLuaVM, PVOID pUserData );
static bool GetVehicleSirensOn ( lua_State* pLuaVM, PVOID pUserData, bool& bSirensOn );
static bool GetVehicleTurnVelocity ( lua_State* pLuaVM, PVOID pUserData, Vector3& vecTurnVelocity );
static bool GetVehicleTurretPosition ( lua_State* pLuaVM, PVOID pUserData, Vector2& vecPosition );
static bool IsVehicleLocked ( lua_State* pLuaVM, PVOID pUserData, bool& bLocked );
static CLuaArgumentsVector GetVehiclesOfType ( lua_State* pLuaVM, unsigned int uiModel );
static bool GetVehicleUpgradeOnSlot ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucSlot, unsigned short& usUpgrade );
static CLuaArgumentsVector GetVehicleUpgrades ( lua_State* pLuaVM, PVOID pUserData );
static bool GetVehicleUpgradeSlotName ( lua_State* pLuaVM, unsigned char ucSlot, string& strOutName );
static bool GetVehicleUpgradeSlotName ( lua_State* pLuaVM, unsigned short usUpgrade, string& strOutName );
static CLuaArguments* GetVehicleCompatibleUpgrades ( lua_State* pLuaVM, void* pUserData );
static bool GetVehicleDoorState ( lua_State* pLuaVM, void* pUserData, unsigned char ucDoor, unsigned char& ucState );
static bool GetVehicleWheelStates ( lua_State* pLuaVM, void* pUserData, unsigned char& ucFrontLeft, unsigned char& ucRearLeft, unsigned char& ucFrontRight, unsigned char& ucRearRight );
static bool GetVehicleLightState ( lua_State* pLuaVM, void* pUserData, unsigned char ucLight, unsigned char& ucState );
static bool GetVehiclePanelState ( lua_State* pLuaVM, void* pUserData, unsigned char ucPanel, unsigned char& ucState );
static bool GetVehicleOverrideLights ( lua_State* pLuaVM, void* pUserData, unsigned char& ucLights );
static void* GetVehicleTowedByVehicle ( lua_State* pLuaVM, void* pUserData );
static void* GetVehicleTowingVehicle ( lua_State* pLuaVM, void* pUserData );
static bool GetVehiclePaintjob ( lua_State* pLuaVM, void* pUserData, unsigned char& ucPaintjob );
static bool GetVehiclePlateText ( lua_State* pLuaVM, void* pUserData, char* szPlateText );
static bool IsVehicleDamageProof ( lua_State* pLuaVM, void* pUserData, bool& bDamageProof );
static bool IsVehicleFuelTankExplodable ( lua_State* pLuaVM, void* pUserData, bool& bExplodable );
static bool IsVehicleFrozen ( lua_State* pLuaVM, void* pUserData, bool& bFrozen );
static bool IsVehicleOnGround ( lua_State* pLuaVM, void* pUserData, bool& bOnGround );
static bool GetVehicleEngineState ( lua_State* pLuaVM, void* pUserData, bool& bState );
static bool IsTrainDerailed ( lua_State* pLuaVM, void* pUserData, bool& bDerailed );
static bool IsTrainDerailable ( lua_State* pLuaVM, void* pUserData, bool& bDerailable );
static bool GetTrainDirection ( lua_State* pLuaVM, void* pUserData, bool& bDirection );
static bool GetTrainSpeed ( lua_State* pLuaVM, void* pUserData, float& fSpeed );
static bool IsVehicleBlown ( lua_State* pLuaVM, void* pUserData );
static bool GetVehicleHeadLightColor ( lua_State* pLuaVM, void* pUserData, SColor& outColor );
static bool GetVehicleDoorOpenRatio ( lua_State* pLuaVM, void* pUserData, unsigned char ucDoor, float& fRatio );
static bool IsVehicleTaxiLightOn ( lua_State* pLuaVM, void* pUserData, bool& bLightOn );
static CLuaArgumentsVector GetVehicleCompatibleUpgrades ( lua_State* pLuaVM, PVOID pUserData );
static bool GetVehicleDoorState ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucDoor, unsigned char& ucState );
static bool GetVehicleWheelStates ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucFrontLeft, unsigned char& ucRearLeft, unsigned char& ucFrontRight, unsigned char& ucRearRight );
static bool GetVehicleLightState ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucLight, unsigned char& ucState );
static bool GetVehiclePanelState ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucPanel, unsigned char& ucState );
static bool GetVehicleOverrideLights ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucLights );
static PVOID GetVehicleTowedByVehicle ( lua_State* pLuaVM, PVOID pUserData );
static PVOID GetVehicleTowingVehicle ( lua_State* pLuaVM, PVOID pUserData );
static bool GetVehiclePaintjob ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucPaintjob );
static bool GetVehiclePlateText ( lua_State* pLuaVM, PVOID pUserData, char* szPlateText );
static bool IsVehicleDamageProof ( lua_State* pLuaVM, PVOID pUserData, bool& bDamageProof );
static bool IsVehicleFuelTankExplodable ( lua_State* pLuaVM, PVOID pUserData, bool& bExplodable );
static bool IsVehicleFrozen ( lua_State* pLuaVM, PVOID pUserData, bool& bFrozen );
static bool IsVehicleOnGround ( lua_State* pLuaVM, PVOID pUserData, bool& bOnGround );
static bool GetVehicleEngineState ( lua_State* pLuaVM, PVOID pUserData, bool& bState );
static bool IsTrainDerailed ( lua_State* pLuaVM, PVOID pUserData, bool& bDerailed );
static bool IsTrainDerailable ( lua_State* pLuaVM, PVOID pUserData, bool& bDerailable );
static bool GetTrainDirection ( lua_State* pLuaVM, PVOID pUserData, bool& bDirection );
static bool GetTrainSpeed ( lua_State* pLuaVM, PVOID pUserData, float& fSpeed );
static bool IsVehicleBlown ( lua_State* pLuaVM, PVOID pUserData );
static bool GetVehicleHeadLightColor ( lua_State* pLuaVM, PVOID pUserData, SColor& outColor );
static bool GetVehicleDoorOpenRatio ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucDoor, float& fRatio );
static bool IsVehicleTaxiLightOn ( lua_State* pLuaVM, PVOID pUserData, bool& bLightOn );
// Vehicle set functions
static bool FixVehicle ( lua_State* pLuaVM, void* pUserData );
static bool BlowVehicle ( lua_State* pLuaVM, void* pUserData, bool bExplode );
static bool SetVehicleTurnVelocity ( lua_State* pLuaVM, void* pUserData, float fX, float fY, float fZ );
static bool SetVehicleColor ( lua_State* pLuaVM, void* pUserData, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue, unsigned char ucRed2, unsigned char ucGreen2, unsigned char ucBlue2, unsigned char ucRed3, unsigned char ucGreen3, unsigned char ucBlue3, unsigned char ucRed4, unsigned char ucGreen4, unsigned char ucBlue4 );
static bool SetVehicleLandingGearDown ( lua_State* pLuaVM, void* pUserData, bool bLandingGearDown );
static bool SetVehicleLocked ( lua_State* pLuaVM, void* pUserData, bool bLocked );
static bool SetVehicleDoorsUndamageable ( lua_State* pLuaVM, void* pUserData, bool bDoorsUndamageable );
static bool SetVehicleSirensOn ( lua_State* pLuaVM, void* pUserData, bool bSirensOn );
static bool SetVehicleTaxiLightOn ( lua_State* pLuaVM, void* pUserData, bool bTaxiLightState );
static bool AddVehicleUpgrade ( lua_State* pLuaVM, void* pUserData, unsigned short usUpgrade );
static bool RemoveVehicleUpgrade ( lua_State* pLuaVM, void* pUserData, unsigned short usUpgrade );
static bool SetVehicleDoorState ( lua_State* pLuaVM, void* pUserData, unsigned char ucDoor, unsigned char ucState );
static bool SetVehicleWheelStates ( lua_State* pLuaVM, void* pUserData, int iFrontLeft, int iRearLeft = -1, int iFrontRight = -1, int iRearRight = -1 );
static bool SetVehicleLightState ( lua_State* pLuaVM, void* pUserData, unsigned char ucLight, unsigned char ucState );
static bool SetVehiclePanelState ( lua_State* pLuaVM, void* pUserData, unsigned char ucPanel, unsigned char ucState );
static bool SetVehicleIdleRespawnDelay ( lua_State* pLuaVM, void* pUserData, unsigned long ulTime );
static bool SetVehicleRespawnDelay ( lua_State* pLuaVM, void* pUserData, unsigned long ulTime );
static bool SetVehicleRespawnPosition ( lua_State* pLuaVM, void* pUserData, float fX, float fY, float fZ, float fRX, float fRY, float fRZ );
static bool ToggleVehicleRespawn ( lua_State* pLuaVM, void* pUserData, bool bRespawn );
static bool ResetVehicleExplosionTime ( lua_State* pLuaVM, void* pUserData );
static bool ResetVehicleIdleTime ( lua_State* pLuaVM, void* pUserData );
static bool SpawnVehicle ( lua_State* pLuaVM, void* pUserData, float fX, float fY, float fZ, float fRX, float fRY, float fRZ );
static bool RespawnVehicle ( lua_State* pLuaVM, void* pUserData );
static bool SetVehicleOverrideLights ( lua_State* pLuaVM, void* pUserData, unsigned char ucLights );
static bool AttachTrailerToVehicle ( lua_State* pLuaVM, void* pUserData, void* pTrailer );
static bool DetachTrailerFromVehicle ( lua_State* pLuaVM, void* pUserData, void* pTrailer = NULL );
static bool SetVehicleEngineState ( lua_State* pLuaVM, void* pUserData, bool bState );
static bool SetVehicleDirtLevel ( lua_State* pLuaVM, void* pUserData, float fDirtLevel );
static bool SetVehicleDamageProof ( lua_State* pLuaVM, void* pUserData, bool bDamageProof );
static bool SetVehiclePaintjob ( lua_State* pLuaVM, void* pUserData, unsigned char ucPaintjob );
static bool SetVehicleFuelTankExplodable ( lua_State* pLuaVM, void* pUserData, bool bExplodable );
static bool SetVehicleFrozen ( lua_State* pLuaVM, void* pUserData, bool bFrozen );
static bool SetTrainDerailed ( lua_State* pLuaVM, void* pUserData, bool bDerailed );
static bool SetTrainDerailable ( lua_State* pLuaVM, void* pUserData, bool bDerailable );
static bool SetTrainDirection ( lua_State* pLuaVM, void* pUserData, bool bDireciton );
static bool SetTrainSpeed ( lua_State* pLuaVM, void* pUserData, float fSpeed );
static bool SetVehicleHeadLightColor ( lua_State* pLuaVM, void* pUserData, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue );
static bool SetVehicleTurretPosition ( lua_State* pLuaVM, void* pUserData, float fHorizontal, float fVertical );
static bool SetVehicleDoorOpenRatio ( lua_State* pLuaVM, void* pUserData, unsigned char ucDoor, float fRatio, unsigned long ulTime = 0 );
static bool SetVehicleVariant ( lua_State* pLuaVM, void* pUserData, unsigned char ucVariant, unsigned char ucVariant2 );
static bool GiveVehicleSirens ( lua_State* pLuaVM, void* pUserData, unsigned char ucSirenType, unsigned char ucSirenCount, bool bFlag360 = false, bool bCheckLosFlag = true, bool bUseRandomiserFlag = true, bool bSilentFlag = false );
static bool RemoveVehicleSirens ( lua_State* pLuaVM, void* pUserData );
static bool SetVehicleSirens ( lua_State* pLuaVM, void* pUserData, unsigned char ucSirenID, float fX, float fY, float fZ, float fRed, float fGreen, float fBlue, float fAlpha = 255, float fMinAlpha = 0.0 );
// static bool GetVehicleSirens ( lua_State* pLuaVM, void* pUserData );
// static bool GetVehicleSirenParams ( lua_State* pLuaVM, void* pUserData );
static bool SetVehiclePlateText ( lua_State* pLuaVM, void* pUserData, const char* szName );
static bool FixVehicle ( lua_State* pLuaVM, PVOID pUserData );
static bool BlowVehicle ( lua_State* pLuaVM, PVOID pUserData, bool bExplode );
static bool SetVehicleTurnVelocity ( lua_State* pLuaVM, PVOID pUserData, float fX, float fY, float fZ );
static bool SetVehicleColor ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue, unsigned char ucRed2, unsigned char ucGreen2, unsigned char ucBlue2, unsigned char ucRed3, unsigned char ucGreen3, unsigned char ucBlue3, unsigned char ucRed4, unsigned char ucGreen4, unsigned char ucBlue4 );
static bool SetVehicleLandingGearDown ( lua_State* pLuaVM, PVOID pUserData, bool bLandingGearDown );
static bool SetVehicleLocked ( lua_State* pLuaVM, PVOID pUserData, bool bLocked );
static bool SetVehicleDoorsUndamageable ( lua_State* pLuaVM, PVOID pUserData, bool bDoorsUndamageable );
static bool SetVehicleSirensOn ( lua_State* pLuaVM, PVOID pUserData, bool bSirensOn );
static bool SetVehicleTaxiLightOn ( lua_State* pLuaVM, PVOID pUserData, bool bTaxiLightState );
static bool AddVehicleUpgrade ( lua_State* pLuaVM, PVOID pUserData, unsigned short usUpgrade );
static bool RemoveVehicleUpgrade ( lua_State* pLuaVM, PVOID pUserData, unsigned short usUpgrade );
static bool SetVehicleDoorState ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucDoor, unsigned char ucState );
static bool SetVehicleWheelStates ( lua_State* pLuaVM, PVOID pUserData, int iFrontLeft, int iRearLeft = -1, int iFrontRight = -1, int iRearRight = -1 );
static bool SetVehicleLightState ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucLight, unsigned char ucState );
static bool SetVehiclePanelState ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucPanel, unsigned char ucState );
static bool SetVehicleIdleRespawnDelay ( lua_State* pLuaVM, PVOID pUserData, unsigned long ulTime );
static bool SetVehicleRespawnDelay ( lua_State* pLuaVM, PVOID pUserData, unsigned long ulTime );
static bool SetVehicleRespawnPosition ( lua_State* pLuaVM, PVOID pUserData, float fX, float fY, float fZ, float fRX, float fRY, float fRZ );
static bool ToggleVehicleRespawn ( lua_State* pLuaVM, PVOID pUserData, bool bRespawn );
static bool ResetVehicleExplosionTime ( lua_State* pLuaVM, PVOID pUserData );
static bool ResetVehicleIdleTime ( lua_State* pLuaVM, PVOID pUserData );
static bool SpawnVehicle ( lua_State* pLuaVM, PVOID pUserData, float fX, float fY, float fZ, float fRX, float fRY, float fRZ );
static bool RespawnVehicle ( lua_State* pLuaVM, PVOID pUserData );
static bool SetVehicleOverrideLights ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucLights );
static bool AttachTrailerToVehicle ( lua_State* pLuaVM, PVOID pUserData, PVOID pTrailer );
static bool DetachTrailerFromVehicle ( lua_State* pLuaVM, PVOID pUserData, PVOID pTrailer = NULL );
static bool SetVehicleEngineState ( lua_State* pLuaVM, PVOID pUserData, bool bState );
static bool SetVehicleDirtLevel ( lua_State* pLuaVM, PVOID pUserData, float fDirtLevel );
static bool SetVehicleDamageProof ( lua_State* pLuaVM, PVOID pUserData, bool bDamageProof );
static bool SetVehiclePaintjob ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucPaintjob );
static bool SetVehicleFuelTankExplodable ( lua_State* pLuaVM, PVOID pUserData, bool bExplodable );
static bool SetVehicleFrozen ( lua_State* pLuaVM, PVOID pUserData, bool bFrozen );
static bool SetTrainDerailed ( lua_State* pLuaVM, PVOID pUserData, bool bDerailed );
static bool SetTrainDerailable ( lua_State* pLuaVM, PVOID pUserData, bool bDerailable );
static bool SetTrainDirection ( lua_State* pLuaVM, PVOID pUserData, bool bDireciton );
static bool SetTrainSpeed ( lua_State* pLuaVM, PVOID pUserData, float fSpeed );
static bool SetVehicleHeadLightColor ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue );
static bool SetVehicleTurretPosition ( lua_State* pLuaVM, PVOID pUserData, float fHorizontal, float fVertical );
static bool SetVehicleDoorOpenRatio ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucDoor, float fRatio, unsigned long ulTime = 0 );
static bool SetVehicleVariant ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucVariant, unsigned char ucVariant2 );
static bool GiveVehicleSirens ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucSirenType, unsigned char ucSirenCount, bool bFlag360 = false, bool bCheckLosFlag = true, bool bUseRandomiserFlag = true, bool bSilentFlag = false );
static bool RemoveVehicleSirens ( lua_State* pLuaVM, PVOID pUserData );
static bool SetVehicleSirens ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucSirenID, float fX, float fY, float fZ, float fRed, float fGreen, float fBlue, float fAlpha = 255, float fMinAlpha = 0.0 );
// static bool GetVehicleSirens ( lua_State* pLuaVM, PVOID pUserData );
// static bool GetVehicleSirenParams ( lua_State* pLuaVM, PVOID pUserData );
static bool SetVehiclePlateText ( lua_State* pLuaVM, PVOID pUserData, const char* szName );
// Marker create/destroy functions
static void* CreateMarker ( lua_State* pLuaVM, const Vector3& vecPosition, const char* szType, float fSize, const SColor color, void* pVisibleTo );
static PVOID CreateMarker ( lua_State* pLuaVM, const Vector3& vecPosition, const char* szType, float fSize, const SColor color, PVOID pVisibleTo );
// Marker get functions
static bool GetMarkerCount ( lua_State* pLuaVM, unsigned int& uiCount );
static bool GetMarkerType ( lua_State* pLuaVM, void* pUserData, char* szType );
static bool GetMarkerSize ( lua_State* pLuaVM, void* pUserData, float& fSize );
static bool GetMarkerColor ( lua_State* pLuaVM, void* pUserData, SColor& outColor );
static bool GetMarkerTarget ( lua_State* pLuaVM, void* pUserData, Vector3& vecTarget );
static bool GetMarkerIcon ( lua_State* pLuaVM, void* pUserData, char* szIcon );
static bool GetMarkerType ( lua_State* pLuaVM, PVOID pUserData, char* szType );
static bool GetMarkerSize ( lua_State* pLuaVM, PVOID pUserData, float& fSize );
static bool GetMarkerColor ( lua_State* pLuaVM, PVOID pUserData, SColor& outColor );
static bool GetMarkerTarget ( lua_State* pLuaVM, PVOID pUserData, Vector3& vecTarget );
static bool GetMarkerIcon ( lua_State* pLuaVM, PVOID pUserData, char* szIcon );
// Marker set functions
static bool SetMarkerType ( lua_State* pLuaVM, void* pUserData, const char* szType );
static bool SetMarkerSize ( lua_State* pLuaVM, void* pUserData, float fSize );
static bool SetMarkerColor ( lua_State* pLuaVM, void* pUserData, const SColor color );
static bool SetMarkerTarget ( lua_State* pLuaVM, void* pUserData, const Vector3& pTarget );
static bool SetMarkerIcon ( lua_State* pLuaVM, void* pUserData, const char* szIcon );
static bool SetMarkerType ( lua_State* pLuaVM, PVOID pUserData, const char* szType );
static bool SetMarkerSize ( lua_State* pLuaVM, PVOID pUserData, float fSize );
static bool SetMarkerColor ( lua_State* pLuaVM, PVOID pUserData, const SColor color );
static bool SetMarkerTarget ( lua_State* pLuaVM, PVOID pUserData, const Vector3& pTarget );
static bool SetMarkerIcon ( lua_State* pLuaVM, PVOID pUserData, const char* szIcon );
// Blip create/destroy functions
static void* CreateBlip ( lua_State* pLuaVM, const Vector3& vecPosition, unsigned char ucIcon, unsigned char ucSize, const SColor color, short sOrdering, unsigned short usVisibleDistance, void* pVisibleTo = NULL );
static void* CreateBlipAttachedTo ( lua_State* pLuaVM, void* pTarget, unsigned char ucIcon, unsigned char ucSize, const SColor color, short sOrdering, unsigned short usVisibleDistance, void* pVisibleTo = NULL );
static PVOID CreateBlip ( lua_State* pLuaVM, const Vector3& vecPosition, unsigned char ucIcon, unsigned char ucSize, const SColor color, short sOrdering, unsigned short usVisibleDistance, PVOID pVisibleTo = NULL );
static PVOID CreateBlipAttachedTo ( lua_State* pLuaVM, PVOID pTarget, unsigned char ucIcon, unsigned char ucSize, const SColor color, short sOrdering, unsigned short usVisibleDistance, PVOID pVisibleTo = NULL );
// Blip get functions
static bool GetBlipIcon ( lua_State* pLuaVM, void* pUserData, unsigned char& ucIcon );
static bool GetBlipSize ( lua_State* pLuaVM, void* pUserData, unsigned char& ucSize );
static bool GetBlipColor ( lua_State* pLuaVM, void* pUserData, SColor& outColor );
static bool GetBlipOrdering ( lua_State* pLuaVM, void* pUserData, short& sOrdering );
static bool GetBlipVisibleDistance ( lua_State* pLuaVM, void* pUserData, unsigned short& usVisibleDistance );
static bool GetBlipIcon ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucIcon );
static bool GetBlipSize ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucSize );
static bool GetBlipColor ( lua_State* pLuaVM, PVOID pUserData, SColor& outColor );
static bool GetBlipOrdering ( lua_State* pLuaVM, PVOID pUserData, short& sOrdering );
static bool GetBlipVisibleDistance ( lua_State* pLuaVM, PVOID pUserData, unsigned short& usVisibleDistance );
// Blip set functions
static bool SetBlipIcon ( lua_State* pLuaVM, void* pUserData, unsigned char ucIcon );
static bool SetBlipSize ( lua_State* pLuaVM, void* pUserData, unsigned char ucSize );
static bool SetBlipColor ( lua_State* pLuaVM, void* pUserData, const SColor color );
static bool SetBlipOrdering ( lua_State* pLuaVM, void* pUserData, short sOrdering );
static bool SetBlipVisibleDistance ( lua_State* pLuaVM, void* pUserData, unsigned short usVisibleDistance );
static bool SetBlipIcon ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucIcon );
static bool SetBlipSize ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucSize );
static bool SetBlipColor ( lua_State* pLuaVM, PVOID pUserData, const SColor color );
static bool SetBlipOrdering ( lua_State* pLuaVM, PVOID pUserData, short sOrdering );
static bool SetBlipVisibleDistance ( lua_State* pLuaVM, PVOID pUserData, unsigned short usVisibleDistance );
// Object create/destroy functions
static void* CreateObject ( lua_State* pLuaVM, unsigned short usModelID, const Vector3& vecPosition, const Vector3& vecRotation, bool bIsLowLod );
static PVOID CreateObject ( lua_State* pLuaVM, unsigned short usModelID, const Vector3& vecPosition, const Vector3& vecRotation, bool bIsLowLod );
// Object get functions
static bool GetObjectScale ( lua_State* pLuaVM, void* pUserData, Vector3& vecScale );
static bool GetObjectScale ( lua_State* pLuaVM, PVOID pUserData, Vector3& vecScale );
// Object set functions
static bool SetObjectScale ( lua_State* pLuaVM, void* pUserData, const Vector3& vecScale );
static bool MoveObject ( lua_State* pLuaVM, void* pUserData, unsigned long ulTime, const Vector3& vecPosition, const Vector3& vecRotation, const char* szEasingType, float fEasingPeriod, float fEasingAmplitude, float fEasingOvershoot );
static bool StopObject ( lua_State* pLuaVM, void* pUserData );
static bool SetObjectScale ( lua_State* pLuaVM, PVOID pUserData, const Vector3& vecScale );
static bool MoveObject ( lua_State* pLuaVM, PVOID pUserData, unsigned long ulTime, const Vector3& vecPosition, const Vector3& vecRotation, const char* szEasingType, float fEasingPeriod, float fEasingAmplitude, float fEasingOvershoot );
static bool StopObject ( lua_State* pLuaVM, PVOID pUserData );
// Radar area create/destroy funcs
static void* CreateRadarArea ( lua_State* pLuaVM, const Vector2& vecPosition, const Vector2& vecSize, const SColor color, void* pVisibleTo = NULL );
static PVOID CreateRadarArea ( lua_State* pLuaVM, const Vector2& vecPosition, const Vector2& vecSize, const SColor color, PVOID pVisibleTo = NULL );
// Radar area get funcs
static bool GetRadarAreaSize ( lua_State* pLuaVM, void* pUserData, Vector2& vecSize );
static bool GetRadarAreaColor ( lua_State* pLuaVM, void* pUserData, SColor& outColor );
static bool IsRadarAreaFlashing ( lua_State* pLuaVM, void* pUserData );
static bool IsInsideRadarArea ( lua_State* pLuaVM, void* pUserData, const Vector2& vecPosition, bool& bInside );
static bool GetRadarAreaSize ( lua_State* pLuaVM, PVOID pUserData, Vector2& vecSize );
static bool GetRadarAreaColor ( lua_State* pLuaVM, PVOID pUserData, SColor& outColor );
static bool IsRadarAreaFlashing ( lua_State* pLuaVM, PVOID pUserData );
static bool IsInsideRadarArea ( lua_State* pLuaVM, PVOID pUserData, const Vector2& vecPosition, bool& bInside );
// Radar area set funcs
static bool SetRadarAreaSize ( lua_State* pLuaVM, void* pUserData, const Vector2& vecSize );
static bool SetRadarAreaColor ( lua_State* pLuaVM, void* pUserData, const SColor color );
static bool SetRadarAreaFlashing ( lua_State* pLuaVM, void* pUserData, bool bFlashing );
static bool SetRadarAreaSize ( lua_State* pLuaVM, PVOID pUserData, const Vector2& vecSize );
static bool SetRadarAreaColor ( lua_State* pLuaVM, PVOID pUserData, const SColor color );
static bool SetRadarAreaFlashing ( lua_State* pLuaVM, PVOID pUserData, bool bFlashing );
// Pickup create/destroy funcs
static void* CreatePickup ( lua_State* pLuaVM, const Vector3& vecPosition, unsigned char ucType, double dFive, unsigned long ulRespawnInterval = 30000, double dSix = 50 );
static PVOID CreatePickup ( lua_State* pLuaVM, const Vector3& vecPosition, unsigned char ucType, double dFive, unsigned long ulRespawnInterval = 30000, double dSix = 50 );
// Pickup get funcs
static bool GetPickupType ( lua_State* pLuaVM, void* pUserData, unsigned char& ucType );
static bool GetPickupWeapon ( lua_State* pLuaVM, void* pUserData, unsigned char& ucWeapon );
static bool GetPickupAmount ( lua_State* pLuaVM, void* pUserData, float& fAmount );
static bool GetPickupAmmo ( lua_State* pLuaVM, void* pUserData, unsigned short& ucAmmo );
static bool GetPickupRespawnInterval ( lua_State* pLuaVM, void* pUserData, unsigned long& ulInterval );
static bool IsPickupSpawned ( lua_State* pLuaVM, void* pUserData, bool& bSpawned );
static bool GetPickupType ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucType );
static bool GetPickupWeapon ( lua_State* pLuaVM, PVOID pUserData, unsigned char& ucWeapon );
static bool GetPickupAmount ( lua_State* pLuaVM, PVOID pUserData, float& fAmount );
static bool GetPickupAmmo ( lua_State* pLuaVM, PVOID pUserData, unsigned short& ucAmmo );
static bool GetPickupRespawnInterval ( lua_State* pLuaVM, PVOID pUserData, unsigned long& ulInterval );
static bool IsPickupSpawned ( lua_State* pLuaVM, PVOID pUserData, bool& bSpawned );
// Pickup set funcs
static bool SetPickupType ( lua_State* pLuaVM, void* pUserData, unsigned char ucType, double dThree, double dFour );
static bool SetPickupRespawnInterval ( lua_State* pLuaVM, void* pUserData, unsigned long ulInterval );
static bool UsePickup ( lua_State* pLuaVM, void* pUserData, void* pPlayer );
static bool SetPickupType ( lua_State* pLuaVM, PVOID pUserData, unsigned char ucType, double dThree, double dFour );
static bool SetPickupRespawnInterval ( lua_State* pLuaVM, PVOID pUserData, unsigned long ulInterval );
static bool UsePickup ( lua_State* pLuaVM, PVOID pUserData, PVOID pPlayer );
// Shape create funcs
static void* CreateColCircle ( lua_State* pLuaVM, const Vector2& vecPosition, float fRadius );
static void* CreateColCuboid ( lua_State* pLuaVM, const Vector3& vecPosition, const Vector3& vecSize );
static void* CreateColSphere ( lua_State* pLuaVM, const Vector3& vecPosition, float fRadius );
static void* CreateColRectangle ( lua_State* pLuaVM, const Vector2& vecPosition, const Vector2& vecSize );
static void* CreateColPolygon ( lua_State* pLuaVM, const vector< Vector2 >& vecPointList );
static void* CreateColTube ( lua_State* pLuaVM, const Vector3& vecPosition, float fRadius, float fHeight );
static PVOID CreateColCircle ( lua_State* pLuaVM, const Vector2& vecPosition, float fRadius );
static PVOID CreateColCuboid ( lua_State* pLuaVM, const Vector3& vecPosition, const Vector3& vecSize );
static PVOID CreateColSphere ( lua_State* pLuaVM, const Vector3& vecPosition, float fRadius );
static PVOID CreateColRectangle ( lua_State* pLuaVM, const Vector2& vecPosition, const Vector2& vecSize );
static PVOID CreateColPolygon ( lua_State* pLuaVM, const vector< Vector2 >& vecPointList );
static PVOID CreateColTube ( lua_State* pLuaVM, const Vector3& vecPosition, float fRadius, float fHeight );
// Explosion funcs
static bool CreateExplosion ( lua_State* pLuaVM, const Vector3& vecPosition, unsigned char ucType, void* pCreator = NULL );
static bool CreateExplosion ( lua_State* pLuaVM, const Vector3& vecPosition, unsigned char ucType, PVOID pCreator = NULL );
// Fire funcs
// static int CreateFire ( lua_State* pLuaVM );
// Audio funcs
static bool PlaySoundFrontEnd ( lua_State* pLuaVM, void* pElement, unsigned char ucSound );
static bool PlayMissionAudio ( lua_State* pLuaVM, void* pElement, Vector3& vecPosition, unsigned short usSlot );
static bool PlaySoundFrontEnd ( lua_State* pLuaVM, PVOID pElement, unsigned char ucSound );
static bool PlayMissionAudio ( lua_State* pLuaVM, PVOID pElement, Vector3& vecPosition, unsigned short usSlot );
// Ped body?
static bool GetBodyPartName ( lua_State* pLuaVM, unsigned char ucID, char* szName );
@ -423,40 +423,40 @@ public:
static bool GetClothesTypeName ( lua_State* pLuaVM, unsigned char ucType, char* szNameReturn );
// Input funcs
// static bool BindKey ( lua_State* pLuaVM, void* pPlayer, const char* szKey, const char* szHitState, const CLuaFunctionRef& iLuaFunction, CLuaArguments& Arguments );
static bool BindKey ( lua_State* pLuaVM, void* pPlayer, const char* szKey, const char* szHitState, const char* szCommandName, const char* szArguments );
// static bool UnbindKey ( lua_State* pLuaVM, void* pPlayer, const char* szKey, const char* szHitState = NULL, const CLuaFunctionRef& iLuaFunction = CLuaFunctionRef() );
static bool UnbindKey ( lua_State* pLuaVM, void* pPlayer, const char* szKey, const char* szHitState, const char* szCommandName );
// static bool IsKeyBound ( lua_State* pLuaVM, void* pPlayer, const char* szKey, const char* szHitState, const CLuaFunctionRef& iLuaFunction, bool& bBound );
static bool GetControlState ( lua_State* pLuaVM, void* pPlayer, const char* szControl, bool& bState );
static bool IsControlEnabled ( lua_State* pLuaVM, void* pPlayer, const char* szControl, bool& bEnabled );
// static bool BindKey ( lua_State* pLuaVM, PVOID pPlayer, const char* szKey, const char* szHitState, const CLuaFunctionRef& iLuaFunction, CLuaArguments& Arguments );
static bool BindKey ( lua_State* pLuaVM, PVOID pPlayer, const char* szKey, const char* szHitState, const char* szCommandName, const char* szArguments );
// static bool UnbindKey ( lua_State* pLuaVM, PVOID pPlayer, const char* szKey, const char* szHitState = NULL, const CLuaFunctionRef& iLuaFunction = CLuaFunctionRef() );
static bool UnbindKey ( lua_State* pLuaVM, PVOID pPlayer, const char* szKey, const char* szHitState, const char* szCommandName );
// static bool IsKeyBound ( lua_State* pLuaVM, PVOID pPlayer, const char* szKey, const char* szHitState, const CLuaFunctionRef& iLuaFunction, bool& bBound );
static bool GetControlState ( lua_State* pLuaVM, PVOID pPlayer, const char* szControl, bool& bState );
static bool IsControlEnabled ( lua_State* pLuaVM, PVOID pPlayer, const char* szControl, bool& bEnabled );
static bool SetControlState ( lua_State* pLuaVM, void* pPlayer, const char* szControl, bool bState );
static bool ToggleControl ( lua_State* pLuaVM, void* pPlayer, const char* szControl, bool bEnabled );
static bool ToggleAllControls ( lua_State* pLuaVM, void* pPlayer, bool bGTAControls, bool bMTAControls, bool bEnabled );
static bool SetControlState ( lua_State* pLuaVM, PVOID pPlayer, const char* szControl, bool bState );
static bool ToggleControl ( lua_State* pLuaVM, PVOID pPlayer, const char* szControl, bool bEnabled );
static bool ToggleAllControls ( lua_State* pLuaVM, PVOID pPlayer, bool bGTAControls, bool bMTAControls, bool bEnabled );
// Team get funcs
static void* CreateTeam ( lua_State* pLuaVM, const char* szTeamName, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue );
static void* GetTeamFromName ( lua_State* pLuaVM, const char* szTeamName );
static bool GetTeamName ( lua_State* pLuaVM, void* pTeam, string& strOutName );
static bool GetTeamColor ( lua_State* pLuaVM, void* pTeam, unsigned char& ucRed, unsigned char& ucGreen, unsigned char& ucBlue );
static bool CountPlayersInTeam ( lua_State* pLuaVM, void* pTeam, unsigned int& uiCount );
static bool GetTeamFriendlyFire ( lua_State* pLuaVM, void* pTeam, bool& bFriendlyFire );
static PVOID CreateTeam ( lua_State* pLuaVM, const char* szTeamName, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue );
static PVOID GetTeamFromName ( lua_State* pLuaVM, const char* szTeamName );
static bool GetTeamName ( lua_State* pLuaVM, PVOID pTeam, string& strOutName );
static bool GetTeamColor ( lua_State* pLuaVM, PVOID pTeam, unsigned char& ucRed, unsigned char& ucGreen, unsigned char& ucBlue );
static bool CountPlayersInTeam ( lua_State* pLuaVM, PVOID pTeam, unsigned int& uiCount );
static bool GetTeamFriendlyFire ( lua_State* pLuaVM, PVOID pTeam, bool& bFriendlyFire );
// Team set funcs
static bool SetTeamName ( lua_State* pLuaVM, void* pTeam, const char* szTeamName );
static bool SetTeamColor ( lua_State* pLuaVM, void* pTeam, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue );
static bool SetPlayerTeam ( lua_State* pLuaVM, void* pPlayer, void* pTeam );
static bool SetTeamFriendlyFire ( lua_State* pLuaVM, void* pTeam, bool bFriendlyFire );
static bool SetTeamName ( lua_State* pLuaVM, PVOID pTeam, const char* szTeamName );
static bool SetTeamColor ( lua_State* pLuaVM, PVOID pTeam, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue );
static bool SetPlayerTeam ( lua_State* pLuaVM, PVOID pPlayer, PVOID pTeam );
static bool SetTeamFriendlyFire ( lua_State* pLuaVM, PVOID pTeam, bool bFriendlyFire );
// Water funcs
static void* CreateWater ( lua_State* pLuaVM, Vector3* pV1, Vector3* pV2, Vector3* pV3, Vector3* pV4, bool bShallow );
static bool SetElementWaterLevel ( lua_State* pLuaVM, void* pWater, float fLevel );
static PVOID CreateWater ( lua_State* pLuaVM, Vector3* pV1, Vector3* pV2, Vector3* pV3, Vector3* pV4, bool bShallow );
static bool SetElementWaterLevel ( lua_State* pLuaVM, PVOID pWater, float fLevel );
static bool SetAllElementWaterLevel ( lua_State* pLuaVM, float fLevel );
static bool SetWorldWaterLevel ( lua_State* pLuaVM, float fLevel, bool bIncludeWorldNonSeaLevel );
static bool ResetWorldWaterLevel ( lua_State* pLuaVM );
static bool GetWaterVertexPosition ( lua_State* pLuaVM, void* pWater, int iVertexIndex, Vector3& vecPosition );
static bool SetWaterVertexPosition ( lua_State* pLuaVM, void* pWater, int iVertexIndex, Vector3& vecPosition );
static bool GetWaterVertexPosition ( lua_State* pLuaVM, PVOID pWater, int iVertexIndex, Vector3& vecPosition );
static bool SetWaterVertexPosition ( lua_State* pLuaVM, PVOID pWater, int iVertexIndex, Vector3& vecPosition );
static bool GetWaterColor ( lua_State* pLuaVM, unsigned char& ucRed, unsigned char& ucGreen, unsigned char& ucBlue, unsigned char& ucAlpha );
static bool SetWaterColor ( lua_State* pLuaVM, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue, unsigned char ucAlpha );
static bool ResetWaterColor ( lua_State* pLuaVM );
@ -464,8 +464,8 @@ public:
// Standard server functions
static unsigned int GetMaxPlayers ( lua_State* pLuaVM );
static bool SetMaxPlayers ( lua_State* pLuaVM, unsigned int uiMax );
static bool OutputChatBox ( lua_State* pLuaVM, const char* szText, void* pElement, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue, bool bColorCoded );
static bool OutputConsole ( lua_State* pLuaVM, const char* szText, void* pElement );
static bool OutputChatBox ( lua_State* pLuaVM, const char* szText, PVOID pElement, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue, bool bColorCoded );
static bool OutputConsole ( lua_State* pLuaVM, const char* szText, PVOID pElement );
static bool SetServerPassword ( lua_State* pLuaVM, const string& strPassword, bool bSave );
// General world get funcs
@ -537,129 +537,129 @@ public:
static bool RemoveWorldModel ( lua_State* pLuaVM, unsigned short usModel, float fRadius, const Vector3& vecPosition, char cInterior );
static bool RestoreWorldModel ( lua_State* pLuaVM, unsigned short usModel, float fRadius, const Vector3& vecPosition, char cInterior );
static bool RestoreAllWorldModels ( lua_State* pLuaVM );
static bool SendSyncIntervals ( lua_State* pLuaVM, void* pPlayer = NULL );
static bool SendSyncIntervals ( lua_State* pLuaVM, PVOID pPlayer = NULL );
static bool SetPedTargetingMarkerEnabled ( lua_State* pLuaVM, bool bEnabled );
static bool IsPedTargetingMarkerEnabled ( lua_State* pLuaVM );
static bool SetMoonSize ( lua_State* pLuaVM, int iMoonSize );
static bool ResetMoonSize ( lua_State* pLuaVM );
// Loaded Map Functions
static void* GetRootElement ( lua_State* pLuaVM );
// static void* LoadMapData ( lua_State* pLuaVM, void* pParent, CXMLNode* pNode );
// static void* SaveMapData ( lua_State* pLuaVM, void* pElement, CXMLNode* pNode, bool bChildren );
static PVOID GetRootElement ( lua_State* pLuaVM );
// static PVOID LoadMapData ( lua_State* pLuaVM, PVOID pParent, CXMLNode* pNode );
// static PVOID SaveMapData ( lua_State* pLuaVM, PVOID pElement, CXMLNode* pNode, bool bChildren );
// Account get funcs
static void* GetAccount ( lua_State* pLuaVM, const char* szName, const char* szPassword );
static CLuaArguments* GetAccounts ( lua_State* pLuaVM );
static void* GetAccountPlayer ( lua_State* pLuaVM, void* pAccount );
static bool IsGuestAccount ( lua_State* pLuaVM, void* pAccount, bool& bGuest );
static CLuaArgument* GetAccountData ( lua_State* pLuaVM, void* pAccount, const char* szKey );
static bool GetAllAccountData ( lua_State* pLuaVM, void* pAccount );
static bool GetAccountSerial ( lua_State* pLuaVM, void* pAccount, string& strSerial );
static bool GetAccountsBySerial ( lua_State* pLuaVM, const string& strSerial, std::vector<void*>& outAccounts );
static PVOID GetAccount ( lua_State* pLuaVM, const char* szName, const char* szPassword );
static CLuaArgumentsVector GetAccounts ( lua_State* pLuaVM );
static PVOID GetAccountPlayer ( lua_State* pLuaVM, PVOID pAccount );
static bool IsGuestAccount ( lua_State* pLuaVM, PVOID pAccount, bool& bGuest );
static CLuaArgument GetAccountData ( lua_State* pLuaVM, PVOID pAccount, const char* szKey );
static bool GetAllAccountData ( lua_State* pLuaVM, PVOID pAccount );
static bool GetAccountSerial ( lua_State* pLuaVM, PVOID pAccount, string& strSerial );
static bool GetAccountsBySerial ( lua_State* pLuaVM, const string& strSerial, std::vector<PVOID>& outAccounts );
// Account set funcs
static void* AddAccount ( lua_State* pLuaVM, const char* szName, const char* szPassword );
static bool RemoveAccount ( lua_State* pLuaVM, void* pAccount );
static bool SetAccountPassword ( lua_State* pLuaVM, void* pAccount, const char* szPassword );
static bool SetAccountData ( lua_State* pLuaVM, void* pAccount, const char* szKey, CLuaArgument* pArgument );
static bool CopyAccountData ( lua_State* pLuaVM, void* pAccount, void* pFromAccount );
static PVOID AddAccount ( lua_State* pLuaVM, const char* szName, const char* szPassword );
static bool RemoveAccount ( lua_State* pLuaVM, PVOID pAccount );
static bool SetAccountPassword ( lua_State* pLuaVM, PVOID pAccount, const char* szPassword );
static bool SetAccountData ( lua_State* pLuaVM, PVOID pAccount, const char* szKey, CLuaArgument* pArgument );
static bool CopyAccountData ( lua_State* pLuaVM, PVOID pAccount, PVOID pFromAccount );
// Log in/out funcs
static bool LogIn ( lua_State* pLuaVM, void* pPlayer, void* pAccount, const char* szPassword );
static bool LogOut ( lua_State* pLuaVM, void* pPlayer );
static bool LogIn ( lua_State* pLuaVM, PVOID pPlayer, PVOID pAccount, const char* szPassword );
static bool LogOut ( lua_State* pLuaVM, PVOID pPlayer );
// Admin funcs
static bool KickPlayer ( lua_State* pLuaVM, void* pPlayer, string strResponsible = "Console", string strReason = "" );
static void* BanPlayer ( lua_State* pLuaVM, void* pPlayer, bool bIP, bool bUsername, bool bSerial, void* pResponsible = NULL, string strResponsible = "Console", string strReason = "", time_t tUnban = 0 );
static bool KickPlayer ( lua_State* pLuaVM, PVOID pPlayer, string strResponsible = "Console", string strReason = "" );
static PVOID BanPlayer ( lua_State* pLuaVM, PVOID pPlayer, bool bIP, bool bUsername, bool bSerial, PVOID pResponsible = NULL, string strResponsible = "Console", string strReason = "", time_t tUnban = 0 );
static void* AddBan ( lua_State* pLuaVM, string strIP, string strUsername, string strSerial, void* pResponsible = NULL, string strResponsible = "Console", string strReason = "", time_t tUnban = 0 );
static bool RemoveBan ( lua_State* pLuaVM, void* pBan, void* pResponsible = NULL );
static PVOID AddBan ( lua_State* pLuaVM, string strIP, string strUsername, string strSerial, PVOID pResponsible = NULL, string strResponsible = "Console", string strReason = "", time_t tUnban = 0 );
static bool RemoveBan ( lua_State* pLuaVM, PVOID pBan, PVOID pResponsible = NULL );
static bool GetBans ( lua_State* pLuaVM );
static bool ReloadBanList ( lua_State* pLuaVM );
static bool GetBanIP ( lua_State* pLuaVM, void* pBan, string& strOutIP );
static bool GetBanSerial ( lua_State* pLuaVM, void* pBan, string& strOutSerial );
static bool GetBanUsername ( lua_State* pLuaVM, void* pBan, string& strOutUsername );
static bool GetBanNick ( lua_State* pLuaVM, void* pBan, string& strOutNick );
static bool GetBanReason ( lua_State* pLuaVM, void* pBan, string& strOutReason );
static bool GetBanAdmin ( lua_State* pLuaVM, void* pBan, string& strOutAdmin );
static bool GetBanIP ( lua_State* pLuaVM, PVOID pBan, string& strOutIP );
static bool GetBanSerial ( lua_State* pLuaVM, PVOID pBan, string& strOutSerial );
static bool GetBanUsername ( lua_State* pLuaVM, PVOID pBan, string& strOutUsername );
static bool GetBanNick ( lua_State* pLuaVM, PVOID pBan, string& strOutNick );
static bool GetBanReason ( lua_State* pLuaVM, PVOID pBan, string& strOutReason );
static bool GetBanAdmin ( lua_State* pLuaVM, PVOID pBan, string& strOutAdmin );
static bool GetBanTime ( lua_State* pLuaVM, void* pBan, time_t& time );
static bool GetUnbanTime ( lua_State* pLuaVM, void* pBan, time_t& time );
static bool GetBanTime ( lua_State* pLuaVM, PVOID pBan, time_t& time );
static bool GetUnbanTime ( lua_State* pLuaVM, PVOID pBan, time_t& time );
static bool SetUnbanTime ( lua_State* pLuaVM, void* pBan, time_t time);
static bool SetBanReason ( lua_State* pLuaVM, void* pBan, const string& strReason );
static bool SetBanAdmin ( lua_State* pLuaVM, void* pBan, const string& strAdminName );
static bool SetUnbanTime ( lua_State* pLuaVM, PVOID pBan, time_t time);
static bool SetBanReason ( lua_State* pLuaVM, PVOID pBan, const string& strReason );
static bool SetBanAdmin ( lua_State* pLuaVM, PVOID pBan, const string& strAdminName );
// Cursor get funcs
static bool IsCursorShowing ( lua_State* pLuaVM, void* pPlayer, bool& bShowing );
static bool IsCursorShowing ( lua_State* pLuaVM, PVOID pPlayer, bool& bShowing );
// Cursor set funcs
static bool ShowCursor ( lua_State* pLuaVM, void* pElement, bool bShow, bool bToggleControls );
static bool ShowCursor ( lua_State* pLuaVM, PVOID pElement, bool bShow, bool bToggleControls );
// Chat funcs
static bool ShowChat ( lua_State* pLuaVM, void* pElement, bool bShow );
static bool ShowChat ( lua_State* pLuaVM, PVOID pElement, bool bShow );
// Misc funcs
static bool ResetMapInfo ( lua_State* pLuaVM, void* pElement );
static bool ResetMapInfo ( lua_State* pLuaVM, PVOID pElement );
// Resource funcs
static void* CreateResource ( lua_State* pLuaVM, const char* szResourceName, const char* szOrganizationalDir );
static void* CopyResource ( lua_State* pLuaVM, void* pResource, const char* szNewResourceName, const char* szOrganizationalDir );
static void* GetResourceRootElement ( lua_State* pLuaVM, void* pResource = NULL );
static void* GetResourceMapRootElement ( lua_State* pLuaVM, void* pResource, const char* szMap );
static void* GetResourceDynamicElementRoot ( lua_State* pLuaVM, void* pResource );
static PVOID CreateResource ( lua_State* pLuaVM, const char* szResourceName, const char* szOrganizationalDir );
static PVOID CopyResource ( lua_State* pLuaVM, PVOID pResource, const char* szNewResourceName, const char* szOrganizationalDir );
static PVOID GetResourceRootElement ( lua_State* pLuaVM, PVOID pResource = NULL );
static PVOID GetResourceMapRootElement ( lua_State* pLuaVM, PVOID pResource, const char* szMap );
static PVOID GetResourceDynamicElementRoot ( lua_State* pLuaVM, PVOID pResource );
// static CXMLNode* AddResourceMap ( lua_State* pLuaVM, const string& strFilePath, const std::string& strMapName, int iDimension );
// static CXMLNode* AddResourceConfig ( lua_State* pLuaVM, const string& strFilePath, const std::string& strConfigName, int iType );
static bool RemoveResourceFile ( lua_State* pLuaVM, void* pResource, const char* szFilename );
static bool RemoveResourceFile ( lua_State* pLuaVM, PVOID pResource, const char* szFilename );
// static CXMLNode AddResourceConfig ( lua_State* pLuaVM, const char* szFilePath, const char* szFileType = "server" );
// static CXMLNode AddResourceMap ( lua_State* pLuaVM, const char* szFilePath, unsigned int uiDimension = 0 );
// static CXMLNode GetResourceConfig ( lua_State* pLuaVM, const char* szFilePath );
static CLuaArguments* GetResourceExportedFunctions ( lua_State* pLuaVM, void* pResource );
static void* GetResourceFromName ( lua_State* pLuaVM, const char* szResourceName );
static bool GetResourceInfo ( lua_State* pLuaVM, void* pResource, const char* szAttribute, string& strInfo );
static bool GetResourceLastStartTime ( lua_State* pLuaVM, void* pResource, unsigned int& uiTime );
static bool GetResourceLoadFailureReason ( lua_State* pLuaVM, void* pResource, string& strReason );
static bool GetResourceLoadTime ( lua_State* pLuaVM, void* pResource, unsigned int& uiTime );
static bool GetResourceName ( lua_State* pLuaVM, void* pResource, string& strName );
static CLuaArguments* GetResources ( lua_State* pLuaVM );
static bool GetResourceState ( lua_State* pLuaVM, void* pResource, string& strState );
static void* GetThisResource ( lua_State* pLuaVM );
static CLuaArgumentsVector GetResourceExportedFunctions ( lua_State* pLuaVM, PVOID pResource );
static PVOID GetResourceFromName ( lua_State* pLuaVM, const char* szResourceName );
static bool GetResourceInfo ( lua_State* pLuaVM, PVOID pResource, const char* szAttribute, string& strInfo );
static bool GetResourceLastStartTime ( lua_State* pLuaVM, PVOID pResource, unsigned int& uiTime );
static bool GetResourceLoadFailureReason ( lua_State* pLuaVM, PVOID pResource, string& strReason );
static bool GetResourceLoadTime ( lua_State* pLuaVM, PVOID pResource, unsigned int& uiTime );
static bool GetResourceName ( lua_State* pLuaVM, PVOID pResource, string& strName );
static CLuaArgumentsVector GetResources ( lua_State* pLuaVM );
static bool GetResourceState ( lua_State* pLuaVM, PVOID pResource, string& strState );
static PVOID GetThisResource ( lua_State* pLuaVM );
static bool RefreshResources ( lua_State* pLuaVM, bool refreshAll = false );
static bool RemoveResourceDefaultSetting ( lua_State* pLuaVM, void* pResource, const char* szSettingName );
static bool StartResource ( lua_State* pLuaVM, void* pResource, bool persistent = false, bool startIncludedResources = true, bool loadServerConfigs = true, bool loadMaps = true, bool loadServerScripts = true, bool loadHTML = true, bool loadClientConfigs = true, bool loadClientScripts = true, bool loadFiles = true );
static bool RestartResource ( lua_State* pLuaVM, void* pResource );
static bool StopResource ( lua_State* pLuaVM, void* pResource );
static bool SetResourceDefaultSetting ( lua_State* pLuaVM, void* pResource, const char* szSettingName, const char* szSettingValue );
static bool SetResourceDefaultSetting ( lua_State* pLuaVM, void* pResource, const char* szSettingName, int iSettingValue );
static bool SetResourceDefaultSetting ( lua_State* pLuaVM, void* pResource, const char* szSettingName, float fSettingValue );
static bool SetResourceInfo ( lua_State* pLuaVM, void* pResource, const char* szAttribute, const char* szValue );
static bool RemoveResourceDefaultSetting ( lua_State* pLuaVM, PVOID pResource, const char* szSettingName );
static bool StartResource ( lua_State* pLuaVM, PVOID pResource, bool persistent = false, bool startIncludedResources = true, bool loadServerConfigs = true, bool loadMaps = true, bool loadServerScripts = true, bool loadHTML = true, bool loadClientConfigs = true, bool loadClientScripts = true, bool loadFiles = true );
static bool RestartResource ( lua_State* pLuaVM, PVOID pResource );
static bool StopResource ( lua_State* pLuaVM, PVOID pResource );
static bool SetResourceDefaultSetting ( lua_State* pLuaVM, PVOID pResource, const char* szSettingName, const char* szSettingValue );
static bool SetResourceDefaultSetting ( lua_State* pLuaVM, PVOID pResource, const char* szSettingName, int iSettingValue );
static bool SetResourceDefaultSetting ( lua_State* pLuaVM, PVOID pResource, const char* szSettingName, float fSettingValue );
static bool SetResourceInfo ( lua_State* pLuaVM, PVOID pResource, const char* szAttribute, const char* szValue );
static bool RenameResource ( lua_State* pLuaVM, const char* szResourceName, const char* szNewResourceName, const char* szOrganizationalPath );
static bool DeleteResource ( lua_State* pLuaVM, const char* szResourceName );
// static CLuaArguments* GetResourceACLRequests ( lua_State* pLuaVM, void* pResource );
static bool UpdateResourceACLRequest ( lua_State* pLuaVM, void* pResource, const char* szRightName, bool bAccess, const char* szByWho = NULL );
// static CLuaArguments* GetResourceACLRequests ( lua_State* pLuaVM, PVOID pResource );
static bool UpdateResourceACLRequest ( lua_State* pLuaVM, PVOID pResource, const char* szRightName, bool bAccess, const char* szByWho = NULL );
// Version funcs
static LuaTable GetVersion ( lua_State* pLuaVM );
static CLuaArgumentsMap GetVersion ( lua_State* pLuaVM );
// Camera get functions
static bool GetCameraMatrix ( lua_State* pLuaVM, void* pPlayer, Vector3& vecPosition, Vector3& vecLookAt, float& fRoll, float& fFOV );
static void* GetCameraTarget ( lua_State* pLuaVM, void* pPlayer );
static bool GetCameraInterior ( lua_State* pLuaVM, void* pPlayer, unsigned char & ucInterior );
static bool GetCameraMatrix ( lua_State* pLuaVM, PVOID pPlayer, Vector3& vecPosition, Vector3& vecLookAt, float& fRoll, float& fFOV );
static PVOID GetCameraTarget ( lua_State* pLuaVM, PVOID pPlayer );
static bool GetCameraInterior ( lua_State* pLuaVM, PVOID pPlayer, unsigned char & ucInterior );
// Camera set functions
static bool SetCameraMatrix ( lua_State* pLuaVM, void* pPlayer, const Vector3& vecPosition, Vector3& pvecLookAt, float fRoll, float fFOV );
static bool SetCameraTarget ( lua_State* pLuaVM, void* pPlayer, void* pTarget );
static bool SetCameraInterior ( lua_State* pLuaVM, void* pPlayer, unsigned char ucInterior );
static bool FadeCamera ( lua_State* pLuaVM, void* pPlayer, bool bFadeIn, float fFadeTime, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue );
static bool SetCameraMatrix ( lua_State* pLuaVM, PVOID pPlayer, const Vector3& vecPosition, Vector3& pvecLookAt, float fRoll, float fFOV );
static bool SetCameraTarget ( lua_State* pLuaVM, PVOID pPlayer, PVOID pTarget );
static bool SetCameraInterior ( lua_State* pLuaVM, PVOID pPlayer, unsigned char ucInterior );
static bool FadeCamera ( lua_State* pLuaVM, PVOID pPlayer, bool bFadeIn, float fFadeTime, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue );
// Weapon give/take functions
static bool GiveWeapon ( lua_State* pLuaVM, void* pPed, unsigned char ucWeaponID, unsigned short usAmmo, bool bSetAsCurrent = false );
static bool TakeWeapon ( lua_State* pLuaVM, void* pPed, unsigned char ucWeaponID, unsigned short usAmmo = 9999 );
static bool TakeAllWeapons ( lua_State* pLuaVM, void* pPed );
static bool SetWeaponAmmo ( lua_State* pLuaVM, void* pPed, unsigned char ucWeaponID, unsigned short usAmmo, unsigned short usAmmoInClip );
static bool GiveWeapon ( lua_State* pLuaVM, PVOID pPed, unsigned char ucWeaponID, unsigned short usAmmo, bool bSetAsCurrent = false );
static bool TakeWeapon ( lua_State* pLuaVM, PVOID pPed, unsigned char ucWeaponID, unsigned short usAmmo = 9999 );
static bool TakeAllWeapons ( lua_State* pLuaVM, PVOID pPed );
static bool SetWeaponAmmo ( lua_State* pLuaVM, PVOID pPed, unsigned char ucWeaponID, unsigned short usAmmo, unsigned short usAmmoInClip );
};
#endif