diff --git a/YSF.dll b/YSF.dll
deleted file mode 100644
index c9acc9f..0000000
Binary files a/YSF.dll and /dev/null differ
diff --git a/YSF.rar b/YSF.rar
deleted file mode 100644
index a4a374e..0000000
Binary files a/YSF.rar and /dev/null differ
diff --git a/YSF.sln.old b/YSF.sln.old
deleted file mode 100644
index b53cf41..0000000
--- a/YSF.sln.old
+++ /dev/null
@@ -1,20 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 10.00
-# Visual Studio 2013
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "YSF", "YSF.vcxproj", "{0843F08F-F40F-4B9B-1D29-394309558029}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{0843F08F-F40F-4B9B-1D29-394309558029}.Debug|Win32.ActiveCfg = Debug|Win32
-		{0843F08F-F40F-4B9B-1D29-394309558029}.Debug|Win32.Build.0 = Debug|Win32
-		{0843F08F-F40F-4B9B-1D29-394309558029}.Release|Win32.ActiveCfg = Release|Win32
-		{0843F08F-F40F-4B9B-1D29-394309558029}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal
diff --git a/YSF.suo.old b/YSF.suo.old
deleted file mode 100644
index 93a6ba5..0000000
Binary files a/YSF.suo.old and /dev/null differ
diff --git a/filterscripts/YSF_examples.pwn b/filterscripts/YSF_examples.pwn
new file mode 100644
index 0000000..27d8ec1
--- /dev/null
+++ b/filterscripts/YSF_examples.pwn
@@ -0,0 +1,1011 @@
+#include <a_samp>
+#define FILTERSCRIPT
+#include <zcmd>
+#include <sscanf2>
+#include <YSF>
+#tryinclude <streamer>
+
+new
+	g_szFormatString[4096], tmp[4096];
+
+#define strcatf(%1,%3) \
+    strcat(%1, (format(g_szFormatString, sizeof(g_szFormatString), %3), g_szFormatString))
+
+#define isnull(%1) \
+	((!(%1[0])) || (((%1[0]) == '\1') && (!(%1[1]))))
+
+public OnFilterScriptInit()
+{
+
+/*
+	AllowNickNameCharacter('!', true);
+	AllowNickNameCharacter('"', true);
+	AllowNickNameCharacter('#', true);
+	AllowNickNameCharacter('&', true);
+	AllowNickNameCharacter('*', true);
+	AllowNickNameCharacter('+', true);
+	AllowNickNameCharacter(',', true);
+	AllowNickNameCharacter('-', true);
+	AllowNickNameCharacter(':', true);
+	AllowNickNameCharacter(';', true);
+	AllowNickNameCharacter('<', true);
+	AllowNickNameCharacter('>', true);
+	AllowNickNameCharacter('?', true);
+	AllowNickNameCharacter('{', true);
+	AllowNickNameCharacter('|', true);
+	AllowNickNameCharacter('}', true);
+	AllowNickNameCharacter('~', true);
+*/
+	return 1;
+}
+
+CMD:serversettings(playerid, params[])
+{
+	new showplayermarkes, shownametags, stuntbonus, useplayerpedanims, bLimitchatradius, disableinteriorenterexits, nametaglos,
+	    manualvehicleengine, limitplayermarkers, vehiclefriendlyfire, defaultcameracollision, Float:fGlobalchatradius, Float:fNameTagDrawDistance, Float:fPlayermarkerslimit;
+	    
+	GetServerSettings(showplayermarkes, shownametags, stuntbonus, useplayerpedanims, bLimitchatradius, disableinteriorenterexits, nametaglos,
+		manualvehicleengine, limitplayermarkers, vehiclefriendlyfire, defaultcameracollision, fGlobalchatradius, fNameTagDrawDistance, fPlayermarkerslimit);
+
+	new dir[128];
+	GetRecordingDirectory(dir, sizeof(dir));
+
+	SendClientMessagef(playerid, -1, "markers = %d, nametags = %d, stuntbonus = %d, playerpedanims = %d, limitcharadius = %d, disableinteriorenter = %d, nametaglos = %d", showplayermarkes, shownametags, stuntbonus, useplayerpedanims, bLimitchatradius, disableinteriorenterexits, nametaglos);
+	SendClientMessagef(playerid, -1, "manuale = %d, limitmarkers = %d, vfriendlyfire = %d, dcamcol: %d, gchatr = %.2f, namedd = %.2f, pmarkerlimit = %.2f", manualvehicleengine, limitplayermarkers, vehiclefriendlyfire, defaultcameracollision, fGlobalchatradius, fNameTagDrawDistance, fPlayermarkerslimit);
+	SendClientMessagef(playerid, -1, "number of timers = %d, recording directory = %s", GetRunningTimers(), dir);
+	return 1;
+}
+
+CMD:setrecdir(playerid, params[])
+{
+    SetRecordingDirectory(params); // eg. "filterscripts", "scriptfiles", "npcmodes\recordings"
+	SendClientMessagef(playerid, -1, "SetRecordingDirectory = %s", params);
+	return 1;
+}
+
+CMD:ysftickrate(playerid, params[])
+{
+	new ticks;
+	if(sscanf(params, "d", ticks)) return SendClientMessagef(playerid, 0xFF0000AA, "USAGE: /ysftickrate <ticks> = %d", YSF_GetTickRate());
+
+	YSF_SetTickRate(ticks);
+	SendClientMessagef(playerid, -1, "YSF_Tickrate = %d", ticks);
+	return 1;
+}
+
+CMD:restarttime(playerid, params[])
+{
+	new Float:fTime;
+	if(sscanf(params, "f", fTime)) return SendClientMessagef(playerid, 0xFF0000AA, "USAGE: /restarttime <time in milliseconds> = %.4f", GetModeRestartTime());
+
+	SetModeRestartTime(fTime);
+	SendClientMessagef(playerid, -1, "restart time = %.4f", fTime);
+	return 1;
+}
+
+CMD:maxplayers(playerid, params[])
+{
+	new maxplayers;
+	if(sscanf(params, "d", maxplayers)) return SendClientMessagef(playerid, 0xFF0000AA, "USAGE: /maxplayers <maxplayers> = %d", GetMaxPlayers());
+
+	SetMaxPlayers(maxplayers);
+	SendClientMessagef(playerid, -1, "maxplayers = %d", maxplayers);
+	return 1;
+}
+
+CMD:maxnpcs(playerid, params[])
+{
+	new maxnpcs;
+	if(sscanf(params, "d", maxnpcs)) return SendClientMessagef(playerid, 0xFF0000AA, "USAGE: /maxnpcs <maxnpcs> = %d", GetServerVarAsInt("maxnpc"));
+
+	SetMaxNPCs(maxnpcs);
+	SendClientMessagef(playerid, -1, "maxplayers = %d", maxnpcs);
+	return 1;
+}
+
+CMD:listfs(playerid, params[])
+{
+	new scriptname[256];
+	for(new i; i != 16; i++)
+	{
+		GetFilterScriptName(i, scriptname);
+		if(isnull(scriptname)) continue; // If no FS
+
+		SendClientMessagef(playerid, -1, "%d. - %s", i, scriptname);
+	}
+	return 1;
+}
+
+CMD:allownamechar(playerid, params[])
+{
+	new character, bool:allow;
+	if(sscanf(params, "cd", character, bool:allow)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /allownamechar <character> <allow>");
+
+	AllowNickNameCharacter(character, allow);
+	SendClientMessagef(playerid, -1, "%c = %d", character, allow);
+	return 1;
+}
+
+CMD:isnamechar(playerid, params[])
+{
+	new character;
+	if(sscanf(params, "c", character)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /isnamechar <character>");
+
+	SendClientMessagef(playerid, -1, "%c = %d", character, IsNickNameCharacterAllowed(character));
+	return 1;
+}
+
+CMD:classinfo(playerid, params[])
+{
+	new classid, teamid, modelid, Float:fX, Float:fY, Float:fZ, Float:fAngle, weapon[3], weapon_ammo[3];
+	if(sscanf(params, "d", classid)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /classinfo <classid>");
+	if(!(0 <= classid <= GetAvailableClasses())) return SendClientMessagef(playerid, 0xFF0000AA, "ERROR: Wrong ID! 0 - %d", GetAvailableClasses());
+
+	GetPlayerClass(classid, teamid, modelid, fX, fY, fZ, fAngle, weapon[0], weapon_ammo[0], weapon[1], weapon_ammo[1], weapon[2], weapon_ammo[2]);
+	SendClientMessagef(playerid, -1, "{FF0000}class ID: %d {FFFFFF}- teamid: %d, skinid: %d, spawn: %.4f, %.4f, %.4f, %.4f", classid, teamid, modelid, fX, fY, fZ, fAngle);
+	SendClientMessagef(playerid, -1, "weapon1: %d, %d, weapon2: %d, %d, weapon3: %d, %d", weapon[0], weapon_ammo[0], weapon[1], weapon_ammo[1], weapon[2], weapon_ammo[2]);
+	return 1;
+}
+
+CMD:scoreupdate(playerid, params[])
+{
+	new update;
+	if(sscanf(params, "d", update)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /scoreupdate <update>");
+
+    TogglePlayerScoresPingsUpdate(playerid, !!update);
+	SendClientMessagef(playerid, -1, "TogglePlayerScoresPingsUpdate = %d", update);
+	return 1;
+}
+
+CMD:fakeping(playerid, params[])
+{
+	new fakeping;
+	if(sscanf(params, "d", fakeping)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /fakeping <value> (-1 = disable)");
+
+	if(fakeping == -1)
+	{
+		TogglePlayerFakePing(playerid, false);
+	}
+	else
+	{
+        TogglePlayerFakePing(playerid, true);
+        SetPlayerFakePing(playerid, fakeping);
+	}
+	SendClientMessagef(playerid, -1, "fakeping = %d", fakeping);
+	return 1;
+}
+
+CMD:hidefromquery(playerid, params[])
+{
+	new update;
+	if(sscanf(params, "d", update)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /hidefromquery <hide>");
+
+    TogglePlayerOnPlayerList(playerid, !update);
+	SendClientMessagef(playerid, -1, "TogglePlayerOnPlayerList = %d", !update);
+	return 1;
+}
+
+CMD:timeouttime(playerid, params[])
+{
+	new playertwo, time;
+	if(sscanf(params, "ud", playertwo, time)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /timeouttime <playertwo> <time>");
+
+	SetTimeoutTime(playertwo, time);
+	SendClientMessagef(playerid, -1, "timeout %s(%d) = %d", pName(playertwo), playertwo, time);
+	return 1;
+}
+
+CMD:mygrav(playerid, params[])
+{
+	new Float:gravity;
+	if(sscanf(params, "f", gravity)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /mygrav <Float:gravity>");
+
+    SendClientMessagef(playerid, -1, "gravity has been changed to %.3f; old has %.3f", gravity, GetPlayerGravity(playerid));
+	SetPlayerGravity(playerid, gravity);
+	return 1;
+}
+
+CMD:myteamforplayer(playerid, params[])
+{
+	new playertwo, teamid;
+	if(sscanf(params, "ud", playertwo, teamid)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /myteamforplayer <playertwo> <teamid>");
+
+	SetPlayerTeamForPlayer(playertwo, playerid, teamid);
+	SendClientMessagef(playerid, -1, "%s(%d) -> %s(%d) = %d", pName(playerid), playerid, pName(playertwo), playertwo, teamid);
+	return 1;
+}
+
+CMD:nameforme(playerid, params[])
+{
+	new playertwo, szName[24];
+	if(sscanf(params, "us[24]", playertwo, szName)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /nameforme <playertwo> <name>");
+
+	SetPlayerNameForPlayer(playerid, playertwo, szName);
+	return 1;
+}
+
+CMD:skinforme(playerid, params[])
+{
+	new playertwo, skinid;
+	if(sscanf(params, "ud", playertwo, skinid)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /nameforme <playertwo> <skinid>");
+
+	SetPlayerSkinForPlayer(playerid, playertwo, skinid);
+	return 1;
+}
+
+CMD:styleforme(playerid, params[])
+{
+	new playertwo, skinid;
+	if(sscanf(params, "ud", playertwo, skinid)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /nameforme <playertwo> <style>");
+
+	SetPlayerFightStyleForPlayer(playerid, playertwo, skinid);
+	return 1;
+}
+
+CMD:posforme(playerid, params[])
+{
+	new playertwo, bool:forcesync;
+	if(sscanf(params, "uD(1)", playertwo, forcesync)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /posforme <playertwo> <forcesync = 1>");
+
+	new Float:x, Float:y, Float:z;
+	GetPlayerPos(playerid, x, y, z);
+	SetPlayerPosForPlayer(playerid, playertwo, x + 1.0, y, z, forcesync);
+	return 1;
+}
+
+CMD:quatforme(playerid, params[])
+{
+	new playertwo, bool:forcesync, Float:w, Float:x, Float:y, Float:z;
+	if(sscanf(params, "uffffD(1)", playertwo, w, x, y, z, forcesync)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /quatforme <playertwo> <w> <x - SetPlayerFacingAngle> <y> <z> <forcesync = 1>");
+
+	// Change X if you want to use something similar like SetPlayerFacingAngle - just you need to convert euler angles to quaternion
+	SetPlayerRotationQuatForPlayer(playerid, playertwo, w, x, y, z, forcesync);
+	return 1;
+}
+
+CMD:shotme(playerid, params[])
+{
+	new playertwo;
+	if(sscanf(params, "u", playertwo)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /shotme <playertwo>");
+
+	new Float:x, Float:y, Float:z;
+	GetPlayerPos(playertwo, x, y, z);
+	SendBulletData(playertwo, playerid, BULLET_HIT_TYPE_PLAYER, GetPlayerWeapon(playerid), x, y, z, 0.0, 0.0, 0.0, 0.1, 0.1, 0.1);
+	return 1;
+}
+
+CMD:showplayer(playerid, params[])
+{
+	new playertwo;
+	if(sscanf(params, "u", playertwo)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /showplayer <playertwo>");
+
+	ShowPlayerForPlayer(playerid, playertwo);
+	SendClientMessagef(playerid, -1, "show player %s(%d)", pName(playertwo), playertwo);
+	return 1;
+}
+
+CMD:hideplayer(playerid, params[])
+{
+	new playertwo;
+	if(sscanf(params, "u", playertwo)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /hideplayer <playertwo>");
+
+	HidePlayerForPlayer(playerid, playertwo);
+	SendClientMessagef(playerid, -1, "show player %s(%d)", pName(playertwo), playertwo);
+	return 1;
+}
+
+CMD:spawnforworld(playerid, params[])
+{
+	new playertwo;
+	if(sscanf(params, "u", playertwo)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /spawnforworld <playertwo>");
+
+	SpawnForWorld(playertwo);
+	return 1;
+}
+
+CMD:broadcastdeath(playerid, params[])
+{
+	new playertwo;
+	if(sscanf(params, "u", playertwo)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /broadcastdeath <playertwo>");
+
+	BroadcastDeath(playertwo);
+	return 1;
+}
+
+CMD:psyncdata(playerid, params[])
+{
+	new player1;
+	if(sscanf(params, "u", player1)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /psyncdata <playerid>");
+
+	new
+	    Float:x, Float:y, Float:z, Float:qw, Float:qx, Float:qy, Float:qz, teamid, modelid, Float:fX, Float:fY, Float:fZ, Float:fAngle, weapon[3], weapon_ammo[3],
+	    Float:fCP[4], Float:fRaceCP[7], Float:fBounds[4];
+
+	GetPlayerSurfingOffsets(player1, x, y, z);
+	GetPlayerRotationQuat(player1, qw, qx, qy, qz);
+	GetSpawnInfo(player1, teamid, modelid, fX, fY, fZ, fAngle, weapon[0], weapon_ammo[0], weapon[1], weapon_ammo[1], weapon[2], weapon_ammo[2]);
+	GetPlayerCheckpoint(player1, fCP[0], fCP[1], fCP[2], fCP[3]);
+	GetPlayerRaceCheckpoint(player1, fRaceCP[0], fRaceCP[1], fRaceCP[2], fRaceCP[3], fRaceCP[4], fRaceCP[5], fRaceCP[6]);
+	GetPlayerWorldBounds(player1, fBounds[0], fBounds[1], fBounds[2], fBounds[3]);
+
+    tmp[0] = EOS;
+	strcatf(tmp, "siren: %d, gear: %d, reactor: %d, trainspeed: %f, zaim: %f, surf: %f, %f, %f\n", GetPlayerSirenState(player1), GetPlayerLandingGearState(player1), GetPlayerHydraReactorAngle(player1), GetPlayerTrainSpeed(player1), GetPlayerZAim(player1), x, y, z);
+	strcatf(tmp, "server gravity: %.3f, quat: %f, %f, %f, %f, weather: %d, inmodshop: %d, cameratarget: %d\n", GetGravity(), qw, qx, qy, qz, GetPlayerWeather(player1), IsPlayerInModShop(player1), IsPlayerCameraTargetEnabled(player1));
+	strcatf(tmp, "teamid: %d, skinid: %d, spawn: %.4f, %.4f, %.4f, %.4f, spawned: %d\n", teamid, modelid, fX, fY, fZ, fAngle, IsPlayerSpawned(player1));
+	strcatf(tmp, "weapon1: %d, %d, weapon2: %d, %d, weapon3: %d, %d\n", weapon[0], weapon_ammo[0], weapon[1], weapon_ammo[1], weapon[2], weapon_ammo[2]);
+	strcatf(tmp, "specid: %d, spectype: %d, \n", GetPlayerSpectateID(player1), GetPlayerSpectateType(player1));
+	strcatf(tmp, "checkpoint %d: %f, %f, %f, size: %f\n", IsPlayerCheckpointActive(player1), fCP[0], fCP[1], fCP[2], fCP[3]);
+	strcatf(tmp, "race checkpoint %d: %f, %f, %f, next: %f, %f, %f, size: %f\n", IsPlayerRaceCheckpointActive(player1), fRaceCP[0], fRaceCP[1], fRaceCP[2], fRaceCP[3], fRaceCP[4], fRaceCP[5], fRaceCP[6]);
+	strcatf(tmp, "worldbounds: %f, %f, %f, %f, gravity: %.3f, widescreen: %d, surfplayerobject: %d\n", fBounds[0], fBounds[1], fBounds[2], fBounds[3], GetPlayerGravity(player1), IsPlayerWidescreenToggled(player1), GetPlayerSurfingPlayerObjectID(player1));
+	strcatf(tmp, "last synced - vehicle: %d, trailer: %d, pause: %d, controllable: %d\n", GetPlayerLastSyncedVehicleID(player1), GetPlayerLastSyncedTrailerID(player1), GetPlayerPausedTime(player1), IsPlayerControllable(player1));
+
+	new str[64];
+	format(str, sizeof(str), "Info - YSF - {%06x}%s(%d)", GetPlayerColor(player1) >>> 8, pName(player1), player1);
+	ShowPlayerDialog(playerid, 5000, DIALOG_STYLE_MSGBOX, str, tmp, "Ok");
+	return 1;
+}
+
+CMD:actorinfo(playerid, params[])
+{
+	new actorid, skinid, Float:x, Float:y, Float:z, Float:a, animlib[32], animname[32], Float:fDelta, loop, lockx, locky, freeze, time;
+	if(sscanf(params, "u", actorid)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /actorinfo <actorid>");
+	if(!IsValidActor(actorid)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid actor ID");
+
+	GetActorSpawnInfo(actorid, skinid, x, y, z, a);
+	GetActorAnimation(actorid, animlib, _, animname, _, fDelta, loop, lockx, locky, freeze, time);
+	
+	SendClientMessagef(playerid, -1, "skinid: %d, pos: %.4f, %.4f, %.4f, %.4f", skinid, x, y, z, a);
+	SendClientMessagef(playerid, -1, "anim: %s/%s, fDelta: %.4f, loop: %d, lockx: %d, locky: %d, freeze: %d, time: %d", animlib, animname, fDelta, loop, lockx, locky, freeze, time);
+	return 1;
+}
+
+CMD:setplayerver(playerid, params[])
+{
+	SetPlayerVersion(playerid, params);
+	return 1;
+}
+
+CMD:disablekey(playerid, params[])
+{
+	SetPlayerDisabledKeysSync(playerid, strval(params));
+	SendClientMessagef(playerid, -1, "disabled: %d", GetPlayerDisabledKeysSync(playerid));
+	return 1;
+}
+
+CMD:vinfo(playerid, params[])
+{
+	new vehicleid;
+    if(sscanf(params, "D(-1)", vehicleid)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /vdata <vehicleid>");
+
+    if(vehicleid == -1) vehicleid = GetPlayerVehicleID(playerid);
+    if(!vehicleid) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: You're not in vehicle!");
+
+	new modelid, scolor1, scolor2, color1, color2, Float:X, Float:Y, Float:Z, Float:A, plate[33], respawn, Float:CurrX, Float:CurrY, Float:CurrZ;
+
+    modelid = GetVehicleModel(vehicleid);
+    GetVehicleSpawnInfo(vehicleid, X, Y, Z, A, scolor1, scolor2);
+    GetVehiclePos(vehicleid, CurrX, CurrY, CurrZ);
+	GetVehicleColor(vehicleid, color1, color2);
+	GetVehicleNumberPlate(vehicleid, plate, sizeof(plate));
+	
+	SendClientMessagef(playerid, 0xFF0000AA, "--- {33FF33}vehicleid: %d{FFFFFF}, {33FF33}modelid: %d {FF0000}---", vehicleid, modelid);
+	SendClientMessagef(playerid, -1, "color: %d, %d; pj: %d; interior: %d; respawn: %d - %f, %f, %f, %f, spawn color: %d, %d", color1, color2, GetVehiclePaintjob(vehicleid), GetVehicleInterior(vehicleid), GetVehicleRespawnDelay(vehicleid), X, Y, Z, A, scolor1, scolor2);
+	SendClientMessagef(playerid, -1, "current pos: %f, %f, %f", CurrX, CurrY, CurrZ);
+
+	respawn = GetTickCount() - GetVehicleRespawnTick(vehicleid);
+	SendClientMessagef(playerid, -1, "occupiedtick: %d, respawntick: %d, lastdriver: %d, plate: %s", GetVehicleOccupiedTick(vehicleid), respawn, GetVehicleLastDriver(vehicleid), plate);
+	SendClientMessagef(playerid, -1, "hasbeenoccupied: %d, occupied: %d, dead: %d, trailer: %d, cab: %d", HasVehicleBeenOccupied(vehicleid), IsVehicleOccupied(vehicleid), IsVehicleDead(vehicleid), GetVehicleTrailer(vehicleid), GetVehicleCab(vehicleid));
+	SendClientMessagef(playerid, -1, "models: %d, used models: %d/212", GetVehicleModelCount(modelid), GetVehicleModelsUsed());
+	return 1;
+}
+
+CMD:vspawninfo(playerid, params[])
+{
+	new vehicleid, Float:X, Float:Y, Float:Z;
+    if(sscanf(params, "d", vehicleid)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /vspawninfo <vehicleid>");
+
+	GetPlayerPos(playerid, X, Y, Z);
+	SetVehicleSpawnInfo(vehicleid, GetVehicleModel(vehicleid), X, Y, Z, 0.0, random(255), random(255));
+	return 1;
+}
+
+CMD:tdinfo(playerid, params[])
+{
+	new id;
+	if(!strcmp(params, "all"))
+	{
+		for(new i; i != 2048; i++)
+		{
+			if(!IsTextDrawVisibleForPlayer(playerid, Text:i)) continue;
+
+			TextDrawGetString(Text:i, tmp, 128);
+			SendClientMessagef(playerid, -1, "%d - %s", i, tmp);
+		}
+		return 1;
+	}
+
+	if(!sscanf(params, "d", id))
+	{
+		if(!IsValidTextDraw(Text:id)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid TextDraw id!");
+
+		new str[114], Float:pos[2], Float:lettersize[2], Float:fontsize[2], Float:rot[3], Float:zoom, color[2];
+
+		TextDrawGetString(Text:id, str, sizeof(str));
+		TextDrawGetPos(Text:id, pos[0], pos[1]);
+		TextDrawGetLetterSize(Text:id, lettersize[0], lettersize[1]);
+		TextDrawGetTextSize(Text:id, fontsize[0], fontsize[1]);
+
+		TextDrawGetPreviewRot(Text:id, rot[0], rot[1], rot[2], zoom);
+		TextDrawGetPreviewVehCol(Text:id, color[0], color[1]);
+
+		SendClientMessagef(playerid, 0x33FF33AA, "TextDrawID: {FF0000}%d, {33FF33}str: %s", id, str);
+		SendClientMessagef(playerid, -1, "pos: %.2f, %.2f - lettersize: %.2f, %.2f - fontsize: %.2f, %.2f", pos[0], pos[1], lettersize[0], lettersize[1], fontsize[0], fontsize[1]);
+		SendClientMessagef(playerid, -1, "color: %x, boxcolor: %x, backgroundcolor: %x, shadow: %d, outline: %d, font: %d", TextDrawGetColor(Text:id), TextDrawGetBoxColor(Text:id), TextDrawGetBackgroundColor(Text:id), TextDrawGetShadow(Text:id), TextDrawGetOutline(Text:id), TextDrawGetFont(Text:id));
+		SendClientMessagef(playerid, -1, "box: %d, proportional: %d, alignment: %d, selectable: %d", TextDrawIsBox(Text:id), TextDrawIsProportional(Text:id), TextDrawGetAlignment(Text:id), TextDrawIsSelectable(Text:id));
+		SendClientMessagef(playerid, -1, "prevmodel: %d, rot: %.2f, %.2f, %.2f - zoom: %.2f - color: %d, %d", TextDrawGetPreviewModel(Text:id), rot[0], rot[1], rot[2], zoom, color[0], color[1]);
+		return 1;
+	}
+
+	SendClientMessage(playerid, 0xFF0000AA, "USAGE: /tdinfo <all/Textdraw ID here>");
+	return 1;
+}
+
+CMD:tdpos(playerid, params[])
+{
+	new id, Float:fX, Float:fY;
+	if(sscanf(params, "dff", id, fX, fY)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /tdpos <TextDrawID> <fX <fY>");
+	if(!IsValidTextDraw(Text:id)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid TextDraw id!");
+
+	TextDrawSetPos(Text:id, fX, fY);
+	TextDrawShowForAll(Text:id);
+	return 1;
+}
+
+CMD:bubble(playerid, params[]) // illustrate how SendRPC works. this is equal to SetPlayerChatBubbleForPlayer
+{
+	SendRPC(playerid, 0x3B, // rpcid
+		BS_UNSIGNEDSHORT, strval(params), // at player, where you want to create bubble
+		BS_INT,	0x33FF33AA, // color
+		BS_FLOAT, 50.0, // drawdistance
+		BS_INT,	4325,   // expiretime
+		BS_UNSIGNEDCHAR, 3, // string lenght
+		BS_STRING, "asd"); // string
+	return 1;
+}
+
+
+CMD:attachobject(playerid, params[])
+{
+	new objectid, attachplayer;
+	if(sscanf(params, "dd", objectid, attachplayer)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /attachobject <objectid> <attachplayer>");
+
+	AttachObjectToPlayer(objectid, attachplayer, 0.0, 0.1, 0.2, 1.0, 1.0, 1.0);
+	return 1;
+}
+
+CMD:attachpobject(playerid, params[])
+{
+	new objectplayer, objectid, attachplayer, wait;
+	if(sscanf(params, "dddD(0)", objectplayer, objectid, attachplayer, wait)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /attachpobject <objectplayer> <objectid> <attachplayer> <wait = 0>");
+
+	AttachPlayerObjectToPlayer(objectplayer, objectid, attachplayer, 0.0, 0.1, 0.2, 1.0, 1.0, 1.0);
+	return 1;
+}
+
+#if defined STREAMER_TYPE_OBJECT
+CMD:attachdynamic(playerid, params[])
+{
+	new player1, Float:X, Float:Y, Float:Z;
+	if(sscanf(params, "d", player1)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /attachdynamic <player1>");
+
+	new obj = CreateDynamicObject(1224, X, Y, Z, 1.0, 2.0, 3.0);
+	AttachDynamicObjectToPlayer(obj, player1, 0.1, 0.7, 2.0, 30, 40, 50);
+	return 1;
+}
+#endif
+
+CMD:attachedobj(playerid, params[])
+{
+	new slot;
+	if(sscanf(params, "n", slot)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /attachedobj <slot>");
+	if(!(0 <= slot <= MAX_PLAYER_ATTACHED_OBJECTS)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid slot id! 0 - " #MAX_PLAYER_ATTACHED_OBJECTS "");
+
+	new modelid, bone, Float:offset[3], Float:rotation[3], Float:scale[3], material1, material2;
+	GetPlayerAttachedObject(playerid, slot, modelid, bone, offset[0], offset[1], offset[2], rotation[0], rotation[1], rotation[2], scale[0], scale[1], scale[2], material1, material2);
+
+	SendClientMessagef(playerid, -1, "modelid: %d, bone: %d", modelid, bone);
+	SendClientMessagef(playerid, -1, "offset: %.4f, %.4f, %.4f, {33FF33}rotation: %.4f, %.4f, %.4f", offset[0], offset[1], offset[2], rotation[0], rotation[1], rotation[2]);
+	SendClientMessagef(playerid, -1, "scale: %.4f, %.4f, %.4f, materialcolor: %x, %x", scale[0], scale[1], scale[2], material1, material2);
+	return 1;
+}
+
+CMD:objectinfo(playerid, params[])
+{
+	new objectid;
+	if(sscanf(params, "n", objectid)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /objectinfo <Object ID>");
+	if(!IsValidObject(objectid)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid object id!");
+
+	new attached_vehicle, attached_object, attached_playerid, Float:offset[3], Float:rotation[3], Float:target[3];
+	GetObjectAttachedData(objectid, attached_vehicle, attached_object, attached_playerid);
+	GetObjectAttachedOffset(objectid, offset[0], offset[1], offset[2], rotation[0], rotation[1], rotation[2]);
+	GetObjectTarget(objectid, target[0], target[1], target[2]);
+
+	SendClientMessagef(playerid, -1, "objectid: %d, model: %d, nocameracol: %d, drawdistance: %.4f, attached - vehicle: %d, object: %d, player: %d", objectid, GetObjectModel(objectid), IsObjectNoCameraCol(objectid), GetObjectDrawDistance(objectid), attached_vehicle, attached_object, attached_playerid);
+
+	// If moving..
+	if(IsObjectMoving(objectid))
+		SendClientMessagef(playerid, -1, "movespeed: %.4f, target: %.4f, %.4f, %.4f", GetObjectMoveSpeed(objectid), target[0], target[1], target[2]);
+
+	// If attached to something..
+	if(attached_vehicle != 0xFFFF || attached_object != 0xFFFF || attached_playerid != 0xFFFF)
+		SendClientMessagef(playerid, -1, "attached offsets: %.4f, %.4f, %.4f, rot: %.4f, %.4f, %.4f", offset[0], offset[1], offset[2], rotation[0], rotation[1], rotation[2]);
+	return 1;
+}
+
+CMD:pobjectinfo(playerid, params[])
+{
+	new objectid;
+	if(sscanf(params, "n", objectid)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /objectinfo <Object ID>");
+	if(!IsValidPlayerObject(playerid, objectid)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid object id!");
+
+	new attached_vehicle, attached_object, attached_player, Float:offset[3], Float:rotation[3], Float:target[3];
+	GetPlayerObjectAttachedData(playerid, objectid, attached_vehicle, attached_object, attached_player);
+	GetPlayerObjectAttachedOffset(playerid, objectid, offset[0], offset[1], offset[2], rotation[0], rotation[1], rotation[2]);
+	GetPlayerObjectTarget(playerid, objectid, target[0], target[1], target[2]);
+
+	SendClientMessagef(playerid, -1, "player objectid: %d, model: %d, nocameracol: %d, drawdistance: %.4f, attached - vehicle: %d, object: %d, player: %d", objectid, GetPlayerObjectModel(playerid, objectid), IsPlayerObjectNoCameraCol(playerid, objectid), GetPlayerObjectDrawDistance(playerid, objectid), attached_vehicle, attached_object, attached_player);
+
+	// If moving..
+	if(IsPlayerObjectMoving(playerid, objectid))
+		SendClientMessagef(playerid, -1, "movespeed: %.4f, target: %.4f, %.4f, %.4f", GetObjectMoveSpeed(objectid), target[0], target[1], target[2]);
+
+	// If attached to something..
+	if(attached_vehicle != 0xFFFF || attached_object != 0xFFFF || attached_player != 0xFFFF)
+		SendClientMessagef(playerid, -1, "attached offsets: %.4f, %.4f, %.4f, rot: %.4f, %.4f, %.4f", offset[0], offset[1], offset[2], rotation[0], rotation[1], rotation[2]);
+	return 1;
+}
+
+CMD:objecttype(playerid, params[])
+{
+	new objectid;
+	if(sscanf(params, "n", objectid)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /objecttype <Object ID>");
+
+	SendClientMessagef(playerid, -1, "objectid: %d, type: %d", objectid, GetObjectType(playerid, objectid));
+	return 1;
+}
+
+CMD:objmovespeed(playerid, params[])
+{
+	new objectid, Float:fSpeed;
+	if(sscanf(params, "nf", objectid, fSpeed)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /objmovespeed <Object ID> <fSpeed>");
+	if(!IsValidObject(objectid)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid object id!");
+
+	SetObjectMoveSpeed(objectid, fSpeed);
+	return 1;
+}
+
+CMD:ptdinfo(playerid, params[])
+{
+	new id;
+	if(!strcmp(params, "all"))
+	{
+		for(new i; i != 2048; i++)
+		{
+			if(!IsPlayerTextDrawVisible(playerid, PlayerText:i)) continue;
+
+			PlayerTextDrawGetString(playerid, PlayerText:i, tmp, 128);
+			SendClientMessagef(playerid, -1, "%d - %s", i, tmp);
+		}
+		return 1;
+	}
+
+	if(!sscanf(params, "d", id))
+	{
+		if(!IsValidPlayerTextDraw(playerid, PlayerText:id)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid TextDraw id!");
+
+		new str[114], Float:pos[2], Float:lettersize[2], Float:fontsize[2], Float:rot[3], Float:zoom, color[2];
+
+		PlayerTextDrawGetString(playerid, PlayerText:id, str, sizeof(str));
+		PlayerTextDrawGetPos(playerid, PlayerText:id, pos[0], pos[1]);
+		PlayerTextDrawGetLetterSize(playerid, PlayerText:id, lettersize[0], lettersize[1]);
+		PlayerTextDrawGetTextSize(playerid, PlayerText:id, fontsize[0], fontsize[1]);
+
+		PlayerTextDrawGetPreviewRot(playerid, PlayerText:id, rot[0], rot[1], rot[2], zoom);
+		PlayerTextDrawGetPreviewVehCol(playerid, PlayerText:id, color[0], color[1]);
+
+		SendClientMessagef(playerid, 0x33FF33AA, "TextDrawID: {FF0000}%d, {33FF33}str: %s", id, str);
+		SendClientMessagef(playerid, -1, "pos: %.2f, %.2f - lettersize: %.2f, %.2f - fontsize: %.2f, %.2f", pos[0], pos[1], lettersize[0], lettersize[1], fontsize[0], fontsize[1]);
+		SendClientMessagef(playerid, -1, "color: %x, boxcolor: %x, backgroundcolor: %x, shadow: %d, outline: %d, font: %d", PlayerTextDrawGetColor(playerid, PlayerText:id), PlayerTextDrawGetBoxColor(playerid, PlayerText:id), PlayerTextDrawGetBackgroundCol(playerid, PlayerText:id), PlayerTextDrawGetShadow(playerid, PlayerText:id), PlayerTextDrawGetOutline(playerid, PlayerText:id), PlayerTextDrawGetFont(playerid, PlayerText:id));
+		SendClientMessagef(playerid, -1, "box: %d, proportional: %d, alignment: %d, selectable: %d", PlayerTextDrawIsBox(playerid, PlayerText:id), PlayerTextDrawIsProportional(playerid, PlayerText:id), PlayerTextDrawGetAlignment(playerid, PlayerText:id), PlayerTextDrawIsSelectable(playerid, PlayerText:id));
+		SendClientMessagef(playerid, -1, "prevmodel: %d, rot: %.2f, %.2f, %.2f - zoom: %.2f - color: %d, %d", PlayerTextDrawGetPreviewModel(playerid, PlayerText:id), rot[0], rot[1], rot[2], zoom, color[0], color[1]);
+		return 1;
+	}
+
+	SendClientMessage(playerid, 0xFF0000AA, "USAGE: /ptdinfo <all/Textdraw ID here>");
+	return 1;
+}
+
+CMD:ptdpos(playerid, params[])
+{
+	new id, Float:fX, Float:fY;
+	if(sscanf(params, "dff", id, fX, fY)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /ptdpos <TextDrawID> <fX <fY>");
+	if(!IsValidPlayerTextDraw(playerid, PlayerText:id)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid TextDraw id!");
+
+	PlayerTextDrawSetPos(playerid, PlayerText:id, fX, fY);
+	PlayerTextDrawShow(playerid, PlayerText:id);
+	return 1;
+}
+
+CMD:ptdcolor(playerid, params[])
+{
+	new id, color;
+	if(sscanf(params, "dn", id, color)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /ptdcolor <TextDrawID> <color>");
+	if(!IsValidPlayerTextDraw(playerid, PlayerText:id)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid TextDraw id!");
+
+	SendClientMessagef(playerid, -1, "oldcolor: %x, newcolor: %x", PlayerTextDrawGetColor(playerid, PlayerText:id), color);
+
+	PlayerTextDrawColor(playerid, PlayerText:id, color);
+	PlayerTextDrawShow(playerid, PlayerText:id);
+	return 1;
+}
+
+CMD:ismaterial(playerid, params[])
+{
+	new objectid, materialindex;
+	if(sscanf(params, "dd", objectid, materialindex)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /ismaterial <ObjectID> <materialindex>");
+	if(!IsValidObject(objectid)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid Object id!");
+
+    SendClientMessagef(playerid, -1, "used: %d", IsObjectMaterialSlotUsed(objectid, materialindex));
+	return 1;
+}
+
+CMD:getmaterial(playerid, params[])
+{
+	new objectid, materialindex;
+	if(sscanf(params, "dd", objectid, materialindex)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /getmaterial <ObjectID> <materialindex>");
+	if(!IsValidObject(objectid)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid Object id!");
+
+	new modelid, txdname[64], texturename[64], materialcolor;
+
+	GetObjectMaterial(objectid, materialindex, modelid, txdname, sizeof(txdname), texturename, sizeof(texturename), materialcolor);
+	SendClientMessagef(playerid, -1, "modelid: %d, txdname: %s, texturename: %s, color: %x", modelid, txdname, texturename, materialcolor);
+	return 1;
+}
+
+CMD:getpmaterial(playerid, params[])
+{
+	new objectid, materialindex;
+	if(sscanf(params, "dd", objectid, materialindex)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /getpmaterial <ObjectID> <materialindex>");
+	if(!IsValidPlayerObject(playerid, objectid)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid Object id!");
+
+	new modelid, txdname[64], texturename[64], materialcolor;
+
+	GetPlayerObjectMaterial(playerid, objectid, materialindex, modelid, txdname, sizeof(txdname), texturename, sizeof(texturename), materialcolor);
+	SendClientMessagef(playerid, -1, "modelid: %d, txdname: %s, texturename: %s, color: %x", modelid, txdname, texturename, materialcolor);
+	return 1;
+}
+
+CMD:getmaterialtext(playerid, params[])
+{
+	new objectid, materialindex, text[144], materialsize, fontface[32], fontsize, bold, fontcolor, backcolor, textalignment;
+	if(sscanf(params, "dd", objectid, materialindex)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /getmaterialtext <ObjectID> <materialindex>");
+	if(!IsValidObject(objectid)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid Object id!");
+
+	GetObjectMaterialText(objectid, materialindex, text, sizeof(text), materialsize, fontface, sizeof(fontface), fontsize, bold, fontcolor, backcolor, textalignment);
+
+    SendClientMessagef(playerid, -1, "text: %s", text);
+	SendClientMessagef(playerid, -1, "materialsize: %d, fontface: %s, fontsize: %d, bold: %d, fontcolor: %x, backcolor: %x, alignment: %d", materialsize, fontface, fontsize, bold, fontcolor, backcolor, textalignment);
+	return 1;
+}
+
+CMD:getpmaterialtext(playerid, params[])
+{
+	new objectid, materialindex, text[144], materialsize, fontface[32], fontsize, bold, fontcolor, backcolor, textalignment;
+	if(sscanf(params, "dd", objectid, materialindex)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /getpmaterialtext <ObjectID> <materialindex>");
+	if(!IsValidPlayerObject(playerid, objectid)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid Object id!");
+
+	GetPlayerObjectMaterialText(playerid, objectid, materialindex, text, sizeof(text), materialsize, fontface, sizeof(fontface), fontsize, bold, fontcolor, backcolor, textalignment);
+
+    SendClientMessagef(playerid, -1, "text: %s", text);
+	SendClientMessagef(playerid, -1, "materialsize: %d, fontface: %s, fontsize: %d, bold: %d, fontcolor: %x, backcolor: %x, alignment: %d", materialsize, fontface, fontsize, bold, fontcolor, backcolor, textalignment);
+	return 1;
+}
+
+CMD:gzinfo(playerid, params[])
+{
+	new id;
+	if(!strcmp(params, "all"))
+	{
+		for(new i; i != 1024; i++)
+		{
+			if(!IsGangZoneVisibleForPlayer(playerid, i)) continue;
+
+			SendClientMessagef(playerid, -1, "%d", i);
+		}
+		return 1;
+	}
+
+	if(!sscanf(params, "d", id))
+	{
+		if(!IsValidGangZone(id)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid GangZone ID!");
+
+		new Float:fPos[4];
+		GangZoneGetPos(id, fPos[0], fPos[1], fPos[2], fPos[3]);
+
+		SendClientMessagef(playerid, 0x33FF33AA, "GangZoneID: {FF0000}%d, {33FF33}visible: %d - %x", id, IsGangZoneVisibleForPlayer(playerid, id), GangZoneGetColorForPlayer(playerid, id));
+		SendClientMessagef(playerid, -1, "pos: %.4f, %.4f, %.4f, %.4f", fPos[0], fPos[1], fPos[2], fPos[3]);
+		SendClientMessagef(playerid, -1, "isflashing: %d, flashcolor: %x", IsGangZoneFlashingForPlayer(playerid, id), GangZoneGetFlashColorForPlayer(playerid, id));
+		return 1;
+	}
+
+	SendClientMessage(playerid, 0xFF0000AA, "USAGE: /gzinfo <all/Textdraw ID here>");
+	return 1;
+}
+
+CMD:pgzinfo(playerid, params[])
+{
+	new id;
+	if(!strcmp(params, "all"))
+	{
+		for(new i; i != 1024; i++)
+		{
+			if(!IsPlayerGangZoneVisible(playerid, i)) continue;
+
+			SendClientMessagef(playerid, -1, "%d", i);
+		}
+		return 1;
+	}
+
+	if(!sscanf(params, "d", id))
+	{
+		if(!IsValidPlayerGangZone(playerid, id)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid GangZone ID!");
+
+		new Float:fPos[4];
+		PlayerGangZoneGetPos(playerid, id, fPos[0], fPos[1], fPos[2], fPos[3]);
+
+		SendClientMessagef(playerid, 0x33FF33AA, "GangZoneID: {FF0000}%d, {33FF33}visible: %d - %x", id, IsPlayerGangZoneVisible(playerid, id), PlayerGangZoneGetColor(playerid, id));
+		SendClientMessagef(playerid, -1, "pos: %.4f, %.4f, %.4f, %.4f", fPos[0], fPos[1], fPos[2], fPos[3]);
+		SendClientMessagef(playerid, -1, "isflashing: %d, flashcolor: %x", IsPlayerGangZoneFlashing(playerid, id), PlayerGangZoneGetFlashColor(playerid, id));
+		return 1;
+	}
+
+	SendClientMessage(playerid, 0xFF0000AA, "USAGE: /pgzinfo <all/Textdraw ID here>");
+	return 1;
+}
+
+CMD:3dtextinfo(playerid, params[])
+{
+	if(!strcmp(params, "all"))
+	{
+		for(new i; i != 1024; i++)
+		{
+			if(!IsValid3DTextLabel(Text3D:i)) continue;
+
+			SendClientMessagef(playerid, -1, "%d", i);
+		}
+		return 1;
+	}
+	
+	new Text3D:id, text[144], color, Float:fPos[3], attached_player, attached_vehicle;
+	if(sscanf(params, "d", _:id)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /3dtextinfo <id>");
+	if(!IsValid3DTextLabel(id)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid ID!");
+
+	Get3DTextLabelText(id, text);
+	color = Get3DTextLabelColor(id);
+	Get3DTextLabelPos(id, fPos[0], fPos[1], fPos[2]);
+	Get3DTextLabelAttachedData(id, attached_player, attached_vehicle);
+
+	SendClientMessagef(playerid, color, "text: %s", text);
+	SendClientMessagef(playerid, color, "color: %x, pos: %.4f, %.4f, %.4f, drawdistance: %.4f, los: %d, world: %d, attached: %d, %d, streamed: %d", color, fPos[0], fPos[1], fPos[2], Get3DTextLabelDrawDistance(id), Get3DTextLabelLOS(id), Get3DTextLabelVirtualWorld(id), attached_player, attached_vehicle, Is3DTextLabelStreamedIn(playerid, id));
+	return 1;
+}
+
+CMD:p3dtextinfo(playerid, params[])
+{
+	if(!strcmp(params, "all"))
+	{
+		for(new i; i != 1024; i++)
+		{
+			if(!IsValidPlayer3DTextLabel(playerid, PlayerText3D:i)) continue;
+
+			SendClientMessagef(playerid, -1, "%d", i);
+		}
+		return 1;
+	}
+
+	new PlayerText3D:id, text[144], color, Float:fPos[3], attached_player, attached_vehicle;
+	if(sscanf(params, "d", _:id)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /p3dtextinfo <id>");
+	if(!IsValidPlayer3DTextLabel(playerid, id)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid ID!");
+
+	GetPlayer3DTextLabelText(playerid, id, text);
+	color = GetPlayer3DTextLabelColor(playerid, id);
+	GetPlayer3DTextLabelPos(playerid, id, fPos[0], fPos[1], fPos[2]);
+	GetPlayer3DTextLabelAttached(playerid, id, attached_player, attached_vehicle);
+
+	SendClientMessagef(playerid, color, "text: %s", text);
+	SendClientMessagef(playerid, color, "color: %x, pos: %.4f, %.4f, %.4f, drawdistance: %.4f, los: %d, world: %d, attached: %d, %d, streamed: %d", color, fPos[0], fPos[1], fPos[2], GetPlayer3DTextLabelDrawDist(playerid, id), GetPlayer3DTextLabelLOS(playerid, id), GetPlayer3DTextLabelVirtualW(playerid, id), attached_player, attached_vehicle, Is3DTextLabelStreamedIn(playerid, Text3D:id));
+	return 1;
+}
+/*
+CMD:ppickup(playerid, params[])
+{
+	new modelid, type, Float:fPos[3];
+	if(sscanf(params, "dd", modelid, type)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /ppickup <modelid> <type>");
+
+    GetPlayerPos(playerid, fPos[0], fPos[1], fPos[2]);
+	SendClientMessagef(playerid, -1, "id: %d", CreatePlayerPickup(playerid, modelid, type, fPos[0] + 2.0, fPos[1], fPos[2]));
+	return 1;
+}
+
+CMD:dppickup(playerid, params[])
+{
+	new pickupid;
+	if(sscanf(params, "d", pickupid)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /dppickup <pickupid>");
+	if(!IsValidPlayerPickup(playerid, pickupid)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid ID!");
+
+	SendClientMessagef(playerid, -1, "id: %d", DestroyPlayerPickup(playerid, pickupid));
+	return 1;
+}
+*/
+CMD:pickupinfo(playerid, params[])
+{
+	new id, Float:fPos[3];
+	if(!strcmp(params, "all"))
+	{
+		for( ; id != MAX_PICKUPS; id++)
+		{
+			if(!IsPickupStreamedIn(playerid, id)) continue;
+
+			GetPickupPos(id, fPos[0], fPos[1], fPos[2]);
+			SendClientMessagef(playerid, -1, "id: %d, model: %d, type: %d, pos: %.4f, %.4f, %.4f, world: %d, streamed: %d", id, GetPickupModel(id), GetPickupType(id), fPos[0], fPos[1], fPos[2], GetPickupVirtualWorld(id), IsPickupStreamedIn(playerid, id));
+		}
+		return 1;
+	}
+
+	if(sscanf(params, "d", id)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /pickupinfo <id>");
+	if(!IsValidPickup(id)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid ID!");
+
+	GetPickupPos(id, fPos[0], fPos[1], fPos[2]);
+	SendClientMessagef(playerid, -1, "model: %d, type: %d, pos: %.4f, %.4f, %.4f, world: %d, streamed: %d", GetPickupModel(id), GetPickupType(id), fPos[0], fPos[1], fPos[2], GetPickupVirtualWorld(id), IsPickupStreamedIn(playerid, id));
+	return 1;
+}
+/*
+CMD:ppickupinfo(playerid, params[])
+{
+	new id, Float:fPos[3];
+	if(!strcmp(params, "all"))
+	{
+		for( ; id != MAX_PICKUPS; id++)
+		{
+			if(!IsPlayerPickupStreamedIn(playerid, id)) continue;
+
+			GetPlayerPickupPos(playerid, id, fPos[0], fPos[1], fPos[2]);
+			SendClientMessagef(playerid, -1, "id: %d, model: %d, type: %d, pos: %.4f, %.4f, %.4f, world: %d, streamed: %d", id, GetPickupModel(id), GetPickupType(id), fPos[0], fPos[1], fPos[2], GetPickupVirtualWorld(id), IsPickupStreamedIn(playerid, id));
+		}
+		return 1;
+	}
+
+	if(sscanf(params, "d", id)) return SendClientMessage(playerid, 0xFF0000AA, "USAGE: /pickupinfo <id>");
+	if(!IsValidPlayerPickup(playerid, id)) return SendClientMessage(playerid, 0xFF0000AA, "ERROR: Invalid ID!");
+
+	GetPlayerPickupPos(playerid, id, fPos[0], fPos[1], fPos[2]);
+	SendClientMessagef(playerid, -1, "model: %d, type: %d, pos: %.4f, %.4f, %.4f, world: %d, streamed: %d", GetPlayerPickupModel(playerid, id), GetPlayerPickupType(playerid, id), fPos[0], fPos[1], fPos[2], GetPlayerPickupVirtualWorld(playerid, id), IsPlayerPickupStreamedIn(playerid, id));
+	return 1;
+}
+*/
+CMD:modelinfo(playerid, params[])
+{
+	new id, Float:fOffset[3];
+	if(sscanf(params, "d", id)) return SendClientMessagef(playerid, 0xFF0000AA, "USAGE: /modelinfo <id> (max: %d)", GetColCount());
+
+	GetColSphereOffset(id, fOffset[0], fOffset[1], fOffset[2]);
+	SendClientMessagef(playerid, -1, "col sphere: %.4f, offsets: %.4f, %.4f, %.4f", GetColSphereRadius(id), fOffset[0], fOffset[1], fOffset[2]);
+	return 1;
+}
+
+CMD:formatmsg(playerid, params[])
+{
+    SendClientMessagef(playerid, 0x33FF33AA, "Kurva %s %d %.3f", "anyád", -1547, 2654.6542);
+    SendClientMessageToAllf(0x33FF33AA, "lofasz a %s", "füledbe");
+
+    GameTextForPlayerf(playerid, 3000, 3, "Kis %s", "kecske");
+    GameTextForAllf(3000, 3, "Kis %s", "kecske");
+
+    SendPlayerMessageToPlayerf(playerid, playerid, "megbasztam %s %s hátán", "apádat", "anyád");
+    SendPlayerMessageToAllf(playerid, "megbasztam %s %s hátán", "apádat", "anyád");
+    return 1;
+}
+
+CMD:netstats(playerid, params[])
+{
+    SendClientMessagef(playerid, 0x33FF33AA, "ConTime: %d, ConStatus: %d", NetStats_GetConnectedTime(playerid), NetStats_ConnectionStatus(playerid));
+    return 1;
+}
+
+CMD:ysf_netstats(playerid, params[])
+{
+    SendClientMessagef(playerid, -1, "Extended net stats: %d", YSF_IsExtendedNetStatsEnabled());
+    
+    YSF_SetExtendedNetStatsEnabled(!YSF_IsExtendedNetStatsEnabled());
+    return 1;
+}
+
+
+stock pName(playerid)
+{
+	static
+	    szName[24];
+	GetPlayerName(playerid, szName, sizeof(szName));
+	return szName;
+}
+
+public OnPlayerEnterGangZone(playerid, zoneid)
+{
+    SendClientMessagef(playerid, -1, "OnPlayerEnterGangZone(playerid = %d, zoneid = %d)", playerid, zoneid);
+	return 1;
+}
+
+public OnPlayerLeaveGangZone(playerid, zoneid)
+{
+    SendClientMessagef(playerid, -1, "OnPlayerLeaveGangZone(playerid = %d, zoneid = %d)", playerid, zoneid);
+	return 1;
+}
+
+public OnPlayerEnterPlayerGangZone(playerid, zoneid)
+{
+    SendClientMessagef(playerid, 0xd3e836AA, "OnPlayerEnterPlayerGangZone(playerid = %d, zoneid = %d)", playerid, zoneid);
+	return 1;
+}
+
+public OnPlayerLeavePlayerGangZone(playerid, zoneid)
+{
+    SendClientMessagef(playerid, 0xd3e836AA, "OnPlayerLeavePlayerGangZone(playerid = %d, zoneid = %d)", playerid, zoneid);
+	return 1;
+}
+/*
+public OnPlayerPickUpPickup(playerid, pickupid)
+{
+    SendClientMessagef(playerid, 0x00e893AA, "OnPlayerPickUpPickup(playerid = %d, pickupid = %d)", playerid, pickupid);
+	return 1;
+}
+
+public OnPlayerPickUpPlayerPickup(playerid, pickupid)
+{
+    SendClientMessagef(playerid, 0xFFD700FF, "OnPlayerPickUpPlayerPickup(playerid = %d, pickupid = %d)", playerid, pickupid);
+	return 1;
+}
+*/
+public OnPlayerPauseStateChange(playerid, pausestate)
+{
+    SendClientMessagef(playerid, 0xFFD700FF, "OnPlayerPauseStateChange(playerid = %d, pausestate = %d)", playerid, pausestate);
+	return 1;
+}
+
+public OnRemoteRCONPacket(const ipaddr[], port, const password[], success, const command[])
+{
+	printf("remote console - ip: %s, port: %d, pass: %s, command: %s", ipaddr, port, password, command);
+	return 1;
+}
+
+
+forward OnPlayerClientGameInit(playerid, &usecjwalk, &limitglobalchat, &globalchatradius, &nametagdistance, &disableenterexits, &nametaglos, &manualvehengineandlights,
+				&spawnsavailable, &shownametags, &showplayermarkers, &onfoot_rate, &incar_rate, &weapon_rate, &lacgompmode, &vehiclefriendlyfire);
+
+public OnPlayerClientGameInit(playerid, &usecjwalk, &limitglobalchat, &globalchatradius, &nametagdistance, &disableenterexits, &nametaglos, &manualvehengineandlights,
+				&spawnsavailable, &shownametags, &showplayermarkers, &onfoot_rate, &incar_rate, &weapon_rate, &lacgompmode, &vehiclefriendlyfire)
+
+{
+	printf("OnPlayerClientGameInit(playerid = %d, &usecjwalk = %d, &limitglobalchat = %d, &globalchatradius = %f, &nametagdistance = %f, &disableenterexits = %d, &nametaglos = %d, &manualvehengineandlights = %d, \
+				&spawnsavailable = %d, &shownametags = %d, &showplayermarkers = %d, &onfoot_rate = %d, &incar_rate = %d, &weapon_rate = %d, &lacgompmode = %d, &vehiclefriendlyfire = %d",
+	playerid, usecjwalk, limitglobalchat, globalchatradius, nametagdistance, disableenterexits, nametaglos, manualvehengineandlights,
+				spawnsavailable, shownametags, showplayermarkers, onfoot_rate, incar_rate, weapon_rate, lacgompmode, vehiclefriendlyfire);
+				
+
+    onfoot_rate = 13;
+	limitglobalchat = true;
+	globalchatradius = 200;
+	//nametagdistance = -50;
+	disableenterexits = false;
+    printf("lófasz - %d", limitglobalchat);
+}
+
diff --git a/pawno/include/YSF.inc b/pawno/include/YSF.inc
new file mode 100644
index 0000000..7a25933
--- /dev/null
+++ b/pawno/include/YSF.inc
@@ -0,0 +1,439 @@
+/* YSF - kurta999's version */
+#if defined _YSF_included
+	#endinput
+#endif
+#define _YSF_included
+
+// Definitions
+enum E_SERVER_RULE_FLAGS (<<= 1)
+{
+	CON_VARFLAG_DEBUG = 1,
+	CON_VARFLAG_READONLY,
+	CON_VARFLAG_RULE,
+	CON_VARFLAG_UNREMOVABLE
+}
+
+enum E_SCM_EVENT_TYPE
+{
+    SCM_EVENT_PAINTJOB = 1,
+    SCM_EVENT_MOD = 2,
+    SCM_EVENT_RESPRAY = 3,
+    SCM_EVENT_MOD_SHOP = 4
+}
+
+// File functions
+native ffind(const pattern[], filename[], len, &idx);
+native frename(const oldname[], const newname[]);
+
+// Directory functions
+native dfind(const pattern[], filename[], len, &idx);
+native dcreate(const name[]);
+native drename(const oldname[], const newname[]);
+
+// Gamemode restart time
+native SetModeRestartTime(Float:time);
+native Float:GetModeRestartTime();
+
+// Player position sync bounds
+native GetSyncBounds(&Float:hmin, &Float:hmax, &Float:vmin, &Float:vmax);
+native SetSyncBounds(Float:hmin, Float:hmax, Float:vmin, Float:vmax);
+
+// Max player/npc change at runtime
+native SetMaxPlayers(maxplayers);
+native SetMaxNPCs(maxnpcs);
+
+// Filterscript functions
+native LoadFilterScript(const scriptname[]); // difference between "rcon loadfs": Return -> True if success, false if not
+native UnLoadFilterScript(const scriptname[]); // ^
+native GetFilterScriptCount();
+native GetFilterScriptName(id, name[], len = sizeof(name));
+
+// Server rule modifications
+native AddServerRule(const name[], const value[], E_SERVER_RULE_FLAGS:flags = CON_VARFLAG_RULE);
+native SetServerRule(const name[], const value[]);
+native IsValidServerRule(const name[]);
+native SetServerRuleFlags(const name[], E_SERVER_RULE_FLAGS:flags);
+native E_SERVER_RULE_FLAGS:GetServerRuleFlags(const name[]);
+// Just for backward compatibility...
+native ModifyFlag(const name[], flags);
+
+// Server settings
+native GetServerSettings(&showplayermarkes, &shownametags, &stuntbonus, &useplayerpedanims, &bLimitchatradius, &disableinteriorenterexits, &nametaglos, &manualvehicleengine, &limitplayermarkers, &vehiclefriendlyfire, &defaultcameracollision, &Float:fGlobalchatradius, &Float:fNameTagDrawDistance, &Float:fPlayermarkerslimit);
+
+// YSF settings
+native YSF_SetTickRate(ticks);
+native YSF_GetTickRate();
+native YSF_EnableNightVisionFix(enable);
+native YSF_IsNightVisionFixEnabled();
+native YSF_SetExtendedNetStatsEnabled(enable);
+native YSF_IsExtendedNetStatsEnabled();
+native YSF_SetAFKAccuracy(time_ms);
+native YSF_GetAFKAccuracy();
+native YSF_ToggleNPCTracking(bool:enable);
+native YSF_IsNPCTrackingEnabled();
+
+native SetRecordingDirectory(const dir[]);
+native GetRecordingDirectory(dir[], len = sizeof(dir));
+
+// Nickname
+native IsValidNickName(const name[]);
+native AllowNickNameCharacter(character, bool:allow);
+native IsNickNameCharacterAllowed(character);
+
+// Classes
+native GetAvailableClasses();
+native GetPlayerClass(classid, &teamid, &modelid, &Float:spawn_x, &Float:spawn_y, &Float:spawn_z, &Float:z_angle, &weapon1, &weapon1_ammo, &weapon2, &weapon2_ammo,& weapon3, &weapon3_ammo);
+native EditPlayerClass(classid, teamid, modelid, Float:spawn_x, Float:spawn_y, Float:spawn_z, Float:z_angle, weapon1, weapon1_ammo, weapon2, weapon2_ammo, weapon3, weapon3_ammo);
+
+// Timers
+native GetRunningTimers();
+
+// Per player things
+native SetPlayerGravity(playerid, Float:gravity);
+native Float:GetPlayerGravity(playerid);
+native SetPlayerAdmin(playerid, bool:admin); // Set player as RCON admin
+native SetPlayerTeamForPlayer(playerid, teamplayerid, teamid);
+native GetPlayerTeamForPlayer(playerid, teamplayerid);
+native SetPlayerSkinForPlayer(playerid, skinplayerid, skin);
+native GetPlayerSkinForPlayer(playerid, skinplayerid);
+native SetPlayerNameForPlayer(playerid, nameplayerid, const playername[]);
+native GetPlayerNameForPlayer(playerid, nameplayerid, playername[], size = sizeof(playername));
+native SetPlayerFightStyleForPlayer(playerid, styleplayerid, style);
+native GetPlayerFightStyleForPlayer(playerid, skinplayerid);
+native SetPlayerPosForPlayer(playerid, posplayerid, Float:fX, Float:fY, Float:fZ, bool:forcesync = true);
+native SetPlayerRotationQuatForPlayer(playerid, quatplayerid, Float:w, Float:x, Float:y, Float:z, bool:forcesync = true);
+native ApplyAnimationForPlayer(playerid, animplayerid, const animlib[], const animname[], Float:fDelta, loop, lockx, locky, freeze, time); // DOESN'T WORK
+native GetPlayerWeather(playerid);
+native TogglePlayerWidescreen(playerid, bool:set);
+native IsPlayerWidescreenToggled(playerid);
+native GetSpawnInfo(playerid, &teamid, &modelid, &Float:spawn_x, &Float:spawn_y, &Float:spawn_z, &Float:z_angle, &weapon1, &weapon1_ammo, &weapon2, &weapon2_ammo,& weapon3, &weapon3_ammo);
+native GetPlayerSkillLevel(playerid, skill);
+native IsPlayerCheckpointActive(playerid);
+native GetPlayerCheckpoint(playerid, &Float:fX, &Float:fY, &Float:fZ, &Float:fSize);
+native IsPlayerRaceCheckpointActive(playerid);
+native GetPlayerRaceCheckpoint(playerid, &Float:fX, &Float:fY, &Float:fZ, &Float:fNextX, &Float:fNextY, &Float:fNextZ, &Float:fSize);
+native GetPlayerWorldBounds(playerid, &Float:x_max, &Float:x_min, &Float:y_max, &Float:y_min);
+native IsPlayerInModShop(playerid);
+native GetPlayerSirenState(playerid);
+native GetPlayerLandingGearState(playerid);
+native GetPlayerHydraReactorAngle(playerid);
+native Float:GetPlayerTrainSpeed(playerid);
+native Float:GetPlayerZAim(playerid);
+native GetPlayerSurfingOffsets(playerid, &Float:fOffsetX, &Float:fOffsetY, &Float:fOffsetZ);
+native GetPlayerRotationQuat(playerid, &Float:w, &Float:x, &Float:y, &Float:z);
+native GetPlayerSpectateID(playerid);
+native GetPlayerSpectateType(playerid);
+native GetPlayerLastSyncedVehicleID(playerid);
+native GetPlayerLastSyncedTrailerID(playerid);
+
+native SendBulletData(sender, hitid, hittype, weaponid, Float:fHitOriginX, Float:fHitOriginY, Float:fHitOriginZ, Float:fHitTargetX, Float:fHitTargetY, Float:fHitTargetZ, Float:fCenterOfHitX, Float:fCenterOfHitY, Float:fCenterOfHitZ, forplayerid = -1);
+native ShowPlayerForPlayer(forplayerid, playerid);
+native HidePlayerForPlayer(forplayerid, playerid);
+native AddPlayerForPlayer(forplayerid, playerid, isnpc = 0);
+native RemovePlayerForPlayer(forplayerid, playerid);
+native SetPlayerChatBubbleForPlayer(forplayerid, playerid, const text[], color, Float:drawdistance, expiretime);
+native ResetPlayerMarkerForPlayer(playerid, resetplayerid);
+native SetPlayerVersion(playerid, const version[]);
+native IsPlayerSpawned(playerid);
+native IsPlayerControllable(playerid);
+native SpawnForWorld(playerid);
+native BroadcastDeath(playerid);
+native IsPlayerCameraTargetEnabled(playerid);
+native SetPlayerDisabledKeysSync(playerid, keys);
+native GetPlayerDisabledKeysSync(playerid);
+
+native GetNPCCommandLine(npcid, script[], length=sizeof(script));
+
+// Actors
+native GetActorSpawnInfo(actorid, &skinid, &Float:fX, &Float:fY, &Float:fZ, &Float:fAngle);
+native GetActorSkin(actorid);
+native GetActorAnimation(actorid, animlib[], animlibsize = sizeof(animlib), animname[], animnamesize = sizeof(animname), &Float:fDelta, &loop, &lockx, &locky, &freeze, &time);
+
+// Scoreboard manipulation
+native TogglePlayerScoresPingsUpdate(playerid, bool:toggle);
+native TogglePlayerFakePing(playerid, bool:toggle);
+native SetPlayerFakePing(playerid, ping);
+native TogglePlayerInServerQuery(playerid, bool:toggle);
+native IsPlayerToggledInServerQuery(playerid);
+
+// Pause functions
+native IsPlayerPaused(playerid);
+native GetPlayerPausedTime(playerid);
+
+// Objects get - global
+native Float:GetObjectDrawDistance(objectid);
+native SetObjectMoveSpeed(objectid, Float:fSpeed);
+native Float:GetObjectMoveSpeed(objectid);
+native GetObjectTarget(objectid, &Float:fX, &Float:fY, &Float:fZ);
+native GetObjectAttachedData(objectid, &attached_vehicleid, &attached_objectid, &attached_playerid);
+native GetObjectAttachedOffset(objectid, &Float:fX, &Float:fY, &Float:fZ, &Float:fRotX, &Float:fRotY, &Float:fRotZ);
+native IsObjectMaterialSlotUsed(objectid, materialindex); // Return values: 1 = material, 2 = material text
+native GetObjectMaterial(objectid, materialindex, &modelid, txdname[], txdnamelen = sizeof(txdname), texturename[], texturenamelen = sizeof(texturename), &materialcoor);
+native GetObjectMaterialText(objectid, materialindex, text[], textlen = sizeof(text), &materialsize, fontface[], fontfacelen = sizeof(fontface), &fontsize, &bold, &fontcolor, &backcolor, &textalignment);
+native IsObjectNoCameraCol(objectid);
+
+// Objects get - player
+native Float:GetPlayerObjectDrawDistance(playerid, objectid);
+native SetPlayerObjectMoveSpeed(playerid, objectid, Float:fSpeed);
+native Float:GetPlayerObjectMoveSpeed(playerid, objectid);
+native Float:GetPlayerObjectTarget(playerid, objectid, &Float:fX, &Float:fY, &Float:fZ);
+native GetPlayerObjectAttachedData(playerid, objectid, &attached_vehicleid, &attached_objectid, &attached_playerid);
+native GetPlayerObjectAttachedOffset(playerid, objectid, &Float:fX, &Float:fY, &Float:fZ, &Float:fRotX, &Float:fRotY, &Float:fRotZ);
+native IsPlayerObjectMaterialSlotUsed(playerid, objectid, materialindex); // Return values: 1 = material, 2 = material text
+native GetPlayerObjectMaterial(playerid, objectid, materialindex, &modelid, txdname[], txdnamelen = sizeof(txdname), texturename[], texturenamelen = sizeof(texturename), &materialcolor);
+native GetPlayerObjectMaterialText(playerid, objectid, materialindex, text[], textlen = sizeof(text), &materialsize, fontface[], fontfacelen = sizeof(fontface), &fontsize, &bold, &fontcolor, &backcolor, &textalignment);
+native IsPlayerObjectNoCameraCol(playerid, objectid);
+native GetPlayerSurfingPlayerObjectID(playerid);
+native GetPlayerCameraTargetPlayerObj(playerid);
+native GetObjectType(playerid, objectid);
+
+// special - for attached objects
+native GetPlayerAttachedObject(playerid, index, &modelid, &bone, &Float:fX, &Float:fY, &Float:fZ, &Float:fRotX, &Float:fRotY, &Float:fRotZ, &Float:fSacleX, &Float:fScaleY, &Float:fScaleZ, &materialcolor1, &materialcolor2);
+
+//n_ative AttachPlayerObjectToPlayer(objectplayer, objectid, attachplayer, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:rX, Float:rY, Float:rZ);
+native AttachPlayerObjectToObject(playerid, objectid, attachtoid, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:RotX, Float:RotY, Float:RotZ, SyncRotation = 1);
+
+// RakNet ban functions
+native ClearBanList();
+native IsBanned(const ipaddress[]);
+
+// RakNet
+native SetTimeoutTime(playerid, time_ms);
+native GetMTUSize();
+native GetLocalIP(index, localip[], len = sizeof(localip));
+
+// Vehicle functions
+native GetVehicleSpawnInfo(vehicleid, &Float:fX, &Float:fY, &Float:fZ, &Float:fRot, &color1, &color2);
+native SetVehicleSpawnInfo(vehicleid, modelid, Float:fX, Float:fY, Float:fZ, Float:fAngle, color1, color2, respawntime = -2, interior = -2);
+#if !defined GetVehicleColor
+native GetVehicleColor(vehicleid, &color1, &color2);
+#endif
+#if !defined GetVehiclePaintjob
+native GetVehiclePaintjob(vehicleid);
+#endif
+#if !defined GetVehicleInterior
+native GetVehicleInterior(vehicleid);
+#endif
+native GetVehicleNumberPlate(vehicleid, plate[], len = sizeof(plate));
+native SetVehicleRespawnDelay(vehicleid, delay);
+native GetVehicleRespawnDelay(vehicleid);
+native SetVehicleOccupiedTick(vehicleid, ticks);
+native GetVehicleOccupiedTick(vehicleid); // GetTickCount() - GetVehicleOccupiedTick(vehicleid) = time passed since vehicle is occupied, in ms
+native SetVehicleRespawnTick(vehicleid, ticks);
+native GetVehicleRespawnTick(vehicleid); // GetTickCount() - GetVehicleRespawnTick(vehicleid) = time passed since vehicle spawned, in ms
+native GetVehicleLastDriver(vehicleid);
+native GetVehicleCab(vehicleid);
+native HasVehicleBeenOccupied(vehicleid);
+native SetVehicleBeenOccupied(vehicleid, occupied);
+native IsVehicleOccupied(vehicleid);
+native IsVehicleDead(vehicleid);
+native GetVehicleModelCount(modelid);
+native GetVehicleModelsUsed();
+native SetVehicleParamsSirenState(vehicleid, sirenState);
+native ToggleVehicleSirenEnabled(vehicleid, bool:enabled);
+native IsVehicleSirenEnabled(vehicleid);
+native GetVehicleMatrix(vehicleid, &Float:rightX, &Float:rightY, &Float:rightZ, &Float:upX, &Float:upY, &Float:upZ, &Float:atX, &Float:atY, &Float:atZ);
+native SetVehicleMatrix(vehicleid, Float:rightX, Float:rightY, Float:rightZ, Float:upX, Float:upY, Float:upZ, Float:atX, Float:atY, Float:atZ);
+
+// Gangzones - Global
+native IsValidGangZone(zoneid);
+native IsPlayerInGangZone(playerid, zoneid);
+native IsGangZoneVisibleForPlayer(playerid, zoneid);
+native GangZoneGetColorForPlayer(playerid, zoneid);
+native GangZoneGetFlashColorForPlayer(playerid, zoneid);
+native IsGangZoneFlashingForPlayer(playerid, zoneid);
+native GangZoneGetPos(zoneid, &Float:fMinX, &Float:fMinY, &Float:fMaxX, &Float:fMaxY);
+
+// Gangzones - Player
+native CreatePlayerGangZone(playerid, Float:minx, Float:miny, Float:maxx, Float:maxy);
+native PlayerGangZoneDestroy(playerid, zoneid);
+native PlayerGangZoneShow(playerid, zoneid, color);
+native PlayerGangZoneHide(playerid, zoneid);
+native PlayerGangZoneFlash(playerid, zoneid, color);
+native PlayerGangZoneStopFlash(playerid, zoneid);
+native IsValidPlayerGangZone(playerid, zoneid);
+native IsPlayerInPlayerGangZone(playerid, zoneid);
+native IsPlayerGangZoneVisible(playerid, zoneid);
+native PlayerGangZoneGetColor(playerid, zoneid);
+native PlayerGangZoneGetFlashColor(playerid, zoneid);
+native IsPlayerGangZoneFlashing(playerid, zoneid);
+native PlayerGangZoneGetPos(playerid, zoneid, &Float:fMinX, &Float:fMinY, &Float:fMaxX, &Float:fMaxY);
+
+// Textdraw - Global
+native IsValidTextDraw(Text:textdrawid);
+native IsTextDrawVisibleForPlayer(playerid, Text:textdrawid);
+native TextDrawGetString(Text:textdrawid, text[], len = sizeof(text));
+native TextDrawSetPos(Text:textdrawid, Float:fX, Float:fY); // You can change textdraw pos with it, but you need to use TextDrawShowForPlayer() after that
+native TextDrawGetLetterSize(Text:textdrawid, &Float:fX, &Float:fY);
+native TextDrawGetTextSize(Text:textdrawid, &Float:fX, &Float:fY);
+native TextDrawGetPos(Text:textdrawid, &Float:fX, &Float:fY);
+native TextDrawGetColor(Text:textdrawid);
+native TextDrawGetBoxColor(Text:textdrawid);
+native TextDrawGetBackgroundColor(Text:textdrawid);
+native TextDrawGetShadow(Text:textdrawid);
+native TextDrawGetOutline(Text:textdrawid);
+native TextDrawGetFont(Text:textdrawid);
+native TextDrawIsBox(Text:textdrawid);
+native TextDrawIsProportional(Text:textdrawid);
+native TextDrawIsSelectable(Text:textdrawid);
+native TextDrawGetAlignment(Text:textdrawid);
+native TextDrawGetPreviewModel(Text:textdrawid);
+native TextDrawGetPreviewRot(Text:textdrawid, &Float:fRotX, &Float:fRotY, &Float:fRotZ, &Float:fZoom);
+native TextDrawGetPreviewVehCol(Text:textdrawid, &color1, &color2);
+
+// Textdraw - Player
+native IsValidPlayerTextDraw(playerid, PlayerText:textdrawid);
+native IsPlayerTextDrawVisible(playerid, PlayerText:textdrawid);
+native PlayerTextDrawGetString(playerid, PlayerText:textdrawid, text[], len = sizeof(text));
+native PlayerTextDrawSetPos(playerid, PlayerText:textdrawid, Float:fX, Float:fY);
+native PlayerTextDrawGetLetterSize(playerid, PlayerText:textdrawid, &Float:fX, &Float:fY);
+native PlayerTextDrawGetTextSize(playerid, PlayerText:textdrawid, &Float:fX, &Float:fY);
+native PlayerTextDrawGetPos(playerid, PlayerText:textdrawid, &Float:fX, &Float:fY);
+native PlayerTextDrawGetColor(playerid, PlayerText:textdrawid);
+native PlayerTextDrawGetBoxColor(playerid, PlayerText:textdrawid);
+native PlayerTextDrawGetBackgroundCol(playerid, PlayerText:textdrawid);
+native PlayerTextDrawGetShadow(playerid, PlayerText:textdrawid);
+native PlayerTextDrawGetOutline(playerid, PlayerText:textdrawid);
+native PlayerTextDrawGetFont(playerid, PlayerText:textdrawid);
+native PlayerTextDrawIsBox(playerid, PlayerText:textdrawid);
+native PlayerTextDrawIsProportional(playerid, PlayerText:textdrawid);
+native PlayerTextDrawIsSelectable(playerid, PlayerText:textdrawid);
+native PlayerTextDrawGetAlignment(playerid, PlayerText:textdrawid);
+native PlayerTextDrawGetPreviewModel(playerid, PlayerText:textdrawid);
+native PlayerTextDrawGetPreviewRot(playerid, PlayerText:textdrawid, &Float:fRotX, &Float:fRotY, &Float:fRotZ, &Float:fZoom);
+native PlayerTextDrawGetPreviewVehCol(playerid, PlayerText:textdrawid, &color1, &color2);
+
+// 3D Text - Global
+native IsValid3DTextLabel(Text3D:id);
+native Is3DTextLabelStreamedIn(playerid, Text3D:id);
+native Get3DTextLabelText(Text3D:id, text[], len = sizeof(text));
+native Get3DTextLabelColor(Text3D:id);
+native Get3DTextLabelPos(Text3D:id, &Float:fX, &Float:fY, &Float:fZ);
+native Float:Get3DTextLabelDrawDistance(Text3D:id);
+native Get3DTextLabelLOS(Text3D:id);
+native Get3DTextLabelVirtualWorld(Text3D:id);
+native Get3DTextLabelAttachedData(Text3D:id, &attached_playerid, &attached_vehicleid);
+
+// 3D Text - Player
+native IsValidPlayer3DTextLabel(playerid, PlayerText3D:id);
+native GetPlayer3DTextLabelText(playerid, PlayerText3D:id, text[], len = sizeof(text));
+native GetPlayer3DTextLabelColor(playerid, PlayerText3D:id);
+native GetPlayer3DTextLabelPos(playerid, PlayerText3D:id, &Float:fX, &Float:fY, &Float:fZ);
+native Float:GetPlayer3DTextLabelDrawDist(playerid, PlayerText3D:id);
+native GetPlayer3DTextLabelLOS(playerid, PlayerText3D:id);
+native GetPlayer3DTextLabelVirtualW(playerid, PlayerText3D:id);
+native GetPlayer3DTextLabelAttached(playerid, PlayerText3D:id, &attached_playerid, &attached_vehicleid);
+
+// Menu
+native IsMenuDisabled(Menu:menuid);
+native IsMenuRowDisabled(Menu:menuid, row);
+native GetMenuColumns(Menu:menuid);
+native GetMenuItems(Menu:menuid, column);
+native GetMenuPos(Menu:menuid, &Float:fX, &Float:fY);
+native GetMenuColumnWidth(Menu:menuid, &Float:fColumn1, &Float:fColumn2);
+native GetMenuColumnHeader(Menu:menuid, column, header[], len = sizeof(header));
+native GetMenuItem(Menu:menuid, column, itemid, item[], len = sizeof(item));
+
+// Pickups - Global
+native IsValidPickup(pickupid);
+native IsPickupStreamedIn(playerid, pickupid);
+native GetPickupPos(pickupid, &Float:fX, &Float:fY, &Float:fZ);
+native GetPickupModel(pickupid);
+native GetPickupType(pickupid);
+native GetPickupVirtualWorld(pickupid);
+/*
+// Pickups - Player
+native CreatePlayerPickup(playerid, model, type, Float:X, Float:Y, Float:Z, virtualworld = 0);
+native DestroyPlayerPickup(playerid, pickupid);
+native IsValidPlayerPickup(playerid, pickupid);
+native IsPlayerPickupStreamedIn(playerid, pickupid);
+native GetPlayerPickupPos(playerid, pickupid, &Float:fX, &Float:fY, &Float:fZ);
+native GetPlayerPickupModel(playerid, pickupid);
+native GetPlayerPickupType(playerid, pickupid);
+native GetPlayerPickupVirtualWorld(playerid, pickupid);
+*/
+// Y_Less's model sizes inc
+native GetColCount();
+native Float:GetColSphereRadius(modelid);
+native GetColSphereOffset(modelid, &Float:fX, &Float:fY, &Float:fZ);
+
+// Formatting
+native SendClientMessagef(playerid, color, const message[], {Float,_}:...);
+native SendClientMessageToAllf(color, const message[], {Float,_}:...);
+native GameTextForPlayerf(playerid, displaytime, style, const message[], {Float,_}:...);
+native GameTextForAllf(displaytime, style, const message[], {Float,_}:...);
+native SendPlayerMessageToPlayerf(playerid, senderid, const message[], {Float,_}:...);
+native SendPlayerMessageToAllf(senderid, const message[], {Float,_}:...);
+native SendRconCommandf(const command[], {Float,_}:...);
+
+// Callbacks
+forward OnPlayerEnterGangZone(playerid, zoneid);
+forward OnPlayerLeaveGangZone(playerid, zoneid);
+forward OnPlayerEnterPlayerGangZone(playerid, zoneid);
+forward OnPlayerLeavePlayerGangZone(playerid, zoneid);
+forward OnPlayerPickUpPlayerPickup(playerid, pickupid);
+forward OnPlayerPauseStateChange(playerid, pausestate);
+forward OnPlayerStatsAndWeaponsUpdate(playerid);
+forward OnRemoteRCONPacket(const ipaddr[], port, const password[], success, const command[]);
+forward OnServerMessage(const msg[]);
+forward OnPlayerClientGameInit(playerid, &usecjwalk, &limitglobalchat, &Float:globalchatradius, &Float:nametagdistance, &disableenterexits, &nametaglos, &manualvehengineandlights, &spawnsavailable, &shownametags, &showplayermarkers, &onfoot_rate, &incar_rate, &weapon_rate, &lacgompmode, &vehiclefriendlyfire);
+forward OnOutcomeScmEvent(playerid, issuerid, E_SCM_EVENT_TYPE:eventid, vehicleid, arg1, arg2);
+forward OnServerQueryInfo(addr[], hostname[51], gameMode[31], language[31]);
+
+//////////////////////////////////////////////////////////////
+// Fixes
+//////////////////////////////////////////////////////////////
+
+// No comment..
+#if !defined IsValidVehicle
+	native IsValidVehicle(vehicleid);
+#endif
+
+#if !defined GetGravity
+	native Float:GetGravity();
+#endif
+
+native GetWeather();
+native GetWeaponSlot(weaponid);
+
+enum
+{
+	BS_BOOL,
+	BS_CHAR,
+	BS_UNSIGNEDCHAR,
+	BS_SHORT,
+	BS_UNSIGNEDSHORT,
+	BS_INT,
+	BS_UNSIGNEDINT,
+	BS_FLOAT,
+	BS_STRING
+};
+
+// Developer functions
+native SendRPC(playerid, RPC, {Float,_}:...); // playerid == -1 -> broadcast
+native SendData(playerid, {Float,_}:...); // playerid == -1 -> broadcast
+
+/* EXAMPLE
+CMD:pickup(playerid, params[])
+{
+	new
+	    Float:X, Float:Y, Float:Z;
+	GetPlayerPos(playerid, X, Y, Z);
+
+    SendRPC(playerid, 95, // rpcid
+		BS_INT, strval(params), // int - pickupid
+		BS_INT, 1222,    // int - modelid
+		BS_INT, 19,     // int   - type
+		BS_FLOAT, X + 2.0,   // float
+		BS_FLOAT, Y,     // float
+		BS_FLOAT, Z);    // float
+	return 1;
+}
+
+CMD:destroypickup(playerid, params[])
+{
+	SendRPC(playerid, 63, // rpcid
+		BS_INT, strval(params));    // int - pickupid
+	return 1;
+}
+*/
diff --git a/.gitignore b/src/.gitignore
similarity index 99%
rename from .gitignore
rename to src/.gitignore
index bd34223..2518b00 100644
--- a/.gitignore
+++ b/src/.gitignore
@@ -53,7 +53,6 @@ dlldata.c
 *.pidb
 *.svclog
 *.scc
-*.vcxproj
 
 # Chutzpah Test files
 _Chutzpah*
diff --git a/YSF.def b/src/YSF.def
similarity index 100%
rename from YSF.def
rename to src/YSF.def
diff --git a/YSF.rc b/src/YSF.rc
similarity index 100%
rename from YSF.rc
rename to src/YSF.rc
diff --git a/YSF.sln b/src/YSF.sln
similarity index 61%
rename from YSF.sln
rename to src/YSF.sln
index b3608cc..2f10fd2 100644
--- a/YSF.sln
+++ b/src/YSF.sln
@@ -1,16 +1,22 @@
 
-Microsoft Visual Studio Solution File, Format Version 14.00
-# Visual Studio 2015
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "YSF", "YSF.vcxproj", "{0843F08F-F40F-4B9B-1D29-394309558029}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
 		Debug|Win32 = Debug|Win32
+		Release|Any CPU = Release|Any CPU
 		Release|Win32 = Release|Win32
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{0843F08F-F40F-4B9B-1D29-394309558029}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0843F08F-F40F-4B9B-1D29-394309558029}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0843F08F-F40F-4B9B-1D29-394309558029}.Debug|Win32.ActiveCfg = Debug|Win32
 		{0843F08F-F40F-4B9B-1D29-394309558029}.Debug|Win32.Build.0 = Debug|Win32
+		{0843F08F-F40F-4B9B-1D29-394309558029}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0843F08F-F40F-4B9B-1D29-394309558029}.Release|Any CPU.Build.0 = Release|Any CPU
 		{0843F08F-F40F-4B9B-1D29-394309558029}.Release|Win32.ActiveCfg = Release|Win32
 		{0843F08F-F40F-4B9B-1D29-394309558029}.Release|Win32.Build.0 = Release|Win32
 	EndGlobalSection
diff --git a/YSF.vcxproj b/src/YSF.vcxproj
similarity index 94%
rename from YSF.vcxproj
rename to src/YSF.vcxproj
index c550704..6731559 100644
--- a/YSF.vcxproj
+++ b/src/YSF.vcxproj
@@ -1,179 +1,179 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{0843F08F-F40F-4B9B-1D29-394309558029}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>YSF</RootNamespace>
-    <ProjectName>YSF</ProjectName>
-    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v140_xp</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <CharacterSet>MultiByte</CharacterSet>
-    <PlatformToolset>v140_xp</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-    <OutDir>bin\win32\Release\</OutDir>
-    <IntDir>obj\win32\Release\</IntDir>
-    <TargetName>YSF</TargetName>
-    <TargetExt>.dll</TargetExt>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRules />
-    <CodeAnalysisRuleAssemblies />
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <OutDir>bin\win32\Debug\</OutDir>
-    <IntDir>obj\win32\Debug\</IntDir>
-    <TargetName>YSF</TargetName>
-    <TargetExt>.dll</TargetExt>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <CodeAnalysisRules />
-    <CodeAnalysisRuleAssemblies />
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <TreatWarningAsError>true</TreatWarningAsError>
-      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;NDEBUG;SAMPGDK_AMALGAMATION;SUBHOOK_IMPLEMENTATION;_WINSOCK_DEPRECATED_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>include;lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <MinimalRebuild>false</MinimalRebuild>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <WholeProgramOptimization>true</WholeProgramOptimization>
-      <StringPooling>true</StringPooling>
-      <BufferSecurityCheck>true</BufferSecurityCheck>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <OmitFramePointers>true</OmitFramePointers>
-      <StructMemberAlignment>1Byte</StructMemberAlignment>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>BOOST_ALL_NO_LIB;BOOST_CHRONO_HEADER_ONLY;_CRT_SECURE_NO_WARNINGS;NDEBUG;SAMPGDK_AMALGAMATION;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>include;lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ResourceCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>DebugFastLink</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <ImportLibrary>bin\win32\Release\YSF.lib</ImportLibrary>
-      <ModuleDefinitionFile>YSF.def</ModuleDefinitionFile>
-      <OutputFile>C:\Users\Ati\Desktop\SERVER\plugins\YSF.dll</OutputFile>
-      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;psapi.lib;winmm.lib;Ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <RandomizedBaseAddress>false</RandomizedBaseAddress>
-      <DataExecutionPrevention>false</DataExecutionPrevention>
-      <TreatLinkerWarningAsErrors>true</TreatLinkerWarningAsErrors>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <TreatWarningAsError>true</TreatWarningAsError>
-      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;SAMPGDK_AMALGAMATION;SUBHOOK_IMPLEMENTATION;_WINSOCK_DEPRECATED_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>include;lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
-      <ProgramDataBaseFileName>$(OutDir)YSF.pdb</ProgramDataBaseFileName>
-      <Optimization>Disabled</Optimization>
-      <StructMemberAlignment>1Byte</StructMemberAlignment>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>BOOST_ALL_NO_LIB;BOOST_CHRONO_HEADER_ONLY;_CRT_SECURE_NO_WARNINGS;SAMPGDK_AMALGAMATION;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>include;lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ResourceCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <ImportLibrary>bin\win32\Debug\YSF.lib</ImportLibrary>
-      <ModuleDefinitionFile>YSF.def</ModuleDefinitionFile>
-      <TreatLinkerWarningAsErrors>true</TreatLinkerWarningAsErrors>
-      <OutputFile>$(ProjectDir)bin\win32\Debug\YSF.dll</OutputFile>
-      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;Ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="lib\raknet\BitStream.cpp" />
-    <ClCompile Include="lib\sampgdk\sampgdk.c" />
-    <ClCompile Include="lib\sdk\amxplugin.cpp" />
-    <ClCompile Include="lib\subhook\subhook.c" />
-    <ClCompile Include="src\Addresses.cpp" />
-    <ClCompile Include="src\amxfunctions.cpp" />
-    <ClCompile Include="src\CCallbackManager.cpp" />
-    <ClCompile Include="src\CGangZonePool.cpp" />
-    <ClCompile Include="src\CModelSizes.cpp" />
-    <ClCompile Include="src\CPickupPool.cpp" />
-    <ClCompile Include="src\CPlayerData.cpp" />
-    <ClCompile Include="src\CServer.cpp" />
-    <ClCompile Include="src\Functions.cpp" />
-    <ClCompile Include="src\Hooks.cpp" />
-    <ClCompile Include="src\main.cpp" />
-    <ClCompile Include="src\RPCs.cpp" />
-    <ClCompile Include="src\Scripting.cpp" />
-    <ClCompile Include="src\Utils.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="YSF.def" />
-  </ItemGroup>
-  <ItemGroup>
-    <ResourceCompile Include="YSF.rc" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="lib\raknet\BitStream.h" />
-    <ClInclude Include="lib\sampgdk\sampgdk.h" />
-    <ClInclude Include="lib\subhook\subhook.h" />
-    <ClInclude Include="resource.h" />
-    <ClInclude Include="src\Addresses.h" />
-    <ClInclude Include="src\amxfunctions.h" />
-    <ClInclude Include="src\CCallbackManager.h" />
-    <ClInclude Include="src\CGangZonePool.h" />
-    <ClInclude Include="src\CModelSizes.h" />
-    <ClInclude Include="src\CPickupPool.h" />
-    <ClInclude Include="src\CPlayerData.h" />
-    <ClInclude Include="src\CServer.h" />
-    <ClInclude Include="src\CVector.h" />
-    <ClInclude Include="src\Functions.h" />
-    <ClInclude Include="src\Hooks.h" />
-    <ClInclude Include="src\main.h" />
-    <ClInclude Include="src\RPCs.h" />
-    <ClInclude Include="src\Scripting.h" />
-    <ClInclude Include="src\Structs.h" />
-    <ClInclude Include="src\Utils.h" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{0843F08F-F40F-4B9B-1D29-394309558029}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>YSF</RootNamespace>
+    <ProjectName>YSF</ProjectName>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v100</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v100</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>bin\win32\Release\</OutDir>
+    <IntDir>obj\win32\Release\</IntDir>
+    <TargetName>YSF</TargetName>
+    <TargetExt>.dll</TargetExt>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>bin\win32\Debug\</OutDir>
+    <IntDir>obj\win32\Debug\</IntDir>
+    <TargetName>YSF</TargetName>
+    <TargetExt>.dll</TargetExt>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;NDEBUG;SAMPGDK_AMALGAMATION;SUBHOOK_IMPLEMENTATION;_WINSOCK_DEPRECATED_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>include;lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <MinimalRebuild>false</MinimalRebuild>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <StringPooling>true</StringPooling>
+      <BufferSecurityCheck>true</BufferSecurityCheck>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StructMemberAlignment>1Byte</StructMemberAlignment>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>BOOST_ALL_NO_LIB;BOOST_CHRONO_HEADER_ONLY;_CRT_SECURE_NO_WARNINGS;NDEBUG;SAMPGDK_AMALGAMATION;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>include;lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ResourceCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <ImportLibrary>bin\win32\Release\YSF.lib</ImportLibrary>
+      <ModuleDefinitionFile>YSF.def</ModuleDefinitionFile>
+      <OutputFile>$(ProjectDir)bin\win32\Release\YSF.dll</OutputFile>
+      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;psapi.lib;winmm.lib;Ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+      <DataExecutionPrevention>false</DataExecutionPrevention>
+      <TreatLinkerWarningAsErrors>true</TreatLinkerWarningAsErrors>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;SAMPGDK_AMALGAMATION;SUBHOOK_IMPLEMENTATION;_WINSOCK_DEPRECATED_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>include;lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <ProgramDataBaseFileName>$(OutDir)YSF.pdb</ProgramDataBaseFileName>
+      <Optimization>Disabled</Optimization>
+      <StructMemberAlignment>1Byte</StructMemberAlignment>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>BOOST_ALL_NO_LIB;BOOST_CHRONO_HEADER_ONLY;_CRT_SECURE_NO_WARNINGS;SAMPGDK_AMALGAMATION;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>include;lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ResourceCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ImportLibrary>bin\win32\Debug\YSF.lib</ImportLibrary>
+      <ModuleDefinitionFile>YSF.def</ModuleDefinitionFile>
+      <TreatLinkerWarningAsErrors>true</TreatLinkerWarningAsErrors>
+      <OutputFile>$(ProjectDir)bin\win32\Debug\YSF.dll</OutputFile>
+      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;Ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="lib\raknet\BitStream.cpp" />
+    <ClCompile Include="lib\sampgdk\sampgdk.c" />
+    <ClCompile Include="lib\sdk\amxplugin.cpp" />
+    <ClCompile Include="lib\subhook\subhook.c" />
+    <ClCompile Include="src\Addresses.cpp" />
+    <ClCompile Include="src\amxfunctions.cpp" />
+    <ClCompile Include="src\CCallbackManager.cpp" />
+    <ClCompile Include="src\CGangZonePool.cpp" />
+    <ClCompile Include="src\CModelSizes.cpp" />
+    <ClCompile Include="src\CPickupPool.cpp" />
+    <ClCompile Include="src\CPlayerData.cpp" />
+    <ClCompile Include="src\CServer.cpp" />
+    <ClCompile Include="src\Functions.cpp" />
+    <ClCompile Include="src\Hooks.cpp" />
+    <ClCompile Include="src\main.cpp" />
+    <ClCompile Include="src\RPCs.cpp" />
+    <ClCompile Include="src\Scripting.cpp" />
+    <ClCompile Include="src\Utils.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="YSF.def" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="YSF.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="lib\raknet\BitStream.h" />
+    <ClInclude Include="lib\sampgdk\sampgdk.h" />
+    <ClInclude Include="lib\subhook\subhook.h" />
+    <ClInclude Include="resource.h" />
+    <ClInclude Include="src\Addresses.h" />
+    <ClInclude Include="src\amxfunctions.h" />
+    <ClInclude Include="src\CCallbackManager.h" />
+    <ClInclude Include="src\CGangZonePool.h" />
+    <ClInclude Include="src\CModelSizes.h" />
+    <ClInclude Include="src\CPickupPool.h" />
+    <ClInclude Include="src\CPlayerData.h" />
+    <ClInclude Include="src\CServer.h" />
+    <ClInclude Include="src\CVector.h" />
+    <ClInclude Include="src\Functions.h" />
+    <ClInclude Include="src\Hooks.h" />
+    <ClInclude Include="src\main.h" />
+    <ClInclude Include="src\RPCs.h" />
+    <ClInclude Include="src\Scripting.h" />
+    <ClInclude Include="src\Structs.h" />
+    <ClInclude Include="src\Utils.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
 </Project>
\ No newline at end of file
diff --git a/YSF.vcxproj.filters b/src/YSF.vcxproj.filters
similarity index 100%
rename from YSF.vcxproj.filters
rename to src/YSF.vcxproj.filters
diff --git a/lib/raknet/BitStream.cpp b/src/lib/raknet/BitStream.cpp
similarity index 100%
rename from lib/raknet/BitStream.cpp
rename to src/lib/raknet/BitStream.cpp
diff --git a/lib/raknet/BitStream.h b/src/lib/raknet/BitStream.h
similarity index 99%
rename from lib/raknet/BitStream.h
rename to src/lib/raknet/BitStream.h
index 6798d86..ccd911d 100644
--- a/lib/raknet/BitStream.h
+++ b/src/lib/raknet/BitStream.h
@@ -838,7 +838,9 @@ namespace RakNet
 	template <>
 		inline void BitStream::WriteCompressed(float var)
 	{
+#ifdef _DEBUG
 		assert(var > -1.01f && var < 1.01f);
+#endif
 		if (var < -1.0f)
 			var=-1.0f;
 		if (var > 1.0f)
@@ -850,7 +852,9 @@ namespace RakNet
 	template <>
 		inline void BitStream::WriteCompressed(double var)
 	{
+#ifdef _DEBUG
 		assert(var > -1.01 && var < 1.01);
+#endif
 		if (var < -1.0f)
 			var=-1.0f;
 		if (var > 1.0f)
diff --git a/lib/sampgdk/sampgdk.c b/src/lib/sampgdk/sampgdk.c
similarity index 100%
rename from lib/sampgdk/sampgdk.c
rename to src/lib/sampgdk/sampgdk.c
diff --git a/lib/sampgdk/sampgdk.h b/src/lib/sampgdk/sampgdk.h
similarity index 100%
rename from lib/sampgdk/sampgdk.h
rename to src/lib/sampgdk/sampgdk.h
diff --git a/lib/sdk/amx/amx.h b/src/lib/sdk/amx/amx.h
similarity index 100%
rename from lib/sdk/amx/amx.h
rename to src/lib/sdk/amx/amx.h
diff --git a/lib/sdk/amx/getch.h b/src/lib/sdk/amx/getch.h
similarity index 100%
rename from lib/sdk/amx/getch.h
rename to src/lib/sdk/amx/getch.h
diff --git a/lib/sdk/amx/sclinux.h b/src/lib/sdk/amx/sclinux.h
similarity index 100%
rename from lib/sdk/amx/sclinux.h
rename to src/lib/sdk/amx/sclinux.h
diff --git a/lib/sdk/amxplugin.cpp b/src/lib/sdk/amxplugin.cpp
similarity index 100%
rename from lib/sdk/amxplugin.cpp
rename to src/lib/sdk/amxplugin.cpp
diff --git a/lib/sdk/plugin.h b/src/lib/sdk/plugin.h
similarity index 100%
rename from lib/sdk/plugin.h
rename to src/lib/sdk/plugin.h
diff --git a/lib/sdk/plugincommon.h b/src/lib/sdk/plugincommon.h
similarity index 100%
rename from lib/sdk/plugincommon.h
rename to src/lib/sdk/plugincommon.h
diff --git a/lib/subhook/subhook.c b/src/lib/subhook/subhook.c
similarity index 100%
rename from lib/subhook/subhook.c
rename to src/lib/subhook/subhook.c
diff --git a/lib/subhook/subhook.h b/src/lib/subhook/subhook.h
similarity index 100%
rename from lib/subhook/subhook.h
rename to src/lib/subhook/subhook.h
diff --git a/lib/subhook/subhook_linux.c b/src/lib/subhook/subhook_linux.c
similarity index 100%
rename from lib/subhook/subhook_linux.c
rename to src/lib/subhook/subhook_linux.c
diff --git a/lib/subhook/subhook_private.h b/src/lib/subhook/subhook_private.h
similarity index 100%
rename from lib/subhook/subhook_private.h
rename to src/lib/subhook/subhook_private.h
diff --git a/lib/subhook/subhook_windows.c b/src/lib/subhook/subhook_windows.c
similarity index 100%
rename from lib/subhook/subhook_windows.c
rename to src/lib/subhook/subhook_windows.c
diff --git a/lib/subhook/subhook_x86.c b/src/lib/subhook/subhook_x86.c
similarity index 100%
rename from lib/subhook/subhook_x86.c
rename to src/lib/subhook/subhook_x86.c
diff --git a/makefile b/src/makefile
similarity index 100%
rename from makefile
rename to src/makefile
diff --git a/resource.h b/src/resource.h
similarity index 100%
rename from resource.h
rename to src/resource.h
diff --git a/src/Addresses.cpp b/src/src/Addresses.cpp
similarity index 89%
rename from src/Addresses.cpp
rename to src/src/Addresses.cpp
index 3818dd8..46b5e31 100644
--- a/src/Addresses.cpp
+++ b/src/src/Addresses.cpp
@@ -24,6 +24,7 @@ DWORD CAddress::VAR_ppRakServer = NULL;
 
 // Variables
 DWORD CAddress::VAR_pRestartWaitTime = NULL;
+DWORD CAddress::VAR_pPosSyncBounds[4];
 
 // Functions
 DWORD CAddress::FUNC_CConsole__AddStringVariable = NULL;
@@ -64,11 +65,24 @@ DWORD CAddress::ADDR_RecordingDirectory = NULL;
 void CAddress::Initialize(eSAMPVersion sampVersion)
 {
 	// Thx for Whitetiger
-	DWORD dwRestartTime; 
+	DWORD dwRestartTime, dwPosSyncBounds;
 #ifdef _WIN32
 	dwRestartTime =								FindPattern("\xD9\x15\x00\x00\x00\x00\xD8\x1D\x00\x00\x00\x00\xDF\xE0\xF6\xC4\x41\x75\x07", "xx????xx????xxxxxxx") + 6;
 	VAR_pRestartWaitTime =						 *(DWORD*)(dwRestartTime + 2);
- 
+
+	dwPosSyncBounds =							FindPattern("Shot out of bounds.\0", "xxxxxxxxxxxxxxxxxxxx");
+	if(dwPosSyncBounds)
+	{
+		VAR_pPosSyncBounds[0] = dwPosSyncBounds + 20;
+		VAR_pPosSyncBounds[1] = VAR_pPosSyncBounds[0] + 4;
+	}
+	dwPosSyncBounds =							FindPattern("Offset out of bounds.\0\0\0", "xxxxxxxxxxxxxxxxxxxxxxxx");
+	if(dwPosSyncBounds)
+	{
+		VAR_pPosSyncBounds[2] = dwPosSyncBounds + 24;
+	}					
+	VAR_pPosSyncBounds[3] =						FindPattern("\x00\x50\x43\x48\x00\x00\xC8\xC2\x00\x00\x00\x3F\xB2\x00\x00\x00\xAD\x00\x00\x00\xAE\x00\x00\x00maxnpc", "????xxxxxxxxxxxxxxxxxxxxxxxxxx");
+
 	FUNC_CConsole__AddStringVariable =			FindPattern("\x53\x56\x57\x8B\x7C\x24\x18\x85\xFF", "xxxxxxxxx");
 	FUNC_CConsole__GetStringVariable =			FindPattern("\x8B\x44\x24\x04\x50\xE8\x00\x00\x00\x00\x85\xC0\x74\x0B", "xxxxxx????xxxx");
 	FUNC_CConsole__SetStringVariable =			FindPattern("\x8B\x44\x24\x04\x53\x50\xE8\xD5\xFE\xFF\xFF\x8B\xD8\x85\xDB", "xxxxxxx???xxxx");
@@ -106,6 +120,16 @@ void CAddress::Initialize(eSAMPVersion sampVersion)
 
 	// Thx for Mellnik
 	VAR_pRestartWaitTime = 						NULL;
+	/*
+	dwPosSyncBounds =							FindPattern("\x00\x00\x80\xBF\x00\x40\x9C\x46\x00\x40\x9C\xC6\x00\x50\x43\x48\x00\x00\x7A\xC4\x00\x00\xC8\x42\x00\x00\xC8\xC2\x00\x00\x00\x3F\x00\x00\x00\xC0", "xxxx????????????????xxxxxxxxxxxxxxxx");
+	if(dwPosSyncBounds)
+	{
+		VAR_pPosSyncBounds[0] = dwPosSyncBounds+8;
+		VAR_pPosSyncBounds[1] = dwPosSyncBounds+4;
+		VAR_pPosSyncBounds[2] = dwPosSyncBounds+20;
+		VAR_pPosSyncBounds[3] = dwPosSyncBounds+12;
+	}
+	*/
 
 	FUNC_CConsole__AddStringVariable = 			FindPattern("\x55\x89\xE5\x56\x53\x83\xEC\x00\x8B\x75\x00\x85\xF6\x74\x00\x89\x34\x24", "xxxxxxx?xx?xxx?xxx");
 	FUNC_CConsole__GetStringVariable =			FUNC_CConsole__AddStringVariable - 0x760;//0x80A0190;
@@ -148,6 +172,10 @@ void CAddress::Initialize(eSAMPVersion sampVersion)
 		case SAMP_VERSION_037_R2:
 		{
 			VAR_pRestartWaitTime =						0x0815A528; // 12.0
+			VAR_pPosSyncBounds[0] =						0x08150710;
+			VAR_pPosSyncBounds[1] =						0x0815070C;
+			VAR_pPosSyncBounds[2] =						0x08150718;
+			VAR_pPosSyncBounds[3] =						0x08150714;
 			ADDR_RecordingDirectory =					0x080CC7D1;
 			FUNC_CVehicle__Respawn =					0x814B4C0;
 			FUNC_CPlayerPool__HandleVehicleRespawn =	0x80D1480;
@@ -190,6 +218,13 @@ void CAddress::Initialize(eSAMPVersion sampVersion)
 	// Unlock restart wait time
 	if (VAR_pRestartWaitTime)
 		Unlock((void*)VAR_pRestartWaitTime, 4);
+	for(BYTE i = 0; i < 4; i++)
+	{
+		if(VAR_pPosSyncBounds[i])
+		{
+			Unlock((void*)VAR_pPosSyncBounds[i], 4);
+		}
+	}
 
 	// Patch GetNetworkStats to get more advanced stats than default
 	if(ADDR_GetNetworkStats_VerbosityLevel)
diff --git a/src/Addresses.h b/src/src/Addresses.h
similarity index 94%
rename from src/Addresses.h
rename to src/src/Addresses.h
index 98d8809..14cc929 100644
--- a/src/Addresses.h
+++ b/src/src/Addresses.h
@@ -43,6 +43,12 @@
 	#define RAKNET_RECEIVE_OFFSET		11
 #endif
 
+#ifdef CUSTOM_BANLIST
+	#define RAKNET_ADD_BAN_OFFSET		61
+	#define RAKNET_REMOVE_BAN_OFFSET    62
+	#define RAKNET_CLEAR_BANS_OFFSET    63
+#endif
+
 #include <vector>
 
 enum eSAMPVersion
@@ -74,6 +80,7 @@ class CAddress
 
 	// Variables
 	static DWORD			VAR_pRestartWaitTime;
+	static DWORD			VAR_pPosSyncBounds[4];
 
 	// Functions
 	static DWORD			FUNC_CConsole__AddStringVariable;
diff --git a/src/CCallbackManager.cpp b/src/src/CCallbackManager.cpp
similarity index 76%
rename from src/CCallbackManager.cpp
rename to src/src/CCallbackManager.cpp
index 7587040..b24fe18 100644
--- a/src/CCallbackManager.cpp
+++ b/src/src/CCallbackManager.cpp
@@ -212,6 +212,10 @@ bool CCallbackManager::OnServerMessage(char* message)
 
 bool CCallbackManager::OnRemoteRCONPacket(unsigned int binaryAddress, int port, char *password, bool success, char* command)
 {
+	in_addr in;
+	in.s_addr = binaryAddress;
+	char *addr = inet_ntoa(in);
+
 	int idx = -1;
 	cell ret = 1;
 	for(std::vector<AMX*>::const_iterator iter = m_vecAMX.begin(); iter != m_vecAMX.end(); ++iter)
@@ -220,14 +224,12 @@ bool CCallbackManager::OnRemoteRCONPacket(unsigned int binaryAddress, int port,
 		{
 			cell amx_addr, *phys_addr;
 			
-			in_addr in;
-			in.s_addr = binaryAddress;
 
 			amx_PushString(*iter, &amx_addr, &phys_addr, command, 0, 0);
 			amx_Push(*iter, static_cast<cell>(success));
-			amx_PushString(*iter, &amx_addr, &phys_addr, password, 0, 0);
+			amx_PushString(*iter, NULL, &phys_addr, password, 0, 0);
 			amx_Push(*iter, static_cast<cell>(port));
-			amx_PushString(*iter, &amx_addr, &phys_addr, inet_ntoa(in), 0, 0);
+			amx_PushString(*iter, NULL, &phys_addr, addr, 0, 0);
 			amx_Exec(*iter, &ret, idx);
 			amx_Release(*iter, amx_addr);
 
@@ -278,7 +280,7 @@ void CCallbackManager::OnPlayerClientGameInit(WORD playerid, bool* usecjwalk, bo
 	{
 		if (!amx_FindPublic(*iter, "OnPlayerClientGameInit", &idx))
 		{
-			cell addr = NULL, amx_addr, amx_addr_last = NULL, *phys_ptr, *temp_ptr;
+			cell amx_addr, amx_addr_last, *phys_ptr, *temp_ptr;
 
 			dwTemp = *vehiclefriendlyfire;
 			amx_PushArray(*iter, &amx_addr, &phys_ptr, reinterpret_cast<cell*>(&dwTemp), 1);							// 0
@@ -297,8 +299,8 @@ void CCallbackManager::OnPlayerClientGameInit(WORD playerid, bool* usecjwalk, bo
 			amx_PushArray(*iter, &amx_addr_last, &temp_ptr, reinterpret_cast<cell*>(&dwTemp), 1);						// 9
 			dwTemp = *disableenterexits;
 			amx_PushArray(*iter, &amx_addr_last, &temp_ptr, reinterpret_cast<cell*>(&dwTemp), 1);						// 10
-			amx_PushArray(*iter, &amx_addr_last, &temp_ptr, reinterpret_cast<cell*>(amx_ftoc(nametagdistance)), 1);		// 11
-			amx_PushArray(*iter, &amx_addr_last, &temp_ptr, reinterpret_cast<cell*>(amx_ftoc(globalchatradius)), 1);	// 12
+			amx_PushArray(*iter, &amx_addr_last, &temp_ptr, &amx_ftoc(*nametagdistance), 1);							// 11
+			amx_PushArray(*iter, &amx_addr_last, &temp_ptr, &amx_ftoc(*globalchatradius), 1);							// 12
 			dwTemp = *limitglobalchat;
 			amx_PushArray(*iter, &amx_addr_last, &temp_ptr, reinterpret_cast<cell*>(&dwTemp), 1);						// 13
 			dwTemp = *usecjwalk;
@@ -306,10 +308,8 @@ void CCallbackManager::OnPlayerClientGameInit(WORD playerid, bool* usecjwalk, bo
 		
 			amx_Push(*iter, static_cast<cell>(playerid));
 			amx_Exec(*iter, &ret, idx);
-			for(int i = 0; i != ((amx_addr_last - amx_addr) / 4); i++)
-			{
-				amx_Release(*iter, amx_addr + (i * 4));
-			}
+
+			amx_Release(*iter, amx_addr);
 			
 			*vehiclefriendlyfire = static_cast<int>(phys_ptr[0]) != 0;
 			*lacgompmode = static_cast<int>(phys_ptr[1]);
@@ -329,3 +329,89 @@ void CCallbackManager::OnPlayerClientGameInit(WORD playerid, bool* usecjwalk, bo
 		}
 	}
 }
+
+bool CCallbackManager::OnOutcomeScmEvent(WORD playerid, WORD issuerid, int eventid, int vehicleid, int arg1, int arg2)
+{
+	int idx = -1;
+	cell ret = 1;
+	for(std::vector<AMX*>::const_iterator iter = m_vecAMX.begin(); iter != m_vecAMX.end(); ++iter)
+	{
+		if(!amx_FindPublic(*iter, "OnOutcomeScmEvent", &idx))
+		{
+			amx_Push(*iter, static_cast<cell>(arg2));
+			amx_Push(*iter, static_cast<cell>(arg1));
+			amx_Push(*iter, static_cast<cell>(vehicleid));
+			amx_Push(*iter, static_cast<cell>(eventid));
+			amx_Push(*iter, static_cast<cell>(issuerid));
+			amx_Push(*iter, static_cast<cell>(playerid));
+
+			amx_Exec(*iter, &ret, idx);
+
+			if (!ret) return false;
+		}
+	}
+	return static_cast<int>(ret) != 0;
+}
+
+bool CCallbackManager::OnServerQueryInfo(unsigned int binaryAddress, char (&hostname)[51], char (&gameMode)[31], char (&language)[31])
+{
+	in_addr in;
+	in.s_addr = binaryAddress;
+	char *addr = inet_ntoa(in);
+
+	int idx = -1;
+	cell ret = 0;
+	for(std::vector<AMX*>::const_iterator iter = m_vecAMX.begin(); iter != m_vecAMX.end(); ++iter)
+	{
+		if(!amx_FindPublic(*iter, "OnServerQueryInfo", &idx))
+		{
+			cell amx_addr, amx_addr_last, *phys_addr;
+			
+			cell *outputHostname, *outputGameMode, *outputLanguage;
+
+			cell languageCells[sizeof(language)];
+			for(int i = 0; i < sizeof(language); i++)
+			{
+				languageCells[i] = language[i];
+			}
+			amx_PushArray(*iter, &amx_addr, &outputLanguage, languageCells, sizeof(language));
+
+			cell gameModeCells[sizeof(gameMode)];
+			for(int i = 0; i < sizeof(gameMode); i++)
+			{
+				gameModeCells[i] = gameMode[i];
+			}
+			amx_PushArray(*iter, &amx_addr_last, &outputGameMode, gameModeCells, sizeof(gameMode));
+
+			cell hostnameCells[sizeof(hostname)];
+			for(int i = 0; i < sizeof(hostname); i++)
+			{
+				hostnameCells[i] = hostname[i];
+			}
+			amx_PushArray(*iter, &amx_addr_last, &outputHostname, hostnameCells, sizeof(hostname));
+
+			amx_PushString(*iter, &amx_addr_last, &phys_addr, addr, 0, 0);
+
+			amx_Exec(*iter, &ret, idx);
+			
+			for(int i = 0; i < sizeof(hostname); i++)
+			{
+				hostname[i] = outputHostname[i];
+			}
+			for(int i = 0; i < sizeof(gameMode); i++)
+			{
+				gameMode[i] = outputGameMode[i];
+			}
+			for(int i = 0; i < sizeof(language); i++)
+			{
+				language[i] = outputLanguage[i];
+			}
+
+			amx_Release(*iter, amx_addr);
+
+			if(ret) return true;
+			if(ret != -1) ret = 1;
+		}
+	}
+	return static_cast<int>(ret) == 1;
+}
\ No newline at end of file
diff --git a/src/CCallbackManager.h b/src/src/CCallbackManager.h
similarity index 86%
rename from src/CCallbackManager.h
rename to src/src/CCallbackManager.h
index 9797090..e73bc93 100644
--- a/src/CCallbackManager.h
+++ b/src/src/CCallbackManager.h
@@ -21,6 +21,8 @@ class CCallbackManager
 	static bool OnServerMessage(char* message);
 	static bool OnRemoteRCONPacket(unsigned int binaryAddress, int port, char *password, bool success, char* command);
 	static void OnPlayerClientGameInit(WORD playerid, bool* usecjwalk, bool* limitglobalchat, float* globalchatradius, float* nametagdistance, bool* disableenterexits, bool* nametaglos, bool* manualvehengineandlights, int* spawnsavailable, bool* shownametags, bool* showplayermarkers, int* onfoot_rate, int* incar_rate, int* weapon_rate, int* lacgompmode, bool* vehiclefriendlyfire);
+	static bool OnOutcomeScmEvent(WORD playerid, WORD issuerid, int eventid, int vehicleid, int arg1, int arg2);
+	static bool OnServerQueryInfo(unsigned int binaryAddress, char (&hostname)[51], char (&gameMode)[31], char (&language)[31]);
 
 	// Default SAMP Callbakcs
 	static void	OnPlayerDeath(WORD playerid, WORD killerid, BYTE reason);
diff --git a/src/CGangZonePool.cpp b/src/src/CGangZonePool.cpp
similarity index 96%
rename from src/CGangZonePool.cpp
rename to src/src/CGangZonePool.cpp
index 44a85e9..5722c11 100644
--- a/src/CGangZonePool.cpp
+++ b/src/src/CGangZonePool.cpp
@@ -1,309 +1,309 @@
-#include "main.h"
-
-CGangZonePool::CGangZonePool()
-{
-	// Set every gang zone pointer to NULL
-	memset(pGangZone, NULL, sizeof(pGangZone));
-}
-
-CGangZonePool::~CGangZonePool()
-{
-	for (WORD i = 0; i != MAX_GANG_ZONES; i++)
-	{
-		SAFE_DELETE(pGangZone[i]);
-	}
-}
-
-WORD CGangZonePool::New(float fMinX, float fMinY, float fMaxX, float fMaxY)
-{
-	WORD wZone = 0;
-	while (wZone < MAX_GANG_ZONES)
-	{
-		if (!pGangZone[wZone]) break;
-		wZone++;
-	}
-	if (wZone == MAX_GANG_ZONES) return 0xFFFF;
-	
-	// Allocate memory for gangzone
-	pGangZone[wZone] = new CGangZone();
-	pGangZone[wZone]->fGangZone[0] = fMinX;
-	pGangZone[wZone]->fGangZone[1] = fMinY;
-	pGangZone[wZone]->fGangZone[2] = fMaxX;
-	pGangZone[wZone]->fGangZone[3] = fMaxY;
-	return wZone;
-}
-
-WORD CGangZonePool::New(WORD playerid, float fMinX, float fMinY, float fMaxX, float fMaxY)
-{
-	WORD wZone = 0;
-	while (wZone < MAX_GANG_ZONES)
-	{
-		if (!pPlayerData[playerid]->pPlayerZone[wZone]) break;
-		wZone++;
-	}
-	if (wZone == MAX_GANG_ZONES) return 0xFFFF;
-		
-	// Allocate memory for gangzone
-	pPlayerData[playerid]->pPlayerZone[wZone] = new CGangZone();
-	pPlayerData[playerid]->pPlayerZone[wZone]->fGangZone[0] = fMinX;
-	pPlayerData[playerid]->pPlayerZone[wZone]->fGangZone[1] = fMinY;
-	pPlayerData[playerid]->pPlayerZone[wZone]->fGangZone[2] = fMaxX;
-	pPlayerData[playerid]->pPlayerZone[wZone]->fGangZone[3] = fMaxY;
-	return wZone;
-}
-
-void CGangZonePool::Delete(WORD wZone)
-{
-	for (WORD i = 0; i != MAX_PLAYERS; i++)
-	{
-		// Skip not connected players
-		if (!IsPlayerConnectedEx(i)) continue;
-
-		HideForPlayer(i, wZone);
-	}
-	
-	SAFE_DELETE(pGangZone[wZone]);
-}
-
-void CGangZonePool::Delete(WORD playerid, WORD wZone)
-{
-	HideForPlayer(playerid, wZone, true);
-
-	SAFE_DELETE(pPlayerData[playerid]->pPlayerZone[wZone]);
-}
-
-bool CGangZonePool::ShowForPlayer(WORD playerid, WORD wZone, DWORD dwColor, bool bPlayerZone)
-{	
-	// Find free zone slot on player, client side
-	WORD i = 0;;
-	CGangZone *pZone = NULL;
-
-	while(i != MAX_GANG_ZONES)
-	{
-		if(pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 0xFF) break;
-		i++;
-	}
-	if (i == MAX_GANG_ZONES) return 0;
-
-	// Mark client side zone id as used
-	if(!bPlayerZone)
-	{
-		pZone = pGangZone[wZone];
-		if(!pZone) return 0;
-
-		// Hide the old one, if showed
-		HideForPlayer(playerid, wZone, false);
-
-		pPlayerData[playerid]->byteClientSideZoneIDUsed[i] = 0;
-		pPlayerData[playerid]->wClientSideGlobalZoneID[i] = wZone;
-		
-	}
-	else
-	{
-		pZone = pPlayerData[playerid]->pPlayerZone[wZone];
-		if(!pZone) return 0;
-
-		// Hide the old one, if showed
-		HideForPlayer(playerid, wZone, true);
-
-		pPlayerData[playerid]->byteClientSideZoneIDUsed[i] = 1;
-		pPlayerData[playerid]->wClientSidePlayerZoneID[i] = wZone;
-	}
-	pPlayerData[playerid]->dwClientSideZoneColor[i] = dwColor;
-
-	//logprintf("CGangZonePool::ShowForPlayer playerid = %d, zoneid = %d, clientsideid = %d, bPlayerZone = %d", playerid, wZone, i, bPlayerZone);
-
-	RakNet::BitStream bsParams;
-	bsParams.Write(i);
-	bsParams.Write(pZone->fGangZone[0]);
-	bsParams.Write(pZone->fGangZone[1]);
-	bsParams.Write(pZone->fGangZone[2]);
-	bsParams.Write(pZone->fGangZone[3]);
-	bsParams.Write(RGBA_ABGR(dwColor));
-	pRakServer->RPC(&RPC_ShowGangZone, &bsParams, MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
-	return 1;
-}
-
-void CGangZonePool::ShowForAll(WORD wZone, DWORD dwColor)
-{
-	for(WORD playerid = 0; playerid != MAX_PLAYERS; playerid++)
-	{
-		// Skip not connected players
-		if(!IsPlayerConnectedEx(playerid)) continue;
-
-		WORD i = 0;
-
-		while(i != MAX_GANG_ZONES)
-		{
-			if(pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 0xFF) break;
-			i++;
-		}
-		if (i == MAX_GANG_ZONES) return;
-
-		// Hide the old one, if showed
-		if(pPlayerData[playerid]->byteClientSideZoneIDUsed[i] != 0xFF)
-			HideForPlayer(playerid, wZone, false, false);
-
-		// Mark client side zone id as used
-		pPlayerData[playerid]->byteClientSideZoneIDUsed[i] = 0;
-		pPlayerData[playerid]->wClientSideGlobalZoneID[i] = wZone;
-		pPlayerData[playerid]->dwClientSideZoneColor[i] = dwColor;
-
-		RakNet::BitStream bsParams;
-		bsParams.Write(i);
-		bsParams.Write(pGangZone[wZone]->fGangZone[0]);
-		bsParams.Write(pGangZone[wZone]->fGangZone[1]);
-		bsParams.Write(pGangZone[wZone]->fGangZone[2]);
-		bsParams.Write(pGangZone[wZone]->fGangZone[3]);
-		bsParams.Write(RGBA_ABGR(dwColor));
-		pRakServer->RPC(&RPC_ShowGangZone, &bsParams, MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
-	}
-}
-
-bool CGangZonePool::HideForPlayer(WORD playerid, WORD wZone, bool bPlayerZone, bool bCallCallback)
-{
-	WORD i = 0;
-
-	// Mark client side zone id as unused
-	if(!bPlayerZone)
-	{
-		while(i != MAX_GANG_ZONES)
-		{
-			if(pPlayerData[playerid]->wClientSideGlobalZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 0) break;
-			i++;
-		}
-		if(i == MAX_GANG_ZONES) return 0;
-
-		if (pPlayerData[playerid]->bInGangZone[i] && bCallCallback)
-		{
-			CCallbackManager::OnPlayerLeaveGangZone(playerid, pPlayerData[playerid]->wClientSideGlobalZoneID[i]);
-		}
-
-		pPlayerData[playerid]->wClientSideGlobalZoneID[i] = 0xFFFF;
-	}
-	else
-	{
-		while(i != MAX_GANG_ZONES)
-		{
-			if(pPlayerData[playerid]->wClientSidePlayerZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 1) break;
-			i++;
-		}
-		if(i == MAX_GANG_ZONES) return 0;
-		
-		if (pPlayerData[playerid]->bInGangZone[i] && bCallCallback)
-		{
-			CCallbackManager::OnPlayerLeavePlayerGangZone(playerid, pPlayerData[playerid]->wClientSidePlayerZoneID[i]);
-		}
-
-		pPlayerData[playerid]->wClientSidePlayerZoneID[i] = 0xFFFF;
-	}
-	if (i == MAX_GANG_ZONES) return 0;
-
-	pPlayerData[playerid]->byteClientSideZoneIDUsed[i] = 0xFF;
-	pPlayerData[playerid]->dwClientSideZoneColor[i] = 0;
-	pPlayerData[playerid]->bInGangZone[i] = false;
-	pPlayerData[playerid]->bIsGangZoneFlashing[i] = false;
-
-	//logprintf("CGangZonePool::HideForPlayer playerid = %d, zoneid = %d, clientsideid = %d, bPlayerZone = %d", playerid, wZone, i, bPlayerZone);
-
-	RakNet::BitStream bsParams;
-	bsParams.Write(i);
-	pRakServer->RPC(&RPC_HideGangZone, &bsParams, MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
-	return 1;
-}
-
-void CGangZonePool::HideForAll(WORD wZone)
-{
-	for(WORD i = 0; i != MAX_PLAYERS; i++)
-	{
-		// Skip not connected players
-		if(!IsPlayerConnectedEx(i)) continue;
-
-		HideForPlayer(i, wZone);
-	}
-}
-
-void CGangZonePool::FlashForPlayer(WORD playerid, WORD wZone, DWORD dwColor, bool bPlayerZone)
-{
-	WORD i = 0;
-
-	// check id
-	if(!bPlayerZone)
-	{
-		while(i != MAX_GANG_ZONES)
-		{
-			if(pPlayerData[playerid]->wClientSideGlobalZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 0) break;
-			i++;
-		}
-	}
-	else
-	{
-		while(i != MAX_GANG_ZONES)
-		{
-			if(pPlayerData[playerid]->wClientSidePlayerZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 1) break;
-			i++;
-		}
-	}
-	if (i == MAX_GANG_ZONES) return;
-
-	pPlayerData[playerid]->dwClientSideZoneFlashColor[i] = dwColor;
-	pPlayerData[playerid]->bIsGangZoneFlashing[i] = true;
-
-	RakNet::BitStream bsParams;
-	bsParams.Write(i);
-	bsParams.Write(RGBA_ABGR(dwColor));
-	pRakServer->RPC(&RPC_FlashGangZone, &bsParams, MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
-}
-
-void CGangZonePool::FlashForAll(WORD wZone, DWORD dwColor)
-{
-	for(WORD i = 0; i != MAX_PLAYERS; i++)
-	{
-		// Skip not connected players
-		if(!IsPlayerConnectedEx(i)) continue;
-
-		FlashForPlayer(i, wZone, dwColor);
-	}
-}
-
-void CGangZonePool::StopFlashForPlayer(WORD playerid, WORD wZone, bool bPlayerZone)
-{
-	WORD i = 0;
-
-	// check id
-	if(!bPlayerZone)
-	{
-		while(i != MAX_GANG_ZONES)
-		{
-			if(pPlayerData[playerid]->wClientSideGlobalZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 0) break;
-			i++;
-		}
-	}
-	else
-	{
-		while(i != MAX_GANG_ZONES)
-		{
-			if(pPlayerData[playerid]->wClientSidePlayerZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 1) break;
-			i++;
-		}
-	}
-	if (i == MAX_GANG_ZONES) return;
-
-	pPlayerData[playerid]->dwClientSideZoneFlashColor[i] = 0;
-	pPlayerData[playerid]->bIsGangZoneFlashing[i] = true;
-
-	RakNet::BitStream bsParams;
-	bsParams.Write(i);
-	pRakServer->RPC(&RPC_StopFlashGangZone, &bsParams, MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
-}
-
-void CGangZonePool::StopFlashForAll(WORD wZone)
-{
-	for(WORD i = 0; i != MAX_PLAYERS; i++)
-	{
-		// Skip not connected players
-		if(!IsPlayerConnectedEx(i)) continue;
-
-		StopFlashForPlayer(i, wZone);
-	}
-}
+#include "main.h"
+
+CGangZonePool::CGangZonePool()
+{
+	// Set every gang zone pointer to NULL
+	memset(pGangZone, NULL, sizeof(pGangZone));
+}
+
+CGangZonePool::~CGangZonePool()
+{
+	for (WORD i = 0; i != MAX_GANG_ZONES; i++)
+	{
+		SAFE_DELETE(pGangZone[i]);
+	}
+}
+
+WORD CGangZonePool::New(float fMinX, float fMinY, float fMaxX, float fMaxY)
+{
+	WORD wZone = 0;
+	while (wZone < MAX_GANG_ZONES)
+	{
+		if (!pGangZone[wZone]) break;
+		wZone++;
+	}
+	if (wZone == MAX_GANG_ZONES) return 0xFFFF;
+	
+	// Allocate memory for gangzone
+	pGangZone[wZone] = new CGangZone();
+	pGangZone[wZone]->fGangZone[0] = fMinX;
+	pGangZone[wZone]->fGangZone[1] = fMinY;
+	pGangZone[wZone]->fGangZone[2] = fMaxX;
+	pGangZone[wZone]->fGangZone[3] = fMaxY;
+	return wZone;
+}
+
+WORD CGangZonePool::New(WORD playerid, float fMinX, float fMinY, float fMaxX, float fMaxY)
+{
+	WORD wZone = 0;
+	while (wZone < MAX_GANG_ZONES)
+	{
+		if (!pPlayerData[playerid]->pPlayerZone[wZone]) break;
+		wZone++;
+	}
+	if (wZone == MAX_GANG_ZONES) return 0xFFFF;
+		
+	// Allocate memory for gangzone
+	pPlayerData[playerid]->pPlayerZone[wZone] = new CGangZone();
+	pPlayerData[playerid]->pPlayerZone[wZone]->fGangZone[0] = fMinX;
+	pPlayerData[playerid]->pPlayerZone[wZone]->fGangZone[1] = fMinY;
+	pPlayerData[playerid]->pPlayerZone[wZone]->fGangZone[2] = fMaxX;
+	pPlayerData[playerid]->pPlayerZone[wZone]->fGangZone[3] = fMaxY;
+	return wZone;
+}
+
+void CGangZonePool::Delete(WORD wZone)
+{
+	for (WORD i = 0; i != MAX_PLAYERS; i++)
+	{
+		// Skip not connected players
+		if (!IsPlayerConnectedEx(i)) continue;
+
+		HideForPlayer(i, wZone);
+	}
+	
+	SAFE_DELETE(pGangZone[wZone]);
+}
+
+void CGangZonePool::Delete(WORD playerid, WORD wZone)
+{
+	HideForPlayer(playerid, wZone, true);
+
+	SAFE_DELETE(pPlayerData[playerid]->pPlayerZone[wZone]);
+}
+
+bool CGangZonePool::ShowForPlayer(WORD playerid, WORD wZone, DWORD dwColor, bool bPlayerZone)
+{	
+	// Find free zone slot on player, client side
+	WORD i = 0;;
+	CGangZone *pZone = NULL;
+
+	while(i != MAX_GANG_ZONES)
+	{
+		if(pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 0xFF) break;
+		i++;
+	}
+	if (i == MAX_GANG_ZONES) return 0;
+
+	// Mark client side zone id as used
+	if(!bPlayerZone)
+	{
+		pZone = pGangZone[wZone];
+		if(!pZone) return 0;
+
+		// Hide the old one, if showed
+		HideForPlayer(playerid, wZone, false);
+
+		pPlayerData[playerid]->byteClientSideZoneIDUsed[i] = 0;
+		pPlayerData[playerid]->wClientSideGlobalZoneID[i] = wZone;
+		
+	}
+	else
+	{
+		pZone = pPlayerData[playerid]->pPlayerZone[wZone];
+		if(!pZone) return 0;
+
+		// Hide the old one, if showed
+		HideForPlayer(playerid, wZone, true);
+
+		pPlayerData[playerid]->byteClientSideZoneIDUsed[i] = 1;
+		pPlayerData[playerid]->wClientSidePlayerZoneID[i] = wZone;
+	}
+	pPlayerData[playerid]->dwClientSideZoneColor[i] = dwColor;
+
+	//logprintf("CGangZonePool::ShowForPlayer playerid = %d, zoneid = %d, clientsideid = %d, bPlayerZone = %d", playerid, wZone, i, bPlayerZone);
+
+	RakNet::BitStream bsParams;
+	bsParams.Write(i);
+	bsParams.Write(pZone->fGangZone[0]);
+	bsParams.Write(pZone->fGangZone[1]);
+	bsParams.Write(pZone->fGangZone[2]);
+	bsParams.Write(pZone->fGangZone[3]);
+	bsParams.Write(RGBA_ABGR(dwColor));
+	pRakServer->RPC(&RPC_ShowGangZone, &bsParams, MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
+	return 1;
+}
+
+void CGangZonePool::ShowForAll(WORD wZone, DWORD dwColor)
+{
+	for(WORD playerid = 0; playerid != MAX_PLAYERS; playerid++)
+	{
+		// Skip not connected players
+		if(!IsPlayerConnectedEx(playerid)) continue;
+
+		WORD i = 0;
+
+		while(i != MAX_GANG_ZONES)
+		{
+			if(pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 0xFF) break;
+			i++;
+		}
+		if (i == MAX_GANG_ZONES) return;
+
+		// Hide the old one, if showed
+		if(pPlayerData[playerid]->byteClientSideZoneIDUsed[i] != 0xFF)
+			HideForPlayer(playerid, wZone, false, false);
+
+		// Mark client side zone id as used
+		pPlayerData[playerid]->byteClientSideZoneIDUsed[i] = 0;
+		pPlayerData[playerid]->wClientSideGlobalZoneID[i] = wZone;
+		pPlayerData[playerid]->dwClientSideZoneColor[i] = dwColor;
+
+		RakNet::BitStream bsParams;
+		bsParams.Write(i);
+		bsParams.Write(pGangZone[wZone]->fGangZone[0]);
+		bsParams.Write(pGangZone[wZone]->fGangZone[1]);
+		bsParams.Write(pGangZone[wZone]->fGangZone[2]);
+		bsParams.Write(pGangZone[wZone]->fGangZone[3]);
+		bsParams.Write(RGBA_ABGR(dwColor));
+		pRakServer->RPC(&RPC_ShowGangZone, &bsParams, MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
+	}
+}
+
+bool CGangZonePool::HideForPlayer(WORD playerid, WORD wZone, bool bPlayerZone, bool bCallCallback)
+{
+	WORD i = 0;
+
+	// Mark client side zone id as unused
+	if(!bPlayerZone)
+	{
+		while(i != MAX_GANG_ZONES)
+		{
+			if(pPlayerData[playerid]->wClientSideGlobalZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 0) break;
+			i++;
+		}
+		if(i == MAX_GANG_ZONES) return 0;
+
+		if (pPlayerData[playerid]->bInGangZone[i] && bCallCallback)
+		{
+			CCallbackManager::OnPlayerLeaveGangZone(playerid, pPlayerData[playerid]->wClientSideGlobalZoneID[i]);
+		}
+
+		pPlayerData[playerid]->wClientSideGlobalZoneID[i] = 0xFFFF;
+	}
+	else
+	{
+		while(i != MAX_GANG_ZONES)
+		{
+			if(pPlayerData[playerid]->wClientSidePlayerZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 1) break;
+			i++;
+		}
+		if(i == MAX_GANG_ZONES) return 0;
+		
+		if (pPlayerData[playerid]->bInGangZone[i] && bCallCallback)
+		{
+			CCallbackManager::OnPlayerLeavePlayerGangZone(playerid, pPlayerData[playerid]->wClientSidePlayerZoneID[i]);
+		}
+
+		pPlayerData[playerid]->wClientSidePlayerZoneID[i] = 0xFFFF;
+	}
+	if (i == MAX_GANG_ZONES) return 0;
+
+	pPlayerData[playerid]->byteClientSideZoneIDUsed[i] = 0xFF;
+	pPlayerData[playerid]->dwClientSideZoneColor[i] = 0;
+	pPlayerData[playerid]->bInGangZone[i] = false;
+	pPlayerData[playerid]->bIsGangZoneFlashing[i] = false;
+
+	//logprintf("CGangZonePool::HideForPlayer playerid = %d, zoneid = %d, clientsideid = %d, bPlayerZone = %d", playerid, wZone, i, bPlayerZone);
+
+	RakNet::BitStream bsParams;
+	bsParams.Write(i);
+	pRakServer->RPC(&RPC_HideGangZone, &bsParams, MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
+	return 1;
+}
+
+void CGangZonePool::HideForAll(WORD wZone)
+{
+	for(WORD i = 0; i != MAX_PLAYERS; i++)
+	{
+		// Skip not connected players
+		if(!IsPlayerConnectedEx(i)) continue;
+
+		HideForPlayer(i, wZone);
+	}
+}
+
+void CGangZonePool::FlashForPlayer(WORD playerid, WORD wZone, DWORD dwColor, bool bPlayerZone)
+{
+	WORD i = 0;
+
+	// check id
+	if(!bPlayerZone)
+	{
+		while(i != MAX_GANG_ZONES)
+		{
+			if(pPlayerData[playerid]->wClientSideGlobalZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 0) break;
+			i++;
+		}
+	}
+	else
+	{
+		while(i != MAX_GANG_ZONES)
+		{
+			if(pPlayerData[playerid]->wClientSidePlayerZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 1) break;
+			i++;
+		}
+	}
+	if (i == MAX_GANG_ZONES) return;
+
+	pPlayerData[playerid]->dwClientSideZoneFlashColor[i] = dwColor;
+	pPlayerData[playerid]->bIsGangZoneFlashing[i] = true;
+
+	RakNet::BitStream bsParams;
+	bsParams.Write(i);
+	bsParams.Write(RGBA_ABGR(dwColor));
+	pRakServer->RPC(&RPC_FlashGangZone, &bsParams, MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
+}
+
+void CGangZonePool::FlashForAll(WORD wZone, DWORD dwColor)
+{
+	for(WORD i = 0; i != MAX_PLAYERS; i++)
+	{
+		// Skip not connected players
+		if(!IsPlayerConnectedEx(i)) continue;
+
+		FlashForPlayer(i, wZone, dwColor);
+	}
+}
+
+void CGangZonePool::StopFlashForPlayer(WORD playerid, WORD wZone, bool bPlayerZone)
+{
+	WORD i = 0;
+
+	// check id
+	if(!bPlayerZone)
+	{
+		while(i != MAX_GANG_ZONES)
+		{
+			if(pPlayerData[playerid]->wClientSideGlobalZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 0) break;
+			i++;
+		}
+	}
+	else
+	{
+		while(i != MAX_GANG_ZONES)
+		{
+			if(pPlayerData[playerid]->wClientSidePlayerZoneID[i] == wZone && pPlayerData[playerid]->byteClientSideZoneIDUsed[i] == 1) break;
+			i++;
+		}
+	}
+	if (i == MAX_GANG_ZONES) return;
+
+	pPlayerData[playerid]->dwClientSideZoneFlashColor[i] = 0;
+	pPlayerData[playerid]->bIsGangZoneFlashing[i] = true;
+
+	RakNet::BitStream bsParams;
+	bsParams.Write(i);
+	pRakServer->RPC(&RPC_StopFlashGangZone, &bsParams, MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
+}
+
+void CGangZonePool::StopFlashForAll(WORD wZone)
+{
+	for(WORD i = 0; i != MAX_PLAYERS; i++)
+	{
+		// Skip not connected players
+		if(!IsPlayerConnectedEx(i)) continue;
+
+		StopFlashForPlayer(i, wZone);
+	}
+}
diff --git a/src/CGangZonePool.h b/src/src/CGangZonePool.h
similarity index 100%
rename from src/CGangZonePool.h
rename to src/src/CGangZonePool.h
diff --git a/src/CModelSizes.cpp b/src/src/CModelSizes.cpp
similarity index 100%
rename from src/CModelSizes.cpp
rename to src/src/CModelSizes.cpp
diff --git a/src/CModelSizes.h b/src/src/CModelSizes.h
similarity index 100%
rename from src/CModelSizes.h
rename to src/src/CModelSizes.h
diff --git a/src/CPickupPool.cpp b/src/src/CPickupPool.cpp
similarity index 100%
rename from src/CPickupPool.cpp
rename to src/src/CPickupPool.cpp
diff --git a/src/CPickupPool.h b/src/src/CPickupPool.h
similarity index 100%
rename from src/CPickupPool.h
rename to src/src/CPickupPool.h
diff --git a/src/CPlayerData.cpp b/src/src/CPlayerData.cpp
similarity index 94%
rename from src/CPlayerData.cpp
rename to src/src/CPlayerData.cpp
index 1767f42..a0cfdcf 100644
--- a/src/CPlayerData.cpp
+++ b/src/src/CPlayerData.cpp
@@ -1,595 +1,632 @@
-#include "main.h"
-
-CPlayerData::CPlayerData( WORD playerid )
-{
-	static DWORD dwPlayerColors[100] = 
-	{
-		0xFF8C13FF,0xC715FFFF,0x20B2AAFF,0xDC143CFF,0x6495EDFF,0xf0e68cFF,0x778899FF,0xFF1493FF,0xF4A460FF,
-		0xEE82EEFF,0xFFD720FF,0x8b4513FF,0x4949A0FF,0x148b8bFF,0x14ff7fFF,0x556b2fFF,0x0FD9FAFF,0x10DC29FF,
-		0x534081FF,0x0495CDFF,0xEF6CE8FF,0xBD34DAFF,0x247C1BFF,0x0C8E5DFF,0x635B03FF,0xCB7ED3FF,0x65ADEBFF,
-		0x5C1ACCFF,0xF2F853FF,0x11F891FF,0x7B39AAFF,0x53EB10FF,0x54137DFF,0x275222FF,0xF09F5BFF,0x3D0A4FFF,
-		0x22F767FF,0xD63034FF,0x9A6980FF,0xDFB935FF,0x3793FAFF,0x90239DFF,0xE9AB2FFF,0xAF2FF3FF,0x057F94FF,
-		0xB98519FF,0x388EEAFF,0x028151FF,0xA55043FF,0x0DE018FF,0x93AB1CFF,0x95BAF0FF,0x369976FF,0x18F71FFF,
-		0x4B8987FF,0x491B9EFF,0x829DC7FF,0xBCE635FF,0xCEA6DFFF,0x20D4ADFF,0x2D74FDFF,0x3C1C0DFF,0x12D6D4FF,
-		0x48C000FF,0x2A51E2FF,0xE3AC12FF,0xFC42A8FF,0x2FC827FF,0x1A30BFFF,0xB740C2FF,0x42ACF5FF,0x2FD9DEFF,
-		0xFAFB71FF,0x05D1CDFF,0xC471BDFF,0x94436EFF,0xC1F7ECFF,0xCE79EEFF,0xBD1EF2FF,0x93B7E4FF,0x3214AAFF,
-		0x184D3BFF,0xAE4B99FF,0x7E49D7FF,0x4C436EFF,0xFA24CCFF,0xCE76BEFF,0xA04E0AFF,0x9F945CFF,0xDCDE3DFF,
-		0x10C9C5FF,0x70524DFF,0x0BE472FF,0x8A2CD7FF,0x6152C2FF,0xCF72A9FF,0xE59338FF,0xEEDC2DFF,0xD8C762FF,
-		0xD8C762FF
-	};
-
-	// Null object data
-	for(int i = 0; i != MAX_OBJECTS; i++)
-	{
-		this->stObj[i].wObjectID = INVALID_OBJECT_ID;
-		this->stObj[i].wAttachPlayerID = INVALID_PLAYER_ID;
-		this->stObj[i].vecOffset = CVector(0.0f, 0.0f, 0.0f);
-		this->stObj[i].vecRot = CVector(0.0f, 0.0f, 0.0f);
-	}
-
-	wPlayerID = playerid;
-	bObjectsRemoved = false;
-	fGravity = pServer->GetGravity_();
-	byteWeather = pServer->GetWeather_();
-	bWidescreen = false;
-
-	// Fix for GetPlayerColor
-	if(pNetGame->pPlayerPool->pPlayer[playerid])
-	{
-		pNetGame->pPlayerPool->pPlayer[playerid]->dwNickNameColor = dwPlayerColors[playerid % 100];
-	}
-
-	fBounds[0] = 20000.0f;
-	fBounds[1] = -20000.0f;
-	fBounds[2] = 20000.0f;
-	fBounds[3] = -20000.0f;
-
-	memset(pPlayerZone, NULL, sizeof(pPlayerZone));
-	memset(byteClientSideZoneIDUsed, 0xFF, sizeof(byteClientSideZoneIDUsed));
-	memset(wClientSideGlobalZoneID, 0xFFFF, sizeof(wClientSideGlobalZoneID));
-	memset(wClientSidePlayerZoneID, 0xFFFF, sizeof(wClientSidePlayerZoneID));
-
-	memset(dwClientSideZoneColor, NULL, sizeof(dwClientSideZoneColor));
-	memset(dwClientSideZoneFlashColor, NULL, sizeof(dwClientSideZoneFlashColor));
-//	memset(bIsGangZoneFlashing, false, sizeof(bIsGangZoneFlashing));
-#ifdef NEW_PICKUP_SYSTEM
-	// Pickpus
-	ClientPlayerPickups.clear();
-#endif
-	bUpdateScoresPingsDisabled = false;
-	bFakePingToggle = false;
-	dwFakePingValue = 0;
-
-	memset(bCustomPos, false, MAX_PLAYERS);
-	memset(bCustomQuat, false, MAX_PLAYERS);
-	memset(vecCustomPos, NULL, sizeof(CVector));
-
+#include "main.h"
+
+CPlayerData::CPlayerData( WORD playerid )
+{
+	static DWORD dwPlayerColors[100] = 
+	{
+		0xFF8C13FF,0xC715FFFF,0x20B2AAFF,0xDC143CFF,0x6495EDFF,0xf0e68cFF,0x778899FF,0xFF1493FF,0xF4A460FF,
+		0xEE82EEFF,0xFFD720FF,0x8b4513FF,0x4949A0FF,0x148b8bFF,0x14ff7fFF,0x556b2fFF,0x0FD9FAFF,0x10DC29FF,
+		0x534081FF,0x0495CDFF,0xEF6CE8FF,0xBD34DAFF,0x247C1BFF,0x0C8E5DFF,0x635B03FF,0xCB7ED3FF,0x65ADEBFF,
+		0x5C1ACCFF,0xF2F853FF,0x11F891FF,0x7B39AAFF,0x53EB10FF,0x54137DFF,0x275222FF,0xF09F5BFF,0x3D0A4FFF,
+		0x22F767FF,0xD63034FF,0x9A6980FF,0xDFB935FF,0x3793FAFF,0x90239DFF,0xE9AB2FFF,0xAF2FF3FF,0x057F94FF,
+		0xB98519FF,0x388EEAFF,0x028151FF,0xA55043FF,0x0DE018FF,0x93AB1CFF,0x95BAF0FF,0x369976FF,0x18F71FFF,
+		0x4B8987FF,0x491B9EFF,0x829DC7FF,0xBCE635FF,0xCEA6DFFF,0x20D4ADFF,0x2D74FDFF,0x3C1C0DFF,0x12D6D4FF,
+		0x48C000FF,0x2A51E2FF,0xE3AC12FF,0xFC42A8FF,0x2FC827FF,0x1A30BFFF,0xB740C2FF,0x42ACF5FF,0x2FD9DEFF,
+		0xFAFB71FF,0x05D1CDFF,0xC471BDFF,0x94436EFF,0xC1F7ECFF,0xCE79EEFF,0xBD1EF2FF,0x93B7E4FF,0x3214AAFF,
+		0x184D3BFF,0xAE4B99FF,0x7E49D7FF,0x4C436EFF,0xFA24CCFF,0xCE76BEFF,0xA04E0AFF,0x9F945CFF,0xDCDE3DFF,
+		0x10C9C5FF,0x70524DFF,0x0BE472FF,0x8A2CD7FF,0x6152C2FF,0xCF72A9FF,0xE59338FF,0xEEDC2DFF,0xD8C762FF,
+		0xD8C762FF
+	};
+
+	// Null object data
+	for(int i = 0; i != MAX_OBJECTS; i++)
+	{
+		this->stObj[i].wObjectID = INVALID_OBJECT_ID;
+		this->stObj[i].wAttachPlayerID = INVALID_PLAYER_ID;
+		this->stObj[i].vecOffset = CVector(0.0f, 0.0f, 0.0f);
+		this->stObj[i].vecRot = CVector(0.0f, 0.0f, 0.0f);
+	}
+
+	wPlayerID = playerid;
+	bObjectsRemoved = false;
+	fGravity = pServer->GetGravity_();
+	byteWeather = pServer->GetWeather_();
+	bWidescreen = false;
+
+	// Fix for GetPlayerColor
+	if(pNetGame->pPlayerPool->pPlayer[playerid])
+	{
+		pNetGame->pPlayerPool->pPlayer[playerid]->dwNickNameColor = dwPlayerColors[playerid % 100];
+	}
+
+	fBounds[0] = 20000.0f;
+	fBounds[1] = -20000.0f;
+	fBounds[2] = 20000.0f;
+	fBounds[3] = -20000.0f;
+
+	memset(pPlayerZone, NULL, sizeof(pPlayerZone));
+	memset(byteClientSideZoneIDUsed, 0xFF, sizeof(byteClientSideZoneIDUsed));
+	memset(wClientSideGlobalZoneID, 0xFFFF, sizeof(wClientSideGlobalZoneID));
+	memset(wClientSidePlayerZoneID, 0xFFFF, sizeof(wClientSidePlayerZoneID));
+
+	memset(dwClientSideZoneColor, NULL, sizeof(dwClientSideZoneColor));
+	memset(dwClientSideZoneFlashColor, NULL, sizeof(dwClientSideZoneFlashColor));
+//	memset(bIsGangZoneFlashing, false, sizeof(bIsGangZoneFlashing));
+#ifdef NEW_PICKUP_SYSTEM
+	// Pickpus
+	ClientPlayerPickups.clear();
+#endif
+	bUpdateScoresPingsDisabled = false;
+	bFakePingToggle = false;
+	dwFakePingValue = 0;
+
+	memset(bCustomPos, false, MAX_PLAYERS);
+	memset(bCustomQuat, false, MAX_PLAYERS);
+	memset(vecCustomPos, NULL, sizeof(CVector));
+
 	dwFPS = 0;
-	dwLastDrunkLevel = 0;
-	wSurfingInfo = 0;
-
-	bAFKState = false;
-	bEverUpdated = false;
-	dwLastUpdateTick = 0;
-	dwCreateAttachedObj = 0;
-	dwObjectID = INVALID_OBJECT_ID;
-
-	bHidden = false;
-	bControllable = true;
-	bAttachedObjectCreated = false;
-
-	// Private
-	memset(m_iTeams, -1, sizeof(m_iSkins));
-	memset(m_iSkins, -1, sizeof(m_iSkins));
-	memset(m_iFightingStyles, -1, sizeof(m_iFightingStyles));
-	memset(m_szNames, NULL, sizeof(m_szNames));
-}
-
-CPlayerData::~CPlayerData( void )
-{
-
-}
-
+	dwLastDrunkLevel = 0;
+	wSurfingInfo = 0;
+
+	bAFKState = false;
+	bEverUpdated = false;
+	dwLastUpdateTick = 0;
+	dwCreateAttachedObj = 0;
+	dwObjectID = INVALID_OBJECT_ID;
+
+	bHidden = false;
+	bControllable = true;
+	bAttachedObjectCreated = false;
+
+	// Private
+	memset(m_iTeams, -1, sizeof(m_iSkins));
+	memset(m_iSkins, -1, sizeof(m_iSkins));
+	memset(m_iFightingStyles, -1, sizeof(m_iFightingStyles));
+	memset(m_szNames, NULL, sizeof(m_szNames));
+	
+	if(pServer->IsNPCTrackingEnabled())
+	{
+		if(pNetGame->pPlayerPool->bIsNPC[playerid])
+		{
+			PlayerID id = pRakServer->GetPlayerIDFromIndex(playerid);
+			if(id.binaryAddress == 0x0100007F)
+			{
+				npcPid = CSAMPFunctions::FindNPCProcessID(playerid);
+			}
+		}
+	}
+}
+
+CPlayerData::~CPlayerData( void )
+{
+
+}
+
+bool CPlayerData::ResetPlayerMarkerForPlayer(WORD resetplayerid)
+{
+	CPlayer *p = pNetGame->pPlayerPool->pPlayer[resetplayerid];
+
+	RakNet::BitStream bs;
+	bs.Write(resetplayerid);
+	bs.Write(p->dwNickNameColor);
+	pRakServer->RPC(&RPC_SetPlayerColor, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(wPlayerID), 0, 0);
+	return true;
+}
+
 bool CPlayerData::SetPlayerTeamForPlayer(WORD teamplayerid, int team)
 {
-	m_iTeams[teamplayerid] = team;
-
-	RakNet::BitStream bs;
-	bs.Write((WORD)teamplayerid);
-	bs.Write((BYTE)team);	
+	m_iTeams[teamplayerid] = team;
+
+	RakNet::BitStream bs;
+	bs.Write((WORD)teamplayerid);
+	bs.Write((BYTE)team);	
 	pRakServer->RPC(&RPC_SetPlayerTeam, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(wPlayerID), 0, 0);
 	return true;
 }
 
-int CPlayerData::GetPlayerTeamForPlayer(WORD teamplayerid)
-{
-	CPlayer *p = pNetGame->pPlayerPool->pPlayer[teamplayerid];
-	if (m_iTeams[teamplayerid] == -1)
-	{
-		return p->spawn.byteTeam;
-	}
-	return m_iTeams[teamplayerid];
+int CPlayerData::GetPlayerTeamForPlayer(WORD teamplayerid)
+{
+	CPlayer *p = pNetGame->pPlayerPool->pPlayer[teamplayerid];
+	if (m_iTeams[teamplayerid] == -1)
+	{
+		return p->spawn.byteTeam;
+	}
+	return m_iTeams[teamplayerid];
 }
 
 
-bool CPlayerData::SetPlayerSkinForPlayer(WORD skinplayerid, int skin)
-{
-	m_iSkins[skinplayerid] = skin;
-
-	RakNet::BitStream bs;
-	bs.Write((int)skinplayerid);
-	bs.Write((int)skin);
-	pRakServer->RPC(&RPC_SetPlayerSkin, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(wPlayerID), 0, 0);
+bool CPlayerData::SetPlayerSkinForPlayer(WORD skinplayerid, int skin)
+{
+	m_iSkins[skinplayerid] = skin;
+
+	RakNet::BitStream bs;
+	bs.Write((int)skinplayerid);
+	bs.Write((int)skin);
+	pRakServer->RPC(&RPC_SetPlayerSkin, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(wPlayerID), 0, 0);
 	return true;
 }
 
-int CPlayerData::GetPlayerSkinForPlayer(WORD skinplayerid)
-{
-	CPlayer *p = pNetGame->pPlayerPool->pPlayer[skinplayerid];
-	if (m_iSkins[skinplayerid] == -1)
-	{
-		return p->spawn.iSkin;
-	}
-	return m_iSkins[skinplayerid];
-}
-
+int CPlayerData::GetPlayerSkinForPlayer(WORD skinplayerid)
+{
+	CPlayer *p = pNetGame->pPlayerPool->pPlayer[skinplayerid];
+	if (m_iSkins[skinplayerid] == -1)
+	{
+		return p->spawn.iSkin;
+	}
+	return m_iSkins[skinplayerid];
+}
+
 bool CPlayerData::SetPlayerNameForPlayer(WORD nameplayerid, char *name)
 {
-	memcpy(&m_szNames[nameplayerid], name, MAX_PLAYER_NAME);
-	BYTE len = static_cast<BYTE>(strlen(name));
-
-	RakNet::BitStream bs;
-	bs.Write((WORD)nameplayerid);
-	bs.Write((BYTE)len);
-	bs.Write(name, len);
-	bs.Write((BYTE)1);
-
+	memcpy(&m_szNames[nameplayerid], name, MAX_PLAYER_NAME);
+	BYTE len = static_cast<BYTE>(strlen(name));
+
+	RakNet::BitStream bs;
+	bs.Write((WORD)nameplayerid);
+	bs.Write((BYTE)len);
+	bs.Write(name, len);
+	bs.Write((BYTE)1);
+
 	pRakServer->RPC(&RPC_SetPlayerName, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(wPlayerID), 0, 0);
-	return true;
-}
-
-char *CPlayerData::GetPlayerNameForPlayer(WORD nameplayerid)
-{
-	if (!m_szNames[nameplayerid][0])
-	{
-		return GetPlayerName_(nameplayerid);
-	}
-	return &m_szNames[nameplayerid][0];
-}
-
-bool CPlayerData::SetPlayerFightingStyleForPlayer(WORD styleplayerid, int style)
-{
-	m_iFightingStyles[styleplayerid] = style;
-
-	RakNet::BitStream bs;
-	bs.Write((WORD)styleplayerid);
-	bs.Write((BYTE)style);
-	pRakServer->RPC(&RPC_SetFightingStyle, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(wPlayerID), 0, 0);
 	return true;
 }
 
-int CPlayerData::GetPlayerFightingStyleForPlayer(WORD styleplayerid)
-{
-	CPlayer *p = pNetGame->pPlayerPool->pPlayer[styleplayerid];
-	if (m_iFightingStyles[styleplayerid] == -1)
-	{
-		return p->byteFightingStyle;
-	}
-	return m_iFightingStyles[styleplayerid];
-}
-
-WORD CPlayerData::GetGangZoneIDFromClientSide(WORD zoneid, bool bPlayer)
-{
-	// Loop though every global gang zone
-	if(!bPlayer)
-	{
-		for(WORD wZone = 0; wZone != MAX_GANG_ZONES; wZone++)
-		{
-			if(wClientSideGlobalZoneID[wZone] == zoneid)
-				return wZone;
-		}
-	}
-	else
-	{
-		for(WORD wZone = 0; wZone != MAX_GANG_ZONES; wZone++)
-		{
-			if(wClientSidePlayerZoneID[wZone] == zoneid)
-				return wZone;
-		}	
-	}
-	return 0xFFFF;
-}
-
-bool CPlayerData::DestroyObject_(WORD objectid)
-{
-	RakNet::BitStream bs;
-	bs.Write(objectid);
-	pRakServer->RPC(&RPC_DestroyObject, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(wPlayerID), 0, 0);
-	return 1;
-}
-
-void CPlayerData::Process(void)
-{
-	// Process AFK detection
-	DWORD dwTickCount = GetTickCount();
-	
-	CPlayerPool *pPlayerPool = pNetGame->pPlayerPool;
-	if (bEverUpdated && pPlayerPool->pPlayer[wPlayerID]->byteState != PLAYER_STATE_NONE && pPlayerPool->pPlayer[wPlayerID]->byteState != PLAYER_STATE_WASTED)
-	{
-		if(bAFKState == false && dwTickCount - dwLastUpdateTick > pServer->GetAFKAccuracy())
-		{
-			bAFKState = true;
-
-			CCallbackManager::OnPlayerPauseStateChange(wPlayerID, bAFKState);
-		}
-
-		else if(bAFKState == true && dwTickCount - dwLastUpdateTick < pServer->GetAFKAccuracy())
-		{
-			bAFKState = false;
-
-			CCallbackManager::OnPlayerPauseStateChange(wPlayerID, bAFKState);
-		}
-	}
-
-	if((dwTickCount - dwCreateAttachedObj > 3000) && dwCreateAttachedObj != 0)
-	{
-		//logprintf("wPlayerID: %d, stObj[i].wAttachPlayerID: %d - %d", wPlayerID, stObj[dwObjectID].wAttachPlayerID, dwObjectID);
-
-		// Attach created object to player
-		RakNet::BitStream bs;
-		bs.Write(pNetGame->pObjectPool->pPlayerObjects[wPlayerID][dwObjectID]->wObjectID); // m_wObjectID
-		bs.Write(stObj[dwObjectID].wAttachPlayerID); // playerid
-
-		bs.Write(stObj[dwObjectID].vecOffset.fX);
-		bs.Write(stObj[dwObjectID].vecOffset.fY);
-		bs.Write(stObj[dwObjectID].vecOffset.fZ);
-
-		bs.Write(stObj[dwObjectID].vecRot.fX);
-		bs.Write(stObj[dwObjectID].vecRot.fY);
-		bs.Write(stObj[dwObjectID].vecRot.fZ);
-
-		pRakServer->RPC(&RPC_AttachObject, &bs, LOW_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(wPlayerID), 0, 0);
-		dwCreateAttachedObj = 0;
-		dwObjectID = INVALID_OBJECT_ID;
-		bAttachedObjectCreated = true;
-	}
-
-	// Process gangzones
-	for(WORD zoneid = 0; zoneid != MAX_GANG_ZONES; zoneid++)
-	{
-		// If zone id is unused client side, then continue
-		if(byteClientSideZoneIDUsed[zoneid] == 0xFF) continue;
-
-		CGangZone *pGangZone = NULL;
-		if(byteClientSideZoneIDUsed[zoneid] == 0)
-		{
-			if(wClientSideGlobalZoneID[zoneid] == 0xFFFF)
-			{
-				logprintf("pPlayer->wClientSideGlobalZoneID[%d] = 0xFFFF", zoneid);
-				return;
-			}
-					
-			pGangZone = pServer->pGangZonePool->pGangZone[wClientSideGlobalZoneID[zoneid]];
-		}
-		else
-		{
-			if(wClientSidePlayerZoneID[zoneid] == 0xFFFF)
-			{
-				logprintf("pPlayer->wClientSidePlayerZoneID[%d] = 0xFFFF", zoneid);
-				return;
-			}
-
-			pGangZone = pPlayerZone[wClientSidePlayerZoneID[zoneid]];
-		}
-
-		if(!pGangZone) continue;
-
-		// Mutatók létrehozása
-		CVector *vecPos = &pNetGame->pPlayerPool->pPlayer[wPlayerID]->vecPosition;
-		float *fMinX = &pGangZone->fGangZone[0];
-		float *fMinY = &pGangZone->fGangZone[1];
-		float *fMaxX = &pGangZone->fGangZone[2];
-		float *fMaxY = &pGangZone->fGangZone[3];
-
-		//logprintf("validzone: %d, %f, %f, %f, %f", this->wClientSideGlobalZoneID[zoneid], *fMinX, *fMinY, *fMaxX, *fMaxY);
-		
-		// Ha benne van
-		if(vecPos->fX >= *fMinX && vecPos->fX <= *fMaxX && vecPos->fY >= *fMinY && vecPos->fY <= *fMaxY && !bInGangZone[zoneid])
-		{
-			bInGangZone[zoneid] = true;
-			//logprintf("enterzone: %d", zoneid);
-					
-			if(byteClientSideZoneIDUsed[zoneid] == 0)
-			{
-				CCallbackManager::OnPlayerEnterGangZone(wPlayerID, wClientSideGlobalZoneID[zoneid]);
-			}
-			else if(byteClientSideZoneIDUsed[zoneid] == 1)
-			{
-				CCallbackManager::OnPlayerEnterPlayerGangZone(wPlayerID, wClientSidePlayerZoneID[zoneid]);
-			}
-		}
-		else if(!(vecPos->fX >= *fMinX && vecPos->fX <= *fMaxX && vecPos->fY >= *fMinY && vecPos->fY <= *fMaxY) && bInGangZone[zoneid])
-		{
-			bInGangZone[zoneid] = false;
-			//logprintf("leavezone: %d", zoneid);
-					
-			if(byteClientSideZoneIDUsed[zoneid] == 0)
-			{
-				CCallbackManager::OnPlayerLeaveGangZone(wPlayerID, wClientSideGlobalZoneID[zoneid]);
-			}
-			else if(byteClientSideZoneIDUsed[zoneid] == 1)
-			{
-				CCallbackManager::OnPlayerLeavePlayerGangZone(wPlayerID, wClientSidePlayerZoneID[zoneid]);
-			}
-		}
-	}
-}
-
-void RebuildSyncData(RakNet::BitStream *bsSync, WORD toplayerid)
-{
-	BYTE id;
-	WORD playerid;
-
-	bsSync->Read(id);
-	bsSync->Read(playerid);
-	
-	//logprintf("RebuildSyncData pre %d - %d", id, playerid);
-	if(!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(toplayerid)) return;
-
-	//logprintf("RebuildSyncData %d - %d", id, playerid);
-	switch(id)
-	{
-		case ID_PLAYER_SYNC:
-		{
-			CPlayer *p = pNetGame->pPlayerPool->pPlayer[playerid];
-	
-			bsSync->Reset();
-			bsSync->Write((BYTE)ID_PLAYER_SYNC);
-			bsSync->Write(playerid);
-
-			// UP/DOWN KEYS
-			if(p->syncData.wUDAnalog) 
-			{
-				bsSync->Write(true);
-				bsSync->Write(p->syncData.wUDAnalog);
-			} 
-			else 
-			{
-				bsSync->Write(false);
-			}
-
-			// LEFT/RIGHT KEYS
-			if(p->syncData.wLRAnalog) 
-			{
-				bsSync->Write(true);
-				bsSync->Write(p->syncData.wLRAnalog);
-			} 
-			else 
-			{
-				bsSync->Write(false);
-			}
-
-			// Keys
-			WORD keys = p->syncData.wKeys &= ~pPlayerData[playerid]->dwDisabledKeys;
-			bsSync->Write(keys);
-	
-			// Position
-			if(pPlayerData[toplayerid]->bCustomPos[playerid])				
-				bsSync->Write(*pPlayerData[toplayerid]->vecCustomPos[playerid]);	
-			else
-				bsSync->Write((char*)&p->syncData.vecPosition, sizeof(CVector));
-			
-			// Rotation (in quaternion)
-			if(pPlayerData[toplayerid]->bCustomQuat[playerid])
-				bsSync->WriteNormQuat(pPlayerData[toplayerid]->fCustomQuat[playerid][0], pPlayerData[toplayerid]->fCustomQuat[playerid][1], pPlayerData[toplayerid]->fCustomQuat[playerid][2], pPlayerData[toplayerid]->fCustomQuat[playerid][3]);	
-			else
-				bsSync->WriteNormQuat(p->syncData.fQuaternion[0], p->syncData.fQuaternion[1], p->syncData.fQuaternion[2], p->syncData.fQuaternion[3]);
-			
-			// Health & armour compression
-			BYTE byteSyncHealthArmour = 0;
-			if( p->syncData.byteHealth > 0 && p->syncData.byteHealth < 100 ) 
-			{
-				byteSyncHealthArmour = ((BYTE)(p->syncData.byteHealth / 7)) << 4;
-			} 
-			else if(p->syncData.byteHealth >= 100) 
-			{
-				byteSyncHealthArmour = 0xF << 4;
-			}
-
-			if( p->syncData.byteArmour > 0 && p->syncData.byteArmour < 100 ) 
-			{
-				byteSyncHealthArmour |=  (BYTE)(p->syncData.byteArmour / 7);
-			}
-			else if(p->syncData.byteArmour >= 100) 
-			{
-				byteSyncHealthArmour |= 0xF;
-			}
-	
-			bsSync->Write(byteSyncHealthArmour);
-
-			// Current weapon
-			bsSync->Write(p->syncData.byteWeapon);
-
-			// Special action
-			bsSync->Write(p->syncData.byteSpecialAction);
-
-			// Velocity
-			bsSync->WriteVector(p->syncData.vecVelocity.fX, p->syncData.vecVelocity.fY, p->syncData.vecVelocity.fZ);
-
-			// Vehicle surfing (POSITION RELATIVE TO CAR SYNC)
-			if(p->syncData.wSurfingInfo) 
-			{
-				bsSync->Write(true);
-				bsSync->Write(p->syncData.wSurfingInfo);
-				bsSync->Write(p->syncData.vecSurfing.fX);
-				bsSync->Write(p->syncData.vecSurfing.fY);
-				bsSync->Write(p->syncData.vecSurfing.fZ);
-			} 
-			else 
-			{
-				bsSync->Write(false);
-			}
-	
-			// Animation
-			if(p->syncData.dwAnimationData)
-			{
-				bsSync->Write(true);
-				bsSync->Write((int)p->syncData.dwAnimationData);
-			}
-			else bsSync->Write(false);
-			break;
-		}
-		case ID_VEHICLE_SYNC:
-		{
-			CPlayer *p = pNetGame->pPlayerPool->pPlayer[playerid];
-
-			bsSync->Reset();
-			bsSync->Write((BYTE)ID_VEHICLE_SYNC);
-			bsSync->Write(playerid);
-
-			bsSync->Write(p->vehicleSyncData.wVehicleId);
-			bsSync->Write(p->vehicleSyncData.wUDAnalog);
-			bsSync->Write(p->vehicleSyncData.wLRAnalog);
-			
-			WORD keys = p->vehicleSyncData.wKeys &= ~pPlayerData[playerid]->dwDisabledKeys;
-			bsSync->Write(keys);
-			
-			bsSync->WriteNormQuat(p->vehicleSyncData.fQuaternion[0], p->vehicleSyncData.fQuaternion[1], p->vehicleSyncData.fQuaternion[2], p->vehicleSyncData.fQuaternion[3]);
-			bsSync->Write((char*)&p->vehicleSyncData.vecPosition, sizeof(CVector));
-			bsSync->WriteVector(p->vehicleSyncData.vecVelocity.fX, p->vehicleSyncData.vecVelocity.fY, p->vehicleSyncData.vecVelocity.fZ);
-			bsSync->Write((WORD)p->vehicleSyncData.fHealth);
-
-			// Health & armour compression
-			BYTE byteSyncHealthArmour=0;
-			if( p->vehicleSyncData.bytePlayerHealth > 0 && p->vehicleSyncData.bytePlayerHealth < 100 ) 
-			{
-				byteSyncHealthArmour = ((BYTE)(p->vehicleSyncData.bytePlayerHealth / 7)) << 4;
-			} 
-			else if(p->vehicleSyncData.bytePlayerHealth >= 100) 
-			{
-				byteSyncHealthArmour = 0xF << 4;
-			}
-
-			if( p->vehicleSyncData.bytePlayerArmour > 0 && p->vehicleSyncData.bytePlayerArmour < 100 ) 
-			{
-				byteSyncHealthArmour |=  (BYTE)(p->vehicleSyncData.bytePlayerArmour / 7);
-			}
-			else if(p->vehicleSyncData.bytePlayerArmour >= 100) 
-			{
-				byteSyncHealthArmour |= 0xF;
-			}
-
-			bsSync->Write(byteSyncHealthArmour);
-			bsSync->Write(p->vehicleSyncData.bytePlayerWeapon);
-
-			if(p->vehicleSyncData.byteSirenState)
-			{
-				bsSync->Write(true);
-			}
-			else
-			{
-				bsSync->Write(false);
-			}
-			
-			if(p->vehicleSyncData.byteGearState)
-			{
-				bsSync->Write(true);
-			}
-			else
-			{
-				bsSync->Write(false);
-			}
-
-			if(p->vehicleSyncData.fTrainSpeed)
-			{
-				bsSync->Write(true);
-				bsSync->Write(p->vehicleSyncData.fTrainSpeed);
-			}
-			else
-			{
-				bsSync->Write(false);
-			}
-
-			if(p->vehicleSyncData.wTrailerID)
-			{
-				bsSync->Write(true);
-				bsSync->Write(p->vehicleSyncData.wTrailerID);
-			}
-			else
-			{
-				bsSync->Write(false);
-			}
-			break;
-		}
-	}
-}
-
-void RebuildRPCData(BYTE uniqueID, RakNet::BitStream *bsSync, WORD playerid)
-{
-	switch(uniqueID)
-	{
-		case RPC_InitGame:
-		{
-			bool usecjwalk = static_cast<int>(pNetGame->bUseCJWalk) != 0;
-			bool limitglobalchat = static_cast<int>(pNetGame->bLimitGlobalChatRadius) != 0;
-			float globalchatradius = pNetGame->fGlobalChatRadius;
-			float nametagdistance = pNetGame->fNameTagDrawDistance;
-			bool disableenterexits = static_cast<int>(pNetGame->byteDisableEnterExits) != 0;
-			bool nametaglos = static_cast<int>(pNetGame->byteNameTagLOS) != 0;
-			bool manualvehengineandlights = static_cast<int>(pNetGame->bManulVehicleEngineAndLights) != 0;
-			int spawnsavailable = pNetGame->iSpawnsAvailable;
-			bool shownametags = static_cast<int>(pNetGame->byteShowNameTags) != 0;
-			bool showplayermarkers = static_cast<int>(pNetGame->bShowPlayerMarkers) != 0;
-			int onfoot_rate = CSAMPFunctions::GetIntVariable("onfoot_rate");
-			int incar_rate = CSAMPFunctions::GetIntVariable("incar_rate");
-			int weapon_rate = CSAMPFunctions::GetIntVariable("weapon_rate");
-			int lacgompmode = CSAMPFunctions::GetIntVariable("lagcompmode");
-			bool vehiclefriendlyfire = static_cast<int>(pNetGame->bVehicleFriendlyFire) != 0;
-
-			CCallbackManager::OnPlayerClientGameInit(playerid, &usecjwalk, &limitglobalchat, &globalchatradius, &nametagdistance, &disableenterexits, &nametaglos, &manualvehengineandlights,
-				&spawnsavailable, &shownametags, &showplayermarkers, &onfoot_rate, &incar_rate, &weapon_rate, &lacgompmode, &vehiclefriendlyfire);
-
-			bsSync->Reset();
-			bsSync->Write((bool)!!pNetGame->unklofasz);
-			bsSync->Write((bool)usecjwalk);
-			bsSync->Write((bool)!!pNetGame->byteAllowWeapons);
-			bsSync->Write(limitglobalchat);
-			bsSync->Write(globalchatradius);
-			bsSync->Write((bool)!!pNetGame->byteStuntBonus);
-			bsSync->Write(nametagdistance);
-			bsSync->Write(disableenterexits);
-			bsSync->Write(nametaglos);
-			bsSync->Write(manualvehengineandlights);
-			bsSync->Write(pNetGame->iSpawnsAvailable);
-			bsSync->Write(playerid);
-			bsSync->Write(shownametags);
-			bsSync->Write((int)showplayermarkers);
-			bsSync->Write(pNetGame->bTirePopping);
-			bsSync->Write(pNetGame->byteWeather);
-			bsSync->Write(pNetGame->fGravity);
-			bsSync->Write((bool)!!pNetGame->bLanMode);
-			bsSync->Write(pNetGame->iDeathDropMoney);
-			bsSync->Write(false);
-			bsSync->Write(onfoot_rate);
-			bsSync->Write(incar_rate);
-			bsSync->Write(weapon_rate);
-			bsSync->Write((int)2);
-			bsSync->Write(lacgompmode);
-
-			char* szHostName = CSAMPFunctions::GetStringVariable("hostname");
-			if(szHostName)
-			{
-				size_t len = strlen(szHostName);
-				bsSync->Write((BYTE)len);
-				bsSync->Write(szHostName, len);
-			}
-			else
-			{
-				bsSync->Write((BYTE)0);
-			}
-			bsSync->Write((char*)&pNetGame->pVehiclePool, 212); // modelsUsed
-			bsSync->Write((DWORD)vehiclefriendlyfire);
-			break;
-		}
-	}
-}
+char *CPlayerData::GetPlayerNameForPlayer(WORD nameplayerid)
+{
+	if (!m_szNames[nameplayerid][0])
+	{
+		return GetPlayerName_(nameplayerid);
+	}
+	return &m_szNames[nameplayerid][0];
+}
+
+bool CPlayerData::SetPlayerFightingStyleForPlayer(WORD styleplayerid, int style)
+{
+	m_iFightingStyles[styleplayerid] = style;
+
+	RakNet::BitStream bs;
+	bs.Write((WORD)styleplayerid);
+	bs.Write((BYTE)style);
+	pRakServer->RPC(&RPC_SetFightingStyle, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(wPlayerID), 0, 0);
+	return true;
+}
+
+int CPlayerData::GetPlayerFightingStyleForPlayer(WORD styleplayerid)
+{
+	CPlayer *p = pNetGame->pPlayerPool->pPlayer[styleplayerid];
+	if (m_iFightingStyles[styleplayerid] == -1)
+	{
+		return p->byteFightingStyle;
+	}
+	return m_iFightingStyles[styleplayerid];
+}
+
+WORD CPlayerData::GetGangZoneIDFromClientSide(WORD zoneid, bool bPlayer)
+{
+	// Loop though every global gang zone
+	if(!bPlayer)
+	{
+		for(WORD wZone = 0; wZone != MAX_GANG_ZONES; wZone++)
+		{
+			if(wClientSideGlobalZoneID[wZone] == zoneid)
+				return wZone;
+		}
+	}
+	else
+	{
+		for(WORD wZone = 0; wZone != MAX_GANG_ZONES; wZone++)
+		{
+			if(wClientSidePlayerZoneID[wZone] == zoneid)
+				return wZone;
+		}	
+	}
+	return 0xFFFF;
+}
+
+bool CPlayerData::DestroyObject_(WORD objectid)
+{
+	RakNet::BitStream bs;
+	bs.Write(objectid);
+	pRakServer->RPC(&RPC_DestroyObject, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(wPlayerID), 0, 0);
+	return 1;
+}
+
+void CPlayerData::Process(void)
+{
+	// Process AFK detection
+	DWORD dwTickCount = GetTickCount();
+	
+	CPlayerPool *pPlayerPool = pNetGame->pPlayerPool;
+	if (bEverUpdated && pPlayerPool->pPlayer[wPlayerID]->byteState != PLAYER_STATE_NONE && pPlayerPool->pPlayer[wPlayerID]->byteState != PLAYER_STATE_WASTED)
+	{
+		if(bAFKState == false && dwTickCount - dwLastUpdateTick > pServer->GetAFKAccuracy())
+		{
+			bAFKState = true;
+
+			CCallbackManager::OnPlayerPauseStateChange(wPlayerID, bAFKState);
+		}
+
+		else if(bAFKState == true && dwTickCount - dwLastUpdateTick < pServer->GetAFKAccuracy())
+		{
+			bAFKState = false;
+
+			CCallbackManager::OnPlayerPauseStateChange(wPlayerID, bAFKState);
+		}
+	}
+
+	if((dwTickCount - dwCreateAttachedObj > 3000) && dwCreateAttachedObj != 0)
+	{
+		//logprintf("wPlayerID: %d, stObj[i].wAttachPlayerID: %d - %d", wPlayerID, stObj[dwObjectID].wAttachPlayerID, dwObjectID);
+
+		// Attach created object to player
+		RakNet::BitStream bs;
+		bs.Write(pNetGame->pObjectPool->pPlayerObjects[wPlayerID][dwObjectID]->wObjectID); // m_wObjectID
+		bs.Write(stObj[dwObjectID].wAttachPlayerID); // playerid
+
+		bs.Write(stObj[dwObjectID].vecOffset.fX);
+		bs.Write(stObj[dwObjectID].vecOffset.fY);
+		bs.Write(stObj[dwObjectID].vecOffset.fZ);
+
+		bs.Write(stObj[dwObjectID].vecRot.fX);
+		bs.Write(stObj[dwObjectID].vecRot.fY);
+		bs.Write(stObj[dwObjectID].vecRot.fZ);
+
+		pRakServer->RPC(&RPC_AttachObject, &bs, LOW_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(wPlayerID), 0, 0);
+		dwCreateAttachedObj = 0;
+		dwObjectID = INVALID_OBJECT_ID;
+		bAttachedObjectCreated = true;
+	}
+
+	// Process gangzones
+	for(WORD zoneid = 0; zoneid != MAX_GANG_ZONES; zoneid++)
+	{
+		// If zone id is unused client side, then continue
+		if(byteClientSideZoneIDUsed[zoneid] == 0xFF) continue;
+
+		CGangZone *pGangZone = NULL;
+		if(byteClientSideZoneIDUsed[zoneid] == 0)
+		{
+			if(wClientSideGlobalZoneID[zoneid] == 0xFFFF)
+			{
+				logprintf("pPlayer->wClientSideGlobalZoneID[%d] = 0xFFFF", zoneid);
+				return;
+			}
+					
+			pGangZone = pServer->pGangZonePool->pGangZone[wClientSideGlobalZoneID[zoneid]];
+		}
+		else
+		{
+			if(wClientSidePlayerZoneID[zoneid] == 0xFFFF)
+			{
+				logprintf("pPlayer->wClientSidePlayerZoneID[%d] = 0xFFFF", zoneid);
+				return;
+			}
+
+			pGangZone = pPlayerZone[wClientSidePlayerZoneID[zoneid]];
+		}
+
+		if(!pGangZone) continue;
+
+		// Mutatók létrehozása
+		CVector *vecPos = &pNetGame->pPlayerPool->pPlayer[wPlayerID]->vecPosition;
+		float *fMinX = &pGangZone->fGangZone[0];
+		float *fMinY = &pGangZone->fGangZone[1];
+		float *fMaxX = &pGangZone->fGangZone[2];
+		float *fMaxY = &pGangZone->fGangZone[3];
+
+		//logprintf("validzone: %d, %f, %f, %f, %f", this->wClientSideGlobalZoneID[zoneid], *fMinX, *fMinY, *fMaxX, *fMaxY);
+		
+		// Ha benne van
+		if(vecPos->fX >= *fMinX && vecPos->fX <= *fMaxX && vecPos->fY >= *fMinY && vecPos->fY <= *fMaxY && !bInGangZone[zoneid])
+		{
+			bInGangZone[zoneid] = true;
+			//logprintf("enterzone: %d", zoneid);
+					
+			if(byteClientSideZoneIDUsed[zoneid] == 0)
+			{
+				CCallbackManager::OnPlayerEnterGangZone(wPlayerID, wClientSideGlobalZoneID[zoneid]);
+			}
+			else if(byteClientSideZoneIDUsed[zoneid] == 1)
+			{
+				CCallbackManager::OnPlayerEnterPlayerGangZone(wPlayerID, wClientSidePlayerZoneID[zoneid]);
+			}
+		}
+		else if(!(vecPos->fX >= *fMinX && vecPos->fX <= *fMaxX && vecPos->fY >= *fMinY && vecPos->fY <= *fMaxY) && bInGangZone[zoneid])
+		{
+			bInGangZone[zoneid] = false;
+			//logprintf("leavezone: %d", zoneid);
+					
+			if(byteClientSideZoneIDUsed[zoneid] == 0)
+			{
+				CCallbackManager::OnPlayerLeaveGangZone(wPlayerID, wClientSideGlobalZoneID[zoneid]);
+			}
+			else if(byteClientSideZoneIDUsed[zoneid] == 1)
+			{
+				CCallbackManager::OnPlayerLeavePlayerGangZone(wPlayerID, wClientSidePlayerZoneID[zoneid]);
+			}
+		}
+	}
+}
+
+void RebuildSyncData(RakNet::BitStream *bsSync, WORD toplayerid)
+{
+	BYTE id;
+	WORD playerid;
+
+	bsSync->Read(id);
+	bsSync->Read(playerid);
+	
+	//logprintf("RebuildSyncData pre %d - %d", id, playerid);
+	if(!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(toplayerid)) return;
+
+	//logprintf("RebuildSyncData %d - %d", id, playerid);
+	switch(id)
+	{
+		case ID_PLAYER_SYNC:
+		{
+			CPlayer *p = pNetGame->pPlayerPool->pPlayer[playerid];
+	
+			bsSync->Reset();
+			bsSync->Write((BYTE)ID_PLAYER_SYNC);
+			bsSync->Write(playerid);
+
+			// UP/DOWN KEYS
+			if(p->syncData.wUDAnalog) 
+			{
+				bsSync->Write(true);
+				bsSync->Write(p->syncData.wUDAnalog);
+			} 
+			else 
+			{
+				bsSync->Write(false);
+			}
+
+			// LEFT/RIGHT KEYS
+			if(p->syncData.wLRAnalog) 
+			{
+				bsSync->Write(true);
+				bsSync->Write(p->syncData.wLRAnalog);
+			} 
+			else 
+			{
+				bsSync->Write(false);
+			}
+
+			// Keys
+			WORD keys = p->syncData.wKeys &= ~pPlayerData[playerid]->dwDisabledKeys;
+			bsSync->Write(keys);
+	
+			// Position
+			if(pPlayerData[toplayerid]->bCustomPos[playerid])				
+				bsSync->Write(*pPlayerData[toplayerid]->vecCustomPos[playerid]);	
+			else
+				bsSync->Write((char*)&p->syncData.vecPosition, sizeof(CVector));
+			
+			// Rotation (in quaternion)
+			if(pPlayerData[toplayerid]->bCustomQuat[playerid])
+				bsSync->WriteNormQuat(pPlayerData[toplayerid]->fCustomQuat[playerid][0], pPlayerData[toplayerid]->fCustomQuat[playerid][1], pPlayerData[toplayerid]->fCustomQuat[playerid][2], pPlayerData[toplayerid]->fCustomQuat[playerid][3]);	
+			else
+				bsSync->WriteNormQuat(p->syncData.fQuaternion[0], p->syncData.fQuaternion[1], p->syncData.fQuaternion[2], p->syncData.fQuaternion[3]);
+			
+			// Health & armour compression
+			BYTE byteSyncHealthArmour = 0;
+			if( p->syncData.byteHealth > 0 && p->syncData.byteHealth < 100 ) 
+			{
+				byteSyncHealthArmour = ((BYTE)(p->syncData.byteHealth / 7)) << 4;
+			} 
+			else if(p->syncData.byteHealth >= 100) 
+			{
+				byteSyncHealthArmour = 0xF << 4;
+			}
+
+			if( p->syncData.byteArmour > 0 && p->syncData.byteArmour < 100 ) 
+			{
+				byteSyncHealthArmour |=  (BYTE)(p->syncData.byteArmour / 7);
+			}
+			else if(p->syncData.byteArmour >= 100) 
+			{
+				byteSyncHealthArmour |= 0xF;
+			}
+	
+			bsSync->Write(byteSyncHealthArmour);
+
+			// Current weapon
+			bsSync->Write(p->syncData.byteWeapon);
+
+			// Special action
+			bsSync->Write(p->syncData.byteSpecialAction);
+
+			// Velocity
+			bsSync->WriteVector(p->syncData.vecVelocity.fX, p->syncData.vecVelocity.fY, p->syncData.vecVelocity.fZ);
+
+			// Vehicle surfing (POSITION RELATIVE TO CAR SYNC)
+			if(p->syncData.wSurfingInfo) 
+			{
+				bsSync->Write(true);
+				bsSync->Write(p->syncData.wSurfingInfo);
+				bsSync->Write(p->syncData.vecSurfing.fX);
+				bsSync->Write(p->syncData.vecSurfing.fY);
+				bsSync->Write(p->syncData.vecSurfing.fZ);
+			} 
+			else 
+			{
+				bsSync->Write(false);
+			}
+	
+			// Animation
+			if(p->syncData.dwAnimationData)
+			{
+				bsSync->Write(true);
+				bsSync->Write((int)p->syncData.dwAnimationData);
+			}
+			else bsSync->Write(false);
+			break;
+		}
+		case ID_VEHICLE_SYNC:
+		{
+			CPlayer *p = pNetGame->pPlayerPool->pPlayer[playerid];
+
+			bsSync->Reset();
+			bsSync->Write((BYTE)ID_VEHICLE_SYNC);
+			bsSync->Write(playerid);
+
+			bsSync->Write(p->vehicleSyncData.wVehicleId);
+			bsSync->Write(p->vehicleSyncData.wUDAnalog);
+			bsSync->Write(p->vehicleSyncData.wLRAnalog);
+			
+			WORD keys = p->vehicleSyncData.wKeys &= ~pPlayerData[playerid]->dwDisabledKeys;
+			bsSync->Write(keys);
+			
+			bsSync->WriteNormQuat(p->vehicleSyncData.fQuaternion[0], p->vehicleSyncData.fQuaternion[1], p->vehicleSyncData.fQuaternion[2], p->vehicleSyncData.fQuaternion[3]);
+			bsSync->Write((char*)&p->vehicleSyncData.vecPosition, sizeof(CVector));
+			bsSync->WriteVector(p->vehicleSyncData.vecVelocity.fX, p->vehicleSyncData.vecVelocity.fY, p->vehicleSyncData.vecVelocity.fZ);
+			bsSync->Write((WORD)p->vehicleSyncData.fHealth);
+
+			// Health & armour compression
+			BYTE byteSyncHealthArmour=0;
+			if( p->vehicleSyncData.bytePlayerHealth > 0 && p->vehicleSyncData.bytePlayerHealth < 100 ) 
+			{
+				byteSyncHealthArmour = ((BYTE)(p->vehicleSyncData.bytePlayerHealth / 7)) << 4;
+			} 
+			else if(p->vehicleSyncData.bytePlayerHealth >= 100) 
+			{
+				byteSyncHealthArmour = 0xF << 4;
+			}
+
+			if( p->vehicleSyncData.bytePlayerArmour > 0 && p->vehicleSyncData.bytePlayerArmour < 100 ) 
+			{
+				byteSyncHealthArmour |=  (BYTE)(p->vehicleSyncData.bytePlayerArmour / 7);
+			}
+			else if(p->vehicleSyncData.bytePlayerArmour >= 100) 
+			{
+				byteSyncHealthArmour |= 0xF;
+			}
+
+			bsSync->Write(byteSyncHealthArmour);
+			bsSync->Write(p->vehicleSyncData.bytePlayerWeapon);
+
+			if(p->vehicleSyncData.byteSirenState)
+			{
+				bsSync->Write(true);
+			}
+			else
+			{
+				bsSync->Write(false);
+			}
+			
+			if(p->vehicleSyncData.byteGearState)
+			{
+				bsSync->Write(true);
+			}
+			else
+			{
+				bsSync->Write(false);
+			}
+
+			if(p->vehicleSyncData.fTrainSpeed)
+			{
+				bsSync->Write(true);
+				bsSync->Write(p->vehicleSyncData.fTrainSpeed);
+			}
+			else
+			{
+				bsSync->Write(false);
+			}
+
+			if(p->vehicleSyncData.wTrailerID)
+			{
+				bsSync->Write(true);
+				bsSync->Write(p->vehicleSyncData.wTrailerID);
+			}
+			else
+			{
+				bsSync->Write(false);
+			}
+			break;
+		}
+	}
+}
+
+bool RebuildRPCData(BYTE uniqueID, RakNet::BitStream *bsSync, WORD playerid)
+{
+	switch(uniqueID)
+	{
+		case RPC_ScmEvent:
+		{
+			bsSync->ResetReadPointer();
+			WORD issuerid;
+			bsSync->Read<WORD>(issuerid);
+			int data[4];
+			bsSync->Read<int>(data[0]);
+			bsSync->Read<int>(data[1]);
+			bsSync->Read<int>(data[2]);
+			bsSync->Read<int>(data[3]);
+			if(!CCallbackManager::OnOutcomeScmEvent(playerid, issuerid, data[0], data[1], data[2], data[3])) return false;
+			break;
+		}
+		case RPC_InitGame:
+		{
+			bool usecjwalk = static_cast<int>(pNetGame->bUseCJWalk) != 0;
+			bool limitglobalchat = static_cast<int>(pNetGame->bLimitGlobalChatRadius) != 0;
+			float globalchatradius = pNetGame->fGlobalChatRadius;
+			float nametagdistance = pNetGame->fNameTagDrawDistance;
+			bool disableenterexits = static_cast<int>(pNetGame->byteDisableEnterExits) != 0;
+			bool nametaglos = static_cast<int>(pNetGame->byteNameTagLOS) != 0;
+			bool manualvehengineandlights = static_cast<int>(pNetGame->bManulVehicleEngineAndLights) != 0;
+			int spawnsavailable = pNetGame->iSpawnsAvailable;
+			bool shownametags = static_cast<int>(pNetGame->byteShowNameTags) != 0;
+			bool showplayermarkers = static_cast<int>(pNetGame->bShowPlayerMarkers) != 0;
+			int onfoot_rate = CSAMPFunctions::GetIntVariable("onfoot_rate");
+			int incar_rate = CSAMPFunctions::GetIntVariable("incar_rate");
+			int weapon_rate = CSAMPFunctions::GetIntVariable("weapon_rate");
+			int lacgompmode = CSAMPFunctions::GetIntVariable("lagcompmode");
+			bool vehiclefriendlyfire = static_cast<int>(pNetGame->bVehicleFriendlyFire) != 0;
+
+			CCallbackManager::OnPlayerClientGameInit(playerid, &usecjwalk, &limitglobalchat, &globalchatradius, &nametagdistance, &disableenterexits, &nametaglos, &manualvehengineandlights,
+				&spawnsavailable, &shownametags, &showplayermarkers, &onfoot_rate, &incar_rate, &weapon_rate, &lacgompmode, &vehiclefriendlyfire);
+
+			bsSync->Reset();
+			bsSync->Write((bool)!!pNetGame->unklofasz);
+			bsSync->Write((bool)usecjwalk);
+			bsSync->Write((bool)!!pNetGame->byteAllowWeapons);
+			bsSync->Write(limitglobalchat);
+			bsSync->Write(globalchatradius);
+			bsSync->Write((bool)!!pNetGame->byteStuntBonus);
+			bsSync->Write(nametagdistance);
+			bsSync->Write(disableenterexits);
+			bsSync->Write(nametaglos);
+			bsSync->Write(manualvehengineandlights);
+			bsSync->Write(pNetGame->iSpawnsAvailable);
+			bsSync->Write(playerid);
+			bsSync->Write(shownametags);
+			bsSync->Write((int)showplayermarkers);
+			bsSync->Write(pNetGame->bTirePopping);
+			bsSync->Write(pNetGame->byteWeather);
+			bsSync->Write(pNetGame->fGravity);
+			bsSync->Write((bool)!!pNetGame->bLanMode);
+			bsSync->Write(pNetGame->iDeathDropMoney);
+			bsSync->Write(false);
+			bsSync->Write(onfoot_rate);
+			bsSync->Write(incar_rate);
+			bsSync->Write(weapon_rate);
+			bsSync->Write((int)2);
+			bsSync->Write(lacgompmode);
+
+			char* szHostName = CSAMPFunctions::GetStringVariable("hostname");
+			if(szHostName)
+			{
+				size_t len = strlen(szHostName);
+				bsSync->Write((BYTE)len);
+				bsSync->Write(szHostName, len);
+			}
+			else
+			{
+				bsSync->Write((BYTE)0);
+			}
+			bsSync->Write((char*)&pNetGame->pVehiclePool, 212); // modelsUsed
+			bsSync->Write((DWORD)vehiclefriendlyfire);
+			break;
+		}
+	}
+	return true;
+}
diff --git a/src/CPlayerData.h b/src/src/CPlayerData.h
similarity index 96%
rename from src/CPlayerData.h
rename to src/src/CPlayerData.h
index bff8250..793b7f9 100644
--- a/src/CPlayerData.h
+++ b/src/src/CPlayerData.h
@@ -58,20 +58,22 @@ class CPlayerData
 	CPlayerData(WORD playerid);
 	~CPlayerData(void);
 
+	bool ResetPlayerMarkerForPlayer(WORD resetplayerid);
+
 	bool SetPlayerTeamForPlayer(WORD teamplayerid, int team);
-	int GetPlayerTeamForPlayer(WORD teamplayerid);
+	int GetPlayerTeamForPlayer(WORD teamplayerid);
 	inline void ResetPlayerTeam(WORD playerid) { m_iTeams[playerid] = -1; }
 
-	bool SetPlayerSkinForPlayer(WORD skinplayerid, int skin);
-	int GetPlayerSkinForPlayer(WORD skinplayerid);
+	bool SetPlayerSkinForPlayer(WORD skinplayerid, int skin);
+	int GetPlayerSkinForPlayer(WORD skinplayerid);
 	inline void ResetPlayerSkin(WORD playerid) { m_iSkins[playerid] = -1; }
 
 	bool SetPlayerNameForPlayer(WORD nameplayerid, char *name);
-	char *GetPlayerNameForPlayer(WORD nameplayerid);
+	char *GetPlayerNameForPlayer(WORD nameplayerid);
 	inline void ResetPlayerName(WORD playerid) { m_szNames[playerid][0] = NULL; }
-
+
 	bool SetPlayerFightingStyleForPlayer(WORD styleplayerid, int style);
-	int GetPlayerFightingStyleForPlayer(WORD styleplayerid);
+	int GetPlayerFightingStyleForPlayer(WORD styleplayerid);
 	inline void ResetPlayerFightingStyle(WORD playerid){ m_iFightingStyles[playerid] = -1; }
 
 	WORD GetGangZoneIDFromClientSide(WORD zoneid, bool bPlayer = false);
@@ -94,6 +96,8 @@ class CPlayerData
 	float fBounds[4];
 
 	BYTE byteTeam;
+
+	int npcPid;
 	
 	// Special shits for store sync data
 	WORD dwDisabledKeys;
@@ -153,5 +157,5 @@ class CPlayerData
 };
 
 void RebuildSyncData(RakNet::BitStream *bsSync, WORD toplayerid);
-void RebuildRPCData(BYTE uniqueID, RakNet::BitStream *bsSync, WORD playerid);
+bool RebuildRPCData(BYTE uniqueID, RakNet::BitStream *bsSync, WORD playerid);
 #endif
\ No newline at end of file
diff --git a/src/CServer.cpp b/src/src/CServer.cpp
similarity index 95%
rename from src/CServer.cpp
rename to src/src/CServer.cpp
index f91ee26..92bff76 100644
--- a/src/CServer.cpp
+++ b/src/src/CServer.cpp
@@ -1,328 +1,339 @@
-#include "main.h"
-
-CServer::CServer(eSAMPVersion version)
-{
-	m_iTicks = 0;
-	m_iTickRate = 5;
-	m_bNightVisionFix = true;
-	m_dwAFKAccuracy = 1500;
-
-	memset(&pPlayerData, NULL, sizeof(pPlayerData));
-	bChangedVehicleColor.reset();
-	memset(&COBJECT_AttachedObjectPlayer, INVALID_PLAYER_ID, sizeof(COBJECT_AttachedObjectPlayer));
-
-	// Initialize addresses
-	CAddress::Initialize(version);
-	// Initialize SAMP Function
-	CSAMPFunctions::PreInitialize();
-
-	// Initialize default valid name characters
-	for(BYTE i = '0'; i <= '9'; i++)
-	{
-		m_vecValidNameCharacters.push_back(i);
-	}
-	for(BYTE i = 'A'; i <= 'Z'; i++)
-	{
-		m_vecValidNameCharacters.push_back(i);
-	}
-	for(BYTE i = 'a'; i <= 'z'; i++)
-	{
-		m_vecValidNameCharacters.push_back(i);
-	}
-	m_vecValidNameCharacters.push_back(']');
-	m_vecValidNameCharacters.push_back('[');
-	m_vecValidNameCharacters.push_back('_');
-	m_vecValidNameCharacters.push_back('$');
-	m_vecValidNameCharacters.push_back('=');
-	m_vecValidNameCharacters.push_back('(');
-	m_vecValidNameCharacters.push_back(')');
-	m_vecValidNameCharacters.push_back('@');
-	m_vecValidNameCharacters.push_back('.');
-}
-
-CServer::~CServer()
-{
-	for(int i = 0; i != MAX_PLAYERS; i++)
-		RemovePlayer(i);
-
-	SAFE_DELETE(pGangZonePool);
-}
-
-bool CServer::AddPlayer(int playerid)
-{
-	if(!pPlayerData[playerid])
-	{
-		pPlayerData[playerid] = new CPlayerData(static_cast<WORD>(playerid));
-		return 1;
-	}
-	return 0;
-}
-
-bool CServer::RemovePlayer(int playerid)
-{
-	if(pPlayerData[playerid])
-	{
-		SAFE_DELETE(pPlayerData[playerid]);
-		return 1;
-	}
-	return 0;
-}
-
-void CServer::Process()
-{
-	if(m_iTickRate == -1) return;
-
-	if(++m_iTicks >= m_iTickRate)
-	{
-		m_iTicks = 0;
-		for(WORD playerid = 0; playerid != MAX_PLAYERS; playerid++)
-		{
-			if(!IsPlayerConnectedEx(playerid)) continue;
-			
-			// Process player
-			pPlayerData[playerid]->Process();
-		}
-#ifdef NEW_PICKUP_SYSTEM
-		if(pServer->pPickupPool)
-			pServer->pPickupPool->Process();
-#endif
-	}
-}
-
-bool CServer::OnPlayerStreamIn(WORD playerid, WORD forplayerid)
-{
-	//logprintf("join stream zone playerid = %d, forplayerid = %d", playerid, forplayerid);
-	PlayerID playerId = pRakServer->GetPlayerIDFromIndex(playerid);
-	PlayerID forplayerId = pRakServer->GetPlayerIDFromIndex(forplayerid);
-	
-	// For security..
-	if (playerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress || forplayerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress)
-		return 0;
-
-	if(!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(forplayerid))
-		return 0;
-
-	CObjectPool *pObjectPool = pNetGame->pObjectPool;
-	for(WORD i = 0; i != MAX_OBJECTS; i++)
-	{
-		if(pPlayerData[forplayerid]->stObj[i].wAttachPlayerID == playerid && !pPlayerData[forplayerid]->bAttachedObjectCreated)
-		{
-			logprintf("should work");
-			if(!pObjectPool->pPlayerObjects[forplayerid][i]) 
-			{
-				logprintf("YSF ASSERTATION FAILED <OnPlayerStreamIn> - m_pPlayerObjects = 0");
-				return 0;
-			}
-
-			logprintf("attach objects i: %d, forplayerid: %d", i, forplayerid);
-			// First create the object for the player. We don't remove it from the pools, so we need to send RPC for the client to create object
-			RakNet::BitStream bs;
-			bs.Write(pObjectPool->pPlayerObjects[forplayerid][i]->wObjectID); // m_wObjectID
-			bs.Write(pObjectPool->pPlayerObjects[forplayerid][i]->iModel);  // iModel
-
-			bs.Write(pPlayerData[forplayerid]->stObj[i].vecOffset.fX);
-			bs.Write(pPlayerData[forplayerid]->stObj[i].vecOffset.fY);
-			bs.Write(pPlayerData[forplayerid]->stObj[i].vecOffset.fZ);
-
-			bs.Write(pPlayerData[forplayerid]->stObj[i].vecRot.fX);
-			bs.Write(pPlayerData[forplayerid]->stObj[i].vecRot.fY);
-			bs.Write(pPlayerData[forplayerid]->stObj[i].vecRot.fZ);
-			bs.Write(pObjectPool->pPlayerObjects[forplayerid][i]->fDrawDistance);
-			bs.Write(pObjectPool->pPlayerObjects[forplayerid][i]->bNoCameraCol); 
-			bs.Write((WORD)-1); // wAttachedVehicleID
-			bs.Write((WORD)-1); // wAttachedObjectID
-			bs.Write((BYTE)0); // dwMaterialCount
-
-			pRakServer->RPC(&RPC_CreateObject, &bs, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, forplayerId, 0, 0);
-			
-			pPlayerData[forplayerid]->dwCreateAttachedObj = GetTickCount();
-			pPlayerData[forplayerid]->dwObjectID = i;
-			pPlayerData[forplayerid]->bAttachedObjectCreated = true;
-			/*
-			logprintf("join, modelid: %d, %d, %f, %f, %f, %f, %f, %f", pObjectPool->pPlayerObjects[forplayerid][i]->iModel,
-				pPlayerData[forplayerid]->stObj[i].wAttachPlayerID,
-				pPlayerData[forplayerid]->stObj[i].vecOffset.fX, pPlayerData[forplayerid]->stObj[i].vecOffset.fY, pPlayerData[forplayerid]->stObj[i].vecOffset.fZ,
-				pPlayerData[forplayerid]->stObj[i].vecRot.fX, pPlayerData[forplayerid]->stObj[i].vecRot.fY, pPlayerData[forplayerid]->stObj[i].vecRot.fZ);
-			*/
-		}
-	}
-	return 1;
-}
-
-bool CServer::OnPlayerStreamOut(WORD playerid, WORD forplayerid)
-{
-	//logprintf("leave stream zone playerid = %d, forplayerid = %d", playerid, forplayerid);
-	PlayerID playerId = pRakServer->GetPlayerIDFromIndex(playerid);
-	PlayerID forplayerId = pRakServer->GetPlayerIDFromIndex(forplayerid);
-	
-	if (playerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress || forplayerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress)
-		return 0;
-
-	if(!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(forplayerid))
-		return 0;
-
-	CObjectPool *pObjectPool = pNetGame->pObjectPool;
-	for(WORD i = 0; i != MAX_OBJECTS; i++)
-	{
-		if(pPlayerData[forplayerid]->stObj[i].wAttachPlayerID == playerid && pPlayerData[forplayerid]->bAttachedObjectCreated)
-		{
-			if(!pObjectPool->pPlayerObjects[forplayerid][i]) 
-			{
-				logprintf("YSF ASSERTATION FAILED <OnPlayerStreamOut> - m_pPlayerObjects = 0");
-				return 0;
-			}
-
-			//logprintf("remove objects i: %d, forplayerid: %d", i, forplayerid);
-			if(pPlayerData[playerid]->bAttachedObjectCreated)
-			{
-				pPlayerData[playerid]->DestroyObject_(i);
-			}
-			pPlayerData[playerid]->dwCreateAttachedObj = 0;
-			pPlayerData[forplayerid]->bAttachedObjectCreated = false;
-			/*
-			logprintf("leave, modelid: %d, %d, %f, %f, %f, %f, %f, %f", pObjectPool->pPlayerObjects[forplayerid][i]->iModel,
-				pPlayerData[forplayerid]->stObj[i].wAttachPlayerID,
-				pPlayerData[forplayerid]->stObj[i].vecOffset.fX, pPlayerData[forplayerid]->stObj[i].vecOffset.fY, pPlayerData[forplayerid]->stObj[i].vecOffset.fZ,
-				pPlayerData[forplayerid]->stObj[i].vecRot.fX, pPlayerData[forplayerid]->stObj[i].vecRot.fY, pPlayerData[forplayerid]->stObj[i].vecRot.fZ);
-			*/
-		}
-	}
-	return 1;
-}
-
-void CServer::SetGravity_(float fGravity)
-{
-	// Update console
-	char szGravity[16];
-	sprintf(szGravity, "%f", fGravity);
-
-	pNetGame->fGravity = fGravity;
-	CSAMPFunctions::SetStringVariable("gravity", szGravity);
-
-	// Minden játékos gravitációja átállítása arra, amire a szerver gravitációját beállítottuk
-	for(WORD i = 0; i != MAX_PLAYERS; i++)
-	{
-		if(IsPlayerConnectedEx(i))
-			pPlayerData[i]->fGravity = fGravity; 
-	}
-	
-	RakNet::BitStream bs;
-	bs.Write(fGravity);
-	pRakServer->RPC(&RPC_Gravity, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, 0);
-}
-
-float CServer::GetGravity_(void)
-{
-	return pNetGame->fGravity;
-}
-
-void CServer::SetWeather_(BYTE byteWeather)
-{
-	// Update console
-	char szWeather[8];
-	sprintf(szWeather, "%d", byteWeather);
-	
-	pNetGame->byteWeather = byteWeather;
-	CSAMPFunctions::SetStringVariable("weather", szWeather);
-
-	// Minden játékos időjárása átállítása arra, amire a szerver időjárást beállítottuk
-
-	RakNet::BitStream bs;
-	bs.Write(byteWeather);
-	pRakServer->RPC(&RPC_Weather, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, 0);
-}
-
-BYTE CServer::GetWeather_(void)
-{
-	return pNetGame->byteWeather;
-}
-
-void CServer::AllowNickNameCharacter(char character, bool enable)
-{
-	if (enable)
-	{
-		std::vector<char>::iterator it = std::find(m_vecValidNameCharacters.begin(), m_vecValidNameCharacters.end(), character);
-		if (it == m_vecValidNameCharacters.end())
-		{
-			m_vecValidNameCharacters.push_back(character);
-		}
-	}
-	else
-	{
-		std::vector<char>::iterator it = std::find(m_vecValidNameCharacters.begin(), m_vecValidNameCharacters.end(), character);
-		if (it != m_vecValidNameCharacters.end())
-		{
-			m_vecValidNameCharacters.erase(it);
-		}
-	}
-}
-
-bool CServer::IsNickNameCharacterAllowed(char character)
-{
-	std::vector<char>::iterator it = std::find(m_vecValidNameCharacters.begin(), m_vecValidNameCharacters.end(), character);
-	return (it != m_vecValidNameCharacters.end());
-}
-
-bool CServer::IsValidNick(char *szName)
-{
-	while (*szName)
-	{
-		if (IsNickNameCharacterAllowed(*szName))
-		{
-			szName++;
-		}
-		else
-		{
-			return false;
-		}
-	}
-	return true;
-}
-
-void CServer::SetExtendedNetStatsEnabled(bool enable)
-{
-	if(CAddress::ADDR_GetNetworkStats_VerbosityLevel)
-	{
-		*(BYTE*)(CAddress::ADDR_GetNetworkStats_VerbosityLevel + 1) = enable ? 2 : 1;
-		*(BYTE*)(CAddress::ADDR_GetPlayerNetworkStats_VerbosityLevel + 1) = enable ? 2 : 1;
-	}
-}
-
-bool CServer::IsExtendedNetStatsEnabled(void)
-{
-	if(CAddress::ADDR_GetNetworkStats_VerbosityLevel)
-	{
-		return static_cast<int>(*(BYTE*)(CAddress::ADDR_GetNetworkStats_VerbosityLevel + 1) != 1);
-	}
-	return false;
-}
-
-WORD CServer::GetMaxPlayers_()
-{
-	WORD count = 0;
-	CPlayerPool *pPlayerPool = pNetGame->pPlayerPool;
-	for (WORD i = 0; i != MAX_PLAYERS; i++)
-		if (pPlayerPool->bIsNPC[i])
-			count++;
-	return static_cast<WORD>(CSAMPFunctions::GetIntVariable("maxplayers")) - count;
-}
-
-WORD CServer::GetPlayerCount()
-{
-	WORD count = 0;
-	CPlayerPool *pPlayerPool = pNetGame->pPlayerPool;
-	for (WORD i = 0; i != MAX_PLAYERS; i++)
-		if (IsPlayerConnectedEx(i) && !pPlayerPool->bIsNPC[i] && !pPlayerData[i]->bHidden)
-			count++;
-	return count;
-}
-
-WORD CServer::GetNPCCount()
-{
-	WORD count = 0;
-	CPlayerPool *pPlayerPool = pNetGame->pPlayerPool;
-	for (WORD i = 0; i != MAX_PLAYERS; i++)
-		if (pPlayerPool->bIsPlayerConnectedEx[i] && pPlayerPool->bIsNPC[i])
-			count++;
-	return count;
+#include "main.h"
+
+CServer::CServer(eSAMPVersion version)
+{
+	m_iTicks = 0;
+	m_iTickRate = 5;
+	m_bNightVisionFix = true;
+	m_dwAFKAccuracy = 1500;
+	NPCTrackingEnabled = false;
+
+	memset(&pPlayerData, NULL, sizeof(pPlayerData));
+	bChangedVehicleColor.reset();
+	memset(&COBJECT_AttachedObjectPlayer, INVALID_PLAYER_ID, sizeof(COBJECT_AttachedObjectPlayer));
+
+	// Initialize addresses
+	CAddress::Initialize(version);
+	// Initialize SAMP Function
+	CSAMPFunctions::PreInitialize();
+
+	// Initialize default valid name characters
+	for(BYTE i = '0'; i <= '9'; i++)
+	{
+		m_vecValidNameCharacters.push_back(i);
+	}
+	for(BYTE i = 'A'; i <= 'Z'; i++)
+	{
+		m_vecValidNameCharacters.push_back(i);
+	}
+	for(BYTE i = 'a'; i <= 'z'; i++)
+	{
+		m_vecValidNameCharacters.push_back(i);
+	}
+	m_vecValidNameCharacters.push_back(']');
+	m_vecValidNameCharacters.push_back('[');
+	m_vecValidNameCharacters.push_back('_');
+	m_vecValidNameCharacters.push_back('$');
+	m_vecValidNameCharacters.push_back('=');
+	m_vecValidNameCharacters.push_back('(');
+	m_vecValidNameCharacters.push_back(')');
+	m_vecValidNameCharacters.push_back('@');
+	m_vecValidNameCharacters.push_back('.');
+}
+
+CServer::~CServer()
+{
+	for(int i = 0; i != MAX_PLAYERS; i++)
+		RemovePlayer(i);
+
+	SAFE_DELETE(pGangZonePool);
+}
+
+bool CServer::AddPlayer(int playerid)
+{
+	if(!pPlayerData[playerid])
+	{
+		pPlayerData[playerid] = new CPlayerData(static_cast<WORD>(playerid));
+		return 1;
+	}
+	return 0;
+}
+
+bool CServer::RemovePlayer(int playerid)
+{
+	if(pPlayerData[playerid])
+	{
+		SAFE_DELETE(pPlayerData[playerid]);
+		return 1;
+	}
+	return 0;
+}
+
+void CServer::Process()
+{
+	if(m_iTickRate == -1) return;
+
+	if(++m_iTicks >= m_iTickRate)
+	{
+		m_iTicks = 0;
+		for(WORD playerid = 0; playerid != MAX_PLAYERS; playerid++)
+		{
+			if(!IsPlayerConnectedEx(playerid)) continue;
+			
+			// Process player
+			pPlayerData[playerid]->Process();
+		}
+#ifdef NEW_PICKUP_SYSTEM
+		if(pServer->pPickupPool)
+			pServer->pPickupPool->Process();
+#endif
+	}
+}
+
+bool CServer::OnPlayerStreamIn(WORD playerid, WORD forplayerid)
+{
+	//logprintf("join stream zone playerid = %d, forplayerid = %d", playerid, forplayerid);
+	PlayerID playerId = pRakServer->GetPlayerIDFromIndex(playerid);
+	PlayerID forplayerId = pRakServer->GetPlayerIDFromIndex(forplayerid);
+	
+	// For security..
+	if (playerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress || forplayerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress)
+		return 0;
+
+	if(!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(forplayerid))
+		return 0;
+
+	CObjectPool *pObjectPool = pNetGame->pObjectPool;
+	for(WORD i = 0; i != MAX_OBJECTS; i++)
+	{
+		if(pPlayerData[forplayerid]->stObj[i].wAttachPlayerID == playerid && !pPlayerData[forplayerid]->bAttachedObjectCreated)
+		{
+			//logprintf("should work");
+			if(!pObjectPool->pPlayerObjects[forplayerid][i]) 
+			{
+				logprintf("YSF ASSERTATION FAILED <OnPlayerStreamIn> - m_pPlayerObjects = 0");
+				return 0;
+			}
+
+			//logprintf("attach objects i: %d, forplayerid: %d", i, forplayerid);
+			// First create the object for the player. We don't remove it from the pools, so we need to send RPC for the client to create object
+			RakNet::BitStream bs;
+			bs.Write(pObjectPool->pPlayerObjects[forplayerid][i]->wObjectID); // m_wObjectID
+			bs.Write(pObjectPool->pPlayerObjects[forplayerid][i]->iModel);  // iModel
+
+			bs.Write(pPlayerData[forplayerid]->stObj[i].vecOffset.fX);
+			bs.Write(pPlayerData[forplayerid]->stObj[i].vecOffset.fY);
+			bs.Write(pPlayerData[forplayerid]->stObj[i].vecOffset.fZ);
+
+			bs.Write(pPlayerData[forplayerid]->stObj[i].vecRot.fX);
+			bs.Write(pPlayerData[forplayerid]->stObj[i].vecRot.fY);
+			bs.Write(pPlayerData[forplayerid]->stObj[i].vecRot.fZ);
+			bs.Write(pObjectPool->pPlayerObjects[forplayerid][i]->fDrawDistance);
+			bs.Write(pObjectPool->pPlayerObjects[forplayerid][i]->bNoCameraCol); 
+			bs.Write((WORD)-1); // wAttachedVehicleID
+			bs.Write((WORD)-1); // wAttachedObjectID
+			bs.Write((BYTE)0); // dwMaterialCount
+
+			pRakServer->RPC(&RPC_CreateObject, &bs, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, forplayerId, 0, 0);
+			
+			pPlayerData[forplayerid]->dwCreateAttachedObj = GetTickCount();
+			pPlayerData[forplayerid]->dwObjectID = i;
+			pPlayerData[forplayerid]->bAttachedObjectCreated = true;
+			/*
+			logprintf("join, modelid: %d, %d, %f, %f, %f, %f, %f, %f", pObjectPool->pPlayerObjects[forplayerid][i]->iModel,
+				pPlayerData[forplayerid]->stObj[i].wAttachPlayerID,
+				pPlayerData[forplayerid]->stObj[i].vecOffset.fX, pPlayerData[forplayerid]->stObj[i].vecOffset.fY, pPlayerData[forplayerid]->stObj[i].vecOffset.fZ,
+				pPlayerData[forplayerid]->stObj[i].vecRot.fX, pPlayerData[forplayerid]->stObj[i].vecRot.fY, pPlayerData[forplayerid]->stObj[i].vecRot.fZ);
+			*/
+		}
+	}
+	return 1;
+}
+
+bool CServer::OnPlayerStreamOut(WORD playerid, WORD forplayerid)
+{
+	//logprintf("leave stream zone playerid = %d, forplayerid = %d", playerid, forplayerid);
+	PlayerID playerId = pRakServer->GetPlayerIDFromIndex(playerid);
+	PlayerID forplayerId = pRakServer->GetPlayerIDFromIndex(forplayerid);
+	
+	if (playerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress || forplayerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress)
+		return 0;
+
+	if(!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(forplayerid))
+		return 0;
+
+	CObjectPool *pObjectPool = pNetGame->pObjectPool;
+	for(WORD i = 0; i != MAX_OBJECTS; i++)
+	{
+		if(pPlayerData[forplayerid]->stObj[i].wAttachPlayerID == playerid && pPlayerData[forplayerid]->bAttachedObjectCreated)
+		{
+			if(!pObjectPool->pPlayerObjects[forplayerid][i]) 
+			{
+				logprintf("YSF ASSERTATION FAILED <OnPlayerStreamOut> - m_pPlayerObjects = 0");
+				return 0;
+			}
+
+			//logprintf("remove objects i: %d, forplayerid: %d", i, forplayerid);
+			if(pPlayerData[playerid]->bAttachedObjectCreated)
+			{
+				pPlayerData[playerid]->DestroyObject_(i);
+			}
+			pPlayerData[playerid]->dwCreateAttachedObj = 0;
+			pPlayerData[forplayerid]->bAttachedObjectCreated = false;
+			/*
+			logprintf("leave, modelid: %d, %d, %f, %f, %f, %f, %f, %f", pObjectPool->pPlayerObjects[forplayerid][i]->iModel,
+				pPlayerData[forplayerid]->stObj[i].wAttachPlayerID,
+				pPlayerData[forplayerid]->stObj[i].vecOffset.fX, pPlayerData[forplayerid]->stObj[i].vecOffset.fY, pPlayerData[forplayerid]->stObj[i].vecOffset.fZ,
+				pPlayerData[forplayerid]->stObj[i].vecRot.fX, pPlayerData[forplayerid]->stObj[i].vecRot.fY, pPlayerData[forplayerid]->stObj[i].vecRot.fZ);
+			*/
+		}
+	}
+	return 1;
+}
+
+void CServer::SetGravity_(float fGravity)
+{
+	// Update console
+	char szGravity[16];
+	sprintf(szGravity, "%f", fGravity);
+
+	pNetGame->fGravity = fGravity;
+	CSAMPFunctions::SetStringVariable("gravity", szGravity);
+
+	// Minden játékos gravitációja átállítása arra, amire a szerver gravitációját beállítottuk
+	for(WORD i = 0; i != MAX_PLAYERS; i++)
+	{
+		if(IsPlayerConnectedEx(i))
+			pPlayerData[i]->fGravity = fGravity; 
+	}
+	
+	RakNet::BitStream bs;
+	bs.Write(fGravity);
+	pRakServer->RPC(&RPC_Gravity, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, 0);
+}
+
+float CServer::GetGravity_(void)
+{
+	return pNetGame->fGravity;
+}
+
+void CServer::SetWeather_(BYTE byteWeather)
+{
+	// Update console
+	char szWeather[8];
+	sprintf(szWeather, "%d", byteWeather);
+	
+	pNetGame->byteWeather = byteWeather;
+	CSAMPFunctions::SetStringVariable("weather", szWeather);
+
+	// Minden játékos időjárása átállítása arra, amire a szerver időjárást beállítottuk
+
+	RakNet::BitStream bs;
+	bs.Write(byteWeather);
+	pRakServer->RPC(&RPC_Weather, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, 0);
+}
+
+BYTE CServer::GetWeather_(void)
+{
+	return pNetGame->byteWeather;
+}
+
+void CServer::AllowNickNameCharacter(char character, bool enable)
+{
+	if (enable)
+	{
+		std::vector<char>::iterator it = std::find(m_vecValidNameCharacters.begin(), m_vecValidNameCharacters.end(), character);
+		if (it == m_vecValidNameCharacters.end())
+		{
+			m_vecValidNameCharacters.push_back(character);
+		}
+	}
+	else
+	{
+		std::vector<char>::iterator it = std::find(m_vecValidNameCharacters.begin(), m_vecValidNameCharacters.end(), character);
+		if (it != m_vecValidNameCharacters.end())
+		{
+			m_vecValidNameCharacters.erase(it);
+		}
+	}
+}
+
+bool CServer::IsNickNameCharacterAllowed(char character)
+{
+	std::vector<char>::iterator it = std::find(m_vecValidNameCharacters.begin(), m_vecValidNameCharacters.end(), character);
+	return (it != m_vecValidNameCharacters.end());
+}
+
+bool CServer::IsValidNick(char *szName)
+{
+	while (*szName)
+	{
+		if (IsNickNameCharacterAllowed(*szName))
+		{
+			szName++;
+		}
+		else
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+void CServer::SetExtendedNetStatsEnabled(bool enable)
+{
+	if(CAddress::ADDR_GetNetworkStats_VerbosityLevel)
+	{
+		*(BYTE*)(CAddress::ADDR_GetNetworkStats_VerbosityLevel + 1) = enable ? 2 : 1;
+		*(BYTE*)(CAddress::ADDR_GetPlayerNetworkStats_VerbosityLevel + 1) = enable ? 2 : 1;
+	}
+}
+
+bool CServer::IsExtendedNetStatsEnabled(void)
+{
+	if(CAddress::ADDR_GetNetworkStats_VerbosityLevel)
+	{
+		return static_cast<int>(*(BYTE*)(CAddress::ADDR_GetNetworkStats_VerbosityLevel + 1) != 1);
+	}
+	return false;
+}
+
+WORD CServer::GetMaxPlayers_()
+{
+	WORD count = 0;
+	CPlayerPool *pPlayerPool = pNetGame->pPlayerPool;
+	for (WORD i = 0; i != MAX_PLAYERS; i++)
+		if (pPlayerPool->bIsNPC[i])
+			count++;
+	return static_cast<WORD>(CSAMPFunctions::GetIntVariable("maxplayers")) - count;
+}
+
+WORD CServer::GetPlayerCount()
+{
+	WORD count = 0;
+	CPlayerPool *pPlayerPool = pNetGame->pPlayerPool;
+	for (WORD i = 0; i != MAX_PLAYERS; i++)
+		if (IsPlayerConnectedEx(i) && !pPlayerPool->bIsNPC[i] && !pPlayerData[i]->bHidden)
+			count++;
+	return count;
+}
+
+WORD CServer::GetNPCCount()
+{
+	WORD count = 0;
+	CPlayerPool *pPlayerPool = pNetGame->pPlayerPool;
+	for (WORD i = 0; i != MAX_PLAYERS; i++)
+		if (pPlayerPool->bIsPlayerConnectedEx[i] && pPlayerPool->bIsNPC[i])
+			count++;
+	return count;
+}
+
+void CServer::ToggleNPCTracking(bool enable)
+{
+	NPCTrackingEnabled = enable;
+}
+
+bool CServer::IsNPCTrackingEnabled()
+{
+	return NPCTrackingEnabled;
 }
\ No newline at end of file
diff --git a/src/CServer.h b/src/src/CServer.h
similarity index 94%
rename from src/CServer.h
rename to src/src/CServer.h
index d367470..ca4e99d 100644
--- a/src/CServer.h
+++ b/src/src/CServer.h
@@ -57,6 +57,9 @@ class CServer
 	WORD GetPlayerCount();
 	WORD GetNPCCount();
 
+	void ToggleNPCTracking(bool enable);
+	bool IsNPCTrackingEnabled();
+
 	CGangZonePool *pGangZonePool;
 	CYSFPickupPool *pPickupPool;
 
@@ -70,6 +73,7 @@ class CServer
 	int m_iTickRate;
 	bool m_bNightVisionFix : 1;
 	bool m_bExtendedNetStats : 1;
+	bool NPCTrackingEnabled : 1;
 	DWORD m_dwAFKAccuracy;
 
 	std::vector <char> m_vecValidNameCharacters;
diff --git a/src/CVector.h b/src/src/CVector.h
similarity index 100%
rename from src/CVector.h
rename to src/src/CVector.h
diff --git a/src/Functions.cpp b/src/src/Functions.cpp
similarity index 52%
rename from src/Functions.cpp
rename to src/src/Functions.cpp
index b05db78..da17b7a 100644
--- a/src/Functions.cpp
+++ b/src/src/Functions.cpp
@@ -1,4 +1,20 @@
 #include "main.h"
+#if !defined(_WIN32) && !defined(CUSTOM_BANLIST)
+#include <fnmatch.h>
+#endif
+
+#ifdef _WIN32
+#include <tlhelp32.h>
+#include <winternl.h>
+
+#include <comdef.h>
+#include <Wbemidl.h>
+#pragma comment(lib, "wbemuuid.lib")
+#else
+#include <stdio.h>
+#include <sys/types.h>
+#include <dirent.h>
+#endif
 
 CConsole__AddStringVariable_t			CSAMPFunctions::pfn__CConsole__AddStringVariable = NULL;
 CConsole__GetStringVariable_t			CSAMPFunctions::pfn__CConsole__GetStringVariable = NULL;
@@ -26,6 +42,83 @@ RakNet__Send_t							CSAMPFunctions::pfn__RakNet__Send = NULL;
 RakNet__RPC_t							CSAMPFunctions::pfn__RakNet__RPC = NULL;
 RakNet__Receive_t						CSAMPFunctions::pfn__RakNet__Receive = NULL;
 
+#ifdef CUSTOM_BANLIST
+RakNet__AddToBanList_t					CSAMPFunctions::pfn__RakNet__AddToBanList = NULL;
+RakNet__RemoveFromBanList_t				CSAMPFunctions::pfn__RakNet__RemoveFromBanList = NULL;
+RakNet__ClearBanList_t					CSAMPFunctions::pfn__RakNet__ClearBanList = NULL;
+
+struct BanRecord
+{
+	unsigned long ip;
+	unsigned long mask;
+
+	BanRecord(const char *addr)
+	{
+		/*logprintf(addr);
+		size_t len = strlen(addr);
+		char *str = (char*)alloca(len+1);
+		memcpy(str, addr, len);
+		str[len] = 0;*/
+
+		ip = 0;
+		mask = 0;
+
+		int pos = 0;
+		bool next = false;
+		size_t len = strlen(addr);
+		for(unsigned int i = 0; i < len; i++)
+		{
+			if(addr[i] == '*')
+			{
+				mask |= 0xFF << (pos*8);
+				next = true;
+				pos++;
+			}else if(addr[i] == '.')
+			{
+				next = false;
+			}else{
+				if(!next)
+				{
+					ip |= strtol(addr+i, NULL, 10) << (pos*8);
+					next = true;
+					pos++;
+				}
+			}
+		}
+		mask = ~mask;
+
+		logprintf("%x & %x", ip, mask);
+		
+		/*int pos;
+		char *p = strtok(str, ".");
+		while(p != NULL)
+		{
+			if(p[0] != '*')
+			{
+				ip |= strtol(p, NULL, 10) << (pos*8);
+			}else{
+				mask |= 0xFF << (pos*8);
+			}
+			p = strtok(NULL, ".");
+			pos++;
+		}
+		mask = ~mask;*/
+	}
+
+	bool operator==(const BanRecord &rec) const
+	{
+		return (ip == rec.ip && mask == rec.mask);
+	}
+
+    /*bool operator <(const BanRecord &rec) const
+    {
+       return ip < rec.ip;
+    }*/
+};
+
+std::vector<BanRecord> banList;
+#endif
+
 void CSAMPFunctions::PreInitialize()
 {
 	pfn__CConsole__AddStringVariable = (CConsole__AddStringVariable_t)(CAddress::FUNC_CConsole__AddStringVariable);
@@ -80,6 +173,29 @@ void CSAMPFunctions::PostInitialize()
 	pRakServer_VTBL[RAKNET_SEND_OFFSET] = (int)CHookRakServer::Send;
 	pRakServer_VTBL[RAKNET_RPC_OFFSET] = (int)CHookRakServer::RPC_2;
 	pRakServer_VTBL[RAKNET_RECEIVE_OFFSET] = (int)CHookRakServer::Receive;
+
+#ifdef CUSTOM_BANLIST
+	Unlock((void*)&pRakServer_VTBL[RAKNET_ADD_BAN_OFFSET], 4);
+	Unlock((void*)&pRakServer_VTBL[RAKNET_REMOVE_BAN_OFFSET], 4);
+	Unlock((void*)&pRakServer_VTBL[RAKNET_CLEAR_BANS_OFFSET], 4);
+	
+	pfn__RakNet__AddToBanList = (RakNet__AddToBanList_t)(pRakServer_VTBL[RAKNET_ADD_BAN_OFFSET]);
+	pfn__RakNet__RemoveFromBanList = (RakNet__RemoveFromBanList_t)(pRakServer_VTBL[RAKNET_REMOVE_BAN_OFFSET]);
+	pfn__RakNet__ClearBanList = (RakNet__ClearBanList_t)(pRakServer_VTBL[RAKNET_CLEAR_BANS_OFFSET]);
+	
+	pRakServer_VTBL[RAKNET_ADD_BAN_OFFSET] = (int)CHookRakServer::AddToBanList;
+	pRakServer_VTBL[RAKNET_REMOVE_BAN_OFFSET] = (int)CHookRakServer::RemoveFromBanList;
+	pRakServer_VTBL[RAKNET_CLEAR_BANS_OFFSET] = (int)CHookRakServer::ClearBanList;
+	
+	int bans = pRakServer->GetBanListSize();
+	char ***banlist = pRakServer->GetBanList();
+	for(int i = 0; i < bans; i++)
+	{
+		banList.push_back(BanRecord(*banlist[i]));
+	}
+
+	logprintf("added %d, count %d", bans, banList.size());
+#endif
 }
 
 void CSAMPFunctions::AddStringVariable(char *szRule, int flags, char *szString, void *changefunc)
@@ -177,6 +293,60 @@ Packet* CSAMPFunctions::Receive(void* ppRakServer)
 	return pfn__RakNet__Receive(ppRakServer);
 }
 
+bool CSAMPFunctions::IsBanned(const char *IP)
+{
+#ifdef CUSTOM_BANLIST
+	unsigned long addr = inet_addr(IP);
+	std::vector<BanRecord>::iterator iter;
+	for(iter = banList.begin(); iter != banList.end(); ++iter)
+	{
+		if((addr & iter->mask) == (iter->ip & iter->mask)) return true;
+	}
+	return false;
+#elif defined(_WIN32)
+	return pRakServer->_IsBanned(IP);
+#else
+	RakBanList *banlist = pRakServer->GetBanList();
+	for(unsigned int i = 0; i < banlist->list_size; i++)
+	{
+		RakBanStruct *ban = banlist->listArray[i];
+		if(!fnmatch(ban->IP, IP, 0)) return true;
+	}
+	return false;
+#endif
+}
+
+#ifdef CUSTOM_BANLIST
+
+void CSAMPFunctions::AddToBanList(void* ppRakServer, const char *IP, unsigned int milliseconds)
+{
+	BanRecord rec = BanRecord(IP);
+
+	if(rec.ip != 0x0100007F) //SA-MP prevents banning NPCs
+	{
+		banList.push_back(rec);
+	}
+
+	pfn__RakNet__AddToBanList(ppRakServer, IP, milliseconds);
+}
+
+void CSAMPFunctions::RemoveFromBanList(void* ppRakServer, const char *IP)
+{
+	BanRecord rec = BanRecord(IP);
+
+	banList.erase(std::remove(banList.begin(), banList.end(), rec), banList.end());
+	
+	pfn__RakNet__RemoveFromBanList(ppRakServer, IP);
+}
+
+void CSAMPFunctions::ClearBanList(void* ppRakServer)
+{
+	banList.clear();
+
+	pfn__RakNet__ClearBanList(ppRakServer);
+}
+#endif
+
 void CSAMPFunctions::RespawnVehicle(CVehicle *pVehicle)
 {
 	memset(&pVehicle->vehMatrix, 0, sizeof(MATRIX4X4));
@@ -242,4 +412,215 @@ void CSAMPFunctions::RespawnVehicle(CVehicle *pVehicle)
 		pfn__CPlayerPool__HandleVehicleRespawn(pNetGame->pPlayerPool, pVehicle->wVehicleID);
 
 	CCallbackManager::OnVehicleSpawn(pVehicle->wVehicleID);
+}
+
+char* CSAMPFunctions::GetNPCCommandLine(WORD npcid)
+{
+	if(!pPlayerData[npcid]) return NULL;
+	int pid = pPlayerData[npcid]->npcPid;
+	char *line = NULL;
+
+#ifdef _WIN32
+    HRESULT hr = 0;
+    IWbemLocator         *WbemLocator  = NULL;
+    IWbemServices        *WbemServices = NULL;
+    IEnumWbemClassObject *EnumWbem  = NULL;
+
+    hr = CoInitializeEx(0, COINIT_MULTITHREADED);
+    hr = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL);
+    hr = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *) &WbemLocator);
+    hr = WbemLocator->ConnectServer(L"ROOT\\CIMV2", NULL, NULL, NULL, 0, NULL, NULL, &WbemServices);
+
+	std::ostringstream query;
+	query << "SELECT CommandLine FROM Win32_Process WHERE ProcessId=" << pid;
+	hr = WbemServices->ExecQuery(L"WQL", bstr_t(query.str().c_str()), WBEM_FLAG_FORWARD_ONLY, NULL, &EnumWbem);
+
+    if(EnumWbem == NULL) return 0;
+
+    IWbemClassObject *result = NULL;
+    ULONG returnedCount = 0;
+	
+    while((hr = EnumWbem->Next(WBEM_INFINITE, 1, &result, &returnedCount)) == S_OK)
+	{
+        VARIANT CommandLine;
+        hr = result->Get(L"CommandLine", 0, &CommandLine, 0, 0);
+
+        line = _com_util::ConvertBSTRToString(CommandLine.bstrVal);
+
+		VariantClear(&CommandLine);
+        result->Release();
+
+		break;
+    }
+
+    EnumWbem->Release();
+    WbemServices->Release();
+    WbemLocator->Release();
+	
+    CoUninitialize();
+#else
+	char fname[32];
+	sprintf(fname, "/proc/%d/cmdline", pid);
+						
+	FILE *fcmd = fopen(fname, "r");
+	if(fcmd != NULL)
+	{
+		size_t size = 128;
+		line = (char*)malloc(size);
+		size_t total = 0, read;
+		while((read = fread(line+total, 1, size-total, fcmd)) >= size-total)
+		{
+			total += read;
+			size *= 2;
+			line = (char*)realloc(line, size);
+		}
+		fclose(fcmd);
+		total += read;
+		for(unsigned int i = 0; i < total-1; i++)
+		{
+			if(!line[i]) line[i] = ' ';
+		}
+	}
+#endif
+
+	return line;
+}
+
+int CSAMPFunctions::FindNPCProcessID(WORD npcid)
+{
+	char *name = pNetGame->pPlayerPool->szName[npcid];
+#ifdef _WIN32
+	DWORD cpid = GetCurrentProcessId();
+	
+    HRESULT hr = 0;
+    IWbemLocator         *WbemLocator  = NULL;
+    IWbemServices        *WbemServices = NULL;
+    IEnumWbemClassObject *EnumWbem  = NULL;
+
+    hr = CoInitializeEx(0, COINIT_MULTITHREADED);
+    hr = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL);
+    hr = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *) &WbemLocator);
+    hr = WbemLocator->ConnectServer(L"ROOT\\CIMV2", NULL, NULL, NULL, 0, NULL, NULL, &WbemServices);
+
+	std::ostringstream query;
+	query << "SELECT ProcessId, CommandLine FROM Win32_Process WHERE ParentProcessId=" << cpid;
+	hr = WbemServices->ExecQuery(L"WQL", bstr_t(query.str().c_str()), WBEM_FLAG_FORWARD_ONLY, NULL, &EnumWbem);
+	
+
+    if(EnumWbem == NULL) return 0;
+
+    IWbemClassObject *result = NULL;
+    ULONG returnedCount = 0;
+	
+	DWORD pid = 0;
+    while((hr = EnumWbem->Next(WBEM_INFINITE, 1, &result, &returnedCount)) == S_OK)
+	{
+        VARIANT ProcessId, CommandLine;
+        hr = result->Get(L"ProcessId", 0, &ProcessId, 0, 0);
+        hr = result->Get(L"CommandLine", 0, &CommandLine, 0, 0);
+
+        char *line = _com_util::ConvertBSTRToString(CommandLine.bstrVal);
+			
+		char *iter = line;
+		
+		bool found = false;
+		while(*iter)
+		{
+			if(*iter == ' ')
+			{
+				if(*++iter == '-' && *++iter == 'n' && *++iter == ' ')
+				{
+					if(!strncmp(++iter, name, strlen(name)))
+					{
+						pid = ProcessId.uintVal;
+						found = true;
+						break;
+					}
+				}
+			}else{
+				iter++;
+			}
+		}
+
+		free(line);
+		VariantClear(&ProcessId);
+		VariantClear(&CommandLine);
+        result->Release();
+
+		if(found) break;
+    }
+
+    EnumWbem->Release();
+    WbemServices->Release();
+    WbemLocator->Release();
+
+    CoUninitialize();
+
+	return pid;
+#else
+	pid_t pid, cpid = getpid();
+
+	DIR *dp = opendir("/proc/");
+	if(dp != NULL)
+	{
+		struct dirent *ep;
+		
+		char line[1024], fname[32];
+		while(ep = readdir(dp))
+		{
+			if(sscanf(ep->d_name, "%d", &pid) == 1)
+			{
+				sprintf(fname, "/proc/%d/stat", pid);
+				
+				FILE *fstat = fopen(fname, "r");
+				if(fstat != NULL)
+				{
+					fread(line, 1, sizeof(line), fstat);
+					fclose(fstat);
+
+					int gpid;
+					if(sscanf(line, "%*d (samp-npc) %*c %*d %d", &gpid) == 1)
+					{
+						if(gpid == cpid)
+						{
+							sprintf(fname, "/proc/%d/cmdline", pid);
+						
+							FILE *fcmd = fopen(fname, "r");
+							if(fcmd != NULL)
+							{
+								size_t total = fread(line, 1, sizeof(line), fcmd);
+								fclose(fcmd);
+								
+								char *iter = line;
+								char *end = line+total;
+
+								bool found = false;
+								while(iter < end)
+								{
+									if(*iter == '\0')
+									{
+										if(*++iter == '-' && *++iter == 'n' && *++iter == '\0')
+										{
+											if(!strncmp(++iter, name, strlen(name)))
+											{
+												found = true;
+												break;
+											}
+										}
+									}else{
+										iter++;
+									}
+								}
+								if(found) break;
+							}
+						}
+					}
+				}
+			}
+			pid = 0;
+		}
+		closedir(dp);
+	}
+	return pid;
+#endif
 }
\ No newline at end of file
diff --git a/src/Functions.h b/src/src/Functions.h
similarity index 83%
rename from src/Functions.h
rename to src/src/Functions.h
index 88b6b66..a7ff089 100644
--- a/src/Functions.h
+++ b/src/src/Functions.h
@@ -46,12 +46,24 @@ class CHookRakServer
 	static bool THISCALL Send(void* ppRakServer, RakNet::BitStream* parameters, PacketPriority priority, PacketReliability reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast);
 	static bool THISCALL RPC_2(void* ppRakServer, BYTE* uniqueID, RakNet::BitStream* parameters, PacketPriority priority, PacketReliability reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp);
 	static Packet* THISCALL Receive(void* ppRakServer);
+
+#ifdef CUSTOM_BANLIST
+	static void THISCALL AddToBanList(void* ppRakServer, const char *IP, unsigned int milliseconds=0);
+	static void THISCALL RemoveFromBanList(void* ppRakServer, const char *IP);
+	static void THISCALL ClearBanList(void* ppRakServer);
+#endif
 };
 
 typedef bool (THISCALL *RakNet__Send_t)(void* ppRakServer, RakNet::BitStream* parameters, PacketPriority priority, PacketReliability reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast);
 typedef bool (THISCALL *RakNet__RPC_t)(void* ppRakServer, BYTE* uniqueID, RakNet::BitStream* parameters, PacketPriority priority, PacketReliability reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp);
 typedef Packet* (THISCALL *RakNet__Receive_t)(void* ppRakServer);
 
+#ifdef CUSTOM_BANLIST
+typedef void (THISCALL *RakNet__AddToBanList_t)(void* ppRakServer, const char *IP, unsigned int milliseconds);
+typedef void (THISCALL *RakNet__RemoveFromBanList_t)(void* ppRakServer, const char *IP);
+typedef void (THISCALL *RakNet__ClearBanList_t)(void* ppRakServer);
+#endif
+
 class CSAMPFunctions
 {
 public:
@@ -83,8 +95,18 @@ class CSAMPFunctions
 	static bool		RPC(void* ppRakServer, BYTE* uniqueID, RakNet::BitStream* parameters, PacketPriority priority, PacketReliability reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp);
 	static Packet*	Receive(void* ppRakServer);
 
+	static bool		IsBanned(const char *IP);
+#ifdef CUSTOM_BANLIST
+	static void		AddToBanList(void* ppRakServer, const char *IP, unsigned int milliseconds=0);
+	static void		RemoveFromBanList(void* ppRakServer, const char *IP);
+	static void		ClearBanList(void* ppRakServer);
+#endif
+
 	static void		RespawnVehicle(CVehicle *pVehicle);
 
+	static char*	GetNPCCommandLine(WORD npcid);
+	static int		FindNPCProcessID(WORD npcid);
+
 	// Function
 	// Rules
 	static CConsole__AddStringVariable_t			pfn__CConsole__AddStringVariable;
@@ -115,6 +137,12 @@ class CSAMPFunctions
 	static RakNet__Send_t							pfn__RakNet__Send;
 	static RakNet__RPC_t							pfn__RakNet__RPC;
 	static RakNet__Receive_t						pfn__RakNet__Receive;
+
+#ifdef CUSTOM_BANLIST
+	static RakNet__AddToBanList_t					pfn__RakNet__AddToBanList;
+	static RakNet__RemoveFromBanList_t				pfn__RakNet__RemoveFromBanList;
+	static RakNet__ClearBanList_t					pfn__RakNet__ClearBanList;
+#endif
 };
 
 #endif
diff --git a/src/Hooks.cpp b/src/src/Hooks.cpp
similarity index 92%
rename from src/Hooks.cpp
rename to src/src/Hooks.cpp
index f911aea..8318222 100644
--- a/src/Hooks.cpp
+++ b/src/src/Hooks.cpp
@@ -1,827 +1,878 @@
-
-/*  
- *  Version: MPL 1.1
- *  
- *  The contents of this file are subject to the Mozilla Public License Version 
- *  1.1 (the "License"); you may not use this file except in compliance with 
- *  the License. You may obtain a copy of the License at 
- *  http://www.mozilla.org/MPL/
- *  
- *  Software distributed under the License is distributed on an "AS IS" basis,
- *  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- *  for the specific language governing rights and limitations under the
- *  License.
- *  
- *  The Original Code is the YSI 2.0 SA:MP plugin.
- *  
- *  The Initial Developer of the Original Code is Alex "Y_Less" Cole.
- *  Portions created by the Initial Developer are Copyright (C) 2008
- *  the Initial Developer. All Rights Reserved.
- *  
- *  Contributor(s):
- *  
- *  Peter Beverloo
- *  Marcus Bauer
- *  MaVe;
- *  Sammy91
- *  Incognito
- *  
- *  Special Thanks to:
- *  
- *  SA:MP Team past, present and future
- */
-
-#include "main.h"
-
-extern void *pAMXFunctions;
-
-subhook_t SetWeather_hook;
-subhook_t SetGravity_hook;
-subhook_t Namecheck_hook;
-subhook_t amx_Register_hook;
-subhook_t logprintf_hook;
-subhook_t query_hook;
-
-AMX_NATIVE pDestroyObject = NULL, pDestroyPlayerObject = NULL, pTogglePlayerControllable = NULL, pSetPlayerWorldBounds = NULL,
-	pSetPlayerTeam = NULL, pSetPlayerSkin = NULL, pSetPlayerFightingStyle = NULL, pSetPlayerName = NULL, pSetVehicleToRespawn = NULL, 
-	pChangeVehicleColor = NULL, pDestroyVehicle = NULL, pAttachObjectToPlayer = NULL;
-
-char gRecordingDataPath[MAX_PATH];
-
-///////////////////////////////////////////////////////////////
-// Hooks //
-///////////////////////////////////////////////////////////////
-/* I was unable to hook this function :(
-This needed in future to fix /rcon weather id do not update GetPlayerWeather
-class CHookedNetgame
-{
-	static void __thiscall HOOK_CNetGame__SetWeather(void *pNetGame_, BYTE byteWeather);
-	static void __thiscall HOOK_CNetGame__SetGravity(void *pNetGame_, float fGravity);
-
-};
-
-//----------------------------------------------------
-typedef void (__thiscall *FUNC_CNetGame__SetWeather)(void *pNetGame_, BYTE byteWeather);
-void __thiscall HOOK_CNetGame__SetWeather(void *pNetGame_, BYTE byteWeather)
-{
-	subhook_remove(SetWeather_hook);
-
-	((FUNC_CNetGame__SetWeather)CAddress::FUNC_CNetGame__SetWeather)(pNetGame, byteWeather);
-
-	for (WORD i = 0; i != MAX_PLAYERS; i++)
-	{
-		if (IsPlayerConnectedEx(i))
-			pPlayerData[i]->byteWeather = byteWeather;
-	}
-
-	subhook_install(SetWeather_hook);
-}
-
-
-//typedef BYTE (*FUNC_GetPacketID)(Packet *p);
-//----------------------------------------------------
-typedef void (__thiscall *FUNC_CNetGame__SetGravity)(void *pNetGame_, float fGravity);
-void HOOK_CNetGame__SetGravity(void *pNetGame_, float fGravity)
-{
-	((FUNC_CNetGame__SetGravity)CAddress::FUNC_CNetGame__SetWeather)(pNetGame_, fGravity);
-
-	for(WORD i = 0; i != MAX_PLAYERS; i++)
-	{
-		if(IsPlayerConnectedEx(i))
-			pPlayerData[i]->fGravity = fGravity; 
-	}
-}
-*/
-//----------------------------------------------------
-// Custom name check
-bool HOOK_ContainsInvalidChars(char * szString)
-{
-	return !pServer->IsValidNick(szString);
-}
-
-//----------------------------------------------------
-
-typedef BYTE (*FUNC_amx_Register)(AMX *amx, AMX_NATIVE_INFO *nativelist, int number);
-int AMXAPI HOOK_amx_Register(AMX *amx, AMX_NATIVE_INFO *nativelist, int number)
-{
-	// amx_Register hook for redirect natives
-	static bool g_bNativesHooked = false;
-
-	if (!g_bNativesHooked && pServer)
-	{
-		int i = 0;
-		while (nativelist[i].name)
-		{
-			if(!pDestroyPlayerObject && !strcmp(nativelist[i].name, "DestroyObject"))
-				pDestroyObject = nativelist[i].func;
-
-			if(!pDestroyPlayerObject && !strcmp(nativelist[i].name, "DestroyPlayerObject"))
-				pDestroyPlayerObject = nativelist[i].func;
-
-			if(!pTogglePlayerControllable && !strcmp(nativelist[i].name, "TogglePlayerControllable"))
-				pTogglePlayerControllable = nativelist[i].func;
-
-			if(!pSetPlayerWorldBounds && !strcmp(nativelist[i].name, "SetPlayerWorldBounds"))
-				pSetPlayerWorldBounds = nativelist[i].func;
-			
-			if(!pSetPlayerTeam && !strcmp(nativelist[i].name, "SetPlayerTeam"))
-				pSetPlayerTeam = nativelist[i].func;
-			
-			if(!pSetPlayerSkin && !strcmp(nativelist[i].name, "SetPlayerSkin"))
-				pSetPlayerSkin = nativelist[i].func;
-			
-			if(!pSetPlayerFightingStyle && !strcmp(nativelist[i].name, "SetPlayerFightingStyle"))
-				pSetPlayerFightingStyle = nativelist[i].func;
-			
-			if(!pSetPlayerName && !strcmp(nativelist[i].name, "SetPlayerName"))
-				pSetPlayerName = nativelist[i].func;
-			
-			if(!pSetVehicleToRespawn && !strcmp(nativelist[i].name, "SetVehicleToRespawn"))
-				pSetVehicleToRespawn = nativelist[i].func;
-
-			if(!pChangeVehicleColor && !strcmp(nativelist[i].name, "ChangeVehicleColor"))
-				pChangeVehicleColor = nativelist[i].func;
-
-			if(!pDestroyVehicle && !strcmp(nativelist[i].name, "DestroyVehicle"))
-				pDestroyVehicle = nativelist[i].func;
-
-			if(!pAttachObjectToPlayer && !strcmp(nativelist[i].name, "AttachObjectToPlayer"))
-				pAttachObjectToPlayer = nativelist[i].func;
-
-			//logprintf("native %s", nativelist[i].name);
-			int x = 0;
-			
-			while (RedirectedNatives[x].name)
-			{
-				//logprintf("asdasd %s", RedirectedNatives[x].name);
-				if (!strcmp(nativelist[i].name, RedirectedNatives[x].name))
-				{
-					if (!g_bNativesHooked) g_bNativesHooked = true;
-				
-					//logprintf("native: %s, %s", nativelist[i].name, RedirectedNatives[x].name);
-					nativelist[i].func = RedirectedNatives[x].func;
-				}
-				x++;
-			}
-			i++;
-		}
-	}
-
-	return ((FUNC_amx_Register)subhook_get_trampoline(amx_Register_hook))(amx, nativelist, number);
-}
-
-//----------------------------------------------------
-
-bool THISCALL CHookRakServer::Send(void* ppRakServer, RakNet::BitStream* parameters, PacketPriority priority, PacketReliability reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast)
-{
-	/*
-	BYTE id;
-	WORD playerid;
-	parameters->Read(id);
-	parameters->Read(playerid);
-
-	logprintf("id: %d - playerid: %d, sendto. %d", id, playerid, pRakServer->GetIndexFromPlayerID(playerId));
-	*/
-	RebuildSyncData(parameters, static_cast<WORD>(pRakServer->GetIndexFromPlayerID(playerId)));
-
-	return CSAMPFunctions::Send(ppRakServer, parameters, priority, reliability, orderingChannel, playerId, broadcast);
-}
-
-//----------------------------------------------------
-
-bool THISCALL CHookRakServer::RPC_2(void* ppRakServer, BYTE* uniqueID, RakNet::BitStream* parameters, PacketPriority priority, PacketReliability reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp)
-{
-	RebuildRPCData(*uniqueID, parameters, static_cast<WORD>(pRakServer->GetIndexFromPlayerID(playerId)));
-
-	return CSAMPFunctions::RPC(ppRakServer, uniqueID, parameters, priority, reliability, orderingChannel, playerId, broadcast, shiftTimestamp);
-}
-
-//----------------------------------------------------
-
-Packet* THISCALL CHookRakServer::Receive(void* ppRakServer)
-{
-	Packet* p = CSAMPFunctions::Receive(ppRakServer);
-	BYTE packetId = GetPacketID(p);
-	if(packetId == 0xFF) return p;
-
-	WORD playerid = p->playerIndex;
-
-	//logprintf("Receive packet playerid: %d, id: %d", playerid, packetId);
-	
-	if (IsPlayerConnectedEx(playerid))
-	{
-		// AFK
-		if (IsPlayerUpdatePacket(packetId))
-		{
-			pPlayerData[playerid]->dwLastUpdateTick = GetTickCount();
-			pPlayerData[playerid]->bEverUpdated = true;
-		}
-
-		switch(packetId)
-		{
-			case ID_PLAYER_SYNC:
-			{
-				CSyncData *pSyncData = reinterpret_cast<CSyncData*>(&p->data[1]);
-
-				if(pServer->IsNightVisionFixEnabled())
-				{
-					// Fix nightvision and infrared sync
-					if (pSyncData->byteWeapon == WEAPON_NIGHTVISION || pSyncData->byteWeapon == WEAPON_INFRARED)
-					{
-						pSyncData->wKeys &= ~4;
-						pSyncData->byteWeapon = 0;
-					}
-				}
-
-				// Store surfing info because server reset it when player surfing on player object
-				pPlayerData[playerid]->wSurfingInfo = pSyncData->wSurfingInfo;
-				break;
-			}
-			case ID_AIM_SYNC:
-			{
-				CAimSyncData *pAim = reinterpret_cast<CAimSyncData*>(&p->data[1]);
-
-				// Fix up, down aim sync - thx to Slice, from SKY
-				switch(pNetGame->pPlayerPool->pPlayer[playerid]->byteCurrentWeapon)
-				{
-					case WEAPON_SNIPER:
-					case WEAPON_ROCKETLAUNCHER:
-					case WEAPON_HEATSEEKER:
-					case WEAPON_CAMERA:
-					{
-						pAim->fZAim = -pAim->vecFront.fZ;
-
-						if (pAim->fZAim > 1.0f)
-						{
-							pAim->fZAim = 1.0f;
-						}
-						else if (pAim->fZAim < -1.0f)
-						{
-							pAim->fZAim = -1.0f;
-						}
-						break;
-					}
-				}
-				break;
-			}
-			case ID_STATS_UPDATE:
-			{
-				CSAMPFunctions::Packet_StatsUpdate(p);
-				CCallbackManager::OnPlayerStatsAndWeaponsUpdate(playerid);
-
-				p->data[0] = 0xFF;
-				break;
-			}
-			case ID_WEAPONS_UPDATE:
-			{
-				CSAMPFunctions::Packet_WeaponsUpdate(p);
-				CCallbackManager::OnPlayerStatsAndWeaponsUpdate(playerid);
-
-				p->data[0] = 0xFF;
-				break;
-			}
-		}
-	}
-	return p;
-}
-
-//----------------------------------------------------
-
-bool	bRconSocketReply = false;
-
-SOCKET	cur_sock = INVALID_SOCKET;
-char*	cur_data = NULL;
-int		cur_datalen = 0;
-sockaddr_in to;
-
-//----------------------------------------------------
-
-void RconSocketReply(char* szMessage);
-
-//----------------------------------------------------
-
-typedef void (*FUNC_logprintf)(const char *msg, ...);
-
-void HOOK_logprintf(const char *msg, ...)
-{
-	subhook_remove(logprintf_hook);
-
-	char buffer[1024];
-	va_list arguments;
-	va_start(arguments, msg);
-	vsnprintf(buffer, sizeof(buffer), msg, arguments);
-	va_end(arguments);
-	// CCallbackManager::OnServerMessage(buffer)
-	if(true)
-	{
-		// Fix crash caused by % symbol (by default this crash at /rcon varlist)
-		int i = 0;
-		bool bDoNotPrint = false;
-		while(buffer[i])
-		{
-			if(buffer[i++] == '%')
-			{
-				bDoNotPrint = true;
- 				break;
-			}
-		}
-
-		if(!bDoNotPrint)
-			logprintf(buffer);
-	
-		if (bRconSocketReply) 
-			RconSocketReply(buffer);
-	}
-
-	subhook_install(logprintf_hook);
-}
-
-//----------------------------------------------------
-
-void RconSocketReply(char* szMessage)
-{
-	// IMPORTANT!
-	// Don't use logprintf from here... You'll cause an infinite loop.
-	if (bRconSocketReply)
-	{
-		char* newdata = (char*)malloc(cur_datalen + strlen(szMessage) + sizeof(WORD));
-		char* keep_ptr = newdata;
-		memcpy(newdata, cur_data, cur_datalen);
-		newdata += cur_datalen;
-		*(WORD*)newdata = (WORD)strlen(szMessage);
-		newdata += sizeof(WORD);
-		memcpy(newdata, szMessage, strlen(szMessage));
-		newdata += strlen(szMessage);
-		sendto(cur_sock, keep_ptr, (int)(newdata - keep_ptr), 0, (sockaddr*)&to, sizeof(to));
-		free(keep_ptr);
-	}
-}
-
-//----------------------------------------------------
-// bool CheckQueryFlood()
-// returns 1 if this query could flood
-// returns 0 otherwise
-bool CheckQueryFlood(unsigned int binaryAddress)
-{
-	static DWORD dwLastQueryTick = 0;
-	static unsigned int lastBinAddr = 0;
-
-	if(!dwLastQueryTick)
-	{
-		dwLastQueryTick = static_cast<DWORD>(GetTickCount());
-		lastBinAddr = binaryAddress;
-		return 0;
-	}
-	if(lastBinAddr != binaryAddress)
-	{
-		if((static_cast<DWORD>(GetTickCount()) - dwLastQueryTick) < 25)
-			return 1;
-
-		dwLastQueryTick = static_cast<DWORD>(GetTickCount());
-		lastBinAddr = binaryAddress;
-	}
-	return 0;
-}
-
-//----------------------------------------------------
-
-int HOOK_ProcessQueryPacket(unsigned int binaryAddress, unsigned short port, char* data, int length, SOCKET s)
-{
-	char* szPassword = NULL;
-	WORD wStrLen = 0;
-	in_addr in;
-	in.s_addr = binaryAddress;
-
-	if ((length > 4) && (*(unsigned long*)(data) == 0x504D4153)) // 0x504D4153 = "SAMP" as hex.
-	{
-		if (!pNetGame || (pNetGame->iGameState != GAMESTATE_RUNNING)) return 0;
-
-		if (length >= 11)
-		{
-			to.sin_family = AF_INET;
-			to.sin_port = htons(port);
-			to.sin_addr.s_addr = binaryAddress;
-
-			if (CSAMPFunctions::GetBoolVariable("logqueries"))
-			{
-				logprintf("[query:%c] from %s", data[10], inet_ntoa(in));
-			}
-
-			switch (data[10])
-			{
-				case 'p':	// ping
-				{
-					if (length == 15)
-					{
-						sendto(s, data, 15, 0, (sockaddr*)&to, sizeof(to));
-					}
-					break;
-				}
-				case 'i':	// info
-				{
-					// We do not process these queries 'query' is 0
-					if (!CSAMPFunctions::GetBoolVariable("query")) return 1;
-					if (CheckQueryFlood(binaryAddress)) return 1;
-
-					char* szHostname = CSAMPFunctions::GetStringVariable("hostname");
-					size_t dwHostnameLen = strlen(szHostname);
-					if (dwHostnameLen > 50) dwHostnameLen = 50;
-
-					char* szGameMode = CSAMPFunctions::GetStringVariable("gamemodetext");
-					size_t dwGameModeLen = strlen(szGameMode);
-					if (dwGameModeLen > 30) dwGameModeLen = 30;
-
-					char* szLanguage = CSAMPFunctions::GetStringVariable("language");
-					char* szMapName = (!szLanguage[0]) ? CSAMPFunctions::GetStringVariable("mapname") : szLanguage;
-
-					size_t dwMapNameLen = strlen(szMapName);
-					if (dwMapNameLen > 30) dwMapNameLen = 30;
-
-					WORD wPlayerCount = pServer->GetPlayerCount();
-//					CPlayerPool* pPlayerPool = pNetGame->pPlayerPool;
-
-					WORD wMaxPlayers = pServer->GetMaxPlayers_();
-
-					BYTE byteIsPassworded = CSAMPFunctions::GetStringVariable("password")[0] != 0;
-
-					size_t datalen = 28;	// Previous data = 11b
-					// IsPassworded = 1b
-					// Player count = 2b
-					// Max player count = 2b
-					// String-length bytes = 12b (3 * sizeof(DWORD))
-					datalen += dwHostnameLen;
-					datalen += dwGameModeLen;
-					datalen += dwMapNameLen;
-
-
-					char* newdata = (char*)malloc(datalen);
-					char* keep_ptr = newdata;
-					// Previous Data
-					memcpy(newdata, data, 11);
-					newdata += 11;
-
-					// IsPassworded
-					memcpy(newdata, &byteIsPassworded, sizeof(BYTE));
-					newdata += sizeof(BYTE);
-
-					// Player Count
-					memcpy(newdata, &wPlayerCount, sizeof(WORD));
-					newdata += sizeof(WORD);
-
-					// Max Players
-					memcpy(newdata, &wMaxPlayers, sizeof(WORD));
-					newdata += sizeof(WORD);
-
-					// Hostname
-					memcpy(newdata, &dwHostnameLen, sizeof(DWORD));
-					newdata += sizeof(DWORD);
-					memcpy(newdata, szHostname, dwHostnameLen);
-					newdata += dwHostnameLen;
-
-					// Game Mode
-					memcpy(newdata, &dwGameModeLen, sizeof(DWORD));
-					newdata += sizeof(DWORD);
-					memcpy(newdata, szGameMode, dwGameModeLen);
-					newdata += dwGameModeLen;
-
-					// Map Name
-					memcpy(newdata, &dwMapNameLen, sizeof(DWORD));
-					newdata += sizeof(DWORD);
-					memcpy(newdata, szMapName, dwMapNameLen);
-					newdata += dwMapNameLen;
-
-					sendto(s, keep_ptr, datalen, 0, (sockaddr*)&to, sizeof(to));
-					free(keep_ptr);
-					break;
-				}
-				case 'c':	// players
-				{
-					// We do not process these queries 'query' is 0
-					if (!CSAMPFunctions::GetBoolVariable("query")) return 1;
-					if (CheckQueryFlood(binaryAddress)) return 1;
-
-					WORD wPlayerCount = pServer->GetPlayerCount();
-					CPlayerPool* pPlayerPool = pNetGame->pPlayerPool;
-					char* newdata = (char*)malloc(13 + (wPlayerCount * (MAX_PLAYER_NAME + 5))); // 5 = 1b String len, and 4b Score
-					char* keep_ptr = newdata;
-					// Previous Data
-					memcpy(newdata, data, 11);
-					newdata += 11;
-
-					// Player Count
-					memcpy(newdata, &wPlayerCount, sizeof(WORD));
-					newdata += sizeof(WORD);
-
-					if (pPlayerPool) 
-					{
-						char* szName;
-						BYTE byteNameLen;
-						DWORD dwScore;
-
-						for (WORD r = 0; r < MAX_PLAYERS; r++)
-						{
-							if (IsPlayerConnectedEx(r) && !pPlayerPool->bIsNPC[r] && !pPlayerData[r]->bHidden)
-							{
-								szName = GetPlayerName_(r);
-								byteNameLen = (BYTE)strlen(szName);
-								memcpy(newdata, &byteNameLen, sizeof(BYTE));
-								newdata += sizeof(BYTE);
-								memcpy(newdata, szName, byteNameLen);
-								newdata += byteNameLen;
-								dwScore = pPlayerPool->dwScore[r];
-								memcpy(newdata, &dwScore, sizeof(DWORD));
-								newdata += sizeof(DWORD);
-
-							}
-						}
-					}
-
-					sendto(s, keep_ptr, (int)(newdata - keep_ptr), 0, (sockaddr*)&to, sizeof(to));
-					free(keep_ptr);
-					break;
-				}
-				case 'd':	// detailed player list id.namelength.name.score.ping
-				{
-					// We do not process these queries 'query' is 0
-					if (!CSAMPFunctions::GetBoolVariable("query")) return 1;
-					if (CheckQueryFlood(binaryAddress)) return 1;
-
-					WORD wPlayerCount = pServer->GetPlayerCount();
-					CPlayerPool* pPlayerPool = pNetGame->pPlayerPool;
-					char* newdata = (char*)malloc(13 + (wPlayerCount * (MAX_PLAYER_NAME + 10))); // 9 = 1b String len, 4b Score, 4b Ping, 1b Playerid
-					char* keep_ptr = newdata;
-					// Previous Data
-					memcpy(newdata, data, 11);
-					newdata += 11;
-
-					// Player Count
-					memcpy(newdata, &wPlayerCount, sizeof(WORD));
-					newdata += sizeof(WORD);
-
-					if (pPlayerPool) 
-					{
-						char* szName;
-						BYTE byteNameLen;
-						DWORD dwScore, dwPing;
-
-						for (WORD r = 0; r < MAX_PLAYERS; r++)
-						{
-							if (IsPlayerConnectedEx(r) && !pPlayerPool->bIsNPC[r] && !pPlayerData[r]->bHidden)
-							{
-								memcpy(newdata, &r, sizeof(BYTE));
-								newdata += sizeof(BYTE);
-								szName = GetPlayerName_(r);
-								byteNameLen = (BYTE)strlen(szName);
-								memcpy(newdata, &byteNameLen, sizeof(BYTE));
-								newdata += sizeof(BYTE);
-								memcpy(newdata, szName, byteNameLen);
-								newdata += byteNameLen;
-								dwScore = pPlayerPool->dwScore[r];
-								memcpy(newdata, &dwScore, sizeof(DWORD));
-								newdata += sizeof(DWORD);
-								dwPing = pRakServer->GetLastPing(pRakServer->GetPlayerIDFromIndex(r));
-								memcpy(newdata, &dwPing, sizeof(DWORD));
-								newdata += sizeof(DWORD);
-							}
-						}
-					}
-					sendto(s, keep_ptr, (int)(newdata - keep_ptr), 0, (sockaddr*)&to, sizeof(to));
-					free(keep_ptr);
-					break;
-				}
-
-				case 'r':	// rules
-				{
-					// We do not process these queries 'query' is 0
-					if (!CSAMPFunctions::GetBoolVariable("query")) return 1;
-					if (CheckQueryFlood(binaryAddress)) return 1;
-
-					CSAMPFunctions::SendRules(s, data, (sockaddr_in*)&to, sizeof(to));
-					break;
-				}
-				case 'x':	// rcon
-				{
-					if (pRakServer/* && pRakServer->IsBanned(inet_ntoa(in))*/) return 1;
-					
-					// We do not process these queries 'query' is 0
-					if (!CSAMPFunctions::GetBoolVariable("query") || !CSAMPFunctions::GetBoolVariable("rcon")) return 1;
-					if (CheckQueryFlood(binaryAddress)) return 1;
-					
-					cur_sock = s;
-					cur_data = data;
-					cur_datalen = 11; // How much of the message we send back.
-					int tmp_datalen = cur_datalen;
-
-					data += cur_datalen;
-
-					// Check there's enough data for another WORD
-					tmp_datalen += sizeof(WORD);
-					if (length < tmp_datalen)
-						goto cleanup;	// Malformed packet! Haxy bastard!
-					// Read the string length for the password
-					wStrLen = *(WORD*)data;
-					data += sizeof(WORD);
-					// Check there's enough data for the password string
-					tmp_datalen += wStrLen;
-					if (length < tmp_datalen)
-						goto cleanup;	// Malformed packet! Haxy bastard!
-					// Read the password string
-					szPassword = (char*)malloc(wStrLen + 1);
-					memcpy(szPassword, data, wStrLen);
-					szPassword[wStrLen] = 0;
-					data += wStrLen;
-					
-					if (!strcmp(szPassword, CSAMPFunctions::GetStringVariable("rcon_password")))
-					{
-						// Check there's enough data for another WORD
-						tmp_datalen += sizeof(WORD);
-						if (length < tmp_datalen)
-						{
-							free(szPassword);
-							goto cleanup;	// Malformed packet! Haxy bastard!
-						}
-						// Read the string length for the command
-						wStrLen = *(WORD*)data;
-						data += sizeof(WORD);
-						tmp_datalen += wStrLen;
-						if (length < tmp_datalen)
-						{
-							free(szPassword);
-							goto cleanup;	// Malformed packet! Haxy bastard!
-						}
-						
-						// Read the command string
-						char* szCommand = (char*)malloc(wStrLen + 1);
-						memcpy(szCommand, data, wStrLen);
-						szCommand[wStrLen] = 0;
-
-						if (pConsole)
-						{
-							//logprintf("onremoterconpacket %d, %d, %s - %s", binaryAddress, port, szPassword, szCommand);
-							if (CCallbackManager::OnRemoteRCONPacket(binaryAddress, port, szPassword, true, szCommand))
-							{ 
-								bRconSocketReply = true;
-								// Execute the command
-								CSAMPFunctions::Execute(szCommand);
-								bRconSocketReply = false;
-							}
-						}
-
-						free(szCommand);
-					}
-					else 
-					{
-						in_addr in;
-						in.s_addr = binaryAddress;
-						logprintf("BAD RCON ATTEMPT BY: %s", inet_ntoa(in));
-
-						bRconSocketReply = true;
-						RconSocketReply("Invalid RCON password.");
-						bRconSocketReply = false;
-
-						CCallbackManager::OnRemoteRCONPacket(binaryAddress, port, szPassword, false, "NULL");
-					}
-					free(szPassword);
-					
-				cleanup:
-					cur_datalen = 0;
-					cur_data = NULL;
-					cur_sock = INVALID_SOCKET;
-					break;
-					
-				}
-			}
-		}
-		return 1;
-	}
-	else 
-	{
-		return 0;
-	}
-}
-
-#ifdef _WIN32
-
-CVehicle *_pVehicle;
-
-void _declspec(naked) HOOK_CVehicle__Respawn()
-{
-	_asm mov _pVehicle, ecx
-	_asm pushad
-
-	CSAMPFunctions::RespawnVehicle(_pVehicle);
-
-	_asm popad
-	_asm retn
-}
-
-#endif
-
-// Things that needs to be hooked before netgame initialied
-void InstallPreHooks()
-{
-	if (pServer)
-	{
-	/*
-		SetWeather_hook = subhook_new((void *)CAddress::FUNC_CNetGame__SetWeather, (void *)CHookedNetgame::HOOK_CNetGame__SetWeather);
-		subhook_install(SetWeather_hook);
-		
-		SetGravity_hook = subhook_new((void *)CAddress::FUNC_CNetGame__SetGravity, (void *)HOOK_CNetGame__SetGravity);
-		subhook_install(SetGravity_hook);
-		*/
-		Namecheck_hook = subhook_new((void*)CAddress::FUNC_ContainsInvalidChars, (void *)HOOK_ContainsInvalidChars);
-		subhook_install(Namecheck_hook);
-
-		amx_Register_hook = subhook_new((void*)*(DWORD*)((DWORD)pAMXFunctions + (PLUGIN_AMX_EXPORT_Register * 4)), (void*)HOOK_amx_Register);
-		subhook_install(amx_Register_hook);
-
-		query_hook = subhook_new((void*)CAddress::FUNC_ProcessQueryPacket, (void*)HOOK_ProcessQueryPacket);
-		subhook_install(query_hook);
-
-		logprintf_hook = subhook_new((void*)ppPluginData[PLUGIN_DATA_LOGPRINTF], (void*)HOOK_logprintf);
-		subhook_install(logprintf_hook);
-
-		if(CAddress::FUNC_CVehicle__Respawn)
-		{
-#ifdef WIN32
-			InstallJump(CAddress::FUNC_CVehicle__Respawn, (void*)HOOK_CVehicle__Respawn);
-#else
-			InstallJump(CAddress::FUNC_CVehicle__Respawn, (void*)CSAMPFunctions::RespawnVehicle);
-#endif
-		}
-
-		if(CAddress::ADDR_RecordingDirectory)
-		{
-			strcpy(gRecordingDataPath, "scriptfiles/%s.rec");
-			Unlock((void*)CAddress::ADDR_RecordingDirectory, 5);
-			*(DWORD*)(CAddress::ADDR_RecordingDirectory + 1) = (DWORD)&gRecordingDataPath;
-		}
-	}	
-}
-
-// Things that needs to be hooked after netgame initialied
-void InstallPostHooks()
-{
-	CSAMPFunctions::PostInitialize();
-
-	// !!! READ !!!
-	// If "myriad 1" present in server.cfg, then the internal raknet player "pool" will start with MAX_PLAYERS - needed for SetMaxPlayers if you want to increase your slots, eg. add +30 slot for 30 bot, and you paid for 60 slots only.
-	// This isn't enabled by default, because if it's enabled, then doesn't matter which value used for maxplayers in server.cfg, 
-	// server will allow up to connect MAX_PLAYERS at same time (currently 1000). 
-	// use this only if you want to have much NPC to trick hosts to allow them insted of paying for more slots for bots.
-	if(CSAMPFunctions::GetBoolVariable("myriad"))
-	{
-		pRakServer->Start(MAX_PLAYERS, 0, 5, static_cast<unsigned short>(CSAMPFunctions::GetIntVariable("port")), CSAMPFunctions::GetStringVariable("bind"));
-	}
-
-	// Recreate pools
-	pServer->pGangZonePool = new CGangZonePool();
-
-#ifdef NEW_PICKUP_SYSTEM
-	// Recreate Pickup pool
-	pServer->pPickupPool = new CYSFPickupPool();
-#endif
-	// Re-init some RPCs
-	InitRPCs();
-
-	//logprintf("YSF - pNetGame: 0x%X, pConsole: 0x%X, pRakServer: 0x%X", pNetGame, pConsole, pRakServer);
-}
-
-void UninstallHooks()
-{
-	if(SetWeather_hook)
-	{
-		subhook_remove(SetWeather_hook);
-		subhook_free(SetWeather_hook);
-	}
-	
-	if(SetGravity_hook)
-	{
-		subhook_remove(SetGravity_hook);
-		subhook_free(SetGravity_hook);
-	}
-	
-	if(Namecheck_hook)
-	{
-		subhook_remove(Namecheck_hook);
-		subhook_free(Namecheck_hook);
-	}
-
-	if(amx_Register_hook)
-	{
-		subhook_remove(amx_Register_hook);
-		subhook_free(amx_Register_hook);
-	}
-
-	if(query_hook)
-	{
-		subhook_remove(query_hook);
-		subhook_free(query_hook);
-	}
-
-	if(logprintf_hook)
-	{
-		subhook_remove(logprintf_hook);
-		subhook_free(logprintf_hook);
-	}
-}
+
+/*  
+ *  Version: MPL 1.1
+ *  
+ *  The contents of this file are subject to the Mozilla Public License Version 
+ *  1.1 (the "License"); you may not use this file except in compliance with 
+ *  the License. You may obtain a copy of the License at 
+ *  http://www.mozilla.org/MPL/
+ *  
+ *  Software distributed under the License is distributed on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing rights and limitations under the
+ *  License.
+ *  
+ *  The Original Code is the YSI 2.0 SA:MP plugin.
+ *  
+ *  The Initial Developer of the Original Code is Alex "Y_Less" Cole.
+ *  Portions created by the Initial Developer are Copyright (C) 2008
+ *  the Initial Developer. All Rights Reserved.
+ *  
+ *  Contributor(s):
+ *  
+ *  Peter Beverloo
+ *  Marcus Bauer
+ *  MaVe;
+ *  Sammy91
+ *  Incognito
+ *  
+ *  Special Thanks to:
+ *  
+ *  SA:MP Team past, present and future
+ */
+
+#include "main.h"
+
+extern void *pAMXFunctions;
+
+subhook_t SetWeather_hook;
+subhook_t SetGravity_hook;
+subhook_t Namecheck_hook;
+subhook_t amx_Register_hook;
+subhook_t logprintf_hook;
+subhook_t query_hook;
+
+AMX_NATIVE pDestroyObject = NULL, pDestroyPlayerObject = NULL, pTogglePlayerControllable = NULL, pSetPlayerWorldBounds = NULL,
+	pSetPlayerTeam = NULL, pSetPlayerSkin = NULL, pSetPlayerFightingStyle = NULL, pSetPlayerName = NULL, pSetVehicleToRespawn = NULL, 
+	pChangeVehicleColor = NULL, pDestroyVehicle = NULL, pAttachObjectToPlayer = NULL;
+
+char gRecordingDataPath[MAX_PATH];
+
+///////////////////////////////////////////////////////////////
+// Hooks //
+///////////////////////////////////////////////////////////////
+/* I was unable to hook this function :(
+This needed in future to fix /rcon weather id do not update GetPlayerWeather
+class CHookedNetgame
+{
+	static void __thiscall HOOK_CNetGame__SetWeather(void *pNetGame_, BYTE byteWeather);
+	static void __thiscall HOOK_CNetGame__SetGravity(void *pNetGame_, float fGravity);
+
+};
+
+//----------------------------------------------------
+typedef void (__thiscall *FUNC_CNetGame__SetWeather)(void *pNetGame_, BYTE byteWeather);
+void __thiscall HOOK_CNetGame__SetWeather(void *pNetGame_, BYTE byteWeather)
+{
+	subhook_remove(SetWeather_hook);
+
+	((FUNC_CNetGame__SetWeather)CAddress::FUNC_CNetGame__SetWeather)(pNetGame, byteWeather);
+
+	for (WORD i = 0; i != MAX_PLAYERS; i++)
+	{
+		if (IsPlayerConnectedEx(i))
+			pPlayerData[i]->byteWeather = byteWeather;
+	}
+
+	subhook_install(SetWeather_hook);
+}
+
+
+//typedef BYTE (*FUNC_GetPacketID)(Packet *p);
+//----------------------------------------------------
+typedef void (__thiscall *FUNC_CNetGame__SetGravity)(void *pNetGame_, float fGravity);
+void HOOK_CNetGame__SetGravity(void *pNetGame_, float fGravity)
+{
+	((FUNC_CNetGame__SetGravity)CAddress::FUNC_CNetGame__SetWeather)(pNetGame_, fGravity);
+
+	for(WORD i = 0; i != MAX_PLAYERS; i++)
+	{
+		if(IsPlayerConnectedEx(i))
+			pPlayerData[i]->fGravity = fGravity; 
+	}
+}
+*/
+//----------------------------------------------------
+// Custom name check
+bool HOOK_ContainsInvalidChars(char * szString)
+{
+	return !pServer->IsValidNick(szString);
+}
+
+//----------------------------------------------------
+
+typedef BYTE (*FUNC_amx_Register)(AMX *amx, AMX_NATIVE_INFO *nativelist, int number);
+int AMXAPI HOOK_amx_Register(AMX *amx, AMX_NATIVE_INFO *nativelist, int number)
+{
+	// amx_Register hook for redirect natives
+	static bool g_bNativesHooked = false;
+
+	if (!g_bNativesHooked && pServer)
+	{
+		int i = 0;
+		while (nativelist[i].name)
+		{
+			if(!pDestroyPlayerObject && !strcmp(nativelist[i].name, "DestroyObject"))
+				pDestroyObject = nativelist[i].func;
+
+			if(!pDestroyPlayerObject && !strcmp(nativelist[i].name, "DestroyPlayerObject"))
+				pDestroyPlayerObject = nativelist[i].func;
+
+			if(!pTogglePlayerControllable && !strcmp(nativelist[i].name, "TogglePlayerControllable"))
+				pTogglePlayerControllable = nativelist[i].func;
+
+			if(!pSetPlayerWorldBounds && !strcmp(nativelist[i].name, "SetPlayerWorldBounds"))
+				pSetPlayerWorldBounds = nativelist[i].func;
+			
+			if(!pSetPlayerTeam && !strcmp(nativelist[i].name, "SetPlayerTeam"))
+				pSetPlayerTeam = nativelist[i].func;
+			
+			if(!pSetPlayerSkin && !strcmp(nativelist[i].name, "SetPlayerSkin"))
+				pSetPlayerSkin = nativelist[i].func;
+			
+			if(!pSetPlayerFightingStyle && !strcmp(nativelist[i].name, "SetPlayerFightingStyle"))
+				pSetPlayerFightingStyle = nativelist[i].func;
+			
+			if(!pSetPlayerName && !strcmp(nativelist[i].name, "SetPlayerName"))
+				pSetPlayerName = nativelist[i].func;
+			
+			if(!pSetVehicleToRespawn && !strcmp(nativelist[i].name, "SetVehicleToRespawn"))
+				pSetVehicleToRespawn = nativelist[i].func;
+
+			if(!pChangeVehicleColor && !strcmp(nativelist[i].name, "ChangeVehicleColor"))
+				pChangeVehicleColor = nativelist[i].func;
+
+			if(!pDestroyVehicle && !strcmp(nativelist[i].name, "DestroyVehicle"))
+				pDestroyVehicle = nativelist[i].func;
+
+			if(!pAttachObjectToPlayer && !strcmp(nativelist[i].name, "AttachObjectToPlayer"))
+				pAttachObjectToPlayer = nativelist[i].func;
+
+			//logprintf("native %s", nativelist[i].name);
+			int x = 0;
+			
+			while (RedirectedNatives[x].name)
+			{
+				//logprintf("asdasd %s", RedirectedNatives[x].name);
+				if (!strcmp(nativelist[i].name, RedirectedNatives[x].name))
+				{
+					if (!g_bNativesHooked) g_bNativesHooked = true;
+				
+					//logprintf("native: %s, %s", nativelist[i].name, RedirectedNatives[x].name);
+					nativelist[i].func = RedirectedNatives[x].func;
+				}
+				x++;
+			}
+			i++;
+		}
+	}
+
+	return ((FUNC_amx_Register)subhook_get_trampoline(amx_Register_hook))(amx, nativelist, number);
+}
+
+//----------------------------------------------------
+
+bool THISCALL CHookRakServer::Send(void* ppRakServer, RakNet::BitStream* parameters, PacketPriority priority, PacketReliability reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast)
+{
+	/*
+	BYTE id;
+	WORD playerid;
+	parameters->Read(id);
+	parameters->Read(playerid);
+
+	logprintf("id: %d - playerid: %d, sendto. %d", id, playerid, pRakServer->GetIndexFromPlayerID(playerId));
+	*/
+	RebuildSyncData(parameters, static_cast<WORD>(pRakServer->GetIndexFromPlayerID(playerId)));
+
+	return CSAMPFunctions::Send(ppRakServer, parameters, priority, reliability, orderingChannel, playerId, broadcast);
+}
+
+//----------------------------------------------------
+
+bool THISCALL CHookRakServer::RPC_2(void* ppRakServer, BYTE* uniqueID, RakNet::BitStream* parameters, PacketPriority priority, PacketReliability reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp)
+{
+	if(!RebuildRPCData(*uniqueID, parameters, static_cast<WORD>(pRakServer->GetIndexFromPlayerID(playerId)))) return true;
+
+	return CSAMPFunctions::RPC(ppRakServer, uniqueID, parameters, priority, reliability, orderingChannel, playerId, broadcast, shiftTimestamp);
+}
+
+//----------------------------------------------------
+
+Packet* THISCALL CHookRakServer::Receive(void* ppRakServer)
+{
+	Packet* p = CSAMPFunctions::Receive(ppRakServer);
+	BYTE packetId = GetPacketID(p);
+	if(packetId == 0xFF) return p;
+
+	WORD playerid = p->playerIndex;
+
+	//logprintf("Receive packet playerid: %d, id: %d", playerid, packetId);
+	
+	if (IsPlayerConnectedEx(playerid))
+	{
+		// AFK
+		if (IsPlayerUpdatePacket(packetId))
+		{
+			pPlayerData[playerid]->dwLastUpdateTick = GetTickCount();
+			pPlayerData[playerid]->bEverUpdated = true;
+		}
+
+		switch(packetId)
+		{
+			case ID_PLAYER_SYNC:
+			{
+				CSyncData *pSyncData = reinterpret_cast<CSyncData*>(&p->data[1]);
+
+				if(pServer->IsNightVisionFixEnabled())
+				{
+					// Fix nightvision and infrared sync
+					if (pSyncData->byteWeapon == WEAPON_NIGHTVISION || pSyncData->byteWeapon == WEAPON_INFRARED)
+					{
+						pSyncData->wKeys &= ~4;
+						pSyncData->byteWeapon = 0;
+					}
+				}
+
+				// Store surfing info because server reset it when player surfing on player object
+				pPlayerData[playerid]->wSurfingInfo = pSyncData->wSurfingInfo;
+				break;
+			}
+			case ID_AIM_SYNC:
+			{
+				CAimSyncData *pAim = reinterpret_cast<CAimSyncData*>(&p->data[1]);
+
+				// Fix up, down aim sync - thx to Slice, from SKY
+				switch(pNetGame->pPlayerPool->pPlayer[playerid]->byteCurrentWeapon)
+				{
+					case WEAPON_SNIPER:
+					case WEAPON_ROCKETLAUNCHER:
+					case WEAPON_HEATSEEKER:
+					case WEAPON_CAMERA:
+					{
+						pAim->fZAim = -pAim->vecFront.fZ;
+
+						if (pAim->fZAim > 1.0f)
+						{
+							pAim->fZAim = 1.0f;
+						}
+						else if (pAim->fZAim < -1.0f)
+						{
+							pAim->fZAim = -1.0f;
+						}
+						break;
+					}
+				}
+				break;
+			}
+			case ID_STATS_UPDATE:
+			{
+				CSAMPFunctions::Packet_StatsUpdate(p);
+				CCallbackManager::OnPlayerStatsAndWeaponsUpdate(playerid);
+
+				p->data[0] = 0xFF;
+				break;
+			}
+			case ID_WEAPONS_UPDATE:
+			{
+				CSAMPFunctions::Packet_WeaponsUpdate(p);
+				CCallbackManager::OnPlayerStatsAndWeaponsUpdate(playerid);
+
+				p->data[0] = 0xFF;
+				break;
+			}
+		}
+	}
+	return p;
+}
+
+//----------------------------------------------------
+#ifdef CUSTOM_BANLIST
+
+void THISCALL CHookRakServer::AddToBanList(void* ppRakServer, const char *IP, unsigned int milliseconds)
+{
+	CSAMPFunctions::AddToBanList(ppRakServer, IP, milliseconds);
+}
+
+void THISCALL CHookRakServer::RemoveFromBanList(void* ppRakServer, const char *IP)
+{
+	CSAMPFunctions::RemoveFromBanList(ppRakServer, IP);
+}
+
+void THISCALL CHookRakServer::ClearBanList(void* ppRakServer)
+{
+	CSAMPFunctions::ClearBanList(ppRakServer);
+}
+
+#endif
+//----------------------------------------------------
+
+bool	bRconSocketReply = false;
+
+SOCKET	cur_sock = INVALID_SOCKET;
+char*	cur_data = NULL;
+int		cur_datalen = 0;
+sockaddr_in to;
+
+//----------------------------------------------------
+
+void RconSocketReply(char* szMessage);
+
+//----------------------------------------------------
+
+typedef void (*FUNC_logprintf)(const char *msg, ...);
+
+void HOOK_logprintf(const char *msg, ...)
+{
+	subhook_remove(logprintf_hook);
+
+	char buffer[1024];
+	va_list arguments;
+	va_start(arguments, msg);
+	vsnprintf(buffer, sizeof(buffer), msg, arguments);
+	va_end(arguments);
+	// CCallbackManager::OnServerMessage(buffer)
+	if(true)
+	{
+		// Fix crash caused by % symbol (by default this crash at /rcon varlist)
+		int i = 0;
+		bool bDoNotPrint = false;
+		while(buffer[i])
+		{
+			if(buffer[i++] == '%')
+			{
+				bDoNotPrint = true;
+ 				break;
+			}
+		}
+
+		if(!bDoNotPrint)
+			logprintf(buffer);
+	
+		if (bRconSocketReply) 
+			RconSocketReply(buffer);
+	}
+
+	subhook_install(logprintf_hook);
+}
+
+//----------------------------------------------------
+
+void RconSocketReply(char* szMessage)
+{
+	// IMPORTANT!
+	// Don't use logprintf from here... You'll cause an infinite loop.
+	if (bRconSocketReply)
+	{
+		char* newdata = (char*)malloc(cur_datalen + strlen(szMessage) + sizeof(WORD));
+		char* keep_ptr = newdata;
+		memcpy(newdata, cur_data, cur_datalen);
+		newdata += cur_datalen;
+		*(WORD*)newdata = (WORD)strlen(szMessage);
+		newdata += sizeof(WORD);
+		memcpy(newdata, szMessage, strlen(szMessage));
+		newdata += strlen(szMessage);
+		sendto(cur_sock, keep_ptr, (int)(newdata - keep_ptr), 0, (sockaddr*)&to, sizeof(to));
+		free(keep_ptr);
+	}
+}
+
+//----------------------------------------------------
+// bool CheckQueryFlood()
+// returns 1 if this query could flood
+// returns 0 otherwise
+bool CheckQueryFlood(unsigned int binaryAddress)
+{
+	static DWORD dwLastQueryTick = 0;
+	static unsigned int lastBinAddr = 0;
+
+	if(!dwLastQueryTick)
+	{
+		dwLastQueryTick = static_cast<DWORD>(GetTickCount());
+		lastBinAddr = binaryAddress;
+		return 0;
+	}
+	if(lastBinAddr != binaryAddress)
+	{
+		if((static_cast<DWORD>(GetTickCount()) - dwLastQueryTick) < 25)
+			return 1;
+
+		dwLastQueryTick = static_cast<DWORD>(GetTickCount());
+		lastBinAddr = binaryAddress;
+	}
+	return 0;
+}
+
+//----------------------------------------------------
+
+int HOOK_ProcessQueryPacket(unsigned int binaryAddress, unsigned short port, char* data, int length, SOCKET s)
+{
+	char* szPassword = NULL;
+	WORD wStrLen = 0;
+	in_addr in;
+	in.s_addr = binaryAddress;
+
+	if ((length > 4) && (*(unsigned long*)(data) == 0x504D4153)) // 0x504D4153 = "SAMP" as hex.
+	{
+		if (!pNetGame || (pNetGame->iGameState != GAMESTATE_RUNNING)) return 0;
+
+		if (length >= 11)
+		{
+			to.sin_family = AF_INET;
+			to.sin_port = htons(port);
+			to.sin_addr.s_addr = binaryAddress;
+
+			if (CSAMPFunctions::GetBoolVariable("logqueries"))
+			{
+				logprintf("[query:%c] from %s", data[10], inet_ntoa(in));
+			}
+
+			switch (data[10])
+			{
+				case 'p':	// ping
+				{
+					if (length == 15)
+					{
+						sendto(s, data, 15, 0, (sockaddr*)&to, sizeof(to));
+					}
+					break;
+				}
+				case 'i':	// info
+				{
+					// We do not process these queries 'query' is 0
+					if (!CSAMPFunctions::GetBoolVariable("query")) return 1;
+					if (CheckQueryFlood(binaryAddress)) return 1;
+
+					/*char* szHostname = CSAMPFunctions::GetStringVariable("hostname");
+					size_t dwHostnameLen = strlen(szHostname);
+					if (dwHostnameLen > 50) dwHostnameLen = 50;
+
+					char* szGameMode = CSAMPFunctions::GetStringVariable("gamemodetext");
+					size_t dwGameModeLen = strlen(szGameMode);
+					if (dwGameModeLen > 30) dwGameModeLen = 30;
+
+					char* szLanguage = CSAMPFunctions::GetStringVariable("language");
+					char* szMapName = (!szLanguage[0]) ? CSAMPFunctions::GetStringVariable("mapname") : szLanguage;
+
+					size_t dwMapNameLen = strlen(szMapName);
+					if (dwMapNameLen > 30) dwMapNameLen = 30;*/
+
+					char *gamerule;
+
+					char szHostname[51];
+					gamerule = CSAMPFunctions::GetStringVariable("hostname");
+					size_t dwHostnameLen = strlen(gamerule);
+					if (dwHostnameLen > 50) dwHostnameLen = 50;
+					memcpy(szHostname, gamerule, dwHostnameLen);
+					szHostname[dwHostnameLen] = 0;
+
+					char szGameMode[31];
+					gamerule = CSAMPFunctions::GetStringVariable("gamemodetext");
+					size_t dwGameModeLen = strlen(gamerule);
+					if (dwGameModeLen > 30) dwGameModeLen = 30;
+					memcpy(szGameMode, gamerule, dwGameModeLen);
+					szGameMode[dwGameModeLen] = 0;
+
+					char szMapName[31];
+					gamerule = CSAMPFunctions::GetStringVariable("language");
+					if(!gamerule[0]) gamerule = CSAMPFunctions::GetStringVariable("mapname");
+					size_t dwMapNameLen = strlen(gamerule);
+					if (dwMapNameLen > 30) dwMapNameLen = 30;
+					memcpy(szMapName, gamerule, dwMapNameLen);
+					szMapName[dwMapNameLen] = 0;
+
+					bool stringsChanged = CCallbackManager::OnServerQueryInfo(binaryAddress, szHostname, szGameMode, szMapName);
+					if(stringsChanged)
+					{
+						dwHostnameLen = strlen(szHostname);
+						dwGameModeLen = strlen(szGameMode);
+						dwMapNameLen = strlen(szMapName);
+					}
+
+					WORD wPlayerCount = pServer->GetPlayerCount();
+//					CPlayerPool* pPlayerPool = pNetGame->pPlayerPool;
+
+					WORD wMaxPlayers = pServer->GetMaxPlayers_();
+
+					BYTE byteIsPassworded = CSAMPFunctions::GetStringVariable("password")[0] != 0;
+
+					size_t datalen = 28;	// Previous data = 11b
+					// IsPassworded = 1b
+					// Player count = 2b
+					// Max player count = 2b
+					// String-length bytes = 12b (3 * sizeof(DWORD))
+					datalen += dwHostnameLen;
+					datalen += dwGameModeLen;
+					datalen += dwMapNameLen;
+
+
+					char* newdata = (char*)malloc(datalen);
+					char* keep_ptr = newdata;
+					// Previous Data
+					memcpy(newdata, data, 11);
+					newdata += 11;
+
+					// IsPassworded
+					memcpy(newdata, &byteIsPassworded, sizeof(BYTE));
+					newdata += sizeof(BYTE);
+
+					// Player Count
+					memcpy(newdata, &wPlayerCount, sizeof(WORD));
+					newdata += sizeof(WORD);
+
+					// Max Players
+					memcpy(newdata, &wMaxPlayers, sizeof(WORD));
+					newdata += sizeof(WORD);
+
+					// Hostname
+					memcpy(newdata, &dwHostnameLen, sizeof(DWORD));
+					newdata += sizeof(DWORD);
+					memcpy(newdata, szHostname, dwHostnameLen);
+					newdata += dwHostnameLen;
+
+					// Game Mode
+					memcpy(newdata, &dwGameModeLen, sizeof(DWORD));
+					newdata += sizeof(DWORD);
+					memcpy(newdata, szGameMode, dwGameModeLen);
+					newdata += dwGameModeLen;
+
+					// Map Name
+					memcpy(newdata, &dwMapNameLen, sizeof(DWORD));
+					newdata += sizeof(DWORD);
+					memcpy(newdata, szMapName, dwMapNameLen);
+					newdata += dwMapNameLen;
+
+					sendto(s, keep_ptr, datalen, 0, (sockaddr*)&to, sizeof(to));
+					free(keep_ptr);
+					break;
+				}
+				case 'c':	// players
+				{
+					// We do not process these queries 'query' is 0
+					if (!CSAMPFunctions::GetBoolVariable("query")) return 1;
+					if (CheckQueryFlood(binaryAddress)) return 1;
+
+					WORD wPlayerCount = pServer->GetPlayerCount();
+					CPlayerPool* pPlayerPool = pNetGame->pPlayerPool;
+					char* newdata = (char*)malloc(13 + (wPlayerCount * (MAX_PLAYER_NAME + 5))); // 5 = 1b String len, and 4b Score
+					char* keep_ptr = newdata;
+					// Previous Data
+					memcpy(newdata, data, 11);
+					newdata += 11;
+
+					// Player Count
+					memcpy(newdata, &wPlayerCount, sizeof(WORD));
+					newdata += sizeof(WORD);
+
+					if (pPlayerPool) 
+					{
+						char* szName;
+						BYTE byteNameLen;
+						DWORD dwScore;
+
+						for (WORD r = 0; r < MAX_PLAYERS; r++)
+						{
+							if (IsPlayerConnectedEx(r) && !pPlayerPool->bIsNPC[r] && !pPlayerData[r]->bHidden)
+							{
+								szName = GetPlayerName_(r);
+								byteNameLen = (BYTE)strlen(szName);
+								memcpy(newdata, &byteNameLen, sizeof(BYTE));
+								newdata += sizeof(BYTE);
+								memcpy(newdata, szName, byteNameLen);
+								newdata += byteNameLen;
+								dwScore = pPlayerPool->dwScore[r];
+								memcpy(newdata, &dwScore, sizeof(DWORD));
+								newdata += sizeof(DWORD);
+
+							}
+						}
+					}
+
+					sendto(s, keep_ptr, (int)(newdata - keep_ptr), 0, (sockaddr*)&to, sizeof(to));
+					free(keep_ptr);
+					break;
+				}
+				case 'd':	// detailed player list id.namelength.name.score.ping
+				{
+					// We do not process these queries 'query' is 0
+					if (!CSAMPFunctions::GetBoolVariable("query")) return 1;
+					if (CheckQueryFlood(binaryAddress)) return 1;
+
+					WORD wPlayerCount = pServer->GetPlayerCount();
+					CPlayerPool* pPlayerPool = pNetGame->pPlayerPool;
+					char* newdata = (char*)malloc(13 + (wPlayerCount * (MAX_PLAYER_NAME + 10))); // 9 = 1b String len, 4b Score, 4b Ping, 1b Playerid
+					char* keep_ptr = newdata;
+					// Previous Data
+					memcpy(newdata, data, 11);
+					newdata += 11;
+
+					// Player Count
+					memcpy(newdata, &wPlayerCount, sizeof(WORD));
+					newdata += sizeof(WORD);
+
+					if (pPlayerPool) 
+					{
+						char* szName;
+						BYTE byteNameLen;
+						DWORD dwScore, dwPing;
+
+						for (WORD r = 0; r < MAX_PLAYERS; r++)
+						{
+							if (IsPlayerConnectedEx(r) && !pPlayerPool->bIsNPC[r] && !pPlayerData[r]->bHidden)
+							{
+								memcpy(newdata, &r, sizeof(BYTE));
+								newdata += sizeof(BYTE);
+								szName = GetPlayerName_(r);
+								byteNameLen = (BYTE)strlen(szName);
+								memcpy(newdata, &byteNameLen, sizeof(BYTE));
+								newdata += sizeof(BYTE);
+								memcpy(newdata, szName, byteNameLen);
+								newdata += byteNameLen;
+								dwScore = pPlayerPool->dwScore[r];
+								memcpy(newdata, &dwScore, sizeof(DWORD));
+								newdata += sizeof(DWORD);
+								dwPing = pRakServer->GetLastPing(pRakServer->GetPlayerIDFromIndex(r));
+								memcpy(newdata, &dwPing, sizeof(DWORD));
+								newdata += sizeof(DWORD);
+							}
+						}
+					}
+					sendto(s, keep_ptr, (int)(newdata - keep_ptr), 0, (sockaddr*)&to, sizeof(to));
+					free(keep_ptr);
+					break;
+				}
+
+				case 'r':	// rules
+				{
+					// We do not process these queries 'query' is 0
+					if (!CSAMPFunctions::GetBoolVariable("query")) return 1;
+					if (CheckQueryFlood(binaryAddress)) return 1;
+
+					CSAMPFunctions::SendRules(s, data, (sockaddr_in*)&to, sizeof(to));
+					break;
+				}
+				case 'x':	// rcon
+				{
+					if (CSAMPFunctions::IsBanned(inet_ntoa(in))) return 1;
+					
+					// We do not process these queries 'query' is 0
+					if (!CSAMPFunctions::GetBoolVariable("query") || !CSAMPFunctions::GetBoolVariable("rcon")) return 1;
+					if (CheckQueryFlood(binaryAddress)) return 1;
+					
+					cur_sock = s;
+					cur_data = data;
+					cur_datalen = 11; // How much of the message we send back.
+					int tmp_datalen = cur_datalen;
+
+					data += cur_datalen;
+
+					// Check there's enough data for another WORD
+					tmp_datalen += sizeof(WORD);
+					if (length < tmp_datalen)
+						goto cleanup;	// Malformed packet! Haxy bastard!
+					// Read the string length for the password
+					wStrLen = *(WORD*)data;
+					data += sizeof(WORD);
+					// Check there's enough data for the password string
+					tmp_datalen += wStrLen;
+					if (length < tmp_datalen)
+						goto cleanup;	// Malformed packet! Haxy bastard!
+					// Read the password string
+					szPassword = (char*)malloc(wStrLen + 1);
+					memcpy(szPassword, data, wStrLen);
+					szPassword[wStrLen] = 0;
+					data += wStrLen;
+					
+					if (!strcmp(szPassword, CSAMPFunctions::GetStringVariable("rcon_password")))
+					{
+						// Check there's enough data for another WORD
+						tmp_datalen += sizeof(WORD);
+						if (length < tmp_datalen)
+						{
+							free(szPassword);
+							goto cleanup;	// Malformed packet! Haxy bastard!
+						}
+						// Read the string length for the command
+						wStrLen = *(WORD*)data;
+						data += sizeof(WORD);
+						tmp_datalen += wStrLen;
+						if (length < tmp_datalen)
+						{
+							free(szPassword);
+							goto cleanup;	// Malformed packet! Haxy bastard!
+						}
+						
+						// Read the command string
+						char* szCommand = (char*)malloc(wStrLen + 1);
+						memcpy(szCommand, data, wStrLen);
+						szCommand[wStrLen] = 0;
+
+						if (pConsole)
+						{
+							//logprintf("onremoterconpacket %d, %d, %s - %s", binaryAddress, port, szPassword, szCommand);
+							if (CCallbackManager::OnRemoteRCONPacket(binaryAddress, port, szPassword, true, szCommand))
+							{ 
+								bRconSocketReply = true;
+								// Execute the command
+								CSAMPFunctions::Execute(szCommand);
+								bRconSocketReply = false;
+							}
+						}
+
+						free(szCommand);
+					}
+					else 
+					{
+						in_addr in;
+						in.s_addr = binaryAddress;
+						logprintf("BAD RCON ATTEMPT BY: %s", inet_ntoa(in));
+
+						bRconSocketReply = true;
+						RconSocketReply("Invalid RCON password.");
+						bRconSocketReply = false;
+
+						CCallbackManager::OnRemoteRCONPacket(binaryAddress, port, szPassword, false, "NULL");
+					}
+					free(szPassword);
+					
+				cleanup:
+					cur_datalen = 0;
+					cur_data = NULL;
+					cur_sock = INVALID_SOCKET;
+					break;
+					
+				}
+			}
+		}
+		return 1;
+	}
+	else 
+	{
+		return 0;
+	}
+}
+
+#ifdef _WIN32
+
+CVehicle *_pVehicle;
+
+void _declspec(naked) HOOK_CVehicle__Respawn()
+{
+	_asm mov _pVehicle, ecx
+	_asm pushad
+
+	CSAMPFunctions::RespawnVehicle(_pVehicle);
+
+	_asm popad
+	_asm retn
+}
+
+#endif
+
+// Things that needs to be hooked before netgame initialied
+void InstallPreHooks()
+{
+	if (pServer)
+	{
+	/*
+		SetWeather_hook = subhook_new((void *)CAddress::FUNC_CNetGame__SetWeather, (void *)CHookedNetgame::HOOK_CNetGame__SetWeather);
+		subhook_install(SetWeather_hook);
+		
+		SetGravity_hook = subhook_new((void *)CAddress::FUNC_CNetGame__SetGravity, (void *)HOOK_CNetGame__SetGravity);
+		subhook_install(SetGravity_hook);
+		*/
+		Namecheck_hook = subhook_new((void*)CAddress::FUNC_ContainsInvalidChars, (void *)HOOK_ContainsInvalidChars);
+		subhook_install(Namecheck_hook);
+
+		amx_Register_hook = subhook_new((void*)*(DWORD*)((DWORD)pAMXFunctions + (PLUGIN_AMX_EXPORT_Register * 4)), (void*)HOOK_amx_Register);
+		subhook_install(amx_Register_hook);
+
+		query_hook = subhook_new((void*)CAddress::FUNC_ProcessQueryPacket, (void*)HOOK_ProcessQueryPacket);
+		subhook_install(query_hook);
+
+		logprintf_hook = subhook_new((void*)ppPluginData[PLUGIN_DATA_LOGPRINTF], (void*)HOOK_logprintf);
+		subhook_install(logprintf_hook);
+
+		if(CAddress::FUNC_CVehicle__Respawn)
+		{
+#ifdef WIN32
+			InstallJump(CAddress::FUNC_CVehicle__Respawn, (void*)HOOK_CVehicle__Respawn);
+#else
+			InstallJump(CAddress::FUNC_CVehicle__Respawn, (void*)CSAMPFunctions::RespawnVehicle);
+#endif
+		}
+
+		if(CAddress::ADDR_RecordingDirectory)
+		{
+			strcpy(gRecordingDataPath, "scriptfiles/%s.rec");
+			Unlock((void*)CAddress::ADDR_RecordingDirectory, 5);
+			*(DWORD*)(CAddress::ADDR_RecordingDirectory + 1) = (DWORD)&gRecordingDataPath;
+		}
+	}	
+}
+
+// Things that needs to be hooked after netgame initialied
+void InstallPostHooks()
+{
+	CSAMPFunctions::PostInitialize();
+
+	// !!! READ !!!
+	// If "myriad 1" present in server.cfg, then the internal raknet player "pool" will start with MAX_PLAYERS - needed for SetMaxPlayers if you want to increase your slots, eg. add +30 slot for 30 bot, and you paid for 60 slots only.
+	// This isn't enabled by default, because if it's enabled, then doesn't matter which value used for maxplayers in server.cfg, 
+	// server will allow up to connect MAX_PLAYERS at same time (currently 1000). 
+	// use this only if you want to have much NPC to trick hosts to allow them insted of paying for more slots for bots.
+	if(CSAMPFunctions::GetBoolVariable("myriad"))
+	{
+		pRakServer->Start(MAX_PLAYERS, 0, 5, static_cast<unsigned short>(CSAMPFunctions::GetIntVariable("port")), CSAMPFunctions::GetStringVariable("bind"));
+	}
+
+	// Recreate pools
+	pServer->pGangZonePool = new CGangZonePool();
+
+#ifdef NEW_PICKUP_SYSTEM
+	// Recreate Pickup pool
+	pServer->pPickupPool = new CYSFPickupPool();
+#endif
+	// Re-init some RPCs
+	InitRPCs();
+
+	//logprintf("YSF - pNetGame: 0x%X, pConsole: 0x%X, pRakServer: 0x%X", pNetGame, pConsole, pRakServer);
+}
+
+void UninstallHooks()
+{
+	if(SetWeather_hook)
+	{
+		subhook_remove(SetWeather_hook);
+		subhook_free(SetWeather_hook);
+	}
+	
+	if(SetGravity_hook)
+	{
+		subhook_remove(SetGravity_hook);
+		subhook_free(SetGravity_hook);
+	}
+	
+	if(Namecheck_hook)
+	{
+		subhook_remove(Namecheck_hook);
+		subhook_free(Namecheck_hook);
+	}
+
+	if(amx_Register_hook)
+	{
+		subhook_remove(amx_Register_hook);
+		subhook_free(amx_Register_hook);
+	}
+
+	if(query_hook)
+	{
+		subhook_remove(query_hook);
+		subhook_free(query_hook);
+	}
+
+	if(logprintf_hook)
+	{
+		subhook_remove(logprintf_hook);
+		subhook_free(logprintf_hook);
+	}
+}
diff --git a/src/Hooks.h b/src/src/Hooks.h
similarity index 100%
rename from src/Hooks.h
rename to src/src/Hooks.h
diff --git a/src/RPCs.cpp b/src/src/RPCs.cpp
similarity index 99%
rename from src/RPCs.cpp
rename to src/src/RPCs.cpp
index 727261d..fd74a5b 100644
--- a/src/RPCs.cpp
+++ b/src/src/RPCs.cpp
@@ -24,6 +24,7 @@ int RPC_WorldPlayerRemove = 163;
 int RPC_ChatBubble = 0x3B;
 int RPC_SetPlayerSkin = 0x99;
 int RPC_SetPlayerName = 0x0B;
+int RPC_SetPlayerColor = 72;
 int RPC_SetFightingStyle = 0x59;
 int RPC_ScrApplyAnimation = 0x56;
 int RPC_ClientMessage = 0x5D;
@@ -225,4 +226,4 @@ void InitRPCs()
 
 	pRakServer->UnregisterAsRemoteProcedureCall(&RPC_PickedUpPickup);
 	pRakServer->RegisterAsRemoteProcedureCall(&RPC_PickedUpPickup, PickedUpPickup);
-}
+}
\ No newline at end of file
diff --git a/src/RPCs.h b/src/src/RPCs.h
similarity index 95%
rename from src/RPCs.h
rename to src/src/RPCs.h
index ea32b88..a1ceecd 100644
--- a/src/RPCs.h
+++ b/src/src/RPCs.h
@@ -52,6 +52,7 @@ extern int RPC_WorldPlayerRemove;
 extern int RPC_ChatBubble;
 extern int RPC_SetPlayerSkin;
 extern int RPC_SetPlayerName;
+extern int RPC_SetPlayerColor;
 extern int RPC_SetFightingStyle;
 extern int RPC_ScrApplyAnimation;
 extern int RPC_ClientMessage;
@@ -69,9 +70,10 @@ extern int RPC_ServerQuit;
 
 void InitRPCs();
 
-enum PacketEnumeration : unsigned char
+enum PacketEnumeration // : unsigned char
 {	
-	RPC_InitGame = 0x8B, 
+	RPC_InitGame = 0x8B,
+	RPC_ScmEvent = 96,
 
 	ID_TIMESTAMP = 40,
 	ID_VEHICLE_SYNC = 200,
diff --git a/src/Scripting.cpp b/src/src/Scripting.cpp
similarity index 96%
rename from src/Scripting.cpp
rename to src/src/Scripting.cpp
index f7c9999..34a16c0 100644
--- a/src/Scripting.cpp
+++ b/src/src/Scripting.cpp
@@ -1,6757 +1,7011 @@
-/*  
- *  Version: MPL 1.1
- *  
- *  The contents of this file are subject to the Mozilla Public License Version 
- *  1.1 (the "License"); you may not use this file except in compliance with 
- *  the License. You may obtain a copy of the License at 
- *  http://www.mozilla.org/MPL/
- *  
- *  Software distributed under the License is distributed on an "AS IS" basis,
- *  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- *  for the specific language governing rights and limitations under the
- *  License.
- *  
- *  The Original Code is the YSI 2.0 SA:MP plugin.
- *  
- *  The Initial Developer of the Original Code is Alex "Y_Less" Cole.
- *  Portions created by the Initial Developer are Copyright (C) 2008
- *  the Initial Developer. All Rights Reserved.
- *  
- *  Contributor(s):
- *  
- *  Peter Beverloo
- *  Marcus Bauer
- *  MaVe;
- *  Sammy91
- *  Incognito
- *  
- *  Special Thanks to:
- *  
- *  SA:MP Team past, present and future
- */
-
-#include "main.h"
-
-// extern
-typedef cell AMX_NATIVE_CALL (* AMX_Function_t)(AMX *amx, cell *params);
-
-//----------------------------------------------------
-#ifdef _WIN32
-	// native ffind(const pattern[], filename[], len, &idx);
-	static cell AMX_NATIVE_CALL Natives::ffind(AMX *amx, cell *params)
-	{
-		// Find a file, idx determines which one of a number of matches to use
-		CHECK_PARAMS(4, "ffind");
-		cell
-			*cptr;
-		char
-			*szSearch;
-		// Get the search pattern
-		amx_StrParam(amx, params[1], szSearch);
-		if (szSearch)
-		{
-			// Get associated search information
-			amx_GetAddr(amx, params[4], &cptr);
-			cell
-				count = *cptr;
-			WIN32_FIND_DATA
-				ffd;
-			TCHAR
-				szDir[MAX_PATH] = TEXT("./scriptfiles/");
-			StringCchCat(szDir, MAX_PATH, szSearch);
-			// Get a serch handle
-			HANDLE
-				hFind = FindFirstFile(szDir, &ffd);
-			if (hFind != INVALID_HANDLE_VALUE)
-			{
-				do
-				{
-					// Check that this isn't a directory
-					if (!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
-					{
-						// It's not - update idx
-						if (!count)
-						{
-							// No files left to skip, return the data
-							(*cptr)++;
-							amx_GetAddr(amx, params[2], &cptr);
-							amx_SetString(cptr, ffd.cFileName, 0, 0, params[3]);
-							FindClose(hFind);
-							return 1;
-						}
-						count--;
-					}
-				}
-				while (FindNextFile(hFind, &ffd) != 0);
-				FindClose(hFind);
-			}
-		}
-		return 0;
-	}
-	
-	// native dfind(const pattern[], filename[], len, &idx);
-	static cell AMX_NATIVE_CALL Natives::dfind(AMX *amx, cell *params)
-	{
-		// Find a directory, idx determines which one of a number of matches to use
-		// Identical to ffind in all but 1 line
-		CHECK_PARAMS(4, "dfind");
-		cell
-			*cptr;
-		char
-			*szSearch;
-		// Get the search pattern
-		amx_StrParam(amx, params[1], szSearch);
-		if (szSearch)
-		{
-			// Get associated search information
-			amx_GetAddr(amx, params[4], &cptr);
-			cell
-				count = *cptr;
-			WIN32_FIND_DATA
-				ffd;
-			TCHAR
-				szDir[MAX_PATH] = TEXT("./scriptfiles/");
-			StringCchCat(szDir, MAX_PATH, szSearch);
-			// Get a serch handle
-			HANDLE
-				hFind = FindFirstFile(szDir, &ffd);
-			if (hFind != INVALID_HANDLE_VALUE)
-			{
-				do
-				{
-					// Check that this is a directory
-					if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
-					{
-						// It is - update idx
-						if (!count)
-						{
-							// No files left to skip, return the data
-							(*cptr)++;
-							amx_GetAddr(amx, params[2], &cptr);
-							amx_SetString(cptr, ffd.cFileName, 0, 0, params[3]);
-							FindClose(hFind);
-							return 1;
-						}
-						count--;
-					}
-				}
-				while (FindNextFile(hFind, &ffd) != 0);
-				FindClose(hFind);
-			}
-		}
-		return 0;
-	}
-#else
-	// native ffind(const pattern[], filename[], len, &idx);
-	static cell AMX_NATIVE_CALL Natives::ffind(AMX *amx, cell *params)
-	{
-		// Find a file, idx determines which one of a number of matches to use
-		CHECK_PARAMS(4, "dfind");
-		cell
-			*cptr;
-		char
-			*szSearch;
-		// Get the search pattern
-		amx_StrParam(amx, params[1], szSearch);
-		if (szSearch)
-		{
-			// Get associated search information
-			amx_GetAddr(amx, params[4], &cptr);
-			cell
-				count = *cptr;
-			// Find the end of the directory name
-			int
-				end = strlen(szSearch) - 1;
-			if (end == -1)
-			{
-				return 0;
-			}
-			while (szSearch[end] != '\\' && szSearch[end] != '/')
-			{
-				if (!end)
-				{
-					break;
-				}
-				end--;
-			}
-			// Split up the information
-			// Ensure that we search in scriptfiles
-			// And separate out the filename and path
-			char
-				*szDir = (char *)alloca(end + 16),
-				*szFile;
-			strcpy(szDir, "./scriptfiles/");
-			if (end)
-			{
-				szFile = &szSearch[end + 1];
-				szSearch[end] = '\0';
-				strcpy(szDir + 14, szSearch);
-				strcpy(szDir + strlen(szDir), "/");
-			}
-			else
-			{
-				szFile = szSearch;
-			}
-			end = strlen(szDir);
-			DIR
-				*dp = opendir(szDir);
-			if (dp)
-			{
-				// Loop through all files in the directory
-				struct dirent
-					*ep;
-				while (ep = readdir(dp))
-				{
-					// Check if this file matches the pattern
-					if (!fnmatch(szFile, ep->d_name, FNM_NOESCAPE))
-					{
-						// Check if this is a directory
-						// There MUST be an easier way to do this!
-						char
-							*full = (char *)malloc(strlen(ep->d_name) + end + 1);
-						if (!full)
-						{
-							closedir(dp);
-							return 0;
-						}
-						strcpy(full, szDir);
-						strcpy(full + end, ep->d_name);
-						DIR
-							*xp = opendir(full);
-						free(full);
-						if (xp)
-						{
-							closedir(xp);
-							continue;
-						}
-						// Check if there's any left to skip
-						if (!count)
-						{
-							// No files left to skip, return the data
-							(*cptr)++;
-							amx_GetAddr(amx, params[2], &cptr);
-							amx_SetString(cptr, ep->d_name, 0, 0, params[3]);
-							closedir(dp);
-							return 1;
-						}
-						count--;
-					}
-				}
-				closedir(dp);
-				return 0;
-			}
-		}
-		return 0;
-	}
-	
-	// native dfind(const pattern[], filename[], len, &idx);
-	static cell AMX_NATIVE_CALL Natives::dfind(AMX *amx, cell *params)
-	{
-		// Find a file, idx determines which one of a number of matches to use
-		CHECK_PARAMS(4, "ffind");
-		cell
-			*cptr;
-		char
-			*szSearch;
-		// Get the search pattern
-		amx_StrParam(amx, params[1], szSearch);
-		if (szSearch)
-		{
-			// Get associated search information
-			amx_GetAddr(amx, params[4], &cptr);
-			cell
-				count = *cptr;
-			// Find the end of the directory name
-			int
-				end = strlen(szSearch) - 1;
-			if (end == -1)
-			{
-				return 0;
-			}
-			while (szSearch[end] != '\\' && szSearch[end] != '/')
-			{
-				if (!end)
-				{
-					break;
-				}
-				end--;
-			}
-			// Split up the information
-			// Ensure that we search in scriptfiles
-			// And separate out the filename and path
-			char
-				*szDir = (char *)alloca(end + 16),
-				*szFile;
-			strcpy(szDir, "./scriptfiles/");
-			if (end)
-			{
-				szFile = &szSearch[end + 1];
-				szSearch[end] = '\0';
-				strcpy(szDir + 14, szSearch);
-				strcpy(szDir + strlen(szDir), "/");
-			}
-			else
-			{
-				szFile = szSearch;
-			}
-			end = strlen(szDir);
-			DIR
-				*dp = opendir(szDir);
-			if (dp)
-			{
-				// Loop through all files in the directory
-				struct dirent
-					*ep;
-				while (ep = readdir(dp))
-				{
-					// Check if this file matches the pattern
-					if (!fnmatch(szFile, ep->d_name, FNM_NOESCAPE))
-					{
-						// Check if this is a directory
-						// There MUST be an easier way to do this!
-						char
-							*full = (char *)malloc(strlen(ep->d_name) + end + 1);
-						if (!full)
-						{
-							closedir(dp);
-							return 0;
-						}
-						strcpy(full, szDir);
-						strcpy(full + end, ep->d_name);
-						DIR
-							*xp = opendir(full);
-						free(full);
-						if (!xp)
-						{
-							continue;
-						}
-						closedir(xp);
-						// Check if there's any left to skip
-						if (!count)
-						{
-							// No files left to skip, return the data
-							(*cptr)++;
-							amx_GetAddr(amx, params[2], &cptr);
-							amx_SetString(cptr, ep->d_name, 0, 0, params[3]);
-							closedir(dp);
-							return 1;
-						}
-						count--;
-					}
-				}
-				closedir(dp);
-				return 0;
-			}
-		}
-		return 0;
-	}
-#endif
-
-// native dcreate(const name[]);
-static cell AMX_NATIVE_CALL Natives::dcreate(AMX *amx, cell *params)
-{
-	// Creates a directory
-	CHECK_PARAMS(1, "dcreate");
-	char
-		*szSearch;
-	// Get the search pattern
-	amx_StrParam(amx, params[1], szSearch);
-	if (szSearch)
-	{
-		#ifdef _WIN32
-			TCHAR
-				szDir[MAX_PATH] = TEXT("./scriptfiles/");
-			StringCchCat(szDir, MAX_PATH, szSearch);
-			return (cell)CreateDirectory(szDir, NULL);
-		#else
-			char
-				*szDir = (char *)alloca(strlen(szSearch) + 15);
-			strcpy(szDir, "./scriptfiles/");
-			strcpy(szDir + 14, szSearch);
-			return (cell)mkdir(szDir, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
-		#endif
-	}
-	return 0;
-}
-
-// native frename(const oldname[], const newname[]);
-static cell AMX_NATIVE_CALL Natives::frename(AMX *amx, cell *params)
-{
-	// Creates a directory
-	CHECK_PARAMS(2, "frename");
-	char
-		*szOld,
-		*szNew;
-	// Get the search pattern
-	amx_StrParam(amx, params[1], szOld);
-	amx_StrParam(amx, params[2], szNew);
-	if (szOld && szNew)
-	{
-		char
-			*szO = (char *)alloca(strlen(szOld) + 16),
-			*szN = (char *)alloca(strlen(szNew) + 16);
-		strcpy(szO, "./scriptfiles/");
-		strcpy(szO + 14, szOld);
-		strcpy(szN, "./scriptfiles/");
-		strcpy(szN + 14, szNew);
-		return (cell)rename(szO, szN);
-	}
-	return 0;
-}
-
-// native drename(const oldname[], const newname[]);
-static cell AMX_NATIVE_CALL Natives::drename(AMX *amx, cell *params)
-{
-	// Creates a directory
-	CHECK_PARAMS(2, "drename");
-	char
-		*szOld,
-		*szNew;
-	// Get the search pattern
-	amx_StrParam(amx, params[1], szOld);
-	amx_StrParam(amx, params[2], szNew);
-	if (szOld && szNew)
-	{
-		char
-			*szO = (char *)alloca(strlen(szOld) + 16),
-			*szN = (char *)alloca(strlen(szNew) + 16);
-		strcpy(szO, "./scriptfiles/");
-		strcpy(szO + 14, szOld);
-		int
-			end;
-		end = strlen(szO);
-		if (szO[end - 1] != '/')
-		{
-			szO[end] = '/';
-			szO[end + 1] = '\0';
-		}
-		strcpy(szN, "./scriptfiles/");
-		strcpy(szN + 14, szNew);
-		end = strlen(szN);
-		if (szN[end - 1] != '/')
-		{
-			szN[end] = '/';
-			szN[end + 1] = '\0';
-		}
-		return (cell)rename(szO, szN);
-	}
-	return 0;
-}
-
-// native SetModeRestartTime(Float:time);
-static cell AMX_NATIVE_CALL Natives::SetModeRestartTime(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	if (!CAddress::VAR_pRestartWaitTime) return 0;
-
-	CHECK_PARAMS(1, "SetModeRestartTime");
-
-	*(float*)CAddress::VAR_pRestartWaitTime = amx_ctof(params[1]);
-	return 1;
-}
-
-// native Float:GetModeRestartTime();
-static cell AMX_NATIVE_CALL Natives::GetModeRestartTime(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	if (!CAddress::VAR_pRestartWaitTime) return 0;
-
-	float fRestartTime = *(float*)CAddress::VAR_pRestartWaitTime;
-	return amx_ftoc(fRestartTime);
-}
-
-// native SetMaxPlayers(maxplayers);
-static cell AMX_NATIVE_CALL Natives::SetMaxPlayers(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	int maxplayers = static_cast<int>(params[1]);
-	if(maxplayers < 1 || maxplayers > MAX_PLAYERS) return 0;
-
-	CSAMPFunctions::SetIntVariable("maxplayers", maxplayers);
-	return 1;
-}
-
-// native SetMaxNPCs(maxnpcs);
-static cell AMX_NATIVE_CALL Natives::SetMaxNPCs(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	int maxnpcs = static_cast<int>(params[1]);
-	if(maxnpcs < 1 || maxnpcs > MAX_PLAYERS) return 0;
-
-	CSAMPFunctions::SetIntVariable("maxnpc", maxnpcs);
-	return 1;
-}
-
-// native SetPlayerAdmin(playerid, bool:admin);
-static cell AMX_NATIVE_CALL Natives::SetPlayerAdmin(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetPlayerAdmin");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	pNetGame->pPlayerPool->bIsAnAdmin[playerid] = !!params[2];
-	return 1;
-}
-
-// native LoadFilterScript(scriptname[]);
-static cell AMX_NATIVE_CALL Natives::LoadFilterScript(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "LoadFilterScript");
-	
-	char
-		*name;
-	amx_StrParam(amx, params[1], name);
-	if(name)
-	{
-		return CSAMPFunctions::LoadFilterscript(name);
-	}
-	return 0;
-}
-
-// UnLoadFilterScript(scriptname[]);
-static cell AMX_NATIVE_CALL Natives::UnLoadFilterScript(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "UnLoadFilterScript");
-	
-	char
-		*name;
-	amx_StrParam(amx, params[1], name);
-	if(name)
-	{
-		return CSAMPFunctions::UnLoadFilterscript(name);
-	}
-	return 0;
-}
-
-// native GetFilterScriptCount();
-static cell AMX_NATIVE_CALL Natives::GetFilterScriptCount(AMX *amx, cell *params)
-{
-	return pNetGame->pFilterScriptPool->iFilterScriptCount;
-}
-
-// native GetFilterScriptName(id, name[], len = sizeof(name));
-static cell AMX_NATIVE_CALL Natives::GetFilterScriptName(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(3, "GetFilterScriptName");
-
-	int id = static_cast<int>(params[1]);
-	if(id >= MAX_FILTER_SCRIPTS) return 0;
-
-	return set_amxstring(amx, params[2], pNetGame->pFilterScriptPool->szFilterScriptName[id], params[3]);
-}
-
-// native AddServerRule(name[], value[], flags = CON_VARFLAG_RULE);
-static cell AMX_NATIVE_CALL Natives::AddServerRule(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "AddServerRule");
-	
-	char *name, *value;
-	amx_StrParam(amx, params[1], name);
-	amx_StrParam(amx, params[2], value);
-	if (name && value)
-	{
-		ConsoleVariable_s* ConVar = CSAMPFunctions::FindVariable(name);
-		if (ConVar == NULL)
-		{
-			CSAMPFunctions::AddStringVariable(name, static_cast<int>(params[3]), value, NULL);
-			return 1;
-		}
-	}
-	return 0;
-}
-
-// native SetServerRule(name[], value[]);
-static cell AMX_NATIVE_CALL Natives::SetServerRule(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetServerRule");
-
-	char *name, *value;
-	amx_StrParam(amx, params[1], name);
-	amx_StrParam(amx, params[2], value);
-	if (name && value)
-	{
-		ConsoleVariable_s* ConVar = CSAMPFunctions::FindVariable(name);
-		if (ConVar != NULL)
-		{
-			CSAMPFunctions::SetStringVariable(name, value);
-			return 1;
-		}
-	}
-	return 0;
-}
-
-// native SetServerRuleInt(name[], value);
-static cell AMX_NATIVE_CALL Natives::SetServerRuleInt(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetServerRuleInt");
-
-	char *name;
-	amx_StrParam(amx, params[1], name);
-	if (name)
-	{
-		ConsoleVariable_s* ConVar = CSAMPFunctions::FindVariable(name);
-		if (ConVar != NULL)
-		{
-			CSAMPFunctions::SetIntVariable(name, static_cast<int>(params[2]));
-			return 1;
-		}
-		return 1;
-	}
-	return 0;
-}
-
-// native IsValidServerRule(name[]);
-static cell AMX_NATIVE_CALL Natives::IsValidServerRule(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsValidServerRule");
-
-	char *name;
-	amx_StrParam(amx, params[1], name);
-	if (name)
-	{
-		ConsoleVariable_s* ConVar = CSAMPFunctions::FindVariable(name);
-		return ConVar != NULL;
-	}
-	return 0;
-}
-
-// native RemoveServerRule(name[]);
-static cell AMX_NATIVE_CALL Natives::RemoveServerRule(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "RemoveServerRule");
-
-	char *name;
-	amx_StrParam(amx, params[1], name);
-	if (name)
-	{
-		//RemoveServerRule(name);
-		return 1;
-	}
-	return 0;
-}
-
-// native SetServerRuleFlags(name[], flags);
-static cell AMX_NATIVE_CALL Natives::SetServerRuleFlags(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetServerRuleFlags");
-	
-	char *name;
-	amx_StrParam(amx, params[1], name);
-	if (name)
-	{
-		CSAMPFunctions::ModifyVariableFlags(name, (DWORD)params[2]);
-		return 1;
-	}
-	return 0;
-}
-
-// native GetServerRuleFlags(name[]);
-static cell AMX_NATIVE_CALL Natives::GetServerRuleFlags(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetServerRuleFlags");
-	
-	char *name;
-	amx_StrParam(amx, params[1], name);
-	if (name)
-	{
-		ConsoleVariable_s* ConVar = CSAMPFunctions::FindVariable(name);
-		if (ConVar != NULL)
-		{
-			return ConVar->VarFlags;
-		}
-		return 0;
-	}
-	return 0;
-}
-
-// native GetServerSettings(&showplayermarkes, &shownametags, &stuntbonus, &useplayerpedanims, &bLimitchatradius, &disableinteriorenterexits, &nametaglos, &manualvehicleengine, 
-//		&limitplayermarkers, &vehiclefriendlyfire, &defaultcameracollision, &Float:fGlobalchatradius, &Float:fNameTagDrawDistance, &Float:fPlayermarkerslimit);
-static cell AMX_NATIVE_CALL Natives::GetServerSettings(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(14, "GetServerSettings");
-
-	cell *cptr;
-	amx_GetAddr(amx, params[1], &cptr); *cptr = (cell)pNetGame->bShowPlayerMarkers;
-	amx_GetAddr(amx, params[2], &cptr); *cptr = (cell)pNetGame->byteShowNameTags;
-	amx_GetAddr(amx, params[3], &cptr); *cptr = (cell)pNetGame->byteStuntBonus;
-	amx_GetAddr(amx, params[4], &cptr); *cptr = (cell)pNetGame->bUseCJWalk;
-	amx_GetAddr(amx, params[5], &cptr); *cptr = (cell)pNetGame->bLimitGlobalChatRadius;
-	amx_GetAddr(amx, params[6], &cptr); *cptr = (cell)pNetGame->byteDisableEnterExits;
-	amx_GetAddr(amx, params[7], &cptr); *cptr = (cell)pNetGame->byteNameTagLOS;
-	amx_GetAddr(amx, params[8], &cptr); *cptr = (cell)pNetGame->bManulVehicleEngineAndLights;
-	amx_GetAddr(amx, params[9], &cptr); *cptr = (cell)pNetGame->bLimitPlayerMarkers;
-	amx_GetAddr(amx, params[10], &cptr); *cptr = (cell)pNetGame->bVehicleFriendlyFire;
-	amx_GetAddr(amx, params[11], &cptr); *cptr = (cell)pNetGame->byteDefaultCameraCollision;
-	amx_GetAddr(amx, params[12], &cptr); *cptr = amx_ftoc(pNetGame->fGlobalChatRadius);
-	amx_GetAddr(amx, params[13], &cptr); *cptr = amx_ftoc(pNetGame->fNameTagDrawDistance);
-	amx_GetAddr(amx, params[14], &cptr); *cptr = amx_ftoc(pNetGame->fPlayerMarkesLimit);
-	return 1;
-}
-
-// native IsValidNickName(name[]);
-static cell AMX_NATIVE_CALL Natives::IsValidNickName(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsValidNickName");
-
-	char *name;
-	amx_StrParam(amx, params[1], name);
-	if (name)
-	{
-		return pServer->IsValidNick(name);
-	}
-	return 0;
-}
-
-// native AllowNickNameCharacter(character, bool:allow);
-static cell AMX_NATIVE_CALL Natives::AllowNickNameCharacter(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "AllowNickNameCharacter");
-	
-	char character = (char)params[1];
-
-	// Enable %s is disallowed
-	if(character == '%') return 0;
-
-	pServer->AllowNickNameCharacter(character, !!params[2]);
-	return 0;
-}
-
-// native IsNickNameCharacterAllowed(character);
-static cell AMX_NATIVE_CALL Natives::IsNickNameCharacterAllowed(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsNickNameCharacterAllowed");
-
-	return pServer->IsNickNameCharacterAllowed((char)params[1]);
-}
-
-/////////////// Timers
-
-// native GetAvailableClasses();
-static cell AMX_NATIVE_CALL Natives::GetAvailableClasses(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	return pNetGame->iSpawnsAvailable;
-}
-
-// native RemoveLastClass();
-static cell AMX_NATIVE_CALL Natives::RemoveLastClass(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	if(pNetGame->iSpawnsAvailable <= 0)
-		return 0;
-
-	pNetGame->iSpawnsAvailable--;
-	return 1;
-}
-
-// native GetPlayerClass(classid, &teamid, &modelid, &Float:spawn_x, &Float:spawn_y, &Float:spawn_z, &Float:z_angle, &weapon1, &weapon1_ammo, &weapon2, &weapon2_ammo,& weapon3, &weapon3_ammo);
-static cell AMX_NATIVE_CALL Natives::GetPlayerClass(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(13, "GetPlayerClass");
-
-	int classid = static_cast<int>(params[1]);
-	if(classid < 0 || classid > pNetGame->iSpawnsAvailable) return 0;
-
-	CPlayerSpawnInfo *pSpawn = &pNetGame->AvailableSpawns[classid];
-	
-	cell *cptr;
-	amx_GetAddr(amx, params[2], &cptr); *cptr = (cell)pSpawn->byteTeam;
-	amx_GetAddr(amx, params[3], &cptr); *cptr = (cell)pSpawn->iSkin;
-	amx_GetAddr(amx, params[4], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fX);
-	amx_GetAddr(amx, params[5], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fY);
-	amx_GetAddr(amx, params[6], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fZ);
-	amx_GetAddr(amx, params[7], &cptr); *cptr = amx_ftoc(pSpawn->fRotation);
-	amx_GetAddr(amx, params[8], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[0];
-	amx_GetAddr(amx, params[9], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[0];
-	amx_GetAddr(amx, params[10], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[1];
-	amx_GetAddr(amx, params[11], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[1];
-	amx_GetAddr(amx, params[12], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[2];
-	amx_GetAddr(amx, params[13], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[2];
-	return 1;
-}
-
-// native EditPlayerClass(classid, teamid, modelid, Float:spawn_x, Float:spawn_y, Float:spawn_z, Float:z_angle, weapon1, weapon1_ammo, weapon2, weapon2_ammo, weapon3, weapon3_ammo);
-static cell AMX_NATIVE_CALL Natives::EditPlayerClass(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(13, "EditPlayerClass");
-
-	int classid = static_cast<int>(params[1]);
-	if(classid < 0 || classid > pNetGame->iSpawnsAvailable) return 0;
-
-	CPlayerSpawnInfo *pSpawn = &pNetGame->AvailableSpawns[classid];
-
-	pSpawn->byteTeam = static_cast<BYTE>(params[2]);
-	pSpawn->iSkin = static_cast<int>(params[3]);
-	pSpawn->vecPos = CVector(amx_ctof(params[4]), amx_ctof(params[5]), amx_ctof(params[6]));
-	pSpawn->fRotation = amx_ctof(params[7]);
-	pSpawn->iSpawnWeapons[0] = static_cast<int>(params[8]);
-	pSpawn->iSpawnWeaponsAmmo[0] = static_cast<int>(params[9]);
-	pSpawn->iSpawnWeapons[1] = static_cast<int>(params[10]);
-	pSpawn->iSpawnWeaponsAmmo[1] = static_cast<int>(params[11]);
-	pSpawn->iSpawnWeapons[2] = static_cast<int>(params[12]);
-	pSpawn->iSpawnWeaponsAmmo[2] = static_cast<int>(params[13]);
-	return 1;
-}
-
-// native GetActiveTimers();
-static cell AMX_NATIVE_CALL Natives::GetRunningTimers(AMX *amx, cell *params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	return pNetGame->pScriptTimers->dwTimerCount;
-}
-
-// native SetGravity(Float:gravity);
-static cell AMX_NATIVE_CALL Natives::YSF_SetGravity( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "SetGravity");
-
-	pServer->SetGravity_(amx_ctof(params[1]));
-	return 1;
-}
-
-// native Float:GetGravity();
-static cell AMX_NATIVE_CALL Natives::YSF_GetGravity( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	float fGravity = pServer->GetGravity_();
-	return amx_ftoc(fGravity);
-}
-
-// native SetPlayerGravity(playerid, Float:gravity);
-static cell AMX_NATIVE_CALL Natives::SetPlayerGravity( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetPlayerGravity");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	// Update stored values
-	pPlayerData[playerid]->fGravity = amx_ctof(params[2]);
-
-	RakNet::BitStream bs;
-	bs.Write(pPlayerData[playerid]->fGravity);
-	pRakServer->RPC(&RPC_Gravity, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), 0, 0);
-	return 1;
-}
-
-// native Float:GetPlayerGravity(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerGravity( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerGravity");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return amx_ftoc(pPlayerData[playerid]->fGravity);
-}
-
-// native SetPlayerTeamForPlayer(playerid, teamplayerid, teamid);
-static cell AMX_NATIVE_CALL Natives::SetPlayerTeamForPlayer( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "SetPlayerTeamForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int teamplayerid = static_cast<int>(params[2]);
-	int team = static_cast<int>(params[3]);
-
-	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(teamplayerid)) return 0;
-	if (team < 0 || team > 255) return 0;
-
-	pPlayerData[playerid]->SetPlayerTeamForPlayer(static_cast<WORD>(teamplayerid), team);
-	return 1;
-}
-
-// native GetPlayerTeamForPlayer(playerid, teamplayerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerTeamForPlayer( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "GetPlayerTeamForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int teamplayerid = static_cast<int>(params[2]);
-
-	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(teamplayerid)) return 0;
-
-	return pPlayerData[playerid]->GetPlayerTeamForPlayer(static_cast<WORD>(teamplayerid));
-}
-
-static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerTeam(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetPlayerTeam");
-
-	int playerid = static_cast<int>(params[1]);
-	if(pSetPlayerTeam(amx, params))
-	{
-		for(WORD i = 0; i != MAX_PLAYERS; i++)
-		{
-			if(IsPlayerConnectedEx(i))
-				pPlayerData[i]->ResetPlayerTeam(static_cast<WORD>(playerid));
-		}
-		return 1;
-	}
-	return 0;
-}
-
-// native SetPlayerSkinForPlayer(playerid, skinplayerid, skin);
-static cell AMX_NATIVE_CALL Natives::SetPlayerSkinForPlayer(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "SetPlayerSkinForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int skinplayerid = static_cast<int>(params[2]);
-	int skin = static_cast<int>(params[3]);
-
-	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(skinplayerid)) return 0;
-	if (skin < 0 || skin > 300) return 0;
-
-	pPlayerData[playerid]->SetPlayerSkinForPlayer(static_cast<WORD>(skinplayerid), skin);
-	return 1;
-}
-
-// native GetPlayerSkinForPlayer(playerid, skinplayerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerSkinForPlayer(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "GetPlayerSkinForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int skinplayerid = static_cast<int>(params[2]);
-
-	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(skinplayerid)) return 0;
-
-	return pPlayerData[playerid]->GetPlayerSkinForPlayer(static_cast<WORD>(skinplayerid));
-}
-
-static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerSkin(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetPlayerSkin");
-
-	int playerid = static_cast<int>(params[1]);
-	if(pSetPlayerSkin(amx, params))
-	{
-		for(WORD i = 0; i != MAX_PLAYERS; i++)
-		{
-			if(IsPlayerConnectedEx(i))
-				pPlayerData[i]->ResetPlayerSkin(static_cast<WORD>(playerid));
-		}
-		return 1;
-	}
-	return 0;
-}
-
-// native SetPlayerNameForPlayer(playerid, nameplayerid, playername[]);
-static cell AMX_NATIVE_CALL Natives::SetPlayerNameForPlayer(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "SetPlayerNameForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int nameplayerid = static_cast<int>(params[2]);
-	char *name = NULL;
-
-	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(nameplayerid)) return 0;
-
-	amx_StrParam(amx, params[3], name);
-	logprintf("playername: %s", name);
-
-	pPlayerData[playerid]->SetPlayerNameForPlayer(static_cast<WORD>(nameplayerid), name);
-	return 1;
-}
-
-// native GetPlayerNameForPlayer(playerid, nameplayerid, playername[], size = sizeof(playername));
-static cell AMX_NATIVE_CALL Natives::GetPlayerNameForPlayer(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(4, "GetPlayerNameForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int nameplayerid = static_cast<int>(params[2]);
-
-	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(nameplayerid)) return 0;
-
-	return set_amxstring(amx, params[3], pPlayerData[playerid]->GetPlayerNameForPlayer(static_cast<WORD>(nameplayerid)), params[4]);
-}
-
-static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerName(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetPlayerName");
-
-	int playerid = static_cast<int>(params[1]);
-	int ret = pSetPlayerName(amx, params);
-
-	if(ret == 1)
-	{
-		for(WORD i = 0; i != MAX_PLAYERS; i++)
-		{
-			if(IsPlayerConnectedEx(i))
-				pPlayerData[i]->ResetPlayerName(static_cast<WORD>(playerid));
-		}
-	}
-	return ret;
-}
-
-// native SetPlayerFightStyleForPlayer(playerid, styleplayerid, style);
-static cell AMX_NATIVE_CALL Natives::SetPlayerFightStyleForPlayer(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "SetPlayerFightStyleForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int styleplayerid = static_cast<int>(params[2]);
-	int style = static_cast<int>(params[3]);
-
-	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(styleplayerid)) return 0;
-
-	pPlayerData[playerid]->SetPlayerFightingStyleForPlayer(static_cast<WORD>(styleplayerid), style);
-	return 1;
-}
-
-// native GetPlayerFightStyleForPlayer(playerid, skinplayerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerFightStyleForPlayer(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "GetPlayerFightStyleForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int styleplayerid = static_cast<int>(params[2]);
-
-	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(styleplayerid)) return 0;
-
-	return pPlayerData[playerid]->GetPlayerFightingStyleForPlayer(static_cast<WORD>(styleplayerid));
-}
-
-static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerFightingStyle(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetPlayerFightingStyle");
-
-	int playerid = static_cast<int>(params[1]);
-	if(pSetPlayerFightingStyle(amx, params))
-	{
-		for(WORD i = 0; i != MAX_PLAYERS; i++)
-		{
-			if(IsPlayerConnectedEx(i))
-				pPlayerData[i]->ResetPlayerFightingStyle(static_cast<WORD>(playerid));
-		}
-		return 1;
-	}
-	return 0;
-}
-
-// native SetPlayerPosForPlayer(playerid, posplayerid, Float:fX, Float:fY, Float:fZ, bool:forcesync = true);
-static cell AMX_NATIVE_CALL Natives::SetPlayerPosForPlayer(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 5;
-
-	CHECK_PARAMS(6, "SetPlayerPosForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int posplayerid = static_cast<int>(params[2]);
-	bool forcesync = static_cast<int>(params[6]) != 0;
-	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(posplayerid)) return 0;
-
-	SAFE_DELETE(pPlayerData[playerid]->vecCustomPos[posplayerid]);
-
-	if(!forcesync)
-	{
-		pPlayerData[playerid]->bCustomPos[posplayerid] = false;
-		return 1;
-	}
-
-	CVector vecPos = CVector(amx_ctof(params[3]), amx_ctof(params[4]), amx_ctof(params[5]));
-		
-	pPlayerData[playerid]->vecCustomPos[posplayerid] = new CVector;
-	pPlayerData[playerid]->bCustomPos[posplayerid] = true;
-
-	memcpy(pPlayerData[playerid]->vecCustomPos[posplayerid], &vecPos, sizeof(CVector));
-	/*
-	RakNet::BitStream bs;
-	bs.Write(ID_PLAYER_SYNC);
-	bs.Write((WORD)posplayerid);
-	RebuildSyncData(&bs, playerid);
-	pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false);
-	*/
-	return 1;
-}
-
-// native SetPlayerRotationQuatForPlayer(playerid, quatplayerid, Float:w, Float:x, Float:y, Float:z, bool:forcesync = true);
-static cell AMX_NATIVE_CALL Natives::SetPlayerRotationQuatForPlayer(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 5;
-
-	CHECK_PARAMS(7, "SetPlayerRotationQuatForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int posplayerid = static_cast<int>(params[2]);
-	bool forcesync = static_cast<int>(params[4]) != 0;
-	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(posplayerid)) return 0;
-
-	if(!forcesync)
-	{
-		pPlayerData[playerid]->bCustomQuat[posplayerid] = false;
-		return 1;
-	}
-	
-	CPlayer *p = pNetGame->pPlayerPool->pPlayer[playerid];
-
-	pPlayerData[playerid]->fCustomQuat[posplayerid][0] = amx_ctof(params[3]);
-	pPlayerData[playerid]->fCustomQuat[posplayerid][1] = amx_ctof(params[4]);
-	pPlayerData[playerid]->fCustomQuat[posplayerid][2] = amx_ctof(params[5]);
-	pPlayerData[playerid]->fCustomQuat[posplayerid][3] = amx_ctof(params[6]);
-
-	pPlayerData[playerid]->bCustomQuat[posplayerid] = true;
-
-	RakNet::BitStream bs;
-	bs.Write((BYTE)ID_PLAYER_SYNC);
-	bs.Write((WORD)posplayerid);
-	bs.Write((bool)0); // bHasLR
-	bs.Write((bool)0); // bHasUD
-	bs.Write(p->syncData.wKeys); // bHasUD
-	
-	if(pPlayerData[playerid]->bCustomPos[posplayerid])
-		bs.Write(*pPlayerData[playerid]->vecCustomPos[posplayerid]);
-	else 
-		bs.Write(p->vecPosition);
-
-	bs.Write(pPlayerData[playerid]->fCustomQuat[posplayerid][0]);
-	bs.Write(pPlayerData[playerid]->fCustomQuat[posplayerid][1]);
-	bs.Write(pPlayerData[playerid]->fCustomQuat[posplayerid][2]);
-	bs.Write(pPlayerData[playerid]->fCustomQuat[posplayerid][3]);
-
-	pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false);
-	return 1;
-}
-
-// native ApplyAnimationForPlayer(playerid, animplayerid, animlib[], animname[], Float:fDelta, loop, lockx, locky, freeze, time);
-static cell AMX_NATIVE_CALL Natives::ApplyAnimationForPlayer(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(10, "ApplyAnimationForPlayer");
-	RakNet::BitStream bsSend;
-
-	char *szAnimLib;
-	char *szAnimName;
-	BYTE byteAnimLibLen;
-	BYTE byteAnimNameLen;
-	float fS;
-	bool opt1,opt2,opt3,opt4;
-	int time;
-	
-	int playerid = static_cast<int>(params[1]);
-	int animplayerid = static_cast<int>(params[2]);
-	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(animplayerid)) return 0;
-
-	amx_StrParam(amx, params[3], szAnimLib);
-	amx_StrParam(amx, params[4], szAnimName);
-
-	if(!szAnimLib || !szAnimName) return 0;
-
-	byteAnimLibLen = static_cast<BYTE>(strlen(szAnimLib));
-	byteAnimNameLen = static_cast<BYTE>(strlen(szAnimName));
-
-	fS = amx_ctof(params[5]);
-	opt1 = !!params[6];
-	opt2 = !!params[7];
-	opt3 = !!params[8];
-	opt4 = !!params[9];
-	time = static_cast<int>(params[10]);
-
-	bsSend.Write((WORD)animplayerid);
-	bsSend.Write(byteAnimLibLen);
-	bsSend.Write(szAnimLib,byteAnimLibLen);
-	bsSend.Write(byteAnimNameLen);
-	bsSend.Write(szAnimName,byteAnimNameLen);
-	bsSend.Write(fS);
-	bsSend.Write(opt1);
-	bsSend.Write(opt2);
-	bsSend.Write(opt3);
-	bsSend.Write(opt4);
-	bsSend.Write(time);
-
-	pRakServer->RPC(&RPC_ScrApplyAnimation, &bsSend, MEDIUM_PRIORITY, UNRELIABLE, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
-	return 1;
-}
-
-// native SetWeather(weatherid);
-static cell AMX_NATIVE_CALL Natives::YSF_SetWeather( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "SetWeather");
-
-	pServer->SetWeather_(static_cast<BYTE>(params[1]));
-	return 1;
-}
-
-// native SetPlayerWeather(playerid, weatherid);
-static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerWeather(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetPlayerWeather");
-
-	int playerid = static_cast<int>(params[1]);
-	if (!IsPlayerConnectedEx(playerid)) return 0;
-
-	// Update stored values
-	pPlayerData[playerid]->byteWeather = static_cast<BYTE>(params[2]);
-
-	RakNet::BitStream bs;
-	bs.Write(pPlayerData[playerid]->byteWeather);
-	pRakServer->RPC(&RPC_Weather, &bs, MEDIUM_PRIORITY, RELIABLE, 0, pRakServer->GetPlayerIDFromIndex(playerid), 0, 0);
-	return 1;
-}
-
-// native GetPlayerWeather(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerWeather( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerWeather");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pPlayerData[playerid]->byteWeather;
-}
-
-// native SetPlayerWorldBounds(playerid, Float:x_max, Float:x_min, Float:y_max, Float:y_min)
-static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerWorldBounds(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(5, "SetPlayerWorldBounds");
-
-	int playerid = static_cast<int>(params[1]);
-
-	if(pSetPlayerWorldBounds(amx, params) && IsPlayerConnectedEx(playerid))
-	{
-		pPlayerData[playerid]->fBounds[0] = amx_ctof(params[2]);
-		pPlayerData[playerid]->fBounds[1] = amx_ctof(params[3]);
-		pPlayerData[playerid]->fBounds[2] = amx_ctof(params[4]);
-		pPlayerData[playerid]->fBounds[3] = amx_ctof(params[5]);
-	}
-	return 1;
-}
-
-// native DestroyObject(objectid)
-static cell AMX_NATIVE_CALL Natives::YSF_DestroyObject(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "DestroyObject");
-
-	int objectid = static_cast<int>(params[1]);
-
-	if(objectid < 0 || objectid > MAX_OBJECTS) return 0;
-	if(!pNetGame->pObjectPool->pObjects[objectid]) return 0;
-
-	if(pDestroyObject(amx, params))
-	{
-		pServer->COBJECT_AttachedObjectPlayer[objectid] = INVALID_PLAYER_ID;
-		return 1;
-	}
-	return 0;
-}
-
-// native DestroyPlayerObject(playerid, objectid)
-static cell AMX_NATIVE_CALL Natives::YSF_DestroyPlayerObject(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "DestroyPlayerObject");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-
-	if(objectid < 0 || objectid > MAX_OBJECTS) return 0;
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-
-	if(pDestroyPlayerObject(amx, params) && IsPlayerConnectedEx(playerid))
-	{
-		if(pPlayerData[playerid]->stObj[objectid].wObjectID != 0xFFFF || pPlayerData[playerid]->stObj[objectid].wAttachPlayerID != INVALID_PLAYER_ID)
-		{
-			pPlayerData[playerid]->stObj[objectid].wObjectID = INVALID_OBJECT_ID;
-			pPlayerData[playerid]->stObj[objectid].wAttachPlayerID = INVALID_PLAYER_ID;
-			pPlayerData[playerid]->stObj[objectid].vecOffset = CVector(0.0f, 0.0f, 0.0f);
-			pPlayerData[playerid]->stObj[objectid].vecRot = CVector(0.0f, 0.0f, 0.0f);		
-			pPlayerData[playerid]->dwCreateAttachedObj = 0;
-			pPlayerData[playerid]-> bAttachedObjectCreated = false;
-
-			//logprintf("remove attached shit");
-		}
-		return 1;
-	}
-	return 0;
-}
-
-// native TogglePlayerControllable(playerid, bool:toggle)
-static cell AMX_NATIVE_CALL Natives::YSF_TogglePlayerControllable(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "TogglePlayerControllable");
-
-	int playerid = static_cast<int>(params[1]);
-	bool toggle = static_cast<int>(params[2]) != 0;
-
-	if(pTogglePlayerControllable(amx, params) && IsPlayerConnectedEx(playerid))
-	{
-		pPlayerData[playerid]->bControllable = toggle;
-		return 1;
-	}
-	return 0;
-}
-
-// native ChangeVehicleColor(vehicleid, color1, color2)
-static cell AMX_NATIVE_CALL Natives::YSF_ChangeVehicleColor(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(pChangeVehicleColor(amx, params))
-	{
-		pServer->bChangedVehicleColor[vehicleid] = true;
-		return 1;
-	}
-	return 0;
-}
-
-static cell AMX_NATIVE_CALL Natives::YSF_DestroyVehicle(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(pDestroyVehicle(amx, params))
-	{
-		pServer->bChangedVehicleColor[vehicleid] = false;
-		return 1;
-	}
-	return 0;
-}
-
-// native TogglePlayerWidescreen(playerid, bool:set);
-static cell AMX_NATIVE_CALL Natives::TogglePlayerWidescreen( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "TogglePlayerWidescreen");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	BYTE set = static_cast<BYTE>(params[2]) != 0;
-	pPlayerData[playerid]->bWidescreen = !!set;
-
-	RakNet::BitStream bs;
-	bs.Write(set);
-	pRakServer->RPC(&RPC_Widescreen, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), 0, 0);
-	return 1;
-}
-
-// native IsPlayerWidescreenToggled(playerid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerWidescreenToggled( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsPlayerWideScreen");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pPlayerData[playerid]->bWidescreen;
-}
-
-// native GetSpawnInfo(playerid, &teamid, &modelid, &Float:spawn_x, &Float:spawn_y, &Float:spawn_z, &Float:z_angle, &weapon1, &weapon1_ammo, &weapon2, &weapon2_ammo,& weapon3, &weapon3_ammo);
-static cell AMX_NATIVE_CALL Natives::GetSpawnInfo( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(13, "GetSpawnInfo");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	CPlayerSpawnInfo *pSpawn = &pNetGame->pPlayerPool->pPlayer[playerid]->spawn;
-
-	cell *cptr;
-	amx_GetAddr(amx, params[2], &cptr); *cptr = (cell)pSpawn->byteTeam;
-	amx_GetAddr(amx, params[3], &cptr); *cptr = (cell)pSpawn->iSkin;
-	amx_GetAddr(amx, params[4], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fX);
-	amx_GetAddr(amx, params[5], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fY);
-	amx_GetAddr(amx, params[6], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fZ);
-	amx_GetAddr(amx, params[7], &cptr); *cptr = amx_ftoc(pSpawn->fRotation);
-	amx_GetAddr(amx, params[8], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[0];
-	amx_GetAddr(amx, params[9], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[0];
-	amx_GetAddr(amx, params[10], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[1];
-	amx_GetAddr(amx, params[11], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[1];
-	amx_GetAddr(amx, params[12], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[2];
-	amx_GetAddr(amx, params[13], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[2];
-	return 1;
-}
-
-// native GetPlayerSkillLevel(playerid, skill);
-static cell AMX_NATIVE_CALL Natives::GetPlayerSkillLevel( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "GetPlayerSkillLevel");
-
-	int playerid = static_cast<int>(params[1]);
-	int skillid = static_cast<int>(params[2]);
-	
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(skillid < 0 || skillid > 10) return -1;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->wSkillLevel[skillid];
-}
-
-// native IsPlayerCheckpointActive(playerid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerCheckpointActive(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsPlayerCheckpointActive");
-
-	int playerid = static_cast<int>(params[1]);
-	if (!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->bShowCheckpoint;
-}
-
-// native GetPlayerCheckpoint(playerid, &Float:fX, &Float:fY, &Float:fZ, &Float:fSize);
-static cell AMX_NATIVE_CALL Natives::GetPlayerCheckpoint( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(5, "GetPlayerCheckpoint");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	cell* cptr;
-	CVector *vecPos = &pNetGame->pPlayerPool->pPlayer[playerid]->vecCPPos;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(vecPos->fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(vecPos->fY);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(vecPos->fZ);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(pNetGame->pPlayerPool->pPlayer[playerid]->fCPSize);
-	return 1;
-}
-
-// native IsPlayerRaceCheckpointActive(playerid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerRaceCheckpointActive(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsPlayerRaceCheckpointActive");
-
-	int playerid = static_cast<int>(params[1]);
-	if (!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->bShowRaceCheckpoint;
-}
-
-// native GetPlayerRaceCheckpoint(playerid, &Float:fX, &Float:fY, &Float:fZ, &Float:fNextX, &Float:fNextY, &fNextZ, &Float:fSize);
-static cell AMX_NATIVE_CALL Natives::GetPlayerRaceCheckpoint( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(8, "GetPlayerRaceCheckpoint");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	cell* cptr;
-	CVector *vecPos = &pNetGame->pPlayerPool->pPlayer[playerid]->vecRaceCPPos;
-	CVector *vecNextPos = &pNetGame->pPlayerPool->pPlayer[playerid]->vecRaceCPNextPos;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(vecPos->fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(vecPos->fY);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(vecPos->fZ);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(vecNextPos->fX);
-	amx_GetAddr(amx, params[6], &cptr);
-	*cptr = amx_ftoc(vecNextPos->fY);
-	amx_GetAddr(amx, params[7], &cptr);
-	*cptr = amx_ftoc(vecNextPos->fZ);
-	amx_GetAddr(amx, params[8], &cptr);
-	*cptr = amx_ftoc(pNetGame->pPlayerPool->pPlayer[playerid]->fRaceCPSize);
-	return 1;
-}
-
-// native GetPlayerWorldBounds(playerid, &Float:x_max, &Float:x_min, &Float:y_max, &Float:y_min);
-static cell AMX_NATIVE_CALL Natives::GetPlayerWorldBounds( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(5, "GetPlayerWorldBounds");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	cell* cptr;
-	float *fBounds = pPlayerData[playerid]->fBounds;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(fBounds[0]);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(fBounds[1]);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(fBounds[2]);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(fBounds[3]);
-	return 1;
-}
-
-// native IsPlayerInModShop(playerid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerInModShop( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsPlayerInModShop");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->bIsInModShop;
-}
-
-// native GetPlayerSirenState(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerSirenState( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerSirenState");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->wVehicleId) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->vehicleSyncData.byteSirenState;
-}
-
-// native GetPlayerLandingGearState(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerLandingGearState( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerLandingGearState");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->wVehicleId) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->vehicleSyncData.byteGearState;
-}
-
-// native GetPlayerHydraReactorAngle(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerHydraReactorAngle( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerHydraReactorAngle");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->wVehicleId) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->vehicleSyncData.wHydraReactorAngle[0];
-}
-
-// native Float:GetPlayerTrainSpeed(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerTrainSpeed( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerTrainSpeed");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->wVehicleId) return 0;
-
-	return amx_ftoc(pNetGame->pPlayerPool->pPlayer[playerid]->vehicleSyncData.fTrainSpeed);
-}
-
-// native Float:GetPlayerZAim(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerZAim( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerZAim");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return amx_ftoc(pNetGame->pPlayerPool->pPlayer[playerid]->aimSyncData.fZAim);
-}
-
-// native GetPlayerSurfingOffsets(playerid, &Float:fOffsetX, &Float:fOffsetY, &Float:fOffsetZ);
-static cell AMX_NATIVE_CALL Natives::GetPlayerSurfingOffsets( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(4, "GetPlayerSurfingOffsets");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	CVector vecPos = pNetGame->pPlayerPool->pPlayer[playerid]->syncData.vecSurfing;
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(vecPos.fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(vecPos.fY);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(vecPos.fZ);
-	return 1;
-}
-
-// native GetPlayerRotationQuat(playerid, &Float:w, &Float:x, &Float:y, &Float:z);
-static cell AMX_NATIVE_CALL Natives::GetPlayerRotationQuat( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(5, "GetPlayerRotationQuat");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	CPlayer *pPlayer = pNetGame->pPlayerPool->pPlayer[playerid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pPlayer->fQuaternion[0]);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pPlayer->fQuaternion[1]);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pPlayer->fQuaternion[2]);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(pPlayer->fQuaternion[3]);
-	return 1;
-}
-
-// native GetPlayerDialogID(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerDialogID( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerDialogID");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->wDialogID;
-}
-
-// native GetPlayerSpectateID(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerSpectateID( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerSpectateID");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->wSpectateID;
-}
-
-// native GetPlayerSpectateType(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerSpectateType( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerSpectateType");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->byteSpectateType;
-}
-
-// native GetPlayerLastSyncedVehicleID(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerLastSyncedVehicleID(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerLastSyncedVehicleID");
-
-	int playerid = static_cast<int>(params[1]);
-	if (!IsPlayerConnectedEx(playerid)) return 0;
-
-	return (cell)pNetGame->pPlayerPool->pPlayer[playerid]->vehicleSyncData.wVehicleId;
-}
-
-// native GetPlayerLastSyncedTrailerID(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerLastSyncedTrailerID(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerLastSyncedTrailerID");
-
-	int playerid = static_cast<int>(params[1]);
-	if (!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->trailerSyncData.wTrailerID;  //* (WORD*)(((char*)pNetGame->pPlayerPool->pPlayer[playerid]) + 271);
-}
-
-// native GetPlayerFPS(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerFPS(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerFPS");
-
-	// TODO
-	return 1;
-}
-
-// native GetActorSpawnInfo(actorid, &skinid, &Float:fX, &Float:fY, &Float:fZ, &Float:fAngle);
-static cell AMX_NATIVE_CALL Natives::GetActorSpawnInfo(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(6, "GetActorSpawnInfo");
-
-	int actorid = static_cast<int>(params[1]);
-	if(actorid < 0 || actorid > MAX_PLAYERS) return 0;
-
-	CActor *pActor = pNetGame->pActorPool->pActor[actorid];
-	if(!pActor) return 0;
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = (cell)pActor->iSkinID;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pActor->vecSpawnPos.fX);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pActor->vecSpawnPos.fY);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(pActor->vecSpawnPos.fZ);
-	amx_GetAddr(amx, params[6], &cptr);
-	*cptr = amx_ftoc(pActor->fSpawnAngle);
-	return 1;
-}
-
-// native GetActorSkin(actorid);
-static cell AMX_NATIVE_CALL Natives::GetActorSkin(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetActorSkin");
-
-	int actorid = static_cast<int>(params[1]);
-	if(actorid < 0 || actorid > MAX_PLAYERS) return 0;
-
-	CActor *pActor = pNetGame->pActorPool->pActor[actorid];
-	if(!pActor) return 0;
-
-	return pActor->iSkinID;
-}
-
-
-// native GetActorAnimation(actorid, animlib[], animlibsize = sizeof(animlib), animname[], animnamesize = sizeof(animname), &Float:fDelta, &loop, &lockx, &locky, &freeze, &time)
-static cell AMX_NATIVE_CALL Natives::GetActorAnimation(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(11, "GetActorAnimation");
-
-	int actorid = static_cast<int>(params[1]);
-	if(actorid < 0 || actorid > MAX_PLAYERS) return 0;
-
-	CActor *pActor = pNetGame->pActorPool->pActor[actorid];
-	if(!pActor) return 0;
-
-	set_amxstring(amx, params[2], pActor->anim.szAnimLib, params[3]);
-	set_amxstring(amx, params[4], pActor->anim.szAnimName, params[5]);
-
-	cell* cptr;
-	amx_GetAddr(amx, params[6], &cptr);
-	*cptr = amx_ftoc(pActor->anim.fDelta);
-	amx_GetAddr(amx, params[7], &cptr);
-	*cptr = *(cell*)pActor->anim.byteLoop;
-	amx_GetAddr(amx, params[8], &cptr);
-	*cptr = *(cell*)pActor->anim.byteLockX;
-	amx_GetAddr(amx, params[9], &cptr);
-	*cptr = *(cell*)pActor->anim.byteLockY;
-	amx_GetAddr(amx, params[10], &cptr);
-	*cptr = *(cell*)pActor->anim.byteFreeze;
-	amx_GetAddr(amx, params[11], &cptr);
-	*cptr = *(cell*)pActor->anim.iTime;
-	return 1;
-}
-
-// native SendBulletData(sender, hitid, hittype, weaponid, Float:fHitOriginX, Float:fHitOriginY, Float:fHitOriginZ, Float:fHitTargetX, Float:fHitTargetY, Float:fHitTargetZ, Float:fCenterOfHitX, Float:fCenterOfHitY, Float:fCenterOfHitZ, forplayerid = -1);
-static cell AMX_NATIVE_CALL Natives::SendBulletData( AMX* amx, cell* params ) 
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(14, "SendBulletData");
-
-	int playerid = static_cast<int>(params[1]);
-	int forplayerid = static_cast<int>(params[14]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(forplayerid != -1)
-	{
-		if(!IsPlayerConnectedEx(forplayerid)) return 0;
-	}
-
-	CBulletSyncData bulletSync;
-	bulletSync.byteHitType = static_cast<BYTE>(params[3]);
-	bulletSync.wHitID = static_cast<WORD>(params[2]);
-	bulletSync.byteWeaponID = static_cast<BYTE>(params[4]);
-	bulletSync.vecHitOrigin = CVector(amx_ctof(params[5]), amx_ctof(params[6]), amx_ctof(params[7]));
-	bulletSync.vecHitTarget = CVector(amx_ctof(params[8]), amx_ctof(params[9]), amx_ctof(params[10]));
-	bulletSync.vecCenterOfHit = CVector(amx_ctof(params[11]), amx_ctof(params[12]), amx_ctof(params[13]));
-
-	RakNet::BitStream bs;
-	bs.Write((BYTE)ID_BULLET_SYNC);
-	bs.Write((WORD)playerid);
-	bs.Write((char*)&bulletSync, sizeof(CBulletSyncData));
-
-	if(forplayerid == -1)
-	{
-		pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true);
-	}
-	else
-	{
-		pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), false);
-	}
-	return 1;
-}
-
-// native ShowPlayerForPlayer(forplayerid, playerid);
-static cell AMX_NATIVE_CALL Natives::ShowPlayerForPlayer( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "ShowPlayerForPlayer");
-
-	int forplayerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(forplayerid)) return 0;
-
-	int playerid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(playerid == forplayerid) return 0;
-
-	RakNet::BitStream bs;
-	bs.Write((WORD)playerid);
-	pRakServer->RPC(&RPC_WorldPlayerAdd, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0);
-	return 1;
-}
-
-// native HidePlayerForPlayer(forplayerid, playerid);
-static cell AMX_NATIVE_CALL Natives::HidePlayerForPlayer( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "HidePlayerForPlayer");
-
-	int forplayerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(forplayerid)) return 0;
-
-	int playerid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(playerid == forplayerid) return 0;
-
-	RakNet::BitStream bs;
-	bs.Write((WORD)playerid);
-	pRakServer->RPC(&RPC_WorldPlayerRemove, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0);
-	return 1;
-}
-
-// native AddPlayerForPlayer(forplayerid, playerid, isnpc = 0);
-static cell AMX_NATIVE_CALL Natives::AddPlayerForPlayer( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "AddPlayerForPlayer");
-
-	int forplayerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(forplayerid)) return 0;
-
-	int playerid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(playerid == forplayerid) return 0;
-
-	bool npc = static_cast<int>(params[3]) != 0;
-	char* szName = GetPlayerName_(playerid);
-	BYTE len = static_cast<BYTE>(strlen(szName));
-
-	RakNet::BitStream bs;
-	bs.Write((WORD)playerid);
-	bs.Write((DWORD)0);
-	bs.Write((BYTE)npc); //  // isNPC
-	bs.Write(len);
-	bs.Write(szName, len);
-	pRakServer->RPC(&RPC_ServerJoin, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0);
-	return 1;
-}
-
-// native RemovePlayerForPlayer(forplayerid, playerid);
-static cell AMX_NATIVE_CALL Natives::RemovePlayerForPlayer( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "RemovePlayerForPlayer");
-
-	int forplayerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(forplayerid)) return 0;
-
-	int playerid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(playerid == forplayerid) return 0;
-
-	RakNet::BitStream bs;
-	bs.Write((WORD)playerid);
-	bs.Write((BYTE)0); 
-	pRakServer->RPC(&RPC_ServerQuit, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0);
-	return 1;
-}
-
-// native SetPlayerChatBubbleForPlayer(forplayerid, playerid, text[], color, Float:drawdistance, expiretime);
-static cell AMX_NATIVE_CALL Natives::SetPlayerChatBubbleForPlayer( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(6, "SetPlayerChatBubbleForPlayer");
-
-	int forplayerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(forplayerid)) return 0;
-
-	int playerid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	int color = static_cast<int>(params[4]);
-	float drawdistance = amx_ctof(params[5]);
-	int expiretime = static_cast<int>(params[6]);
-
-	char *str;
-	amx_StrParam(amx, params[3], str);
-	if(str)
-	{
-		BYTE len = static_cast<BYTE>(strlen(str));
-		RakNet::BitStream bs;
-		bs.Write((WORD)playerid);
-		bs.Write(color);
-		bs.Write(drawdistance);
-		bs.Write(expiretime);
-		bs.Write(len);
-		bs.Write(str, len);
-		pRakServer->RPC(&RPC_ChatBubble, &bs, LOW_PRIORITY, RELIABLE, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0);
-		return 1;
-	}
-	return 0;
-}
-
-// native SetPlayerVersion(playerid, version[];
-static cell AMX_NATIVE_CALL Natives::SetPlayerVersion( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetPlayerVersion");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	
-	char *version;
-	amx_StrParam(amx, params[2], version);
-
-	if (version && strlen(version) < 28)
-	{
-		pNetGame->pPlayerPool->szVersion[playerid][0] = NULL;
-		strcpy(pNetGame->pPlayerPool->szVersion[playerid], version);
-		return 1;
-	}
-	return 0;
-}
-
-// native IsPlayerSpawned(playerid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerSpawned( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsPlayerSpawned");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	int state = pNetGame->pPlayerPool->pPlayer[playerid]->byteState;
-	return (state != PLAYER_STATE_NONE && state != PLAYER_STATE_WASTED && state != PLAYER_STATE_SPAWNED && pNetGame->pPlayerPool->pPlayer[playerid]->bHasSpawnInfo);
-}
-
-// native IsPlayerControllable(playerid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerControllable( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsPlayerSpawned");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pPlayerData[playerid]->bControllable;
-}
-
-// native SpawnForWorld(playerid);
-static cell AMX_NATIVE_CALL Natives::SpawnForWorld(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "SpawnForWorld");
-
-	int playerid = static_cast<int>(params[1]);
-	if (!IsPlayerConnectedEx(playerid)) return 0;
-
-	CSAMPFunctions::SpawnPlayer_(playerid);
-	return 1;
-}
-
-// native BroadcastDeath(playerid);
-static cell AMX_NATIVE_CALL Natives::BroadcastDeath(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "BroadcastDeath");
-
-	int playerid = static_cast<int>(params[1]);
-	if (!IsPlayerConnectedEx(playerid)) return 0;
-
-	RakNet::BitStream bsData;
-	bsData.Write((WORD)playerid);
-	pRakServer->RPC(&RPC_DeathBroadcast, &bsData, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), true, false);
-	return 1;
-}
-
-// native IsPlayerCameraTargetEnabled(playerid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerCameraTargetEnabled( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsPlayerCameraTargetEnabled");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->bCameraTarget;
-}
-
-// native SetPlayerDisabledKeysSync(playerid, keys);
-static cell AMX_NATIVE_CALL Natives::SetPlayerDisabledKeysSync( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetPlayerDisabledKeySync");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	pPlayerData[playerid]->dwDisabledKeys = static_cast<WORD>(params[2]);
-	return 1;
-}
-
-// native GetPlayerDisabledKeysSync(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerDisabledKeysSync( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "SetPlayerDisabledKeySync");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pPlayerData[playerid]->dwDisabledKeys;
-}
-
-// Scoreboard manipulation
-// native TogglePlayerScoresPingsUpdate(playerid, bool:toggle);
-static cell AMX_NATIVE_CALL Natives::TogglePlayerScoresPingsUpdate(AMX *amx, cell *params)
-{
-	if(!pServer) return 0;
-
-	CHECK_PARAMS(2, "TogglePlayerScoresPingsUpdate");
-
-	int playerid = static_cast<int>(params[1]);
-	bool toggle = static_cast<int>(params[2]) != 0;
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	pPlayerData[playerid]->bUpdateScoresPingsDisabled = !toggle;
-	return 1;
-}
-
-// native TogglePlayerFakePing(playerid, bool:toggle);
-static cell AMX_NATIVE_CALL Natives::TogglePlayerFakePing(AMX *amx, cell *params)
-{
-	if(!pServer) return 0;
-
-	CHECK_PARAMS(2, "TogglePlayerFakePing");
-
-	int playerid = static_cast<int>(params[1]);
-	bool toggle = static_cast<int>(params[2]) != 0;
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	pPlayerData[playerid]->bFakePingToggle = toggle;
-	return 1;
-}
-
-// native SetPlayerFakePing(playerid, ping);
-static cell AMX_NATIVE_CALL Natives::SetPlayerFakePing(AMX *amx, cell *params)
-{
-	if(!pServer) return 0;
-
-	CHECK_PARAMS(2, "SetPlayerFakePing");
-
-	int playerid = static_cast<int>(params[1]);
-	int fakeping = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	pPlayerData[playerid]->dwFakePingValue = fakeping;
-	return 1;
-}
-
-// native TogglePlayerInServerQuery(playerid, bool:toggle);
-static cell AMX_NATIVE_CALL Natives::TogglePlayerInServerQuery(AMX *amx, cell *params)
-{
-	if (!pServer) return 0;
-
-	CHECK_PARAMS(2, "TogglePlayerInServerQuery");
-
-	int playerid = static_cast<int>(params[1]);
-	if (!IsPlayerConnectedEx(playerid)) return 0;
-
-	pPlayerData[playerid]->bHidden = !(!!params[2]);
-	return 1;
-}
-
-// native IsPlayerToggledInServerQuery(playerid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerToggledInServerQuery(AMX *amx, cell *params)
-{
-	if (!pServer) return 0;
-
-	CHECK_PARAMS(1, "IsPlayerToggledInServerQuery");
-
-	int playerid = static_cast<int>(params[1]);
-	if (!IsPlayerConnectedEx(playerid)) return 0;
-
-	return !pPlayerData[playerid]->bHidden;
-}
-
-// native IsPlayerPaused(playerid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerPaused(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(1, "IsPlayerPaused");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pPlayerData[playerid]->bAFKState;
-}
-
-// native GetPlayerPausedTime(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerPausedTime(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(1, "GetPlayerPausedTime");
-
-	int playerid = static_cast<int>(params[1]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(!pPlayerData[playerid]->bAFKState) return 0;
-
-	return GetTickCount() - pPlayerData[playerid]->dwLastUpdateTick;
-}
-
-// Objects - global
-// native Float:GetObjectDrawDistance(objectid);
-static cell AMX_NATIVE_CALL Natives::GetObjectDrawDistance( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetObjectDrawDistance");
-
-	int objectid = static_cast<int>(params[1]);
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
-
-	return amx_ftoc(pNetGame->pObjectPool->pObjects[objectid]->fDrawDistance);
-}
-
-// native Float:SetObjectMoveSpeed(objectid, Float:fSpeed);
-static cell AMX_NATIVE_CALL Natives::SetObjectMoveSpeed( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetObjectMoveSpeed");
-
-	int objectid = static_cast<int>(params[1]);
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
-
-	pNetGame->pObjectPool->pObjects[objectid]->fMoveSpeed = amx_ctof(params[2]);
-	return 1;
-}
-
-// native Float:GetObjectMoveSpeed(objectid);
-static cell AMX_NATIVE_CALL Natives::GetObjectMoveSpeed( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetObjectMoveSpeed");
-
-	int objectid = static_cast<int>(params[1]);
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
-
-	return amx_ftoc(pNetGame->pObjectPool->pObjects[objectid]->fMoveSpeed);
-}
-
-// native GetObjectTarget(objectid, &Float:fX, &Float:fY, &Float:fZ);
-static cell AMX_NATIVE_CALL Natives::GetObjectTarget( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(4, "GetObjectTarget");
-
-	int objectid = static_cast<int>(params[1]);
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
-
-	cell* cptr;
-	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pObject->matTarget.pos.fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pObject->matTarget.pos.fY);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pObject->matTarget.pos.fZ);
-	return 1;
-}
-
-// native GetObjectAttachedData(objectid, &vehicleid, &objectid, &attachedplayerid);
-static cell AMX_NATIVE_CALL Natives::GetObjectAttachedData( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(4, "GetObjectAttachedData");
-
-	int objectid = static_cast<int>(params[1]);
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-	
-	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
-
-	cell* cptr;
-	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = (cell)pObject->wAttachedVehicleID;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = (cell)pObject->wAttachedObjectID;
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = (cell)pServer->COBJECT_AttachedObjectPlayer[objectid];
-	return 1;
-}
-
-// native GetObjectAttachedOffset(objectid, &Float:fX, &Float:fY, &Float:fZ, &Float:fRotX, &Float:fRotY, &Float:fRotZ);
-static cell AMX_NATIVE_CALL Natives::GetObjectAttachedOffset( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(7, "GetObjectAttachedOffset");
-
-	int objectid = static_cast<int>(params[1]);
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-
-	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
-
-	cell* cptr;
-	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pObject->vecAttachedOffset.fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pObject->vecAttachedOffset.fY);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pObject->vecAttachedOffset.fZ);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(pObject->vecAttachedRotation.fX);
-	amx_GetAddr(amx, params[6], &cptr);
-	*cptr = amx_ftoc(pObject->vecAttachedRotation.fY);
-	amx_GetAddr(amx, params[7], &cptr);
-	*cptr = amx_ftoc(pObject->vecAttachedRotation.fZ);
-	return 1;
-}
-
-// native IsObjectMaterialSlotUsed(objectid, materialindex); // Return values: 1 = material, 2 = material text
-static cell AMX_NATIVE_CALL Natives::IsObjectMaterialSlotUsed( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "IsObjectMaterialSlotUsed");
-
-	int objectid = static_cast<int>(params[1]);
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-
-	int materialindex = static_cast<int>(params[2]);
-	if(materialindex < 0 || materialindex >= 16) return 0;
-
-	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
-
-	int i = 0;
-	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
-	
-	// Nothing to comment here..
-	while(i != 16)
-	{
-		if(pObject->Material[i].byteSlot == materialindex) break;
-		i++;
-	}
-	if(i == 16) return 0;
-
-	return pObject->Material[i].byteUsed;
-}
-
-// native GetObjectMaterial(objectid, materialindex, &modelid, txdname[], txdnamelen = sizeof(txdname), texturename[], texturenamelen = sizeof(texturename), &materialcolor);
-static cell AMX_NATIVE_CALL Natives::GetObjectMaterial( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(8, "GetObjectMaterial");
-
-	int objectid = static_cast<int>(params[1]);
-	int materialindex = static_cast<int>(params[2]);
-
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-	if(materialindex < 0 || materialindex >= 16) return 0;
-
-	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
-
-	int i = 0;
-	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
-
-	// Nothing to comment here..
-	while(i != 16)
-	{
-		if(pObject->Material[i].byteSlot == materialindex) break;
-		i++;
-	}
-	if(i == 16) return 0;
-
-	cell *cptr;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = (cell)pObject->Material[i].wModelID; //  modelid
-
-	set_amxstring(amx, params[4], pObject->Material[i].szMaterialTXD, params[5]); // txdname[], txdnamelen = sizeof(txdname)
-	set_amxstring(amx, params[6], pObject->Material[i].szMaterialTexture, params[7]); // texturenamelen = sizeof(txdnamelen),
-
-	amx_GetAddr(amx, params[8], &cptr);
-	*cptr = ABGR_ARGB(pObject->Material[i].dwMaterialColor); // materialcolor
-	return 1;
-}
-
-// native GetObjectMaterialText(objectid, materialindex, text[], textlen = sizeof(text), &materialsize, fontface[], fontfacelen = sizeof(fontface), &fontsize, &bold, &fontcolor, &backcolor, &textalignment);
-static cell AMX_NATIVE_CALL Natives::GetObjectMaterialText( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(12, "GetObjectMaterialText");
-
-	int objectid = static_cast<int>(params[1]);
-	int materialindex = static_cast<int>(params[2]);
-
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-	if(materialindex < 0 || materialindex >= 16) return 0;
-
-	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
-
-	int i = 0;
-	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
-
-	// Nothing to comment here..
-	while(i != 16)
-	{
-		if(pObject->Material[i].byteSlot == materialindex) break;
-		i++;
-	}
-	if(i == 16) return 0;
-
-	cell *cptr;
-
-	set_amxstring(amx, params[3], pObject->szMaterialText[i], params[4]); 
-
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = (cell)pObject->Material[i].byteMaterialSize; // materialsize
-
-	set_amxstring(amx, params[6], pObject->Material[i].szFont, params[7]); 
-
-	amx_GetAddr(amx, params[8], &cptr);
-	*cptr = (cell)pObject->Material[i].byteFontSize; // fontsize
-	amx_GetAddr(amx, params[9], &cptr);
-	*cptr = (cell)pObject->Material[i].byteBold; // bold
-	amx_GetAddr(amx, params[10], &cptr);
-	*cptr = (cell)pObject->Material[i].dwFontColor; // fontcolor
-	amx_GetAddr(amx, params[11], &cptr);
-	*cptr = (cell)pObject->Material[i].dwBackgroundColor; // backcolor
-	amx_GetAddr(amx, params[12], &cptr);
-	*cptr = (cell)pObject->Material[i].byteAlignment; // textalignment
-	return 1;
-}
-
-// native IsObjectNoCameraCol(objectid);
-static cell AMX_NATIVE_CALL Natives::IsObjectNoCameraCol( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsObjectNoCameraCol");
-
-	int objectid = static_cast<int>(params[1]);
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-
-	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
-
-	return pNetGame->pObjectPool->pObjects[objectid]->bNoCameraCol;
-}
-
-// native Float:GetPlayerObjectDrawDistance(playerid, objectid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerObjectDrawDistance( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "GetPlayerObjectDrawDistance");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(objectid < 0 || objectid >= 1000) return 0;
-
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-
-	return amx_ftoc(pNetGame->pObjectPool->pPlayerObjects[playerid][objectid]->fDrawDistance);
-}
-
-// native Float:SetPlayerObjectMoveSpeed(playerid, objectid, Float:fSpeed);
-static cell AMX_NATIVE_CALL Natives::SetPlayerObjectMoveSpeed( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "SetPlayerObjectMoveSpeed");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-
-	pNetGame->pObjectPool->pPlayerObjects[playerid][objectid]->fMoveSpeed = amx_ctof(params[3]);
-	return 1;
-}
-
-// native Float:GetPlayerObjectMoveSpeed(playerid, objectid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerObjectMoveSpeed( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "GetPlayerObjectMoveSpeed");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-
-	return amx_ftoc(pNetGame->pObjectPool->pPlayerObjects[playerid][objectid]->fMoveSpeed);
-}
-
-// native Float:GetPlayerObjectTarget(playerid, objectid, &Float:fX, &Float:fY, &Float:fZ);
-static cell AMX_NATIVE_CALL Natives::GetPlayerObjectTarget( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(5, "GetPlayerObjectTarget");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-
-	cell* cptr;
-	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pObject->matTarget.pos.fX);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pObject->matTarget.pos.fY);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(pObject->matTarget.pos.fZ);
-	return 1;
-}
-
-// native GetPlayerObjectAttachedData(playerid, objectid, &vehicleid, &objectid, &attachedplayerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerObjectAttachedData( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(5, "GetPlayerObjectAttachedData");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-	
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-
-	cell* cptr;
-	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = (cell)pObject->wAttachedVehicleID;
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = (cell)pPlayerData[playerid]->stObj[objectid].wObjectID;
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = (cell)pPlayerData[playerid]->stObj[objectid].wAttachPlayerID;
-	return 1;
-}
-
-// native GetPlayerObjectAttachedOffset(playerid, objectid, &Float:fX, &Float:fY, &Float:fZ, &Float:fRotX, &Float:fRotY, &Float:fRotZ);
-static cell AMX_NATIVE_CALL Natives::GetPlayerObjectAttachedOffset( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(8, "GetPlayerObjectAttachedOffset");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-
-	cell* cptr;
-	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
-	
-	CVector* vecOffset = NULL;
-	CVector* vecRot = NULL;
-	
-	if(pObject->wAttachedVehicleID)
-	{
-		vecOffset = &pObject->vecAttachedOffset;
-		vecRot = &pObject->vecAttachedRotation;
-	}
-	else
-	{
-		vecOffset = &pPlayerData[playerid]->stObj[objectid].vecOffset;
-		vecRot = &pPlayerData[playerid]->stObj[objectid].vecRot;
-	}
-	
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(vecOffset->fX);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(vecOffset->fY);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(vecOffset->fZ);
-	amx_GetAddr(amx, params[6], &cptr);
-	*cptr = amx_ftoc(vecRot->fX);
-	amx_GetAddr(amx, params[7], &cptr);
-	*cptr = amx_ftoc(vecRot->fY);
-	amx_GetAddr(amx, params[8], &cptr);
-	*cptr = amx_ftoc(vecRot->fZ);
-	return 1;
-}
-
-// native IsPlayerObjectMaterialSlotUsed(playerid, objectid, materialindex); // Return values: 1 = material, 2 = material text
-static cell AMX_NATIVE_CALL Natives::IsPlayerObjectMaterialSlotUsed( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "IsPlayerObjectMaterialSlotUsed");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	int materialindex = static_cast<int>(params[3]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-	if(materialindex < 0 || materialindex >= 16) return 0;
-
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-
-	int i = 0;
-	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
-	
-	// Nothing to comment here..
-	while(i != 16)
-	{
-		if(pObject->Material[i].byteSlot == materialindex) break;
-		i++;
-	}
-	if(i == 16) return 0;
-
-	return pObject->Material[i].byteUsed;
-}
-
-
-// native GetPlayerObjectMaterial(playerid, objectid, materialindex, &modelid, txdname[], txdnamelen = sizeof(txdname), texturename[], texturenamelen = sizeof(texturename), &materialcolor);
-static cell AMX_NATIVE_CALL Natives::GetPlayerObjectMaterial( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(9, "GetPlayerObjectMaterial");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	int materialindex = static_cast<int>(params[3]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-	if(materialindex < 0 || materialindex >= 16) return 0;
-
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-
-	cell* cptr;
-	int i = 0;
-	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
-	
-	// Nothing to comment here..
-	while(i != 16)
-	{
-		if(pObject->Material[i].byteSlot == materialindex) break;
-		i++;
-	}
-	if(i == 16) return 0;
-
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = (cell)pObject->Material[i].wModelID; //  modelid
-
-	set_amxstring(amx, params[5], pObject->Material[i].szMaterialTXD, params[6]); // txdname[], txdnamelen = sizeof(txdname)
-	set_amxstring(amx, params[7], pObject->Material[i].szMaterialTexture, params[8]); // texturenamelen = sizeof(txdnamelen),
-
-	amx_GetAddr(amx, params[9], &cptr);
-	*cptr = ABGR_ARGB(pObject->Material[i].dwMaterialColor); // materialcolor
-	return 1;
-}
-
-// native GetPlayerObjectMaterialText(playerid, objectid, materialindex, text[], textlen = sizeof(text), &materialsize, fontface[], fontfacelen = sizeof(fontface), &fontsize, &bold, &fontcolor, &backcolor, &textalignment);
-static cell AMX_NATIVE_CALL Natives::GetPlayerObjectMaterialText( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(13, "GetPlayerObjectMaterialText");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	int materialindex = static_cast<int>(params[3]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-	if(materialindex < 0 || materialindex >= 16) return 0;
-
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-
-	cell* cptr;
-	int i = 0;
-	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
-	
-	// Nothing to comment here..
-	while(i != 16)
-	{
-		if(pObject->Material[i].byteSlot == materialindex) break;
-		i++;
-	}
-	if(i == 16) return 0;
-
-	set_amxstring(amx, params[4], pObject->szMaterialText[i], params[5]); 
-
-	amx_GetAddr(amx, params[6], &cptr);
-	*cptr = (cell)pObject->Material[i].byteMaterialSize; // materialsize
-
-	set_amxstring(amx, params[7], pObject->Material[i].szFont, params[8]); 
-
-	amx_GetAddr(amx, params[9], &cptr);
-	*cptr = (cell)pObject->Material[i].byteFontSize; // fontsize
-	amx_GetAddr(amx, params[10], &cptr);
-	*cptr = (cell)pObject->Material[i].byteBold; // bold
-	amx_GetAddr(amx, params[11], &cptr);
-	*cptr = (cell)pObject->Material[i].dwFontColor; // fontcolor
-	amx_GetAddr(amx, params[12], &cptr);
-	*cptr = (cell)pObject->Material[i].dwBackgroundColor; // backcolor
-	amx_GetAddr(amx, params[13], &cptr);
-	*cptr = (cell)pObject->Material[i].byteAlignment; // textalignment
-	return 1;
-}
-
-// native IsPlayerObjectNoCameraCol(playerid, objectid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerObjectNoCameraCol( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "IsPlayerObjectNoCameraCol");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-
-	return pNetGame->pObjectPool->pPlayerObjects[playerid][objectid]->bNoCameraCol;
-}
-
-// native GetPlayerSurfingPlayerObjectID(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerSurfingPlayerObjectID( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerSurfingPlayerObjectID");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return INVALID_OBJECT_ID;
-
-	int surf = pPlayerData[playerid]->wSurfingInfo - MAX_VEHICLES;
-	if(surf >= 0 && surf < MAX_OBJECTS)
-	{
-		if(pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][surf])
-			return surf;
-	}
-	return INVALID_OBJECT_ID;
-}
-
-// native GetPlayerCameraTargetPlayerObj(playerid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerCameraTargetPlayerObj( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPlayerCameraTargetPlayerObj");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return INVALID_OBJECT_ID;
-	
-	CPlayer *pPlayer = pNetGame->pPlayerPool->pPlayer[playerid];
-	if(!pPlayer->bCameraTarget) return INVALID_OBJECT_ID;
-
-	int target = pNetGame->pPlayerPool->pPlayer[playerid]->aimSyncData.wCameraObject;
-	if(target >= 0 && target < MAX_OBJECTS)
-	{
-		if(pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][target])
-			return target;
-	}
-	return INVALID_OBJECT_ID;
-}
-
-// native GetObjectType(playerid, objectid);
-static cell AMX_NATIVE_CALL Natives::GetObjectType( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "GetObjectType");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
-
-	BYTE ret;
-	if(pNetGame->pObjectPool->bObjectSlotState[objectid])
-		ret = SELECT_OBJECT_GLOBAL_OBJECT;
-	else if(pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid])
-		ret = SELECT_OBJECT_PLAYER_OBJECT;
-	else 
-		ret = 0;
-	return ret;
-}
-
-// native GetPlayerAttachedObject(playerid, index, &modelid, &bone, &Float:fX, &Float:fY, &Float:fZ, &Float:fRotX, &Float:fRotY, &Float:fRotZ, Float:&fSacleX, Float:&fScaleY, Float:&fScaleZ, &materialcolor1, &materialcolor2);
-static cell AMX_NATIVE_CALL Natives::GetPlayerAttachedObject( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(15, "GetPlayerAttachedObject");
-
-	int playerid = static_cast<int>(params[1]);
-	int slot = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(slot < 0 || slot >= MAX_PLAYER_ATTACHED_OBJECTS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->attachedObjectSlot[slot]) return 0;
-
-	cell* cptr;
-	CAttachedObject *pObject = &pNetGame->pPlayerPool->pPlayer[playerid]->attachedObject[slot];
-	
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = *(cell*)&pObject->iModelID;	
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = *(cell*)&pObject->iBoneiD;	
-	
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(pObject->vecPos.fX);
-	amx_GetAddr(amx, params[6], &cptr);
-	*cptr = amx_ftoc(pObject->vecPos.fY);
-	amx_GetAddr(amx, params[7], &cptr);
-	*cptr = amx_ftoc(pObject->vecPos.fZ);
-
-	amx_GetAddr(amx, params[8], &cptr);
-	*cptr = amx_ftoc(pObject->vecRot.fX);
-	amx_GetAddr(amx, params[9], &cptr);
-	*cptr = amx_ftoc(pObject->vecRot.fY);
-	amx_GetAddr(amx, params[10], &cptr);
-	*cptr = amx_ftoc(pObject->vecRot.fZ);
-
-	amx_GetAddr(amx, params[11], &cptr);
-	*cptr = amx_ftoc(pObject->vecScale.fX);
-	amx_GetAddr(amx, params[12], &cptr);
-	*cptr = amx_ftoc(pObject->vecScale.fY);
-	amx_GetAddr(amx, params[13], &cptr);
-	*cptr = amx_ftoc(pObject->vecScale.fZ);
-
-	amx_GetAddr(amx, params[14], &cptr);
-	*cptr = RGBA_ABGR(pObject->dwMaterialColor1);
-	amx_GetAddr(amx, params[15], &cptr);
-	*cptr = RGBA_ABGR(pObject->dwMaterialColor2);
-	return 1;
-}
-
-// Vehicle functions
-// native GetVehicleSpawnInfo(vehicleid, &Float:fX, &Float:fY, &Float:fZ, &Float:fRot, &color1, &color2);
-static cell AMX_NATIVE_CALL Natives::GetVehicleSpawnInfo( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(7, "GetVehicleSpawnInfo");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	CVehicle* pVehicle = pNetGame->pVehiclePool->pVehicle[vehicleid];
-	if(!pVehicle) 
-		return 0;
-
-	CVehicleSpawn spawn; 
-	std::map<int, CVehicleSpawn>::iterator v = pServer->vehicleSpawnData.find(vehicleid);
-	if(v == pServer->vehicleSpawnData.end())
-	{
-		spawn.vecPos = pVehicle->customSpawn.vecPos;
-		spawn.fRot = pVehicle->customSpawn.fRot;
-		spawn.iColor1 = pVehicle->customSpawn.iColor1;
-		spawn.iColor2 = pVehicle->customSpawn.iColor2;
-
-	}
-	else
-	{
-		spawn.vecPos = v->second.vecPos;
-		spawn.fRot = v->second.fRot;
-		spawn.iColor1 = v->second.iColor1;
-		spawn.iColor2 = v->second.iColor2;	
-	}
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(spawn.vecPos.fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(spawn.vecPos.fY);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(spawn.vecPos.fZ);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(spawn.fRot);
-	amx_GetAddr(amx, params[6], &cptr);
-	*cptr = (cell)spawn.iColor1;
-	amx_GetAddr(amx, params[7], &cptr);
-	*cptr = (cell)spawn.iColor2;
-	return 1;
-}
-
-// native SetVehicleSpawnInfo(vehicleid, modelid, Float:fX, Float:fY, Float:fZ, Float:fAngle, color1, color2, respawntime = -2, interior = -2);
-static cell AMX_NATIVE_CALL Natives::SetVehicleSpawnInfo( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer || !CAddress::FUNC_CVehicle__Respawn)
-		return 0;
-
-	CHECK_PARAMS(10, "SetVehicleSpawnInfo");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	int modelid = static_cast<int>(params[2]);
-	if(modelid < 400 || modelid > 611) return 0;
-
-	CVehicle *pVehicle = pNetGame->pVehiclePool->pVehicle[vehicleid]; 
-	if(!pVehicle) 
-		return 0;
-
-	bool bStreamedIn = false;
-	CPlayerPool *pPlayerPool = pNetGame->pPlayerPool;		
-
-	for(WORD i = 0; i != MAX_PLAYERS; i++)
-	{
-		if(IsPlayerConnectedEx(i))
-		{
-			if(pPlayerPool->pPlayer[i]->byteVehicleStreamedIn[pVehicle->wVehicleID])
-			{
-				bStreamedIn = true;
-				break;
-			}
-		}
-	}
-
-	CVehicleSpawn spawn;
-	spawn.iModelID = modelid;
-	spawn.vecPos =  CVector(amx_ctof(params[3]), amx_ctof(params[4]), amx_ctof(params[5]));
-	spawn.fRot = amx_ctof(params[6]);
-	spawn.iColor1 = static_cast<int>(params[7]);
-	spawn.iColor2 = static_cast<int>(params[8]);
-	spawn.iRespawnTime = pVehicle->customSpawn.iRespawnTime;
-	spawn.iInterior = pVehicle->customSpawn.iInterior;
-
-	// logprintf("spandata: %d, %d", spawn.iRespawnTime, spawn.iInterior);
-
-	int respawntime = static_cast<int>(params[9]);
-	if(respawntime >= -1)
-	{
-		spawn.iRespawnTime = respawntime;
-	}
-
-	int interior = static_cast<int>(params[10]);
-	if(interior != -2)
-	{
-		spawn.iInterior = interior;
-	}
-	
-	std::map<int, CVehicleSpawn>::iterator v = pServer->vehicleSpawnData.find(pVehicle->wVehicleID);
-	if(v != pServer->vehicleSpawnData.end())
-	{
-		pServer->vehicleSpawnData.erase(v);
-		// logprintf("add custom");
-	}
-	pServer->vehicleSpawnData.insert(std::make_pair(vehicleid, spawn));
-
-	// logprintf("streamedin: %d, iRespawnTime: %d, interior: %d", bStreamedIn, respawntime, interior);
-
-	if(!bStreamedIn)
-	{
-		pVehicle->customSpawn.iModelID = spawn.iModelID;
-		pVehicle->customSpawn.fRot = spawn.fRot;
-		pVehicle->customSpawn.iColor1 = spawn.iColor1;
-		pVehicle->customSpawn.iColor2 = spawn.iColor2;
-		pVehicle->customSpawn.iRespawnTime = spawn.iRespawnTime;
-		pVehicle->customSpawn.iInterior= spawn.iInterior;
-	}
-	return 1;
-}
-
-// native GetVehicleModelCount(modelid);
-static cell AMX_NATIVE_CALL Natives::GetVehicleModelCount( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetVehicleModelCount");
-
-	int modelid = static_cast<int>(params[1]);
-	if(modelid < 400 || modelid > 611) return 0;
-	
-	return pNetGame->pVehiclePool->byteVehicleModelsUsed[modelid - 400];
-}
-
-// native GetVehicleModelsUsed();
-static cell AMX_NATIVE_CALL Natives::GetVehicleModelsUsed( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	BYTE byteModelsUsed = 0;
-	for(BYTE i = 0; i != 212; i++)
-	{
-		if(pNetGame->pVehiclePool->byteVehicleModelsUsed[i] != 0)
-			byteModelsUsed++;
-	}
-
-	return byteModelsUsed;
-}
-
-// native GetVehicleColor(vehicleid, &color1, &color2);
-static cell AMX_NATIVE_CALL Natives::GetVehicleColor( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "GetVehicleColor");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	cell* cptr;
-	CVehicle *pVehicle = pNetGame->pVehiclePool->pVehicle[vehicleid];
-
-	amx_GetAddr(amx, params[2], &cptr);
-	if(pServer->bChangedVehicleColor[vehicleid])
-	{
-		*cptr = *(cell*)&pVehicle->vehModInfo.iColor1;
-	}
-	else
-	{
-		*cptr = *(cell*)&pVehicle->customSpawn.iColor1;
-	}
-
-	amx_GetAddr(amx, params[3], &cptr);
-	if(pServer->bChangedVehicleColor[vehicleid])
-	{
-		*cptr = *(cell*)&pVehicle->vehModInfo.iColor2;
-	}
-	else
-	{
-		*cptr = *(cell*)&pVehicle->customSpawn.iColor2;
-	}
-	return 1;
-}
-
-// native GetVehiclePaintjob(vehicleid);
-static cell AMX_NATIVE_CALL Natives::GetVehiclePaintjob( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetVehiclePaintjob");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	return pNetGame->pVehiclePool->pVehicle[vehicleid]->vehModInfo.bytePaintJob;
-}
-
-// native GetVehicleInterior(vehicleid);
-static cell AMX_NATIVE_CALL Natives::GetVehicleInterior( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetVehicleInterior");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	return pNetGame->pVehiclePool->pVehicle[vehicleid]->customSpawn.iInterior;
-}
-
-// native GetVehicleNumberPlate(vehicleid, plate[], len = sizeof(plate));
-static cell AMX_NATIVE_CALL Natives::GetVehicleNumberPlate( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "GetVehicleNumberPlate");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	return set_amxstring(amx, params[2], pNetGame->pVehiclePool->pVehicle[vehicleid]->szNumberplate, params[3]);
-}
-
-// native SetVehicleRespawnDelay(vehicleid, delay);
-static cell AMX_NATIVE_CALL Natives::SetVehicleRespawnDelay( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetVehicleRespawnDelay");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	pNetGame->pVehiclePool->pVehicle[vehicleid]->customSpawn.iRespawnTime = (static_cast<int>(params[2]) * 1000);
-	return 1;
-}
-
-// native GetVehicleRespawnDelay(vehicleid);
-static cell AMX_NATIVE_CALL Natives::GetVehicleRespawnDelay( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetVehicleRespawnDelay");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	return pNetGame->pVehiclePool->pVehicle[vehicleid]->customSpawn.iRespawnTime / 1000;
-}
-
-// native SetVehicleOccupiedTick(vehicleid, ticks);
-static cell AMX_NATIVE_CALL Natives::SetVehicleOccupiedTick( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetVehicleOccupiedTick");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	pNetGame->pVehiclePool->pVehicle[vehicleid]->vehOccupiedTick = static_cast<int>(params[2]);
-	return 1;
-}
-
-// native GetVehicleOccupiedTick(vehicleid);
-static cell AMX_NATIVE_CALL Natives::GetVehicleOccupiedTick( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetVehicleOccupiedTick");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	return pNetGame->pVehiclePool->pVehicle[vehicleid]->vehOccupiedTick;
-}
-
-// native SetVehicleRespawnTick(vehicleid, ticks);
-static cell AMX_NATIVE_CALL Natives::SetVehicleRespawnTick( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetVehicleRespawnTick");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	pNetGame->pVehiclePool->pVehicle[vehicleid]->vehRespawnTick = static_cast<int>(params[2]);
-	return 1;
-}
-
-// native GetVehicleRespawnTick(vehicleid);
-static cell AMX_NATIVE_CALL Natives::GetVehicleRespawnTick( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetVehicleRespawnTick");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	return pNetGame->pVehiclePool->pVehicle[vehicleid]->vehRespawnTick;
-}
-
-// native GetVehicleLastDriver(vehicleid);
-static cell AMX_NATIVE_CALL Natives::GetVehicleLastDriver( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetVehicleLastDriver");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	return pNetGame->pVehiclePool->pVehicle[vehicleid]->wLastDriverID;
-}
-
-// native GetVehicleCab(vehicleid);
-static cell AMX_NATIVE_CALL Natives::GetVehicleCab( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetVehicleCab");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-	
-	CVehicle *pVeh;
-	for(WORD i = 0; i != MAX_VEHICLES; i++)
-	{
-		pVeh = pNetGame->pVehiclePool->pVehicle[i];
-		if(!pVeh) continue;
-
-		if(pVeh->wTrailerID != 0 && pVeh->wTrailerID == vehicleid)
-			return i;
-	}
-	return 0;
-}
-
-// native HasVehicleBeenOccupied(vehicleid);
-static cell AMX_NATIVE_CALL Natives::HasVehicleBeenOccupied( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "HasVehicleBeenOccupied");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	return pNetGame->pVehiclePool->pVehicle[vehicleid]->bOccupied;
-}
-
-// native SetVehicleBeenOccupied(vehicleid, occupied);
-static cell AMX_NATIVE_CALL Natives::SetVehicleBeenOccupied( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetVehicleBeenOccupied");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	pNetGame->pVehiclePool->pVehicle[vehicleid]->bOccupied = !!params[2];;
-	return 1;
-}
-
-// native IsVehicleOccupied(vehicleid);
-static cell AMX_NATIVE_CALL Natives::IsVehicleOccupied( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsVehicleOccupied");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	CPlayer *pPlayer;
-	for(WORD i = 0; i != MAX_PLAYERS; i++)
-	{
-		if(!IsPlayerConnectedEx(i)) continue; 
-		pPlayer = pNetGame->pPlayerPool->pPlayer[i];
-
-		if(pPlayer->wVehicleId == vehicleid && (pPlayer->byteState == PLAYER_STATE_DRIVER || pPlayer->byteState == PLAYER_STATE_PASSENGER)) 
-			return 1;
-	}
-	return 0;
-}
-
-// native IsVehicleDead(vehicleid);
-static cell AMX_NATIVE_CALL Natives::IsVehicleDead( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsVehicleDead");
-
-	int vehicleid = static_cast<int>(params[1]);
-	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
-	
-	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
-		return 0;
-
-	return pNetGame->pVehiclePool->pVehicle[vehicleid]->bDead;
-}
-
-// Gangzone functions
-// native IsValidGangZone(zoneid);
-static cell AMX_NATIVE_CALL Natives::IsValidGangZone( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "IsValidGangZone");
-	
-	int zoneid = static_cast<int>(params[1]);
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	return pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid));
-}
-
-// native IsGangZoneVisibleForPlayer(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::IsGangZoneVisibleForPlayer( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsGangZoneVisibleForPlayer");
-	
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
-
-	return !!(pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid)) != 0xFF);
-}
-
-// native GangZoneGetColorForPlayer(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::GangZoneGetColorForPlayer( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "GangZoneGetColorForPlayer");
-	
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
-
-	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid));
-	if(id != 0xFFFF) 
-	{
-		return pPlayerData[playerid]->dwClientSideZoneColor[id];
-	}
-	return 0;
-}
-
-// native GangZoneGetFlashColorForPlayer(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::GangZoneGetFlashColorForPlayer( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "GangZoneGetFlashColorForPlayer");
-	
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
-
-	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid));
-	if(id != 0xFFFF) 
-	{
-		return pPlayerData[playerid]->dwClientSideZoneFlashColor[id];
-	}
-	return 0;
-}
-
-// native IsGangZoneFlashingForPlayer(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::IsGangZoneFlashingForPlayer( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsGangZoneFlashingForPlayer");
-	
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
-
-	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid));
-	if(id != 0xFFFF) 
-	{
-		return pPlayerData[playerid]->bIsGangZoneFlashing[id];
-	}
-	return 0;
-}
-
-// native IsPlayerInGangZone(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerInGangZone( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsPlayerInGangZone");
-	
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
-
-	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid));
-	if(id != 0xFFFF) 
-	{
-		return pPlayerData[playerid]->bInGangZone[id];
-	}
-	return 0;
-}
-
-// native GangZoneGetPos(zoneid, &Float:fMinX, &Float:fMinY, &Float:fMaxX, &Float:fMaxY);
-static cell AMX_NATIVE_CALL Natives::GangZoneGetPos( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(5, "GangZoneGetPos");
-
-	int zoneid = static_cast<int>(params[1]);
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid)))  return 0;
-	
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pServer->pGangZonePool->pGangZone[zoneid]->fGangZone[0]);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pServer->pGangZonePool->pGangZone[zoneid]->fGangZone[1]);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pServer->pGangZonePool->pGangZone[zoneid]->fGangZone[2]);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(pServer->pGangZonePool->pGangZone[zoneid]->fGangZone[3]);
-	return 1;
-}
-
-// Textdraw functions
-// native IsValidTextDraw(textdrawid);
-static cell AMX_NATIVE_CALL Natives::IsValidTextDraw( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "IsValidTextDraw");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	return pNetGame->pTextDrawPool->bSlotState[textdrawid];
-}
-
-// native IsTextDrawVisibleForPlayer(playerid, textdrawid);
-static cell AMX_NATIVE_CALL Natives::IsTextDrawVisibleForPlayer( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsTextDrawVisibleForPlayer");
-	
-	int playerid = static_cast<int>(params[1]);
-	if(playerid < 0 || playerid >= MAX_PLAYERS) return 0;
-
-	int textdrawid = static_cast<int>(params[2]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-
-	return pNetGame->pTextDrawPool->bHasText[textdrawid][playerid];
-}
-
-// native TextDrawGetString(textdrawid, text[], len = sizeof(text));
-static cell AMX_NATIVE_CALL Natives::TextDrawGetString( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "TextDrawGetString");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	const char *szText = (pNetGame->pTextDrawPool->bSlotState[textdrawid]) ? pNetGame->pTextDrawPool->szFontText[textdrawid] : '\0';
-	return set_amxstring(amx, params[2], szText, params[3]);
-}
-
-// native TextDrawSetPos(textdrawid, Float:fX, Float:fY);
-static cell AMX_NATIVE_CALL Natives::TextDrawSetPos( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(3, "TextDrawPos");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	pTD->fX = amx_ctof(params[2]);
-	pTD->fY = amx_ctof(params[3]);
-	return 1;
-}
-
-// native TextDrawGetLetterSize(textdrawid, &Float:fX, &Float:fY);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetLetterSize( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(3, "TextDrawGetLetterSize");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pTD->fLetterWidth);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pTD->fLetterHeight);
-	return 1;
-}
-
-// native TextDrawGetTextSize(textdrawid, &Float:fX, &Float:fY);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetTextSize( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(3, "TextDrawGetTextSize");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pTD->fLineWidth);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pTD->fLineHeight);
-	return 1;
-}
-
-// native TextDrawGetPos(textdrawid, &Float:fX, &Float:fY);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetPos( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(3, "TextDrawGetPos");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pTD->fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pTD->fY);
-	return 1;
-}
-
-// native TextDrawGetColor(textdrawid);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetColor( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "TextDrawGetColor");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	return ABGR_RGBA(pTD->dwLetterColor);
-}
-
-// native TextDrawGetBoxColor(textdrawid);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetBoxColor( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "TextDrawGetBoxColor");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	return ABGR_RGBA(pTD->dwBoxColor);
-}
-
-// native TextDrawGetBackgroundColor(textdrawid);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetBackgroundColor( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "TextDrawGetBackgroundColor");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	return ABGR_RGBA(pTD->dwBackgroundColor);
-}
-
-// native TextDrawGetShadow(textdrawid);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetShadow( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "TextDrawGetShadow");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	return pTD->byteShadow;
-}
-
-// native TextDrawGetOutline(textdrawid);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetOutline( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "TextDrawGetOutline");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	return pTD->byteOutline;
-}
-
-// native TextDrawGetFont(textdrawid);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetFont( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "TextDrawGetOutline");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	return pTD->byteStyle;
-}
-
-// native TextDrawIsBox(textdrawid);
-static cell AMX_NATIVE_CALL Natives::TextDrawIsBox( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "TextDrawIsBox");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	return pTD->byteBox;
-}
-
-// native TextDrawIsProportional(textdrawid);
-static cell AMX_NATIVE_CALL Natives::TextDrawIsProportional( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "TextDrawIsProportional");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	return pTD->byteProportional;
-}
-
-// native TextDrawIsSelectable(textdrawid);
-static cell AMX_NATIVE_CALL Natives::TextDrawIsSelectable( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "TextDrawIsSelectable");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	return pTD->byteSelectable;
-}
-
-// native TextDrawGetAlignment(textdrawid);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetAlignment( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "TextDrawGetAlignment");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	BYTE ret = 0;
-
-	if(pTD->byteCenter) ret = 2;
-	else if(pTD->byteLeft) ret = 1;
-	else if(pTD->byteRight) ret = 3;
-	return ret;
-}
-
-// native TextDrawGetPreviewModel(textdrawid);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetPreviewModel( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "TextDrawGetPreviewModel");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	return pTD->dwModelIndex;
-}
-
-// native TextDrawGetPreviewRot(textdrawid, &Float:fRotX, &Float:fRotY, &Float:fRotZ, &Float:fZoom);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetPreviewRot( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(5, "TextDrawGetPreviewRot");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pTD->vecRot.fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pTD->vecRot.fY);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pTD->vecRot.fZ);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(pTD->fZoom);
-	return 1;
-}
-
-// native TextDrawGetPreviewVehCol(textdrawid, &color1, &color2);
-static cell AMX_NATIVE_CALL Natives::TextDrawGetPreviewVehCol( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(3, "TextDrawGetPreviewVehCol");
-	
-	int textdrawid = static_cast<int>(params[1]);
-	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
-	
-	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
-	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = (cell)pTD->color1;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = (cell)pTD->color2;
-	return 1;
-}
-
-// Per-Player textdraws
-// native IsValidPlayerTextDraw(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::IsValidPlayerTextDraw( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsValidPlayerTextDraw");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid];
-}
-
-// native IsPlayerTextDrawVisible(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerTextDrawVisible( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsPlayerTextDrawVisible");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bHasText[textdrawid];
-}
-
-// native PlayerTextDrawGetString(playerid, PlayerText:textdrawid, text[], len = sizeof(text));
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetString( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(4, "PlayerTextDrawGetString");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	
-	bool bIsValid = static_cast<int>(pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) != 0;
-	if(!bIsValid) return 0;
-
-	const char *szText = (bIsValid) ? pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->szFontText[textdrawid]: '\0';
-	return set_amxstring(amx, params[3], szText, params[4]);
-}
-
-// native PlayerTextDrawSetPos(playerid, PlayerText:textdrawid, Float:fX, Float:fY);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawSetPos( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(4, "PlayerTextDrawSetPos");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-
-	pTD->fX = amx_ctof(params[3]);
-	pTD->fY = amx_ctof(params[4]);
-	return 1;
-}
-
-// native PlayerTextDrawGetLetterSize(playerid, PlayerText:textdrawid, &Float:fX, &Float:fY);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetLetterSize( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(4, "PlayerTextDrawGetLetterSize");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pTD->fLetterWidth);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pTD->fLetterHeight);
-	return 1;
-}
-
-// native PlayerTextDrawGetTextSize(playerid, PlayerText:textdrawid, &Float:fX, &Float:fY);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetTextSize( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(4, "PlayerTextDrawGetTextSize");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pTD->fLineWidth);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pTD->fLineHeight);
-	return 1;
-}
-
-// native PlayerTextDrawGetPos(playerid, PlayerText:textdrawid, &Float:fX, &Float:fY);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetPos( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(4, "PlayerTextDrawGetPos");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pTD->fX);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pTD->fY);
-	return 1;
-}
-
-// native PlayerTextDrawGetColor(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetColor( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerTextDrawGetColor");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-	return ABGR_RGBA(pTD->dwLetterColor);
-}
-
-// native PlayerTextDrawGetBoxColor(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetBoxColor( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerTextDrawGetBoxColor");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-	return ABGR_RGBA(pTD->dwBoxColor);
-}
-
-// native PlayerTextDrawGetBackgroundCol(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetBackgroundCol( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerTextDrawGetBackgroundCol");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-	return ABGR_RGBA(pTD->dwBackgroundColor);
-}
-
-// native PlayerTextDrawGetShadow(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetShadow( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerTextDrawGetShadow");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-	return pTD->byteShadow;
-}
-
-// native PlayerTextDrawGetOutline(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetOutline( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerTextDrawGetOutline");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-	return pTD->byteOutline;
-}
-
-// native PlayerTextDrawGetFont(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetFont( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerTextDrawGetFont");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-	return pTD->byteStyle;
-}
-
-// native PlayerTextDrawIsBox(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawIsBox( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerTextDrawIsBox");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-	return pTD->byteBox;
-}
-
-// native PlayerTextDrawIsProportional(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawIsProportional( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerTextDrawIsProportional");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-	return pTD->byteProportional;
-}
-
-// native PlayerTextDrawIsSelectable(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawIsSelectable( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerTextDrawIsSelectable");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-	return pTD->byteSelectable;
-}
-
-// native PlayerTextDrawGetAlignment(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetAlignment( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerTextDrawGetAlignment");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-	BYTE ret = 0;
-
-	if(pTD->byteCenter) ret = 2;
-	else if(pTD->byteLeft) ret = 1;
-	else if(pTD->byteRight) ret = 3;
-	return ret;
-}
-
-// native PlayerTextDrawGetPreviewModel(playerid, PlayerText:textdrawid);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetPreviewModel( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerTextDrawGetPreviewModel");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-	return pTD->dwModelIndex;
-}
-
-// native PlayerTextDrawGetPreviewRot(playerid, PlayerText:textdrawid, &Float:fRotX, &Float:fRotY, &Float:fRotZ, &Float:fZoom);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetPreviewRot( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(6, "PlayerTextDrawGetPreviewRot");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pTD->vecRot.fX);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pTD->vecRot.fY);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(pTD->vecRot.fZ);
-	amx_GetAddr(amx, params[6], &cptr);
-	*cptr = amx_ftoc(pTD->fZoom);
-	return 1;
-}
-
-// native PlayerTextDrawGetPreviewVehCol(playerid, PlayerText:textdrawid, &color1, &color2);
-static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetPreviewVehCol( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(4, "PlayerTextDrawGetPreviewVehCol");
-	
-	int playerid = static_cast<int>(params[1]);
-	int textdrawid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
-
-	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = (cell)pTD->color1;
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = (cell)pTD->color2;
-	return 1;
-}
-
-// 3D Text labels
-// native IsValid3DTextLabel(Text3D:id);
-static cell AMX_NATIVE_CALL Natives::IsValid3DTextLabel( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "IsValid3DTextLabel");
-	
-	int id = static_cast<int>(params[1]);
-	if(0 < id || id >= MAX_3DTEXT_GLOBAL) return 0;
-	
-	return pNetGame->p3DTextPool->bIsCreated[id];
-}
-
-// native Is3DTextLabelStreamedIn(playerid, Text3D:id);
-static cell AMX_NATIVE_CALL Natives::Is3DTextLabelStreamedIn( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "Is3DTextLabelStreamedIn");
-	
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[1]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(0 < id || id >= MAX_3DTEXT_PLAYER) return 0;
-	
-	return pNetGame->pPlayerPool->pPlayer[playerid]->byte3DTextLabelStreamedIn[id];
-}
-
-// native Get3DTextLabelText(id, text[], len = sizeof(text));
-static cell AMX_NATIVE_CALL Natives::Get3DTextLabelText( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "Get3DTextLabelText");
-	
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
-
-	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
-
-	const char *szText = pNetGame->p3DTextPool->TextLabels[id].szText;
-	return set_amxstring(amx, params[2], szText, params[3]);
-}
-
-// native Get3DTextLabelColor(id);
-static cell AMX_NATIVE_CALL Natives::Get3DTextLabelColor( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "Get3DTextLabelColor");
-	
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
-	
-	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
-	C3DText &p3DText = pNetGame->p3DTextPool->TextLabels[id];
-
-	return p3DText.dwColor;
-}
-
-// native Get3DTextLabelPos(id, &Float:fX, &Float:fY, &Float:fZ);
-static cell AMX_NATIVE_CALL Natives::Get3DTextLabelPos( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(4, "Get3DTextLabelPos");
-	
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
-	
-	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
-	C3DText p3DText = pNetGame->p3DTextPool->TextLabels[id];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(p3DText.vecPos.fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(p3DText.vecPos.fY);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(p3DText.vecPos.fZ);
-	return 1;
-}
-
-// native Float:Get3DTextLabelDrawDistance(id);
-static cell AMX_NATIVE_CALL Natives::Get3DTextLabelDrawDistance( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "Get3DTextLabelDrawDistance");
-	
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
-	
-	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
-	C3DText p3DText = pNetGame->p3DTextPool->TextLabels[id];
-
-	return amx_ftoc(p3DText.fDrawDistance);
-}
-
-// native Get3DTextLabelLOS(id);
-static cell AMX_NATIVE_CALL Natives::Get3DTextLabelLOS( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "Get3DTextLabelLOS");
-	
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
-	
-	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
-	C3DText p3DText = pNetGame->p3DTextPool->TextLabels[id];
-
-	return p3DText.bLineOfSight;
-}
-
-// native Get3DTextLabelVirtualWorld(id);
-static cell AMX_NATIVE_CALL Natives::Get3DTextLabelVirtualWorld( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "Get3DTextLabelVirtualWorld");
-	
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
-	
-	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
-	C3DText p3DText = pNetGame->p3DTextPool->TextLabels[id];
-
-	return p3DText.iWorld;
-}
-
-// native Get3DTextLabelAttachedData(id, &attached_playerid, &attached_vehicleid);
-static cell AMX_NATIVE_CALL Natives::Get3DTextLabelAttachedData( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(3, "Get3DTextLabelAttachedData");
-	
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
-	
-	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
-	C3DText p3DText = pNetGame->p3DTextPool->TextLabels[id];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = (cell)p3DText.attachedToPlayerID;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = (cell)p3DText.attachedToVehicleID;
-	return 1;
-}
-
-// native IsValidPlayer3DTextLabel(playerid, PlayerText3D:id);
-static cell AMX_NATIVE_CALL Natives::IsValidPlayer3DTextLabel( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsValidPlayer3DTextLabel");
-	
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
-	
-	return pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id];
-}
-
-// native GetPlayer3DTextLabelText(playerid, PlayerText3D:id, text[], len = sizeof(text));
-static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelText( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(4, "GetPlayer3DTextLabelText");
-	
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
-	
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
-
-	const char *szText = (pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id].szText) ? pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id].szText : '\0';
-	return set_amxstring(amx, params[3], szText, params[4]);
-}
-
-// native GetPlayer3DTextLabelColor(playerid, PlayerText3D:id);
-static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelColor( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "GetPlayer3DTextLabelColor");
-	
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
-	
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
-
-	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
-	return p3DText.dwColor;
-}
-
-// native GetPlayer3DTextLabelPos(playerid, PlayerText3D:id, &Float:fX, &Float:fY, &Float:fZ);
-static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelPos( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(5, "GetPlayer3DTextLabelPos");
-	
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
-
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
-	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(p3DText.vecPos.fX);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(p3DText.vecPos.fY);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(p3DText.vecPos.fZ);
-	return 1;
-}
-
-// native Float:GetPlayer3DTextLabelDrawDist(playerid, PlayerText3D:id);
-static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelDrawDist( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "GetPlayer3DTextLabelDrawDist");
-	
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
-	
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
-
-	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
-	return amx_ftoc(p3DText.fDrawDistance);
-}
-
-// native GetPlayer3DTextLabelLOS(playerid, PlayerText3D:id);
-static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelLOS( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "GetPlayer3DTextLabelLOS");
-	
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
-	
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
-
-	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
-	return p3DText.bLineOfSight;
-}
-
-// native GetPlayer3DTextLabelVirtualW(playerid, PlayerText3D:id);
-static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelVirtualW( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "GetPlayer3DTextLabelVirtualW");
-	
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
-	
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
-
-	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
-	return p3DText.iWorld;
-}
-
-// native GetPlayer3DTextLabelAttached(playerid, PlayerText3D:id, &attached_playerid, &attached_vehicleid);
-static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelAttached( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(4, "GetPlayer3DTextLabelAttached");
-	
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
-	
-	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
-
-	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
-	cell* cptr;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = (cell)p3DText.attachedToPlayerID;
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = (cell)p3DText.attachedToVehicleID;
-	return 1;
-}
-
-// native AttachObjectToPlayer(objectid, playerid, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:rX, Float:rY, Float:rZ)
-static cell AMX_NATIVE_CALL Natives::YSF_AttachObjectToPlayer( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(8, "AttachObjectToPlayer");
-
-	// FUCK SAMP -.- n_AttachObjectToPlayer always return 0
-	int playerid = static_cast<int>(params[2]);
-	int objectid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(objectid < 1 || objectid >= MAX_OBJECTS) return 0;
-
-	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
-	if(!pObject) return 0;
-
-	if(pAttachObjectToPlayer(amx, params))
-	{
-		pServer->COBJECT_AttachedObjectPlayer[objectid] = playerid;
-		pObject->vecAttachedOffset = CVector(amx_ctof(params[3]), amx_ctof(params[4]), amx_ctof(params[5]));
-		pObject->vecAttachedRotation = CVector(amx_ctof(params[6]), amx_ctof(params[7]), amx_ctof(params[8]));
-	}
-	return 1;
-}
-
-// native AttachPlayerObjectToPlayer(objectplayer, objectid, attachplayer, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:rX, Float:rY, Float:rZ, onlyaddtoinstance = 0)
-static cell AMX_NATIVE_CALL Natives::YSF_AttachPlayerObjectToPlayer( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-//	CHECK_PARAMS(9, "AttachPlayerObjectToPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int objectid = static_cast<int>(params[2]);
-	int attachplayerid = static_cast<int>(params[3]);
-	bool bOnlyAddToInstance = static_cast<int>(params[10]) != 0;
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(!IsPlayerConnectedEx(attachplayerid)) return 0;
-
-	if(objectid < 1 || objectid >= MAX_OBJECTS) return 0;
-	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
-	
-	pPlayerData[playerid]->stObj[objectid].wAttachPlayerID = static_cast<WORD>(attachplayerid);
-	pPlayerData[playerid]->stObj[objectid].vecOffset = CVector(amx_ctof(params[4]), amx_ctof(params[5]), amx_ctof(params[6]));
-	pPlayerData[playerid]->stObj[objectid].vecRot = CVector(amx_ctof(params[7]), amx_ctof(params[8]), amx_ctof(params[9]));
-
-	if(!bOnlyAddToInstance)
-	{
-		if(pNetGame->pPlayerPool->pPlayer[playerid]->byteStreamedIn[attachplayerid])
-		{
-			RakNet::BitStream bs;
-			bs.Write((WORD)objectid); // wObjectID
-			bs.Write((WORD)attachplayerid); // playerid
-			bs.Write(amx_ctof(params[4]));
-			bs.Write(amx_ctof(params[5]));
-			bs.Write(amx_ctof(params[6]));
-			bs.Write(amx_ctof(params[7]));
-			bs.Write(amx_ctof(params[8]));
-			bs.Write(amx_ctof(params[9]));
-			pRakServer->RPC(&RPC_AttachObject, &bs, LOW_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), 0, 0);
-
-			pPlayerData[playerid]->bAttachedObjectCreated = true;
-		}
-	}
-	else
-	{
-			pPlayerData[playerid]->dwCreateAttachedObj = GetTickCount();
-			pPlayerData[playerid]->dwObjectID = objectid;
-			pPlayerData[playerid]->bAttachedObjectCreated = true;
-		
-	}
-	return 1;
-}
-
-// native AttachPlayerObjectToObject(playerid, objectid, attachtoid, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:RotX, Float:RotY, Float:RotZ, SyncRotation = 1);
-static cell AMX_NATIVE_CALL Natives::AttachPlayerObjectToObject( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(10, "AttachPlayerObjectToObject");
-
-	int forplayerid = static_cast<int>(params[1]);
-	int wObjectID = static_cast<int>(params[2]);
-	int wAttachTo = static_cast<int>(params[3]);
-
-	if(!IsPlayerConnectedEx(forplayerid)) return 0;
-
-	if(wObjectID < 1 || wObjectID >= MAX_OBJECTS) return 0;
-	if(wAttachTo < 1 || wAttachTo >= MAX_OBJECTS) return 0;
-
-	CObjectPool *pObjectPool = pNetGame->pObjectPool;
-	if(!pObjectPool->pPlayerObjects[forplayerid][wObjectID] || !pObjectPool->pPlayerObjects[forplayerid][wAttachTo]) return 0; // Check if object is exist
-
-	// Get data
-	CVector vecOffset = CVector(amx_ctof(params[4]), amx_ctof(params[5]), amx_ctof(params[6]));
-	CVector vecOffsetRot = CVector(amx_ctof(params[7]), amx_ctof(params[8]), amx_ctof(params[9]));
-	BYTE byteSyncRot = !!params[10];
-
-	// Store data
-	pPlayerData[forplayerid]->stObj[wObjectID].wObjectID = static_cast<WORD>(wAttachTo);
-	pPlayerData[forplayerid]->stObj[wObjectID].vecOffset = vecOffset;
-	pPlayerData[forplayerid]->stObj[wObjectID].vecRot = vecOffsetRot;
-
-	// Attach it
-	int iModelID = pObjectPool->pPlayerObjects[forplayerid][wObjectID]->iModel;
-	CVector vecPos = pObjectPool->pPlayerObjects[forplayerid][wObjectID]->matWorld.pos;
-	CVector vecRot = pObjectPool->pPlayerObjects[forplayerid][wObjectID]->vecRot;
-	float fDrawDistance = 299.0;
-	BYTE byteNoCameraCol = pObjectPool->pPlayerObjects[forplayerid][wObjectID]->bNoCameraCol;
-
-	RakNet::BitStream bs;
-	bs.Write((WORD)wObjectID);
-	bs.Write(iModelID);
-	bs.Write(vecPos);
-	bs.Write(vecRot);
-	bs.Write(fDrawDistance); // 159
-	bs.Write(byteNoCameraCol);
-	bs.Write((WORD)-1); // attached vehicle
-	bs.Write((WORD)wAttachTo); // attached object
-	bs.Write(vecOffset);
-	bs.Write(vecOffsetRot);	
-	bs.Write(byteSyncRot);
-	
-	pRakServer->RPC(&RPC_CreateObject, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0); // Send this on same RPC as CreateObject
-	return 1;
-}
-
-// native SetRecordingDirectory(const dir[]);
-static cell AMX_NATIVE_CALL Natives::SetRecordingDirectory( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "SetRecordingDirectory");
-
-	char *dir;
-	amx_StrParam(amx, params[1], dir);
-	if (!dir || !CAddress::ADDR_RecordingDirectory) return 0;
-
-	strcpy(gRecordingDataPath, dir);
-	strcat(gRecordingDataPath, "/%s.rec");
-	return 1;
-}
-
-// native GetRecordingDirectory(dir[], len = sizeof(dir));
-static cell AMX_NATIVE_CALL Natives::GetRecordingDirectory( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "GetRecordingDirectory");
-	
-	if(!CAddress::ADDR_RecordingDirectory) return 0;
-
-	char temp[MAX_PATH];
-	int len = strlen(gRecordingDataPath);
-	strcpy(temp, gRecordingDataPath);
-	temp[len - 7] = 0;
-
-	return set_amxstring(amx, params[1], temp, params[2]);
-}
-
-// native SendClientMessagef(playerid, color, const message[], {Float,_}:...);
-static cell AMX_NATIVE_CALL Natives::SendClientMessagef( AMX* amx, cell* params )
-{
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	int len;
-	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 3, len);
-	if(!szMessage) return 0;
-
-	RakNet::BitStream bsParams;
-	bsParams.Write((DWORD)params[2]);
-	bsParams.Write((DWORD)len);
-	bsParams.Write(szMessage, len);
-	pRakServer->RPC(&RPC_ClientMessage, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
-	return 1;
-}
-
-// native SendClientMessageToAllf(color, const message[], {Float,_}:...);
-static cell AMX_NATIVE_CALL Natives::SendClientMessageToAllf( AMX* amx, cell* params )
-{
-	int len;
-	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 2, len);
-	if(!szMessage) return 0;
-
-	RakNet::BitStream bsParams;
-	bsParams.Write((DWORD)params[1]);
-	bsParams.Write((DWORD)len);
-	bsParams.Write(szMessage, len);
-	pRakServer->RPC(&RPC_ClientMessage, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, false);
-	return 1;
-}
-
-// native GameTextForPlayerf(playerid, displaytime, style, const message[], {Float,_}:...);
-static cell AMX_NATIVE_CALL Natives::GameTextForPlayerf( AMX* amx, cell* params )
-{
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	int len;
-	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 4, len);
-	if(!szMessage) return 0;
-
-	RakNet::BitStream bsParams;
-	bsParams.Write((int)params[3]);
-	bsParams.Write((int)params[2]);
-	bsParams.Write(len);
-	bsParams.Write(szMessage, len);
-	pRakServer->RPC(&RPC_ScrDisplayGameText, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
-	return 1;
-}
-
-// native GameTextForAllf(displaytime, style, const message[], {Float,_}:...);
-static cell AMX_NATIVE_CALL Natives::GameTextForAllf( AMX* amx, cell* params )
-{
-	int len;
-	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 3, len);
-	if(!szMessage) return 0;
-
-	RakNet::BitStream bsParams;
-	bsParams.Write((int)params[2]);
-	bsParams.Write((int)params[1]);
-	bsParams.Write(len);
-	bsParams.Write(szMessage, len);
-	pRakServer->RPC(&RPC_ScrDisplayGameText, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, false);
-	return 1;
-}
-
-// native SendPlayerMessageToPlayerf(playerid, senderid, const message[], {Float,_}:...);
-static cell AMX_NATIVE_CALL Natives::SendPlayerMessageToPlayerf( AMX* amx, cell* params )
-{
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	int senderid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(senderid)) return 0;
-
-	int len;
-	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 3, len);
-	if(!szMessage) return 0;
-
-	RakNet::BitStream bsParams;
-	bsParams.Write((WORD)senderid);
-	bsParams.Write((BYTE)len);
-	bsParams.Write(szMessage, len);
-	pRakServer->RPC(&RPC_Chat, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
-	return 1;
-}
-
-// native SendPlayerMessageToAllf(senderid, const message[], {Float,_}:...);
-static cell AMX_NATIVE_CALL Natives::SendPlayerMessageToAllf( AMX* amx, cell* params )
-{
-	int senderid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(senderid)) return 0;
-
-	int len;
-	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 2, len);
-	if(!szMessage) return 0;
-
-	RakNet::BitStream bsParams;
-	bsParams.Write((WORD)senderid);
-	bsParams.Write((BYTE)len);
-	bsParams.Write(szMessage, len);
-	pRakServer->RPC(&RPC_Chat, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, false);
-	return 1;
-}
-
-// native SendRconCommandf(command[], {Float,_}:...);
-static cell AMX_NATIVE_CALL Natives::SendRconCommandf( AMX* amx, cell* params )
-{
-	int len;
-	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 1, len);
-	if(!szMessage) return 0;
-
-	CSAMPFunctions::Execute(szMessage);
-	return 1;
-}
-
-// native YSF_SetTickRate(ticks);
-static cell AMX_NATIVE_CALL Natives::YSF_SetTickRate( AMX* amx, cell* params )
-{
-	if(!pServer)
-		return 1;
-
-	CHECK_PARAMS(1, "YSF_SetTickRate");
-
-	int rate = static_cast<int>(params[1]);
-	if(rate < -1 || rate == 0) return 0; // -1 = no update
-
-	pServer->SetTickRate(rate);
-	return 1;
-}
-
-// native YSF_GetTickRate();
-static cell AMX_NATIVE_CALL Natives::YSF_GetTickRate( AMX* amx, cell* params )
-{
-	if(!pServer)
-		return 1;
-
-	return static_cast<cell>(pServer->GetTickRate());
-}
-
-// native YSF_EnableNightVisionFix(enable);
-static cell AMX_NATIVE_CALL Natives::YSF_EnableNightVisionFix(AMX* amx, cell* params)
-{
-	if (!pServer)
-		return 1;
-
-	CHECK_PARAMS(1, "YSF_EnableNightVisionFix");
-
-	pServer->EnableNightVisionFix(static_cast<int>(params[1]) != 0);
-	return 1;
-}
-
-// native YSF_IsNightVisionFixEnabled();
-static cell AMX_NATIVE_CALL Natives::YSF_IsNightVisionFixEnabled(AMX* amx, cell* params)
-{
-	if (!pServer)
-		return 1;
-
-	return static_cast<cell>(pServer->IsNightVisionFixEnabled());
-}
-
-// native YSF_SetExtendedNetStatsEnabled(enable);
-static cell AMX_NATIVE_CALL Natives::YSF_SetExtendedNetStatsEnabled(AMX* amx, cell* params)
-{
-	if (!pServer)
-		return 1;
-
-	CHECK_PARAMS(1, "YSF_SetExtendedNetStatsEnabled");
-
-	pServer->SetExtendedNetStatsEnabled(static_cast<int>(params[1]) != 0);
-	return 1;
-}
-
-// native YSF_IsExtendedNetStatsEnabled();
-static cell AMX_NATIVE_CALL Natives::YSF_IsExtendedNetStatsEnabled(AMX* amx, cell* params)
-{
-	if (!pServer)
-		return 1;
-
-	return static_cast<cell>(pServer->IsExtendedNetStatsEnabled());
-}
-
-// native YSF_SetAFKAccuracy(time_ms);
-static cell AMX_NATIVE_CALL Natives::YSF_SetAFKAccuracy(AMX* amx, cell* params)
-{
-	if (!pServer)
-		return 1;
-
-	CHECK_PARAMS(1, "YSF_SetAFKAccuracy");
-
-	pServer->SetAFKAccuracy(static_cast<DWORD>(params[1]));
-	return 1;
-}
-
-// native YSF_GetAFKAccuracy();
-static cell AMX_NATIVE_CALL Natives::YSF_GetAFKAccuracy(AMX* amx, cell* params)
-{
-	if (!pServer)
-		return 1;
-
-	return static_cast<cell>(pServer->GetAFKAccuracy());
-}
-
-static cell AMX_NATIVE_CALL Natives::YSF_GangZoneCreate(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(4, "GangZoneCreate");
-
-	float fMinX = amx_ctof(params[1]);
-	float fMinY = amx_ctof(params[2]);
-	float fMaxX = amx_ctof(params[3]);
-	float fMaxY = amx_ctof(params[4]);
-
-	// If coordinates are wrong, then won't create bugged zone!
-	if(fMaxX <= fMinX || fMaxY <= fMinY) 
-	{
-		//logprintf("GangZoneCreate: MaxX, MaxY must be bigger than MinX, MinY. Not inversely!");
-		//logprintf("GangZoneCreate: %f, %f, %f, %f",fMinX, fMinY, fMaxX, fMaxY);
-		return -1;
-	}
-
-	WORD ret = pServer->pGangZonePool->New(fMinX, fMinY, fMaxX, fMaxY);
-
-	return (ret == 0xFFFF) ? -1 : ret;
-}
-
-static cell AMX_NATIVE_CALL Natives::YSF_GangZoneDestroy(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(1, "GangZoneDestroy");
-
-	CGangZonePool *pGangZonePool = pServer->pGangZonePool;
-	int zoneid = static_cast<int>(params[1]);
-	if(!pGangZonePool || !pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
-
-	pGangZonePool->Delete(static_cast<WORD>(zoneid));
-	return 1;
-}
-
-// native YSF_GangZoneShowForPlayer(playerid, zone, color);
-static cell AMX_NATIVE_CALL Natives::YSF_GangZoneShowForPlayer( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "GangZoneShowForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	DWORD color = (DWORD)params[3];
-
-	// For security
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	return pServer->pGangZonePool->ShowForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), static_cast<DWORD>(color));
-}
-
-// native YSF_GangZoneHideForPlayer(playerid, zone);
-static cell AMX_NATIVE_CALL Natives::YSF_GangZoneHideForPlayer( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "GangZoneHideForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-
-	// For security
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	pServer->pGangZonePool->HideForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid));
-	return 1;
-}
-
-// native YSF_GangZoneShowForAll(zone, color);
-static cell AMX_NATIVE_CALL Natives::YSF_GangZoneShowForAll( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "GangZoneShowForAll");
-
-	int zoneid = static_cast<int>(params[1]);
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	pServer->pGangZonePool->ShowForAll(static_cast<WORD>(zoneid), static_cast<DWORD>(params[2]));
-	return 1;
-}
-
-// native YSF_GangZoneHideForAll(zone);
-static cell AMX_NATIVE_CALL Natives::YSF_GangZoneHideForAll( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GangZoneHideForAll");
-
-	int zoneid = static_cast<int>(params[1]);
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	pServer->pGangZonePool->HideForAll(static_cast<WORD>(zoneid));
-	return 1;
-}
-
-static cell AMX_NATIVE_CALL Natives::YSF_GangZoneFlashForPlayer(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(3, "GangZoneFlashForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-
-	// For security
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	pServer->pGangZonePool->FlashForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), static_cast<DWORD>(params[3]));
-	return 1;
-}
-
-static cell AMX_NATIVE_CALL Natives::YSF_GangZoneFlashForAll(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(2, "GangZoneFlashForAll");
-
-	int zoneid = static_cast<int>(params[1]);
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	pServer->pGangZonePool->FlashForAll(static_cast<WORD>(zoneid), static_cast<DWORD>(params[2]));
-	return 1;
-}
-
-static cell AMX_NATIVE_CALL Natives::YSF_GangZoneStopFlashForPlayer(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(2, "GangZoneStopFlashForPlayer");
-
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-
-	// For security
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	pServer->pGangZonePool->StopFlashForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid));
-	return 1;
-}
-
-static cell AMX_NATIVE_CALL Natives::YSF_GangZoneStopFlashForAll(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(1, "GangZoneStopFlashForAll");
-
-	int zoneid = static_cast<int>(params[1]);
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	pServer->pGangZonePool->StopFlashForAll(static_cast<WORD>(zoneid));
-	return 1;
-}
-
-// Menu functions
-// native IsMenuDisabled(Menu:menuid);
-static cell AMX_NATIVE_CALL Natives::IsMenuDisabled( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "IsMenuDisabled");
-	
-	int menuid = static_cast<int>(params[1]);
-	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
-	
-	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
-	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
-
-	return !!(!pMenu->interaction.Menu);
-}
-
-// native IsMenuRowDisabled(Menu:menuid, row);
-static cell AMX_NATIVE_CALL Natives::IsMenuRowDisabled( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsMenuRowDisabled");
-	
-	int menuid = static_cast<int>(params[1]);
-	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
-	
-	int itemid = static_cast<int>(params[2]);
-	if(itemid < 0 || itemid >= 12) return 0;
-
-	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
-	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
-
-	return !!(!pMenu->interaction.Row[itemid]);
-}
-
-// native GetMenuColumns(menuid);
-static cell AMX_NATIVE_CALL Natives::GetMenuColumns( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "GetMenuColumns");
-	
-	int menuid = static_cast<int>(params[1]);
-	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
-	
-	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
-	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
-
-	return pMenu->byteColumnsNumber;
-}
-
-// native GetMenuItems(menuid, column);
-static cell AMX_NATIVE_CALL Natives::GetMenuItems( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "GetMenuItems");
-	
-	int menuid = static_cast<int>(params[1]);
-	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
-
-	int column = static_cast<int>(params[2]);
-	if(menuid < 0 || menuid > 2) return 0;
-
-	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
-	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
-
-	return pMenu->byteItemsCount[column];
-}
-
-// native GetMenuPos(menuid, &Float:fX, &Float:fY);
-static cell AMX_NATIVE_CALL Natives::GetMenuPos( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(3, "GetMenuColumns");
-	
-	int menuid = static_cast<int>(params[1]);
-	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
-
-	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
-	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pMenu->fPosX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pMenu->fPosY);
-	return 1;
-}
-
-// native GetMenuColumnWidth(menuid, &Float:fColumn1, &Float:fColumn2);
-static cell AMX_NATIVE_CALL Natives::GetMenuColumnWidth( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(4, "GetMenuColumnWidth");
-	
-	int menuid = static_cast<int>(params[1]);
-	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
-
-	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
-	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pMenu->fColumn1Width);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pMenu->fColumn2Width);
-	return 1;
-}
-
-// native GetMenuColumnHeader(menuid, column, header[], len = sizeof(header));
-static cell AMX_NATIVE_CALL Natives::GetMenuColumnHeader( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(4, "GetMenuColumnHeader");
-	
-	int menuid = static_cast<int>(params[1]);
-	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
-
-	int column = static_cast<int>(params[2]);
-	if(menuid < 0 || menuid > 2) return 0;
-
-	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
-	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
-
-	return set_amxstring(amx, params[3], pMenu->szHeaders[column], params[4]);
-}
-
-// native GetMenuItem(menuid, column, itemid, item[], len = sizeof(item));
-static cell AMX_NATIVE_CALL Natives::GetMenuItem( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(5, "GetMenuItem");
-	
-	int menuid = static_cast<int>(params[1]);
-	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
-
-	int column = static_cast<int>(params[2]);
-	if(menuid < 0 || menuid > 2) return 0;
-
-	int itemid = static_cast<int>(params[3]);
-	if(itemid < 0 || itemid >= 12) return 0;
-
-	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
-	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
-
-	return set_amxstring(amx, params[4], pMenu->szItems[itemid][column], params[5]);
-}
-
-// native CreatePlayerGangZone(playerid, Float:minx, Float:miny, Float:maxx, Float:maxy);
-static cell AMX_NATIVE_CALL Natives::CreatePlayerGangZone( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(5, "CreatePlayerGangZone");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	float fMinX = amx_ctof(params[2]);
-	float fMinY = amx_ctof(params[3]);
-	float fMaxX = amx_ctof(params[4]);
-	float fMaxY = amx_ctof(params[5]);
-
-	// If coordinates are wrong, then won't create bugged zone!
-	if(fMaxX <= fMinX || fMaxY <= fMinY) 
-	{
-		logprintf("CreatePlayerGangZone: MaxX, MaxY must be bigger than MinX, MinY. Not inversely!");
-		logprintf("CreatePlayerGangZone: %f, %f, %f, %f",fMinX, fMinY, fMaxX, fMaxY);
-		return -1;
-	}
-
-	WORD ret = pServer->pGangZonePool->New(static_cast<WORD>(playerid), fMinX, fMinY, fMaxX, fMaxY);
-	if (ret == 0xFFFF) return -1;
-
-	return ret;
-}
-
-// native PlayerGangZoneShow(playerid, zoneid, color);
-static cell AMX_NATIVE_CALL Natives::PlayerGangZoneShow( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "PlayerGangZoneShow");
-
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	DWORD dwColor = static_cast<DWORD>(params[3]);
-
-	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
-
-	pServer->pGangZonePool->ShowForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), dwColor, true);
-	return 1;
-}
-
-// native PlayerGangZoneHide(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::PlayerGangZoneHide( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "PlayerGangZoneHide");
-
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
-
-	pServer->pGangZonePool->HideForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), true);
-	return 1;
-}
-
-// native PlayerGangZoneFlash(playerid, zoneid, color);
-static cell AMX_NATIVE_CALL Natives::PlayerGangZoneFlash( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "PlayerGangZoneFlash");
-
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	DWORD dwColor = static_cast<DWORD>(params[3]);
-
-	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
-
-	pServer->pGangZonePool->FlashForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), dwColor, true);
-	return 1;
-}
-
-// native PlayerGangZoneStopFlash(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::PlayerGangZoneStopFlash( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "PlayerGangZoneStopFlash");
-
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
-
-	pServer->pGangZonePool->StopFlashForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), true);
-	return 1;
-}
-
-// native PlayerGangZoneDestroy(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::PlayerGangZoneDestroy( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "PlayerGangZoneDestroy");
-
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-
-	pServer->pGangZonePool->HideForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), true);
-	return 1;
-}
-
-// native IsValidPlayerGangZone(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::IsValidPlayerGangZone( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsValidPlayerGangZone");
-	
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	return pPlayerData[playerid]->pPlayerZone[zoneid] != NULL;
-}
-
-// native IsPlayerInPlayerGangZone(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerInPlayerGangZone( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsPlayerInPlayerGangZone");
-	
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
-
-	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true);
-	if(id != 0xFFFF) 
-	{
-		return pPlayerData[playerid]->bInGangZone[id];
-	}
-	return 0;
-}
-
-// native PlayerGangZoneGetPos(playerid, zoneid, &Float:fMinX, &Float:fMinY, &Float:fMaxX, &Float:fMaxY);
-static cell AMX_NATIVE_CALL Natives::PlayerGangZoneGetPos( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(6, "PlayerGangZoneGetPos");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	int zoneid = static_cast<int>(params[2]);
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
-	
-	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true);
-	if(id != 0xFFFF) 
-	{
-		cell* cptr;
-		amx_GetAddr(amx, params[3], &cptr);
-		*cptr = amx_ftoc(pPlayerData[playerid]->pPlayerZone[zoneid]->fGangZone[0]);
-		amx_GetAddr(amx, params[4], &cptr);
-		*cptr = amx_ftoc(pPlayerData[playerid]->pPlayerZone[zoneid]->fGangZone[1]);
-		amx_GetAddr(amx, params[5], &cptr);
-		*cptr = amx_ftoc(pPlayerData[playerid]->pPlayerZone[zoneid]->fGangZone[2]);
-		amx_GetAddr(amx, params[6], &cptr);
-		*cptr = amx_ftoc(pPlayerData[playerid]->pPlayerZone[zoneid]->fGangZone[3]);
-	}
-	return 1;
-}
-
-// native IsPlayerGangZoneVisible(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerGangZoneVisible( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsPlayerInPlayerGangZone");
-	
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
-
-	return pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true) != 0xFFFF;
-}
-
-// native PlayerGangZoneGetColor(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::PlayerGangZoneGetColor( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerGangZoneGetColor");
-	
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
-
-	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true);
-	if(id != 0xFFFF) 
-	{
-		return pPlayerData[playerid]->dwClientSideZoneColor[id];
-	}
-	return 0;
-}
-
-// native PlayerGangZoneGetFlashColor(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::PlayerGangZoneGetFlashColor( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "PlayerGangZoneGetFlashColor");
-	
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
-
-	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true);
-	if(id != 0xFFFF) 
-	{
-		return pPlayerData[playerid]->dwClientSideZoneFlashColor[id];
-	}
-	return 0;
-}
-
-// native IsPlayerGangZoneFlashing(playerid, zoneid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerGangZoneFlashing( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(2, "IsPlayerGangZoneFlashing");
-	
-	int playerid = static_cast<int>(params[1]);
-	int zoneid = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
-	
-	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
-
-	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true);
-	if(id != 0xFFFF) 
-	{
-		return pPlayerData[playerid]->bIsGangZoneFlashing[id];
-	}
-	return 0;
-}
-
-#ifdef NEW_PICKUP_SYSTEM
-
-// native IsValidPickup(pickupid);
-static cell AMX_NATIVE_CALL Natives::IsValidPickup( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-	
-	CHECK_PARAMS(1, "IsValidPickup");
-
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-
-	return pServer->pPickupPool->FindPickup(id) != 0;
-}
-
-// native IsPickupStreamedIn(playerid, pickupid);
-static cell AMX_NATIVE_CALL Natives::IsPickupStreamedIn( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "IsPickupStreamedIn");
-
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-
-	CPickup *pPickup = pServer->pPickupPool->FindPickup(id);
-	if(!pPickup) return 0;
-
-	return pServer->pPickupPool->IsStreamed(playerid, pPickup);
-}
-
-// native GetPickupPos(pickupid, &Float:fX, &Float:fY, &Float:fZ);
-static cell AMX_NATIVE_CALL Natives::GetPickupPos( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(4, "GetPickupPos");
-
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-
-	CPickup *pPickup = pServer->pPickupPool->FindPickup(id);
-	if(!pPickup) return 0;
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pPickup->vecPos.fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pPickup->vecPos.fY);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pPickup->vecPos.fZ);
-	return 1;
-}
-
-// native GetPickupModel(pickupid);
-static cell AMX_NATIVE_CALL Natives::GetPickupModel( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPickupModel");
-
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-
-	CPickup *pPickup = pServer->pPickupPool->FindPickup(id);
-	if(!pPickup) return 0;
-
-	return pPickup->iModel;
-}
-
-// native GetPickupType(pickupid);
-static cell AMX_NATIVE_CALL Natives::GetPickupType( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPickupType");
-
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-
-	CPickup *pPickup = pServer->pPickupPool->FindPickup(id);
-	if(!pPickup) return 0;
-
-	return pPickup->iType;
-}
-
-// native GetPickupVirtualWorld(pickupid);
-static cell AMX_NATIVE_CALL Natives::GetPickupVirtualWorld( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPickupVirtualWorld");
-
-	int id = static_cast<int>(params[1]);
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-
-	CPickup *pPickup = pServer->pPickupPool->FindPickup(id);
-	if(!pPickup) return 0;
-
-	return pPickup->iWorld;
-}
-
-// CreatePlayerPickup(playerid, model, type, Float:X, Float:Y, Float:Z, virtualworld = 0);
-static cell AMX_NATIVE_CALL Natives::CreatePlayerPickup( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(7, "CreatePlayerPickup");
-
-	int playerid = static_cast<int>(params[1]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;
-
-	return pServer->pPickupPool->New(playerid, (int)params[2], (int)params[3], CVector(amx_ctof(params[4]), amx_ctof(params[5]), amx_ctof(params[6])), (int)params[7]);
-}
-
-// native DestroyPlayerPickup(playerid, pickupid);
-static cell AMX_NATIVE_CALL Natives::DestroyPlayerPickup( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-	
-	CHECK_PARAMS(2, "DestroyPlayerPickup");
-
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;	
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-	
-	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
-	if(!pPickup) return 0;
-
-	pServer->pPickupPool->Destroy((WORD)playerid, id);
-	return 1;
-}
-
-// native IsValidPlayerPickup(playerid, pickupid);
-static cell AMX_NATIVE_CALL Natives::IsValidPlayerPickup( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-	
-	CHECK_PARAMS(2, "IsValidPlayerPickup");
-
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;	
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-
-	return pServer->pPickupPool->FindPickup(playerid, id) != 0;
-}
-
-// native IsPlayerPickupStreamedIn(playerid, pickupid);
-static cell AMX_NATIVE_CALL Natives::IsPlayerPickupStreamedIn( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-	
-	CHECK_PARAMS(2, "IsPlayerPickupStreamedIn");
-
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;	
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-	
-	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
-	if(!pPickup) return 0;
-
-	return pServer->pPickupPool->IsStreamed(playerid, pPickup);
-}
-
-// native GetPlayerPickupPos(playerid, pickupid, &Float:fX, &Float:fY, &Float:fZ);
-static cell AMX_NATIVE_CALL Natives::GetPlayerPickupPos( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-	
-	CHECK_PARAMS(5, "GetPlayerPickupPos");
-
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;	
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-	
-	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
-	if(!pPickup) return 0;
-
-	cell* cptr;
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pPickup->vecPos.fX);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pPickup->vecPos.fY);
-	amx_GetAddr(amx, params[5], &cptr);
-	*cptr = amx_ftoc(pPickup->vecPos.fZ);
-	return 1;
-}
-
-// native GetPlayerPickupModel(playerid, pickupid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerPickupModel( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-	
-	CHECK_PARAMS(2, "GetPlayerPickupModel");
-
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;	
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-	
-	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
-	if(!pPickup) return 0;
-
-	return pPickup->iModel;
-}
-
-// native GetPlayerPickupType(playerid, pickupid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerPickupType( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-	
-	CHECK_PARAMS(2, "GetPlayerPickupType");
-
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;	
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-	
-	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
-	if(!pPickup) return 0;
-
-	return pPickup->iType;
-}
-
-// native GetPlayerPickupVirtualWorld(playerid, pickupid);
-static cell AMX_NATIVE_CALL Natives::GetPlayerPickupVirtualWorld( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-	
-	CHECK_PARAMS(2, "GetPlayerPickupVirtualWorld");
-
-	int playerid = static_cast<int>(params[1]);
-	int id = static_cast<int>(params[2]);
-	if(!IsPlayerConnectedEx(playerid)) return 0;	
-	if(id < 0 || id >= MAX_PICKUPS) return 0;
-	
-	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
-	if(!pPickup) return 0;
-
-	return pPickup->iWorld;
-}
-
-#else
-
-// native IsValidPickup(pickupid);
-static cell AMX_NATIVE_CALL Natives::IsValidPickup(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsValidPickup");
-
-	int id = static_cast<int>(params[1]);
-	if (id < 0 || id >= MAX_PICKUPS)
-		return 0;
-
-	return pNetGame->pPickupPool->bActive[id];
-}
-
-// native IsPickupStreamedIn(playerid, pickupid);
-static cell AMX_NATIVE_CALL Natives::IsPickupStreamedIn(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "IsPickupStreamedIn");
-
-	int playerid = static_cast<int>(params[1]);
-	int pickupid = static_cast<int>(params[2]);
-	if (!IsPlayerConnectedEx(playerid)) return 0;
-	if (pickupid < 0 || pickupid >= MAX_PICKUPS) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid]->bPickupStreamedIn[pickupid];
-}
-
-// native GetPickupPos(pickupid, &Float:fX, &Float:fY, &Float:fZ);
-static cell AMX_NATIVE_CALL Natives::GetPickupPos(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(4, "GetPickupPos");
-
-	int id = static_cast<int>(params[1]);
-	if (id < 0 || id >= MAX_PICKUPS)
-		return 0;
-
-	if (!pNetGame->pPickupPool->bActive[id]) return 0;
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(pNetGame->pPickupPool->Pickup[id].vecPos.fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(pNetGame->pPickupPool->Pickup[id].vecPos.fY);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(pNetGame->pPickupPool->Pickup[id].vecPos.fZ);
-	return 1;
-}
-
-// native GetPickupModel(pickupid);
-static cell AMX_NATIVE_CALL Natives::GetPickupModel(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPickupModel");
-
-	int id = static_cast<int>(params[1]);
-	if (id < 0 || id >= MAX_PICKUPS)
-		return 0;
-
-	if (!pNetGame->pPickupPool->bActive[id]) return 0;
-
-	return pNetGame->pPickupPool->Pickup[id].iModel;
-}
-
-// native GetPickupType(pickupid);
-static cell AMX_NATIVE_CALL Natives::GetPickupType(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPickupType");
-
-	int id = static_cast<int>(params[1]);
-	if (id < 0 || id >= MAX_PICKUPS)
-		return 0;
-
-	if (!pNetGame->pPickupPool->bActive[id]) return 0;
-
-	return pNetGame->pPickupPool->Pickup[id].iType;
-}
-
-// native GetPickupVirtualWorld(pickupid);
-static cell AMX_NATIVE_CALL Natives::GetPickupVirtualWorld(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "GetPickupVirtualWorld");
-
-	int id = static_cast<int>(params[1]);
-	if (id < 0 || id >= MAX_PICKUPS)
-		return 0;
-
-	if (!pNetGame->pPickupPool->bActive[id]) return 0;
-
-	return pNetGame->pPickupPool->iWorld[id];
-}
-
-#endif
-// RakServer functions //
-// native ClearBanList();
-static cell AMX_NATIVE_CALL Natives::ClearBanList( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	pRakServer->ClearBanList();
-	return 1;
-}
-
-// native IsBanned(_ip[]);
-static cell AMX_NATIVE_CALL Natives::IsBanned( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsBanned");
-
-	char *ip;
-	amx_StrParam(amx, params[1], ip);
-	return (ip) ? pRakServer->IsBanned(ip) : 0;
-}
-
-// native SetTimeoutTime(playerid, time);
-static cell AMX_NATIVE_CALL Natives::SetTimeoutTime( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(2, "SetTimeoutTime");
-	
-	PlayerID playerId = pRakServer->GetPlayerIDFromIndex(static_cast<int>(params[1]));
-	if(playerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress || !IsPlayerConnectedEx(static_cast<int>(params[1])))
-		return 0;
-
-	pRakServer->SetTimeoutTime((RakNetTime)params[2], playerId);
-	return 1;
-}
-
-// native SetMTUSize(size);
-static cell AMX_NATIVE_CALL Natives::SetMTUSize( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "SetMTUSize");
-	
-	return pRakServer->SetMTUSize(static_cast<int>(params[1]));
-}
-
-// native GetMTUSize();
-static cell AMX_NATIVE_CALL Natives::GetMTUSize( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-	
-	return pRakServer->GetMTUSize();
-}
-
-// native GetLocalIP(index, localip[], len = sizeof(localip));
-static cell AMX_NATIVE_CALL Natives::GetLocalIP( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "GetLocalIP");
-
-	return set_amxstring(amx, params[2], pRakServer->GetLocalIP((unsigned int)params[1]), params[3]);
-}
-
-// native SendRPC(playerid, RPC, {Float,_}:...)
-static cell AMX_NATIVE_CALL Natives::SendRPC( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	bool bBroadcast = static_cast<int>(params[1]) == -1;
-	int rpcid = static_cast<int>(params[2]);
-	
-	PlayerID playerId = bBroadcast ? UNASSIGNED_PLAYER_ID : pRakServer->GetPlayerIDFromIndex(static_cast<int>(params[1]));
-	
-	if (playerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress && !bBroadcast)
-		return 0;
-	
-	RakNet::BitStream bs;
-	cell *type = (cell*)0;
-	cell *data = (cell*)0;
-
-	for (int i = 0; i < (int)((params[0]/sizeof(cell)) - 2); i+=2)
-	{
-		amx_GetAddr(amx, params[i + 3], &type);
-		amx_GetAddr(amx, params[i + 4], &data);
-					
-		if (type && data)
-		{
-			switch (*type)
-			{
-			case BS_BOOL:
-				bs.Write((bool)(*data!=0));
-				break;
-			case BS_CHAR:
-				bs.Write(*(char*)data);
-				break;
-			case BS_UNSIGNEDCHAR:
-				bs.Write(*(unsigned char*)data);
-				break;
-			case BS_SHORT:
-				bs.Write(*(short*)data);
-				break;
-			case BS_UNSIGNEDSHORT:
-				bs.Write(*(unsigned short*)data);
-				break;
-			case BS_INT:
-				bs.Write(*(int*)data);
-				break;
-			case BS_UNSIGNEDINT:
-				bs.Write(*(unsigned int*)data);
-				break;
-			case BS_FLOAT:
-				bs.Write(*(float*)data);
-				break;
-			case BS_STRING:
-				{
-					int len;
-					amx_StrLen(data, &len);
-					len++;
-					char* str = new char[len];
-					amx_GetString(str, data, 0, len);
-					bs.Write(str, len - 1);
-					//logprintf("str: %s", str);
-					delete [] str;
-				}
-				break;
-			}
-		}
-	}
-
-	if(bBroadcast)
-	{
-		pRakServer->RPC(&rpcid, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, 0);
-	}
-	else
-	{
-		pRakServer->RPC(&rpcid, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, playerId, 0, 0);
-	}
-	return 1;
-}
-
-// native SendData(playerid, {Float,_}:...)
-static cell AMX_NATIVE_CALL Natives::SendData( AMX* amx, cell* params )
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	bool bBroadcast = static_cast<int>(params[1]) == -1;
-	PlayerID playerId = bBroadcast ? UNASSIGNED_PLAYER_ID : pRakServer->GetPlayerIDFromIndex(static_cast<int>(params[1]));
-
-	if (playerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress && !bBroadcast)
-		return 0;
-	
-	RakNet::BitStream bs;
-	cell *type = (cell*)0;
-	cell *data = (cell*)0;
-
-	for (int i = 0; i < (int)((params[0]/sizeof(cell)) - 2); i+=2)
-	{
-		amx_GetAddr(amx, params[i + 2], &type);
-		amx_GetAddr(amx, params[i + 3], &data);
-					
-		if (type && data)
-		{
-			switch (*type)
-			{
-			case BS_BOOL:
-				bs.Write((bool)(*data!=0));
-				break;
-			case BS_CHAR:
-				bs.Write(*(char*)data);
-				break;
-			case BS_UNSIGNEDCHAR:
-				bs.Write(*(unsigned char*)data);
-				break;
-			case BS_SHORT:
-				bs.Write(*(short*)data);
-				break;
-			case BS_UNSIGNEDSHORT:
-				bs.Write(*(unsigned short*)data);
-				break;
-			case BS_INT:
-				bs.Write(*(int*)data);
-				break;
-			case BS_UNSIGNEDINT:
-				bs.Write(*(unsigned int*)data);
-				break;
-			case BS_FLOAT:
-				bs.Write(*(float*)data);
-				break;
-			case BS_STRING:
-				{
-					int len;
-					amx_StrLen(data, &len);
-					len++;
-					char* str = new char[len];
-					amx_GetString(str, data, 0, len);
-					bs.Write(str, len - 1);
-					//logprintf("str: %s", str);
-					delete [] str;
-				}
-				break;
-			}
-		}
-	}
-
-	if(bBroadcast)
-	{
-		pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true);
-	}
-	else
-	{
-		pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, playerId, 0);
-	}
-	return 1;
-}
-
-// native GetColCount();
-static cell AMX_NATIVE_CALL Natives::GetColCount( AMX* amx, cell* params )
-{
-	return CModelSizes::GetColCount();
-}
-
-// native Float:GetColSphereRadius(modelid);
-static cell AMX_NATIVE_CALL Natives::GetColSphereRadius( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "GetColSphereRadius");
-	
-	float fRet = CModelSizes::GetColSphereRadius(static_cast<int>(params[1]));
-	return amx_ftoc(fRet);
-}
-
-// native GetColSphereOffset(modelid, &Float:fX, &Float:fY, &Float:fZ);
-static cell AMX_NATIVE_CALL Natives::GetColSphereOffset( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(4, "GetColSphereOffset");
-
-	CVector vecOffset = CModelSizes::GetColSphereOffset(static_cast<int>(params[1]));
-
-	cell* cptr;
-	amx_GetAddr(amx, params[2], &cptr);
-	*cptr = amx_ftoc(vecOffset.fX);
-	amx_GetAddr(amx, params[3], &cptr);
-	*cptr = amx_ftoc(vecOffset.fY);
-	amx_GetAddr(amx, params[4], &cptr);
-	*cptr = amx_ftoc(vecOffset.fZ);
-	return 1;
-}
-
-// native GetWeaponSlot(weaponid);
-static cell AMX_NATIVE_CALL Natives::GetWeaponSlot( AMX* amx, cell* params )
-{
-	CHECK_PARAMS(1, "GetWeaponSlot");
-	
-	return CUtils::GetWeaponSlot(static_cast<BYTE>(params[1]));
-}
-
-// native GetWeaponName(weaponid, weaponname[], len = sizeof(weaponname));
-static cell AMX_NATIVE_CALL Natives::FIXED_GetWeaponName(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if(!pServer)
-		return 0;
-
-	CHECK_PARAMS(3, "GetWeaponName");
-
-	return set_amxstring(amx, params[2], CUtils::GetWeaponName_(static_cast<BYTE>(params[1])), params[3]);
-}
-
-// native IsPlayerConnectedEx(playerid);
-static cell AMX_NATIVE_CALL Natives::FIXED_IsPlayerConnectedEx(AMX* amx, cell* params)
-{
-	// If unknown server version
-	if (!pServer)
-		return 0;
-
-	CHECK_PARAMS(1, "IsPlayerConnectedEx");
-
-	int playerid = static_cast<int>(params[1]);
-	if (playerid < 0 || playerid >= MAX_PLAYERS) return 0;
-
-	return pNetGame->pPlayerPool->pPlayer[playerid] != NULL;
-}
-
-#ifdef NEW_PICKUP_SYSTEM
-// native CreatePickup(model, type, Float:X, Float:Y, Float:Z, virtualworld = 0);
-static cell AMX_NATIVE_CALL Natives::CreatePickup(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(6, "CreatePickup");
-
-	return pServer->pPickupPool->New((int)params[1], (int)params[2], CVector(amx_ctof(params[3]), amx_ctof(params[4]), amx_ctof(params[5])), (int)params[6]);
-}
-
-// native DestroyPickup(pickupid);
-static cell AMX_NATIVE_CALL Natives::DestroyPickup(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(1, "DestroyPickup");
-
-	pServer->pPickupPool->Destroy((int)params[1]);
-	return 1;
-}
-
-// native SetPickupStreamingEnabled(enabled);
-static cell AMX_NATIVE_CALL Natives::SetPickupStreamingEnabled(AMX *amx, cell *params)
-{
-	CHECK_PARAMS(1, "SetPickupStreamingEnabled");
-
-	pServer->pPickupPool->SetStreamingEnabled(!!params[1]);
-	return 1;
-}
-#endif
-
-
-// And an array containing the native function-names and the functions specified with them
-AMX_NATIVE_INFO YSINatives [] =
-{
-	// File
-	{"ffind",							Natives::ffind},
-	{"frename",							Natives::frename},
-	
-	// Directory
-	{"dfind",							Natives::dfind},
-	{"dcreate",							Natives::dcreate},
-	{"drename",							Natives::drename},
-
-	// Generic
-	{"SetModeRestartTime",				Natives::SetModeRestartTime},
-	{"GetModeRestartTime",				Natives::GetModeRestartTime},
-	{"SetMaxPlayers",					Natives::SetMaxPlayers}, // R8
-	{"SetMaxNPCs",						Natives::SetMaxNPCs}, // R8
-
-	{"SetPlayerAdmin",					Natives::SetPlayerAdmin},
-	{"LoadFilterScript",				Natives::LoadFilterScript},
-	{"UnLoadFilterScript",				Natives::UnLoadFilterScript},
-	{"GetFilterScriptCount",			Natives::GetFilterScriptCount},
-	{"GetFilterScriptName",				Natives::GetFilterScriptName},
-
-	{"AddServerRule",					Natives::AddServerRule},
-	{"SetServerRule",					Natives::SetServerRule},
-	{"SetServerRuleInt",				Natives::SetServerRuleInt},
-	{"IsValidServerRule",				Natives::IsValidServerRule},
-	{"RemoveServerRule",				Natives::RemoveServerRule}, // Doesn't work!
-	{"ModifyFlag",						Natives::SetServerRuleFlags},
-	{"SetServerRuleFlags",				Natives::SetServerRuleFlags},
-	{"GetServerRuleFlags",				Natives::GetServerRuleFlags},
-
-	// Server settings
-	{"GetServerSettings",				Natives::GetServerSettings},
-
-	// Nick name
-	{"IsValidNickName",					Natives::IsValidNickName},	// R8
-	{"AllowNickNameCharacter",			Natives::AllowNickNameCharacter}, // R7
-	{"IsNickNameCharacterAllowed",		Natives::IsNickNameCharacterAllowed}, // R7
-
-	// Player classes
-	{ "GetAvailableClasses",			Natives::GetAvailableClasses}, // R6
-	{ "RemoveLastClass",				Natives::RemoveLastClass}, // R16
-	{ "GetPlayerClass",					Natives::GetPlayerClass}, // R6
-	{ "EditPlayerClass",				Natives::EditPlayerClass}, // R6
-	
-	// Timers
-	{ "GetRunningTimers",				Natives::GetRunningTimers}, // R8
-
-	// Special
-	{ "SetPlayerGravity",				Natives::SetPlayerGravity },
-	{ "GetPlayerGravity",				Natives::GetPlayerGravity },
-	
-	{ "SetPlayerTeamForPlayer",			Natives::SetPlayerTeamForPlayer }, // R5
-	{ "GetPlayerTeamForPlayer",			Natives::GetPlayerTeamForPlayer }, // R5
-	{ "SetPlayerSkinForPlayer",			Natives::SetPlayerSkinForPlayer }, // R11
-	{ "GetPlayerSkinForPlayer",			Natives::GetPlayerSkinForPlayer }, // R11
-	{ "SetPlayerNameForPlayer",			Natives::SetPlayerNameForPlayer }, // R11
-	{ "GetPlayerNameForPlayer",			Natives::GetPlayerNameForPlayer }, // R11
-	{ "SetPlayerFightStyleForPlayer",	Natives::SetPlayerFightStyleForPlayer }, // R11
-	{ "GetPlayerFightStyleForPlayer",	Natives::GetPlayerFightStyleForPlayer }, // R11
-	{ "SetPlayerPosForPlayer",			Natives::SetPlayerPosForPlayer}, // R12
-	{ "SetPlayerRotationQuatForPlayer",	Natives::SetPlayerRotationQuatForPlayer}, // R12
-	{ "ApplyAnimationForPlayer",		Natives::ApplyAnimationForPlayer}, // R11
-	{ "GetPlayerWeather",				Natives::GetPlayerWeather },
-	{ "GetPlayerWorldBounds",			Natives::GetPlayerWorldBounds },
-	{ "TogglePlayerWidescreen",			Natives::TogglePlayerWidescreen },
-	{ "IsPlayerWidescreenToggled",		Natives::IsPlayerWidescreenToggled },
-	{ "GetSpawnInfo",					Natives::GetSpawnInfo }, // R8
-	{ "GetPlayerSkillLevel",			Natives::GetPlayerSkillLevel }, // R3
-	{ "IsPlayerCheckpointActive",		Natives::IsPlayerCheckpointActive }, // R10
-	{ "GetPlayerCheckpoint",			Natives::GetPlayerCheckpoint }, // R4
-	{ "IsPlayerRaceCheckpointActive",	Natives::IsPlayerRaceCheckpointActive }, // R10
-	{ "GetPlayerRaceCheckpoint",		Natives::GetPlayerRaceCheckpoint }, // R4
-	{ "GetPlayerWorldBounds",			Natives::GetPlayerWorldBounds }, // R5
-	{ "IsPlayerInModShop",				Natives::IsPlayerInModShop }, // R4
-	{ "SendBulletData",					Natives::SendBulletData }, // R6
-	{ "ShowPlayerForPlayer",			Natives::ShowPlayerForPlayer }, // R8
-	{ "HidePlayerForPlayer",			Natives::HidePlayerForPlayer }, // R8
-	{ "AddPlayerForPlayer",				Natives::AddPlayerForPlayer }, // R17
-	{ "RemovePlayerForPlayer",			Natives::RemovePlayerForPlayer }, // R17
-	{ "SetPlayerChatBubbleForPlayer",	Natives::SetPlayerChatBubbleForPlayer}, // R10
-	{ "SetPlayerVersion",				Natives::SetPlayerVersion }, // R9
-	{ "IsPlayerSpawned",				Natives::IsPlayerSpawned }, // R9
-	{"IsPlayerControllable",			Natives::IsPlayerControllable}, // R11
-	{ "SpawnForWorld",					Natives::SpawnForWorld }, // R10
-	{ "BroadcastDeath",					Natives::BroadcastDeath }, // R13
-	{ "IsPlayerCameraTargetEnabled",	Natives::IsPlayerCameraTargetEnabled }, // R13
-	{ "SetPlayerDisabledKeysSync",		Natives::SetPlayerDisabledKeysSync }, // R16
-	{ "GetPlayerDisabledKeysSync",		Natives::GetPlayerDisabledKeysSync }, // R16
-
-	// Special things from syncdata
-	{ "GetPlayerSirenState",			Natives::GetPlayerSirenState },
-	{ "GetPlayerLandingGearState",		Natives::GetPlayerLandingGearState },
-	{ "GetPlayerHydraReactorAngle",		Natives::GetPlayerHydraReactorAngle },
-	{ "GetPlayerTrainSpeed",			Natives::GetPlayerTrainSpeed },
-	{ "GetPlayerZAim",					Natives::GetPlayerZAim },
-	{ "GetPlayerSurfingOffsets",		Natives::GetPlayerSurfingOffsets },
-	{ "GetPlayerRotationQuat",			Natives::GetPlayerRotationQuat }, // R3
-	{ "GetPlayerDialogID",				Natives::GetPlayerDialogID }, // R8
-	{ "GetPlayerSpectateID",			Natives::GetPlayerSpectateID }, // R8
-	{ "GetPlayerSpectateType",			Natives::GetPlayerSpectateType }, // R8
-	{ "GetPlayerLastSyncedVehicleID",	Natives::GetPlayerLastSyncedVehicleID }, // R10
-	{ "GetPlayerLastSyncedTrailerID",	Natives::GetPlayerLastSyncedTrailerID }, // R10
-	{ "GetPlayerFPS", 					Natives::GetPlayerFPS},
-
-	// Actor
-	{ "GetActorSpawnInfo", 				Natives::GetActorSpawnInfo}, // R13
-	{ "GetActorSkin", 					Natives::GetActorSkin}, // R13
-	{ "GetActorAnimation", 				Natives::GetActorAnimation}, // R17
-
-	// Scoreboard manipulation
-	{ "TogglePlayerScoresPingsUpdate",	Natives::TogglePlayerScoresPingsUpdate }, // R8
-	{ "TogglePlayerFakePing",			Natives::TogglePlayerFakePing }, // R8
-	{ "SetPlayerFakePing",				Natives::SetPlayerFakePing }, // R8
-	{ "TogglePlayerOnPlayerList",		Natives::TogglePlayerInServerQuery }, // R11
-	{ "IsPlayerToggledOnPlayerList",	Natives::IsPlayerToggledInServerQuery }, // R11
-	{ "TogglePlayerInServerQuery",		Natives::TogglePlayerInServerQuery }, // R11
-	{ "IsPlayerToggledInServerQuery",	Natives::IsPlayerToggledInServerQuery }, // R11
-
-	// AFK
-	{ "IsPlayerPaused",					Natives::IsPlayerPaused },
-	{ "GetPlayerPausedTime",			Natives::GetPlayerPausedTime },
-	
-	// Objects get - global
-	{"GetObjectDrawDistance",			Natives::GetObjectDrawDistance},
-	{"SetObjectMoveSpeed",				Natives::SetObjectMoveSpeed}, // R6
-	{"GetObjectMoveSpeed",				Natives::GetObjectMoveSpeed}, // R6
-	{"GetObjectTarget",					Natives::GetObjectTarget}, // R6
-	{"GetObjectAttachedData",			Natives::GetObjectAttachedData},
-	{"GetObjectAttachedOffset",			Natives::GetObjectAttachedOffset},
-	{"IsObjectMaterialSlotUsed",		Natives::IsObjectMaterialSlotUsed}, // R6
-	{"GetObjectMaterial",				Natives::GetObjectMaterial}, // R6
-	{"GetObjectMaterialText",			Natives::GetObjectMaterialText}, // R6
-	{"IsObjectNoCameraCol",				Natives::IsObjectNoCameraCol}, // R13
-
-	// Objects get - player
-	{"GetPlayerObjectDrawDistance",		Natives::GetPlayerObjectDrawDistance},
-	{"SetPlayerObjectMoveSpeed",		Natives::SetPlayerObjectMoveSpeed}, // R6
-	{"GetPlayerObjectMoveSpeed",		Natives::GetPlayerObjectMoveSpeed}, // R6
-	{"GetPlayerObjectTarget",			Natives::GetPlayerObjectTarget}, // R6
-	{"GetPlayerObjectAttachedData",		Natives::GetPlayerObjectAttachedData},
-	{"GetPlayerObjectAttachedOffset",	Natives::GetPlayerObjectAttachedOffset},
-	{"IsPlayerObjectMaterialSlotUsed",	Natives::IsPlayerObjectMaterialSlotUsed}, // R6
-	{"GetPlayerObjectMaterial",			Natives::GetPlayerObjectMaterial}, // R6
-	{"GetPlayerObjectMaterialText",		Natives::GetPlayerObjectMaterialText}, // R6
-	{"IsPlayerObjectNoCameraCol",		Natives::IsPlayerObjectNoCameraCol}, // R13
-	{"GetPlayerSurfingPlayerObjectID",	Natives::GetPlayerSurfingPlayerObjectID}, // R12
-	{"GetPlayerCameraTargetPlayerObj",	Natives::GetPlayerCameraTargetPlayerObj}, // R13
-	{"GetObjectType",					Natives::GetObjectType}, // R12
-
-	// special - for attached objects
-	{"GetPlayerAttachedObject",			Natives::GetPlayerAttachedObject}, // R3
-	
-	// Vehicle functions
-	{"GetVehicleSpawnInfo",				Natives::GetVehicleSpawnInfo},
-	{"SetVehicleSpawnInfo",				Natives::SetVehicleSpawnInfo}, // R16
-	{"GetVehicleColor",					Natives::GetVehicleColor},
-	{"GetVehiclePaintjob",				Natives::GetVehiclePaintjob},
-	{"GetVehicleInterior",				Natives::GetVehicleInterior},
-	{"GetVehicleNumberPlate",			Natives::GetVehicleNumberPlate},
-	{"SetVehicleRespawnDelay",			Natives::SetVehicleRespawnDelay},
-	{"GetVehicleRespawnDelay",			Natives::GetVehicleRespawnDelay},
-	{"SetVehicleOccupiedTick",			Natives::SetVehicleOccupiedTick}, // R6
-	{"GetVehicleOccupiedTick",			Natives::GetVehicleOccupiedTick},
-	{"SetVehicleRespawnTick",			Natives::SetVehicleRespawnTick},
-	{"GetVehicleRespawnTick",			Natives::GetVehicleRespawnTick},
-	{"GetVehicleLastDriver",			Natives::GetVehicleLastDriver},
-	{"GetVehicleCab",					Natives::GetVehicleCab}, // R9
-	{"HasVehicleBeenOccupied",			Natives::HasVehicleBeenOccupied}, // R9
-	{"SetVehicleBeenOccupied",			Natives::SetVehicleBeenOccupied}, // R9
-	{"IsVehicleOccupied",				Natives::IsVehicleOccupied}, // R9
-	{"IsVehicleDead",					Natives::IsVehicleDead}, // R9
-	{"GetVehicleModelCount",			Natives::GetVehicleModelCount}, // R17
-	{"GetVehicleModelsUsed",			Natives::GetVehicleModelsUsed}, // R17
-
-	// Gangzone - Global
-	{"IsValidGangZone",					Natives::IsValidGangZone},
-	{"IsPlayerInGangZone",				Natives::IsPlayerInGangZone},
-	{"IsGangZoneVisibleForPlayer",		Natives::IsGangZoneVisibleForPlayer},
-	{"GangZoneGetColorForPlayer",		Natives::GangZoneGetColorForPlayer},
-	{"GangZoneGetFlashColorForPlayer",	Natives::GangZoneGetFlashColorForPlayer},
-	{"IsGangZoneFlashingForPlayer",		Natives::IsGangZoneFlashingForPlayer}, // R6
-	{"GangZoneGetPos",					Natives::GangZoneGetPos},
-
-	// Gangzone - Player
-	{ "CreatePlayerGangZone",			Natives::CreatePlayerGangZone },
-	{ "PlayerGangZoneDestroy",			Natives::PlayerGangZoneDestroy },
-	{ "PlayerGangZoneShow",				Natives::PlayerGangZoneShow },
-	{ "PlayerGangZoneHide",				Natives::PlayerGangZoneHide },
-	{ "PlayerGangZoneFlash",			Natives::PlayerGangZoneFlash},
-	{ "PlayerGangZoneStopFlash",		Natives::PlayerGangZoneStopFlash },
-	{ "IsValidPlayerGangZone",			Natives::IsValidPlayerGangZone },
-	{ "IsPlayerInPlayerGangZone",		Natives::IsPlayerInPlayerGangZone },
-	{ "IsPlayerGangZoneVisible",		Natives::IsPlayerGangZoneVisible },
-	{ "PlayerGangZoneGetColor",			Natives::PlayerGangZoneGetColor },
-	{ "PlayerGangZoneGetFlashColor",	Natives::PlayerGangZoneGetFlashColor },
-	{ "IsPlayerGangZoneFlashing",		Natives::IsPlayerGangZoneFlashing }, // R6
-	{ "PlayerGangZoneGetPos",			Natives::PlayerGangZoneGetPos },
-
-	// Textdraw functions
-	{"IsValidTextDraw",					Natives::IsValidTextDraw},
-	{"IsTextDrawVisibleForPlayer",		Natives::IsTextDrawVisibleForPlayer},
-	{"TextDrawGetString",				Natives::TextDrawGetString},
-	{"TextDrawSetPos",					Natives::TextDrawSetPos},
-	{"TextDrawGetLetterSize",			Natives::TextDrawGetLetterSize},
-	{"TextDrawGetFontSize",				Natives::TextDrawGetTextSize},
-	{"TextDrawGetTextSize",				Natives::TextDrawGetTextSize},
-	{"TextDrawGetPos",					Natives::TextDrawGetPos},
-	{"TextDrawGetColor",				Natives::TextDrawGetColor},
-	{"TextDrawGetBoxColor",				Natives::TextDrawGetBoxColor},
-	{"TextDrawGetBackgroundColor",		Natives::TextDrawGetBackgroundColor},
-	{"TextDrawGetShadow",				Natives::TextDrawGetShadow},
-	{"TextDrawGetOutline",				Natives::TextDrawGetOutline},
-	{"TextDrawGetFont",					Natives::TextDrawGetFont},
-	{"TextDrawIsBox",					Natives::TextDrawIsBox},
-	{"TextDrawIsProportional",			Natives::TextDrawIsProportional},
-	{"TextDrawIsSelectable",			Natives::TextDrawIsSelectable}, // R6
-	{"TextDrawGetAlignment",			Natives::TextDrawGetAlignment},
-	{"TextDrawGetPreviewModel",			Natives::TextDrawGetPreviewModel},
-	{"TextDrawGetPreviewRot",			Natives::TextDrawGetPreviewRot},
-	{"TextDrawGetPreviewVehCol",		Natives::TextDrawGetPreviewVehCol},
-
-	// Per-Player Textdraw functions - R4
-	{"IsValidPlayerTextDraw",			Natives::IsValidPlayerTextDraw},
-	{"IsPlayerTextDrawVisible",			Natives::IsPlayerTextDrawVisible},
-	{"PlayerTextDrawGetString",			Natives::PlayerTextDrawGetString},
-	{"PlayerTextDrawSetPos",			Natives::PlayerTextDrawSetPos},
-	{"PlayerTextDrawGetLetterSize",		Natives::PlayerTextDrawGetLetterSize},
-	{"PlayerTextDrawGetFontSize",		Natives::PlayerTextDrawGetTextSize},
-	{"PlayerTextDrawGetTextSize",		Natives::PlayerTextDrawGetTextSize},
-	{"PlayerTextDrawGetPos",			Natives::PlayerTextDrawGetPos},
-	{"PlayerTextDrawGetColor",			Natives::PlayerTextDrawGetColor},
-	{"PlayerTextDrawGetBoxColor",		Natives::PlayerTextDrawGetBoxColor},
-	{"PlayerTextDrawGetBackgroundCol",	Natives::PlayerTextDrawGetBackgroundCol},
-	{"PlayerTextDrawGetShadow",			Natives::PlayerTextDrawGetShadow},
-	{"PlayerTextDrawGetOutline",		Natives::PlayerTextDrawGetOutline},
-	{"PlayerTextDrawGetFont",			Natives::PlayerTextDrawGetFont},
-	{"PlayerTextDrawIsBox",				Natives::PlayerTextDrawIsBox},
-	{"PlayerTextDrawIsProportional",	Natives::PlayerTextDrawIsProportional},
-	{"PlayerTextDrawIsSelectable",		Natives::PlayerTextDrawIsSelectable}, // R6
-	{"PlayerTextDrawGetAlignment",		Natives::PlayerTextDrawGetAlignment},
-	{"PlayerTextDrawGetPreviewModel",	Natives::PlayerTextDrawGetPreviewModel},
-	{"PlayerTextDrawGetPreviewRot",		Natives::PlayerTextDrawGetPreviewRot},
-	{"PlayerTextDrawGetPreviewVehCol",	Natives::PlayerTextDrawGetPreviewVehCol},
-
-	// 3D Text
-	{"IsValid3DTextLabel",				Natives::IsValid3DTextLabel}, // R4
-	{"Is3DTextLabelStreamedIn",			Natives::Is3DTextLabelStreamedIn}, // R9
-	{"Get3DTextLabelText",				Natives::Get3DTextLabelText},
-	{"Get3DTextLabelColor",				Natives::Get3DTextLabelColor},
-	{"Get3DTextLabelPos",				Natives::Get3DTextLabelPos},
-	{"Get3DTextLabelDrawDistance",		Natives::Get3DTextLabelDrawDistance},
-	{"Get3DTextLabelLOS",				Natives::Get3DTextLabelLOS},
-	{"Get3DTextLabelVirtualWorld",		Natives::Get3DTextLabelVirtualWorld},
-	{"Get3DTextLabelAttachedData",		Natives::Get3DTextLabelAttachedData},
-
-	// Per-Player 3D Text
-	{"IsValidPlayer3DTextLabel",		Natives::IsValidPlayer3DTextLabel}, // R4
-	{"GetPlayer3DTextLabelText",		Natives::GetPlayer3DTextLabelText}, // R4
-	{"GetPlayer3DTextLabelColor",		Natives::GetPlayer3DTextLabelColor}, // R4
-	{"GetPlayer3DTextLabelPos",			Natives::GetPlayer3DTextLabelPos}, // R4
-	{"GetPlayer3DTextLabelDrawDist",	Natives::GetPlayer3DTextLabelDrawDist},
-	{"GetPlayer3DTextLabelLOS",			Natives::GetPlayer3DTextLabelLOS}, // R4
-	{"GetPlayer3DTextLabelVirtualW",	Natives::GetPlayer3DTextLabelVirtualW}, // R4
-	{"GetPlayer3DTextLabelAttached",	Natives::GetPlayer3DTextLabelAttached}, // R9
-
-	// Menus
-	{"IsMenuDisabled",					Natives::IsMenuDisabled}, // R5 
-	{"IsMenuRowDisabled",				Natives::IsMenuRowDisabled}, // R5
-	{"GetMenuColumns",					Natives::GetMenuColumns},
-	{"GetMenuItems",					Natives::GetMenuItems},
-	{"GetMenuPos",						Natives::GetMenuPos},
-	{"GetMenuColumnWidth",				Natives::GetMenuColumnWidth},
-	{"GetMenuColumnHeader",				Natives::GetMenuColumnHeader},
-	{"GetMenuItem",						Natives::GetMenuItem},
-	
-	// Pickups - Global
-	{ "IsValidPickup",					Natives::IsValidPickup }, // R10
-	{ "IsPickupStreamedIn",				Natives::IsPickupStreamedIn }, // R10
-	{ "GetPickupPos",					Natives::GetPickupPos }, // R10
-	{ "GetPickupModel",					Natives::GetPickupModel }, // R10
-	{ "GetPickupType",					Natives::GetPickupType }, // R10
-	{ "GetPickupVirtualWorld",			Natives::GetPickupVirtualWorld }, // R10
-#ifdef NEW_PICKUP_SYSTEM
-	// Pickups - Per-player
-	{ "CreatePlayerPickup",				Natives::CreatePlayerPickup}, // R10
-	{ "DestroyPlayerPickup",			Natives::DestroyPlayerPickup }, // R10
-	{ "IsValidPlayerPickup",			Natives::IsValidPlayerPickup }, // R10
-	{ "IsPlayerPickupStreamedIn",		Natives::IsPlayerPickupStreamedIn }, // R10
-	{ "GetPlayerPickupPos",				Natives::GetPlayerPickupPos }, // R10
-	{ "GetPlayerPickupModel",			Natives::GetPlayerPickupModel }, // R10
-	{ "GetPlayerPickupType",			Natives::GetPlayerPickupType }, // R10
-	{ "GetPlayerPickupVirtualWorld",	Natives::GetPlayerPickupVirtualWorld }, // R10
-#endif
-	// RakServer functions
-	{ "ClearBanList",					Natives::ClearBanList },
-	{ "IsBanned",						Natives::IsBanned },
-
-	{ "SetTimeoutTime",					Natives::SetTimeoutTime },
-//	{ "SetMTUSize",						Natives::SetMTUSize },
-	{ "GetMTUSize",						Natives::GetMTUSize },
-	{ "GetLocalIP",						Natives::GetLocalIP },
-	
-	{ "SendRPC",						Natives::SendRPC },
-	{ "SendData",						Natives::SendData },
-	{ "YSF_SetTickRate",				Natives::YSF_SetTickRate},
-	{ "YSF_GetTickRate",				Natives::YSF_GetTickRate},
-	{ "YSF_EnableNightVisionFix",		Natives::YSF_EnableNightVisionFix },
-	{ "YSF_IsNightVisionFixEnabled",	Natives::YSF_IsNightVisionFixEnabled },
-	{ "YSF_SetExtendedNetStatsEnabled",	Natives::YSF_SetExtendedNetStatsEnabled }, // R17
-	{ "YSF_IsExtendedNetStatsEnabled",	Natives::YSF_IsExtendedNetStatsEnabled }, // R17
-	{ "YSF_SetAFKAccuracy",				Natives::YSF_SetAFKAccuracy }, // R17
-	{ "YSF_GetAFKAccuracy",				Natives::YSF_GetAFKAccuracy }, // R17
-
-	{ "AttachPlayerObjectToObject",		Natives::AttachPlayerObjectToObject },
-	
-	// Recording functions
-	{ "SetRecordingDirectory",			Natives::SetRecordingDirectory }, // R17
-	{ "GetRecordingDirectory",			Natives::GetRecordingDirectory }, // R17
-
-	// Format functions
-	{ "SendClientMessagef",				Natives::SendClientMessagef },
-	{ "SendClientMessageToAllf",		Natives::SendClientMessageToAllf },
-	{ "GameTextForPlayerf",				Natives::GameTextForPlayerf },
-	{ "GameTextForAllf",				Natives::GameTextForAllf },
-	{ "SendPlayerMessageToPlayerf",		Natives::SendPlayerMessageToPlayerf },
-	{ "SendPlayerMessageToAllf",		Natives::SendPlayerMessageToAllf },
-	{ "SendRconCommandf",				Natives::SendRconCommandf },
-
-	// Other
-	{"GetColCount",						Natives::GetColCount},
-	{"GetColSphereRadius",				Natives::GetColSphereRadius},
-	{"GetColSphereOffset",				Natives::GetColSphereOffset},
-
-	{ "GetWeaponSlot",					Natives::GetWeaponSlot},
-#ifdef NEW_PICKUP_SYSTEM
-	{ "SetPickupStreamingEnabled",		Natives::SetPickupStreamingEnabled },
-#endif
-	{ 0,								0 }
-};
-
-AMX_NATIVE_INFO RedirectedNatives[] =
-{
-	// File
-	{ "AttachObjectToPlayer",			Natives::YSF_AttachObjectToPlayer },
-	{ "AttachPlayerObjectToPlayer",		Natives::YSF_AttachPlayerObjectToPlayer },
-	{ "SetGravity",						Natives::YSF_SetGravity },
-	{ "GetGravity",						Natives::YSF_GetGravity },
-	{ "SetWeather",						Natives::YSF_SetWeather },
-	{ "SetPlayerWeather",				Natives::YSF_SetPlayerWeather },
-	{ "SetPlayerWorldBounds",			Natives::YSF_SetPlayerWorldBounds },
-	{ "DestroyObject",					Natives::YSF_DestroyObject },
-	{ "DestroyPlayerObject",			Natives::YSF_DestroyPlayerObject },
-	{ "TogglePlayerControllable",		Natives::YSF_TogglePlayerControllable},
-	{ "ChangeVehicleColor",				Natives::YSF_ChangeVehicleColor},
-	{ "DestroyVehicle",					Natives::YSF_DestroyVehicle},
-
-	{ "GangZoneCreate",					Natives::YSF_GangZoneCreate },
-	{ "GangZoneDestroy",				Natives::YSF_GangZoneDestroy },
-	{ "GangZoneShowForPlayer",			Natives::YSF_GangZoneShowForPlayer },
-	{ "GangZoneHideForPlayer",			Natives::YSF_GangZoneHideForPlayer },
-	{ "GangZoneShowForAll",				Natives::YSF_GangZoneShowForAll },
-	{ "GangZoneHideForAll",				Natives::YSF_GangZoneHideForAll },
-								
-	{ "GangZoneFlashForPlayer",			Natives::YSF_GangZoneFlashForPlayer },
-	{ "GangZoneFlashForAll",			Natives::YSF_GangZoneFlashForAll },
-	{ "GangZoneStopFlashForPlayer",		Natives::YSF_GangZoneStopFlashForPlayer },
-	{ "GangZoneStopFlashForAll",		Natives::YSF_GangZoneStopFlashForAll },
-#ifdef NEW_PICKUP_SYSTEM
-	{ "CreatePickup",					Natives::CreatePickup },
-	{ "AddStaticPickup",				Natives::CreatePickup },
-	{ "DestroyPickup",					Natives::DestroyPickup },
-#endif
-	{ "GetWeaponName",					Natives::FIXED_GetWeaponName },
-	{ "IsPlayerConnectedEx",			Natives::FIXED_IsPlayerConnectedEx },
-
-	{ "SetPlayerTeam",					Natives::YSF_SetPlayerTeam },
-	{ "SetPlayerSkin",					Natives::YSF_SetPlayerSkin },
-	{ "SetPlayerName",					Natives::YSF_SetPlayerName },
-	{ "SetPlayerFightingStyle",			Natives::YSF_SetPlayerFightingStyle },
-	{ 0,								0 }
-};
-
-int InitScripting(AMX *amx)
-{
-	return amx_Register(amx, YSINatives, -1);
+/*  
+ *  Version: MPL 1.1
+ *  
+ *  The contents of this file are subject to the Mozilla Public License Version 
+ *  1.1 (the "License"); you may not use this file except in compliance with 
+ *  the License. You may obtain a copy of the License at 
+ *  http://www.mozilla.org/MPL/
+ *  
+ *  Software distributed under the License is distributed on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing rights and limitations under the
+ *  License.
+ *  
+ *  The Original Code is the YSI 2.0 SA:MP plugin.
+ *  
+ *  The Initial Developer of the Original Code is Alex "Y_Less" Cole.
+ *  Portions created by the Initial Developer are Copyright (C) 2008
+ *  the Initial Developer. All Rights Reserved.
+ *  
+ *  Contributor(s):
+ *  
+ *  Peter Beverloo
+ *  Marcus Bauer
+ *  MaVe;
+ *  Sammy91
+ *  Incognito
+ *  
+ *  Special Thanks to:
+ *  
+ *  SA:MP Team past, present and future
+ */
+
+#include "main.h"
+
+// extern
+typedef cell AMX_NATIVE_CALL (* AMX_Function_t)(AMX *amx, cell *params);
+
+//----------------------------------------------------
+#ifdef _WIN32
+	// native ffind(const pattern[], filename[], len, &idx);
+	static cell AMX_NATIVE_CALL Natives::ffind(AMX *amx, cell *params)
+	{
+		// Find a file, idx determines which one of a number of matches to use
+		CHECK_PARAMS(4, "ffind");
+		cell
+			*cptr;
+		char
+			*szSearch;
+		// Get the search pattern
+		amx_StrParam(amx, params[1], szSearch);
+		if (szSearch)
+		{
+			// Get associated search information
+			amx_GetAddr(amx, params[4], &cptr);
+			cell
+				count = *cptr;
+			WIN32_FIND_DATA
+				ffd;
+			TCHAR
+				szDir[MAX_PATH] = TEXT("./scriptfiles/");
+			StringCchCat(szDir, MAX_PATH, szSearch);
+			// Get a serch handle
+			HANDLE
+				hFind = FindFirstFile(szDir, &ffd);
+			if (hFind != INVALID_HANDLE_VALUE)
+			{
+				do
+				{
+					// Check that this isn't a directory
+					if (!(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
+					{
+						// It's not - update idx
+						if (!count)
+						{
+							// No files left to skip, return the data
+							(*cptr)++;
+							amx_GetAddr(amx, params[2], &cptr);
+							amx_SetString(cptr, ffd.cFileName, 0, 0, params[3]);
+							FindClose(hFind);
+							return 1;
+						}
+						count--;
+					}
+				}
+				while (FindNextFile(hFind, &ffd) != 0);
+				FindClose(hFind);
+			}
+		}
+		return 0;
+	}
+	
+	// native dfind(const pattern[], filename[], len, &idx);
+	static cell AMX_NATIVE_CALL Natives::dfind(AMX *amx, cell *params)
+	{
+		// Find a directory, idx determines which one of a number of matches to use
+		// Identical to ffind in all but 1 line
+		CHECK_PARAMS(4, "dfind");
+		cell
+			*cptr;
+		char
+			*szSearch;
+		// Get the search pattern
+		amx_StrParam(amx, params[1], szSearch);
+		if (szSearch)
+		{
+			// Get associated search information
+			amx_GetAddr(amx, params[4], &cptr);
+			cell
+				count = *cptr;
+			WIN32_FIND_DATA
+				ffd;
+			TCHAR
+				szDir[MAX_PATH] = TEXT("./scriptfiles/");
+			StringCchCat(szDir, MAX_PATH, szSearch);
+			// Get a serch handle
+			HANDLE
+				hFind = FindFirstFile(szDir, &ffd);
+			if (hFind != INVALID_HANDLE_VALUE)
+			{
+				do
+				{
+					// Check that this is a directory
+					if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+					{
+						// It is - update idx
+						if (!count)
+						{
+							// No files left to skip, return the data
+							(*cptr)++;
+							amx_GetAddr(amx, params[2], &cptr);
+							amx_SetString(cptr, ffd.cFileName, 0, 0, params[3]);
+							FindClose(hFind);
+							return 1;
+						}
+						count--;
+					}
+				}
+				while (FindNextFile(hFind, &ffd) != 0);
+				FindClose(hFind);
+			}
+		}
+		return 0;
+	}
+#else
+	// native ffind(const pattern[], filename[], len, &idx);
+	static cell AMX_NATIVE_CALL Natives::ffind(AMX *amx, cell *params)
+	{
+		// Find a file, idx determines which one of a number of matches to use
+		CHECK_PARAMS(4, "dfind");
+		cell
+			*cptr;
+		char
+			*szSearch;
+		// Get the search pattern
+		amx_StrParam(amx, params[1], szSearch);
+		if (szSearch)
+		{
+			// Get associated search information
+			amx_GetAddr(amx, params[4], &cptr);
+			cell
+				count = *cptr;
+			// Find the end of the directory name
+			int
+				end = strlen(szSearch) - 1;
+			if (end == -1)
+			{
+				return 0;
+			}
+			while (szSearch[end] != '\\' && szSearch[end] != '/')
+			{
+				if (!end)
+				{
+					break;
+				}
+				end--;
+			}
+			// Split up the information
+			// Ensure that we search in scriptfiles
+			// And separate out the filename and path
+			char
+				*szDir = (char *)alloca(end + 16),
+				*szFile;
+			strcpy(szDir, "./scriptfiles/");
+			if (end)
+			{
+				szFile = &szSearch[end + 1];
+				szSearch[end] = '\0';
+				strcpy(szDir + 14, szSearch);
+				strcpy(szDir + strlen(szDir), "/");
+			}
+			else
+			{
+				szFile = szSearch;
+			}
+			end = strlen(szDir);
+			DIR
+				*dp = opendir(szDir);
+			if (dp)
+			{
+				// Loop through all files in the directory
+				struct dirent
+					*ep;
+				while (ep = readdir(dp))
+				{
+					// Check if this file matches the pattern
+					if (!fnmatch(szFile, ep->d_name, FNM_NOESCAPE))
+					{
+						// Check if this is a directory
+						// There MUST be an easier way to do this!
+						char
+							*full = (char *)malloc(strlen(ep->d_name) + end + 1);
+						if (!full)
+						{
+							closedir(dp);
+							return 0;
+						}
+						strcpy(full, szDir);
+						strcpy(full + end, ep->d_name);
+						DIR
+							*xp = opendir(full);
+						free(full);
+						if (xp)
+						{
+							closedir(xp);
+							continue;
+						}
+						// Check if there's any left to skip
+						if (!count)
+						{
+							// No files left to skip, return the data
+							(*cptr)++;
+							amx_GetAddr(amx, params[2], &cptr);
+							amx_SetString(cptr, ep->d_name, 0, 0, params[3]);
+							closedir(dp);
+							return 1;
+						}
+						count--;
+					}
+				}
+				closedir(dp);
+				return 0;
+			}
+		}
+		return 0;
+	}
+	
+	// native dfind(const pattern[], filename[], len, &idx);
+	static cell AMX_NATIVE_CALL Natives::dfind(AMX *amx, cell *params)
+	{
+		// Find a file, idx determines which one of a number of matches to use
+		CHECK_PARAMS(4, "ffind");
+		cell
+			*cptr;
+		char
+			*szSearch;
+		// Get the search pattern
+		amx_StrParam(amx, params[1], szSearch);
+		if (szSearch)
+		{
+			// Get associated search information
+			amx_GetAddr(amx, params[4], &cptr);
+			cell
+				count = *cptr;
+			// Find the end of the directory name
+			int
+				end = strlen(szSearch) - 1;
+			if (end == -1)
+			{
+				return 0;
+			}
+			while (szSearch[end] != '\\' && szSearch[end] != '/')
+			{
+				if (!end)
+				{
+					break;
+				}
+				end--;
+			}
+			// Split up the information
+			// Ensure that we search in scriptfiles
+			// And separate out the filename and path
+			char
+				*szDir = (char *)alloca(end + 16),
+				*szFile;
+			strcpy(szDir, "./scriptfiles/");
+			if (end)
+			{
+				szFile = &szSearch[end + 1];
+				szSearch[end] = '\0';
+				strcpy(szDir + 14, szSearch);
+				strcpy(szDir + strlen(szDir), "/");
+			}
+			else
+			{
+				szFile = szSearch;
+			}
+			end = strlen(szDir);
+			DIR
+				*dp = opendir(szDir);
+			if (dp)
+			{
+				// Loop through all files in the directory
+				struct dirent
+					*ep;
+				while (ep = readdir(dp))
+				{
+					// Check if this file matches the pattern
+					if (!fnmatch(szFile, ep->d_name, FNM_NOESCAPE))
+					{
+						// Check if this is a directory
+						// There MUST be an easier way to do this!CommandLine
+						char
+							*full = (char *)malloc(strlen(ep->d_name) + end + 1);
+						if (!full)
+						{
+							closedir(dp);
+							return 0;
+						}
+						strcpy(full, szDir);
+						strcpy(full + end, ep->d_name);
+						DIR
+							*xp = opendir(full);
+						free(full);
+						if (!xp)
+						{
+							continue;
+						}
+						closedir(xp);
+						// Check if there's any left to skip
+						if (!count)
+						{
+							// No files left to skip, return the data
+							(*cptr)++;
+							amx_GetAddr(amx, params[2], &cptr);
+							amx_SetString(cptr, ep->d_name, 0, 0, params[3]);
+							closedir(dp);
+							return 1;
+						}
+						count--;
+					}
+				}
+				closedir(dp);
+				return 0;
+			}
+		}
+		return 0;
+	}
+#endif
+
+// native dcreate(const name[]);
+static cell AMX_NATIVE_CALL Natives::dcreate(AMX *amx, cell *params)
+{
+	// Creates a directory
+	CHECK_PARAMS(1, "dcreate");
+	char
+		*szSearch;
+	// Get the search pattern
+	amx_StrParam(amx, params[1], szSearch);
+	if (szSearch)
+	{
+		#ifdef _WIN32
+			TCHAR
+				szDir[MAX_PATH] = TEXT("./scriptfiles/");
+			StringCchCat(szDir, MAX_PATH, szSearch);
+			return (cell)CreateDirectory(szDir, NULL);
+		#else
+			char
+				*szDir = (char *)alloca(strlen(szSearch) + 15);
+			strcpy(szDir, "./scriptfiles/");
+			strcpy(szDir + 14, szSearch);
+			return (cell)mkdir(szDir, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+		#endif
+	}
+	return 0;
+}
+
+// native frename(const oldname[], const newname[]);
+static cell AMX_NATIVE_CALL Natives::frename(AMX *amx, cell *params)
+{
+	// Creates a directory
+	CHECK_PARAMS(2, "frename");
+	char
+		*szOld,
+		*szNew;
+	// Get the search pattern
+	amx_StrParam(amx, params[1], szOld);
+	amx_StrParam(amx, params[2], szNew);
+	if (szOld && szNew)
+	{
+		char
+			*szO = (char *)alloca(strlen(szOld) + 16),
+			*szN = (char *)alloca(strlen(szNew) + 16);
+		strcpy(szO, "./scriptfiles/");
+		strcpy(szO + 14, szOld);
+		strcpy(szN, "./scriptfiles/");
+		strcpy(szN + 14, szNew);
+		return (cell)rename(szO, szN);
+	}
+	return 0;
+}
+
+// native drename(const oldname[], const newname[]);
+static cell AMX_NATIVE_CALL Natives::drename(AMX *amx, cell *params)
+{
+	// Creates a directory
+	CHECK_PARAMS(2, "drename");
+	char
+		*szOld,
+		*szNew;
+	// Get the search pattern
+	amx_StrParam(amx, params[1], szOld);
+	amx_StrParam(amx, params[2], szNew);
+	if (szOld && szNew)
+	{
+		char
+			*szO = (char *)alloca(strlen(szOld) + 16),
+			*szN = (char *)alloca(strlen(szNew) + 16);
+		strcpy(szO, "./scriptfiles/");
+		strcpy(szO + 14, szOld);
+		int
+			end;
+		end = strlen(szO);
+		if (szO[end - 1] != '/')
+		{
+			szO[end] = '/';
+			szO[end + 1] = '\0';
+		}
+		strcpy(szN, "./scriptfiles/");
+		strcpy(szN + 14, szNew);
+		end = strlen(szN);
+		if (szN[end - 1] != '/')
+		{
+			szN[end] = '/';
+			szN[end + 1] = '\0';
+		}
+		return (cell)rename(szO, szN);
+	}
+	return 0;
+}
+
+// native SetModeRestartTime(Float:time);
+static cell AMX_NATIVE_CALL Natives::SetModeRestartTime(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	if (!CAddress::VAR_pRestartWaitTime) return 0;
+
+	CHECK_PARAMS(1, "SetModeRestartTime");
+
+	*(float*)CAddress::VAR_pRestartWaitTime = amx_ctof(params[1]);
+	return 1;
+}
+
+// native Float:GetModeRestartTime();
+static cell AMX_NATIVE_CALL Natives::GetModeRestartTime(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	if (!CAddress::VAR_pRestartWaitTime) return 0;
+
+	float fRestartTime = *(float*)CAddress::VAR_pRestartWaitTime;
+	return amx_ftoc(fRestartTime);
+}
+
+// native SetMaxPlayers(maxplayers);
+static cell AMX_NATIVE_CALL Natives::SetMaxPlayers(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	int maxplayers = static_cast<int>(params[1]);
+	if(maxplayers < 1 || maxplayers > MAX_PLAYERS) return 0;
+
+	CSAMPFunctions::SetIntVariable("maxplayers", maxplayers);
+	return 1;
+}
+
+// native SetMaxNPCs(maxnpcs);
+static cell AMX_NATIVE_CALL Natives::SetMaxNPCs(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	int maxnpcs = static_cast<int>(params[1]);
+	if(maxnpcs < 1 || maxnpcs > MAX_PLAYERS) return 0;
+
+	CSAMPFunctions::SetIntVariable("maxnpc", maxnpcs);
+	return 1;
+}
+
+// native GetSyncBounds(&Float:hmin, &Float:hmax, &Float:vmin, &Float:vmax);
+static cell AMX_NATIVE_CALL Natives::GetSyncBounds(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+	
+	CHECK_PARAMS(4, "GetSyncBounds");
+	
+	cell *cptr;
+
+	for(BYTE i = 0; i < 4; i++)
+	{
+		if(CAddress::VAR_pPosSyncBounds[i])
+		{
+			//logprintf("%d %f", i, (*(float*)CAddress::VAR_pPosSyncBounds[i]));
+			amx_GetAddr(amx, params[i+1], &cptr);
+			*cptr = amx_ftoc(*(float*)CAddress::VAR_pPosSyncBounds[i]);
+			//params[i+1] = amx_ftoc(*(float*)CAddress::VAR_pPosSyncBounds[i]);
+		}else{
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+// native SetSyncBounds(Float:hmin, Float:hmax, Float:vmin, Float:vmax);
+static cell AMX_NATIVE_CALL Natives::SetSyncBounds(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+	
+	CHECK_PARAMS(4, "SetSyncBounds");
+	
+	for(BYTE i = 0; i < 4; i++)
+	{
+		if(CAddress::VAR_pPosSyncBounds[i])
+		{
+			*(float*)CAddress::VAR_pPosSyncBounds[i] = amx_ctof(params[i+1]);
+		}else{
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+// native SetPlayerAdmin(playerid, bool:admin);
+static cell AMX_NATIVE_CALL Natives::SetPlayerAdmin(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetPlayerAdmin");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	pNetGame->pPlayerPool->bIsAnAdmin[playerid] = !!params[2];
+	return 1;
+}
+
+// native LoadFilterScript(scriptname[]);
+static cell AMX_NATIVE_CALL Natives::LoadFilterScript(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "LoadFilterScript");
+	
+	char
+		*name;
+	amx_StrParam(amx, params[1], name);
+	if(name)
+	{
+		return CSAMPFunctions::LoadFilterscript(name);
+	}
+	return 0;
+}
+
+// UnLoadFilterScript(scriptname[]);
+static cell AMX_NATIVE_CALL Natives::UnLoadFilterScript(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "UnLoadFilterScript");
+	
+	char
+		*name;
+	amx_StrParam(amx, params[1], name);
+	if(name)
+	{
+		return CSAMPFunctions::UnLoadFilterscript(name);
+	}
+	return 0;
+}
+
+// native GetFilterScriptCount();
+static cell AMX_NATIVE_CALL Natives::GetFilterScriptCount(AMX *amx, cell *params)
+{
+	return pNetGame->pFilterScriptPool->iFilterScriptCount;
+}
+
+// native GetFilterScriptName(id, name[], len = sizeof(name));
+static cell AMX_NATIVE_CALL Natives::GetFilterScriptName(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(3, "GetFilterScriptName");
+
+	int id = static_cast<int>(params[1]);
+	if(id >= MAX_FILTER_SCRIPTS) return 0;
+
+	return set_amxstring(amx, params[2], pNetGame->pFilterScriptPool->szFilterScriptName[id], params[3]);
+}
+
+// native AddServerRule(name[], value[], flags = CON_VARFLAG_RULE);
+static cell AMX_NATIVE_CALL Natives::AddServerRule(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "AddServerRule");
+	
+	char *name, *value;
+	amx_StrParam(amx, params[1], name);
+	amx_StrParam(amx, params[2], value);
+	if (name && value)
+	{
+		ConsoleVariable_s* ConVar = CSAMPFunctions::FindVariable(name);
+		if (ConVar == NULL)
+		{
+			CSAMPFunctions::AddStringVariable(name, static_cast<int>(params[3]), value, NULL);
+			return 1;
+		}
+	}
+	return 0;
+}
+
+// native SetServerRule(name[], value[]);
+static cell AMX_NATIVE_CALL Natives::SetServerRule(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetServerRule");
+
+	char *name, *value;
+	amx_StrParam(amx, params[1], name);
+	amx_StrParam(amx, params[2], value);
+	if (name && value)
+	{
+		ConsoleVariable_s* ConVar = CSAMPFunctions::FindVariable(name);
+		if (ConVar != NULL)
+		{
+			CSAMPFunctions::SetStringVariable(name, value);
+			return 1;
+		}
+	}
+	return 0;
+}
+
+// native SetServerRuleInt(name[], value);
+static cell AMX_NATIVE_CALL Natives::SetServerRuleInt(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetServerRuleInt");
+
+	char *name;
+	amx_StrParam(amx, params[1], name);
+	if (name)
+	{
+		ConsoleVariable_s* ConVar = CSAMPFunctions::FindVariable(name);
+		if (ConVar != NULL)
+		{
+			CSAMPFunctions::SetIntVariable(name, static_cast<int>(params[2]));
+			return 1;
+		}
+		return 1;
+	}
+	return 0;
+}
+
+// native IsValidServerRule(name[]);
+static cell AMX_NATIVE_CALL Natives::IsValidServerRule(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsValidServerRule");
+
+	char *name;
+	amx_StrParam(amx, params[1], name);
+	if (name)
+	{
+		ConsoleVariable_s* ConVar = CSAMPFunctions::FindVariable(name);
+		return ConVar != NULL;
+	}
+	return 0;
+}
+
+// native RemoveServerRule(name[]);
+static cell AMX_NATIVE_CALL Natives::RemoveServerRule(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "RemoveServerRule");
+
+	char *name;
+	amx_StrParam(amx, params[1], name);
+	if (name)
+	{
+		//RemoveServerRule(name);
+		return 1;
+	}
+	return 0;
+}
+
+// native SetServerRuleFlags(name[], flags);
+static cell AMX_NATIVE_CALL Natives::SetServerRuleFlags(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetServerRuleFlags");
+	
+	char *name;
+	amx_StrParam(amx, params[1], name);
+	if (name)
+	{
+		CSAMPFunctions::ModifyVariableFlags(name, (DWORD)params[2]);
+		return 1;
+	}
+	return 0;
+}
+
+// native GetServerRuleFlags(name[]);
+static cell AMX_NATIVE_CALL Natives::GetServerRuleFlags(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetServerRuleFlags");
+	
+	char *name;
+	amx_StrParam(amx, params[1], name);
+	if (name)
+	{
+		ConsoleVariable_s* ConVar = CSAMPFunctions::FindVariable(name);
+		if (ConVar != NULL)
+		{
+			return ConVar->VarFlags;
+		}
+		return 0;
+	}
+	return 0;
+}
+
+// native GetServerSettings(&showplayermarkes, &shownametags, &stuntbonus, &useplayerpedanims, &bLimitchatradius, &disableinteriorenterexits, &nametaglos, &manualvehicleengine, 
+//		&limitplayermarkers, &vehiclefriendlyfire, &defaultcameracollision, &Float:fGlobalchatradius, &Float:fNameTagDrawDistance, &Float:fPlayermarkerslimit);
+static cell AMX_NATIVE_CALL Natives::GetServerSettings(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(14, "GetServerSettings");
+
+	cell *cptr;
+	amx_GetAddr(amx, params[1], &cptr); *cptr = (cell)pNetGame->bShowPlayerMarkers;
+	amx_GetAddr(amx, params[2], &cptr); *cptr = (cell)pNetGame->byteShowNameTags;
+	amx_GetAddr(amx, params[3], &cptr); *cptr = (cell)pNetGame->byteStuntBonus;
+	amx_GetAddr(amx, params[4], &cptr); *cptr = (cell)pNetGame->bUseCJWalk;
+	amx_GetAddr(amx, params[5], &cptr); *cptr = (cell)pNetGame->bLimitGlobalChatRadius;
+	amx_GetAddr(amx, params[6], &cptr); *cptr = (cell)pNetGame->byteDisableEnterExits;
+	amx_GetAddr(amx, params[7], &cptr); *cptr = (cell)pNetGame->byteNameTagLOS;
+	amx_GetAddr(amx, params[8], &cptr); *cptr = (cell)pNetGame->bManulVehicleEngineAndLights;
+	amx_GetAddr(amx, params[9], &cptr); *cptr = (cell)pNetGame->bLimitPlayerMarkers;
+	amx_GetAddr(amx, params[10], &cptr); *cptr = (cell)pNetGame->bVehicleFriendlyFire;
+	amx_GetAddr(amx, params[11], &cptr); *cptr = (cell)pNetGame->byteDefaultCameraCollision;
+	amx_GetAddr(amx, params[12], &cptr); *cptr = amx_ftoc(pNetGame->fGlobalChatRadius);
+	amx_GetAddr(amx, params[13], &cptr); *cptr = amx_ftoc(pNetGame->fNameTagDrawDistance);
+	amx_GetAddr(amx, params[14], &cptr); *cptr = amx_ftoc(pNetGame->fPlayerMarkesLimit);
+	return 1;
+}
+
+// native IsValidNickName(name[]);
+static cell AMX_NATIVE_CALL Natives::IsValidNickName(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsValidNickName");
+
+	char *name;
+	amx_StrParam(amx, params[1], name);
+	if (name)
+	{
+		return pServer->IsValidNick(name);
+	}
+	return 0;
+}
+
+// native AllowNickNameCharacter(character, bool:allow);
+static cell AMX_NATIVE_CALL Natives::AllowNickNameCharacter(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "AllowNickNameCharacter");
+	
+	char character = (char)params[1];
+
+	// Enable %s is disallowed
+	if(character == '%') return 0;
+
+	pServer->AllowNickNameCharacter(character, !!params[2]);
+	return 0;
+}
+
+// native IsNickNameCharacterAllowed(character);
+static cell AMX_NATIVE_CALL Natives::IsNickNameCharacterAllowed(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsNickNameCharacterAllowed");
+
+	return pServer->IsNickNameCharacterAllowed((char)params[1]);
+}
+
+/////////////// Timers
+
+// native GetAvailableClasses();
+static cell AMX_NATIVE_CALL Natives::GetAvailableClasses(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	return pNetGame->iSpawnsAvailable;
+}
+
+// native RemoveLastClass();
+static cell AMX_NATIVE_CALL Natives::RemoveLastClass(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	if(pNetGame->iSpawnsAvailable <= 0)
+		return 0;
+
+	pNetGame->iSpawnsAvailable--;
+	return 1;
+}
+
+// native GetPlayerClass(classid, &teamid, &modelid, &Float:spawn_x, &Float:spawn_y, &Float:spawn_z, &Float:z_angle, &weapon1, &weapon1_ammo, &weapon2, &weapon2_ammo,& weapon3, &weapon3_ammo);
+static cell AMX_NATIVE_CALL Natives::GetPlayerClass(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(13, "GetPlayerClass");
+
+	int classid = static_cast<int>(params[1]);
+	if(classid < 0 || classid > pNetGame->iSpawnsAvailable) return 0;
+
+	CPlayerSpawnInfo *pSpawn = &pNetGame->AvailableSpawns[classid];
+	
+	cell *cptr;
+	amx_GetAddr(amx, params[2], &cptr); *cptr = (cell)pSpawn->byteTeam;
+	amx_GetAddr(amx, params[3], &cptr); *cptr = (cell)pSpawn->iSkin;
+	amx_GetAddr(amx, params[4], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fX);
+	amx_GetAddr(amx, params[5], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fY);
+	amx_GetAddr(amx, params[6], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fZ);
+	amx_GetAddr(amx, params[7], &cptr); *cptr = amx_ftoc(pSpawn->fRotation);
+	amx_GetAddr(amx, params[8], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[0];
+	amx_GetAddr(amx, params[9], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[0];
+	amx_GetAddr(amx, params[10], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[1];
+	amx_GetAddr(amx, params[11], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[1];
+	amx_GetAddr(amx, params[12], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[2];
+	amx_GetAddr(amx, params[13], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[2];
+	return 1;
+}
+
+// native EditPlayerClass(classid, teamid, modelid, Float:spawn_x, Float:spawn_y, Float:spawn_z, Float:z_angle, weapon1, weapon1_ammo, weapon2, weapon2_ammo, weapon3, weapon3_ammo);
+static cell AMX_NATIVE_CALL Natives::EditPlayerClass(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(13, "EditPlayerClass");
+
+	int classid = static_cast<int>(params[1]);
+	if(classid < 0 || classid > pNetGame->iSpawnsAvailable) return 0;
+
+	CPlayerSpawnInfo *pSpawn = &pNetGame->AvailableSpawns[classid];
+
+	pSpawn->byteTeam = static_cast<BYTE>(params[2]);
+	pSpawn->iSkin = static_cast<int>(params[3]);
+	pSpawn->vecPos = CVector(amx_ctof(params[4]), amx_ctof(params[5]), amx_ctof(params[6]));
+	pSpawn->fRotation = amx_ctof(params[7]);
+	pSpawn->iSpawnWeapons[0] = static_cast<int>(params[8]);
+	pSpawn->iSpawnWeaponsAmmo[0] = static_cast<int>(params[9]);
+	pSpawn->iSpawnWeapons[1] = static_cast<int>(params[10]);
+	pSpawn->iSpawnWeaponsAmmo[1] = static_cast<int>(params[11]);
+	pSpawn->iSpawnWeapons[2] = static_cast<int>(params[12]);
+	pSpawn->iSpawnWeaponsAmmo[2] = static_cast<int>(params[13]);
+	return 1;
+}
+
+// native GetActiveTimers();
+static cell AMX_NATIVE_CALL Natives::GetRunningTimers(AMX *amx, cell *params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	return pNetGame->pScriptTimers->dwTimerCount;
+}
+
+// native SetGravity(Float:gravity);
+static cell AMX_NATIVE_CALL Natives::YSF_SetGravity( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "SetGravity");
+
+	pServer->SetGravity_(amx_ctof(params[1]));
+	return 1;
+}
+
+// native Float:GetGravity();
+static cell AMX_NATIVE_CALL Natives::YSF_GetGravity( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	float fGravity = pServer->GetGravity_();
+	return amx_ftoc(fGravity);
+}
+
+// native SetPlayerGravity(playerid, Float:gravity);
+static cell AMX_NATIVE_CALL Natives::SetPlayerGravity( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetPlayerGravity");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	// Update stored values
+	pPlayerData[playerid]->fGravity = amx_ctof(params[2]);
+
+	RakNet::BitStream bs;
+	bs.Write(pPlayerData[playerid]->fGravity);
+	pRakServer->RPC(&RPC_Gravity, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), 0, 0);
+	return 1;
+}
+
+// native Float:GetPlayerGravity(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerGravity( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerGravity");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return amx_ftoc(pPlayerData[playerid]->fGravity);
+}
+
+// native SetPlayerTeamForPlayer(playerid, teamplayerid, teamid);
+static cell AMX_NATIVE_CALL Natives::SetPlayerTeamForPlayer( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "SetPlayerTeamForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int teamplayerid = static_cast<int>(params[2]);
+	int team = static_cast<int>(params[3]);
+
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(teamplayerid)) return 0;
+	if (team < 0 || team > 255) return 0;
+
+	pPlayerData[playerid]->SetPlayerTeamForPlayer(static_cast<WORD>(teamplayerid), team);
+	return 1;
+}
+
+// native GetPlayerTeamForPlayer(playerid, teamplayerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerTeamForPlayer( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "GetPlayerTeamForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int teamplayerid = static_cast<int>(params[2]);
+
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(teamplayerid)) return 0;
+
+	return pPlayerData[playerid]->GetPlayerTeamForPlayer(static_cast<WORD>(teamplayerid));
+}
+
+static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerTeam(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetPlayerTeam");
+
+	int playerid = static_cast<int>(params[1]);
+	if(pSetPlayerTeam(amx, params))
+	{
+		for(WORD i = 0; i != MAX_PLAYERS; i++)
+		{
+			if(IsPlayerConnectedEx(i))
+				pPlayerData[i]->ResetPlayerTeam(static_cast<WORD>(playerid));
+		}
+		return 1;
+	}
+	return 0;
+}
+
+// native SetPlayerSkinForPlayer(playerid, skinplayerid, skin);
+static cell AMX_NATIVE_CALL Natives::SetPlayerSkinForPlayer(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "SetPlayerSkinForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int skinplayerid = static_cast<int>(params[2]);
+	int skin = static_cast<int>(params[3]);
+
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(skinplayerid)) return 0;
+	if (skin < 0 || skin > 300) return 0;
+
+	pPlayerData[playerid]->SetPlayerSkinForPlayer(static_cast<WORD>(skinplayerid), skin);
+	return 1;
+}
+
+// native GetPlayerSkinForPlayer(playerid, skinplayerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerSkinForPlayer(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "GetPlayerSkinForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int skinplayerid = static_cast<int>(params[2]);
+
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(skinplayerid)) return 0;
+
+	return pPlayerData[playerid]->GetPlayerSkinForPlayer(static_cast<WORD>(skinplayerid));
+}
+
+static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerSkin(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetPlayerSkin");
+
+	int playerid = static_cast<int>(params[1]);
+	if(pSetPlayerSkin(amx, params))
+	{
+		for(WORD i = 0; i != MAX_PLAYERS; i++)
+		{
+			if(IsPlayerConnectedEx(i))
+				pPlayerData[i]->ResetPlayerSkin(static_cast<WORD>(playerid));
+		}
+		return 1;
+	}
+	return 0;
+}
+
+// native SetPlayerNameForPlayer(playerid, nameplayerid, playername[]);
+static cell AMX_NATIVE_CALL Natives::SetPlayerNameForPlayer(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "SetPlayerNameForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int nameplayerid = static_cast<int>(params[2]);
+	char *name = NULL;
+
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(nameplayerid)) return 0;
+
+	amx_StrParam(amx, params[3], name);
+	//logprintf("playername: %s", name);
+
+	pPlayerData[playerid]->SetPlayerNameForPlayer(static_cast<WORD>(nameplayerid), name);
+	return 1;
+}
+
+// native GetPlayerNameForPlayer(playerid, nameplayerid, playername[], size = sizeof(playername));
+static cell AMX_NATIVE_CALL Natives::GetPlayerNameForPlayer(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(4, "GetPlayerNameForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int nameplayerid = static_cast<int>(params[2]);
+
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(nameplayerid)) return 0;
+
+	return set_amxstring(amx, params[3], pPlayerData[playerid]->GetPlayerNameForPlayer(static_cast<WORD>(nameplayerid)), params[4]);
+}
+
+static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerName(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetPlayerName");
+
+	int playerid = static_cast<int>(params[1]);
+	int ret = pSetPlayerName(amx, params);
+
+	if(ret == 1)
+	{
+		for(WORD i = 0; i != MAX_PLAYERS; i++)
+		{
+			if(IsPlayerConnectedEx(i))
+				pPlayerData[i]->ResetPlayerName(static_cast<WORD>(playerid));
+		}
+	}
+	return ret;
+}
+
+// native SetPlayerFightStyleForPlayer(playerid, styleplayerid, style);
+static cell AMX_NATIVE_CALL Natives::SetPlayerFightStyleForPlayer(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "SetPlayerFightStyleForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int styleplayerid = static_cast<int>(params[2]);
+	int style = static_cast<int>(params[3]);
+
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(styleplayerid)) return 0;
+
+	pPlayerData[playerid]->SetPlayerFightingStyleForPlayer(static_cast<WORD>(styleplayerid), style);
+	return 1;
+}
+
+// native GetPlayerFightStyleForPlayer(playerid, skinplayerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerFightStyleForPlayer(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "GetPlayerFightStyleForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int styleplayerid = static_cast<int>(params[2]);
+
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(styleplayerid)) return 0;
+
+	return pPlayerData[playerid]->GetPlayerFightingStyleForPlayer(static_cast<WORD>(styleplayerid));
+}
+
+static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerFightingStyle(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetPlayerFightingStyle");
+
+	int playerid = static_cast<int>(params[1]);
+	if(pSetPlayerFightingStyle(amx, params))
+	{
+		for(WORD i = 0; i != MAX_PLAYERS; i++)
+		{
+			if(IsPlayerConnectedEx(i))
+				pPlayerData[i]->ResetPlayerFightingStyle(static_cast<WORD>(playerid));
+		}
+		return 1;
+	}
+	return 0;
+}
+
+// native SetPlayerPosForPlayer(playerid, posplayerid, Float:fX, Float:fY, Float:fZ, bool:forcesync = true);
+static cell AMX_NATIVE_CALL Natives::SetPlayerPosForPlayer(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 5;
+
+	CHECK_PARAMS(6, "SetPlayerPosForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int posplayerid = static_cast<int>(params[2]);
+	bool forcesync = static_cast<int>(params[6]) != 0;
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(posplayerid)) return 0;
+
+	SAFE_DELETE(pPlayerData[playerid]->vecCustomPos[posplayerid]);
+
+	if(!forcesync)
+	{
+		pPlayerData[playerid]->bCustomPos[posplayerid] = false;
+		return 1;
+	}
+
+	CVector vecPos = CVector(amx_ctof(params[3]), amx_ctof(params[4]), amx_ctof(params[5]));
+		
+	pPlayerData[playerid]->vecCustomPos[posplayerid] = new CVector;
+	pPlayerData[playerid]->bCustomPos[posplayerid] = true;
+
+	memcpy(pPlayerData[playerid]->vecCustomPos[posplayerid], &vecPos, sizeof(CVector));
+	/*
+	RakNet::BitStream bs;
+	bs.Write(ID_PLAYER_SYNC);
+	bs.Write((WORD)posplayerid);
+	RebuildSyncData(&bs, playerid);
+	pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false);
+	*/
+	return 1;
+}
+
+// native SetPlayerRotationQuatForPlayer(playerid, quatplayerid, Float:w, Float:x, Float:y, Float:z, bool:forcesync = true);
+static cell AMX_NATIVE_CALL Natives::SetPlayerRotationQuatForPlayer(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 5;
+
+	CHECK_PARAMS(7, "SetPlayerRotationQuatForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int posplayerid = static_cast<int>(params[2]);
+	bool forcesync = static_cast<int>(params[4]) != 0;
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(posplayerid)) return 0;
+
+	if(!forcesync)
+	{
+		pPlayerData[playerid]->bCustomQuat[posplayerid] = false;
+		return 1;
+	}
+	
+	CPlayer *p = pNetGame->pPlayerPool->pPlayer[playerid];
+
+	pPlayerData[playerid]->fCustomQuat[posplayerid][0] = amx_ctof(params[3]);
+	pPlayerData[playerid]->fCustomQuat[posplayerid][1] = amx_ctof(params[4]);
+	pPlayerData[playerid]->fCustomQuat[posplayerid][2] = amx_ctof(params[5]);
+	pPlayerData[playerid]->fCustomQuat[posplayerid][3] = amx_ctof(params[6]);
+
+	pPlayerData[playerid]->bCustomQuat[posplayerid] = true;
+
+	RakNet::BitStream bs;
+	bs.Write((BYTE)ID_PLAYER_SYNC);
+	bs.Write((WORD)posplayerid);
+	bs.Write((bool)0); // bHasLR
+	bs.Write((bool)0); // bHasUD
+	bs.Write(p->syncData.wKeys); // bHasUD
+	
+	if(pPlayerData[playerid]->bCustomPos[posplayerid])
+		bs.Write(*pPlayerData[playerid]->vecCustomPos[posplayerid]);
+	else 
+		bs.Write(p->vecPosition);
+
+	bs.Write(pPlayerData[playerid]->fCustomQuat[posplayerid][0]);
+	bs.Write(pPlayerData[playerid]->fCustomQuat[posplayerid][1]);
+	bs.Write(pPlayerData[playerid]->fCustomQuat[posplayerid][2]);
+	bs.Write(pPlayerData[playerid]->fCustomQuat[posplayerid][3]);
+
+	pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false);
+	return 1;
+}
+
+// native ApplyAnimationForPlayer(playerid, animplayerid, animlib[], animname[], Float:fDelta, loop, lockx, locky, freeze, time);
+static cell AMX_NATIVE_CALL Natives::ApplyAnimationForPlayer(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(10, "ApplyAnimationForPlayer");
+	RakNet::BitStream bsSend;
+
+	char *szAnimLib;
+	char *szAnimName;
+	BYTE byteAnimLibLen;
+	BYTE byteAnimNameLen;
+	float fS;
+	bool opt1,opt2,opt3,opt4;
+	int time;
+	
+	int playerid = static_cast<int>(params[1]);
+	int animplayerid = static_cast<int>(params[2]);
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(animplayerid)) return 0;
+
+	amx_StrParam(amx, params[3], szAnimLib);
+	amx_StrParam(amx, params[4], szAnimName);
+
+	if(!szAnimLib || !szAnimName) return 0;
+
+	byteAnimLibLen = static_cast<BYTE>(strlen(szAnimLib));
+	byteAnimNameLen = static_cast<BYTE>(strlen(szAnimName));
+
+	fS = amx_ctof(params[5]);
+	opt1 = !!params[6];
+	opt2 = !!params[7];
+	opt3 = !!params[8];
+	opt4 = !!params[9];
+	time = static_cast<int>(params[10]);
+
+	bsSend.Write((WORD)animplayerid);
+	bsSend.Write(byteAnimLibLen);
+	bsSend.Write(szAnimLib,byteAnimLibLen);
+	bsSend.Write(byteAnimNameLen);
+	bsSend.Write(szAnimName,byteAnimNameLen);
+	bsSend.Write(fS);
+	bsSend.Write(opt1);
+	bsSend.Write(opt2);
+	bsSend.Write(opt3);
+	bsSend.Write(opt4);
+	bsSend.Write(time);
+
+	pRakServer->RPC(&RPC_ScrApplyAnimation, &bsSend, MEDIUM_PRIORITY, UNRELIABLE, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
+	return 1;
+}
+
+// native SetWeather(weatherid);
+static cell AMX_NATIVE_CALL Natives::YSF_SetWeather( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "SetWeather");
+
+	pServer->SetWeather_(static_cast<BYTE>(params[1]));
+	return 1;
+}
+
+// native SetPlayerWeather(playerid, weatherid);
+static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerWeather(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetPlayerWeather");
+
+	int playerid = static_cast<int>(params[1]);
+	if (!IsPlayerConnectedEx(playerid)) return 0;
+
+	// Update stored values
+	pPlayerData[playerid]->byteWeather = static_cast<BYTE>(params[2]);
+
+	RakNet::BitStream bs;
+	bs.Write(pPlayerData[playerid]->byteWeather);
+	pRakServer->RPC(&RPC_Weather, &bs, MEDIUM_PRIORITY, RELIABLE, 0, pRakServer->GetPlayerIDFromIndex(playerid), 0, 0);
+	return 1;
+}
+
+// native GetPlayerWeather(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerWeather( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerWeather");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pPlayerData[playerid]->byteWeather;
+}
+
+// native SetPlayerWorldBounds(playerid, Float:x_max, Float:x_min, Float:y_max, Float:y_min)
+static cell AMX_NATIVE_CALL Natives::YSF_SetPlayerWorldBounds(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(5, "SetPlayerWorldBounds");
+
+	int playerid = static_cast<int>(params[1]);
+
+	if(pSetPlayerWorldBounds(amx, params) && IsPlayerConnectedEx(playerid))
+	{
+		pPlayerData[playerid]->fBounds[0] = amx_ctof(params[2]);
+		pPlayerData[playerid]->fBounds[1] = amx_ctof(params[3]);
+		pPlayerData[playerid]->fBounds[2] = amx_ctof(params[4]);
+		pPlayerData[playerid]->fBounds[3] = amx_ctof(params[5]);
+	}
+	return 1;
+}
+
+// native DestroyObject(objectid)
+static cell AMX_NATIVE_CALL Natives::YSF_DestroyObject(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "DestroyObject");
+
+	int objectid = static_cast<int>(params[1]);
+
+	if(objectid < 0 || objectid > MAX_OBJECTS) return 0;
+	if(!pNetGame->pObjectPool->pObjects[objectid]) return 0;
+
+	if(pDestroyObject(amx, params))
+	{
+		pServer->COBJECT_AttachedObjectPlayer[objectid] = INVALID_PLAYER_ID;
+		return 1;
+	}
+	return 0;
+}
+
+// native DestroyPlayerObject(playerid, objectid)
+static cell AMX_NATIVE_CALL Natives::YSF_DestroyPlayerObject(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "DestroyPlayerObject");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+
+	if(objectid < 0 || objectid > MAX_OBJECTS) return 0;
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+
+	if(pDestroyPlayerObject(amx, params) && IsPlayerConnectedEx(playerid))
+	{
+		if(pPlayerData[playerid]->stObj[objectid].wObjectID != 0xFFFF || pPlayerData[playerid]->stObj[objectid].wAttachPlayerID != INVALID_PLAYER_ID)
+		{
+			pPlayerData[playerid]->stObj[objectid].wObjectID = INVALID_OBJECT_ID;
+			pPlayerData[playerid]->stObj[objectid].wAttachPlayerID = INVALID_PLAYER_ID;
+			pPlayerData[playerid]->stObj[objectid].vecOffset = CVector(0.0f, 0.0f, 0.0f);
+			pPlayerData[playerid]->stObj[objectid].vecRot = CVector(0.0f, 0.0f, 0.0f);		
+			pPlayerData[playerid]->dwCreateAttachedObj = 0;
+			pPlayerData[playerid]-> bAttachedObjectCreated = false;
+
+			//logprintf("remove attached shit");
+		}
+		return 1;
+	}
+	return 0;
+}
+
+// native TogglePlayerControllable(playerid, bool:toggle)
+static cell AMX_NATIVE_CALL Natives::YSF_TogglePlayerControllable(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "TogglePlayerControllable");
+
+	int playerid = static_cast<int>(params[1]);
+	bool toggle = static_cast<int>(params[2]) != 0;
+
+	if(pTogglePlayerControllable(amx, params) && IsPlayerConnectedEx(playerid))
+	{
+		pPlayerData[playerid]->bControllable = toggle;
+		return 1;
+	}
+	return 0;
+}
+
+// native ChangeVehicleColor(vehicleid, color1, color2)
+static cell AMX_NATIVE_CALL Natives::YSF_ChangeVehicleColor(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(pChangeVehicleColor(amx, params))
+	{
+		pServer->bChangedVehicleColor[vehicleid] = true;
+		return 1;
+	}
+	return 0;
+}
+
+static cell AMX_NATIVE_CALL Natives::YSF_DestroyVehicle(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(pDestroyVehicle(amx, params))
+	{
+		pServer->bChangedVehicleColor[vehicleid] = false;
+		return 1;
+	}
+	return 0;
+}
+
+// native TogglePlayerWidescreen(playerid, bool:set);
+static cell AMX_NATIVE_CALL Natives::TogglePlayerWidescreen( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "TogglePlayerWidescreen");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	BYTE set = static_cast<BYTE>(params[2]) != 0;
+	pPlayerData[playerid]->bWidescreen = !!set;
+
+	RakNet::BitStream bs;
+	bs.Write(set);
+	pRakServer->RPC(&RPC_Widescreen, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), 0, 0);
+	return 1;
+}
+
+// native IsPlayerWidescreenToggled(playerid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerWidescreenToggled( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsPlayerWideScreen");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pPlayerData[playerid]->bWidescreen;
+}
+
+// native GetSpawnInfo(playerid, &teamid, &modelid, &Float:spawn_x, &Float:spawn_y, &Float:spawn_z, &Float:z_angle, &weapon1, &weapon1_ammo, &weapon2, &weapon2_ammo,& weapon3, &weapon3_ammo);
+static cell AMX_NATIVE_CALL Natives::GetSpawnInfo( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(13, "GetSpawnInfo");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	CPlayerSpawnInfo *pSpawn = &pNetGame->pPlayerPool->pPlayer[playerid]->spawn;
+
+	cell *cptr;
+	amx_GetAddr(amx, params[2], &cptr); *cptr = (cell)pSpawn->byteTeam;
+	amx_GetAddr(amx, params[3], &cptr); *cptr = (cell)pSpawn->iSkin;
+	amx_GetAddr(amx, params[4], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fX);
+	amx_GetAddr(amx, params[5], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fY);
+	amx_GetAddr(amx, params[6], &cptr); *cptr = amx_ftoc(pSpawn->vecPos.fZ);
+	amx_GetAddr(amx, params[7], &cptr); *cptr = amx_ftoc(pSpawn->fRotation);
+	amx_GetAddr(amx, params[8], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[0];
+	amx_GetAddr(amx, params[9], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[0];
+	amx_GetAddr(amx, params[10], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[1];
+	amx_GetAddr(amx, params[11], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[1];
+	amx_GetAddr(amx, params[12], &cptr); *cptr = (cell)pSpawn->iSpawnWeapons[2];
+	amx_GetAddr(amx, params[13], &cptr); *cptr = (cell)pSpawn->iSpawnWeaponsAmmo[2];
+	return 1;
+}
+
+// native GetPlayerSkillLevel(playerid, skill);
+static cell AMX_NATIVE_CALL Natives::GetPlayerSkillLevel( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "GetPlayerSkillLevel");
+
+	int playerid = static_cast<int>(params[1]);
+	int skillid = static_cast<int>(params[2]);
+	
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(skillid < 0 || skillid > 10) return -1;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->wSkillLevel[skillid];
+}
+
+// native IsPlayerCheckpointActive(playerid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerCheckpointActive(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsPlayerCheckpointActive");
+
+	int playerid = static_cast<int>(params[1]);
+	if (!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->bShowCheckpoint;
+}
+
+// native GetPlayerCheckpoint(playerid, &Float:fX, &Float:fY, &Float:fZ, &Float:fSize);
+static cell AMX_NATIVE_CALL Natives::GetPlayerCheckpoint( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(5, "GetPlayerCheckpoint");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	cell* cptr;
+	CVector *vecPos = &pNetGame->pPlayerPool->pPlayer[playerid]->vecCPPos;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(vecPos->fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(vecPos->fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(vecPos->fZ);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(pNetGame->pPlayerPool->pPlayer[playerid]->fCPSize);
+	return 1;
+}
+
+// native IsPlayerRaceCheckpointActive(playerid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerRaceCheckpointActive(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsPlayerRaceCheckpointActive");
+
+	int playerid = static_cast<int>(params[1]);
+	if (!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->bShowRaceCheckpoint;
+}
+
+// native GetPlayerRaceCheckpoint(playerid, &Float:fX, &Float:fY, &Float:fZ, &Float:fNextX, &Float:fNextY, &fNextZ, &Float:fSize);
+static cell AMX_NATIVE_CALL Natives::GetPlayerRaceCheckpoint( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(8, "GetPlayerRaceCheckpoint");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	cell* cptr;
+	CVector *vecPos = &pNetGame->pPlayerPool->pPlayer[playerid]->vecRaceCPPos;
+	CVector *vecNextPos = &pNetGame->pPlayerPool->pPlayer[playerid]->vecRaceCPNextPos;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(vecPos->fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(vecPos->fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(vecPos->fZ);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(vecNextPos->fX);
+	amx_GetAddr(amx, params[6], &cptr);
+	*cptr = amx_ftoc(vecNextPos->fY);
+	amx_GetAddr(amx, params[7], &cptr);
+	*cptr = amx_ftoc(vecNextPos->fZ);
+	amx_GetAddr(amx, params[8], &cptr);
+	*cptr = amx_ftoc(pNetGame->pPlayerPool->pPlayer[playerid]->fRaceCPSize);
+	return 1;
+}
+
+// native GetPlayerWorldBounds(playerid, &Float:x_max, &Float:x_min, &Float:y_max, &Float:y_min);
+static cell AMX_NATIVE_CALL Natives::GetPlayerWorldBounds( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(5, "GetPlayerWorldBounds");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	cell* cptr;
+	float *fBounds = pPlayerData[playerid]->fBounds;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(fBounds[0]);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(fBounds[1]);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(fBounds[2]);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(fBounds[3]);
+	return 1;
+}
+
+// native IsPlayerInModShop(playerid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerInModShop( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsPlayerInModShop");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->bIsInModShop;
+}
+
+// native GetPlayerSirenState(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerSirenState( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerSirenState");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->wVehicleId) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->vehicleSyncData.byteSirenState;
+}
+
+// native GetPlayerLandingGearState(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerLandingGearState( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerLandingGearState");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->wVehicleId) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->vehicleSyncData.byteGearState;
+}
+
+// native GetPlayerHydraReactorAngle(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerHydraReactorAngle( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerHydraReactorAngle");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->wVehicleId) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->vehicleSyncData.wHydraReactorAngle[0];
+}
+
+// native Float:GetPlayerTrainSpeed(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerTrainSpeed( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerTrainSpeed");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->wVehicleId) return 0;
+
+	return amx_ftoc(pNetGame->pPlayerPool->pPlayer[playerid]->vehicleSyncData.fTrainSpeed);
+}
+
+// native Float:GetPlayerZAim(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerZAim( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerZAim");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return amx_ftoc(pNetGame->pPlayerPool->pPlayer[playerid]->aimSyncData.fZAim);
+}
+
+// native GetPlayerSurfingOffsets(playerid, &Float:fOffsetX, &Float:fOffsetY, &Float:fOffsetZ);
+static cell AMX_NATIVE_CALL Natives::GetPlayerSurfingOffsets( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(4, "GetPlayerSurfingOffsets");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	CVector vecPos = pNetGame->pPlayerPool->pPlayer[playerid]->syncData.vecSurfing;
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(vecPos.fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(vecPos.fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(vecPos.fZ);
+	return 1;
+}
+
+// native GetPlayerRotationQuat(playerid, &Float:w, &Float:x, &Float:y, &Float:z);
+static cell AMX_NATIVE_CALL Natives::GetPlayerRotationQuat( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(5, "GetPlayerRotationQuat");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	CPlayer *pPlayer = pNetGame->pPlayerPool->pPlayer[playerid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pPlayer->fQuaternion[0]);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pPlayer->fQuaternion[1]);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pPlayer->fQuaternion[2]);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(pPlayer->fQuaternion[3]);
+	return 1;
+}
+
+// native GetPlayerDialogID(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerDialogID( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerDialogID");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->wDialogID;
+}
+
+// native GetPlayerSpectateID(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerSpectateID( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerSpectateID");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->wSpectateID;
+}
+
+// native GetPlayerSpectateType(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerSpectateType( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerSpectateType");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->byteSpectateType;
+}
+
+// native GetPlayerLastSyncedVehicleID(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerLastSyncedVehicleID(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerLastSyncedVehicleID");
+
+	int playerid = static_cast<int>(params[1]);
+	if (!IsPlayerConnectedEx(playerid)) return 0;
+
+	return (cell)pNetGame->pPlayerPool->pPlayer[playerid]->vehicleSyncData.wVehicleId;
+}
+
+// native GetPlayerLastSyncedTrailerID(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerLastSyncedTrailerID(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerLastSyncedTrailerID");
+
+	int playerid = static_cast<int>(params[1]);
+	if (!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->trailerSyncData.wTrailerID;  //* (WORD*)(((char*)pNetGame->pPlayerPool->pPlayer[playerid]) + 271);
+}
+
+// native GetPlayerFPS(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerFPS(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerFPS");
+
+	// TODO
+	return 1;
+}
+
+// native GetActorSpawnInfo(actorid, &skinid, &Float:fX, &Float:fY, &Float:fZ, &Float:fAngle);
+static cell AMX_NATIVE_CALL Natives::GetActorSpawnInfo(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(6, "GetActorSpawnInfo");
+
+	int actorid = static_cast<int>(params[1]);
+	if(actorid < 0 || actorid > MAX_PLAYERS) return 0;
+
+	CActor *pActor = pNetGame->pActorPool->pActor[actorid];
+	if(!pActor) return 0;
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = (cell)pActor->iSkinID;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pActor->vecSpawnPos.fX);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pActor->vecSpawnPos.fY);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(pActor->vecSpawnPos.fZ);
+	amx_GetAddr(amx, params[6], &cptr);
+	*cptr = amx_ftoc(pActor->fSpawnAngle);
+	return 1;
+}
+
+// native GetActorSkin(actorid);
+static cell AMX_NATIVE_CALL Natives::GetActorSkin(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetActorSkin");
+
+	int actorid = static_cast<int>(params[1]);
+	if(actorid < 0 || actorid > MAX_PLAYERS) return 0;
+
+	CActor *pActor = pNetGame->pActorPool->pActor[actorid];
+	if(!pActor) return 0;
+
+	return pActor->iSkinID;
+}
+
+
+// native GetActorAnimation(actorid, animlib[], animlibsize = sizeof(animlib), animname[], animnamesize = sizeof(animname), &Float:fDelta, &loop, &lockx, &locky, &freeze, &time)
+static cell AMX_NATIVE_CALL Natives::GetActorAnimation(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(11, "GetActorAnimation");
+
+	int actorid = static_cast<int>(params[1]);
+	if(actorid < 0 || actorid > MAX_PLAYERS) return 0;
+
+	CActor *pActor = pNetGame->pActorPool->pActor[actorid];
+	if(!pActor) return 0;
+
+	set_amxstring(amx, params[2], pActor->anim.szAnimLib, params[3]);
+	set_amxstring(amx, params[4], pActor->anim.szAnimName, params[5]);
+
+	cell* cptr;
+	amx_GetAddr(amx, params[6], &cptr);
+	*cptr = amx_ftoc(pActor->anim.fDelta);
+	amx_GetAddr(amx, params[7], &cptr);
+	*cptr = *(cell*)pActor->anim.byteLoop;
+	amx_GetAddr(amx, params[8], &cptr);
+	*cptr = *(cell*)pActor->anim.byteLockX;
+	amx_GetAddr(amx, params[9], &cptr);
+	*cptr = *(cell*)pActor->anim.byteLockY;
+	amx_GetAddr(amx, params[10], &cptr);
+	*cptr = *(cell*)pActor->anim.byteFreeze;
+	amx_GetAddr(amx, params[11], &cptr);
+	*cptr = *(cell*)pActor->anim.iTime;
+	return 1;
+}
+
+// native SendBulletData(sender, hitid, hittype, weaponid, Float:fHitOriginX, Float:fHitOriginY, Float:fHitOriginZ, Float:fHitTargetX, Float:fHitTargetY, Float:fHitTargetZ, Float:fCenterOfHitX, Float:fCenterOfHitY, Float:fCenterOfHitZ, forplayerid = -1);
+static cell AMX_NATIVE_CALL Natives::SendBulletData( AMX* amx, cell* params ) 
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(14, "SendBulletData");
+
+	int playerid = static_cast<int>(params[1]);
+	int forplayerid = static_cast<int>(params[14]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(forplayerid != -1)
+	{
+		if(!IsPlayerConnectedEx(forplayerid)) return 0;
+	}
+
+	CBulletSyncData bulletSync;
+	bulletSync.byteHitType = static_cast<BYTE>(params[3]);
+	bulletSync.wHitID = static_cast<WORD>(params[2]);
+	bulletSync.byteWeaponID = static_cast<BYTE>(params[4]);
+	bulletSync.vecHitOrigin = CVector(amx_ctof(params[5]), amx_ctof(params[6]), amx_ctof(params[7]));
+	bulletSync.vecHitTarget = CVector(amx_ctof(params[8]), amx_ctof(params[9]), amx_ctof(params[10]));
+	bulletSync.vecCenterOfHit = CVector(amx_ctof(params[11]), amx_ctof(params[12]), amx_ctof(params[13]));
+
+	RakNet::BitStream bs;
+	bs.Write((BYTE)ID_BULLET_SYNC);
+	bs.Write((WORD)playerid);
+	bs.Write((char*)&bulletSync, sizeof(CBulletSyncData));
+
+	if(forplayerid == -1)
+	{
+		pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true);
+	}
+	else
+	{
+		pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), false);
+	}
+	return 1;
+}
+
+// native ShowPlayerForPlayer(forplayerid, playerid);
+static cell AMX_NATIVE_CALL Natives::ShowPlayerForPlayer( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "ShowPlayerForPlayer");
+
+	int forplayerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(forplayerid)) return 0;
+
+	int playerid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(playerid == forplayerid) return 0;
+
+	RakNet::BitStream bs;
+	bs.Write((WORD)playerid);
+	pRakServer->RPC(&RPC_WorldPlayerAdd, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0);
+	return 1;
+}
+
+// native HidePlayerForPlayer(forplayerid, playerid);
+static cell AMX_NATIVE_CALL Natives::HidePlayerForPlayer( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "HidePlayerForPlayer");
+
+	int forplayerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(forplayerid)) return 0;
+
+	int playerid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(playerid == forplayerid) return 0;
+
+	RakNet::BitStream bs;
+	bs.Write((WORD)playerid);
+	pRakServer->RPC(&RPC_WorldPlayerRemove, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0);
+	return 1;
+}
+
+// native AddPlayerForPlayer(forplayerid, playerid, isnpc = 0);
+static cell AMX_NATIVE_CALL Natives::AddPlayerForPlayer( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "AddPlayerForPlayer");
+
+	int forplayerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(forplayerid)) return 0;
+
+	int playerid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(playerid == forplayerid) return 0;
+
+	bool npc = static_cast<int>(params[3]) != 0;
+	char* szName = GetPlayerName_(playerid);
+	BYTE len = static_cast<BYTE>(strlen(szName));
+
+	RakNet::BitStream bs;
+	bs.Write((WORD)playerid);
+	bs.Write((DWORD)0);
+	bs.Write((BYTE)npc); //  // isNPC
+	bs.Write(len);
+	bs.Write(szName, len);
+	pRakServer->RPC(&RPC_ServerJoin, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0);
+	return 1;
+}
+
+// native RemovePlayerForPlayer(forplayerid, playerid);
+static cell AMX_NATIVE_CALL Natives::RemovePlayerForPlayer( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "RemovePlayerForPlayer");
+
+	int forplayerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(forplayerid)) return 0;
+
+	int playerid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(playerid == forplayerid) return 0;
+
+	RakNet::BitStream bs;
+	bs.Write((WORD)playerid);
+	bs.Write((BYTE)0); 
+	pRakServer->RPC(&RPC_ServerQuit, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0);
+	return 1;
+}
+
+// native SetPlayerChatBubbleForPlayer(forplayerid, playerid, text[], color, Float:drawdistance, expiretime);
+static cell AMX_NATIVE_CALL Natives::SetPlayerChatBubbleForPlayer( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(6, "SetPlayerChatBubbleForPlayer");
+
+	int forplayerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(forplayerid)) return 0;
+
+	int playerid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	int color = static_cast<int>(params[4]);
+	float drawdistance = amx_ctof(params[5]);
+	int expiretime = static_cast<int>(params[6]);
+
+	char *str;
+	amx_StrParam(amx, params[3], str);
+	if(str)
+	{
+		BYTE len = static_cast<BYTE>(strlen(str));
+		RakNet::BitStream bs;
+		bs.Write((WORD)playerid);
+		bs.Write(color);
+		bs.Write(drawdistance);
+		bs.Write(expiretime);
+		bs.Write(len);
+		bs.Write(str, len);
+		pRakServer->RPC(&RPC_ChatBubble, &bs, LOW_PRIORITY, RELIABLE, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0);
+		return 1;
+	}
+	return 0;
+}
+
+// native ResetPlayerMarkerForPlayer(playerid, resetplayerid)
+static cell AMX_NATIVE_CALL Natives::ResetPlayerMarkerForPlayer(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "ResetPlayerMarkerForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int resetplayerid = static_cast<int>(params[2]);
+
+	if (!IsPlayerConnectedEx(playerid) || !IsPlayerConnectedEx(resetplayerid)) return 0;
+
+	return pPlayerData[playerid]->ResetPlayerMarkerForPlayer(static_cast<WORD>(resetplayerid));
+}
+
+// native SetPlayerVersion(playerid, version[];
+static cell AMX_NATIVE_CALL Natives::SetPlayerVersion( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetPlayerVersion");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	
+	char *version;
+	amx_StrParam(amx, params[2], version);
+
+	if (version && strlen(version) < 28)
+	{
+		pNetGame->pPlayerPool->szVersion[playerid][0] = NULL;
+		strcpy(pNetGame->pPlayerPool->szVersion[playerid], version);
+		return 1;
+	}
+	return 0;
+}
+
+// native IsPlayerSpawned(playerid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerSpawned( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsPlayerSpawned");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	int state = pNetGame->pPlayerPool->pPlayer[playerid]->byteState;
+	return (state != PLAYER_STATE_NONE && state != PLAYER_STATE_WASTED && state != PLAYER_STATE_SPAWNED && pNetGame->pPlayerPool->pPlayer[playerid]->bHasSpawnInfo);
+}
+
+// native IsPlayerControllable(playerid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerControllable( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsPlayerSpawned");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pPlayerData[playerid]->bControllable;
+}
+
+// native SpawnForWorld(playerid);
+static cell AMX_NATIVE_CALL Natives::SpawnForWorld(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "SpawnForWorld");
+
+	int playerid = static_cast<int>(params[1]);
+	if (!IsPlayerConnectedEx(playerid)) return 0;
+
+	CSAMPFunctions::SpawnPlayer_(playerid);
+	return 1;
+}
+
+// native BroadcastDeath(playerid);
+static cell AMX_NATIVE_CALL Natives::BroadcastDeath(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "BroadcastDeath");
+
+	int playerid = static_cast<int>(params[1]);
+	if (!IsPlayerConnectedEx(playerid)) return 0;
+
+	RakNet::BitStream bsData;
+	bsData.Write((WORD)playerid);
+	pRakServer->RPC(&RPC_DeathBroadcast, &bsData, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), true, false);
+	return 1;
+}
+
+// native IsPlayerCameraTargetEnabled(playerid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerCameraTargetEnabled( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsPlayerCameraTargetEnabled");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->bCameraTarget;
+}
+
+// native SetPlayerDisabledKeysSync(playerid, keys);
+static cell AMX_NATIVE_CALL Natives::SetPlayerDisabledKeysSync( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetPlayerDisabledKeySync");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	pPlayerData[playerid]->dwDisabledKeys = static_cast<WORD>(params[2]);
+	return 1;
+}
+
+// native GetPlayerDisabledKeysSync(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerDisabledKeysSync( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "SetPlayerDisabledKeySync");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pPlayerData[playerid]->dwDisabledKeys;
+}
+
+// Scoreboard manipulation
+// native TogglePlayerScoresPingsUpdate(playerid, bool:toggle);
+static cell AMX_NATIVE_CALL Natives::TogglePlayerScoresPingsUpdate(AMX *amx, cell *params)
+{
+	if(!pServer) return 0;
+
+	CHECK_PARAMS(2, "TogglePlayerScoresPingsUpdate");
+
+	int playerid = static_cast<int>(params[1]);
+	bool toggle = static_cast<int>(params[2]) != 0;
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	pPlayerData[playerid]->bUpdateScoresPingsDisabled = !toggle;
+	return 1;
+}
+
+// native TogglePlayerFakePing(playerid, bool:toggle);
+static cell AMX_NATIVE_CALL Natives::TogglePlayerFakePing(AMX *amx, cell *params)
+{
+	if(!pServer) return 0;
+
+	CHECK_PARAMS(2, "TogglePlayerFakePing");
+
+	int playerid = static_cast<int>(params[1]);
+	bool toggle = static_cast<int>(params[2]) != 0;
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	pPlayerData[playerid]->bFakePingToggle = toggle;
+	return 1;
+}
+
+// native SetPlayerFakePing(playerid, ping);
+static cell AMX_NATIVE_CALL Natives::SetPlayerFakePing(AMX *amx, cell *params)
+{
+	if(!pServer) return 0;
+
+	CHECK_PARAMS(2, "SetPlayerFakePing");
+
+	int playerid = static_cast<int>(params[1]);
+	int fakeping = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	pPlayerData[playerid]->dwFakePingValue = fakeping;
+	return 1;
+}
+
+// native TogglePlayerInServerQuery(playerid, bool:toggle);
+static cell AMX_NATIVE_CALL Natives::TogglePlayerInServerQuery(AMX *amx, cell *params)
+{
+	if (!pServer) return 0;
+
+	CHECK_PARAMS(2, "TogglePlayerInServerQuery");
+
+	int playerid = static_cast<int>(params[1]);
+	if (!IsPlayerConnectedEx(playerid)) return 0;
+
+	pPlayerData[playerid]->bHidden = !(!!params[2]);
+	return 1;
+}
+
+// native IsPlayerToggledInServerQuery(playerid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerToggledInServerQuery(AMX *amx, cell *params)
+{
+	if (!pServer) return 0;
+
+	CHECK_PARAMS(1, "IsPlayerToggledInServerQuery");
+
+	int playerid = static_cast<int>(params[1]);
+	if (!IsPlayerConnectedEx(playerid)) return 0;
+
+	return !pPlayerData[playerid]->bHidden;
+}
+
+// native IsPlayerPaused(playerid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerPaused(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(1, "IsPlayerPaused");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pPlayerData[playerid]->bAFKState;
+}
+
+// native GetPlayerPausedTime(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerPausedTime(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(1, "GetPlayerPausedTime");
+
+	int playerid = static_cast<int>(params[1]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(!pPlayerData[playerid]->bAFKState) return 0;
+
+	return GetTickCount() - pPlayerData[playerid]->dwLastUpdateTick;
+}
+
+// Objects - global
+// native Float:GetObjectDrawDistance(objectid);
+static cell AMX_NATIVE_CALL Natives::GetObjectDrawDistance( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetObjectDrawDistance");
+
+	int objectid = static_cast<int>(params[1]);
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
+
+	return amx_ftoc(pNetGame->pObjectPool->pObjects[objectid]->fDrawDistance);
+}
+
+// native Float:SetObjectMoveSpeed(objectid, Float:fSpeed);
+static cell AMX_NATIVE_CALL Natives::SetObjectMoveSpeed( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetObjectMoveSpeed");
+
+	int objectid = static_cast<int>(params[1]);
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
+
+	pNetGame->pObjectPool->pObjects[objectid]->fMoveSpeed = amx_ctof(params[2]);
+	return 1;
+}
+
+// native Float:GetObjectMoveSpeed(objectid);
+static cell AMX_NATIVE_CALL Natives::GetObjectMoveSpeed( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetObjectMoveSpeed");
+
+	int objectid = static_cast<int>(params[1]);
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
+
+	return amx_ftoc(pNetGame->pObjectPool->pObjects[objectid]->fMoveSpeed);
+}
+
+// native GetObjectTarget(objectid, &Float:fX, &Float:fY, &Float:fZ);
+static cell AMX_NATIVE_CALL Natives::GetObjectTarget( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(4, "GetObjectTarget");
+
+	int objectid = static_cast<int>(params[1]);
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
+
+	cell* cptr;
+	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pObject->matTarget.pos.fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pObject->matTarget.pos.fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pObject->matTarget.pos.fZ);
+	return 1;
+}
+
+// native GetObjectAttachedData(objectid, &vehicleid, &objectid, &attachedplayerid);
+static cell AMX_NATIVE_CALL Natives::GetObjectAttachedData( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(4, "GetObjectAttachedData");
+
+	int objectid = static_cast<int>(params[1]);
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+	
+	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
+
+	cell* cptr;
+	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = (cell)pObject->wAttachedVehicleID;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = (cell)pObject->wAttachedObjectID;
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = (cell)pServer->COBJECT_AttachedObjectPlayer[objectid];
+	return 1;
+}
+
+// native GetObjectAttachedOffset(objectid, &Float:fX, &Float:fY, &Float:fZ, &Float:fRotX, &Float:fRotY, &Float:fRotZ);
+static cell AMX_NATIVE_CALL Natives::GetObjectAttachedOffset( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(7, "GetObjectAttachedOffset");
+
+	int objectid = static_cast<int>(params[1]);
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+
+	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
+
+	cell* cptr;
+	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pObject->vecAttachedOffset.fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pObject->vecAttachedOffset.fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pObject->vecAttachedOffset.fZ);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(pObject->vecAttachedRotation.fX);
+	amx_GetAddr(amx, params[6], &cptr);
+	*cptr = amx_ftoc(pObject->vecAttachedRotation.fY);
+	amx_GetAddr(amx, params[7], &cptr);
+	*cptr = amx_ftoc(pObject->vecAttachedRotation.fZ);
+	return 1;
+}
+
+// native IsObjectMaterialSlotUsed(objectid, materialindex); // Return values: 1 = material, 2 = material text
+static cell AMX_NATIVE_CALL Natives::IsObjectMaterialSlotUsed( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "IsObjectMaterialSlotUsed");
+
+	int objectid = static_cast<int>(params[1]);
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+
+	int materialindex = static_cast<int>(params[2]);
+	if(materialindex < 0 || materialindex >= 16) return 0;
+
+	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
+
+	int i = 0;
+	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
+	
+	// Nothing to comment here..
+	while(i != 16)
+	{
+		if(pObject->Material[i].byteSlot == materialindex) break;
+		i++;
+	}
+	if(i == 16) return 0;
+
+	return pObject->Material[i].byteUsed;
+}
+
+// native GetObjectMaterial(objectid, materialindex, &modelid, txdname[], txdnamelen = sizeof(txdname), texturename[], texturenamelen = sizeof(texturename), &materialcolor);
+static cell AMX_NATIVE_CALL Natives::GetObjectMaterial( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(8, "GetObjectMaterial");
+
+	int objectid = static_cast<int>(params[1]);
+	int materialindex = static_cast<int>(params[2]);
+
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+	if(materialindex < 0 || materialindex >= 16) return 0;
+
+	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
+
+	int i = 0;
+	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
+
+	// Nothing to comment here..
+	while(i != 16)
+	{
+		if(pObject->Material[i].byteSlot == materialindex) break;
+		i++;
+	}
+	if(i == 16) return 0;
+
+	cell *cptr;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = (cell)pObject->Material[i].wModelID; //  modelid
+
+	set_amxstring(amx, params[4], pObject->Material[i].szMaterialTXD, params[5]); // txdname[], txdnamelen = sizeof(txdname)
+	set_amxstring(amx, params[6], pObject->Material[i].szMaterialTexture, params[7]); // texturenamelen = sizeof(txdnamelen),
+
+	amx_GetAddr(amx, params[8], &cptr);
+	*cptr = ABGR_ARGB(pObject->Material[i].dwMaterialColor); // materialcolor
+	return 1;
+}
+
+// native GetObjectMaterialText(objectid, materialindex, text[], textlen = sizeof(text), &materialsize, fontface[], fontfacelen = sizeof(fontface), &fontsize, &bold, &fontcolor, &backcolor, &textalignment);
+static cell AMX_NATIVE_CALL Natives::GetObjectMaterialText( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(12, "GetObjectMaterialText");
+
+	int objectid = static_cast<int>(params[1]);
+	int materialindex = static_cast<int>(params[2]);
+
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+	if(materialindex < 0 || materialindex >= 16) return 0;
+
+	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
+
+	int i = 0;
+	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
+
+	// Nothing to comment here..
+	while(i != 16)
+	{
+		if(pObject->Material[i].byteSlot == materialindex) break;
+		i++;
+	}
+	if(i == 16) return 0;
+
+	cell *cptr;
+
+	set_amxstring(amx, params[3], pObject->szMaterialText[i], params[4]); 
+
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = (cell)pObject->Material[i].byteMaterialSize; // materialsize
+
+	set_amxstring(amx, params[6], pObject->Material[i].szFont, params[7]); 
+
+	amx_GetAddr(amx, params[8], &cptr);
+	*cptr = (cell)pObject->Material[i].byteFontSize; // fontsize
+	amx_GetAddr(amx, params[9], &cptr);
+	*cptr = (cell)pObject->Material[i].byteBold; // bold
+	amx_GetAddr(amx, params[10], &cptr);
+	*cptr = (cell)pObject->Material[i].dwFontColor; // fontcolor
+	amx_GetAddr(amx, params[11], &cptr);
+	*cptr = (cell)pObject->Material[i].dwBackgroundColor; // backcolor
+	amx_GetAddr(amx, params[12], &cptr);
+	*cptr = (cell)pObject->Material[i].byteAlignment; // textalignment
+	return 1;
+}
+
+// native IsObjectNoCameraCol(objectid);
+static cell AMX_NATIVE_CALL Natives::IsObjectNoCameraCol( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsObjectNoCameraCol");
+
+	int objectid = static_cast<int>(params[1]);
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+
+	if(!pNetGame->pObjectPool->bObjectSlotState[objectid]) return 0;
+
+	return pNetGame->pObjectPool->pObjects[objectid]->bNoCameraCol;
+}
+
+// native Float:GetPlayerObjectDrawDistance(playerid, objectid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerObjectDrawDistance( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "GetPlayerObjectDrawDistance");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(objectid < 0 || objectid >= 1000) return 0;
+
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+
+	return amx_ftoc(pNetGame->pObjectPool->pPlayerObjects[playerid][objectid]->fDrawDistance);
+}
+
+// native Float:SetPlayerObjectMoveSpeed(playerid, objectid, Float:fSpeed);
+static cell AMX_NATIVE_CALL Natives::SetPlayerObjectMoveSpeed( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "SetPlayerObjectMoveSpeed");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+
+	pNetGame->pObjectPool->pPlayerObjects[playerid][objectid]->fMoveSpeed = amx_ctof(params[3]);
+	return 1;
+}
+
+// native Float:GetPlayerObjectMoveSpeed(playerid, objectid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerObjectMoveSpeed( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "GetPlayerObjectMoveSpeed");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+
+	return amx_ftoc(pNetGame->pObjectPool->pPlayerObjects[playerid][objectid]->fMoveSpeed);
+}
+
+// native Float:GetPlayerObjectTarget(playerid, objectid, &Float:fX, &Float:fY, &Float:fZ);
+static cell AMX_NATIVE_CALL Natives::GetPlayerObjectTarget( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(5, "GetPlayerObjectTarget");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+
+	cell* cptr;
+	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pObject->matTarget.pos.fX);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pObject->matTarget.pos.fY);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(pObject->matTarget.pos.fZ);
+	return 1;
+}
+
+// native GetPlayerObjectAttachedData(playerid, objectid, &vehicleid, &objectid, &attachedplayerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerObjectAttachedData( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(5, "GetPlayerObjectAttachedData");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+	
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+
+	cell* cptr;
+	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = (cell)pObject->wAttachedVehicleID;
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = (cell)pPlayerData[playerid]->stObj[objectid].wObjectID;
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = (cell)pPlayerData[playerid]->stObj[objectid].wAttachPlayerID;
+	return 1;
+}
+
+// native GetPlayerObjectAttachedOffset(playerid, objectid, &Float:fX, &Float:fY, &Float:fZ, &Float:fRotX, &Float:fRotY, &Float:fRotZ);
+static cell AMX_NATIVE_CALL Natives::GetPlayerObjectAttachedOffset( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(8, "GetPlayerObjectAttachedOffset");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+
+	cell* cptr;
+	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
+	
+	CVector* vecOffset = NULL;
+	CVector* vecRot = NULL;
+	
+	if(pObject->wAttachedVehicleID)
+	{
+		vecOffset = &pObject->vecAttachedOffset;
+		vecRot = &pObject->vecAttachedRotation;
+	}
+	else
+	{
+		vecOffset = &pPlayerData[playerid]->stObj[objectid].vecOffset;
+		vecRot = &pPlayerData[playerid]->stObj[objectid].vecRot;
+	}
+	
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(vecOffset->fX);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(vecOffset->fY);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(vecOffset->fZ);
+	amx_GetAddr(amx, params[6], &cptr);
+	*cptr = amx_ftoc(vecRot->fX);
+	amx_GetAddr(amx, params[7], &cptr);
+	*cptr = amx_ftoc(vecRot->fY);
+	amx_GetAddr(amx, params[8], &cptr);
+	*cptr = amx_ftoc(vecRot->fZ);
+	return 1;
+}
+
+// native IsPlayerObjectMaterialSlotUsed(playerid, objectid, materialindex); // Return values: 1 = material, 2 = material text
+static cell AMX_NATIVE_CALL Natives::IsPlayerObjectMaterialSlotUsed( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "IsPlayerObjectMaterialSlotUsed");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	int materialindex = static_cast<int>(params[3]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+	if(materialindex < 0 || materialindex >= 16) return 0;
+
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+
+	int i = 0;
+	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
+	
+	// Nothing to comment here..
+	while(i != 16)
+	{
+		if(pObject->Material[i].byteSlot == materialindex) break;
+		i++;
+	}
+	if(i == 16) return 0;
+
+	return pObject->Material[i].byteUsed;
+}
+
+
+// native GetPlayerObjectMaterial(playerid, objectid, materialindex, &modelid, txdname[], txdnamelen = sizeof(txdname), texturename[], texturenamelen = sizeof(texturename), &materialcolor);
+static cell AMX_NATIVE_CALL Natives::GetPlayerObjectMaterial( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(9, "GetPlayerObjectMaterial");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	int materialindex = static_cast<int>(params[3]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+	if(materialindex < 0 || materialindex >= 16) return 0;
+
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+
+	cell* cptr;
+	int i = 0;
+	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
+	
+	// Nothing to comment here..
+	while(i != 16)
+	{
+		if(pObject->Material[i].byteSlot == materialindex) break;
+		i++;
+	}
+	if(i == 16) return 0;
+
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = (cell)pObject->Material[i].wModelID; //  modelid
+
+	set_amxstring(amx, params[5], pObject->Material[i].szMaterialTXD, params[6]); // txdname[], txdnamelen = sizeof(txdname)
+	set_amxstring(amx, params[7], pObject->Material[i].szMaterialTexture, params[8]); // texturenamelen = sizeof(txdnamelen),
+
+	amx_GetAddr(amx, params[9], &cptr);
+	*cptr = ABGR_ARGB(pObject->Material[i].dwMaterialColor); // materialcolor
+	return 1;
+}
+
+// native GetPlayerObjectMaterialText(playerid, objectid, materialindex, text[], textlen = sizeof(text), &materialsize, fontface[], fontfacelen = sizeof(fontface), &fontsize, &bold, &fontcolor, &backcolor, &textalignment);
+static cell AMX_NATIVE_CALL Natives::GetPlayerObjectMaterialText( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(13, "GetPlayerObjectMaterialText");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	int materialindex = static_cast<int>(params[3]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+	if(materialindex < 0 || materialindex >= 16) return 0;
+
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+
+	cell* cptr;
+	int i = 0;
+	CObject *pObject = pNetGame->pObjectPool->pPlayerObjects[playerid][objectid];
+	
+	// Nothing to comment here..
+	while(i != 16)
+	{
+		if(pObject->Material[i].byteSlot == materialindex) break;
+		i++;
+	}
+	if(i == 16) return 0;
+
+	set_amxstring(amx, params[4], pObject->szMaterialText[i], params[5]); 
+
+	amx_GetAddr(amx, params[6], &cptr);
+	*cptr = (cell)pObject->Material[i].byteMaterialSize; // materialsize
+
+	set_amxstring(amx, params[7], pObject->Material[i].szFont, params[8]); 
+
+	amx_GetAddr(amx, params[9], &cptr);
+	*cptr = (cell)pObject->Material[i].byteFontSize; // fontsize
+	amx_GetAddr(amx, params[10], &cptr);
+	*cptr = (cell)pObject->Material[i].byteBold; // bold
+	amx_GetAddr(amx, params[11], &cptr);
+	*cptr = (cell)pObject->Material[i].dwFontColor; // fontcolor
+	amx_GetAddr(amx, params[12], &cptr);
+	*cptr = (cell)pObject->Material[i].dwBackgroundColor; // backcolor
+	amx_GetAddr(amx, params[13], &cptr);
+	*cptr = (cell)pObject->Material[i].byteAlignment; // textalignment
+	return 1;
+}
+
+// native IsPlayerObjectNoCameraCol(playerid, objectid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerObjectNoCameraCol( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "IsPlayerObjectNoCameraCol");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+
+	return pNetGame->pObjectPool->pPlayerObjects[playerid][objectid]->bNoCameraCol;
+}
+
+// native GetPlayerSurfingPlayerObjectID(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerSurfingPlayerObjectID( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerSurfingPlayerObjectID");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return INVALID_OBJECT_ID;
+
+	int surf = pPlayerData[playerid]->wSurfingInfo - MAX_VEHICLES;
+	if(surf >= 0 && surf < MAX_OBJECTS)
+	{
+		if(pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][surf])
+			return surf;
+	}
+	return INVALID_OBJECT_ID;
+}
+
+// native GetPlayerCameraTargetPlayerObj(playerid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerCameraTargetPlayerObj( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPlayerCameraTargetPlayerObj");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return INVALID_OBJECT_ID;
+	
+	CPlayer *pPlayer = pNetGame->pPlayerPool->pPlayer[playerid];
+	if(!pPlayer->bCameraTarget) return INVALID_OBJECT_ID;
+
+	int target = pNetGame->pPlayerPool->pPlayer[playerid]->aimSyncData.wCameraObject;
+	if(target >= 0 && target < MAX_OBJECTS)
+	{
+		if(pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][target])
+			return target;
+	}
+	return INVALID_OBJECT_ID;
+}
+
+// native GetObjectType(playerid, objectid);
+static cell AMX_NATIVE_CALL Natives::GetObjectType( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "GetObjectType");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(objectid < 0 || objectid >= MAX_OBJECTS) return 0;
+
+	BYTE ret;
+	if(pNetGame->pObjectPool->bObjectSlotState[objectid])
+		ret = SELECT_OBJECT_GLOBAL_OBJECT;
+	else if(pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid])
+		ret = SELECT_OBJECT_PLAYER_OBJECT;
+	else 
+		ret = 0;
+	return ret;
+}
+
+// native GetPlayerAttachedObject(playerid, index, &modelid, &bone, &Float:fX, &Float:fY, &Float:fZ, &Float:fRotX, &Float:fRotY, &Float:fRotZ, Float:&fSacleX, Float:&fScaleY, Float:&fScaleZ, &materialcolor1, &materialcolor2);
+static cell AMX_NATIVE_CALL Natives::GetPlayerAttachedObject( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(15, "GetPlayerAttachedObject");
+
+	int playerid = static_cast<int>(params[1]);
+	int slot = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(slot < 0 || slot >= MAX_PLAYER_ATTACHED_OBJECTS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->attachedObjectSlot[slot]) return 0;
+
+	cell* cptr;
+	CAttachedObject *pObject = &pNetGame->pPlayerPool->pPlayer[playerid]->attachedObject[slot];
+	
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = *(cell*)&pObject->iModelID;	
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = *(cell*)&pObject->iBoneiD;	
+	
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(pObject->vecPos.fX);
+	amx_GetAddr(amx, params[6], &cptr);
+	*cptr = amx_ftoc(pObject->vecPos.fY);
+	amx_GetAddr(amx, params[7], &cptr);
+	*cptr = amx_ftoc(pObject->vecPos.fZ);
+
+	amx_GetAddr(amx, params[8], &cptr);
+	*cptr = amx_ftoc(pObject->vecRot.fX);
+	amx_GetAddr(amx, params[9], &cptr);
+	*cptr = amx_ftoc(pObject->vecRot.fY);
+	amx_GetAddr(amx, params[10], &cptr);
+	*cptr = amx_ftoc(pObject->vecRot.fZ);
+
+	amx_GetAddr(amx, params[11], &cptr);
+	*cptr = amx_ftoc(pObject->vecScale.fX);
+	amx_GetAddr(amx, params[12], &cptr);
+	*cptr = amx_ftoc(pObject->vecScale.fY);
+	amx_GetAddr(amx, params[13], &cptr);
+	*cptr = amx_ftoc(pObject->vecScale.fZ);
+
+	amx_GetAddr(amx, params[14], &cptr);
+	*cptr = RGBA_ABGR(pObject->dwMaterialColor1);
+	amx_GetAddr(amx, params[15], &cptr);
+	*cptr = RGBA_ABGR(pObject->dwMaterialColor2);
+	return 1;
+}
+
+// Vehicle functions
+// native GetVehicleSpawnInfo(vehicleid, &Float:fX, &Float:fY, &Float:fZ, &Float:fRot, &color1, &color2);
+static cell AMX_NATIVE_CALL Natives::GetVehicleSpawnInfo( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(7, "GetVehicleSpawnInfo");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	CVehicle* pVehicle = pNetGame->pVehiclePool->pVehicle[vehicleid];
+	if(!pVehicle) 
+		return 0;
+
+	CVehicleSpawn spawn; 
+	std::map<int, CVehicleSpawn>::iterator v = pServer->vehicleSpawnData.find(vehicleid);
+	if(v == pServer->vehicleSpawnData.end())
+	{
+		spawn.vecPos = pVehicle->customSpawn.vecPos;
+		spawn.fRot = pVehicle->customSpawn.fRot;
+		spawn.iColor1 = pVehicle->customSpawn.iColor1;
+		spawn.iColor2 = pVehicle->customSpawn.iColor2;
+
+	}
+	else
+	{
+		spawn.vecPos = v->second.vecPos;
+		spawn.fRot = v->second.fRot;
+		spawn.iColor1 = v->second.iColor1;
+		spawn.iColor2 = v->second.iColor2;	
+	}
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(spawn.vecPos.fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(spawn.vecPos.fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(spawn.vecPos.fZ);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(spawn.fRot);
+	amx_GetAddr(amx, params[6], &cptr);
+	*cptr = (cell)spawn.iColor1;
+	amx_GetAddr(amx, params[7], &cptr);
+	*cptr = (cell)spawn.iColor2;
+	return 1;
+}
+
+// native SetVehicleSpawnInfo(vehicleid, modelid, Float:fX, Float:fY, Float:fZ, Float:fAngle, color1, color2, respawntime = -2, interior = -2);
+static cell AMX_NATIVE_CALL Natives::SetVehicleSpawnInfo( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer || !CAddress::FUNC_CVehicle__Respawn)
+		return 0;
+
+	CHECK_PARAMS(10, "SetVehicleSpawnInfo");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	int modelid = static_cast<int>(params[2]);
+	if(modelid < 400 || modelid > 611) return 0;
+
+	CVehicle *pVehicle = pNetGame->pVehiclePool->pVehicle[vehicleid]; 
+	if(!pVehicle) 
+		return 0;
+
+	bool bStreamedIn = false;
+	CPlayerPool *pPlayerPool = pNetGame->pPlayerPool;		
+
+	for(WORD i = 0; i != MAX_PLAYERS; i++)
+	{
+		if(IsPlayerConnectedEx(i))
+		{
+			if(pPlayerPool->pPlayer[i]->byteVehicleStreamedIn[pVehicle->wVehicleID])
+			{
+				bStreamedIn = true;
+				break;
+			}
+		}
+	}
+
+	CVehicleSpawn spawn;
+	spawn.iModelID = modelid;
+	spawn.vecPos =  CVector(amx_ctof(params[3]), amx_ctof(params[4]), amx_ctof(params[5]));
+	spawn.fRot = amx_ctof(params[6]);
+	spawn.iColor1 = static_cast<int>(params[7]);
+	spawn.iColor2 = static_cast<int>(params[8]);
+	spawn.iRespawnTime = pVehicle->customSpawn.iRespawnTime;
+	spawn.iInterior = pVehicle->customSpawn.iInterior;
+
+	// logprintf("spandata: %d, %d", spawn.iRespawnTime, spawn.iInterior);
+
+	int respawntime = static_cast<int>(params[9]);
+	if(respawntime >= -1)
+	{
+		spawn.iRespawnTime = respawntime;
+	}
+
+	int interior = static_cast<int>(params[10]);
+	if(interior != -2)
+	{
+		spawn.iInterior = interior;
+	}
+	
+	std::map<int, CVehicleSpawn>::iterator v = pServer->vehicleSpawnData.find(pVehicle->wVehicleID);
+	if(v != pServer->vehicleSpawnData.end())
+	{
+		pServer->vehicleSpawnData.erase(v);
+		// logprintf("add custom");
+	}
+	pServer->vehicleSpawnData.insert(std::make_pair(vehicleid, spawn));
+
+	// logprintf("streamedin: %d, iRespawnTime: %d, interior: %d", bStreamedIn, respawntime, interior);
+
+	if(!bStreamedIn)
+	{
+		pVehicle->customSpawn.iModelID = spawn.iModelID;
+		pVehicle->customSpawn.fRot = spawn.fRot;
+		pVehicle->customSpawn.iColor1 = spawn.iColor1;
+		pVehicle->customSpawn.iColor2 = spawn.iColor2;
+		pVehicle->customSpawn.iRespawnTime = spawn.iRespawnTime;
+		pVehicle->customSpawn.iInterior= spawn.iInterior;
+	}
+	return 1;
+}
+
+// native GetVehicleModelCount(modelid);
+static cell AMX_NATIVE_CALL Natives::GetVehicleModelCount( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetVehicleModelCount");
+
+	int modelid = static_cast<int>(params[1]);
+	if(modelid < 400 || modelid > 611) return 0;
+	
+	return pNetGame->pVehiclePool->byteVehicleModelsUsed[modelid - 400];
+}
+
+// native GetVehicleModelsUsed();
+static cell AMX_NATIVE_CALL Natives::GetVehicleModelsUsed( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	BYTE byteModelsUsed = 0;
+	for(BYTE i = 0; i != 212; i++)
+	{
+		if(pNetGame->pVehiclePool->byteVehicleModelsUsed[i] != 0)
+			byteModelsUsed++;
+	}
+
+	return byteModelsUsed;
+}
+
+// native GetVehicleColor(vehicleid, &color1, &color2);
+static cell AMX_NATIVE_CALL Natives::GetVehicleColor( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "GetVehicleColor");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	cell* cptr;
+	CVehicle *pVehicle = pNetGame->pVehiclePool->pVehicle[vehicleid];
+
+	amx_GetAddr(amx, params[2], &cptr);
+	if(pServer->bChangedVehicleColor[vehicleid])
+	{
+		*cptr = *(cell*)&pVehicle->vehModInfo.iColor1;
+	}
+	else
+	{
+		*cptr = *(cell*)&pVehicle->customSpawn.iColor1;
+	}
+
+	amx_GetAddr(amx, params[3], &cptr);
+	if(pServer->bChangedVehicleColor[vehicleid])
+	{
+		*cptr = *(cell*)&pVehicle->vehModInfo.iColor2;
+	}
+	else
+	{
+		*cptr = *(cell*)&pVehicle->customSpawn.iColor2;
+	}
+	return 1;
+}
+
+// native GetVehiclePaintjob(vehicleid);
+static cell AMX_NATIVE_CALL Natives::GetVehiclePaintjob( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetVehiclePaintjob");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+	
+	return ((short)pNetGame->pVehiclePool->pVehicle[vehicleid]->vehModInfo.bytePaintJob)-1;
+}
+
+// native SetVehicleParamsSirenState(vehicleid, sirenState);
+static cell AMX_NATIVE_CALL Natives::SetVehicleParamsSirenState( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetVehicleParamsSirenState");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+	
+	BYTE sirenState = static_cast<BYTE>(params[2]);
+
+	pNetGame->pVehiclePool->pVehicle[vehicleid]->vehParamEx.siren = sirenState;
+	return 1;
+}
+
+// native ToggleVehicleSirenEnabled(vehicleid, enabled);
+static cell AMX_NATIVE_CALL Natives::ToggleVehicleSirenEnabled( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "ToggleVehicleSirenEnabled");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+	
+	BYTE enabled = static_cast<BYTE>(params[2]);
+
+	pNetGame->pVehiclePool->pVehicle[vehicleid]->sirenEnabled = enabled;
+	return 1;
+}
+
+// native IsVehicleSirenEnabled(vehicleid);
+static cell AMX_NATIVE_CALL Natives::IsVehicleSirenEnabled( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsVehicleSirenEnabled");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+	
+	return pNetGame->pVehiclePool->pVehicle[vehicleid]->sirenEnabled;
+}
+
+// native GetVehicleMatrix(vehicleid, &Float:rightX, &Float:rightY, &Float:rightZ, &Float:upX, &Float:upY, &Float:upZ, &Float:atX, &Float:atY, &Float:atZ);
+static cell AMX_NATIVE_CALL Natives::GetVehicleMatrix( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(10, "GetVehicleMatrix");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+	
+	MATRIX4X4* matrix = &pNetGame->pVehiclePool->pVehicle[vehicleid]->vehMatrix;
+
+	cell *cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(matrix->right.fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(matrix->right.fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(matrix->right.fZ);
+	
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(matrix->up.fX);
+	amx_GetAddr(amx, params[6], &cptr);
+	*cptr = amx_ftoc(matrix->up.fY);
+	amx_GetAddr(amx, params[7], &cptr);
+	*cptr = amx_ftoc(matrix->up.fZ);
+	
+	amx_GetAddr(amx, params[8], &cptr);
+	*cptr = amx_ftoc(matrix->at.fX);
+	amx_GetAddr(amx, params[9], &cptr);
+	*cptr = amx_ftoc(matrix->at.fY);
+	amx_GetAddr(amx, params[10], &cptr);
+	*cptr = amx_ftoc(matrix->at.fZ);
+
+	//IS4 Note for the future - vehicles remotely updated have the "at" vector zeroed, which corrupts results from GetVehicleRotationQuat
+	//Might be a reasonable method to replace IsValidQuaternion from i_quat
+
+	return 1;
+}
+
+// native SetVehicleMatrix(vehicleid, Float:rightX, Float:rightY, Float:rightZ, Float:upX, Float:upY, Float:upZ, Float:atX, Float:atY, Float:atZ);
+static cell AMX_NATIVE_CALL Natives::SetVehicleMatrix( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(10, "SetVehicleMatrix");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+	
+	MATRIX4X4* matrix = &pNetGame->pVehiclePool->pVehicle[vehicleid]->vehMatrix;
+
+	matrix->right.fX = amx_ctof(params[2]);
+	matrix->right.fY = amx_ctof(params[3]);
+	matrix->right.fZ = amx_ctof(params[4]);
+
+	matrix->up.fX = amx_ctof(params[5]);
+	matrix->up.fY = amx_ctof(params[6]);
+	matrix->up.fZ = amx_ctof(params[7]);
+
+	matrix->at.fX = amx_ctof(params[8]);
+	matrix->at.fY = amx_ctof(params[9]);
+	matrix->at.fZ = amx_ctof(params[10]);
+
+	return 1;
+}
+
+// native GetVehicleInterior(vehicleid);
+static cell AMX_NATIVE_CALL Natives::GetVehicleInterior( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetVehicleInterior");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	return pNetGame->pVehiclePool->pVehicle[vehicleid]->customSpawn.iInterior;
+}
+
+// native GetVehicleNumberPlate(vehicleid, plate[], len = sizeof(plate));
+static cell AMX_NATIVE_CALL Natives::GetVehicleNumberPlate( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "GetVehicleNumberPlate");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	return set_amxstring(amx, params[2], pNetGame->pVehiclePool->pVehicle[vehicleid]->szNumberplate, params[3]);
+}
+
+// native SetVehicleRespawnDelay(vehicleid, delay);
+static cell AMX_NATIVE_CALL Natives::SetVehicleRespawnDelay( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetVehicleRespawnDelay");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	pNetGame->pVehiclePool->pVehicle[vehicleid]->customSpawn.iRespawnTime = (static_cast<int>(params[2]) * 1000);
+	return 1;
+}
+
+// native GetVehicleRespawnDelay(vehicleid);
+static cell AMX_NATIVE_CALL Natives::GetVehicleRespawnDelay( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetVehicleRespawnDelay");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	return pNetGame->pVehiclePool->pVehicle[vehicleid]->customSpawn.iRespawnTime / 1000;
+}
+
+// native SetVehicleOccupiedTick(vehicleid, ticks);
+static cell AMX_NATIVE_CALL Natives::SetVehicleOccupiedTick( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetVehicleOccupiedTick");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	pNetGame->pVehiclePool->pVehicle[vehicleid]->vehOccupiedTick = static_cast<int>(params[2]);
+	return 1;
+}
+
+// native GetVehicleOccupiedTick(vehicleid);
+static cell AMX_NATIVE_CALL Natives::GetVehicleOccupiedTick( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetVehicleOccupiedTick");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	return pNetGame->pVehiclePool->pVehicle[vehicleid]->vehOccupiedTick;
+}
+
+// native SetVehicleRespawnTick(vehicleid, ticks);
+static cell AMX_NATIVE_CALL Natives::SetVehicleRespawnTick( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetVehicleRespawnTick");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	pNetGame->pVehiclePool->pVehicle[vehicleid]->vehRespawnTick = static_cast<int>(params[2]);
+	return 1;
+}
+
+// native GetVehicleRespawnTick(vehicleid);
+static cell AMX_NATIVE_CALL Natives::GetVehicleRespawnTick( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetVehicleRespawnTick");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	return pNetGame->pVehiclePool->pVehicle[vehicleid]->vehRespawnTick;
+}
+
+// native GetVehicleLastDriver(vehicleid);
+static cell AMX_NATIVE_CALL Natives::GetVehicleLastDriver( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetVehicleLastDriver");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	return pNetGame->pVehiclePool->pVehicle[vehicleid]->wLastDriverID;
+}
+
+// native GetVehicleCab(vehicleid);
+static cell AMX_NATIVE_CALL Natives::GetVehicleCab( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetVehicleCab");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+	
+	CVehicle *pVeh;
+	for(WORD i = 0; i != MAX_VEHICLES; i++)
+	{
+		pVeh = pNetGame->pVehiclePool->pVehicle[i];
+		if(!pVeh) continue;
+
+		if(pVeh->wTrailerID != 0 && pVeh->wTrailerID == vehicleid)
+			return i;
+	}
+	return 0;
+}
+
+// native HasVehicleBeenOccupied(vehicleid);
+static cell AMX_NATIVE_CALL Natives::HasVehicleBeenOccupied( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "HasVehicleBeenOccupied");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	return pNetGame->pVehiclePool->pVehicle[vehicleid]->bOccupied;
+}
+
+// native SetVehicleBeenOccupied(vehicleid, occupied);
+static cell AMX_NATIVE_CALL Natives::SetVehicleBeenOccupied( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetVehicleBeenOccupied");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	pNetGame->pVehiclePool->pVehicle[vehicleid]->bOccupied = !!params[2];;
+	return 1;
+}
+
+// native IsVehicleOccupied(vehicleid);
+static cell AMX_NATIVE_CALL Natives::IsVehicleOccupied( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsVehicleOccupied");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	CPlayer *pPlayer;
+	for(WORD i = 0; i != MAX_PLAYERS; i++)
+	{
+		if(!IsPlayerConnectedEx(i)) continue; 
+		pPlayer = pNetGame->pPlayerPool->pPlayer[i];
+
+		if(pPlayer->wVehicleId == vehicleid && (pPlayer->byteState == PLAYER_STATE_DRIVER || pPlayer->byteState == PLAYER_STATE_PASSENGER)) 
+			return 1;
+	}
+	return 0;
+}
+
+// native IsVehicleDead(vehicleid);
+static cell AMX_NATIVE_CALL Natives::IsVehicleDead( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsVehicleDead");
+
+	int vehicleid = static_cast<int>(params[1]);
+	if(vehicleid < 1 || vehicleid > MAX_VEHICLES) return 0;
+	
+	if(!pNetGame->pVehiclePool->pVehicle[vehicleid]) 
+		return 0;
+
+	return pNetGame->pVehiclePool->pVehicle[vehicleid]->bDead;
+}
+
+// Gangzone functions
+// native IsValidGangZone(zoneid);
+static cell AMX_NATIVE_CALL Natives::IsValidGangZone( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "IsValidGangZone");
+	
+	int zoneid = static_cast<int>(params[1]);
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	return pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid));
+}
+
+// native IsGangZoneVisibleForPlayer(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::IsGangZoneVisibleForPlayer( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsGangZoneVisibleForPlayer");
+	
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
+
+	return !!(pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid)) != 0xFF);
+}
+
+// native GangZoneGetColorForPlayer(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::GangZoneGetColorForPlayer( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "GangZoneGetColorForPlayer");
+	
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
+
+	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid));
+	if(id != 0xFFFF) 
+	{
+		return pPlayerData[playerid]->dwClientSideZoneColor[id];
+	}
+	return 0;
+}
+
+// native GangZoneGetFlashColorForPlayer(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::GangZoneGetFlashColorForPlayer( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "GangZoneGetFlashColorForPlayer");
+	
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
+
+	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid));
+	if(id != 0xFFFF) 
+	{
+		return pPlayerData[playerid]->dwClientSideZoneFlashColor[id];
+	}
+	return 0;
+}
+
+// native IsGangZoneFlashingForPlayer(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::IsGangZoneFlashingForPlayer( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsGangZoneFlashingForPlayer");
+	
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
+
+	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid));
+	if(id != 0xFFFF) 
+	{
+		return pPlayerData[playerid]->bIsGangZoneFlashing[id];
+	}
+	return 0;
+}
+
+// native IsPlayerInGangZone(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerInGangZone( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsPlayerInGangZone");
+	
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
+
+	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid));
+	if(id != 0xFFFF) 
+	{
+		return pPlayerData[playerid]->bInGangZone[id];
+	}
+	return 0;
+}
+
+// native GangZoneGetPos(zoneid, &Float:fMinX, &Float:fMinY, &Float:fMaxX, &Float:fMaxY);
+static cell AMX_NATIVE_CALL Natives::GangZoneGetPos( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(5, "GangZoneGetPos");
+
+	int zoneid = static_cast<int>(params[1]);
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	if(!pServer->pGangZonePool->GetSlotState(static_cast<WORD>(zoneid)))  return 0;
+	
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pServer->pGangZonePool->pGangZone[zoneid]->fGangZone[0]);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pServer->pGangZonePool->pGangZone[zoneid]->fGangZone[1]);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pServer->pGangZonePool->pGangZone[zoneid]->fGangZone[2]);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(pServer->pGangZonePool->pGangZone[zoneid]->fGangZone[3]);
+	return 1;
+}
+
+// Textdraw functions
+// native IsValidTextDraw(textdrawid);
+static cell AMX_NATIVE_CALL Natives::IsValidTextDraw( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "IsValidTextDraw");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	return pNetGame->pTextDrawPool->bSlotState[textdrawid];
+}
+
+// native IsTextDrawVisibleForPlayer(playerid, textdrawid);
+static cell AMX_NATIVE_CALL Natives::IsTextDrawVisibleForPlayer( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsTextDrawVisibleForPlayer");
+	
+	int playerid = static_cast<int>(params[1]);
+	if(playerid < 0 || playerid >= MAX_PLAYERS) return 0;
+
+	int textdrawid = static_cast<int>(params[2]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+
+	return pNetGame->pTextDrawPool->bHasText[textdrawid][playerid];
+}
+
+// native TextDrawGetString(textdrawid, text[], len = sizeof(text));
+static cell AMX_NATIVE_CALL Natives::TextDrawGetString( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "TextDrawGetString");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	const char *szText = (pNetGame->pTextDrawPool->bSlotState[textdrawid]) ? pNetGame->pTextDrawPool->szFontText[textdrawid] : '\0';
+	return set_amxstring(amx, params[2], szText, params[3]);
+}
+
+// native TextDrawSetPos(textdrawid, Float:fX, Float:fY);
+static cell AMX_NATIVE_CALL Natives::TextDrawSetPos( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(3, "TextDrawPos");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	pTD->fX = amx_ctof(params[2]);
+	pTD->fY = amx_ctof(params[3]);
+	return 1;
+}
+
+// native TextDrawGetLetterSize(textdrawid, &Float:fX, &Float:fY);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetLetterSize( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(3, "TextDrawGetLetterSize");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pTD->fLetterWidth);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pTD->fLetterHeight);
+	return 1;
+}
+
+// native TextDrawGetTextSize(textdrawid, &Float:fX, &Float:fY);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetTextSize( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(3, "TextDrawGetTextSize");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pTD->fLineWidth);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pTD->fLineHeight);
+	return 1;
+}
+
+// native TextDrawGetPos(textdrawid, &Float:fX, &Float:fY);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetPos( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(3, "TextDrawGetPos");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pTD->fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pTD->fY);
+	return 1;
+}
+
+// native TextDrawGetColor(textdrawid);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetColor( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "TextDrawGetColor");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	return ABGR_RGBA(pTD->dwLetterColor);
+}
+
+// native TextDrawGetBoxColor(textdrawid);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetBoxColor( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "TextDrawGetBoxColor");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	return ABGR_RGBA(pTD->dwBoxColor);
+}
+
+// native TextDrawGetBackgroundColor(textdrawid);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetBackgroundColor( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "TextDrawGetBackgroundColor");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	return ABGR_RGBA(pTD->dwBackgroundColor);
+}
+
+// native TextDrawGetShadow(textdrawid);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetShadow( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "TextDrawGetShadow");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	return pTD->byteShadow;
+}
+
+// native TextDrawGetOutline(textdrawid);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetOutline( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "TextDrawGetOutline");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	return pTD->byteOutline;
+}
+
+// native TextDrawGetFont(textdrawid);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetFont( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "TextDrawGetOutline");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	return pTD->byteStyle;
+}
+
+// native TextDrawIsBox(textdrawid);
+static cell AMX_NATIVE_CALL Natives::TextDrawIsBox( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "TextDrawIsBox");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	return pTD->byteBox;
+}
+
+// native TextDrawIsProportional(textdrawid);
+static cell AMX_NATIVE_CALL Natives::TextDrawIsProportional( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "TextDrawIsProportional");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	return pTD->byteProportional;
+}
+
+// native TextDrawIsSelectable(textdrawid);
+static cell AMX_NATIVE_CALL Natives::TextDrawIsSelectable( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "TextDrawIsSelectable");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	return pTD->byteSelectable;
+}
+
+// native TextDrawGetAlignment(textdrawid);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetAlignment( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "TextDrawGetAlignment");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	BYTE ret = 0;
+
+	if(pTD->byteCenter) ret = 2;
+	else if(pTD->byteLeft) ret = 1;
+	else if(pTD->byteRight) ret = 3;
+	return ret;
+}
+
+// native TextDrawGetPreviewModel(textdrawid);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetPreviewModel( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "TextDrawGetPreviewModel");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	return pTD->dwModelIndex;
+}
+
+// native TextDrawGetPreviewRot(textdrawid, &Float:fRotX, &Float:fRotY, &Float:fRotZ, &Float:fZoom);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetPreviewRot( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(5, "TextDrawGetPreviewRot");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pTD->vecRot.fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pTD->vecRot.fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pTD->vecRot.fZ);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(pTD->fZoom);
+	return 1;
+}
+
+// native TextDrawGetPreviewVehCol(textdrawid, &color1, &color2);
+static cell AMX_NATIVE_CALL Natives::TextDrawGetPreviewVehCol( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(3, "TextDrawGetPreviewVehCol");
+	
+	int textdrawid = static_cast<int>(params[1]);
+	if(textdrawid < 0 || textdrawid >= MAX_TEXT_DRAWS) return 0;
+	
+	if(!pNetGame->pTextDrawPool->bSlotState[textdrawid]) return 0;
+	CTextdraw *pTD = pNetGame->pTextDrawPool->TextDraw[textdrawid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = (cell)pTD->color1;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = (cell)pTD->color2;
+	return 1;
+}
+
+// Per-Player textdraws
+// native IsValidPlayerTextDraw(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::IsValidPlayerTextDraw( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsValidPlayerTextDraw");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid];
+}
+
+// native IsPlayerTextDrawVisible(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerTextDrawVisible( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsPlayerTextDrawVisible");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bHasText[textdrawid];
+}
+
+// native PlayerTextDrawGetString(playerid, PlayerText:textdrawid, text[], len = sizeof(text));
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetString( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(4, "PlayerTextDrawGetString");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	
+	bool bIsValid = static_cast<int>(pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) != 0;
+	if(!bIsValid) return 0;
+
+	const char *szText = (bIsValid) ? pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->szFontText[textdrawid]: '\0';
+	return set_amxstring(amx, params[3], szText, params[4]);
+}
+
+// native PlayerTextDrawSetPos(playerid, PlayerText:textdrawid, Float:fX, Float:fY);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawSetPos( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(4, "PlayerTextDrawSetPos");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+
+	pTD->fX = amx_ctof(params[3]);
+	pTD->fY = amx_ctof(params[4]);
+	return 1;
+}
+
+// native PlayerTextDrawGetLetterSize(playerid, PlayerText:textdrawid, &Float:fX, &Float:fY);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetLetterSize( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(4, "PlayerTextDrawGetLetterSize");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pTD->fLetterWidth);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pTD->fLetterHeight);
+	return 1;
+}
+
+// native PlayerTextDrawGetTextSize(playerid, PlayerText:textdrawid, &Float:fX, &Float:fY);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetTextSize( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(4, "PlayerTextDrawGetTextSize");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pTD->fLineWidth);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pTD->fLineHeight);
+	return 1;
+}
+
+// native PlayerTextDrawGetPos(playerid, PlayerText:textdrawid, &Float:fX, &Float:fY);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetPos( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(4, "PlayerTextDrawGetPos");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pTD->fX);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pTD->fY);
+	return 1;
+}
+
+// native PlayerTextDrawGetColor(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetColor( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerTextDrawGetColor");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+	return ABGR_RGBA(pTD->dwLetterColor);
+}
+
+// native PlayerTextDrawGetBoxColor(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetBoxColor( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerTextDrawGetBoxColor");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+	return ABGR_RGBA(pTD->dwBoxColor);
+}
+
+// native PlayerTextDrawGetBackgroundCol(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetBackgroundCol( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerTextDrawGetBackgroundCol");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+	return ABGR_RGBA(pTD->dwBackgroundColor);
+}
+
+// native PlayerTextDrawGetShadow(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetShadow( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerTextDrawGetShadow");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+	return pTD->byteShadow;
+}
+
+// native PlayerTextDrawGetOutline(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetOutline( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerTextDrawGetOutline");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+	return pTD->byteOutline;
+}
+
+// native PlayerTextDrawGetFont(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetFont( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerTextDrawGetFont");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+	return pTD->byteStyle;
+}
+
+// native PlayerTextDrawIsBox(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawIsBox( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerTextDrawIsBox");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+	return pTD->byteBox;
+}
+
+// native PlayerTextDrawIsProportional(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawIsProportional( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerTextDrawIsProportional");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+	return pTD->byteProportional;
+}
+
+// native PlayerTextDrawIsSelectable(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawIsSelectable( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerTextDrawIsSelectable");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+	return pTD->byteSelectable;
+}
+
+// native PlayerTextDrawGetAlignment(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetAlignment( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerTextDrawGetAlignment");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+	BYTE ret = 0;
+
+	if(pTD->byteCenter) ret = 2;
+	else if(pTD->byteLeft) ret = 1;
+	else if(pTD->byteRight) ret = 3;
+	return ret;
+}
+
+// native PlayerTextDrawGetPreviewModel(playerid, PlayerText:textdrawid);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetPreviewModel( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerTextDrawGetPreviewModel");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+	return pTD->dwModelIndex;
+}
+
+// native PlayerTextDrawGetPreviewRot(playerid, PlayerText:textdrawid, &Float:fRotX, &Float:fRotY, &Float:fRotZ, &Float:fZoom);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetPreviewRot( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(6, "PlayerTextDrawGetPreviewRot");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pTD->vecRot.fX);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pTD->vecRot.fY);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(pTD->vecRot.fZ);
+	amx_GetAddr(amx, params[6], &cptr);
+	*cptr = amx_ftoc(pTD->fZoom);
+	return 1;
+}
+
+// native PlayerTextDrawGetPreviewVehCol(playerid, PlayerText:textdrawid, &color1, &color2);
+static cell AMX_NATIVE_CALL Natives::PlayerTextDrawGetPreviewVehCol( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(4, "PlayerTextDrawGetPreviewVehCol");
+	
+	int playerid = static_cast<int>(params[1]);
+	int textdrawid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(textdrawid >= MAX_PLAYER_TEXT_DRAWS) return 0;
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->bSlotState[textdrawid]) return 0;
+
+	CTextdraw *pTD = pNetGame->pPlayerPool->pPlayer[playerid]->pTextdraw->TextDraw[textdrawid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = (cell)pTD->color1;
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = (cell)pTD->color2;
+	return 1;
+}
+
+// 3D Text labels
+// native IsValid3DTextLabel(Text3D:id);
+static cell AMX_NATIVE_CALL Natives::IsValid3DTextLabel( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "IsValid3DTextLabel");
+	
+	int id = static_cast<int>(params[1]);
+	if(0 < id || id >= MAX_3DTEXT_GLOBAL) return 0;
+	
+	return pNetGame->p3DTextPool->bIsCreated[id];
+}
+
+// native Is3DTextLabelStreamedIn(playerid, Text3D:id);
+static cell AMX_NATIVE_CALL Natives::Is3DTextLabelStreamedIn( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "Is3DTextLabelStreamedIn");
+	
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[1]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(0 < id || id >= MAX_3DTEXT_PLAYER) return 0;
+	
+	return pNetGame->pPlayerPool->pPlayer[playerid]->byte3DTextLabelStreamedIn[id];
+}
+
+// native Get3DTextLabelText(id, text[], len = sizeof(text));
+static cell AMX_NATIVE_CALL Natives::Get3DTextLabelText( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "Get3DTextLabelText");
+	
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
+
+	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
+
+	const char *szText = pNetGame->p3DTextPool->TextLabels[id].szText;
+	return set_amxstring(amx, params[2], szText, params[3]);
+}
+
+// native Get3DTextLabelColor(id);
+static cell AMX_NATIVE_CALL Natives::Get3DTextLabelColor( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "Get3DTextLabelColor");
+	
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
+	
+	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
+	C3DText &p3DText = pNetGame->p3DTextPool->TextLabels[id];
+
+	return p3DText.dwColor;
+}
+
+// native Get3DTextLabelPos(id, &Float:fX, &Float:fY, &Float:fZ);
+static cell AMX_NATIVE_CALL Natives::Get3DTextLabelPos( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(4, "Get3DTextLabelPos");
+	
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
+	
+	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
+	C3DText p3DText = pNetGame->p3DTextPool->TextLabels[id];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(p3DText.vecPos.fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(p3DText.vecPos.fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(p3DText.vecPos.fZ);
+	return 1;
+}
+
+// native Float:Get3DTextLabelDrawDistance(id);
+static cell AMX_NATIVE_CALL Natives::Get3DTextLabelDrawDistance( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "Get3DTextLabelDrawDistance");
+	
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
+	
+	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
+	C3DText p3DText = pNetGame->p3DTextPool->TextLabels[id];
+
+	return amx_ftoc(p3DText.fDrawDistance);
+}
+
+// native Get3DTextLabelLOS(id);
+static cell AMX_NATIVE_CALL Natives::Get3DTextLabelLOS( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "Get3DTextLabelLOS");
+	
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
+	
+	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
+	C3DText p3DText = pNetGame->p3DTextPool->TextLabels[id];
+
+	return p3DText.bLineOfSight;
+}
+
+// native Get3DTextLabelVirtualWorld(id);
+static cell AMX_NATIVE_CALL Natives::Get3DTextLabelVirtualWorld( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "Get3DTextLabelVirtualWorld");
+	
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
+	
+	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
+	C3DText p3DText = pNetGame->p3DTextPool->TextLabels[id];
+
+	return p3DText.iWorld;
+}
+
+// native Get3DTextLabelAttachedData(id, &attached_playerid, &attached_vehicleid);
+static cell AMX_NATIVE_CALL Natives::Get3DTextLabelAttachedData( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(3, "Get3DTextLabelAttachedData");
+	
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_3DTEXT_GLOBAL) return 0;
+	
+	if(!pNetGame->p3DTextPool->bIsCreated[id]) return 0;
+	C3DText p3DText = pNetGame->p3DTextPool->TextLabels[id];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = (cell)p3DText.attachedToPlayerID;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = (cell)p3DText.attachedToVehicleID;
+	return 1;
+}
+
+// native IsValidPlayer3DTextLabel(playerid, PlayerText3D:id);
+static cell AMX_NATIVE_CALL Natives::IsValidPlayer3DTextLabel( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsValidPlayer3DTextLabel");
+	
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
+	
+	return pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id];
+}
+
+// native GetPlayer3DTextLabelText(playerid, PlayerText3D:id, text[], len = sizeof(text));
+static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelText( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(4, "GetPlayer3DTextLabelText");
+	
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
+	
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
+
+	const char *szText = (pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id].szText) ? pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id].szText : '\0';
+	return set_amxstring(amx, params[3], szText, params[4]);
+}
+
+// native GetPlayer3DTextLabelColor(playerid, PlayerText3D:id);
+static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelColor( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "GetPlayer3DTextLabelColor");
+	
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
+	
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
+
+	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
+	return p3DText.dwColor;
+}
+
+// native GetPlayer3DTextLabelPos(playerid, PlayerText3D:id, &Float:fX, &Float:fY, &Float:fZ);
+static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelPos( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(5, "GetPlayer3DTextLabelPos");
+	
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
+
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
+	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(p3DText.vecPos.fX);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(p3DText.vecPos.fY);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(p3DText.vecPos.fZ);
+	return 1;
+}
+
+// native Float:GetPlayer3DTextLabelDrawDist(playerid, PlayerText3D:id);
+static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelDrawDist( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "GetPlayer3DTextLabelDrawDist");
+	
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
+	
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
+
+	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
+	return amx_ftoc(p3DText.fDrawDistance);
+}
+
+// native GetPlayer3DTextLabelLOS(playerid, PlayerText3D:id);
+static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelLOS( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "GetPlayer3DTextLabelLOS");
+	
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
+	
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
+
+	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
+	return p3DText.bLineOfSight;
+}
+
+// native GetPlayer3DTextLabelVirtualW(playerid, PlayerText3D:id);
+static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelVirtualW( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "GetPlayer3DTextLabelVirtualW");
+	
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
+	
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
+
+	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
+	return p3DText.iWorld;
+}
+
+// native GetPlayer3DTextLabelAttached(playerid, PlayerText3D:id, &attached_playerid, &attached_vehicleid);
+static cell AMX_NATIVE_CALL Natives::GetPlayer3DTextLabelAttached( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(4, "GetPlayer3DTextLabelAttached");
+	
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(id < 0 || id >= MAX_3DTEXT_PLAYER) return 0;
+	
+	if(!pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->isCreated[id]) return 0;
+
+	C3DText p3DText = pNetGame->pPlayerPool->pPlayer[playerid]->p3DText->TextLabels[id];
+	cell* cptr;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = (cell)p3DText.attachedToPlayerID;
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = (cell)p3DText.attachedToVehicleID;
+	return 1;
+}
+
+// native AttachObjectToPlayer(objectid, playerid, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:rX, Float:rY, Float:rZ)
+static cell AMX_NATIVE_CALL Natives::YSF_AttachObjectToPlayer( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(8, "AttachObjectToPlayer");
+
+	// FUCK SAMP -.- n_AttachObjectToPlayer always return 0
+	int playerid = static_cast<int>(params[2]);
+	int objectid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid) && playerid != INVALID_PLAYER_ID) return 0;
+
+	if(objectid < 1 || objectid >= MAX_OBJECTS) return 0;
+
+	CObject *pObject = pNetGame->pObjectPool->pObjects[objectid];
+	if(!pObject) return 0;
+
+	pAttachObjectToPlayer(amx, params); //so we shouldn't depend on the return, should we?
+	pServer->COBJECT_AttachedObjectPlayer[objectid] = playerid;
+	pObject->vecAttachedOffset = CVector(amx_ctof(params[3]), amx_ctof(params[4]), amx_ctof(params[5]));
+	pObject->vecAttachedRotation = CVector(amx_ctof(params[6]), amx_ctof(params[7]), amx_ctof(params[8]));
+	//Apparently SA-MP doesn't store AttachObjectToPlayer anywhere
+	return 1;
+}
+
+// native AttachPlayerObjectToPlayer(objectplayer, objectid, attachplayer, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:rX, Float:rY, Float:rZ, onlyaddtoinstance = 0)
+static cell AMX_NATIVE_CALL Natives::YSF_AttachPlayerObjectToPlayer( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+//	CHECK_PARAMS(9, "AttachPlayerObjectToPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int objectid = static_cast<int>(params[2]);
+	int attachplayerid = static_cast<int>(params[3]);
+	bool bOnlyAddToInstance = static_cast<int>(params[10]) != 0;
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(!IsPlayerConnectedEx(attachplayerid)) return 0;
+
+	if(objectid < 1 || objectid >= MAX_OBJECTS) return 0;
+	if(!pNetGame->pObjectPool->bPlayerObjectSlotState[playerid][objectid]) return 0;
+	
+	pPlayerData[playerid]->stObj[objectid].wAttachPlayerID = static_cast<WORD>(attachplayerid);
+	pPlayerData[playerid]->stObj[objectid].vecOffset = CVector(amx_ctof(params[4]), amx_ctof(params[5]), amx_ctof(params[6]));
+	pPlayerData[playerid]->stObj[objectid].vecRot = CVector(amx_ctof(params[7]), amx_ctof(params[8]), amx_ctof(params[9]));
+
+	if(!bOnlyAddToInstance)
+	{
+		if(pNetGame->pPlayerPool->pPlayer[playerid]->byteStreamedIn[attachplayerid])
+		{
+			RakNet::BitStream bs;
+			bs.Write((WORD)objectid); // wObjectID
+			bs.Write((WORD)attachplayerid); // playerid
+			bs.Write(amx_ctof(params[4]));
+			bs.Write(amx_ctof(params[5]));
+			bs.Write(amx_ctof(params[6]));
+			bs.Write(amx_ctof(params[7]));
+			bs.Write(amx_ctof(params[8]));
+			bs.Write(amx_ctof(params[9]));
+			pRakServer->RPC(&RPC_AttachObject, &bs, LOW_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), 0, 0);
+
+			pPlayerData[playerid]->bAttachedObjectCreated = true;
+		}
+	}
+	else
+	{
+			pPlayerData[playerid]->dwCreateAttachedObj = GetTickCount();
+			pPlayerData[playerid]->dwObjectID = objectid;
+			pPlayerData[playerid]->bAttachedObjectCreated = true;
+		
+	}
+	return 1;
+}
+
+// native AttachPlayerObjectToObject(playerid, objectid, attachtoid, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:RotX, Float:RotY, Float:RotZ, SyncRotation = 1);
+static cell AMX_NATIVE_CALL Natives::AttachPlayerObjectToObject( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(10, "AttachPlayerObjectToObject");
+
+	int forplayerid = static_cast<int>(params[1]);
+	int wObjectID = static_cast<int>(params[2]);
+	int wAttachTo = static_cast<int>(params[3]);
+
+	if(!IsPlayerConnectedEx(forplayerid)) return 0;
+
+	if(wObjectID < 1 || wObjectID >= MAX_OBJECTS) return 0;
+	if(wAttachTo < 1 || wAttachTo >= MAX_OBJECTS) return 0;
+
+	CObjectPool *pObjectPool = pNetGame->pObjectPool;
+	if(!pObjectPool->pPlayerObjects[forplayerid][wObjectID] || !pObjectPool->pPlayerObjects[forplayerid][wAttachTo]) return 0; // Check if object is exist
+
+	// Get data
+	CVector vecOffset = CVector(amx_ctof(params[4]), amx_ctof(params[5]), amx_ctof(params[6]));
+	CVector vecOffsetRot = CVector(amx_ctof(params[7]), amx_ctof(params[8]), amx_ctof(params[9]));
+	BYTE byteSyncRot = !!params[10];
+
+	// Store data
+	pPlayerData[forplayerid]->stObj[wObjectID].wObjectID = static_cast<WORD>(wAttachTo);
+	pPlayerData[forplayerid]->stObj[wObjectID].vecOffset = vecOffset;
+	pPlayerData[forplayerid]->stObj[wObjectID].vecRot = vecOffsetRot;
+
+	// Attach it
+	int iModelID = pObjectPool->pPlayerObjects[forplayerid][wObjectID]->iModel;
+	CVector vecPos = pObjectPool->pPlayerObjects[forplayerid][wObjectID]->matWorld.pos;
+	CVector vecRot = pObjectPool->pPlayerObjects[forplayerid][wObjectID]->vecRot;
+	float fDrawDistance = 299.0;
+	BYTE byteNoCameraCol = pObjectPool->pPlayerObjects[forplayerid][wObjectID]->bNoCameraCol;
+
+	RakNet::BitStream bs;
+	bs.Write((WORD)wObjectID);
+	bs.Write(iModelID);
+	bs.Write(vecPos);
+	bs.Write(vecRot);
+	bs.Write(fDrawDistance); // 159
+	bs.Write(byteNoCameraCol);
+	bs.Write((WORD)-1); // attached vehicle
+	bs.Write((WORD)wAttachTo); // attached object
+	bs.Write(vecOffset);
+	bs.Write(vecOffsetRot);	
+	bs.Write(byteSyncRot);
+	
+	pRakServer->RPC(&RPC_CreateObject, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(forplayerid), 0, 0); // Send this on same RPC as CreateObject
+	return 1;
+}
+
+// native SetRecordingDirectory(const dir[]);
+static cell AMX_NATIVE_CALL Natives::SetRecordingDirectory( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "SetRecordingDirectory");
+
+	char *dir;
+	amx_StrParam(amx, params[1], dir);
+	if (!dir || !CAddress::ADDR_RecordingDirectory) return 0;
+
+	strcpy(gRecordingDataPath, dir);
+	strcat(gRecordingDataPath, "/%s.rec");
+	return 1;
+}
+
+// native GetRecordingDirectory(dir[], len = sizeof(dir));
+static cell AMX_NATIVE_CALL Natives::GetRecordingDirectory( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "GetRecordingDirectory");
+	
+	if(!CAddress::ADDR_RecordingDirectory) return 0;
+
+	char temp[MAX_PATH];
+	int len = strlen(gRecordingDataPath);
+	strcpy(temp, gRecordingDataPath);
+	temp[len - 7] = 0;
+
+	return set_amxstring(amx, params[1], temp, params[2]);
+}
+
+// native SendClientMessagef(playerid, color, const message[], {Float,_}:...);
+static cell AMX_NATIVE_CALL Natives::SendClientMessagef( AMX* amx, cell* params )
+{
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	int len;
+	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 3, len);
+	if(!szMessage) return 0;
+
+	RakNet::BitStream bsParams;
+	bsParams.Write((DWORD)params[2]);
+	bsParams.Write((DWORD)len);
+	bsParams.Write(szMessage, len);
+	pRakServer->RPC(&RPC_ClientMessage, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
+	return 1;
+}
+
+// native SendClientMessageToAllf(color, const message[], {Float,_}:...);
+static cell AMX_NATIVE_CALL Natives::SendClientMessageToAllf( AMX* amx, cell* params )
+{
+	int len;
+	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 2, len);
+	if(!szMessage) return 0;
+
+	RakNet::BitStream bsParams;
+	bsParams.Write((DWORD)params[1]);
+	bsParams.Write((DWORD)len);
+	bsParams.Write(szMessage, len);
+	pRakServer->RPC(&RPC_ClientMessage, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, false);
+	return 1;
+}
+
+// native GameTextForPlayerf(playerid, displaytime, style, const message[], {Float,_}:...);
+static cell AMX_NATIVE_CALL Natives::GameTextForPlayerf( AMX* amx, cell* params )
+{
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	int len;
+	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 4, len);
+	if(!szMessage) return 0;
+
+	RakNet::BitStream bsParams;
+	bsParams.Write((int)params[3]);
+	bsParams.Write((int)params[2]);
+	bsParams.Write(len);
+	bsParams.Write(szMessage, len);
+	pRakServer->RPC(&RPC_ScrDisplayGameText, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
+	return 1;
+}
+
+// native GameTextForAllf(displaytime, style, const message[], {Float,_}:...);
+static cell AMX_NATIVE_CALL Natives::GameTextForAllf( AMX* amx, cell* params )
+{
+	int len;
+	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 3, len);
+	if(!szMessage) return 0;
+
+	RakNet::BitStream bsParams;
+	bsParams.Write((int)params[2]);
+	bsParams.Write((int)params[1]);
+	bsParams.Write(len);
+	bsParams.Write(szMessage, len);
+	pRakServer->RPC(&RPC_ScrDisplayGameText, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, false);
+	return 1;
+}
+
+// native SendPlayerMessageToPlayerf(playerid, senderid, const message[], {Float,_}:...);
+static cell AMX_NATIVE_CALL Natives::SendPlayerMessageToPlayerf( AMX* amx, cell* params )
+{
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	int senderid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(senderid)) return 0;
+
+	int len;
+	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 3, len);
+	if(!szMessage) return 0;
+
+	RakNet::BitStream bsParams;
+	bsParams.Write((WORD)senderid);
+	bsParams.Write((BYTE)len);
+	bsParams.Write(szMessage, len);
+	pRakServer->RPC(&RPC_Chat, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pRakServer->GetPlayerIDFromIndex(playerid), false, false);
+	return 1;
+}
+
+// native SendPlayerMessageToAllf(senderid, const message[], {Float,_}:...);
+static cell AMX_NATIVE_CALL Natives::SendPlayerMessageToAllf( AMX* amx, cell* params )
+{
+	int senderid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(senderid)) return 0;
+
+	int len;
+	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 2, len);
+	if(!szMessage) return 0;
+
+	RakNet::BitStream bsParams;
+	bsParams.Write((WORD)senderid);
+	bsParams.Write((BYTE)len);
+	bsParams.Write(szMessage, len);
+	pRakServer->RPC(&RPC_Chat, &bsParams, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, false);
+	return 1;
+}
+
+// native SendRconCommandf(command[], {Float,_}:...);
+static cell AMX_NATIVE_CALL Natives::SendRconCommandf( AMX* amx, cell* params )
+{
+	int len;
+	char* szMessage = CSAMPFunctions::format_amxstring(amx, params, 1, len);
+	if(!szMessage) return 0;
+
+	CSAMPFunctions::Execute(szMessage);
+	return 1;
+}
+
+// native YSF_SetTickRate(ticks);
+static cell AMX_NATIVE_CALL Natives::YSF_SetTickRate( AMX* amx, cell* params )
+{
+	if(!pServer)
+		return 1;
+
+	CHECK_PARAMS(1, "YSF_SetTickRate");
+
+	int rate = static_cast<int>(params[1]);
+	if(rate < -1 || rate == 0) return 0; // -1 = no update
+
+	pServer->SetTickRate(rate);
+	return 1;
+}
+
+// native YSF_GetTickRate();
+static cell AMX_NATIVE_CALL Natives::YSF_GetTickRate( AMX* amx, cell* params )
+{
+	if(!pServer)
+		return 1;
+
+	return static_cast<cell>(pServer->GetTickRate());
+}
+
+// native YSF_EnableNightVisionFix(enable);
+static cell AMX_NATIVE_CALL Natives::YSF_EnableNightVisionFix(AMX* amx, cell* params)
+{
+	if (!pServer)
+		return 1;
+
+	CHECK_PARAMS(1, "YSF_EnableNightVisionFix");
+
+	pServer->EnableNightVisionFix(static_cast<int>(params[1]) != 0);
+	return 1;
+}
+
+// native YSF_IsNightVisionFixEnabled();
+static cell AMX_NATIVE_CALL Natives::YSF_IsNightVisionFixEnabled(AMX* amx, cell* params)
+{
+	if (!pServer)
+		return 1;
+
+	return static_cast<cell>(pServer->IsNightVisionFixEnabled());
+}
+
+// native YSF_SetExtendedNetStatsEnabled(enable);
+static cell AMX_NATIVE_CALL Natives::YSF_SetExtendedNetStatsEnabled(AMX* amx, cell* params)
+{
+	if (!pServer)
+		return 1;
+
+	CHECK_PARAMS(1, "YSF_SetExtendedNetStatsEnabled");
+
+	pServer->SetExtendedNetStatsEnabled(static_cast<int>(params[1]) != 0);
+	return 1;
+}
+
+// native YSF_IsExtendedNetStatsEnabled();
+static cell AMX_NATIVE_CALL Natives::YSF_IsExtendedNetStatsEnabled(AMX* amx, cell* params)
+{
+	if (!pServer)
+		return 1;
+
+	return static_cast<cell>(pServer->IsExtendedNetStatsEnabled());
+}
+
+// native YSF_SetAFKAccuracy(time_ms);
+static cell AMX_NATIVE_CALL Natives::YSF_SetAFKAccuracy(AMX* amx, cell* params)
+{
+	if (!pServer)
+		return 1;
+
+	CHECK_PARAMS(1, "YSF_SetAFKAccuracy");
+
+	pServer->SetAFKAccuracy(static_cast<DWORD>(params[1]));
+	return 1;
+}
+
+// native YSF_GetAFKAccuracy();
+static cell AMX_NATIVE_CALL Natives::YSF_GetAFKAccuracy(AMX* amx, cell* params)
+{
+	if (!pServer)
+		return 1;
+
+	return static_cast<cell>(pServer->GetAFKAccuracy());
+}
+
+// native YSF_ToggleNPCTracking(bool:enable);
+static cell AMX_NATIVE_CALL Natives::YSF_ToggleNPCTracking(AMX* amx, cell* params)
+{
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "YSF_ToggleNPCTracking");
+
+	pServer->ToggleNPCTracking(!!params[1]);
+	return 1;
+}
+
+// native bool:YSF_IsNPCTrackingEnabled();
+static cell AMX_NATIVE_CALL Natives::YSF_IsNPCTrackingEnabled(AMX* amx, cell* params)
+{
+	if (!pServer)
+		return 0;
+
+	return pServer->IsNPCTrackingEnabled();
+}
+
+// native GetNPCCommandLine(npcid, script[], length=sizeof(script));
+static cell AMX_NATIVE_CALL Natives::GetNPCCommandLine(AMX* amx, cell* params)
+{
+	if (!pServer)
+		return 0;
+	
+	CHECK_PARAMS(3, "GetNPCCommandLine");
+
+	if(!pServer->IsNPCTrackingEnabled()) return 0;
+	char *cmdline = CSAMPFunctions::GetNPCCommandLine(params[1]);
+	if(cmdline == NULL) return 0;
+	cell *phys_addr;
+	amx_GetAddr(amx, params[2], &phys_addr);
+	amx_SetString(phys_addr, cmdline, 0, 0, params[3]);
+	delete[] cmdline;
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL Natives::YSF_GangZoneCreate(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(4, "GangZoneCreate");
+
+	float fMinX = amx_ctof(params[1]);
+	float fMinY = amx_ctof(params[2]);
+	float fMaxX = amx_ctof(params[3]);
+	float fMaxY = amx_ctof(params[4]);
+
+	// If coordinates are wrong, then won't create bugged zone!
+	if(fMaxX <= fMinX || fMaxY <= fMinY) 
+	{
+		//logprintf("GangZoneCreate: MaxX, MaxY must be bigger than MinX, MinY. Not inversely!");
+		//logprintf("GangZoneCreate: %f, %f, %f, %f",fMinX, fMinY, fMaxX, fMaxY);
+		return -1;
+	}
+
+	WORD ret = pServer->pGangZonePool->New(fMinX, fMinY, fMaxX, fMaxY);
+
+	return (ret == 0xFFFF) ? -1 : ret;
+}
+
+static cell AMX_NATIVE_CALL Natives::YSF_GangZoneDestroy(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(1, "GangZoneDestroy");
+
+	CGangZonePool *pGangZonePool = pServer->pGangZonePool;
+	int zoneid = static_cast<int>(params[1]);
+	if(!pGangZonePool || !pGangZonePool->GetSlotState(static_cast<WORD>(zoneid))) return 0;
+
+	pGangZonePool->Delete(static_cast<WORD>(zoneid));
+	return 1;
+}
+
+// native YSF_GangZoneShowForPlayer(playerid, zone, color);
+static cell AMX_NATIVE_CALL Natives::YSF_GangZoneShowForPlayer( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "GangZoneShowForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	DWORD color = (DWORD)params[3];
+
+	// For security
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	return pServer->pGangZonePool->ShowForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), static_cast<DWORD>(color));
+}
+
+// native YSF_GangZoneHideForPlayer(playerid, zone);
+static cell AMX_NATIVE_CALL Natives::YSF_GangZoneHideForPlayer( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "GangZoneHideForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+
+	// For security
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	pServer->pGangZonePool->HideForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid));
+	return 1;
+}
+
+// native YSF_GangZoneShowForAll(zone, color);
+static cell AMX_NATIVE_CALL Natives::YSF_GangZoneShowForAll( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "GangZoneShowForAll");
+
+	int zoneid = static_cast<int>(params[1]);
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	pServer->pGangZonePool->ShowForAll(static_cast<WORD>(zoneid), static_cast<DWORD>(params[2]));
+	return 1;
+}
+
+// native YSF_GangZoneHideForAll(zone);
+static cell AMX_NATIVE_CALL Natives::YSF_GangZoneHideForAll( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GangZoneHideForAll");
+
+	int zoneid = static_cast<int>(params[1]);
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	pServer->pGangZonePool->HideForAll(static_cast<WORD>(zoneid));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL Natives::YSF_GangZoneFlashForPlayer(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(3, "GangZoneFlashForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+
+	// For security
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	pServer->pGangZonePool->FlashForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), static_cast<DWORD>(params[3]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL Natives::YSF_GangZoneFlashForAll(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(2, "GangZoneFlashForAll");
+
+	int zoneid = static_cast<int>(params[1]);
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	pServer->pGangZonePool->FlashForAll(static_cast<WORD>(zoneid), static_cast<DWORD>(params[2]));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL Natives::YSF_GangZoneStopFlashForPlayer(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(2, "GangZoneStopFlashForPlayer");
+
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+
+	// For security
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	pServer->pGangZonePool->StopFlashForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid));
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL Natives::YSF_GangZoneStopFlashForAll(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(1, "GangZoneStopFlashForAll");
+
+	int zoneid = static_cast<int>(params[1]);
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	pServer->pGangZonePool->StopFlashForAll(static_cast<WORD>(zoneid));
+	return 1;
+}
+
+// Menu functions
+// native IsMenuDisabled(Menu:menuid);
+static cell AMX_NATIVE_CALL Natives::IsMenuDisabled( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "IsMenuDisabled");
+	
+	int menuid = static_cast<int>(params[1]);
+	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
+	
+	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
+	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
+
+	return !!(!pMenu->interaction.Menu);
+}
+
+// native IsMenuRowDisabled(Menu:menuid, row);
+static cell AMX_NATIVE_CALL Natives::IsMenuRowDisabled( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsMenuRowDisabled");
+	
+	int menuid = static_cast<int>(params[1]);
+	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
+	
+	int itemid = static_cast<int>(params[2]);
+	if(itemid < 0 || itemid >= 12) return 0;
+
+	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
+	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
+
+	return !!(!pMenu->interaction.Row[itemid]);
+}
+
+// native GetMenuColumns(menuid);
+static cell AMX_NATIVE_CALL Natives::GetMenuColumns( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "GetMenuColumns");
+	
+	int menuid = static_cast<int>(params[1]);
+	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
+	
+	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
+	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
+
+	return pMenu->byteColumnsNumber;
+}
+
+// native GetMenuItems(menuid, column);
+static cell AMX_NATIVE_CALL Natives::GetMenuItems( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "GetMenuItems");
+	
+	int menuid = static_cast<int>(params[1]);
+	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
+
+	int column = static_cast<int>(params[2]);
+	if(menuid < 0 || menuid > 2) return 0;
+
+	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
+	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
+
+	return pMenu->byteItemsCount[column];
+}
+
+// native GetMenuPos(menuid, &Float:fX, &Float:fY);
+static cell AMX_NATIVE_CALL Natives::GetMenuPos( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(3, "GetMenuColumns");
+	
+	int menuid = static_cast<int>(params[1]);
+	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
+
+	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
+	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pMenu->fPosX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pMenu->fPosY);
+	return 1;
+}
+
+// native GetMenuColumnWidth(menuid, &Float:fColumn1, &Float:fColumn2);
+static cell AMX_NATIVE_CALL Natives::GetMenuColumnWidth( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(4, "GetMenuColumnWidth");
+	
+	int menuid = static_cast<int>(params[1]);
+	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
+
+	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
+	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pMenu->fColumn1Width);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pMenu->fColumn2Width);
+	return 1;
+}
+
+// native GetMenuColumnHeader(menuid, column, header[], len = sizeof(header));
+static cell AMX_NATIVE_CALL Natives::GetMenuColumnHeader( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(4, "GetMenuColumnHeader");
+	
+	int menuid = static_cast<int>(params[1]);
+	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
+
+	int column = static_cast<int>(params[2]);
+	if(menuid < 0 || menuid > 2) return 0;
+
+	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
+	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
+
+	return set_amxstring(amx, params[3], pMenu->szHeaders[column], params[4]);
+}
+
+// native GetMenuItem(menuid, column, itemid, item[], len = sizeof(item));
+static cell AMX_NATIVE_CALL Natives::GetMenuItem( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(5, "GetMenuItem");
+	
+	int menuid = static_cast<int>(params[1]);
+	if(menuid < 1 || menuid >= MAX_MENUS) return 0;
+
+	int column = static_cast<int>(params[2]);
+	if(menuid < 0 || menuid > 2) return 0;
+
+	int itemid = static_cast<int>(params[3]);
+	if(itemid < 0 || itemid >= 12) return 0;
+
+	if(!pNetGame->pMenuPool->bIsCreated[menuid]) return 0;
+	CMenu *pMenu = pNetGame->pMenuPool->pMenu[menuid];
+
+	return set_amxstring(amx, params[4], pMenu->szItems[itemid][column], params[5]);
+}
+
+// native CreatePlayerGangZone(playerid, Float:minx, Float:miny, Float:maxx, Float:maxy);
+static cell AMX_NATIVE_CALL Natives::CreatePlayerGangZone( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(5, "CreatePlayerGangZone");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	float fMinX = amx_ctof(params[2]);
+	float fMinY = amx_ctof(params[3]);
+	float fMaxX = amx_ctof(params[4]);
+	float fMaxY = amx_ctof(params[5]);
+
+	// If coordinates are wrong, then won't create bugged zone!
+	if(fMaxX <= fMinX || fMaxY <= fMinY) 
+	{
+		//logprintf("CreatePlayerGangZone: MaxX, MaxY must be bigger than MinX, MinY. Not inversely!");
+		//logprintf("CreatePlayerGangZone: %f, %f, %f, %f",fMinX, fMinY, fMaxX, fMaxY);
+		return -1;
+	}
+
+	WORD ret = pServer->pGangZonePool->New(static_cast<WORD>(playerid), fMinX, fMinY, fMaxX, fMaxY);
+	if (ret == 0xFFFF) return -1;
+
+	return ret;
+}
+
+// native PlayerGangZoneShow(playerid, zoneid, color);
+static cell AMX_NATIVE_CALL Natives::PlayerGangZoneShow( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "PlayerGangZoneShow");
+
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	DWORD dwColor = static_cast<DWORD>(params[3]);
+
+	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
+
+	pServer->pGangZonePool->ShowForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), dwColor, true);
+	return 1;
+}
+
+// native PlayerGangZoneHide(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::PlayerGangZoneHide( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "PlayerGangZoneHide");
+
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
+
+	pServer->pGangZonePool->HideForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), true);
+	return 1;
+}
+
+// native PlayerGangZoneFlash(playerid, zoneid, color);
+static cell AMX_NATIVE_CALL Natives::PlayerGangZoneFlash( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "PlayerGangZoneFlash");
+
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	DWORD dwColor = static_cast<DWORD>(params[3]);
+
+	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
+
+	pServer->pGangZonePool->FlashForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), dwColor, true);
+	return 1;
+}
+
+// native PlayerGangZoneStopFlash(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::PlayerGangZoneStopFlash( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "PlayerGangZoneStopFlash");
+
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
+
+	pServer->pGangZonePool->StopFlashForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), true);
+	return 1;
+}
+
+// native PlayerGangZoneDestroy(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::PlayerGangZoneDestroy( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "PlayerGangZoneDestroy");
+
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+
+	pServer->pGangZonePool->HideForPlayer(static_cast<WORD>(playerid), static_cast<WORD>(zoneid), true);
+	return 1;
+}
+
+// native IsValidPlayerGangZone(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::IsValidPlayerGangZone( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsValidPlayerGangZone");
+	
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	return pPlayerData[playerid]->pPlayerZone[zoneid] != NULL;
+}
+
+// native IsPlayerInPlayerGangZone(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerInPlayerGangZone( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsPlayerInPlayerGangZone");
+	
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
+
+	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true);
+	if(id != 0xFFFF) 
+	{
+		return pPlayerData[playerid]->bInGangZone[id];
+	}
+	return 0;
+}
+
+// native PlayerGangZoneGetPos(playerid, zoneid, &Float:fMinX, &Float:fMinY, &Float:fMaxX, &Float:fMaxY);
+static cell AMX_NATIVE_CALL Natives::PlayerGangZoneGetPos( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(6, "PlayerGangZoneGetPos");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	int zoneid = static_cast<int>(params[2]);
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
+	
+	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true);
+	if(id != 0xFFFF) 
+	{
+		cell* cptr;
+		amx_GetAddr(amx, params[3], &cptr);
+		*cptr = amx_ftoc(pPlayerData[playerid]->pPlayerZone[zoneid]->fGangZone[0]);
+		amx_GetAddr(amx, params[4], &cptr);
+		*cptr = amx_ftoc(pPlayerData[playerid]->pPlayerZone[zoneid]->fGangZone[1]);
+		amx_GetAddr(amx, params[5], &cptr);
+		*cptr = amx_ftoc(pPlayerData[playerid]->pPlayerZone[zoneid]->fGangZone[2]);
+		amx_GetAddr(amx, params[6], &cptr);
+		*cptr = amx_ftoc(pPlayerData[playerid]->pPlayerZone[zoneid]->fGangZone[3]);
+	}
+	return 1;
+}
+
+// native IsPlayerGangZoneVisible(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerGangZoneVisible( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsPlayerInPlayerGangZone");
+	
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
+
+	return pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true) != 0xFFFF;
+}
+
+// native PlayerGangZoneGetColor(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::PlayerGangZoneGetColor( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerGangZoneGetColor");
+	
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
+
+	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true);
+	if(id != 0xFFFF) 
+	{
+		return pPlayerData[playerid]->dwClientSideZoneColor[id];
+	}
+	return 0;
+}
+
+// native PlayerGangZoneGetFlashColor(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::PlayerGangZoneGetFlashColor( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "PlayerGangZoneGetFlashColor");
+	
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
+
+	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true);
+	if(id != 0xFFFF) 
+	{
+		return pPlayerData[playerid]->dwClientSideZoneFlashColor[id];
+	}
+	return 0;
+}
+
+// native IsPlayerGangZoneFlashing(playerid, zoneid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerGangZoneFlashing( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(2, "IsPlayerGangZoneFlashing");
+	
+	int playerid = static_cast<int>(params[1]);
+	int zoneid = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(zoneid < 0 || zoneid >= MAX_GANG_ZONES) return 0;
+	
+	if(!pPlayerData[playerid]->pPlayerZone[zoneid]) return 0;
+
+	WORD id = pPlayerData[playerid]->GetGangZoneIDFromClientSide(static_cast<WORD>(zoneid), true);
+	if(id != 0xFFFF) 
+	{
+		return pPlayerData[playerid]->bIsGangZoneFlashing[id];
+	}
+	return 0;
+}
+
+#ifdef NEW_PICKUP_SYSTEM
+
+// native IsValidPickup(pickupid);
+static cell AMX_NATIVE_CALL Natives::IsValidPickup( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+	
+	CHECK_PARAMS(1, "IsValidPickup");
+
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+
+	return pServer->pPickupPool->FindPickup(id) != 0;
+}
+
+// native IsPickupStreamedIn(playerid, pickupid);
+static cell AMX_NATIVE_CALL Natives::IsPickupStreamedIn( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "IsPickupStreamedIn");
+
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+
+	CPickup *pPickup = pServer->pPickupPool->FindPickup(id);
+	if(!pPickup) return 0;
+
+	return pServer->pPickupPool->IsStreamed(playerid, pPickup);
+}
+
+// native GetPickupPos(pickupid, &Float:fX, &Float:fY, &Float:fZ);
+static cell AMX_NATIVE_CALL Natives::GetPickupPos( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(4, "GetPickupPos");
+
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+
+	CPickup *pPickup = pServer->pPickupPool->FindPickup(id);
+	if(!pPickup) return 0;
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pPickup->vecPos.fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pPickup->vecPos.fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pPickup->vecPos.fZ);
+	return 1;
+}
+
+// native GetPickupModel(pickupid);
+static cell AMX_NATIVE_CALL Natives::GetPickupModel( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPickupModel");
+
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+
+	CPickup *pPickup = pServer->pPickupPool->FindPickup(id);
+	if(!pPickup) return 0;
+
+	return pPickup->iModel;
+}
+
+// native GetPickupType(pickupid);
+static cell AMX_NATIVE_CALL Natives::GetPickupType( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPickupType");
+
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+
+	CPickup *pPickup = pServer->pPickupPool->FindPickup(id);
+	if(!pPickup) return 0;
+
+	return pPickup->iType;
+}
+
+// native GetPickupVirtualWorld(pickupid);
+static cell AMX_NATIVE_CALL Natives::GetPickupVirtualWorld( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPickupVirtualWorld");
+
+	int id = static_cast<int>(params[1]);
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+
+	CPickup *pPickup = pServer->pPickupPool->FindPickup(id);
+	if(!pPickup) return 0;
+
+	return pPickup->iWorld;
+}
+
+// CreatePlayerPickup(playerid, model, type, Float:X, Float:Y, Float:Z, virtualworld = 0);
+static cell AMX_NATIVE_CALL Natives::CreatePlayerPickup( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(7, "CreatePlayerPickup");
+
+	int playerid = static_cast<int>(params[1]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;
+
+	return pServer->pPickupPool->New(playerid, (int)params[2], (int)params[3], CVector(amx_ctof(params[4]), amx_ctof(params[5]), amx_ctof(params[6])), (int)params[7]);
+}
+
+// native DestroyPlayerPickup(playerid, pickupid);
+static cell AMX_NATIVE_CALL Natives::DestroyPlayerPickup( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+	
+	CHECK_PARAMS(2, "DestroyPlayerPickup");
+
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;	
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+	
+	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
+	if(!pPickup) return 0;
+
+	pServer->pPickupPool->Destroy((WORD)playerid, id);
+	return 1;
+}
+
+// native IsValidPlayerPickup(playerid, pickupid);
+static cell AMX_NATIVE_CALL Natives::IsValidPlayerPickup( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+	
+	CHECK_PARAMS(2, "IsValidPlayerPickup");
+
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;	
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+
+	return pServer->pPickupPool->FindPickup(playerid, id) != 0;
+}
+
+// native IsPlayerPickupStreamedIn(playerid, pickupid);
+static cell AMX_NATIVE_CALL Natives::IsPlayerPickupStreamedIn( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+	
+	CHECK_PARAMS(2, "IsPlayerPickupStreamedIn");
+
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;	
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+	
+	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
+	if(!pPickup) return 0;
+
+	return pServer->pPickupPool->IsStreamed(playerid, pPickup);
+}
+
+// native GetPlayerPickupPos(playerid, pickupid, &Float:fX, &Float:fY, &Float:fZ);
+static cell AMX_NATIVE_CALL Natives::GetPlayerPickupPos( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+	
+	CHECK_PARAMS(5, "GetPlayerPickupPos");
+
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;	
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+	
+	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
+	if(!pPickup) return 0;
+
+	cell* cptr;
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pPickup->vecPos.fX);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pPickup->vecPos.fY);
+	amx_GetAddr(amx, params[5], &cptr);
+	*cptr = amx_ftoc(pPickup->vecPos.fZ);
+	return 1;
+}
+
+// native GetPlayerPickupModel(playerid, pickupid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerPickupModel( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+	
+	CHECK_PARAMS(2, "GetPlayerPickupModel");
+
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;	
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+	
+	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
+	if(!pPickup) return 0;
+
+	return pPickup->iModel;
+}
+
+// native GetPlayerPickupType(playerid, pickupid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerPickupType( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+	
+	CHECK_PARAMS(2, "GetPlayerPickupType");
+
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;	
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+	
+	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
+	if(!pPickup) return 0;
+
+	return pPickup->iType;
+}
+
+// native GetPlayerPickupVirtualWorld(playerid, pickupid);
+static cell AMX_NATIVE_CALL Natives::GetPlayerPickupVirtualWorld( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+	
+	CHECK_PARAMS(2, "GetPlayerPickupVirtualWorld");
+
+	int playerid = static_cast<int>(params[1]);
+	int id = static_cast<int>(params[2]);
+	if(!IsPlayerConnectedEx(playerid)) return 0;	
+	if(id < 0 || id >= MAX_PICKUPS) return 0;
+	
+	CPickup *pPickup = pServer->pPickupPool->FindPickup(playerid, id);
+	if(!pPickup) return 0;
+
+	return pPickup->iWorld;
+}
+
+#else
+
+// native IsValidPickup(pickupid);
+static cell AMX_NATIVE_CALL Natives::IsValidPickup(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsValidPickup");
+
+	int id = static_cast<int>(params[1]);
+	if (id < 0 || id >= MAX_PICKUPS)
+		return 0;
+
+	return pNetGame->pPickupPool->bActive[id];
+}
+
+// native IsPickupStreamedIn(playerid, pickupid);
+static cell AMX_NATIVE_CALL Natives::IsPickupStreamedIn(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "IsPickupStreamedIn");
+
+	int playerid = static_cast<int>(params[1]);
+	int pickupid = static_cast<int>(params[2]);
+	if (!IsPlayerConnectedEx(playerid)) return 0;
+	if (pickupid < 0 || pickupid >= MAX_PICKUPS) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid]->bPickupStreamedIn[pickupid];
+}
+
+// native GetPickupPos(pickupid, &Float:fX, &Float:fY, &Float:fZ);
+static cell AMX_NATIVE_CALL Natives::GetPickupPos(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(4, "GetPickupPos");
+
+	int id = static_cast<int>(params[1]);
+	if (id < 0 || id >= MAX_PICKUPS)
+		return 0;
+
+	if (!pNetGame->pPickupPool->bActive[id]) return 0;
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(pNetGame->pPickupPool->Pickup[id].vecPos.fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(pNetGame->pPickupPool->Pickup[id].vecPos.fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(pNetGame->pPickupPool->Pickup[id].vecPos.fZ);
+	return 1;
+}
+
+// native GetPickupModel(pickupid);
+static cell AMX_NATIVE_CALL Natives::GetPickupModel(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPickupModel");
+
+	int id = static_cast<int>(params[1]);
+	if (id < 0 || id >= MAX_PICKUPS)
+		return 0;
+
+	if (!pNetGame->pPickupPool->bActive[id]) return 0;
+
+	return pNetGame->pPickupPool->Pickup[id].iModel;
+}
+
+// native GetPickupType(pickupid);
+static cell AMX_NATIVE_CALL Natives::GetPickupType(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPickupType");
+
+	int id = static_cast<int>(params[1]);
+	if (id < 0 || id >= MAX_PICKUPS)
+		return 0;
+
+	if (!pNetGame->pPickupPool->bActive[id]) return 0;
+
+	return pNetGame->pPickupPool->Pickup[id].iType;
+}
+
+// native GetPickupVirtualWorld(pickupid);
+static cell AMX_NATIVE_CALL Natives::GetPickupVirtualWorld(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "GetPickupVirtualWorld");
+
+	int id = static_cast<int>(params[1]);
+	if (id < 0 || id >= MAX_PICKUPS)
+		return 0;
+
+	if (!pNetGame->pPickupPool->bActive[id]) return 0;
+
+	return pNetGame->pPickupPool->iWorld[id];
+}
+
+#endif
+// RakServer functions //
+// native ClearBanList();
+static cell AMX_NATIVE_CALL Natives::ClearBanList( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	pRakServer->ClearBanList();
+	return 1;
+}
+
+// native IsBanned(_ip[]);
+static cell AMX_NATIVE_CALL Natives::IsBanned( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsBanned");
+
+	char *ip;
+	amx_StrParam(amx, params[1], ip);
+	//return (ip) ? pRakServer->IsBanned(ip) : 0;
+	return (ip) ? CSAMPFunctions::IsBanned(ip) : 0;
+}
+
+// native SetTimeoutTime(playerid, time);
+static cell AMX_NATIVE_CALL Natives::SetTimeoutTime( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(2, "SetTimeoutTime");
+	
+	PlayerID playerId = pRakServer->GetPlayerIDFromIndex(static_cast<int>(params[1]));
+	if(playerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress || !IsPlayerConnectedEx(static_cast<int>(params[1])))
+		return 0;
+
+	pRakServer->SetTimeoutTime((RakNetTime)params[2], playerId);
+	return 1;
+}
+
+// native SetMTUSize(size);
+static cell AMX_NATIVE_CALL Natives::SetMTUSize( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "SetMTUSize");
+	
+	return pRakServer->SetMTUSize(static_cast<int>(params[1]));
+}
+
+// native GetMTUSize();
+static cell AMX_NATIVE_CALL Natives::GetMTUSize( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+	
+	return pRakServer->GetMTUSize();
+}
+
+// native GetLocalIP(index, localip[], len = sizeof(localip));
+static cell AMX_NATIVE_CALL Natives::GetLocalIP( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "GetLocalIP");
+
+	return set_amxstring(amx, params[2], pRakServer->GetLocalIP((unsigned int)params[1]), params[3]);
+}
+
+// native SendRPC(playerid, RPC, {Float,_}:...)
+static cell AMX_NATIVE_CALL Natives::SendRPC( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	bool bBroadcast = static_cast<int>(params[1]) == -1;
+	int rpcid = static_cast<int>(params[2]);
+	
+	PlayerID playerId = bBroadcast ? UNASSIGNED_PLAYER_ID : pRakServer->GetPlayerIDFromIndex(static_cast<int>(params[1]));
+	
+	if (playerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress && !bBroadcast)
+		return 0;
+	
+	RakNet::BitStream bs;
+	cell *type = (cell*)0;
+	cell *data = (cell*)0;
+
+	for (int i = 0; i < (int)((params[0]/sizeof(cell)) - 2); i+=2)
+	{
+		amx_GetAddr(amx, params[i + 3], &type);
+		amx_GetAddr(amx, params[i + 4], &data);
+					
+		if (type && data)
+		{
+			switch (*type)
+			{
+			case BS_BOOL:
+				bs.Write((bool)(*data!=0));
+				break;
+			case BS_CHAR:
+				bs.Write(*(char*)data);
+				break;
+			case BS_UNSIGNEDCHAR:
+				bs.Write(*(unsigned char*)data);
+				break;
+			case BS_SHORT:
+				bs.Write(*(short*)data);
+				break;
+			case BS_UNSIGNEDSHORT:
+				bs.Write(*(unsigned short*)data);
+				break;
+			case BS_INT:
+				bs.Write(*(int*)data);
+				break;
+			case BS_UNSIGNEDINT:
+				bs.Write(*(unsigned int*)data);
+				break;
+			case BS_FLOAT:
+				bs.Write(*(float*)data);
+				break;
+			case BS_STRING:
+				{
+					int len;
+					amx_StrLen(data, &len);
+					len++;
+					char* str = new char[len];
+					amx_GetString(str, data, 0, len);
+					bs.Write(str, len - 1);
+					//logprintf("str: %s", str);
+					delete [] str;
+				}
+				break;
+			}
+		}
+	}
+
+	if(bBroadcast)
+	{
+		pRakServer->RPC(&rpcid, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true, 0);
+	}
+	else
+	{
+		pRakServer->RPC(&rpcid, &bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, playerId, 0, 0);
+	}
+	return 1;
+}
+
+// native SendData(playerid, {Float,_}:...)
+static cell AMX_NATIVE_CALL Natives::SendData( AMX* amx, cell* params )
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	bool bBroadcast = static_cast<int>(params[1]) == -1;
+	PlayerID playerId = bBroadcast ? UNASSIGNED_PLAYER_ID : pRakServer->GetPlayerIDFromIndex(static_cast<int>(params[1]));
+
+	if (playerId.binaryAddress == UNASSIGNED_PLAYER_ID.binaryAddress && !bBroadcast)
+		return 0;
+	
+	RakNet::BitStream bs;
+	cell *type = (cell*)0;
+	cell *data = (cell*)0;
+
+	for (int i = 0; i < (int)((params[0]/sizeof(cell)) - 2); i+=2)
+	{
+		amx_GetAddr(amx, params[i + 2], &type);
+		amx_GetAddr(amx, params[i + 3], &data);
+					
+		if (type && data)
+		{
+			switch (*type)
+			{
+			case BS_BOOL:
+				bs.Write((bool)(*data!=0));
+				break;
+			case BS_CHAR:
+				bs.Write(*(char*)data);
+				break;
+			case BS_UNSIGNEDCHAR:
+				bs.Write(*(unsigned char*)data);
+				break;
+			case BS_SHORT:
+				bs.Write(*(short*)data);
+				break;
+			case BS_UNSIGNEDSHORT:
+				bs.Write(*(unsigned short*)data);
+				break;
+			case BS_INT:
+				bs.Write(*(int*)data);
+				break;
+			case BS_UNSIGNEDINT:
+				bs.Write(*(unsigned int*)data);
+				break;
+			case BS_FLOAT:
+				bs.Write(*(float*)data);
+				break;
+			case BS_STRING:
+				{
+					int len;
+					amx_StrLen(data, &len);
+					len++;
+					char* str = new char[len];
+					amx_GetString(str, data, 0, len);
+					bs.Write(str, len - 1);
+					//logprintf("str: %s", str);
+					delete [] str;
+				}
+				break;
+			}
+		}
+	}
+
+	if(bBroadcast)
+	{
+		pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true);
+	}
+	else
+	{
+		pRakServer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, 0, playerId, 0);
+	}
+	return 1;
+}
+
+// native GetColCount();
+static cell AMX_NATIVE_CALL Natives::GetColCount( AMX* amx, cell* params )
+{
+	return CModelSizes::GetColCount();
+}
+
+// native Float:GetColSphereRadius(modelid);
+static cell AMX_NATIVE_CALL Natives::GetColSphereRadius( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "GetColSphereRadius");
+	
+	float fRet = CModelSizes::GetColSphereRadius(static_cast<int>(params[1]));
+	return amx_ftoc(fRet);
+}
+
+// native GetColSphereOffset(modelid, &Float:fX, &Float:fY, &Float:fZ);
+static cell AMX_NATIVE_CALL Natives::GetColSphereOffset( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(4, "GetColSphereOffset");
+
+	CVector vecOffset = CModelSizes::GetColSphereOffset(static_cast<int>(params[1]));
+
+	cell* cptr;
+	amx_GetAddr(amx, params[2], &cptr);
+	*cptr = amx_ftoc(vecOffset.fX);
+	amx_GetAddr(amx, params[3], &cptr);
+	*cptr = amx_ftoc(vecOffset.fY);
+	amx_GetAddr(amx, params[4], &cptr);
+	*cptr = amx_ftoc(vecOffset.fZ);
+	return 1;
+}
+
+// native GetWeaponSlot(weaponid);
+static cell AMX_NATIVE_CALL Natives::GetWeaponSlot( AMX* amx, cell* params )
+{
+	CHECK_PARAMS(1, "GetWeaponSlot");
+	
+	return CUtils::GetWeaponSlot(static_cast<BYTE>(params[1]));
+}
+
+// native GetWeaponName(weaponid, weaponname[], len = sizeof(weaponname));
+static cell AMX_NATIVE_CALL Natives::FIXED_GetWeaponName(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if(!pServer)
+		return 0;
+
+	CHECK_PARAMS(3, "GetWeaponName");
+
+	return set_amxstring(amx, params[2], CUtils::GetWeaponName_(static_cast<BYTE>(params[1])), params[3]);
+}
+
+// native IsPlayerConnectedEx(playerid);
+static cell AMX_NATIVE_CALL Natives::FIXED_IsPlayerConnectedEx(AMX* amx, cell* params)
+{
+	// If unknown server version
+	if (!pServer)
+		return 0;
+
+	CHECK_PARAMS(1, "IsPlayerConnectedEx");
+
+	int playerid = static_cast<int>(params[1]);
+	if (playerid < 0 || playerid >= MAX_PLAYERS) return 0;
+
+	return pNetGame->pPlayerPool->pPlayer[playerid] != NULL;
+}
+
+#ifdef NEW_PICKUP_SYSTEM
+// native CreatePickup(model, type, Float:X, Float:Y, Float:Z, virtualworld = 0);
+static cell AMX_NATIVE_CALL Natives::CreatePickup(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(6, "CreatePickup");
+
+	return pServer->pPickupPool->New((int)params[1], (int)params[2], CVector(amx_ctof(params[3]), amx_ctof(params[4]), amx_ctof(params[5])), (int)params[6]);
+}
+
+// native DestroyPickup(pickupid);
+static cell AMX_NATIVE_CALL Natives::DestroyPickup(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(1, "DestroyPickup");
+
+	pServer->pPickupPool->Destroy((int)params[1]);
+	return 1;
+}
+
+// native SetPickupStreamingEnabled(enabled);
+static cell AMX_NATIVE_CALL Natives::SetPickupStreamingEnabled(AMX *amx, cell *params)
+{
+	CHECK_PARAMS(1, "SetPickupStreamingEnabled");
+
+	pServer->pPickupPool->SetStreamingEnabled(!!params[1]);
+	return 1;
+}
+#endif
+
+
+// And an array containing the native function-names and the functions specified with them
+AMX_NATIVE_INFO YSINatives [] =
+{
+	// File
+	{"ffind",							Natives::ffind},
+	{"frename",							Natives::frename},
+	
+	// Directory
+	{"dfind",							Natives::dfind},
+	{"dcreate",							Natives::dcreate},
+	{"drename",							Natives::drename},
+
+	// Generic
+	{"SetModeRestartTime",				Natives::SetModeRestartTime},
+	{"GetModeRestartTime",				Natives::GetModeRestartTime},
+	{"SetMaxPlayers",					Natives::SetMaxPlayers}, // R8
+	{"SetMaxNPCs",						Natives::SetMaxNPCs}, // R8
+	{"GetSyncBounds",					Natives::GetSyncBounds}, // R17-2
+	{"SetSyncBounds",					Natives::SetSyncBounds}, // R17-2
+
+	{"SetPlayerAdmin",					Natives::SetPlayerAdmin},
+	{"LoadFilterScript",				Natives::LoadFilterScript},
+	{"UnLoadFilterScript",				Natives::UnLoadFilterScript},
+	{"GetFilterScriptCount",			Natives::GetFilterScriptCount},
+	{"GetFilterScriptName",				Natives::GetFilterScriptName},
+
+	{"AddServerRule",					Natives::AddServerRule},
+	{"SetServerRule",					Natives::SetServerRule},
+	{"SetServerRuleInt",				Natives::SetServerRuleInt},
+	{"IsValidServerRule",				Natives::IsValidServerRule},
+	{"RemoveServerRule",				Natives::RemoveServerRule}, // Doesn't work!
+	{"ModifyFlag",						Natives::SetServerRuleFlags},
+	{"SetServerRuleFlags",				Natives::SetServerRuleFlags},
+	{"GetServerRuleFlags",				Natives::GetServerRuleFlags},
+
+	// Server settings
+	{"GetServerSettings",				Natives::GetServerSettings},
+
+	// Nick name
+	{"IsValidNickName",					Natives::IsValidNickName},	// R8
+	{"AllowNickNameCharacter",			Natives::AllowNickNameCharacter}, // R7
+	{"IsNickNameCharacterAllowed",		Natives::IsNickNameCharacterAllowed}, // R7
+
+	// Player classes
+	{ "GetAvailableClasses",			Natives::GetAvailableClasses}, // R6
+	{ "RemoveLastClass",				Natives::RemoveLastClass}, // R16
+	{ "GetPlayerClass",					Natives::GetPlayerClass}, // R6
+	{ "EditPlayerClass",				Natives::EditPlayerClass}, // R6
+	
+	// Timers
+	{ "GetRunningTimers",				Natives::GetRunningTimers}, // R8
+
+	// Special
+	{ "SetPlayerGravity",				Natives::SetPlayerGravity },
+	{ "GetPlayerGravity",				Natives::GetPlayerGravity },
+	
+	{ "SetPlayerTeamForPlayer",			Natives::SetPlayerTeamForPlayer }, // R5
+	{ "GetPlayerTeamForPlayer",			Natives::GetPlayerTeamForPlayer }, // R5
+	{ "SetPlayerSkinForPlayer",			Natives::SetPlayerSkinForPlayer }, // R11
+	{ "GetPlayerSkinForPlayer",			Natives::GetPlayerSkinForPlayer }, // R11
+	{ "SetPlayerNameForPlayer",			Natives::SetPlayerNameForPlayer }, // R11
+	{ "GetPlayerNameForPlayer",			Natives::GetPlayerNameForPlayer }, // R11
+	{ "SetPlayerFightStyleForPlayer",	Natives::SetPlayerFightStyleForPlayer }, // R11
+	{ "GetPlayerFightStyleForPlayer",	Natives::GetPlayerFightStyleForPlayer }, // R11
+	{ "SetPlayerPosForPlayer",			Natives::SetPlayerPosForPlayer}, // R12
+	{ "SetPlayerRotationQuatForPlayer",	Natives::SetPlayerRotationQuatForPlayer}, // R12
+	{ "ApplyAnimationForPlayer",		Natives::ApplyAnimationForPlayer}, // R11
+	{ "GetPlayerWeather",				Natives::GetPlayerWeather },
+	{ "GetPlayerWorldBounds",			Natives::GetPlayerWorldBounds },
+	{ "TogglePlayerWidescreen",			Natives::TogglePlayerWidescreen },
+	{ "IsPlayerWidescreenToggled",		Natives::IsPlayerWidescreenToggled },
+	{ "GetSpawnInfo",					Natives::GetSpawnInfo }, // R8
+	{ "GetPlayerSkillLevel",			Natives::GetPlayerSkillLevel }, // R3
+	{ "IsPlayerCheckpointActive",		Natives::IsPlayerCheckpointActive }, // R10
+	{ "GetPlayerCheckpoint",			Natives::GetPlayerCheckpoint }, // R4
+	{ "IsPlayerRaceCheckpointActive",	Natives::IsPlayerRaceCheckpointActive }, // R10
+	{ "GetPlayerRaceCheckpoint",		Natives::GetPlayerRaceCheckpoint }, // R4
+	{ "GetPlayerWorldBounds",			Natives::GetPlayerWorldBounds }, // R5
+	{ "IsPlayerInModShop",				Natives::IsPlayerInModShop }, // R4
+	{ "SendBulletData",					Natives::SendBulletData }, // R6
+	{ "ShowPlayerForPlayer",			Natives::ShowPlayerForPlayer }, // R8
+	{ "HidePlayerForPlayer",			Natives::HidePlayerForPlayer }, // R8
+	{ "AddPlayerForPlayer",				Natives::AddPlayerForPlayer }, // R17
+	{ "RemovePlayerForPlayer",			Natives::RemovePlayerForPlayer }, // R17
+	{ "SetPlayerChatBubbleForPlayer",   Natives::SetPlayerChatBubbleForPlayer }, // R10
+	{ "ResetPlayerMarkerForPlayer",     Natives::ResetPlayerMarkerForPlayer }, //2.2
+	{ "SetPlayerVersion",				Natives::SetPlayerVersion }, // R9
+	{ "IsPlayerSpawned",				Natives::IsPlayerSpawned }, // R9
+	{ "IsPlayerControllable",			Natives::IsPlayerControllable}, // R11
+	{ "SpawnForWorld",					Natives::SpawnForWorld }, // R10
+	{ "BroadcastDeath",					Natives::BroadcastDeath }, // R13
+	{ "IsPlayerCameraTargetEnabled",	Natives::IsPlayerCameraTargetEnabled }, // R13
+	{ "SetPlayerDisabledKeysSync",		Natives::SetPlayerDisabledKeysSync }, // R16
+	{ "GetPlayerDisabledKeysSync",		Natives::GetPlayerDisabledKeysSync }, // R16
+
+	// Special things from syncdata
+	{ "GetPlayerSirenState",			Natives::GetPlayerSirenState },
+	{ "GetPlayerLandingGearState",		Natives::GetPlayerLandingGearState },
+	{ "GetPlayerHydraReactorAngle",		Natives::GetPlayerHydraReactorAngle },
+	{ "GetPlayerTrainSpeed",			Natives::GetPlayerTrainSpeed },
+	{ "GetPlayerZAim",					Natives::GetPlayerZAim },
+	{ "GetPlayerSurfingOffsets",		Natives::GetPlayerSurfingOffsets },
+	{ "GetPlayerRotationQuat",			Natives::GetPlayerRotationQuat }, // R3
+	{ "GetPlayerDialogID",				Natives::GetPlayerDialogID }, // R8
+	{ "GetPlayerSpectateID",			Natives::GetPlayerSpectateID }, // R8
+	{ "GetPlayerSpectateType",			Natives::GetPlayerSpectateType }, // R8
+	{ "GetPlayerLastSyncedVehicleID",	Natives::GetPlayerLastSyncedVehicleID }, // R10
+	{ "GetPlayerLastSyncedTrailerID",	Natives::GetPlayerLastSyncedTrailerID }, // R10
+	{ "GetPlayerFPS", 					Natives::GetPlayerFPS},
+
+	// Actor
+	{ "GetActorSpawnInfo", 				Natives::GetActorSpawnInfo}, // R13
+	{ "GetActorSkin", 					Natives::GetActorSkin}, // R13
+	{ "GetActorAnimation", 				Natives::GetActorAnimation}, // R17
+
+	// Scoreboard manipulation
+	{ "TogglePlayerScoresPingsUpdate",	Natives::TogglePlayerScoresPingsUpdate }, // R8
+	{ "TogglePlayerFakePing",			Natives::TogglePlayerFakePing }, // R8
+	{ "SetPlayerFakePing",				Natives::SetPlayerFakePing }, // R8
+	{ "TogglePlayerOnPlayerList",		Natives::TogglePlayerInServerQuery }, // R11
+	{ "IsPlayerToggledOnPlayerList",	Natives::IsPlayerToggledInServerQuery }, // R11
+	{ "TogglePlayerInServerQuery",		Natives::TogglePlayerInServerQuery }, // R11
+	{ "IsPlayerToggledInServerQuery",	Natives::IsPlayerToggledInServerQuery }, // R11
+
+	// AFK
+	{ "IsPlayerPaused",					Natives::IsPlayerPaused },
+	{ "GetPlayerPausedTime",			Natives::GetPlayerPausedTime },
+	
+	// Objects get - global
+	{"GetObjectDrawDistance",			Natives::GetObjectDrawDistance},
+	{"SetObjectMoveSpeed",				Natives::SetObjectMoveSpeed}, // R6
+	{"GetObjectMoveSpeed",				Natives::GetObjectMoveSpeed}, // R6
+	{"GetObjectTarget",					Natives::GetObjectTarget}, // R6
+	{"GetObjectAttachedData",			Natives::GetObjectAttachedData},
+	{"GetObjectAttachedOffset",			Natives::GetObjectAttachedOffset},
+	{"IsObjectMaterialSlotUsed",		Natives::IsObjectMaterialSlotUsed}, // R6
+	{"GetObjectMaterial",				Natives::GetObjectMaterial}, // R6
+	{"GetObjectMaterialText",			Natives::GetObjectMaterialText}, // R6
+	{"IsObjectNoCameraCol",				Natives::IsObjectNoCameraCol}, // R13
+
+	// Objects get - player
+	{"GetPlayerObjectDrawDistance",		Natives::GetPlayerObjectDrawDistance},
+	{"SetPlayerObjectMoveSpeed",		Natives::SetPlayerObjectMoveSpeed}, // R6
+	{"GetPlayerObjectMoveSpeed",		Natives::GetPlayerObjectMoveSpeed}, // R6
+	{"GetPlayerObjectTarget",			Natives::GetPlayerObjectTarget}, // R6
+	{"GetPlayerObjectAttachedData",		Natives::GetPlayerObjectAttachedData},
+	{"GetPlayerObjectAttachedOffset",	Natives::GetPlayerObjectAttachedOffset},
+	{"IsPlayerObjectMaterialSlotUsed",	Natives::IsPlayerObjectMaterialSlotUsed}, // R6
+	{"GetPlayerObjectMaterial",			Natives::GetPlayerObjectMaterial}, // R6
+	{"GetPlayerObjectMaterialText",		Natives::GetPlayerObjectMaterialText}, // R6
+	{"IsPlayerObjectNoCameraCol",		Natives::IsPlayerObjectNoCameraCol}, // R13
+	{"GetPlayerSurfingPlayerObjectID",	Natives::GetPlayerSurfingPlayerObjectID}, // R12
+	{"GetPlayerCameraTargetPlayerObj",	Natives::GetPlayerCameraTargetPlayerObj}, // R13
+	{"GetObjectType",					Natives::GetObjectType}, // R12
+
+	// special - for attached objects
+	{"GetPlayerAttachedObject",			Natives::GetPlayerAttachedObject}, // R3
+	
+	// Vehicle functions
+	{"GetVehicleSpawnInfo",				Natives::GetVehicleSpawnInfo},
+	{"SetVehicleSpawnInfo",				Natives::SetVehicleSpawnInfo}, // R16
+	{"GetVehicleColor",					Natives::GetVehicleColor},
+	{"GetVehiclePaintjob",				Natives::GetVehiclePaintjob},
+	{"GetVehicleInterior",				Natives::GetVehicleInterior},
+	{"GetVehicleNumberPlate",			Natives::GetVehicleNumberPlate},
+	{"SetVehicleRespawnDelay",			Natives::SetVehicleRespawnDelay},
+	{"GetVehicleRespawnDelay",			Natives::GetVehicleRespawnDelay},
+	{"SetVehicleOccupiedTick",			Natives::SetVehicleOccupiedTick}, // R6
+	{"GetVehicleOccupiedTick",			Natives::GetVehicleOccupiedTick},
+	{"SetVehicleRespawnTick",			Natives::SetVehicleRespawnTick},
+	{"GetVehicleRespawnTick",			Natives::GetVehicleRespawnTick},
+	{"GetVehicleLastDriver",			Natives::GetVehicleLastDriver},
+	{"GetVehicleCab",					Natives::GetVehicleCab}, // R9
+	{"HasVehicleBeenOccupied",			Natives::HasVehicleBeenOccupied}, // R9
+	{"SetVehicleBeenOccupied",			Natives::SetVehicleBeenOccupied}, // R9
+	{"IsVehicleOccupied",				Natives::IsVehicleOccupied}, // R9
+	{"IsVehicleDead",					Natives::IsVehicleDead}, // R9
+	{"GetVehicleModelCount",			Natives::GetVehicleModelCount}, // R17
+	{"GetVehicleModelsUsed",			Natives::GetVehicleModelsUsed}, // R17
+	{"SetVehicleParamsSirenState",		Natives::SetVehicleParamsSirenState}, //R17-3
+	{"ToggleVehicleSirenEnabled",		Natives::ToggleVehicleSirenEnabled}, //R17-3
+	{"IsVehicleSirenEnabled",			Natives::IsVehicleSirenEnabled}, //R17-3
+	{"GetVehicleMatrix",				Natives::GetVehicleMatrix}, //R17-3
+	{"SetVehicleMatrix",				Natives::SetVehicleMatrix}, //R17-3
+
+	// Gangzone - Global
+	{"IsValidGangZone",					Natives::IsValidGangZone},
+	{"IsPlayerInGangZone",				Natives::IsPlayerInGangZone},
+	{"IsGangZoneVisibleForPlayer",		Natives::IsGangZoneVisibleForPlayer},
+	{"GangZoneGetColorForPlayer",		Natives::GangZoneGetColorForPlayer},
+	{"GangZoneGetFlashColorForPlayer",	Natives::GangZoneGetFlashColorForPlayer},
+	{"IsGangZoneFlashingForPlayer",		Natives::IsGangZoneFlashingForPlayer}, // R6
+	{"GangZoneGetPos",					Natives::GangZoneGetPos},
+
+	// Gangzone - Player
+	{ "CreatePlayerGangZone",			Natives::CreatePlayerGangZone },
+	{ "PlayerGangZoneDestroy",			Natives::PlayerGangZoneDestroy },
+	{ "PlayerGangZoneShow",				Natives::PlayerGangZoneShow },
+	{ "PlayerGangZoneHide",				Natives::PlayerGangZoneHide },
+	{ "PlayerGangZoneFlash",			Natives::PlayerGangZoneFlash},
+	{ "PlayerGangZoneStopFlash",		Natives::PlayerGangZoneStopFlash },
+	{ "IsValidPlayerGangZone",			Natives::IsValidPlayerGangZone },
+	{ "IsPlayerInPlayerGangZone",		Natives::IsPlayerInPlayerGangZone },
+	{ "IsPlayerGangZoneVisible",		Natives::IsPlayerGangZoneVisible },
+	{ "PlayerGangZoneGetColor",			Natives::PlayerGangZoneGetColor },
+	{ "PlayerGangZoneGetFlashColor",	Natives::PlayerGangZoneGetFlashColor },
+	{ "IsPlayerGangZoneFlashing",		Natives::IsPlayerGangZoneFlashing }, // R6
+	{ "PlayerGangZoneGetPos",			Natives::PlayerGangZoneGetPos },
+
+	// Textdraw functions
+	{"IsValidTextDraw",					Natives::IsValidTextDraw},
+	{"IsTextDrawVisibleForPlayer",		Natives::IsTextDrawVisibleForPlayer},
+	{"TextDrawGetString",				Natives::TextDrawGetString},
+	{"TextDrawSetPos",					Natives::TextDrawSetPos},
+	{"TextDrawGetLetterSize",			Natives::TextDrawGetLetterSize},
+	{"TextDrawGetFontSize",				Natives::TextDrawGetTextSize},
+	{"TextDrawGetTextSize",				Natives::TextDrawGetTextSize},
+	{"TextDrawGetPos",					Natives::TextDrawGetPos},
+	{"TextDrawGetColor",				Natives::TextDrawGetColor},
+	{"TextDrawGetBoxColor",				Natives::TextDrawGetBoxColor},
+	{"TextDrawGetBackgroundColor",		Natives::TextDrawGetBackgroundColor},
+	{"TextDrawGetShadow",				Natives::TextDrawGetShadow},
+	{"TextDrawGetOutline",				Natives::TextDrawGetOutline},
+	{"TextDrawGetFont",					Natives::TextDrawGetFont},
+	{"TextDrawIsBox",					Natives::TextDrawIsBox},
+	{"TextDrawIsProportional",			Natives::TextDrawIsProportional},
+	{"TextDrawIsSelectable",			Natives::TextDrawIsSelectable}, // R6
+	{"TextDrawGetAlignment",			Natives::TextDrawGetAlignment},
+	{"TextDrawGetPreviewModel",			Natives::TextDrawGetPreviewModel},
+	{"TextDrawGetPreviewRot",			Natives::TextDrawGetPreviewRot},
+	{"TextDrawGetPreviewVehCol",		Natives::TextDrawGetPreviewVehCol},
+
+	// Per-Player Textdraw functions - R4
+	{"IsValidPlayerTextDraw",			Natives::IsValidPlayerTextDraw},
+	{"IsPlayerTextDrawVisible",			Natives::IsPlayerTextDrawVisible},
+	{"PlayerTextDrawGetString",			Natives::PlayerTextDrawGetString},
+	{"PlayerTextDrawSetPos",			Natives::PlayerTextDrawSetPos},
+	{"PlayerTextDrawGetLetterSize",		Natives::PlayerTextDrawGetLetterSize},
+	{"PlayerTextDrawGetFontSize",		Natives::PlayerTextDrawGetTextSize},
+	{"PlayerTextDrawGetTextSize",		Natives::PlayerTextDrawGetTextSize},
+	{"PlayerTextDrawGetPos",			Natives::PlayerTextDrawGetPos},
+	{"PlayerTextDrawGetColor",			Natives::PlayerTextDrawGetColor},
+	{"PlayerTextDrawGetBoxColor",		Natives::PlayerTextDrawGetBoxColor},
+	{"PlayerTextDrawGetBackgroundCol",	Natives::PlayerTextDrawGetBackgroundCol},
+	{"PlayerTextDrawGetShadow",			Natives::PlayerTextDrawGetShadow},
+	{"PlayerTextDrawGetOutline",		Natives::PlayerTextDrawGetOutline},
+	{"PlayerTextDrawGetFont",			Natives::PlayerTextDrawGetFont},
+	{"PlayerTextDrawIsBox",				Natives::PlayerTextDrawIsBox},
+	{"PlayerTextDrawIsProportional",	Natives::PlayerTextDrawIsProportional},
+	{"PlayerTextDrawIsSelectable",		Natives::PlayerTextDrawIsSelectable}, // R6
+	{"PlayerTextDrawGetAlignment",		Natives::PlayerTextDrawGetAlignment},
+	{"PlayerTextDrawGetPreviewModel",	Natives::PlayerTextDrawGetPreviewModel},
+	{"PlayerTextDrawGetPreviewRot",		Natives::PlayerTextDrawGetPreviewRot},
+	{"PlayerTextDrawGetPreviewVehCol",	Natives::PlayerTextDrawGetPreviewVehCol},
+
+	// 3D Text
+	{"IsValid3DTextLabel",				Natives::IsValid3DTextLabel}, // R4
+	{"Is3DTextLabelStreamedIn",			Natives::Is3DTextLabelStreamedIn}, // R9
+	{"Get3DTextLabelText",				Natives::Get3DTextLabelText},
+	{"Get3DTextLabelColor",				Natives::Get3DTextLabelColor},
+	{"Get3DTextLabelPos",				Natives::Get3DTextLabelPos},
+	{"Get3DTextLabelDrawDistance",		Natives::Get3DTextLabelDrawDistance},
+	{"Get3DTextLabelLOS",				Natives::Get3DTextLabelLOS},
+	{"Get3DTextLabelVirtualWorld",		Natives::Get3DTextLabelVirtualWorld},
+	{"Get3DTextLabelAttachedData",		Natives::Get3DTextLabelAttachedData},
+
+	// Per-Player 3D Text
+	{"IsValidPlayer3DTextLabel",		Natives::IsValidPlayer3DTextLabel}, // R4
+	{"GetPlayer3DTextLabelText",		Natives::GetPlayer3DTextLabelText}, // R4
+	{"GetPlayer3DTextLabelColor",		Natives::GetPlayer3DTextLabelColor}, // R4
+	{"GetPlayer3DTextLabelPos",			Natives::GetPlayer3DTextLabelPos}, // R4
+	{"GetPlayer3DTextLabelDrawDist",	Natives::GetPlayer3DTextLabelDrawDist},
+	{"GetPlayer3DTextLabelLOS",			Natives::GetPlayer3DTextLabelLOS}, // R4
+	{"GetPlayer3DTextLabelVirtualW",	Natives::GetPlayer3DTextLabelVirtualW}, // R4
+	{"GetPlayer3DTextLabelAttached",	Natives::GetPlayer3DTextLabelAttached}, // R9
+
+	// Menus
+	{"IsMenuDisabled",					Natives::IsMenuDisabled}, // R5 
+	{"IsMenuRowDisabled",				Natives::IsMenuRowDisabled}, // R5
+	{"GetMenuColumns",					Natives::GetMenuColumns},
+	{"GetMenuItems",					Natives::GetMenuItems},
+	{"GetMenuPos",						Natives::GetMenuPos},
+	{"GetMenuColumnWidth",				Natives::GetMenuColumnWidth},
+	{"GetMenuColumnHeader",				Natives::GetMenuColumnHeader},
+	{"GetMenuItem",						Natives::GetMenuItem},
+	
+	// Pickups - Global
+	{ "IsValidPickup",					Natives::IsValidPickup }, // R10
+	{ "IsPickupStreamedIn",				Natives::IsPickupStreamedIn }, // R10
+	{ "GetPickupPos",					Natives::GetPickupPos }, // R10
+	{ "GetPickupModel",					Natives::GetPickupModel }, // R10
+	{ "GetPickupType",					Natives::GetPickupType }, // R10
+	{ "GetPickupVirtualWorld",			Natives::GetPickupVirtualWorld }, // R10
+#ifdef NEW_PICKUP_SYSTEM
+	// Pickups - Per-player
+	{ "CreatePlayerPickup",				Natives::CreatePlayerPickup}, // R10
+	{ "DestroyPlayerPickup",			Natives::DestroyPlayerPickup }, // R10
+	{ "IsValidPlayerPickup",			Natives::IsValidPlayerPickup }, // R10
+	{ "IsPlayerPickupStreamedIn",		Natives::IsPlayerPickupStreamedIn }, // R10
+	{ "GetPlayerPickupPos",				Natives::GetPlayerPickupPos }, // R10
+	{ "GetPlayerPickupModel",			Natives::GetPlayerPickupModel }, // R10
+	{ "GetPlayerPickupType",			Natives::GetPlayerPickupType }, // R10
+	{ "GetPlayerPickupVirtualWorld",	Natives::GetPlayerPickupVirtualWorld }, // R10
+#endif
+	// RakServer functions
+	{ "ClearBanList",					Natives::ClearBanList },
+	{ "IsBanned",						Natives::IsBanned },
+
+	{ "SetTimeoutTime",					Natives::SetTimeoutTime },
+//	{ "SetMTUSize",						Natives::SetMTUSize },
+	{ "GetMTUSize",						Natives::GetMTUSize },
+	{ "GetLocalIP",						Natives::GetLocalIP },
+	
+	{ "SendRPC",						Natives::SendRPC },
+	{ "SendData",						Natives::SendData },
+	{ "YSF_SetTickRate",				Natives::YSF_SetTickRate},
+	{ "YSF_GetTickRate",				Natives::YSF_GetTickRate},
+	{ "YSF_EnableNightVisionFix",		Natives::YSF_EnableNightVisionFix },
+	{ "YSF_IsNightVisionFixEnabled",	Natives::YSF_IsNightVisionFixEnabled },
+	{ "YSF_SetExtendedNetStatsEnabled",	Natives::YSF_SetExtendedNetStatsEnabled }, // R17
+	{ "YSF_IsExtendedNetStatsEnabled",	Natives::YSF_IsExtendedNetStatsEnabled }, // R17
+	{ "YSF_SetAFKAccuracy",				Natives::YSF_SetAFKAccuracy }, // R17
+	{ "YSF_GetAFKAccuracy",				Natives::YSF_GetAFKAccuracy }, // R17
+	{ "YSF_ToggleNPCTracking",			Natives::YSF_ToggleNPCTracking }, // 2.2
+	{ "YSF_IsNPCTrackingEnabled",		Natives::YSF_IsNPCTrackingEnabled }, // 2.2
+	{ "GetNPCCommandLine",				Natives::GetNPCCommandLine }, // 2.2
+
+	{ "AttachPlayerObjectToObject",		Natives::AttachPlayerObjectToObject },
+	
+	// Recording functions
+	{ "SetRecordingDirectory",			Natives::SetRecordingDirectory }, // R17
+	{ "GetRecordingDirectory",			Natives::GetRecordingDirectory }, // R17
+
+	// Format functions
+	{ "SendClientMessagef",				Natives::SendClientMessagef },
+	{ "SendClientMessageToAllf",		Natives::SendClientMessageToAllf },
+	{ "GameTextForPlayerf",				Natives::GameTextForPlayerf },
+	{ "GameTextForAllf",				Natives::GameTextForAllf },
+	{ "SendPlayerMessageToPlayerf",		Natives::SendPlayerMessageToPlayerf },
+	{ "SendPlayerMessageToAllf",		Natives::SendPlayerMessageToAllf },
+	{ "SendRconCommandf",				Natives::SendRconCommandf },
+
+	// Other
+	{"GetColCount",						Natives::GetColCount},
+	{"GetColSphereRadius",				Natives::GetColSphereRadius},
+	{"GetColSphereOffset",				Natives::GetColSphereOffset},
+
+	{ "GetWeaponSlot",					Natives::GetWeaponSlot},
+#ifdef NEW_PICKUP_SYSTEM
+	{ "SetPickupStreamingEnabled",		Natives::SetPickupStreamingEnabled },
+#endif
+	{ 0,								0 }
+};
+
+AMX_NATIVE_INFO RedirectedNatives[] =
+{
+	// File
+	{ "AttachObjectToPlayer",			Natives::YSF_AttachObjectToPlayer },
+	{ "AttachPlayerObjectToPlayer",		Natives::YSF_AttachPlayerObjectToPlayer },
+	{ "SetGravity",						Natives::YSF_SetGravity },
+	{ "GetGravity",						Natives::YSF_GetGravity },
+	{ "SetWeather",						Natives::YSF_SetWeather },
+	{ "SetPlayerWeather",				Natives::YSF_SetPlayerWeather },
+	{ "SetPlayerWorldBounds",			Natives::YSF_SetPlayerWorldBounds },
+	{ "DestroyObject",					Natives::YSF_DestroyObject },
+	{ "DestroyPlayerObject",			Natives::YSF_DestroyPlayerObject },
+	{ "TogglePlayerControllable",		Natives::YSF_TogglePlayerControllable},
+	{ "ChangeVehicleColor",				Natives::YSF_ChangeVehicleColor},
+	{ "DestroyVehicle",					Natives::YSF_DestroyVehicle},
+
+	{ "GangZoneCreate",					Natives::YSF_GangZoneCreate },
+	{ "GangZoneDestroy",				Natives::YSF_GangZoneDestroy },
+	{ "GangZoneShowForPlayer",			Natives::YSF_GangZoneShowForPlayer },
+	{ "GangZoneHideForPlayer",			Natives::YSF_GangZoneHideForPlayer },
+	{ "GangZoneShowForAll",				Natives::YSF_GangZoneShowForAll },
+	{ "GangZoneHideForAll",				Natives::YSF_GangZoneHideForAll },
+								
+	{ "GangZoneFlashForPlayer",			Natives::YSF_GangZoneFlashForPlayer },
+	{ "GangZoneFlashForAll",			Natives::YSF_GangZoneFlashForAll },
+	{ "GangZoneStopFlashForPlayer",		Natives::YSF_GangZoneStopFlashForPlayer },
+	{ "GangZoneStopFlashForAll",		Natives::YSF_GangZoneStopFlashForAll },
+#ifdef NEW_PICKUP_SYSTEM
+	{ "CreatePickup",					Natives::CreatePickup },
+	{ "AddStaticPickup",				Natives::CreatePickup },
+	{ "DestroyPickup",					Natives::DestroyPickup },
+#endif
+	{ "GetWeaponName",					Natives::FIXED_GetWeaponName },
+	{ "IsPlayerConnectedEx",			Natives::FIXED_IsPlayerConnectedEx },
+
+	{ "SetPlayerTeam",					Natives::YSF_SetPlayerTeam },
+	{ "SetPlayerSkin",					Natives::YSF_SetPlayerSkin },
+	{ "SetPlayerName",					Natives::YSF_SetPlayerName },
+	{ "SetPlayerFightingStyle",			Natives::YSF_SetPlayerFightingStyle },
+	{ 0,								0 }
+};
+
+int InitScripting(AMX *amx)
+{
+	return amx_Register(amx, YSINatives, -1);
 }
\ No newline at end of file
diff --git a/src/Scripting.h b/src/src/Scripting.h
similarity index 96%
rename from src/Scripting.h
rename to src/src/Scripting.h
index a5d238f..59bd024 100644
--- a/src/Scripting.h
+++ b/src/src/Scripting.h
@@ -56,6 +56,8 @@ namespace Natives
 	static cell AMX_NATIVE_CALL GetModeRestartTime(AMX *amx, cell *params);
 	static cell AMX_NATIVE_CALL SetMaxPlayers(AMX *amx, cell *params); // R8
 	static cell AMX_NATIVE_CALL SetMaxNPCs(AMX *amx, cell *params); // R8
+	static cell AMX_NATIVE_CALL GetSyncBounds(AMX *amx, cell *params);
+	static cell AMX_NATIVE_CALL SetSyncBounds(AMX *amx, cell *params);
 
 	static cell AMX_NATIVE_CALL SetPlayerAdmin(AMX *amx, cell *params);
 	static cell AMX_NATIVE_CALL LoadFilterScript(AMX *amx, cell *params);
@@ -114,6 +116,7 @@ namespace Natives
 	static cell AMX_NATIVE_CALL AddPlayerForPlayer(AMX *amx, cell *params); // R17
 	static cell AMX_NATIVE_CALL RemovePlayerForPlayer(AMX *amx, cell *params); // R17
 	static cell AMX_NATIVE_CALL SetPlayerChatBubbleForPlayer(AMX *amx, cell *params); // R10
+	static cell AMX_NATIVE_CALL ResetPlayerMarkerForPlayer(AMX *amx, cell *params);
 	static cell AMX_NATIVE_CALL SetPlayerVersion(AMX *amx, cell *params); // R9
 	static cell AMX_NATIVE_CALL IsPlayerSpawned(AMX *amx, cell *params); // R9
 	static cell AMX_NATIVE_CALL IsPlayerControllable(AMX *amx, cell *params); // R11
@@ -197,6 +200,11 @@ namespace Natives
 	static cell AMX_NATIVE_CALL SetVehicleSpawnInfo(AMX *amx, cell *params); // R12
 	static cell AMX_NATIVE_CALL GetVehicleModelCount(AMX *amx, cell *params); // R17
 	static cell AMX_NATIVE_CALL GetVehicleModelsUsed(AMX *amx, cell *params); // R17
+	static cell AMX_NATIVE_CALL SetVehicleParamsSirenState(AMX *amx, cell *params); // R17-3
+	static cell AMX_NATIVE_CALL ToggleVehicleSirenEnabled(AMX *amx, cell *params); // R17-3
+	static cell AMX_NATIVE_CALL IsVehicleSirenEnabled(AMX *amx, cell *params); // R17-3
+	static cell AMX_NATIVE_CALL GetVehicleMatrix(AMX *amx, cell *params); // R17-3
+	static cell AMX_NATIVE_CALL SetVehicleMatrix(AMX *amx, cell *params); // R17-3
 
 	static cell AMX_NATIVE_CALL IsValidGangZone(AMX *amx, cell *params);
 	static cell AMX_NATIVE_CALL IsPlayerInGangZone(AMX *amx, cell *params);
@@ -325,6 +333,9 @@ namespace Natives
 	static cell AMX_NATIVE_CALL YSF_IsExtendedNetStatsEnabled(AMX *amx, cell *params);
 	static cell AMX_NATIVE_CALL YSF_SetAFKAccuracy(AMX *amx, cell *params);
 	static cell AMX_NATIVE_CALL YSF_GetAFKAccuracy(AMX *amx, cell *params);
+	static cell AMX_NATIVE_CALL YSF_ToggleNPCTracking(AMX *amx, cell *params);
+	static cell AMX_NATIVE_CALL YSF_IsNPCTrackingEnabled(AMX *amx, cell *params);
+	static cell AMX_NATIVE_CALL GetNPCCommandLine(AMX *amx, cell *params);
 	
 	static cell AMX_NATIVE_CALL AttachPlayerObjectToObject(AMX *amx, cell *params);
 
diff --git a/src/Structs.h b/src/src/Structs.h
similarity index 93%
rename from src/Structs.h
rename to src/src/Structs.h
index e6517fc..95e157c 100644
--- a/src/Structs.h
+++ b/src/src/Structs.h
@@ -1,1128 +1,1150 @@
-/*  
- *  Version: MPL 1.1
- *  
- *  The contents of this file are subject to the Mozilla Public License Version 
- *  1.1 (the "License"); you may not use this file except in compliance with 
- *  the License. You may obtain a copy of the License at 
- *  http://www.mozilla.org/MPL/
- *  
- *  Software distributed under the License is distributed on an "AS IS" basis,
- *  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- *  for the specific language governing rights and limitations under the
- *  License.
- *  
- *  The Original Code is the YSI 2.0 SA:MP plugin.
- *  
- *  The Initial Developer of the Original Code is Alex "Y_Less" Cole.
- *  Portions created by the Initial Developer are Copyright (C) 2008
- *  the Initial Developer. All Rights Reserved.
- *  
- *  Contributor(s):
- *  
- *  Peter Beverloo
- *  Marcus Bauer
- *  MaVe;
- *  Sammy91
- *  Incognito
- *  
- *  Special Thanks to:
- *  
- *  SA:MP Team past, present and future
- */
-
-#ifndef YSF_STRUCTS_H
-#define YSF_STRUCTS_H
-
-#include "CServer.h"
-#include "CVector.h"
-#include "CGangZonePool.h"
-#include "CPickupPool.h"
-#include <map>
-
-#include <raknet/BitStream.h>
-#include <sampgdk/sampgdk.h>
-
-class CGangZonePool;
-
-/* -------------------------------------------------------- */
-
-// Defines
-#define	MAX_ATTACHED_OBJECTS		10
-#define	MAX_FILTER_SCRIPTS			16
-
-#define MAX_PVARS					800
-#define MAX_PVAR_NAME				40
-
-#define MAX_MENU_TEXT_SIZE			32
-#define MAX_ITEMS					12
-#define MAX_COLUMNS					2
-
-/* -------------------------------------------------------- */
-
-// Server rules special
-enum CON_VARTYPE { CON_VARTYPE_FLOAT, CON_VARTYPE_INT, CON_VARTYPE_BOOL, CON_VARTYPE_STRING };
-
-#define CON_VARFLAG_DEBUG		1
-#define CON_VARFLAG_READONLY	2
-#define CON_VARFLAG_RULE		4	// Gets sent with a RULES query responce
-
-typedef void(*VARCHANGEFUNC)();
-
-/* -------------------------------------------------------- */
-typedef struct _MATRIX4X4 
-{
-	CVector right;
-	DWORD  flags;
-	CVector up;
-	float  pad_u;
-	CVector at;
-	float  pad_a;
-	CVector pos;
-	float  pad_p;
-} MATRIX4X4, *PMATRIX4X4;
-
-struct ConsoleVariable_s
-{
-	CON_VARTYPE		VarType;
-	DWORD			VarFlags;
-	void*			VarPtr;
-	VARCHANGEFUNC	VarChangeFunc;
-};
-
-struct C3DText  // size 0x21
-{
-	char*			szText;                                     // + 0x00
-    DWORD			dwColor;                         // + 0x04
-	CVector			vecPos;
-	float			fDrawDistance;                     // + 0x14
-    bool			bLineOfSight;            // + 0x18
-    int				iWorld;                  // + 0x19
-    WORD			attachedToPlayerID;    // + 0x1D
-	WORD			attachedToVehicleID;   // + 0x1F
-};
-
-/* -------------------------------------------------------- */
-// CPlayer
-/* -------------------------------------------------------- */
-
-// Big thanks to OrMisicL
-struct CAimSyncData
-{
-	BYTE			byteCameraMode;			// 0
-	CVector			vecFront;				// 1 - 13
-	CVector			vecPosition;			// 13 - 25
-	float			fZAim;					// 25 - 29
-	BYTE			byteCameraZoom : 6;		// 29
-	BYTE			byteWeaponState  : 2;	// 29
-	BYTE			unk;					// 30 - 31
-	WORD			wCameraObject;			// 31 - 33
-	WORD			wCameraVehicle;			// 33 - 35
-	WORD			wCameraPlayer;			// 35 - 37
-	WORD			wCameraActor;			// 37 - 39
-	// Size = 39
-};
-
-struct CVehicleSyncData
-{
-	WORD			wVehicleId;				// 0x001F - 0x0021
-	WORD			wUDAnalog;				// 0x0021 - 0x0023
-	WORD			wLRAnalog;				// 0x0023 - 0x0025
-	WORD			wKeys;					// 0x0025 - 0x0027
-	float			fQuaternion[4];			// 0x002B - 0x0037
-	CVector			vecPosition;			// 0x0037 - 0x0043
-	CVector			vecVelocity;			// 0x0043 - 0x004F
-	float			fHealth;				// 0x004F - 0x0053
-	BYTE			bytePlayerHealth;		// 0x0053 - 0x0054
-	BYTE			bytePlayerArmour;		// 0x0054 - 0x0055
-	BYTE			bytePlayerWeapon : 6;	// 0x0055 - 0x0056
-	BYTE			unk_2 : 2;				// 0x0055 - 0x0056
-	BYTE			byteSirenState;			// 0x0056 - 0x0057
-	BYTE			byteGearState;			// 0x0057 -	0x0058
-	WORD			wTrailerID;				// 0x0058 - 0x005A
-    union									// 
-    {
-            WORD			wHydraReactorAngle[2];                       
-            float           fTrainSpeed;
-    };
-	// Size = 63
-};
-
-struct CPassengerSyncData
-{
-	WORD			wVehicleId;				// 0x005E - 0x0060
-	BYTE			byteSeatFlags : 7;
-	BYTE			byteDriveBy : 1;
-	BYTE			bytePlayerWeapon;		// 0x0061 - 0x0062
-	BYTE			bytePlayerHealth;		// 0x0062 - 0x0063
-	BYTE			bytePlayerArmour;		// 0x0063 - 0x0064
-	WORD			wUDAnalog;				// 0x0064 - 0x0066
-	WORD			wLRAnalog;				// 0x0066 - 0x0068
-	WORD			wKeys;					// 0x0068 - 0x006A
-	CVector			vecPosition;			// 0x006A - 0x0076
-	// Size = 24
-};
-
-struct CSyncData
-{
-	WORD			wUDAnalog;				// 0x0076 - 0x0078
-	WORD			wLRAnalog;				// 0x0078 - 0x007A
-	WORD			wKeys;					// 0x007A - 0x007C
-	CVector			vecPosition;			// 0x007C - 0x0088
-	float			fQuaternion[4];			// 0x0088 - 0x008C
-	BYTE			byteHealth;				// 0x0098 - 0x0099
-	BYTE			byteArmour;				// 0x0099 - 0x009A
-	BYTE			byteWeapon : 6;				// 0x009A - 0x009B
-	BYTE			_unk_ : 2;
-	BYTE			byteSpecialAction;		// 0x009B - 0x009C
-	CVector			vecVelocity;			// 0x009C - 0x00A8
-	CVector			vecSurfing;				// 0x00A8 - 0x00B4
-	WORD			wSurfingInfo;			// 0x00B4 - 0x00B6
-	union 
-	{
-		DWORD		dwAnimationData;		// 0x00B6 - 0x00BA
-		struct 
-		{
-			WORD	wAnimIndex;
-			WORD	wAnimFlags;
-		};
-	};
-	// Size = 68
-};
-
-struct CUnoccupiedSyncData // size 0x43
-{
-	WORD			wVehicleID;				// + 0x0000
-	BYTE			bytePassengerSlot;			// + 0x0002
-	CVector			vecRool;				// + 0x0003
-	CVector			vecDirection;			// + 0x000F
-	CVector			vecPosition;			// + 0x001B
-	CVector			vecVelocity;			// + 0x0027
-	CVector			vecTurnVelocity;		// + 0x0033
-	float			fHealth;					// + 0x003F
-};
-
-struct CSpectatingSyncData		// size 0x12
-{
-	WORD			wLeftRightKeysOnSpectating;				// + 0x0000
-	WORD			wUpDownKeysOnSpectating;				// + 0x0002
-	WORD			wKeysOnSpectating;						// + 0x0004
-	CVector			vecPosition;							// + 0x0006
-};
-
-struct CTrailerSyncData // size 0x36 = 54
-{
-	WORD			wTrailerID;				// + 0x0000
-	CVector			vecRoll;				// + 0x0002
-	CVector			vecDirection;			// + 0x000E
-	CVector			vecPosition;			// + 0x001A
-	CVector			vecVelocity;			// + 0x0026
-	DWORD			pad;
-};
-
-typedef struct CTextdraw
-{
-	union
-	{
-		BYTE byteFlags;			// 25
-		struct
-		{
-			BYTE byteBox : 1;
-			BYTE byteLeft : 1; 
-			BYTE byteRight : 1;
-			BYTE byteCenter : 1;
-			BYTE byteProportional : 1;
-			BYTE bytePadding : 3;
-		};
-	};
-	float			fLetterWidth;			// 1
-	float			fLetterHeight;		// 5
-	DWORD			dwLetterColor;		// 9
-	float			fLineWidth;			// 13
-	float			fLineHeight;			// 17
-	DWORD			dwBoxColor;			// 21
-	BYTE			byteShadow; // 26
-	BYTE			byteOutline; // 27
-	DWORD			dwBackgroundColor; // 31
-	BYTE			byteStyle; // 32
-	BYTE			byteSelectable; // 32
-	float			fX; // 33
-	float			fY; // 37
-	WORD			dwModelIndex; // 41 - 43
-	CVector			vecRot;  // 43 - 55
-	float			fZoom; // 55 - 59
-	WORD			color1; // 59 - 61
-	WORD			color2; // 61 - 63
-} _CTextdraw;
-
-struct CPlayerTextDraw
-{
-	BOOL			bSlotState[MAX_PLAYER_TEXT_DRAWS];
-	CTextdraw	    *TextDraw[MAX_PLAYER_TEXT_DRAWS];
-	char			*szFontText[MAX_PLAYER_TEXT_DRAWS];
-	bool			bHasText[MAX_PLAYER_TEXT_DRAWS];
-};
-
-struct CPlayerText3DLabels // size 0x9802
-{
-	C3DText			TextLabels[ MAX_3DTEXT_PLAYER ];	// + 0x0000
-	BOOL			isCreated[ MAX_3DTEXT_PLAYER ];	// + 0x8400
-	BYTE			unknown9800[MAX_3DTEXT_PLAYER];				// + 0x9400
-	WORD			wOwnerID;
-};
-
-struct CAttachedObject // sizeof = 52 - 0x34
-{
-    int				iModelID;
-    int				iBoneiD;
-    CVector         vecPos;
-    CVector         vecRot;
-    CVector         vecScale;
-	DWORD			dwMaterialColor1;
-	DWORD			dwMaterialColor2;
-};
-
-struct CPlayerSpawnInfo // size  46
-{
-	BYTE			byteTeam;				// 0 - 1
-	int				iSkin;					// 1 - 5
-	BYTE			unk;					// 5 - 6
-	CVector			vecPos;				// 6 - 18
-	float			fRotation;			// 18 - 22
-	int				iSpawnWeapons[3];		// 22 - 34
-	int				iSpawnWeaponsAmmo[3];	// 34 - 46
-};
-
-struct CBulletSyncData // sizeof = 40
-{
-	BYTE			byteHitType;
-	WORD			wHitID;
-	CVector			vecHitOrigin;
-	CVector			vecHitTarget;
-	CVector			vecCenterOfHit;
-	BYTE			byteWeaponID;
-}; 
-
-struct CPVar
-{
-    char			szVarName[MAX_PVAR_NAME + 1];
-    BOOL			bIsReadOnly;
-    int				iVarType;
-    int				iValue;
-    float			fValue;
-    char*			szValue;
-};
-
-struct CPlayerVar
-{
-    CPVar			Vars[MAX_PVARS];
-	BOOL			bIsPVarActive[MAX_PVARS];
-    int				iUpperIndex;
-};
-
-struct CPlayer
-{
-	CAimSyncData			aimSyncData;			// 0 - 39
-	CVehicleSyncData		vehicleSyncData;		// 39 -
-	CPassengerSyncData		passengerSyncData;		//
-	CSyncData				syncData;				// 126 - 194
-	CUnoccupiedSyncData		unoccupiedSyncData;		// 194 - 261
-	CSpectatingSyncData		spectatingSyncData;		// 261 - 279
-	CTrailerSyncData		trailerSyncData;		// 279 - 333
-	DWORD					dwPlayerSyncUnused;		// 333 - 337
-	DWORD					dwVehicleSyncUnused;	// 337 - 341
-	BYTE					byteStreamedIn[MAX_PLAYERS];				// 341 - 1341
-	BYTE					byteVehicleStreamedIn[MAX_VEHICLES];		// 1341 - 3341
-	BYTE					byteSomethingUnused[1000];					// 3341 - 4341
-	BYTE					byte3DTextLabelStreamedIn[1024];			// 4341  - 5365
-	BYTE					bPickupStreamedIn[MAX_PICKUPS];				// 5365 - 9461
-	BYTE					byteActorStreamedIn[MAX_PLAYERS];			// 9461 - 10461
-	DWORD					dwStreamedInPlayers;						// 10461 - 10465
-	DWORD					dwStreamedInVehicles;						// 10465 - 10469
-	DWORD					dwStreamedInSomethingUnused;				// 10469 - 10473
-	DWORD					dwStreamedIn3DTextLabels;					// 10479 - 10477
-	DWORD					dwStreamedInPickups;						// 10477 - 10481
-	DWORD					dwStreamedInActors;							// 10481 - 10485
-	DWORD					bHasSetVehiclePos;	// 10485 - 10489
-	DWORD					dwSetVehiclePosTick;// 10489 - 10493
-	CVector					vecVehicleNewPos;	// 10493 - 10505
-	BOOL					bCameraTarget;		// 10505
-	DWORD					bHasSpawnInfo;		// 10509
-	BOOL					bUpdateKeys;		// 10513
-	CVector					vecPosition;		// 10517
-	float					fHealth;			// 10529 - 10533
-	float					fArmour;			// 10533 - 10537
-	float					fQuaternion[4];		// 10537 - 10553
-	float					fAngle;				// 10553 - 10557
-	CVector					vecVelocity;		// 10557 - 10569
-	WORD					wUDAnalog;			// 10569
-	WORD					wLRAnalog;			// 10571
-	DWORD					dwKeys;				// 10573 - 10577
-	DWORD					dwOldKeys;			// 10577 - 10581
-	BOOL					bEditObject;		// 10581 - 10585
-	BOOL					bEditAttachedObject;// 10585 - 10589
-	WORD					wDialogID;			// 10589 - 10591
-	CPlayerTextDraw*		pTextdraw;			// 10591 - 10595
-	CPlayerText3DLabels*	p3DText;			// 10595 - 10599
-	WORD					wPlayerId;			// 10599 - 10601
-	int						iUpdateState;		// 10601 - 10605
-	//DWORD					dwLastSyncTick;		// 10605 - 10609
-	CAttachedObject			attachedObject[MAX_ATTACHED_OBJECTS]; // 10605 - 11125
-	BOOL					attachedObjectSlot[MAX_ATTACHED_OBJECTS]; // 11125 - 11165
-	BOOL					bHasAimSync;		// 11165 - 11169
-	BOOL					bHasTrailerSync;	// 11169 - 11173
-	BOOL					bHasUnoccupiedSync;	// 11173 - 11177
-	BYTE					byteState;			// 11177 - 11178
-	CVector					vecCPPos;			// 11178 - 11190
-	float					fCPSize;			// 11190 - 11194
-	BOOL					bIsInCP;			// 11194 - 11198
-	CVector					vecRaceCPPos;		// 11198 - 11210
-	CVector					vecRaceCPNextPos;	// 11210 - 11222 
-	BYTE					byteRaceCPType;		// 11222 - 11223 // TODO -> replace
-	float					fRaceCPSize;		// 11223 - 11227
-	BOOL					bIsInRaceCP;		// 11227 - 11231
-	BOOL					bIsInModShop;		// 11231 - 11235
-	WORD					wSkillLevel[11];	// 11235 - 11257
-	int						iLastMarkerUpdate;	// 11257 - 11261
-	CPlayerSpawnInfo		spawn;				// 11261 - 11307
-	BOOL					bReadyToSpawn;		// 11307 - 11311
-	BYTE					byteWantedLevel;	// 11311 - 11312
-	BYTE					byteFightingStyle;  // 11312 - 11313
-	BYTE					byteSeatId;			// 11313 - 11314
-	WORD					wVehicleId;			// 11314 - 11316
-	DWORD					dwNickNameColor;	// 11316 - 11320
-	BOOL					bShowCheckpoint;	// 11320 - 11324
-	BOOL					bShowRaceCheckpoint;// 11324 - 11328
-	int						iInteriorId;		// 11328 - 11332
-	WORD					wWeaponAmmo[12];	// 11332 - 11356
-	PAD(pad10, 28);								// 11356 - 11384
-	BYTE					byteWeaponId[12];	// 11384 - 11396
-	BYTE					byteWeaponID_unknown;// 11396 - 11397
-	BYTE					byteCurrentWeapon;	// 11397 - 11398
-	WORD					wTargetId;			// 11398 - 11400
-	WORD					wTargetActorId;		// 11400 - 11402
-	DWORD					dwLastShotTick;		// 11402 - 11406
-	BYTE					dwLastShotWeapon;	// 11406 - 11407
-	CBulletSyncData			bulletSyncData;		// 11407 - 11447	
-	BYTE					m_byteTime;			// 11447 - 11448
-	float					m_fGameTime;		// 11448 - 11452
-	BYTE					byteSpectateType;	// 11452 - 11453
-	DWORD					wSpectateID;		// 11453 - 11457
-	DWORD					dwLastStreaming;	// 11457 - 11461
-	DWORD					dwNPCRecordingType;	// 11461 - 11465
-	FILE					*pRecordingFile;	// 11465 - 11469
-	DWORD					dwFirstNPCWritingTime; // 11469 - 11473 
-	PAD(unused, 9);								// 11473 - 11482
-	CPlayerVar*				pPlayerVars;		// 11482 - 11486
-	// Size = 9963
-};
-
-struct CPlayerPool // sizeof = 99520
-{
-	DWORD			dwVirtualWorld[MAX_PLAYERS];			// 0 - 4000
-	DWORD			dwPlayersCount;							// 4000 - 4004
-	DWORD			dwlastMarkerUpdate;						// 4004 - 4008
-	float			fUpdatePlayerGameTimers;				// 4008 - 4012
-	DWORD			dwScore[MAX_PLAYERS];					// 4012 - 8012
-	DWORD			dwMoney[MAX_PLAYERS];					// 8012 - 12012
-	DWORD			dwDrunkLevel[MAX_PLAYERS];				// 12012 - 16012
-	DWORD			dwLastScoreUpdate[MAX_PLAYERS];			// 16012 - 20012
-	char			szSerial[MAX_PLAYERS][101];				// 20012 - 121012				
-	char			szVersion[MAX_PLAYERS][29];				// 121012 - 150012
-	BOOL			bIsPlayerConnectedEx[MAX_PLAYERS];		// 150012 - 154012
-	CPlayer			*pPlayer[MAX_PLAYERS];					// 154012 - 158012
-	char			szName[MAX_PLAYERS][25];				// 158012 - 183012
-	BOOL			bIsAnAdmin[MAX_PLAYERS];				// 183012 - 187012
-	BOOL			bIsNPC[MAX_PLAYERS];					// 187012 - 191012
-	PAD(pad0, 8000);											// 191012 - 199012
-	DWORD			dwConnectedPlayers;						// 199012 - 199016
-	DWORD			dwPlayerPoolSize;						// 199016 - 199020
-};
-
-/* -------------------------------------------------------- */
-// CVehicle
-/* -------------------------------------------------------- */
-
-struct CVehicleSpawn // size 36
-{
-	int				iModelID;
-    CVector			vecPos;   
-    float			fRot;
-    int				iColor1;  
-    int				iColor2;  
-    int				iRespawnTime;
-    int				iInterior;
-};
-
-struct CVehicleModInfo // sizeof = 26
-{
-	BYTE			byteModSlots[14];                // + 0x0000
-    BYTE			bytePaintJob;                    // + 0x000E
-    int				iColor1;                             // + 0x000F
-    int				iColor2;                             // + 0x0010
-};
-
-struct CVehicleParams // sizeof = 16
-{
-	BYTE engine;
-	BYTE lights;
-	BYTE alarm;
-	BYTE doors;
-	BYTE bonnet;
-	BYTE boot;
-	BYTE objective; // 6
-	BYTE siren; // 7
-	BYTE door_driver; // 8
-	BYTE door_passenger;
-	BYTE door_backleft;
-	BYTE door_backright; // 11
-	BYTE window_driver; // 12
-	BYTE window_passenger;
-	BYTE window_backleft;
-	BYTE window_backright; // 15 - 16
-};
-
-struct CVehicle
-{
-	CVector			vecPosition;		// 0 - 12
-	MATRIX4X4		vehMatrix;			// 12 - 76
-	CVector			vecVelocity;		// 76 - 88
-	CVector			vecTurnSpeed;		// 88 - 100
-	WORD			wVehicleID;			// 100 - 102
-	WORD			wTrailerID;			// 102 - 104
-	WORD			wCabID;				// 104 - 106
-	WORD			wLastDriverID;		// 106 - 108
-	WORD			vehPassengers[7];	// 108 - 122
-	DWORD			vehActive;			// 122 - 126
-	DWORD			vehWasted;			// 126 - 130	
-	CVehicleSpawn	customSpawn;		// 130 - 166
-	float			fHealth;			// 166 - 170
-	DWORD			vehDoorStatus;		// 170 - 174
-	DWORD			vehPanelStatus;		// 174 - 178
-	BYTE			vehLightStatus;		// 178 - 179
-	BYTE			vehTireStatus;		// 179 - 180
-	bool			bDead;				// 180 - 181
-	WORD			wKillerID;			// 181 - 183
-	CVehicleModInfo vehModInfo;			// 183 - 206
-	char			szNumberplate[32 + 1]; // 206 - 239
-	CVehicleParams	vehParamEx;			// 239 - 255
-    BYTE			bDeathNotification; // 255 - 256
-    BYTE			bOccupied;			// 256 - 257
-    DWORD			vehOccupiedTick;	// 257 - 261
-    DWORD			vehRespawnTick;		// 261 -265
-};
-
-struct CVehiclePool
-{
-	BYTE			byteVehicleModelsUsed[212];			// 0 - 212
-	int				iVirtualWorld[MAX_VEHICLES];		// 212 - 8212
-	BOOL			bVehicleSlotState[MAX_VEHICLES];	// 8212 - 16212
-	CVehicle		*pVehicle[MAX_VEHICLES];			// 16212 - 24212
-	DWORD			dwVehiclePoolSize;					// 24212
-};
-
-/* -------------------------------------------------------- */
-// CPickup
-/* -------------------------------------------------------- */
-
-struct tPickup // size 0x14
-{
-	int				iModel;
-	int				iType;
-	CVector			vecPos;
-};
-
-struct CPickupPool
-{
-	tPickup			Pickup[MAX_PICKUPS];			// + 0x0000
-	BOOL			bActive[MAX_PICKUPS];			// + 0xA000
-	int				iWorld[MAX_PICKUPS];		// + 0xC000
-	int				iPickupCount;
-};
-
-/* -------------------------------------------------------- */
-// CObject
-/* -------------------------------------------------------- */
-
-struct CObjectMaterial // sizeof = 212
-{
-	BYTE			byteUsed;				// 197 - 198
-	BYTE			byteSlot;				// 198 - 199
-	WORD			wModelID;				// 199 - 201
-	DWORD			dwMaterialColor;		// 201 - 205
-	char			szMaterialTXD[64 + 1];	// 205 - 270
-	char			szMaterialTexture[64 + 1]; // 270 - 335
-	BYTE			byteMaterialSize;		// 335 - 336
-	char			szFont[64 + 1];			// 336 - 401
-	BYTE			byteFontSize;			// 401 - 402
-	BYTE			byteBold;				// 402 - 403
-	DWORD			dwFontColor;			// 403 - 407
-	DWORD			dwBackgroundColor;		// 407 - 411
-	BYTE			byteAlignment;			// 411 - 412
-};
-
-struct CObject // sizeof = 3700
-{
-	WORD			wObjectID;			// 0 - 2
-	int				iModel;				// 2 - 6
-	BOOL			bActive;			// 6 - 10
-	MATRIX4X4		matWorld;			// 10 - 74 - pos - Object position
-	CVector			vecRot; 			// 74 - 86 - Object rotation
-	MATRIX4X4		matTarget;			// 86 - 150	- 
-	BYTE			bIsMoving;			// 150 - 151
-	BYTE			bNoCameraCol;		// 151 - 152
-	float			fMoveSpeed;			// 152 - 156
-	DWORD			unk_4;				// 156 -160
-	float			fDrawDistance;		// 160 - 164
-	WORD			wAttachedVehicleID;	// 164 - 166
-	WORD			wAttachedObjectID;	// 166 - 168
-	CVector			vecAttachedOffset;	// 168 - 180
-	CVector			vecAttachedRotation;// 180 - 192
-	BYTE			byteSyncRot;		// 192 - 193
-	DWORD			dwMaterialCount;	// 193 - 197
-	CObjectMaterial	Material[16];		// 197 - 3637
-	char			*szMaterialText[16];// 3637 - 3653
-};
-
-struct CObjectPool
-{
-	BOOL			bPlayerObjectSlotState[MAX_PLAYERS][MAX_OBJECTS];	// 0 
-	BOOL			bPlayersObject[MAX_OBJECTS];							// 4.000.000
-	CObject			*pPlayerObjects[MAX_PLAYERS][MAX_OBJECTS];		// 4.004.000
-	BOOL			bObjectSlotState[MAX_OBJECTS];						// 8.004.000
-	CObject			*pObjects[MAX_OBJECTS];							// 8.008.000
-};
-
-/* -------------------------------------------------------- */
-// CMenu
-/* -------------------------------------------------------- */
-
-struct MenuInteraction
-{
-	BOOL			Menu;
-	BOOL			Row[MAX_ITEMS];
-	char			unknown[12];
-};
-	
-struct CMenu	// size 0xB84
-{
-	BYTE			menuID;														// + 0x0000
-	char			szTitle[ MAX_MENU_TEXT_SIZE ];								// + 0x0001
-	char			szItems[ MAX_ITEMS ][ MAX_COLUMNS ][ MAX_MENU_TEXT_SIZE ];	// + 0x0021
-	char			szHeaders[MAX_COLUMNS][MAX_MENU_TEXT_SIZE];					// + 0x0321
-	BOOL			bIsInitiedForPlayer[MAX_PLAYERS];							// + 0x0361
-	MenuInteraction interaction;												// + 0x0B31
-	float			fPosX;														// + 0x0B71
-	float			fPosY;														// + 0x0B75
-	float			fColumn1Width;												// + 0x0B79
-	float			fColumn2Width;												// + 0x0B7D
-	BYTE			byteColumnsNumber;											// + 0x0B81
-	BYTE			byteItemsCount[ MAX_COLUMNS ];								// + 0x0B82
-};
-
-struct CMenuPool
-{
-	CMenu*			pMenu[ MAX_MENUS ];			//	+ 0x0000
-	BOOL			bIsCreated[ MAX_MENUS ];		//	+ 0x0200
-	BOOL			bPlayerMenu[MAX_PLAYERS];	//	+ 0x0400
-};
-
-/* -------------------------------------------------------- */
-// CTextDraw
-/* -------------------------------------------------------- */
-struct CTextDrawPool
-{
-	BOOL			bSlotState[MAX_TEXT_DRAWS];
-	CTextdraw*		TextDraw[MAX_TEXT_DRAWS];
-	char*			szFontText[MAX_TEXT_DRAWS];
-	bool			bHasText[MAX_TEXT_DRAWS][MAX_PLAYERS];
-};
-
-/* -------------------------------------------------------- */
-// C3DText
-/* -------------------------------------------------------- */
-
-class C3DTextPool
-{
-public:
-	BOOL			bIsCreated[MAX_3DTEXT_GLOBAL]; // 0 - 4096 <- OK
-	C3DText			TextLabels[MAX_3DTEXT_GLOBAL];
-};
-
-/* -------------------------------------------------------- */
-// CGangZone
-/* -------------------------------------------------------- */
-
-struct CSAMPGangZonePool
-{
-	float			fGangZone[MAX_GANG_ZONES][4];
-	BOOL			bSlotState[MAX_GANG_ZONES];
-};
-
-/* -------------------------------------------------------- */
-// CActor
-/* -------------------------------------------------------- */
-
-struct CActorAnim // 140
-{
-	char			szAnimLib[64]; // 0 - 64
-	char			szAnimName[64]; // 64 - 128
-	float			fDelta;		// 128 - 132
-	BYTE			byteLoop;		// 132 - 133
-	BYTE			byteLockX;			// 133 - 134
-	BYTE			byteLockY;			// 134 - 135
-	BYTE			byteFreeze;		// 135 - 136
-	int				iTime;				//  136 - 140
-};
-
-struct CActor
-{
-	BYTE			pad0;				// 0
-	int				iSkinID;			// 1 - 5
-	CVector			vecSpawnPos;	// 5 - 17
-	float			fSpawnAngle;		// 17 - 21
-	DWORD			pad4;				// 21 - 25
-	DWORD			pad5;				// 25 - 29
-	BYTE			byteLoopAnim;		// 29 - 30
-	CActorAnim		anim;
-	WORD			wTime;				// 170 - 171
-	float			fHealth;			// 172 - 176
-	DWORD			pad;				// 176 - 180
-	float			fAngle;			// 180 - 184
-	CVector			vecPos;			// 184 - 196
-	DWORD			pad8[3];			// 196 - 208
-	BYTE			byteInvulnerable;	// 208 - 209
-	WORD			wActorID;			// 209 - 211
-};
-
-struct CActorPool
-{
-	int				iActorVirtualWorld[MAX_ACTORS];
-	BOOL			bValidActor[MAX_ACTORS];
-	CActor*			pActor[MAX_ACTORS];
-	DWORD			dwActorPoolSize;
-};
-
-struct CGameMode
-{
-	AMX				amx;
-	bool			bInitialised;
-	bool			bSleeping;
-	float			fSleepTime;
-};
-
-struct CFilterScripts
-{
-	AMX*			pFilterScripts[MAX_FILTER_SCRIPTS];
-	char			szFilterScriptName[MAX_FILTER_SCRIPTS][255];
-	int				iFilterScriptCount;
-};
-
-struct ScriptTimer_s // sizeof = 0x11B (283)
-{
-	char szScriptFunc[255];
-	int iTotalTime;
-	int iRemainingTime;
-	BOOL bRepeating;
-	BOOL bKilled;
-	AMX* pAMX;
-	int iParamCount;
-	void* cellParams;
-};
-
-typedef std::map<DWORD, ScriptTimer_s*> DwordTimerMap;
-
-class CScriptTimers
-{
-public:
-	DwordTimerMap			Timers;
-	DWORD					dwTimerCount;
-};
-
-struct CNetGame
-{
-	CGameMode				*pGameModePool;			// 0
-	CFilterScripts			*pFilterScriptPool;		// 4
-	CPlayerPool				*pPlayerPool;			// 8
-	CVehiclePool			*pVehiclePool;			// 12
-	CPickupPool				*pPickupPool;			// 16
-	CObjectPool				*pObjectPool;			// 20
-	CMenuPool				*pMenuPool;				// 24
-	CTextDrawPool			*pTextDrawPool;			// 28
-	C3DTextPool				*p3DTextPool;			// 32
-	CGangZonePool			*pGangZonePool;			// 36 
-	CActorPool				*pActorPool;			// 40 
-	int						iCurrentGameModeIndex;	// 44
-	int						iCurrentGameModeRepeat;	// 48
-	BOOL					bFirstGameModeLoaded;	// 52
-	BOOL					unkasdasd;				// 56
-	CScriptTimers			*pScriptTimers;			// 60
-	RakServer				*pRak;					// 64
-	DWORD					dwSomethingTick;
-	DWORD					dwUnk;
-	DWORD					dwUnk1;
-	BOOL					bLanMode;				// 
-	BOOL					bShowPlayerMarkers;		// 84
-	BYTE					byteShowNameTags;		// 
-	BYTE					bTirePopping;			// 
-	BYTE					byteAllowWeapons;		// 
-	BYTE					byteStuntBonus;			// 91 - 92
-	BYTE					byteDefaultCameraCollision; // 92 - 93
-	BYTE					byteWeather;			// 93 - 94
-	int						iGameState;				// 94 - 98
-	float					fGravity;				// 98 - 102
-	int						iDeathDropMoney;		// 102 - 106
-	BYTE					unklofasz;				// 106 - 107
-	BYTE					byteMode;				// 107 - 108
-	BYTE					bLimitGlobalChatRadius;	// 108 - 109
-	BYTE					bUseCJWalk;				// 109 - 110
-	float					fGlobalChatRadius;		// 110 - 114
-	float					fNameTagDrawDistance;	// 114 - 118
-	BYTE					byteDisableEnterExits;	// 118 - 119
-	BYTE					byteNameTagLOS;			// 119 - 120
-	BYTE					bManulVehicleEngineAndLights; // 120 - 121
-	BYTE					bLimitPlayerMarkers;	// 121 - 122
-	float					fPlayerMarkesLimit;		// 122 - 126 
-	BOOL					bVehicleFriendlyFire;	// 126 - 130
-#ifndef _WIN32
-	double					dElapsedTime;			// size = 8
-#endif
-	int						iSpawnsAvailable;		// 130 - 134
-	CPlayerSpawnInfo		AvailableSpawns[300];	// 129 - 13929
-};
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-struct PlayerID
-{
-	unsigned int binaryAddress;
-	unsigned short port;
-};
-
-const PlayerID UNASSIGNED_PLAYER_ID =
-{
-	0xFFFFFFFF, 0xFFFF
-};
-
-/// All RPC functions have the same parameter list - this structure.
-struct RPCParameters
-{
-	/// The data from the remote system
-	unsigned char *input;
-
-	/// How many bits long \a input is
-	unsigned int numberOfBitsOfData;
-
-	/// Which system called this RPC
-	PlayerID sender;
-
-	/// Which instance of RakPeer (or a derived RakServer or RakClient) got this call
-	void *recipient;
-
-	/// You can return values from RPC calls by writing them to this BitStream.
-	/// This is only sent back if the RPC call originally passed a BitStream to receive the reply.
-	/// If you do so and your send is reliable, it will block until you get a reply or you get disconnected from the system you are sending to, whichever is first.
-	/// If your send is not reliable, it will block for triple the ping time, or until you are disconnected, or you get a reply, whichever is first.
-	RakNet::BitStream *replyToSender;
-};
-
-/// These enumerations are used to describe when packets are delivered.
-enum PacketPriority
-{
-	SYSTEM_PRIORITY,   /// \internal Used by RakNet to send above-high priority messages.
-	HIGH_PRIORITY,   /// High priority messages are send before medium priority messages.
-	MEDIUM_PRIORITY,   /// Medium priority messages are send before low priority messages.
-	LOW_PRIORITY,   /// Low priority messages are only sent when no other messages are waiting.
-	NUMBER_OF_PRIORITIES
-};
-
-/// These enumerations are used to describe how packets are delivered.
-/// \note  Note to self: I write this with 3 bits in the stream.  If I add more remember to change that
-enum PacketReliability
-{
-	UNRELIABLE = 6,   /// Same as regular UDP, except that it will also discard duplicate datagrams.  RakNet adds (6 to 17) + 21 bits of overhead, 16 of which is used to detect duplicate packets and 6 to 17 of which is used for message length.
-	UNRELIABLE_SEQUENCED,  /// Regular UDP with a sequence counter.  Out of order messages will be discarded.  This adds an additional 13 bits on top what is used for UNRELIABLE.
-	RELIABLE,   /// The message is sent reliably, but not necessarily in any order.  Same overhead as UNRELIABLE.
-	RELIABLE_ORDERED,   /// This message is reliable and will arrive in the order you sent it.  Messages will be delayed while waiting for out of order messages.  Same overhead as UNRELIABLE_SEQUENCED.
-	RELIABLE_SEQUENCED /// This message is reliable and will arrive in the sequence you sent it.  Out or order messages will be dropped.  Same overhead as UNRELIABLE_SEQUENCED.
-};
-
-/// \sa NetworkIDGenerator.h
-typedef unsigned char UniqueIDType;
-typedef unsigned short PlayerIndex;
-typedef unsigned char RPCIndex;
-const int MAX_RPC_MAP_SIZE=((RPCIndex)-1)-1;
-const int UNDEFINED_RPC_INDEX=((RPCIndex)-1);
-
-/// First byte of a network message
-typedef unsigned char MessageID;
-
-typedef unsigned int RakNetTime;
-typedef long long RakNetTimeNS;
-
-struct RakNetStatisticsStruct
-{
-	///  Number of Messages in the send Buffer (high, medium, low priority)
-	unsigned messageSendBuffer[ NUMBER_OF_PRIORITIES ];
-	///  Number of messages sent (high, medium, low priority)
-	unsigned messagesSent[ NUMBER_OF_PRIORITIES ];
-	///  Number of data bits used for user messages
-	unsigned messageDataBitsSent[ NUMBER_OF_PRIORITIES ];
-	///  Number of total bits used for user messages, including headers
-	unsigned messageTotalBitsSent[ NUMBER_OF_PRIORITIES ];
-	
-	///  Number of packets sent containing only acknowledgements
-	unsigned packetsContainingOnlyAcknowlegements;
-	///  Number of acknowledgements sent
-	unsigned acknowlegementsSent;
-	///  Number of acknowledgements waiting to be sent
-	unsigned acknowlegementsPending;
-	///  Number of acknowledgements bits sent
-	unsigned acknowlegementBitsSent;
-	
-	///  Number of packets containing only acknowledgements and resends
-	unsigned packetsContainingOnlyAcknowlegementsAndResends;
-	
-	///  Number of messages resent
-	unsigned messageResends;
-	///  Number of bits resent of actual data
-	unsigned messageDataBitsResent;
-	///  Total number of bits resent, including headers
-	unsigned messagesTotalBitsResent;
-	///  Number of messages waiting for ack (// TODO - rename this)
-	unsigned messagesOnResendQueue;
-	
-	///  Number of messages not split for sending
-	unsigned numberOfUnsplitMessages;
-	///  Number of messages split for sending
-	unsigned numberOfSplitMessages;
-	///  Total number of splits done for sending
-	unsigned totalSplits;
-	
-	///  Total packets sent
-	unsigned packetsSent;
-	
-	///  Number of bits added by encryption
-	unsigned encryptionBitsSent;
-	///  total bits sent
-	unsigned totalBitsSent;
-	
-	///  Number of sequenced messages arrived out of order
-	unsigned sequencedMessagesOutOfOrder;
-	///  Number of sequenced messages arrived in order
-	unsigned sequencedMessagesInOrder;
-	
-	///  Number of ordered messages arrived out of order
-	unsigned orderedMessagesOutOfOrder;
-	///  Number of ordered messages arrived in order
-	unsigned orderedMessagesInOrder;
-	
-	///  Packets with a good CRC received
-	unsigned packetsReceived;
-	///  Packets with a bad CRC received
-	unsigned packetsWithBadCRCReceived;
-	///  Bits with a good CRC received
-	unsigned bitsReceived;
-	///  Bits with a bad CRC received
-	unsigned bitsWithBadCRCReceived;
-	///  Number of acknowledgement messages received for packets we are resending
-	unsigned acknowlegementsReceived;
-	///  Number of acknowledgement messages received for packets we are not resending
-	unsigned duplicateAcknowlegementsReceived;
-	///  Number of data messages (anything other than an ack) received that are valid and not duplicate
-	unsigned messagesReceived;
-	///  Number of data messages (anything other than an ack) received that are invalid
-	unsigned invalidMessagesReceived;
-	///  Number of data messages (anything other than an ack) received that are duplicate
-	unsigned duplicateMessagesReceived;
-	///  Number of messages waiting for reassembly
-	unsigned messagesWaitingForReassembly;
-	///  Number of messages in reliability output queue
-	unsigned internalOutputQueueSize;
-	///  Current bits per second
-	double bitsPerSecond;
-	///  connection start time
-	RakNetTime connectionStartTime;
-};
-
-/// This represents a user message from another system.
-struct Packet
-{
-	/// Server only - this is the index into the player array that this playerId maps to
-	PlayerIndex playerIndex; // 0 - 2
-
-	/// The system that send this packet.
-	PlayerID playerId; // 2  - 8
-
-	/// The length of the data in bytes
-	/// \deprecated You should use bitSize.
-	unsigned int length; // 8 - 12
-
-	/// The length of the data in bits
-	unsigned int bitSize; // 12 - 16
-
-	/// The data from the sender
-	unsigned char* data; // 16 - 20
-
-	/// @internal
-	/// Indicates whether to delete the data, or to simply delete the packet.
-	bool deleteData;
-};
-
-#ifdef _WIN32
-class RakServer
-{
-public:
-	~RakServer(); // THIS NOT
-	virtual void _0();
-	virtual bool Start(unsigned short AllowedPlayers, unsigned int depreciated, int threadSleepTimer, unsigned short port, const char *forceHostAddress = 0) = 0; // 4
-	virtual void DisableSecurity( void ); // 8
-	virtual void SetPassword( const char *_password );	// 12
-	virtual bool HasPassword( void );	// 16
-	virtual void Disconnect( unsigned int blockDuration, unsigned char orderingChannel=0 );	// 20
-	virtual bool Send_ASD(const char *data, const int length, int priority, int reliability, char orderingChannel, PlayerID playerId, bool broadcast); // 24
-	virtual bool Send(RakNet::BitStream* parameters, int priority, int reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast);	// 28
-	virtual void _20(); // 
-	virtual void _24();
-	virtual Packet* ReceiveEx( void );
-	virtual void Kick( const PlayerID playerId ); // 0x2C
-	virtual void DeallocatePacket(Packet* asd);
-	virtual void SetAllowedPlayers(unsigned short numberAllowed); // 0x34
-	virtual unsigned short GetAllowedPlayers( void ) const;
-	virtual unsigned short GetConnectedPlayers( void );
-	virtual void GetPlayerIPFromID( const PlayerID playerId, char returnValue[ 22 ], unsigned short *port );
-	virtual void PingPlayer( const PlayerID playerId );
-	virtual int GetAveragePing( const PlayerID playerId );
-	virtual int GetLastPing( const PlayerID playerId ); // 4C
-	virtual int GetLowestPing( const PlayerID playerId );
-	virtual void _54();
-	virtual void _58();
-	virtual void _5C();
-	virtual void _60();
-	virtual void _64();
-	virtual void _68();
-	virtual void _6C();
-	virtual void _70();
-	virtual void RegisterAsRemoteProcedureCall( int* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) );	// 74
-	virtual void RegisterClassMemberRPC( int* uniqueID, void *functionPointer );	// 78
-	virtual void UnregisterAsRemoteProcedureCall( int* uniqueID );	// 7C
-	virtual bool RPC(int* uniqueID, RakNet::BitStream* parameters, PacketPriority priority, PacketReliability reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp); // 80
-	virtual void _84();
-	virtual void _88();
-	virtual void _8C();
-	virtual void _90();
-	virtual void _94();
-	virtual void _98();
-	virtual void _9C();
-	virtual void _A0();
-	virtual void _A4();
-	virtual void _A8();
-	virtual void _AC();
-	virtual void _B0();
-	virtual void _B4();
-	virtual void _B8();
-	virtual void _BC();
-	virtual void _C0();
-	virtual void _C4();
-	virtual void _C8();
-	virtual void _CC();
-	virtual const char* GetLocalIP( unsigned int index );
-	virtual PlayerID GetInternalID( void ) const;
-	virtual void PushBackPacket( Packet *packet, bool pushAtHead );
-	virtual void SetRouterInterface( void *routerInterface );
-	virtual void RemoveRouterInterface( void *routerInterface );
-	virtual int GetIndexFromPlayerID( PlayerID playerId ); // E4
-	virtual PlayerID GetPlayerIDFromIndex( int index ); // E8 - 232 - 236
-	virtual void UNKNOWN(void); // 236 - 240
-	virtual void AddToBanList( const char *IP, unsigned int milliseconds=0 ); // 240 - 244
-	virtual void RemoveFromBanList( const char *IP );
-	virtual void ClearBanList( void );
-	virtual bool IsBanned( const char *IP );
-	virtual bool IsActivePlayerID( const PlayerID playerId );
-	virtual void SetTimeoutTime( RakNetTime timeMS, const PlayerID target );
-	virtual bool SetMTUSize( int size );
-	virtual int GetMTUSize( void ) const;
-	virtual void AdvertiseSystem( const char *host, unsigned short remotePort, const char *data, int dataLength );
-	virtual RakNetStatisticsStruct * const GetStatistics( const PlayerID playerId );
-	virtual void ApplyNetworkSimulator( double maxSendBPS, unsigned short minExtraPing, unsigned short extraPingVariance);
-};
-
-#else
-
-class RakServer
-{
-public:
-	~RakServer();
-	virtual bool _0(); 
-	virtual void _4();
-	virtual bool Start(unsigned short AllowedPlayers, unsigned int depreciated, int threadSleepTimer, unsigned short port, const char *forceHostAddress = 0) = 0;
-	virtual void _C();
-	virtual void _10();
-	virtual void _14();
-	virtual void _18();
-	virtual void _1C();
-	virtual bool SendGECI(RakNet::BitStream* parameters, int priority, int reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast);
-	virtual bool Send(RakNet::BitStream* parameters, int priority, int reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast);
-	virtual void _28();
-	virtual void _2C();
-	virtual void _30();
-	virtual void _34();
-	virtual void SetAllowedPlayers(unsigned short numberAllowed);
-	virtual void _3C();
-	virtual void _40();
-	virtual void _44();
-	virtual void _48();
-	virtual void _4C();
-	virtual int GetLastPing( const PlayerID playerId ); // 0x50
-	virtual void _54();
-	virtual void _58();
-	virtual void _5C();
-	virtual const char* GetLocalIP( unsigned int index );
-	virtual PlayerID GetInternalID( void ) const;
-	virtual void PushBackPacket( Packet *packet, bool pushAtHead );
-	virtual void SetRouterInterface( void *routerInterface );
-	virtual void RemoveRouterInterface( void *routerInterface );
-	virtual void UnregisterAsRemoteProcedureCall_BAD( int* uniqueID );
-	virtual void RegisterAsRemoteProcedureCall( int* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ); // 120
-	virtual void RegisterClassMemberRPC( int* uniqueID, void *functionPointer ); // 124
-	virtual void UnregisterAsRemoteProcedureCall( int* uniqueID ); // 128
-	virtual void UnregisterAsRemoteProcedureCall_4( int* uniqueID );
-	virtual void UnregisterAsRemoteProcedureCall_5( int* uniqueID );
-	virtual bool RPC(int* uniqueID, RakNet::BitStream* parameters, int priority, int reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp);
-	virtual void _90();
-	virtual void _94();
-	virtual void _98();
-	virtual void _9C();
-	virtual void _A0();
-	virtual void _A4();
-	virtual void _A8();
-	virtual void _AC();
-	virtual void _B0();
-	virtual void _B4();
-	virtual void _B8();
-	virtual void _BC();
-	virtual void _C0();
-	virtual void _C4();
-	virtual void _C8();
-	virtual void _CC();
-	virtual void _D0();
-	virtual void _D4();
-	virtual void _D8();
-	virtual void _DC();
-	virtual void _E0();
-	virtual void _E8();
-	virtual int GetIndexFromPlayerID( PlayerID playerId ); // EC
-	virtual PlayerID GetPlayerIDFromIndex( int index ); // F0 - 240 - 244
-	virtual void AddToBanList( const char *IP, unsigned int milliseconds=0 ); // 244 - 248
-	virtual void RemoveFromBanList( const char *IP ); // 248 - 252
-	virtual void ClearBanList( void );
-	virtual bool IsBanned( const char *IP );
-	virtual bool IsActivePlayerID( const PlayerID playerId );
-	virtual void SetTimeoutTime( RakNetTime timeMS, const PlayerID target );
-	virtual bool SetMTUSize( int size );
-	virtual int GetMTUSize( void ) const;
-	virtual void AdvertiseSystem( const char *host, unsigned short remotePort, const char *data, int dataLength );
-	virtual RakNetStatisticsStruct * const GetStatistics( const PlayerID playerId );
-	virtual void ApplyNetworkSimulator( double maxSendBPS, unsigned short minExtraPing, unsigned short extraPingVariance);
-};
-#endif
-
-#endif
+/*  
+ *  Version: MPL 1.1
+ *  
+ *  The contents of this file are subject to the Mozilla Public License Version 
+ *  1.1 (the "License"); you may not use this file except in compliance with 
+ *  the License. You may obtain a copy of the License at 
+ *  http://www.mozilla.org/MPL/
+ *  
+ *  Software distributed under the License is distributed on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing rights and limitations under the
+ *  License.
+ *  
+ *  The Original Code is the YSI 2.0 SA:MP plugin.
+ *  
+ *  The Initial Developer of the Original Code is Alex "Y_Less" Cole.
+ *  Portions created by the Initial Developer are Copyright (C) 2008
+ *  the Initial Developer. All Rights Reserved.
+ *  
+ *  Contributor(s):
+ *  
+ *  Peter Beverloo
+ *  Marcus Bauer
+ *  MaVe;
+ *  Sammy91
+ *  Incognito
+ *  
+ *  Special Thanks to:
+ *  
+ *  SA:MP Team past, present and future
+ */
+
+#ifndef YSF_STRUCTS_H
+#define YSF_STRUCTS_H
+
+#include "CServer.h"
+#include "CVector.h"
+#include "CGangZonePool.h"
+#include "CPickupPool.h"
+#include <map>
+
+#include <raknet/BitStream.h>
+#include <sampgdk/sampgdk.h>
+
+class CGangZonePool;
+
+/* -------------------------------------------------------- */
+
+// Defines
+#define	MAX_ATTACHED_OBJECTS		10
+#define	MAX_FILTER_SCRIPTS			16
+
+#define MAX_PVARS					800
+#define MAX_PVAR_NAME				40
+
+#define MAX_MENU_TEXT_SIZE			32
+#define MAX_ITEMS					12
+#define MAX_COLUMNS					2
+
+/* -------------------------------------------------------- */
+
+// Server rules special
+enum CON_VARTYPE { CON_VARTYPE_FLOAT, CON_VARTYPE_INT, CON_VARTYPE_BOOL, CON_VARTYPE_STRING };
+
+#define CON_VARFLAG_DEBUG		1
+#define CON_VARFLAG_READONLY	2
+#define CON_VARFLAG_RULE		4	// Gets sent with a RULES query responce
+
+typedef void(*VARCHANGEFUNC)();
+
+/* -------------------------------------------------------- */
+typedef struct _MATRIX4X4 
+{
+	CVector right;	// 0 - 12
+	DWORD  flags;	// 12 - 16
+	CVector up;		// 16 - 28
+	float  pad_u;	// 28 - 32
+	CVector at;		// 32 - 44
+	float  pad_a;	// 44 - 48
+	CVector pos;	// 48 - 60
+	float  pad_p;	// 60 - 64
+} MATRIX4X4, *PMATRIX4X4;
+
+struct ConsoleVariable_s
+{
+	CON_VARTYPE		VarType;
+	DWORD			VarFlags;
+	void*			VarPtr;
+	VARCHANGEFUNC	VarChangeFunc;
+};
+
+struct C3DText  // size 0x21
+{
+	char*			szText;                                     // + 0x00
+    DWORD			dwColor;                         // + 0x04
+	CVector			vecPos;
+	float			fDrawDistance;                     // + 0x14
+    bool			bLineOfSight;            // + 0x18
+    int				iWorld;                  // + 0x19
+    WORD			attachedToPlayerID;    // + 0x1D
+	WORD			attachedToVehicleID;   // + 0x1F
+};
+
+/* -------------------------------------------------------- */
+// CPlayer
+/* -------------------------------------------------------- */
+
+// Big thanks to OrMisicL
+struct CAimSyncData
+{
+	BYTE			byteCameraMode;			// 0
+	CVector			vecFront;				// 1 - 13
+	CVector			vecPosition;			// 13 - 25
+	float			fZAim;					// 25 - 29
+	BYTE			byteCameraZoom : 6;		// 29
+	BYTE			byteWeaponState  : 2;	// 29
+	BYTE			unk;					// 30 - 31
+	WORD			wCameraObject;			// 31 - 33
+	WORD			wCameraVehicle;			// 33 - 35
+	WORD			wCameraPlayer;			// 35 - 37
+	WORD			wCameraActor;			// 37 - 39
+	// Size = 39
+};
+
+struct CVehicleSyncData
+{
+	WORD			wVehicleId;				// 0x001F - 0x0021
+	WORD			wLRAnalog;				// 0x0021 - 0x0023
+	WORD			wUDAnalog;				// 0x0023 - 0x0025
+	WORD			wKeys;					// 0x0025 - 0x0027
+	float			fQuaternion[4];			// 0x002B - 0x0037
+	CVector			vecPosition;			// 0x0037 - 0x0043
+	CVector			vecVelocity;			// 0x0043 - 0x004F
+	float			fHealth;				// 0x004F - 0x0053
+	BYTE			bytePlayerHealth;		// 0x0053 - 0x0054
+	BYTE			bytePlayerArmour;		// 0x0054 - 0x0055
+	BYTE			bytePlayerWeapon : 6;	// 0x0055 - 0x0056
+	BYTE			unk_2 : 2;				// 0x0055 - 0x0056
+	BYTE			byteSirenState;			// 0x0056 - 0x0057
+	BYTE			byteGearState;			// 0x0057 -	0x0058
+	WORD			wTrailerID;				// 0x0058 - 0x005A
+    union									// 
+    {
+            WORD			wHydraReactorAngle[2];                       
+            float           fTrainSpeed;
+    };
+	// Size = 63
+};
+
+struct CPassengerSyncData
+{
+	WORD			wVehicleId;				// 0x005E - 0x0060
+	BYTE			byteSeatFlags : 7;
+	BYTE			byteDriveBy : 1;
+	BYTE			bytePlayerWeapon;		// 0x0061 - 0x0062
+	BYTE			bytePlayerHealth;		// 0x0062 - 0x0063
+	BYTE			bytePlayerArmour;		// 0x0063 - 0x0064
+	WORD			wLRAnalog;				// 0x0064 - 0x0066
+	WORD			wUDAnalog;				// 0x0066 - 0x0068
+	WORD			wKeys;					// 0x0068 - 0x006A
+	CVector			vecPosition;			// 0x006A - 0x0076
+	// Size = 24
+};
+
+struct CSyncData
+{
+	WORD			wLRAnalog;				// 0x0076 - 0x0078
+	WORD			wUDAnalog;				// 0x0078 - 0x007A
+	WORD			wKeys;					// 0x007A - 0x007C
+	CVector			vecPosition;			// 0x007C - 0x0088
+	float			fQuaternion[4];			// 0x0088 - 0x008C
+	BYTE			byteHealth;				// 0x0098 - 0x0099
+	BYTE			byteArmour;				// 0x0099 - 0x009A
+	BYTE			byteWeapon : 6;				// 0x009A - 0x009B
+	BYTE			_unk_ : 2;
+	BYTE			byteSpecialAction;		// 0x009B - 0x009C
+	CVector			vecVelocity;			// 0x009C - 0x00A8
+	CVector			vecSurfing;				// 0x00A8 - 0x00B4
+	WORD			wSurfingInfo;			// 0x00B4 - 0x00B6
+	union 
+	{
+		DWORD		dwAnimationData;		// 0x00B6 - 0x00BA
+		struct 
+		{
+			WORD	wAnimIndex;
+			WORD	wAnimFlags;
+		};
+	};
+	// Size = 68
+};
+
+struct CUnoccupiedSyncData // size 0x43
+{
+	WORD			wVehicleID;				// + 0x0000
+	BYTE			bytePassengerSlot;			// + 0x0002
+	CVector			vecRool;				// + 0x0003
+	CVector			vecDirection;			// + 0x000F
+	CVector			vecPosition;			// + 0x001B
+	CVector			vecVelocity;			// + 0x0027
+	CVector			vecTurnVelocity;		// + 0x0033
+	float			fHealth;					// + 0x003F
+};
+
+struct CSpectatingSyncData		// size 0x12
+{
+	WORD			wLeftRightKeysOnSpectating;				// + 0x0000
+	WORD			wUpDownKeysOnSpectating;				// + 0x0002
+	WORD			wKeysOnSpectating;						// + 0x0004
+	CVector			vecPosition;							// + 0x0006
+};
+
+struct CTrailerSyncData // size 0x36 = 54
+{
+	WORD			wTrailerID;				// + 0x0000
+	CVector			vecRoll;				// + 0x0002
+	CVector			vecDirection;			// + 0x000E
+	CVector			vecPosition;			// + 0x001A
+	CVector			vecVelocity;			// + 0x0026
+	DWORD			pad;
+};
+
+typedef struct CTextdraw
+{
+	union
+	{
+		BYTE byteFlags;			// 25
+		struct
+		{
+			BYTE byteBox : 1;
+			BYTE byteLeft : 1; 
+			BYTE byteRight : 1;
+			BYTE byteCenter : 1;
+			BYTE byteProportional : 1;
+			BYTE bytePadding : 3;
+		};
+	};
+	float			fLetterWidth;			// 1
+	float			fLetterHeight;		// 5
+	DWORD			dwLetterColor;		// 9
+	float			fLineWidth;			// 13
+	float			fLineHeight;			// 17
+	DWORD			dwBoxColor;			// 21
+	BYTE			byteShadow; // 26
+	BYTE			byteOutline; // 27
+	DWORD			dwBackgroundColor; // 31
+	BYTE			byteStyle; // 32
+	BYTE			byteSelectable; // 32
+	float			fX; // 33
+	float			fY; // 37
+	WORD			dwModelIndex; // 41 - 43
+	CVector			vecRot;  // 43 - 55
+	float			fZoom; // 55 - 59
+	WORD			color1; // 59 - 61
+	WORD			color2; // 61 - 63
+} _CTextdraw;
+
+struct CPlayerTextDraw
+{
+	BOOL			bSlotState[MAX_PLAYER_TEXT_DRAWS];
+	CTextdraw	    *TextDraw[MAX_PLAYER_TEXT_DRAWS];
+	char			*szFontText[MAX_PLAYER_TEXT_DRAWS];
+	bool			bHasText[MAX_PLAYER_TEXT_DRAWS];
+};
+
+struct CPlayerText3DLabels // size 0x9802
+{
+	C3DText			TextLabels[ MAX_3DTEXT_PLAYER ];	// + 0x0000
+	BOOL			isCreated[ MAX_3DTEXT_PLAYER ];	// + 0x8400
+	BYTE			unknown9800[MAX_3DTEXT_PLAYER];				// + 0x9400
+	WORD			wOwnerID;
+};
+
+struct CAttachedObject // sizeof = 52 - 0x34
+{
+    int				iModelID;
+    int				iBoneiD;
+    CVector         vecPos;
+    CVector         vecRot;
+    CVector         vecScale;
+	DWORD			dwMaterialColor1;
+	DWORD			dwMaterialColor2;
+};
+
+struct CPlayerSpawnInfo // size  46
+{
+	BYTE			byteTeam;				// 0 - 1
+	int				iSkin;					// 1 - 5
+	BYTE			unk;					// 5 - 6
+	CVector			vecPos;				// 6 - 18
+	float			fRotation;			// 18 - 22
+	int				iSpawnWeapons[3];		// 22 - 34
+	int				iSpawnWeaponsAmmo[3];	// 34 - 46
+};
+
+struct CBulletSyncData // sizeof = 40
+{
+	BYTE			byteHitType;
+	WORD			wHitID;
+	CVector			vecHitOrigin;
+	CVector			vecHitTarget;
+	CVector			vecCenterOfHit;
+	BYTE			byteWeaponID;
+}; 
+
+struct CPVar
+{
+    char			szVarName[MAX_PVAR_NAME + 1];
+    BOOL			bIsReadOnly;
+    int				iVarType;
+    int				iValue;
+    float			fValue;
+    char*			szValue;
+};
+
+struct CPlayerVar
+{
+    CPVar			Vars[MAX_PVARS];
+	BOOL			bIsPVarActive[MAX_PVARS];
+    int				iUpperIndex;
+};
+
+struct CPlayer
+{
+	CAimSyncData			aimSyncData;			// 0 - 39
+	CVehicleSyncData		vehicleSyncData;		// 39 -
+	CPassengerSyncData		passengerSyncData;		//
+	CSyncData				syncData;				// 126 - 194
+	CUnoccupiedSyncData		unoccupiedSyncData;		// 194 - 261
+	CSpectatingSyncData		spectatingSyncData;		// 261 - 279
+	CTrailerSyncData		trailerSyncData;		// 279 - 333
+	DWORD					dwPlayerSyncUnused;		// 333 - 337
+	DWORD					dwVehicleSyncUnused;	// 337 - 341
+	BYTE					byteStreamedIn[MAX_PLAYERS];				// 341 - 1341
+	BYTE					byteVehicleStreamedIn[MAX_VEHICLES];		// 1341 - 3341
+	BYTE					byteSomethingUnused[1000];					// 3341 - 4341
+	BYTE					byte3DTextLabelStreamedIn[1024];			// 4341  - 5365
+	BYTE					bPickupStreamedIn[MAX_PICKUPS];				// 5365 - 9461
+	BYTE					byteActorStreamedIn[MAX_PLAYERS];			// 9461 - 10461
+	DWORD					dwStreamedInPlayers;						// 10461 - 10465
+	DWORD					dwStreamedInVehicles;						// 10465 - 10469
+	DWORD					dwStreamedInSomethingUnused;				// 10469 - 10473
+	DWORD					dwStreamedIn3DTextLabels;					// 10479 - 10477
+	DWORD					dwStreamedInPickups;						// 10477 - 10481
+	DWORD					dwStreamedInActors;							// 10481 - 10485
+	DWORD					bHasSetVehiclePos;	// 10485 - 10489
+	DWORD					dwSetVehiclePosTick;// 10489 - 10493
+	CVector					vecVehicleNewPos;	// 10493 - 10505
+	BOOL					bCameraTarget;		// 10505
+	DWORD					bHasSpawnInfo;		// 10509
+	BOOL					bUpdateKeys;		// 10513
+	CVector					vecPosition;		// 10517
+	float					fHealth;			// 10529 - 10533
+	float					fArmour;			// 10533 - 10537
+	float					fQuaternion[4];		// 10537 - 10553
+	float					fAngle;				// 10553 - 10557
+	CVector					vecVelocity;		// 10557 - 10569
+	WORD					wLRAnalog;			// 10569
+	WORD					wUDAnalog;			// 10571
+	DWORD					dwKeys;				// 10573 - 10577
+	DWORD					dwOldKeys;			// 10577 - 10581
+	BOOL					bEditObject;		// 10581 - 10585
+	BOOL					bEditAttachedObject;// 10585 - 10589
+	WORD					wDialogID;			// 10589 - 10591
+	CPlayerTextDraw*		pTextdraw;			// 10591 - 10595
+	CPlayerText3DLabels*	p3DText;			// 10595 - 10599
+	WORD					wPlayerId;			// 10599 - 10601
+	int						iUpdateState;		// 10601 - 10605
+	//DWORD					dwLastSyncTick;		// 10605 - 10609
+	CAttachedObject			attachedObject[MAX_ATTACHED_OBJECTS]; // 10605 - 11125
+	BOOL					attachedObjectSlot[MAX_ATTACHED_OBJECTS]; // 11125 - 11165
+	BOOL					bHasAimSync;		// 11165 - 11169
+	BOOL					bHasTrailerSync;	// 11169 - 11173
+	BOOL					bHasUnoccupiedSync;	// 11173 - 11177
+	BYTE					byteState;			// 11177 - 11178
+	CVector					vecCPPos;			// 11178 - 11190
+	float					fCPSize;			// 11190 - 11194
+	BOOL					bIsInCP;			// 11194 - 11198
+	CVector					vecRaceCPPos;		// 11198 - 11210
+	CVector					vecRaceCPNextPos;	// 11210 - 11222 
+	BYTE					byteRaceCPType;		// 11222 - 11223 // TODO -> replace
+	float					fRaceCPSize;		// 11223 - 11227
+	BOOL					bIsInRaceCP;		// 11227 - 11231
+	BOOL					bIsInModShop;		// 11231 - 11235
+	WORD					wSkillLevel[11];	// 11235 - 11257
+	int						iLastMarkerUpdate;	// 11257 - 11261
+	CPlayerSpawnInfo		spawn;				// 11261 - 11307
+	BOOL					bReadyToSpawn;		// 11307 - 11311
+	BYTE					byteWantedLevel;	// 11311 - 11312
+	BYTE					byteFightingStyle;  // 11312 - 11313
+	BYTE					byteSeatId;			// 11313 - 11314
+	WORD					wVehicleId;			// 11314 - 11316
+	DWORD					dwNickNameColor;	// 11316 - 11320
+	BOOL					bShowCheckpoint;	// 11320 - 11324
+	BOOL					bShowRaceCheckpoint;// 11324 - 11328
+	int						iInteriorId;		// 11328 - 11332
+	WORD					wWeaponAmmo[12];	// 11332 - 11356
+	PAD(pad10, 28);								// 11356 - 11384
+	BYTE					byteWeaponId[12];	// 11384 - 11396
+	BYTE					byteWeaponID_unknown;// 11396 - 11397
+	BYTE					byteCurrentWeapon;	// 11397 - 11398
+	WORD					wTargetId;			// 11398 - 11400
+	WORD					wTargetActorId;		// 11400 - 11402
+	DWORD					dwLastShotTick;		// 11402 - 11406
+	BYTE					dwLastShotWeapon;	// 11406 - 11407
+	CBulletSyncData			bulletSyncData;		// 11407 - 11447	
+	BYTE					m_byteTime;			// 11447 - 11448
+	float					m_fGameTime;		// 11448 - 11452
+	BYTE					byteSpectateType;	// 11452 - 11453
+	DWORD					wSpectateID;		// 11453 - 11457
+	DWORD					dwLastStreaming;	// 11457 - 11461
+	DWORD					dwNPCRecordingType;	// 11461 - 11465
+	FILE					*pRecordingFile;	// 11465 - 11469
+	DWORD					dwFirstNPCWritingTime; // 11469 - 11473 
+	PAD(unused, 9);								// 11473 - 11482
+	CPlayerVar*				pPlayerVars;		// 11482 - 11486
+	// Size = 9963
+};
+
+struct CPlayerPool // sizeof = 99520
+{
+	DWORD			dwVirtualWorld[MAX_PLAYERS];			// 0 - 4000
+	DWORD			dwPlayersCount;							// 4000 - 4004
+	DWORD			dwlastMarkerUpdate;						// 4004 - 4008
+	float			fUpdatePlayerGameTimers;				// 4008 - 4012
+	DWORD			dwScore[MAX_PLAYERS];					// 4012 - 8012
+	DWORD			dwMoney[MAX_PLAYERS];					// 8012 - 12012
+	DWORD			dwDrunkLevel[MAX_PLAYERS];				// 12012 - 16012
+	DWORD			dwLastScoreUpdate[MAX_PLAYERS];			// 16012 - 20012
+	char			szSerial[MAX_PLAYERS][101];				// 20012 - 121012				
+	char			szVersion[MAX_PLAYERS][29];				// 121012 - 150012
+	BOOL			bIsPlayerConnectedEx[MAX_PLAYERS];		// 150012 - 154012
+	CPlayer			*pPlayer[MAX_PLAYERS];					// 154012 - 158012
+	char			szName[MAX_PLAYERS][25];				// 158012 - 183012
+	BOOL			bIsAnAdmin[MAX_PLAYERS];				// 183012 - 187012
+	BOOL			bIsNPC[MAX_PLAYERS];					// 187012 - 191012
+	PAD(pad0, 8000);											// 191012 - 199012
+	DWORD			dwConnectedPlayers;						// 199012 - 199016
+	DWORD			dwPlayerPoolSize;						// 199016 - 199020
+};
+
+/* -------------------------------------------------------- */
+// CVehicle
+/* -------------------------------------------------------- */
+
+struct CVehicleSpawn // size 36
+{
+	int				iModelID;
+    CVector			vecPos;   
+    float			fRot;
+    int				iColor1;  
+    int				iColor2;  
+    int				iRespawnTime;
+    int				iInterior;
+};
+
+struct CVehicleModInfo // sizeof = 26
+{
+	BYTE			byteModSlots[14];                // + 0x0000
+    BYTE			bytePaintJob;                    // + 0x000E
+    int				iColor1;                             // + 0x000F
+    int				iColor2;                             // + 0x0010
+};
+
+struct CVehicleParams // sizeof = 16
+{
+	BYTE engine;
+	BYTE lights;
+	BYTE alarm;
+	BYTE doors;
+	BYTE bonnet;
+	BYTE boot;
+	BYTE objective; // 6
+	BYTE siren; // 7
+	BYTE door_driver; // 8
+	BYTE door_passenger;
+	BYTE door_backleft;
+	BYTE door_backright; // 11
+	BYTE window_driver; // 12
+	BYTE window_passenger;
+	BYTE window_backleft;
+	BYTE window_backright; // 15 - 16
+};
+
+struct CVehicle
+{
+	CVector			vecPosition;		// 0 - 12
+	MATRIX4X4		vehMatrix;			// 12 - 76
+	CVector			vecVelocity;		// 76 - 88
+	CVector			vecTurnSpeed;		// 88 - 100
+	WORD			wVehicleID;			// 100 - 102
+	WORD			wTrailerID;			// 102 - 104
+	WORD			wCabID;				// 104 - 106
+	WORD			wLastDriverID;		// 106 - 108
+	WORD			vehPassengers[7];	// 108 - 122
+	DWORD			vehActive;			// 122 - 126
+	DWORD			vehWasted;			// 126 - 130	
+	CVehicleSpawn	customSpawn;		// 130 - 166
+	float			fHealth;			// 166 - 170
+	DWORD			vehDoorStatus;		// 170 - 174
+	DWORD			vehPanelStatus;		// 174 - 178
+	BYTE			vehLightStatus;		// 178 - 179
+	BYTE			vehTireStatus;		// 179 - 180
+	bool			bDead;				// 180 - 181
+	WORD			wKillerID;			// 181 - 183
+	CVehicleModInfo vehModInfo;			// 183 - 206
+	char			szNumberplate[32 + 1]; // 206 - 239
+	CVehicleParams	vehParamEx;			// 239 - 255
+    BYTE			bDeathNotification; // 255 - 256
+    BYTE			bOccupied;			// 256 - 257
+    DWORD			vehOccupiedTick;	// 257 - 261
+    DWORD			vehRespawnTick;		// 261 - 265
+	BYTE			sirenEnabled;		// 265 - 266
+	BYTE			newSirenState;		// 266 - 267 passed to OnVehicleSirenStateChange
+};
+
+struct CVehiclePool
+{
+	BYTE			byteVehicleModelsUsed[212];			// 0 - 212
+	int				iVirtualWorld[MAX_VEHICLES];		// 212 - 8212
+	BOOL			bVehicleSlotState[MAX_VEHICLES];	// 8212 - 16212
+	CVehicle		*pVehicle[MAX_VEHICLES];			// 16212 - 24212
+	DWORD			dwVehiclePoolSize;					// 24212
+};
+
+/* -------------------------------------------------------- */
+// CPickup
+/* -------------------------------------------------------- */
+
+struct tPickup // size 0x14
+{
+	int				iModel;
+	int				iType;
+	CVector			vecPos;
+};
+
+struct CPickupPool
+{
+	tPickup			Pickup[MAX_PICKUPS];			// + 0x0000
+	BOOL			bActive[MAX_PICKUPS];			// + 0xA000
+	int				iWorld[MAX_PICKUPS];		// + 0xC000
+	int				iPickupCount;
+};
+
+/* -------------------------------------------------------- */
+// CObject
+/* -------------------------------------------------------- */
+
+struct CObjectMaterial // sizeof = 215
+{
+	BYTE			byteUsed;				// 197 - 198
+	BYTE			byteSlot;				// 198 - 199
+	WORD			wModelID;				// 199 - 201
+	DWORD			dwMaterialColor;		// 201 - 205
+	char			szMaterialTXD[64 + 1];	// 205 - 270
+	char			szMaterialTexture[64 + 1]; // 270 - 335
+	BYTE			byteMaterialSize;		// 335 - 336
+	char			szFont[64 + 1];			// 336 - 401
+	BYTE			byteFontSize;			// 401 - 402
+	BYTE			byteBold;				// 402 - 403
+	DWORD			dwFontColor;			// 403 - 407
+	DWORD			dwBackgroundColor;		// 407 - 411
+	BYTE			byteAlignment;			// 411 - 412
+};
+
+struct CObject // sizeof = 3712
+{
+	WORD			wObjectID;			// 0 - 2
+	int				iModel;				// 2 - 6
+	BOOL			bActive;			// 6 - 10
+	MATRIX4X4		matWorld;			// 10 - 74 - pos - Object position
+	CVector			vecRot; 			// 74 - 86 - Object rotation
+	MATRIX4X4		matTarget;			// 86 - 150	- 
+	BYTE			bIsMoving;			// 150 - 151
+	BYTE			bNoCameraCol;		// 151 - 152
+	float			fMoveSpeed;			// 152 - 156
+	DWORD			unk_4;				// 156 - 160
+	float			fDrawDistance;		// 160 - 164
+	WORD			wAttachedVehicleID;	// 164 - 166
+	WORD			wAttachedObjectID;	// 166 - 168
+	CVector			vecAttachedOffset;	// 168 - 180
+	CVector			vecAttachedRotation;// 180 - 192
+	BYTE			byteSyncRot;		// 192 - 193
+	DWORD			dwMaterialCount;	// 193 - 197
+	CObjectMaterial	Material[16];		// 197 - 3637
+	char			*szMaterialText[16];// 3637 - 3653
+};
+
+struct CObjectPool
+{
+	BOOL			bPlayerObjectSlotState[MAX_PLAYERS][MAX_OBJECTS];	// 0 
+	BOOL			bPlayersObject[MAX_OBJECTS];							// 4.000.000
+	CObject			*pPlayerObjects[MAX_PLAYERS][MAX_OBJECTS];		// 4.004.000
+	BOOL			bObjectSlotState[MAX_OBJECTS];						// 8.004.000
+	CObject			*pObjects[MAX_OBJECTS];							// 8.008.000
+};
+
+/* -------------------------------------------------------- */
+// CMenu
+/* -------------------------------------------------------- */
+
+struct MenuInteraction
+{
+	BOOL			Menu;
+	BOOL			Row[MAX_ITEMS];
+	char			unknown[12];
+};
+	
+struct CMenu	// size 0xB84
+{
+	BYTE			menuID;														// + 0x0000
+	char			szTitle[ MAX_MENU_TEXT_SIZE ];								// + 0x0001
+	char			szItems[ MAX_ITEMS ][ MAX_COLUMNS ][ MAX_MENU_TEXT_SIZE ];	// + 0x0021
+	char			szHeaders[MAX_COLUMNS][MAX_MENU_TEXT_SIZE];					// + 0x0321
+	BOOL			bIsInitiedForPlayer[MAX_PLAYERS];							// + 0x0361
+	MenuInteraction interaction;												// + 0x0B31
+	float			fPosX;														// + 0x0B71
+	float			fPosY;														// + 0x0B75
+	float			fColumn1Width;												// + 0x0B79
+	float			fColumn2Width;												// + 0x0B7D
+	BYTE			byteColumnsNumber;											// + 0x0B81
+	BYTE			byteItemsCount[ MAX_COLUMNS ];								// + 0x0B82
+};
+
+struct CMenuPool
+{
+	CMenu*			pMenu[ MAX_MENUS ];			//	+ 0x0000
+	BOOL			bIsCreated[ MAX_MENUS ];		//	+ 0x0200
+	BOOL			bPlayerMenu[MAX_PLAYERS];	//	+ 0x0400
+};
+
+/* -------------------------------------------------------- */
+// CTextDraw
+/* -------------------------------------------------------- */
+struct CTextDrawPool
+{
+	BOOL			bSlotState[MAX_TEXT_DRAWS];
+	CTextdraw*		TextDraw[MAX_TEXT_DRAWS];
+	char*			szFontText[MAX_TEXT_DRAWS];
+	bool			bHasText[MAX_TEXT_DRAWS][MAX_PLAYERS];
+};
+
+/* -------------------------------------------------------- */
+// C3DText
+/* -------------------------------------------------------- */
+
+class C3DTextPool
+{
+public:
+	BOOL			bIsCreated[MAX_3DTEXT_GLOBAL]; // 0 - 4096 <- OK
+	C3DText			TextLabels[MAX_3DTEXT_GLOBAL];
+};
+
+/* -------------------------------------------------------- */
+// CGangZone
+/* -------------------------------------------------------- */
+
+struct CSAMPGangZonePool
+{
+	float			fGangZone[MAX_GANG_ZONES][4];
+	BOOL			bSlotState[MAX_GANG_ZONES];
+};
+
+/* -------------------------------------------------------- */
+// CActor
+/* -------------------------------------------------------- */
+
+struct CActorAnim // 140
+{
+	char			szAnimLib[64]; // 0 - 64
+	char			szAnimName[64]; // 64 - 128
+	float			fDelta;		// 128 - 132
+	BYTE			byteLoop;		// 132 - 133
+	BYTE			byteLockX;			// 133 - 134
+	BYTE			byteLockY;			// 134 - 135
+	BYTE			byteFreeze;		// 135 - 136
+	int				iTime;				//  136 - 140
+};
+
+struct CActor
+{
+	BYTE			pad0;				// 0
+	int				iSkinID;			// 1 - 5
+	CVector			vecSpawnPos;	// 5 - 17
+	float			fSpawnAngle;		// 17 - 21
+	DWORD			pad4;				// 21 - 25
+	DWORD			pad5;				// 25 - 29
+	BYTE			byteLoopAnim;		// 29 - 30
+	CActorAnim		anim;
+	WORD			wTime;				// 170 - 171
+	float			fHealth;			// 172 - 176
+	DWORD			pad;				// 176 - 180
+	float			fAngle;			// 180 - 184
+	CVector			vecPos;			// 184 - 196
+	DWORD			pad8[3];			// 196 - 208
+	BYTE			byteInvulnerable;	// 208 - 209
+	WORD			wActorID;			// 209 - 211
+};
+
+struct CActorPool
+{
+	int				iActorVirtualWorld[MAX_ACTORS];
+	BOOL			bValidActor[MAX_ACTORS];
+	CActor*			pActor[MAX_ACTORS];
+	DWORD			dwActorPoolSize;
+};
+
+struct CGameMode
+{
+	AMX				amx;
+	bool			bInitialised;
+	bool			bSleeping;
+	float			fSleepTime;
+};
+
+struct CFilterScripts
+{
+	AMX*			pFilterScripts[MAX_FILTER_SCRIPTS];
+	char			szFilterScriptName[MAX_FILTER_SCRIPTS][255];
+	int				iFilterScriptCount;
+};
+
+struct ScriptTimer_s // sizeof = 0x11B (283)
+{
+	char szScriptFunc[255];
+	int iTotalTime;
+	int iRemainingTime;
+	BOOL bRepeating;
+	BOOL bKilled;
+	AMX* pAMX;
+	int iParamCount;
+	void* cellParams;
+};
+
+typedef std::map<DWORD, ScriptTimer_s*> DwordTimerMap;
+
+class CScriptTimers
+{
+public:
+	DwordTimerMap			Timers;
+	DWORD					dwTimerCount;
+};
+
+struct CNetGame
+{
+	CGameMode				*pGameModePool;			// 0
+	CFilterScripts			*pFilterScriptPool;		// 4
+	CPlayerPool				*pPlayerPool;			// 8
+	CVehiclePool			*pVehiclePool;			// 12
+	CPickupPool				*pPickupPool;			// 16
+	CObjectPool				*pObjectPool;			// 20
+	CMenuPool				*pMenuPool;				// 24
+	CTextDrawPool			*pTextDrawPool;			// 28
+	C3DTextPool				*p3DTextPool;			// 32
+	CGangZonePool			*pGangZonePool;			// 36 
+	CActorPool				*pActorPool;			// 40 
+	int						iCurrentGameModeIndex;	// 44
+	int						iCurrentGameModeRepeat;	// 48
+	BOOL					bFirstGameModeLoaded;	// 52
+	BOOL					unkasdasd;				// 56
+	CScriptTimers			*pScriptTimers;			// 60
+	RakServer				*pRak;					// 64
+	DWORD					dwSomethingTick;
+	DWORD					dwUnk;
+	DWORD					dwUnk1;
+	BOOL					bLanMode;				// 
+	BOOL					bShowPlayerMarkers;		// 84
+	BYTE					byteShowNameTags;		// 
+	BYTE					bTirePopping;			// 
+	BYTE					byteAllowWeapons;		// 
+	BYTE					byteStuntBonus;			// 91 - 92
+	BYTE					byteDefaultCameraCollision; // 92 - 93
+	BYTE					byteWeather;			// 93 - 94
+	int						iGameState;				// 94 - 98
+	float					fGravity;				// 98 - 102
+	int						iDeathDropMoney;		// 102 - 106
+	BYTE					unklofasz;				// 106 - 107
+	BYTE					byteMode;				// 107 - 108
+	BYTE					bLimitGlobalChatRadius;	// 108 - 109
+	BYTE					bUseCJWalk;				// 109 - 110
+	float					fGlobalChatRadius;		// 110 - 114
+	float					fNameTagDrawDistance;	// 114 - 118
+	BYTE					byteDisableEnterExits;	// 118 - 119
+	BYTE					byteNameTagLOS;			// 119 - 120
+	BYTE					bManulVehicleEngineAndLights; // 120 - 121
+	BYTE					bLimitPlayerMarkers;	// 121 - 122
+	float					fPlayerMarkesLimit;		// 122 - 126 
+	BOOL					bVehicleFriendlyFire;	// 126 - 130
+#ifndef _WIN32
+	double					dElapsedTime;			// size = 8
+#endif
+	int						iSpawnsAvailable;		// 130 - 134
+	CPlayerSpawnInfo		AvailableSpawns[300];	// 129 - 13929
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+struct PlayerID
+{
+	unsigned int binaryAddress;
+	unsigned short port;
+};
+
+const PlayerID UNASSIGNED_PLAYER_ID =
+{
+	0xFFFFFFFF, 0xFFFF
+};
+
+/// All RPC functions have the same parameter list - this structure.
+struct RPCParameters
+{
+	/// The data from the remote system
+	unsigned char *input;
+
+	/// How many bits long \a input is
+	unsigned int numberOfBitsOfData;
+
+	/// Which system called this RPC
+	PlayerID sender;
+
+	/// Which instance of RakPeer (or a derived RakServer or RakClient) got this call
+	void *recipient;
+
+	/// You can return values from RPC calls by writing them to this BitStream.
+	/// This is only sent back if the RPC call originally passed a BitStream to receive the reply.
+	/// If you do so and your send is reliable, it will block until you get a reply or you get disconnected from the system you are sending to, whichever is first.
+	/// If your send is not reliable, it will block for triple the ping time, or until you are disconnected, or you get a reply, whichever is first.
+	RakNet::BitStream *replyToSender;
+};
+
+/// These enumerations are used to describe when packets are delivered.
+enum PacketPriority
+{
+	SYSTEM_PRIORITY,   /// \internal Used by RakNet to send above-high priority messages.
+	HIGH_PRIORITY,   /// High priority messages are send before medium priority messages.
+	MEDIUM_PRIORITY,   /// Medium priority messages are send before low priority messages.
+	LOW_PRIORITY,   /// Low priority messages are only sent when no other messages are waiting.
+	NUMBER_OF_PRIORITIES
+};
+
+/// These enumerations are used to describe how packets are delivered.
+/// \note  Note to self: I write this with 3 bits in the stream.  If I add more remember to change that
+enum PacketReliability
+{
+	UNRELIABLE = 6,   /// Same as regular UDP, except that it will also discard duplicate datagrams.  RakNet adds (6 to 17) + 21 bits of overhead, 16 of which is used to detect duplicate packets and 6 to 17 of which is used for message length.
+	UNRELIABLE_SEQUENCED,  /// Regular UDP with a sequence counter.  Out of order messages will be discarded.  This adds an additional 13 bits on top what is used for UNRELIABLE.
+	RELIABLE,   /// The message is sent reliably, but not necessarily in any order.  Same overhead as UNRELIABLE.
+	RELIABLE_ORDERED,   /// This message is reliable and will arrive in the order you sent it.  Messages will be delayed while waiting for out of order messages.  Same overhead as UNRELIABLE_SEQUENCED.
+	RELIABLE_SEQUENCED /// This message is reliable and will arrive in the sequence you sent it.  Out or order messages will be dropped.  Same overhead as UNRELIABLE_SEQUENCED.
+};
+
+/// \sa NetworkIDGenerator.h
+typedef unsigned char UniqueIDType;
+typedef unsigned short PlayerIndex;
+typedef unsigned char RPCIndex;
+const int MAX_RPC_MAP_SIZE=((RPCIndex)-1)-1;
+const int UNDEFINED_RPC_INDEX=((RPCIndex)-1);
+
+/// First byte of a network message
+typedef unsigned char MessageID;
+
+typedef unsigned int RakNetTime;
+typedef long long RakNetTimeNS;
+
+struct RakNetStatisticsStruct
+{
+	///  Number of Messages in the send Buffer (high, medium, low priority)
+	unsigned messageSendBuffer[ NUMBER_OF_PRIORITIES ];
+	///  Number of messages sent (high, medium, low priority)
+	unsigned messagesSent[ NUMBER_OF_PRIORITIES ];
+	///  Number of data bits used for user messages
+	unsigned messageDataBitsSent[ NUMBER_OF_PRIORITIES ];
+	///  Number of total bits used for user messages, including headers
+	unsigned messageTotalBitsSent[ NUMBER_OF_PRIORITIES ];
+	
+	///  Number of packets sent containing only acknowledgements
+	unsigned packetsContainingOnlyAcknowlegements;
+	///  Number of acknowledgements sent
+	unsigned acknowlegementsSent;
+	///  Number of acknowledgements waiting to be sent
+	unsigned acknowlegementsPending;
+	///  Number of acknowledgements bits sent
+	unsigned acknowlegementBitsSent;
+	
+	///  Number of packets containing only acknowledgements and resends
+	unsigned packetsContainingOnlyAcknowlegementsAndResends;
+	
+	///  Number of messages resent
+	unsigned messageResends;
+	///  Number of bits resent of actual data
+	unsigned messageDataBitsResent;
+	///  Total number of bits resent, including headers
+	unsigned messagesTotalBitsResent;
+	///  Number of messages waiting for ack (// TODO - rename this)
+	unsigned messagesOnResendQueue;
+	
+	///  Number of messages not split for sending
+	unsigned numberOfUnsplitMessages;
+	///  Number of messages split for sending
+	unsigned numberOfSplitMessages;
+	///  Total number of splits done for sending
+	unsigned totalSplits;
+	
+	///  Total packets sent
+	unsigned packetsSent;
+	
+	///  Number of bits added by encryption
+	unsigned encryptionBitsSent;
+	///  total bits sent
+	unsigned totalBitsSent;
+	
+	///  Number of sequenced messages arrived out of order
+	unsigned sequencedMessagesOutOfOrder;
+	///  Number of sequenced messages arrived in order
+	unsigned sequencedMessagesInOrder;
+	
+	///  Number of ordered messages arrived out of order
+	unsigned orderedMessagesOutOfOrder;
+	///  Number of ordered messages arrived in order
+	unsigned orderedMessagesInOrder;
+	
+	///  Packets with a good CRC received
+	unsigned packetsReceived;
+	///  Packets with a bad CRC received
+	unsigned packetsWithBadCRCReceived;
+	///  Bits with a good CRC received
+	unsigned bitsReceived;
+	///  Bits with a bad CRC received
+	unsigned bitsWithBadCRCReceived;
+	///  Number of acknowledgement messages received for packets we are resending
+	unsigned acknowlegementsReceived;
+	///  Number of acknowledgement messages received for packets we are not resending
+	unsigned duplicateAcknowlegementsReceived;
+	///  Number of data messages (anything other than an ack) received that are valid and not duplicate
+	unsigned messagesReceived;
+	///  Number of data messages (anything other than an ack) received that are invalid
+	unsigned invalidMessagesReceived;
+	///  Number of data messages (anything other than an ack) received that are duplicate
+	unsigned duplicateMessagesReceived;
+	///  Number of messages waiting for reassembly
+	unsigned messagesWaitingForReassembly;
+	///  Number of messages in reliability output queue
+	unsigned internalOutputQueueSize;
+	///  Current bits per second
+	double bitsPerSecond;
+	///  connection start time
+	RakNetTime connectionStartTime;
+};
+
+/// This represents a user message from another system.
+struct Packet
+{
+	/// Server only - this is the index into the player array that this playerId maps to
+	PlayerIndex playerIndex; // 0 - 2
+
+	/// The system that send this packet.
+	PlayerID playerId; // 2  - 8
+
+	/// The length of the data in bytes
+	/// \deprecated You should use bitSize.
+	unsigned int length; // 8 - 12
+
+	/// The length of the data in bits
+	unsigned int bitSize; // 12 - 16
+
+	/// The data from the sender
+	unsigned char* data; // 16 - 20
+
+	/// @internal
+	/// Indicates whether to delete the data, or to simply delete the packet.
+	bool deleteData;
+};
+
+#ifdef _WIN32
+class RakServer
+{
+public:
+	~RakServer(); // THIS NOT
+	virtual void _0();
+	virtual bool Start(unsigned short AllowedPlayers, unsigned int depreciated, int threadSleepTimer, unsigned short port, const char *forceHostAddress = 0) = 0; // 4
+	virtual void DisableSecurity( void ); // 8
+	virtual void SetPassword( const char *_password );	// 12
+	virtual bool HasPassword( void );	// 16 these two may be switched
+	virtual void Disconnect( unsigned int blockDuration, unsigned char orderingChannel=0 );	// 20
+	virtual bool Send_ASD(const char *data, const int length, int priority, int reliability, char orderingChannel, PlayerID playerId, bool broadcast); // 24
+	virtual bool Send(RakNet::BitStream* parameters, int priority, int reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast);	// 28
+	virtual void _20(); // 
+	virtual void _24();
+	virtual Packet* ReceiveEx( void );
+	virtual void Kick( const PlayerID playerId ); // 0x2C
+	virtual void DeallocatePacket(Packet* asd);
+	virtual void SetAllowedPlayers(unsigned short numberAllowed); // 0x34
+	virtual unsigned short GetAllowedPlayers( void ) const;
+	virtual unsigned short GetConnectedPlayers( void );
+	virtual void GetPlayerIPFromID( const PlayerID playerId, char returnValue[ 22 ], unsigned short *port );
+	virtual void PingPlayer( const PlayerID playerId );
+	virtual int GetAveragePing( const PlayerID playerId );
+	virtual int GetLastPing( const PlayerID playerId ); // 4C
+	virtual int GetLowestPing( const PlayerID playerId );
+	virtual void _54();
+	virtual void _58();
+	virtual void _5C();
+	virtual void _60();
+	virtual void _64();
+	virtual void _68();
+	virtual void _6C();
+	virtual void _70();
+	virtual void RegisterAsRemoteProcedureCall( int* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) );	// 74
+	virtual void RegisterClassMemberRPC( int* uniqueID, void *functionPointer );	// 78
+	virtual void UnregisterAsRemoteProcedureCall( int* uniqueID );	// 7C
+	virtual bool RPC(int* uniqueID, RakNet::BitStream* parameters, PacketPriority priority, PacketReliability reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp); // 80
+	virtual void _84();
+	virtual void _88();
+	virtual void _8C();
+	virtual void _90();
+	virtual void _94();
+	virtual void _98();
+	virtual void _9C();
+	virtual void _A0();
+	virtual void _A4();
+	virtual void _A8();
+	virtual void _AC();
+	virtual void _B0();
+	virtual void _B4();
+	virtual void _B8();
+	virtual void _BC();
+	virtual void _C0();
+	virtual void _C4();
+	virtual void _C8();
+	virtual void _CC();
+	virtual const char* GetLocalIP( unsigned int index ); // 208
+	virtual PlayerID GetInternalID( void ) const; // 212
+	virtual void PushBackPacket( Packet *packet, bool pushAtHead ); // 216
+	virtual void SetRouterInterface( void *routerInterface ); // 220
+	virtual void RemoveRouterInterface( void *routerInterface ); // 224
+	virtual int GetIndexFromPlayerID( PlayerID playerId ); // E4 - 228
+	virtual PlayerID GetPlayerIDFromIndex( int index ); // E8 - 232 - 236
+	virtual void UNKNOWN(void); // 236 - 240 ; possibly GetPlayerIPFromIndex(struct in_addr *, _DWORD)
+	virtual void AddToBanList( const char *IP, unsigned int milliseconds=0 ); // 240 - 244
+	virtual void RemoveFromBanList( const char *IP ); // 244
+	virtual void ClearBanList( void ); // 248
+	virtual bool _IsBanned( const char *IP ); // 252
+	virtual bool IsActivePlayerID( const PlayerID playerId ); // 256
+	virtual void SetTimeoutTime( RakNetTime timeMS, const PlayerID target ); // 260
+	virtual bool SetMTUSize( int size ); // 264
+	virtual int GetMTUSize( void ) const; // 268
+	virtual void AdvertiseSystem( const char *host, unsigned short remotePort, const char *data, int dataLength ); // 272
+	virtual RakNetStatisticsStruct * const GetStatistics( const PlayerID playerId ); // 276
+	virtual void ApplyNetworkSimulator( double maxSendBPS, unsigned short minExtraPing, unsigned short extraPingVariance); // 280
+};
+
+#else
+
+struct RakBanStruct
+{
+	char *IP;
+	unsigned int timeout;
+};
+
+struct RakBanList
+{
+	RakBanStruct* *listArray;
+	unsigned int list_size;
+	unsigned int allocation_size;
+};
+
+class RakServer
+{
+public:
+	~RakServer();
+	virtual bool _0(); 
+	virtual void _4();
+	virtual bool Start(unsigned short AllowedPlayers, unsigned int depreciated, int threadSleepTimer, unsigned short port, const char *forceHostAddress = 0) = 0;
+	virtual void _C();
+	virtual void _10();
+	virtual void _14();
+	virtual void _18();
+	virtual void _1C();
+	virtual bool SendGECI(RakNet::BitStream* parameters, int priority, int reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast);
+	virtual bool Send(RakNet::BitStream* parameters, int priority, int reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast);
+	virtual void _28();
+	virtual void _2C();
+	virtual void _30();
+	virtual void _34();
+	virtual void SetAllowedPlayers(unsigned short numberAllowed);
+	virtual void _3C();
+	virtual void _40();
+	virtual void _44();
+	virtual void _48();
+	virtual void _4C();
+	virtual int GetLastPing( const PlayerID playerId ); // 0x50
+	virtual void _54();
+	virtual void _58();
+	virtual void _5C();
+	virtual const char* GetLocalIP( unsigned int index );
+	virtual PlayerID GetInternalID( void ) const;
+	virtual void PushBackPacket( Packet *packet, bool pushAtHead );
+	virtual void SetRouterInterface( void *routerInterface );
+	virtual void RemoveRouterInterface( void *routerInterface );
+	virtual void UnregisterAsRemoteProcedureCall_BAD( int* uniqueID );
+	virtual void RegisterAsRemoteProcedureCall( int* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ); // 120
+	virtual void RegisterClassMemberRPC( int* uniqueID, void *functionPointer ); // 124
+	virtual void UnregisterAsRemoteProcedureCall( int* uniqueID ); // 128
+	virtual void UnregisterAsRemoteProcedureCall_4( int* uniqueID );
+	virtual void UnregisterAsRemoteProcedureCall_5( int* uniqueID );
+	virtual bool RPC(int* uniqueID, RakNet::BitStream* parameters, int priority, int reliability, unsigned orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp);
+	virtual void _90();
+	virtual void _94();
+	virtual void _98();
+	virtual void _9C();
+	virtual void _A0();
+	virtual void _A4();
+	virtual void _A8();
+	virtual void _AC();
+	virtual void _B0();
+	virtual void _B4();
+	virtual void _B8();
+	virtual void _BC();
+	virtual void _C0();
+	virtual void _C4();
+	virtual void _C8();
+	virtual void _CC();
+	virtual void _D0();
+	virtual void _D4();
+	virtual void _D8();
+	virtual void _DC();
+	virtual void _E0();
+	virtual void _E8();
+	virtual int GetIndexFromPlayerID( PlayerID playerId ); // EC
+	virtual PlayerID GetPlayerIDFromIndex( int index ); // F0 - 240 - 244
+	virtual void AddToBanList( const char *IP, unsigned int milliseconds=0 ); // 244 - 248
+	virtual void RemoveFromBanList( const char *IP ); // 248 - 252
+	virtual void ClearBanList( void ); // 252
+private:
+	virtual bool _IsBanned( const char *IP ); // 256
+public:
+	virtual bool IsActivePlayerID( const PlayerID playerId );
+	virtual void SetTimeoutTime( RakNetTime timeMS, const PlayerID target );
+	virtual bool SetMTUSize( int size );
+	virtual int GetMTUSize( void ) const;
+	virtual void AdvertiseSystem( const char *host, unsigned short remotePort, const char *data, int dataLength );
+	virtual RakNetStatisticsStruct * const GetStatistics( const PlayerID playerId );
+	virtual void ApplyNetworkSimulator( double maxSendBPS, unsigned short minExtraPing, unsigned short extraPingVariance);
+
+	RakBanList* GetBanList()
+	{
+		return reinterpret_cast<RakBanList*>(((char*)this)+4+929);
+	}
+};
+#endif
+
+#endif
diff --git a/src/Utils.cpp b/src/src/Utils.cpp
similarity index 97%
rename from src/Utils.cpp
rename to src/src/Utils.cpp
index d5ca315..c881691 100644
--- a/src/Utils.cpp
+++ b/src/src/Utils.cpp
@@ -9,6 +9,8 @@
   =========================================*/
 
 #include "main.h"
+#pragma comment( lib, "psapi.lib" )
+
 
 // Linux GetTickCount
 #ifndef _WIN32
@@ -347,7 +349,7 @@ DWORD FindPattern(char *pattern, char *mask)
 	size = (DWORD)info.SizeOfImage;
 #else
 	address = 0x804b480; // around the elf base
-	size = 0x8128B80 - address;
+	size = 0x8128B80 - address; // size of the elf base is too small, build more moonwells
 #endif
 	for(i = 0; i < size; ++i)
 	{
@@ -364,7 +366,7 @@ void InstallJump(unsigned long addr, void *func)
 	VirtualProtect((LPVOID)addr, 5, PAGE_EXECUTE_READWRITE, &dwOld);
 #else
 	int pagesize = sysconf(_SC_PAGE_SIZE);
-	void *unpraddr = (void *)(((int)addr + pagesize - 1) & ~(pagesize - 1)) - pagesize;
+	void *unpraddr = (void *)((((int)addr + pagesize - 1) & ~(pagesize - 1)) - pagesize);
 	mprotect(unpraddr, pagesize, PROT_WRITE);
 #endif
 	*(unsigned char *)addr = 0xE9;
diff --git a/src/Utils.h b/src/src/Utils.h
similarity index 100%
rename from src/Utils.h
rename to src/src/Utils.h
diff --git a/src/amxfunctions.cpp b/src/src/amxfunctions.cpp
similarity index 100%
rename from src/amxfunctions.cpp
rename to src/src/amxfunctions.cpp
diff --git a/src/amxfunctions.h b/src/src/amxfunctions.h
similarity index 100%
rename from src/amxfunctions.h
rename to src/src/amxfunctions.h
diff --git a/src/main.cpp b/src/src/main.cpp
similarity index 95%
rename from src/main.cpp
rename to src/src/main.cpp
index ad9b59f..66064f8 100644
--- a/src/main.cpp
+++ b/src/src/main.cpp
@@ -1,211 +1,212 @@
-//----------------------------------------------------------
-//
-//   SA:MP Multiplayer Modification For GTA:SA
-//   Copyright 2004-2007 SA:MP Team
-//
-//----------------------------------------------------------
-
-#include "main.h"
-
-//----------------------------------------------------------
-
-void **ppPluginData;
-extern void *pAMXFunctions;
-
-// Server instance
-CServer *pServer = NULL;
-
-// Internal server pointers
-CNetGame *pNetGame = NULL;
-void *pConsole = NULL;
-RakServer *pRakServer = NULL;
-CPlayerData *pPlayerData[MAX_PLAYERS];
-
-//----------------------------------------------------------
-// The Support() function indicates what possibilities this
-// plugin has. The SUPPORTS_VERSION flag is required to check
-// for compatibility with the server. 
-
-PLUGIN_EXPORT unsigned int PLUGIN_CALL Supports() 
-{
-	return sampgdk_Supports() | SUPPORTS_VERSION | SUPPORTS_AMX_NATIVES | SUPPORTS_PROCESS_TICK;
-}
-
-//----------------------------------------------------------
-// The Load() function gets passed on exported functions from
-// the SA-MP Server, like the AMX Functions and logprintf().
-// Should return true if loading the plugin has succeeded.
-//typedef void(*logprintf_t)(char* format, ...);
-//logprintf_t logprintf;
-
-PLUGIN_EXPORT bool PLUGIN_CALL Load(void ** ppData)
-{
-	ppPluginData = ppData;
-	pAMXFunctions = ppData[PLUGIN_DATA_AMX_EXPORTS];
-	//logprintf = (logprintf_t);
-
-	bool ret = sampgdk_Load(ppData);
-	logprintf("logprintf = 0x%08X\n", ppData[PLUGIN_DATA_LOGPRINTF]);
-	
+//----------------------------------------------------------
+//
+//   SA:MP Multiplayer Modification For GTA:SA
+//   Copyright 2004-2007 SA:MP Team
+//
+//----------------------------------------------------------
+
+#include "main.h"
+
+//----------------------------------------------------------
+
+void **ppPluginData;
+extern void *pAMXFunctions;
+
+// Server instance
+CServer *pServer = NULL;
+
+// Internal server pointers
+CNetGame *pNetGame = NULL;
+void *pConsole = NULL;
+RakServer *pRakServer = NULL;
+CPlayerData *pPlayerData[MAX_PLAYERS];
+
+//----------------------------------------------------------
+// The Support() function indicates what possibilities this
+// plugin has. The SUPPORTS_VERSION flag is required to check
+// for compatibility with the server. 
+
+PLUGIN_EXPORT unsigned int PLUGIN_CALL Supports() 
+{
+	return sampgdk_Supports() | SUPPORTS_VERSION | SUPPORTS_AMX_NATIVES | SUPPORTS_PROCESS_TICK;
+}
+
+//----------------------------------------------------------
+// The Load() function gets passed on exported functions from
+// the SA-MP Server, like the AMX Functions and logprintf().
+// Should return true if loading the plugin has succeeded.
+//typedef void(*logprintf_t)(char* format, ...);
+//logprintf_t logprintf;
+
+PLUGIN_EXPORT bool PLUGIN_CALL Load(void ** ppData)
+{
+	ppPluginData = ppData;
+	pAMXFunctions = ppData[PLUGIN_DATA_AMX_EXPORTS];
+	//logprintf = (logprintf_t);
+
+	bool ret = sampgdk_Load(ppData);
+	logprintf("logprintf = 0x%08X\n", ppData[PLUGIN_DATA_LOGPRINTF]);
+	
 	//logprintf("offset: killer: %d", _OFFSET(CVehicle, wKillerID));
-
-	// 10473
-//	logprintf("object drawdistance offset: %d", _OFFSET2(RakServer, Send));
-
-#ifndef _WIN32
-	LoadTickCount();
-#endif	
-	// Check server version
-	eSAMPVersion version = SAMP_VERSION_UNKNOWN;
-	char szVersion[64];
-
-	DWORD addr = (DWORD)ppData[PLUGIN_DATA_LOGPRINTF];
-	if(addr == CAddress::FUNC_Logprintf_037_R2_1)
-	{
-		version = SAMP_VERSION_037_R2;
-		strcpy(szVersion, "0.3.7 R2-1");
-	}
-
-	if (version != SAMP_VERSION_UNKNOWN)
-	{
-		// Create server instance
-		pServer = new CServer(version);
-	}
-	else
-	{
-		logprintf("Error: Unknown " OS_NAME " server version\n");
-		return true;
-	}
-
-	InstallPreHooks();
-
-	logprintf("\n");
-	logprintf(" ===============================\n");
-	logprintf("        " PROJECT_NAME " - kurta999 version " PROJECT_VERSION " loaded\n");
-	logprintf("   (c) 2008 Alex \"Y_Less\" Cole - (c) 2010 - 2015 kurta999\n");
-	logprintf("    Server version: %s\n", szVersion);
-	logprintf("    Operating System: " OS_NAME "\n");
-	logprintf("    Built on: " __DATE__ " at " __TIME__ "\n");
-	logprintf(" ===============================\n");
-	return ret;
-}
-
-//----------------------------------------------------------
-// The Unload() function is called when the server shuts down,
-// meaning this plugin gets shut down with it.
-
-PLUGIN_EXPORT void PLUGIN_CALL Unload()
-{
-	// Corrected apperance in log file
-	logprintf("\n");
-	logprintf(" ==============\n");
-	logprintf("  %s unloaded\n", PROJECT_NAME);
-	logprintf(" ==============");
-
-#ifdef NEW_PICKUP_SYSTEM
-	delete pNetGame->pPickupPool;
-	pNetGame->pPickupPool = NULL;
-#endif
-	UninstallHooks();
-	SAFE_DELETE(pServer);
-	sampgdk_Unload();
-}
-
-//----------------------------------------------------------
-// The AmxLoad() function gets called when a new gamemode or
-// filterscript gets loaded with the server. In here we register
-// the native functions we like to add to the scripts.
-
-PLUGIN_EXPORT int PLUGIN_CALL AmxLoad(AMX * amx) 
-{
-	CCallbackManager::RegisterAMX(amx);
-	
-	if(pServer)
-	{
-		static bool bFirst = false;
-		if(!bFirst)
-		{
-			bFirst = true;
-			InstallPostHooks();
-		}
-	}
-	return InitScripting(amx);
-}
-
-//----------------------------------------------------------
-// When a gamemode is over or a filterscript gets unloaded, this
-// function gets called. No special actions needed in here.
-
-PLUGIN_EXPORT int PLUGIN_CALL AmxUnload(AMX * amx) 
-{
-	// Remove AMX instance from our amxlist
-	CCallbackManager::UnregisterAMX(amx);
-	return AMX_ERR_NONE;
-}
-
-PLUGIN_EXPORT void PLUGIN_CALL ProcessTick()
-{
-	if(pServer)
-	{
-		pServer->Process();
-	}
-}
-
-//----------------------------------------------------------
-// SAMP GDK callbacks
-PLUGIN_EXPORT bool PLUGIN_CALL OnPlayerConnect(int playerid)
-{
-	if(!pServer)
-		return true;
-
-	if (playerid >= 0 && playerid < MAX_PLAYERS)
-	{
-#ifndef NEW_PICKUP_SYSTEM
-		pServer->AddPlayer(playerid);
-#else
-		// Initialize pickups
-		if (pServer->AddPlayer(playerid))
-			pServer->pPickupPool->InitializeForPlayer(playerid);
-#endif
-	}
-	return true;
-}
-
-PLUGIN_EXPORT bool PLUGIN_CALL OnPlayerDisconnect(int playerid, int reason)
-{
-	if(!pServer)
-		return true;
-
-	pServer->RemovePlayer(playerid);
-	return true;
-}
-
-PLUGIN_EXPORT bool PLUGIN_CALL OnPlayerStreamIn(int playerid, int forplayerid)
-{
-	if(!pServer)
-		return true;
-
-	pServer->OnPlayerStreamIn(static_cast<WORD>(playerid), static_cast<WORD>(forplayerid));
-	return true;
-}
-
-PLUGIN_EXPORT bool PLUGIN_CALL OnPlayerStreamOut(int playerid, int forplayerid)
-{
-	if(!pServer)
-		return true;
-
-	pServer->OnPlayerStreamOut(static_cast<WORD>(playerid), static_cast<WORD>(forplayerid));
-	return true;
-}
-
-PLUGIN_EXPORT bool PLUGIN_CALL OnPlayerSpawn(int playerid)
-{
-	if(!pServer)
-		return true;
-
-	if (IsPlayerConnectedEx(playerid))
-	{
-		pPlayerData[playerid]->bControllable = true;
-	}
-	return true;
+
+	// 10473
+//	logprintf("object drawdistance offset: %d", _OFFSET2(RakServer, Send));
+
+#ifndef _WIN32
+	LoadTickCount();
+#endif	
+	// Check server version
+	eSAMPVersion version = SAMP_VERSION_UNKNOWN;
+	char szVersion[64];
+
+	DWORD addr = (DWORD)ppData[PLUGIN_DATA_LOGPRINTF];
+	if(addr == CAddress::FUNC_Logprintf_037_R2_1)
+	{
+		version = SAMP_VERSION_037_R2;
+		strcpy(szVersion, "0.3.7 R2-1");
+	}
+
+	if (version != SAMP_VERSION_UNKNOWN)
+	{
+		// Create server instance
+		pServer = new CServer(version);
+	}
+	else
+	{
+		logprintf("Error: Unknown " OS_NAME " server version\n");
+		return true;
+	}
+
+	InstallPreHooks();
+
+	logprintf("\n");
+	logprintf(" ===============================\n");
+	logprintf("        " PROJECT_NAME " - kurta999 version " PROJECT_VERSION " loaded\n");
+	logprintf("   (c) 2008 Alex \"Y_Less\" Cole - (c) 2010 - 2016 kurta999\n");
+	logprintf("    2016 fork by IllidanS4\n");
+	logprintf("    Server version: %s\n", szVersion);
+	logprintf("    Operating System: " OS_NAME "\n");
+	logprintf("    Built on: " __DATE__ " at " __TIME__ "\n");
+	logprintf(" ===============================\n");
+	return ret;
+}
+
+//----------------------------------------------------------
+// The Unload() function is called when the server shuts down,
+// meaning this plugin gets shut down with it.
+
+PLUGIN_EXPORT void PLUGIN_CALL Unload()
+{
+	// Corrected apperance in log file
+	logprintf("\n");
+	logprintf(" ==============\n");
+	logprintf("  %s unloaded\n", PROJECT_NAME);
+	logprintf(" ==============");
+
+#ifdef NEW_PICKUP_SYSTEM
+	delete pNetGame->pPickupPool;
+	pNetGame->pPickupPool = NULL;
+#endif
+	UninstallHooks();
+	SAFE_DELETE(pServer);
+	sampgdk_Unload();
+}
+
+//----------------------------------------------------------
+// The AmxLoad() function gets called when a new gamemode or
+// filterscript gets loaded with the server. In here we register
+// the native functions we like to add to the scripts.
+
+PLUGIN_EXPORT int PLUGIN_CALL AmxLoad(AMX * amx) 
+{
+	CCallbackManager::RegisterAMX(amx);
+	
+	if(pServer)
+	{
+		static bool bFirst = false;
+		if(!bFirst)
+		{
+			bFirst = true;
+			InstallPostHooks();
+		}
+	}
+	return InitScripting(amx);
+}
+
+//----------------------------------------------------------
+// When a gamemode is over or a filterscript gets unloaded, this
+// function gets called. No special actions needed in here.
+
+PLUGIN_EXPORT int PLUGIN_CALL AmxUnload(AMX * amx) 
+{
+	// Remove AMX instance from our amxlist
+	CCallbackManager::UnregisterAMX(amx);
+	return AMX_ERR_NONE;
+}
+
+PLUGIN_EXPORT void PLUGIN_CALL ProcessTick()
+{
+	if(pServer)
+	{
+		pServer->Process();
+	}
+}
+
+//----------------------------------------------------------
+// SAMP GDK callbacks
+PLUGIN_EXPORT bool PLUGIN_CALL OnPlayerConnect(int playerid)
+{
+	if(!pServer)
+		return true;
+
+	if (playerid >= 0 && playerid < MAX_PLAYERS)
+	{
+#ifndef NEW_PICKUP_SYSTEM
+		pServer->AddPlayer(playerid);
+#else
+		// Initialize pickups
+		if (pServer->AddPlayer(playerid))
+			pServer->pPickupPool->InitializeForPlayer(playerid);
+#endif
+	}
+	return true;
+}
+
+PLUGIN_EXPORT bool PLUGIN_CALL OnPlayerDisconnect(int playerid, int reason)
+{
+	if(!pServer)
+		return true;
+
+	pServer->RemovePlayer(playerid);
+	return true;
+}
+
+PLUGIN_EXPORT bool PLUGIN_CALL OnPlayerStreamIn(int playerid, int forplayerid)
+{
+	if(!pServer)
+		return true;
+
+	pServer->OnPlayerStreamIn(static_cast<WORD>(playerid), static_cast<WORD>(forplayerid));
+	return true;
+}
+
+PLUGIN_EXPORT bool PLUGIN_CALL OnPlayerStreamOut(int playerid, int forplayerid)
+{
+	if(!pServer)
+		return true;
+
+	pServer->OnPlayerStreamOut(static_cast<WORD>(playerid), static_cast<WORD>(forplayerid));
+	return true;
+}
+
+PLUGIN_EXPORT bool PLUGIN_CALL OnPlayerSpawn(int playerid)
+{
+	if(!pServer)
+		return true;
+
+	if (IsPlayerConnectedEx(playerid))
+	{
+		pPlayerData[playerid]->bControllable = true;
+	}
+	return true;
 }
\ No newline at end of file
diff --git a/src/main.h b/src/src/main.h
similarity index 82%
rename from src/main.h
rename to src/src/main.h
index 051b3ae..a4088fa 100644
--- a/src/main.h
+++ b/src/src/main.h
@@ -7,6 +7,7 @@
 #pragma warning(disable: 4995)
 
 //#define NEW_PICKUP_SYSTEM
+//#define CUSTOM_BANLIST
 
 #define PI 3.14159265
 
@@ -25,7 +26,7 @@
 // ------------
 
 #define PROJECT_NAME		"YSF"
-#define PROJECT_VERSION		"R16"
+#define PROJECT_VERSION		"2.2.0"
 
 // ------------
 // OS SPECIFICS
@@ -112,6 +113,16 @@
 // SAMP GDK
 #include <sampgdk/sampgdk.h>
 using sampgdk::logprintf;
+
+#undef amx_ftoc
+#undef amx_ctof
+#if PAWN_CELL_SIZE==32
+  #define amx_ftoc(f)   ( * reinterpret_cast<const cell*>(&static_cast<const float&>(f)) )   /* float to cell */
+  #define amx_ctof(c)   ( * reinterpret_cast<const float*>(&static_cast<const cell&>(c)) )  /* cell to float */
+#elif PAWN_CELL_SIZE==64
+  #define amx_ftoc(f)   ( * reinterpret_cast<const cell*>(&static_cast<const double&>(f)) )   /* float to cell */
+  #define amx_ctof(c)   ( * reinterpret_cast<const double*>(&static_cast<const cell&>(c)) )  /* cell to float */
+#endif
 	
 // Subhook
 #include <subhook/subhook.h>