Upload 8 files

bitstream_io.lua

@@ -0,0 +1,267 @@
+-- This file is part of the SAMP.Lua project.
+-- Licensed under the MIT License.
+-- Copyright (c) 2016, FYP @ BlastHack Team <blast.hk>
+-- https://github.com/THE-FYP/SAMP.Lua
+
+local mod = {}
+local vector3d = require 'vector3d'
+local ffi = require 'ffi'
+
+local function bitstream_read_fixed_string(bs, size)
+	local buf = ffi.new('uint8_t[?]', size + 1)
+	raknetBitStreamReadBuffer(bs, tonumber(ffi.cast('intptr_t', buf)), size)
+	buf[size] = 0
+	-- Length is not specified to throw off trailing zeros.
+	return ffi.string(buf)
+end
+
+local function bitstream_write_fixed_string(bs, str, size)
+	local buf = ffi.new('uint8_t[?]', size, string.sub(str, 1, size))
+	raknetBitStreamWriteBuffer(bs, tonumber(ffi.cast('intptr_t', buf)), size)
+end
+
+mod.bool = {
+	read = function(bs) return raknetBitStreamReadBool(bs) end,
+	write = function(bs, value) return raknetBitStreamWriteBool(bs, value) end
+}
+
+mod.uint8 = {
+	read = function(bs) return raknetBitStreamReadInt8(bs) end,
+	write = function(bs, value) return raknetBitStreamWriteInt8(bs, value) end
+}
+
+mod.uint16 = {
+	read = function(bs) return raknetBitStreamReadInt16(bs) end,
+	write = function(bs, value) return raknetBitStreamWriteInt16(bs, value) end
+}
+
+mod.uint32 = {
+	read = function(bs)
+		local v = raknetBitStreamReadInt32(bs)
+		return v < 0 and 0x100000000 + v or v
+	end,
+	write = function(bs, value)
+		return raknetBitStreamWriteInt32(bs, value)
+	end
+}
+
+mod.int8 = {
+	read = function(bs)
+		local v = raknetBitStreamReadInt8(bs)
+		return v >= 0x80 and v - 0x100 or v
+	end,
+	write = function(bs, value)
+		return raknetBitStreamWriteInt8(bs, value)
+	end
+}
+
+mod.int16 = {
+	read = function(bs)
+		local v = raknetBitStreamReadInt16(bs)
+		return v >= 0x8000 and v - 0x10000 or v
+	end,
+	write = function(bs, value)
+		return raknetBitStreamWriteInt16(bs, value)
+	end
+}
+
+mod.int32 = {
+	read = function(bs) return raknetBitStreamReadInt32(bs) end,
+	write = function(bs, value) return raknetBitStreamWriteInt32(bs, value) end
+}
+
+mod.float = {
+	read = function(bs) return raknetBitStreamReadFloat(bs) end,
+	write = function(bs, value) return raknetBitStreamWriteFloat(bs, value) end
+}
+
+mod.string8 = {
+	read = function(bs)
+		local len = raknetBitStreamReadInt8(bs)
+		if len <= 0 then return '' end
+		return raknetBitStreamReadString(bs, len)
+	end,
+	write = function(bs, value)
+		raknetBitStreamWriteInt8(bs, #value)
+		raknetBitStreamWriteString(bs, value)
+	end
+}
+
+mod.string16 = {
+	read = function(bs)
+		local len = raknetBitStreamReadInt16(bs)
+		if len <= 0 then return '' end
+		return raknetBitStreamReadString(bs, len)
+	end,
+	write = function(bs, value)
+		raknetBitStreamWriteInt16(bs, #value)
+		raknetBitStreamWriteString(bs, value)
+	end
+}
+
+mod.string32 = {
+	read = function(bs)
+		local len = raknetBitStreamReadInt32(bs)
+		if len <= 0 then return '' end
+		return raknetBitStreamReadString(bs, len)
+	end,
+	write = function(bs, value)
+		raknetBitStreamWriteInt32(bs, #value)
+		raknetBitStreamWriteString(bs, value)
+	end
+}
+
+mod.bool8 = {
+	read = function(bs)
+		return raknetBitStreamReadInt8(bs) ~= 0
+	end,
+	write = function(bs, value)
+		raknetBitStreamWriteInt8(bs, value == true and 1 or 0)
+	end
+}
+
+mod.bool32 = {
+	read = function(bs)
+		return raknetBitStreamReadInt32(bs) ~= 0
+	end,
+	write = function(bs, value)
+		raknetBitStreamWriteInt32(bs, value == true and 1 or 0)
+	end
+}
+
+mod.int1 = {
+	read = function(bs)
+		if raknetBitStreamReadBool(bs) == true then return 1 else return 0 end
+	end,
+	write = function(bs, value)
+		raknetBitStreamWriteBool(bs, value ~= 0 and true or false)
+	end
+}
+
+mod.fixedString32 = {
+	read = function(bs)
+		return bitstream_read_fixed_string(bs, 32)
+	end,
+	write = function(bs, value)
+		bitstream_write_fixed_string(bs, value, 32)
+	end
+}
+
+mod.string256 = mod.fixedString32
+
+mod.encodedString2048 = {
+	read = function(bs) return raknetBitStreamDecodeString(bs, 2048) end,
+	write = function(bs, value) raknetBitStreamEncodeString(bs, value) end
+}
+
+mod.encodedString4096 = {
+	read = function(bs) return raknetBitStreamDecodeString(bs, 4096) end,
+	write = function(bs, value) raknetBitStreamEncodeString(bs, value) end
+}
+
+mod.compressedFloat = {
+	read = function(bs)
+		return raknetBitStreamReadInt16(bs) / 32767.5 - 1
+	end,
+	write = function(bs, value)
+		if value < -1 then
+			value = -1
+		elseif value > 1 then
+			value = 1
+		end
+		raknetBitStreamWriteInt16(bs, (value + 1) * 32767.5)
+	end
+}
+
+mod.compressedVector = {
+	read = function(bs)
+		local magnitude = raknetBitStreamReadFloat(bs)
+		if magnitude ~= 0 then
+			local readCf = mod.compressedFloat.read
+			return vector3d(readCf(bs) * magnitude, readCf(bs) * magnitude, readCf(bs) * magnitude)
+		else
+			return vector3d(0, 0, 0)
+		end
+	end,
+	write = function(bs, data)
+		local x, y, z = data.x, data.y, data.z
+		local magnitude = math.sqrt(x * x + y * y + z * z)
+		raknetBitStreamWriteFloat(bs, magnitude)
+		if magnitude > 0 then
+			local writeCf = mod.compressedFloat.write
+			writeCf(bs, x / magnitude)
+			writeCf(bs, y / magnitude)
+			writeCf(bs, z / magnitude)
+		end
+	end
+}
+
+mod.normQuat = {
+	read = function(bs)
+		local readBool, readShort = raknetBitStreamReadBool, raknetBitStreamReadInt16
+		local cwNeg, cxNeg, cyNeg, czNeg = readBool(bs), readBool(bs), readBool(bs), readBool(bs)
+		local cx, cy, cz = readShort(bs), readShort(bs), readShort(bs)
+		local x = cx / 65535
+		local y = cy / 65535
+		local z = cz / 65535
+		if cxNeg then x = -x end
+		if cyNeg then y = -y end
+		if czNeg then z = -z end
+		local diff = 1 - x * x - y * y - z * z
+		if diff < 0 then diff = 0 end
+		local w = math.sqrt(diff)
+		if cwNeg then w = -w end
+		return {w, x, y, z}
+	end,
+	write = function(bs, value)
+		local w, x, y, z = value[1], value[2], value[3], value[4]
+		raknetBitStreamWriteBool(bs, w < 0)
+		raknetBitStreamWriteBool(bs, x < 0)
+		raknetBitStreamWriteBool(bs, y < 0)
+		raknetBitStreamWriteBool(bs, z < 0)
+		raknetBitStreamWriteInt16(bs, math.abs(x) * 65535)
+		raknetBitStreamWriteInt16(bs, math.abs(y) * 65535)
+		raknetBitStreamWriteInt16(bs, math.abs(z) * 65535)
+		-- w is calculated on the target
+	end
+}
+
+mod.vector3d = {
+	read = function(bs)
+		local x, y, z =
+			raknetBitStreamReadFloat(bs),
+			raknetBitStreamReadFloat(bs),
+			raknetBitStreamReadFloat(bs)
+		return vector3d(x, y, z)
+	end,
+	write = function(bs, value)
+		raknetBitStreamWriteFloat(bs, value.x)
+		raknetBitStreamWriteFloat(bs, value.y)
+		raknetBitStreamWriteFloat(bs, value.z)
+	end
+}
+
+mod.vector2d = {
+	read = function(bs)
+		local x = raknetBitStreamReadFloat(bs)
+		local y = raknetBitStreamReadFloat(bs)
+		return {x = x, y = y}
+	end,
+	write = function(bs, value)
+		raknetBitStreamWriteFloat(bs, value.x)
+		raknetBitStreamWriteFloat(bs, value.y)
+	end
+}
+
+local function bitstream_io_interface(field)
+	return setmetatable({}, {
+		__index = function(t, index)
+			return mod[index][field]
+		end
+	})
+end
+
+mod.bs_read = bitstream_io_interface('read')
+mod.bs_write = bitstream_io_interface('write')
+
+return mod

core.lua

@@ -0,0 +1,141 @@
+-- This file is part of the SAMP.Lua project.
+-- Licensed under the MIT License.
+-- Copyright (c) 2016, FYP @ BlastHack Team <blast.hk>
+-- https://github.com/THE-FYP/SAMP.Lua
+
+local MODULE = {
+	MODULEINFO = {
+		name = 'samp.events',
+		version = 4
+	},
+	INTERFACE = {
+		OUTCOMING_RPCS    = {},
+		OUTCOMING_PACKETS = {},
+		INCOMING_RPCS     = {},
+		INCOMING_PACKETS  = {}
+	},
+	EXPORTS = {}
+}
+
+-- check dependencies
+assert(isSampLoaded(), 'SA-MP is not loaded')
+assert(isSampfuncsLoaded(), 'samp.events requires SAMPFUNCS')
+assert(getMoonloaderVersion() >= 20, 'samp.events requires MoonLoader v.020 or greater')
+
+local BitStreamIO            = require 'samp.events.bitstream_io'
+MODULE.INTERFACE.BitStreamIO = BitStreamIO
+
+
+local function read_data(bs, dataType)
+	if type(dataType) ~= 'table' then
+		return BitStreamIO[dataType].read(bs)
+	else -- process nested structures
+		local values = {}
+		for _, it in ipairs(dataType) do
+			local name, t = next(it)
+			values[name] = read_data(bs, t)
+		end
+		return values
+	end
+end
+
+local function write_data(bs, dataType, value)
+	if type(dataType) ~= 'table' then
+		BitStreamIO[dataType].write(bs, value)
+	else -- process nested structures
+		for _, it in ipairs(dataType) do
+			local name, t = next(it)
+			write_data(bs, t, value[name])
+		end
+	end
+end
+
+local function process_event(bs, callback, struct, ignorebits)
+	local args = {}
+	if bs ~= 0 then
+		if ignorebits then
+			raknetBitStreamIgnoreBits(bs, ignorebits)
+		end
+		if type(struct[2]) == 'function' then
+			local r1, r2 = struct[2](bs) -- call custom reading function
+			if type(callback) == 'table' and type(r1) == 'string' then
+				callback = callback[r1]
+				if callback then
+					args = r2
+				else
+					return
+				end
+			else
+				args = r1
+			end
+		else
+			-- skip event name
+			for i = 2, #struct do
+				local _, t = next(struct[i]) -- type
+				table.insert(args, read_data(bs, t))
+			end
+		end
+	end
+	local result = callback(unpack(args))
+	if result == false then
+		return false -- consume packet
+	end
+	if bs ~= 0 and type(result) == 'table' then
+		raknetBitStreamSetWriteOffset(bs, ignorebits or 0)
+		if type(struct[3]) == 'function' then
+			struct[3](bs, result) -- call custom writing function
+		else
+			assert(#struct - 1 == #result)
+			for i = 2, #struct do
+				local _, t = next(struct[i]) -- type
+				write_data(bs, t, result[i - 1])
+			end
+		end
+	end
+end
+
+local function process_packet(id, bs, event_table, ignorebits)
+	local entry = event_table[id]
+	if entry ~= nil then
+		local key = entry[1]
+		local callback = nil
+		if type(key) == 'table' then
+			for i, name in ipairs(key) do
+				if type(MODULE[name]) == 'function' then
+					if not callback then callback = {} end
+					callback[name] = MODULE[name]
+				end
+			end
+		elseif type(MODULE[key]) == 'function' then
+			callback = MODULE[key]
+		end
+		if callback then
+			return process_event(bs, callback, entry, ignorebits)
+		end
+	end
+end
+
+
+local interface = MODULE.INTERFACE
+local function samp_on_send_rpc(id, bitStream, priority, reliability, orderingChannel, shiftTs)
+	return process_packet(id, bitStream, interface.OUTCOMING_RPCS)
+end
+
+local function samp_on_send_packet(id, bitStream, priority, reliability, orderingChannel)
+	return process_packet(id, bitStream, interface.OUTCOMING_PACKETS, 8)
+end
+
+local function samp_on_receive_rpc(id, bitStream)
+	return process_packet(id, bitStream, interface.INCOMING_RPCS)
+end
+
+local function samp_on_receive_packet(id, bitStream)
+	return process_packet(id, bitStream, interface.INCOMING_PACKETS, 8)
+end
+
+addEventHandler('onSendRpc', samp_on_send_rpc)
+addEventHandler('onSendPacket', samp_on_send_packet)
+addEventHandler('onReceiveRpc', samp_on_receive_rpc)
+addEventHandler('onReceivePacket', samp_on_receive_packet)
+
+return MODULE

events.lua

@@ -0,0 +1,293 @@
+-- This file is part of the SAMP.Lua project.
+-- Licensed under the MIT License.
+-- Copyright (c) 2016, FYP @ BlastHack Team <blast.hk>
+-- https://github.com/THE-FYP/SAMP.Lua
+
+local raknet                                  = require 'samp.raknet'
+local events                                  = require 'samp.events.core'
+local utils                                   = require 'samp.events.utils'
+local handler                                 = require 'samp.events.handlers'
+                                                require 'samp.events.extra_types'
+local RPC                                     = raknet.RPC
+local PACKET                                  = raknet.PACKET
+local OUTCOMING_RPCS                          = events.INTERFACE.OUTCOMING_RPCS
+local OUTCOMING_PACKETS                       = events.INTERFACE.OUTCOMING_PACKETS
+local INCOMING_RPCS                           = events.INTERFACE.INCOMING_RPCS
+local INCOMING_PACKETS                        = events.INTERFACE.INCOMING_PACKETS
+
+-- Outgoing rpcs
+OUTCOMING_RPCS[RPC.ENTERVEHICLE]              = {'onSendEnterVehicle', {vehicleId = 'uint16'}, {passenger = 'bool8'}}
+OUTCOMING_RPCS[RPC.CLICKPLAYER]               = {'onSendClickPlayer', {playerId = 'uint16'}, {source = 'uint8'}}
+OUTCOMING_RPCS[RPC.CLIENTJOIN]                = {'onSendClientJoin', {version = 'int32'}, {mod = 'uint8'}, {nickname = 'string8'}, {challengeResponse = 'int32'}, {joinAuthKey = 'string8'}, {clientVer = 'string8'}, {challengeResponse2 = 'int32'}}
+--OUTCOMING_RPCS[RPC.SELECTOBJECT]              = {'onSendSelectObject', {type = 'int32'}, {objectId = 'uint16'}, {model = 'int32'}, {position = 'vector3d'}}
+OUTCOMING_RPCS[RPC.SELECTOBJECT]              = {'onSendEnterEditObject', {type = 'int32'}, {objectId = 'uint16'}, {model = 'int32'}, {position = 'vector3d'}}
+OUTCOMING_RPCS[RPC.SERVERCOMMAND]             = {'onSendCommand', {command = 'string32'}}
+OUTCOMING_RPCS[RPC.SPAWN]                     = {'onSendSpawn'}
+OUTCOMING_RPCS[RPC.DEATH]                     = {'onSendDeathNotification', {reason = 'uint8'}, {killerId = 'uint16'}}
+OUTCOMING_RPCS[RPC.DIALOGRESPONSE]            = {'onSendDialogResponse', {dialogId = 'uint16'}, {button = 'uint8'}, {listboxId = 'uint16'}, {input = 'string8'}}
+OUTCOMING_RPCS[RPC.CLICKTEXTDRAW]             = {'onSendClickTextDraw', {textdrawId = 'uint16'}}
+OUTCOMING_RPCS[RPC.SCMEVENT]                  = {'onSendVehicleTuningNotification', {vehicleId = 'int32'}, {param1 = 'int32'}, {param2 = 'int32'}, {event = 'int32'}}
+OUTCOMING_RPCS[RPC.CHAT]                      = {'onSendChat', {message = 'string8'}}
+OUTCOMING_RPCS[RPC.CLIENTCHECK]               = {'onSendClientCheckResponse', {requestType = 'uint8'}, {result1 = 'int32'}, {result2 = 'uint8'}}
+OUTCOMING_RPCS[RPC.DAMAGEVEHICLE]             = {'onSendVehicleDamaged', {vehicleId = 'uint16'}, {panelDmg = 'int32'}, {doorDmg = 'int32'}, {lights = 'uint8'}, {tires = 'uint8'}}
+OUTCOMING_RPCS[RPC.EDITATTACHEDOBJECT]        = {'onSendEditAttachedObject', {response = 'int32'}, {index = 'int32'}, {model = 'int32'}, {bone = 'int32'}, {position = 'vector3d'}, {rotation = 'vector3d'}, {scale = 'vector3d'}, {color1 = 'int32'}, {color2 = 'int32'}}
+OUTCOMING_RPCS[RPC.EDITOBJECT]                = {'onSendEditObject', {playerObject = 'bool'}, {objectId = 'uint16'}, {response = 'int32'}, {position = 'vector3d'}, {rotation = 'vector3d'}}
+OUTCOMING_RPCS[RPC.SETINTERIORID]             = {'onSendInteriorChangeNotification', {interior = 'uint8'}}
+OUTCOMING_RPCS[RPC.MAPMARKER]                 = {'onSendMapMarker', {position = 'vector3d'}}
+OUTCOMING_RPCS[RPC.REQUESTCLASS]              = {'onSendRequestClass', {classId = 'int32'}}
+OUTCOMING_RPCS[RPC.REQUESTSPAWN]              = {'onSendRequestSpawn'}
+OUTCOMING_RPCS[RPC.PICKEDUPPICKUP]            = {'onSendPickedUpPickup', {pickupId = 'int32'}}
+OUTCOMING_RPCS[RPC.MENUSELECT]                = {'onSendMenuSelect', {row = 'uint8'}}
+OUTCOMING_RPCS[RPC.VEHICLEDESTROYED]          = {'onSendVehicleDestroyed', {vehicleId = 'uint16'}}
+OUTCOMING_RPCS[RPC.MENUQUIT]                  = {'onSendQuitMenu'}
+OUTCOMING_RPCS[RPC.EXITVEHICLE]               = {'onSendExitVehicle', {vehicleId = 'uint16'}}
+OUTCOMING_RPCS[RPC.UPDATESCORESPINGSIPS]      = {'onSendUpdateScoresAndPings'}
+-- playerId = 'uint16', damage = 'float', weapon = 'int32', bodypart ='int32'
+OUTCOMING_RPCS[RPC.GIVETAKEDAMAGE]            = {{'onSendGiveDamage', 'onSendTakeDamage'}, handler.rpc_send_give_take_damage_reader, handler.rpc_send_give_take_damage_writer}
+OUTCOMING_RPCS[RPC.SCRIPTCASH] = {'onSendMoneyIncreaseNotification', {amount = 'int32'}, {increaseType = 'int32'}}
+OUTCOMING_RPCS[RPC.NPCJOIN] = {'onSendNPCJoin', {version = 'int32'}, {mod = 'uint8'}, {nickname = 'string8'}, {challengeResponse = 'int32'}}
+OUTCOMING_RPCS[RPC.SRVNETSTATS] = {'onSendServerStatisticsRequest'}
+OUTCOMING_RPCS[RPC.WEAPONPICKUPDESTROY] = {'onSendPickedUpWeapon', {id = 'uint16'}}
+OUTCOMING_RPCS[RPC.CAMTARGETUPDATE] = {'onSendCameraTargetUpdate', {objectId = 'uint16'}, {vehicleId = 'uint16'}, {playerId = 'uint16'}, {actorId = 'uint16'}}
+OUTCOMING_RPCS[RPC.GIVEACTORDAMAGE] = {'onSendGiveActorDamage', {_unused = 'bool'}, {actorId = 'uint16'}, {damage = 'float'}, {weapon = 'int32'}, {bodypart ='int32'}}
+
+-- Incoming rpcs
+-- int playerId, string hostName, table settings, table vehicleModels, bool vehicleFriendlyFire
+INCOMING_RPCS[RPC.INITGAME]                   = {'onInitGame', handler.rpc_init_game_reader, handler.rpc_init_game_writer}
+INCOMING_RPCS[RPC.SERVERJOIN]                 = {'onPlayerJoin', {playerId = 'uint16'}, {color = 'int32'}, {isNpc = 'bool8'}, {nickname = 'string8'}}
+INCOMING_RPCS[RPC.SERVERQUIT]                 = {'onPlayerQuit', {playerId = 'uint16'}, {reason = 'uint8'}}
+INCOMING_RPCS[RPC.REQUESTCLASS]               = {'onRequestClassResponse', {canSpawn = 'bool8'}, {team = 'uint8'}, {skin = 'int32'}, {_unused = 'uint8'}, {positon = 'vector3d'}, {rotation = 'float'}, {weapons = 'Int32Array3'}, {ammo = 'Int32Array3'}}
+INCOMING_RPCS[RPC.REQUESTSPAWN]               = {'onRequestSpawnResponse', {response = 'bool8'}}
+INCOMING_RPCS[RPC.SETPLAYERNAME]              = {'onSetPlayerName', {playerId = 'uint16'}, {name = 'string8'}, {success = 'bool8'}}
+INCOMING_RPCS[RPC.SETPLAYERPOS]               = {'onSetPlayerPos', {position = 'vector3d'}}
+INCOMING_RPCS[RPC.SETPLAYERPOSFINDZ]          = {'onSetPlayerPosFindZ', {position = 'vector3d'}}
+INCOMING_RPCS[RPC.SETPLAYERHEALTH]            = {'onSetPlayerHealth', {health = 'float'}}
+INCOMING_RPCS[RPC.TOGGLEPLAYERCONTROLLABLE]   = {'onTogglePlayerControllable', {controllable = 'bool8'}}
+INCOMING_RPCS[RPC.PLAYSOUND]                  = {'onPlaySound', {soundId = 'int32'}, {position = 'vector3d'}}
+INCOMING_RPCS[RPC.SETPLAYERWORLDBOUNDS]       = {'onSetWorldBounds', {maxX = 'float'}, {minX = 'float'}, {maxY = 'float'}, {minY = 'float'}}
+INCOMING_RPCS[RPC.GIVEPLAYERMONEY]            = {'onGivePlayerMoney', {money = 'int32'}}
+INCOMING_RPCS[RPC.SETPLAYERFACINGANGLE]       = {'onSetPlayerFacingAngle', {angle = 'float'}}
+INCOMING_RPCS[RPC.RESETPLAYERMONEY]           = {'onResetPlayerMoney'}
+INCOMING_RPCS[RPC.RESETPLAYERWEAPONS]         = {'onResetPlayerWeapons'}
+INCOMING_RPCS[RPC.GIVEPLAYERWEAPON]           = {'onGivePlayerWeapon', {weaponId = 'int32'}, {ammo = 'int32'}}
+INCOMING_RPCS[RPC.CANCELEDIT]                 = {'onCancelEdit'}
+INCOMING_RPCS[RPC.SETPLAYERTIME]              = {'onSetPlayerTime', {hour = 'uint8'}, {minute = 'uint8'}}
+INCOMING_RPCS[RPC.TOGGLECLOCK]                = {'onSetToggleClock', {state = 'bool8'}}
+INCOMING_RPCS[RPC.WORLDPLAYERADD]             = {'onPlayerStreamIn', {playerId = 'uint16'}, {team = 'uint8'}, {model = 'int32'}, {position = 'vector3d'}, {rotation = 'float'}, {color = 'int32'}, {fightingStyle = 'uint8'}}
+INCOMING_RPCS[RPC.SETPLAYERSHOPNAME]          = {'onSetShopName', {name = 'fixedString32'}}
+INCOMING_RPCS[RPC.SETPLAYERSKILLLEVEL]        = {'onSetPlayerSkillLevel', {playerId = 'uint16'}, {skill = 'int32'}, {level = 'uint16'}}
+INCOMING_RPCS[RPC.SETPLAYERDRUNKLEVEL]        = {'onSetPlayerDrunk', {drunkLevel = 'int32'}}
+INCOMING_RPCS[RPC.CREATE3DTEXTLABEL]          = {'onCreate3DText', {id = 'uint16'}, {color = 'int32'}, {position = 'vector3d'}, {distance = 'float'}, {testLOS = 'bool8'}, {attachedPlayerId = 'uint16'}, {attachedVehicleId = 'uint16'}, {text = 'encodedString4096'}}
+INCOMING_RPCS[RPC.DISABLECHECKPOINT]          = {'onDisableCheckpoint'}
+INCOMING_RPCS[RPC.SETRACECHECKPOINT]          = {'onSetRaceCheckpoint', {type = 'uint8'}, {position = 'vector3d'}, {nextPosition = 'vector3d'}, {size = 'float'}}
+INCOMING_RPCS[RPC.DISABLERACECHECKPOINT]      = {'onDisableRaceCheckpoint'}
+INCOMING_RPCS[RPC.GAMEMODERESTART]            = {'onGamemodeRestart'}
+INCOMING_RPCS[RPC.PLAYAUDIOSTREAM]            = {'onPlayAudioStream', {url = 'string8'}, {position = 'vector3d'}, {radius = 'float'}, {usePosition = 'bool8'}}
+INCOMING_RPCS[RPC.STOPAUDIOSTREAM]            = {'onStopAudioStream'}
+INCOMING_RPCS[RPC.REMOVEBUILDINGFORPLAYER]    = {'onRemoveBuilding', {modelId = 'int32'}, {position = 'vector3d'}, {radius = 'float'}}
+INCOMING_RPCS[RPC.CREATEOBJECT]               = {'onCreateObject', handler.rpc_create_object_reader, handler.rpc_create_object_writer}
+INCOMING_RPCS[RPC.SETOBJECTPOS]               = {'onSetObjectPosition', {objectId = 'uint16'}, {position = 'vector3d'}}
+INCOMING_RPCS[RPC.SETOBJECTROT]               = {'onSetObjectRotation', {objectId = 'uint16'}, {rotation = 'vector3d'}}
+INCOMING_RPCS[RPC.DESTROYOBJECT]              = {'onDestroyObject', {objectId = 'uint16'}}
+INCOMING_RPCS[RPC.DEATHMESSAGE]               = {'onPlayerDeathNotification', {killerId = 'uint16'}, {killedId = 'uint16'}, {reason = 'uint8'}}
+INCOMING_RPCS[RPC.SETPLAYERMAPICON]           = {'onSetMapIcon', {iconId = 'uint8'}, {position = 'vector3d'}, {type = 'uint8'}, {color = 'int32'}, {style = 'uint8'}}
+INCOMING_RPCS[RPC.REMOVEVEHICLECOMPONENT]     = {'onRemoveVehicleComponent', {vehicleId = 'uint16'}, {componentId = 'uint16'}}
+INCOMING_RPCS[RPC.DESTROY3DTEXTLABEL]         = {'onRemove3DTextLabel', {textLabelId = 'uint16'}}
+INCOMING_RPCS[RPC.CHATBUBBLE]                 = {'onPlayerChatBubble', {playerId = 'uint16'}, {color = 'int32'}, {distance = 'float'}, {duration = 'int32'}, {message = 'string8'}}
+INCOMING_RPCS[RPC.UPDATETIME]                 = {'onUpdateGlobalTimer', {time = 'int32'}}
+INCOMING_RPCS[RPC.SHOWDIALOG]                 = {'onShowDialog', {dialogId = 'uint16'}, {style = 'uint8'}, {title = 'string8'}, {button1 = 'string8'}, {button2 = 'string8'}, {text = 'encodedString4096'}}
+INCOMING_RPCS[RPC.DESTROYPICKUP]              = {'onDestroyPickup', {id = 'int32'}}
+INCOMING_RPCS[RPC.LINKVEHICLETOINTERIOR]      = {'onLinkVehicleToInterior', {vehicleId = 'uint16'}, {interiorId = 'uint8'}}
+INCOMING_RPCS[RPC.SETPLAYERARMOUR]            = {'onSetPlayerArmour', {armour = 'float'}}
+INCOMING_RPCS[RPC.SETPLAYERARMEDWEAPON]       = {'onSetPlayerArmedWeapon', {weaponId = 'int32'}}
+INCOMING_RPCS[RPC.SETSPAWNINFO]               = {'onSetSpawnInfo', {team = 'uint8'}, {skin = 'int32'}, {_unused = 'uint8'}, {position = 'vector3d'}, {rotation = 'float'}, {weapons = 'Int32Array3'}, {ammo = 'Int32Array3'}}
+INCOMING_RPCS[RPC.SETPLAYERTEAM]              = {'onSetPlayerTeam', {playerId = 'uint16'}, {teamId = 'uint8'}}
+INCOMING_RPCS[RPC.PUTPLAYERINVEHICLE]         = {'onPutPlayerInVehicle', {vehicleId = 'uint16'}, {seatId = 'uint8'}}
+INCOMING_RPCS[RPC.REMOVEPLAYERFROMVEHICLE]    = {'onRemovePlayerFromVehicle'}
+INCOMING_RPCS[RPC.SETPLAYERCOLOR]             = {'onSetPlayerColor', {playerId = 'uint16'}, {color = 'int32'}}
+INCOMING_RPCS[RPC.DISPLAYGAMETEXT]            = {'onDisplayGameText', {style = 'int32'}, {time = 'int32'}, {text = 'string32'}}
+INCOMING_RPCS[RPC.FORCECLASSSELECTION]        = {'onForceClassSelection'}
+INCOMING_RPCS[RPC.ATTACHOBJECTTOPLAYER]       = {'onAttachObjectToPlayer', {objectId = 'uint16'}, {playerId = 'uint16'}, {offsets = 'vector3d'}, {rotation = 'vector3d'}}
+-- menuId = 'uint8', menuTitle = 'fixedString32', x = 'float', y = 'float', twoColumns = 'bool32', columns = 'table', rows = 'table', menu = 'bool32'
+INCOMING_RPCS[RPC.INITMENU]                   = {'onInitMenu', handler.rpc_init_menu_reader, handler.rpc_init_menu_writer}
+INCOMING_RPCS[RPC.SHOWMENU]                   = {'onShowMenu', {menuId = 'uint8'}}
+INCOMING_RPCS[RPC.HIDEMENU]                   = {'onHideMenu', {menuId = 'uint8'}}
+INCOMING_RPCS[RPC.CREATEEXPLOSION]            = {'onCreateExplosion', {position = 'vector3d'}, {style = 'int32'}, {radius = 'float'}}
+INCOMING_RPCS[RPC.SHOWPLAYERNAMETAGFORPLAYER] = {'onShowPlayerNameTag', {playerId = 'uint16'}, {show = 'bool8'}}
+INCOMING_RPCS[RPC.ATTACHCAMERATOOBJECT]       = {'onAttachCameraToObject', {objectId = 'uint16'}}
+INCOMING_RPCS[RPC.INTERPOLATECAMERA]          = {'onInterpolateCamera', {setPos = 'bool'}, {fromPos = 'vector3d'}, {destPos = 'vector3d'}, {time = 'int32'}, {mode = 'uint8'}}
+INCOMING_RPCS[RPC.GANGZONESTOPFLASH]          = {'onGangZoneStopFlash', {zoneId = 'uint16'}}
+INCOMING_RPCS[RPC.APPLYANIMATION]             = {'onApplyPlayerAnimation', {playerId = 'uint16'}, {animLib = 'string8'}, {animName = 'string8'}, {frameDelta = 'float'}, {loop = 'bool'}, {lockX = 'bool'}, {lockY = 'bool'}, {freeze = 'bool'}, {time = 'int32'}}
+INCOMING_RPCS[RPC.CLEARANIMATIONS]            = {'onClearPlayerAnimation', {playerId = 'uint16'}}
+INCOMING_RPCS[RPC.SETPLAYERSPECIALACTION]     = {'onSetPlayerSpecialAction', {actionId = 'uint8'}}
+INCOMING_RPCS[RPC.SETPLAYERFIGHTINGSTYLE]     = {'onSetPlayerFightingStyle', {playerId = 'uint16'}, {styleId = 'uint8'}}
+INCOMING_RPCS[RPC.SETPLAYERVELOCITY]          = {'onSetPlayerVelocity', {velocity = 'vector3d'}}
+INCOMING_RPCS[RPC.SETVEHICLEVELOCITY]         = {'onSetVehicleVelocity', {turn = 'bool8'}, {velocity = 'vector3d'}}
+INCOMING_RPCS[RPC.CLIENTMESSAGE]              = {'onServerMessage', {color = 'int32'}, {text = 'string32'}}
+INCOMING_RPCS[RPC.SETWORLDTIME]               = {'onSetWorldTime', {hour = 'uint8'}}
+INCOMING_RPCS[RPC.CREATEPICKUP]               = {'onCreatePickup', {id = 'int32'}, {model = 'int32'}, {pickupType = 'int32'}, {position = 'vector3d'}}
+INCOMING_RPCS[RPC.MOVEOBJECT]                 = {'onMoveObject', {objectId = 'uint16'}, {fromPos = 'vector3d'}, {destPos = 'vector3d'}, {speed = 'float'}, {rotation = 'vector3d'}}
+INCOMING_RPCS[RPC.ENABLESTUNTBONUSFORPLAYER]  = {'onEnableStuntBonus', {state = 'bool'}}
+INCOMING_RPCS[RPC.TEXTDRAWSETSTRING]          = {'onTextDrawSetString', {id = 'uint16'}, {text = 'string16'}}
+INCOMING_RPCS[RPC.SETCHECKPOINT]              = {'onSetCheckpoint', {position = 'vector3d'}, {radius = 'float'}}
+INCOMING_RPCS[RPC.GANGZONECREATE]             = {'onCreateGangZone', {zoneId = 'uint16'}, {squareStart = 'vector2d'}, {squareEnd = 'vector2d'}, {color = 'int32'}}
+INCOMING_RPCS[RPC.PLAYCRIMEREPORT]            = {'onPlayCrimeReport', {suspectId = 'uint16'}, {inVehicle = 'bool32'}, {vehicleModel = 'int32'}, {vehicleColor = 'int32'}, {crime = 'int32'}, {coordinates = 'vector3d'}}
+INCOMING_RPCS[RPC.GANGZONEDESTROY]            = {'onGangZoneDestroy', {zoneId = 'uint16'}}
+INCOMING_RPCS[RPC.GANGZONEFLASH]              = {'onGangZoneFlash', {zoneId = 'uint16'}, {color = 'int32'}}
+INCOMING_RPCS[RPC.STOPOBJECT]                 = {'onStopObject', {objectId = 'uint16'}}
+INCOMING_RPCS[RPC.SETNUMBERPLATE]             = {'onSetVehicleNumberPlate', {vehicleId = 'uint16'}, {text = 'string8'}}
+INCOMING_RPCS[RPC.TOGGLEPLAYERSPECTATING]     = {'onTogglePlayerSpectating', {state = 'bool32'}}
+INCOMING_RPCS[RPC.PLAYERSPECTATEPLAYER]       = {'onSpectatePlayer', {playerId = 'uint16'}, {camType = 'uint8'}}
+INCOMING_RPCS[RPC.PLAYERSPECTATEVEHICLE]      = {'onSpectateVehicle', {vehicleId = 'uint16'}, {camType = 'uint8'}}
+INCOMING_RPCS[RPC.SHOWTEXTDRAW]               = {'onShowTextDraw',
+  {textdrawId = 'uint16'},
+  {textdraw = {
+    {flags = 'uint8'},
+    {letterWidth = 'float'},
+    {letterHeight = 'float'},
+    {letterColor = 'int32'},
+    {lineWidth = 'float'},
+    {lineHeight = 'float'},
+    {boxColor = 'int32'},
+    {shadow = 'uint8'},
+    {outline = 'uint8'},
+    {backgroundColor = 'int32'},
+    {style = 'uint8'},
+    {selectable = 'uint8'},
+    {position = 'vector2d'},
+    {modelId = 'uint16'},
+    {rotation = 'vector3d'},
+    {zoom = 'float'},
+    {color1 = 'int16'},
+    {color2 = 'int16'},
+    {text = 'string16'}
+  }}
+}
+INCOMING_RPCS[RPC.SETPLAYERWANTEDLEVEL]       = {'onSetPlayerWantedLevel', {wantedLevel = 'uint8'}}
+INCOMING_RPCS[RPC.TEXTDRAWHIDEFORPLAYER]      = {'onTextDrawHide', {textDrawId = 'uint16'}}
+INCOMING_RPCS[RPC.REMOVEPLAYERMAPICON]        = {'onRemoveMapIcon', {iconId = 'uint8'}}
+INCOMING_RPCS[RPC.SETPLAYERAMMO]              = {'onSetWeaponAmmo', {weaponId = 'uint8'}, {ammo = 'uint16'}}
+INCOMING_RPCS[RPC.SETGRAVITY]                 = {'onSetGravity', {gravity = 'float'}}
+INCOMING_RPCS[RPC.SETVEHICLEHEALTH]           = {'onSetVehicleHealth', {vehicleId = 'uint16'}, {health = 'float'}}
+INCOMING_RPCS[RPC.ATTACHTRAILERTOVEHICLE]     = {'onAttachTrailerToVehicle', {trailerId = 'uint16'}, {vehicleId = 'uint16'}}
+INCOMING_RPCS[RPC.DETACHTRAILERFROMVEHICLE]   = {'onDetachTrailerFromVehicle', {vehicleId = 'uint16'}}
+INCOMING_RPCS[RPC.SETWEATHER]                 = {'onSetWeather', {weatherId = 'uint8'}}
+INCOMING_RPCS[RPC.SETPLAYERSKIN]              = {'onSetPlayerSkin', {playerId = 'int32'}, {skinId = 'int32'}}
+INCOMING_RPCS[RPC.SETPLAYERINTERIOR]          = {'onSetInterior', {interior = 'uint8'}}
+INCOMING_RPCS[RPC.SETPLAYERCAMERAPOS]         = {'onSetCameraPosition', {position = 'vector3d'}}
+INCOMING_RPCS[RPC.SETPLAYERCAMERALOOKAT]      = {'onSetCameraLookAt', {lookAtPosition = 'vector3d'}, {cutType = 'uint8'}}
+INCOMING_RPCS[RPC.SETVEHICLEPOS]              = {'onSetVehiclePosition', {vehicleId = 'uint16'}, {position = 'vector3d'}}
+INCOMING_RPCS[RPC.SETVEHICLEZANGLE]           = {'onSetVehicleAngle', {vehicleId = 'uint16'}, {angle = 'float'}}
+INCOMING_RPCS[RPC.SETVEHICLEPARAMSFORPLAYER]  = {'onSetVehicleParams', {vehicleId = 'uint16'}, {objective = 'bool8'}, {doorsLocked = 'bool8'}}
+INCOMING_RPCS[RPC.SETCAMERABEHINDPLAYER]      = {'onSetCameraBehind'}
+INCOMING_RPCS[RPC.CHAT]                       = {'onChatMessage', {playerId = 'uint16'}, {text = 'string8'}}
+INCOMING_RPCS[RPC.CONNECTIONREJECTED]         = {'onConnectionRejected', {reason = 'uint8'}}
+INCOMING_RPCS[RPC.WORLDPLAYERREMOVE]          = {'onPlayerStreamOut', {playerId = 'uint16'}}
+INCOMING_RPCS[RPC.WORLDVEHICLEADD]            = {'onVehicleStreamIn', handler.rpc_vehicle_stream_in_reader, handler.rpc_vehicle_stream_in_writer}
+INCOMING_RPCS[RPC.WORLDVEHICLEREMOVE]         = {'onVehicleStreamOut', {vehicleId = 'uint16'}}
+INCOMING_RPCS[RPC.WORLDPLAYERDEATH]           = {'onPlayerDeath', {playerId = 'uint16'}}
+INCOMING_RPCS[RPC.ENTERVEHICLE]               = {'onPlayerEnterVehicle', {playerId = 'uint16'}, {vehicleId = 'uint16'}, {passenger = 'bool8'}}
+INCOMING_RPCS[RPC.UPDATESCORESPINGSIPS]       = {'onUpdateScoresAndPings', handler.rpc_update_scores_and_pings_reader, handler.rpc_update_scores_and_pings_writer}
+INCOMING_RPCS[RPC.SETOBJECTMATERIAL]          = {{'onSetObjectMaterial', 'onSetObjectMaterialText'}, handler.rpc_set_object_material_reader, handler.rpc_set_object_material_writer}
+INCOMING_RPCS[RPC.CREATEACTOR]                = {'onCreateActor', {actorId = 'uint16'}, {skinId = 'int32'}, {position = 'vector3d'}, {rotation = 'float'}, {health = 'float'}}
+INCOMING_RPCS[RPC.CLICKTEXTDRAW]              = {'onToggleSelectTextDraw', {state = 'bool'}, {hovercolor = 'int32'}}
+INCOMING_RPCS[RPC.SETVEHICLEPARAMSEX]         = {'onSetVehicleParamsEx',
+  {vehicleId = 'uint16'},
+  {params = {
+    {engine = 'uint8'},
+    {lights = 'uint8'},
+    {alarm = 'uint8'},
+    {doors = 'uint8'},
+    {bonnet = 'uint8'},
+    {boot = 'uint8'},
+    {objective = 'uint8'},
+    {unknown = 'uint8'}
+  }},
+  {doors = {
+    {driver = 'uint8'},
+    {passenger = 'uint8'},
+    {backleft = 'uint8'},
+    {backright = 'uint8'}
+  }},
+  {windows = {
+    {driver = 'uint8'},
+    {passenger = 'uint8'},
+    {backleft = 'uint8'},
+    {backright = 'uint8'}
+  }}
+}
+INCOMING_RPCS[RPC.SETPLAYERATTACHEDOBJECT]    = {'onSetPlayerAttachedObject',
+  {playerId = 'uint16'},
+  {index = 'int32'},
+  {create = 'bool'},
+  {object = {
+    {modelId = 'int32'},
+    {bone = 'int32'},
+    {offset = 'vector3d'},
+    {rotation = 'vector3d'},
+    {scale = 'vector3d'},
+    {color1 = 'int32'},
+    {color2 = 'int32'}}
+  }
+}
+INCOMING_RPCS[RPC.CLIENTCHECK] = {'onClientCheck', {requestType = 'uint8'}, {subject = 'int32'}, {offset = 'uint16'}, {length = 'uint16'}}
+INCOMING_RPCS[RPC.DESTROYACTOR] = {'onDestroyActor', {actorId = 'uint16'}}
+INCOMING_RPCS[RPC.DESTROYWEAPONPICKUP] = {'onDestroyWeaponPickup', {id = 'uint8'}}
+INCOMING_RPCS[RPC.EDITATTACHEDOBJECT] = {'onEditAttachedObject', {index = 'int32'}}
+INCOMING_RPCS[RPC.TOGGLECAMERATARGET] = {'onToggleCameraTargetNotifying', {enable = 'bool'}}
+INCOMING_RPCS[RPC.SELECTOBJECT] = {'onEnterSelectObject'}
+INCOMING_RPCS[RPC.EXITVEHICLE] = {'onPlayerExitVehicle', {playerId = 'uint16'}, {vehicleId = 'uint16'}}
+INCOMING_RPCS[RPC.SCMEVENT] = {'onVehicleTuningNotification', {playerId = 'uint16'}, {event = 'int32'}, {vehicleId = 'int32'}, {param1 = 'int32'}, {param2 = 'int32'}}
+INCOMING_RPCS[RPC.SRVNETSTATS] = {'onServerStatisticsResponse'} --, {data = 'RakNetStatisticsStruct'}}
+INCOMING_RPCS[RPC.EDITOBJECT] = {'onEnterEditObject', {playerObject = 'bool'}, {objectId = 'uint16'}}
+INCOMING_RPCS[RPC.DAMAGEVEHICLE] = {'onVehicleDamageStatusUpdate', {vehicleId = 'uint16'}, {panelDmg = 'int32'}, {doorDmg = 'int32'}, {lights = 'uint8'}, {tires = 'uint8'}}
+INCOMING_RPCS[RPC.DISABLEVEHICLECOLLISIONS] = {'onDisableVehicleCollisions', {disable = 'bool'}}
+INCOMING_RPCS[RPC.TOGGLEWIDESCREEN] = {'onToggleWidescreen', {enable = 'bool8'}}
+INCOMING_RPCS[RPC.SETVEHICLETIRES] = {'onSetVehicleTires', {vehicleId = 'uint16'}, {tires = 'uint8'}}
+INCOMING_RPCS[RPC.SETPLAYERDRUNKVISUALS] = {'onSetPlayerDrunkVisuals', {level = 'int32'}}
+INCOMING_RPCS[RPC.SETPLAYERDRUNKHANDLING] = {'onSetPlayerDrunkHandling', {level = 'int32'}}
+INCOMING_RPCS[RPC.APPLYACTORANIMATION] = {'onApplyActorAnimation', {actorId = 'uint16'}, {animLib = 'string8'}, {animName = 'string8'}, {frameDelta = 'float'}, {loop = 'bool'}, {lockX = 'bool'}, {lockY = 'bool'}, {freeze = 'bool'}, {time = 'int32'}}
+INCOMING_RPCS[RPC.CLEARACTORANIMATION] = {'onClearActorAnimation', {actorId = 'uint16'}}
+INCOMING_RPCS[RPC.SETACTORROTATION] = {'onSetActorFacingAngle', {actorId = 'uint16'}, {angle = 'float'}}
+INCOMING_RPCS[RPC.SETACTORPOSITION] = {'onSetActorPos', {actorId = 'uint16'}, {position = 'vector3d'}}
+INCOMING_RPCS[RPC.SETACTORHEALTH] = {'onSetActorHealth', {actorId = 'uint16'}, {health = 'float'}}
+INCOMING_RPCS[RPC.SETPLAYEROBJECTNOCAMCOL] = {'onSetPlayerObjectNoCameraCol', {objectId = 'uint16'}}
+INCOMING_RPCS[125] = {'_dummy125'}
+INCOMING_RPCS[64] = {'_dummy64', {'uint16'}}
+INCOMING_RPCS[48] = {'_unused48', {'int32'}}
+
+
+-- Outgoing packets
+OUTCOMING_PACKETS[PACKET.RCON_COMMAND]        = {'onSendRconCommand', {command = 'string32'}}
+OUTCOMING_PACKETS[PACKET.STATS_UPDATE]        = {'onSendStatsUpdate', {money = 'int32'}, {drunkLevel = 'int32'}}
+local function empty_writer() end
+OUTCOMING_PACKETS[PACKET.PLAYER_SYNC]         = {'onSendPlayerSync', function(bs) return utils.process_outcoming_sync_data(bs, 'PlayerSyncData') end, empty_writer}
+OUTCOMING_PACKETS[PACKET.VEHICLE_SYNC]        = {'onSendVehicleSync', function(bs) return utils.process_outcoming_sync_data(bs, 'VehicleSyncData') end, empty_writer}
+OUTCOMING_PACKETS[PACKET.PASSENGER_SYNC]      = {'onSendPassengerSync', function(bs) return utils.process_outcoming_sync_data(bs, 'PassengerSyncData') end, empty_writer}
+OUTCOMING_PACKETS[PACKET.AIM_SYNC]            = {'onSendAimSync', function(bs) return utils.process_outcoming_sync_data(bs, 'AimSyncData') end, empty_writer}
+OUTCOMING_PACKETS[PACKET.UNOCCUPIED_SYNC]     = {'onSendUnoccupiedSync', function(bs) return utils.process_outcoming_sync_data(bs, 'UnoccupiedSyncData') end, empty_writer}
+OUTCOMING_PACKETS[PACKET.TRAILER_SYNC]        = {'onSendTrailerSync', function(bs) return utils.process_outcoming_sync_data(bs, 'TrailerSyncData') end, empty_writer}
+OUTCOMING_PACKETS[PACKET.BULLET_SYNC]         = {'onSendBulletSync', function(bs) return utils.process_outcoming_sync_data(bs, 'BulletSyncData') end, empty_writer}
+OUTCOMING_PACKETS[PACKET.SPECTATOR_SYNC]      = {'onSendSpectatorSync', function(bs) return utils.process_outcoming_sync_data(bs, 'SpectatorSyncData') end, empty_writer}
+OUTCOMING_PACKETS[PACKET.WEAPONS_UPDATE] = {'onSendWeaponsUpdate', handler.packet_weapons_update_reader, handler.packet_weapons_update_writer}
+OUTCOMING_PACKETS[PACKET.AUTHENTICATION] = {'onSendAuthenticationResponse', {response = 'string8'}}
+
+-- Incoming packets
+INCOMING_PACKETS[PACKET.PLAYER_SYNC]          = {'onPlayerSync', handler.packet_player_sync_reader, handler.packet_player_sync_writer}
+INCOMING_PACKETS[PACKET.VEHICLE_SYNC]         = {'onVehicleSync', handler.packet_vehicle_sync_reader, handler.packet_vehicle_sync_writer}
+INCOMING_PACKETS[PACKET.MARKERS_SYNC]         = {'onMarkersSync', handler.packet_markers_sync_reader, handler.packet_markers_sync_writer}
+INCOMING_PACKETS[PACKET.AIM_SYNC]             = {'onAimSync', {playerId = 'uint16'}, {data = 'AimSyncData'}}
+INCOMING_PACKETS[PACKET.BULLET_SYNC]          = {'onBulletSync', {playerId = 'uint16'}, {data = 'BulletSyncData'}}
+INCOMING_PACKETS[PACKET.UNOCCUPIED_SYNC]      = {'onUnoccupiedSync', {playerId = 'uint16'}, {data = 'UnoccupiedSyncData'}}
+INCOMING_PACKETS[PACKET.TRAILER_SYNC]         = {'onTrailerSync', {playerId = 'uint16'}, {data = 'TrailerSyncData'}}
+INCOMING_PACKETS[PACKET.PASSENGER_SYNC]       = {'onPassengerSync', {playerId = 'uint16'}, {data = 'PassengerSyncData'}}
+INCOMING_PACKETS[PACKET.AUTHENTICATION] = {'onAuthenticationRequest', {key = 'string8'}}
+INCOMING_PACKETS[PACKET.CONNECTION_REQUEST_ACCEPTED] = {'onConnectionRequestAccepted', {ip = 'int32'}, {port = 'uint16'}, {playerId = 'uint16'}, {challenge = 'int32'}}
+INCOMING_PACKETS[PACKET.CONNECTION_LOST] = {'onConnectionLost'}
+INCOMING_PACKETS[PACKET.CONNECTION_BANNED] = {'onConnectionBanned'}
+INCOMING_PACKETS[PACKET.CONNECTION_ATTEMPT_FAILED] = {'onConnectionAttemptFailed'}
+INCOMING_PACKETS[PACKET.NO_FREE_INCOMING_CONNECTIONS] = {'onConnectionNoFreeSlot'}
+INCOMING_PACKETS[PACKET.INVALID_PASSWORD] = {'onConnectionPasswordInvalid'}
+INCOMING_PACKETS[PACKET.DISCONNECTION_NOTIFICATION] = {'onConnectionClosed'}
+
+return events

extra_types.lua

@@ -0,0 +1,45 @@
+-- This file is part of the SAMP.Lua project.
+-- Licensed under the MIT License.
+-- Copyright (c) 2016, FYP @ BlastHack Team <blast.hk>
+-- https://github.com/THE-FYP/SAMP.Lua
+
+local BitStreamIO = require 'samp.events.bitstream_io'
+local utils = require 'samp.events.utils'
+
+BitStreamIO.Int32Array3 = {
+	read = function(bs)
+		local arr = {}
+		for i = 1, 3 do arr[i] = raknetBitStreamReadInt32(bs) end
+		return arr
+	end,
+	write = function(bs, value)
+		for i = 1, 3 do raknetBitStreamWriteInt32(bs, value[i]) end
+	end
+}
+
+BitStreamIO.AimSyncData = {
+	read = function(bs) return utils.read_sync_data(bs, 'AimSyncData')  end,
+	write = function(bs, value) utils.write_sync_data(bs, 'AimSyncData', value) end
+}
+
+BitStreamIO.UnoccupiedSyncData = {
+	read = function(bs) return utils.read_sync_data(bs, 'UnoccupiedSyncData')  end,
+	write = function(bs, value) utils.write_sync_data(bs, 'UnoccupiedSyncData', value) end
+}
+
+BitStreamIO.PassengerSyncData = {
+	read = function(bs) 	return utils.read_sync_data(bs, 'PassengerSyncData')  end,
+	write = function(bs, value) utils.write_sync_data(bs, 'PassengerSyncData', value) end
+}
+
+BitStreamIO.BulletSyncData = {
+	read = function(bs) return utils.read_sync_data(bs, 'BulletSyncData')  end,
+	write = function(bs, value) utils.write_sync_data(bs, 'BulletSyncData', value) end
+}
+
+BitStreamIO.TrailerSyncData = {
+	read = function(bs) return utils.read_sync_data(bs, 'TrailerSyncData')  end,
+	write = function(bs, value) utils.write_sync_data(bs, 'TrailerSyncData', value) end
+}
+
+return BitStreamIO

handlers.lua

@@ -0,0 +1,526 @@
+-- This file is part of the SAMP.Lua project.
+-- Licensed under the MIT License.
+-- Copyright (c) 2016, FYP @ BlastHack Team <blast.hk>
+-- https://github.com/THE-FYP/SAMP.Lua
+
+local bs_io = require 'samp.events.bitstream_io'
+local utils = require 'samp.events.utils'
+local bsread, bswrite = bs_io.bs_read, bs_io.bs_write
+local handler = {}
+
+--- onSendGiveDamage, onSendTakeDamage
+function handler.rpc_send_give_take_damage_reader(bs)
+	local take = bsread.bool(bs) -- 'true' is take damage
+	local data = {
+		bsread.uint16(bs), -- playerId
+		bsread.float(bs), -- damage
+		bsread.int32(bs), -- weapon
+		bsread.int32(bs), -- bodypart
+		take,
+	}
+	return (take and 'onSendTakeDamage' or 'onSendGiveDamage'), data
+end
+
+function handler.rpc_send_give_take_damage_writer(bs, data)
+	bswrite.bool(bs, data[5]) -- give or take
+	bswrite.uint16(bs, data[1]) -- playerId
+	bswrite.float(bs, data[2]) -- damage
+	bswrite.int32(bs, data[3]) -- weapon
+	bswrite.int32(bs, data[4]) -- bodypart
+end
+
+--- onInitGame
+function handler.rpc_init_game_reader(bs)
+	local settings                 = {}
+	settings.zoneNames             = bsread.bool(bs)
+	settings.useCJWalk             = bsread.bool(bs)
+	settings.allowWeapons          = bsread.bool(bs)
+	settings.limitGlobalChatRadius = bsread.bool(bs)
+	settings.globalChatRadius      = bsread.float(bs)
+	settings.stuntBonus            = bsread.bool(bs)
+	settings.nametagDrawDist       = bsread.float(bs)
+	settings.disableEnterExits     = bsread.bool(bs)
+	settings.nametagLOS            = bsread.bool(bs)
+	settings.tirePopping           = bsread.bool(bs)
+	settings.classesAvailable      = bsread.int32(bs)
+	local playerId                 = bsread.uint16(bs)
+	settings.showPlayerTags        = bsread.bool(bs)
+	settings.playerMarkersMode     = bsread.int32(bs)
+	settings.worldTime             = bsread.uint8(bs)
+	settings.worldWeather          = bsread.uint8(bs)
+	settings.gravity               = bsread.float(bs)
+	settings.lanMode               = bsread.bool(bs)
+	settings.deathMoneyDrop        = bsread.int32(bs)
+	settings.instagib              = bsread.bool(bs)
+	settings.normalOnfootSendrate  = bsread.int32(bs)
+	settings.normalIncarSendrate   = bsread.int32(bs)
+	settings.normalFiringSendrate  = bsread.int32(bs)
+	settings.sendMultiplier        = bsread.int32(bs)
+	settings.lagCompMode           = bsread.int32(bs)
+	local hostName                 = bsread.string8(bs)
+	local vehicleModels = {}
+	for i = 0, 212 - 1 do
+		vehicleModels[i] = bsread.uint8(bs)
+	end
+	settings.vehicleFriendlyFire = bsread.bool32(bs)
+	return {playerId, hostName, settings, vehicleModels, settings.vehicleFriendlyFire}
+end
+
+function handler.rpc_init_game_writer(bs, data)
+	local settings = data[3]
+	local vehicleModels = data[4]
+	bswrite.bool(bs, settings.zoneNames)
+	bswrite.bool(bs, settings.useCJWalk)
+	bswrite.bool(bs, settings.allowWeapons)
+	bswrite.bool(bs, settings.limitGlobalChatRadius)
+	bswrite.float(bs, settings.globalChatRadius)
+	bswrite.bool(bs, settings.stuntBonus)
+	bswrite.float(bs, settings.nametagDrawDist)
+	bswrite.bool(bs, settings.disableEnterExits)
+	bswrite.bool(bs, settings.nametagLOS)
+	bswrite.bool(bs, settings.tirePopping)
+	bswrite.int32(bs, settings.classesAvailable)
+	bswrite.uint16(bs, data[1]) -- playerId
+	bswrite.bool(bs, settings.showPlayerTags)
+	bswrite.int32(bs, settings.playerMarkersMode)
+	bswrite.uint8(bs, settings.worldTime)
+	bswrite.uint8(bs, settings.worldWeather)
+	bswrite.float(bs, settings.gravity)
+	bswrite.bool(bs, settings.lanMode)
+	bswrite.int32(bs, settings.deathMoneyDrop)
+	bswrite.bool(bs, settings.instagib)
+	bswrite.int32(bs, settings.normalOnfootSendrate)
+	bswrite.int32(bs, settings.normalIncarSendrate)
+	bswrite.int32(bs, settings.normalFiringSendrate)
+	bswrite.int32(bs, settings.sendMultiplier)
+	bswrite.int32(bs, settings.lagCompMode)
+	bswrite.string8(bs, data[2]) -- hostName
+	for i = 1, 212 do
+		bswrite.uint8(bs, vehicleModels[i])
+	end
+	bswrite.bool32(bs, settings.vehicleFriendlyFire)
+end
+
+--- onInitMenu
+function handler.rpc_init_menu_reader(bs)
+	local colWidth2
+	local rows = {}
+	local columns = {}
+	local readColumn = function(width)
+		local title = bsread.fixedString32(bs)
+		local rowCount = bsread.uint8(bs)
+		local column = {title = title, width = width, text = {}}
+		for i = 1, rowCount do
+			column.text[i] = bsread.fixedString32(bs)
+		end
+		return column
+	end
+	local menuId = bsread.uint8(bs)
+	local twoColumns = bsread.bool32(bs)
+	local menuTitle = bsread.fixedString32(bs)
+	local x = bsread.float(bs)
+	local y = bsread.float(bs)
+	local colWidth1 = bsread.float(bs)
+	if twoColumns then
+		colWidth2 = bsread.float(bs)
+	end
+	local menu = bsread.bool32(bs)
+	for i = 1, 12 do
+		rows[i] = bsread.int32(bs)
+	end
+	columns[1] = readColumn(colWidth1)
+	if twoColumns then
+		columns[2] = readColumn(colWidth2)
+	end
+	return {menuId, menuTitle, x, y, twoColumns, columns, rows, menu}
+end
+
+function handler.rpc_init_menu_writer(bs, data)
+	local columns = data[6]
+	bswrite.uint8(bs, data[1])      -- menuId
+	bswrite.bool32(bs, data[5])    -- twoColumns
+	bswrite.fixedString32(bs, data[2]) -- title
+	bswrite.float(bs, data[3])     -- x
+	bswrite.float(bs, data[4])     -- y
+	-- columns width
+	bswrite.float(bs, columns[1].width)
+	if data[5] then
+		bswrite.float(bs, columns[2].width)
+	end
+	bswrite.bool32(bs, data[8]) -- menu
+	 -- rows
+	for i = 1, 12 do
+		bswrite.int32(bs, data[7][i])
+	end
+	-- columns
+	for i = 1, (data[5] and 2 or 1) do
+		bswrite.fixedString32(bs, columns[i].title)
+		bswrite.uint8(bs, #columns[i].text)
+		for r, t in ipairs(columns[i].text) do
+			bswrite.fixedString32(bs, t)
+		end
+	end
+end
+
+--- onMarkersSync
+function handler.packet_markers_sync_reader(bs)
+	local markers = {}
+	local players = bsread.int32(bs)
+	for i = 1, players do
+		local playerId = bsread.uint16(bs)
+		local active = bsread.bool(bs)
+		if active then
+			local vector3d = require 'vector3d'
+			local x, y, z = bsread.int16(bs), bsread.int16(bs), bsread.int16(bs)
+			table.insert(markers, {playerId = playerId, active = true, coords = vector3d(x, y, z)})
+		else
+			table.insert(markers, {playerId = playerId, active = false})
+		end
+	end
+	return {markers}
+end
+
+function handler.packet_markers_sync_writer(bs, data)
+	bswrite.int32(bs, #data)
+	for i = 1, #data do
+		local it = data[i]
+		bswrite.uint16(bs, it.playerId)
+		bswrite.bool(bs, it.active)
+		if it.active then
+			bswrite.uint16(bs, it.coords.x)
+			bswrite.uint16(bs, it.coords.y)
+			bswrite.uint16(bs, it.coords.z)
+		end
+	end
+end
+
+--- onPlayerSync
+function handler.packet_player_sync_reader(bs)
+	local has_value = bsread.bool
+	local data = {}
+	local playerId = bsread.uint16(bs)
+	if has_value(bs) then data.leftRightKeys = bsread.uint16(bs) end
+	if has_value(bs) then data.upDownKeys = bsread.uint16(bs) end
+	data.keysData = bsread.uint16(bs)
+	data.position = bsread.vector3d(bs)
+	data.quaternion = bsread.normQuat(bs)
+	data.health, data.armor = utils.decompress_health_and_armor(bsread.uint8(bs))
+	data.weapon = bsread.uint8(bs)
+	data.specialAction = bsread.uint8(bs)
+	data.moveSpeed = bsread.compressedVector(bs)
+	if has_value(bs) then
+		data.surfingVehicleId = bsread.uint16(bs)
+		data.surfingOffsets = bsread.vector3d(bs)
+	end
+	if has_value(bs) then
+		data.animationId = bsread.uint16(bs)
+		data.animationFlags = bsread.uint16(bs)
+	end
+	return {playerId, data}
+end
+
+function handler.packet_player_sync_writer(bs, data)
+	local playerId = data[1]
+	local data = data[2]
+	bswrite.uint16(bs, playerId)
+	bswrite.bool(bs, data.leftRightKeys ~= nil)
+	if data.leftRightKeys then bswrite.uint16(bs, data.leftRightKeys) end
+	bswrite.bool(bs, data.upDownKeys ~= nil)
+	if data.upDownKeys then bswrite.uint16(bs, data.upDownKeys) end
+	bswrite.uint16(bs, data.keysData)
+	bswrite.vector3d(bs, data.position)
+	bswrite.normQuat(bs, data.quaternion)
+	bswrite.uint8(bs, utils.compress_health_and_armor(data.health, data.armor))
+	bswrite.uint8(bs, data.weapon)
+	bswrite.uint8(bs, data.specialAction)
+	bswrite.compressedVector(bs, data.moveSpeed)
+	bswrite.bool(bs, data.surfingVehicleId ~= nil)
+	if data.surfingVehicleId then
+		bswrite.uint16(bs, data.surfingVehicleId)
+		bswrite.vector3d(bs, data.surfingOffsets)
+	end
+	bswrite.bool(bs, data.animationId ~= nil)
+	if data.animationId then
+		bswrite.uint16(bs, data.animationId)
+		bswrite.uint16(bs, data.animationFlags)
+	end
+end
+
+--- onVehicleSync
+function handler.packet_vehicle_sync_reader(bs)
+	local data = {}
+	local playerId = bsread.uint16(bs)
+	local vehicleId = bsread.uint16(bs)
+	data.leftRightKeys = bsread.uint16(bs)
+	data.upDownKeys = bsread.uint16(bs)
+	data.keysData = bsread.uint16(bs)
+	data.quaternion = bsread.normQuat(bs)
+	data.position = bsread.vector3d(bs)
+	data.moveSpeed = bsread.compressedVector(bs)
+	data.vehicleHealth = bsread.uint16(bs)
+	data.playerHealth, data.armor = utils.decompress_health_and_armor(bsread.uint8(bs))
+	data.currentWeapon = bsread.uint8(bs)
+	data.siren = bsread.bool(bs)
+	data.landingGear = bsread.bool(bs)
+	if bsread.bool(bs) then
+		data.trainSpeed = bsread.int32(bs)
+	end
+	if bsread.bool(bs) then
+		data.trailerId = bsread.uint16(bs)
+	end
+	return {playerId, vehicleId, data}
+end
+
+function handler.packet_vehicle_sync_writer(bs, data)
+	local playerId = data[1]
+	local vehicleId = data[2]
+	local data = data[3]
+	bswrite.uint16(bs, playerId)
+	bswrite.uint16(bs, vehicleId)
+	bswrite.uint16(bs, data.leftRightKeys)
+	bswrite.uint16(bs, data.upDownKeys)
+	bswrite.uint16(bs, data.keysData)
+	bswrite.normQuat(bs, data.quaternion)
+	bswrite.vector3d(bs, data.position)
+	bswrite.compressedVector(bs, data.moveSpeed)
+	bswrite.uint16(bs, data.vehicleHealth)
+	bswrite.uint8(bs, utils.compress_health_and_armor(data.playerHealth, data.armor))
+	bswrite.uint8(bs, data.currentWeapon)
+	bswrite.bool(bs, data.siren)
+	bswrite.bool(bs, data.landingGear)
+	bswrite.bool(bs, data.trainSpeed ~= nil)
+	if data.trainSpeed ~= nil then
+		bswrite.int32(bs, data.trainSpeed)
+	end
+	bswrite.bool(bs, data.trailerId ~= nil)
+	if data.trailerId ~= nil then
+		bswrite.uint16(bs, data.trailerId)
+	end
+end
+
+--- onVehicleStreamIn
+function handler.rpc_vehicle_stream_in_reader(bs)
+	local data = {modSlots = {}}
+	local vehicleId = bsread.uint16(bs)
+	data.type = bsread.int32(bs)
+	data.position = bsread.vector3d(bs)
+	data.rotation = bsread.float(bs)
+	data.bodyColor1 = bsread.uint8(bs)
+	data.bodyColor2 = bsread.uint8(bs)
+	data.health = bsread.float(bs)
+	data.interiorId = bsread.uint8(bs)
+	data.doorDamageStatus = bsread.int32(bs)
+	data.panelDamageStatus = bsread.int32(bs)
+	data.lightDamageStatus = bsread.uint8(bs)
+	data.tireDamageStatus = bsread.uint8(bs)
+	data.addSiren = bsread.uint8(bs)
+	for i = 1, 14 do
+		data.modSlots[i] = bsread.uint8(bs)
+	end
+	data.paintJob = bsread.uint8(bs)
+	data.interiorColor1 = bsread.int32(bs)
+	data.interiorColor2 = bsread.int32(bs)
+	return {vehicleId, data}
+end
+
+function handler.rpc_vehicle_stream_in_writer(bs, data)
+	local vehicleId = data[1]
+	local data = data[2]
+	bswrite.uint16(bs, vehicleId)
+	bswrite.int32(bs, data.type)
+	bswrite.vector3d(bs, data.position)
+	bswrite.float(bs, data.rotation)
+	bswrite.uint8(bs, data.bodyColor1)
+	bswrite.uint8(bs, data.bodyColor2)
+	bswrite.float(bs, data.health)
+	bswrite.uint8(bs, data.interiorId)
+	bswrite.int32(bs, data.doorDamageStatus)
+	bswrite.int32(bs, data.panelDamageStatus)
+	bswrite.uint8(bs, data.lightDamageStatus)
+	bswrite.uint8(bs, data.tireDamageStatus)
+	bswrite.uint8(bs, data.addSiren)
+	for i = 1, 14 do
+		bswrite.uint8(bs, data.modSlots[i])
+	end
+	bswrite.uint8(bs, data.paintJob)
+	bswrite.int32(bs, data.interiorColor1)
+	bswrite.int32(bs, data.interiorColor2)
+end
+
+local MATERIAL_TYPE = {
+	NONE = 0,
+	TEXTURE = 1,
+	TEXT = 2,
+}
+
+local function read_object_material(bs)
+	local data = {}
+	data.materialId = bsread.uint8(bs)
+	data.modelId = bsread.uint16(bs)
+	data.libraryName = bsread.string8(bs)
+	data.textureName = bsread.string8(bs)
+	data.color = bsread.int32(bs)
+	data.type = MATERIAL_TYPE.TEXTURE
+	return data
+end
+
+local function write_object_material(bs, data)
+	bswrite.uint8(bs, data.type)
+	bswrite.uint8(bs, data.materialId)
+	bswrite.uint16(bs, data.modelId)
+	bswrite.string8(bs, data.libraryName)
+	bswrite.string8(bs, data.textureName)
+	bswrite.int32(bs, data.color)
+end
+
+local function read_object_material_text(bs)
+	local data = {}
+	data.materialId = bsread.uint8(bs)
+	data.materialSize = bsread.uint8(bs)
+	data.fontName = bsread.string8(bs)
+	data.fontSize = bsread.uint8(bs)
+	data.bold = bsread.uint8(bs)
+	data.fontColor = bsread.int32(bs)
+	data.backGroundColor = bsread.int32(bs)
+	data.align = bsread.uint8(bs)
+	data.text = bsread.encodedString2048(bs)
+	data.type = MATERIAL_TYPE.TEXT
+	return data
+end
+
+local function write_object_material_text(bs, data)
+	bswrite.uint8(bs, data.type)
+	bswrite.uint8(bs, data.materialId)
+	bswrite.uint8(bs, data.materialSize)
+	bswrite.string8(bs, data.fontName)
+	bswrite.uint8(bs, data.fontSize)
+	bswrite.uint8(bs, data.bold)
+	bswrite.int32(bs, data.fontColor)
+	bswrite.int32(bs, data.backGroundColor)
+	bswrite.uint8(bs, data.align)
+	bswrite.encodedString2048(bs, data.text)
+end
+
+--- onSetObjectMaterial
+function handler.rpc_set_object_material_reader(bs)
+	local objectId = bsread.uint16(bs)
+	local materialType = bsread.uint8(bs)
+	local material
+	if materialType == MATERIAL_TYPE.TEXTURE then
+		material = read_object_material(bs)
+	elseif materialType == MATERIAL_TYPE.TEXT then
+		material = read_object_material_text(bs)
+	end
+	local ev = materialType == MATERIAL_TYPE.TEXTURE and 'onSetObjectMaterial' or 'onSetObjectMaterialText'
+	return ev, {objectId, material}
+end
+
+function handler.rpc_set_object_material_writer(bs, data)
+	local objectId = data[1]
+	local mat = data[2]
+	bswrite.uint16(bs, objectId)
+	if mat.type == MATERIAL_TYPE.TEXTURE then
+		write_object_material(bs, mat)
+	elseif mat.type == MATERIAL_TYPE.TEXT then
+		write_object_material_text(bs, mat)
+	end
+end
+
+--- onCreateObject
+function handler.rpc_create_object_reader(bs)
+	local data = {materials = {}, materialText = {}}
+	local objectId = bsread.uint16(bs)
+	data.modelId = bsread.int32(bs)
+	data.position = bsread.vector3d(bs)
+	data.rotation = bsread.vector3d(bs)
+	data.drawDistance = bsread.float(bs)
+	data.noCameraCol = bsread.bool8(bs)
+	data.attachToVehicleId = bsread.uint16(bs)
+	data.attachToObjectId = bsread.uint16(bs)
+	if data.attachToVehicleId ~= 0xFFFF or data.attachToObjectId ~= 0xFFFF then
+		data.attachOffsets = bsread.vector3d(bs)
+		data.attachRotation = bsread.vector3d(bs)
+		data.syncRotation = bsread.bool8(bs)
+	end
+	data.texturesCount = bsread.uint8(bs)
+	while raknetBitStreamGetNumberOfUnreadBits(bs) >= 8 do
+		local materialType = bsread.uint8(bs)
+		if materialType == MATERIAL_TYPE.TEXTURE then
+			table.insert(data.materials, read_object_material(bs))
+		elseif materialType == MATERIAL_TYPE.TEXT then
+			table.insert(data.materialText, read_object_material_text(bs))
+		end
+	end
+	data.materials_text = data.materialText -- obsolete
+	return {objectId, data}
+end
+
+function handler.rpc_create_object_writer(bs, data)
+	local objectId = data[1]
+	local data = data[2]
+	bswrite.uint16(bs, objectId)
+	bswrite.int32(bs, data.modelId)
+	bswrite.vector3d(bs, data.position)
+	bswrite.vector3d(bs, data.rotation)
+	bswrite.float(bs, data.drawDistance)
+	bswrite.bool8(bs, data.noCameraCol)
+	bswrite.uint16(bs, data.attachToVehicleId)
+	bswrite.uint16(bs, data.attachToObjectId)
+	if data.attachToVehicleId ~= 0xFFFF or data.attachToObjectId ~= 0xFFFF then
+		bswrite.vector3d(bs, data.attachOffsets)
+		bswrite.vector3d(bs, data.attachRotation)
+		bswrite.bool8(bs, data.syncRotation)
+	end
+	bswrite.uint8(bs, data.texturesCount)
+	for _, it in ipairs(data.materials) do
+		write_object_material(bs, it)
+	end
+	for _, it in ipairs(data.materialText) do
+		write_object_material_text(bs, it)
+	end
+end
+
+function handler.rpc_update_scores_and_pings_reader(bs)
+	local data = {}
+	for i = 1, raknetBitStreamGetNumberOfBytesUsed(bs) / 10 do
+		local playerId = bsread.uint16(bs)
+		local playerScore = bsread.int32(bs)
+		local playerPing = bsread.int32(bs)
+		data[playerId] = {score = playerScore, ping = playerPing}
+	end
+	return {data}
+end
+
+function handler.rpc_update_scores_and_pings_writer(bs, data)
+	for id, info in pairs(data[1]) do
+		bswrite.uint16(bs, id)
+		bswrite.int32(bs, info.score)
+		bswrite.int32(bs, info.ping)
+	end
+end
+
+function handler.packet_weapons_update_reader(bs)
+	local playerTarget = bsread.uint16(bs)
+	local actorTarget = bsread.uint16(bs)
+	local weapons = {}
+	local count = raknetBitStreamGetNumberOfUnreadBits(bs) / 32
+	for i = 1, count do
+		local slot = bsread.uint8(bs)
+		local weapon = bsread.uint8(bs)
+		local ammo = bsread.uint16(bs)
+		weapons[i] = {slot = slot, weapon = weapon, ammo = ammo}
+	end
+	return {playerTarget, actorTarget, weapons}
+end
+
+function handler.packet_weapons_update_writer(bs, data)
+	bswrite.uint16(bs, data[1])
+	bswrite.uint16(bs, data[2])
+	for i, weap in ipairs(data[3]) do
+		bswrite.uint8(bs, weap.slot)
+		bswrite.uint8(bs, weap.weapon)
+		bswrite.uint16(bs, weap.ammo)
+	end
+end
+
+return handler

raknet.lua

@@ -1,700 +1,236 @@
---[[
-    Project: SF.lua <https://github.com/imring/SF.lua>
-    License: MIT License
-    Author: imring
-]]
-
-local sampapi = require 'sampapi'
-local shared = require 'sampapi.shared'
-local ffi = shared.ffi
-
-local netgame = sampapi.require('CNetGame', true)
-local rakluaLoaded, raklua = pcall(require, 'RakLua')
-
-if not rakluaLoaded then
-require 'sflua.cdef.bitstream'
-local StringCompressor = require 'sflua.cdef.stringcompressor'
-
-function raknetBitStreamReadBool(bitstream)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    return bitstream:ReadBit()
-end
-jit.off(raknetBitStreamReadBool, true)
-
-function raknetBitStreamReadBuffer(bitstream, dest, size)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    bitstream:ReadBits(dest, size * 8, true)
-end
-jit.off(raknetBitStreamReadBuffer, true)
-
-function raknetBitStreamReadInt8(bitstream)
-    local buf = ffi.new('char[1]')
-    raknetBitStreamReadBuffer(bitstream, buf, ffi.sizeof(buf))
-    return buf[0]
-end
-jit.off(raknetBitStreamReadInt8, true)
-
-function raknetBitStreamReadInt16(bitstream)
-    local buf = ffi.new('short[1]')
-    raknetBitStreamReadBuffer(bitstream, buf, ffi.sizeof(buf))
-    return buf[0]
-end
-jit.off(raknetBitStreamReadInt16, true)
-
-function raknetBitStreamReadInt32(bitstream)
-    local buf = ffi.new('long [1]')
-    raknetBitStreamReadBuffer(bitstream, buf, ffi.sizeof(buf))
-    return buf[0]
-end
-jit.off(raknetBitStreamReadInt32, true)
-
-function raknetBitStreamReadFloat(bitstream)
-    local buf = ffi.new('float[1]')
-    raknetBitStreamReadBuffer(bitstream, buf, ffi.sizeof(buf))
-    return buf[0]
-end
-jit.off(raknetBitStreamReadFloat, true)
-
-function raknetBitStreamReadString(bitstream, size)
-    local buf = ffi.new('char[?]', size + 1)
-    raknetBitStreamReadBuffer(bitstream, buf, ffi.sizeof(buf) - 1)
-    buf[size] = 0
-    return ffi.string(buf)
-end
-jit.off(raknetBitStreamReadString, true)
-
-function raknetBitStreamResetReadPointer(bitstream)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    bitstream:ResetReadPointer()
-end
-jit.off(raknetBitStreamResetReadPointer, true)
-
-function raknetBitStreamResetWritePointer(bitstream)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    bitstream:ResetWritePointer()
-end
-jit.off(raknetBitStreamResetWritePointer, true)
-
-function raknetBitStreamIgnoreBits(bitstream, amount)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    bitstream:IgnoreBits(amount)
-end
-jit.off(raknetBitStreamIgnoreBits, true)
-
-function raknetBitStreamSetWriteOffset(bitstream, offset)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    bitstream:SetWriteOffset(offset)
-end
-jit.off(raknetBitStreamSetWriteOffset, true)
-
-function raknetBitStreamSetReadOffset(bitstream, offset)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    bitstream.readOffset = offset
-end
-jit.off(raknetBitStreamSetReadOffset, true)
-
-function raknetBitStreamGetNumberOfBitsUsed(bitstream)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    return bitstream.numberOfBitsUsed
-end
-jit.off(raknetBitStreamGetNumberOfBitsUsed, true)
-
-function raknetBitStreamGetNumberOfBytesUsed(bitstream)
-    local bits = raknetBitStreamGetNumberOfBitsUsed(bitstream)
-    return bit.rshift(bits + 7, 3)
-end
-jit.off(raknetBitStreamGetNumberOfBytesUsed, true)
-
-function raknetBitStreamGetNumberOfUnreadBits(bitstream)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    return bitstream.numberOfBitsAllocated - bitstream.numberOfBitsUsed
-end
-jit.off(raknetBitStreamGetNumberOfUnreadBits, true)
-
-function raknetBitStreamGetWriteOffset(bitstream)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    return bitstream.numberOfBitsUsed
-end
-jit.off(raknetBitStreamGetWriteOffset, true)
-
-function raknetBitStreamGetReadOffset(bitstream)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    return bitstream.readOffset
-end
-jit.off(raknetBitStreamGetReadOffset, true)
-
-function raknetBitStreamGetDataPtr(bitstream)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    return shared.get_pointer(bitstream.data)
-end
-jit.off(raknetBitStreamGetDataPtr, true)
-
-function raknetNewBitStream()
-    local bitstream = bs()
-    return shared.get_pointer(bitstream)
-end
-jit.off(raknetNewBitStream, true)
-
-function raknetDeleteBitStream(bitstream)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    bitstream:__gc()
-end
-jit.off(raknetDeleteBitStream, true)
-
-function raknetResetBitStream(bitstream)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    bitstream:Reset()
-end
-jit.off(raknetResetBitStream, true)
-
-function raknetBitStreamWriteBool(bitstream, value)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    if value then bitstream:Write1()
-    else bitstream:Write0() end
-end
-jit.off(raknetBitStreamWriteBool, true)
-
-function raknetBitStreamWriteInt8(bitstream, value)
-    local buf = ffi.new('char[1]', value)
-    raknetBitStreamWriteBuffer(bitstream, buf, ffi.sizeof(buf))
-end
-jit.off(raknetBitStreamWriteInt8, true)
-
-function raknetBitStreamWriteInt16(bitstream, value)
-    local buf = ffi.new('short[1]', value)
-    raknetBitStreamWriteBuffer(bitstream, buf, ffi.sizeof(buf))
-end
-jit.off(raknetBitStreamWriteInt16, true)
-
-function raknetBitStreamWriteInt32(bitstream, value)
-    local buf = ffi.new('long[1]', value)
-    raknetBitStreamWriteBuffer(bitstream, buf, ffi.sizeof(buf))
-end
-jit.off(raknetBitStreamWriteInt32, true)
-
-function raknetBitStreamWriteFloat(bitstream, value)
-    local buf = ffi.new('float[1]', value)
-    raknetBitStreamWriteBuffer(bitstream, buf, ffi.sizeof(buf))
-end
-jit.off(raknetBitStreamWriteFloat, true)
-
-function raknetBitStreamWriteBuffer(bitstream, dest, size)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    bitstream:WriteBits(dest, size * 8, true)
-end
-jit.off(raknetBitStreamWriteBuffer, true)
-
-function raknetBitStreamWriteString(bitstream, str)
-    local buf = ffi.new('char[?]', #str + 1, str)
-    raknetBitStreamWriteBuffer(bitstream, buf, ffi.sizeof(buf) - 1)
-end
-jit.off(raknetBitStreamWriteString, true)
-
-function raknetBitStreamDecodeString(bitstream, size)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    local buf = ffi.new('char[?]', size + 1)
-    StringCompressor.Instance():DecodeString(buf, size, bitstream, 0)
-    buf[size] = 0
-    return ffi.string(buf)
-end
-jit.off(raknetBitStreamDecodeString, true)
-
-function raknetBitStreamEncodeString(bitstream, str)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    local buf = ffi.new('char[?]', #str + 1, str)
-    StringCompressor.Instance():EncodeString(buf, #str, bitstream, 0)
-end
-jit.off(raknetBitStreamEncodeString, true)
-
-function raknetBitStreamWriteBitStream(bitstream, bitStream)
-    bitstream = ffi.cast('SBitStream*', bitstream)
-    bitstream:Write(bitStream)
-end
-jit.off(raknetBitStreamWriteBitStream, true)
-
-function raknetSendRpcEx(rpc, bs, priority, reliability, channel, timestamp)
-    local rakclient = ffi.cast('void***', netgame.RefNetGame().m_pRakClient)
-    local vtbl = rakclient[0]
-    rpc = ffi.new('int[1]', rpc)
-    bs = ffi.cast('SBitStream*', bs)
-
-    -- RPC(int *uniqueID, RakNet::BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, bool shiftTimestamp)
-    local RPC = ffi.cast('bool(__thiscall *)(void *, int *, SBitStream *, int, int, char, bool)', vtbl[25])
-    return RPC(rakclient, rpc, bs, priority, reliability, channel, timestamp)
-end
-jit.off(raknetSendRpcEx, true)
-
-function raknetSendBitStreamEx(bs, priority, reliability, channel)
-    local rakclient = ffi.cast('void***', netgame.RefNetGame().m_pRakClient)
-    local vtbl = rakclient[0]
-    bs = ffi.cast('SBitStream*', bs)
-
-    -- Send(RakNet::BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel)
-    local Send = ffi.cast('bool(__thiscall *)(void *, SBitStream *, int, int, char)', vtbl[6])
-    return Send(rakclient, bs, priority, reliability, channel)
-end
-jit.off(raknetSendBitStreamEx, true)
-
-function raknetSendRpc(rpc, bs)
-    return raknetSendRpcEx(rpc, bs, HIGH_PRIORITY, RELIABLE, 0, false)
-end
-
-function raknetSendBitStream(bs)
-    return raknetSendBitStreamEx(bs, HIGH_PRIORITY, UNRELIABLE_SEQUENCED, 0)
-end
-
-end
-
-function raknetGetRpcName(id)
-    local tab = {
-        [23] = 'ClickPlayer',
-        [25] = 'ClientJoin',
-        [26] = 'EnterVehicle',
-        [27] = 'EnterEditObject',
-        [31] = 'ScriptCash',
-        [50] = 'ServerCommand',
-        [52] = 'Spawn',
-        [53] = 'Death',
-        [54] = 'NPCJoin',
-        [62] = 'DialogResponse',
-        [83] = 'ClickTextDraw',
-        [96] = 'SCMEvent',
-        [101] = 'Chat',
-        [102] = 'SrvNetStats',
-        [103] = 'ClientCheck',
-        [106] = 'DamageVehicle',
-        [115] = 'GiveTakeDamage',
-        [116] = 'EditAttachedObject',
-        [117] = 'EditObject',
-        [118] = 'SetInteriorId',
-        [119] = 'MapMarker',
-        [128] = 'RequestClass',
-        [129] = 'RequestSpawn',
-        [131] = 'PickedUpPickup',
-        [132] = 'MenuSelect',
-        [136] = 'VehicleDestroyed',
-        [140] = 'MenuQuit',
-        [154] = 'ExitVehicle',
-        [155] = 'UpdateScoresPingsIPs',
-        [11] = 'SetPlayerName',
-        [12] = 'SetPlayerPos',
-        [13] = 'SetPlayerPosFindZ',
-        [14] = 'SetPlayerHealth',
-        [15] = 'TogglePlayerControllable',
-        [16] = 'PlaySound',
-        [17] = 'SetPlayerWorldBounds',
-        [18] = 'GivePlayerMoney',
-        [19] = 'SetPlayerFacingAngle',
-        [20] = 'ResetPlayerMoney',
-        [21] = 'ResetPlayerWeapons',
-        [22] = 'GivePlayerWeapon',
-        [24] = 'SetVehicleParamsEx',
-        [28] = 'CancelEdit',
-        [29] = 'SetPlayerTime',
-        [30] = 'ToggleClock',
-        [32] = 'WorldPlayerAdd',
-        [33] = 'SetPlayerShopName',
-        [34] = 'SetPlayerSkillLevel',
-        [35] = 'SetPlayerDrunkLevel',
-        [36] = 'Create3DTextLabel',
-        [37] = 'DisableCheckpoint',
-        [38] = 'SetRaceCheckpoint',
-        [39] = 'DisableRaceCheckpoint',
-        [40] = 'GameModeRestart',
-        [41] = 'PlayAudioStream',
-        [42] = 'StopAudioStream',
-        [43] = 'RemoveBuildingForPlayer',
-        [44] = 'CreateObject',
-        [45] = 'SetObjectPos',
-        [46] = 'SetObjectRot',
-        [47] = 'DestroyObject',
-        [55] = 'DeathMessage',
-        [56] = 'SetPlayerMapIcon',
-        [57] = 'RemoveVehicleComponent',
-        [58] = 'Update3DTextLabel',
-        [59] = 'ChatBubble',
-        [60] = 'UpdateSystemTime',
-        [61] = 'ShowDialog',
-        [63] = 'DestroyPickup',
-        [64] = 'WeaponPickupDestroy',
-        [65] = 'LinkVehicleToInterior',
-        [66] = 'SetPlayerArmour',
-        [67] = 'SetPlayerArmedWeapon',
-        [68] = 'SetSpawnInfo',
-        [69] = 'SetPlayerTeam',
-        [70] = 'PutPlayerInVehicle',
-        [71] = 'RemovePlayerFromVehicle',
-        [72] = 'SetPlayerColor',
-        [73] = 'DisplayGameText',
-        [74] = 'ForceClassSelection',
-        [75] = 'AttachObjectToPlayer',
-        [76] = 'InitMenu',
-        [77] = 'ShowMenu',
-        [78] = 'HideMenu',
-        [79] = 'CreateExplosion',
-        [80] = 'ShowPlayerNameTagForPlayer',
-        [81] = 'AttachCameraToObject',
-        [82] = 'InterpolateCamera',
-        [84] = 'SetObjectMaterial',
-        [85] = 'GangZoneStopFlash',
-        [86] = 'ApplyAnimation',
-        [87] = 'ClearAnimations',
-        [88] = 'SetPlayerSpecialAction',
-        [89] = 'SetPlayerFightingStyle',
-        [90] = 'SetPlayerVelocity',
-        [91] = 'SetVehicleVelocity',
-        [92] = 'SetPlayerDrunkVisuals',
-        [93] = 'ClientMessage',
-        [94] = 'SetWorldTime',
-        [95] = 'CreatePickup',
-        [98] = 'SetVehicleTireStatus',
-        [99] = 'MoveObject',
-        [104] = 'EnableStuntBonusForPlayer',
-        [105] = 'TextDrawSetString',
-        [107] = 'SetCheckpoint',
-        [108] = 'GangZoneCreate',
-        [112] = 'PlayCrimeReport',
-        [113] = 'SetPlayerAttachedObject',
-        [120] = 'GangZoneDestroy',
-        [121] = 'GangZoneFlash',
-        [122] = 'StopObject',
-        [123] = 'SetNumberPlate',
-        [124] = 'TogglePlayerSpectating',
-        [126] = 'PlayerSpectatePlayer',
-        [127] = 'PlayerSpectateVehicle',
-        [133] = 'SetPlayerWantedLevel',
-        [134] = 'ShowTextDraw',
-        [135] = 'TextDrawHideForPlayer',
-        [137] = 'ServerJoin',
-        [138] = 'ServerQuit',
-        [139] = 'InitGame',
-        [144] = 'RemovePlayerMapIcon',
-        [145] = 'SetPlayerAmmo',
-        [146] = 'SetPlayerGravity',
-        [147] = 'SetVehicleHealth',
-        [148] = 'AttachTrailerToVehicle',
-        [149] = 'DetachTrailerFromVehicle',
-        [150] = 'SetPlayerDrunkHandling',
-        [151] = 'DestroyPickups',
-        [152] = 'SetWeather',
-        [153] = 'SetPlayerSkin',
-        [156] = 'SetPlayerInterior',
-        [157] = 'SetPlayerCameraPos',
-        [158] = 'SetPlayerCameraLookAt',
-        [159] = 'SetVehiclePos',
-        [160] = 'SetVehicleZAngle',
-        [161] = 'SetVehicleParamsForPlayer',
-        [162] = 'SetCameraBehindPlayer',
-        [163] = 'WorldPlayerRemove',
-        [164] = 'WorldVehicleAdd',
-        [165] = 'WorldVehicleRemove',
-        [166] = 'WorldPlayerDeath'
-    }
-    return tab[id]
-end
-
-function raknetGetPacketName(id)
-    local tab = {
-        [6] = 'INTERNAL_PING',
-        [7] = 'PING',
-        [8] = 'PING_OPEN_CONNECTIONS',
-        [9] = 'CONNECTED_PONG',
-        [10] = 'REQUEST_STATIC_DATA',
-        [11] = 'CONNECTION_REQUEST',
-        [12] = 'AUTH_KEY',
-        [14] = 'BROADCAST_PINGS',
-        [15] = 'SECURED_CONNECTION_RESPONSE',
-        [16] = 'SECURED_CONNECTION_CONFIRMATION',
-        [17] = 'RPC_MAPPING',
-        [19] = 'SET_RANDOM_NUMBER_SEED',
-        [20] = 'RPC',
-        [21] = 'RPC_REPLY',
-        [23] = 'DETECT_LOST_CONNECTIONS',
-        [24] = 'OPEN_CONNECTION_REQUEST',
-        [25] = 'OPEN_CONNECTION_REPLY',
-        [26] = 'CONNECTION_COOKIE',
-        [28] = 'RSA_PUBLIC_KEY_MISMATCH',
-        [29] = 'CONNECTION_ATTEMPT_FAILED',
-        [30] = 'NEW_INCOMING_CONNECTION',
-        [31] = 'NO_FREE_INCOMING_CONNECTIONS',
-        [32] = 'DISCONNECTION_NOTIFICATION',
-        [33] = 'CONNECTION_LOST',
-        [34] = 'CONNECTION_REQUEST_ACCEPTED',
-        [35] = 'INITIALIZE_ENCRYPTION',
-        [36] = 'CONNECTION_BANNED',
-        [37] = 'INVALID_PASSWORD',
-        [38] = 'MODIFIED_PACKET',
-        [39] = 'PONG',
-        [40] = 'TIMESTAMP',
-        [41] = 'RECEIVED_STATIC_DATA',
-        [42] = 'REMOTE_DISCONNECTION_NOTIFICATION',
-        [43] = 'REMOTE_CONNECTION_LOST',
-        [44] = 'REMOTE_NEW_INCOMING_CONNECTION',
-        [45] = 'REMOTE_EXISTING_CONNECTION',
-        [46] = 'REMOTE_STATIC_DATA',
-        [56] = 'ADVERTISE_SYSTEM',
-        [200] = 'VEHICLE_SYNC',
-        [201] = 'RCON_COMMAND',
-        [202] = 'RCON_RESPONCE',
-        [203] = 'AIM_SYNC',
-        [204] = 'WEAPONS_UPDATE',
-        [205] = 'STATS_UPDATE',
-        [206] = 'BULLET_SYNC',
-        [207] = 'PLAYER_SYNC',
-        [208] = 'MARKERS_SYNC',
-        [209] = 'UNOCCUPIED_SYNC',
-        [210] = 'TRAILER_SYNC',
-        [211] = 'PASSENGER_SYNC',
-        [212] = 'SPECTATOR_SYNC'
-    }
-    return tab[id]
-end
-
-function sampGetRakclientInterface()
-    return shared.get_pointer(netgame.RefNetGame().m_pRakClient)
-end
-jit.off(sampGetRakclientInterface, true)
-
-function sampGetRakpeer()
-    return shared.get_pointer(netgame.RefNetGame().m_pRakClient) - 0xDDE -- 0xDDE = sizeof(RakPeer)
-end
-jit.off(sampGetRakpeer, true)
-
-function sampSendAimData(data)
-    local bs = raknetNewBitStream()
-    raknetBitStreamReadInt8(bs, PACKET_AIM_SYNC)
-    raknetBitStreamWriteBuffer(bs, data, ffi.sizeof('SAimData'))
-    raknetSendBitStream(bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendBulletData(data)
-    local bs = raknetNewBitStream()
-    raknetBitStreamReadInt8(bs, PACKET_BULLET_SYNC)
-    raknetBitStreamWriteBuffer(bs, data, ffi.sizeof('SBulletData'))
-    raknetSendBitStream(bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendIncarData(data)
-    local bs = raknetNewBitStream()
-    raknetBitStreamReadInt8(bs, PACKET_VEHICLE_SYNC)
-    raknetBitStreamWriteBuffer(bs, data, ffi.sizeof('SIncarData'))
-    raknetSendBitStream(bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendOnfootData(data)
-    local bs = raknetNewBitStream()
-    raknetBitStreamReadInt8(bs, PACKET_PLAYER_SYNC)
-    raknetBitStreamWriteBuffer(bs, data, ffi.sizeof('SOnfootData'))
-    raknetSendBitStream(bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendSpectatorData(data)
-    local bs = raknetNewBitStream()
-    raknetBitStreamReadInt8(bs, PACKET_SPECTATOR_SYNC)
-    raknetBitStreamWriteBuffer(bs, data, ffi.sizeof('SSpectatorData'))
-    raknetSendBitStream(bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendTrailerData(data)
-    local bs = raknetNewBitStream()
-    raknetBitStreamReadInt8(bs, PACKET_TRAILER_SYNC)
-    raknetBitStreamWriteBuffer(bs, data, ffi.sizeof('STrailerData'))
-    raknetSendBitStream(bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendPassengerData(data)
-    local bs = raknetNewBitStream()
-    raknetBitStreamReadInt8(bs, PACKET_PASSENGER_SYNC)
-    raknetBitStreamWriteBuffer(bs, data, ffi.sizeof('SPassengerData'))
-    raknetSendBitStream(bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendUnoccupiedData(data)
-    local bs = raknetNewBitStream()
-    raknetBitStreamReadInt8(bs, PACKET_UNOCCUPIED_SYNC)
-    raknetBitStreamWriteBuffer(bs, data, ffi.sizeof('SUnoccupiedData'))
-    raknetSendBitStream(bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendDamageVehicle(car, panel, doors, lights, tires)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteInt16(bs, car) -- TODO: is car a handle or an id?
-    raknetBitStreamWriteInt32(bs, panel)
-    raknetBitStreamWriteInt32(bs, doors)
-    raknetBitStreamWriteInt8(bs, lights)
-    raknetBitStreamWriteInt8(bs, tires)
-    raknetSendRpc(RPC_DAMAGEVEHICLE, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendScmEvent(event, id, param1, param2)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteInt32(bs, id)
-    raknetBitStreamWriteInt32(bs, param1)
-    raknetBitStreamWriteInt32(bs, param2)
-    raknetBitStreamWriteInt32(bs, event)
-    raknetSendRpc(RPC_SCMEVENT, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendGiveDamage(id, damage, weapon, bodypart)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteBool(bs, false)
-    raknetBitStreamWriteInt16(bs, id)
-    raknetBitStreamWriteFloat(bs, damage)
-    raknetBitStreamWriteInt32(bs, weapon)
-    raknetBitStreamWriteInt32(bs, bodypart)
-    raknetSendRpc(RPC_GIVETAKEDAMAGE, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendTakeDamage(id, damage, weapon, bodypart)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteBool(bs, true)
-    raknetBitStreamWriteInt16(bs, id)
-    raknetBitStreamWriteFloat(bs, damage)
-    raknetBitStreamWriteInt32(bs, weapon)
-    raknetBitStreamWriteInt32(bs, bodypart)
-    raknetSendRpc(RPC_GIVETAKEDAMAGE, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendRequestSpawn()
-    local bs = raknetNewBitStream()
-    raknetSendRpc(RPC_REQUESTSPAWN, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendClickPlayer(id, source)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteInt16(bs, id)
-    raknetBitStreamWriteInt8(bs, source)
-    raknetSendRpc(RPC_CLICKPLAYER, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendClickTextdraw(id)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteInt16(bs, id)
-    raknetSendRpc(RPC_CLICKTEXTDRAW, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendDeathByPlayer(playerId, reason)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteInt8(bs, reason)
-    raknetBitStreamWriteInt16(bs, playerId)
-    raknetSendRpc(RPC_DEATH, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendDialogResponse(id, button, listitem, input)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteInt16(bs, id)
-    raknetBitStreamWriteInt8(bs, button)
-    raknetBitStreamWriteInt16(bs, listitem)
-    raknetBitStreamWriteInt8(bs, #input)
-    raknetBitStreamWriteString(bs, input)
-    raknetSendRpc(RPC_DIALOGRESPONSE, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendEditAttachedObject(response, index, model, bone, offsetX, offsetY, offsetZ, rotX, rotY, rotZ, scaleX, scaleY, scaleZ)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteInt32(bs, response)
-    raknetBitStreamWriteInt32(bs, index)
-    raknetBitStreamWriteInt32(bs, model)
-    raknetBitStreamWriteInt32(bs, bone)
-    raknetBitStreamWriteFloat(bs, offsetX)
-    raknetBitStreamWriteFloat(bs, offsetY)
-    raknetBitStreamWriteFloat(bs, offsetZ)
-    raknetBitStreamWriteFloat(bs, rotX)
-    raknetBitStreamWriteFloat(bs, rotY)
-    raknetBitStreamWriteFloat(bs, rotZ)
-    raknetBitStreamWriteFloat(bs, scaleX)
-    raknetBitStreamWriteFloat(bs, scaleY)
-    raknetBitStreamWriteFloat(bs, scaleZ)
-    -- TODO: color1/color2?
-    raknetSendRpc(RPC_EDITATTACHEDOBJECT, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendEditObject(playerObject, objectId, response, posX, posY, posZ, rotX, rotY, rotZ)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteBool(bs, playerObject)
-    raknetBitStreamWriteInt16(bs, objectId)
-    raknetBitStreamWriteInt32(bs, response)
-    raknetBitStreamWriteFloat(bs, posX)
-    raknetBitStreamWriteFloat(bs, posY)
-    raknetBitStreamWriteFloat(bs, posZ)
-    raknetBitStreamWriteFloat(bs, rotX)
-    raknetBitStreamWriteFloat(bs, rotY)
-    raknetBitStreamWriteFloat(bs, rotZ)
-    raknetSendRpc(RPC_EDITOBJECT, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendMenuQuit()
-    local bs = raknetNewBitStream()
-    raknetSendRpc(RPC_MENUQUIT, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendMenuSelectRow(id)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteInt8(bs, id)
-    raknetSendRpc(RPC_MENUSELECT, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendPickedUpPickup(id)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteInt32(bs, id)
-    raknetSendRpc(RPC_PICKEDUPPICKUP, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendRconCommand(cmd)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteInt8(bs, PACKET_RCON_COMMAND)
-    raknetBitStreamWriteInt32(bs, #cmd)
-    raknetBitStreamWriteString(bs, cmd)
-    raknetSendBitStream(bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampSendVehicleDestroyed(id)
-    local bs = raknetNewBitStream()
-    raknetBitStreamWriteInt16(bs, id)
-    raknetSendRpc(RPC_VEHICLEDESTROYED, bs)
-    raknetDeleteBitStream(bs)
-end
-
-function sampDisconnectWithReason(reason)
-    local ref = netgame.RefNetGame()
-    local rakclient = ffi.cast('void***', ref.m_pRakClient)
-    local vtbl = rakclient[0]
-
-    -- Disconnect(unsigned int blockDuration, unsigned char orderingChannel = 0)
-    local Disconnect = ffi.cast('void(__thiscall *)(void *, unsigned int, unsigned char)', vtbl[2])
-    Disconnect(rakclient, reason, 0)
-
-    ref:ShutdownForRestart()
-end
-jit.off(sampDisconnectWithReason, true)
-
-function sampConnectToServer(ip, port)
-    local ref = netgame.RefNetGame()
-    ffi.copy(ref.m_szHostAddress, ip)
-    ref.m_nPort = port
-    sampSetGamestate(GAMESTATE_WAIT_CONNECT)
-end
-jit.off(sampConnectToServer, true)
+-- This file is part of the SAMP.Lua project.
+-- Licensed under the MIT License.
+-- Copyright (c) 2016, FYP @ BlastHack Team <blast.hk>
+-- https://github.com/THE-FYP/SAMP.Lua
+
+local mod =
+{
+	MODULEINFO = {
+		name = 'samp.raknet',
+		version = 2
+	}
+}
+require 'sampfuncs'
+
+mod.RPC = {
+	CLICKPLAYER                   = RPC_CLICKPLAYER,
+	CLIENTJOIN                    = RPC_CLIENTJOIN,
+	ENTERVEHICLE                  = RPC_ENTERVEHICLE,
+	SCRIPTCASH                    = RPC_SCRIPTCASH,
+	SERVERCOMMAND                 = RPC_SERVERCOMMAND,
+	SPAWN                         = RPC_SPAWN,
+	DEATH                         = RPC_DEATH,
+	NPCJOIN                       = RPC_NPCJOIN,
+	DIALOGRESPONSE                = RPC_DIALOGRESPONSE,
+	CLICKTEXTDRAW                 = RPC_CLICKTEXTDRAW,
+	SCMEVENT                      = RPC_SCMEVENT,
+	WEAPONPICKUPDESTROY           = RPC_WEAPONPICKUPDESTROY,
+	CHAT                          = RPC_CHAT,
+	SRVNETSTATS                   = RPC_SRVNETSTATS,
+	CLIENTCHECK                   = RPC_CLIENTCHECK,
+	DAMAGEVEHICLE                 = RPC_DAMAGEVEHICLE,
+	GIVETAKEDAMAGE                = RPC_GIVETAKEDAMAGE,
+	EDITATTACHEDOBJECT            = RPC_EDITATTACHEDOBJECT,
+	EDITOBJECT                    = RPC_EDITOBJECT,
+	SETINTERIORID                 = RPC_SETINTERIORID,
+	MAPMARKER                     = RPC_MAPMARKER,
+	REQUESTCLASS                  = RPC_REQUESTCLASS,
+	REQUESTSPAWN                  = RPC_REQUESTSPAWN,
+	PICKEDUPPICKUP                = RPC_PICKEDUPPICKUP,
+	MENUSELECT                    = RPC_MENUSELECT,
+	VEHICLEDESTROYED              = RPC_VEHICLEDESTROYED,
+	MENUQUIT                      = RPC_MENUQUIT,
+	EXITVEHICLE                   = RPC_EXITVEHICLE,
+	UPDATESCORESPINGSIPS          = RPC_UPDATESCORESPINGSIPS,
+	CAMTARGETUPDATE = 168,
+	GIVEACTORDAMAGE = 177,
+
+	CONNECTIONREJECTED            = 130,
+	SETPLAYERNAME                 = RPC_SCRSETPLAYERNAME,
+	SETPLAYERPOS                  = RPC_SCRSETPLAYERPOS,
+	SETPLAYERPOSFINDZ             = RPC_SCRSETPLAYERPOSFINDZ,
+	SETPLAYERHEALTH               = RPC_SCRSETPLAYERHEALTH,
+	TOGGLEPLAYERCONTROLLABLE      = RPC_SCRTOGGLEPLAYERCONTROLLABLE,
+	PLAYSOUND                     = RPC_SCRPLAYSOUND,
+	SETPLAYERWORLDBOUNDS          = RPC_SCRSETPLAYERWORLDBOUNDS,
+	GIVEPLAYERMONEY               = RPC_SCRGIVEPLAYERMONEY,
+	SETPLAYERFACINGANGLE          = RPC_SCRSETPLAYERFACINGANGLE,
+	RESETPLAYERMONEY              = RPC_SCRRESETPLAYERMONEY,
+	RESETPLAYERWEAPONS            = RPC_SCRRESETPLAYERWEAPONS,
+	GIVEPLAYERWEAPON              = RPC_SCRGIVEPLAYERWEAPON,
+	SETVEHICLEPARAMSEX            = RPC_SCRSETVEHICLEPARAMSEX,
+	CANCELEDIT                    = RPC_SCRCANCELEDIT,
+	SETPLAYERTIME                 = RPC_SCRSETPLAYERTIME,
+	TOGGLECLOCK                   = RPC_SCRTOGGLECLOCK,
+	WORLDPLAYERADD                = RPC_SCRWORLDPLAYERADD,
+	SETPLAYERSHOPNAME             = RPC_SCRSETPLAYERSHOPNAME,
+	SETPLAYERSKILLLEVEL           = RPC_SCRSETPLAYERSKILLLEVEL,
+	SETPLAYERDRUNKLEVEL           = RPC_SCRSETPLAYERDRUNKLEVEL,
+	CREATE3DTEXTLABEL             = RPC_SCRCREATE3DTEXTLABEL,
+	DISABLECHECKPOINT             = RPC_SCRDISABLECHECKPOINT,
+	SETRACECHECKPOINT             = RPC_SCRSETRACECHECKPOINT,
+	DISABLERACECHECKPOINT         = RPC_SCRDISABLERACECHECKPOINT,
+	GAMEMODERESTART               = RPC_SCRGAMEMODERESTART,
+	PLAYAUDIOSTREAM               = RPC_SCRPLAYAUDIOSTREAM,
+	STOPAUDIOSTREAM               = RPC_SCRSTOPAUDIOSTREAM,
+	REMOVEBUILDINGFORPLAYER       = RPC_SCRREMOVEBUILDINGFORPLAYER,
+	CREATEOBJECT                  = RPC_SCRCREATEOBJECT,
+	SETOBJECTPOS                  = RPC_SCRSETOBJECTPOS,
+	SETOBJECTROT                  = RPC_SCRSETOBJECTROT,
+	DESTROYOBJECT                 = RPC_SCRDESTROYOBJECT,
+	DEATHMESSAGE                  = RPC_SCRDEATHMESSAGE,
+	SETPLAYERMAPICON              = RPC_SCRSETPLAYERMAPICON,
+	REMOVEVEHICLECOMPONENT        = RPC_SCRREMOVEVEHICLECOMPONENT,
+	CHATBUBBLE                    = RPC_SCRCHATBUBBLE,
+	UPDATETIME                    = RPC_SCRSOMEUPDATE,
+	SHOWDIALOG                    = RPC_SCRSHOWDIALOG,
+	DESTROYPICKUP                 = RPC_SCRDESTROYPICKUP,
+	LINKVEHICLETOINTERIOR         = RPC_SCRLINKVEHICLETOINTERIOR,
+	SETPLAYERARMOUR               = RPC_SCRSETPLAYERARMOUR,
+	SETPLAYERARMEDWEAPON          = RPC_SCRSETPLAYERARMEDWEAPON,
+	SETSPAWNINFO                  = RPC_SCRSETSPAWNINFO,
+	SETPLAYERTEAM                 = RPC_SCRSETPLAYERTEAM,
+	PUTPLAYERINVEHICLE            = RPC_SCRPUTPLAYERINVEHICLE,
+	REMOVEPLAYERFROMVEHICLE       = RPC_SCRREMOVEPLAYERFROMVEHICLE,
+	SETPLAYERCOLOR                = RPC_SCRSETPLAYERCOLOR,
+	DISPLAYGAMETEXT               = RPC_SCRDISPLAYGAMETEXT,
+	FORCECLASSSELECTION           = RPC_SCRFORCECLASSSELECTION,
+	ATTACHOBJECTTOPLAYER          = RPC_SCRATTACHOBJECTTOPLAYER,
+	INITMENU                      = RPC_SCRINITMENU,
+	SHOWMENU                      = RPC_SCRSHOWMENU,
+	HIDEMENU                      = RPC_SCRHIDEMENU,
+	CREATEEXPLOSION               = RPC_SCRCREATEEXPLOSION,
+	SHOWPLAYERNAMETAGFORPLAYER    = RPC_SCRSHOWPLAYERNAMETAGFORPLAYER,
+	ATTACHCAMERATOOBJECT          = RPC_SCRATTACHCAMERATOOBJECT,
+	INTERPOLATECAMERA             = RPC_SCRINTERPOLATECAMERA,
+	SETOBJECTMATERIAL             = RPC_SCRSETOBJECTMATERIAL,
+	GANGZONESTOPFLASH             = RPC_SCRGANGZONESTOPFLASH,
+	APPLYANIMATION                = RPC_SCRAPPLYANIMATION,
+	CLEARANIMATIONS               = RPC_SCRCLEARANIMATIONS,
+	SETPLAYERSPECIALACTION        = RPC_SCRSETPLAYERSPECIALACTION,
+	SETPLAYERFIGHTINGSTYLE        = RPC_SCRSETPLAYERFIGHTINGSTYLE,
+	SETPLAYERVELOCITY             = RPC_SCRSETPLAYERVELOCITY,
+	SETVEHICLEVELOCITY            = RPC_SCRSETVEHICLEVELOCITY,
+	CLIENTMESSAGE                 = RPC_SCRCLIENTMESSAGE,
+	SETWORLDTIME                  = RPC_SCRSETWORLDTIME,
+	CREATEPICKUP                  = RPC_SCRCREATEPICKUP,
+	MOVEOBJECT                    = RPC_SCRMOVEOBJECT,
+	ENABLESTUNTBONUSFORPLAYER     = RPC_SCRENABLESTUNTBONUSFORPLAYER,
+	TEXTDRAWSETSTRING             = RPC_SCRTEXTDRAWSETSTRING,
+	SETCHECKPOINT                 = RPC_SCRSETCHECKPOINT,
+	GANGZONECREATE                = RPC_SCRGANGZONECREATE,
+	PLAYCRIMEREPORT               = RPC_SCRPLAYCRIMEREPORT,
+	SETPLAYERATTACHEDOBJECT       = RPC_SCRSETPLAYERATTACHEDOBJECT,
+	GANGZONEDESTROY               = RPC_SCRGANGZONEDESTROY,
+	GANGZONEFLASH                 = RPC_SCRGANGZONEFLASH,
+	STOPOBJECT                    = RPC_SCRSTOPOBJECT,
+	SETNUMBERPLATE                = RPC_SCRSETNUMBERPLATE,
+	TOGGLEPLAYERSPECTATING        = RPC_SCRTOGGLEPLAYERSPECTATING,
+	PLAYERSPECTATEPLAYER          = RPC_SCRPLAYERSPECTATEPLAYER,
+	PLAYERSPECTATEVEHICLE         = RPC_SCRPLAYERSPECTATEVEHICLE,
+	SETPLAYERWANTEDLEVEL          = RPC_SCRSETPLAYERWANTEDLEVEL,
+	SHOWTEXTDRAW                  = RPC_SCRSHOWTEXTDRAW,
+	TEXTDRAWHIDEFORPLAYER         = RPC_SCRTEXTDRAWHIDEFORPLAYER,
+	SERVERJOIN                    = RPC_SCRSERVERJOIN,
+	SERVERQUIT                    = RPC_SCRSERVERQUIT,
+	INITGAME                      = RPC_SCRINITGAME,
+	REMOVEPLAYERMAPICON           = RPC_SCRREMOVEPLAYERMAPICON,
+	SETPLAYERAMMO                 = RPC_SCRSETPLAYERAMMO,
+	SETGRAVITY                    = RPC_SCRSETGRAVITY,
+	SETVEHICLEHEALTH              = RPC_SCRSETVEHICLEHEALTH,
+	ATTACHTRAILERTOVEHICLE        = RPC_SCRATTACHTRAILERTOVEHICLE,
+	DETACHTRAILERFROMVEHICLE      = RPC_SCRDETACHTRAILERFROMVEHICLE,
+	SETWEATHER                    = RPC_SCRSETWEATHER,
+	SETPLAYERSKIN                 = RPC_SCRSETPLAYERSKIN,
+	SETPLAYERINTERIOR             = RPC_SCRSETPLAYERINTERIOR,
+	SETPLAYERCAMERAPOS            = RPC_SCRSETPLAYERCAMERAPOS,
+	SETPLAYERCAMERALOOKAT         = RPC_SCRSETPLAYERCAMERALOOKAT,
+	SETVEHICLEPOS                 = RPC_SCRSETVEHICLEPOS,
+	SETVEHICLEZANGLE              = RPC_SCRSETVEHICLEZANGLE,
+	SETVEHICLEPARAMSFORPLAYER     = RPC_SCRSETVEHICLEPARAMSFORPLAYER,
+	SETCAMERABEHINDPLAYER         = RPC_SCRSETCAMERABEHINDPLAYER,
+	WORLDPLAYERREMOVE             = RPC_SCRWORLDPLAYERREMOVE,
+	WORLDVEHICLEADD               = RPC_SCRWORLDVEHICLEADD,
+	WORLDVEHICLEREMOVE            = RPC_SCRWORLDVEHICLEREMOVE,
+	WORLDPLAYERDEATH              = RPC_SCRWORLDPLAYERDEATH,
+	CREATEACTOR                   = 171,
+	DESTROYACTOR = 172,
+	DESTROY3DTEXTLABEL = 58,
+	DESTROYWEAPONPICKUP = 151,
+	TOGGLECAMERATARGET = 170,
+	SELECTOBJECT = 27,
+	DISABLEVEHICLECOLLISIONS = 167,
+	TOGGLEWIDESCREEN = 111,
+	SETVEHICLETIRES = 98,
+	SETPLAYERDRUNKVISUALS = 92,
+	SETPLAYERDRUNKHANDLING = 150,
+	APPLYACTORANIMATION = 173,
+	CLEARACTORANIMATION = 174,
+	SETACTORROTATION = 175,
+	SETACTORPOSITION = 176,
+	SETACTORHEALTH = 178,
+	SETPLAYEROBJECTNOCAMCOL = 169,
+
+	-- Invalid. Retained only for backward compatibility.
+	ENTEREDITOBJECT = RPC_ENTEREDITOBJECT,
+	UPDATE3DTEXTLABEL = RPC_SCRUPDATE3DTEXTLABEL,
+}
+
+mod.PACKET = {
+	VEHICLE_SYNC                      = PACKET_VEHICLE_SYNC,
+	RCON_COMMAND                      = PACKET_RCON_COMMAND,
+	RCON_RESPONCE                     = PACKET_RCON_RESPONCE,
+	AIM_SYNC                          = PACKET_AIM_SYNC,
+	WEAPONS_UPDATE                    = PACKET_WEAPONS_UPDATE,
+	STATS_UPDATE                      = PACKET_STATS_UPDATE,
+	BULLET_SYNC                       = PACKET_BULLET_SYNC,
+	PLAYER_SYNC                       = PACKET_PLAYER_SYNC,
+	MARKERS_SYNC                      = PACKET_MARKERS_SYNC,
+	UNOCCUPIED_SYNC                   = PACKET_UNOCCUPIED_SYNC,
+	TRAILER_SYNC                      = PACKET_TRAILER_SYNC,
+	PASSENGER_SYNC                    = PACKET_PASSENGER_SYNC,
+	SPECTATOR_SYNC                    = PACKET_SPECTATOR_SYNC,
+
+	INTERNAL_PING                     = PACKET_INTERNAL_PING,
+	PING                              = PACKET_PING,
+	PING_OPEN_CONNECTIONS             = PACKET_PING_OPEN_CONNECTIONS,
+	CONNECTED_PONG                    = PACKET_CONNECTED_PONG,
+	REQUEST_STATIC_DATA               = PACKET_REQUEST_STATIC_DATA,
+	CONNECTION_REQUEST                = PACKET_CONNECTION_REQUEST,
+	AUTHENTICATION                    = PACKET_AUTH_KEY,
+	BROADCAST_PINGS                   = PACKET_BROADCAST_PINGS,
+	SECURED_CONNECTION_RESPONSE       = PACKET_SECURED_CONNECTION_RESPONSE,
+	SECURED_CONNECTION_CONFIRMATION   = PACKET_SECURED_CONNECTION_CONFIRMATION,
+	RPC_MAPPING                       = PACKET_RPC_MAPPING,
+	SET_RANDOM_NUMBER_SEED            = PACKET_SET_RANDOM_NUMBER_SEED,
+	RPC                               = PACKET_RPC,
+	RPC_REPLY                         = PACKET_RPC_REPLY,
+	DETECT_LOST_CONNECTIONS           = PACKET_DETECT_LOST_CONNECTIONS,
+	OPEN_CONNECTION_REQUEST           = PACKET_OPEN_CONNECTION_REQUEST,
+	OPEN_CONNECTION_REPLY             = PACKET_OPEN_CONNECTION_REPLY,
+	CONNECTION_COOKIE                 = PACKET_CONNECTION_COOKIE,
+	RSA_PUBLIC_KEY_MISMATCH           = PACKET_RSA_PUBLIC_KEY_MISMATCH,
+	CONNECTION_ATTEMPT_FAILED         = PACKET_CONNECTION_ATTEMPT_FAILED,
+	NEW_INCOMING_CONNECTION           = PACKET_NEW_INCOMING_CONNECTION,
+	NO_FREE_INCOMING_CONNECTIONS      = PACKET_NO_FREE_INCOMING_CONNECTIONS,
+	DISCONNECTION_NOTIFICATION        = PACKET_DISCONNECTION_NOTIFICATION,
+	CONNECTION_LOST                   = PACKET_CONNECTION_LOST,
+	CONNECTION_REQUEST_ACCEPTED       = PACKET_CONNECTION_REQUEST_ACCEPTED,
+	INITIALIZE_ENCRYPTION             = PACKET_INITIALIZE_ENCRYPTION,
+	CONNECTION_BANNED                 = PACKET_CONNECTION_BANNED,
+	INVALID_PASSWORD                  = PACKET_INVALID_PASSWORD,
+	MODIFIED_PACKET                   = PACKET_MODIFIED_PACKET,
+	PONG                              = PACKET_PONG,
+	TIMESTAMP                         = PACKET_TIMESTAMP,
+	RECEIVED_STATIC_DATA              = PACKET_RECEIVED_STATIC_DATA,
+	REMOTE_DISCONNECTION_NOTIFICATION = PACKET_REMOTE_DISCONNECTION_NOTIFICATION,
+	REMOTE_CONNECTION_LOST            = PACKET_REMOTE_CONNECTION_LOST,
+	REMOTE_NEW_INCOMING_CONNECTION    = PACKET_REMOTE_NEW_INCOMING_CONNECTION,
+	REMOTE_EXISTING_CONNECTION        = PACKET_REMOTE_EXISTING_CONNECTION,
+	REMOTE_STATIC_DATA                = PACKET_REMOTE_STATIC_DATA,
+	ADVERTISE_SYSTEM                  = PACKET_ADVERTISE_SYSTEM,
+
+	AUTH_KEY                          = PACKET_AUTH_KEY,
+}
+
+return mod

synchronization.lua

@@ -0,0 +1,199 @@
+-- This file is part of the SAMP.Lua project.
+-- Licensed under the MIT License.
+-- Copyright (c) 2016, FYP @ BlastHack Team <blast.hk>
+-- https://github.com/THE-FYP/SAMP.Lua
+
+local mod =
+{
+	MODULEINFO = {
+		name = 'samp.synchronization',
+		version = 2
+	}
+}
+local ffi = require 'ffi'
+
+ffi.cdef[[
+#pragma pack(push, 1)
+
+typedef struct VectorXYZ {
+	float x, y, z;
+} VectorXYZ;
+
+typedef struct SampKeys {
+	uint8_t primaryFire : 1;
+	uint8_t horn_crouch : 1;
+	uint8_t secondaryFire_shoot : 1;
+	uint8_t accel_zoomOut : 1;
+	uint8_t enterExitCar : 1;
+	uint8_t decel_jump : 1;
+	uint8_t circleRight : 1;
+	uint8_t aim : 1;
+	uint8_t circleLeft : 1;
+	uint8_t landingGear_lookback : 1;
+	uint8_t unknown_walkSlow : 1;
+	uint8_t specialCtrlUp : 1;
+	uint8_t specialCtrlDown : 1;
+	uint8_t specialCtrlLeft : 1;
+	uint8_t specialCtrlRight : 1;
+	uint8_t _unknown : 1;
+} SampKeys;
+
+typedef struct PlayerSyncData {
+	uint16_t leftRightKeys;
+	uint16_t upDownKeys;
+	union {
+		uint16_t keysData;
+		SampKeys keys;
+	};
+	VectorXYZ position;
+	float     quaternion[4];
+	uint8_t   health;
+	uint8_t   armor;
+	uint8_t   weapon : 6;
+	uint8_t   specialKey : 2;
+	uint8_t   specialAction;
+	VectorXYZ moveSpeed;
+	VectorXYZ surfingOffsets;
+	uint16_t  surfingVehicleId;
+	union {
+		struct {
+			uint16_t id;
+			uint8_t  frameDelta;
+			union {
+				struct {
+					bool    loop : 1;
+					bool    lockX : 1;
+					bool    lockY : 1;
+					bool    freeze : 1;
+					uint8_t time : 2;
+					uint8_t _unused : 1;
+					bool    regular : 1;
+				};
+				uint8_t value;
+			} flags;
+		} animation;
+		struct {
+			uint16_t  animationId;
+			uint16_t  animationFlags;
+		};
+	};
+} PlayerSyncData;
+
+typedef struct VehicleSyncData {
+	uint16_t vehicleId;
+	uint16_t leftRightKeys;
+	uint16_t upDownKeys;
+	union {
+		uint16_t keysData;
+		SampKeys keys;
+	};
+	float     quaternion[4];
+	VectorXYZ position;
+	VectorXYZ moveSpeed;
+	float     vehicleHealth;
+	uint8_t   playerHealth;
+	uint8_t   armor;
+	uint8_t   currentWeapon : 6;
+	uint8_t   specialKey : 2;
+	uint8_t   siren;
+	uint8_t   landingGearState;
+	uint16_t  trailerId;
+	union {
+		float    bikeLean;
+		float    trainSpeed;
+		uint16_t hydraThrustAngle[2];
+	};
+} VehicleSyncData;
+
+typedef struct PassengerSyncData {
+	uint16_t vehicleId;
+	uint8_t  seatId : 6;
+	bool     driveBy : 1;
+	bool     cuffed : 1;
+	uint8_t  currentWeapon : 6;
+	uint8_t  specialKey : 2;
+	uint8_t  health;
+	uint8_t  armor;
+	uint16_t leftRightKeys;
+	uint16_t upDownKeys;
+	union {
+		uint16_t keysData;
+		SampKeys keys;
+	};
+	VectorXYZ position;
+} PassengerSyncData;
+
+typedef struct UnoccupiedSyncData {
+	uint16_t  vehicleId;
+	uint8_t   seatId;
+	VectorXYZ roll;
+	VectorXYZ direction;
+	VectorXYZ position;
+	VectorXYZ moveSpeed;
+	VectorXYZ turnSpeed;
+	float     vehicleHealth;
+} UnoccupiedSyncData;
+
+typedef struct TrailerSyncData {
+	uint16_t  trailerId;
+	VectorXYZ position;
+	union {
+		struct {
+			float quaternion[4];
+			VectorXYZ moveSpeed;
+			VectorXYZ turnSpeed;
+		};
+		/* Invalid. Retained for backwards compatibility. */
+		struct {
+			VectorXYZ roll;
+			VectorXYZ direction;
+			VectorXYZ speed;
+			uint32_t  unk;
+		};
+	};
+} TrailerSyncData;
+
+typedef struct SpectatorSyncData {
+	uint16_t leftRightKeys;
+	uint16_t upDownKeys;
+	union {
+		uint16_t keysData;
+		SampKeys keys;
+	};
+	VectorXYZ position;
+} SpectatorSyncData;
+
+typedef struct BulletSyncData {
+	uint8_t   targetType;
+	uint16_t  targetId;
+	VectorXYZ origin;
+	VectorXYZ target;
+	VectorXYZ center;
+	uint8_t   weaponId;
+} BulletSyncData;
+
+typedef struct AimSyncData {
+	uint8_t   camMode;
+	VectorXYZ camFront;
+	VectorXYZ camPos;
+	float     aimZ;
+	uint8_t   camExtZoom : 6;
+	uint8_t   weaponState : 2;
+	uint8_t   aspectRatio;
+} AimSyncData;
+
+#pragma pack(pop)
+]]
+
+assert(ffi.sizeof('VectorXYZ') == 12)
+assert(ffi.sizeof('SampKeys') == 2)
+assert(ffi.sizeof('PlayerSyncData') == 68)
+assert(ffi.sizeof('VehicleSyncData') == 63)
+assert(ffi.sizeof('PassengerSyncData') == 24)
+assert(ffi.sizeof('UnoccupiedSyncData') == 67)
+assert(ffi.sizeof('TrailerSyncData') == 54)
+assert(ffi.sizeof('SpectatorSyncData') == 18)
+assert(ffi.sizeof('BulletSyncData') == 40)
+assert(ffi.sizeof('AimSyncData') == 31)
+
+return mod

utils.lua

@@ -0,0 +1,45 @@
+-- This file is part of the SAMP.Lua project.
+-- Licensed under the MIT License.
+-- Copyright (c) 2016, FYP @ BlastHack Team <blast.hk>
+-- https://github.com/THE-FYP/SAMP.Lua
+
+local ffi = require 'ffi'
+local utils = {}
+
+function utils.decompress_health_and_armor(hpAp)
+	local hp = math.min(bit.rshift(hpAp, 4) * 7, 100)
+	local armor = math.min(bit.band(hpAp, 0x0F) * 7, 100)
+	return hp, armor
+end
+
+function utils.compress_health_and_armor(health, armor)
+	local hp = health >= 100 and 0xF0 or bit.lshift(health / 7, 4)
+	local ap = armor >= 100 and 0x0F or bit.band(armor / 7, 0x0F)
+	return bit.bor(hp, ap)
+end
+
+function utils.create_sync_data(st)
+	require 'samp.synchronization'
+	return ffi.new(st)
+end
+
+function utils.read_sync_data(bs, st)
+	local dataStruct = utils.create_sync_data(st)
+	local ptr = tonumber(ffi.cast('intptr_t', ffi.cast('void*', dataStruct)))
+	raknetBitStreamReadBuffer(bs, ptr, ffi.sizeof(dataStruct))
+	return dataStruct
+end
+
+function utils.write_sync_data(bs, st, ffiobj)
+	require 'samp.synchronization'
+	local ptr = tonumber(ffi.cast('intptr_t', ffi.cast('void*', ffiobj)))
+	raknetBitStreamWriteBuffer(bs, ptr, ffi.sizeof(st))
+end
+
+function utils.process_outcoming_sync_data(bs, st)
+	local data = raknetBitStreamGetDataPtr(bs) + 1
+	require 'samp.synchronization'
+	return {ffi.cast(st .. '*', data)}
+end
+
+return utils