From b5e16c46272e4cba103033251ef621c5a0d44667 Mon Sep 17 00:00:00 2001
From: Vortrex <3858226+VortrexFTW@users.noreply.github.com>
Date: Tue, 17 May 2022 14:59:08 -0500
Subject: [PATCH] Work on native class

---
 .../server/native/connected-nativeclass.js    | 1047 +++++++++++++++++
 1 file changed, 1047 insertions(+)
 create mode 100644 scripts/server/native/connected-nativeclass.js

diff --git a/scripts/server/native/connected-nativeclass.js b/scripts/server/native/connected-nativeclass.js
new file mode 100644
index 00000000..0e681846
--- /dev/null
+++ b/scripts/server/native/connected-nativeclass.js
@@ -0,0 +1,1047 @@
+// ===========================================================================
+// Vortrex's Roleplay Resource
+// https://github.com/VortrexFTW/gtac_roleplay
+// ===========================================================================
+// FILE: connected.js
+// DESC: Provides wrapped natives for GTA Connected and Mafia Connected mods
+// TYPE: Server (JavaScript)
+// ===========================================================================
+
+class CustomNatives {
+	getPlayerPosition(client) {
+		if(!areServerElementsSupported()) {
+			return getPlayerData(client).syncPosition;
+		} else {
+			if(getPlayerPed(client) != null) {
+				return getPlayerPed(client).position;
+			}
+		}
+	};
+
+	static setPlayerPosition(client, position) {
+		logToConsole(LOG_DEBUG, `Setting ${getPlayerDisplayForConsole(client)}'s position to ${position.x}, ${position.y}, ${position.z}`);
+		sendPlayerSetPosition(client, position);
+	}
+
+	static getPlayerHeading(client) {
+		if(!areServerElementsSupported()) {
+			return getPlayerData(client).syncHeading;
+		} else {
+			if(getPlayerPed(client) != null) {
+				return getPlayerPed(client).heading;
+			}
+		}
+	}
+	static setPlayerHeading(client, heading) {
+		logToConsole(LOG_DEBUG, `Setting ${getPlayerDisplayForConsole(client)}'s heading to ${heading}`);
+		sendPlayerSetHeading(client, heading);
+	}
+
+	static getPlayerVehicle(client) {
+		if(!areServerElementsSupported())  {
+			return getPlayerData().syncVehicle;
+		} else {
+			if(getPlayerPed(client).vehicle) {
+				return getPlayerPed(client).vehicle;
+			}
+		}
+		return false;
+	}
+	static getPlayerDimension(client) {
+		if(!areServerElementsSupported()) {
+			return getPlayerData(client).syncDimension;
+		} else {
+			if(getPlayerPed(client) != null) {
+				return getPlayerPed(client).dimension;
+			}
+		}
+	}
+	static getPlayerInterior(client) {
+		return getPlayerCurrentSubAccount(client).interior || 0;
+	}
+
+	static setPlayerDimension(client, dimension) {
+		logToConsole(LOG_VERBOSE, `Setting ${getPlayerDisplayForConsole(client)}'s dimension to ${dimension}`);
+		if(!areServerElementsSupported()) {
+			getPlayerData(client).syncDimension = dimension;
+		} else {
+			if(getPlayerPed(client) != null) {
+				getPlayerPed(client).dimension = dimension;
+			}
+		}
+	}
+
+	static setPlayerInterior(client, interior) {
+		logToConsole(LOG_VERBOSE, `Setting ${getPlayerDisplayForConsole(client)}'s interior to ${interior}`);
+		sendPlayerSetInterior(client, interior);
+		if(isPlayerLoggedIn(client) && isPlayerSpawned(client)) {
+			getPlayerCurrentSubAccount(client).interior = interior;
+		}
+	}
+
+	static isPlayerInAnyVehicle(client) {
+		if(!areServerElementsSupported())  {
+			return (getPlayerData().syncVehicle != null);
+		} else {
+			return (getPlayerPed(client).vehicle != null);
+		}
+	}
+
+	static getPlayerVehicleSeat(client) {
+		if(!isPlayerInAnyVehicle(client)) {
+			return false;
+		}
+
+		if(!areServerElementsSupported()) {
+			return getPlayerData().syncVehicleSeat;
+		} else {
+			for(let i = 0 ; i <= 8 ; i++) {
+				if(getPlayerVehicle(client).getOccupant(i) == getPlayerPed(client)) {
+					return i;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	static isPlayerSpawned(client) {
+		return getPlayerData(client).spawned;
+	}
+
+	static getVehiclePosition(vehicle) {
+		return vehicle.position;
+	}
+
+	static getVehicleHeading(vehicle) {
+		return vehicle.heading;
+	}
+
+	static setVehicleHeading(vehicle, heading) {
+		if(getGame() == VRR_GAME_GTA_IV) {
+			return sendNetworkEventToPlayer("vrr.vehPosition", null, getVehicleForNetworkEvent(vehicle), heading);
+		}
+		return vehicle.heading = heading;
+	}
+
+	static getElementTransient(element) {
+		if(typeof element.transient != "undefined") {
+			return element.transient;
+		}
+		return false;
+	}
+
+	static setElementTransient(element, state) {
+		if(typeof element.transient != "undefined") {
+			element.transient = state;
+			return true;
+		}
+		return false;
+	}
+
+	static getVehicleSyncer(vehicle) {
+		return getElementSyncer(vehicle);
+	}
+
+	static getVehicleForNetworkEvent(vehicle) {
+		if(getGame() == VRR_GAME_GTA_IV) {
+			if(getVehicleData(vehicle).ivNetworkId != -1) {
+				return getVehicleData(vehicle).ivNetworkId;
+			}
+			return -1;
+		}
+		return vehicle.id;
+	}
+
+	static deleteGameElement(element) {
+		try {
+			if(element != null) {
+				destroyElement(element);
+				return true;
+			}
+		} catch(error) {
+			return false;
+		}
+	}
+
+	static isPlayerInFrontVehicleSeat(client) {
+		return (getPlayerVehicleSeat(client) == 0 || getPlayerVehicleSeat(client) == 1);
+	}
+
+	static removePlayerFromVehicle(client) {
+		logToConsole(LOG_DEBUG, `Removing ${getPlayerDisplayForConsole(client)} from their vehicle`);
+		sendPlayerRemoveFromVehicle(client);
+		return true;
+	}
+
+	static setPlayerSkin(client, skinIndex) {
+		logToConsole(LOG_DEBUG, `Setting ${getPlayerDisplayForConsole(client)}'s skin to ${getGameConfig().skins[getGame()][skinIndex][0]} (Index: ${skinIndex}, Name: ${getGameConfig().skins[getGame()][skinIndex][1]})`);
+		if(getGame() == VRR_GAME_GTA_IV) {
+			triggerNetworkEvent("vrr.localPlayerSkin", client, getGameConfig().skins[getGame()][skinIndex][0]);
+		} else {
+			getPlayerPed(client).modelIndex = getGameConfig().skins[getGame()][skinIndex][0];
+		}
+	}
+
+	static getPlayerSkin(client) {
+		return getSkinIndexFromModel(client.player.modelIndex);
+	}
+
+	static setPlayerHealth(client, health) {
+		logToConsole(LOG_DEBUG, `Setting ${getPlayerDisplayForConsole(client)}'s health to ${health}`);
+		sendPlayerSetHealth(client, health);
+		getServerData(client).health = health;
+	}
+
+	static getPlayerHealth(client) {
+		return getPlayerData(client).health;
+	}
+
+	static setPlayerArmour(client, armour) {
+		logToConsole(LOG_DEBUG, `Setting ${getPlayerDisplayForConsole(client)}'s armour to ${armour}`);
+		sendPlayerSetArmour(client, armour);
+		//client.player.armour = armour;
+	}
+
+	static getPlayerArmour(client) {
+		if(areServerElementsSupported(client)) {
+			return getPlayerPed(client).armour;
+		} else {
+			return getPlayerData(client).syncArmour;
+		}
+	}
+
+	static setPlayerCash(client, amount) {
+		if(client == null) {
+			return false;
+		}
+
+		if(isNaN(amount)) {
+			return false;
+		}
+
+		getPlayerCurrentSubAccount(client).cash = toInteger(amount);
+		updatePlayerCash(client);
+	}
+
+	static givePlayerCash(client, amount) {
+		if(client == null) {
+			return false;
+		}
+
+		if(isNaN(amount)) {
+			return false;
+		}
+
+		getPlayerCurrentSubAccount(client).cash = getPlayerCurrentSubAccount(client).cash + toInteger(amount);
+		updatePlayerCash(client);
+	}
+
+	static takePlayerCash(client, amount) {
+		if(client == null) {
+			return false;
+		}
+
+		if(isNaN(amount)) {
+			return false;
+		}
+
+		getPlayerCurrentSubAccount(client).cash = getPlayerCurrentSubAccount(client).cash - toInteger(amount);
+		updatePlayerCash(client);
+	}
+
+	static disconnectPlayer(client) {
+		logToConsole(LOG_DEBUG, `Disconnecting (kicking) ${getPlayerDisplayForConsole(client)}`);
+		disconnectPlayer(client);
+		return false;
+	}
+
+	static getElementSyncer(element) {
+		return getClients()[element.syncer];
+	}
+
+	static getPlayerWeaponAmmo(client) {
+		return getPlayerPed(client).weaponAmmunition;
+	}
+
+	static setPlayerVelocity(client, velocity) {
+		logToConsole(LOG_DEBUG, `Setting ${getPlayerDisplayForConsole(client)}'s velocity to ${velocity.x}, ${velocity.y}, ${velocity.z}`);
+		if(typeof getPlayerPed(client).velocity != "undefined") {
+			getPlayerPed(client).velocity = velocity;
+		}
+	}
+
+	static getPlayerVelocity(client) {
+		if(typeof getPlayerPed(client).velocity != "undefined") {
+			return getPlayerPed(client).velocity;
+		}
+		return toVector3(0.0, 0.0, 0.0);
+	}
+
+	static getElementDimension(element) {
+		if(typeof element.dimension != "undefined") {
+			return element.dimension;
+		}
+		return 0;
+	}
+
+	static setElementDimension(element, dimension) {
+		if(typeof element.dimension != "undefined") {
+			logToConsole(LOG_VERBOSE, `Setting element ${element} (${element.id}) dimension to ${dimension}`);
+			element.dimension = dimension;
+			return true;
+		}
+		return false;
+	}
+
+	static setElementRotation(element, rotation) {
+		if(typeof element.setRotation != "undefined") {
+			element.setRotation(rotation);
+		} else {
+			return element.rotation = rotation;
+		}
+	}
+
+	static givePlayerHealth(client, amount) {
+		if(getPlayerHealth(client)+amount > 100) {
+			logToConsole(LOG_DEBUG, `Setting ${getPlayerDisplayForConsole(client)}'s health to 100`);
+			setPlayerHealth(client, 100);
+		} else {
+			logToConsole(LOG_DEBUG, `Setting ${getPlayerDisplayForConsole(client)}'s health to ${getPlayerHealth(client)+amount}`);
+			setPlayerHealth(client, getPlayerHealth(client)+amount);
+		}
+	}
+
+	static givePlayerArmour(client, amount) {
+		if(getPlayerArmour(client)+amount > 100) {
+			logToConsole(LOG_DEBUG, `Setting ${getPlayerDisplayForConsole(client)}'s armour to 100`);
+			setPlayerArmour(client, 100);
+		} else {
+			logToConsole(LOG_DEBUG, `Setting ${getPlayerDisplayForConsole(client)}'s armour to ${getPlayerArmour(client)+amount}`);
+			setPlayerArmour(client, getPlayerArmour(client)+amount);
+		}
+	}
+
+	static consolePrint(text) {
+		console.log(text);
+	}
+
+	static consoleWarn(text) {
+		console.warn(text);
+	}
+
+	static consoleError(text) {
+		console.error(text);
+	}
+
+	static getPlayerName(client) {
+		return client.name;
+	}
+
+	static getServerName() {
+		return server.name;
+	}
+
+	static createGamePickup(modelIndex, position, type) {
+		if(!isGameFeatureSupported("pickups")) {
+			return false;
+		}
+		return game.createPickup(modelIndex, position, type);
+	}
+
+	static createGameBlip(position, type = 0, colour = toColour(255, 255, 255, 255)) {
+		if(!isGameFeatureSupported("blips")) {
+			return false;
+		}
+		return game.createBlip(type, position, 1, colour);
+	}
+
+	static createGameObject(modelIndex, position) {
+		if(!isGameFeatureSupported("objects")) {
+			return false;
+		}
+		return game.createObject(getGameConfig().objects[getGame()][modelIndex][0], position);
+	}
+
+	static setElementOnAllDimensions(element, state) {
+		if(!isNull(element) && element != false) {
+			if(typeof element.netFlags != "undefined") {
+				if(typeof element.netFlags.onAllDimensions != "undefined") {
+					element.netFlags.onAllDimensions = state;
+				}
+			} else {
+				if(typeof element.onAllDimensions != "undefined") {
+					element.onAllDimensions = state;
+				}
+			}
+		}
+	}
+
+	static destroyGameElement(element) {
+		if(!isNull(element) && element != false) {
+			destroyElement(element);
+		}
+	}
+
+	static isMeleeWeapon(weaponId, gameId = getGame()) {
+		return (getGameConfig().meleeWeapons[gameId].indexOf(weaponId) != -1);
+	}
+
+	static getPlayerLastVehicle(client) {
+		return getPlayerData(client).lastVehicle;
+	}
+
+	static isVehicleObject(vehicle) {
+		if(vehicle == null || vehicle == undefined) {
+			return false;
+		}
+		return (vehicle.type == ELEMENT_VEHICLE);
+	}
+
+	static repairVehicle(vehicle) {
+		vehicle.fix();
+	}
+
+	static setVehicleLights(vehicle, lights) {
+		setEntityData(vehicle, "vrr.lights", lights, true);
+		sendNetworkEventToPlayer("vrr.veh.lights", null, vehicle.id, lights);
+	}
+
+	static setVehicleEngine(vehicle, engine) {
+		vehicle.engine = engine;
+		setEntityData(vehicle, "vrr.engine", engine, true);
+	}
+
+	static setVehicleLocked(vehicle, locked) {
+		vehicle.locked = locked;
+	}
+
+	static setVehicleSiren(vehicle, siren) {
+		vehicle.siren = siren;
+	}
+
+	static getVehicleLights(vehicle) {
+		return vehicle.lights;
+	}
+
+	static getVehicleEngine(vehicle) {
+		return vehicle.engine;
+	}
+
+	static getVehicleLocked(vehicle) {
+		return vehicle.lockedStatus;
+	}
+
+	static getVehicleSiren(vehicle) {
+		return vehicle.siren;
+	}
+
+	static setVehicleColours(vehicle, colour1, colour2, colour3 = -1, colour4 = -1) {
+		vehicle.colour1 = colour1;
+		vehicle.colour2 = colour2;
+
+		if(colour3 != -1) {
+			vehicle.colour3 = colour3;
+		}
+
+		if(colour4 != -1) {
+			vehicle.colour4 = colour4;
+		}
+	}
+
+	static createGameVehicle(modelIndex, position, heading, toClient = null) {
+		if(areServerElementsSupported()) {
+			return game.createVehicle(getGameConfig().vehicles[getGame()][modelIndex][0], position, heading);
+		}
+	}
+
+	static createGameCivilian(modelIndex, position, heading, toClient = null) {
+		if(areServerElementsSupported()) {
+			let civilian = game.createCivilian(getGameConfig().skins[getGame()][modelIndex][0], 0);
+			if(!isNull(civilian)) {
+				civilian.position = position;
+				civilian.heading = heading;
+				addToWorld(civilian);
+				return civilian;
+			}
+		}
+
+		return false;
+	}
+
+	static getIsland(position) {
+		if(getGame() == VRR_GAME_GTA_III) {
+			if(position.x > 616) {
+				return VRR_ISLAND_PORTLAND;
+			} else if(position.x < -283) {
+				return VRR_ISLAND_SHORESIDEVALE;
+			}
+			return VRR_ISLAND_STAUNTON;
+		} else {
+			return VRR_ISLAND_NONE;
+		}
+
+		//return game.getIslandFromPosition(position);
+	}
+
+	static isValidVehicleModel(model) {
+		if(getVehicleModelIndexFromModel(model) != false) {
+			return true;
+		}
+
+		return false;
+	}
+
+	static setGameTime(hour, minute, minuteDuration = 1000) {
+		if(isTimeSupported()) {
+			game.time.hour = hour;
+			game.time.minute = minute;
+			game.time.minuteDuration = minuteDuration;
+		}
+	}
+
+	static setPlayerFightStyle(client, fightStyleId) {
+		if(!isPlayerSpawned(client)) {
+			return false;
+		}
+
+		if(!areFightStylesSupported()) {
+			return false;
+		}
+
+		setEntityData(getPlayerElement(client), "vrr.fightStyle", [getGameConfig().fightStyles[getGame()][fightStyleId][1][0], getGameConfig().fightStyles[getGame()][fightStyleId][1][1]]);
+		forcePlayerToSyncElementProperties(null, getPlayerElement(client));
+	}
+
+	static isPlayerAtGym(client) {
+		return true;
+	}
+
+	static getPlayerElement(client) {
+		return client.player;
+	}
+
+	static setElementPosition(element, position) {
+		sendNetworkEventToPlayer("vrr.elementPosition", null, element.id, position);
+	}
+
+	static getElementPosition(element) {
+		return element.position;
+	}
+
+	static getElementHeading(element) {
+		return element.heading;
+	}
+
+	static setElementInterior(element, interior) {
+		setEntityData(element, "vrr.interior", interior, true);
+		forcePlayerToSyncElementProperties(null, element);
+	}
+
+	static setElementCollisionsEnabled(element, state) {
+		sendNetworkEventToPlayer("vrr.elementCollisions", null, element.id, state);
+	}
+
+	static isTaxiVehicle(vehicle) {
+		if(taxiModels[getGame()].indexOf(vehicle.modelIndex) != -1) {
+			return true;
+		}
+
+		return false;
+	}
+
+	static getVehicleName(vehicle) {
+		let model = getElementModel(vehicle);
+		return getVehicleNameFromModel(model) || "Unknown";
+	}
+
+	static getElementModel(element) {
+		if(typeof element.modelIndex != "undefined") {
+			return element.modelIndex;
+		}
+
+		if(typeof element.model != "undefined") {
+			return element.model;
+		}
+	}
+
+	static givePlayerWeaponAmmo(client, ammo) {
+		givePlayerWeapon(client, getPlayerWeapon(client), getPlayerWeaponAmmo(client) + ammo);
+	}
+
+	static getPlayerWeapon(client) {
+		if(areServerElementsSupported(client)) {
+			return getPlayerPed(client).weapon;
+		} else {
+			return getPlayerData(client).syncWeapon;
+		}
+	}
+
+	static connectToDatabase() {
+		if(getDatabaseConfig().usePersistentConnection) {
+			if(persistentDatabaseConnection == null) {
+				logToConsole(LOG_DEBUG, `[VRR.Database] Initializing database connection ...`);
+				persistentDatabaseConnection = module.mysql.connect(getDatabaseConfig().host, getDatabaseConfig().user, getDatabaseConfig().pass, getDatabaseConfig().name, getDatabaseConfig().port);
+				if(persistentDatabaseConnection.error) {
+					logToConsole(LOG_ERROR, `[VRR.Database] Database connection error: ${persistentDatabaseConnection.error}`);
+					persistentDatabaseConnection = null;
+					return false;
+				}
+
+				logToConsole(LOG_DEBUG, `[VRR.Database] Database connection successful!`);
+				return persistentDatabaseConnection;
+			} else {
+				logToConsole(LOG_DEBUG, `[VRR.Database] Using existing database connection.`);
+				return persistentDatabaseConnection;
+			}
+		} else {
+			let databaseConnection = module.mysql.connect(getDatabaseConfig().host, getDatabaseConfig().user, getDatabaseConfig().pass, getDatabaseConfig().name, getDatabaseConfig().port);
+			if(databaseConnection.error) {
+				logToConsole(LOG_ERROR, `[VRR.Database] Database connection error: ${persistentDatabaseConnection.error}`);
+				return false;
+			} else {
+				return databaseConnection;
+			}
+		}
+	}
+
+	static disconnectFromDatabase(dbConnection) {
+		if(!getDatabaseConfig().usePersistentConnection) {
+			try {
+				dbConnection.close();
+				logToConsole(LOG_DEBUG, `[VRR.Database] Database connection closed successfully`);
+			} catch(error) {
+				logToConsole(LOG_ERROR, `[VRR.Database] Database connection could not be closed! (Error: ${error})`);
+			}
+		}
+		return true;
+	}
+
+	static queryDatabase(dbConnection, queryString, useThread = false) {
+		logToConsole(LOG_DEBUG, `[VRR.Database] Query string: ${queryString}`);
+		if(useThread == true) {
+			Promise.resolve().then(() => {
+				let queryResult = dbConnection.query(queryString);
+				return queryResult;
+			});
+		} else {
+			return dbConnection.query(queryString);
+		}
+	}
+
+	static escapeDatabaseString(dbConnection, unsafeString = "") {
+		if(!dbConnection) {
+			dbConnection = connectToDatabase();
+		}
+
+		if(typeof unsafeString == "string") {
+			return dbConnection.escapeString(unsafeString);
+		}
+		return unsafeString;
+	}
+
+	static getDatabaseInsertId(dbConnection) {
+		return dbConnection.insertId;
+	}
+
+	static getQueryNumRows(dbQuery) {
+		return dbQuery.numRows;
+	}
+
+	static getDatabaseError(dbConnection) {
+		return dbConnection.error;
+	}
+
+	static freeDatabaseQuery(dbQuery) {
+		if(dbQuery != null) {
+			dbQuery.free();
+		}
+		return;
+	}
+
+	static fetchQueryAssoc(dbQuery) {
+		return dbQuery.fetchAssoc();
+	}
+
+	static quickDatabaseQuery(queryString) {
+		let dbConnection = connectToDatabase();
+		let insertId = 0;
+		if(dbConnection) {
+			//logToConsole(LOG_DEBUG, `[VRR.Database] Query string: ${queryString}`);
+			let dbQuery = queryDatabase(dbConnection, queryString);
+			if(getDatabaseInsertId(dbConnection)) {
+				insertId = getDatabaseInsertId(dbConnection);
+				logToConsole(LOG_DEBUG, `[VRR.Database] Query returned insert id ${insertId}`);
+			}
+
+			if(dbQuery) {
+				try {
+					freeDatabaseQuery(dbQuery);
+					logToConsole(LOG_DEBUG, `[VRR.Database] Query result free'd successfully`);
+				} catch(error) {
+					logToConsole(LOG_ERROR, `[VRR.Database] Query result could not be free'd! (Error: ${error})`);
+				}
+			}
+
+			disconnectFromDatabase(dbConnection);
+
+			if(insertId != 0) {
+				return insertId;
+			}
+
+			return true;
+		}
+		return false;
+	}
+
+	static executeDatabaseQueryCommand(command, params, client) {
+		if(areParamsEmpty(params)) {
+			messagePlayerSyntax(client, getCommandSyntaxText(command));
+			return false;
+		}
+
+		if(!targetClient) {
+			messagePlayerError(client, "That player was not found!");
+			return false;
+		}
+
+		if(targetCode == "") {
+			messagePlayerError(client, "You didn't enter any code!");
+			return false;
+		}
+
+		let success = quickDatabaseQuery(params);
+
+		if(!success) {
+			messagePlayerAlert(client, `Database query failed to execute: {ALTCOLOUR}${query}`);
+		} else if(typeof success != "boolean") {
+			messagePlayeSuccess(client, `Database query successful: {ALTCOLOUR}${query}`);
+			messagePlayerInfo(client, `Returns: ${success}`);
+		} else {
+			messagePlayerSuccess(client, `Database query successful: {ALTCOLOUR}${query}`);
+		}
+		return true;
+	}
+
+	static setConstantsAsGlobalVariablesInDatabase() {
+		let dbConnection = connectToDatabase();
+		let entries = Object.entries(global);
+		for(let i in entries) {
+			logToConsole(LOG_DEBUG, `[VRR.Database] Checking entry ${i} (${entries[i]})`);
+			if(toString(i).slice(0, 3).indexOf("VRR_") != -1) {
+				logToConsole(LOG_DEBUG, `[VRR.Database] Adding ${i} (${entries[i]}) to database global variables`);
+			}
+		}
+	}
+
+	static createDatabaseInsertQuery(tableName, data) {
+		let fields = [];
+		let values = [];
+
+		for(let i in data) {
+			if(data[i][1] != "undefined" && data[i][1] != NaN && data[i][0] != 'NaN') {
+				if(data[i][1] != "undefined" && data[i][1] != NaN && data[i][1] != 'NaN') {
+					fields.push(data[i][0]);
+
+					if(typeof data[i][1] == "string") {
+						if(data[i][1] == "{UNIXTIMESTAMP}") {
+							values.push("UNIX_TIMESTAMP()");
+						} else {
+							values.push(`'${data[i][1]}'`);
+						}
+					} else {
+						values.push(data[i][1]);
+					}
+				}
+			}
+		}
+
+		let queryString = `INSERT INTO ${tableName} (${fields.join(", ")}) VALUES (${values.join(", ")})`;
+		return queryString;
+	}
+
+	static createDatabaseUpdateQuery(tableName, data, whereClause) {
+		let values = [];
+
+		for(let i in data) {
+			if(data[i][0] != "undefined" && data[i][0] != NaN && data[i][0] != 'NaN') {
+				if(data[i][1] != "undefined" && data[i][1] != NaN && data[i][1] != 'NaN') {
+					if(typeof data[i][1] == "string") {
+						if(data[i][1] == "{UNIXTIMESTAMP}") {
+							values.push(`${data[i][0]}=UNIX_TIMESTAMP()`);
+						} else {
+							values.push(`${data[i][0]}='${data[i][1]}'`);
+						}
+					} else {
+						values.push(`${data[i][0]}=${data[i][1]}`);
+					}
+				}
+			}
+		}
+
+		let queryString = `UPDATE ${tableName} SET ${values.join(", ")} WHERE ${whereClause}`;
+		return queryString;
+	}
+
+	static sendNetworkEventToPlayer(eventName, client, ...args) {
+		let argsArray = [eventName, client];
+		argsArray = argsArray.concat(args);
+		triggerNetworkEvent.apply(null, argsArray);
+	}
+
+	static addNetworkEventHandler(eventName, handlerFunction) {
+		addNetworkHandler(eventName, handlerFunction);
+	}
+
+	static getElementId(element) {
+		return element.id;
+	}
+
+	static getClientFromIndex(index) {
+		let clients = getClients();
+		for(let i in clients) {
+			if(clients[i].index == index) {
+				return clients[i];
+			}
+		}
+	}
+
+	static getClientsInRange(position, distance) {
+		return getPlayersInRange(position, distance);
+	}
+
+	static getCiviliansInRange(position, distance) {
+		return getElementsByTypeInRange(ELEMENT_PED, position, distance).filter(x => !x.isType(ELEMENT_PLAYER));
+	}
+
+	static getPlayersInRange(position, distance) {
+		return getClients().filter(x => getDistance(position, getPlayerPosition(x)) <= distance);
+	}
+
+	static getElementsByTypeInRange(elementType, position, distance) {
+		return getElementsByType(elementType).filter(x => getDistance(position, getElementPosition(x)) <= distance);
+	}
+
+	static getClosestCivilian(position) {
+		return getClosestElementByType(ELEMENT_PED, position).filter(ped => !ped.isType(ELEMENT_PLAYER));
+	}
+
+	static getVehiclesInRange(position, range) {
+		if(getGame() == VRR_GAME_GTA_IV) {
+			return getServerData().vehicles.reduce((i, j) => (getDistance(position, i.syncPosition) <= getDistance(position, j.syncPosition)) ? i : j);
+		}
+		return getElementsByTypeInRange(ELEMENT_VEHICLE, position, range);
+	}
+
+	static getClosestVehicle(position) {
+		return getClosestElementByType(ELEMENT_VEHICLE, position);
+	}
+
+	static getClosestElementByType(elementType, position) {
+		return getElementsByType(elementType).reduce((i, j) => (getDistance(position, getElementPosition(i)) <= getDistance(position, getElementPosition(j))) ? i : j);
+	}
+
+	static getVehicleFirstEmptySeat(vehicle) {
+		for(let i = 0; i <= 4; i++) {
+			if(vehicle.getOccupant(i) == null) {
+				return i;
+			}
+		}
+
+		return false;
+	}
+
+	static isVehicleTrain(vehicle) {
+		if(getGame() == VRR_GAME_GTA_III) {
+			if(vehicle.modelIndex == 124) {
+				return true;
+			}
+		}
+
+		return false
+	}
+
+	static warpPedIntoVehicle(ped, vehicle, seatId) {
+		ped.warpIntoVehicle(vehicle, seatId);
+	}
+
+	static getPlayerPing(client) {
+		return client.ping
+	}
+
+	static setVehicleHealth(vehicle, health) {
+		vehicle.health = 1000;
+	}
+
+	static givePlayerWeapon(client, weaponId, ammo, active = true) {
+		logToConsole(LOG_DEBUG, `[VRR.Client] Sending signal to ${getPlayerDisplayForConsole(client)} to give weapon (Weapon: ${weaponId}, Ammo: ${ammo})`);
+		sendNetworkEventToPlayer("vrr.giveWeapon", client, weaponId, ammo, active);
+	}
+
+	static setPlayerWantedLevel(client, wantedLevel) {
+		sendNetworkEventToPlayer("vrr.wantedLevel", client, wantedLevel);
+		return true;
+	}
+
+	static setElementStreamInDistance(element, distance) {
+		if(!isNull(element) && element != false) {
+			if(typeof element == "Entity") {
+				if(typeof element.streamInDistance != "undefined") {
+					element.streamInDistance = distance;
+				}
+			}
+		}
+	}
+
+	static setElementStreamOutDistance(element, distance) {
+		if(!isNull(element) && element != false) {
+			if(typeof element == "Entity") {
+				if(typeof element.streamOutDistance != "undefined") {
+					element.streamOutDistance = distance;
+				}
+			}
+		}
+	}
+
+	static getPlayerPed(client) {
+		if(getGame() == VRR_GAME_GTA_IV) {
+			return getPlayerData(client).ped;
+		} else {
+			return client.player;
+		}
+	}
+
+	static setEntityData(entity, dataName, dataValue, syncToClients = true) {
+		if(entity != null) {
+			if(areServerElementsSupported()) {
+				return entity.setData(dataName, dataValue, syncToClients);
+			}
+		}
+		return false;
+	}
+
+	static removeEntityData(entity, dataName) {
+		if(entity != null) {
+			if(areServerElementsSupported()) {
+				return entity.removeData(dataName);
+			}
+		}
+		return false;
+	}
+
+	static doesEntityDataExist(entity, dataName) {
+		if(entity != null) {
+			if(areServerElementsSupported()) {
+				return (entity.getData(dataName) != null);
+			} else {
+				return false;
+			}
+		}
+		return null;
+	}
+
+	static disconnectPlayer(client) {
+		client.disconnect();
+	}
+
+	static getPlayerId(client) {
+		return client.index;
+	}
+
+	static getPlayerIP(client) {
+		return client.ip;
+	}
+
+	static getPlayerGameVersion(client) {
+		client.gameVersion;
+	}
+
+	static setPlayerNativeAdminState(client, state) {
+		client.administrator = state;
+	}
+
+	static despawnPlayer(client) {
+		client.despawnPlayer();
+	}
+
+	static getGame() {
+		return server.game;
+	}
+
+	static getCountryNameFromIP(ip) {
+		if(module.geoip.getCountryName(ip)) {
+			return module.geoip.getCountryName(ip);
+		}
+		return false;
+	}
+
+	static getServerPort() {
+		return server.port;
+	}
+
+	static serverBanIP(ip) {
+		server.banIP(ip);
+	}
+
+	static setVehicleTrunkState(vehicle, trunkState) {
+		sendNetworkEventToPlayer("vrr.veh.trunk", null, getVehicleForNetworkEvent(vehicle), trunkState);
+	}
+
+	static addCommandHandler(command, params, client) {
+		addCommandHandler(command, params, client);
+	}
+
+	static removeCommandHandler(command, params, client) {
+		removeCommandHandler(command);
+	}
+
+	static onScriptInit() {
+		onScriptInit();
+	}
+
+	static onScriptExit() {
+		onScriptExit();
+	}
+
+	static onPlayerEnterVehicle() {
+		onPlayerEnterVehicle();
+	}
+
+	static onPlayerExitVehicle() {
+		onPlayerExitVehicle();
+	}
+};
+
+// ===========================================================================
+
+let builtInCommands = [
+	"refresh",
+	"restart",
+	"stop",
+	"start",
+	"reconnect",
+	"setname",
+	"connect",
+	"disconnect",
+	"say",
+	"dumpdoc",
+];
+
+// ===========================================================================
+
+let disconnectReasons = [
+	"Lost Connection",
+	"Disconnected",
+	"Unsupported Client",
+	"Wrong Game",
+	"Incorrect Password",
+	"Unsupported Executable",
+	"Disconnected",
+	"Banned",
+	"Failed",
+	"Invalid Name",
+	"Crashed",
+	"Modified Game"
+];
+
+// ===========================================================================