Upload 31 files

Pawn.CMD.inc

@@ -0,0 +1,94 @@
+#if !defined PAWNCMD_INC_
+    #define PAWNCMD_INC_
+    #if !defined PACK_PLUGIN_VERSION
+        #define PACK_PLUGIN_VERSION(%0,%1,%2) (((%0) << 16) | ((%1) << 8) | (%2))
+    #endif
+    #define PAWNCMD_VERSION PACK_PLUGIN_VERSION(3, 4, 0)
+    #define PAWNCMD_INCLUDE_VERSION PAWNCMD_VERSION
+    #if !defined __cplusplus
+        public _pawncmd_version = PAWNCMD_VERSION;
+        #pragma unused _pawncmd_version
+        public bool:_pawncmd_is_gamemode = !defined FILTERSCRIPT;
+        #pragma unused _pawncmd_is_gamemode
+        native PC_Init();
+        native PC_RegAlias(const cmd[], const alias[], ...);
+        native PC_SetFlags(const cmd[], flags);
+        native PC_GetFlags(const cmd[]);
+        native PC_RenameCommand(const cmd[], const newname[]);
+        native PC_CommandExists(const cmd[]);
+        native PC_DeleteCommand(const cmd[]);
+        native CmdArray:PC_GetCommandArray();
+        native CmdArray:PC_GetAliasArray(const cmd[]);
+        native PC_GetArraySize(CmdArray:arr);
+        native PC_GetCommandName(CmdArray:arr, index, dest[], size = sizeof dest);
+        native PC_FreeArray(&CmdArray:arr);
+        native PC_EmulateCommand(playerid, const cmdtext[]);
+        #if defined PC_OnInit
+            forward PC_OnInit();
+        #endif
+        #if defined OnPlayerCommandReceived
+            forward OnPlayerCommandReceived(playerid, cmd[], params[], flags);
+        #endif
+        #if defined OnPlayerCommandPerformed
+            forward OnPlayerCommandPerformed(playerid, cmd[], params[], result, flags);
+        #endif
+        #define cmd:%0(%1) \
+            forward pc_cmd_%0(%1); \
+            public pc_cmd_%0(%1)
+        #define alias:%0(%1) \
+            forward pc_alias_%0(); \
+            public pc_alias_%0() \
+                PC_RegAlias(#%0, %1);
+        #define flags:%0(%1) \
+            forward pc_flags_%0(); \
+            public pc_flags_%0() \
+                PC_SetFlags(#%0, %1);
+        #define CMD cmd
+        #define COMMAND cmd
+        #define callcmd::%0(%1) \
+            pc_cmd_%0(%1)
+        #define PC_HasFlag(%0,%1) \
+            (PC_GetFlags(%0) & %1)
+        #if !defined isnull
+            #define isnull(%0) \
+                ((!(%0[0])) || (((%0[0]) == '\1') && (!(%0[1]))))
+        #endif
+        #if defined FILTERSCRIPT
+            public OnFilterScriptInit()
+            {
+                PC_Init();
+                #if defined PawnCmd_OnFilterScriptInit
+                    PawnCmd_OnFilterScriptInit();
+                #endif
+                return 1;
+            }
+            #if defined _ALS_OnFilterScriptInit
+                #undef OnFilterScriptInit
+            #else
+                #define _ALS_OnFilterScriptInit
+            #endif
+            #define OnFilterScriptInit PawnCmd_OnFilterScriptInit
+            #if defined PawnCmd_OnFilterScriptInit
+                forward PawnCmd_OnFilterScriptInit();
+            #endif
+        #else
+            public OnGameModeInit()
+            {
+                PC_Init();
+                #if defined PawnCmd_OnGameModeInit
+                    PawnCmd_OnGameModeInit();
+                #endif
+                return 1;
+            }
+            #if defined _ALS_OnGameModeInit
+                #undef OnGameModeInit
+            #else
+                #define _ALS_OnGameModeInit
+            #endif
+            #define OnGameModeInit PawnCmd_OnGameModeInit
+            #if defined PawnCmd_OnGameModeInit
+                forward PawnCmd_OnGameModeInit();
+            #endif
+        #endif
+    #endif
+#endif

Pawn.RakNet.inc

@@ -0,0 +1,974 @@
+#if !defined PAWNRAKNET_INC_
+    #define PAWNRAKNET_INC_
+    #if !defined PACK_PLUGIN_VERSION
+        #define PACK_PLUGIN_VERSION(%0,%1,%2) (((%0) << 16) | ((%1) << 8) | (%2))
+    #endif
+    #define PAWNRAKNET_VERSION PACK_PLUGIN_VERSION(1, 6, 0)
+    #define PAWNRAKNET_INCLUDE_VERSION PAWNRAKNET_VERSION
+    #define PR_MAX_HANDLERS 256
+    enum PR_EventType
+    {
+        PR_INCOMING_PACKET,
+        PR_INCOMING_RPC,
+        PR_OUTGOING_PACKET,
+        PR_OUTGOING_RPC,
+        PR_INCOMING_CUSTOM_RPC,
+        PR_NUMBER_OF_EVENT_TYPES,
+        PR_OUTCOMING_PACKET = PR_OUTGOING_PACKET,
+        PR_OUTCOMING_RPC = PR_OUTGOING_RPC,
+    };
+    enum PR_ValueType
+    {
+        PR_INT8,
+        PR_INT16,
+        PR_INT32,
+        PR_UINT8,
+        PR_UINT16,
+        PR_UINT32,
+        PR_FLOAT,
+        PR_BOOL,
+        PR_STRING,
+        PR_CINT8,
+        PR_CINT16,
+        PR_CINT32,
+        PR_CUINT8,
+        PR_CUINT16,
+        PR_CUINT32,
+        PR_CFLOAT,
+        PR_CBOOL,
+        PR_CSTRING,
+        PR_BITS,
+        PR_FLOAT3,
+        PR_FLOAT4,
+        PR_VECTOR,
+        PR_NORM_QUAT,
+        PR_STRING8,
+        PR_STRING32,
+        PR_IGNORE_BITS,
+    };
+    enum PR_PacketPriority
+    {
+        PR_SYSTEM_PRIORITY,
+        PR_HIGH_PRIORITY,
+        PR_MEDIUM_PRIORITY,
+        PR_LOW_PRIORITY,
+    };
+    enum PR_PacketReliability
+    {
+        PR_UNRELIABLE = 6,
+        PR_UNRELIABLE_SEQUENCED,
+        PR_RELIABLE,
+        PR_RELIABLE_ORDERED,
+        PR_RELIABLE_SEQUENCED,
+    };
+    #if !defined __cplusplus
+        public _pawnraknet_version = PAWNRAKNET_VERSION;
+        #pragma unused _pawnraknet_version
+        public bool:_pawnraknet_is_gamemode = !defined FILTERSCRIPT;
+        #pragma unused _pawnraknet_is_gamemode
+        #define PR_BITS_TO_BYTES(%0) (((%0)+7)>>3)
+        #define PR_BYTES_TO_BITS(%0) ((%0)<<3)
+        #define PR_Handler<%0,%1>:%2(%3) \
+        forward pr_r%1_%2(); \
+        public pr_r%1_%2() PR_RegHandler(%2,"pr_"#%1"_"#%2,%0); \
+        forward pr_%1_%2(%3); \
+        public pr_%1_%2(%3)
+        #define IPacket:%0(%1) PR_Handler<PR_INCOMING_PACKET,ip>:%0(%1)
+        #define IRPC:%0(%1) PR_Handler<PR_INCOMING_RPC,ir>:%0(%1)
+        #define OPacket:%0(%1) PR_Handler<PR_OUTGOING_PACKET,op>:%0(%1)
+        #define ORPC:%0(%1) PR_Handler<PR_OUTGOING_RPC,or>:%0(%1)
+        #define ICustomRPC:%0(%1) PR_Handler<PR_INCOMING_CUSTOM_RPC,icr>:%0(%1)
+        #define IncomingPacket IPacket
+        #define IncomingRPC IRPC
+        #define OutgoingPacket OPacket
+        #define OutgoingRPC ORPC
+        #define IncomingCustomRPC ICustomRPC
+        #define OutcomingPacket OutgoingPacket
+        #define OutcomingRPC OutgoingRPC
+        #define PR_MAX_WEAPON_SLOTS 13
+        enum PR_OnFootSync
+        {
+            PR_lrKey,
+            PR_udKey,
+            PR_keys,
+            Float:PR_position[3],
+            Float:PR_quaternion[4],
+            PR_health,
+            PR_armour,
+            PR_weaponId,
+            PR_additionalKey,
+            PR_specialAction,
+            Float:PR_velocity[3],
+            Float:PR_surfingOffsets[3],
+            PR_surfingVehicleId,
+            PR_animationId,
+            PR_animationFlags,
+        };
+        enum PR_InCarSync
+        {
+            PR_vehicleId,
+            PR_lrKey,
+            PR_udKey,
+            PR_keys,
+            Float:PR_quaternion[4],
+            Float:PR_position[3],
+            Float:PR_velocity[3],
+            Float:PR_vehicleHealth,
+            PR_playerHealth,
+            PR_armour,
+            PR_weaponId,
+            PR_additionalKey,
+            PR_sirenState,
+            PR_landingGearState,
+            PR_trailerId,
+            Float:PR_trainSpeed,
+        };
+        enum PR_TrailerSync
+        {
+            PR_trailerId,
+            Float:PR_position[3],
+            Float:PR_quaternion[4],
+            Float:PR_velocity[3],
+            Float:PR_angularVelocity[3],
+        };
+        enum PR_PassengerSync
+        {
+            PR_vehicleId,
+            PR_seatId,
+            PR_driveBy,
+            PR_weaponId,
+            PR_additionalKey,
+            PR_playerHealth,
+            PR_playerArmour,
+            PR_lrKey,
+            PR_udKey,
+            PR_keys,
+            Float:PR_position[3],
+        };
+        enum PR_UnoccupiedSync
+        {
+            PR_vehicleId,
+            PR_seatId,
+            Float:PR_roll[3],
+            Float:PR_direction[3],
+            Float:PR_position[3],
+            Float:PR_velocity[3],
+            Float:PR_angularVelocity[3],
+            Float:PR_vehicleHealth,
+        };
+        enum PR_AimSync
+        {
+            PR_camMode,
+            Float:PR_camFrontVec[3],
+            Float:PR_camPos[3],
+            Float:PR_aimZ,
+            PR_camZoom,
+            PR_weaponState,
+            PR_aspectRatio,
+        };
+        enum PR_BulletSync
+        {
+            PR_hitType,
+            PR_hitId,
+            Float:PR_origin[3],
+            Float:PR_hitPos[3],
+            Float:PR_offsets[3],
+            PR_weaponId,
+        };
+        enum PR_SpectatingSync
+        {
+            PR_lrKey,
+            PR_udKey,
+            PR_keys,
+            Float:PR_position[3],
+        };
+        enum PR_MarkersSync
+        {
+            PR_numberOfPlayers,
+            PR_playerIsActive[MAX_PLAYERS],
+            PR_playerPositionX[MAX_PLAYERS],
+            PR_playerPositionY[MAX_PLAYERS],
+            PR_playerPositionZ[MAX_PLAYERS],
+            PR_playerIsParticipant[MAX_PLAYERS],
+        };
+        enum PR_WeaponsUpdate
+        {
+            PR_targetId,
+            PR_targetActorId,
+            PR_slotWeaponId[PR_MAX_WEAPON_SLOTS],
+            PR_slotWeaponAmmo[PR_MAX_WEAPON_SLOTS],
+            PR_slotUpdated[PR_MAX_WEAPON_SLOTS],
+        };
+        enum PR_StatsUpdate
+        {
+            PR_money,
+            PR_drunkLevel,
+        };
+        enum PR_RconCommand
+        {
+            PR_command[256],
+        };
+        native PR_Init();
+        native PR_SendPacket(BitStream:bs, playerid, PR_PacketPriority:priority = PR_HIGH_PRIORITY, PR_PacketReliability:reliability = PR_RELIABLE_ORDERED, orderingchannel = 0);
+        native PR_SendRPC(BitStream:bs, playerid, rpcid, PR_PacketPriority:priority = PR_HIGH_PRIORITY, PR_PacketReliability:reliability = PR_RELIABLE_ORDERED, orderingchannel = 0);
+        #pragma deprecated Use PR_SendPacket instead
+        native BS_Send(BitStream:bs, playerid, PR_PacketPriority:priority = PR_HIGH_PRIORITY, PR_PacketReliability:reliability = PR_RELIABLE_ORDERED, orderingchannel = 0) = PR_SendPacket;
+        #pragma deprecated Use PR_SendRPC instead
+        native BS_RPC(BitStream:bs, playerid, rpcid, PR_PacketPriority:priority = PR_HIGH_PRIORITY, PR_PacketReliability:reliability = PR_RELIABLE_ORDERED, orderingchannel = 0) = PR_SendRPC;
+        native PR_EmulateIncomingPacket(BitStream:bs, playerid);
+        native PR_EmulateIncomingRPC(BitStream:bs, playerid, rpcid);
+        #pragma deprecated Use PR_EmulateIncomingPacket instead
+        native BS_EmulateIncomingPacket(BitStream:bs, playerid) = PR_EmulateIncomingPacket;
+        #pragma deprecated Use PR_EmulateIncomingRPC instead
+        native BS_EmulateIncomingRPC(BitStream:bs, playerid, rpcid) = PR_EmulateIncomingRPC;
+        native BitStream:BS_New();
+        native BitStream:BS_NewCopy(BitStream:bs);
+        native BS_Delete(&BitStream:bs);
+        native BS_Reset(BitStream:bs);
+        native BS_ResetReadPointer(BitStream:bs);
+        native BS_ResetWritePointer(BitStream:bs);
+        native BS_IgnoreBits(BitStream:bs, number_of_bits);
+        native BS_SetWriteOffset(BitStream:bs, offset);
+        native BS_GetWriteOffset(BitStream:bs, &offset);
+        native BS_SetReadOffset(BitStream:bs, offset);
+        native BS_GetReadOffset(BitStream:bs, &offset);
+        native BS_GetNumberOfBitsUsed(BitStream:bs, &number);
+        native BS_GetNumberOfBytesUsed(BitStream:bs, &number);
+        native BS_GetNumberOfUnreadBits(BitStream:bs, &number);
+        native BS_GetNumberOfBitsAllocated(BitStream:bs, &number);
+        native BS_WriteValue(BitStream:bs, {PR_ValueType, Float, _}:...);
+        native BS_ReadValue(BitStream:bs, {PR_ValueType, Float, _}:...);
+        native PR_RegHandler(eventid, const publicname[], PR_EventType:type);
+        #define BS_ReadInt8(%0,%1) BS_ReadValue(%0,PR_INT8,%1)
+        #define BS_ReadInt16(%0,%1) BS_ReadValue(%0,PR_INT16,%1)
+        #define BS_ReadInt32(%0,%1) BS_ReadValue(%0,PR_INT32,%1)
+        #define BS_ReadUint8(%0,%1) BS_ReadValue(%0,PR_UINT8,%1)
+        #define BS_ReadUint16(%0,%1) BS_ReadValue(%0,PR_UINT16,%1)
+        #define BS_ReadUint32(%0,%1) BS_ReadValue(%0,PR_UINT32,%1)
+        #define BS_ReadFloat(%0,%1) BS_ReadValue(%0,PR_FLOAT,%1)
+        #define BS_ReadBool(%0,%1) BS_ReadValue(%0,PR_BOOL,%1)
+        #define BS_ReadString(%0,%1,%2) BS_ReadValue(%0,PR_STRING,%1,%2)
+        #define BS_ReadCompressedInt8(%0,%1) BS_ReadValue(%0,PR_CINT8,%1)
+        #define BS_ReadCompressedInt16(%0,%1) BS_ReadValue(%0,PR_CINT16,%1)
+        #define BS_ReadCompressedInt32(%0,%1) BS_ReadValue(%0,PR_CINT32,%1)
+        #define BS_ReadCompressedUint8(%0,%1) BS_ReadValue(%0,PR_CUINT8,%1)
+        #define BS_ReadCompressedUint16(%0,%1) BS_ReadValue(%0,PR_CUINT16,%1)
+        #define BS_ReadCompressedUint32(%0,%1) BS_ReadValue(%0,PR_CUINT32,%1)
+        #define BS_ReadCompressedFloat(%0,%1) BS_ReadValue(%0,PR_CFLOAT,%1)
+        #define BS_ReadCompressedBool(%0,%1) BS_ReadValue(%0,PR_CBOOL,%1)
+        #define BS_ReadCompressedString(%0,%1,%2) BS_ReadValue(%0,PR_CSTRING,%1,%2)
+        #define BS_ReadBits(%0,%1,%2) BS_ReadValue(%0,PR_BITS,%1,%2)
+        #define BS_ReadFloat3(%0,%1) BS_ReadValue(%0,PR_FLOAT3,%1)
+        #define BS_ReadFloat4(%0,%1) BS_ReadValue(%0,PR_FLOAT4,%1)
+        #define BS_ReadVector(%0,%1) BS_ReadValue(%0,PR_VECTOR,%1)
+        #define BS_ReadNormQuat(%0,%1) BS_ReadValue(%0,PR_NORM_QUAT,%1)
+        #define BS_ReadString8(%0,%1) BS_ReadValue(%0,PR_STRING8,%1,sizeof(%1))
+        #define BS_ReadString32(%0,%1) BS_ReadValue(%0,PR_STRING32,%1,sizeof(%1))
+        #define BS_WriteInt8(%0,%1) BS_WriteValue(%0,PR_INT8,%1)
+        #define BS_WriteInt16(%0,%1) BS_WriteValue(%0,PR_INT16,%1)
+        #define BS_WriteInt32(%0,%1) BS_WriteValue(%0,PR_INT32,%1)
+        #define BS_WriteUint8(%0,%1) BS_WriteValue(%0,PR_UINT8,%1)
+        #define BS_WriteUint16(%0,%1) BS_WriteValue(%0,PR_UINT16,%1)
+        #define BS_WriteUint32(%0,%1) BS_WriteValue(%0,PR_UINT32,%1)
+        #define BS_WriteFloat(%0,%1) BS_WriteValue(%0,PR_FLOAT,%1)
+        #define BS_WriteBool(%0,%1) BS_WriteValue(%0,PR_BOOL,%1)
+        #define BS_WriteString(%0,%1) BS_WriteValue(%0,PR_STRING,%1)
+        #define BS_WriteCompressedInt8(%0,%1) BS_WriteValue(%0,PR_CINT8,%1)
+        #define BS_WriteCompressedInt16(%0,%1) BS_WriteValue(%0,PR_CINT16,%1)
+        #define BS_WriteCompressedInt32(%0,%1) BS_WriteValue(%0,PR_CINT32,%1)
+        #define BS_WriteCompressedUint8(%0,%1) BS_WriteValue(%0,PR_CUINT8,%1)
+        #define BS_WriteCompressedUint16(%0,%1) BS_WriteValue(%0,PR_CUINT16,%1)
+        #define BS_WriteCompressedUint32(%0,%1) BS_WriteValue(%0,PR_CUINT32,%1)
+        #define BS_WriteCompressedFloat(%0,%1) BS_WriteValue(%0,PR_CFLOAT,%1)
+        #define BS_WriteCompressedBool(%0,%1) BS_WriteValue(%0,PR_CBOOL,%1)
+        #define BS_WriteCompressedString(%0,%1) BS_WriteValue(%0,PR_CSTRING,%1)
+        #define BS_WriteBits(%0,%1,%2) BS_WriteValue(%0,PR_BITS,%1,%2)
+        #define BS_WriteFloat3(%0,%1) BS_WriteValue(%0,PR_FLOAT3,%1)
+        #define BS_WriteFloat4(%0,%1) BS_WriteValue(%0,PR_FLOAT4,%1)
+        #define BS_WriteVector(%0,%1) BS_WriteValue(%0,PR_VECTOR,%1)
+        #define BS_WriteNormQuat(%0,%1) BS_WriteValue(%0,PR_NORM_QUAT,%1)
+        #define BS_WriteString8(%0,%1) BS_WriteValue(%0,PR_STRING8,%1)
+        #define BS_WriteString32(%0,%1) BS_WriteValue(%0,PR_STRING32,%1)
+        #define PR_EXPAND_ARR3(%0) %0[0],%0[1],%0[2]
+        #define PR_EXPAND_ARR4(%0) %0[0],%0[1],%0[2],%0[3]
+        stock BS_PackAspectRatio(Float:value)
+        {
+            return floatround((value - 1.0) * 255.0);
+        }
+        stock Float:BS_UnpackAspectRatio(value)
+        {
+            return float(value) / 255.0 + 1.0;
+        }
+        stock BS_PackCameraZoom(Float:value)
+        {
+            return floatround(((value - 35.0) / 35.0) * 63.0);
+        }
+        stock Float:BS_UnpackCameraZoom(value)
+        {
+            return (float(value) / 63.0) * 35.0 + 35.0;
+        }
+        stock BS_PackHealthArmour(health, armour, &healthArmour)
+        {
+            if (health > 0 && health < 100) {
+                healthArmour = (health / 7) << 4;
+            } else if (health >= 100) {
+                healthArmour = 0xF0;
+            } else {
+                healthArmour = 0;
+            }
+            if (armour > 0 && armour < 100) {
+                healthArmour |= (armour / 7);
+            } else if (armour >= 100) {
+                healthArmour |= 0xF;
+            }
+        }
+        stock BS_UnpackHealthArmour(healthArmour, &health, &armour)
+        {
+            health = healthArmour >> 4;
+            if (health == 0xF) {
+                health = 100;
+            } else {
+                health *= 7;
+            }
+            armour = healthArmour & 0xF;
+            if (armour == 0xF) {
+                armour = 100;
+            } else {
+                armour *= 7;
+            }
+        }
+        stock BS_ReadOnFootSync(BitStream:bs, data[PR_OnFootSync], outgoing = false)
+        {
+            if (outgoing) {
+                new hasLeftRight, hasUpDown, hasSurfInfo, hasAnimation, healthArmour;
+                BS_ReadValue(bs, PR_BOOL, hasLeftRight);
+                if (hasLeftRight) {
+                    BS_ReadValue(bs, PR_UINT16, data[PR_lrKey]);
+                } else {
+                    data[PR_lrKey] = 0;
+                }
+                BS_ReadValue(bs, PR_BOOL, hasUpDown);
+                if (hasUpDown) {
+                    BS_ReadValue(bs, PR_UINT16, data[PR_udKey]);
+                } else {
+                    data[PR_udKey] = 0;
+                }
+                BS_ReadValue(
+                    bs,
+                    PR_UINT16, data[PR_keys],
+                    PR_FLOAT3, data[PR_position],
+                    PR_NORM_QUAT, data[PR_quaternion],
+                    PR_UINT8, healthArmour,
+                    PR_UINT8, data[PR_weaponId],
+                    PR_UINT8, data[PR_specialAction],
+                    PR_VECTOR, data[PR_velocity],
+                    PR_BOOL, hasSurfInfo
+                );
+                BS_UnpackHealthArmour(healthArmour, data[PR_health], data[PR_armour]);
+                if (hasSurfInfo) {
+                    BS_ReadValue(
+                        bs,
+                        PR_UINT16, data[PR_surfingVehicleId],
+                        PR_FLOAT3, data[PR_surfingOffsets]
+                    );
+                } else {
+                    data[PR_surfingVehicleId] = 0;
+                }
+                BS_ReadValue(bs, PR_BOOL, hasAnimation);
+                if (hasAnimation) {
+                    BS_ReadValue(
+                        bs,
+                        PR_INT16, data[PR_animationId],
+                        PR_INT16, data[PR_animationFlags]
+                    );
+                } else {
+                    data[PR_animationId] = 0;
+                    data[PR_animationFlags] = 0;
+                }
+            } else {
+                BS_ReadValue(
+                    bs,
+                    PR_UINT16, data[PR_lrKey],
+                    PR_UINT16, data[PR_udKey],
+                    PR_UINT16, data[PR_keys],
+                    PR_FLOAT3, data[PR_position],
+                    PR_FLOAT4, data[PR_quaternion],
+                    PR_UINT8, data[PR_health],
+                    PR_UINT8, data[PR_armour],
+                    PR_BITS, data[PR_additionalKey], 2,
+                    PR_BITS, data[PR_weaponId], 6,
+                    PR_UINT8, data[PR_specialAction],
+                    PR_FLOAT3, data[PR_velocity],
+                    PR_FLOAT3, data[PR_surfingOffsets],
+                    PR_UINT16, data[PR_surfingVehicleId],
+                    PR_INT16, data[PR_animationId],
+                    PR_INT16, data[PR_animationFlags]
+                );
+            }
+        }
+        stock BS_ReadInCarSync(BitStream:bs, data[PR_InCarSync], outgoing = false)
+        {
+            if (outgoing) {
+                new vehicleHealth, healthArmour;
+                BS_ReadValue(
+                    bs,
+                    PR_UINT16, data[PR_vehicleId],
+                    PR_UINT16, data[PR_lrKey],
+                    PR_UINT16, data[PR_udKey],
+                    PR_UINT16, data[PR_keys],
+                    PR_NORM_QUAT, data[PR_quaternion],
+                    PR_FLOAT3, data[PR_position],
+                    PR_VECTOR, data[PR_velocity],
+                    PR_UINT16, vehicleHealth,
+                    PR_UINT8, healthArmour,
+                    PR_UINT8, data[PR_weaponId],
+                    PR_BOOL, data[PR_sirenState],
+                    PR_BOOL, data[PR_landingGearState]
+                );
+                data[PR_vehicleHealth] = float(vehicleHealth);
+                BS_UnpackHealthArmour(healthArmour, data[PR_playerHealth], data[PR_armour]);
+                new hasTrainSpeed, hasTrailer;
+                BS_ReadValue(bs, PR_BOOL, hasTrainSpeed);
+                if (hasTrainSpeed) {
+                    BS_ReadValue(bs, PR_FLOAT, data[PR_trainSpeed]);
+                } else {
+                    data[PR_trainSpeed] = 0.0;
+                }
+                BS_ReadValue(bs, PR_BOOL, hasTrailer);
+                if (hasTrailer) {
+                    BS_ReadValue(bs, PR_UINT16, data[PR_trailerId]);
+                } else {
+                    data[PR_trailerId] = 0;
+                }
+            } else {
+                BS_ReadValue(
+                    bs,
+                    PR_UINT16, data[PR_vehicleId],
+                    PR_UINT16, data[PR_lrKey],
+                    PR_UINT16, data[PR_udKey],
+                    PR_UINT16, data[PR_keys],
+                    PR_FLOAT4, data[PR_quaternion],
+                    PR_FLOAT3, data[PR_position],
+                    PR_FLOAT3, data[PR_velocity],
+                    PR_FLOAT, data[PR_vehicleHealth],
+                    PR_UINT8, data[PR_playerHealth],
+                    PR_UINT8, data[PR_armour],
+                    PR_BITS, data[PR_additionalKey], 2,
+                    PR_BITS, data[PR_weaponId], 6,
+                    PR_UINT8, data[PR_sirenState],
+                    PR_UINT8, data[PR_landingGearState],
+                    PR_UINT16, data[PR_trailerId],
+                    PR_FLOAT, data[PR_trainSpeed]
+                );
+            }
+        }
+        stock BS_ReadTrailerSync(BitStream:bs, data[PR_TrailerSync])
+        {
+            BS_ReadValue(
+                bs,
+                PR_UINT16, data[PR_trailerId],
+                PR_FLOAT3, data[PR_position],
+                PR_FLOAT4, data[PR_quaternion],
+                PR_FLOAT3, data[PR_velocity],
+                PR_FLOAT3, data[PR_angularVelocity]
+            );
+        }
+        stock BS_ReadPassengerSync(BitStream:bs, data[PR_PassengerSync])
+        {
+            BS_ReadValue(
+                bs,
+                PR_UINT16, data[PR_vehicleId],
+                PR_BITS, data[PR_driveBy], 2,
+                PR_BITS, data[PR_seatId], 6,
+                PR_BITS, data[PR_additionalKey], 2,
+                PR_BITS, data[PR_weaponId], 6,
+                PR_UINT8, data[PR_playerHealth],
+                PR_UINT8, data[PR_playerArmour],
+                PR_UINT16, data[PR_lrKey],
+                PR_UINT16, data[PR_udKey],
+                PR_UINT16, data[PR_keys],
+                PR_FLOAT3, data[PR_position]
+            );
+        }
+        stock BS_ReadUnoccupiedSync(BitStream:bs, data[PR_UnoccupiedSync])
+        {
+            BS_ReadValue(
+                bs,
+                PR_UINT16, data[PR_vehicleId],
+                PR_UINT8, data[PR_seatId],
+                PR_FLOAT3, data[PR_roll],
+                PR_FLOAT3, data[PR_direction],
+                PR_FLOAT3, data[PR_position],
+                PR_FLOAT3, data[PR_velocity],
+                PR_FLOAT3, data[PR_angularVelocity],
+                PR_FLOAT, data[PR_vehicleHealth]
+            );
+        }
+        stock BS_ReadAimSync(BitStream:bs, data[PR_AimSync])
+        {
+            BS_ReadValue(
+                bs,
+                PR_UINT8, data[PR_camMode],
+                PR_FLOAT3, data[PR_camFrontVec],
+                PR_FLOAT3, data[PR_camPos],
+                PR_FLOAT, data[PR_aimZ],
+                PR_BITS, data[PR_weaponState], 2,
+                PR_BITS, data[PR_camZoom], 6,
+                PR_UINT8, data[PR_aspectRatio]
+            );
+        }
+        stock BS_ReadBulletSync(BitStream:bs, data[PR_BulletSync])
+        {
+            BS_ReadValue(
+                bs,
+                PR_UINT8, data[PR_hitType],
+                PR_UINT16, data[PR_hitId],
+                PR_FLOAT3, data[PR_origin],
+                PR_FLOAT3, data[PR_hitPos],
+                PR_FLOAT3, data[PR_offsets],
+                PR_UINT8, data[PR_weaponId]
+            );
+        }
+        stock BS_ReadSpectatingSync(BitStream:bs, data[PR_SpectatingSync])
+        {
+            BS_ReadValue(
+                bs,
+                PR_UINT16, data[PR_lrKey],
+                PR_UINT16, data[PR_udKey],
+                PR_UINT16, data[PR_keys],
+                PR_FLOAT3, data[PR_position]
+            );
+        }
+        stock BS_ReadMarkersSync(BitStream:bs, data[PR_MarkersSync])
+        {
+            new numberOfPlayers, playerId, isActive;
+            BS_ReadInt32(bs, numberOfPlayers);
+            if (numberOfPlayers < 0 || numberOfPlayers > MAX_PLAYERS) {
+                return;
+            }
+            data[PR_numberOfPlayers] = numberOfPlayers;
+            for (new i; i < numberOfPlayers; i++) {
+                playerId = isActive = 0;
+                BS_ReadUint16(bs, playerId);
+                if (playerId >= MAX_PLAYERS) {
+                    return;
+                }
+                data[PR_playerIsParticipant][playerId] = true;
+                BS_ReadCompressedBool(bs, isActive);
+                if (isActive) {
+                    data[PR_playerIsActive][playerId] = true;
+                    BS_ReadValue(
+                        bs,
+                        PR_INT16, data[PR_playerPositionX][playerId],
+                        PR_INT16, data[PR_playerPositionY][playerId],
+                        PR_INT16, data[PR_playerPositionZ][playerId]
+                    );
+                }
+            }
+        }
+        stock BS_ReadWeaponsUpdate(BitStream:bs, data[PR_WeaponsUpdate])
+        {
+            new numberOfBytes, numberOfSlots, slotId, weaponId, ammo;
+            BS_GetNumberOfBytesUsed(bs, numberOfBytes);
+            if (numberOfBytes > 5) {
+                numberOfSlots = (numberOfBytes - 5) / 4;
+            }
+            BS_ReadValue(
+                bs,
+                PR_UINT16, data[PR_targetId],
+                PR_UINT16, data[PR_targetActorId]
+            );
+            while (numberOfSlots--) {
+                slotId = weaponId = ammo = 0;
+                BS_ReadValue(
+                    bs,
+                    PR_UINT8, slotId,
+                    PR_UINT8, weaponId,
+                    PR_UINT16, ammo
+                );
+                if (slotId < PR_MAX_WEAPON_SLOTS) {
+                    data[PR_slotWeaponId][slotId] = weaponId;
+                    data[PR_slotWeaponAmmo][slotId] = ammo;
+                    data[PR_slotUpdated][slotId] = true;
+                }
+            }
+        }
+        stock BS_ReadStatsUpdate(BitStream:bs, data[PR_StatsUpdate])
+        {
+            BS_ReadValue(
+                bs,
+                PR_INT32, data[PR_money],
+                PR_INT32, data[PR_drunkLevel]
+            );
+        }
+        stock BS_ReadRconCommand(BitStream:bs, data[PR_RconCommand])
+        {
+            BS_ReadValue(
+                bs,
+                PR_STRING32, data[PR_command], sizeof(data[PR_command])
+            );
+        }
+        stock BS_WriteOnFootSync(BitStream:bs, data[PR_OnFootSync], outgoing = false)
+        {
+            if (outgoing) {
+                new healthArmour;
+                if (data[PR_lrKey]) {
+                    BS_WriteValue(
+                        bs,
+                        PR_BOOL, true,
+                        PR_UINT16, data[PR_lrKey]
+                    );
+                } else {
+                    BS_WriteValue(bs, PR_BOOL, false);
+                }
+                if (data[PR_udKey]) {
+                    BS_WriteValue(
+                        bs,
+                        PR_BOOL, true,
+                        PR_UINT16, data[PR_udKey]
+                    );
+                } else {
+                    BS_WriteValue(bs, PR_BOOL, false);
+                }
+                BS_PackHealthArmour(data[PR_health], data[PR_armour], healthArmour);
+                BS_WriteValue(
+                    bs,
+                    PR_UINT16, data[PR_keys],
+                    PR_FLOAT3, data[PR_position],
+                    PR_NORM_QUAT, data[PR_quaternion],
+                    PR_UINT8, healthArmour,
+                    PR_UINT8, data[PR_weaponId],
+                    PR_UINT8, data[PR_specialAction],
+                    PR_VECTOR, data[PR_velocity]
+                );
+                if (data[PR_surfingVehicleId]) {
+                    BS_WriteValue(
+                        bs,
+                        PR_BOOL, true,
+                        PR_UINT16, data[PR_surfingVehicleId],
+                        PR_FLOAT3, data[PR_surfingOffsets]
+                    );
+                } else {
+                    BS_WriteValue(bs, PR_BOOL, false);
+                }
+                if (data[PR_animationId] || data[PR_animationFlags]) {
+                    BS_WriteValue(
+                        bs,
+                        PR_BOOL, true,
+                        PR_INT16, data[PR_animationId],
+                        PR_INT16, data[PR_animationFlags]
+                    );
+                } else {
+                    BS_WriteValue(bs, PR_BOOL, false);
+                }
+            } else {
+                BS_WriteValue(
+                    bs,
+                    PR_UINT16, data[PR_lrKey],
+                    PR_UINT16, data[PR_udKey],
+                    PR_UINT16, data[PR_keys],
+                    PR_FLOAT3, data[PR_position],
+                    PR_FLOAT4, data[PR_quaternion],
+                    PR_UINT8, data[PR_health],
+                    PR_UINT8, data[PR_armour],
+                    PR_BITS, data[PR_additionalKey], 2,
+                    PR_BITS, data[PR_weaponId], 6,
+                    PR_UINT8, data[PR_specialAction],
+                    PR_FLOAT3, data[PR_velocity],
+                    PR_FLOAT3, data[PR_surfingOffsets],
+                    PR_UINT16, data[PR_surfingVehicleId],
+                    PR_INT16, data[PR_animationId],
+                    PR_INT16, data[PR_animationFlags]
+                );
+            }
+        }
+        stock BS_WriteInCarSync(BitStream:bs, data[PR_InCarSync], outgoing = false)
+        {
+            if (outgoing) {
+                new healthArmour;
+                BS_PackHealthArmour(data[PR_playerHealth], data[PR_armour], healthArmour);
+                BS_WriteValue(
+                    bs,
+                    PR_UINT16, data[PR_vehicleId],
+                    PR_UINT16, data[PR_lrKey],
+                    PR_UINT16, data[PR_udKey],
+                    PR_UINT16, data[PR_keys],
+                    PR_NORM_QUAT, data[PR_quaternion],
+                    PR_FLOAT3, data[PR_position],
+                    PR_VECTOR, data[PR_velocity],
+                    PR_UINT16, floatround(data[PR_vehicleHealth]),
+                    PR_UINT8, healthArmour,
+                    PR_UINT8, data[PR_weaponId],
+                    PR_BOOL, data[PR_sirenState],
+                    PR_BOOL, data[PR_landingGearState]
+                );
+                if (data[PR_trainSpeed]) {
+                    BS_WriteValue(bs,
+                        PR_BOOL, true,
+                        PR_FLOAT, data[PR_trainSpeed]
+                    );
+                } else {
+                    BS_WriteValue(bs, PR_BOOL, false);
+                }
+                if (data[PR_trailerId]) {
+                    BS_WriteValue(bs,
+                        PR_BOOL, true,
+                        PR_UINT16, data[PR_trailerId]
+                    );
+                } else {
+                    BS_WriteValue(bs, PR_BOOL, false);
+                }
+            } else {
+                BS_WriteValue(
+                    bs,
+                    PR_UINT16, data[PR_vehicleId],
+                    PR_UINT16, data[PR_lrKey],
+                    PR_UINT16, data[PR_udKey],
+                    PR_UINT16, data[PR_keys],
+                    PR_FLOAT4, data[PR_quaternion],
+                    PR_FLOAT3, data[PR_position],
+                    PR_FLOAT3, data[PR_velocity],
+                    PR_FLOAT, data[PR_vehicleHealth],
+                    PR_UINT8, data[PR_playerHealth],
+                    PR_UINT8, data[PR_armour],
+                    PR_BITS, data[PR_additionalKey], 2,
+                    PR_BITS, data[PR_weaponId], 6,
+                    PR_UINT8, data[PR_sirenState],
+                    PR_UINT8, data[PR_landingGearState],
+                    PR_UINT16, data[PR_trailerId],
+                    PR_FLOAT, data[PR_trainSpeed]
+                );
+            }
+        }
+        stock BS_WriteTrailerSync(BitStream:bs, data[PR_TrailerSync])
+        {
+            BS_WriteValue(
+                bs,
+                PR_UINT16, data[PR_trailerId],
+                PR_FLOAT3, data[PR_position],
+                PR_FLOAT4, data[PR_quaternion],
+                PR_FLOAT3, data[PR_velocity],
+                PR_FLOAT3, data[PR_angularVelocity]
+            );
+        }
+        stock BS_WritePassengerSync(BitStream:bs, data[PR_PassengerSync])
+        {
+            BS_WriteValue(
+                bs,
+                PR_UINT16, data[PR_vehicleId],
+                PR_BITS, data[PR_driveBy], 2,
+                PR_BITS, data[PR_seatId], 6,
+                PR_BITS, data[PR_additionalKey], 2,
+                PR_BITS, data[PR_weaponId], 6,
+                PR_UINT8, data[PR_playerHealth],
+                PR_UINT8, data[PR_playerArmour],
+                PR_UINT16, data[PR_lrKey],
+                PR_UINT16, data[PR_udKey],
+                PR_UINT16, data[PR_keys],
+                PR_FLOAT3, data[PR_position]
+            );
+        }
+        stock BS_WriteUnoccupiedSync(BitStream:bs, data[PR_UnoccupiedSync])
+        {
+            BS_WriteValue(
+                bs,
+                PR_UINT16, data[PR_vehicleId],
+                PR_UINT8, data[PR_seatId],
+                PR_FLOAT3, data[PR_roll],
+                PR_FLOAT3, data[PR_direction],
+                PR_FLOAT3, data[PR_position],
+                PR_FLOAT3, data[PR_velocity],
+                PR_FLOAT3, data[PR_angularVelocity],
+                PR_FLOAT, data[PR_vehicleHealth]
+            );
+        }
+        stock BS_WriteAimSync(BitStream:bs, data[PR_AimSync])
+        {
+            BS_WriteValue(
+                bs,
+                PR_UINT8, data[PR_camMode],
+                PR_FLOAT3, data[PR_camFrontVec],
+                PR_FLOAT3, data[PR_camPos],
+                PR_FLOAT, data[PR_aimZ],
+                PR_BITS, data[PR_weaponState], 2,
+                PR_BITS, data[PR_camZoom], 6,
+                PR_UINT8, data[PR_aspectRatio]
+            );
+        }
+        stock BS_WriteBulletSync(BitStream:bs, data[PR_BulletSync])
+        {
+            BS_WriteValue(
+                bs,
+                PR_UINT8, data[PR_hitType],
+                PR_UINT16, data[PR_hitId],
+                PR_FLOAT3, data[PR_origin],
+                PR_FLOAT3, data[PR_hitPos],
+                PR_FLOAT3, data[PR_offsets],
+                PR_UINT8, data[PR_weaponId]
+            );
+        }
+        stock BS_WriteSpectatingSync(BitStream:bs, data[PR_SpectatingSync])
+        {
+            BS_WriteValue(
+                bs,
+                PR_UINT16, data[PR_lrKey],
+                PR_UINT16, data[PR_udKey],
+                PR_UINT16, data[PR_keys],
+                PR_FLOAT3, data[PR_position]
+            );
+        }
+        stock BS_WriteMarkersSync(BitStream:bs, data[PR_MarkersSync])
+        {
+            BS_WriteInt32(bs, data[PR_numberOfPlayers]);
+            for (new i; i < MAX_PLAYERS; i++) {
+                if (!data[PR_playerIsParticipant][i]) {
+                    continue;
+                }
+                BS_WriteValue(
+                    bs,
+                    PR_UINT16, i,
+                    PR_CBOOL, data[PR_playerIsActive][i]
+                );
+                if (data[PR_playerIsActive][i]) {
+                    BS_WriteValue(
+                        bs,
+                        PR_INT16, data[PR_playerPositionX][i],
+                        PR_INT16, data[PR_playerPositionY][i],
+                        PR_INT16, data[PR_playerPositionZ][i]
+                    );
+                }
+            }
+        }
+        stock BS_WriteWeaponsUpdate(BitStream:bs, data[PR_WeaponsUpdate])
+        {
+            BS_WriteValue(
+                bs,
+                PR_UINT16, data[PR_targetId],
+                PR_UINT16, data[PR_targetActorId]
+            );
+            for (new slotId; slotId < PR_MAX_WEAPON_SLOTS; slotId++) {
+                if (!data[PR_slotUpdated][slotId]) {
+                    continue;
+                }
+                BS_WriteValue(
+                    bs,
+                    PR_UINT8, slotId,
+                    PR_UINT8, data[PR_slotWeaponId][slotId],
+                    PR_UINT16, data[PR_slotWeaponAmmo][slotId]
+                );
+            }
+        }
+        stock BS_WriteStatsUpdate(BitStream:bs, data[PR_StatsUpdate])
+        {
+            BS_WriteValue(
+                bs,
+                PR_INT32, data[PR_money],
+                PR_INT32, data[PR_drunkLevel]
+            );
+        }
+        stock BS_WriteRconCommand(BitStream:bs, data[PR_RconCommand])
+        {
+            BS_WriteValue(
+                bs,
+                PR_STRING32, data[PR_command]
+            );
+        }
+        stock PR_SendPacketToPlayerStream(BitStream:bs, playerid, PR_PacketPriority:priority = PR_HIGH_PRIORITY, PR_PacketReliability:reliability = PR_RELIABLE_ORDERED, orderingchannel = 0)
+        {
+            #if defined foreach
+            foreach (new i : Player) {
+            #else
+            for (new i = GetPlayerPoolSize(); i >= 0; i--) {
+            #endif
+                if (!IsPlayerStreamedIn(i, playerid)) {
+                    continue;
+                }
+                PR_SendPacket(bs, i, priority, reliability, orderingchannel);
+            }
+        }
+        stock PR_SendRPCToPlayerStream(BitStream:bs, playerid, rpcid, PR_PacketPriority:priority = PR_HIGH_PRIORITY, PR_PacketReliability:reliability = PR_RELIABLE_ORDERED, orderingchannel = 0)
+        {
+            #if defined foreach
+            foreach (new i : Player) {
+            #else
+            for (new i = GetPlayerPoolSize(); i >= 0; i--) {
+            #endif
+                if (!IsPlayerStreamedIn(i, playerid)) {
+                    continue;
+                }
+                PR_SendRPC(bs, i, rpcid, priority, reliability, orderingchannel);
+            }
+        }
+        stock PR_SendPacketToVehicleStream(BitStream:bs, vehicleid, excludedplayerid = INVALID_PLAYER_ID, PR_PacketPriority:priority = PR_HIGH_PRIORITY, PR_PacketReliability:reliability = PR_RELIABLE_ORDERED, orderingchannel = 0)
+        {
+            #if defined foreach
+            foreach (new i : Player) {
+            #else
+            for (new i = GetPlayerPoolSize(); i >= 0; i--) {
+            #endif
+                if (i == excludedplayerid || !IsVehicleStreamedIn(vehicleid, i)) {
+                    continue;
+                }
+                PR_SendPacket(bs, i, priority, reliability, orderingchannel);
+            }
+        }
+        stock PR_SendRPCToVehicleStream(BitStream:bs, vehicleid, rpcid, excludedplayerid = INVALID_PLAYER_ID, PR_PacketPriority:priority = PR_HIGH_PRIORITY, PR_PacketReliability:reliability = PR_RELIABLE_ORDERED, orderingchannel = 0)
+        {
+            #if defined foreach
+            foreach (new i : Player) {
+            #else
+            for (new i = GetPlayerPoolSize(); i >= 0; i--) {
+            #endif
+                if (i == excludedplayerid || !IsVehicleStreamedIn(vehicleid, i)) {
+                    continue;
+                }
+                PR_SendRPC(bs, i, rpcid, priority, reliability, orderingchannel);
+            }
+        }
+        forward OnIncomingPacket(playerid, packetid, BitStream:bs);
+        forward OnIncomingRPC(playerid, rpcid, BitStream:bs);
+        forward OnOutgoingPacket(playerid, packetid, BitStream:bs);
+        forward OnOutgoingRPC(playerid, rpcid, BitStream:bs);
+        #pragma deprecated Use OnOutgoingPacket instead
+        forward OnOutcomingPacket(playerid, packetid, BitStream:bs);
+        #pragma deprecated Use OnOutgoingRPC instead
+        forward OnOutcomingRPC(playerid, rpcid, BitStream:bs);
+        #if defined FILTERSCRIPT
+            public OnFilterScriptInit()
+            {
+                PR_Init();
+                #if defined PawnRakNet_OnFilterScriptInit
+                    PawnRakNet_OnFilterScriptInit();
+                #endif
+                return 1;
+            }
+            #if defined _ALS_OnFilterScriptInit
+                #undef OnFilterScriptInit
+            #else
+                #define _ALS_OnFilterScriptInit
+            #endif
+            #define OnFilterScriptInit PawnRakNet_OnFilterScriptInit
+            #if defined PawnRakNet_OnFilterScriptInit
+                forward PawnRakNet_OnFilterScriptInit();
+            #endif
+        #else
+            public OnGameModeInit()
+            {
+                PR_Init();
+                #if defined PawnRakNet_OnGameModeInit
+                    PawnRakNet_OnGameModeInit();
+                #endif
+                return 1;
+            }
+            #if defined _ALS_OnGameModeInit
+                #undef OnGameModeInit
+            #else
+                #define _ALS_OnGameModeInit
+            #endif
+            #define OnGameModeInit PawnRakNet_OnGameModeInit
+            #if defined PawnRakNet_OnGameModeInit
+                forward PawnRakNet_OnGameModeInit();
+            #endif
+        #endif
+    #endif
+#endif

Pawn.Regex.inc

@@ -0,0 +1,69 @@
+#if !defined PAWNREGEX_INC_
+    #define PAWNREGEX_INC_
+    #define _pawnregex_included
+    #if !defined PACK_PLUGIN_VERSION
+        #define PACK_PLUGIN_VERSION(%0,%1,%2) (((%0) << 16) | ((%1) << 8) | (%2))
+    #endif
+    #define PAWNREGEX_VERSION PACK_PLUGIN_VERSION(1, 2, 3)
+    #define PAWNREGEX_INCLUDE_VERSION PAWNREGEX_VERSION
+    enum E_REGEX_GRAMMAR
+    {
+        REGEX_ECMASCRIPT,
+        REGEX_BASIC,
+        REGEX_EXTENDED,
+        REGEX_AWK,
+        REGEX_GREP,
+        REGEX_EGREP
+    };
+    enum E_REGEX_FLAG
+    {
+        REGEX_DEFAULT = 1 << 0,
+        REGEX_ICASE = 1 << 1,
+        REGEX_NOSUBS = 1 << 2,
+        REGEX_OPTIMIZE = 1 << 3,
+        REGEX_COLLATE = 1 << 4,
+    };
+    enum E_MATCH_FLAG
+    {
+        MATCH_DEFAULT = 1 << 0,
+        MATCH_NOT_BOL = 1 << 1,
+        MATCH_NOT_EOL = 1 << 2,
+        MATCH_NOT_BOW = 1 << 3,
+        MATCH_NOT_EOW = 1 << 4,
+        MATCH_ANY = 1 << 5,
+        MATCH_NOT_NULL = 1 << 6,
+        MATCH_CONTINUOUS = 1 << 7,
+        MATCH_PREV_AVAIL = 1 << 8,
+        MATCH_FORMAT_SED = 1 << 9,
+        MATCH_FORMAT_NO_COPY = 1 << 10,
+        MATCH_FORMAT_FIRST_ONLY = 1 << 11,
+    };
+    #if !defined __cplusplus
+        public _pawnregex_version = PAWNREGEX_VERSION;
+        #pragma unused _pawnregex_version
+        native Regex:Regex_New(const pattern[], E_REGEX_FLAG:flags = REGEX_DEFAULT, E_REGEX_GRAMMAR:grammar = REGEX_ECMASCRIPT);
+        native Regex_Delete(&Regex:r);
+        native Regex_Check(const str[], Regex:r, E_MATCH_FLAG:flags = MATCH_DEFAULT);
+        native Regex_Match(const str[], Regex:r, &RegexMatch:m, E_MATCH_FLAG:flags = MATCH_DEFAULT);
+        native Regex_Search(const str[], Regex:r, &RegexMatch:m, &pos, startpos = 0, E_MATCH_FLAG:flags = MATCH_DEFAULT);
+        native Regex_Replace(const str[], Regex:r, const fmt[], dest[], E_MATCH_FLAG:flags = MATCH_DEFAULT, size = sizeof dest);
+        native Match_GetGroup(RegexMatch:m, index, dest[], &length, size = sizeof dest);
+        native Match_Free(&RegexMatch:m);
+        #pragma deprecated Use Regex_New instead
+        native regex:regex_new(const pattern[], E_REGEX_FLAG:flags = REGEX_DEFAULT, E_REGEX_GRAMMAR:grammar = REGEX_ECMASCRIPT) = Regex_New;
+        #pragma deprecated Use Regex_Delete instead
+        native regex_delete(&regex:r) = Regex_Delete;
+        #pragma deprecated Use Regex_Check instead
+        native regex_check(const str[], regex:r, E_MATCH_FLAG:flags = MATCH_DEFAULT) = Regex_Check;
+        #pragma deprecated Use Regex_Match instead
+        native regex_match(const str[], regex:r, &match_results:m, E_MATCH_FLAG:flags = MATCH_DEFAULT) = Regex_Match;
+        #pragma deprecated Use Regex_Search instead
+        native regex_search(const str[], regex:r, &match_results:m, &pos, startpos = 0, E_MATCH_FLAG:flags = MATCH_DEFAULT) = Regex_Search;
+        #pragma deprecated Use Regex_Replace instead
+        native regex_replace(const str[], regex:r, const fmt[], dest[], E_MATCH_FLAG:flags = MATCH_DEFAULT, size = sizeof dest) = Regex_Replace;
+        #pragma deprecated Use Match_GetGroup instead
+        native match_get_group(match_results:m, index, dest[], &length, size = sizeof dest) = Match_GetGroup;
+        #pragma deprecated Use Match_Free instead
+        native match_free(&match_results:m) = Match_Free;
+    #endif
+#endif

_fixes_options.inc

@@ -0,0 +1,310 @@
+#if !_FIXES_NEW_COMPILER
+	#endinput
+#endif
+#if !FIXES_ExplicitOptions
+	#endinput
+#endif
+#if defined _inc__fixes_options
+	#undef _inc__fixes_options
+#endif
+#if defined _FIXES_OPTION
+	#undef _FIXES_OPTION
+	#define _FIXES_OPTION stock
+#endif
+#if !defined _FIXES_WARNING
+	#error `_fixes_options.inc` included, but `_FIXES_WARNING` is not defined to select a warning message.
+#endif
+#pragma warning push
+#pragma warning enable 237
+#if _FIXES_WARNING == 1
+	#warning Option `FIX_API` must now be explicit.
+#elseif _FIXES_WARNING == 2
+	#warning Option `FIX_Natives` must now be explicit.
+#elseif _FIXES_WARNING == 3
+	#warning Option `FIX_GetPlayerColour` must now be explicit.
+#elseif _FIXES_WARNING == 4
+	#warning Option `FIX_FILTERSCRIPT` must now be explicit.
+#elseif _FIXES_WARNING == 5
+	#warning Option `FIX_SpawnPlayer` must now be explicit.
+#elseif _FIXES_WARNING == 6
+	#warning Option `FIX_SetPlayerName` must now be explicit.
+#elseif _FIXES_WARNING == 7
+	#warning Option `FIX_GetPlayerSkin` must now be explicit.
+#elseif _FIXES_WARNING == 8
+	#warning Option `FIX_GetWeaponName` must now be explicit.
+#elseif _FIXES_WARNING == 9
+	#warning Option `FIX_SetPlayerWorldBounds` must now be explicit.
+#elseif _FIXES_WARNING == 10
+	#warning Option `FIX_TogglePlayerControllable` must now be explicit.
+#elseif _FIXES_WARNING == 11
+	#warning Option `FIX_HydraSniper` must now be explicit.
+#elseif _FIXES_WARNING == 12
+	#warning Option `FIX_IsPlayerInCheckpoint` must now be explicit.
+#elseif _FIXES_WARNING == 13
+	#warning Option `FIX_IsPlayerInRaceCheckpoint` must now be explicit.
+#elseif _FIXES_WARNING == 14
+	#warning Option `FIX_GetPlayerWeapon` must now be explicit.
+#elseif _FIXES_WARNING == 15
+	#warning Option `FIX_PutPlayerInVehicle` must now be explicit.
+#elseif _FIXES_WARNING == 16
+	#warning Option `FIX_KEY_AIM` must now be explicit.
+#elseif _FIXES_WARNING == 17
+	#warning Option `FIX_SPECIAL_ACTION_PISSING` must now be explicit.
+#elseif _FIXES_WARNING == 18
+	#warning Option `FIX_IsValidVehicle` must now be explicit.
+#elseif _FIXES_WARNING == 19
+	#warning Option `FIX_GetGravity` must now be explicit.
+#elseif _FIXES_WARNING == 20
+	#warning Option `FIX_gpci` must now be explicit.
+#elseif _FIXES_WARNING == 21
+	#warning Option `FIX_WEAPONS` must now be explicit.
+#elseif _FIXES_WARNING == 22
+	#warning Option `FIX_BODYPARTS` must now be explicit.
+#elseif _FIXES_WARNING == 23
+	#warning Option `FIX_CAMERAMODES` must now be explicit.
+#elseif _FIXES_WARNING == 24
+	#warning Option `FIX_DriveBy` must now be explicit.
+#elseif _FIXES_WARNING == 25
+	#warning Option `FIX_SilentTeleport` must now be explicit.
+#elseif _FIXES_WARNING == 26
+	#warning Option `FIX_SetPlayerCheckpoint` must now be explicit.
+#elseif _FIXES_WARNING == 27
+	#warning Option `FIX_SetPlayerRaceCheckpoint` must now be explicit.
+#elseif _FIXES_WARNING == 28
+	#warning Option `FIX_TextDrawCreate` must now be explicit.
+#elseif _FIXES_WARNING == 29
+	#warning Option `FIX_AttachTrailerToVehicle` must now be explicit.
+#elseif _FIXES_WARNING == 30
+	#warning Option `FIX_GetVehicleComponentInSlot` must now be explicit.
+#elseif _FIXES_WARNING == 31
+	#warning Option `FIX_TextDrawCreate_2` must now be explicit.
+#elseif _FIXES_WARNING == 32
+	#warning Option `FIX_TextDrawSetString` must now be explicit.
+#elseif _FIXES_WARNING == 33
+	#warning Option `FIX_TextDrawSetString_2` must now be explicit.
+#elseif _FIXES_WARNING == 34
+	#warning Option `FIX_AllowInteriorWeapons` must now be explicit.
+#elseif _FIXES_WARNING == 35
+	#warning Option `FIX_OnPlayerEnterVehicle` must now be explicit.
+#elseif _FIXES_WARNING == 36
+	#warning Option `FIX_OnPlayerEnterVehicle_2` must now be explicit.
+#elseif _FIXES_WARNING == 37
+	#warning Option `FIX_OnPlayerEnterVehicle_3` must now be explicit.
+#elseif _FIXES_WARNING == 38
+	#warning Option `FIX_AllowTeleport` must now be explicit.
+#elseif _FIXES_WARNING == 39
+	#warning Option `FIX_SetPlayerSpecialAction` must now be explicit.
+#elseif _FIXES_WARNING == 40
+	#warning Option `FIX_ClearAnimations` must now be explicit.
+#elseif _FIXES_WARNING == 41
+	#warning Option `FIX_ClearAnimations_2` must now be explicit.
+#elseif _FIXES_WARNING == 42
+	#warning Option `FIX_GangZoneCreate` must now be explicit.
+#elseif _FIXES_WARNING == 43
+	#warning Option `FIX_OnDialogResponse` must now be explicit.
+#elseif _FIXES_WARNING == 44
+	#warning Option `FIX_GetPlayerDialog` must now be explicit.
+#elseif _FIXES_WARNING == 45
+	#warning Option `FIX_PlayerDialogResponse` must now be explicit.
+#elseif _FIXES_WARNING == 46
+	#warning Option `FIX_SetSpawnInfo` must now be explicit.
+#elseif _FIXES_WARNING == 47
+	#warning Option `FIX_SetSpawnInfo_2` must now be explicit.
+#elseif _FIXES_WARNING == 48
+	#warning Option `FIX_SetPlayerSkin` must now be explicit.
+#elseif _FIXES_WARNING == 49
+	#warning Option `FIX_valstr` must now be explicit.
+#elseif _FIXES_WARNING == 50
+	#warning Option `FIX_file_inc` must now be explicit.
+#elseif _FIXES_WARNING == 51
+	#warning Option `FIX_SetPlayerAttachedObject` must now be explicit.
+#elseif _FIXES_WARNING == 52
+	#warning Option `FIX_OnPlayerDeath` must now be explicit.
+#elseif _FIXES_WARNING == 53
+	#warning Option `FIX_strins` must now be explicit.
+#elseif _FIXES_WARNING == 54
+	#warning Option `FIX_IsPlayerConnected` must now be explicit.
+#elseif _FIXES_WARNING == 55
+	#warning Option `FIX_TrainExit` must now be explicit.
+#elseif _FIXES_WARNING == 56
+	#warning Option `FIX_Kick` must now be explicit.
+#elseif _FIXES_WARNING == 57
+	#warning Option `FIX_OnVehicleMod` must now be explicit.
+#elseif _FIXES_WARNING == 58
+	#warning Option `FIX_random` must now be explicit.
+#elseif _FIXES_WARNING == 59
+	#warning Option `FIX_sleep` must now be explicit.
+#elseif _FIXES_WARNING == 60
+	#warning Option `FIX_Menus` must now be explicit.
+#elseif _FIXES_WARNING == 61
+	#warning Option `FIX_AddMenuItem` must now be explicit.
+#elseif _FIXES_WARNING == 62
+	#warning Option `FIX_SetMenuColumnHeader` must now be explicit.
+#elseif _FIXES_WARNING == 63
+	#warning Option `FIX_ShowMenuForPlayer` must now be explicit.
+#elseif _FIXES_WARNING == 64
+	#warning Option `FIX_HideMenuForPlayer` must now be explicit.
+#elseif _FIXES_WARNING == 65
+	#warning Option `FIX_GetPlayerMenu` must now be explicit.
+#elseif _FIXES_WARNING == 66
+	#warning Option `FIX_HideMenuForPlayer_2` must now be explicit.
+#elseif _FIXES_WARNING == 67
+	#warning Option `FIX_DisableMenu` must now be explicit.
+#elseif _FIXES_WARNING == 68
+	#warning Option `FIX_DisableMenuRow` must now be explicit.
+#elseif _FIXES_WARNING == 69
+	#warning Option `FIX_GetPlayerInterior` must now be explicit.
+#elseif _FIXES_WARNING == 70
+	#warning Option `FIX_ApplyAnimation` must now be explicit.
+#elseif _FIXES_WARNING == 71
+	#warning Option `FIX_ApplyAnimation_2` must now be explicit.
+#elseif _FIXES_WARNING == 72
+	#warning Option `FIX_ApplyActorAnimation` must now be explicit.
+#elseif _FIXES_WARNING == 73
+	#warning Option `FIX_ApplyActorAnimation_2` must now be explicit.
+#elseif _FIXES_WARNING == 74
+	#warning Option `FIX_OnPlayerSpawn` must now be explicit.
+#elseif _FIXES_WARNING == 75
+	#warning Option `FIX_GameText` must now be explicit.
+#elseif _FIXES_WARNING == 76
+	#warning Option `FIX_HideGameText` must now be explicit.
+#elseif _FIXES_WARNING == 77
+	#warning Option `FIX_GetPlayerWorldBounds` must now be explicit.
+#elseif _FIXES_WARNING == 78
+	#warning Option `FIX_ClearPlayerWorldBounds` must now be explicit.
+#elseif _FIXES_WARNING == 79
+	#warning Option `FIX_GameTextStyles` must now be explicit.
+#elseif _FIXES_WARNING == 80
+	#warning Option `FIX_OnPlayerConnect` must now be explicit.
+#elseif _FIXES_WARNING == 81
+	#warning Option `FIX_OnPlayerDisconnect` must now be explicit.
+#elseif _FIXES_WARNING == 82
+	#warning Option `FIX_CreatePlayerTextDraw` must now be explicit.
+#elseif _FIXES_WARNING == 83
+	#warning Option `FIX_CreatePlayerTextDraw_2` must now be explicit.
+#elseif _FIXES_WARNING == 84
+	#warning Option `FIX_PlayerTextDrawSetString` must now be explicit.
+#elseif _FIXES_WARNING == 85
+	#warning Option `FIX_PlayerTextDrawSetString_2` must now be explicit.
+#elseif _FIXES_WARNING == 86
+	#warning Option `FIX_SetPlayerCamera` must now be explicit.
+#elseif _FIXES_WARNING == 87
+	#warning Option `FIX_SetPlayerTime` must now be explicit.
+#elseif _FIXES_WARNING == 88
+	#warning Option `FIX_OnPlayerRequestClass` must now be explicit.
+#elseif _FIXES_WARNING == 89
+	#warning Option `FIX_SetPlayerColour` must now be explicit.
+#elseif _FIXES_WARNING == 90
+	#warning Option `FIX_FileMaths` must now be explicit.
+#elseif _FIXES_WARNING == 91
+	#warning Option `FIX_GetPlayerWeaponData` must now be explicit.
+#elseif _FIXES_WARNING == 92
+	#warning Option `FIX_strcmp` must now be explicit.
+#elseif _FIXES_WARNING == 93
+	#warning Option `FIX_GetPVarString` must now be explicit.
+#elseif _FIXES_WARNING == 94
+	#warning Option `FIX_GetSVarString` must now be explicit.
+#elseif _FIXES_WARNING == 95
+	#warning Option `FIX_toupper` must now be explicit.
+#elseif _FIXES_WARNING == 96
+	#warning Option `FIX_tolower` must now be explicit.
+#elseif _FIXES_WARNING == 97
+	#warning Option `FIX_ispacked` must now be explicit.
+#elseif _FIXES_WARNING == 98
+	#warning Option `FIX_PassengerSeating` must now be explicit.
+#elseif _FIXES_WARNING == 99
+	#warning Option `FIX_GogglesSync` must now be explicit.
+#elseif _FIXES_WARNING == 100
+	#warning Option `FIX_GetPlayerPoolSize` must now be explicit.
+#elseif _FIXES_WARNING == 101
+	#warning Option `FIX_SetPlayerPos` must now be explicit.
+#elseif _FIXES_WARNING == 102
+	#warning Option `FIX_GetPlayerAmmo` must now be explicit.
+#elseif _FIXES_WARNING == 103
+	#warning Option `FIX_JIT` must now be explicit.
+#elseif _FIXES_WARNING == 104
+	#warning Option `FIX_OS` must now be explicit.
+#elseif _FIXES_WARNING == 105
+	#warning Option `FIX_const` must now be explicit.
+#elseif _FIXES_WARNING == 106
+	#warning Option `FIX_VEHICLES` must now be explicit.
+#elseif _FIXES_WARNING == 107
+	#warning Option `FIX_GetPlayerWeather` must now be explicit.
+#elseif _FIXES_WARNING == 108
+	#warning Option `FIX_GetWeather` must now be explicit.
+#elseif _FIXES_WARNING == 109
+	#warning Option `FIX_GetWorldTime` must now be explicit.
+#elseif _FIXES_WARNING == 110
+	#warning Option `FIX_GetConsoleVarAsString` must now be explicit.
+#elseif _FIXES_WARNING == 111
+	#warning Option `FIX_GetConsoleVarAsInt` must now be explicit.
+#elseif _FIXES_WARNING == 112
+	#warning Option `FIX_GetConsoleVarAsBool` must now be explicit.
+#elseif _FIXES_WARNING == 113
+	#warning Option `FIX_GetConsoleVarAsFloat` must now be explicit.
+#elseif _FIXES_WARNING == 114
+	#warning Option `FIX_tabsize` must now be explicit.
+#elseif _FIXES_WARNING == 115
+	#warning Option `FIX_Callbacks` must now be explicit.
+#elseif _FIXES_WARNING == 116
+	#warning Option `FIX_OnRconCommand` must now be explicit.
+#elseif _FIXES_WARNING == 117
+	#warning Option `FIX_OnClientCheckResponse` must now be explicit.
+#elseif _FIXES_WARNING == 118
+	#warning Option `FIX_GetMaxPlayers` must now be explicit.
+#elseif _FIXES_WARNING == 119
+	#warning Option `FIX_BypassDialog` must now be explicit.
+#elseif _FIXES_WARNING == 120
+	#warning Option `FIX_SetTimer` must now be explicit.
+#elseif _FIXES_WARNING == 121
+	#warning Option `FIX_main` must now be explicit.
+#elseif _FIXES_WARNING == 122
+	#warning Option `FIX_Pawndoc` must now be explicit.
+#elseif _FIXES_WARNING == 123
+	#warning Option `FIX_OnVehicleSpawn` must now be explicit.
+#elseif _FIXES_WARNING == 124
+	#warning Option `FIX_floatfract` must now be explicit.
+#elseif _FIXES_WARNING == 125
+	#warning Option `FIX_strfind` must now be explicit.
+#elseif _FIXES_WARNING == 126
+	#warning Option `FIX_strdel` must now be explicit.
+#elseif _FIXES_WARNING == 127
+	#warning Option `FIX_LocalNPCNatives` must now be explicit.
+#elseif _FIXES_WARNING == 128
+	#warning Option `FIX_RemoteNPCNatives` must now be explicit.
+#elseif _FIXES_WARNING == 129
+	#warning Option `FIX_deconst` must now be explicit.
+#elseif _FIXES_WARNING == 130
+	#warning Option `FIX_Streamer_HasIntData` must now be explicit.
+#elseif _FIXES_WARNING == 131
+	#warning Option `FIX_Streamer_RemoveIntData` must now be explicit.
+#elseif _FIXES_WARNING == 132
+	#warning Option `FIX_defaults` must now be explicit.
+#elseif _FIXES_WARNING == 133
+	#warning Option `FIX_limit_tags` must now be explicit.
+#elseif _FIXES_WARNING == 134
+	#warning Option `FIX_bool_tags` must now be explicit.
+#elseif _FIXES_WARNING == 135
+	#warning Option `FIX_TEXT_DRAW_ALIGN` must now be explicit.
+#elseif _FIXES_WARNING == 136
+	#warning Option `FIX_TEXT_DRAW_FONT` must now be explicit.
+#elseif _FIXES_WARNING == 137
+	#warning Option `FIX_GetPlayerKeys` must now be explicit.
+#elseif _FIXES_WARNING == 138
+	#warning Option `FIX_FORCE_SYNC` must now be explicit.
+#elseif _FIXES_WARNING == 139
+	#warning Option `FIX_address_naught` must now be explicit.
+#elseif _FIXES_WARNING == 140
+	#warning Option `FIX_main2` must now be explicit.
+#elseif _FIXES_WARNING == 141
+	#warning Option `FIX_npcmodes` must now be explicit.
+#elseif _FIXES_WARNING == 142
+	#warning Option `FIX_fgetchar2` must now be explicit.
+#elseif _FIXES_WARNING == 143
+	#warning Option `FIX_memcpy` must now be explicit.
+#elseif _FIXES_WARNING == 144
+	#warning Option `FIX_SHA256` must now be explicit.
+#else
+	#error `_fixes_options.inc` included, but `_FIXES_WARNING` is not set to a valid warning message.
+#endif
+#pragma warning pop

_fixes_settings.inc

@@ -0,0 +1,58 @@
+#if !_FIXES_NEW_COMPILER
+	#endinput
+#endif
+#if !FIXES_ExplicitSettings
+	#endinput
+#endif
+#if defined _inc__fixes_settings
+	#undef _inc__fixes_settings
+#endif
+#if defined _FIXES_SETTING
+	#undef _FIXES_SETTING
+	#define _FIXES_SETTING stock
+#endif
+#if !defined _FIXES_WARNING
+	#error `_fixes_settings.inc` included, but `_FIXES_WARNING` is not defined to select a warning message.
+#endif
+#pragma warning push
+#pragma warning enable 237
+#if _FIXES_WARNING == 1
+	#warning Setting `FIXES_ExplicitSettings`, to make all settings explicit, must now be explicit.
+#elseif _FIXES_WARNING == 2
+	#warning Setting `FIXES_EnableAll`, to enable all fixes, must now be explicit.
+#elseif _FIXES_WARNING == 3
+	#warning Setting `FIXES_EnableDeprecated`, to enable fixes for fixed bugs, must now be explicit.
+#elseif _FIXES_WARNING == 4
+	#warning Setting `FIXES_DefaultDisabled`, to disable all fixes by default, must now be explicit.
+#elseif _FIXES_WARNING == 5
+	#warning Setting `FIXES_ExplicitOptions`, to make all fixes explicit, must now be explicit.
+#elseif _FIXES_WARNING == 6
+	#warning Setting `FIXES_SilentKick`, to kick users without any message, must now be explicit.
+#elseif _FIXES_WARNING == 7
+	#warning Setting `FIXES_Debug`, to enable debug mode, must now be explicit.
+#elseif _FIXES_WARNING == 8
+	#warning Setting `FIXES_Single`, to enable single script mode, must now be explicit.
+#elseif _FIXES_WARNING == 9
+	#warning Setting `FIXES_NoSingleMsg`, to disable the single mode warning message, must now be explicit.
+#elseif _FIXES_WARNING == 10
+	#warning Setting `FIXES_NoServerVarMsg`, to disable the config access warning message, must now be explicit.
+#elseif _FIXES_WARNING == 11
+	#warning Setting `FIXES_NoGetMaxPlayersMsg`, to disable the `MAX_PLAYERS` warning message, must now be explicit.
+#elseif _FIXES_WARNING == 12
+	#warning Setting `FIXES_NoPawndoc`, to disable all fixes.inc pawndoc output, must now be explicit.
+#elseif _FIXES_WARNING == 13
+	#warning Setting `FIXES_CorrectInvalidTimerID`, to specify that you know invalid timers are `0`, must now be explicit.
+#elseif _FIXES_WARNING == 14
+	#warning Setting `FIXES_NoYSI`, to optimise the code when YSI isn't used, must now be explicit.
+#elseif _FIXES_WARNING == 15
+	#warning Setting `FIXES_OneRandomVehicleColour`, to allow only one random vehicle colour, must now be explicit.
+#elseif _FIXES_WARNING == 16
+	#warning Setting `FIXES_NoVehicleColourMsg`, to disable the vehicle colours warning, must now be explicit.
+#elseif _FIXES_WARNING == 17
+	#warning Setting `FIXES_CountFilterscripts`, to count loaded filterscripts, must now be explicit.
+#elseif _FIXES_WARNING == 18
+	#warning Setting `FIXES_NoFilterscriptsMsg`, to hide the filterscripts error information, must now be explicit.
+#else
+	#error `_fixes_settings.inc` included, but `_FIXES_WARNING` is not set to a valid warning message.
+#endif
+#pragma warning pop

a_actor.inc

@@ -0,0 +1,23 @@
+#if defined _INC_a_actor
+	#endinput
+#endif
+#define _INC_a_actor
+#define _actor_included
+#define SAMP_CONST_CORRECT
+#pragma tabsize 4
+native CreateActor(modelid, Float:X, Float:Y, Float:Z, Float:Rotation);
+native DestroyActor(actorid);
+native IsActorStreamedIn(actorid, forplayerid);
+native SetActorVirtualWorld(actorid, vworld);
+native GetActorVirtualWorld(actorid);
+native ApplyActorAnimation(actorid, const animlib[], const animname[], Float:fDelta, loop, lockx, locky, freeze, time);
+native ClearActorAnimations(actorid);
+native SetActorPos(actorid, Float:X, Float:Y, Float:Z);
+native GetActorPos(actorid, &Float:X, &Float:Y, &Float:Z);
+native SetActorFacingAngle(actorid, Float:ang);
+native GetActorFacingAngle(actorid, &Float:ang);
+native SetActorHealth(actorid, Float:health);
+native GetActorHealth(actorid, &Float:health);
+native SetActorInvulnerable(actorid, invulnerable = true);
+native IsActorInvulnerable(actorid);
+native IsValidActor(actorid);

a_http.inc

@@ -0,0 +1,16 @@
+#if defined _INC_a_http
+	#endinput
+#endif
+#define _INC_a_http
+#define SAMP_CONST_CORRECT
+#pragma tabsize 4
+#define HTTP_GET                               (1)
+#define HTTP_POST                              (2)
+#define HTTP_HEAD                              (3)
+#define HTTP_ERROR_BAD_HOST                    (1)
+#define HTTP_ERROR_NO_SOCKET                   (2)
+#define HTTP_ERROR_CANT_CONNECT                (3)
+#define HTTP_ERROR_CANT_WRITE                  (4)
+#define HTTP_ERROR_CONTENT_TOO_BIG             (5)
+#define HTTP_ERROR_MALFORMED_RESPONSE          (6)
+native HTTP(index, type, const url[], const data[], const callback[]);

a_mysql.inc

@@ -0,0 +1,196 @@
+#if defined mysql_included
+	#endinput
+#endif
+#define mysql_included
+#define ER_DBACCESS_DENIED_ERROR 		1044
+#define ER_ACCESS_DENIED_ERROR 			1045
+#define ER_UNKNOWN_TABLE 				1109
+#define ER_SYNTAX_ERROR 				1149
+#define CR_SERVER_GONE_ERROR 			2006
+#define CR_SERVER_LOST 					2013
+#define CR_COMMAND_OUT_OF_SYNC 			2014
+#define CR_SERVER_LOST_EXTENDED 		2055
+#if !defined E_LOGLEVEL
+enum E_LOGLEVEL
+{
+	NONE = 0,
+	DEBUG = 1,
+	INFO = 2,
+	WARNING = 4,
+	ERROR = 8,
+	ALL = ERROR | WARNING | INFO | DEBUG
+};
+#endif
+enum E_ORM_ERROR
+{
+	ERROR_INVALID,
+	ERROR_OK,
+	ERROR_NO_DATA
+};
+enum E_MYSQL_GLOBAL_OPTION
+{
+	DUPLICATE_CONNECTIONS,
+	DUPLICATE_CONNECTION_WARNING
+};
+enum E_MYSQL_OPTION
+{
+	AUTO_RECONNECT,
+	MULTI_STATEMENTS,
+	POOL_SIZE,
+	SERVER_PORT,
+	SSL_ENABLE,
+	SSL_KEY_FILE,
+	SSL_CERT_FILE,
+	SSL_CA_FILE,
+	SSL_CA_PATH,
+	SSL_CIPHER
+};
+enum E_MYSQL_FIELD_TYPE
+{
+	MYSQL_TYPE_INVALID = -1,
+	MYSQL_TYPE_DECIMAL = 0,
+	MYSQL_TYPE_TINY,
+	MYSQL_TYPE_SHORT,
+	MYSQL_TYPE_LONG,
+	MYSQL_TYPE_FLOAT,
+	MYSQL_TYPE_DOUBLE,
+	MYSQL_TYPE_NULL,
+	MYSQL_TYPE_TIMESTAMP,
+	MYSQL_TYPE_LONGLONG,
+	MYSQL_TYPE_INT24,
+	MYSQL_TYPE_DATE,
+	MYSQL_TYPE_TIME,
+	MYSQL_TYPE_DATETIME,
+	MYSQL_TYPE_YEAR,
+	MYSQL_TYPE_NEWDATE,
+	MYSQL_TYPE_VARCHAR,
+	MYSQL_TYPE_BIT,
+	MYSQL_TYPE_TIMESTAMP2,
+	MYSQL_TYPE_DATETIME2,
+	MYSQL_TYPE_TIME2,
+	MYSQL_TYPE_JSON = 245,
+	MYSQL_TYPE_NEWDECIMAL = 246,
+	MYSQL_TYPE_ENUM = 247,
+	MYSQL_TYPE_SET = 248,
+	MYSQL_TYPE_TINY_BLOB = 249,
+	MYSQL_TYPE_MEDIUM_BLOB = 250,
+	MYSQL_TYPE_LONG_BLOB = 251,
+	MYSQL_TYPE_BLOB = 252,
+	MYSQL_TYPE_VAR_STRING = 253,
+	MYSQL_TYPE_STRING = 254,
+	MYSQL_TYPE_GEOMETRY = 255
+};
+enum E_MYSQL_EXECTIME_UNIT
+{
+	MILLISECONDS,
+	MICROSECONDS
+};
+#define MYSQL_DEFAULT_HANDLE MySQL:1
+#define MYSQL_INVALID_HANDLE MySQL:0
+#define MYSQL_INVALID_CACHE Cache:0
+#define MYSQL_INVALID_ORM ORM:0
+native ORM:orm_create(const table[], MySQL:handle = MYSQL_DEFAULT_HANDLE);
+native orm_destroy(ORM:id);
+native E_ORM_ERROR:orm_errno(ORM:id);
+native orm_apply_cache(ORM:id, row_idx, result_idx = 0);
+native orm_select(ORM:id, const callback[] = "", const format[] = "", {Float, _}:...);
+native orm_update(ORM:id, const callback[] = "", const format[] = "", {Float, _}:...);
+native orm_insert(ORM:id, const callback[] = "", const format[] = "", {Float, _}:...);
+native orm_delete(ORM:id, const callback[] = "", const format[] = "", {Float, _}:...);
+native orm_load(ORM:id, const callback[] = "", const format[] = "", {Float, _}:...) = orm_select;
+native orm_save(ORM:id, const callback[] = "", const format[] = "", {Float, _}:...);
+native orm_addvar_int(ORM:id, &var, const columnname[]);
+native orm_addvar_float(ORM:id, &Float:var, const columnname[]);
+native orm_addvar_string(ORM:id, var[], var_maxlen, const columnname[]);
+native orm_clear_vars(ORM:id);
+native orm_delvar(ORM:id, const columnname[]);
+native orm_setkey(ORM:id, const columnname[]);
+native mysql_log(E_LOGLEVEL:loglevel = ERROR | WARNING);
+native MySQL:mysql_connect(const host[], const user[], const password[], const database[], MySQLOpt:option_id = MySQLOpt:0);
+native MySQL:mysql_connect_file(const file_name[] = "mysql.ini");
+native mysql_close(MySQL:handle = MYSQL_DEFAULT_HANDLE);
+native mysql_unprocessed_queries(MySQL:handle = MYSQL_DEFAULT_HANDLE);
+native mysql_global_options(E_MYSQL_GLOBAL_OPTION:type, value);
+native MySQLOpt:mysql_init_options();
+native mysql_set_option(MySQLOpt:option_id, E_MYSQL_OPTION:type, ...);
+native mysql_pquery(MySQL:handle, const query[], const callback[] = "", const format[] = "", {Float,_}:...);
+native mysql_tquery(MySQL:handle, const query[], const callback[] = "", const format[] = "", {Float,_}:...);
+native Cache:mysql_query(MySQL:handle, const query[], bool:use_cache = true);
+native mysql_tquery_file(MySQL:handle, const file_path[], const callback[] = "", const format[] = "", {Float,_}:...);
+native Cache:mysql_query_file(MySQL:handle, const file_path[], bool:use_cache = false);
+native mysql_errno(MySQL:handle = MYSQL_DEFAULT_HANDLE);
+native mysql_error(destination[], max_len = sizeof(destination), MySQL:handle = MYSQL_DEFAULT_HANDLE);
+native mysql_escape_string(const source[], destination[], max_len = sizeof(destination), MySQL:handle = MYSQL_DEFAULT_HANDLE);
+native mysql_format(MySQL:handle, output[], max_len, const format[], {Float,_}:...);
+native mysql_set_charset(const charset[], MySQL:handle = MYSQL_DEFAULT_HANDLE);
+native mysql_get_charset(destination[], max_len = sizeof(destination), MySQL:handle = MYSQL_DEFAULT_HANDLE);
+native mysql_stat(destination[], max_len = sizeof(destination), MySQL:handle = MYSQL_DEFAULT_HANDLE);
+native cache_get_row_count(&destination);
+native cache_get_field_count(&destination);
+native cache_get_result_count(&destination);
+native cache_get_field_name(field_index, destination[], max_len = sizeof(destination));
+native E_MYSQL_FIELD_TYPE:cache_get_field_type(field_index);
+native cache_set_result(result_index);
+stock cache_num_rows()
+{
+	new row_count;
+	cache_get_row_count(row_count);
+	return row_count;
+}
+stock cache_num_fields()
+{
+	new field_count;
+	cache_get_field_count(field_count);
+	return field_count;
+}
+stock cache_num_results()
+{
+	new result_count;
+	cache_get_result_count(result_count);
+	return result_count;
+}
+#define cache_get_value(%1) (_:MSCGV0:MSCGV1:MSCGV2:cache_get_ovrld_value(%1))
+#define MSCGV0:MSCGV1:MSCGV2:cache_get_ovrld_value(%1,"%2",%3) cache_get_value_name(%1,#%2,%3)
+#define MSCGV1:MSCGV2:cache_get_ovrld_value(%1,%8string%9:%2,%3) cache_get_value_name(%1,%2,%3)
+#define MSCGV2:cache_get_ovrld_value(%1,%2,%3) cache_get_value_index(%1,%2,%3)
+#define cache_get_value_int(%1) (_:MSCGVI0:MSCGVI1:MSCGVI2:cache_get_value_int_ovrld(%1))
+#define MSCGVI0:MSCGVI1:MSCGVI2:cache_get_value_int_ovrld(%1,"%2",%3) cache_get_value_name_int(%1,#%2,%3)
+#define MSCGVI1:MSCGVI2:cache_get_value_int_ovrld(%1,%8string%9:%2,%3) cache_get_value_name_int(%1,%2,%3)
+#define MSCGVI2:cache_get_value_int_ovrld(%1,%2,%3) cache_get_value_index_int(%1,%2,%3)
+#define cache_get_value_float(%1) (_:MSCGVF0:MSCGVF1:MSCGVF2:cache_get_value_float_ovrld(%1))
+#define MSCGVF0:MSCGVF1:MSCGVF2:cache_get_value_float_ovrld(%1,"%2",%3) cache_get_value_name_float(%1,#%2,%3)
+#define MSCGVF1:MSCGVF2:cache_get_value_float_ovrld(%1,%8string%9:%2,%3) cache_get_value_name_float(%1,%2,%3)
+#define MSCGVF2:cache_get_value_float_ovrld(%1,%2,%3) cache_get_value_index_float(%1,%2,%3)
+#define cache_get_value_bool(%1) cache_get_value_int(%1)
+#define cache_is_value_null(%1) (_:MSCIVN0:MSCIVN1:MSCIVN2:cache_is_value_null_ovrld(%1))
+#define MSCIVN0:MSCIVN1:MSCIVN2:cache_is_value_null_ovrld(%1,"%2",%3) cache_is_value_name_null(%1,#%2,%3)
+#define MSCIVN1:MSCIVN2:cache_is_value_null_ovrld(%1,%8string%9:%2,%3) cache_is_value_name_null(%1,%2,%3)
+#define MSCIVN2:cache_is_value_null_ovrld(%1,%2,%3) cache_is_value_index_null(%1,%2,%3)
+native cache_get_value_index(row_idx, column_idx, destination[], max_len = sizeof(destination));
+native cache_get_value_index_int(row_idx, column_idx, &destination);
+native cache_get_value_index_float(row_idx, column_idx, &Float:destination);
+stock cache_get_value_index_bool(row_idx, column_idx, &bool:destination)
+{
+    return cache_get_value_index_int(row_idx, column_idx, _:destination);
+}
+native cache_is_value_index_null(row_idx, column_idx, &bool:destination);
+native cache_get_value_name(row_idx, const column_name[], destination[], max_len = sizeof(destination));
+native cache_get_value_name_int(row_idx, const column_name[], &destination);
+native cache_get_value_name_float(row_idx, const column_name[], &Float:destination);
+stock cache_get_value_name_bool(row_idx, const column_name[], &bool:destination)
+{
+    return cache_get_value_name_int(row_idx, column_name, _:destination);
+}
+native cache_is_value_name_null(row_idx, const column_name[], &bool:destination);
+native Cache:cache_save();
+native cache_delete(Cache:cache_id);
+native cache_set_active(Cache:cache_id);
+native cache_unset_active();
+native bool:cache_is_any_active();
+native bool:cache_is_valid(Cache:cache_id);
+native cache_affected_rows();
+native cache_insert_id();
+native cache_warning_count();
+native cache_get_query_exec_time(E_MYSQL_EXECTIME_UNIT:unit = MICROSECONDS);
+native cache_get_query_string(destination[], max_len = sizeof(destination));
+forward OnQueryError(errorid, const error[], const callback[], const query[], MySQL:handle);

a_npc.inc

@@ -0,0 +1,194 @@
+#if defined _INC_a_npc
+	#endinput
+#endif
+#if defined _INC_a_samp
+	#error Include `<a_samp>` or `<a_npc>`, not both.
+#endif
+#define _INC_a_npc
+#define _samp_included
+#define SAMP_CONST_CORRECT
+#pragma tabsize 4
+#if !defined MAX_PLAYER_NAME
+	#define MAX_PLAYER_NAME                    (24)
+#endif
+#if !defined MAX_PLAYERS
+	#define MAX_PLAYERS                        (1000)
+#endif
+#if !defined MAX_VEHICLES
+	#define MAX_VEHICLES                       (2000)
+#endif
+#if !defined MAX_OBJECTS
+	#define MAX_OBJECTS                        (2000)
+#endif
+#if !defined MAX_GANG_ZONES
+	#define MAX_GANG_ZONES                     (1024)
+#endif
+#if !defined MAX_TEXT_DRAWS
+	#define MAX_TEXT_DRAWS                     (Text:2048)
+#endif
+#if !defined MAX_MENUS
+	#define MAX_MENUS                          (Menu:128)
+#endif
+#define NO_TEAM                                (255)
+#define INVALID_PLAYER_ID                      (0xFFFF)
+#define INVALID_VEHICLE_ID                     (0xFFFF)
+#define INVALID_OBJECT_ID                      (0xFFFF)
+#define INVALID_MENU                           (Menu:0xFF)
+#define INVALID_TEXT_DRAW                      (Text:0xFFFF)
+#define INVALID_GANG_ZONE                      (-1)
+#define PLAYER_STATE_NONE                      (0)
+#define PLAYER_STATE_ONFOOT                    (1)
+#define PLAYER_STATE_DRIVER                    (2)
+#define PLAYER_STATE_PASSENGER                 (3)
+#define PLAYER_STATE_WASTED                    (7)
+#define PLAYER_STATE_SPAWNED                   (8)
+#define PLAYER_STATE_SPECTATING                (9)
+#define WEAPON_BRASSKNUCKLE                    (1)
+#define WEAPON_GOLFCLUB                        (2)
+#define WEAPON_NITESTICK                       (3)
+#define WEAPON_KNIFE                           (4)
+#define WEAPON_BAT                             (5)
+#define WEAPON_SHOVEL                          (6)
+#define WEAPON_POOLSTICK                       (7)
+#define WEAPON_KATANA                          (8)
+#define WEAPON_CHAINSAW                        (9)
+#define WEAPON_DILDO                           (10)
+#define WEAPON_DILDO2                          (11)
+#define WEAPON_VIBRATOR                        (12)
+#define WEAPON_VIBRATOR2                       (13)
+#define WEAPON_FLOWER                          (14)
+#define WEAPON_CANE                            (15)
+#define WEAPON_GRENADE                         (16)
+#define WEAPON_TEARGAS                         (17)
+#define WEAPON_MOLTOV                          (18)
+#define WEAPON_COLT45                          (22)
+#define WEAPON_SILENCED                        (23)
+#define WEAPON_DEAGLE                          (24)
+#define WEAPON_SHOTGUN                         (25)
+#define WEAPON_SAWEDOFF                        (26)
+#define WEAPON_SHOTGSPA                        (27)
+#define WEAPON_UZI                             (28)
+#define WEAPON_MP5                             (29)
+#define WEAPON_AK47                            (30)
+#define WEAPON_M4                              (31)
+#define WEAPON_TEC9                            (32)
+#define WEAPON_RIFLE                           (33)
+#define WEAPON_SNIPER                          (34)
+#define WEAPON_ROCKETLAUNCHER                  (35)
+#define WEAPON_HEATSEEKER                      (36)
+#define WEAPON_FLAMETHROWER                    (37)
+#define WEAPON_MINIGUN                         (38)
+#define WEAPON_SATCHEL                         (39)
+#define WEAPON_BOMB                            (40)
+#define WEAPON_SPRAYCAN                        (41)
+#define WEAPON_FIREEXTINGUISHER                (42)
+#define WEAPON_CAMERA                          (43)
+#define WEAPON_PARACHUTE                       (46)
+#define WEAPON_VEHICLE                         (49)
+#define WEAPON_DROWN                           (53)
+#define WEAPON_COLLISION                       (54)
+#define KEY_ACTION                             (1)
+#define KEY_CROUCH                             (2)
+#define KEY_FIRE                               (4)
+#define KEY_SPRINT                             (8)
+#define KEY_SECONDARY_ATTACK                   (16)
+#define KEY_JUMP                               (32)
+#define KEY_LOOK_RIGHT                         (64)
+#define KEY_HANDBRAKE                          (128)
+#define KEY_LOOK_LEFT                          (256)
+#define KEY_SUBMISSION                         (512)
+#define KEY_LOOK_BEHIND                        (512)
+#define KEY_WALK                               (1024)
+#define KEY_ANALOG_UP                          (2048)
+#define KEY_ANALOG_DOWN                        (4096)
+#define KEY_ANALOG_RIGHT                       (16384)
+#define KEY_ANALOG_LEFT                        (8192)
+#define KEY_UP                                 (-128)
+#define KEY_DOWN                               (128)
+#define KEY_LEFT                               (-128)
+#define KEY_RIGHT                              (128)
+#define PLAYER_RECORDING_TYPE_NONE             (0)
+#define PLAYER_RECORDING_TYPE_DRIVER           (1)
+#define PLAYER_RECORDING_TYPE_ONFOOT           (2)
+#if MAX_PLAYER_NAME < 1 || MAX_PLAYER_NAME > 24
+	#error MAX_PLAYER_NAME must be >= 1 and <= 24
+#endif
+#if MAX_PLAYERS < 1 || MAX_PLAYERS > 1000
+	#error MAX_PLAYERS must be >= 1 and <= 1000
+#endif
+#if MAX_VEHICLES < 1 || MAX_VEHICLES > 2000
+	#error MAX_VEHICLES must be >= 1 and <= 2000
+#endif
+#if MAX_OBJECTS < 1 || MAX_OBJECTS > 2000
+	#error MAX_OBJECTS must be >= 1 and <= 2000
+#endif
+#if MAX_GANG_ZONES < 1 || MAX_GANG_ZONES > 1024
+	#error MAX_GANG_ZONES must be >= 1 and <= 1024
+#endif
+#if MAX_TEXT_DRAWS < Text:1 || MAX_TEXT_DRAWS > Text:2048
+	#error MAX_TEXT_DRAWS must be >= 1 and <= 2048
+#endif
+#if MAX_MENUS < Menu:1 || MAX_MENUS > Menu:128
+	#error MAX_MENUS must be >= 1 and <= 128
+#endif
+public const SAMP_INCLUDES_VERSION = 0x037030;
+#include <core>
+#include <float>
+#include <string>
+#include <file>
+#include <time>
+#include <datagram>
+#tryinclude <console>
+#if !defined _console_included
+	#define _console_included
+	native print(const string[]);
+	native printf(const format[], {Float,_}:...);
+#endif
+native format(output[], len = sizeof output, const format[], {Float,_}:...);
+native SetTimer(const funcname[], interval, repeating);
+native KillTimer(timerid);
+native GetTickCount();
+native Float:asin(Float:value);
+native Float:acos(Float:value);
+native Float:atan(Float:value);
+native Float:atan2(Float:y, Float:x);
+native SendChat(const msg[]);
+native SendCommand(const commandtext[]);
+native GetPlayerState(playerid);
+native GetPlayerPos(playerid, &Float:x, &Float:y, &Float:z);
+native GetPlayerVehicleID(playerid);
+native GetPlayerArmedWeapon(playerid);
+native GetPlayerHealth(playerid);
+native GetPlayerArmour(playerid);
+native GetPlayerSpecialAction(playerid);
+native IsPlayerStreamedIn(playerid);
+native IsVehicleStreamedIn(vehicleid);
+native GetPlayerKeys(playerid, &keys, &updown, &leftright);
+native GetPlayerFacingAngle(playerid, &Float:ang);
+native GetMyPos(&Float:x, &Float:y, &Float:z);
+native SetMyPos(Float:x, Float:y, Float:z);
+native GetMyFacingAngle(&Float:ang);
+native SetMyFacingAngle(Float:ang);
+native GetDistanceFromMeToPoint(Float:X, Float:Y, Float:Z, &Float:Distance);
+native IsPlayerInRangeOfPoint(playerid, Float:range, Float:X, Float:Y, Float:Z);
+native GetPlayerName(playerid, name[], len = sizeof name);
+native IsPlayerConnected(playerid);
+native StartRecordingPlayback(playbacktype, const recordname[]);
+native StopRecordingPlayback();
+native PauseRecordingPlayback();
+native ResumeRecordingPlayback();
+forward OnNPCModeInit();
+forward OnNPCModeExit();
+forward OnNPCConnect(myplayerid);
+forward OnNPCDisconnect(reason[]);
+forward OnNPCSpawn();
+forward OnNPCEnterVehicle(vehicleid, seatid);
+forward OnNPCExitVehicle();
+forward OnClientMessage(color, text[]);
+forward OnPlayerDeath(playerid);
+forward OnPlayerText(playerid, text[]);
+forward OnPlayerStreamIn(playerid);
+forward OnPlayerStreamOut(playerid);
+forward OnVehicleStreamIn(vehicleid);
+forward OnVehicleStreamOut(vehicleid);
+forward OnRecordingPlaybackEnd();

a_objects.inc

@@ -0,0 +1,62 @@
+#if defined _INC_a_objects
+	#endinput
+#endif
+#define _INC_a_objects
+#define _objects_included
+#define SAMP_CONST_CORRECT
+#pragma tabsize 4
+#define OBJECT_MATERIAL_SIZE_32x32             (10)
+#define OBJECT_MATERIAL_SIZE_64x32             (20)
+#define OBJECT_MATERIAL_SIZE_64x64             (30)
+#define OBJECT_MATERIAL_SIZE_128x32            (40)
+#define OBJECT_MATERIAL_SIZE_128x64            (50)
+#define OBJECT_MATERIAL_SIZE_128x128           (60)
+#define OBJECT_MATERIAL_SIZE_256x32            (70)
+#define OBJECT_MATERIAL_SIZE_256x64            (80)
+#define OBJECT_MATERIAL_SIZE_256x128           (90)
+#define OBJECT_MATERIAL_SIZE_256x256           (100)
+#define OBJECT_MATERIAL_SIZE_512x64            (110)
+#define OBJECT_MATERIAL_SIZE_512x128           (120)
+#define OBJECT_MATERIAL_SIZE_512x256           (130)
+#define OBJECT_MATERIAL_SIZE_512x512           (140)
+#define OBJECT_MATERIAL_TEXT_ALIGN_LEFT        (0)
+#define OBJECT_MATERIAL_TEXT_ALIGN_CENTER      (1)
+#define OBJECT_MATERIAL_TEXT_ALIGN_RIGHT       (2)
+native CreateObject(modelid, Float:X, Float:Y, Float:Z, Float:rX, Float:rY, Float:rZ, Float:DrawDistance = 0.0);
+native AttachObjectToVehicle(objectid, vehicleid, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:RotX, Float:RotY, Float:RotZ);
+native AttachObjectToObject(objectid, attachtoid, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:RotX, Float:RotY, Float:RotZ, SyncRotation = 1);
+native AttachObjectToPlayer(objectid, playerid, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:RotX, Float:RotY, Float:RotZ);
+native SetObjectPos(objectid, Float:X, Float:Y, Float:Z);
+native GetObjectPos(objectid, &Float:X, &Float:Y, &Float:Z);
+native SetObjectRot(objectid, Float:RotX, Float:RotY, Float:RotZ);
+native GetObjectRot(objectid, &Float:RotX, &Float:RotY, &Float:RotZ);
+native GetObjectModel(objectid);
+native SetObjectNoCameraCol(objectid);
+native IsValidObject(objectid);
+native DestroyObject(objectid);
+native MoveObject(objectid, Float:X, Float:Y, Float:Z, Float:Speed, Float:RotX = -1000.0, Float:RotY = -1000.0, Float:RotZ = -1000.0);
+native StopObject(objectid);
+native IsObjectMoving(objectid);
+native EditObject(playerid, objectid);
+native EditPlayerObject(playerid, objectid);
+native SelectObject(playerid);
+native CancelEdit(playerid);
+native CreatePlayerObject(playerid, modelid, Float:X, Float:Y, Float:Z, Float:rX, Float:rY, Float:rZ, Float:DrawDistance = 0.0);
+native AttachPlayerObjectToVehicle(playerid, objectid, vehicleid, Float:fOffsetX, Float:fOffsetY, Float:fOffsetZ, Float:fRotX, Float:fRotY, Float:RotZ);
+native SetPlayerObjectPos(playerid, objectid, Float:X, Float:Y, Float:Z);
+native GetPlayerObjectPos(playerid, objectid, &Float:X, &Float:Y, &Float:Z);
+native SetPlayerObjectRot(playerid, objectid, Float:RotX, Float:RotY, Float:RotZ);
+native GetPlayerObjectRot(playerid, objectid, &Float:RotX, &Float:RotY, &Float:RotZ);
+native GetPlayerObjectModel(playerid, objectid);
+native SetPlayerObjectNoCameraCol(playerid, objectid);
+native IsValidPlayerObject(playerid, objectid);
+native DestroyPlayerObject(playerid, objectid);
+native MovePlayerObject(playerid, objectid, Float:X, Float:Y, Float:Z, Float:Speed, Float:RotX = -1000.0, Float:RotY = -1000.0, Float:RotZ = -1000.0);
+native StopPlayerObject(playerid, objectid);
+native IsPlayerObjectMoving(playerid, objectid);
+native AttachPlayerObjectToPlayer(objectplayer, objectid, attachplayer, Float:OffsetX, Float:OffsetY, Float:OffsetZ, Float:rX, Float:rY, Float:rZ);
+native SetObjectMaterial(objectid, materialindex, modelid, const txdname[], const texturename[], materialcolor=0);
+native SetPlayerObjectMaterial(playerid, objectid, materialindex, modelid, const txdname[], const texturename[], materialcolor=0);
+native SetObjectMaterialText(objectid, const text[], materialindex = 0, materialsize = OBJECT_MATERIAL_SIZE_256x128, const fontface[] = "Arial", fontsize = 24, bold = 1, fontcolor = 0xFFFFFFFF, backcolor = 0, textalignment = 0);
+native SetPlayerObjectMaterialText(playerid, objectid, const text[], materialindex = 0, materialsize = OBJECT_MATERIAL_SIZE_256x128, const fontface[] = "Arial", fontsize = 24, bold = 1, fontcolor = 0xFFFFFFFF, backcolor = 0, textalignment = 0);
+native SetObjectsDefaultCameraCol(disable);

a_players.inc

@@ -0,0 +1,236 @@
+#if defined _INC_a_players
+	#endinput
+#endif
+#define _INC_a_players
+#define _players_included
+#define SAMP_CONST_CORRECT
+#pragma tabsize 4
+#if !defined MAX_PLAYER_ATTACHED_OBJECTS
+	#define MAX_PLAYER_ATTACHED_OBJECTS        (10)
+#endif
+#if !defined MAX_CHATBUBBLE_LENGTH
+	#define MAX_CHATBUBBLE_LENGTH              (144)
+#endif
+#define SPECIAL_ACTION_NONE                    (0)
+#define SPECIAL_ACTION_DUCK                    (1)
+#define SPECIAL_ACTION_USEJETPACK              (2)
+#define SPECIAL_ACTION_ENTER_VEHICLE           (3)
+#define SPECIAL_ACTION_EXIT_VEHICLE            (4)
+#define SPECIAL_ACTION_DANCE1                  (5)
+#define SPECIAL_ACTION_DANCE2                  (6)
+#define SPECIAL_ACTION_DANCE3                  (7)
+#define SPECIAL_ACTION_DANCE4                  (8)
+#define SPECIAL_ACTION_HANDSUP                 (10)
+#define SPECIAL_ACTION_USECELLPHONE            (11)
+#define SPECIAL_ACTION_SITTING                 (12)
+#define SPECIAL_ACTION_STOPUSECELLPHONE        (13)
+#define SPECIAL_ACTION_DRINK_BEER              (20)
+#define SPECIAL_ACTION_SMOKE_CIGGY             (21)
+#define SPECIAL_ACTION_DRINK_WINE              (22)
+#define SPECIAL_ACTION_DRINK_SPRUNK            (23)
+#define SPECIAL_ACTION_PISSING                 (68)
+#define SPECIAL_ACTION_CUFFED                  (24)
+#define SPECIAL_ACTION_CARRY                   (25)
+#define FIGHT_STYLE_NORMAL                     (4)
+#define FIGHT_STYLE_BOXING                     (5)
+#define FIGHT_STYLE_KUNGFU                     (6)
+#define FIGHT_STYLE_KNEEHEAD                   (7)
+#define FIGHT_STYLE_GRABKICK                   (15)
+#define FIGHT_STYLE_ELBOW                      (16)
+#define WEAPONSKILL_PISTOL                     (0)
+#define WEAPONSKILL_PISTOL_SILENCED            (1)
+#define WEAPONSKILL_DESERT_EAGLE               (2)
+#define WEAPONSKILL_SHOTGUN                    (3)
+#define WEAPONSKILL_SAWNOFF_SHOTGUN            (4)
+#define WEAPONSKILL_SPAS12_SHOTGUN             (5)
+#define WEAPONSKILL_MICRO_UZI                  (6)
+#define WEAPONSKILL_MP5                        (7)
+#define WEAPONSKILL_AK47                       (8)
+#define WEAPONSKILL_M4                         (9)
+#define WEAPONSKILL_SNIPERRIFLE                (10)
+#define WEAPONSTATE_UNKNOWN                    (-1)
+#define WEAPONSTATE_NO_BULLETS                 (0)
+#define WEAPONSTATE_LAST_BULLET                (1)
+#define WEAPONSTATE_MORE_BULLETS               (2)
+#define WEAPONSTATE_RELOADING                  (3)
+#define PLAYER_VARTYPE_NONE                    (0)
+#define PLAYER_VARTYPE_INT                     (1)
+#define PLAYER_VARTYPE_STRING                  (2)
+#define PLAYER_VARTYPE_FLOAT                   (3)
+#define MAPICON_LOCAL                          (0)
+#define MAPICON_GLOBAL                         (1)
+#define MAPICON_LOCAL_CHECKPOINT               (2)
+#define MAPICON_GLOBAL_CHECKPOINT              (3)
+#define CAMERA_CUT                             (2)
+#define CAMERA_MOVE                            (1)
+#define SPECTATE_MODE_NORMAL                   (1)
+#define SPECTATE_MODE_FIXED                    (2)
+#define SPECTATE_MODE_SIDE                     (3)
+#define PLAYER_RECORDING_TYPE_NONE             (0)
+#define PLAYER_RECORDING_TYPE_DRIVER           (1)
+#define PLAYER_RECORDING_TYPE_ONFOOT           (2)
+native SetSpawnInfo(playerid, team, skin, Float:x, Float:y, Float:z, Float:rotation, weapon1, weapon1_ammo, weapon2, weapon2_ammo, weapon3, weapon3_ammo);
+native SpawnPlayer(playerid);
+native SetPlayerPos(playerid, Float:x, Float:y, Float:z);
+native SetPlayerPosFindZ(playerid, Float:x, Float:y, Float:z);
+native GetPlayerPos(playerid, &Float:x, &Float:y, &Float:z);
+native SetPlayerFacingAngle(playerid, Float:ang);
+native GetPlayerFacingAngle(playerid, &Float:ang);
+native IsPlayerInRangeOfPoint(playerid, Float:range, Float:x, Float:y, Float:z);
+native Float:GetPlayerDistanceFromPoint(playerid, Float:X, Float:Y, Float:Z);
+native IsPlayerStreamedIn(playerid, forplayerid);
+native SetPlayerInterior(playerid, interiorid);
+native GetPlayerInterior(playerid);
+native SetPlayerHealth(playerid, Float:health);
+native GetPlayerHealth(playerid, &Float:health);
+native SetPlayerArmour(playerid, Float:armour);
+native GetPlayerArmour(playerid, &Float:armour);
+native SetPlayerAmmo(playerid, weaponid, ammo);
+native GetPlayerAmmo(playerid);
+native GetPlayerWeaponState(playerid);
+native GetPlayerTargetPlayer(playerid);
+native GetPlayerTargetActor(playerid);
+native SetPlayerTeam(playerid, teamid);
+native GetPlayerTeam(playerid);
+native SetPlayerScore(playerid, score);
+native GetPlayerScore(playerid);
+native GetPlayerDrunkLevel(playerid);
+native SetPlayerDrunkLevel(playerid, level);
+native SetPlayerColor(playerid, color);
+native GetPlayerColor(playerid);
+native SetPlayerSkin(playerid, skinid);
+native GetPlayerSkin(playerid);
+native GetPlayerCustomSkin(playerid);
+native GivePlayerWeapon(playerid, weaponid, ammo);
+native ResetPlayerWeapons(playerid);
+native SetPlayerArmedWeapon(playerid, weaponid);
+native GetPlayerWeaponData(playerid, slot, &weapons, &ammo);
+native GivePlayerMoney(playerid, money);
+native ResetPlayerMoney(playerid);
+native SetPlayerName(playerid, const name[]);
+native GetPlayerMoney(playerid);
+native GetPlayerState(playerid);
+native GetPlayerIp(playerid, ip[], len = sizeof ip);
+native GetPlayerPing(playerid);
+native GetPlayerWeapon(playerid);
+native GetPlayerKeys(playerid, &keys, &updown, &leftright);
+native GetPlayerName(playerid, name[], len = sizeof name);
+native SetPlayerTime(playerid, hour, minute);
+native GetPlayerTime(playerid, &hour, &minute);
+native TogglePlayerClock(playerid, toggle);
+native SetPlayerWeather(playerid, weather);
+native ForceClassSelection(playerid);
+native SetPlayerWantedLevel(playerid, level);
+native GetPlayerWantedLevel(playerid);
+native SetPlayerFightingStyle(playerid, style);
+native GetPlayerFightingStyle(playerid);
+native SetPlayerVelocity(playerid, Float:X, Float:Y, Float:Z);
+native GetPlayerVelocity( playerid, &Float:X, &Float:Y, &Float:Z );
+native PlayCrimeReportForPlayer(playerid, suspectid, crime);
+native PlayAudioStreamForPlayer(playerid, const url[], Float:posX = 0.0, Float:posY = 0.0, Float:posZ = 0.0, Float:distance = 50.0, usepos = 0);
+native StopAudioStreamForPlayer(playerid);
+native SetPlayerShopName(playerid, const shopname[]);
+native SetPlayerSkillLevel(playerid, skill, level);
+native GetPlayerSurfingVehicleID(playerid);
+native GetPlayerSurfingObjectID(playerid);
+native RemoveBuildingForPlayer(playerid, modelid, Float:fX, Float:fY, Float:fZ, Float:fRadius);
+native GetPlayerLastShotVectors(playerid, &Float:fOriginX, &Float:fOriginY, &Float:fOriginZ, &Float:fHitPosX, &Float:fHitPosY, &Float:fHitPosZ);
+#if MAX_PLAYER_ATTACHED_OBJECTS < 1 || MAX_PLAYER_ATTACHED_OBJECTS > 10
+	#error MAX_PLAYER_ATTACHED_OBJECTS must be >= 1 and <= 10
+#endif
+native SetPlayerAttachedObject(playerid, index, modelid, bone, Float:fOffsetX = 0.0, Float:fOffsetY = 0.0, Float:fOffsetZ = 0.0, Float:fRotX = 0.0, Float:fRotY = 0.0, Float:fRotZ = 0.0, Float:fScaleX = 1.0, Float:fScaleY = 1.0, Float:fScaleZ = 1.0, materialcolor1 = 0, materialcolor2 = 0);
+native RemovePlayerAttachedObject(playerid, index);
+native IsPlayerAttachedObjectSlotUsed(playerid, index);
+native EditAttachedObject(playerid, index);
+native PlayerText:CreatePlayerTextDraw(playerid, Float:x, Float:y, const text[]);
+native PlayerTextDrawDestroy(playerid, PlayerText:text);
+native PlayerTextDrawLetterSize(playerid, PlayerText:text, Float:x, Float:y);
+native PlayerTextDrawTextSize(playerid, PlayerText:text, Float:x, Float:y);
+native PlayerTextDrawAlignment(playerid, PlayerText:text, alignment);
+native PlayerTextDrawColor(playerid, PlayerText:text, color);
+native PlayerTextDrawUseBox(playerid, PlayerText:text, use);
+native PlayerTextDrawBoxColor(playerid, PlayerText:text, color);
+native PlayerTextDrawSetShadow(playerid, PlayerText:text, size);
+native PlayerTextDrawSetOutline(playerid, PlayerText:text, size);
+native PlayerTextDrawBackgroundColor(playerid, PlayerText:text, color);
+native PlayerTextDrawFont(playerid, PlayerText:text, font);
+native PlayerTextDrawSetProportional(playerid, PlayerText:text, set);
+native PlayerTextDrawSetSelectable(playerid, PlayerText:text, set);
+native PlayerTextDrawShow(playerid, PlayerText:text);
+native PlayerTextDrawHide(playerid, PlayerText:text);
+native PlayerTextDrawSetString(playerid, PlayerText:text, const string[]);
+native PlayerTextDrawSetPreviewModel(playerid, PlayerText:text, modelindex);
+native PlayerTextDrawSetPreviewRot(playerid, PlayerText:text, Float:fRotX, Float:fRotY, Float:fRotZ, Float:fZoom = 1.0);
+native PlayerTextDrawSetPreviewVehCol(playerid, PlayerText:text, color1, color2);
+native SetPVarInt(playerid, const varname[], int_value);
+native GetPVarInt(playerid, const varname[]);
+native SetPVarString(playerid, const varname[], const string_value[]);
+native GetPVarString(playerid, const varname[], string_return[], len = sizeof string_return);
+native SetPVarFloat(playerid, const varname[], Float:float_value);
+native Float:GetPVarFloat(playerid, const varname[]);
+native DeletePVar(playerid, const varname[]);
+native GetPVarsUpperIndex(playerid);
+native GetPVarNameAtIndex(playerid, index, ret_varname[], ret_len = sizeof ret_varname);
+native GetPVarType(playerid, const varname[]);
+#if MAX_CHATBUBBLE_LENGTH < 1 || MAX_CHATBUBBLE_LENGTH > 144
+	#error MAX_CHATBUBBLE_LENGTH must be >= 1 and <= 144
+#endif
+native SetPlayerChatBubble(playerid, const text[], color, Float:drawdistance, expiretime);
+native PutPlayerInVehicle(playerid, vehicleid, seatid);
+native GetPlayerVehicleID(playerid);
+native GetPlayerVehicleSeat(playerid);
+native RemovePlayerFromVehicle(playerid);
+native TogglePlayerControllable(playerid, toggle);
+native PlayerPlaySound(playerid, soundid, Float:x, Float:y, Float:z);
+native ApplyAnimation(playerid, const animlib[], const animname[], Float:fDelta, loop, lockx, locky, freeze, time, forcesync = 0);
+native ClearAnimations(playerid, forcesync = 0);
+native GetPlayerAnimationIndex(playerid);
+native GetAnimationName(index, animlib[], len1 = sizeof animlib, animname[], len2 = sizeof animname);
+native GetPlayerSpecialAction(playerid);
+native SetPlayerSpecialAction(playerid, actionid);
+native DisableRemoteVehicleCollisions(playerid, disable);
+native SetPlayerCheckpoint(playerid, Float:x, Float:y, Float:z, Float:size);
+native DisablePlayerCheckpoint(playerid);
+native SetPlayerRaceCheckpoint(playerid, type, Float:x, Float:y, Float:z, Float:nextx, Float:nexty, Float:nextz, Float:size);
+native DisablePlayerRaceCheckpoint(playerid);
+native SetPlayerWorldBounds(playerid, Float:x_max,Float:x_min,Float:y_max,Float:y_min);
+native SetPlayerMarkerForPlayer(playerid, showplayerid, color);
+native ShowPlayerNameTagForPlayer(playerid, showplayerid, show);
+native SetPlayerMapIcon(playerid, iconid, Float:x, Float:y, Float:z, markertype, color, style = MAPICON_LOCAL);
+native RemovePlayerMapIcon(playerid, iconid);
+native AllowPlayerTeleport(playerid, allow);
+native SetPlayerCameraPos(playerid, Float:x, Float:y, Float:z);
+native SetPlayerCameraLookAt(playerid, Float:x, Float:y, Float:z, cut = CAMERA_CUT);
+native SetCameraBehindPlayer(playerid);
+native GetPlayerCameraPos(playerid, &Float:x, &Float:y, &Float:z);
+native GetPlayerCameraFrontVector(playerid, &Float:x, &Float:y, &Float:z);
+native GetPlayerCameraMode(playerid);
+native EnablePlayerCameraTarget(playerid, enable);
+native GetPlayerCameraTargetObject(playerid);
+native GetPlayerCameraTargetVehicle(playerid);
+native GetPlayerCameraTargetPlayer(playerid);
+native GetPlayerCameraTargetActor(playerid);
+native Float:GetPlayerCameraAspectRatio(playerid);
+native Float:GetPlayerCameraZoom(playerid);
+native AttachCameraToObject(playerid, objectid);
+native AttachCameraToPlayerObject(playerid, playerobjectid);
+native InterpolateCameraPos(playerid, Float:FromX, Float:FromY, Float:FromZ, Float:ToX, Float:ToY, Float:ToZ, time, cut = CAMERA_CUT);
+native InterpolateCameraLookAt(playerid, Float:FromX, Float:FromY, Float:FromZ, Float:ToX, Float:ToY, Float:ToZ, time, cut = CAMERA_CUT);
+native IsPlayerConnected(playerid);
+native IsPlayerInVehicle(playerid, vehicleid);
+native IsPlayerInAnyVehicle(playerid);
+native IsPlayerInCheckpoint(playerid);
+native IsPlayerInRaceCheckpoint(playerid);
+native SetPlayerVirtualWorld(playerid, worldid);
+native GetPlayerVirtualWorld(playerid);
+native EnableStuntBonusForPlayer(playerid, enable);
+native EnableStuntBonusForAll(enable);
+native TogglePlayerSpectating(playerid, toggle);
+native PlayerSpectatePlayer(playerid, targetplayerid, mode = SPECTATE_MODE_NORMAL);
+native PlayerSpectateVehicle(playerid, targetvehicleid, mode = SPECTATE_MODE_NORMAL);
+native StartRecordingPlayerData(playerid, recordtype, const recordname[]);
+native StopRecordingPlayerData(playerid);
+native SelectTextDraw(playerid, hovercolor);
+native CancelSelectTextDraw(playerid);
+native CreateExplosionForPlayer(playerid, Float:X, Float:Y, Float:Z, type, Float:Radius);
+native SendClientCheck(playerid, type, memAddr, memOffset, byteCount);

a_samp.inc

@@ -0,0 +1,438 @@
+#if defined _INC_a_samp
+	#endinput
+#endif
+#if defined _INC_a_npc
+	#error Include `<a_samp>` or `<a_npc>`, not both.
+#endif
+#define _INC_a_samp
+#define _samp_included
+#define SAMP_CONST_CORRECT
+#pragma tabsize 4
+#if !defined MAX_PLAYER_NAME
+	#define MAX_PLAYER_NAME                    (24)
+#endif
+#if !defined MAX_PLAYERS
+	#define MAX_PLAYERS                        (1000)
+#endif
+#if !defined MAX_VEHICLES
+	#define MAX_VEHICLES                       (2000)
+#endif
+#if !defined MAX_ACTORS
+	#define MAX_ACTORS                         (1000)
+#endif
+#if !defined MAX_OBJECTS
+	#define MAX_OBJECTS                        (2000)
+#endif
+#if !defined MAX_GANG_ZONES
+	#define MAX_GANG_ZONES                     (1024)
+#endif
+#if !defined MAX_TEXT_DRAWS
+	#define MAX_TEXT_DRAWS                     (Text:2048)
+#endif
+#if !defined MAX_PLAYER_TEXT_DRAWS
+	#define MAX_PLAYER_TEXT_DRAWS              (PlayerText:256)
+#endif
+#if !defined MAX_MENUS
+	#define MAX_MENUS                          (Menu:128)
+#endif
+#if !defined MAX_3DTEXT_GLOBAL
+	#define MAX_3DTEXT_GLOBAL                  (Text3D:1024)
+#endif
+#if !defined MAX_3DTEXT_PLAYER
+	#define MAX_3DTEXT_PLAYER                  (PlayerText3D:1024)
+#endif
+#if !defined MAX_PICKUPS
+	#define MAX_PICKUPS                        (4096)
+#endif
+#define NO_TEAM                                (255)
+#define INVALID_PLAYER_ID                      (0xFFFF)
+#define INVALID_VEHICLE_ID                     (0xFFFF)
+#define INVALID_ACTOR_ID                       (0xFFFF)
+#define INVALID_OBJECT_ID                      (0xFFFF)
+#define INVALID_MENU                           (Menu:0xFF)
+#define INVALID_TEXT_DRAW                      (Text:0xFFFF)
+#define INVALID_PLAYER_TEXT_DRAW               (PlayerText:0xFFFF)
+#define INVALID_GANG_ZONE                      (-1)
+#define INVALID_3DTEXT_ID                      (Text3D:0xFFFF)
+#define INVALID_PLAYER_3DTEXT_ID               (PlayerText3D:0xFFFF)
+#define PLAYER_STATE_NONE                      (0)
+#define PLAYER_STATE_ONFOOT                    (1)
+#define PLAYER_STATE_DRIVER                    (2)
+#define PLAYER_STATE_PASSENGER                 (3)
+#define PLAYER_STATE_EXIT_VEHICLE              (4)
+#define PLAYER_STATE_ENTER_VEHICLE_DRIVER      (5)
+#define PLAYER_STATE_ENTER_VEHICLE_PASSENGER   (6)
+#define PLAYER_STATE_WASTED                    (7)
+#define PLAYER_STATE_SPAWNED                   (8)
+#define PLAYER_STATE_SPECTATING                (9)
+#define PLAYER_MARKERS_MODE_OFF                (0)
+#define PLAYER_MARKERS_MODE_GLOBAL             (1)
+#define PLAYER_MARKERS_MODE_STREAMED           (2)
+#define UNKNOWN_WEAPON	                       (-1)
+#define WEAPON_FIST	                       (0)
+#define WEAPON_BRASSKNUCKLE                    (1)
+#define WEAPON_GOLFCLUB                        (2)
+#define WEAPON_NITESTICK                       (3)
+#define WEAPON_KNIFE                           (4)
+#define WEAPON_BAT                             (5)
+#define WEAPON_SHOVEL                          (6)
+#define WEAPON_POOLSTICK                       (7)
+#define WEAPON_KATANA                          (8)
+#define WEAPON_CHAINSAW                        (9)
+#define WEAPON_DILDO                           (10)
+#define WEAPON_DILDO2                          (11)
+#define WEAPON_VIBRATOR                        (12)
+#define WEAPON_VIBRATOR2                       (13)
+#define WEAPON_FLOWER                          (14)
+#define WEAPON_CANE                            (15)
+#define WEAPON_GRENADE                         (16)
+#define WEAPON_TEARGAS                         (17)
+#define WEAPON_MOLTOV                          (18)
+#define WEAPON_COLT45                          (22)
+#define WEAPON_SILENCED                        (23)
+#define WEAPON_DEAGLE                          (24)
+#define WEAPON_SHOTGUN                         (25)
+#define WEAPON_SAWEDOFF                        (26)
+#define WEAPON_SHOTGSPA                        (27)
+#define WEAPON_UZI                             (28)
+#define WEAPON_MP5                             (29)
+#define WEAPON_AK47                            (30)
+#define WEAPON_M4                              (31)
+#define WEAPON_TEC9                            (32)
+#define WEAPON_RIFLE                           (33)
+#define WEAPON_SNIPER                          (34)
+#define WEAPON_ROCKETLAUNCHER                  (35)
+#define WEAPON_HEATSEEKER                      (36)
+#define WEAPON_FLAMETHROWER                    (37)
+#define WEAPON_MINIGUN                         (38)
+#define WEAPON_SATCHEL                         (39)
+#define WEAPON_BOMB                            (40)
+#define WEAPON_SPRAYCAN                        (41)
+#define WEAPON_FIREEXTINGUISHER                (42)
+#define WEAPON_CAMERA                          (43)
+#define WEAPON_PARACHUTE                       (46)
+#define WEAPON_VEHICLE                         (49)
+#define WEAPON_DROWN                           (53)
+#define WEAPON_COLLISION                       (54)
+#define KEY_ACTION                             (1)
+#define KEY_CROUCH                             (2)
+#define KEY_FIRE                               (4)
+#define KEY_SPRINT                             (8)
+#define KEY_SECONDARY_ATTACK                   (16)
+#define KEY_JUMP                               (32)
+#define KEY_LOOK_RIGHT                         (64)
+#define KEY_HANDBRAKE                          (128)
+#define KEY_LOOK_LEFT                          (256)
+#define KEY_SUBMISSION                         (512)
+#define KEY_LOOK_BEHIND                        (512)
+#define KEY_WALK                               (1024)
+#define KEY_ANALOG_UP                          (2048)
+#define KEY_ANALOG_DOWN                        (4096)
+#define KEY_ANALOG_LEFT                        (8192)
+#define KEY_ANALOG_RIGHT                       (16384)
+#define KEY_YES                                (65536)
+#define KEY_NO                                 (131072)
+#define KEY_CTRL_BACK                          (262144)
+#define KEY_UP                                 (-128)
+#define KEY_DOWN                               (128)
+#define KEY_LEFT                               (-128)
+#define KEY_RIGHT                              (128)
+#define DIALOG_STYLE_MSGBOX                    (0)
+#define DIALOG_STYLE_INPUT                     (1)
+#define DIALOG_STYLE_LIST                      (2)
+#define DIALOG_STYLE_PASSWORD                  (3)
+#define DIALOG_STYLE_TABLIST                   (4)
+#define DIALOG_STYLE_TABLIST_HEADERS           (5)
+#define TEXT_DRAW_FONT_SPRITE_DRAW             (4)
+#define TEXT_DRAW_FONT_MODEL_PREVIEW           (5)
+#define	SERVER_VARTYPE_NONE                    (0)
+#define SERVER_VARTYPE_INT                     (1)
+#define SERVER_VARTYPE_STRING                  (2)
+#define SERVER_VARTYPE_FLOAT                   (3)
+#define DOWNLOAD_REQUEST_EMPTY                 (0)
+#define DOWNLOAD_REQUEST_MODEL_FILE            (1)
+#define DOWNLOAD_REQUEST_TEXTURE_FILE          (2)
+#define CLICK_SOURCE_SCOREBOARD                (0)
+#define EDIT_RESPONSE_CANCEL                   (0)
+#define EDIT_RESPONSE_FINAL                    (1)
+#define EDIT_RESPONSE_UPDATE                   (2)
+#define SELECT_OBJECT_GLOBAL_OBJECT            (1)
+#define SELECT_OBJECT_PLAYER_OBJECT            (2)
+#define BULLET_HIT_TYPE_NONE                   (0)
+#define BULLET_HIT_TYPE_PLAYER                 (1)
+#define BULLET_HIT_TYPE_VEHICLE                (2)
+#define BULLET_HIT_TYPE_OBJECT                 (3)
+#define BULLET_HIT_TYPE_PLAYER_OBJECT          (4)
+#if MAX_PLAYER_NAME < 3 || MAX_PLAYER_NAME > 24
+	#error MAX_PLAYER_NAME must be >= 3 and <= 24
+#endif
+#if MAX_PLAYERS < 1 || MAX_PLAYERS > 1000
+	#error MAX_PLAYERS must be >= 1 and <= 1000
+#endif
+#if MAX_VEHICLES < 1 || MAX_VEHICLES > 2000
+	#error MAX_VEHICLES must be >= 1 and <= 2000
+#endif
+#if MAX_ACTORS < 1 || MAX_ACTORS > 1000
+	#error MAX_ACTORS must be >= 1 and <= 1000
+#endif
+#if MAX_OBJECTS < 1 || MAX_OBJECTS > 2000
+	#error MAX_OBJECTS must be >= 1 and <= 2000
+#endif
+#if MAX_GANG_ZONES < 1 || MAX_GANG_ZONES > 1024
+	#error MAX_GANG_ZONES must be >= 1 and <= 1024
+#endif
+#if MAX_TEXT_DRAWS < Text:1 || MAX_TEXT_DRAWS > Text:2048
+	#error MAX_TEXT_DRAWS must be >= 1 and <= 2048
+#endif
+#if MAX_PLAYER_TEXT_DRAWS < PlayerText:1 || MAX_PLAYER_TEXT_DRAWS > PlayerText:256
+	#error MAX_PLAYER_TEXT_DRAWS must be >= 1 and <= 256
+#endif
+#if MAX_MENUS < Menu:1 || MAX_MENUS > Menu:128
+	#error MAX_MENUS must be >= 1 and <= 128
+#endif
+#if MAX_3DTEXT_GLOBAL < Text3D:1 || MAX_3DTEXT_GLOBAL > Text3D:1024
+	#error MAX_3DTEXT_GLOBAL must be >= 1 and <= 1024
+#endif
+#if MAX_3DTEXT_PLAYER < PlayerText3D:1 || MAX_3DTEXT_PLAYER > PlayerText3D:1024
+	#error MAX_3DTEXT_PLAYER must be >= 1 and <= 1024
+#endif
+#if MAX_PICKUPS < 1 || MAX_PICKUPS > 4096
+	#error MAX_PICKUPS must be >= 1 and <= 4096
+#endif
+public const SAMP_INCLUDES_VERSION = 0x037030;
+#pragma unused SAMP_INCLUDES_VERSION
+#include <core>
+#include <float>
+#include <string>
+#include <file>
+#include <time>
+#include <datagram>
+#tryinclude <console>
+#include <a_players>
+#include <a_vehicles>
+#include <a_objects>
+#include <a_actor>
+#include <a_sampdb>
+#include <a_http>
+#if !defined _console_included
+	#define _console_included
+	native print(const string[]);
+	native printf(const format[], {Float,_}:...);
+#endif
+native format(output[], len = sizeof output, const format[], {Float,_}:...);
+native SendClientMessage(playerid, color, const message[]);
+native SendClientMessageToAll(color, const message[]);
+native SendPlayerMessageToPlayer(playerid, senderid, const message[]);
+native SendPlayerMessageToAll(senderid, const message[]);
+native SendDeathMessage(killer, killee, weapon);
+native SendDeathMessageToPlayer(playerid, killer, killee, weapon);
+native GameTextForAll(const string[], time, style);
+native GameTextForPlayer(playerid, const string[], time, style);
+native SetTimer(const funcname[], interval, repeating);
+native SetTimerEx(const funcname[], interval, repeating, const format[], {Float,_}:...);
+native KillTimer(timerid);
+native GetTickCount();
+native GetMaxPlayers();
+native CallRemoteFunction(const function[], const format[], {Float,_}:...);
+native CallLocalFunction(const function[], const format[], {Float,_}:...);
+native Float:VectorSize(Float:x, Float:y, Float:z);
+native Float:asin(Float:value);
+native Float:acos(Float:value);
+native Float:atan(Float:value);
+native Float:atan2(Float:y, Float:x);
+native GetPlayerPoolSize();
+native GetVehiclePoolSize();
+native GetActorPoolSize();
+native SHA256_PassHash(const password[], const salt[], ret_hash[], ret_hash_len = sizeof ret_hash);
+native SetSVarInt(const varname[], int_value);
+native GetSVarInt(const varname[]);
+native SetSVarString(const varname[], const string_value[]);
+native GetSVarString(const varname[], string_return[], len = sizeof string_return);
+native SetSVarFloat(const varname[], Float:float_value);
+native Float:GetSVarFloat(const varname[]);
+native DeleteSVar(const varname[]);
+native GetSVarsUpperIndex();
+native GetSVarNameAtIndex(index, ret_varname[], ret_len = sizeof ret_varname);
+native GetSVarType(const varname[]);
+native SetGameModeText(const string[]);
+native SetTeamCount(count);
+native AddPlayerClass(modelid, Float:spawn_x, Float:spawn_y, Float:spawn_z, Float:z_angle, weapon1, weapon1_ammo, weapon2, weapon2_ammo, weapon3, weapon3_ammo);
+native AddPlayerClassEx(teamid, modelid, Float:spawn_x, Float:spawn_y, Float:spawn_z, Float:z_angle, weapon1, weapon1_ammo, weapon2, weapon2_ammo, weapon3, weapon3_ammo);
+native AddStaticVehicle(modelid, Float:spawn_x, Float:spawn_y, Float:spawn_z, Float:z_angle, color1, color2);
+native AddStaticVehicleEx(modelid, Float:spawn_x, Float:spawn_y, Float:spawn_z, Float:z_angle, color1, color2, respawn_delay, addsiren=0);
+native AddStaticPickup(model, type, Float:X, Float:Y, Float:Z, virtualworld = 0);
+native CreatePickup(model, type, Float:X, Float:Y, Float:Z, virtualworld = 0);
+native DestroyPickup(pickup);
+native ShowNameTags(show);
+native ShowPlayerMarkers(mode);
+native GameModeExit();
+native SetWorldTime(hour);
+native GetWeaponName(weaponid, weapon[], len = sizeof weapon);
+native EnableTirePopping(enable);
+native EnableVehicleFriendlyFire();
+native AllowInteriorWeapons(allow);
+native SetWeather(weatherid);
+native Float:GetGravity();
+native SetGravity(Float:gravity);
+native AllowAdminTeleport(allow);
+native SetDeathDropAmount(amount);
+native CreateExplosion(Float:X, Float:Y, Float:Z, type, Float:Radius);
+native EnableZoneNames(enable);
+native UsePlayerPedAnims();
+native DisableInteriorEnterExits();
+native SetNameTagDrawDistance(Float:distance);
+native DisableNameTagLOS();
+native LimitGlobalChatRadius(Float:chat_radius);
+native LimitPlayerMarkerRadius(Float:marker_radius);
+native ConnectNPC(const name[], const script[]);
+native IsPlayerNPC(playerid);
+native AddCharModel(baseid, newid, const dffname[], const txdname[]);
+native AddSimpleModel(virtualworld, baseid, newid, const dffname[], const txdname[]);
+native AddSimpleModelTimed(virtualworld, baseid, newid, const dffname[], const txdname[], timeon, timeoff);
+native FindModelFileNameFromCRC(crc, retstr[], retstr_size = sizeof retstr);
+native FindTextureFileNameFromCRC(crc, retstr[], retstr_size = sizeof retstr);
+native RedirectDownload(playerid, const url[]);
+native IsPlayerAdmin(playerid);
+native Kick(playerid);
+native Ban(playerid);
+native BanEx(playerid, const reason[]);
+native SendRconCommand(const command[]);
+native GetPlayerNetworkStats(playerid, retstr[], retstr_size = sizeof retstr);
+native GetNetworkStats(retstr[], retstr_size = sizeof retstr);
+native GetPlayerVersion(playerid, version[], len = sizeof version);
+native BlockIpAddress(const ip_address[], timems);
+native UnBlockIpAddress(const ip_address[]);
+native GetServerVarAsString(const varname[], buffer[], len = sizeof buffer);
+native GetServerVarAsInt(const varname[]);
+native GetServerVarAsBool(const varname[]);
+native GetConsoleVarAsString(const varname[], buffer[], len = sizeof buffer);
+native GetConsoleVarAsInt(const varname[]);
+native GetConsoleVarAsBool(const varname[]);
+native GetServerTickRate();
+native NetStats_GetConnectedTime(playerid);
+native NetStats_MessagesReceived(playerid);
+native NetStats_BytesReceived(playerid);
+native NetStats_MessagesSent(playerid);
+native NetStats_BytesSent(playerid);
+native NetStats_MessagesRecvPerSecond(playerid);
+native Float:NetStats_PacketLossPercent(playerid);
+native NetStats_ConnectionStatus(playerid);
+native NetStats_GetIpPort(playerid, ip_port[], ip_port_len = sizeof ip_port);
+native Menu:CreateMenu(const title[], columns, Float:x, Float:y, Float:col1width, Float:col2width = 0.0);
+native DestroyMenu(Menu:menuid);
+native AddMenuItem(Menu:menuid, column, const menutext[]);
+native SetMenuColumnHeader(Menu:menuid, column, const columnheader[]);
+native ShowMenuForPlayer(Menu:menuid, playerid);
+native HideMenuForPlayer(Menu:menuid, playerid);
+native IsValidMenu(Menu:menuid);
+native DisableMenu(Menu:menuid);
+native DisableMenuRow(Menu:menuid, row);
+native Menu:GetPlayerMenu(playerid);
+native Text:TextDrawCreate(Float:x, Float:y, const text[]);
+native TextDrawDestroy(Text:text);
+native TextDrawLetterSize(Text:text, Float:x, Float:y);
+native TextDrawTextSize(Text:text, Float:x, Float:y);
+native TextDrawAlignment(Text:text, alignment);
+native TextDrawColor(Text:text, color);
+native TextDrawUseBox(Text:text, use);
+native TextDrawBoxColor(Text:text, color);
+native TextDrawSetShadow(Text:text, size);
+native TextDrawSetOutline(Text:text, size);
+native TextDrawBackgroundColor(Text:text, color);
+native TextDrawFont(Text:text, font);
+native TextDrawSetProportional(Text:text, set);
+native TextDrawSetSelectable(Text:text, set);
+native TextDrawShowForPlayer(playerid, Text:text);
+native TextDrawHideForPlayer(playerid, Text:text);
+native TextDrawShowForAll(Text:text);
+native TextDrawHideForAll(Text:text);
+native TextDrawSetString(Text:text, const string[]);
+native TextDrawSetPreviewModel(Text:text, modelindex);
+native TextDrawSetPreviewRot(Text:text, Float:fRotX, Float:fRotY, Float:fRotZ, Float:fZoom = 1.0);
+native TextDrawSetPreviewVehCol(Text:text, color1, color2);
+native GangZoneCreate(Float:minx, Float:miny, Float:maxx, Float:maxy);
+native GangZoneDestroy(zone);
+native GangZoneShowForPlayer(playerid, zone, color);
+native GangZoneShowForAll(zone, color);
+native GangZoneHideForPlayer(playerid, zone);
+native GangZoneHideForAll(zone);
+native GangZoneFlashForPlayer(playerid, zone, flashcolor);
+native GangZoneFlashForAll(zone, flashcolor);
+native GangZoneStopFlashForPlayer(playerid, zone);
+native GangZoneStopFlashForAll(zone);
+native Text3D:Create3DTextLabel(const text[], color, Float:X, Float:Y, Float:Z, Float:DrawDistance, virtualworld, testLOS=0);
+native Delete3DTextLabel(Text3D:id);
+native Attach3DTextLabelToPlayer(Text3D:id, playerid, Float:OffsetX, Float:OffsetY, Float:OffsetZ);
+native Attach3DTextLabelToVehicle(Text3D:id, vehicleid, Float:OffsetX, Float:OffsetY, Float:OffsetZ);
+native Update3DTextLabelText(Text3D:id, color, const text[]);
+native PlayerText3D:CreatePlayer3DTextLabel(playerid, const text[], color, Float:X, Float:Y, Float:Z, Float:DrawDistance, attachedplayer=INVALID_PLAYER_ID, attachedvehicle=INVALID_VEHICLE_ID, testLOS=0);
+native DeletePlayer3DTextLabel(playerid, PlayerText3D:id);
+native UpdatePlayer3DTextLabelText(playerid, PlayerText3D:id, color, const text[]);
+native ShowPlayerDialog(playerid, dialogid, style, const caption[], const info[], const button1[], const button2[]);
+native gpci(playerid, serial[], maxlen);
+forward OnGameModeInit();
+forward OnGameModeExit();
+forward OnFilterScriptInit();
+forward OnFilterScriptExit();
+forward OnPlayerConnect(playerid);
+forward OnPlayerDisconnect(playerid, reason);
+forward OnPlayerSpawn(playerid);
+forward OnPlayerDeath(playerid, killerid, reason);
+forward OnVehicleSpawn(vehicleid);
+forward OnVehicleDeath(vehicleid, killerid);
+forward OnPlayerText(playerid, text[]);
+forward OnPlayerCommandText(playerid, cmdtext[]);
+forward OnPlayerRequestClass(playerid, classid);
+forward OnPlayerEnterVehicle(playerid, vehicleid, ispassenger);
+forward OnPlayerExitVehicle(playerid, vehicleid);
+forward OnPlayerStateChange(playerid, newstate, oldstate);
+forward OnPlayerEnterCheckpoint(playerid);
+forward OnPlayerLeaveCheckpoint(playerid);
+forward OnPlayerEnterRaceCheckpoint(playerid);
+forward OnPlayerLeaveRaceCheckpoint(playerid);
+forward OnRconCommand(cmd[]);
+forward OnPlayerRequestSpawn(playerid);
+forward OnObjectMoved(objectid);
+forward OnPlayerObjectMoved(playerid, objectid);
+forward OnPlayerPickUpPickup(playerid, pickupid);
+forward OnVehicleMod(playerid, vehicleid, componentid);
+forward OnEnterExitModShop(playerid, enterexit, interiorid);
+forward OnVehiclePaintjob(playerid, vehicleid, paintjobid);
+forward OnVehicleRespray(playerid, vehicleid, color1, color2);
+forward OnVehicleDamageStatusUpdate(vehicleid, playerid);
+forward OnUnoccupiedVehicleUpdate(vehicleid, playerid, passenger_seat, Float:new_x, Float:new_y, Float:new_z, Float:vel_x, Float:vel_y, Float:vel_z);
+forward OnPlayerSelectedMenuRow(playerid, row);
+forward OnPlayerExitedMenu(playerid);
+forward OnPlayerInteriorChange(playerid, newinteriorid, oldinteriorid);
+forward OnPlayerKeyStateChange(playerid, newkeys, oldkeys);
+forward OnRconLoginAttempt( ip[], password[], success );
+forward OnPlayerUpdate(playerid);
+forward OnPlayerStreamIn(playerid, forplayerid);
+forward OnPlayerStreamOut(playerid, forplayerid);
+forward OnVehicleStreamIn(vehicleid, forplayerid);
+forward OnVehicleStreamOut(vehicleid, forplayerid);
+forward OnActorStreamIn(actorid, forplayerid);
+forward OnActorStreamOut(actorid, forplayerid);
+forward OnDialogResponse(playerid, dialogid, response, listitem, inputtext[]);
+forward OnPlayerTakeDamage(playerid, issuerid, Float:amount, weaponid, bodypart);
+forward OnPlayerGiveDamage(playerid, damagedid, Float:amount, weaponid, bodypart);
+forward OnPlayerGiveDamageActor(playerid, damaged_actorid, Float:amount, weaponid, bodypart);
+forward OnPlayerClickMap(playerid, Float:fX, Float:fY, Float:fZ);
+forward OnPlayerClickTextDraw(playerid, Text:clickedid);
+forward OnPlayerClickPlayerTextDraw(playerid, PlayerText:playertextid);
+forward OnIncomingConnection(playerid, ip_address[], port);
+forward OnTrailerUpdate(playerid, vehicleid);
+forward OnVehicleSirenStateChange(playerid, vehicleid, newstate);
+forward OnPlayerFinishedDownloading(playerid, virtualworld);
+forward OnPlayerRequestDownload(playerid, type, crc);
+forward OnPlayerClickPlayer(playerid, clickedplayerid, source);
+forward OnPlayerEditObject( playerid, playerobject, objectid, response,
+Float:fX, Float:fY, Float:fZ, Float:fRotX, Float:fRotY, Float:fRotZ );
+forward OnPlayerEditAttachedObject( playerid, response, index, modelid, boneid,
+Float:fOffsetX, Float:fOffsetY, Float:fOffsetZ,
+Float:fRotX, Float:fRotY, Float:fRotZ,
+Float:fScaleX, Float:fScaleY, Float:fScaleZ );
+forward OnPlayerSelectObject(playerid, type, objectid, modelid, Float:fX, Float:fY, Float:fZ);
+forward OnPlayerWeaponShot(playerid, weaponid, hittype, hitid, Float:fX, Float:fY, Float:fZ);
+forward OnClientCheckResponse(playerid, actionid, memaddr, retndata);
+forward OnScriptCash(playerid, amount, source);

a_sampdb.inc

@@ -0,0 +1,25 @@
+#if defined _INC_a_sampdb
+	#endinput
+#endif
+#define _INC_a_sampdb
+#define _sampdb_included
+#define SAMP_CONST_CORRECT
+#pragma tabsize 4
+native DB:db_open(const name[]);
+native db_close(DB:db);
+native DBResult:db_query(DB:db, const query[]);
+native db_free_result(DBResult:dbresult);
+native db_num_rows(DBResult:dbresult);
+native db_next_row(DBResult:dbresult);
+native db_num_fields(DBResult:dbresult);
+native db_field_name(DBResult:dbresult, field, result[], maxlength = sizeof result);
+native db_get_field(DBResult:dbresult, field, result[], maxlength = sizeof result);
+native db_get_field_int(DBResult:result, field = 0);
+native Float:db_get_field_float(DBResult:result, field = 0);
+native db_get_field_assoc(DBResult:dbresult, const field[], result[], maxlength = sizeof result);
+native db_get_field_assoc_int(DBResult:result, const field[]);
+native Float:db_get_field_assoc_float(DBResult:result, const field[]);
+native db_get_mem_handle(DB:db);
+native db_get_result_mem_handle(DBResult:result);
+native db_debug_openfiles();
+native db_debug_openresults();

a_vehicles.inc

@@ -0,0 +1,77 @@
+#if defined _INC_a_vehicles
+	#endinput
+#endif
+#define _INC_a_vehicles
+#define _vehicles_included
+#define SAMP_CONST_CORRECT
+#pragma tabsize 4
+#define CARMODTYPE_SPOILER                     (0)
+#define CARMODTYPE_HOOD                        (1)
+#define CARMODTYPE_ROOF                        (2)
+#define CARMODTYPE_SIDESKIRT                   (3)
+#define CARMODTYPE_LAMPS                       (4)
+#define CARMODTYPE_NITRO                       (5)
+#define CARMODTYPE_EXHAUST                     (6)
+#define CARMODTYPE_WHEELS                      (7)
+#define CARMODTYPE_STEREO                      (8)
+#define CARMODTYPE_HYDRAULICS                  (9)
+#define CARMODTYPE_FRONT_BUMPER                (10)
+#define CARMODTYPE_REAR_BUMPER                 (11)
+#define CARMODTYPE_VENT_RIGHT                  (12)
+#define CARMODTYPE_VENT_LEFT                   (13)
+#define VEHICLE_PARAMS_UNSET                   (-1)
+#define VEHICLE_PARAMS_OFF                     (0)
+#define VEHICLE_PARAMS_ON                      (1)
+#define VEHICLE_MODEL_INFO_SIZE                (1)
+#define VEHICLE_MODEL_INFO_FRONTSEAT           (2)
+#define VEHICLE_MODEL_INFO_REARSEAT            (3)
+#define VEHICLE_MODEL_INFO_PETROLCAP           (4)
+#define VEHICLE_MODEL_INFO_WHEELSFRONT         (5)
+#define VEHICLE_MODEL_INFO_WHEELSREAR          (6)
+#define VEHICLE_MODEL_INFO_WHEELSMID           (7)
+#define VEHICLE_MODEL_INFO_FRONT_BUMPER_Z      (8)
+#define VEHICLE_MODEL_INFO_REAR_BUMPER_Z       (9)
+native CreateVehicle(vehicletype, Float:x, Float:y, Float:z, Float:rotation, color1, color2, respawn_delay, addsiren=0);
+native DestroyVehicle(vehicleid);
+native IsVehicleStreamedIn(vehicleid, forplayerid);
+native GetVehiclePos(vehicleid, &Float:x, &Float:y, &Float:z);
+native SetVehiclePos(vehicleid, Float:x, Float:y, Float:z);
+native GetVehicleZAngle(vehicleid, &Float:z_angle);
+native GetVehicleRotationQuat(vehicleid, &Float:w, &Float:x, &Float:y, &Float:z);
+native Float:GetVehicleDistanceFromPoint(vehicleid, Float:X, Float:Y, Float:Z);
+native SetVehicleZAngle(vehicleid, Float:z_angle);
+native SetVehicleParamsForPlayer(vehicleid, playerid, objective, doorslocked);
+native ManualVehicleEngineAndLights();
+native SetVehicleParamsEx(vehicleid, engine, lights, alarm, doors, bonnet, boot, objective);
+native GetVehicleParamsEx(vehicleid, &engine, &lights, &alarm, &doors, &bonnet, &boot, &objective);
+native GetVehicleParamsSirenState(vehicleid);
+native SetVehicleParamsCarDoors(vehicleid, driver, passenger, backleft, backright);
+native GetVehicleParamsCarDoors(vehicleid, &driver, &passenger, &backleft, &backright);
+native SetVehicleParamsCarWindows(vehicleid, driver, passenger, backleft, backright);
+native GetVehicleParamsCarWindows(vehicleid, &driver, &passenger, &backleft, &backright);
+native SetVehicleToRespawn(vehicleid);
+native LinkVehicleToInterior(vehicleid, interiorid);
+native AddVehicleComponent(vehicleid, componentid);
+native RemoveVehicleComponent(vehicleid, componentid);
+native ChangeVehicleColor(vehicleid, color1, color2);
+native ChangeVehiclePaintjob(vehicleid, paintjobid);
+native SetVehicleHealth(vehicleid, Float:health);
+native GetVehicleHealth(vehicleid, &Float:health);
+native AttachTrailerToVehicle(trailerid, vehicleid);
+native DetachTrailerFromVehicle(vehicleid);
+native IsTrailerAttachedToVehicle(vehicleid);
+native GetVehicleTrailer(vehicleid);
+native SetVehicleNumberPlate(vehicleid, const numberplate[]);
+native GetVehicleModel(vehicleid);
+native GetVehicleComponentInSlot(vehicleid, slot);
+native GetVehicleComponentType(component);
+native RepairVehicle(vehicleid);
+native GetVehicleVelocity(vehicleid, &Float:X, &Float:Y, &Float:Z);
+native SetVehicleVelocity(vehicleid, Float:X, Float:Y, Float:Z);
+native SetVehicleAngularVelocity(vehicleid, Float:X, Float:Y, Float:Z);
+native GetVehicleDamageStatus(vehicleid, &panels, &doors, &lights, &tires);
+native UpdateVehicleDamageStatus(vehicleid, panels, doors, lights, tires);
+native GetVehicleModelInfo(vehiclemodel, infotype, &Float:X, &Float:Y, &Float:Z);
+native SetVehicleVirtualWorld(vehicleid, worldid);
+native GetVehicleVirtualWorld(vehicleid);
+native bool:IsValidVehicle(vehicleid);

bcrypt.inc

@@ -0,0 +1,98 @@
+#if defined bcrypt_included
+	#endinput
+#endif
+#define bcrypt_included
+#if !defined HTTP_GET
+	#include <a_http>
+#endif
+#define BCRYPT_HASH_LENGTH 61
+#define BCRYPT_PLUGIN_VERSION "2.2.3"
+enum BCRYPT_DEBUG_LEVEL {
+	BCRYPT_LOG_FATAL,
+	BCRYPT_LOG_ERROR,
+	BCRYPT_LOG_WARNING,
+	BCRYPT_LOG_INFO,
+	BCRYPT_LOG_DEBUG,
+	BCRYPT_LOG_TRACE
+}
+native bcrypt_hash(key[], cost = 12, callback_name[], callback_format[] = "", {Float, _}:...);
+native bcrypt_check(password[], hash[], callback_name[], callback_format[] = "", {Float, _}:...);
+native bcrypt_get_hash(dest[]);
+native bool:bcrypt_is_equal();
+native bool:bcrypt_needs_rehash(hash[], cost);
+native bcrypt_find_cost(time_target = 250);
+native bcrypt_set_thread_limit(value);
+native bcrypt_debug(BCRYPT_DEBUG_LEVEL:level = BCRYPT_LOG_ERROR);
+forward OnBcryptVersionCheck(index, response_code, data[]);
+#if defined FILTERSCRIPT
+	public OnFilterScriptInit()
+	{
+		HTTP(0, HTTP_GET, "api.ls-rcr.com/bcrypt/?version_check&version=" #BCRYPT_PLUGIN_VERSION, "", "OnBcryptVersionCheck");
+		return CallLocalFunction("BCRYPT_OnFilterScriptInit", "");
+	}
+	forward BCRYPT_OnFilterScriptInit();
+	#if defined _ALS_OnFilterScriptInit
+	    #undef OnFilterScriptInit
+	#else
+	    #define _ALS_OnFilterScriptInit
+	#endif
+	#define OnFilterScriptInit BCRYPT_OnFilterScriptInit
+#else
+	public OnGameModeInit()
+	{
+		HTTP(0, HTTP_GET, "api.ls-rcr.com/bcrypt/?version_check&version=" #BCRYPT_PLUGIN_VERSION, "", "OnBcryptVersionCheck");
+		return CallLocalFunction("BCRYPT_OnGameModeInit", "");
+	}
+	forward BCRYPT_OnGameModeInit();
+	#if defined _ALS_OnGameModeInit
+	    #undef OnGameModeInit
+	#else
+	    #define _ALS_OnGameModeInit
+	#endif
+	#define OnGameModeInit BCRYPT_OnGameModeInit
+#endif
+public OnBcryptVersionCheck(index, response_code, data[])
+{
+	if(response_code == 200)
+	{
+		if(!strcmp("OK", data, false, 2))
+		{
+			print("plugin.bcrypt: The plugin is up-to-date.");
+		}
+		else if(!strcmp("UPDATE_AVAILABLE_MAJOR", data, false, 22))
+		{
+			print(" ");
+			printf(" * plugin.bcrypt: A MAJOR UPDATE IS AVAILABLE:");
+			printf(" * plugin.bcrypt: Current version: %s", BCRYPT_PLUGIN_VERSION);
+			printf(" * plugin.bcrypt: Latest version: %s", data[23]);
+			printf(" * plugin.bcrypt: Download: http://api.ls-rcr.com/bcrypt/?upgrade");
+			printf(" * plugin.bcrypt: Upgrading is highly recommended.");
+			print(" ");
+		}
+		else if(!strcmp("UPDATE_AVAILABLE_MINOR", data, false, 22))
+		{
+			print(" ");
+			printf("plugin.bcrypt: A minor update is available:");
+			printf("plugin.bcrypt: Current version: %s", BCRYPT_PLUGIN_VERSION);
+			printf("plugin.bcrypt: Latest version: %s", data[23]);
+			printf("plugin.bcrypt: Download: http://api.ls-rcr.com/bcrypt/?upgrade");
+			printf("plugin.bcrypt: Upgrading is recommended.");
+			print(" ");
+		}
+		else if(!strcmp("UPDATE_AVAILABLE_REVISION", data, false, 25))
+		{
+			print(" ");
+			printf("plugin.bcrypt: A new revision is available:");
+			printf("plugin.bcrypt: Current version: %s", BCRYPT_PLUGIN_VERSION);
+			printf("plugin.bcrypt: Latest version: %s", data[26]);
+			printf("plugin.bcrypt: Download: http://api.ls-rcr.com/bcrypt/?upgrade");
+			printf("plugin.bcrypt: Upgrading is recommended.");
+			print(" ");
+		}
+	}
+	else
+	{
+		print("plugin.bcrypt: Version check failed.");
+	}
+	return 1;
+}

breaks.inc

@@ -0,0 +1,529 @@
+#define IS_FILTERSCRIPT
+static stock
+	bool:BREAKS_gFilterscript = false,
+	BREAKS_gRCPSize[MAX_PLAYERS] = { 0, ... },
+	BREAKS_gCPSize[MAX_PLAYERS] = { 0, ... },
+	bool:BREAKS_gRCPInitialised[MAX_PLAYERS] = { false, ... },
+	bool:BREAKS_gCPInitialised[MAX_PLAYERS] = { false, ... },
+	BREAKS_gPlayerColour[MAX_PLAYERS] = { 0, ... },
+	BREAKS_gPlayerSkin[MAX_PLAYERS] = { 0, ... },
+	bool:BREAKS_gExtraOPC[MAX_PLAYERS] = { false, ... },
+	BREAKS_gLibraryInitialised[MAX_PLAYERS][5];
+static stock const
+	BREAKS_gscAnimLib[135][] =
+		{
+			"AIRPORT",      "ATTRACTORS",   "BAR",          "BASEBALL",     "BD_FIRE",
+			"BEACH",        "BENCHPRESS",   "BF_INJECTION", "BIKE_DBZ",     "BIKED",
+			"BIKEH",        "BIKELEAP",     "BIKES",        "BIKEV",        "BLOWJOBZ",
+			"BMX",          "BOMBER",       "BOX",          "BSKTBALL",     "BUDDY",
+			"BUS",          "CAMERA",       "CAR",          "CAR_CHAT",     "CARRY",
+			"CASINO",       "CHAINSAW",     "CHOPPA",       "CLOTHES",      "COACH",
+			"COLT45",       "COP_AMBIENT",  "COP_DVBYZ",    "CRACK",        "CRIB",
+			"DAM_JUMP",     "DANCING",      "DEALER",       "DILDO",        "DODGE",
+			"DOZER",        "DRIVEBYS",     "FAT",          "FIGHT_B",      "FIGHT_C",
+			"FIGHT_D",      "FIGHT_E",      "FINALE",       "FINALE2",      "FLAME",
+			"FLOWERS",      "FOOD",         "FREEWEIGHTS",  "GANGS",        "GFUNK",
+			"GHANDS",       "GHETTO_DB",    "GOGGLES",      "GRAFFITI",     "GRAVEYARD",
+			"GRENADE",      "GYMNASIUM",    "HAIRCUTS",     "HEIST9",       "INT_HOUSE",
+			"INT_OFFICE",   "INT_SHOP",     "JST_BUISNESS", "KART",         "KISSING",
+			"KNIFE",        "LAPDAN1",      "LAPDAN2",      "LAPDAN3",      "LOWRIDER",
+			"MD_CHASE",     "MD_END",       "MEDIC",        "MISC",         "MTB",
+			"MUSCULAR",     "NEVADA",       "ON_LOOKERS",   "OTB",          "PARACHUTE",
+			"PARK",         "PAULNMAC",     "PED",          "PLAYER_DVBYS", "PLAYIDLES",
+			"POLICE",       "POOL",         "POOR",         "PYTHON",       "QUAD",
+			"QUAD_DBZ",     "RAPPING",      "RIFLE",        "RIOT",         "ROB_BANK",
+			"ROCKET",       "RUNNINGMAN",   "RUSTLER",      "RYDER",        "SAMP",
+			"SCRATCHING",   "SEX",          "SHAMAL",       "SHOP",         "SHOTGUN",
+			"SILENCED",     "SKATE",        "SMOKING",      "SNIPER",       "SNM",
+			"SPRAYCAN",     "STRIP",        "SUNBATHE",     "SWAT",         "SWEET",
+			"SWIM",         "SWORD",        "TANK",         "TATTOOS",      "TEC",
+			"TRAIN",        "TRUCK",        "UZI",          "VAN",          "VENDING",
+			"VORTEX",       "WAYFARER",     "WEAPONS",      "WOP",          "WUZI"
+		};
+stock BREAKS_SetSpawnInfo(playerid, team, skin, Float:x, Float:y, Float:z, Float:rotation, weapon1, weapon1_ammo, weapon2, weapon2_ammo, weapon3, weapon3_ammo)
+{
+	BREAKS_gPlayerSkin[playerid] = skin;
+	return SetSpawnInfo(playerid, team, skin, x, y, z, rotation, WEAPON:weapon1, weapon1_ammo, WEAPON:weapon2, weapon2_ammo, WEAPON:weapon3, weapon3_ammo);
+}
+#if defined _ALS_SetSpawnInfo
+	#undef SetSpawnInfo
+#endif
+#define SetSpawnInfo( BREAKS_SetSpawnInfo(
+#define _ALS_SetSpawnInfo
+stock BREAKS_SetPlayerSkin(playerid, skin)
+{
+	BREAKS_gPlayerSkin[playerid] = skin;
+	return SetPlayerSkin(playerid, skin);
+}
+#if defined _ALS_SetPlayerSkin
+	#undef SetPlayerSkin
+#endif
+#define SetPlayerSkin( BREAKS_SetPlayerSkin(
+#define _ALS_SetPlayerSkin
+stock BREAKS_GetPlayerSkin(playerid)
+{
+	return BREAKS_gPlayerSkin[playerid];
+}
+#if defined _ALS_GetPlayerSkin
+	#undef GetPlayerSkin
+#endif
+#define GetPlayerSkin( BREAKS_GetPlayerSkin(
+#define _ALS_GetPlayerSkin
+stock BREAKS_SetPlayerColor(playerid, colour)
+{
+	BREAKS_gPlayerColour[playerid] = colour;
+	return SetPlayerColor(playerid, colour);
+}
+#if defined _ALS_SetPlayerColor
+	#undef SetPlayerColor
+#endif
+#define SetPlayerColor( BREAKS_SetPlayerColor(
+#define _ALS_SetPlayerColor
+stock BREAKS_GetPlayerColor(playerid)
+{
+	return BREAKS_gPlayerColour[playerid];
+}
+#if defined _ALS_GetPlayerColor
+	#undef GetPlayerColor
+#endif
+#define GetPlayerColor( BREAKS_GetPlayerColor(
+#define _ALS_GetPlayerColor
+public OnFilterScriptInit()
+{
+	BREAKS_gFilterscript = true;
+	for (new i = 0; i != MAX_PLAYERS; ++i)
+	{
+		if (IsPlayerConnected(i))
+		{
+			BREAKS_gExtraOPC[i] = true;
+		}
+	}
+	#if defined BREAKS_OnFilterScriptInit
+		BREAKS_OnFilterScriptInit();
+	#endif
+	return 1;
+}
+#if defined _ALS_OnFilterScriptInit
+	#undef OnFilterScriptInit
+#endif
+#define OnFilterScriptInit( BREAKS_OnFilterScriptInit(
+#define _ALS_OnFilterScriptInit
+#if defined BREAKS_OnFilterScriptInit
+	forward BREAKS_OnFilterScriptInit();
+#endif
+public OnGameModeInit()
+{
+	if (!BREAKS_gFilterscript)
+	{
+		for (new i = 0; i != MAX_PLAYERS; ++i)
+		{
+			if (IsPlayerConnected(i))
+			{
+				BREAKS_gExtraOPC[i] = true;
+			}
+		}
+	}
+	#if defined BREAKS_OnGameModeInit
+		BREAKS_OnGameModeInit();
+	#endif
+	return 1;
+}
+#if defined _ALS_OnGameModeInit
+	#undef OnGameModeInit
+#endif
+#define OnGameModeInit( BREAKS_OnGameModeInit(
+#define _ALS_OnGameModeInit
+#if defined BREAKS_OnGameModeInit
+	forward BREAKS_OnGameModeInit();
+#endif
+public OnPlayerConnect(playerid)
+{
+	BREAKS_gPlayerColour[playerid] = 0;
+	BREAKS_gPlayerSkin[playerid] = 0;
+	BREAKS_gCPInitialised[playerid] = false;
+	BREAKS_gRCPInitialised[playerid] = false;
+	BREAKS_gCPSize[playerid] = 0;
+	BREAKS_gRCPSize[playerid] = 0;
+	if (BREAKS_gExtraOPC[playerid])
+	{
+		BREAKS_gExtraOPC[playerid] = false;
+	}
+	#if defined BREAKS_OnPlayerConnect
+		else
+		{
+			BREAKS_OnPlayerConnect(playerid);
+		}
+	#endif
+	return 1;
+}
+#if defined _ALS_OnPlayerConnect
+	#undef OnPlayerConnect
+#endif
+#define OnPlayerConnect( BREAKS_OnPlayerConnect(
+#define _ALS_OnPlayerConnect
+#if defined BREAKS_OnPlayerConnect
+	forward BREAKS_OnPlayerConnect(playerid);
+#endif
+public OnPlayerDisconnect(playerid, reason)
+{
+	#if defined BREAKS_OnPlayerDisconnect
+		if (reason != 4)
+		{
+			BREAKS_OnPlayerDisconnect(playerid, reason);
+		}
+	#endif
+	return 1;
+}
+#if defined _ALS_OnPlayerDisconnect
+	#undef OnPlayerDisconnect
+#endif
+#define OnPlayerDisconnect( BREAKS_OnPlayerDisconnect(
+#define _ALS_OnPlayerDisconnect
+#if defined BREAKS_OnPlayerDisconnect
+	forward BREAKS_OnPlayerDisconnect(playerid, reason);
+#endif
+public OnPlayerDeath(playerid, killerid, reason)
+{
+	new money = GetPlayerMoney(playerid);
+	if (money > 0)
+	{
+		ResetPlayerMoney(playerid);
+		if (money > 100)
+		{
+			GivePlayerMoney(playerid, money - 100);
+		}
+	}
+	#if defined BREAKS_OnPlayerDeath
+		BREAKS_OnPlayerDeath(playerid, killerid, reason);
+	#endif
+	return 1;
+}
+#if defined _ALS_OnPlayerDeath
+	#undef OnPlayerDeath
+#endif
+#define OnPlayerDeath( BREAKS_OnPlayerDeath(
+#define _ALS_OnPlayerDeath
+#if defined BREAKS_OnPlayerDeath
+	forward BREAKS_OnPlayerDeath(playerid, killerid, reason);
+#endif
+stock BREAKS_SpawnPlayer(playerid)
+{
+	if (IsPlayerInAnyVehicle(playerid))
+	{
+		SetPlayerHealth(playerid, 0.0);
+	}
+	return SpawnPlayer(playerid);
+}
+#if defined _ALS_SpawnPlayer
+	#undef SpawnPlayer
+#endif
+#define SpawnPlayer( BREAKS_SpawnPlayer(
+#define _ALS_SpawnPlayer
+stock BREAKS_SetPlayerName(playerid, name[])
+{
+	new old[MAX_PLAYER_NAME + 1];
+	if (GetPlayerName(playerid, old, sizeof (old)))
+	{
+		if (strcmp(name, old, true) == 0)
+		{
+			return 1;
+		}
+		return SetPlayerName(playerid, name);
+	}
+	return 0;
+}
+#if defined _ALS_SetPlayerName
+	#undef SetPlayerName
+#endif
+#define SetPlayerName( BREAKS_SetPlayerName(
+#define _ALS_SetPlayerName
+stock BREAKS_GetWeaponName(weaponid, const weapon[], len)
+{
+	switch (weaponid)
+	{
+	case 18, 44, 45:
+		weapon[0] = '\0';
+		return 0;
+	}
+	return _:GetWeaponName(WEAPON:weaponid, weapon, len);
+}
+#if defined _ALS_GetWeaponName
+	#undef GetWeaponName
+#endif
+#define GetWeaponName( BREAKS_GetWeaponName(
+#define _ALS_GetWeaponName
+stock BREAKS_SetPlayerCheckpoint(playerid, Float:x, Float:y, Float:z, Float:size)
+{
+	BREAKS_gCPInitialised = true;
+	if (BREAKS_gCPSize[playerid] == 0)
+	{
+		BREAKS_gCPSize[playerid] size;
+	}
+	return SetPlayerCheckpoint(playerid, x, y, z, BREAKS_gCPSize[playerid]);
+}
+#if defined _ALS_SetPlayerCheckpoint
+	#undef SetPlayerCheckpoint
+#endif
+#define SetPlayerCheckpoint( BREAKS_SetPlayerCheckpoint(
+#define _ALS_SetPlayerCheckpoint
+stock BREAKS_DisablePlayerCheckpoint(playerid)
+{
+	BREAKS_gCPInitialised = true;
+	BREAKS_gCPSize[playerid] = 0;
+	return DisablePlayerCheckpoint(playerid);
+}
+#if defined _ALS_DisablePlayerCheckpoint
+	#undef DisablePlayerCheckpoint
+#endif
+#define DisablePlayerCheckpoint( BREAKS_DisablePlayerCheckpoint(
+#define _ALS_DisablePlayerCheckpoint
+stock BREAKS_SetPlayerRaceCheckpoint(playerid, type, Float:x, Float:y, Float:z, Float:nextx, Float:nexty, Float:nextz, Float:size)
+{
+	BREAKS_gRCPInitialised = true;
+	if (BREAKS_gRCPSize[playerid] == 0)
+	{
+		BREAKS_gRCPSize[playerid] size;
+	}
+	return _:SetPlayerRaceCheckpoint(playerid, CP_TYPE:type, x, y, z, nextx, nexty, nextz, BREAKS_gRCPSize[playerid]);
+}
+#if defined _ALS_SetPlayerRaceCheckpoint
+	#undef SetPlayerRaceCheckpoint
+#endif
+#define SetPlayerRaceCheckpoint( BREAKS_SetPlayerRaceCheckpoint(
+#define _ALS_SetPlayerRaceCheckpoint
+stock BREAKS_DisablePlayerRaceCP(playerid)
+{
+	BREAKS_gRCPInitialised = true;
+	BREAKS_gRCPSize[playerid] = 0;
+	return DisablePlayerRaceCheckpoint(playerid);
+}
+#if defined _ALS_DisablePlayerRaceCP
+	#undef DisablePlayerRaceCheckpoint
+#endif
+#define DisablePlayerRaceCheckpoint( BREAKS_DisablePlayerRaceCP(
+#define _ALS_DisablePlayerRaceCP
+stock BREAKS_IsPlayerInCheckpoint(playerid)
+{
+	return BREAKS_gCPInitialised[playerid] ? IsPlayerInCheckpoint(playerid) : random(cellmax);
+}
+#if defined _ALS_IsPlayerInCheckpoint
+	#undef IsPlayerInCheckpoint
+#endif
+#define IsPlayerInCheckpoint( BREAKS_IsPlayerInCheckpoint(
+#define _ALS_IsPlayerInCheckpoint
+stock BREAKS_IsPlayerInRaceCheckpoint(playerid)
+{
+	return BREAKS_gRCPInitialised[playerid] ? IsPlayerInRaceCheckpoint(playerid) : random(cellmax);
+}
+#if defined _ALS_IsPlayerInRaceCheckpoint
+	#undef IsPlayerInRaceCheckpoint
+#endif
+#define IsPlayerInRaceCheckpoint( BREAKS_IsPlayerInRaceCheckpoint(
+#define _ALS_IsPlayerInRaceCheckpoint
+stock Text:BREAKS_TextDrawCreate(Float:x, Float:y, text[])
+{
+	new len = strlen(text);
+	if (len == 0 || len > 1024)
+	{
+		#emit HALT 100
+	}
+	if (text[len - 1] == ' ')
+	{
+		return TextDrawCreate(x, y, " ");
+	}
+	return TextDrawCreate(x, y, text);
+}
+#if defined _ALS_TextDrawCreate
+	#undef TextDrawCreate
+#endif
+#define TextDrawCreate( BREAKS_TextDrawCreate(
+#define _ALS_TextDrawCreate
+stock PlayerText:BREAKS_CreatePlayerTextDraw(playerid, Float:x, Float:y, text[])
+{
+	new len = strlen(text);
+	if (len == 0 || len > 1024)
+	{
+		#emit HALT 100
+	}
+	if (text[len - 1] == ' ')
+	{
+		return CreatePlayerTextDraw(playerid, x, y, " ");
+	}
+	return CreatePlayerTextDraw(playerid, x, y, text);
+}
+#if defined _ALS_CreatePlayerTextDraw
+	#undef CreatePlayerTextDraw
+#endif
+#define CreatePlayerTextDraw( BREAKS_CreatePlayerTextDraw(
+#define _ALS_CreatePlayerTextDraw
+stock BREAKS_TextDrawSetString(Text:text, string[])
+{
+	new len = strlen(string);
+	if (len == 0 || len > 1024)
+	{
+		#emit HALT 100
+	}
+	if (string[len - 1] == ' ')
+	{
+		return TextDrawSetString(text, " ");
+	}
+	return TextDrawSetString(text, string);
+}
+#if defined _ALS_TextDrawSetString
+	#undef TextDrawSetString
+#endif
+#define TextDrawSetString( BREAKS_TextDrawSetString(
+#define _ALS_TextDrawSetString
+stock BREAKS_PlayerTextDrawSetString(playerid, PlayerText:text, string[])
+{
+	new len = strlen(string);
+	if (len == 0 || len > 1024)
+	{
+		#emit HALT 100
+	}
+	if (string[len - 1] == ' ')
+	{
+		return PlayerTextDrawSetString(playerid, text, " ");
+	}
+	return PlayerTextDrawSetString(playerid, text, string);
+}
+#if defined _ALS_PlayerTextDrawSetString
+	#undef PlayerTextDrawSetString
+#endif
+#define PlayerTextDrawSetString( BREAKS_PlayerTextDrawSetString(
+#define _ALS_PlayerTextDrawSetString
+forward BREAKS_AllowInteriorWeapons(allow);
+#if defined _ALS_AllowInteriorWeapons
+	#undef AllowInteriorWeapons
+#endif
+#define AllowInteriorWeapons( BREAKS_AllowInteriorWeapons(
+#define _ALS_AllowInteriorWeapons
+forward Float:BREAKS_GetGravity();
+#if defined _ALS_GetGravity
+	#undef GetGravity
+#endif
+#define GetGravity( BREAKS_GetGravity(
+#define _ALS_GetGravity
+forward BREAKS_gpci(playerid, serial[], len = sizeof (serial));
+#if defined _ALS_gpci
+	#undef gpci
+#endif
+#define gpci( BREAKS_gpci(
+#define _ALS_gpci
+forward BREAKS_HideGameTextForPlayer(playerid, style);
+#if defined _ALS_HideGameTextForPlayer
+	#undef HideGameTextForPlayer
+#endif
+#define HideGameTextForPlayer( BREAKS_HideGameTextForPlayer(
+#define _ALS_HideGameTextForPlayer
+forward BREAKS_HideGameTextForAll(style);
+#if defined _ALS_HideGameTextForAll
+	#undef HideGameTextForAll
+#endif
+#define HideGameTextForAll( BREAKS_HideGameTextForAll(
+#define _ALS_HideGameTextForAll
+forward bool:BREAKS_IsValidVehicle(vehicleid);
+#if defined _ALS_IsValidVehicle
+	#undef IsValidVehicle
+#endif
+#define IsValidVehicle( BREAKS_IsValidVehicle(
+#define _ALS_IsValidVehicle
+stock BREAKS_random(max)
+{
+	if (max < 0)
+	{
+		return 0;
+	}
+	return random(max);
+}
+#if defined _ALS_random
+	#undef random
+#endif
+#define random( BREAKS_random(
+#define _ALS_random
+stock BREAKS_IsPlayerConnected(playerid)
+{
+	return IsPlayerConnected(playerid & 0xFFFF);
+}
+#if defined _ALS_IsPlayerConnected
+	#undef IsPlayerConnected
+#endif
+#define IsPlayerConnected( BREAKS_IsPlayerConnected(
+#define _ALS_IsPlayerConnected
+stock BREAKS_ApplyAnimation(playerid, animlib[], animname[], Float:fDelta, loop, lockx, locky, freeze, time, forcesync = 0)
+{
+	for (new i = 0; i != sizeof (BREAKS_gscAnimLib); ++i)
+	{
+		if (strcmp(animlib, BREAKS_gscAnimLib[i], true) == 0)
+		{
+			if (BREAKS_gLibraryInitialised[playerid][i / 32] & (1 << (i % 32)))
+			{
+				return ApplyAnimation(playerid, animlib, animname, fDelta, loop, lockx, locky, freeze, time, FORCE_SYNC:forcesync);
+			}
+			else
+			{
+				BREAKS_gLibraryInitialised[playerid][i / 32] |= (1 << (i % 32));
+			}
+			return 1;
+		}
+	}
+	return 0;
+}
+#if defined _ALS_ApplyAnimation
+	#undef ApplyAnimation
+#endif
+#define ApplyAnimation( BREAKS_ApplyAnimation(
+#define _ALS_ApplyAnimation
+stock BREAKS_valstr(dest[], value, bool:pack = false)
+{
+	if (value == cellmin)
+	{
+		if (pack)
+		{
+			dest{0} = '-';
+			dest{1} = '-';
+			dest{2} = '\0';
+		}
+		else
+		{
+			dest[0] = '-';
+			dest[1] = '-';
+			dest[2] = '\0';
+		}
+		return 0;
+	}
+	return valstr(dest, value, pack);
+}
+#if defined _ALS_valstr
+	#undef valstr
+#endif
+#define valstr( BREAKS_valstr(
+#define _ALS_valstr
+stock BREAKS_ispacked(const string[])
+{
+	return string[0] >= (1 << (cellbits - 8)) - 1;
+}
+#if defined _ALS_ispacked
+	#undef ispacked
+#endif
+#define ispacked( BREAKS_ispacked(
+#define _ALS_ispacked
+stock Float:BREAKS_floatfract(Float:value)
+{
+	return (value - floatround(value, floatround_floor));
+}
+#if defined _ALS_floatfract
+	#undef floatfract
+#endif
+#define floatfract( BREAKS_floatfract(
+#define _ALS_floatfract
+#endinput
+stock BREAKS_$()
+{
+	return $();
+}
+#if defined _ALS_$
+	#undef $
+#endif
+#define $( BREAKS_$(
+#define _ALS_$

colandreas.inc

@@ -0,0 +1,576 @@
+#if defined _colandreas_included
+	#endinput
+#endif
+#define _colandreas_included
+#pragma library colandreas
+#define COLANDREAS_VERSION	(10500)
+#define COLANDREAS	(COLANDREAS_VERSION)
+#define CA_EXTRA_1	0
+#define CA_EXTRA_2	1
+#define CA_EXTRA_3	2
+#define CA_EXTRA_4	3
+#define CA_EXTRA_5	4
+#define CA_EXTRA_6	5
+#define CA_EXTRA_7	6
+#define CA_EXTRA_8	7
+#define CA_EXTRA_9	8
+#define CA_EXTRA_10	9
+#if defined MAX_CA_OBJECTS
+	#if MAX_CA_OBJECTS > 50000
+		#error [ColAndreas] MAX_CA_OBJECTS is too high, maximum value is 50000
+	#endif
+#else
+	#define MAX_CA_OBJECTS	10000
+#endif
+#define WATER_OBJECT		20000
+#define OBJECT_TYPE_OBJECT	0
+#define OBJECT_TYPE_DYNAMIC	1
+#if !defined FLOAT_INFINITY
+	#define FLOAT_INFINITY	(Float:0x7F800000)
+#endif
+#define MAX_MULTICAST_SIZE	99
+native CA_Init();
+native CA_RemoveBuilding(modelid, Float:x, Float:y, Float:z, Float:radius);
+native CA_RestoreBuilding(modelid, Float:x, Float:y, Float:z, Float:radius);
+native CA_RayCastLine(Float:StartX, Float:StartY, Float:StartZ, Float:EndX, Float:EndY, Float:EndZ, &Float:x, &Float:y, &Float:z);
+native CA_RayCastLineID(Float:StartX, Float:StartY, Float:StartZ, Float:EndX, Float:EndY, Float:EndZ, &Float:x, &Float:y, &Float:z);
+native CA_RayCastLineExtraID(type, Float:StartX, Float:StartY, Float:StartZ, Float:EndX, Float:EndY, Float:EndZ, &Float:x, &Float:y, &Float:z);
+native CA_RayCastMultiLine(Float:StartX, Float:StartY, Float:StartZ, Float:EndX, Float:EndY, Float:EndZ, Float:retx[], Float:rety[], Float:retz[], Float:retdist[], ModelIDs[], size = sizeof(retx));
+native CA_RayCastLineAngle(Float:StartX, Float:StartY, Float:StartZ, Float:EndX, Float:EndY, Float:EndZ, &Float:x, &Float:y, &Float:z, &Float:rx, &Float:ry, &Float:rz);
+native CA_RayCastReflectionVector(Float:startx, Float:starty, Float:startz, Float:endx, Float:endy, Float:endz, &Float:x, &Float:y, &Float:z, &Float:nx, &Float:ny, &Float:nz);
+native CA_RayCastLineNormal(Float:startx, Float:starty, Float:startz, Float:endx, Float:endy, Float:endz, &Float:x, &Float:y, &Float:z, &Float:nx, &Float:ny, &Float:nz);
+native CA_ContactTest(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz);
+native CA_EulerToQuat(Float:rx, Float:ry, Float:rz, &Float:x, &Float:y, &Float:z, &Float:w);
+native CA_QuatToEuler(Float:x, Float:y, Float:z, Float:w, &Float:rx, &Float:ry, &Float:rz);
+native CA_GetModelBoundingSphere(modelid, &Float:offx, &Float:offy, &Float:offz, &Float:radius);
+native CA_GetModelBoundingBox(modelid, &Float:minx, &Float:miny, &Float:minz, &Float:maxx, &Float:maxy, &Float:maxz);
+native CA_SetObjectExtraID(index, type, data);
+native CA_GetObjectExtraID(index, type);
+native CA_RayCastLineEx(Float:StartX, Float:StartY, Float:StartZ, Float:EndX, Float:EndY, Float:EndZ, &Float:x, &Float:y, &Float:z, &Float:rx, &Float:ry, &Float:rz, &Float:rw, &Float:cx, &Float:cy, &Float:cz);
+native CA_RayCastLineAngleEx(Float:StartX, Float:StartY, Float:StartZ, Float:EndX, Float:EndY, Float:EndZ, &Float:x, &Float:y, &Float:z, &Float:rx, &Float:ry, &Float:rz, &Float:ocx, &Float:ocy, &Float:ocz, &Float:orx, &Float:ory, &Float:orz);
+native CA_LoadFromDff(newid, const dffFileName[]);
+native CA_CreateObject(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, bool:add = false);
+native CA_DestroyObject(index);
+native CA_IsValidObject(index);
+native CA_SetObjectPos(index, Float:x, Float:y, Float:z);
+native CA_SetObjectRot(index, Float:rx, Float:ry, Float:rz);
+#if defined _Y_ITERATE_LOCAL_VERSION || defined _FOREACH_LOCAL_VERSION
+	static stock Iterator:CA_Objects<MAX_CA_OBJECTS>;
+#endif
+enum CAOBJECTINFO
+{
+	ColdAndreadsID,
+	ObjectID,
+	ObjectType,
+	#if !defined _Y_ITERATE_LOCAL_VERSION && !defined _FOREACH_LOCAL_VERSION
+		bool:ObjectUsed,
+	#endif
+}
+static stock CA_ObjectList[MAX_CA_OBJECTS][CAOBJECTINFO];
+#if defined STREAMER_TYPE_OBJECT
+	stock STREAMER_TAG_OBJECT:CA_CreateDynamicObjectEx_SC(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, Float:streamdistance = STREAMER_OBJECT_SD, Float:drawdistance = STREAMER_OBJECT_DD, worlds[] = { -1 }, interiors[] = { -1 }, players[] = { -1 }, STREAMER_TAG_AREA:areas[] = { STREAMER_TAG_AREA:-1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players, maxareas = sizeof areas)
+	{
+		new STREAMER_TAG_OBJECT:id = CreateDynamicObjectEx(modelid, x, y, z, rx, ry, rz, streamdistance, drawdistance, worlds, interiors, players, areas, priority, maxworlds, maxinteriors, maxplayers, maxareas);
+		CA_CreateObject(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz);
+		return id;
+	}
+	stock STREAMER_TAG_OBJECT:CA_CreateDynamicObject_SC(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, vw = -1, interior = -1, playerid = -1, Float:streamdistance = STREAMER_OBJECT_SD, Float:drawdistance = STREAMER_OBJECT_DD, STREAMER_TAG_AREA:areaid = STREAMER_TAG_AREA:-1, priority = 0)
+	{
+		new STREAMER_TAG_OBJECT:id = CreateDynamicObject(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, vw, interior, playerid, streamdistance, drawdistance, areaid, priority);
+		CA_CreateObject(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz);
+		return id;
+	}
+	stock CA_CreateObject_SC(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, Float:drawdistance = 300.0)
+	{
+		new id = CreateObject(modelid, x, y, z, rx, ry, rz, drawdistance);
+		if(id != INVALID_OBJECT_ID) CA_CreateObject(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz);
+		return id;
+	}
+	stock CA_CreateDynamicObjectEx_DC(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, Float:streamdistance = STREAMER_OBJECT_SD, Float:drawdistance = STREAMER_OBJECT_DD, worlds[] = { -1 }, interiors[] = { -1 }, players[] = { -1 }, STREAMER_TAG_AREA:areas[] = { STREAMER_TAG_AREA:-1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players, maxareas = sizeof areas)
+	{
+		new index = -1;
+		#if defined _Y_ITERATE_LOCAL_VERSION || defined _FOREACH_LOCAL_VERSION
+			index = Iter_Free(CA_Objects);
+		#else
+			for(new i = 0; i < MAX_CA_OBJECTS; i++)
+			{
+				if(CA_ObjectList[i][ObjectUsed] == false)
+				{
+					index = i;
+					break;
+				}
+			}
+		#endif
+		if(index > -1)
+		{
+			#if defined _Y_ITERATE_LOCAL_VERSION || defined _FOREACH_LOCAL_VERSION
+				Iter_Add(CA_Objects, index);
+			#else
+				CA_ObjectList[index][ObjectUsed] = true;
+			#endif
+			CA_ObjectList[index][ObjectID] = _:CreateDynamicObjectEx(modelid, x, y, z, rx, ry, rz, streamdistance, drawdistance, worlds, interiors, players, areas, priority, maxworlds, maxinteriors, maxplayers, maxareas);
+			CA_ObjectList[index][ColdAndreadsID] = CA_CreateObject(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, true);
+			CA_ObjectList[index][ObjectType] = OBJECT_TYPE_DYNAMIC;
+		}
+		return index;
+	}
+	stock CA_CreateDynamicObject_DC(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, vw = -1, interior = -1, playerid = -1, Float:streamdistance = STREAMER_OBJECT_SD, Float:drawdistance = STREAMER_OBJECT_DD, STREAMER_TAG_AREA:areaid = STREAMER_TAG_AREA:-1, priority = 0)
+	{
+		new index = -1;
+		#if defined _Y_ITERATE_LOCAL_VERSION || defined _FOREACH_LOCAL_VERSION
+			index = Iter_Free(CA_Objects);
+		#else
+			for(new i = 0; i < MAX_CA_OBJECTS; i++)
+			{
+				if(CA_ObjectList[i][ObjectUsed] == false)
+				{
+					index = i;
+					break;
+				}
+			}
+		#endif
+		if(index > -1)
+		{
+			#if defined _Y_ITERATE_LOCAL_VERSION || defined _FOREACH_LOCAL_VERSION
+				Iter_Add(CA_Objects, index);
+			#else
+				CA_ObjectList[index][ObjectUsed] = true;
+			#endif
+			CA_ObjectList[index][ObjectID] = _:CreateDynamicObject(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, vw, interior, playerid, streamdistance, drawdistance, areaid, priority);
+			CA_ObjectList[index][ColdAndreadsID] = CA_CreateObject(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, true);
+			CA_ObjectList[index][ObjectType] = OBJECT_TYPE_DYNAMIC;
+		}
+		return index;
+	}
+#endif
+stock CA_CreateObject_DC(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, Float:drawdistance = 300.0)
+{
+	new index = -1;
+	#if defined _Y_ITERATE_LOCAL_VERSION || defined _FOREACH_LOCAL_VERSION
+		index = Iter_Free(CA_Objects);
+	#else
+		for(new i = 0; i < MAX_CA_OBJECTS; i++)
+		{
+			if(CA_ObjectList[i][ObjectUsed] == false)
+			{
+				index = i;
+				break;
+			}
+		}
+	#endif
+	new id = CreateObject(modelid, x, y, z, rx, ry, rz, drawdistance);
+	if(id == INVALID_OBJECT_ID) return -1;
+	if(index > -1)
+	{
+		#if defined _Y_ITERATE_LOCAL_VERSION || defined _FOREACH_LOCAL_VERSION
+			Iter_Add(CA_Objects, index);
+		#else
+			CA_ObjectList[index][ObjectUsed] = true;
+		#endif
+		CA_ObjectList[index][ObjectID] = id;
+		CA_ObjectList[index][ColdAndreadsID] = CA_CreateObject(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, true);
+		CA_ObjectList[index][ObjectType] = OBJECT_TYPE_OBJECT;
+	}
+	return index;
+}
+stock CA_DestroyObject_DC(index)
+{
+	if(index < 0 || index >= MAX_CA_OBJECTS) return -1;
+	#if defined _Y_ITERATE_LOCAL_VERSION || defined _FOREACH_LOCAL_VERSION
+		if(Iter_Contains(CA_Objects, index))
+		{
+			new next;
+			Iter_SafeRemove(CA_Objects, index, next);
+			if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_OBJECT) DestroyObject(CA_ObjectList[index][ObjectID]);
+			#if defined STREAMER_TYPE_OBJECT
+			else if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_DYNAMIC) DestroyDynamicObject(STREAMER_TAG_OBJECT:CA_ObjectList[index][ObjectID]);
+			#endif
+			CA_DestroyObject(CA_ObjectList[index][ColdAndreadsID]);
+			return next;
+		}
+	#else
+	if(CA_ObjectList[index][ObjectUsed])
+	{
+		if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_OBJECT) DestroyObject(CA_ObjectList[index][ObjectID]);
+		#if defined STREAMER_TYPE_OBJECT
+		else if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_DYNAMIC) DestroyDynamicObject(STREAMER_TAG_OBJECT:CA_ObjectList[index][ObjectID]);
+		#endif
+		CA_ObjectList[index][ObjectUsed] = false;
+		CA_DestroyObject(CA_ObjectList[index][ColdAndreadsID]);
+		return 1;
+	}
+	#endif
+	return -1;
+}
+stock CA_SetObjectPos_DC(index, Float:x, Float:y, Float:z)
+{
+	if(index < 0 || index >= MAX_CA_OBJECTS) return -1;
+	#if defined _Y_ITERATE_LOCAL_VERSION || defined _FOREACH_LOCAL_VERSION
+		if(Iter_Contains(CA_Objects, index))
+		{
+			if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_OBJECT) SetObjectPos(CA_ObjectList[index][ObjectID], x, y, z);
+			#if defined STREAMER_TYPE_OBJECT
+				else if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_DYNAMIC) SetDynamicObjectPos(STREAMER_TAG_OBJECT:CA_ObjectList[index][ObjectID], x, y, z);
+			#endif
+			CA_SetObjectPos(CA_ObjectList[index][ColdAndreadsID], x, y, z);
+		}
+	#else
+	if(CA_ObjectList[index][ObjectUsed])
+	{
+		if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_OBJECT) SetObjectPos(CA_ObjectList[index][ObjectID], x, y, z);
+		#if defined STREAMER_TYPE_OBJECT
+		else if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_DYNAMIC) SetDynamicObjectPos(STREAMER_TAG_OBJECT:CA_ObjectList[index][ObjectID], x, y, z);
+		#endif
+		SetObjectPos(CA_ObjectList[index][ObjectID], x, y, z);
+		CA_SetObjectPos(CA_ObjectList[index][ColdAndreadsID], x, y, z);
+		return 1;
+	}
+	#endif
+	return -1;
+}
+stock CA_SetObjectRot_DC(index, Float:rx, Float:ry, Float:rz)
+{
+	if(index < 0 || index >= MAX_CA_OBJECTS) return -1;
+	#if defined _Y_ITERATE_LOCAL_VERSION || defined _FOREACH_LOCAL_VERSION
+		if(Iter_Contains(CA_Objects, index))
+		{
+			if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_OBJECT) SetObjectRot(CA_ObjectList[index][ObjectID], rx, ry, rz);
+			#if defined STREAMER_TYPE_OBJECT
+				else if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_DYNAMIC) SetDynamicObjectRot(STREAMER_TAG_OBJECT:CA_ObjectList[index][ObjectID], rx, ry, rz);
+			#endif
+			CA_SetObjectRot(CA_ObjectList[index][ColdAndreadsID], rx, ry, rz);
+		}
+	#else
+	if(CA_ObjectList[index][ObjectUsed])
+	{
+		if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_OBJECT) SetObjectRot(CA_ObjectList[index][ObjectID], rx, ry, rz);
+		#if defined STREAMER_TYPE_OBJECT
+			else if(CA_ObjectList[index][ObjectType] == OBJECT_TYPE_DYNAMIC) SetDynamicObjectRot(STREAMER_TAG_OBJECT:CA_ObjectList[index][ObjectID], rx, ry, rz);
+		#endif
+		CA_SetObjectRot(CA_ObjectList[index][ColdAndreadsID], rx, ry, rz);
+		return 1;
+	}
+	#endif
+	return -1;
+}
+stock CA_DestroyAllObjects_DC()
+{
+	#if defined _Y_ITERATE_LOCAL_VERSION || defined _FOREACH_LOCAL_VERSION
+		foreach(new i : CA_Objects)
+		{
+			if(CA_ObjectList[i][ObjectType] == OBJECT_TYPE_OBJECT) i = CA_DestroyObject_DC(i);
+		}
+	#else
+		for(new i = 0; i < MAX_CA_OBJECTS; i++)
+		{
+			if(CA_ObjectList[i][ObjectUsed])
+			{
+				if(CA_ObjectList[i][ObjectType] == OBJECT_TYPE_OBJECT) CA_DestroyObject_DC(i);
+			}
+		}
+	#endif
+}
+stock CA_FindZ_For2DCoord(Float:x, Float:y, &Float:z)
+{
+	if(CA_RayCastLine(x, y, 700.0, x, y, -1000.0, x, y, z)) return 1;
+	return 0;
+}
+stock CA_RayCastExplode(Float:cX, Float:cY, Float:cZ, Float:Radius, Float:intensity = 20.0, Float:collisions[][3])
+{
+	if(intensity < 1.0 || intensity > 360.0 || (((360.0 / intensity) - floatround((360.0 / intensity), floatround_floor)) * intensity))
+		return 0;
+	new index, Float:LAT, Float:LON, Float:x, Float:y, Float:z;
+	for(new Float:lat = -180.0, Float:lon = -90.0; lat < 180.0; lat += (intensity * 0.75))
+	{
+		for(lon = -90.0; lon < 90.0; lon += intensity)
+		{
+			LAT = lat * 3.141593 / 180.0;
+			LON = lon * 3.141593 / 180.0;
+			x = -Radius * floatcos(LAT) * floatcos(LON);
+			y = Radius * floatcos(LAT) * floatsin(LON);
+			z = Radius * floatsin(LAT);
+			if(CA_RayCastLine(cX, cY, cZ, cX + x, cY + y, cZ + z, x, y, z))
+			{
+				collisions[index][0] = x;
+				collisions[index][1] = y;
+				collisions[index][2] = z;
+				index++;
+			}
+		}
+	}
+	return index;
+}
+stock CA_IsPlayerOnSurface(playerid, Float:tolerance = 1.5)
+{
+	new Float:x, Float:y, Float:z;
+	GetPlayerPos(playerid, x, y, z);
+	if(!CA_RayCastLine(x, y, z, x, y, z-tolerance, x, y, z))
+		return 0;
+	return 1;
+}
+stock CA_IsVehicleOnSurface(vehicleid, Float:tolerance = 1.5)
+{
+	new Float:x, Float:y, Float:z;
+	GetVehiclePos(vehicleid, x, y, z);
+	if(!CA_RayCastLine(x, y, z, x, y, z-tolerance, x, y, z))
+		return 0;
+	return 1;
+}
+stock CA_RemoveBarriers()
+{
+	static const BarrierIDS[] = {
+		4504, 4505, 4506, 4507, 4508, 4509, 4510, 4511, 4512, 4513,
+		4514, 4515, 4516, 4517, 4518, 4519, 4520, 4521, 4522, 4523,
+		4524, 4525, 4526, 4527, 16436, 16437, 16438, 16439, 1662
+ 	};
+ 	for(new i = 0; i < sizeof(BarrierIDS); i++)
+		CA_RemoveBuilding(BarrierIDS[i], 0.0, 0.0, 0.0, 4242.6407);
+	return 1;
+}
+stock CA_RemoveBreakableBuildings()
+{
+	static const BreakableIDs[] = {
+		625, 626, 627, 628, 629, 630, 631, 632, 633, 642, 643, 644, 646, 650, 716, 717, 737, 738, 792, 858, 881, 882, 883,
+		884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 904, 905, 941, 955, 956, 959, 961, 990, 993, 996, 1209,
+		1211, 1213, 1219, 1220, 1221, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1235, 1238, 1244, 1251,
+		1255, 1257, 1262, 1264, 1265, 1270, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1293,
+		1294, 1297, 1300, 1302, 1315, 1328, 1329, 1330, 1338, 1350, 1351, 1352, 1370, 1373, 1374, 1375, 1407, 1408, 1409,
+		1410, 1411, 1412, 1413, 1414, 1415, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1428, 1429, 1431,
+		1432, 1433, 1436, 1437, 1438, 1440, 1441, 1443, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, 1452, 1456, 1457,
+		1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476,
+		1477, 1478, 1479, 1480, 1481, 1482, 1483, 1514, 1517, 1520, 1534, 1543, 1544, 1545, 1551, 1553, 1554, 1558, 1564,
+		1568, 1582, 1583, 1584, 1588, 1589, 1590, 1591, 1592, 1645, 1646, 1647, 1654, 1664, 1666, 1667, 1668, 1669, 1670,
+		1672, 1676, 1684, 1686, 1775, 1776, 1949, 1950, 1951, 1960, 1961, 1962, 1975, 1976, 1977, 2647, 2663, 2682, 2683,
+		2885, 2886, 2887, 2900, 2918, 2920, 2925, 2932, 2933, 2942, 2943, 2945, 2947, 2958, 2959, 2966, 2968, 2971, 2977,
+		2987, 2988, 2989, 2991, 2994, 3006, 3018, 3019, 3020, 3021, 3022, 3023, 3024, 3029, 3032, 3036, 3058, 3059, 3067,
+		3083, 3091, 3221, 3260, 3261, 3262, 3263, 3264, 3265, 3267, 3275, 3276, 3278, 3280, 3281, 3282, 3302, 3374, 3409,
+		3460, 3516, 3794, 3795, 3797, 3853, 3855, 3864, 3884, 11103, 12840, 16627, 16628, 16629, 16630, 16631, 16632,
+		16633, 16634, 16635, 16636, 16732, 17968
+	};
+ 	for(new i = 0; i < sizeof(BreakableIDs); i++)
+		CA_RemoveBuilding(BreakableIDs[i], 0.0, 0.0, 0.0, 4242.6407);
+	return 1;
+}
+stock CA_IsPlayerInWater(playerid, &Float:depth, &Float:playerdepth)
+{
+	new Float:x, Float:y, Float:z, Float:retx[10], Float:rety[10], Float:retz[10], Float: retdist[10], modelids[10];
+	GetPlayerPos(playerid, x, y, z);
+	new collisions = CA_RayCastMultiLine(x, y, z+1000.0, x, y, z-1000.0, retx, rety, retz, retdist, modelids, 10);
+	if(collisions > 0)
+	{
+		for(new i = 0, j = 0; i < collisions; i++)
+		{
+			if(modelids[i] == WATER_OBJECT)
+			{
+				depth = FLOAT_INFINITY;
+				for(j = 0; j < collisions; j++)
+				{
+					if(retz[j] < depth)
+					depth = retz[j];
+				}
+				depth = retz[i] - depth;
+				if(depth < 0.001 && depth > -0.001)
+					depth = 100.0;
+				playerdepth = retz[i] - z;
+				if(playerdepth < -2.0)
+					return 0;
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+stock CA_IsVehicleInWater(vehicleid, &Float:depth, &Float:vehicledepth)
+{
+	new Float:x, Float:y, Float:z, Float:retx[10], Float:rety[10], Float:retz[10], Float:retdist[10], modelids[10];
+	GetVehiclePos(vehicleid, x, y, z);
+	new collisions = CA_RayCastMultiLine(x, y, z + 1000.0, x, y, z - 1000.0, retx, rety, retz, retdist, modelids, 10);
+	if(collisions)
+	{
+		for(new i = 0, j = 0; i < collisions; i++)
+		{
+			if(modelids[i] == WATER_OBJECT)
+			{
+				depth = FLOAT_INFINITY;
+				for(j = 0; j < collisions; j++)
+				{
+					if(retz[j] < depth)
+					depth = retz[j];
+				}
+				depth = retz[i] - depth;
+				if(depth < 0.001 && depth > -0.001)
+					depth = 100.0;
+				vehicledepth = retz[i] - z;
+				if(vehicledepth < -2.0)
+					return 0;
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+stock CA_IsPlayerNearWater(playerid, Float:dist = 3.0, Float:height = 3.0)
+{
+	new Float:x, Float:y, Float:z, Float:tmp;
+	GetPlayerPos(playerid, x, y, z);
+	for(new i; i < 6; i++)
+		if(CA_RayCastLine(x + (dist * floatsin(i * 60.0, degrees)), y + (dist * floatcos(i * 60.0, degrees)), z + height, x + (dist * floatsin(i * 60.0, degrees)), y + (dist * floatcos(i * 60.0, degrees)), z - height, tmp, tmp, tmp) == WATER_OBJECT)
+			return 1;
+	return 0;
+}
+stock CA_IsVehicleNearWater(vehicleid, Float:dist = 3.0, Float:height = 3.0)
+{
+	new Float:x, Float:y, Float:z, Float:tmp;
+	GetVehiclePos(vehicleid, x, y, z);
+	for(new i; i < 6; i++)
+		if(CA_RayCastLine(x + (dist * floatsin(i * 60.0, degrees)), y + (dist * floatcos(i * 60.0, degrees)), z + height, x + (dist * floatsin(i * 60.0, degrees)), y + (dist * floatcos(i * 60.0, degrees)), z - height, tmp, tmp, tmp) == WATER_OBJECT)
+			return 1;
+	return 0;
+}
+stock CA_IsPlayerFacingWater(playerid, Float:dist = 3.0, Float:height = 3.0)
+{
+	new Float:x, Float:y, Float:z, Float:r, Float:tmp;
+	GetPlayerPos(playerid, x, y, z);
+	GetPlayerFacingAngle(playerid, r);
+	if(CA_RayCastLine(x + (dist * floatsin(-r, degrees)), y + (dist * floatcos(-r, degrees)), z, x + (dist * floatsin(-r, degrees)), y + (dist * floatcos(-r, degrees)), z - height, tmp, tmp, tmp) == WATER_OBJECT)
+		return 1;
+	return 0;
+}
+stock CA_IsVehicleFacingWater(vehicleid, Float:dist = 3.0, Float:height = 3.0)
+{
+	new Float:x, Float:y, Float:z, Float:r, Float:tmp;
+	GetVehiclePos(vehicleid, x, y, z);
+	GetVehicleZAngle(vehicleid, r);
+	if(CA_RayCastLine(x + (dist * floatsin(-r, degrees)), y + (dist * floatcos(-r, degrees)), z, x + (dist * floatsin(-r, degrees)), y + (dist * floatcos(-r, degrees)), z - height, tmp, tmp, tmp) == WATER_OBJECT)
+		return 1;
+	return 0;
+}
+stock CA_IsPlayerBlocked(playerid, Float:dist = 1.5, Float:height = 0.5)
+{
+	new Float:x, Float:y, Float:z, Float:endx, Float:endy, Float:fa;
+	GetPlayerPos(playerid, x, y, z);
+	z -= 1.0 + height;
+	GetPlayerFacingAngle(playerid, fa);
+	endx = (x + dist * floatsin(-fa, degrees));
+	endy = (y + dist * floatcos(-fa, degrees));
+	if(CA_RayCastLine(x, y, z, endx, endy, z, x, y, z))
+		return 1;
+	return 0;
+}
+stock CA_IsVehicleBlocked(vehicleid, Float:dist = 1.5, Float:height = 0.5)
+{
+	new Float:x, Float:y, Float:z, Float:endx, Float:endy, Float:za;
+	GetVehiclePos(vehicleid, x, y, z);
+	z -= 1.0 + height;
+	GetVehicleZAngle(vehicleid, za);
+	endx = (x + dist * floatsin(-za, degrees));
+	endy = (y + dist * floatcos(-za, degrees));
+	if(CA_RayCastLine(x, y, z, endx, endy, z, x, y, z))
+		return 1;
+	return 0;
+}
+stock Float:CA_GetRoomHeight(Float:x, Float:y, Float:z)
+{
+	new Float:fx, Float:fy, Float:fz, Float:cx, Float:cy, Float:cz;
+	if(CA_RayCastLine(x, y, z, x, y, z - 1000.0, fx, fy, fz))
+	{
+		if(CA_RayCastLine(x, y, z, x, y, z + 1000.0, cx, cy, cz))
+			return floatsqroot(((fx - cx) * (fx - cx)) + ((fy - cy) * (fy - cy)) + ((fz - cz) * (fz - cz)));
+	}
+	return 0.0;
+}
+stock Float:CA_GetRoomCenter(Float:x, Float:y, Float:z, &Float:m_x, &Float:m_y)
+{
+	new Float:pt1x, Float:pt1y,
+		Float:pt2x, Float:pt2y,
+		Float:pt3x, Float:pt3y,
+		Float:tmp;
+	if(!CA_RayCastLine(x, y, z, x + 1000.0 * floatcos(0.0, degrees), y + 1000.0 * floatsin(0.0, degrees), z, pt1x, pt1y, tmp) ||
+		!CA_RayCastLine(x, y, z, x + 1000.0 * floatcos(120.0, degrees), y + 1000.0 * floatsin(120.0, degrees), z, pt2x, pt2y, tmp) ||
+		!CA_RayCastLine(x, y, z, x + 1000.0 * floatcos(-120.0, degrees), y + 1000.0 * floatsin(-120.0, degrees), z, pt3x, pt3y, tmp))
+		return -1.0;
+	new Float:yDelta_a = pt2y - pt1y,
+		Float:xDelta_a = pt2x - pt1x,
+		Float:yDelta_b = pt3y - pt2y,
+		Float:xDelta_b = pt3x - pt2x;
+	if (floatabs(xDelta_a) <= 0.000000001 && floatabs(yDelta_b) <= 0.000000001) {
+		m_x = 0.5 * (pt2x + pt3x);
+		m_y = 0.5 * (pt1y + pt2y);
+		return VectorSize(m_x - pt1x, m_y - pt1y, 0.0);
+	}
+	new Float:aSlope = yDelta_a / xDelta_a,
+		Float:bSlope = yDelta_b / xDelta_b;
+	if (floatabs(aSlope-bSlope) <= 0.000000001)
+		return -1.0;
+	m_x = (aSlope * bSlope * (pt1y - pt3y) + bSlope * (pt1x + pt2x) - aSlope * (pt2x + pt3x)) / (2.0 * (bSlope - aSlope));
+	m_y = -1.0 * (m_x - (pt1x + pt2x) / 2.0) / aSlope + (pt1y + pt2y) / 2.0;
+	return VectorSize(m_x - pt1x, m_y - pt1y, 0.0);
+}
+stock CA_GetObjectID(const index)
+{
+	if (!(0 <= index < sizeof(CA_ObjectList)))
+	{
+		return -1;
+	}
+	if (!CA_IsValidObject(index))
+	{
+		return -2;
+	}
+	return CA_ObjectList[index][ObjectID];
+}
+stock CA_GetObjectType(const index)
+{
+	if (!(0 <= index < sizeof(CA_ObjectList)))
+	{
+		return -1;
+	}
+	if (!CA_IsValidObject(index))
+	{
+		return -2;
+	}
+	return CA_ObjectList[index][ObjectType];
+}
+stock CA_GetCollisionObjectID(const index)
+{
+	if (!(0 <= index < sizeof(CA_ObjectList)))
+	{
+		return -1;
+	}
+	if (!CA_IsValidObject(index))
+	{
+		return -2;
+	}
+	return CA_ObjectList[index][ColdAndreadsID];
+}
+public OnFilterScriptExit()
+{
+	CA_DestroyAllObjects_DC();
+	if (funcidx("CA_OnFilterScriptExit") != -1)
+	{
+		return CallLocalFunction("CA_OnFilterScriptExit", "");
+	}
+	return 1;
+ }
+#if defined _ALS_OnFilterScriptExit
+	#undef OnFilterScriptExit
+#else
+	#define _ALS_OnFilterScriptExit
+#endif
+#define OnFilterScriptExit CA_OnFilterScriptExit
+forward CA_OnFilterScriptExit();
+public OnGameModeExit()
+{
+	CA_DestroyAllObjects_DC();
+	if (funcidx("CA_OnGameModeExit") != -1)
+	{
+		return CallLocalFunction("CA_OnGameModeExit", "");
+	}
+	return 1;
+ }
+#if defined _ALS_OnGameModeExit
+	#undef OnGameModeExit
+#else
+	#define _ALS_OnGameModeExit
+#endif
+#define OnGameModeExit CA_OnGameModeExit
+forward CA_OnGameModeExit();

crashdetect.inc

@@ -0,0 +1,101 @@
+#if defined CRASHDETECT_INC
+	#endinput
+#endif
+#define CRASHDETECT_INC
+#define PrintAmxBacktrace PrintBacktrace
+#define GetAmxBacktrace GetBacktrace
+native PrintBacktrace();
+native PrintNativeBacktrace();
+native GetBacktrace(string[], size = sizeof(string));
+native GetNativeBacktrace(string[], size = sizeof(string));
+forward OnRuntimeError(code, &bool:suppress);
+stock bool:IsCrashDetectPresent() {
+	#emit zero.pri
+	#emit lctrl 0xFF
+	#emit not
+	#emit not
+	#emit retn
+	return false;
+}
+stock SetCrashDetectLongCallTime(us_time) {
+	#emit load.s.pri us_time
+	#emit sctrl 0xFE
+}
+stock GetCrashDetectLongCallTime() {
+	#emit zero.pri
+	#emit lctrl 0xFE
+	#emit retn
+	return 0;
+}
+stock DisableCrashDetectLongCall() {
+	#emit const.pri 32
+	#emit sctrl 0xFF
+}
+stock EnableCrashDetectLongCall() {
+	#emit const.pri 34
+	#emit sctrl 0xFF
+}
+stock ResetCrashDetectLongCallTime() {
+	#emit const.pri 36
+	#emit sctrl 0xFF
+}
+stock RestartCrashDetectLongCall() {
+	#emit const.pri 40
+	#emit sctrl 0xFF
+}
+stock bool:IsCrashDetectLongCallEnabled() {
+	#emit zero.pri
+	#emit lctrl 0xFF
+	#emit shr.c.pri 1
+	#emit const.alt 1
+	#emit and
+	#emit retn
+	return false;
+}
+stock bool:HasCrashDetectLongCall() {
+	#emit zero.pri
+	#emit lctrl 0xFF
+	#emit shr.c.pri 5
+	#emit const.alt 1
+	#emit and
+	#emit retn
+	return false;
+}
+stock GetCrashDetectDefaultTime() {
+	#emit lctrl 0xFE
+	#emit move.alt
+	#emit const.pri 36
+	#emit sctrl 0xFF
+	#emit lctrl 0xFE
+	#emit xchg
+	#emit sctrl 0xFE
+	#emit move.pri
+	#emit retn
+	return 0;
+}
+stock DisableCrashDetectAddr0() {
+	#emit const.pri 64
+	#emit sctrl 0xFF
+}
+stock EnableCrashDetectAddr0() {
+	#emit const.pri 192
+	#emit sctrl 0xFF
+}
+stock bool:IsCrashDetectAddr0Enabled() {
+	#emit zero.pri
+	#emit lctrl 0xFF
+	#emit shr.c.pri 7
+	#emit const.alt 1
+	#emit and
+	#emit retn
+	return false;
+}
+stock bool:HasCrashDetectAddr0() {
+	#emit zero.pri
+	#emit lctrl 0xFF
+	#emit shr.c.pri 6
+	#emit const.alt 1
+	#emit and
+	#emit retn
+	return false;
+}

easyDialog.inc

@@ -0,0 +1,114 @@
+#if defined _easyDialog_included
+	#endinput
+#endif
+#define _easyDialog_included
+#if !defined isnull
+	#define isnull(%1) \
+		((!(%1[0])) || (((%1[0]) == '\1') && (!(%1[1]))))
+#endif
+#if !defined HidePlayerDialog
+	#define HidePlayerDialog(%1) \
+		ShowPlayerDialog(%1, -1, 0, " ", " ", " ", " ")
+#endif
+#define Dialog:%0(%1) \
+	forward dialog_%0(%1); public dialog_%0(%1)
+#define Dialog_Show(%0,%1, \
+	Dialog_Open(%0, #%1,
+#define Dialog_Opened(%0) \
+	(CallRemoteFunction("Dialog_IsOpened", "i", (%0)))
+#if !defined _INC_open_mp
+	#if !defined DIALOG_STYLE
+		#define DIALOG_STYLE: _:
+	#endif
+#endif
+static
+	s_DialogName[MAX_PLAYERS][32 char],
+	bool: s_DialogOpened[MAX_PLAYERS]
+;
+forward OnDialogPerformed(playerid, const dialog[], response, success);
+forward @dialog_format(); @dialog_format() {
+	new emptyString[] = '\1';
+	format(emptyString, sizeof(emptyString), emptyString);
+}
+forward Dialog_IsOpened(playerid);
+public Dialog_IsOpened(playerid) {
+	return (s_DialogOpened[playerid]);
+}
+stock Dialog_Close(playerid) {
+	s_DialogName[playerid]{0} = 0;
+	s_DialogOpened[playerid] = false;
+	return HidePlayerDialog(playerid);
+}
+stock Dialog_Open(playerid, const function[], DIALOG_STYLE:style, const caption[], const info[], const button1[], const button2[], {Float,_}:...) {
+	static
+		string[4096],
+		args
+	;
+	if (!strlen(info)) {
+		return 0;
+	}
+	if ((args = numargs()) > 7) {
+		while (--args >= 7) {
+			#emit LCTRL 5
+			#emit LOAD.alt args
+			#emit SHL.C.alt 2
+			#emit ADD.C 12
+			#emit ADD
+			#emit LOAD.I
+			#emit PUSH.pri
+		}
+		#emit PUSH.S info
+		#emit PUSH.C 4096
+		#emit PUSH.C string
+		#emit LOAD.S.pri 8
+		#emit CONST.alt 16
+		#emit SUB
+		#emit PUSH.pri
+		#emit SYSREQ.C format
+		#emit LCTRL 5
+		#emit SCTRL 4
+		ShowPlayerDialog(playerid, 32700, style, caption, string, button1, button2);
+	}
+	else {
+		ShowPlayerDialog(playerid, 32700, style, caption, info, button1, button2);
+	}
+	s_DialogOpened[playerid] = true;
+	strpack(s_DialogName[playerid], function, 32 char);
+	return 1;
+}
+public OnDialogResponse(playerid, dialogid, response, listitem, inputtext[]) {
+	static
+		s_Public = cellmax;
+	if (s_Public == cellmax) {
+		s_Public = funcidx("OnDialogPerformed");
+	}
+	for (new i = 0, l = strlen(inputtext); i < l; i ++) {
+		if (inputtext[i] == '%') {
+			inputtext[i] = '#';
+		}
+	}
+	if (dialogid == 32700 && strlen(s_DialogName[playerid]) > 0) {
+		new
+			string[40];
+		strcat(string, "dialog_");
+		strcat(string, s_DialogName[playerid]);
+		Dialog_Close(playerid);
+		if ((s_Public == -1) || (CallLocalFunction("OnDialogPerformed", "dsdd", playerid, string[7], response, funcidx(string) != -1))) {
+	 		CallLocalFunction(string, "ddds", playerid, response, listitem, (!inputtext[0]) ? ("\1") : (inputtext));
+		}
+	}
+	#if defined DR_OnDialogResponse
+		return DR_OnDialogResponse(playerid, dialogid, response, listitem, inputtext);
+	#else
+		return 0;
+	#endif
+}
+#if defined _ALS_OnDialogResponse
+	#undef OnDialogResponse
+#else
+	#define _ALS_OnDialogResponse
+#endif
+#define OnDialogResponse DR_OnDialogResponse
+#if defined DR_OnDialogResponse
+	forward DR_OnDialogResponse(playerid, dialogid, response, listitem, inputtext[]);
+#endif

foreach.inc

@@ -0,0 +1,515 @@
+#if defined _FOREACH_LOCAL_VERSION
+	#endinput
+#endif
+#define _FOREACH_LOCAL_VERSION		19
+#if defined _FOREACH_INC_TEST
+	#endinput
+#endif
+#define _FOREACH_INC_TEST
+#if !defined _samp_included
+	#error "Please include a_samp or a_npc before foreach"
+#endif
+#if defined SendChat || defined FOREACH_NO_PLAYERS
+	#define BOTSYNC_IS_BOT		(true)
+#endif
+#if defined IsPlayerNPC
+	#define _FOREACH_BOT
+#endif
+#define ITER_NONE -1
+#define _Y_ITER_ARRAY: _:_Y_ITER_C0:
+#define _Y_ITER_ARRAY_SIZE(%1) _:_Y_ITER_C1:_Y_ITER_C2:sizeof %1@YSII_Ag-1
+#define _Y_ITER_C0:%0[%1]@YSII_%4g%3) %0@YSII_%4g[%1]%3)
+#define _Y_ITER_C1:_Y_ITER_C2:%0[%1]@YSII_Ag%3) %0@YSII_Ag[]%3)
+#define _Y_ITER_C2:sizeof%0(%1)@YSII_Ag-1;_:(%2=_Y_ITER_ARRAY:%3(%4)@YSII_Ag[%5])!=_Y_ITER_ARRAY_SIZE(%6);) -1;_:(%2=%3@YSII_Ag(%4,%5))!=-1;)
+#define _Y_ITER_C3:%0[%1]@YSII_Cg,%2[%3]@YSII_Ag[%4]={%5} _Y_ITER_C3:%0@YSII_Cg[%1],%0@YSII_Ag[%1][%4]
+#if !defined BOTSYNC_IS_BOT
+	static stock
+		YSI_g_sCallbacks = 0;
+	forward Iter_OPDCInternal(playerid);
+	#if !defined FOREACH_I_Vehicle
+		#define FOREACH_I_Vehicle 1
+	#endif
+#else
+	#if !defined FOREACH_I_Vehicle
+		#define FOREACH_I_Vehicle 0
+	#endif
+#endif
+#define IteratorArray:%1[%2]<%3> %1@YSII_Cg[%2],%1@YSII_Ag[%2][%3+1]
+#define Iterator:%1<%2> _Y_ITER_C3:%1@YSII_Cg,%1@YSII_Ag[(%2)+1]={(%2)*2,(%2)*2-1,...}
+#define iterator%0<%1> new Iterator:%0<%1>
+#define Iter_Init(%1) \
+	Iter_InitInternal(%1@YSII_Ag,sizeof %1@YSII_Ag,sizeof %1@YSII_Ag[]-1)
+#define Iter_Add(%1,%2) Iter_AddInternal(_Y_ITER_ARRAY:%1@YSII_Cg,_Y_ITER_ARRAY:%1@YSII_Ag,%2,_Y_ITER_ARRAY_SIZE(%1))
+#define Iter_Free(%1) Iter_FreeInternal(_Y_ITER_ARRAY:%1@YSII_Ag,_Y_ITER_ARRAY_SIZE(%1))
+#define Iter_Remove(%1,%2) Iter_RemoveInternal(_Y_ITER_ARRAY:%1@YSII_Cg,_Y_ITER_ARRAY:%1@YSII_Ag,%2,_Y_ITER_ARRAY_SIZE(%1))
+#define Iter_Contains(%1,%2) Iter_ContainsInternal(_Y_ITER_ARRAY:%1@YSII_Ag,%2,_Y_ITER_ARRAY_SIZE(%1))
+#define Iter_SafeRemove(%1,%2,%3) Iter_SafeRemoveInternal(_Y_ITER_ARRAY:%1@YSII_Cg,_Y_ITER_ARRAY:%1@YSII_Ag,%2,%3,_Y_ITER_ARRAY_SIZE(%1))
+#define Iter_Random(%1) Iter_RandomInternal(_Y_ITER_ARRAY:%1@YSII_Cg,_Y_ITER_ARRAY:%1@YSII_Ag,_Y_ITER_ARRAY_SIZE(%1))
+#define Iter_Count(%1) (_Y_ITER_ARRAY:%1@YSII_Cg)
+#define Iter_Clear(%1) Iter_ClearInternal(_Y_ITER_ARRAY:%1@YSII_Cg,_Y_ITER_ARRAY:%1@YSII_Ag,_Y_ITER_ARRAY_SIZE(%1))
+#if !defined BOTSYNC_IS_BOT
+	new
+		Iterator:Player<MAX_PLAYERS>,
+		Iterator:Actor<MAX_ACTORS>;
+	#if FOREACH_I_Vehicle
+		new Iterator:Vehicle<MAX_VEHICLES>;
+	#endif
+	#if defined _FOREACH_BOT && !defined FOREACH_NO_BOTS
+		new
+			Iterator:Bot<MAX_PLAYERS>,
+			Iterator:Character<MAX_PLAYERS>;
+		#define NPC@YSII_Cg Bot@YSII_Cg
+		#define NPC@YSII_Ag Bot@YSII_Ag
+	#endif
+#endif
+static stock
+	YSI_gsOnPlayerConnect[] = "Iter_OnPlayerConnect",
+	YSI_gsOnPlayerDisconnect[] = "Iter_OnPlayerDisconnect",
+	YSI_gsOnGameModeInit[] = "Iter_OnGameModeInit",
+	YSI_OnFilterScriptInit[] = "Iter_OnFilterScriptInit",
+	YSI_gsSpecifier@[] = "",
+	YSI_gsSpecifier@i[] = "i";
+#define foreach%1(%0) for(new Y_FOREACH_SECOND|||Y_FOREACH_THIRD|||%0|||)
+#define new%0|||%9|||%1:%2||| %9|||%0|||%1|||%2|||
+#define Y_FOREACH_THIRD|||%0|||%1|||%2||| %1=Y_FOREACH_FIFTH|||Y_FOREACH_FOURTH|||%1:%2|||
+#define Y_FOREACH_FOURTH|||%0=Y_FOREACH_FIFTH|||%1|||%2||| new Y_FOREACH_SIXTH;%0|||Y_FOREACH_SEVENTH|||%2|||
+#define Y_FOREACH_SEVENTH|||%9Y_FOREACH_SIXTH;%0|||%1|||%2||| new %0:%1=%0:(_Y_ITER_ARRAY_SIZE(%2));_:(%1=%0:_Y_ITER_ARRAY:%2@YSII_Ag[_:%1])!=_Y_ITER_ARRAY_SIZE(%2);
+#define Y_FOREACH_SIXTH;%0|||Y_FOREACH_SEVENTH|||%2||| %0=_Y_ITER_ARRAY_SIZE(%2);_:(%0=_Y_ITER_ARRAY:%2@YSII_Ag[%0])!=_Y_ITER_ARRAY_SIZE(%2);
+#define Y_FOREACH_FIFTH|||Y_FOREACH_FOURTH|||%1:%2||| _Y_ITER_ARRAY_SIZE(%2);_:(%1=_Y_ITER_ARRAY:%2@YSII_Ag[%1])!=_Y_ITER_ARRAY_SIZE(%2);
+#define Y_FOREACH_SECOND|||Y_FOREACH_THIRD|||%1,%2||| %2=_Y_ITER_ARRAY_SIZE(%1);_:(%2=_Y_ITER_ARRAY:%1@YSII_Ag[%2])!=_Y_ITER_ARRAY_SIZE(%1);
+#define foreachex(%1,%2) foreach(%2:%1)
+stock Iter_ScriptInit()
+{
+	Iter_Clear(Player);
+	#if defined _FOREACH_BOT && !defined FOREACH_NO_BOTS
+		Iter_Clear(Bot);
+		Iter_Clear(Character);
+	#endif
+	#if FOREACH_I_Vehicle
+		Iter_Clear(Vehicle);
+		for(new vehicleid = 1; vehicleid != MAX_VEHICLES; ++vehicleid) {
+			if(!GetVehicleModel(vehicleid)) {
+				continue;
+			}
+			Iter_Add(Vehicle, vehicleid);
+		}
+	#endif
+	Iter_Clear(Actor);
+	for(new actorid = 0; actorid != MAX_ACTORS; ++actorid) {
+		if(!IsValidActor(actorid)) {
+			continue;
+		}
+		Iter_Add(Actor, actorid);
+	}
+	if(funcidx(YSI_gsOnPlayerDisconnect) != -1) {
+		YSI_g_sCallbacks |= 1;
+	}
+	if(funcidx(YSI_gsOnPlayerConnect) != -1) {
+		YSI_g_sCallbacks |= 2;
+	}
+}
+#if !defined BOTSYNC_IS_BOT
+	public OnFilterScriptInit()
+	{
+		Iter_ScriptInit();
+		#if defined _FOREACH_BOT && !defined FOREACH_NO_BOTS
+			Bot@YSII_Cg = _Y_ITER_C3:0;
+			Character@YSII_Cg = _Y_ITER_C3:0;
+			new
+				lastBot = MAX_PLAYERS,
+				lastCharacter = MAX_PLAYERS;
+		#endif
+		Player@YSII_Cg = _Y_ITER_C3:0;
+		new
+			lastPlayer = MAX_PLAYERS;
+		for(new i = 0; i != MAX_PLAYERS; ++i) {
+			if(IsPlayerConnected(i)) {
+				#if defined _FOREACH_BOT
+					if(!IsPlayerNPC(i)) {
+						Player@YSII_Ag[lastPlayer] = i;
+						++Player@YSII_Cg;
+						lastPlayer = i;
+					}
+					#if !defined FOREACH_NO_BOTS
+						else {
+							Bot@YSII_Ag[lastBot] = i;
+							++Bot@YSII_Cg;
+							lastBot = i;
+						}
+						#pragma tabsize 4
+						Character@YSII_Ag[lastCharacter] = i;
+						++Character@YSII_Cg;
+						lastCharacter = i;
+					#endif
+				#else
+					Player@YSII_Ag[lastPlayer] = i;
+					++Player@YSII_Cg;
+					lastPlayer = i;
+				#endif
+			} else {
+				#if defined _FOREACH_BOT && !defined FOREACH_NO_BOTS
+					Bot@YSII_Ag[i] = MAX_PLAYERS + 1;
+					Character@YSII_Ag[i] = MAX_PLAYERS + 1;
+				#endif
+				Player@YSII_Ag[i] = MAX_PLAYERS + 1;
+			}
+		}
+		#if defined _FOREACH_BOT && !defined FOREACH_NO_BOTS
+			Bot@YSII_Ag[lastPlayer] = MAX_PLAYERS;
+			Character@YSII_Ag[lastPlayer] = MAX_PLAYERS;
+		#endif
+		Player@YSII_Ag[lastPlayer] = MAX_PLAYERS;
+		CallLocalFunction(YSI_OnFilterScriptInit, YSI_gsSpecifier@);
+		return 1;
+	}
+	#if defined _ALS_OnFilterScriptInit
+		#undef OnFilterScriptInit
+	#else
+		#define _ALS_OnFilterScriptInit
+	#endif
+	#define OnFilterScriptInit Iter_OnFilterScriptInit
+	forward OnFilterScriptInit();
+#endif
+#if !defined BOTSYNC_IS_BOT
+	public OnGameModeInit()
+	{
+		Iter_ScriptInit();
+		#if defined _FOREACH_BOT && !defined FOREACH_NO_BOTS
+			Bot@YSII_Cg = _Y_ITER_C3:0;
+			Bot@YSII_Ag[MAX_PLAYERS] = MAX_PLAYERS;
+			Character@YSII_Ag[MAX_PLAYERS] = MAX_PLAYERS;
+			Character@YSII_Cg = _Y_ITER_C3:0;
+			new
+				lastBot = MAX_PLAYERS,
+				lastCharacter = MAX_PLAYERS;
+		#endif
+		Player@YSII_Cg = _Y_ITER_C3:0;
+		Player@YSII_Ag[MAX_PLAYERS] = MAX_PLAYERS;
+		new
+			lastPlayer = MAX_PLAYERS;
+		for(new i = 0; i != MAX_PLAYERS; ++i) {
+			if(IsPlayerConnected(i)) {
+				#if defined _FOREACH_BOT
+					if(!IsPlayerNPC(i)) {
+						Player@YSII_Ag[lastPlayer] = i;
+						++Player@YSII_Cg;
+						lastPlayer = i;
+					}
+					#if !defined FOREACH_NO_BOTS
+						else {
+							Bot@YSII_Ag[lastBot] = i;
+							++Bot@YSII_Cg;
+							lastBot = i;
+						}
+						#pragma tabsize 4
+						Character@YSII_Ag[lastCharacter] = i;
+						++Character@YSII_Cg;
+						lastCharacter = i;
+					#endif
+				#else
+					Player@YSII_Ag[lastPlayer] = i;
+					++Player@YSII_Cg;
+					lastPlayer = i;
+				#endif
+			} else {
+				#if defined _FOREACH_BOT && !defined FOREACH_NO_BOTS
+					Bot@YSII_Ag[i] = MAX_PLAYERS + 1;
+					Character@YSII_Ag[i] = MAX_PLAYERS + 1;
+				#endif
+				Player@YSII_Ag[i] = MAX_PLAYERS + 1;
+			}
+		}
+		#if defined _FOREACH_BOT && !defined FOREACH_NO_BOTS
+			Bot@YSII_Ag[lastPlayer] = MAX_PLAYERS;
+			Character@YSII_Ag[lastPlayer] = MAX_PLAYERS;
+		#endif
+		Player@YSII_Ag[lastPlayer] = MAX_PLAYERS;
+		CallLocalFunction(YSI_gsOnGameModeInit, YSI_gsSpecifier@);
+		return 1;
+	}
+	#if defined _ALS_OnGameModeInit
+		#undef OnGameModeInit
+	#else
+		#define _ALS_OnGameModeInit
+	#endif
+	#define OnGameModeInit Iter_OnGameModeInit
+	forward OnGameModeInit();
+#endif
+#if !defined BOTSYNC_IS_BOT
+	public OnPlayerConnect(playerid)
+	{
+		#if defined _FOREACH_BOT
+			if(!IsPlayerNPC(playerid)) {
+				Iter_Add(Player, playerid);
+			}
+			#if !defined FOREACH_NO_BOTS
+				else {
+					Iter_Add(Bot, playerid);
+				}
+				#pragma tabsize 4
+				Iter_Add(Character, playerid);
+			#endif
+		#else
+			Iter_Add(Player, playerid);
+		#endif
+		if(YSI_g_sCallbacks & 2) {
+			CallLocalFunction(YSI_gsOnPlayerConnect, YSI_gsSpecifier@i, playerid);
+		}
+		return 1;
+	}
+	#if defined _ALS_OnPlayerConnect
+		#undef OnPlayerConnect
+	#else
+		#define _ALS_OnPlayerConnect
+	#endif
+	#define OnPlayerConnect Iter_OnPlayerConnect
+	forward OnPlayerConnect(playerid);
+#endif
+#if !defined BOTSYNC_IS_BOT
+	public OnPlayerDisconnect(playerid, reason)
+	{
+		if(YSI_g_sCallbacks & 1) {
+			CallLocalFunction(YSI_gsOnPlayerDisconnect, "ii", playerid, reason);
+		}
+		SetTimerEx("Iter_OPDCInternal", 0, false, YSI_gsSpecifier@i, playerid);
+		return 1;
+	}
+	#if defined _ALS_OnPlayerDisconnect
+		#undef OnPlayerDisconnect
+	#else
+		#define _ALS_OnPlayerDisconnect
+	#endif
+	#define OnPlayerDisconnect Iter_OnPlayerDisconnect
+	forward OnPlayerDisconnect(playerid, reason);
+#endif
+#if !defined BOTSYNC_IS_BOT
+	public Iter_OPDCInternal(playerid)
+	{
+		if(IsPlayerConnected(playerid)) {
+			return;
+		}
+		#if defined _FOREACH_BOT
+			if(!IsPlayerNPC(playerid)) {
+				Iter_Remove(Player, playerid);
+			}
+			#if !defined FOREACH_NO_BOTS
+				else {
+					Iter_Remove(Bot, playerid);
+				}
+				#pragma tabsize 4
+				Iter_Remove(Character, playerid);
+			#endif
+		#else
+			Iter_Remove(Player, playerid);
+		#endif
+	}
+#endif
+#if FOREACH_I_Vehicle
+	stock Iter_CreateVehicle(modelid, Float:x, Float:y, Float:z, Float:angle, color1, color2, respawn_delay, addsiren = 0)
+	{
+		new
+			ret = CreateVehicle(modelid, x, y, z, angle, color1, color2, respawn_delay, !!addsiren);
+		if(ret != INVALID_VEHICLE_ID && ret != 0) {
+			Iter_Add(Vehicle, ret);
+		}
+		return ret;
+	}
+	#if defined _ALS_CreateVehicle
+		#undef CreateVehicle
+	#else
+		#define _ALS_CreateVehicle
+	#endif
+	#define CreateVehicle Iter_CreateVehicle
+	stock Iter_AddStaticVehicle(modelid, Float:x, Float:y, Float:z, Float:angle, color1, color2)
+	{
+		new
+			ret = AddStaticVehicle(modelid, x, y, z, angle, color1, color2);
+		if(ret != INVALID_VEHICLE_ID) {
+			Iter_Add(Vehicle, ret);
+		}
+		return ret;
+	}
+	#if defined _ALS_AddStaticVehicle
+		#undef AddStaticVehicle
+	#else
+		#define _ALS_AddStaticVehicle
+	#endif
+	#define AddStaticVehicle Iter_AddStaticVehicle
+	stock Iter_AddStaticVehicleEx(modelid, Float:x, Float:y, Float:z, Float:angle, color1, color2, respawn_delay, addsiren = 0)
+	{
+		new
+			ret = AddStaticVehicleEx(modelid, x, y, z, angle, color1, color2, respawn_delay, !!addsiren);
+		if(ret != INVALID_VEHICLE_ID) {
+			Iter_Add(Vehicle, ret);
+		}
+		return ret;
+	}
+	#if defined _ALS_AddStaticVehicleEx
+		#undef AddStaticVehicleEx
+	#else
+		#define _ALS_AddStaticVehicleEx
+	#endif
+	#define AddStaticVehicleEx Iter_AddStaticVehicleEx
+	stock DestroyVehicleSafe(&vehicleid)
+	{
+		new success = DestroyVehicle(vehicleid);
+		Iter_SafeRemove(Vehicle, vehicleid, vehicleid);
+		return success;
+	}
+	stock Iter_DestroyVehicle(vehicleid)
+	{
+		Iter_Remove(Vehicle, vehicleid);
+		return DestroyVehicle(vehicleid);
+	}
+	#if defined _ALS_DestroyVehicle
+		#undef DestroyVehicle
+	#else
+		#define _ALS_DestroyVehicle
+	#endif
+	#define DestroyVehicle Iter_DestroyVehicle
+#endif
+#if !defined BOTSYNC_IS_BOT
+	stock Iter_CreateActor(modelid, Float:x, Float:y, Float:z, Float:zAngle)
+	{
+		new
+			ret = CreateActor(modelid, x, y, z, zAngle);
+		if(ret != INVALID_ACTOR_ID) {
+			Iter_Add(Actor, ret);
+		}
+		return ret;
+	}
+	#if defined _ALS_CreateActor
+		#undef CreateActor
+	#else
+		#define _ALS_CreateActor
+	#endif
+	#define CreateActor Iter_CreateActor
+	stock DestroyActorSafe(&actorid)
+	{
+		new success = DestroyActor(actorid);
+		Iter_SafeRemove(Actor, actorid, actorid);
+		return success;
+	}
+	stock Iter_DestroyActor(actorid)
+	{
+		Iter_Remove(Actor, actorid);
+		return DestroyActor(actorid);
+	}
+	#if defined _ALS_DestroyActor
+		#undef DestroyActor
+	#else
+		#define _ALS_DestroyActor
+	#endif
+	#define DestroyActor Iter_DestroyActor
+#endif
+stock Iter_RandomInternal(count, const array[], size)
+{
+	if(count == 0) {
+		return ITER_NONE;
+	}
+	new
+		rnd = random(count),
+		cur = array[size];
+	while(cur != size) {
+		if(rnd-- == 0) {
+			return cur;
+		}
+		cur = array[cur];
+	}
+	return ITER_NONE;
+}
+stock Iter_FreeInternal(const array[], size)
+{
+	for(new i = 0; i != size; ++i) {
+		if(array[i] > size) {
+			return i;
+		}
+	}
+	return ITER_NONE;
+}
+stock Iter_AddInternal(&count, array[], value, size)
+{
+	if(0 <= value < size && array[value] > size) {
+		new
+			last = size,
+			next = array[last];
+		while(next < value) {
+			last = next;
+			next = array[last];
+		}
+		array[last] = value;
+		array[value] = next;
+		++count;
+		return 1;
+	}
+	return 0;
+}
+stock Iter_RemoveInternal(&count, array[], value, size)
+{
+	new
+		last;
+	return Iter_SafeRemoveInternal(count, array, value, last, size);
+}
+stock Iter_SafeRemoveInternal(&count, array[], value, &last, size)
+{
+	if(0 <= value < size && array[value] <= size) {
+		last = size;
+		new
+			next = array[last];
+		while(next < size) {
+			if(next == value) {
+				array[last] = array[value];
+				array[value] = size + 1;
+				--count;
+				return 1;
+			}
+			last = next;
+			next = array[last];
+		}
+	}
+	return 0;
+}
+stock Iter_ContainsInternal(const array[], value, size)
+{
+	return 0 <= value < size && array[value] <= size;
+}
+stock Iter_ClearInternal(&count, array[], size)
+{
+	for(new i = 0, t = size + 1; i < size; ++i) {
+		array[i] = t;
+	}
+	array[size] = size;
+	count = 0;
+}
+stock Iter_InitInternal(arr[][], s0, s1)
+{
+	for(new i = 0, t = s1 + 1; i < s0; ++i) {
+		for(new j = 0; j < s1; ++j) {
+			arr[i][j] = t;
+		}
+		arr[i][s1] = s1;
+	}
+}
+stock Iter_PrevInternal(array[], size, slot)
+{
+	if(0 <= slot <= size && array[slot] <= size) {
+		for(new last = slot; last--; ) {
+			if(array[last] == slot) {
+				return last;
+			}
+		}
+	}
+	return size;
+}
+#define Iter_Begin(%1) (_Y_ITER_ARRAY_SIZE(%1))
+#define Iter_Start Iter_Begin
+#define Iter_End(%1) (_Y_ITER_ARRAY_SIZE(%1))
+#define Iter_Finish Iter_End
+#define Iter_First(%1) (_Y_ITER_ARRAY:%1@YSII_Ag[_Y_ITER_ARRAY_SIZE(%1)])
+#define Iter_Last(%1) Iter_PrevInternal(_Y_ITER_ARRAY:%1@YSII_Ag,_Y_ITER_ARRAY_SIZE(%1),_Y_ITER_ARRAY_SIZE(%1))
+#define Iter_Next(%1,%2) (_Y_ITER_ARRAY:%1@YSII_Ag[(%2)])
+#define Iter_Prev(%1,%2) Iter_PrevInternal(_Y_ITER_ARRAY:%1@YSII_Ag,_Y_ITER_ARRAY_SIZE(%1),(%2))
+#define Iter_Previous Iter_Prev
+#define Iter_InternalArray(%1) (_Y_ITER_ARRAY:%1@YSII_Ag)
+#define _Y_ITER_INT_SIZE:%0(%2[%1]@YSII_Ag)) %0(%2@YSII_Ag[]))
+#define Iter_InternalSize(%1) (_:_Y_ITER_INT_SIZE:sizeof (%1@YSII_Ag))

formatex.inc

@@ -0,0 +1,427 @@
+#include <a_samp>
+#if defined FORMAT_EXTRA_TAGS
+	#define FORMAT_TAGS  _, PlayerText3D, Text, Text3D, Menu, DB, DBResult, File, Float, FORMAT_EXTRA_TAGS
+#else
+	#define FORMAT_TAGS  _, PlayerText3D, Text, Text3D, Menu, DB, DBResult, File, Float
+#endif
+#if !defined FORMAT_BUFFER_SIZE
+	#define FORMAT_BUFFER_SIZE  2048
+#endif
+#if !defined FORMAT_PRINT_BUFFER_SIZE
+	#define FORMAT_PRINT_BUFFER_SIZE 512
+#endif
+#if !defined FORMAT_CUSTOM_SPEC_BUFFER_SIZE
+	#define FORMAT_CUSTOM_SPEC_BUFFER_SIZE  512
+#endif
+#if !defined FORMAT_REPLACE_NATIVES
+	#define FORMAT_REPLACE_NATIVES true
+#endif
+#define FormatSpecifier<'%1'>(%2[%3],%4)  FMAT@1:F@%1(%2[FORMAT_CUSTOM_SPEC_BUFFER_SIZE],FMAT@2:___unused,%4)
+#define FMAT@2:___unused,%1[              %1[
+#define FMAT@1:%1(%2)                     forward %1(%2); public %1(%2)
+static stock
+	     gs_CustomFormatFunctions[127] = {-1, ...},
+	bool:gs_bIsInitialized = false
+;
+forward __fmt_funcinc();
+public __fmt_funcinc() {
+	new szOutput[1];
+	format(szOutput, 0, "");
+}
+static stock InitializeFormatSpecifiers() {
+	new
+		szFunctionName[4 char] = !"F@_",
+		iIndex,
+		iFunctionAddress
+	;
+	gs_bIsInitialized = true;
+	for (new c = '@'; c <= 'z'; c++) {
+		if (c == 'Z' + 1)
+			c = '_';
+		else if (c == '_' + 1)
+			c = 'a';
+		szFunctionName{2} = c;
+		if (-1 != (iIndex = funcidx(szFunctionName))) {
+			#emit LCTRL		   1
+			#emit NEG
+			#emit MOVE.alt
+			#emit ADD.C		   32
+			#emit STOR.S.pri   iFunctionAddress
+			#emit LREF.S.pri   iFunctionAddress
+			#emit ADD
+			#emit LOAD.S.alt   iIndex
+			#emit SHL.C.alt	   3
+			#emit ADD
+			#emit STOR.S.pri   iFunctionAddress
+			#emit LREF.S.pri   iFunctionAddress
+			#emit STOR.S.pri   iFunctionAddress
+			gs_CustomFormatFunctions[c] = iFunctionAddress;
+		}
+	}
+}
+stock formatex(szOutput[], iLength = sizeof(szOutput), const szFormatString[], {FORMAT_TAGS}:...) {
+	static
+		     s_szBuffer[FORMAT_BUFFER_SIZE],
+		bool:s_bIsInCustomSpecifier = false
+	;
+	if (s_bIsInCustomSpecifier) {
+		new
+			iNumArgs,
+			i
+		;
+		#emit LOAD.S.pri  8
+		#emit STOR.S.pri  iNumArgs
+		#emit SHR.C.pri   2
+		#emit STOR.S.pri  i
+		while (--i >= 0) {
+			#emit LOAD.S.pri  i
+			#emit SHL.C.pri   2
+			#emit ADD.C       12
+			#emit MOVE.alt
+			#emit LCTRL       5
+			#emit ADD
+			#emit LOAD.I
+			#emit PUSH.pri
+		}
+		#emit LOAD.S.pri  iNumArgs
+		#emit PUSH.pri
+		#emit MOVE.alt
+		#emit SYSREQ.C    format
+		#emit CONST.pri   4
+		#emit ADD
+		#emit MOVE.alt
+		#emit LCTRL       4
+		#emit ADD
+		#emit SCTRL       4
+	} else {
+		new
+			iPos = -1,
+			iArg = 12 + (3 * 4),
+			iArgCount,
+			iAddress,
+			iArgValue,
+			aiArgs[128],
+			i
+		;
+		if (!gs_bIsInitialized)
+			InitializeFormatSpecifiers();
+		iLength = min(FORMAT_BUFFER_SIZE, iLength);
+		s_szBuffer[0] = 0;
+		strunpack(s_szBuffer, szFormatString);
+		while (-1 != (iPos = strfind(s_szBuffer, !"%", _, ++iPos))) {
+			while (s_szBuffer[++iPos]) {
+				if (1 <= s_szBuffer[iPos] < sizeof(gs_CustomFormatFunctions) && gs_CustomFormatFunctions[s_szBuffer[iPos]] != -1) {
+					new
+						iFunc = gs_CustomFormatFunctions[s_szBuffer[iPos]]
+					;
+					static
+						s_szCustomFormatBuffer[FORMAT_CUSTOM_SPEC_BUFFER_SIZE]
+					;
+					strdel(s_szBuffer, iPos - 1, iPos + 1);
+					s_szCustomFormatBuffer[0] = 0;
+					#emit LCTRL       5
+					#emit LOAD.S.alt  iArg
+					#emit ADD
+					#emit LOAD.I
+					#emit MOVE.alt
+					#emit LOAD.I
+					#emit PUSH.pri
+					#emit PUSH.alt
+					iArg += 4;
+					s_bIsInCustomSpecifier = true;
+					#emit PUSH.C      s_szCustomFormatBuffer
+					#emit PUSH.C      12
+					#emit LCTRL       6
+					#emit ADD.C       28
+					#emit PUSH.pri
+					#emit LOAD.S.pri  iFunc
+					#emit SCTRL       6
+					s_bIsInCustomSpecifier = false;
+					strins(s_szBuffer, s_szCustomFormatBuffer, iPos - 1);
+					break;
+				}
+				switch (s_szBuffer[iPos]) {
+					case '*', 'i', 'd', 'x', 'h', 'c', 's', 'f', 'b', 'q': {
+						#emit LCTRL        5
+						#emit LOAD.S.alt  iArg
+						#emit ADD
+						#emit LOAD.I
+						#emit STOR.S.pri  iAddress
+						#emit MOVE.pri
+						#emit ADD.C       4
+						#emit STOR.S.pri  iArg
+						aiArgs[iArgCount++] = iAddress;
+						if (s_szBuffer[iPos] == '*')
+							continue;
+						break;
+					}
+					case 'u': {
+						new
+							szBuffer[11]
+						;
+						#emit LCTRL       5
+						#emit LOAD.S.alt  iArg
+						#emit ADD
+						#emit LOAD.I
+						#emit LOAD.I
+						#emit STOR.S.pri  iArgValue
+						#emit MOVE.pri
+						#emit ADD.C       4
+						#emit STOR.S.pri  iArg
+						strdel(s_szBuffer, iPos - 1, iPos + 1);
+						if (!iArgValue) {
+							strins(s_szBuffer, "0", iPos - 1);
+						} else {
+							new
+								j = sizeof(szBuffer) - 1
+							;
+							while (iArgValue) {
+								#emit ADDR.alt    szBuffer
+								#emit LOAD.S.pri  j
+								#emit DEC.pri
+								#emit STOR.S.pri  j
+								#emit IDXADDR
+								#emit PUSH.pri
+								#emit LOAD.S.pri  iArgValue
+								#emit CONST.alt   10
+								#emit UDIV
+								#emit STOR.S.pri  iArgValue
+								#emit CONST.pri   '0'
+								#emit ADD
+								#emit POP.alt
+								#emit STOR.I
+							}
+							strins(s_szBuffer, szBuffer[j], iPos - 1);
+						}
+					}
+					case '0' .. '9', ' ', '.':
+						continue;
+					case '%':
+						break;
+					default: {
+						break;
+					}
+				}
+			}
+		}
+		i = iArgCount;
+		while (--i >= 0) {
+			#emit ADDR.alt    aiArgs
+			#emit LOAD.S.pri  i
+			#emit LIDX
+			#emit PUSH.pri
+			#emit STOR.S.pri iAddress
+		}
+		#emit PUSH.C     s_szBuffer
+		#emit PUSH.S     iLength
+		#emit PUSH.S     szOutput
+		#emit LOAD.S.pri iArgCount
+		#emit SHL.C.pri  2
+		#emit ADD.C      12
+		#emit PUSH.pri
+		#emit MOVE.alt
+		#emit SYSREQ.C   format
+		#emit CONST.pri  4
+		#emit ADD
+		#emit MOVE.alt
+		#emit LCTRL      4
+		#emit ADD
+		#emit SCTRL      4
+	}
+	return 1;
+}
+stock printfex(const szFormatString[], {FORMAT_TAGS}:...) {
+	const
+		iBufferSize = FORMAT_PRINT_BUFFER_SIZE
+	;
+	static
+		s_szBuffer[FORMAT_PRINT_BUFFER_SIZE]
+	;
+	new
+		iNumArgs = numargs(),
+		i = iNumArgs - 1
+	;
+	while (--i >= 0) {
+		#emit LOAD.S.pri  i
+		#emit SHL.C.pri   2
+		#emit ADD.C       16
+		#emit MOVE.alt
+		#emit LCTRL       5
+		#emit ADD
+		#emit LOAD.I
+		#emit PUSH.pri
+	}
+	#emit PUSH.S      szFormatString
+	#emit PUSH.C      iBufferSize
+	#emit PUSH.C      s_szBuffer
+	#emit LOAD.S.pri  iNumArgs
+	#emit SHL.C.pri   2
+	#emit ADD.C       8
+	#emit PUSH.pri
+	#emit LCTRL       6
+	#emit ADD.C       28
+	#emit PUSH.pri
+	#emit CONST.pri   formatex
+	#emit SCTRL       6
+	print(s_szBuffer);
+}
+#if !defined FORMAT_NO_DEFAULT_SPECIFIERS
+#if !defined FORMAT_NO_DEFAULT_SPECIFIER_C
+FormatSpecifier<'C'>(output[], color) {
+	format(output, sizeof(output), "{%06x}", color >>> 8);
+}
+#endif
+#if !defined FORMAT_NO_DEFAULT_SPECIFIER_p
+FormatSpecifier<'p'>(output[], playerid) {
+	if (0 <= playerid < GetMaxPlayers() && IsPlayerConnected(playerid))
+		GetPlayerName(playerid, output, sizeof(output));
+	else
+		strcat(output, "<UNKNOWN>");
+}
+#endif
+#if !defined FORMAT_NO_DEFAULT_SPECIFIER_P
+FormatSpecifier<'P'>(output[], playerid) {
+	if (0 <= playerid < GetMaxPlayers() && IsPlayerConnected(playerid)) {
+		format(output, sizeof(output), "{%06x}", GetPlayerColor(playerid) >>> 8);
+		GetPlayerName(playerid, output[8], sizeof(output) - 8);
+	} else
+		strcat(output, "{FFFFFF}<UNKNOWN>");
+}
+#endif
+#if !defined FORMAT_NO_DEFAULT_SPECIFIER_W
+FormatSpecifier<'W'>(output[], weapon) {
+	static const
+		s_WeaponNames[][] = {
+			{!"Fists"          		}, {!"Brass Knuckles"   }, {!"Golf club"       		},
+			{!"Nightstick"     		}, {!"Knife"       		}, {!"Baseball Bat"         },
+			{!"Shovel"         		}, {!"Pool Cue"    		}, {!"Katana"         		},
+			{!"Chainsaw"       		}, {!"Purple Dildo"     }, {!"Dildo"       			},
+			{!"Vibrator"       		}, {!"Silver Vibrator"	}, {!"Flowers"        		},
+			{!"Cane"           		}, {!"Grenade"     		}, {!"Tear Gas"       		},
+			{!"Molotov Cocktail"	}, {!""            		}, {!""               		},
+			{!""               		}, {!"9mm"         		}, {!"Silenced 9mm"			},
+			{!"Desert Eagle"    	}, {!"Shotgun"     		}, {!"Sawnoff Shotgun"      },
+			{!"Combat Shotgun" 		}, {!"Micro Uzi"   		}, {!"MP5"            		},
+			{!"AK-47"          		}, {!"M4"          		}, {!"Tec-9"          		},
+			{!"Country Rifle"   	}, {!"Sniper Rifle"		}, {!"RPG" 					},
+			{!"HS Rocket"			}, {!"Flamethrower"		}, {!"Minigun"        		},
+			{!"Satchel Charge"  	}, {!"Detonator"   		}, {!"Spraycan"       		},
+			{!"Fire Extinguisher"	}, {!"Camera"      		}, {!"Nightvision Goggles"  },
+			{!"Thermal Goggles"     }, {!"Parachute"   		}, {!"Fake Pistol"    		},
+			{!""               		}, {!"Vehicle"     		}, {!"Helikill"       		},
+			{!"Explosion"      		}, {!""            		}, {!"Drown"          		},
+			{!"Collision"      		}, {!"Splat"       		}, {!"Unknown"        		}
+		}
+	;
+	if (0 <= weapon < sizeof(s_WeaponNames))
+		strcat(output, s_WeaponNames[weapon]);
+	else
+		strcat(output, "Unknown");
+}
+#endif
+#if !defined FORMAT_NO_DEFAULT_SPECIFIER_w
+FormatSpecifier<'w'>(output[], weapon) {
+	static const
+		s_WeaponNamesLowercaseSingular[][] = {
+			{!"fists"             	}, {!"brass knuckles"     }, {!"a golfclub"       },
+			{!"a nightstick"      	}, {!"a knife"       		}, {!"a baseball bat"            },
+			{!"a shovel"          	}, {!"a pool cue"    		}, {!"a katana"         },
+			{!"a chainsaw"        	}, {!"a purple dildo"     }, {!"a dildo"       },
+			{!"a vibrator"        	}, {!"a silver vibrator"  }, {!"flowers"          },
+			{!"a cane"            	}, {!"a grenade"     		}, {!"tear gas"          },
+			{!"a molotov cocktail"	}, {!""              		}, {!""                 },
+			{!""                  	}, {!"a 9mm"         		}, {!"a silenced 9mm"},
+			{!"a desert eagle"    	}, {!"a shotgun"     		}, {!"swanoff shotgun"         },
+			{!"a combat shotgun"  	}, {!"a micro uzi"      	}, {!"an mp5"           },
+			{!"an ak-47"          	}, {!"an m4"         		}, {!"a tec-9"          },
+			{!"a country rifle"   	}, {!"a sniper rifle"		}, {!"an rpg" },
+			{!"a hs rpg" 		  	}, {!"a flamethrower"		}, {!"a minigun"        },
+			{!"a satchel charge"  	}, {!"a detonator"   		}, {!"a spraycan"       },
+			{!"a fire extinguisher" }, {!"a camera"      		}, {!"nightvision"      },
+			{!"an infrared"       	}, {!"a parachute"   		}, {!"a fake pistol"    },
+			{!""                  	}, {!"a vehicle"     		}, {!"a helikill"       },
+			{!"an explosion"      	}, {!""              		}, {!"drowning"         },
+			{!"a collision"       	}, {!"a splat"       		}, {!"something unknown"}
+		}
+	;
+	if (0 <= weapon < sizeof(s_WeaponNamesLowercaseSingular))
+		strcat(output, s_WeaponNamesLowercaseSingular[weapon]);
+	else
+		strcat(output, "something unknown");
+}
+#endif
+#define FORMAT_NO_DEFAULT_SPECIFIER_v
+FormatSpecifier<'v'>(output[], modelid) {
+	static const
+		s_VehicleNames[][] = {
+			{!"Landstalker"      }, {!"Bravura"          }, {!"Buffalo"          }, {!"Linerunner"       },
+			{!"Perrenial"        }, {!"Sentinel"         }, {!"Dumper"           }, {!"Firetruck"        },
+			{!"Trashmaster"      }, {!"Stretch"          }, {!"Manana"           }, {!"Infernus"         },
+			{!"Voodoo"           }, {!"Pony"             }, {!"Mule"             }, {!"Cheetah"          },
+			{!"Ambulance"        }, {!"Leviathan"        }, {!"Moonbeam"         }, {!"Esperanto"        },
+			{!"Taxi"             }, {!"Washington"       }, {!"Bobcat"           }, {!"Mr Whoopee"       },
+			{!"BF Injection"     }, {!"Hunter"           }, {!"Premier"          }, {!"Enforcer"         },
+			{!"Securicar"        }, {!"Banshee"          }, {!"Predator"         }, {!"Bus"              },
+			{!"Rhino"            }, {!"Barracks"         }, {!"Hotknife"         }, {!"Trailer 1"        },
+			{!"Previon"          }, {!"Coach"            }, {!"Cabbie"           }, {!"Stallion"         },
+			{!"Rumpo"            }, {!"RC Bandit"        }, {!"Romero"           }, {!"Packer"           },
+			{!"Monster"          }, {!"Admiral"          }, {!"Squalo"           }, {!"Seasparrow"       },
+			{!"Pizzaboy"         }, {!"Tram"             }, {!"Trailer 2"        }, {!"Turismo"          },
+			{!"Speeder"          }, {!"Reefer"           }, {!"Tropic"           }, {!"Flatbed"          },
+			{!"Yankee"           }, {!"Caddy"            }, {!"Solair"           }, {!"Berkley's RC Van" },
+			{!"Skimmer"          }, {!"PCJ-600"          }, {!"Faggio"           }, {!"Freeway"          },
+			{!"RC Baron"         }, {!"RC Raider"        }, {!"Glendale"         }, {!"Oceanic"          },
+			{!"Sanchez"          }, {!"Sparrow"          }, {!"Patriot"          }, {!"Quad"             },
+			{!"Coastguard"       }, {!"Dinghy"           }, {!"Hermes"           }, {!"Sabre"            },
+			{!"Rustler"          }, {!"ZR-350"           }, {!"Walton"           }, {!"Regina"           },
+			{!"Comet"            }, {!"BMX"              }, {!"Burrito"          }, {!"Camper"           },
+			{!"Marquis"          }, {!"Baggage"          }, {!"Dozer"            }, {!"Maverick"         },
+			{!"News Chopper"     }, {!"Rancher"          }, {!"FBI Rancher"      }, {!"Virgo"            },
+			{!"Greenwood"        }, {!"Jetmax"           }, {!"Hotring"          }, {!"Sandking"         },
+			{!"Blista Compact"   }, {!"Police Maverick"  }, {!"Boxville"         }, {!"Benson"           },
+			{!"Mesa"             }, {!"RC Goblin"        }, {!"Hotring Racer A"  }, {!"Hotring Racer B"  },
+			{!"Bloodring Banger" }, {!"Rancher"          }, {!"Super GT"         }, {!"Elegant"          },
+			{!"Journey"          }, {!"Bike"             }, {!"Mountain Bike"    }, {!"Beagle"           },
+			{!"Cropdust"         }, {!"Stunt"            }, {!"Tanker"           }, {!"Roadtrain"        },
+			{!"Nebula"           }, {!"Majestic"         }, {!"Buccaneer"        }, {!"Shamal"           },
+			{!"Hydra"            }, {!"FCR-900"          }, {!"NRG-500"          }, {!"HPV1000"          },
+			{!"Cement Truck"     }, {!"Tow Truck"        }, {!"Fortune"          }, {!"Cadrona"          },
+			{!"FBI Truck"        }, {!"Willard"          }, {!"Forklift"         }, {!"Tractor"          },
+			{!"Combine"          }, {!"Feltzer"          }, {!"Remington"        }, {!"Slamvan"          },
+			{!"Blade"            }, {!"Freight"          }, {!"Streak"           }, {!"Vortex"           },
+			{!"Vincent"          }, {!"Bullet"           }, {!"Clover"           }, {!"Sadler"           },
+			{!"Firetruck LA"     }, {!"Hustler"          }, {!"Intruder"         }, {!"Primo"            },
+			{!"Cargobob"         }, {!"Tampa"            }, {!"Sunrise"          }, {!"Merit"            },
+			{!"Utility"          }, {!"Nevada"           }, {!"Yosemite"         }, {!"Windsor"          },
+			{!"Monster A"        }, {!"Monster B"        }, {!"Uranus"           }, {!"Jester"           },
+			{!"Sultan"           }, {!"Stratum"          }, {!"Elegy"            }, {!"Raindance"        },
+			{!"RC Tiger"         }, {!"Flash"            }, {!"Tahoma"           }, {!"Savanna"          },
+			{!"Bandito"          }, {!"Freight Flat"     }, {!"Streak Carriage"  }, {!"Kart"             },
+			{!"Mower"            }, {!"Duneride"         }, {!"Sweeper"          }, {!"Broadway"         },
+			{!"Tornado"          }, {!"AT-400"           }, {!"DFT-30"           }, {!"Huntley"          },
+			{!"Stafford"         }, {!"BF-400"           }, {!"Newsvan"          }, {!"Tug"              },
+			{!"Trailer 3"        }, {!"Emperor"          }, {!"Wayfarer"         }, {!"Euros"            },
+			{!"Hotdog"           }, {!"Club"             }, {!"Freight Carriage" }, {!"Trailer 3"        },
+			{!"Andromada"        }, {!"Dodo"             }, {!"RC Cam"           }, {!"Launch"           },
+			{!"Police Car (LSPD)"}, {!"Police Car (SFPD)"}, {!"Police Car (LVPD)"}, {!"Police Ranger"    },
+			{!"Picador"          }, {!"S.W.A.T. Van"     }, {!"Alpha"            }, {!"Phoenix"          },
+			{!"Glendale"         }, {!"Sadler"           }, {!"Luggage Trailer A"}, {!"Luggage Trailer B"},
+			{!"Stair Trailer"    }, {!"Boxville"         }, {!"Farm Plow"        }, {!"Utility Trailer"  }
+		}
+	;
+	if (0 <= (modelid -= 400) < sizeof(s_VehicleNames))
+		strcat(output, s_VehicleNames[modelid]);
+	else
+		strcat(output, "Unknown");
+}
+#endif
+#if !defined FORMAT_NO_DEFAULT_SPECIFIER_X
+FormatSpecifier<'X'>(output[], value) {
+	format(output, sizeof(output), "%02x%06x", value >>> 24, value & 0xFFFFFF);
+}
+#endif
+#endif
+#if FORMAT_REPLACE_NATIVES
+	#define format  formatex
+	#define printf  printfex
+#endif

logger.inc

@@ -0,0 +1,187 @@
+#if defined _inc_logger
+	#undef _inc_logger
+#endif
+#if defined _logger_included
+	#endinput
+#endif
+#define _logger_included
+#include <a_samp>
+#include <crashdetect>
+#if !defined MAX_EVENT_FIELDS
+	#define MAX_EVENT_FIELDS (32)
+#endif
+#if !defined MAX_FIELD_NAME
+	#define MAX_FIELD_NAME (16)
+#endif
+#if !defined MAX_FIELD_VALUE
+	#define MAX_FIELD_VALUE (256)
+#endif
+#define MAX_FIELD_LENGTH	(MAX_FIELD_NAME + 3 + MAX_FIELD_VALUE)
+#define MAX_EVENT_LENGTH	(MAX_EVENT_FIELDS * MAX_FIELD_LENGTH)
+forward LOGGER_FIELD:Logger_I(const field[], value);
+forward LOGGER_FIELD:Logger_B(const field[], value);
+forward LOGGER_FIELD:Logger_X(const field[], value);
+forward LOGGER_FIELD:Logger_F(const field[], Float:value);
+forward LOGGER_FIELD:Logger_S(const field[], const value[]);
+static
+	FieldBuffer[MAX_FIELD_LENGTH],
+	EventBuffer[MAX_EVENT_LENGTH];
+stock Logger_Log(const text[], LOGGER_FIELD:...) {
+	new total = numargs();
+	format(EventBuffer, sizeof EventBuffer, "lvl=\"info\" %s",
+		_:Logger_S("msg", text)
+	);
+	if (total == 1) {
+		print(EventBuffer);
+		return;
+	}
+	for(new arg = 1; arg < total && arg < MAX_EVENT_FIELDS; ++arg) {
+		new field[MAX_FIELD_LENGTH];
+		for(new ch; ch < MAX_FIELD_LENGTH; ++ch) {
+			field[ch] = getarg(arg, ch);
+			if(field[ch] == EOS) {
+				strcat(EventBuffer, " ");
+				strcat(EventBuffer, field);
+				break;
+			}
+		}
+	}
+	print(EventBuffer);
+}
+stock Logger_Dbg(const handler[], const text[], LOGGER_FIELD:...) {
+	if(GetSVarInt(handler) == 0) {
+		return;
+	}
+	new total = numargs();
+	format(EventBuffer, sizeof EventBuffer, "lvl=\"debug\" %s",
+		_:Logger_S("msg", text)
+	);
+	if (total == 2) {
+		print(EventBuffer);
+		return;
+	}
+	for(new arg = 2; arg < total && arg < MAX_EVENT_FIELDS; ++arg) {
+		new field[MAX_FIELD_LENGTH];
+		for(new ch; ch < MAX_FIELD_LENGTH; ++ch) {
+			field[ch] = getarg(arg, ch);
+			if(field[ch] == EOS) {
+				strcat(EventBuffer, " ");
+				strcat(EventBuffer, field);
+				break;
+			}
+		}
+	}
+	print(EventBuffer);
+}
+stock Logger_Err(const text[], LOGGER_FIELD:...) {
+	new total = numargs();
+	format(EventBuffer, sizeof EventBuffer, "lvl=\"error\" %s",
+		_:Logger_S("msg", text)
+	);
+	if (total == 1) {
+		_PrintBufferAmxBacktrace();
+		return;
+	}
+	for(new arg = 1; arg < total && arg < MAX_EVENT_FIELDS; ++arg) {
+		new field[MAX_FIELD_LENGTH];
+		for(new ch; ch < MAX_FIELD_LENGTH; ++ch) {
+			field[ch] = getarg(arg, ch);
+			if(field[ch] == EOS) {
+				strcat(EventBuffer, " ");
+				strcat(EventBuffer, field);
+				break;
+			}
+		}
+	}
+	_PrintBufferAmxBacktrace();
+}
+stock Logger_Fatal(const text[], LOGGER_FIELD:...) {
+	new total = numargs();
+	format(EventBuffer, sizeof EventBuffer, "lvl=\"fatal\" %s",
+		_:Logger_S("msg", text)
+	);
+	if (total == 1) {
+		_PrintBufferAmxBacktrace();
+		return;
+	}
+	for(new arg = 1; arg < total && arg < MAX_EVENT_FIELDS; ++arg) {
+		new field[MAX_FIELD_LENGTH];
+		for(new ch; ch < MAX_FIELD_LENGTH; ++ch) {
+			field[ch] = getarg(arg, ch);
+			if(field[ch] == EOS) {
+				strcat(EventBuffer, " ");
+				strcat(EventBuffer, field);
+				break;
+			}
+		}
+	}
+	_PrintBufferAmxBacktrace(true);
+}
+static stock _PrintBufferAmxBacktrace(bool:crash = false) {
+	print(EventBuffer);
+	PrintAmxBacktrace();
+	if(crash) {
+		new File:f = fopen("nonexistentfile", io_read), tmp[1];
+		fread(f, tmp);
+		fclose(f);
+	}
+}
+stock Logger_ToggleDebug(const handler[], bool:toggle) {
+	if(toggle) {
+		SetSVarInt(handler, 1);
+	} else {
+		DeleteSVar(handler);
+	}
+	return 1;
+}
+stock LOGGER_FIELD:Logger_I(const field[], value) {
+	format(FieldBuffer, sizeof(FieldBuffer), "%s=%d", field, value);
+	return LOGGER_FIELD:FieldBuffer;
+}
+stock LOGGER_FIELD:Logger_B(const field[], value) {
+	format(FieldBuffer, sizeof(FieldBuffer), "%s=%b", field, value);
+	return LOGGER_FIELD:FieldBuffer;
+}
+stock LOGGER_FIELD:Logger_X(const field[], value) {
+	format(FieldBuffer, sizeof(FieldBuffer), "%s=%x", field, value);
+	return LOGGER_FIELD:FieldBuffer;
+}
+stock LOGGER_FIELD:Logger_F(const field[], Float:value) {
+	format(FieldBuffer, sizeof(FieldBuffer), "%s=%f", field, value);
+	return LOGGER_FIELD:FieldBuffer;
+}
+stock LOGGER_FIELD:Logger_S(const field[], const value[]) {
+	new quoted[MAX_FIELD_VALUE];
+	Logger_EscapeQuote(value, MAX_FIELD_VALUE, quoted, MAX_FIELD_VALUE);
+	format(FieldBuffer, sizeof(FieldBuffer), "%s=\"%s\"", field, quoted);
+	return LOGGER_FIELD:FieldBuffer;
+}
+stock LOGGER_FIELD:Logger_A(const field[], const value[], len = sizeof value) {
+	new array[MAX_FIELD_VALUE];
+	format(array, sizeof array, "%d", array, value[0]);
+	for(new i = 1; i < len; i++) {
+		format(array, sizeof array, "%s, %d", array, value[i]);
+	}
+	format(FieldBuffer, sizeof(FieldBuffer), "%s=\"[%s]\"", field, array);
+	return LOGGER_FIELD:FieldBuffer;
+}
+stock LOGGER_FIELD:Logger_P(playerid) {
+	if(!IsPlayerConnected(playerid)) {
+		format(FieldBuffer, sizeof(FieldBuffer), "player=\"(disconnected)\"");
+	} else {
+		new name[MAX_PLAYER_NAME];
+		GetPlayerName(playerid, name, MAX_PLAYER_NAME);
+		format(FieldBuffer, sizeof(FieldBuffer), "player=\"%s\"", name);
+	}
+	return LOGGER_FIELD:FieldBuffer;
+}
+stock Logger_EscapeQuote(const input[], inputLen, output[], outputLen) {
+	new j;
+	for(new i; input[i] != EOS && i < inputLen && j < (outputLen - 1); ++i) {
+		if(input[i] == '"') {
+			output[j++] = '\\';
+		}
+		output[j++] = input[i];
+	}
+	output[j] = EOS;
+}

mapandreas.inc

@@ -0,0 +1,16 @@
+#define MAP_ANDREAS_MODE_NONE			0
+#define MAP_ANDREAS_MODE_MINIMAL		1
+#define MAP_ANDREAS_MODE_MEDIUM			2
+#define MAP_ANDREAS_MODE_FULL			3
+#define MAP_ANDREAS_MODE_NOBUFFER		4
+#define MAP_ANDREAS_ERROR_SUCCESS		0
+#define MAP_ANDREAS_ERROR_FAILURE		1
+#define MAP_ANDREAS_ERROR_MEMORY		2
+#define MAP_ANDREAS_ERROR_DATA_FILES	3
+#define MAP_ANDREAS_ERROR_INVALID_AREA	4
+native MapAndreas_Init(mode, name[]="", len=sizeof(name));
+native MapAndreas_FindZ_For2DCoord(Float:X, Float:Y, &Float:Z);
+native MapAndreas_FindAverageZ(Float:X, Float:Y, &Float:Z);
+native MapAndreas_Unload();
+native MapAndreas_SetZ_For2DCoord(Float:X, Float:Y, Float:Z);
+native MapAndreas_SaveCurrentHMap(name[]);

progress2.inc

@@ -0,0 +1,627 @@
+#if defined _inc_progress2
+	#undef _inc_progress2
+#endif
+#if defined _progress2_included
+	#endinput
+#endif
+#define _progress2_included
+#tryinclude <open.mp>
+#if !defined _INC_open_mp
+	#include <a_samp>
+	#if !defined PlayerTextDrawBoxColour
+		#define PlayerTextDrawBoxColour PlayerTextDrawBoxColor
+	#endif
+#endif
+#tryinclude <logger>
+#tryinclude <YSI_Data\y_iterate>
+#tryinclude <YSI_Coding\y_hooks>
+#if defined MAX_PLAYER_BARS
+	#if (MAX_PLAYER_BARS - PlayerBar:0)==PlayerBar:0
+		#error You forgot to set value of MAX_PLAYER_BARS. Type something like: #define MAX_PLAYER_BARS (PlayerBar:30).
+	#endif
+	#if (MAX_PLAYER_BARS < PlayerBar:1)
+		#error You are trying to allocate invalid number of PlayerBars. Set value of MAX_PLAYER_BARS greather than 0.
+	#elseif MAX_PLAYER_BARS > PlayerBar:(MAX_PLAYER_TEXT_DRAWS / 3)
+		#error You are trying to allocate too many PlayerBars. Set value of MAX_PLAYER_BARS below or equals to (MAX_PLAYER_TEXT_DRAWS/3).
+	#endif
+#else
+	#define MAX_PLAYER_BARS					(PlayerBar:(_:MAX_PLAYER_TEXT_DRAWS / 3))
+#endif
+#define INVALID_PLAYER_BAR_VALUE		(Float:0xFFFFFFFF)
+#define INVALID_PLAYER_BAR_ID			(PlayerBar:-1)
+enum progressbar_direction {
+	BAR_DIRECTION_RIGHT,
+	BAR_DIRECTION_LEFT,
+	BAR_DIRECTION_HORIZONTAL_FROM_0,
+	BAR_DIRECTION_UP,
+	BAR_DIRECTION_DOWN,
+	BAR_DIRECTION_VERTICAL_FROM_0,
+};
+enum E_BAR_DATA {
+	bool:is_created,
+	bool:pbar_show,
+	Float:pbar_posX,
+	Float:pbar_posY,
+	Float:pbar_width,
+	Float:pbar_height,
+	pbar_colour,
+	Float:pbar_minValue,
+	Float:pbar_maxValue,
+	Float:pbar_progressValue,
+	Float:E_PADDING_X,
+	Float:E_PADDING_Y,
+	progressbar_direction:pbar_direction
+}
+static const Float:direction_size_mult[] = {
+	1.0,
+	-1.0,
+	1.0,
+	-1.0,
+	1.0,
+	-1.0
+};
+enum E_BAR_TEXT_DRAW {
+	PlayerText:pbar_back,
+	PlayerText:pbar_fill,
+	PlayerText:pbar_main
+}
+enum E_PROGRESSBAR_BOUNDRY {
+	Float:E_PBAR_BACKGROUND_POS_X,
+	Float:E_PBAR_BACKGROUND_POS_Y,
+	Float:E_PBAR_BACKGROUND_RIGHT,
+	Float:E_PBAR_BACKGROUND_HEIGHT,
+	Float:E_PBAR_FILLER_POS_X,
+	Float:E_PBAR_FILLER_POS_Y,
+	Float:E_PBAR_FILLER_RIGHT,
+	Float:E_PBAR_FILLER_HEIGHT,
+	Float:E_PBAR_VALUE_POS_X,
+	Float:E_PBAR_VALUE_POS_Y,
+	Float:E_PBAR_VALUE_RIGHT,
+	Float:E_PBAR_VALUE_HEIGHT,
+};
+static PlayerText:pbar_TextDraw[MAX_PLAYERS][MAX_PLAYER_BARS][E_BAR_TEXT_DRAW];
+new
+	#if(defined _INC_y_iterate)
+		Iterator:pbar_Index[MAX_PLAYERS]<PlayerBar:(_:MAX_PLAYER_BARS)>,
+	#endif
+	pbar_Data[MAX_PLAYERS][MAX_PLAYER_BARS][E_BAR_DATA]
+;
+static bool:is_progressbar_initialised = false;
+stock PlayerBarUI_ResetPlayerItem(const playerid, const PlayerBar:barid) {
+	pbar_TextDraw[playerid][barid][pbar_back] = PlayerText:INVALID_TEXT_DRAW;
+	pbar_TextDraw[playerid][barid][pbar_fill] = PlayerText:INVALID_TEXT_DRAW;
+	pbar_TextDraw[playerid][barid][pbar_main] = PlayerText:INVALID_TEXT_DRAW;
+	pbar_Data[playerid][barid][is_created] = false;
+}
+stock PlayerBarUI_ResetPlayer(const playerid) {
+	for(new PlayerBar:barid = PlayerBar:0; barid < MAX_PLAYER_BARS; ++barid) {
+		PlayerBarUI_ResetPlayerItem(playerid, barid);
+	}
+}
+stock PlayerBarUI_ResetAll() {
+	for(new playerid = 0; playerid < MAX_PLAYERS; ++playerid) {
+		PlayerBarUI_ResetPlayer(playerid);
+	}
+	is_progressbar_initialised = true;
+}
+stock PlayerBar:PlayerBarUI_FindFree(const playerid) {
+	for(new PlayerBar:barid = PlayerBar:0; barid < MAX_PLAYER_BARS; ++barid) {
+		if( !pbar_Data[playerid][barid][is_created] ) {
+			return barid;
+		}
+	}
+	return INVALID_PLAYER_BAR_ID;
+}
+static stock bool:PlayerBarUI_isNeedToDrawValue(const progressbar_direction:direction, const Float:cur_value, const Float:min_value, const Float:max_value) {
+	if( direction == BAR_DIRECTION_HORIZONTAL_FROM_0 || direction == BAR_DIRECTION_VERTICAL_FROM_0 ) {
+		if( max_value < 0.0 ) {
+			return (cur_value < max_value);
+		} else if( min_value > 0.0 ) {
+			return (cur_value > min_value);
+		} else {
+			return (floatabs(cur_value) > 0.001 * (max_value - min_value));
+		}
+	} else {
+		return (cur_value > min_value);
+	}
+}
+forward PlayerBar:CreatePlayerProgressBar(
+	const playerid,
+	const Float:x, const Float:y,
+	const Float:width = 55.5, const Float:height = 3.2,
+	const colour = 0xFF1C1CFF,
+	const Float:max = 100.0,
+	const progressbar_direction:direction = BAR_DIRECTION_RIGHT
+);
+forward Float:GetPlayerProgressBarValue(const playerid, const PlayerBar:barid);
+stock PlayerBar:CreatePlayerProgressBar(
+	const playerid,
+	const Float:x, const Float:y,
+	const Float:width = 55.5, const Float:height = 3.2,
+	const colour = 0xFF1C1CFF,
+	const Float:max = 100.0,
+	const progressbar_direction:direction = BAR_DIRECTION_RIGHT
+) {
+	if( !IsPlayerConnected(playerid) ) {
+		#if(defined _logger_included)
+		Logger_Err("attempt to create player progress bar for invalid player",
+			Logger_I("playerid", playerid));
+		#endif
+		return INVALID_PLAYER_BAR_ID;
+	}
+	if( !is_progressbar_initialised ) {
+		PlayerBarUI_ResetAll();
+	}
+	#if(defined _INC_y_iterate)
+	new PlayerBar:barid = PlayerBar:Iter_Free(pbar_Index[playerid]);
+	if( barid == PlayerBar:ITER_NONE ) {
+		#if(defined _logger_included)
+		Logger_Err("MAX_PLAYER_BARS limit reached.");
+		#endif
+		return INVALID_PLAYER_BAR_ID;
+	}
+	#else
+	new PlayerBar:barid = PlayerBarUI_FindFree(playerid);
+	if( barid == INVALID_PLAYER_BAR_ID ) {
+		#if(defined _logger_included)
+		Logger_Err("MAX_PLAYER_BARS limit reached.");
+		#endif
+		return INVALID_PLAYER_BAR_ID;
+	}
+	#endif
+	pbar_TextDraw[playerid][barid][pbar_back] = PlayerText:INVALID_TEXT_DRAW;
+	pbar_TextDraw[playerid][barid][pbar_fill] = PlayerText:INVALID_TEXT_DRAW;
+	pbar_TextDraw[playerid][barid][pbar_main] = PlayerText:INVALID_TEXT_DRAW;
+	pbar_Data[playerid][barid][is_created] = true;
+	pbar_Data[playerid][barid][pbar_show] = false;
+	pbar_Data[playerid][barid][pbar_posX] = x;
+	pbar_Data[playerid][barid][pbar_posY] = y;
+	pbar_Data[playerid][barid][pbar_width] = width;
+	pbar_Data[playerid][barid][pbar_height] = height;
+	pbar_Data[playerid][barid][pbar_colour] = colour;
+	pbar_Data[playerid][barid][pbar_minValue] = 0.0;
+	pbar_Data[playerid][barid][pbar_maxValue] = max;
+	pbar_Data[playerid][barid][pbar_progressValue] = 0.0;
+	pbar_Data[playerid][barid][pbar_direction] = direction;
+	pbar_Data[playerid][barid][E_PADDING_X] = 1.2;
+	pbar_Data[playerid][barid][E_PADDING_Y] = 1.0;
+	#if(defined _INC_y_iterate)
+	Iter_Add(pbar_Index[playerid], barid);
+	#endif
+	_progress2_renderBar(playerid, barid);
+	return barid;
+}
+stock DestroyPlayerProgressBar(const playerid, const PlayerBar:barid) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	_ptextdraw_destroy_array(playerid, pbar_TextDraw[playerid][barid]);
+	pbar_Data[playerid][barid][is_created] = false;
+	#if(defined _INC_y_iterate)
+	Iter_Remove(pbar_Index[playerid], barid);
+	#endif
+	return 1;
+}
+stock bool:IsPlayerProgressBarVisible(const playerid, const PlayerBar:barid) {
+	return (IsValidPlayerProgressBar(playerid, barid) && pbar_Data[playerid][barid][pbar_show]);
+}
+stock ShowPlayerProgressBar(const playerid, const PlayerBar:barid) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	pbar_Data[playerid][barid][pbar_show] = true;
+	PlayerTextDrawShow(playerid, pbar_TextDraw[playerid][barid][pbar_back]);
+	PlayerTextDrawShow(playerid, pbar_TextDraw[playerid][barid][pbar_fill]);
+	PlayerTextDrawShow(playerid, pbar_TextDraw[playerid][barid][pbar_main]);
+	return 1;
+}
+stock HidePlayerProgressBar(const playerid, const PlayerBar:barid) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	pbar_Data[playerid][barid][pbar_show] = false;
+	PlayerTextDrawHide(playerid, pbar_TextDraw[playerid][barid][pbar_back]);
+	PlayerTextDrawHide(playerid, pbar_TextDraw[playerid][barid][pbar_fill]);
+	PlayerTextDrawHide(playerid, pbar_TextDraw[playerid][barid][pbar_main]);
+	return 1;
+}
+stock IsValidPlayerProgressBar(const playerid, const PlayerBar:barid) {
+	#if(defined _INC_y_iterate)
+		return Iter_Contains(pbar_Index[playerid], barid);
+	#else
+		if( INVALID_PLAYER_BAR_ID < barid && barid < MAX_PLAYER_BARS ) {
+			return pbar_Data[playerid][barid][is_created];
+		}
+		return false;
+	#endif
+}
+stock GetPlayerProgressBarPos(const playerid, const PlayerBar:barid, &Float:x, &Float:y) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	x = pbar_Data[playerid][barid][pbar_posX];
+	y = pbar_Data[playerid][barid][pbar_posY];
+	return 1;
+}
+stock SetPlayerProgressBarPos(const playerid, const PlayerBar:barid, const Float:x, const Float:y) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return false;
+	}
+	pbar_Data[playerid][barid][pbar_posX] = x;
+	pbar_Data[playerid][barid][pbar_posY] = y;
+	_progress2_renderBar(playerid, barid);
+	return true;
+}
+stock Float:GetPlayerProgressBarWidth(const playerid, const PlayerBar:barid) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return INVALID_PLAYER_BAR_VALUE;
+	}
+	return pbar_Data[playerid][barid][pbar_width];
+}
+stock SetPlayerProgressBarWidth(const playerid, const PlayerBar:barid, const Float:width) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	pbar_Data[playerid][barid][pbar_width] = width;
+	_progress2_renderBar(playerid, barid);
+	return 1;
+}
+stock Float:GetPlayerProgressBarHeight(const playerid, const PlayerBar:barid) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return INVALID_PLAYER_BAR_VALUE;
+	}
+	return pbar_Data[playerid][barid][pbar_height];
+}
+stock SetPlayerProgressBarHeight(const playerid, const PlayerBar:barid, const Float:height) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	pbar_Data[playerid][barid][pbar_height] = height;
+	_progress2_renderBar(playerid, barid);
+	return 1;
+}
+stock GetPlayerProgressBarColour(const playerid, const PlayerBar:barid) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	return pbar_Data[playerid][barid][pbar_colour];
+}
+stock SetPlayerProgressBarColour(const playerid, const PlayerBar:barid, const colour) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	pbar_Data[playerid][barid][pbar_colour] = colour;
+	PlayerTextDrawBoxColour(playerid, pbar_TextDraw[playerid][barid][pbar_back], 0x00000000 | (colour & 0x000000FF));
+	PlayerTextDrawBoxColour(playerid, pbar_TextDraw[playerid][barid][pbar_fill], (colour & 0xFFFFFF00) | (0x66 & ((colour & 0x000000FF) / 2)));
+	PlayerTextDrawBoxColour(playerid, pbar_TextDraw[playerid][barid][pbar_main], colour);
+	return 1;
+}
+stock Float:GetPlayerProgressBarMinValue(const playerid, const PlayerBar:barid) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return INVALID_PLAYER_BAR_VALUE;
+	}
+	return pbar_Data[playerid][barid][pbar_minValue];
+}
+stock SetPlayerProgressBarMinValue(const playerid, const PlayerBar:barid, const Float:min_value) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	pbar_Data[playerid][barid][pbar_minValue] = min_value;
+	SetPlayerProgressBarValue(playerid, barid, pbar_Data[playerid][barid][pbar_progressValue]);
+	return 1;
+}
+stock Float:GetPlayerProgressBarMaxValue(const playerid, const PlayerBar:barid) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return INVALID_PLAYER_BAR_VALUE;
+	}
+	return pbar_Data[playerid][barid][pbar_maxValue];
+}
+stock SetPlayerProgressBarMaxValue(const playerid, const PlayerBar:barid, const Float:max) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	pbar_Data[playerid][barid][pbar_maxValue] = max;
+	SetPlayerProgressBarValue(playerid, barid, pbar_Data[playerid][barid][pbar_progressValue]);
+	return 1;
+}
+stock SetPlayerProgressBarValue(const playerid, const PlayerBar:barid, Float:value) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	new
+		boundary[E_PROGRESSBAR_BOUNDRY],
+		Float:min_value = pbar_Data[playerid][barid][pbar_minValue],
+		Float:max_value = pbar_Data[playerid][barid][pbar_maxValue],
+		progressbar_direction:direction = pbar_Data[playerid][barid][pbar_direction],
+		bool:draw_main,
+		color = pbar_Data[playerid][barid][pbar_colour],
+		PlayerText:ptd_main = pbar_TextDraw[playerid][barid][pbar_main]
+	;
+	if( value < min_value ) {
+		value = min_value;
+	} else if( value > max_value ) {
+		value = max_value;
+	}
+	pbar_Data[playerid][barid][pbar_progressValue] = value;
+	draw_main = PlayerBarUI_isNeedToDrawValue(direction, value, min_value, max_value);
+	PlayerBarUI_computeBoundry(playerid, barid, boundary);
+	#if defined PlayerTextDrawSetPos
+	{
+		PlayerTextDrawSetPos(playerid, ptd_main, boundary[E_PBAR_VALUE_POS_X], boundary[E_PBAR_VALUE_POS_Y]);
+		PlayerTextDrawTextSize(playerid, ptd_main, boundary[E_PBAR_VALUE_RIGHT], 0.0);
+		PlayerTextDrawLetterSize(playerid, ptd_main, 1.0, boundary[E_PBAR_VALUE_HEIGHT]);
+		PlayerTextDrawUseBox(playerid, ptd_main, draw_main);
+	}
+	#else
+	{
+		PlayerTextDrawDestroy(playerid, ptd_main);
+		ptd_main = CreatePlayerTextDraw(
+			playerid,
+			boundary[E_PBAR_VALUE_POS_X],
+			boundary[E_PBAR_VALUE_POS_Y],
+			"_"
+		);
+		new PlayerText:ptd_back = pbar_TextDraw[playerid][barid][pbar_back],
+			PlayerText:ptd_fill = pbar_TextDraw[playerid][barid][pbar_fill]
+		;
+		if(
+			(ptd_fill != PlayerText:INVALID_TEXT_DRAW && ptd_fill < ptd_main) ||
+			(ptd_back != PlayerText:INVALID_TEXT_DRAW && ptd_back < ptd_main)
+		) {
+			PlayerTextDrawTextSize(playerid, ptd_main, boundary[E_PBAR_VALUE_RIGHT], 0.0);
+			PlayerTextDrawLetterSize(playerid, ptd_main, 1.0, boundary[E_PBAR_VALUE_HEIGHT]);
+			PlayerTextDrawUseBox(playerid, ptd_main, draw_main);
+			pbar_TextDraw[playerid][barid][pbar_main] = ptd_main;
+		} else {
+			PlayerTextDrawDestroy(playerid, ptd_back);
+			PlayerTextDrawDestroy(playerid, ptd_fill);
+			PlayerTextDrawDestroy(playerid, ptd_main);
+			PlayerBarUI_createGeometry(playerid, barid, boundary, color, draw_main);
+		}
+	}
+	#endif
+	SetPlayerProgressBarColour(playerid, barid, color);
+	if( pbar_Data[playerid][barid][pbar_show] ) {
+		ShowPlayerProgressBar(playerid, barid);
+	}
+	return 1;
+}
+stock Float:GetPlayerProgressBarValue(const playerid, const PlayerBar:barid) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return INVALID_PLAYER_BAR_VALUE;
+	}
+	return pbar_Data[playerid][barid][pbar_progressValue];
+}
+stock progressbar_direction:GetPlayerProgressBarDirection(const playerid, const PlayerBar:barid) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return progressbar_direction:BAR_DIRECTION_RIGHT;
+	}
+	return pbar_Data[playerid][barid][pbar_direction];
+}
+stock SetPlayerProgressBarDirection(const playerid, const PlayerBar:barid, const progressbar_direction:direction) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	pbar_Data[playerid][barid][pbar_direction] = direction;
+	_progress2_renderBar(playerid, barid);
+	return 1;
+}
+stock GetPlayerProgressBarPadding(const playerid, const PlayerBar:barid, &Float:padding_x, &Float:padding_y) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	padding_x = pbar_Data[playerid][barid][E_PADDING_X];
+	padding_y = pbar_Data[playerid][barid][E_PADDING_Y];
+	return 1;
+}
+stock SetPlayerProgressBarPadding(const playerid, const PlayerBar:barid, const Float:padding_x, const Float:padding_y) {
+	if( !IsValidPlayerProgressBar(playerid, barid) ) {
+		return 0;
+	}
+	pbar_Data[playerid][barid][E_PADDING_X] = padding_x;
+	pbar_Data[playerid][barid][E_PADDING_Y] = padding_y;
+	_progress2_renderBar(playerid, barid);
+	return 1;
+}
+static PlayerBarUI_createGeometry(const playerid, const PlayerBar:barid, const boundary[E_PROGRESSBAR_BOUNDRY], const color, const bool:draw_main) {
+	new PlayerText:ptd_back, PlayerText:ptd_fill, PlayerText:ptd_main;
+	ptd_back = CreatePlayerTextDraw(playerid, boundary[E_PBAR_BACKGROUND_POS_X], boundary[E_PBAR_BACKGROUND_POS_Y], "_");
+	PlayerTextDrawTextSize		(playerid, ptd_back, boundary[E_PBAR_BACKGROUND_RIGHT], 0.0);
+	PlayerTextDrawLetterSize	(playerid, ptd_back, 1.0, boundary[E_PBAR_BACKGROUND_HEIGHT]);
+	PlayerTextDrawUseBox		(playerid, ptd_back, true);
+	ptd_fill = CreatePlayerTextDraw(playerid, boundary[E_PBAR_FILLER_POS_X], boundary[E_PBAR_FILLER_POS_Y], "_");
+	PlayerTextDrawTextSize		(playerid, ptd_fill, boundary[E_PBAR_FILLER_RIGHT], 0.0);
+	PlayerTextDrawLetterSize	(playerid, ptd_fill, 1.0, boundary[E_PBAR_FILLER_HEIGHT]);
+	PlayerTextDrawUseBox		(playerid, ptd_fill, true);
+	ptd_main = CreatePlayerTextDraw(playerid, boundary[E_PBAR_VALUE_POS_X], boundary[E_PBAR_VALUE_POS_Y], "_");
+	PlayerTextDrawTextSize(playerid, ptd_main, boundary[E_PBAR_VALUE_RIGHT], 0.0);
+	PlayerTextDrawLetterSize(playerid, ptd_main, 1.0, boundary[E_PBAR_VALUE_HEIGHT]);
+	PlayerTextDrawUseBox		(playerid, ptd_main, draw_main);
+	pbar_TextDraw[playerid][barid][pbar_back] = ptd_back;
+	pbar_TextDraw[playerid][barid][pbar_fill] = ptd_fill;
+	pbar_TextDraw[playerid][barid][pbar_main] = ptd_main;
+	SetPlayerProgressBarColour(playerid, barid, color);
+}
+_progress2_renderBar(const playerid, const PlayerBar:barid) {
+	if(
+		!IsPlayerConnected(playerid) ||
+		!IsValidPlayerProgressBar(playerid, barid)
+	) {
+		return false;
+	}
+	new
+		PlayerText:old_textdraw_array[E_BAR_TEXT_DRAW],
+		boundary[E_PROGRESSBAR_BOUNDRY],
+		Float:min_value = pbar_Data[playerid][barid][pbar_minValue],
+		Float:max_value = pbar_Data[playerid][barid][pbar_maxValue],
+		Float:cur_value = pbar_Data[playerid][barid][pbar_progressValue],
+		progressbar_direction:direction = pbar_Data[playerid][barid][pbar_direction],
+		bool:draw_main,
+		color = pbar_Data[playerid][barid][pbar_colour],
+		PlayerText:ptd_back,
+		PlayerText:ptd_fill,
+		PlayerText:ptd_main
+	;
+	old_textdraw_array = pbar_TextDraw[playerid][barid];
+	_ptextdraw_destroy_array(playerid, old_textdraw_array);
+	draw_main = PlayerBarUI_isNeedToDrawValue(direction, cur_value, min_value, max_value);
+	PlayerBarUI_computeBoundry(playerid, barid, boundary);
+	PlayerBarUI_createGeometry(playerid, barid, boundary, color, draw_main);
+	ptd_back = pbar_TextDraw[playerid][barid][pbar_main];
+	ptd_fill = pbar_TextDraw[playerid][barid][pbar_fill];
+	ptd_main = pbar_TextDraw[playerid][barid][pbar_back];
+	{
+		new E_BAR_TEXT_DRAW:td_slot_old,
+			E_BAR_TEXT_DRAW:td_slot_new,
+			PlayerText:old_textdraw_item
+		;
+		for(td_slot_old = E_BAR_TEXT_DRAW:0; td_slot_old < E_BAR_TEXT_DRAW:sizeof(old_textdraw_array); ++td_slot_old) {
+			old_textdraw_item = old_textdraw_array[td_slot_old];
+			for(td_slot_new = E_BAR_TEXT_DRAW:0; td_slot_new < E_BAR_TEXT_DRAW:sizeof(old_textdraw_array); ++td_slot_new) {
+				if(
+					old_textdraw_item != ptd_back &&
+					old_textdraw_item != ptd_fill &&
+					old_textdraw_item != ptd_main
+				) {
+					PlayerTextDrawHide(playerid, old_textdraw_item);
+				}
+			}
+		}
+	}
+	if( pbar_Data[playerid][barid][pbar_show] ) {
+		ShowPlayerProgressBar(playerid, barid);
+	}
+	return true;
+}
+#if(defined _INC_y_hooks)
+hook OnScriptInit() {
+	PlayerBarUI_ResetAll();
+	#if(defined _INC_y_iterate)
+	Iter_Init(pbar_Index);
+	#endif
+}
+hook OnPlayerDisconnect(playerid, reason) {
+	#if(defined _INC_y_iterate)
+	Iter_Clear(pbar_Index[playerid]);
+	#endif
+}
+hook OnScriptExit() {
+	for(new i = 0; i < MAX_PLAYERS; i++) {
+		if( IsPlayerConnected(i) ) {
+			DestroyAllPlayerProgressBars(i);
+		}
+	}
+}
+#endif
+stock DestroyAllPlayerProgressBars(const playerid) {
+	for(new PlayerBar:i = PlayerBar:0; i < MAX_PLAYER_BARS; i++) {
+		DestroyPlayerProgressBar(playerid, i);
+	}
+	return 1;
+}
+static stock bar_getRatios(const progressbar_direction:direction, const Float:cur_value, const Float:min_value, const Float:max_value, &Float:ratio_from, &Float:ratio_to) {
+	new Float:range_value = max_value - min_value;
+	if( direction == BAR_DIRECTION_HORIZONTAL_FROM_0 || direction == BAR_DIRECTION_VERTICAL_FROM_0 ) {
+		if( max_value < 0.0 ) {
+			ratio_from = 1.0;
+		} else if( min_value > 0.0 ) {
+			ratio_from = 0.0;
+		} else {
+			ratio_from = -min_value / range_value;
+		}
+	} else {
+		ratio_from = 0.0;
+	}
+	ratio_to = (cur_value - min_value) / range_value;
+}
+static stock _ptextdraw_destroy_array(const playerid, const PlayerText:ptd_array[E_BAR_TEXT_DRAW]) {
+	for(new E_BAR_TEXT_DRAW:ptd_slot = E_BAR_TEXT_DRAW:0; ptd_slot < E_BAR_TEXT_DRAW:3; ++ptd_slot) {
+		PlayerTextDrawDestroy(playerid, ptd_array[ptd_slot]);
+	}
+}
+static stock _normalise_range_f(&Float:value_a, &Float:value_b) {
+	if( value_a > value_b ) {
+		new Float:temp_value = value_b;
+		value_b = value_a;
+		value_a = temp_value;
+	}
+}
+static stock PlayerBarUI_computeBoundry(const playerid, const PlayerBar:barid, boundary[E_PROGRESSBAR_BOUNDRY]) {
+	new
+		Float:pos_x, Float:pos_y,
+		Float:padding_x, Float:padding_y,
+		Float:width = pbar_Data[playerid][barid][pbar_width],
+		Float:height = pbar_Data[playerid][barid][pbar_height],
+		Float:min_value = pbar_Data[playerid][barid][pbar_minValue],
+		Float:max_value = pbar_Data[playerid][barid][pbar_maxValue],
+		Float:cur_value = pbar_Data[playerid][barid][pbar_progressValue],
+		progressbar_direction:direction = pbar_Data[playerid][barid][pbar_direction],
+		Float:outer_pos_x2, Float:outer_pos_y2,
+		Float:inner_pos_x1, Float:inner_pos_y1,
+		Float:inner_pos_x2, Float:inner_pos_y2,
+		Float:inner_size_x, Float:inner_size_y,
+		Float:value_pos_x1, Float:value_pos_y1,
+		Float:value_pos_x2, Float:value_pos_y2,
+		Float:size_multiplier = direction_size_mult[direction],
+		bool:is_vertical = (direction > BAR_DIRECTION_HORIZONTAL_FROM_0),
+		Float:ratio_from, Float:ratio_to
+	;
+	GetPlayerProgressBarPos(playerid, barid, pos_x, pos_y);
+	GetPlayerProgressBarPadding(playerid, barid, padding_x, padding_y);
+	outer_pos_x2 = pos_x + width;
+	outer_pos_y2 = pos_y + height;
+	inner_pos_x1 = pos_x + padding_x;
+	inner_pos_x2 = outer_pos_x2 - padding_x;
+	inner_pos_y1 = pos_y + padding_y;
+	inner_pos_y2 = outer_pos_y2 - padding_y;
+	inner_size_x = inner_pos_x2 - inner_pos_x1;
+	inner_size_y = inner_pos_y2 - inner_pos_y1;
+	bar_getRatios(direction, cur_value, min_value, max_value, ratio_from, ratio_to);
+	ratio_from *= size_multiplier;
+	ratio_to *= size_multiplier;
+	if( is_vertical ) {
+		value_pos_x1 = inner_pos_x1;
+		value_pos_x2 = inner_pos_x2;
+	} else {
+		value_pos_y1 = inner_pos_y1;
+		value_pos_y2 = inner_pos_y2;
+	}
+	switch(direction) {
+		case BAR_DIRECTION_RIGHT:				{ value_pos_x1 = inner_pos_x1; }
+		case BAR_DIRECTION_LEFT:				{ value_pos_x1 = inner_pos_x2; }
+		case BAR_DIRECTION_HORIZONTAL_FROM_0:	{ value_pos_x1 = inner_pos_x1; }
+		case BAR_DIRECTION_UP:					{ value_pos_y1 = inner_pos_y2; }
+		case BAR_DIRECTION_DOWN:				{ value_pos_y1 = inner_pos_y1; }
+		case BAR_DIRECTION_VERTICAL_FROM_0:		{ value_pos_y1 = inner_pos_y2; }
+	}
+	if( is_vertical ) {
+		value_pos_y2 = value_pos_y1;
+		value_pos_y1 += inner_size_y * ratio_from;
+		value_pos_y2 += inner_size_y * ratio_to;
+	} else {
+		value_pos_x2 = value_pos_x1;
+		value_pos_x1 += inner_size_x * ratio_from;
+		value_pos_x2 += inner_size_x * ratio_to;
+	}
+	{
+		_normalise_range_f(value_pos_x1, value_pos_x2);
+		_normalise_range_f(value_pos_y1, value_pos_y2);
+	}
+	new Float:correction_x = 1.25;
+	value_pos_x1 += correction_x;
+	value_pos_x2 -= correction_x;
+	inner_pos_x1 += correction_x;
+	inner_pos_x2 -= correction_x;
+	boundary[E_PBAR_BACKGROUND_POS_X] = pos_x;
+	boundary[E_PBAR_BACKGROUND_POS_Y] = pos_y;
+	boundary[E_PBAR_BACKGROUND_RIGHT] = outer_pos_x2;
+	boundary[E_PBAR_BACKGROUND_HEIGHT] = 0.1 * (outer_pos_y2 - pos_y);
+	boundary[E_PBAR_FILLER_POS_X] = inner_pos_x1;
+	boundary[E_PBAR_FILLER_POS_Y] = inner_pos_y1;
+	boundary[E_PBAR_FILLER_RIGHT] = inner_pos_x2;
+	boundary[E_PBAR_FILLER_HEIGHT] = 0.1 * (inner_pos_y2 - inner_pos_y1);
+	boundary[E_PBAR_VALUE_POS_X] = value_pos_x1;
+	boundary[E_PBAR_VALUE_POS_Y] = value_pos_y1;
+	boundary[E_PBAR_VALUE_RIGHT] = value_pos_x2;
+	boundary[E_PBAR_VALUE_HEIGHT] = 0.1 * (value_pos_y2 - value_pos_y1);
+}

samp_logger_version.inc

@@ -0,0 +1,3 @@
+#define SAMP_LOGGER_VERSION_MAJOR (1)
+#define SAMP_LOGGER_VERSION_MINOR (3)
+#define SAMP_LOGGER_VERSION_PATCH (1)

sscanf2.inc

@@ -0,0 +1,793 @@
+#if defined _INC_SSCANF
+	#endinput
+#endif
+#define _INC_SSCANF
+#if !defined _samp_included
+	#error Please include <a_npc> or <a_samp> first.
+#endif
+#define SSCANF_STATIC__
+#if defined __PawnBuild
+	#if __PawnBuild == 11
+		#undef SSCANF_STATIC__
+		#define SSCANF_STATIC__ static
+	#endif
+#else
+	#if !defined SSCANF_NO_NICE_FEATURES
+		#error sscanf utilises community compiler features.  Use `#define SSCANF_NO_NICE_FEATURES` to live without (if you can call that living) or better yet download it here: github.com/pawn-lang/compiler/releases
+	#endif
+#endif
+#if defined GetDistanceFromMeToPoint
+	static stock SSCANF_NPC = 1;
+	#define SSCANF_NPC (1)
+	#pragma library sscanf
+#else
+	static stock SSCANF_NPC = 0;
+	#define SSCANF_NPC (0)
+#endif
+static stock SSCANF_VERSION_MAJOR =  2;
+#define SSCANF_VERSION_MAJOR  2
+static stock SSCANF_VERSION_MINOR = 13;
+#define SSCANF_VERSION_MINOR 13
+static stock SSCANF_VERSION_BUILD = 8;
+#define SSCANF_VERSION_BUILD  8
+static stock SSCANF_VERSION_STRING[] = #SSCANF_VERSION_MAJOR "." #SSCANF_VERSION_MINOR "." #SSCANF_VERSION_BUILD;
+#define SSCANF_VERSION_STRING #SSCANF_VERSION_MAJOR "." #SSCANF_VERSION_MINOR "." #SSCANF_VERSION_BUILD
+forward BCD(number);
+#define BCD(%0) (_:MORE_BCD:NO_MORE_BCD:%0.$0)
+#define MORE_BCD:NO_MORE_BCD:%0.%1$%2) MORE_BCD:NO_MORE_BCD:%1$(%2) << 8 | DO_BCD(%0))
+#define NO_MORE_BCD:$
+#define DO_BCD(%0) _:(%0) / 10 << 4 | _:(%0) % 10
+const SSCANF_VERSION = BCD(SSCANF_VERSION_MAJOR.SSCANF_VERSION_MINOR.SSCANF_VERSION_BUILD);
+stock const SSCANF_VERSION_BCD = SSCANF_VERSION;
+#define sscanf_%0\32; sscanf_
+#define SSCANF:%0(%1) forward sscanf_%0(%1);public sscanf_%0(%1)
+#define @kustom()%0(%1) forward sscanf_%0(%1);public sscanf_%0(%1)
+#if defined sscanf && !defined SSCANF_GetClosestString
+	#error sscanf already defined, or used before inclusion.
+#endif
+ native SSCANF__(const file[], const line, const data[], const format[], {T_WEAPON, Float, _}:...);
+ native UNFORMAT__(const file[], const line, const data[], const format[], {T_WEAPON, Float, _}:...) = SSCANF__;
+ native SSCANF_Init(players, invalid, len);
+ native SSCANF_Join(playerid, const name[], bool:npc);
+ native SSCANF_Leave(playerid);
+ native bool:SSCANF_IsConnected(playerid);
+native SSCANF_Levenshtein(const string1[], const string2[]);
+native Float:SSCANF_TextSimilarity(const string1[], const string2[]);
+native SSCANF_GetOption(const name[]) = SSCANF_Option;
+ native SSCANF_GetOption__(const name[]) = SSCANF_Option;
+native SSCANF_SetOption(const name[], {_, Float}:value) = SSCANF_Option;
+ native SSCANF_SetOption__(const name[], {_, Float}:value) = SSCANF_Option;
+forward SSCANF_Option(const name[], {_, Float}:value = -1);
+#define SSCANF_Option SSCANF_GetOption__
+#define SSCANF_GetOption__(%0,%1) SSCANF_SetOption__(%0,%1)
+#define _ALS_SSCANF_Option
+#define _ALS_SSCANF_GetOption__
+native SSCANF_VersionString(version[], size = sizeof (version)) = SSCANF_Version;
+ native SSCANF_VersionString__(version[], size = sizeof (version)) = SSCANF_Version;
+native SSCANF_VersionBCD() = SSCANF_Version;
+ native SSCANF_VersionBCD__() = SSCANF_Version;
+static stock SSCANF_Version(version[] = "", size = sizeof (version))
+{
+	return SSCANF_VERSION_BCD;
+}
+#define SSCANF_Version SSCANF_VersionString__
+#define SSCANF_VersionString__() SSCANF_VersionBCD__()
+#define _ALS_SSCANF_Version
+#define _ALS_SSCANF_VersionString__
+#if defined __PawnBuild
+	#pragma warning push
+	#pragma warning disable 234
+#endif
+#pragma deprecated - include <sscanf2> first.
+forward sscanf(const data[], const format[], {T_WEAPON, Float, _}:...);
+#if defined __PawnBuild
+	#pragma warning pop
+#endif
+#if defined __PawnBuild
+	#define sscanf( SSCANF__(__file,__line,
+#else
+	#define sscanf( SSCANF__(SSCANF_UNK_,-1,
+#endif
+#if defined __PawnBuild
+	#pragma warning push
+	#pragma warning disable 234
+#endif
+#pragma deprecated - include <sscanf2> first.
+forward unformat(const data[], const format[], {T_WEAPON, Float, _}:...);
+#if defined __PawnBuild
+	#pragma warning pop
+#endif
+#if defined __PawnBuild
+	#define unformat( SSCANF__(__file,__line,
+#else
+	#define unformat( SSCANF__(SSCANF_FOM_,-1,
+#endif
+stock const SSCANF_UNK_[] = "sscanf";
+stock const SSCANF_FOM_[] = "unformat";
+stock const SSCANF_EXT_[] = "extract";
+stock const SSCANF_QUIET[] = "SSCANF_QUIET";
+stock const OLD_DEFAULT_NAME[] = "OLD_DEFAULT_NAME";
+stock const MATCH_NAME_PARTIAL[] = "MATCH_NAME_PARTIAL";
+stock const CELLMIN_ON_MATCHES[] = "CELLMIN_ON_MATCHES";
+stock const OLD_DEFAULT_KUSTOM[] = "OLD_DEFAULT_KUSTOM";
+stock const OLD_DEFAULT_CUSTOM[] = "OLD_DEFAULT_CUSTOM";
+stock const SSCANF_COLOUR_FORMS[] = "SSCANF_COLOUR_FORMS";
+stock const SSCANF_ALPHA[] = "SSCANF_ALPHA";
+stock const SSCANF_ARGB[] = "SSCANF_ARGB";
+stock const MATCH_NAME_FIRST[] = "MATCH_NAME_FIRST";
+stock const MATCH_NAME_SIMILARITY[] = "MATCH_NAME_SIMILARITY";
+static stock SSCANF_gInit = 0;
+#if !defined CHAIN_ORDER
+	#define CHAIN_ORDER() 0
+#endif
+#define CHAIN_HOOK(%0) forward @CO_%0();public @CO_%0(){return CHAIN_ORDER()+1;}
+#define CHAIN_NEXT(%0) @CO_%0
+#define CHAIN_FORWARD:%0_%2(%1)=%3; \
+	forward %0_%2(%1); \
+	public %0_%2(%1) <_ALS : _ALS_x0, _ALS : _ALS_x1> { return (%3); } \
+	public %0_%2(%1) <> { return (%3); }
+#define CHAIN_PUBLIC:%0(%1) %0(%1) <_ALS : _ALS_go>
+CHAIN_HOOK(SSCANF)
+#undef CHAIN_ORDER
+#define CHAIN_ORDER CHAIN_NEXT(SSCANF)
+static stock _SSCANF_IncludeStates() <_ALS : _ALS_x0, _ALS : _ALS_x1, _ALS : _ALS_x2, _ALS : _ALS_x3> {}
+static stock _SSCANF_IncludeStates() <_ALS : _ALS_go> {}
+#if SSCANF_NPC && !defined SSCANF_NO_PLAYERS
+	forward SSCANF_PlayerCheck();
+#endif
+ native SSCANF_SetTimer(const funcname[], interval, bool:repeating) = SetTimer;
+#if !defined __PawnBuild
+	forward SSCANF_RunInit();
+	static stock SSCANF_RunInit0()
+	{
+	}
+#endif
+static stock SSCANF_RunInit()
+{
+	#if SSCANF_NPC
+		state _ALS : _ALS_go;
+		SSCANF_Init(MAX_PLAYERS, INVALID_PLAYER_ID, MAX_PLAYER_NAME);
+		#if !defined SSCANF_NO_PLAYERS
+			SSCANF_PlayerCheck();
+			SSCANF_SetTimer("SSCANF_PlayerCheck", 0, true);
+		#endif
+	#else
+		state _ALS : _ALS_go;
+		if ((SSCANF_gInit = SSCANF_Init(GetMaxPlayers(), INVALID_PLAYER_ID, MAX_PLAYER_NAME)) == 1)
+		{
+			new
+				name[MAX_PLAYER_NAME + 1];
+			for (new i = 0; i != MAX_PLAYERS; ++i)
+			{
+				if (IsPlayerConnected(i) && !SSCANF_IsConnected(i))
+				{
+					GetPlayerName(i, name, sizeof (name));
+					SSCANF_Join(i, name, bool:IsPlayerNPC(i));
+				}
+			}
+		}
+	#endif
+}
+#if SSCANF_NPC
+	public OnNPCModeInit()
+	{
+		SSCANF_RunInit();
+		SSCANF_OnNPCModeInit();
+		return 1;
+	}
+	#if defined _ALS_OnNPCModeInit
+		#undef OnNPCModeInit
+	#else
+		#define _ALS_OnNPCModeInit
+	#endif
+	#define OnNPCModeInit(%0) CHAIN_PUBLIC:SSCANF_OnNPCModeInit(%0)
+	CHAIN_FORWARD:SSCANF_OnNPCModeInit() = 1;
+#else
+	const SSCANF_STATIC__ SSCANF_OnNPCModeInit = 0;
+	#define SSCANF_OnNPCModeInit
+#endif
+#if SSCANF_NPC && !defined SSCANF_NO_PLAYERS
+	public SSCANF_PlayerCheck()
+	{
+		new
+			name[MAX_PLAYER_NAME + 1];
+		for (new i = 0; i != MAX_PLAYERS; ++i)
+		{
+			if (IsPlayerConnected(i))
+			{
+				if (!SSCANF_IsConnected(i))
+				{
+					GetPlayerName(i, name, sizeof (name));
+					SSCANF_Join(i, name, false);
+				}
+			}
+			else
+			{
+				if (SSCANF_IsConnected(i))
+				{
+					SSCANF_Leave(i);
+				}
+			}
+		}
+	}
+#else
+	const SSCANF_STATIC__ SSCANF_PlayerCheck = 0;
+	#define SSCANF_PlayerCheck
+#endif
+#define SSCANF_BRACKETS ()
+forward OnScriptInit SSCANF_BRACKETS;
+#undef SSCANF_BRACKETS
+#if SSCANF_NPC
+	const SSCANF_STATIC__ SSCANF_OnScriptInit = 0;
+	#define SSCANF_OnScriptInit
+#else
+	public OnScriptInit()
+	{
+		if (!SSCANF_gInit)
+		{
+			SSCANF_RunInit();
+		}
+		SSCANF_OnScriptInit();
+		return 1;
+	}
+	#if defined _ALS_OnScriptInit
+		#undef OnScriptInit
+	#else
+		#define _ALS_OnScriptInit
+	#endif
+	#define OnScriptInit(%0) CHAIN_PUBLIC:SSCANF_OnScriptInit(%0)
+	CHAIN_FORWARD:SSCANF_OnScriptInit() = 1;
+#endif
+#if SSCANF_NPC
+	const SSCANF_STATIC__ SSCANF_OnFilterScriptInit = 0;
+	#define SSCANF_OnFilterScriptInit
+#else
+	public OnFilterScriptInit()
+	{
+		if (!SSCANF_gInit)
+		{
+			SSCANF_RunInit();
+		}
+		SSCANF_OnFilterScriptInit();
+		return 1;
+	}
+	#if defined _ALS_OnFilterScriptInit
+		#undef OnFilterScriptInit
+	#else
+		#define _ALS_OnFilterScriptInit
+	#endif
+	#define OnFilterScriptInit(%0) CHAIN_PUBLIC:SSCANF_OnFilterScriptInit(%0)
+	CHAIN_FORWARD:SSCANF_OnFilterScriptInit() = 1;
+#endif
+#if SSCANF_NPC
+	const SSCANF_STATIC__ SSCANF_OnGameModeInit = 0;
+	#define SSCANF_OnGameModeInit
+#else
+	public OnGameModeInit()
+	{
+		if (!SSCANF_gInit)
+		{
+			SSCANF_RunInit();
+		}
+		SSCANF_OnGameModeInit();
+		return 1;
+	}
+	#if defined _ALS_OnGameModeInit
+		#undef OnGameModeInit
+	#else
+		#define _ALS_OnGameModeInit
+	#endif
+	#define OnGameModeInit(%0) CHAIN_PUBLIC:SSCANF_OnGameModeInit(%0)
+	CHAIN_FORWARD:SSCANF_OnGameModeInit() = 1;
+#endif
+forward OnCachedInit();
+#if SSCANF_NPC
+	const SSCANF_STATIC__ SSCANF_OnCachedInit = 0;
+	#define SSCANF_OnCachedInit
+#else
+	public OnCachedInit()
+	{
+		SSCANF_RunInit();
+		SSCANF_OnCachedInit();
+		return 1;
+	}
+	#if defined _ALS_OnCachedInit
+		#undef OnCachedInit
+	#else
+		#define _ALS_OnCachedInit
+	#endif
+	#define OnCachedInit(%0) CHAIN_PUBLIC:SSCANF_OnCachedInit(%0)
+	CHAIN_FORWARD:SSCANF_OnCachedInit() = 1;
+#endif
+#if SSCANF_NPC
+	const SSCANF_STATIC__ SSCANF_OnPlayerConnect = 0;
+	#define SSCANF_OnPlayerConnect
+#else
+	public OnPlayerConnect(playerid)
+	{
+		if (SSCANF_gInit == 1)
+		{
+			new
+				name[MAX_PLAYER_NAME + 1];
+			GetPlayerName(playerid, name, sizeof(name));
+			SSCANF_Join(playerid, name, bool:IsPlayerNPC(playerid));
+		}
+		SSCANF_OnPlayerConnect(playerid);
+		return 1;
+	}
+	#if defined _ALS_OnPlayerConnect
+		#undef OnPlayerConnect
+	#else
+		#define _ALS_OnPlayerConnect
+	#endif
+	#define OnPlayerConnect(%0) CHAIN_PUBLIC:SSCANF_OnPlayerConnect(%0)
+	CHAIN_FORWARD:SSCANF_OnPlayerConnect(playerid) = 1;
+#endif
+#if SSCANF_NPC
+	const SSCANF_STATIC__ SSCANF_OnPlayerDisconnect = 0;
+	#define SSCANF_OnPlayerDisconnect
+#else
+	public OnPlayerDisconnect(playerid, reason)
+	{
+		SSCANF_OnPlayerDisconnect(playerid, reason);
+		if (SSCANF_gInit == 1)
+		{
+			SSCANF_Leave(playerid);
+		}
+		return 1;
+	}
+	#if defined _ALS_OnPlayerDisconnect
+		#undef OnPlayerDisconnect
+	#else
+		#define _ALS_OnPlayerDisconnect
+	#endif
+	#define OnPlayerDisconnect(%0) CHAIN_PUBLIC:SSCANF_OnPlayerDisconnect(%0)
+	CHAIN_FORWARD:SSCANF_OnPlayerDisconnect(playerid, reason) = 1;
+#endif
+#define SSCANF_Init
+#define SSCANF_Join
+#define SSCANF_Leave
+#define SSCANF_IsConnected
+#if defined __PawnBuild
+	#define extract%0->%1; EXTRN%1;UNFORMAT__(__file,__line,_:EXTRV:EXTRX:%0,""#,%1,,);
+#else
+	#define extract%0->%1; EXTRN%1;UNFORMAT__(SSCANF_EXT_,-1,_:EXTRV:EXTRX:%0,""#,%1,,);
+#endif
+#define UNFORMAT__(%7,%8,_:EXTRV:EXTRX:%0,""#,%1);%2else if (UNFORMAT__(%7,%8,_:EXTRV:EXTRX:%0,""#,%1))
+#define EXTRV:EXTRX:%0<%3>%4#,%9new%1,%2) EXTRZ:EXTRY:%0%4#P<%3>,|||%1|||%2)
+#define EXTRZ:EXTRY:%0#P<,> EXTRY:%0"P<,>"#
+#define EXTRX:%0#,%9new%1,%2) EXTRY:%0#,|||%1|||%2)
+#define EXTRY: EXTR8:EXTR9:EXTR0:EXTR1:EXTR2:EXTR3:EXTR4:
+#define EXTR8:EXTR9:EXTR0:EXTR1:EXTR2:EXTR3:EXTR4:%0#%1,%2|||%6:%3=%9|||%4) %6_EXTRO:%0#%1,%2|||%3=%9|||%4)
+#define EXTR9:EXTR0:EXTR1:EXTR2:EXTR3:EXTR4:%0#%1,%2|||%3=%9|||%4) __EXTRO:%0#%1,%2|||%3=%9|||%4)
+#define EXTR0:EXTR1:EXTR2:EXTR3:EXTR4:%0#%1,%2|||%6:%3[%7]|||%4) %6_EXTRW:%0#%1,%2|||%3[%7]|||%4)
+#define EXTR1:EXTR2:EXTR3:EXTR4:%0#%1,%2|||%3[%7]|||%4) __EXTRW:%0#%1,%2|||%3[%7]|||%4)
+#define EXTR2:EXTR3:EXTR4:%0#%1,%2|||%6:%3|||%4) %6_EXTRN:%0#%1,%2|||%3|||%4)
+#define EXTR3:EXTR4:%0#%1,,%2||||||%4) %0#%1,%2)
+#define EXTR4:%0#%1,%2|||%3|||%4) __EXTRN:%0#%1,%2|||%3|||%4)
+#define __EXTRO:%0#%1,%2|||%3=%9|||%4,%5) EXTRY:%0#%1I"("#%9")"#,%2,%3|||%4|||%5)
+#define Float_EXTRO:%0#%1,%2|||%3=%9|||%4,%5) EXTRY:%0#%1F"("#%9")"#,%2,%3|||%4|||%5)
+#define player_EXTRO:%0#%1,%2|||%3=%9|||%4,%5) EXTRY:%0#%1U"("#%9")"#,%2,%3|||%4|||%5)
+#define string_EXTRO:%0#%1,%2|||%3[%7]=%9|||%4,%5) EXTRY:%0#%1S"("#%9")[*]",%2,(%7),%3|||%4|||%5)
+#define __EXTRN:%0#%1,%2|||%3|||%4,%5) EXTRY:%0#%1i,%2,%3|||%4|||%5)
+#define Float_EXTRN:%0#%1,%2|||%3|||%4,%5) EXTRY:%0#%1f,%2,%3|||%4|||%5)
+#define player_EXTRN:%0#%1,%2|||%3|||%4,%5) EXTRY:%0#%1u,%2,%3|||%4|||%5)
+#define __EXTRW:%0#%1,%2|||%3[%7]|||%4,%5) EXTRY:%0#%1a<i>[*],%2,(%7),%3|||%4|||%5)
+#define Float_EXTRW:%0#%1,%2|||%3[%7]|||%4,%5) EXTRY:%0#%1a<f>[*],%2,(%7),%3|||%4|||%5)
+#define player_EXTRW:%0#%1,%2|||%3[%7]|||%4,%5) EXTRY:%0#%1a<u>[*],%2,(%7),%3|||%4|||%5)
+#define string_EXTRW:%0#%1,%2|||%3[%7]|||%4,%5) EXTRY:%0#%1s[*],%2,(%7),%3|||%4|||%5)
+#define EXTRN%0new%1; new%1;
+#if !defined string
+    #define string:
+#endif
+#define player:%0;UNFORMAT__(%1) %0;UNFORMAT__(%1)
+#define hex:%0;UNFORMAT__(%1) %0;UNFORMAT__(%1)
+#define hex_EXTRO:%0#%1,%2|||%3=%9|||%4,%5) EXTRY:%0#%1H"("#%9")"#,%2,%3|||%4|||%5)
+#define hex_EXTRN:%0#%1,%2|||%3|||%4,%5) EXTRY:%0#%1h,%2,%3|||%4|||%5)
+#define hex_EXTRW:%0#%1,%2|||%3[%7]|||%4,%5) EXTRY:%0#%1a<h>[*],%2,(%7),%3|||%4|||%5)
+#define bin:%0;UNFORMAT__(%1) %0;UNFORMAT__(%1)
+#define bin_EXTRO:%0#%1,%2|||%3=%9|||%4,%5) EXTRY:%0#%1B"("#%9")"#,%2,%3|||%4|||%5)
+#define bin_EXTRN:%0#%1,%2|||%3|||%4,%5) EXTRY:%0#%1b,%2,%3|||%4|||%5)
+#define bin_EXTRW:%0#%1,%2|||%3[%7]|||%4,%5) EXTRY:%0#%1a<b>[*],%2,(%7),%3|||%4|||%5)
+#define colour:%0;UNFORMAT__(%1) %0;UNFORMAT__(%1)
+#define colour_EXTRO:%0#%1,%2|||%3=%9|||%4,%5) EXTRY:%0#%1M"("#%9")"#,%2,%3|||%4|||%5)
+#define colour_EXTRN:%0#%1,%2|||%3|||%4,%5) EXTRY:%0#%1m,%2,%3|||%4|||%5)
+#define colour_EXTRW:%0#%1,%2|||%3[%7]|||%4,%5) EXTRY:%0#%1a<m>[*],%2,(%7),%3|||%4|||%5)
+#define kustom:%0<%1> %0
+#define kustom_EXTRO:%0#%1,%2|||%3<%8>=%9|||%4,%5) EXTRY:%0#%1K<%8>"("#%9")"#,%2,%3|||%4|||%5)
+#define kustom_EXTRN:%0#%1,%2|||%3<%8>|||%4,%5) EXTRY:%0#%1k<%8>,%2,%3|||%4|||%5)
+stock SSCANF_GetSimilarString(const input[], const candidates[][], Float:threshold = 0.111111, count = sizeof (candidates))
+{
+	new
+		closest = cellmin,
+		Float:distance;
+	while (count--)
+	{
+		distance = SSCANF_TextSimilarity(input, candidates[count]);
+		if (distance >= threshold)
+		{
+			closest = count,
+			threshold = distance;
+		}
+	}
+	return closest;
+}
+stock SSCANF_GetSimilarValue(const input[], const candidates[][], const results[], fail = cellmin, Float:threshold = 0.111111, count = sizeof (candidates), check = sizeof (results))
+{
+	assert(count == check);
+	new closest = SSCANF_GetSimilarString(input, candidates, threshold, count);
+	if (closest == cellmin)
+	{
+		return fail;
+	}
+	return results[closest];
+}
+#if defined __PawnBuild
+	#pragma warning push
+	#pragma warning disable 234
+#endif
+#pragma deprecated Use `SSCANF_GetSimilarString` for more human results.
+stock SSCANF_GetClosestString(const input[], const candidates[][], threshold = cellmax, count = sizeof (candidates))
+{
+	new
+		closest = cellmin,
+		distance;
+	while (count--)
+	{
+		distance = SSCANF_Levenshtein(input, candidates[count]);
+		if (distance < threshold)
+		{
+			closest = count,
+			threshold = distance;
+		}
+	}
+	return closest;
+}
+#if defined __PawnBuild
+	#pragma warning pop
+#endif
+#if defined __PawnBuild
+	#pragma warning push
+	#pragma warning disable 234
+#endif
+#pragma deprecated Use `SSCANF_GetSimilarValue` for more human results.
+stock SSCANF_GetClosestValue(const input[], const candidates[][], const results[], fail = cellmin, threshold = cellmax, count = sizeof (candidates), check = sizeof (results))
+{
+	assert(count == check);
+	new closest = SSCANF_GetClosestString(input, candidates, threshold, count);
+	if (closest == cellmin)
+	{
+		return fail;
+	}
+	return results[closest];
+}
+#if defined __PawnBuild
+	#pragma warning pop
+#endif
+#if defined SSCANF_NO_K_WEAPON
+	 native SSCANF_no_k_weapon();
+	#define SSCANF_no_k_weapon()
+#else
+	SSCANF:weapon(const string[])
+	{
+		static const results[] = {
+			0, 0, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 22, 23, 24, 25,
+			26, 27, 28, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46
+		};
+		static const candidates[][] = {
+			"Fists",
+			"Unarmed",
+			"Knuckles",
+			"Knuckledusters",
+			"Brass Knuckles",
+			"Golf Club",
+			"Night Stick",
+			"Knife",
+			"Baseball Bat",
+			"Shovel",
+			"Pool cue",
+			"Katana",
+			"Chainsaw",
+			"Purple Dildo",
+			"White Dildo",
+			"Long White Dildo",
+			"White Dildo 2",
+			"Flowers",
+			"Cane",
+			"Grenades",
+			"Tear Gas",
+			"Molotovs",
+			"Pistol",
+			"Silenced Pistol",
+			"Desert Eagle",
+			"Shotgun",
+			"Sawn Off Shotgun",
+			"Combat Shotgun",
+			"Micro Uzi",
+			"Mac 10",
+			"MP5",
+			"AK47",
+			"M4",
+			"Tec9",
+			"Rifle",
+			"Sniper Rifle",
+			"RPG",
+			"Missile Launcher",
+			"Flame Thrower",
+			"Minigun",
+			"Sachel Charges",
+			"Detonator",
+			"Spray Paint",
+			"Fire Extinguisher",
+			"Camera",
+			"Nightvision Goggles",
+			"Thermal Goggles",
+			"Parachute"
+		};
+		if ('0' <= string[0] <= '9')
+		{
+			new
+				ret = strval(string);
+			if (0 <= ret <= 18 || 22 <= ret <= 46)
+			{
+				return ret;
+			}
+		}
+		else
+		{
+			return SSCANF_GetSimilarValue(string, candidates, results, -1);
+		}
+		return -1;
+	}
+#endif
+#if defined SSCANF_NO_K_VEHICLE
+	 native SSCANF_no_k_vehicle();
+	#define SSCANF_no_k_vehicle()
+#else
+	SSCANF:vehicle(const string[])
+	{
+		static const results[] = {
+			400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417,
+			418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435,
+			436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453,
+			454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471,
+			472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489,
+			490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507,
+			508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525,
+			526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543,
+			544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561,
+			562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579,
+			580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597,
+			598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611
+		};
+		static const candidates[][] = {
+			"Landstalker",
+			"Bravura",
+			"Buffalo",
+			"Linerunner",
+			"Perennial",
+			"Sentinel",
+			"Dumper",
+			"Firetruck",
+			"Trashmaster",
+			"Stretch",
+			"Manana",
+			"Infernus",
+			"Voodoo",
+			"Pony",
+			"Mule",
+			"Cheetah",
+			"Ambulance",
+			"Leviathan",
+			"Moonbeam",
+			"Esperanto",
+			"Taxi",
+			"Washington",
+			"Bobcat",
+			"Mr Whoopee",
+			"BF Injection",
+			"Hunter",
+			"Premier",
+			"Enforcer",
+			"Securicar",
+			"Banshee",
+			"Predator",
+			"Bus",
+			"Rhino",
+			"Barracks",
+			"Hotknife",
+			"Article Trailer",
+			"Previon",
+			"Coach",
+			"Cabbie",
+			"Stallion",
+			"Rumpo",
+			"RC Bandit",
+			"Romero",
+			"Packer",
+			"Monster",
+			"Admiral",
+			"Squalo",
+			"Seasparrow",
+			"Pizzaboy",
+			"Tram",
+			"Article Trailer 2",
+			"Turismo",
+			"Speeder",
+			"Reefer",
+			"Tropic",
+			"Flatbed",
+			"Yankee",
+			"Caddy",
+			"Solair",
+			"Topfun Van (Berkley's RC)",
+			"Skimmer",
+			"PCJ-600",
+			"Faggio",
+			"Freeway",
+			"RC Baron",
+			"RC Raider",
+			"Glendale",
+			"Oceanic",
+			"Sanchez",
+			"Sparrow",
+			"Patriot",
+			"Quad",
+			"Coastguard",
+			"Dinghy",
+			"Hermes",
+			"Sabre",
+			"Rustler",
+			"ZR-350",
+			"Walton",
+			"Regina",
+			"Comet",
+			"BMX",
+			"Burrito",
+			"Camper",
+			"Marquis",
+			"Baggage",
+			"Dozer",
+			"Maverick",
+			"SAN News Maverick",
+			"Rancher",
+			"FBI Rancher",
+			"Virgo",
+			"Greenwood",
+			"Jetmax",
+			"Hotring Racer",
+			"Sandking",
+			"Blista Compact",
+			"Police Maverick",
+			"Boxville",
+			"Benson",
+			"Mesa",
+			"RC Goblin",
+			"Hotring Racer \"A\"",
+			"Hotring Racer \"B\"",
+			"Bloodring Banger",
+			"Rancher Lure",
+			"Super GT",
+			"Elegant",
+			"Journey",
+			"Bike",
+			"Mountain Bike",
+			"Beagle",
+			"Cropduster",
+			"Stuntplane",
+			"Tanker",
+			"Roadtrain",
+			"Nebula",
+			"Majestic",
+			"Buccaneer",
+			"Shamal",
+			"Hydra",
+			"FCR-900",
+			"NRG-500",
+			"HPV1000",
+			"Cement Truck",
+			"Towtruck",
+			"Fortune",
+			"Cadrona",
+			"FBI Truck",
+			"Willard",
+			"Forklift",
+			"Tractor",
+			"Combine Harvester",
+			"Feltzer",
+			"Remington",
+			"Slamvan",
+			"Blade",
+			"Freight (Train)",
+			"Brownstreak (Train)",
+			"Vortex",
+			"Vincent",
+			"Bullet",
+			"Clover",
+			"Sadler",
+			"Firetruck LA",
+			"Hustler",
+			"Intruder",
+			"Primo",
+			"Cargobob",
+			"Tampa",
+			"Sunrise",
+			"Merit",
+			"Utility Van",
+			"Nevada",
+			"Yosemite",
+			"Windsor",
+			"Monster \"A\"",
+			"Monster \"B\"",
+			"Uranus",
+			"Jester",
+			"Sultan",
+			"Stratum",
+			"Elegy",
+			"Raindance",
+			"RC Tiger",
+			"Flash",
+			"Tahoma",
+			"Savanna",
+			"Bandito",
+			"Freight Flat Trailer (Train)",
+			"Streak Trailer (Train)",
+			"Kart",
+			"Mower",
+			"Dune",
+			"Sweeper",
+			"Broadway",
+			"Tornado",
+			"AT400",
+			"DFT-30",
+			"Huntley",
+			"Stafford",
+			"BF-400",
+			"Newsvan",
+			"Tug",
+			"Petrol Trailer",
+			"Emperor",
+			"Wayfarer",
+			"Euros",
+			"Hotdog",
+			"Club",
+			"Freight Box Trailer (Train)",
+			"Article Trailer 3",
+			"Andromada",
+			"Dodo",
+			"RC Cam",
+			"Launch",
+			"Police Car (LSPD)",
+			"Police Car (SFPD)",
+			"Police Car (LVPD)",
+			"Police Ranger",
+			"Picador",
+			"S.W.A.T.",
+			"Alpha",
+			"Phoenix",
+			"Glendale Shit",
+			"Sadler Shit",
+			"Baggage Trailer \"A\"",
+			"Baggage Trailer \"B\"",
+			"Tug Stairs Trailer",
+			"Boxville",
+			"Farm Trailer",
+			"Utility Trailer"
+		};
+		if ('0' <= string[0] <= '9')
+		{
+			new
+				ret = strval(string);
+			if (400 <= ret <= 611)
+			{
+				return ret;
+			}
+		}
+		else
+		{
+			return SSCANF_GetSimilarValue(string, candidates, results, -1);
+		}
+		return -1;
+	}
+#endif
+#define SSCANF__(%0:...) BAD_sscanf(%0:...)

streamer.inc

@@ -0,0 +1,371 @@
+#if defined _streamer_included
+	#endinput
+#endif
+#define _streamer_included
+#include <a_samp>
+#define STREAMER_TYPE_OBJECT (0)
+#define STREAMER_TYPE_PICKUP (1)
+#define STREAMER_TYPE_CP (2)
+#define STREAMER_TYPE_RACE_CP (3)
+#define STREAMER_TYPE_MAP_ICON (4)
+#define STREAMER_TYPE_3D_TEXT_LABEL (5)
+#define STREAMER_TYPE_AREA (6)
+#define STREAMER_TYPE_ACTOR (7)
+#define STREAMER_AREA_TYPE_CIRCLE (0)
+#define STREAMER_AREA_TYPE_CYLINDER (1)
+#define STREAMER_AREA_TYPE_SPHERE (2)
+#define STREAMER_AREA_TYPE_RECTANGLE (3)
+#define STREAMER_AREA_TYPE_CUBOID (4)
+#define STREAMER_AREA_TYPE_POLYGON (5)
+#define STREAMER_OBJECT_TYPE_GLOBAL (0)
+#define STREAMER_OBJECT_TYPE_PLAYER (1)
+#define STREAMER_OBJECT_TYPE_DYNAMIC (2)
+#define STREAMER_MAX_TYPES (8)
+#define STREAMER_MAX_AREA_TYPES (6)
+#define STREAMER_MAX_OBJECT_TYPES (3)
+#define INVALID_STREAMER_ID (0)
+#if !defined FLOAT_INFINITY
+    #define FLOAT_INFINITY (Float:0x7F800000)
+#endif
+#if defined STREAMER_ENABLE_TAGS
+	#define STREAMER_TAG_OBJECT DynamicObject
+	#define STREAMER_TAG_OBJECT_ALT {DynamicObject,_}
+	#define STREAMER_TAG_PICKUP DynamicPickup
+	#define STREAMER_TAG_CP DynamicCP
+	#define STREAMER_TAG_RACE_CP DynamicRaceCP
+	#define STREAMER_TAG_MAP_ICON DynamicMapIcon
+	#define STREAMER_TAG_3D_TEXT_LABEL DynamicText3D
+	#define STREAMER_TAG_AREA DynamicArea
+	#define STREAMER_TAG_ACTOR DynamicActor
+	#define STREAMER_ALL_TAGS {DynamicObject,DynamicPickup,DynamicCP,DynamicRaceCP,DynamicMapIcon,DynamicText3D,DynamicArea,DynamicActor,_}
+#else
+	#define STREAMER_TAG_OBJECT _
+	#define STREAMER_TAG_OBJECT_ALT _
+	#define STREAMER_TAG_PICKUP _
+	#define STREAMER_TAG_CP _
+	#define STREAMER_TAG_RACE_CP _
+	#define STREAMER_TAG_MAP_ICON _
+	#define STREAMER_TAG_AREA _
+	#define STREAMER_TAG_ACTOR _
+	#if defined STREAMER_REMOVE_TEXT3D_TAG
+		#define STREAMER_TAG_3D_TEXT_LABEL _
+		#define STREAMER_ALL_TAGS _
+	#else
+		#if defined STREAMER_USE_DYNAMIC_TEXT3D_TAG
+			#define STREAMER_TAG_3D_TEXT_LABEL DynamicText3D
+			#define STREAMER_ALL_TAGS {DynamicText3D,_}
+		#else
+			#define STREAMER_TAG_3D_TEXT_LABEL Text3D
+			#define STREAMER_ALL_TAGS {Text3D,_}
+		#endif
+	#endif
+#endif
+#if !defined STREAMER_OBJECT_SD
+	#define STREAMER_OBJECT_SD 300.0
+#endif
+#if !defined STREAMER_OBJECT_DD
+	#define STREAMER_OBJECT_DD 0.0
+#endif
+#if !defined STREAMER_PICKUP_SD
+	#define STREAMER_PICKUP_SD 200.0
+#endif
+#if !defined STREAMER_CP_SD
+	#define STREAMER_CP_SD 200.0
+#endif
+#if !defined STREAMER_RACE_CP_SD
+	#define STREAMER_RACE_CP_SD 200.0
+#endif
+#if !defined STREAMER_MAP_ICON_SD
+	#define STREAMER_MAP_ICON_SD 200.0
+#endif
+#if !defined STREAMER_3D_TEXT_LABEL_SD
+	#define STREAMER_3D_TEXT_LABEL_SD 200.0
+#endif
+#if !defined STREAMER_ACTOR_SD
+	#define STREAMER_ACTOR_SD 200.0
+#endif
+public Streamer_IncludeFileVersion = 0x296;
+#pragma unused Streamer_IncludeFileVersion
+enum
+{
+	E_STREAMER_AREA_ID,
+	E_STREAMER_ATTACHED_OBJECT,
+	E_STREAMER_ATTACHED_PLAYER,
+	E_STREAMER_ATTACHED_VEHICLE,
+	E_STREAMER_ATTACH_OFFSET_X,
+	E_STREAMER_ATTACH_OFFSET_Y,
+	E_STREAMER_ATTACH_OFFSET_Z,
+	E_STREAMER_ATTACH_R_X,
+	E_STREAMER_ATTACH_R_Y,
+	E_STREAMER_ATTACH_R_Z,
+	E_STREAMER_ATTACH_X,
+	E_STREAMER_ATTACH_Y,
+	E_STREAMER_ATTACH_Z,
+	E_STREAMER_COLOR,
+	E_STREAMER_DRAW_DISTANCE,
+	E_STREAMER_EXTRA_ID,
+	E_STREAMER_HEALTH,
+	E_STREAMER_INTERIOR_ID,
+	E_STREAMER_INVULNERABLE,
+	E_STREAMER_MAX_X,
+	E_STREAMER_MAX_Y,
+	E_STREAMER_MAX_Z,
+	E_STREAMER_MIN_X,
+	E_STREAMER_MIN_Y,
+	E_STREAMER_MIN_Z,
+	E_STREAMER_MODEL_ID,
+	E_STREAMER_MOVE_R_X,
+	E_STREAMER_MOVE_R_Y,
+	E_STREAMER_MOVE_R_Z,
+	E_STREAMER_MOVE_SPEED,
+	E_STREAMER_MOVE_X,
+	E_STREAMER_MOVE_Y,
+	E_STREAMER_MOVE_Z,
+	E_STREAMER_NEXT_X,
+	E_STREAMER_NEXT_Y,
+	E_STREAMER_NEXT_Z,
+	E_STREAMER_PLAYER_ID,
+	E_STREAMER_PRIORITY,
+	E_STREAMER_ROTATION,
+	E_STREAMER_R_X,
+	E_STREAMER_R_Y,
+	E_STREAMER_R_Z,
+	E_STREAMER_SIZE,
+	E_STREAMER_STREAM_DISTANCE,
+	E_STREAMER_STYLE,
+	E_STREAMER_SYNC_ROTATION,
+	E_STREAMER_TEST_LOS,
+	E_STREAMER_TYPE,
+	E_STREAMER_WORLD_ID,
+	E_STREAMER_X,
+	E_STREAMER_Y,
+	E_STREAMER_Z
+}
+#define E_STREAMER_CUSTOM(%0) ((%0) | 0x40000000 & ~0x80000000)
+native Streamer_GetTickRate();
+native Streamer_SetTickRate(rate);
+native Streamer_GetPlayerTickRate(playerid);
+native Streamer_SetPlayerTickRate(playerid, rate);
+native Streamer_ToggleChunkStream(toggle);
+native Streamer_IsToggleChunkStream();
+native Streamer_GetChunkTickRate(type, playerid = -1);
+native Streamer_SetChunkTickRate(type, rate, playerid = -1);
+native Streamer_GetChunkSize(type);
+native Streamer_SetChunkSize(type, size);
+native Streamer_GetMaxItems(type);
+native Streamer_SetMaxItems(type, items);
+native Streamer_GetVisibleItems(type, playerid = -1);
+native Streamer_SetVisibleItems(type, items, playerid = -1);
+native Streamer_GetRadiusMultiplier(type, &Float:multiplier, playerid = -1);
+native Streamer_SetRadiusMultiplier(type, Float:multiplier, playerid = -1);
+native Streamer_GetTypePriority(types[], maxtypes = sizeof types);
+native Streamer_SetTypePriority(const types[], maxtypes = sizeof types);
+native Streamer_GetCellDistance(&Float:distance);
+native Streamer_SetCellDistance(Float:distance);
+native Streamer_GetCellSize(&Float:size);
+native Streamer_SetCellSize(Float:size);
+native Streamer_ToggleItemStatic(type, STREAMER_ALL_TAGS:id, toggle);
+native Streamer_IsToggleItemStatic(type, STREAMER_ALL_TAGS:id);
+native Streamer_ToggleItemInvAreas(type, STREAMER_ALL_TAGS:id, toggle);
+native Streamer_IsToggleItemInvAreas(type, STREAMER_ALL_TAGS:id);
+native Streamer_ToggleItemCallbacks(type, STREAMER_ALL_TAGS:id, toggle);
+native Streamer_IsToggleItemCallbacks(type, STREAMER_ALL_TAGS:id);
+native Streamer_ToggleErrorCallback(toggle);
+native Streamer_IsToggleErrorCallback();
+native Streamer_AmxUnloadDestroyItems(toggle);
+native Streamer_ProcessActiveItems();
+native Streamer_ToggleIdleUpdate(playerid, toggle);
+native Streamer_IsToggleIdleUpdate(playerid);
+native Streamer_ToggleCameraUpdate(playerid, toggle);
+native Streamer_IsToggleCameraUpdate(playerid);
+native Streamer_ToggleItemUpdate(playerid, type, toggle);
+native Streamer_IsToggleItemUpdate(playerid, type);
+native Streamer_GetLastUpdateTime(&Float:time);
+native Streamer_Update(playerid, type = -1);
+native Streamer_UpdateEx(playerid, Float:x, Float:y, Float:z, worldid = -1, interiorid = -1, type = -1, compensatedtime = -1, freezeplayer = 1);
+native Streamer_GetFloatData(type, STREAMER_ALL_TAGS:id, data, &Float:result);
+native Streamer_SetFloatData(type, STREAMER_ALL_TAGS:id, data, Float:value);
+native Streamer_GetIntData(type, STREAMER_ALL_TAGS:id, data);
+native Streamer_SetIntData(type, STREAMER_ALL_TAGS:id, data, value);
+native Streamer_RemoveIntData(type, STREAMER_ALL_TAGS:id, data);
+native Streamer_HasIntData(type, STREAMER_ALL_TAGS:id, data);
+native Streamer_GetArrayData(type, STREAMER_ALL_TAGS:id, data, dest[], maxdest = sizeof dest);
+native Streamer_SetArrayData(type, STREAMER_ALL_TAGS:id, data, const src[], maxsrc = sizeof src);
+native Streamer_IsInArrayData(type, STREAMER_ALL_TAGS:id, data, value);
+native Streamer_AppendArrayData(type, STREAMER_ALL_TAGS:id, data, value);
+native Streamer_RemoveArrayData(type, STREAMER_ALL_TAGS:id, data, value);
+native Streamer_HasArrayData(type, STREAMER_ALL_TAGS:id, data);
+native Streamer_GetArrayDataLength(type, STREAMER_ALL_TAGS:id, data);
+native Streamer_GetUpperBound(type);
+native Streamer_GetDistanceToItem(Float:x, Float:y, Float:z, type, STREAMER_ALL_TAGS:id, &Float:distance, dimensions = 3);
+native Streamer_ToggleItem(playerid, type, STREAMER_ALL_TAGS:id, toggle);
+native Streamer_IsToggleItem(playerid, type, STREAMER_ALL_TAGS:id);
+native Streamer_ToggleAllItems(playerid, type, toggle, const exceptions[] = { -1 }, maxexceptions = sizeof exceptions);
+native Streamer_GetItemInternalID(playerid, type, STREAMER_ALL_TAGS:streamerid);
+native Streamer_GetItemStreamerID(playerid, type, internalid);
+native Streamer_IsItemVisible(playerid, type, STREAMER_ALL_TAGS:id);
+native Streamer_DestroyAllVisibleItems(playerid, type, serverwide = 1);
+native Streamer_CountVisibleItems(playerid, type, serverwide = 1);
+native Streamer_DestroyAllItems(type, serverwide = 1);
+native Streamer_CountItems(type, serverwide = 1);
+native Streamer_GetNearbyItems(Float:x, Float:y, Float:z, type, STREAMER_ALL_TAGS:items[], maxitems = sizeof items, Float:range = 300.0, worldid = -1);
+native Streamer_GetAllVisibleItems(playerid, type, STREAMER_ALL_TAGS:items[], maxitems = sizeof items);
+native Streamer_GetItemPos(type, STREAMER_ALL_TAGS:id, &Float:x, &Float:y, &Float:z);
+native Streamer_SetItemPos(type, STREAMER_ALL_TAGS:id, Float:x, Float:y, Float:z);
+native Streamer_GetItemOffset(type, STREAMER_ALL_TAGS:id, &Float:x, &Float:y, &Float:z);
+native Streamer_SetItemOffset(type, STREAMER_ALL_TAGS:id, Float:x, Float:y, Float:z);
+native STREAMER_TAG_OBJECT:CreateDynamicObject(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, worldid = -1, interiorid = -1, playerid = -1, Float:streamdistance = STREAMER_OBJECT_SD, Float:drawdistance = STREAMER_OBJECT_DD, STREAMER_TAG_AREA:areaid = STREAMER_TAG_AREA:-1, priority = 0);
+native DestroyDynamicObject(STREAMER_TAG_OBJECT:objectid);
+native IsValidDynamicObject(STREAMER_TAG_OBJECT:objectid);
+native GetDynamicObjectPos(STREAMER_TAG_OBJECT:objectid, &Float:x, &Float:y, &Float:z);
+native SetDynamicObjectPos(STREAMER_TAG_OBJECT:objectid, Float:x, Float:y, Float:z);
+native GetDynamicObjectRot(STREAMER_TAG_OBJECT:objectid, &Float:rx, &Float:ry, &Float:rz);
+native SetDynamicObjectRot(STREAMER_TAG_OBJECT:objectid, Float:rx, Float:ry, Float:rz);
+native GetDynamicObjectNoCameraCol(STREAMER_TAG_OBJECT:objectid);
+native SetDynamicObjectNoCameraCol(STREAMER_TAG_OBJECT:objectid);
+native MoveDynamicObject(STREAMER_TAG_OBJECT:objectid, Float:x, Float:y, Float:z, Float:speed, Float:rx = -1000.0, Float:ry = -1000.0, Float:rz = -1000.0);
+native StopDynamicObject(STREAMER_TAG_OBJECT:objectid);
+native IsDynamicObjectMoving(STREAMER_TAG_OBJECT:objectid);
+native AttachCameraToDynamicObject(playerid, STREAMER_TAG_OBJECT:objectid);
+native AttachDynamicObjectToObject(STREAMER_TAG_OBJECT:objectid, attachtoid, Float:offsetx, Float:offsety, Float:offsetz, Float:rx, Float:ry, Float:rz, syncrotation = 1);
+native AttachDynamicObjectToPlayer(STREAMER_TAG_OBJECT:objectid, playerid, Float:offsetx, Float:offsety, Float:offsetz, Float:rx, Float:ry, Float:rz);
+native AttachDynamicObjectToVehicle(STREAMER_TAG_OBJECT:objectid, vehicleid, Float:offsetx, Float:offsety, Float:offsetz, Float:rx, Float:ry, Float:rz);
+native EditDynamicObject(playerid, STREAMER_TAG_OBJECT:objectid);
+native IsDynamicObjectMaterialUsed(STREAMER_TAG_OBJECT:objectid, materialindex);
+native RemoveDynamicObjectMaterial(STREAMER_TAG_OBJECT:objectid, materialindex);
+native GetDynamicObjectMaterial(STREAMER_TAG_OBJECT:objectid, materialindex, &modelid, txdname[], texturename[], &materialcolor, maxtxdname = sizeof txdname, maxtexturename = sizeof texturename);
+native SetDynamicObjectMaterial(STREAMER_TAG_OBJECT:objectid, materialindex, modelid, const txdname[], const texturename[], materialcolor = 0);
+native IsDynamicObjectMaterialTextUsed(STREAMER_TAG_OBJECT:objectid, materialindex);
+native RemoveDynamicObjectMaterialText(STREAMER_TAG_OBJECT:objectid, materialindex);
+native GetDynamicObjectMaterialText(STREAMER_TAG_OBJECT:objectid, materialindex, text[], &materialsize, fontface[], &fontsize, &bold, &fontcolor, &backcolor, &textalignment, maxtext = sizeof text, maxfontface = sizeof fontface);
+native SetDynamicObjectMaterialText(STREAMER_TAG_OBJECT:objectid, materialindex, const text[], materialsize = OBJECT_MATERIAL_SIZE_256x128, const fontface[] = "Arial", fontsize = 24, bold = 1, fontcolor = 0xFFFFFFFF, backcolor = 0, textalignment = 0);
+native STREAMER_TAG_OBJECT:GetPlayerCameraTargetDynObject(playerid);
+native STREAMER_TAG_PICKUP:CreateDynamicPickup(modelid, type, Float:x, Float:y, Float:z, worldid = -1, interiorid = -1, playerid = -1, Float:streamdistance = STREAMER_PICKUP_SD, STREAMER_TAG_AREA:areaid = STREAMER_TAG_AREA:-1, priority = 0);
+native DestroyDynamicPickup(STREAMER_TAG_PICKUP:pickupid);
+native IsValidDynamicPickup(STREAMER_TAG_PICKUP:pickupid);
+native STREAMER_TAG_CP:CreateDynamicCP(Float:x, Float:y, Float:z, Float:size, worldid = -1, interiorid = -1, playerid = -1, Float:streamdistance = STREAMER_CP_SD, STREAMER_TAG_AREA:areaid = STREAMER_TAG_AREA:-1, priority = 0);
+native DestroyDynamicCP(STREAMER_TAG_CP:checkpointid);
+native IsValidDynamicCP(STREAMER_TAG_CP:checkpointid);
+native IsPlayerInDynamicCP(playerid, STREAMER_TAG_CP:checkpointid);
+native STREAMER_TAG_CP:GetPlayerVisibleDynamicCP(playerid);
+native STREAMER_TAG_RACE_CP:CreateDynamicRaceCP(type, Float:x, Float:y, Float:z, Float:nextx, Float:nexty, Float:nextz, Float:size, worldid = -1, interiorid = -1, playerid = -1, Float:streamdistance = STREAMER_RACE_CP_SD, STREAMER_TAG_AREA:areaid = STREAMER_TAG_AREA:-1, priority = 0);
+native DestroyDynamicRaceCP(STREAMER_TAG_RACE_CP:checkpointid);
+native IsValidDynamicRaceCP(STREAMER_TAG_RACE_CP:checkpointid);
+native IsPlayerInDynamicRaceCP(playerid, STREAMER_TAG_RACE_CP:checkpointid);
+native STREAMER_TAG_RACE_CP:GetPlayerVisibleDynamicRaceCP(playerid);
+native STREAMER_TAG_MAP_ICON:CreateDynamicMapIcon(Float:x, Float:y, Float:z, type, color, worldid = -1, interiorid = -1, playerid = -1, Float:streamdistance = STREAMER_MAP_ICON_SD, style = MAPICON_LOCAL, STREAMER_TAG_AREA:areaid = STREAMER_TAG_AREA:-1, priority = 0);
+native DestroyDynamicMapIcon(STREAMER_TAG_MAP_ICON:iconid);
+native IsValidDynamicMapIcon(STREAMER_TAG_MAP_ICON:iconid);
+native STREAMER_TAG_3D_TEXT_LABEL:CreateDynamic3DTextLabel(const text[], color, Float:x, Float:y, Float:z, Float:drawdistance, attachedplayer = INVALID_PLAYER_ID, attachedvehicle = INVALID_VEHICLE_ID, testlos = 0, worldid = -1, interiorid = -1, playerid = -1, Float:streamdistance = STREAMER_3D_TEXT_LABEL_SD, STREAMER_TAG_AREA:areaid = STREAMER_TAG_AREA:-1, priority = 0);
+native DestroyDynamic3DTextLabel(STREAMER_TAG_3D_TEXT_LABEL:id);
+native IsValidDynamic3DTextLabel(STREAMER_TAG_3D_TEXT_LABEL:id);
+native GetDynamic3DTextLabelText(STREAMER_TAG_3D_TEXT_LABEL:id, text[], maxtext = sizeof text);
+native UpdateDynamic3DTextLabelText(STREAMER_TAG_3D_TEXT_LABEL:id, color, const text[]);
+native STREAMER_TAG_AREA:CreateDynamicCircle(Float:x, Float:y, Float:size, worldid = -1, interiorid = -1, playerid = -1, priority = 0);
+native STREAMER_TAG_AREA:CreateDynamicCylinder(Float:x, Float:y, Float:minz, Float:maxz, Float:size, worldid = -1, interiorid = -1, playerid = -1, priority = 0);
+native STREAMER_TAG_AREA:CreateDynamicSphere(Float:x, Float:y, Float:z, Float:size, worldid = -1, interiorid = -1, playerid = -1, priority = 0);
+native STREAMER_TAG_AREA:CreateDynamicRectangle(Float:minx, Float:miny, Float:maxx, Float:maxy, worldid = -1, interiorid = -1, playerid = -1, priority = 0);
+native STREAMER_TAG_AREA:CreateDynamicCuboid(Float:minx, Float:miny, Float:minz, Float:maxx, Float:maxy, Float:maxz, worldid = -1, interiorid = -1, playerid = -1, priority = 0);
+native STREAMER_TAG_AREA:CreateDynamicCube(Float:minx, Float:miny, Float:minz, Float:maxx, Float:maxy, Float:maxz, worldid = -1, interiorid = -1, playerid = -1, priority = 0);
+native STREAMER_TAG_AREA:CreateDynamicPolygon(const Float:points[], Float:minz = -FLOAT_INFINITY, Float:maxz = FLOAT_INFINITY, maxpoints = sizeof points, worldid = -1, interiorid = -1, playerid = -1, priority = 0);
+native DestroyDynamicArea(STREAMER_TAG_AREA:areaid);
+native IsValidDynamicArea(STREAMER_TAG_AREA:areaid);
+native GetDynamicAreaType(STREAMER_TAG_AREA:areaid);
+native GetDynamicPolygonPoints(STREAMER_TAG_AREA:areaid, Float:points[], maxpoints = sizeof points);
+native GetDynamicPolygonNumberPoints(STREAMER_TAG_AREA:areaid);
+native IsPlayerInDynamicArea(playerid, STREAMER_TAG_AREA:areaid, recheck = 0);
+native IsPlayerInAnyDynamicArea(playerid, recheck = 0);
+native IsAnyPlayerInDynamicArea(STREAMER_TAG_AREA:areaid, recheck = 0);
+native IsAnyPlayerInAnyDynamicArea(recheck = 0);
+native GetPlayerDynamicAreas(playerid, STREAMER_TAG_AREA:areas[], maxareas = sizeof areas);
+native GetPlayerNumberDynamicAreas(playerid);
+native IsPointInDynamicArea(STREAMER_TAG_AREA:areaid, Float:x, Float:y, Float:z);
+native IsPointInAnyDynamicArea(Float:x, Float:y, Float:z);
+native IsLineInDynamicArea(STREAMER_TAG_AREA:areaid, Float:x1, Float:y1, Float:z1, Float:x2, Float:y2, Float:z2);
+native IsLineInAnyDynamicArea(Float:x1, Float:y1, Float:z1, Float:x2, Float:y2, Float:z2);
+native GetDynamicAreasForPoint(Float:x, Float:y, Float:z, STREAMER_TAG_AREA:areas[], maxareas = sizeof areas);
+native GetNumberDynamicAreasForPoint(Float:x, Float:y, Float:z);
+native GetDynamicAreasForLine(Float:x1, Float:y1, Float:z1, Float:x2, Float:y2, Float:z2, STREAMER_TAG_AREA:areas[], maxareas = sizeof areas);
+native GetNumberDynamicAreasForLine(Float:x1, Float:y1, Float:z1, Float:x2, Float:y2, Float:z2);
+native AttachDynamicAreaToObject(STREAMER_TAG_AREA:areaid, STREAMER_TAG_OBJECT_ALT:objectid, type = STREAMER_OBJECT_TYPE_DYNAMIC, playerid = INVALID_PLAYER_ID, Float:offsetx = 0.0, Float:offsety = 0.0, Float:offsetz = 0.0);
+native AttachDynamicAreaToPlayer(STREAMER_TAG_AREA:areaid, playerid, Float:offsetx = 0.0, Float:offsety = 0.0, Float:offsetz = 0.0);
+native AttachDynamicAreaToVehicle(STREAMER_TAG_AREA:areaid, vehicleid, Float:offsetx = 0.0, Float:offsety = 0.0, Float:offsetz = 0.0);
+native ToggleDynAreaSpectateMode(STREAMER_TAG_AREA:areaid, toggle);
+native IsToggleDynAreaSpectateMode(STREAMER_TAG_AREA:areaid);
+native STREAMER_TAG_ACTOR:CreateDynamicActor(modelid, Float:x, Float:y, Float:z, Float:r, invulnerable = true, Float:health = 100.0, worldid = 0, interiorid = -1, playerid = -1, Float:streamdistance = STREAMER_ACTOR_SD, STREAMER_TAG_AREA:areaid = STREAMER_TAG_AREA:-1, priority = 0);
+native DestroyDynamicActor(STREAMER_TAG_ACTOR:actorid);
+native IsValidDynamicActor(STREAMER_TAG_ACTOR:actorid);
+native IsDynamicActorStreamedIn(STREAMER_TAG_ACTOR:actorid, forplayerid);
+native GetDynamicActorVirtualWorld(STREAMER_TAG_ACTOR:actorid);
+native SetDynamicActorVirtualWorld(STREAMER_TAG_ACTOR:actorid, vworld);
+native GetDynamicActorAnimation(STREAMER_TAG_ACTOR:actorid, animlib[], animname[], &Float:fdelta, &loop, &lockx, &locky, &freeze, &time, maxanimlib = sizeof animlib, maxanimname = sizeof animname);
+native ApplyDynamicActorAnimation(STREAMER_TAG_ACTOR:actorid, const animlib[], const animname[], Float:fdelta, loop, lockx, locky, freeze, time);
+native ClearDynamicActorAnimations(STREAMER_TAG_ACTOR:actorid);
+native GetDynamicActorFacingAngle(STREAMER_TAG_ACTOR:actorid, &Float:ang);
+native SetDynamicActorFacingAngle(STREAMER_TAG_ACTOR:actorid, Float:ang);
+native GetDynamicActorPos(STREAMER_TAG_ACTOR:actorid, &Float:x, &Float:y, &Float:z);
+native SetDynamicActorPos(STREAMER_TAG_ACTOR:actorid, Float:x, Float:y, Float:z);
+native GetDynamicActorHealth(STREAMER_TAG_ACTOR:actorid, &Float:health);
+native SetDynamicActorHealth(STREAMER_TAG_ACTOR:actorid, Float:health);
+native SetDynamicActorInvulnerable(STREAMER_TAG_ACTOR:actorid, invulnerable = true);
+native IsDynamicActorInvulnerable(STREAMER_TAG_ACTOR:actorid);
+native STREAMER_TAG_ACTOR:GetPlayerTargetDynamicActor(playerid);
+native STREAMER_TAG_ACTOR:GetPlayerCameraTargetDynActor(playerid);
+native STREAMER_TAG_OBJECT:CreateDynamicObjectEx(modelid, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz, Float:streamdistance = STREAMER_OBJECT_SD, Float:drawdistance = STREAMER_OBJECT_DD, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, const STREAMER_TAG_AREA:areas[] = { STREAMER_TAG_AREA:-1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players, maxareas = sizeof areas);
+native STREAMER_TAG_PICKUP:CreateDynamicPickupEx(modelid, type, Float:x, Float:y, Float:z, Float:streamdistance = STREAMER_PICKUP_SD, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, const STREAMER_TAG_AREA:areas[] = { STREAMER_TAG_AREA:-1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players, maxareas = sizeof areas);
+native STREAMER_TAG_CP:CreateDynamicCPEx(Float:x, Float:y, Float:z, Float:size, Float:streamdistance = STREAMER_CP_SD, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, const STREAMER_TAG_AREA:areas[] = { STREAMER_TAG_AREA:-1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players, maxareas = sizeof areas);
+native STREAMER_TAG_RACE_CP:CreateDynamicRaceCPEx(type, Float:x, Float:y, Float:z, Float:nextx, Float:nexty, Float:nextz, Float:size, Float:streamdistance = STREAMER_RACE_CP_SD, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, const STREAMER_TAG_AREA:areas[] = { STREAMER_TAG_AREA:-1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players, maxareas = sizeof areas);
+native STREAMER_TAG_MAP_ICON:CreateDynamicMapIconEx(Float:x, Float:y, Float:z, type, color, style = MAPICON_LOCAL, Float:streamdistance = STREAMER_MAP_ICON_SD, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, const STREAMER_TAG_AREA:areas[] = { STREAMER_TAG_AREA:-1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players, maxareas = sizeof areas);
+native STREAMER_TAG_3D_TEXT_LABEL:CreateDynamic3DTextLabelEx(const text[], color, Float:x, Float:y, Float:z, Float:drawdistance, attachedplayer = INVALID_PLAYER_ID, attachedvehicle = INVALID_VEHICLE_ID, testlos = 0, Float:streamdistance = STREAMER_3D_TEXT_LABEL_SD, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, const STREAMER_TAG_AREA:areas[] = { STREAMER_TAG_AREA:-1 }, priority = 0,
+	maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players, maxareas = sizeof areas);
+native STREAMER_TAG_AREA:CreateDynamicCircleEx(Float:x, Float:y, Float:size, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players);
+native STREAMER_TAG_AREA:CreateDynamicCylinderEx(Float:x, Float:y, Float:minz, Float:maxz, Float:size, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players);
+native STREAMER_TAG_AREA:CreateDynamicSphereEx(Float:x, Float:y, Float:z, Float:size, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players);
+native STREAMER_TAG_AREA:CreateDynamicRectangleEx(Float:minx, Float:miny, Float:maxx, Float:maxy, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players);
+native STREAMER_TAG_AREA:CreateDynamicCuboidEx(Float:minx, Float:miny, Float:minz, Float:maxx, Float:maxy, Float:maxz, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players);
+native STREAMER_TAG_AREA:CreateDynamicCubeEx(Float:minx, Float:miny, Float:minz, Float:maxx, Float:maxy, Float:maxz, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players);
+native STREAMER_TAG_AREA:CreateDynamicPolygonEx(const Float:points[], Float:minz = -FLOAT_INFINITY, Float:maxz = FLOAT_INFINITY, maxpoints = sizeof points, const worlds[] = { -1 }, const interiors[] = { -1 }, const players[] = { -1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players);
+native STREAMER_TAG_ACTOR:CreateDynamicActorEx(modelid, Float:x, Float:y, Float:z, Float:r, invulnerable = 1, Float:health = 100.0, Float:streamdistance = STREAMER_ACTOR_SD, const worlds[] = { 0 }, const interiors[] = { -1 }, const players[] = { -1 }, const STREAMER_TAG_AREA:areas[] = { STREAMER_TAG_AREA:-1 }, priority = 0, maxworlds = sizeof worlds, maxinteriors = sizeof interiors, maxplayers = sizeof players, maxareas = sizeof areas);
+native Streamer_CallbackHook(callback, {Float,_}:...);
+native Streamer_TickRate(rate);
+native Streamer_MaxItems(type, items);
+native Streamer_VisibleItems(type, items, playerid = -1);
+native Streamer_CellDistance(Float:distance);
+native Streamer_CellSize(Float:size);
+native DestroyAllDynamicObjects();
+native CountDynamicObjects();
+native DestroyAllDynamicPickups();
+native CountDynamicPickups();
+native DestroyAllDynamicCPs();
+native CountDynamicCPs();
+native DestroyAllDynamicRaceCPs();
+native CountDynamicRaceCPs();
+native DestroyAllDynamicMapIcons();
+native CountDynamicMapIcons();
+native DestroyAllDynamic3DTextLabels();
+native CountDynamic3DTextLabels();
+native DestroyAllDynamicAreas();
+native CountDynamicAreas();
+native TogglePlayerDynamicCP(playerid, STREAMER_TAG_CP:checkpointid, toggle);
+native TogglePlayerAllDynamicCPs(playerid, toggle, const exceptions[] = { -1 }, maxexceptions = sizeof exceptions);
+native TogglePlayerDynamicRaceCP(playerid, STREAMER_TAG_RACE_CP:checkpointid, toggle);
+native TogglePlayerAllDynamicRaceCPs(playerid, toggle, const exceptions[] = { -1 }, maxexceptions = sizeof exceptions);
+native TogglePlayerDynamicArea(playerid, STREAMER_TAG_AREA:areaid, toggle);
+native TogglePlayerAllDynamicAreas(playerid, toggle, const exceptions[] = { -1 }, maxexceptions = sizeof exceptions);
+forward OnDynamicObjectMoved(STREAMER_TAG_OBJECT:objectid);
+forward OnPlayerEditDynamicObject(playerid, STREAMER_TAG_OBJECT:objectid, response, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz);
+forward OnPlayerSelectDynamicObject(playerid, STREAMER_TAG_OBJECT:objectid, modelid, Float:x, Float:y, Float:z);
+forward OnPlayerShootDynamicObject(playerid, weaponid, STREAMER_TAG_OBJECT:objectid, Float:x, Float:y, Float:z);
+forward OnPlayerPickUpDynamicPickup(playerid, STREAMER_TAG_PICKUP:pickupid);
+forward OnPlayerEnterDynamicCP(playerid, STREAMER_TAG_CP:checkpointid);
+forward OnPlayerLeaveDynamicCP(playerid, STREAMER_TAG_CP:checkpointid);
+forward OnPlayerEnterDynamicRaceCP(playerid, STREAMER_TAG_RACE_CP:checkpointid);
+forward OnPlayerLeaveDynamicRaceCP(playerid, STREAMER_TAG_RACE_CP:checkpointid);
+forward OnPlayerEnterDynamicArea(playerid, STREAMER_TAG_AREA:areaid);
+forward OnPlayerLeaveDynamicArea(playerid, STREAMER_TAG_AREA:areaid);
+forward OnPlayerGiveDamageDynamicActor(playerid, STREAMER_TAG_ACTOR:actorid, Float:amount, weaponid, bodypart);
+forward OnDynamicActorStreamIn(STREAMER_TAG_ACTOR:actorid, forplayerid);
+forward OnDynamicActorStreamOut(STREAMER_TAG_ACTOR:actorid, forplayerid);
+forward Streamer_OnItemStreamIn(type, STREAMER_ALL_TAGS:id, forplayerid);
+forward Streamer_OnItemStreamOut(type, STREAMER_ALL_TAGS:id, forplayerid);
+forward Streamer_OnPluginError(const error[]);

strlib.inc

@@ -0,0 +1,1088 @@
+#if defined STRLIB_INC
+	#endinput
+#endif
+#define STRLIB_INC
+#include <a_samp>
+#if !defined STRLIB_BUFFER_SIZE
+	#define STRLIB_BUFFER_SIZE  2048
+#endif
+#if !defined STRLIB_RETURN_SIZE
+	#define STRLIB_RETURN_SIZE  128
+#endif
+#if !defined STRLIB_USE_FORMATEX
+	#if defined __fmt_funcinc
+		#if !defined FormatSpecifier
+			#error Please include formatex before strlib.
+		#endif
+		#define STRLIB_USE_FORMATEX  true
+	#else
+		#define STRLIB_USE_FORMATEX  false
+	#endif
+#endif
+enum trim_edges {
+	trim_left  = 1,
+	trim_right = 2,
+	trim_both = trim_left | trim_right
+};
+enum string_edges {
+	edge_left  = 1,
+	edge_right = 2,
+	edge_both = edge_left | edge_right
+};
+forward sprintf(const fmat[], {Float, _}:...);
+forward strgetfirstc(const string[]);
+forward strgetc(const string[], index);
+forward strsize(const string[]);
+forward bool:isempty(const string[]);
+forward bool:isequal(const str1[], const str2[], bool:ignorecase = false);
+forward strdistance(const str1[], const str2[], bool:ignorecase = false);
+forward strexplode(output[][], const input[], const delimiter[] = !",", limit = cellmax, bool:trim = true, bool:ignorecase = false, size1 = sizeof(output), size2 = sizeof(output[]));
+forward strimplode(const glue[], output[], maxlength = sizeof(output), ...);
+forward strreplace(string[], const search[], const replacement[], bool:ignorecase = false, pos = 0, limit = -1, maxlength = sizeof(string));
+forward strtrim(string[], const chars[] = !"", string_edges:edge = edge_both);
+forward strpad(string[], length, const substr[] = !" ", string_edges:edge = edge_both, bool:trim_first = true, const trim_chars[] = !"", maxlength = sizeof(string), const input[] = !"");
+forward strwrap(const left[], string[], const right[], maxlength = sizeof(string));
+forward strcount(const string[], const sub[], bool:ignorecase = false, bool:count_overlapped = false);
+forward bool:strfromliteral(output[], const input[], &pos = 0, maxlength = sizeof(output));
+forward strtoliteral(output[], const input[], maxlength = sizeof(output), bool:paranoid = true);
+forward strfrombin(output[], const input[], inputlength = sizeof(input), maxlength = sizeof(output));
+forward strtobin(output[], const input[], maxlength = sizeof(output));
+forward strcatmid(dest[], const source[], start = 0, end = -1, maxlength = sizeof(dest));
+forward utf8encode(dest[], const source[], maxlength = sizeof(dest));
+forward utf8decode(dest[], const source[], maxlength = sizeof(dest));
+forward strurldecode(output[], const input[], maxlength = sizeof(output));
+forward strurlencode(output[], const input[], maxlength = sizeof(output), bool:pack = false);
+forward ret_strcatmid(const string[], const source[], start = 0, end = -1);
+forward ret_strfrombin(const input[], inputlength = sizeof(input));
+forward ret_strimplode(const glue[], ...);
+forward ret_strreplace(const string[], const search[], const replacement[], bool:ignorecase = false, pos = 0, limit = -1);
+forward ret_strfromliteral(const input[], &pos = 0);
+forward ret_strtoliteral(const input[], bool:paranoid = true);
+forward ret_strtrim(const string[], const chars[] = !"", string_edges:edge = edge_both);
+forward ret_strpad(const string[], length, const substr[] = !" ", string_edges:edge = edge_both, bool:trim_first = true, const trim_chars[] = !"");
+forward ret_strwrap(const left[], const string[], const right[]);
+forward ret_strurldecode(const input[]);
+forward ret_strurlencode(const input[], bool:pack = false);
+forward ret_utf8encode(const input[]);
+forward ret_utf8decode(const input[]);
+forward ret_strpack(const source[]);
+forward ret_strunpack(const source[]);
+forward ret_strcat(const string1[], const string2[]);
+forward ret_strmid(const source[], start, end);
+forward ret_strins(const string[], const substr[], pos, maxlength = sizeof(string));
+forward ret_strdel(const string[], start, end);
+forward ret_valstr(value, bool:pack = false);
+forward ret_GetPlayerName(playerid, bool:pack = false);
+stock
+	g_StrlibBuffer[2048]
+;
+forward _strlib_funcinc();
+public _strlib_funcinc() {
+	new temp[1];
+	format(!temp, 0, !temp);
+	strcat(temp, temp);
+	strpack(temp, temp);
+	strunpack(temp, temp);
+}
+static stock RedirectArgument(arg, ...) {
+	#emit LOAD.S.pri  0
+	#emit ADD.C       12
+	#emit LOAD.S.alt  arg
+	#emit SHL.C.alt   2
+	#emit ADD
+	#emit MOVE.alt
+	#emit LOAD.S.pri  16
+	#emit STOR.I
+}
+static stock CopyArgumentToHeap(arg, bool:pack = false, const argptr[] = "") {
+	new arg_address, address;
+	#emit LOAD.S.pri  0
+	#emit ADD.C       12
+	#emit LOAD.S.alt  arg
+	#emit SHL.C.alt   2
+	#emit ADD
+	#emit LOAD.I
+	#emit STOR.S.pri  arg_address
+	#emit STOR.S.pri  argptr
+	if (pack) {
+		new bytes = ((strlen(argptr) + 1 + 3) / 4) * 4;
+		#emit LCTRL       2
+		#emit STOR.S.pri  address
+		#emit LOAD.S.alt  bytes
+		#emit ADD
+		#emit SCTRL       2
+		#emit LOAD.S.pri  bytes
+		#emit SHR.C.pri   2
+		#emit PUSH.pri
+		#emit PUSH.S      arg_address
+		#emit PUSH.S      address
+		#emit PUSH.C      12
+		#emit SYSREQ.C    strpack
+		#emit STACK       16
+	} else {
+		new bytes = (strlen(argptr) + 1) * 4;
+		#emit LCTRL       2
+		#emit STOR.S.pri  address
+		#emit LOAD.S.alt  bytes
+		#emit ADD
+		#emit SCTRL       2
+		#emit LOAD.S.pri  bytes
+		#emit SHR.C.pri   2
+		#emit PUSH.pri
+		#emit PUSH.S      arg_address
+		#emit PUSH.S      address
+		#emit PUSH.C      12
+		#emit SYSREQ.C    strunpack
+		#emit STACK       16
+	}
+	#emit LOAD.S.pri  0
+	#emit ADD.C       12
+	#emit LOAD.S.alt  arg
+	#emit SHL.C.alt   2
+	#emit ADD
+	#emit MOVE.alt
+	#emit LOAD.S.pri  address
+	#emit STOR.I
+	return address;
+}
+static stock RestoreHeapToAddress(address) {
+	#emit LOAD.S.pri  address
+	#emit SCTRL       2
+}
+static stock IsOverlapping(const str1[], size1 = sizeof(str1), const str2[], size2 = sizeof(str2)) {
+	new addr1, addr2;
+	if (size1 == -1) {
+		size1 = strsize(str1);
+	} else {
+		size1 *= 4;
+	}
+	if (size2 == -1) {
+		size2 = strsize(str2);
+	} else {
+		size2 *= 4;
+	}
+	#emit LOAD.S.pri  str1
+	#emit STOR.S.pri  addr1
+	#emit LOAD.S.pri  str2
+	#emit STOR.S.pri  addr2
+	return (addr1 < addr2 + size2) && (addr2 < addr1 + size1);
+}
+#if !defined ispacked
+    #define ispacked(%1) \
+        ((%1)[0] > 255)
+#endif
+stock strgetfirstc(const string[]) {
+	return ispacked(string) ? string{0} : string[0];
+}
+stock strgetc(const string[], index) {
+	if (index < 0)
+		return '\0';
+	new len = strlen(string);
+	if (index >= len)
+		return '\0';
+	return ispacked(string) ? string{index} : string[index];
+}
+stock strsize(const string[]) {
+	new len = strlen(string);
+	if (ispacked(string))
+		return len + 1;
+	return (len + 1) * 4;
+}
+stock bool:isempty(const string[]) {
+	if (ispacked(string))
+		return string{0} == '\0';
+	else
+		return string[0] == '\0';
+}
+stock bool:isequal(const str1[], const str2[], bool:ignorecase = false) {
+    new
+        c1 = (str1[0] > 255) ? str1{0} : str1[0],
+        c2 = (str2[0] > 255) ? str2{0} : str2[0]
+    ;
+    if (!c1 != !c2)
+        return false;
+    return !strcmp(str1, str2, ignorecase);
+}
+stock strdistance(const str1[], const str2[], bool:ignorecase = false) {
+	if(isequal(str1, str2, ignorecase))
+		return 0;
+	static data[128][128];
+	new bool:pack1 = ispacked(str1),
+		bool:pack2 = ispacked(str2);
+	new size1 = strlen(str1),
+		size2 = strlen(str2);
+	if (size1 == 0)
+		return size2;
+	if (size2 == 0)
+		return size1;
+	for (new i; i <= size1; i++)
+		data[i][0] = i;
+	for (new j; j <= size2; j++)
+		data[0][j] = j;
+	for (new j = 1; j <= size2; j++) {
+		for (new i = 1; i <= size1; i++) {
+			new char1 = pack1 ? str1{i - 1} : str1[i - 1],
+				char2 = pack2 ? str2{j - 1} : str2[j - 1];
+			if(ignorecase) {
+				if (65 <= char1 <= 90)
+					char1 += 32;
+				if (65 <= char2 <= 90)
+					char2 += 32;
+			}
+			if (char1 == char2)
+				data[i][j] = data[i - 1][j - 1];
+			else {
+				new l1 = data[i - 1][j] + 1,
+				l2 = data[i][j - 1] + 1,
+				l3 = data[i - 1][j - 1] + 1;
+				l2 = (l1 > l2 ? l2 : l1);
+				data[i][j] = (l3 > l2 ? l2 : l3);
+			}
+		}
+	}
+	return data[size1][size2];
+}
+stock strimplode(const glue[], output[], maxlength = sizeof(output), ...) {
+	new args = numargs();
+	output[0] = '\0';
+	for (new arg = 3; arg < args; arg++) {
+		if (arg != 3)
+			strcat(output, glue, maxlength);
+		{
+			#emit LCTRL       5
+			#emit ADD.C       12
+			#emit LOAD.S.alt  arg
+			#emit SHL.C.alt   2
+			#emit ADD
+			#emit LOAD.I
+			#emit PUSH.S      maxlength
+			#emit PUSH.pri
+			#emit PUSH.S      output
+			#emit PUSH.C      12
+			#emit SYSREQ.C    strcat
+			#emit STACK       16
+		}
+	}
+}
+stock strexplode(output[][], const input[], const delimiter[] = !",", limit = cellmax, bool:trim = true, bool:ignorecase = false, size1 = sizeof(output), size2 = sizeof(output[])) {
+	if (!size1 || !size2) {
+		printf("(strexplode) ERROR: size1 = %d, size2 = %d. Can't be 0.", size1, size2);
+		return 0;
+	}
+	if (isempty(delimiter)) {
+		print(!"(strexplode) ERROR: delimiter is empty.");
+		return 0;
+	}
+	if (trim) {
+		new i = -1;
+		if (ispacked(input)) {
+			while (input{++i}) {
+				if (input{i} > ' ') {
+					i = -1;
+					break;
+				}
+			}
+		} else {
+			while (input[++i]) {
+				if (input[i] > ' ') {
+					i = -1;
+					break;
+				}
+			}
+		}
+		if (i != -1)
+			return 0;
+	} else if (isempty(input)) {
+		return 0;
+	}
+	if (limit == 0) {
+		return 0;
+	} else if (limit == cellmax) {
+		limit = 0;
+	}
+	new
+		     pos = 0,
+		     next,
+		bool:packed = ispacked(input),
+		     dlen = strlen(delimiter),
+		     count = 0,
+		     end
+	;
+	while (pos != -1) {
+		++count;
+		if (limit > 0 && count >= limit) {
+			next = -1;
+		} else {
+			next = strfind(input, delimiter, ignorecase, pos);
+		}
+		end = (next == -1) ? cellmax : next;
+		if (trim) {
+			if (end == cellmax)
+				end = strlen(input);
+			if (packed) {
+				while (0 < input{pos} <= ' ') pos++;
+				while (end > 0 && input{end - 1} <= ' ') end--;
+			} else {
+				while (0 < input[pos] <= ' ') pos++;
+				while (end > 0 && input[end - 1] <= ' ') end--;
+			}
+		}
+		strmid(output[count - 1], input, pos, end, size2);
+		if (count >= size1 || next == -1 || (limit < 0 && count >= -limit))
+			break;
+		pos = next + dlen;
+	}
+	return count;
+}
+stock strreplace(string[], const search[], const replacement[], bool:ignorecase = false, pos = 0, limit = -1, maxlength = sizeof(string)) {
+    if (limit == 0)
+        return 0;
+    new
+             sublen = strlen(search),
+             replen = strlen(replacement),
+        bool:packed = ispacked(string),
+             maxlen = maxlength,
+             len = strlen(string),
+             count = 0
+    ;
+    if (packed)
+        maxlen *= 4;
+    if (!sublen)
+        return 0;
+    while (-1 != (pos = strfind(string, search, ignorecase, pos))) {
+        strdel(string, pos, pos + sublen);
+        len -= sublen;
+        if (replen && len + replen < maxlen) {
+            strins(string, replacement, pos, maxlength);
+            pos += replen;
+            len += replen;
+        }
+        if (limit != -1 && ++count >= limit)
+            break;
+    }
+    return count;
+}
+stock strtrim(string[], const chars[] = !"", string_edges:edge = edge_both) {
+	new bool:packed = ispacked(string);
+	if (!strgetfirstc(chars)) {
+		if (edge & edge_left) {
+			new i = 0;
+			if (packed)
+				while (0 < string{i} <= ' ') i++;
+			else
+				while (0 < string[i] <= ' ') i++;
+			if (i) {
+				strdel(string, 0, i);
+			}
+		}
+		if (edge & edge_right) {
+			new i = strlen(string);
+			if (i) {
+				if (packed) {
+					while (--i && 0 < string{i} <= ' ') {}
+					string{i + 1} = '\0';
+				} else {
+					while (--i && 0 < string[i] <= ' ') {}
+					string[i + 1] = '\0';
+				}
+			}
+		}
+	} else {
+		if (edge & edge_left) {
+			new i = 0, sub[2];
+			if (packed) {
+				while ((sub[0] = string{i})) {
+					if (strfind(chars, sub) == -1)
+						break;
+					i++;
+				}
+				if (i) {
+					strdel(string, 0, i);
+				}
+			} else {
+				while ((sub[0] = string[i])) {
+					if (strfind(chars, sub) == -1)
+						break;
+					i++;
+				}
+				if (i) strdel(string, 0, i);
+			}
+		}
+		if (edge & edge_right) {
+			new i = strlen(string), sub[2];
+			if (i >= 0) {
+				if (packed) {
+					while (i--) {
+						sub[0] = string{i};
+						if (strfind(chars, sub) == -1)
+							break;
+					}
+					string{i + 1} = '\0';
+				} else {
+					while (i--) {
+						sub[0] = string[i];
+						if (strfind(chars, sub) == -1)
+							break;
+					}
+					string[i + 1] = '\0';
+				}
+			}
+		}
+	}
+}
+stock strpad(string[], length, const substr[] = !" ", string_edges:edge = edge_both, bool:trim_first = true, const trim_chars[] = !"", maxlength = sizeof(string), const input[] = !"") {
+	if (trim_first) {
+		strtrim(string, trim_chars, edge);
+	}
+	new
+		     heap,
+		     length_left = 0,
+		     length_right = 0,
+		     len = strlen(string),
+		     sublen = strlen(substr),
+		bool:packed,
+		bool:subpacked = ispacked(substr)
+	;
+	if (len > length)
+		return;
+	else
+		length -= len;
+	#emit LOAD.S.pri  string
+	#emit STOR.S.pri  input
+	heap = CopyArgumentToHeap(7);
+	string[0] = '\0';
+	len = 0;
+	switch (edge) {
+		case edge_left:
+			length_left = length;
+		case edge_right:
+			length_right = length;
+		default:
+			length_left = length / 2, length_right = length - length_left;
+	}
+	if (length_left) {
+		while (len < length_left) {
+			if (subpacked)
+				strcat(string, substr, length_left * 4);
+			else
+				strcat(string, substr, length_left + 1);
+			len += sublen;
+		}
+		if (subpacked)
+			string{length_left} = 0;
+	}
+	strcat(string, input, maxlength);
+	if (length_right) {
+		len = strlen(string);
+		length_right += len;
+		packed = ispacked(string);
+		while (len < length_right) {
+			if (packed)
+				strcat(string, substr, length_right / 4 + 1);
+			else
+				strcat(string, substr, length_right + 1);
+			len += sublen;
+		}
+		if (packed)
+			string{length_right + 1} = 0;
+	}
+	RestoreHeapToAddress(heap);
+}
+stock strwrap(const left[], string[], const right[], maxlength = sizeof(string)) {
+	strins(string, left, 0, maxlength);
+	strcat(string, right, maxlength);
+}
+stock strcount(const string[], const sub[], bool:ignorecase = false, bool:count_overlapped = false) {
+	new
+		increment = count_overlapped ? 1 : strlen(sub),
+		pos = -increment,
+		count = 0
+	;
+	while (-1 != (pos = strfind(string, sub, ignorecase, pos + increment)))
+		count++;
+	return count;
+}
+stock bool:strfromliteral(output[], const input[], &pos = 0, maxlength = sizeof(output)) {
+	new
+		     length = strlen(input),
+			 c,
+			 outlen = 0,
+		     heap = 0
+	;
+	if (!length)
+		return true;
+	if (IsOverlapping(output, maxlength, input, -1))
+		heap = CopyArgumentToHeap(1);
+	output[0] = '\0';
+	if (input[0] == '"')
+		pos++;
+	for (;; pos++) {
+		if (outlen >= maxlength - 1 || pos >= length)
+			break;
+		c = input[pos];
+		switch (c) {
+			case '"': break;
+			case '\\': {}
+			default: {
+				output[outlen++] = c;
+				continue;
+			}
+		}
+		if (pos == length - 1)
+			goto return_false;
+		c = input[++pos];
+		switch (c) {
+			case '"',
+			    '\'',
+			    '\\',
+			     '%': output[outlen++] = c;
+			case 'a': output[outlen++] = '\a';
+			case 'b': output[outlen++] = '\b';
+			case 'e': output[outlen++] = '\e';
+			case 'f': output[outlen++] = '\f';
+			case 'r': output[outlen++] = '\r';
+			case 'n': output[outlen++] = '\n';
+			case 't': output[outlen++] = '\t';
+			case 'v': output[outlen++] = '\v';
+			case 'x': {
+				new val = 0;
+				if (c == length - 1)
+					goto return_false;
+				while ((c = input[pos + 1])) {
+					if ('a' <= c <= 'f' || 'A' <= c <= 'F') {
+						val = (val << 4) + (tolower(c) - 'a' + 10);
+					} else if ('0' <= c <= '9') {
+						val = (val << 4) + (c - '0');
+					} else {
+						break;
+					}
+					pos++;
+				}
+				if (c == ';')
+					pos++;
+				output[outlen++] = val;
+			}
+			case '0' .. '9': {
+				new val = 0;
+				while ((c = input[pos])) {
+					if ('0' <= c <= '9') {
+						val = val * 10 + (c - '0');
+					} else {
+						break;
+					}
+					pos++;
+				}
+				if (c != ';') pos--;
+				output[outlen++] = val;
+			}
+			default: {
+				goto return_false;
+			}
+		}
+	}
+	output[outlen] = '\0';
+	pos++;
+	new bool:ret = true;
+	#pragma unused ret
+	goto return_true;
+return_false:
+	ret = false;
+return_true:
+	if (heap)
+		RestoreHeapToAddress(heap);
+	return ret;
+}
+stock strtoliteral(output[], const input[], maxlength = sizeof(output), bool:paranoid = true) {
+	new i, c, outlen, heap = 0;
+	if (IsOverlapping(output, maxlength, input, -1))
+		heap = CopyArgumentToHeap(1);
+	output[outlen++] = '"';
+	for (i = 0; (c = input[i]); i++) {
+		if (maxlength - outlen <= 3) {
+			outlen = min(outlen, maxlength - 2);
+			break;
+		}
+		switch (c) {
+			case ' ', '!', '#' .. '[', ']', '^' .. '~':
+				output[outlen++] = c;
+			case  '"': strunpack(output[outlen], !"\\\"", 3), outlen += 2;
+			case '\a': strunpack(output[outlen], !"\\a" , 3), outlen += 2;
+			case '\b': strunpack(output[outlen], !"\\b" , 3), outlen += 2;
+			case '\e': strunpack(output[outlen], !"\\e" , 3), outlen += 2;
+			case '\f': strunpack(output[outlen], !"\\f" , 3), outlen += 2;
+			case '\r': strunpack(output[outlen], !"\\r" , 3), outlen += 2;
+			case '\n': strunpack(output[outlen], !"\\n" , 3), outlen += 2;
+			case '\t': strunpack(output[outlen], !"\\t" , 3), outlen += 2;
+			case '\v': strunpack(output[outlen], !"\\v" , 3), outlen += 2;
+			case '\\': strunpack(output[outlen], !"\\\\" , 3), outlen += 2;
+			default: {
+				if (!paranoid && 0x80 <= c <= 0xFF) {
+					output[outlen++] = c;
+					continue;
+				}
+				if (maxlength - outlen <= 8)
+					break;
+				format(output[outlen], 7, "\\x%03x;", c);
+				outlen += 6;
+			}
+		}
+	}
+	output[outlen++] = '"';
+	output[outlen] = '\0';
+	if (heap)
+		RestoreHeapToAddress(heap);
+}
+stock strfrombin(output[], const input[], inputlength = sizeof(input), maxlength = sizeof(output)) {
+	static const hex_chars[] = "0123456789ABCDEF";
+	new outlen = 0, heap = 0;
+	if (IsOverlapping(output, maxlength, input, -1))
+		heap = CopyArgumentToHeap(1);
+	for (new i = 0; i < inputlength; i++) {
+		if (maxlength - outlen <= 7) {
+			outlen = min(outlen, maxlength - 1);
+			break;
+		}
+		new input_cell = input[i];
+		output[outlen++] = hex_chars[(input_cell             ) >>> 28];
+		output[outlen++] = hex_chars[(input_cell & 0x0F000000) >>> 24];
+		output[outlen++] = hex_chars[(input_cell & 0x00F00000) >>> 20];
+		output[outlen++] = hex_chars[(input_cell & 0x000F0000) >>> 16];
+		output[outlen++] = hex_chars[(input_cell & 0x0000F000) >>> 12];
+		output[outlen++] = hex_chars[(input_cell & 0x00000F00) >>>  8];
+		output[outlen++] = hex_chars[(input_cell & 0x000000F0) >>>  4];
+		output[outlen++] = hex_chars[(input_cell & 0x0000000F)       ];
+	}
+	output[outlen] = '\0';
+	if (heap)
+		RestoreHeapToAddress(heap);
+}
+stock strtobin(output[], const input[], maxlength = sizeof(output)) {
+	new len = strlen(input), outlen = 0, heap = 0;
+	if (IsOverlapping(output, maxlength, input, -1))
+		heap = CopyArgumentToHeap(1);
+	for (new i = 0; i < len;) {
+		if (outlen >= maxlength || i > len - 8) {
+			break;
+		}
+		new c, out = 0;
+		#define ADD_OUT(%1) \
+			c = input[i++]; out |= (('a' <= c <= 'f' || 'A' <= c <= 'F') ? (tolower(c) - 'a' + 10) : (c - '0')) << %1
+		ADD_OUT(28);
+		ADD_OUT(24);
+		ADD_OUT(20);
+		ADD_OUT(16);
+		ADD_OUT(12);
+		ADD_OUT(8);
+		ADD_OUT(4);
+		ADD_OUT(0);
+		#undef ADD_OUT
+		output[outlen++] = out;
+	}
+	if (heap)
+		RestoreHeapToAddress(heap);
+	return outlen;
+}
+stock strurlencode(output[], const input[], maxlength = sizeof(output), bool:pack = false) {
+	static const hex_chars[] = "0123456789ABCDEF";
+	new
+		     len = strlen(input),
+		bool:packed = ispacked(input),
+		     outlen = 0,
+		     heap = 0
+	;
+	if (IsOverlapping(output, maxlength, input, -1))
+		heap = CopyArgumentToHeap(1, packed);
+	if (pack)
+		maxlength *= 4;
+	for (new i = 0; i < len; i++) {
+		if (maxlength - outlen <= 1)
+			break;
+		new c = packed ? input{i} : input[i];
+		switch (c) {
+			case 'a' .. 'z', 'A' .. 'Z', '0' .. '9', '_': {
+				if (pack)
+					output{outlen++} = c;
+				else
+					output[outlen++] = c;
+			}
+			case ' ': {
+				if (pack)
+					output{outlen++} = '+';
+				else
+					output[outlen++] = '+';
+			}
+			default: {
+				if (maxlength - outlen <= 3)
+					break;
+				if (pack) {
+					output{outlen++} = '%';
+					output{outlen++} = hex_chars[(c & 0xF0) >>> 4];
+					output{outlen++} = hex_chars[c & 0x0F];
+				} else {
+					output[outlen++] = '%';
+					output[outlen++] = hex_chars[(c & 0xF0) >>> 4];
+					output[outlen++] = hex_chars[c & 0x0F];
+				}
+			}
+		}
+	}
+	if (pack)
+		output{outlen} = '\0';
+	else
+		output[outlen] = '\0';
+	if (heap)
+		RestoreHeapToAddress(heap);
+}
+stock strurldecode(output[], const input[], maxlength = sizeof(output)) {
+	new prev_pos = 0, pos = 0, inputlen = strlen(input), len, heap = 0;
+	if (IsOverlapping(output, maxlength, input, -1))
+		heap = CopyArgumentToHeap(1);
+	output[0] = '\0';
+	while (-1 != (pos = strfind(input, "%", _, pos))) {
+		static str[2];
+		new c;
+		if (prev_pos != pos) {
+			len = strlen(output);
+			strcatmid(output, input, prev_pos, pos, maxlength);
+			strreplace(output, "+", " ", _, len, _, maxlength);
+		}
+		if (inputlen < pos + 3)
+			goto func_end;
+		str[0] = 0;
+		c = input[pos + 1]; str[0] |= (('a' <= c <= 'f' || 'A' <= c <= 'F') ? (tolower(c) - 'a' + 10) : (c - '0')) << 4;
+		c = input[pos + 2]; str[0] |= (('a' <= c <= 'f' || 'A' <= c <= 'F') ? (tolower(c) - 'a' + 10) : (c - '0'));
+		strcat(output, str, maxlength);
+		prev_pos = (pos += 3);
+	}
+	len = strlen(output);
+	strcatmid(output, input, prev_pos, _, maxlength);
+	strreplace(output, "+", " ", _, len, _, maxlength);
+func_end:
+	if (heap)
+		RestoreHeapToAddress(heap);
+}
+stock strcatmid(dest[], const source[], start = 0, end = -1, maxlength = sizeof(dest)) {
+	new heap = 0;
+	if (IsOverlapping(dest, maxlength, source, -1))
+		heap = CopyArgumentToHeap(1);
+	if (start == 0 && end == -1) {
+		strcat(dest, source, maxlength);
+	} else {
+		if (end == -1)
+			end = strlen(source);
+		if (ispacked(dest)) {
+			new len = strlen(dest);
+			if (ispacked(source)) {
+				strunpack(g_StrlibBuffer, source);
+				strcat(dest, g_StrlibBuffer[start], min(maxlength, (len + end - start) / 4 + 1));
+			} else {
+				strcat(dest, source[start], min(maxlength, (len + end - start) / 4 + 1));
+			}
+			dest{len + end - start} = '\0';
+		} else {
+			if (ispacked(source)) {
+				strunpack(g_StrlibBuffer, source);
+				strcat(dest, g_StrlibBuffer[start], min(maxlength, strlen(dest) + end - start + 1));
+			} else {
+				strcat(dest, source[start], min(maxlength, strlen(dest) + end - start + 1));
+			}
+		}
+	}
+	if (heap)
+		RestoreHeapToAddress(heap);
+}
+stock utf8encode(dest[], const source[], maxlength = sizeof(dest)) {
+	new heap = 0;
+	if (IsOverlapping(dest, maxlength, source, -1)) {
+		heap = CopyArgumentToHeap(1);
+	}
+	new len = strlen(source);
+	new packed = ispacked(source);
+	dest[0] = '\0';
+	new idx = 0;
+	for (new i = 0; i < len; i++) {
+		new c = packed ? source{i} : source[i];
+		if (c >= 0x80) {
+			if (c > 0x4000000) {
+				dest[idx++] = 0b11111100 | ((c >>> 30) & 0b00000001);
+				dest[idx++] = 0b10000000 | ((c >>> 24) & 0b00111111);
+				dest[idx++] = 0b10000000 | ((c >>> 18) & 0b00111111);
+				dest[idx++] = 0b10000000 | ((c >>> 12) & 0b00111111);
+				dest[idx++] = 0b10000000 | ((c >>> 6) & 0b00111111);
+				dest[idx++] = 0b10000000 | (c & 0b00111111);
+			} else if (c > 0x200000) {
+				dest[idx++] = 0b11111000 | ((c >>> 24) & 0b00000011);
+				dest[idx++] = 0b10000000 | ((c >>> 18) & 0b00111111);
+				dest[idx++] = 0b10000000 | ((c >>> 12) & 0b00111111);
+				dest[idx++] = 0b10000000 | ((c >>> 6) & 0b00111111);
+				dest[idx++] = 0b10000000 | (c & 0b00111111);
+			} else if (c > 0x10000) {
+				dest[idx++] = 0b11110000 | ((c >>> 18) & 0b00000111);
+				dest[idx++] = 0b10000000 | ((c >>> 12) & 0b00111111);
+				dest[idx++] = 0b10000000 | ((c >>> 6) & 0b00111111);
+				dest[idx++] = 0b10000000 | (c & 0b00111111);
+			} else if (c > 0x800) {
+				dest[idx++] = 0b11100000 | ((c >>> 12) & 0b00001111);
+				dest[idx++] = 0b10000000 | ((c >>> 6) & 0b00111111);
+				dest[idx++] = 0b10000000 | (c & 0b00111111);
+			} else {
+				dest[idx++] = 0b11000000 | ((c >>> 6) & 0b00011111);
+				dest[idx++] = 0b10000000 | (c & 0b00111111);
+			}
+		} else if (c > 0) {
+			dest[idx++] = c;
+		}
+	}
+	dest[idx] = '\0';
+	if (heap) {
+		RestoreHeapToAddress(heap);
+	}
+}
+stock utf8decode(dest[], const source[], maxlength = sizeof(dest)) {
+	new heap = 0;
+	if (IsOverlapping(dest, maxlength, source, -1)) {
+		heap = CopyArgumentToHeap(1);
+	}
+	new len = strlen(source);
+	dest[0] = '\0';
+	new idx = 0;
+	for (new i = 0; i < len; i++) {
+		new c = source[i];
+		if (c & 0b10000000) {
+			if (c & 0b11100000 == 0b11000000) {
+				if (i + 1 >= len) continue;
+				dest[idx++] = (c & 0b00011111) << 6 | (source[++i] & 0b00111111);
+			} else if (c & 0b11110000 == 0b11100000) {
+				if (i + 2 >= len) continue;
+				dest[idx++] = (c & 0b00001111) << 12 |
+				              (source[++i] & 0b00111111) << 6 |
+				              (source[++i] & 0b00111111);
+			} else if (c & 0b11111000 == 0b11110000) {
+				if (i + 3 >= len) continue;
+				dest[idx++] = (c & 0b00000111) << 18 |
+				              (source[++i] & 0b00111111) << 12 |
+				              (source[++i] & 0b00111111) << 6 |
+				              (source[++i] & 0b00111111);
+			} else if (c & 0b11111100 == 0b11111000) {
+				if (i + 4 >= len) continue;
+				dest[idx++] = (c & 0b00000011) << 24 |
+				              (source[++i] & 0b00111111) << 18 |
+				              (source[++i] & 0b00111111) << 12 |
+				              (source[++i] & 0b00111111) << 6 |
+				              (source[++i] & 0b00111111);
+			} else if (c & 0b11111110 == 0b11111100) {
+				if (i + 5 >= len) continue;
+				dest[idx++] = (c & 0b00000001) << 30 |
+				              (source[++i] & 0b00111111) << 24 |
+				              (source[++i] & 0b00111111) << 18 |
+				              (source[++i] & 0b00111111) << 12 |
+				              (source[++i] & 0b00111111) << 6 |
+				              (source[++i] & 0b00111111);
+			}
+		} else {
+			dest[idx++] = c;
+		}
+	}
+	dest[idx] = 0;
+	if (heap) {
+		RestoreHeapToAddress(heap);
+	}
+}
+stock ret_strcatmid(const string[], const source[], start = 0, end = -1) {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, string);
+	strcatmid(output, source, start, end);
+	return output;
+}
+stock ret_strfrombin(const input[], inputlength = sizeof(input)) {
+	new output[STRLIB_RETURN_SIZE];
+	strfrombin(output, input, inputlength);
+	return output;
+}
+stock ret_strimplode(const glue[], ...) {
+	new output[STRLIB_RETURN_SIZE];
+	const maxlength = sizeof(output);
+	new args = numargs();
+	for (new arg = 1; arg < args; arg++) {
+		if (arg != 1)
+			strcat(output, glue, maxlength);
+		{
+			#emit LCTRL       5
+			#emit ADD.C       12
+			#emit LOAD.S.alt  arg
+			#emit SHL.C.alt   2
+			#emit ADD
+			#emit LOAD.I
+			#emit PUSH.C      maxlength
+			#emit PUSH.pri
+			#emit PUSH.ADR    output
+			#emit PUSH.C      12
+			#emit SYSREQ.C    strcat
+			#emit STACK       16
+		}
+	}
+	#emit LOAD.S.pri  8
+	#emit ADD.C       12
+	#emit MOVE.alt
+	#emit LCTRL       5
+	#emit ADD
+	#emit LOAD.I
+	#emit STOR.S.pri  20
+	return output;
+}
+stock ret_strreplace(const string[], const search[], const replacement[], bool:ignorecase = false, pos = 0, limit = -1) {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, string);
+	strreplace(output, search, replacement, ignorecase, pos, limit);
+	return output;
+}
+stock ret_strfromliteral(const input[], &pos = 0) {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, input);
+	strfromliteral(output, input, pos);
+	return output;
+}
+stock ret_strtoliteral(const input[], bool:paranoid = true) {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, input);
+	strtoliteral(output, input, paranoid);
+	return output;
+}
+stock ret_strtrim(const string[], const chars[] = !"", string_edges:edge = edge_both) {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, string);
+	strtrim(output, chars, edge);
+	return output;
+}
+stock ret_strpad(const string[], length, const substr[] = !" ", string_edges:edge = edge_both, bool:trim_first = true, const trim_chars[] = !"") {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, string);
+	strpad(output, length, substr, edge, trim_first, trim_chars);
+	return output;
+}
+stock ret_strwrap(const left[], const string[], const right[]) {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, left);
+	strcat(output, string);
+	strcat(output, right);
+	return output;
+}
+stock ret_strurldecode(const input[]) {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, input);
+	strurldecode(output, input);
+	return output;
+}
+stock ret_strurlencode(const input[], bool:pack = false) {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, input);
+	strurlencode(output, input, _, pack);
+	return output;
+}
+stock ret_utf8encode(const input[]) {
+	new output[STRLIB_RETURN_SIZE];
+	utf8encode(output, input);
+	return output;
+}
+stock ret_utf8decode(const input[]) {
+	new output[STRLIB_RETURN_SIZE];
+	utf8decode(output, input);
+	return output;
+}
+stock ret_strpack(const source[]) {
+	new output[STRLIB_RETURN_SIZE];
+	strpack(output, source);
+	return output;
+}
+stock ret_strunpack(const source[]) {
+	new output[STRLIB_RETURN_SIZE];
+	strunpack(output, source);
+	return output;
+}
+stock ret_strcat(const string1[], const string2[]) {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, string1);
+	strcat(output, string2);
+	return output;
+}
+stock ret_strmid(const source[], start, end) {
+	new output[STRLIB_RETURN_SIZE];
+	strmid(output, source, start, end);
+	return output;
+}
+stock ret_strins(const string[], const substr[], pos, maxlength = sizeof(string)) {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, string);
+	strins(output, substr, pos);
+	return output;
+}
+stock ret_strdel(const string[], start, end) {
+	new output[STRLIB_RETURN_SIZE];
+	strcat(output, string);
+	strdel(output, start, end);
+	return output;
+}
+stock ret_valstr(value, bool:pack = false) {
+	new output[STRLIB_RETURN_SIZE];
+	format(output, sizeof(output), "%d", value);
+	if (pack)
+		strpack(output, output);
+	return output;
+}
+stock ret_GetPlayerName(playerid, bool:pack = false) {
+	new output[MAX_PLAYER_NAME];
+	GetPlayerName(playerid, output, sizeof(output));
+	if (pack)
+		strpack(output, output);
+	return output;
+}
+stock sprintf(const fmat[], {Float, _}:...) {
+	static output[STRLIB_RETURN_SIZE], frm_header[3], heap;
+	const output_size = sizeof(output);
+	if (ispacked(fmat)) {
+		heap = CopyArgumentToHeap(0);
+	} else {
+		heap = 0;
+	}{}
+	#emit LCTRL      5
+	#emit CONST.alt  frm_header
+	#emit MOVS       12
+	#emit LOAD.S.alt  8
+	#emit ADD.C    12
+	#emit SCTRL    4
+	#emit PUSH.C      output_size
+	#emit PUSH.C      output
+	#emit MOVE.pri
+	#emit ADD.C       8
+	#emit PUSH.pri
+	#if !STRLIB_USE_FORMATEX
+		const formatex = 0;
+		goto do_sysreq;
+	#endif
+	#emit LCTRL       6
+	#emit ADD.C       36
+	#emit PUSH.pri
+	#emit CONST.pri   formatex
+	#emit SCTRL       6
+	#if !STRLIB_USE_FORMATEX
+		do_sysreq:
+	#endif
+	#emit SYSREQ.C    format
+	#emit LCTRL       5
+	#emit SCTRL       4
+	#emit MOVE.alt
+	#emit CONST.pri   frm_header
+	#emit MOVS        12
+	if (heap) {
+		RestoreHeapToAddress(heap);
+	}{}
+	#emit LOAD.S.pri  8
+	#emit ADD.C       12
+	#emit MOVE.alt
+	#emit LCTRL       5
+	#emit ADD
+	#emit LOAD.I
+	#emit STOR.S.pri  20
+	return output;
+	#pragma unused fmat
+}

timerfix.inc

@@ -0,0 +1,35 @@
+#define KillTimer_						KillTimer
+native IsValidTimer(timerid);
+native GetActiveTimers();
+native KillPlayerTimer(timerid) = KillTimer;
+native KillPlayerTimers(playerid);
+native SetTimer_(func[], interval, delay, count);
+native SetTimerEx_(func[], interval, delay, count, format[], {Float, _}:...);
+native SetPlayerTimer(playerid, func[], interval, repeating);
+native SetPlayerTimerEx(playerid, func[], interval, repeating, const format[], {Float,_}:...);
+native SetPlayerTimer_(playerid, func[], interval, delay, count);
+native SetPlayerTimerEx_(playerid, func[], interval, delay, count, format[], {Float, _}:...);
+native GetTimerFunctionName(timerid, func[]);
+native SetTimerInterval(timerid, interval);
+native GetTimerInterval(timerid);
+native GetTimerIntervalLeft(timerid);
+native SetTimerDelay(timerid, delay);
+native SetTimerCount(timerid, count);
+native GetTimerCallsLeft(timerid);
+public OnPlayerDisconnect(playerid, reason) {
+	KillPlayerTimers(playerid);
+	#if defined TIMERFIX_OnPlayerDisconnect
+		return TIMERFIX_OnPlayerDisconnect(playerid, reason);
+	#else
+		return 1;
+	#endif
+}
+#if defined _ALS_OnPlayerDisconnect
+	#undef OnPlayerDisconnect
+#else
+	#define _ALS_OnPlayerDisconnect
+#endif
+#define OnPlayerDisconnect TIMERFIX_OnPlayerDisconnect
+#if defined TIMERFIX_OnPlayerDisconnect
+	forward TIMERFIX_OnPlayerDisconnect(playerid, reason);
+#endif