SA-MP/server/scrcustom.cpp

#include "main.h"

int set_amxstring(AMX *amx,cell amx_addr,const char *source,int max);

extern BOOL bGameModeFinished;

//----------------------------------------------------------------------------------

// native gpci(playerid, const clientid[], len) 
static cell AMX_NATIVE_CALL n_gpci(AMX *amx, cell *params)
{
	PLAYERID playerId = (PLAYERID)params[1];
	if (playerId >= MAX_PLAYERS || !pNetGame->GetPlayerPool()->GetSlotState(playerId)) return 0;
	return set_amxstring(amx, params[2], pNetGame->GetPlayerPool()->
		GetPlayerClientID(playerId), params[3]);
}

//----------------------------------------------------------------------------------
// native GetPlayerPoolSize()
static cell AMX_NATIVE_CALL n_GetPlayerPoolSize(AMX *amx, cell *params)
{
	if(!pNetGame) return -1;
	CPlayerPool *pPlayerPool = pNetGame->GetPlayerPool();
	if(pPlayerPool) {
		return pPlayerPool->GetPoolSize();
	}
	return -1;
}

//----------------------------------------------------------------------------------
// native GetVehiclePoolSize()
static cell AMX_NATIVE_CALL n_GetVehiclePoolSize(AMX *amx, cell *params)
{
	if(!pNetGame) return -1;
	CVehiclePool *pVehiclePool = pNetGame->GetVehiclePool();
	if(pVehiclePool) {
		return pVehiclePool->GetPoolSize();
	}
	return -1;
}

//----------------------------------------------------------------------------------
// native GetActorPoolSize()
static cell AMX_NATIVE_CALL n_GetActorPoolSize(AMX *amx, cell *params)
{
	if(!pNetGame) return -1;
	CActorPool *pActorPool = pNetGame->GetActorPool();
	if(pActorPool) {
		return pActorPool->GetPoolSize();
	}
	return -1;
}

//----------------------------------------------------------------------------------

static cell AMX_NATIVE_CALL n_print(AMX *amx, cell *params)
{
	// TODO: print
	return 0;
}

static cell AMX_NATIVE_CALL n_printf(AMX *amx, cell *params)
{
	// TODO: printf
	return 0;
}

static cell AMX_NATIVE_CALL n_format(AMX *amx, cell *params)
{
	// TODO: format
	return 0;
}

static cell AMX_NATIVE_CALL n_SetTimer(AMX *amx, cell *params)
{
	char* szFuncName;
	amx_StrParam(amx, params[1], szFuncName);
	return pNetGame->GetTimers()->New(szFuncName, params[2], params[3], amx);
}

static cell AMX_NATIVE_CALL n_KillTimer(AMX *amx, cell *params)
{
	pNetGame->GetTimers()->Kill(params[1]);

	return 1;
}

//----------------------------------------------------------------------------------

// native GetTickCount()
static cell AMX_NATIVE_CALL n_GetTickCount(AMX *amx, cell *params)
{
	return (cell)pNetGame->GetTime();
}

//----------------------------------------------------------------------------------
// native GetMaxPlayers()
static cell AMX_NATIVE_CALL n_GetMaxPlayers(AMX *amx, cell *params)
{
	extern CConsole *pConsole;
	return pConsole->GetIntVariable("maxplayers");
}

//----------------------------------------------------------------------------------

static cell AMX_NATIVE_CALL n_SetTimerEx(AMX *amx, cell *params)
{
	if (params[0] < 4 * sizeof (cell))
	{
		logprintf("SCRIPT: Bad parameter count (%d < 4): ", params[0]);
		return 0;
	}
	else if (params[0] > 260 * sizeof (cell))
	{
		logprintf("SCRIPT: Bad parameter count (%d > 260): ", params[0]);
		return 0;
	}

	char* szFuncName;
	amx_StrParam(amx, params[1], szFuncName);
	return pNetGame->GetTimers()->NewEx(szFuncName, params[2], params[3], params, amx);
}

//----------------------------------------------------------------------------------
// native LimitGlobalChatRadius(Float:chat_radius)
static cell AMX_NATIVE_CALL n_LimitGlobalChatRadius(AMX *amx, cell *params)
{
	float fRadius = amx_ctof(params[1]);

	pNetGame->m_bLimitGlobalChatRadius = true;
	pNetGame->m_fGlobalChatRadius = fRadius;

	return 1;
}

//----------------------------------------------------------------------------------
// native LimitPlayerMarkerRadius(Float:marker_radius)
static cell AMX_NATIVE_CALL n_LimitPlayerMarkerRadius(AMX *amx, cell *params)
{
	float fRadius = amx_ctof(params[1]);

	pNetGame->m_bLimitPlayerMarkerRadius = true;
	pNetGame->m_fPlayerMarkerRadius = fRadius;

	return 1;
}

//----------------------------------------------------------------------------------

static cell AMX_NATIVE_CALL n_SetWeather(AMX *amx, cell *params)
{
	// TODO: SetWeather
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerWeather(AMX *amx, cell *params)
{
	// TODO: SetPlayerWeather
	return 0;
}

static cell AMX_NATIVE_CALL n_CallRemoteFunction(AMX *amx, cell *params)
{
	// TODO: CallRemoteFunction
	return 0;
}

static cell AMX_NATIVE_CALL n_CallLocalFunction(AMX *amx, cell *params)
{
	// TODO: CallLocalFunction
	return 0;
}

//----------------------------------------------------------------------------------
// native Float:VectorSize(Float:x, Float:y, Float:z)
static cell AMX_NATIVE_CALL n_VectorSize(AMX *amx, cell *params)
{
	VECTOR vec;
	vec.X = amx_ctof(params[1]);
	vec.Y = amx_ctof(params[2]);
	vec.Z = amx_ctof(params[3]);
	float fResult = GetLength(&vec);
	return amx_ftoc(fResult);
}

//----------------------------------------------------------------------------------

static cell AMX_NATIVE_CALL n_asin(AMX *amx, cell *params)
{
	float fResult = (float)(asin(amx_ctof(params[1])) * (180.0f / PI));
	return amx_ftoc(fResult);
}

static cell AMX_NATIVE_CALL n_acos(AMX *amx, cell *params)
{
	float fResult = (float)(acos(amx_ctof(params[1])) * (180.0f / PI));
	return amx_ftoc(fResult);
}

static cell AMX_NATIVE_CALL n_atan(AMX *amx, cell *params)
{
	float fResult = (float)(atan(amx_ctof(params[1])) * (180.0f / PI));
	return amx_ftoc(fResult);
}

static cell AMX_NATIVE_CALL n_atan2(AMX *amx, cell *params)
{
	float fResult = (float)(atan2(amx_ctof(params[1]), amx_ctof(params[2])) * (180.0f / PI));
	return amx_ftoc(fResult);
}

//----------------------------------------------------

static cell AMX_NATIVE_CALL n_SHA256_PassHash(AMX *amx, cell *params)
{
	// TODO: SHA256_PassHash
	return 0;
}

static cell AMX_NATIVE_CALL n_SetSVarInt(AMX *amx, cell *params)
{
	// TODO: SetSVarInt
	return 0;
}

static cell AMX_NATIVE_CALL n_SetSVarString(AMX *amx, cell *params)
{
	// TODO: SetSVarString
	return 0;
}

static cell AMX_NATIVE_CALL n_SetSVarFloat(AMX *amx, cell *params)
{
	// TODO: SetSVarFloat
	return 0;
}

static cell AMX_NATIVE_CALL n_GetSVarInt(AMX *amx, cell *params)
{
	// TODO: GetSVarInt
	return 0;
}

static cell AMX_NATIVE_CALL n_GetSVarString(AMX *amx, cell *params)
{
	// TODO: GetSVarString
	return 0;
}

static cell AMX_NATIVE_CALL n_GetSVarFloat(AMX *amx, cell *params)
{
	// TODO: GetSVarFloat
	return 0;
}

static cell AMX_NATIVE_CALL n_DeleteSVar(AMX *amx, cell *params)
{
	// TODO: DeleteSVar
	return 0;
}

static cell AMX_NATIVE_CALL n_GetSVarType(AMX *amx, cell *params)
{
	// TODO: GetSVarType
	return 0;
}

static cell AMX_NATIVE_CALL n_GetSVarNameAtIndex(AMX *amx, cell *params)
{
	// TODO: GetSVarNameAtIndex
	return 0;
}

static cell AMX_NATIVE_CALL n_GetSVarsUpperIndex(AMX *amx, cell *params)
{
	// TODO: GetSVarsUpperIndex
	return 0;
}

// native GameModeExit()
static cell AMX_NATIVE_CALL n_GameModeExit(AMX *amx, cell *params)
{
	if(pNetGame->SetNextScriptFile(NULL)) {
		bGameModeFinished = TRUE;
	} else {
		logprintf("The gamemode finished and I couldn't start another script.");
		fcloseall();
		exit(1);
	}
	return 0;
}

// native SetGameModeText(const string[])
static cell AMX_NATIVE_CALL n_SetGameModeText(AMX *amx, cell *params)
{
	char* szGameModeText;
	amx_StrParam(amx, params[1], szGameModeText);
	pConsole->SetStringVariable("gamemodetext", szGameModeText);

	return 0;
}

// native SetTeamCount(count)
static cell AMX_NATIVE_CALL n_SetTeamCount(AMX *amx, cell *params)
{
	return 0;
}

static cell AMX_NATIVE_CALL n_AddPlayerClass(AMX *amx, cell *params)
{
	// TODO: AddPlayerClass
	return 0;
}

static cell AMX_NATIVE_CALL n_AddPlayerClassEx(AMX *amx, cell *params)
{
	// TODO: AddPlayerClassEx
	return 0;
}

static cell AMX_NATIVE_CALL n_AddStaticVehicle(AMX *amx, cell *params)
{
	// TODO: AddStaticVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_AddStaticVehicleEx(AMX *amx, cell *params)
{
	// TODO: AddStaticVehicleEx
	return 0;
}

static cell AMX_NATIVE_CALL n_AddStaticPickup(AMX *amx, cell *params)
{
	// TODO: AddStaticPickup
	return 0;
}

static cell AMX_NATIVE_CALL n_CreatePickup(AMX *amx, cell *params)
{
	// TODO: CreatePickup
	return 0;
}

static cell AMX_NATIVE_CALL n_DestroyPickup(AMX *amx, cell *params)
{
	// TODO: DestroyPickup
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerWorldBounds(AMX *amx, cell *params)
{
	// TODO: SetPlayerWorldBounds
	return 0;
}

//----------------------------------------------------------------------------------

// native ShowNameTags(show)
static cell AMX_NATIVE_CALL n_ShowNameTags(AMX *amx, cell *params)
{
	pNetGame->m_bShowNameTags = (bool)params[1];
	return 1;
}

//----------------------------------------------------------------------------------

// native ShowPlayerMarkers(mode)
static cell AMX_NATIVE_CALL n_ShowPlayerMarkers(AMX *amx, cell *params)
{
	pNetGame->m_iShowPlayerMarkers = params[1];
	return 1;
}

//----------------------------------------------------------------------------------

static cell AMX_NATIVE_CALL n_SetWorldTime(AMX *amx, cell *params)
{
	// TODO: SetWorldTime
	return 0;
}

// native GetWeaponName(weaponid, const weapon[], len)
static cell AMX_NATIVE_CALL n_GetWeaponName(AMX *amx, cell *params)
{
	if(params[1] > WEAPON_COLLISION) return 0;

	return set_amxstring(amx,params[2],pNetGame->GetWeaponName(params[1]),params[3]);
}

//----------------------------------------------------------------------------------

// native EnableTirePopping(enable)
static cell AMX_NATIVE_CALL n_EnableTirePopping(AMX *amx, cell *params)
{
	logprintf("EnableTirePopping() function is removed.");
	return 1;
}

//----------------------------------------------------------------------------------
// native EnableVehicleFriendlyFire()
static cell AMX_NATIVE_CALL n_EnableVehicleFriendlyFire(AMX *amx, cell *params)
{
	pNetGame->m_bVehicleFriendlyFire = TRUE;
	return 1;
}

//----------------------------------------------------------------------------------

// native AllowInteriorWeapons(allow)
static cell AMX_NATIVE_CALL n_AllowInteriorWeapons(AMX *amx, cell *params)
{
	pNetGame->m_bAllowWeapons = (bool)params[1];
	return 1;
}

//----------------------------------------------------------------------------------

static cell AMX_NATIVE_CALL n_SetGravity(AMX *amx, cell *params)
{
	// TODO: SetGravity
	return 0;
}

// native GetGravity()
static cell AMX_NATIVE_CALL n_GetGravity(AMX *amx, cell *params)
{
	return amx_ftoc(pNetGame->m_fGravity);
}

//----------------------------------------------------------------------------------

// native AllowAdminTeleport(allow)
static cell AMX_NATIVE_CALL n_AllowAdminTeleport(AMX *amx, cell *params)
{
	logprintf("AllowAdminTeleport() : function is deprecated. Please see OnPlayerClickMap()");
	return 1;
}

//----------------------------------------------------------------------------------

// native SetDeathDropAmount(amount)
static cell AMX_NATIVE_CALL n_SetDeathDropAmount(AMX *amx, cell *params)
{
	pNetGame->m_iDeathDropMoney = params[1];
	return 1;
}

//----------------------------------------------------------------------------------

static cell AMX_NATIVE_CALL n_CreateExplosion(AMX *amx, cell *params)
{
	// TODO: CreateExplosion
	return 0;
}

static cell AMX_NATIVE_CALL n_CreateExplosionForPlayer(AMX *amx, cell *params)
{
	// TODO: CreateExplosionForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_SetDisabledWeapons(AMX *amx, cell *params)
{
	logprintf("[warning] SetDisabledWeapons() : function is deprecated. Check weapon in OnPlayerUpdate.");
	return 1;
}

// native UsePlayerPedAnims()
static cell AMX_NATIVE_CALL n_UsePlayerPedAnims(AMX *amx, cell *params)
{
	pNetGame->m_bUseCJWalk = true;
	return 1;
}

// native DisableInteriorEnterExits()
static cell AMX_NATIVE_CALL n_DisableInteriorEnterExits(AMX *amx, cell *params)
{
	pNetGame->m_bDisableEnterExits = true;

	return 1;
}

// native SetNameTagDrawDistance(Float:distance)
static cell AMX_NATIVE_CALL n_SetNameTagDrawDistance(AMX *amx, cell *params)
{
	pNetGame->m_fNameTagDrawDistance = amx_ctof(params[1]);

	return 1;
}

// native DisableNameTagLOS()
static cell AMX_NATIVE_CALL n_DisableNameTagLOS(AMX *amx, cell *params)
{
	pNetGame->m_bNameTagLOS = false;
	return 1;
}

static cell AMX_NATIVE_CALL n_ConnectNPC(AMX *amx, cell *params)
{
	// TODO: ConnectNPC
	return 0;
}

// native IsPlayerNPC(playerid)
static cell AMX_NATIVE_CALL n_IsPlayerNPC(AMX *amx, cell *params)
{
	BOOL bResult = FALSE;

	if(pNetGame)
	{
		CPlayerPool* pPlayerPool = pNetGame->GetPlayerPool();

		if(pPlayerPool && pPlayerPool->GetSlotState((PLAYERID)params[1]))
		{
			if(pPlayerPool->IsNPC((PLAYERID)params[1]))
			{
				bResult = TRUE;
			}
		}
	}
	return bResult;
}

static cell AMX_NATIVE_CALL n_Create3DTextLabel(AMX *amx, cell *params)
{
	// TODO: Create3DTextLabel
	return 0;
}

static cell AMX_NATIVE_CALL n_Delete3DTextLabel(AMX *amx, cell *params)
{
	// TODO: Delete3DTextLabel
	return 0;
}

static cell AMX_NATIVE_CALL n_Attach3DTextLabelToPlayer(AMX *amx, cell *params)
{
	// TODO: Attach3DTextLabelToPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_Attach3DTextLabelToVehicle(AMX *amx, cell *params)
{
	// TODO: Attach3DTextLabelToVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_Update3DTextLabelText(AMX *amx, cell *params)
{
	// TODO: Update3DTextLabelText
	return 0;
}

static cell AMX_NATIVE_CALL n_CreatePlayer3DTextLabel(AMX *amx, cell *params)
{
	// TODO: CreatePlayer3DTextLabel
	return 0;
}

static cell AMX_NATIVE_CALL n_DeletePlayer3DTextLabel(AMX *amx, cell *params)
{
	// TODO: DeletePlayer3DTextLabel
	return 0;
}

static cell AMX_NATIVE_CALL n_UpdatePlayer3DTextLabelText(AMX *amx, cell *params)
{
	// TODO: UpdatePlayer3DTextLabelText
	return 0;
}

static cell AMX_NATIVE_CALL n_ShowPlayerDialog(AMX *amx, cell *params)
{
	// TODO: ShowPlayerDialog
	return 0;
}

// native EnableZoneNames(enable)
static cell AMX_NATIVE_CALL n_EnableZoneNames(AMX *amx, cell *params)
{
	logprintf("[warning] EnableZoneNames() is removed since 0.3");
	return 1;
}

//----------------------------------------------------------------------------------

// native GangZoneCreate(Float:minx, Float:miny, Float:maxx, Float:maxy)
static cell AMX_NATIVE_CALL n_GangZoneCreate(AMX *amx, cell *params)
{
	CGangZonePool *pGangZonePool = pNetGame->GetGangZonePool();
	if (!pGangZonePool) return -1;
	WORD ret = pGangZonePool->New(amx_ctof(params[1]), amx_ctof(params[2]), amx_ctof(params[3]), amx_ctof(params[4]));
	if (ret == 0xFFFF) return -1;
	return ret;
}

// native GangZoneDestroy(zone)
static cell AMX_NATIVE_CALL n_GangZoneDestroy(AMX *amx, cell *params)
{
	CGangZonePool *pGangZonePool = pNetGame->GetGangZonePool();
	if (!pGangZonePool || !pGangZonePool->GetSlotState(params[1])) return 0;
	pGangZonePool->Delete(params[1]);
	return 1;
}

// native GangZoneShowForPlayer(playerid, zone, color)
static cell AMX_NATIVE_CALL n_GangZoneShowForPlayer(AMX *amx, cell *params)
{
	if (!pNetGame->GetPlayerPool()->GetSlotState(params[1])) return 0;
	CGangZonePool *pGangZonePool = pNetGame->GetGangZonePool();
	if (!pGangZonePool || !pGangZonePool->GetSlotState(params[2])) return 0;
	pGangZonePool->ShowForPlayer(params[1], params[2], params[3]);
	return 1;
}

// native GangZoneShowForAll(zone, color)
static cell AMX_NATIVE_CALL n_GangZoneShowForAll(AMX *amx, cell *params)
{
	CGangZonePool *pGangZonePool = pNetGame->GetGangZonePool();
	if (!pGangZonePool || !pGangZonePool->GetSlotState(params[1])) return 0;
	pGangZonePool->ShowForAll(params[1], params[2]);
	return 1;
}

// native GangZoneHideForPlayer(playerid, zone)
static cell AMX_NATIVE_CALL n_GangZoneHideForPlayer(AMX *amx, cell *params)
{
	if (!pNetGame->GetPlayerPool()->GetSlotState(params[1])) return 0;
	CGangZonePool *pGangZonePool = pNetGame->GetGangZonePool();
	if (!pGangZonePool || !pGangZonePool->GetSlotState(params[2])) return 0;
	pGangZonePool->HideForPlayer(params[1], params[2]);
	return 1;
}

// native GangZoneHideForAll(zone)
static cell AMX_NATIVE_CALL n_GangZoneHideForAll(AMX *amx, cell *params)
{
	CGangZonePool *pGangZonePool = pNetGame->GetGangZonePool();
	if (!pGangZonePool || !pGangZonePool->GetSlotState(params[1])) return 0;
	pGangZonePool->HideForAll(params[1]);
	return 1;
}

// native GangZoneFlashForPlayer(playerid, zone, flashcolor)
static cell AMX_NATIVE_CALL n_GangZoneFlashForPlayer(AMX *amx, cell *params)
{
	if (!pNetGame->GetPlayerPool()->GetSlotState(params[1])) return 0;
	CGangZonePool *pGangZonePool = pNetGame->GetGangZonePool();
	if (!pGangZonePool || !pGangZonePool->GetSlotState(params[2])) return 0;
	pGangZonePool->FlashForPlayer(params[1], params[2], params[3]);
	return 1;
}

// native GangZoneFlashForAll(zone, flashcolor)
static cell AMX_NATIVE_CALL n_GangZoneFlashForAll(AMX *amx, cell *params)
{
	CGangZonePool *pGangZonePool = pNetGame->GetGangZonePool();
	if (!pGangZonePool || !pGangZonePool->GetSlotState(params[1])) return 0;
	pGangZonePool->FlashForAll(params[1], params[2]);
	return 1;
}

static cell AMX_NATIVE_CALL n_GangZoneStopFlashForPlayer(AMX *amx, cell *params)
{
	// TODO: GangZoneStopFlashForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_GangZoneStopFlashForAll(AMX *amx, cell *params)
{
	// TODO: GangZoneStopFlashForAll
	return 0;
}

// native IsPlayerAdmin(playerid)
static cell AMX_NATIVE_CALL n_IsPlayerAdmin(AMX *amx, cell *params)
{
	CPlayerPool* pPlayerPool = pNetGame->GetPlayerPool();

	if (pPlayerPool->GetSlotState((PLAYERID)params[1]))
	{
		return pPlayerPool->IsAdmin((PLAYERID)params[1]);
	}
	return 0;
}

static cell AMX_NATIVE_CALL n_Kick(AMX *amx, cell *params)
{
	// TODO: Kick
	return 0;
}

static cell AMX_NATIVE_CALL n_Ban(AMX *amx, cell *params)
{
	// TODO: Ban
	return 0;
}

static cell AMX_NATIVE_CALL n_BanEx(AMX *amx, cell *params)
{
	// TODO: BanEx
	return 0;
}

static cell AMX_NATIVE_CALL n_SendRconCommand(AMX *amx, cell *params)
{
	// TODO: SendRconCommand
	return 0;
}

static cell AMX_NATIVE_CALL n_GetServerVarAsString(AMX *amx, cell *params)
{
	// TODO: GetServerVarAsString
	return 0;
}

static cell AMX_NATIVE_CALL n_GetServerVarAsInt(AMX *amx, cell *params)
{
	// TODO: GetServerVarAsInt
	return 0;
}

static cell AMX_NATIVE_CALL n_GetServerVarAsBool(AMX *amx, cell *params)
{
	// TODO: GetServerVarAsBool
	return 0;
}

static cell AMX_NATIVE_CALL n_GetConsoleVarAsString(AMX *amx, cell *params)
{
	// TODO: GetConsoleVarAsString
	return 0;
}

static cell AMX_NATIVE_CALL n_GetConsoleVarAsInt(AMX *amx, cell *params)
{
	// TODO: GetConsoleVarAsInt
	return 0;
}

static cell AMX_NATIVE_CALL n_GetConsoleVarAsBool(AMX *amx, cell *params)
{
	// TODO: GetConsoleVarAsBool
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerNetworkStats(AMX *amx, cell *params)
{
	// TODO: GetPlayerNetworkStats
	return 0;
}

static cell AMX_NATIVE_CALL n_GetNetworkStats(AMX *amx, cell *params)
{
	// TODO: GetNetworkStats
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerVersion(AMX *amx, cell *params)
{
	// TODO: GetPlayerVersion
	return 0;
}

static cell AMX_NATIVE_CALL n_BlockIpAddress(AMX *amx, cell *params)
{
	// TODO: BlockIpAddress
	return 0;
}

static cell AMX_NATIVE_CALL n_UnBlockIpAddress(AMX *amx, cell *params)
{
	// TODO: UnBlockIpAddress
	return 0;
}

static cell AMX_NATIVE_CALL n_GetServerTickRate(AMX *amx, cell *params)
{
	// TODO: GetServerTickRate
	return 0;
}

static cell AMX_NATIVE_CALL n_NetStats_GetConnectedTime(AMX *amx, cell *params)
{
	// TODO: NetStats_GetConnectedTime
	return 0;
}

static cell AMX_NATIVE_CALL n_NetStats_MessagesReceived(AMX *amx, cell *params)
{
	// TODO: NetStats_MessagesReceived
	return 0;
}

static cell AMX_NATIVE_CALL n_NetStats_BytesReceived(AMX *amx, cell *params)
{
	// TODO: NetStats_BytesReceived
	return 0;
}

static cell AMX_NATIVE_CALL n_NetStats_MessagesSent(AMX *amx, cell *params)
{
	// TODO: NetStats_MessagesSent
	return 0;
}

static cell AMX_NATIVE_CALL n_NetStats_BytesSent(AMX *amx, cell *params)
{
	// TODO: NetStats_BytesSent
	return 0;
}

static cell AMX_NATIVE_CALL n_NetStats_MessagesRecvPerSecond(AMX *amx, cell *params)
{
	// TODO: NetStats_MessagesRecvPerSecond
	return 0;
}

static cell AMX_NATIVE_CALL n_NetStats_PacketLossPercent(AMX *amx, cell *params)
{
	// TODO: NetStats_PacketLossPercent
	return 0;
}

static cell AMX_NATIVE_CALL n_NetStats_ConnectionStatus(AMX *amx, cell *params)
{
	// TODO: NetStats_ConnectionStatus
	return 0;
}

static cell AMX_NATIVE_CALL n_NetStats_GetIpPort(AMX *amx, cell *params)
{
	// TODO: NetStats_GetIpPort
	return 0;
}

static cell AMX_NATIVE_CALL n_SetSpawnInfo(AMX *amx, cell *params)
{
	CPlayerPool *pPlayerPool = pNetGame->GetPlayerPool();
	if(!pPlayerPool) return 0;

	CPlayer *pPlayer = pPlayerPool->GetAt((PLAYERID)params[1]);
	if (pPlayer)
	{
		PLAYER_SPAWN_INFO SpawnInfo;
		SpawnInfo.byteTeam = (BYTE)params[2];
		SpawnInfo.iSkin = (int)params[3];
		SpawnInfo.vecPos.X = amx_ctof(params[4]);
		SpawnInfo.vecPos.Y = amx_ctof(params[5]);
		SpawnInfo.vecPos.Z = amx_ctof(params[6]);
		SpawnInfo.fRotation = amx_ctof(params[7]);
		SpawnInfo.iSpawnWeapons[0] = (int)params[8];
		SpawnInfo.iSpawnWeaponsAmmo[0] = (int)params[9];
		SpawnInfo.iSpawnWeapons[1] = (int)params[10];
		SpawnInfo.iSpawnWeaponsAmmo[1] = (int)params[11];
		SpawnInfo.iSpawnWeapons[2] = (int)params[12];
		SpawnInfo.iSpawnWeaponsAmmo[2] = (int)params[13];

		pPlayer->SetSpawnInfo(&SpawnInfo);
		pPlayer->field_290D = TRUE;
		RakNet::BitStream bsData;
		bsData.Write((PCHAR)&SpawnInfo, sizeof(PLAYER_SPAWN_INFO));
		pNetGame->SendToPlayer(RPC_ScrSetSpawnInfo, &bsData, (PLAYERID)params[1], 2);
		return 1;
	} else {
		return 0;
	}
}

static cell AMX_NATIVE_CALL n_SpawnPlayer(AMX *amx, cell *params)
{
	// TODO: SpawnPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerTeam(AMX *amx, cell *params)
{
	// TODO: SetPlayerTeam
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerTeam(AMX *amx, cell *params)
{
	// TODO: GetPlayerTeam
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerName(AMX *amx, cell *params)
{
	// TODO: SetPlayerName
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerSkin(AMX *amx, cell *params)
{
	// TODO: SetPlayerSkin
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerSkin(AMX *amx, cell *params)
{
	// TODO: GetPlayerSkin
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerPos(AMX *amx, cell *params)
{
	// TODO: GetPlayerPos
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerPos(AMX *amx, cell *params)
{
	// TODO: SetPlayerPos
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerPosFindZ(AMX *amx, cell *params)
{
	// TODO: SetPlayerPosFindZ
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerLastShotVectors(AMX *amx, cell *params)
{
	// TODO: GetPlayerLastShotVectors
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerHealth(AMX *amx, cell *params)
{
	// TODO: GetPlayerHealth
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerHealth(AMX *amx, cell *params)
{
	// TODO: SetPlayerHealth
	return 0;
}

// native SetPlayerColor(playerid, color)
static cell AMX_NATIVE_CALL n_SetPlayerColor(AMX *amx, cell *params)
{
	CPlayer* pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if(pPlayer) {
		pPlayer->SetPlayerColor(params[2]);
		return 1;
	}

	return 0;
}

// native GetPlayerColor(playerid)
static cell AMX_NATIVE_CALL n_GetPlayerColor(AMX *amx, cell *params)
{
	CPlayer* pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if(pPlayer) {
		return pPlayer->GetPlayerColor();
	}

	return 0;
}

// native GetPlayerVehicleID(playerid)
static cell AMX_NATIVE_CALL n_GetPlayerVehicleID(AMX *amx, cell *params)
{
	CPlayerPool *pPlayerPool = pNetGame->GetPlayerPool();
	if(!pPlayerPool) return 0;
	CPlayer *pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if(pPlayer) {
		return pPlayer->m_VehicleID;
	}
	return 0;
}

// native GetPlayerVehicleSeat(playerid)
static cell AMX_NATIVE_CALL n_GetPlayerVehicleSeat(AMX *amx, cell *params)
{
	CPlayer *pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if (!pPlayer) return -1;

	if (pPlayer->GetState() == PLAYER_STATE_DRIVER ||
		pPlayer->GetState() == PLAYER_STATE_PASSENGER)
		return pPlayer->m_byteSeatID;

	// Vehicle not found or the player isn't in it;
	return -1;
}

static cell AMX_NATIVE_CALL n_GetPlayerSurfingVehicleID(AMX *amx, cell *params)
{
	CPlayerPool *pPlayerPool = pNetGame->GetPlayerPool();
	if(!pPlayerPool) return 0xFFFF;

	CPlayer *pPlayer = pPlayerPool->GetAt((PLAYERID)params[1]);
	if(pPlayer && pPlayer->GetState() == PLAYER_STATE_ONFOOT) {
		WORD wSurfInfo = pPlayer->GetOnFootSyncData()->wSurfInfo;
		if(wSurfInfo != 0 && wSurfInfo < 2000) {
			return wSurfInfo;
		}
	}
	return 0xFFFF;
}

static cell AMX_NATIVE_CALL n_GetPlayerSurfingObjectID(AMX *amx, cell *params)
{
	CPlayerPool *pPlayerPool = pNetGame->GetPlayerPool();
	if(!pPlayerPool) return 0xFFFF;

	CPlayer *pPlayer = pPlayerPool->GetAt((PLAYERID)params[1]);
	if(pPlayer && pPlayer->GetState() == PLAYER_STATE_ONFOOT) {
		WORD wSurfInfo = pPlayer->GetOnFootSyncData()->wSurfInfo;
		if(wSurfInfo != 0 && wSurfInfo >= 2000 && wSurfInfo < 3000) {
			return wSurfInfo - 2000;
		}
	}
	return 0xFFFF;
}

static cell AMX_NATIVE_CALL n_PutPlayerInVehicle(AMX *amx, cell *params)
{
	// TODO: PutPlayerInVehicle
	return 0;
}

// native RemovePlayerFromVehicle(playerid)
static cell AMX_NATIVE_CALL n_RemovePlayerFromVehicle(AMX *amx, cell *params)
{
	RakNet::BitStream bsParams;
	CPlayerPool *pPlayerPool = pNetGame->GetPlayerPool();
	if(!pPlayerPool || !pPlayerPool->GetSlotState((PLAYERID)params[1])) return 0;

	pNetGame->SendToPlayer(RPC_ScrRemovePlayerFromVehicle, &bsParams, (PLAYERID)params[1], 2);

	return 1;
}

// native IsPlayerInVehicle(playerid, vehicleid)
static cell AMX_NATIVE_CALL n_IsPlayerInVehicle(AMX *amx, cell *params)
{
	CPlayer* pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if (!pPlayer) return 0;
	BYTE byteState = pPlayer->GetState();
	if ((byteState == PLAYER_STATE_DRIVER) || (byteState == PLAYER_STATE_PASSENGER))
	{
		if (pPlayer->m_VehicleID == params[2])
		{
			return 1;
		}
	}

	return 0;
}

// native IsPlayerInAnyVehicle(playerid)
static cell AMX_NATIVE_CALL n_IsPlayerInAnyVehicle(AMX *amx, cell *params)
{
	CPlayer* pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if (!pPlayer) return 0;
	BYTE byteState = pPlayer->GetState();

	if ((byteState == PLAYER_STATE_DRIVER) || (byteState == PLAYER_STATE_PASSENGER))
	{
		return 1;
	}

	return 0;
}

// native GetPlayerName(playerid, const name[], len)
static cell AMX_NATIVE_CALL n_GetPlayerName(AMX *amx, cell *params)
{
	PLAYERID playerId = (PLAYERID)params[1];
	if (playerId > MAX_PLAYERS || !pNetGame->GetPlayerPool()->GetSlotState(playerId)) return 0;
	return set_amxstring(amx, params[2], pNetGame->GetPlayerPool()->
		GetPlayerName(playerId), params[3]);
}

static cell AMX_NATIVE_CALL n_SetPlayerCheckpoint(AMX *amx, cell *params)
{
	CPlayer *pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if (pPlayer)
	{
		pPlayer->SetCheckpoint(amx_ctof(params[2]), amx_ctof(params[3]),
			amx_ctof(params[4]), amx_ctof(params[5]));

		return 1;
	}
	return 0;
}

static cell AMX_NATIVE_CALL n_DisablePlayerCheckpoint(AMX *amx, cell *params)
{
	CPlayer *pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if (pPlayer)
	{
		pPlayer->ToggleCheckpoint(FALSE);

		return 1;
	}
	return 0;
}

static cell AMX_NATIVE_CALL n_IsPlayerInCheckpoint(AMX *amx, cell *params)
{
	CPlayer *pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if (pPlayer)
	{
		return pPlayer->IsInCheckpoint();
	}
	return 0;
}

// native SetPlayerRaceCheckpoint(playerid, type, Float:x, Float:y, Float:z, Float:nextx, Float:nexty, Float:nextz, Float:size)
static cell AMX_NATIVE_CALL n_SetPlayerRaceCheckpoint(AMX *amx, cell *params)
{
	CPlayer *pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if (pPlayer)
	{
		pPlayer->SetRaceCheckpoint(params[2], amx_ctof(params[3]),
			amx_ctof(params[4]), amx_ctof(params[5]), amx_ctof(params[6]),
			amx_ctof(params[7]), amx_ctof(params[8]), amx_ctof(params[9]));

		return 1;
	}
	return 0;
}

static cell AMX_NATIVE_CALL n_DisablePlayerRaceCheckpoint(AMX *amx, cell *params)
{
	CPlayer *pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if (pPlayer)
	{
		pPlayer->ToggleRaceCheckpoint(FALSE);

		return 1;
	}
	return 0;
}

static cell AMX_NATIVE_CALL n_IsPlayerInRaceCheckpoint(AMX *amx, cell *params)
{
	CPlayer *pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if (pPlayer)
	{
		return pPlayer->IsInRaceCheckpoint();
	}
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerInterior(AMX *amx, cell *params)
{
	// TODO: SetPlayerInterior
	return 0;
}

// native GetPlayerInterior(playerid,interiorid)
static cell AMX_NATIVE_CALL n_GetPlayerInterior(AMX *amx, cell *params)
{
	CPlayer *pPlayer = pNetGame->GetPlayerPool()->GetAt((PLAYERID)params[1]);
	if (pPlayer)
	{
		return pPlayer->m_iInteriorId;
	}
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerAttachedObject(AMX *amx, cell *params)
{
	// TODO: SetPlayerAttachedObject
	return 0;
}

static cell AMX_NATIVE_CALL n_RemovePlayerAttachedObject(AMX *amx, cell *params)
{
	// TODO: RemovePlayerAttachedObject
	return 0;
}

static cell AMX_NATIVE_CALL n_IsPlayerAttachedObjectSlotUsed(AMX *amx, cell *params)
{
	// TODO: IsPlayerAttachedObjectSlotUsed
	return 0;
}

static cell AMX_NATIVE_CALL n_EditAttachedObject(AMX *amx, cell *params)
{
	// TODO: EditAttachedObject
	return 0;
}

static cell AMX_NATIVE_CALL n_SendClientCheck(AMX *amx, cell *params)
{
	// TODO: SendClientCheck
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerCameraLookAt(AMX *amx, cell *params)
{
	// TODO: SetPlayerCameraLookAt
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerCameraPos(AMX *amx, cell *params)
{
	// TODO: SetPlayerCameraPos
	return 0;
}

static cell AMX_NATIVE_CALL n_SetCameraBehindPlayer(AMX *amx, cell *params)
{
	// TODO: SetCameraBehindPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerCameraMode(AMX *amx, cell *params)
{
	// TODO: GetPlayerCameraMode
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerCameraAspectRatio(AMX *amx, cell *params)
{
	// TODO: GetPlayerCameraAspectRatio
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerCameraZoom(AMX *amx, cell *params)
{
	// TODO: GetPlayerCameraZoom
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerCameraPos(AMX *amx, cell *params)
{
	// TODO: GetPlayerCameraPos
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerCameraFrontVector(AMX *amx, cell *params)
{
	// TODO: GetPlayerCameraFrontVector
	return 0;
}

static cell AMX_NATIVE_CALL n_EnablePlayerCameraTarget(AMX *amx, cell *params)
{
	// TODO: EnablePlayerCameraTarget
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerCameraTargetObject(AMX *amx, cell *params)
{
	// TODO: GetPlayerCameraTargetObject
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerCameraTargetVehicle(AMX *amx, cell *params)
{
	// TODO: GetPlayerCameraTargetVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerCameraTargetPlayer(AMX *amx, cell *params)
{
	// TODO: GetPlayerCameraTargetPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerCameraTargetActor(AMX *amx, cell *params)
{
	// TODO: GetPlayerCameraTargetActor
	return 0;
}

static cell AMX_NATIVE_CALL n_AttachCameraToObject(AMX *amx, cell *params)
{
	// TODO: AttachCameraToObject
	return 0;
}

static cell AMX_NATIVE_CALL n_AttachCameraToPlayerObject(AMX *amx, cell *params)
{
	// TODO: AttachCameraToPlayerObject
	return 0;
}

static cell AMX_NATIVE_CALL n_InterpolateCameraPos(AMX *amx, cell *params)
{
	// TODO: InterpolateCameraPos
	return 0;
}

static cell AMX_NATIVE_CALL n_InterpolateCameraLookAt(AMX *amx, cell *params)
{
	// TODO: InterpolateCameraLookAt
	return 0;
}

static cell AMX_NATIVE_CALL n_TogglePlayerControllable(AMX *amx, cell *params)
{
	// TODO: TogglePlayerControllable
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerPlaySound(AMX *amx, cell *params)
{
	// TODO: PlayerPlaySound
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerScore(AMX *amx, cell *params)
{
	// TODO: SetPlayerScore
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerScore(AMX *amx, cell *params)
{
	// TODO: GetPlayerScore
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerFacingAngle(AMX *amx, cell *params)
{
	// TODO: SetPlayerFacingAngle
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerFacingAngle(AMX *amx, cell *params)
{
	// TODO: GetPlayerFacingAngle
	return 0;
}

static cell AMX_NATIVE_CALL n_GivePlayerMoney(AMX *amx, cell *params)
{
	// TODO: GivePlayerMoney
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerMoney(AMX *amx, cell *params)
{
	// TODO: GetPlayerMoney
	return 0;
}

static cell AMX_NATIVE_CALL n_ResetPlayerMoney(AMX *amx, cell *params)
{
	// TODO: ResetPlayerMoney
	return 0;
}

static cell AMX_NATIVE_CALL n_IsPlayerConnected(AMX *amx, cell *params)
{
	// TODO: IsPlayerConnected
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerState(AMX *amx, cell *params)
{
	// TODO: GetPlayerState
	return 0;
}

static cell AMX_NATIVE_CALL n_ResetPlayerWeapons(AMX *amx, cell *params)
{
	// TODO: ResetPlayerWeapons
	return 0;
}

static cell AMX_NATIVE_CALL n_GivePlayerWeapon(AMX *amx, cell *params)
{
	// TODO: GivePlayerWeapon
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerArmedWeapon(AMX *amx, cell *params)
{
	// TODO: SetPlayerArmedWeapon
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerIp(AMX *amx, cell *params)
{
	// TODO: GetPlayerIp
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerPing(AMX *amx, cell *params)
{
	// TODO: GetPlayerPing
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerWeapon(AMX *amx, cell *params)
{
	// TODO: GetPlayerWeapon
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerArmour(AMX *amx, cell *params)
{
	// TODO: SetPlayerArmour
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerArmour(AMX *amx, cell *params)
{
	// TODO: GetPlayerArmour
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerMapIcon(AMX *amx, cell *params)
{
	// TODO: SetPlayerMapIcon
	return 0;
}

static cell AMX_NATIVE_CALL n_RemovePlayerMapIcon(AMX *amx, cell *params)
{
	// TODO: RemovePlayerMapIcon
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerKeys(AMX *amx, cell *params)
{
	// TODO: GetPlayerKeys
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerMarkerForPlayer(AMX *amx, cell *params)
{
	// TODO: SetPlayerMarkerForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerAmmo(AMX *amx, cell *params)
{
	// TODO: GetPlayerAmmo
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerAmmo(AMX *amx, cell *params)
{
	// TODO: SetPlayerAmmo
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerTargetPlayer(AMX *amx, cell *params)
{
	// TODO: GetPlayerTargetPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerTargetActor(AMX *amx, cell *params)
{
	// TODO: GetPlayerTargetActor
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerWeaponData(AMX *amx, cell *params)
{
	// TODO: GetPlayerWeaponData
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerWeaponState(AMX *amx, cell *params)
{
	// TODO: GetPlayerWeaponState
	return 0;
}

static cell AMX_NATIVE_CALL n_AllowPlayerTeleport(AMX *amx, cell *params)
{
	// TODO: AllowPlayerTeleport
	return 0;
}

static cell AMX_NATIVE_CALL n_ForceClassSelection(AMX *amx, cell *params)
{
	// TODO: ForceClassSelection
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerWantedLevel(AMX *amx, cell *params)
{
	// TODO: SetPlayerWantedLevel
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerWantedLevel(AMX *amx, cell *params)
{
	// TODO: GetPlayerWantedLevel
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerFightingStyle(AMX *amx, cell *params)
{
	// TODO: GetPlayerFightingStyle
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerFightingStyle(AMX *amx, cell *params)
{
	// TODO: SetPlayerFightingStyle
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerVelocity(AMX *amx, cell *params)
{
	// TODO: GetPlayerVelocity
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerVelocity(AMX *amx, cell *params)
{
	// TODO: SetPlayerVelocity
	return 0;
}

static cell AMX_NATIVE_CALL n_IsPlayerInRangeOfPoint(AMX *amx, cell *params)
{
	// TODO: IsPlayerInRangeOfPoint
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerDistanceFromPoint(AMX *amx, cell *params)
{
	// TODO: GetPlayerDistanceFromPoint
	return 0;
}

static cell AMX_NATIVE_CALL n_IsPlayerStreamedIn(AMX *amx, cell *params)
{
	// TODO: IsPlayerStreamedIn
	return 0;
}

static cell AMX_NATIVE_CALL n_IsVehicleStreamedIn(AMX *amx, cell *params)
{
	// TODO: IsVehicleStreamedIn
	return 0;
}

static cell AMX_NATIVE_CALL n_IsActorStreamedIn(AMX *amx, cell *params)
{
	// TODO: IsActorStreamedIn
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerVirtualWorld(AMX *amx, cell *params)
{
	// TODO: SetPlayerVirtualWorld
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerVirtualWorld(AMX *amx, cell *params)
{
	// TODO: GetPlayerVirtualWorld
	return 0;
}

static cell AMX_NATIVE_CALL n_ShowPlayerNameTagForPlayer(AMX *amx, cell *params)
{
	// TODO: ShowPlayerNameTagForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_EnableStuntBonusForAll(AMX *amx, cell *params)
{
	// TODO: EnableStuntBonusForAll
	return 0;
}

static cell AMX_NATIVE_CALL n_EnableStuntBonusForPlayer(AMX *amx, cell *params)
{
	// TODO: EnableStuntBonusForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_TogglePlayerSpectating(AMX *amx, cell *params)
{
	// TODO: TogglePlayerSpectating
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerDrunkLevel(AMX *amx, cell *params)
{
	// TODO: GetPlayerDrunkLevel
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerDrunkLevel(AMX *amx, cell *params)
{
	// TODO: SetPlayerDrunkLevel
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerSpectateVehicle(AMX *amx, cell *params)
{
	// TODO: PlayerSpectateVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerSpectatePlayer(AMX *amx, cell *params)
{
	// TODO: PlayerSpectatePlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_ApplyAnimation(AMX *amx, cell *params)
{
	// TODO: ApplyAnimation
	return 0;
}

static cell AMX_NATIVE_CALL n_ClearAnimations(AMX *amx, cell *params)
{
	// TODO: ClearAnimations
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerAnimationIndex(AMX *amx, cell *params)
{
	// TODO: GetPlayerAnimationIndex
	return 0;
}

static cell AMX_NATIVE_CALL n_GetAnimationName(AMX *amx, cell *params)
{
	// TODO: GetAnimationName
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerSpecialAction(AMX *amx, cell *params)
{
	// TODO: SetPlayerSpecialAction
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerSpecialAction(AMX *amx, cell *params)
{
	// TODO: GetPlayerSpecialAction
	return 0;
}

static cell AMX_NATIVE_CALL n_StartRecordingPlayerData(AMX *amx, cell *params)
{
	// TODO: StartRecordingPlayerData
	return 0;
}

static cell AMX_NATIVE_CALL n_StopRecordingPlayerData(AMX *amx, cell *params)
{
	// TODO: StopRecordingPlayerData
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayCrimeReportForPlayer(AMX *amx, cell *params)
{
	// TODO: PlayCrimeReportForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayAudioStreamForPlayer(AMX *amx, cell *params)
{
	// TODO: PlayAudioStreamForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_StopAudioStreamForPlayer(AMX *amx, cell *params)
{
	// TODO: StopAudioStreamForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_RemoveBuildingForPlayer(AMX *amx, cell *params)
{
	// TODO: RemoveBuildingForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerShopName(AMX *amx, cell *params)
{
	// TODO: SetPlayerShopName
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerSkillLevel(AMX *amx, cell *params)
{
	// TODO: SetPlayerSkillLevel
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerChatBubble(AMX *amx, cell *params)
{
	// TODO: SetPlayerChatBubble
	return 0;
}

static cell AMX_NATIVE_CALL n_SelectTextDraw(AMX *amx, cell *params)
{
	// TODO: SelectTextDraw
	return 0;
}

static cell AMX_NATIVE_CALL n_CancelSelectTextDraw(AMX *amx, cell *params)
{
	// TODO: CancelSelectTextDraw
	return 0;
}

static cell AMX_NATIVE_CALL n_DisableRemoteVehicleCollisions(AMX *amx, cell *params)
{
	// TODO: DisableRemoteVehicleCollisions
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPVarInt(AMX *amx, cell *params)
{
	// TODO: SetPVarInt
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPVarString(AMX *amx, cell *params)
{
	// TODO: SetPVarString
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPVarFloat(AMX *amx, cell *params)
{
	// TODO: SetPVarFloat
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPVarInt(AMX *amx, cell *params)
{
	// TODO: GetPVarInt
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPVarString(AMX *amx, cell *params)
{
	// TODO: GetPVarString
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPVarFloat(AMX *amx, cell *params)
{
	// TODO: GetPVarFloat
	return 0;
}

static cell AMX_NATIVE_CALL n_DeletePVar(AMX *amx, cell *params)
{
	// TODO: DeletePVar
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPVarType(AMX *amx, cell *params)
{
	// TODO: GetPVarType
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPVarNameAtIndex(AMX *amx, cell *params)
{
	// TODO: GetPVarNameAtIndex
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPVarsUpperIndex(AMX *amx, cell *params)
{
	// TODO: GetPVarsUpperIndex
	return 0;
}

static cell AMX_NATIVE_CALL n_CreatePlayerTextDraw(AMX *amx, cell *params)
{
	// TODO: CreatePlayerTextDraw
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawSetString(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawSetString
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawLetterSize(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawLetterSize
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawTextSize(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawTextSize
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawAlignment(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawAlignment
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawColor(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawColor
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawUseBox(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawUseBox
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawBoxColor(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawBoxColor
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawSetShadow(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawSetShadow
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawSetOutline(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawSetOutline
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawBackgroundColor(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawBackgroundColor
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawFont(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawFont
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawSetProportional(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawSetProportional
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawSetSelectable(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawSetSelectable
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawSetPreviewModel(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawSetPreviewModel
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawSetPreviewRot(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawSetPreviewRot
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawSetPreviewVehCol(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawSetPreviewVehCol
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawShow(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawShow
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawHide(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawHide
	return 0;
}

static cell AMX_NATIVE_CALL n_PlayerTextDrawDestroy(AMX *amx, cell *params)
{
	// TODO: PlayerTextDrawDestroy
	return 0;
}

static cell AMX_NATIVE_CALL n_IsValidVehicle(AMX *amx, cell *params)
{
	// TODO: IsValidVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_CreateVehicle(AMX *amx, cell *params)
{
	// TODO: CreateVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_DestroyVehicle(AMX *amx, cell *params)
{
	// TODO: DestroyVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehiclePos(AMX *amx, cell *params)
{
	// TODO: GetVehiclePos
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehiclePos(AMX *amx, cell *params)
{
	// TODO: SetVehiclePos
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleZAngle(AMX *amx, cell *params)
{
	// TODO: GetVehicleZAngle
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleRotationQuat(AMX *amx, cell *params)
{
	// TODO: GetVehicleRotationQuat
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleDistanceFromPoint(AMX *amx, cell *params)
{
	// TODO: GetVehicleDistanceFromPoint
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehicleZAngle(AMX *amx, cell *params)
{
	// TODO: SetVehicleZAngle
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehicleParamsForPlayer(AMX *amx, cell *params)
{
	// TODO: SetVehicleParamsForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_ManualVehicleEngineAndLights(AMX *amx, cell *params)
{
	// TODO: ManualVehicleEngineAndLights
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehicleParamsEx(AMX *amx, cell *params)
{
	// TODO: SetVehicleParamsEx
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleParamsEx(AMX *amx, cell *params)
{
	// TODO: GetVehicleParamsEx
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehicleParamsCarDoors(AMX *amx, cell *params)
{
	// TODO: SetVehicleParamsCarDoors
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleParamsCarDoors(AMX *amx, cell *params)
{
	// TODO: GetVehicleParamsCarDoors
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehicleParamsCarWindows(AMX *amx, cell *params)
{
	// TODO: SetVehicleParamsCarWindows
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleParamsCarWindows(AMX *amx, cell *params)
{
	// TODO: GetVehicleParamsCarWindows
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehicleToRespawn(AMX *amx, cell *params)
{
	// TODO: SetVehicleToRespawn
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleModelInfo(AMX *amx, cell *params)
{
	// TODO: GetVehicleModelInfo
	return 0;
}

static cell AMX_NATIVE_CALL n_RepairVehicle(AMX *amx, cell *params)
{
	// TODO: RepairVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_AddVehicleComponent(AMX *amx, cell *params)
{
	// TODO: AddVehicleComponent
	return 0;
}

static cell AMX_NATIVE_CALL n_RemoveVehicleComponent(AMX *amx, cell *params)
{
	// TODO: RemoveVehicleComponent
	return 0;
}

static cell AMX_NATIVE_CALL n_ChangeVehicleColor(AMX *amx, cell *params)
{
	// TODO: ChangeVehicleColor
	return 0;
}

static cell AMX_NATIVE_CALL n_ChangeVehiclePaintjob(AMX *amx, cell *params)
{
	// TODO: ChangeVehiclePaintjob
	return 0;
}

static cell AMX_NATIVE_CALL n_LinkVehicleToInterior(AMX *amx, cell *params)
{
	// TODO: LinkVehicleToInterior
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehicleHealth(AMX *amx, cell *params)
{
	// TODO: SetVehicleHealth
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleHealth(AMX *amx, cell *params)
{
	// TODO: GetVehicleHealth
	return 0;
}

static cell AMX_NATIVE_CALL n_AttachTrailerToVehicle(AMX *amx, cell *params)
{
	// TODO: AttachTrailerToVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_DetachTrailerFromVehicle(AMX *amx, cell *params)
{
	// TODO: DetachTrailerFromVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_IsTrailerAttachedToVehicle(AMX *amx, cell *params)
{
	// TODO: IsTrailerAttachedToVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleTrailer(AMX *amx, cell *params)
{
	// TODO: GetVehicleTrailer
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehicleNumberPlate(AMX *amx, cell *params)
{
	// TODO: SetVehicleNumberPlate
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleModel(AMX *amx, cell *params)
{
	// TODO: GetVehicleModel
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleParamsSirenState(AMX *amx, cell *params)
{
	// TODO: GetVehicleParamsSirenState
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleComponentInSlot(AMX *amx, cell *params)
{
	// TODO: GetVehicleComponentInSlot
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleComponentType(AMX *amx, cell *params)
{
	// TODO: GetVehicleComponentType
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleVelocity(AMX *amx, cell *params)
{
	// TODO: GetVehicleVelocity
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehicleVelocity(AMX *amx, cell *params)
{
	// TODO: SetVehicleVelocity
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehicleAngularVelocity(AMX *amx, cell *params)
{
	// TODO: SetVehicleAngularVelocity
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleDamageStatus(AMX *amx, cell *params)
{
	// TODO: GetVehicleDamageStatus
	return 0;
}

static cell AMX_NATIVE_CALL n_UpdateVehicleDamageStatus(AMX *amx, cell *params)
{
	// TODO: UpdateVehicleDamageStatus
	return 0;
}

static cell AMX_NATIVE_CALL n_SetVehicleVirtualWorld(AMX *amx, cell *params)
{
	// TODO: SetVehicleVirtualWorld
	return 0;
}

static cell AMX_NATIVE_CALL n_GetVehicleVirtualWorld(AMX *amx, cell *params)
{
	// TODO: GetVehicleVirtualWorld
	return 0;
}

static cell AMX_NATIVE_CALL n_SendClientMessage(AMX *amx, cell *params)
{
	// TODO: SendClientMessage
	return 0;
}

static cell AMX_NATIVE_CALL n_SendClientMessageToAll(AMX *amx, cell *params)
{
	// TODO: SendClientMessageToAll
	return 0;
}

static cell AMX_NATIVE_CALL n_SendDeathMessage(AMX *amx, cell *params)
{
	// TODO: SendDeathMessage
	return 0;
}

static cell AMX_NATIVE_CALL n_SendDeathMessageToPlayer(AMX *amx, cell *params)
{
	// TODO: SendDeathMessageToPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_GameTextForAll(AMX *amx, cell *params)
{
	// TODO: GameTextForAll
	return 0;
}

static cell AMX_NATIVE_CALL n_GameTextForPlayer(AMX *amx, cell *params)
{
	// TODO: GameTextForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_SendPlayerMessageToPlayer(AMX *amx, cell *params)
{
	// TODO: SendPlayerMessageToPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_SendPlayerMessageToAll(AMX *amx, cell *params)
{
	// TODO: SendPlayerMessageToAll
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawCreate(AMX *amx, cell *params)
{
	// TODO: TextDrawCreate
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawSetString(AMX *amx, cell *params)
{
	// TODO: TextDrawSetString
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawLetterSize(AMX *amx, cell *params)
{
	// TODO: TextDrawLetterSize
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawTextSize(AMX *amx, cell *params)
{
	// TODO: TextDrawTextSize
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawAlignment(AMX *amx, cell *params)
{
	// TODO: TextDrawAlignment
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawColor(AMX *amx, cell *params)
{
	// TODO: TextDrawColor
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawUseBox(AMX *amx, cell *params)
{
	// TODO: TextDrawUseBox
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawBoxColor(AMX *amx, cell *params)
{
	// TODO: TextDrawBoxColor
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawSetShadow(AMX *amx, cell *params)
{
	// TODO: TextDrawSetShadow
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawSetOutline(AMX *amx, cell *params)
{
	// TODO: TextDrawSetOutline
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawBackgroundColor(AMX *amx, cell *params)
{
	// TODO: TextDrawBackgroundColor
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawFont(AMX *amx, cell *params)
{
	// TODO: TextDrawFont
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawSetProportional(AMX *amx, cell *params)
{
	// TODO: TextDrawSetProportional
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawSetSelectable(AMX *amx, cell *params)
{
	// TODO: TextDrawSetSelectable
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawSetPreviewModel(AMX *amx, cell *params)
{
	// TODO: TextDrawSetPreviewModel
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawSetPreviewRot(AMX *amx, cell *params)
{
	// TODO: TextDrawSetPreviewRot
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawSetPreviewVehCol(AMX *amx, cell *params)
{
	// TODO: TextDrawSetPreviewVehCol
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawShowForPlayer(AMX *amx, cell *params)
{
	// TODO: TextDrawShowForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawShowForAll(AMX *amx, cell *params)
{
	// TODO: TextDrawShowForAll
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawHideForPlayer(AMX *amx, cell *params)
{
	// TODO: TextDrawHideForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawHideForAll(AMX *amx, cell *params)
{
	// TODO: TextDrawHideForAll
	return 0;
}

static cell AMX_NATIVE_CALL n_TextDrawDestroy(AMX *amx, cell *params)
{
	// TODO: TextDrawDestroy
	return 0;
}

static cell AMX_NATIVE_CALL n_CreateObject(AMX *amx, cell *params)
{
	// TODO: CreateObject
	return 0;
}

static cell AMX_NATIVE_CALL n_AttachObjectToVehicle(AMX *amx, cell *params)
{
	// TODO: AttachObjectToVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_AttachPlayerObjectToVehicle(AMX *amx, cell *params)
{
	// TODO: AttachPlayerObjectToVehicle
	return 0;
}

static cell AMX_NATIVE_CALL n_AttachObjectToObject(AMX *amx, cell *params)
{
	// TODO: AttachObjectToObject
	return 0;
}

static cell AMX_NATIVE_CALL n_SetObjectPos(AMX *amx, cell *params)
{
	// TODO: SetObjectPos
	return 0;
}

static cell AMX_NATIVE_CALL n_SetObjectRot(AMX *amx, cell *params)
{
	// TODO: SetObjectRot
	return 0;
}

static cell AMX_NATIVE_CALL n_GetObjectPos(AMX *amx, cell *params)
{
	// TODO: GetObjectPos
	return 0;
}

static cell AMX_NATIVE_CALL n_GetObjectRot(AMX *amx, cell *params)
{
	// TODO: GetObjectRot
	return 0;
}

static cell AMX_NATIVE_CALL n_GetObjectModel(AMX *amx, cell *params)
{
	// TODO: GetObjectModel
	return 0;
}

static cell AMX_NATIVE_CALL n_SetObjectNoCameraCol(AMX *amx, cell *params)
{
	// TODO: SetObjectNoCameraCol
	return 0;
}

static cell AMX_NATIVE_CALL n_IsValidObject(AMX *amx, cell *params)
{
	// TODO: IsValidObject
	return 0;
}

static cell AMX_NATIVE_CALL n_DestroyObject(AMX *amx, cell *params)
{
	// TODO: DestroyObject
	return 0;
}

static cell AMX_NATIVE_CALL n_IsObjectMoving(AMX *amx, cell *params)
{
	// TODO: IsObjectMoving
	return 0;
}

static cell AMX_NATIVE_CALL n_MoveObject(AMX *amx, cell *params)
{
	// TODO: MoveObject
	return 0;
}

static cell AMX_NATIVE_CALL n_StopObject(AMX *amx, cell *params)
{
	// TODO: StopObject
	return 0;
}

static cell AMX_NATIVE_CALL n_EditObject(AMX *amx, cell *params)
{
	// TODO: EditObject
	return 0;
}

static cell AMX_NATIVE_CALL n_EditPlayerObject(AMX *amx, cell *params)
{
	// TODO: EditPlayerObject
	return 0;
}

static cell AMX_NATIVE_CALL n_SelectObject(AMX *amx, cell *params)
{
	// TODO: SelectObject
	return 0;
}

static cell AMX_NATIVE_CALL n_CancelEdit(AMX *amx, cell *params)
{
	// TODO: CancelEdit
	return 0;
}

static cell AMX_NATIVE_CALL n_SetObjectMaterial(AMX *amx, cell *params)
{
	// TODO: SetObjectMaterial
	return 0;
}

static cell AMX_NATIVE_CALL n_SetObjectMaterialText(AMX *amx, cell *params)
{
	// TODO: SetObjectMaterialText
	return 0;
}

static cell AMX_NATIVE_CALL n_CreatePlayerObject(AMX *amx, cell *params)
{
	// TODO: CreatePlayerObject
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerObjectPos(AMX *amx, cell *params)
{
	// TODO: SetPlayerObjectPos
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerObjectRot(AMX *amx, cell *params)
{
	// TODO: SetPlayerObjectRot
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerObjectPos(AMX *amx, cell *params)
{
	// TODO: GetPlayerObjectPos
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerObjectRot(AMX *amx, cell *params)
{
	// TODO: GetPlayerObjectRot
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerObjectModel(AMX *amx, cell *params)
{
	// TODO: GetPlayerObjectModel
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerObjectNoCameraCol(AMX *amx, cell *params)
{
	// TODO: SetPlayerObjectNoCameraCol
	return 0;
}

static cell AMX_NATIVE_CALL n_IsValidPlayerObject(AMX *amx, cell *params)
{
	// TODO: IsValidPlayerObject
	return 0;
}

static cell AMX_NATIVE_CALL n_DestroyPlayerObject(AMX *amx, cell *params)
{
	// TODO: DestroyPlayerObject
	return 0;
}

static cell AMX_NATIVE_CALL n_IsPlayerObjectMoving(AMX *amx, cell *params)
{
	// TODO: IsPlayerObjectMoving
	return 0;
}

static cell AMX_NATIVE_CALL n_MovePlayerObject(AMX *amx, cell *params)
{
	// TODO: MovePlayerObject
	return 0;
}

static cell AMX_NATIVE_CALL n_StopPlayerObject(AMX *amx, cell *params)
{
	// TODO: StopPlayerObject
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerObjectMaterial(AMX *amx, cell *params)
{
	// TODO: SetPlayerObjectMaterial
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerObjectMaterialText(AMX *amx, cell *params)
{
	// TODO: SetPlayerObjectMaterialText
	return 0;
}

static cell AMX_NATIVE_CALL n_AttachObjectToPlayer(AMX *amx, cell *params)
{
	// TODO: AttachObjectToPlayer
	return 0;
}

// native AttachPlayerObjectToPlayer(objectplayer, objectid, attachplayer, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:rX, Float:rY, Float:rZ)
static cell AMX_NATIVE_CALL n_AttachPlayerObjectToPlayer(AMX *amx, cell *params)
{
	logprintf("AttachPlayerObjectToPlayer : removed in 0.3. I can only attach global objects.");
	return 0;
}

static cell AMX_NATIVE_CALL n_SetObjectsDefaultCameraCol(AMX *amx, cell *params)
{
	// TODO: SetObjectsDefaultCameraCol
	return 0;
}

static cell AMX_NATIVE_CALL n_CreateActor(AMX *amx, cell *params)
{
	// TODO: CreateActor
	return 0;
}

static cell AMX_NATIVE_CALL n_DestroyActor(AMX *amx, cell *params)
{
	// TODO: DestroyActor
	return 0;
}

static cell AMX_NATIVE_CALL n_SetActorPos(AMX *amx, cell *params)
{
	// TODO: SetActorPos
	return 0;
}

static cell AMX_NATIVE_CALL n_GetActorPos(AMX *amx, cell *params)
{
	// TODO: GetActorPos
	return 0;
}

static cell AMX_NATIVE_CALL n_SetActorVirtualWorld(AMX *amx, cell *params)
{
	// TODO: SetActorVirtualWorld
	return 0;
}

static cell AMX_NATIVE_CALL n_GetActorVirtualWorld(AMX *amx, cell *params)
{
	// TODO: GetActorVirtualWorld
	return 0;
}

static cell AMX_NATIVE_CALL n_ApplyActorAnimation(AMX *amx, cell *params)
{
	// TODO: ApplyActorAnimation
	return 0;
}

static cell AMX_NATIVE_CALL n_ClearActorAnimations(AMX *amx, cell *params)
{
	// TODO: ClearActorAnimations
	return 0;
}

static cell AMX_NATIVE_CALL n_SetActorFacingAngle(AMX *amx, cell *params)
{
	// TODO: SetActorFacingAngle
	return 0;
}

static cell AMX_NATIVE_CALL n_GetActorFacingAngle(AMX *amx, cell *params)
{
	// TODO: GetActorFacingAngle
	return 0;
}

static cell AMX_NATIVE_CALL n_GetActorHealth(AMX *amx, cell *params)
{
	// TODO: GetActorHealth
	return 0;
}

static cell AMX_NATIVE_CALL n_SetActorHealth(AMX *amx, cell *params)
{
	// TODO: SetActorHealth
	return 0;
}

static cell AMX_NATIVE_CALL n_IsValidActor(AMX *amx, cell *params)
{
	// TODO: IsValidActor
	return 0;
}

static cell AMX_NATIVE_CALL n_SetActorInvulnerable(AMX *amx, cell *params)
{
	// TODO: SetActorInvulnerable
	return 0;
}

static cell AMX_NATIVE_CALL n_IsActorInvulnerable(AMX *amx, cell *params)
{
	// TODO: IsActorInvulnerable
	return 0;
}

static cell AMX_NATIVE_CALL n_CreateMenu(AMX *amx, cell *params)
{
	// TODO: CreateMenu
	return 0;
}

static cell AMX_NATIVE_CALL n_DestroyMenu(AMX *amx, cell *params)
{
	// TODO: DestroyMenu
	return 0;
}

static cell AMX_NATIVE_CALL n_AddMenuItem(AMX *amx, cell *params)
{
	// TODO: AddMenuItem
	return 0;
}

static cell AMX_NATIVE_CALL n_SetMenuColumnHeader(AMX *amx, cell *params)
{
	// TODO: SetMenuColumnHeader
	return 0;
}

static cell AMX_NATIVE_CALL n_ShowMenuForPlayer(AMX *amx, cell *params)
{
	// TODO: ShowMenuForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_HideMenuForPlayer(AMX *amx, cell *params)
{
	// TODO: HideMenuForPlayer
	return 0;
}

static cell AMX_NATIVE_CALL n_IsValidMenu(AMX *amx, cell *params)
{
	// TODO: IsValidMenu
	return 0;
}

static cell AMX_NATIVE_CALL n_DisableMenu(AMX *amx, cell *params)
{
	// TODO: DisableMenu
	return 0;
}

static cell AMX_NATIVE_CALL n_DisableMenuRow(AMX *amx, cell *params)
{
	// TODO: DisableMenuRow
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerMenu(AMX *amx, cell *params)
{
	// TODO: GetPlayerMenu
	return 0;
}

static cell AMX_NATIVE_CALL n_SetPlayerTime(AMX *amx, cell *params)
{
	// TODO: SetPlayerTime
	return 0;
}

static cell AMX_NATIVE_CALL n_TogglePlayerClock(AMX *amx, cell *params)
{
	// TODO: TogglePlayerClock
	return 0;
}

static cell AMX_NATIVE_CALL n_GetPlayerTime(AMX *amx, cell *params)
{
	// TODO: GetPlayerTime
	return 0;
}

static cell AMX_NATIVE_CALL n_HTTP(AMX *amx, cell *params)
{
	// TODO: HTTP
	return 0;
}

//----------------------------------------------------------------------------------

AMX_NATIVE_INFO custom_Natives[] =
{
	{ "gpci", n_gpci },
	{ "GetPlayerPoolSize", n_GetPlayerPoolSize },
	{ "GetVehiclePoolSize", n_GetVehiclePoolSize },
	{ "GetActorPoolSize", n_GetActorPoolSize },
	{ "print", n_print },
	{ "printf", n_printf },
	{ "format", n_format },
	{ "SetTimer", n_SetTimer },
	{ "KillTimer", n_KillTimer },
	{ "GetTickCount", n_GetTickCount },
	{ "GetMaxPlayers", n_GetMaxPlayers },
	{ "SetTimerEx", n_SetTimerEx },
	{ "LimitGlobalChatRadius", n_LimitGlobalChatRadius },
	{ "LimitPlayerMarkerRadius", n_LimitPlayerMarkerRadius },
	{ "SetWeather", n_SetWeather },
	{ "SetPlayerWeather", n_SetPlayerWeather },
	{ "CallRemoteFunction", n_CallRemoteFunction },
	{ "CallLocalFunction", n_CallLocalFunction },
	{ "VectorSize", n_VectorSize },
	{ "asin", n_asin },
	{ "acos", n_acos },
	{ "atan2", n_atan2 },
	{ "atan", n_atan },
	{ "SHA256_PassHash", n_SHA256_PassHash },
	{ "SetSVarInt", n_SetSVarInt },
	{ "SetSVarString", n_SetSVarString },
	{ "SetSVarFloat", n_SetSVarFloat },
	{ "GetSVarInt", n_GetSVarInt },
	{ "GetSVarString", n_GetSVarString },
	{ "GetSVarFloat", n_GetSVarFloat },
	{ "DeleteSVar", n_DeleteSVar },
	{ "GetSVarType", n_GetSVarType },
	{ "GetSVarNameAtIndex", n_GetSVarNameAtIndex },
	{ "GetSVarsUpperIndex", n_GetSVarsUpperIndex },
	{ "GameModeExit", n_GameModeExit },
	{ "SetGameModeText", n_SetGameModeText },
	{ "SetTeamCount", n_SetTeamCount },
	{ "AddPlayerClass", n_AddPlayerClass },
	{ "AddPlayerClassEx", n_AddPlayerClassEx },
	{ "AddStaticVehicle", n_AddStaticVehicle },
	{ "AddStaticVehicleEx", n_AddStaticVehicleEx },
	{ "AddStaticPickup", n_AddStaticPickup },
	{ "CreatePickup", n_CreatePickup },
	{ "DestroyPickup", n_DestroyPickup },
	{ "SetPlayerWorldBounds", n_SetPlayerWorldBounds },
	{ "ShowNameTags", n_ShowNameTags },
	{ "ShowPlayerMarkers", n_ShowPlayerMarkers },
	{ "SetWorldTime", n_SetWorldTime },
	{ "GetWeaponName", n_GetWeaponName },
	{ "EnableTirePopping", n_EnableTirePopping },
	{ "EnableVehicleFriendlyFire", n_EnableVehicleFriendlyFire },
	{ "AllowInteriorWeapons", n_AllowInteriorWeapons },
	{ "SetGravity", n_SetGravity },
	{ "GetGravity", n_GetGravity },
	{ "AllowAdminTeleport", n_AllowAdminTeleport },
	{ "SetDeathDropAmount", n_SetDeathDropAmount },
	{ "CreateExplosion", n_CreateExplosion },
	{ "CreateExplosionForPlayer", n_CreateExplosionForPlayer },
	{ "SetDisabledWeapons", n_SetDisabledWeapons },
	{ "UsePlayerPedAnims", n_UsePlayerPedAnims },
	{ "DisableInteriorEnterExits", n_DisableInteriorEnterExits },
	{ "SetNameTagDrawDistance", n_SetNameTagDrawDistance },
	{ "DisableNameTagLOS", n_DisableNameTagLOS },
	{ "ConnectNPC", n_ConnectNPC },
	{ "IsPlayerNPC", n_IsPlayerNPC },
	{ "Create3DTextLabel", n_Create3DTextLabel },
	{ "Delete3DTextLabel", n_Delete3DTextLabel },
	{ "Attach3DTextLabelToPlayer", n_Attach3DTextLabelToPlayer },
	{ "Attach3DTextLabelToVehicle", n_Attach3DTextLabelToVehicle },
	{ "Update3DTextLabelText", n_Update3DTextLabelText },
	{ "CreatePlayer3DTextLabel", n_CreatePlayer3DTextLabel },
	{ "DeletePlayer3DTextLabel", n_DeletePlayer3DTextLabel },
	{ "UpdatePlayer3DTextLabelText", n_UpdatePlayer3DTextLabelText },
	{ "ShowPlayerDialog", n_ShowPlayerDialog },
	{ "EnableZoneNames", n_EnableZoneNames },
	{ "GangZoneCreate", n_GangZoneCreate },
	{ "GangZoneDestroy", n_GangZoneDestroy },
	{ "GangZoneShowForPlayer", n_GangZoneShowForPlayer },
	{ "GangZoneShowForAll", n_GangZoneShowForAll },
	{ "GangZoneHideForPlayer", n_GangZoneHideForPlayer },
	{ "GangZoneHideForAll", n_GangZoneHideForAll },
	{ "GangZoneFlashForPlayer", n_GangZoneFlashForPlayer },
	{ "GangZoneFlashForAll", n_GangZoneFlashForAll },
	{ "GangZoneStopFlashForPlayer", n_GangZoneStopFlashForPlayer },
	{ "GangZoneStopFlashForAll", n_GangZoneStopFlashForAll },
	{ "IsPlayerAdmin", n_IsPlayerAdmin },
	{ "Kick", n_Kick },
	{ "Ban", n_Ban },
	{ "BanEx", n_BanEx },
	{ "SendRconCommand", n_SendRconCommand },
	{ "GetServerVarAsString", n_GetServerVarAsString },
	{ "GetServerVarAsInt", n_GetServerVarAsInt },
	{ "GetServerVarAsBool", n_GetServerVarAsBool },
	{ "GetConsoleVarAsString", n_GetConsoleVarAsString },
	{ "GetConsoleVarAsInt", n_GetConsoleVarAsInt },
	{ "GetConsoleVarAsBool", n_GetConsoleVarAsBool },
	{ "GetPlayerNetworkStats", n_GetPlayerNetworkStats },
	{ "GetNetworkStats", n_GetNetworkStats },
	{ "GetPlayerVersion", n_GetPlayerVersion },
	{ "BlockIpAddress", n_BlockIpAddress },
	{ "UnBlockIpAddress", n_UnBlockIpAddress },
	{ "GetServerTickRate", n_GetServerTickRate },
	{ "NetStats_GetConnectedTime", n_NetStats_GetConnectedTime },
	{ "NetStats_MessagesReceived", n_NetStats_MessagesReceived },
	{ "NetStats_BytesReceived", n_NetStats_BytesReceived },
	{ "NetStats_MessagesSent", n_NetStats_MessagesSent },
	{ "NetStats_BytesSent", n_NetStats_BytesSent },
	{ "NetStats_MessagesRecvPerSecond", n_NetStats_MessagesRecvPerSecond },
	{ "NetStats_PacketLossPercent", n_NetStats_PacketLossPercent },
	{ "NetStats_ConnectionStatus", n_NetStats_ConnectionStatus },
	{ "NetStats_GetIpPort", n_NetStats_GetIpPort },
	{ "SetSpawnInfo", n_SetSpawnInfo },
	{ "SpawnPlayer", n_SpawnPlayer },
	{ "SetPlayerTeam", n_SetPlayerTeam },
	{ "GetPlayerTeam", n_GetPlayerTeam },
	{ "SetPlayerName", n_SetPlayerName },
	{ "SetPlayerSkin", n_SetPlayerSkin },
	{ "GetPlayerSkin", n_GetPlayerSkin },
	{ "GetPlayerPos", n_GetPlayerPos },
	{ "SetPlayerPos", n_SetPlayerPos },
	{ "SetPlayerPosFindZ", n_SetPlayerPosFindZ },
	{ "GetPlayerLastShotVectors", n_GetPlayerLastShotVectors },
	{ "GetPlayerHealth", n_GetPlayerHealth },
	{ "SetPlayerHealth", n_SetPlayerHealth },
	{ "SetPlayerColor", n_SetPlayerColor },
	{ "GetPlayerColor", n_GetPlayerColor },
	{ "GetPlayerVehicleID", n_GetPlayerVehicleID },
	{ "GetPlayerVehicleSeat", n_GetPlayerVehicleSeat },
	{ "GetPlayerSurfingVehicleID", n_GetPlayerSurfingVehicleID },
	{ "GetPlayerSurfingObjectID", n_GetPlayerSurfingObjectID },
	{ "PutPlayerInVehicle", n_PutPlayerInVehicle },
	{ "RemovePlayerFromVehicle", n_RemovePlayerFromVehicle },
	{ "IsPlayerInVehicle", n_IsPlayerInVehicle },
	{ "IsPlayerInAnyVehicle", n_IsPlayerInAnyVehicle },
	{ "GetPlayerName", n_GetPlayerName },
	{ "SetPlayerCheckpoint", n_SetPlayerCheckpoint },
	{ "DisablePlayerCheckpoint", n_DisablePlayerCheckpoint },
	{ "IsPlayerInCheckpoint", n_IsPlayerInCheckpoint },
	{ "SetPlayerRaceCheckpoint", n_SetPlayerRaceCheckpoint },
	{ "DisablePlayerRaceCheckpoint", n_DisablePlayerRaceCheckpoint },
	{ "IsPlayerInRaceCheckpoint", n_IsPlayerInRaceCheckpoint },
	{ "SetPlayerInterior", n_SetPlayerInterior },
	{ "GetPlayerInterior", n_GetPlayerInterior },
	{ "SetPlayerAttachedObject", n_SetPlayerAttachedObject },
	{ "RemovePlayerAttachedObject", n_RemovePlayerAttachedObject },
	{ "SetPlayerAttachedObject", n_SetPlayerAttachedObject },
	{ "IsPlayerAttachedObjectSlotUsed", n_IsPlayerAttachedObjectSlotUsed },
	{ "EditAttachedObject", n_EditAttachedObject },
	{ "SendClientCheck", n_SendClientCheck },
	{ "SetPlayerCameraLookAt", n_SetPlayerCameraLookAt },
	{ "SetPlayerCameraPos", n_SetPlayerCameraPos },
	{ "SetCameraBehindPlayer", n_SetCameraBehindPlayer },
	{ "GetPlayerCameraMode", n_GetPlayerCameraMode },
	{ "GetPlayerCameraAspectRatio", n_GetPlayerCameraAspectRatio },
	{ "GetPlayerCameraZoom", n_GetPlayerCameraZoom },
	{ "GetPlayerCameraPos", n_GetPlayerCameraPos },
	{ "GetPlayerCameraFrontVector", n_GetPlayerCameraFrontVector },
	{ "EnablePlayerCameraTarget", n_EnablePlayerCameraTarget },
	{ "GetPlayerCameraTargetObject", n_GetPlayerCameraTargetObject },
	{ "GetPlayerCameraTargetVehicle", n_GetPlayerCameraTargetVehicle },
	{ "GetPlayerCameraTargetPlayer", n_GetPlayerCameraTargetPlayer },
	{ "GetPlayerCameraTargetActor", n_GetPlayerCameraTargetActor },
	{ "AttachCameraToObject", n_AttachCameraToObject },
	{ "AttachCameraToPlayerObject", n_AttachCameraToPlayerObject },
	{ "InterpolateCameraPos", n_InterpolateCameraPos },
	{ "InterpolateCameraLookAt", n_InterpolateCameraLookAt },
	{ "TogglePlayerControllable", n_TogglePlayerControllable },
	{ "PlayerPlaySound", n_PlayerPlaySound },
	{ "SetPlayerScore", n_SetPlayerScore },
	{ "GetPlayerScore", n_GetPlayerScore },
	{ "SetPlayerFacingAngle", n_SetPlayerFacingAngle },
	{ "GetPlayerFacingAngle", n_GetPlayerFacingAngle },
	{ "GivePlayerMoney", n_GivePlayerMoney },
	{ "GetPlayerMoney", n_GetPlayerMoney },
	{ "ResetPlayerMoney", n_ResetPlayerMoney },
	{ "IsPlayerConnected", n_IsPlayerConnected },
	{ "GetPlayerState", n_GetPlayerState },
	{ "ResetPlayerWeapons", n_ResetPlayerWeapons },
	{ "GivePlayerWeapon", n_GivePlayerWeapon },
	{ "SetPlayerArmedWeapon", n_SetPlayerArmedWeapon },
	{ "GetPlayerIp", n_GetPlayerIp },
	{ "GetPlayerPing", n_GetPlayerPing },
	{ "GetPlayerWeapon", n_GetPlayerWeapon },
	{ "SetPlayerArmour", n_SetPlayerArmour },
	{ "GetPlayerArmour", n_GetPlayerArmour },
	{ "SetPlayerMapIcon", n_SetPlayerMapIcon },
	{ "RemovePlayerMapIcon", n_RemovePlayerMapIcon },
	{ "GetPlayerKeys", n_GetPlayerKeys },
	{ "SetPlayerMarkerForPlayer", n_SetPlayerMarkerForPlayer },
	{ "GetPlayerAmmo", n_GetPlayerAmmo },
	{ "SetPlayerAmmo", n_SetPlayerAmmo },
	{ "GetPlayerTargetPlayer", n_GetPlayerTargetPlayer },
	{ "GetPlayerTargetActor", n_GetPlayerTargetActor },
	{ "GetPlayerWeaponData", n_GetPlayerWeaponData },
	{ "GetPlayerWeaponState", n_GetPlayerWeaponState },
	{ "AllowPlayerTeleport", n_AllowPlayerTeleport },
	{ "ForceClassSelection", n_ForceClassSelection },
	{ "SetPlayerWantedLevel", n_SetPlayerWantedLevel },
	{ "GetPlayerWantedLevel", n_GetPlayerWantedLevel },
	{ "GetPlayerFightingStyle", n_GetPlayerFightingStyle },
	{ "SetPlayerFightingStyle", n_SetPlayerFightingStyle },
	{ "GetPlayerVelocity", n_GetPlayerVelocity },
	{ "SetPlayerVelocity", n_SetPlayerVelocity },
	{ "IsPlayerInRangeOfPoint", n_IsPlayerInRangeOfPoint },
	{ "GetPlayerDistanceFromPoint", n_GetPlayerDistanceFromPoint },
	{ "IsPlayerStreamedIn", n_IsPlayerStreamedIn },
	{ "IsVehicleStreamedIn", n_IsVehicleStreamedIn },
	{ "IsActorStreamedIn", n_IsActorStreamedIn },
	{ "SetPlayerVirtualWorld", n_SetPlayerVirtualWorld },
	{ "GetPlayerVirtualWorld", n_GetPlayerVirtualWorld },
	{ "ShowPlayerNameTagForPlayer", n_ShowPlayerNameTagForPlayer },
	{ "EnableStuntBonusForAll", n_EnableStuntBonusForAll },
	{ "EnableStuntBonusForPlayer", n_EnableStuntBonusForPlayer },
	{ "TogglePlayerSpectating", n_TogglePlayerSpectating },
	{ "GetPlayerDrunkLevel", n_GetPlayerDrunkLevel },
	{ "SetPlayerDrunkLevel", n_SetPlayerDrunkLevel },
	{ "PlayerSpectateVehicle", n_PlayerSpectateVehicle },
	{ "PlayerSpectatePlayer", n_PlayerSpectatePlayer },
	{ "ApplyAnimation", n_ApplyAnimation },
	{ "ClearAnimations", n_ClearAnimations },
	{ "GetPlayerAnimationIndex", n_GetPlayerAnimationIndex },
	{ "GetAnimationName", n_GetAnimationName },
	{ "SetPlayerSpecialAction", n_SetPlayerSpecialAction },
	{ "GetPlayerSpecialAction", n_GetPlayerSpecialAction },
	{ "StartRecordingPlayerData", n_StartRecordingPlayerData },
	{ "StopRecordingPlayerData", n_StopRecordingPlayerData },
	{ "PlayCrimeReportForPlayer", n_PlayCrimeReportForPlayer },
	{ "PlayAudioStreamForPlayer", n_PlayAudioStreamForPlayer },
	{ "StopAudioStreamForPlayer", n_StopAudioStreamForPlayer },
	{ "RemoveBuildingForPlayer", n_RemoveBuildingForPlayer },
	{ "SetPlayerShopName", n_SetPlayerShopName },
	{ "SetPlayerSkillLevel", n_SetPlayerSkillLevel },
	{ "SetPlayerChatBubble", n_SetPlayerChatBubble },
	{ "SelectTextDraw", n_SelectTextDraw },
	{ "CancelSelectTextDraw", n_CancelSelectTextDraw },
	{ "DisableRemoteVehicleCollisions", n_DisableRemoteVehicleCollisions },
	{ "SetPVarInt", n_SetPVarInt },
	{ "SetPVarString", n_SetPVarString },
	{ "SetPVarFloat", n_SetPVarFloat },
	{ "GetPVarInt", n_GetPVarInt },
	{ "GetPVarString", n_GetPVarString },
	{ "GetPVarFloat", n_GetPVarFloat },
	{ "DeletePVar", n_DeletePVar },
	{ "GetPVarType", n_GetPVarType },
	{ "GetPVarNameAtIndex", n_GetPVarNameAtIndex },
	{ "GetPVarsUpperIndex", n_GetPVarsUpperIndex },
	{ "CreatePlayerTextDraw", n_CreatePlayerTextDraw },
	{ "PlayerTextDrawSetString", n_PlayerTextDrawSetString },
	{ "PlayerTextDrawLetterSize", n_PlayerTextDrawLetterSize },
	{ "PlayerTextDrawTextSize", n_PlayerTextDrawTextSize },
	{ "PlayerTextDrawAlignment", n_PlayerTextDrawAlignment },
	{ "PlayerTextDrawColor", n_PlayerTextDrawColor },
	{ "PlayerTextDrawUseBox", n_PlayerTextDrawUseBox },
	{ "PlayerTextDrawBoxColor", n_PlayerTextDrawBoxColor },
	{ "PlayerTextDrawSetShadow", n_PlayerTextDrawSetShadow },
	{ "PlayerTextDrawSetOutline", n_PlayerTextDrawSetOutline },
	{ "PlayerTextDrawBackgroundColor", n_PlayerTextDrawBackgroundColor },
	{ "PlayerTextDrawFont", n_PlayerTextDrawFont },
	{ "PlayerTextDrawSetProportional", n_PlayerTextDrawSetProportional },
	{ "PlayerTextDrawSetSelectable", n_PlayerTextDrawSetSelectable },
	{ "PlayerTextDrawSetPreviewModel", n_PlayerTextDrawSetPreviewModel },
	{ "PlayerTextDrawSetPreviewRot", n_PlayerTextDrawSetPreviewRot },
	{ "PlayerTextDrawSetPreviewVehCol", n_PlayerTextDrawSetPreviewVehCol },
	{ "PlayerTextDrawShow", n_PlayerTextDrawShow },
	{ "PlayerTextDrawHide", n_PlayerTextDrawHide },
	{ "PlayerTextDrawDestroy", n_PlayerTextDrawDestroy },
	{ "IsValidVehicle", n_IsValidVehicle },
	{ "CreateVehicle", n_CreateVehicle },
	{ "DestroyVehicle", n_DestroyVehicle },
	{ "GetVehiclePos", n_GetVehiclePos },
	{ "SetVehiclePos", n_SetVehiclePos },
	{ "GetVehicleZAngle", n_GetVehicleZAngle },
	{ "GetVehicleRotationQuat", n_GetVehicleRotationQuat },
	{ "GetVehicleDistanceFromPoint", n_GetVehicleDistanceFromPoint },
	{ "SetVehicleZAngle", n_SetVehicleZAngle },
	{ "SetVehicleParamsForPlayer", n_SetVehicleParamsForPlayer },
	{ "ManualVehicleEngineAndLights", n_ManualVehicleEngineAndLights },
	{ "SetVehicleParamsEx", n_SetVehicleParamsEx },
	{ "GetVehicleParamsEx", n_GetVehicleParamsEx },
	{ "SetVehicleParamsCarDoors", n_SetVehicleParamsCarDoors },
	{ "GetVehicleParamsCarDoors", n_GetVehicleParamsCarDoors },
	{ "SetVehicleParamsCarWindows", n_SetVehicleParamsCarWindows },
	{ "GetVehicleParamsCarWindows", n_GetVehicleParamsCarWindows },
	{ "SetVehicleToRespawn", n_SetVehicleToRespawn },
	{ "GetVehicleModelInfo", n_GetVehicleModelInfo },
	{ "RepairVehicle", n_RepairVehicle },
	{ "AddVehicleComponent", n_AddVehicleComponent },
	{ "RemoveVehicleComponent", n_RemoveVehicleComponent },
	{ "ChangeVehicleColor", n_ChangeVehicleColor },
	{ "ChangeVehiclePaintjob", n_ChangeVehiclePaintjob },
	{ "LinkVehicleToInterior", n_LinkVehicleToInterior },
	{ "SetVehicleHealth", n_SetVehicleHealth },
	{ "GetVehicleHealth", n_GetVehicleHealth },
	{ "AttachTrailerToVehicle", n_AttachTrailerToVehicle },
	{ "DetachTrailerFromVehicle", n_DetachTrailerFromVehicle },
	{ "IsTrailerAttachedToVehicle", n_IsTrailerAttachedToVehicle },
	{ "GetVehicleTrailer", n_GetVehicleTrailer },
	{ "SetVehicleNumberPlate", n_SetVehicleNumberPlate },
	{ "GetVehicleModel", n_GetVehicleModel },
	{ "GetVehicleParamsSirenState", n_GetVehicleParamsSirenState },
	{ "GetVehicleComponentInSlot", n_GetVehicleComponentInSlot },
	{ "GetVehicleComponentType", n_GetVehicleComponentType },
	{ "GetVehicleVelocity", n_GetVehicleVelocity },
	{ "SetVehicleVelocity", n_SetVehicleVelocity },
	{ "SetVehicleAngularVelocity", n_SetVehicleAngularVelocity },
	{ "GetVehicleDamageStatus", n_GetVehicleDamageStatus },
	{ "UpdateVehicleDamageStatus", n_UpdateVehicleDamageStatus },
	{ "SetVehicleVirtualWorld", n_SetVehicleVirtualWorld },
	{ "GetVehicleVirtualWorld", n_GetVehicleVirtualWorld },
	{ "SendClientMessage", n_SendClientMessage },
	{ "SendClientMessageToAll", n_SendClientMessageToAll },
	{ "SendDeathMessage", n_SendDeathMessage },
	{ "SendDeathMessageToPlayer", n_SendDeathMessageToPlayer },
	{ "GameTextForAll", n_GameTextForAll },
	{ "GameTextForPlayer", n_GameTextForPlayer },
	{ "SendPlayerMessageToPlayer", n_SendPlayerMessageToPlayer },
	{ "SendPlayerMessageToAll", n_SendPlayerMessageToAll },
	{ "TextDrawCreate", n_TextDrawCreate },
	{ "TextDrawSetString", n_TextDrawSetString },
	{ "TextDrawLetterSize", n_TextDrawLetterSize },
	{ "TextDrawTextSize", n_TextDrawTextSize },
	{ "TextDrawAlignment", n_TextDrawAlignment },
	{ "TextDrawColor", n_TextDrawColor },
	{ "TextDrawUseBox", n_TextDrawUseBox },
	{ "TextDrawBoxColor", n_TextDrawBoxColor },
	{ "TextDrawSetShadow", n_TextDrawSetShadow },
	{ "TextDrawSetOutline", n_TextDrawSetOutline },
	{ "TextDrawBackgroundColor", n_TextDrawBackgroundColor },
	{ "TextDrawFont", n_TextDrawFont },
	{ "TextDrawSetProportional", n_TextDrawSetProportional },
	{ "TextDrawSetSelectable", n_TextDrawSetSelectable },
	{ "TextDrawSetPreviewModel", n_TextDrawSetPreviewModel },
	{ "TextDrawSetPreviewRot", n_TextDrawSetPreviewRot },
	{ "TextDrawSetPreviewVehCol", n_TextDrawSetPreviewVehCol },
	{ "TextDrawShowForPlayer", n_TextDrawShowForPlayer },
	{ "TextDrawShowForAll", n_TextDrawShowForAll },
	{ "TextDrawHideForPlayer", n_TextDrawHideForPlayer },
	{ "TextDrawHideForAll", n_TextDrawHideForAll },
	{ "TextDrawDestroy", n_TextDrawDestroy },
	{ "CreateObject", n_CreateObject },
	{ "AttachObjectToVehicle", n_AttachObjectToVehicle },
	{ "AttachPlayerObjectToVehicle", n_AttachPlayerObjectToVehicle },
	{ "AttachObjectToObject", n_AttachObjectToObject },
	{ "SetObjectPos", n_SetObjectPos },
	{ "SetObjectRot", n_SetObjectRot },
	{ "GetObjectPos", n_GetObjectPos },
	{ "GetObjectRot", n_GetObjectRot },
	{ "GetObjectModel", n_GetObjectModel },
	{ "SetObjectNoCameraCol", n_SetObjectNoCameraCol },
	{ "IsValidObject", n_IsValidObject },
	{ "DestroyObject", n_DestroyObject },
	{ "IsObjectMoving", n_IsObjectMoving },
	{ "MoveObject", n_MoveObject },
	{ "StopObject", n_StopObject },
	{ "EditObject", n_EditObject },
	{ "EditPlayerObject", n_EditPlayerObject },
	{ "SelectObject", n_SelectObject },
	{ "CancelEdit", n_CancelEdit },
	{ "SetObjectMaterial", n_SetObjectMaterial },
	{ "SetObjectMaterialText", n_SetObjectMaterialText },
	{ "CreatePlayerObject", n_CreatePlayerObject },
	{ "SetPlayerObjectPos", n_SetPlayerObjectPos },
	{ "SetPlayerObjectRot", n_SetPlayerObjectRot },
	{ "GetPlayerObjectPos", n_GetPlayerObjectPos },
	{ "GetPlayerObjectRot", n_GetPlayerObjectRot },
	{ "GetPlayerObjectModel", n_GetPlayerObjectModel },
	{ "SetPlayerObjectNoCameraCol", n_SetPlayerObjectNoCameraCol },
	{ "IsValidPlayerObject", n_IsValidPlayerObject },
	{ "DestroyPlayerObject", n_DestroyPlayerObject },
	{ "IsPlayerObjectMoving", n_IsPlayerObjectMoving },
	{ "MovePlayerObject", n_MovePlayerObject },
	{ "StopPlayerObject", n_StopPlayerObject },
	{ "SetPlayerObjectMaterial", n_SetPlayerObjectMaterial },
	{ "SetPlayerObjectMaterialText", n_SetPlayerObjectMaterialText },
	{ "AttachObjectToPlayer", n_AttachObjectToPlayer },
	{ "AttachPlayerObjectToPlayer", n_AttachPlayerObjectToPlayer },
	{ "SetObjectsDefaultCameraCol", n_SetObjectsDefaultCameraCol },
	{ "CreateActor", n_CreateActor },
	{ "DestroyActor", n_DestroyActor },
	{ "SetActorPos", n_SetActorPos },
	{ "GetActorPos", n_GetActorPos },
	{ "SetActorVirtualWorld", n_SetActorVirtualWorld },
	{ "GetActorVirtualWorld", n_GetActorVirtualWorld },
	{ "ApplyActorAnimation", n_ApplyActorAnimation },
	{ "ClearActorAnimations", n_ClearActorAnimations },
	{ "SetActorFacingAngle", n_SetActorFacingAngle },
	{ "GetActorFacingAngle", n_GetActorFacingAngle },
	{ "GetActorHealth", n_GetActorHealth },
	{ "SetActorHealth", n_SetActorHealth },
	{ "IsValidActor", n_IsValidActor },
	{ "SetActorInvulnerable", n_SetActorInvulnerable },
	{ "IsActorInvulnerable", n_IsActorInvulnerable },
	{ "CreateMenu", n_CreateMenu },
	{ "DestroyMenu", n_DestroyMenu },
	{ "AddMenuItem", n_AddMenuItem },
	{ "SetMenuColumnHeader", n_SetMenuColumnHeader },
	{ "ShowMenuForPlayer", n_ShowMenuForPlayer },
	{ "HideMenuForPlayer", n_HideMenuForPlayer },
	{ "IsValidMenu", n_IsValidMenu },
	{ "DisableMenu", n_DisableMenu },
	{ "DisableMenuRow", n_DisableMenuRow },
	{ "GetPlayerMenu", n_GetPlayerMenu },
	{ "SetPlayerTime", n_SetPlayerTime },
	{ "TogglePlayerClock", n_TogglePlayerClock },
	{ "GetPlayerTime", n_GetPlayerTime },
	{ "HTTP", n_HTTP },

	{ NULL, NULL }
};

//----------------------------------------------------------------------------------

int amx_CustomInit(AMX *amx)
{
  return amx_Register(amx, custom_Natives, -1);
}

//----------------------------------------------------------------------------------