Serveur.tar

Tanoa-Server/0000777000000000000000000000000014004603021012054 5ustar  rootrootTanoa-Server/$PREFIX$0000777000000000000000000000001414003561131013106 0ustar  rootrootTanoa-ServerTanoa-Server/config.cpp0000777000000000000000000000041713535665003014052 0ustar  rootrootclass CfgPatches
{
	class TanoaServer
	{
		units[]={"C_man_1"};
		weapons[]={};
		requiredAddons[]={"extDB3"};
		fileName="Tanoa-Server.pbo";
		author[]={"Lyeed"};
	};
};

/* Functions */
#include "configs\functions.h"

/* Configs */
#include "configs\Config_Server.hpp"
Tanoa-Server/configs/0000777000000000000000000000000014004603013013505 5ustar  rootrootTanoa-Server/configs/Config_Server.hpp0000777000000000000000000001735514006054073016777 0ustar  rootrootclass Cfg_Server {

	/* PASSWORDS */
	rcon_password="NDE1gxLVJK";
	TFR_password="lOyXrlZLeo";

	/* TIME MULTIPLIERS */
	TimeMultiplier_day=5;
	TimeMultiplier_night=20;

	starting_time[]={
		2020,// year
		5,// month
		30,// day
		12,// hour
		0// minute
	};

	serverMods[]={// Local server modsCfgPatches
		"TanoaServer",
		"extDB3",
		"obfusqf",
		"ObfuSQF"
	};

	/* SHUTDOWN */
	rebootHours[]={// Local Time (hours)
		2,
		8,
		14,
		20
	};

	class dynamic_markers
	{
		champs[]=
		{
			{2365.32,11224.1,0.00163078},
			{3824.93,12537.2,0.00182343},
			{1663.96,12692.7,0.00143623},
			{1732.64,8281.58,0.00178719},
			{2432.65,5857.25,0.00166321},
			{2265.09,6764.44,0.00157547},
			{1997.65,3825.91,0.0014863},
			{2890.97,2599.48,0.0018692},
			{6644.15,4360.62,0.00143242},
			{8917.49,4614.93,0.00160503},
			{11130.4,3838.42,0.00190735},
			{10426.7,2946.13,0.00164413},
			{14597,10017.6,0.00129509},
			{13221.4,11780,0.00164652},
			{10954.3,9417.12,0.00180054},
			{10462.3,6793.03,0.00151634},
			{6209.22,8441.29,0.00156403},
			{8762.22,10917.3,0.0018425},
			{6336,8956.25,0.00102997},
			{4245.42,8247.01,0.00158167},
			{7821.38,13369.2,0.00156403},
			{7031.94,12937.3,0.00165558},
			{5574,11598.8,0.00154495},
			{8140.26,7305.32,0.00151634},
			{8377.1,10748.4,0.00156403},
			{10474.9,7946.95,0.00164795},
			{7071.03,11257.8,0.0018158},
			{7569.31,11919.4,0.001297},
			{7053.63,12921,0.00131226},
			{6814.52,6949.2,0.00140524},
			{6333.77,8950.37,0.00162506},
			{13081.1,7552.35,0.00149012},
			{8877.1,8059.07,0.00211334},
			{10199.1,7936,0.00153351},
			{7538.96,13275.3,0.00150776},
			{10952.4,12968.6,0.00188637},
			{9659.99,7099.09,0.00148773},
			{8277.43,9072.52,0.00186157},
			{4984.43,5103.79,0.00141716},
			{2789.8,6998.24,0.00130463},
			{3337.81,12853.3,0.0013752},
			{11732.5,4158.32,0.00149536}
		};

		stands_general[] =
		{
			{7790.95,10588.9,0.165443},
			{8421.89,10851.7,0.0477829},
			{8267.03,11146.4,0.00172424},
			{11179.3,11530.2,0.00143433},
			{11906.9,10317,0.258774},
			{13139.3,10504.3,0.00147247},
			{12905.4,7438.84,0.00137973},
			{11335.4,6593.49,0.00175476},
			{11352.7,7608.71,0.00124359},
			{6676.64,7002.31,0.00156689},
			{6029.49,8445.68,0.00131989},
			{5238.13,10070.4,0.00143886},
			{5754.37,10598,0.00138807},
			{6114.03,9892.13,0.00142479},
			{5868.58,9871.46,0.409147},
			{7632.87,11997.1,0.00140381},
			{9780.04,8490.43,0.00163269},
			{10882.8,8665.98,0.00143433},
			{7038.14,9719.05,0.00143433},
			{9580.36,9104.15,0.00219727},
			{11278.4,12304.7,0.00164795},
			{9593.15,13435,0.00235748},
			{10080.1,13568.4,0.00143886},
			{13924.9,12535.6,0.00144124},
			{13361.8,12428.9,0.00143886},
			{13286.3,12581.9,0.00143886},
			{12476.3,12099.5,0.150276},
			{14514.4,8896.71,2.32632},
			{7611.56,6881.72,0.001297},
			{12374.7,11234.6,0.00152588},
			{7952.05,12445.6,0.379898},
			{7113.81,11036,0.0591812},
			{5407.92,7563.82,0.00156704},
			{9277.74,9077.97,0.001297},
			{11182,9827.68,0.00138855},
			{3673.8,9568.74,0.00167274},
			{10595.1,14679.3,0.00120699},
			{9238.37,5982.97,0.00140464},
			{3761.61,14442.1,0.00146103},
			{724.439,11263.6,0.143232},
			{11348.6,1686.07,0.00159597},
			{12102.8,13130.4,0.00174153},
			{11190.1,14378.1,0.00143909},
			{13677.8,11234.1,0.00144196},
			{6329.45,12802.9,0.00144613},
			{2655.62,11728.2,0.178593},
			{1613.28,12454.6,0.153689},
			{1930.92,12379.1,0.269234},
			{2381.05,8195.42,0.00134373},
			{1504.28,6895.71,2.10801},
			{3996.28,6178.36,0.00131607},
			{5457.33,4003.01,0.00135708},
			{3648.41,2130.01,0.00143433},
			{2937.8,3395.92,0.00128555},
			{10244.7,2680.43,0.000408471},
			{11616.2,4494.65,0.00161743},
			{13268.3,2966.95,0.00144196},
			{12109.6,2481.69,0.00169539}
		};

		archeologie[] =
		{
			{10981.8,8502.67,0.00143433},
			{11069.8,8468.96,0.00143433},
			{11279,8462.52,0.00170898},
			{10972.2,8416.66,0.0610657},
			{11091.5,8426.71,0.231262}
		};

		pillage[] =
		{
			{10480.6,14137.3,3.09222},
			{4844.91,12906.9,3.81049},
			{4085.35,9996.95,1.98737}
		};

		recif[]=
		{
			{6011.56,14544.8,0.801867},
			{8919.8,14746.1,0.0110648},
			{8910.72,14907.3,0.257658},
			{9035.17,14719,1.21929}
		};

		rebels[]=
		{
			{2837.02,9020.92,0.00134659},
			{2547.68,8928.62,0.401365},
			{2546.84,9049.18,0.544365},
			{2551.98,9335.99,0.218096},
			{3743.7,9226.17,0.397479},
			{3673.79,9568.8,0.00180244},
			{6557.12,6321.36,0.00158906},
			{8611.42,4982.13,0.00147915},
			{13425.4,5207.8,0.00175858},
			{10741.1,14571.9,0.00157166},
			{11087.7,14523,0.00188255},
			{5624.17,1991.48,0.00189209},
			{5560.64,1970.11,0.00215912},
			{692.525,11383.4,0.00170755},
			{11165.5,14536.1,0.00130081},
			{5473.69,14553.3,0.00170231},
			{5803.28,13035.7,0.00139999},
			{4617.53,7980.12,0.00143886}
		};

		launder[]=
		{
			{5848.61,10064.9,0.509378},
			{5942.54,10211.3,0.0825872},
			{7490.55,7474.49,0.00123501},
			{5927.05,10547.2,0.262333},
			{5771.61,11016.4,4.14474},
			{5775.61,12640.1,0.083899},
			{6403.13,12789.9,0.145238},
			{6555.92,13090.5,0.0014267},
			{8507.28,12475.3,0.123337},
			{9312.24,13577.1,0.569777},
			{9880.3,13478.9,0.131184},
			{10690.3,13405.2,0.154701},
			{11631,13007,0.00145245},
			{12836,7345.11,0.00117612},
			{12841.3,7353.4,4.3948},
			{10646.3,6604.91,0.00146818},
			{8738.27,6539.07,0.000747919}
		};

		mushroom[]=
		{
			{11532,8111.13,0.000915527},
			{11736.7,9534.02,0.00189209},
			{11869.6,12222,0.00204468},
			{8203.89,11222.9,0.00230408},
			{7194.07,9576.26,0.00141907},
			{6161.28,11834,0.00146484},
			{12397.3,11271.8,0.00138855},
			{12658.9,8022.53,0.00151443},
			{9935.83,6647.4,0.00256348},
			{8880.83,13143.9,0.00100708}
		};

		volcano[]=
		{
			{9728.01,12259.4,0.00158691},
			{9811.04,12004.8,0.00170898},
			{9993.24,11914,-0.00012207},
			{10052.7,12086.1,0.000701904},
			{9998.17,12238.3,0.000762939},
			{10067.2,12215.4,0.00189209},
			{9914.01,12107.2,0.00152588},
			{9963.53,12267.5,0.0012207},
			{9912.25,11994.9,0.00149536},
			{10143.9,12010.2,0.00164795}
		};
	};

	class mission
	{
		class east_1
		{
			positions[]=
			{
				{{6820.75,7323.23,0.00143886}, 128.956},
				{{6845.7,7262.99,0.00144053}, 34.6326},
				{{13298.2,11995.7,0.00143886}, 114.663},
				{{14061.8,12207,0.00143886}, 147.692},
				{{11807.9,13083.5,0.00143909}, 102.569},
				{{5271.75,10027.1,0.00143886}, 359.438}
			};
		};
		class west_1: east_1 {};
		class guer_1: east_1 {};

		class reb_1
		{
			positions[]=
			{
				{{2520.13,9279.53,0.00119781},356.961},
				{{3645.99,9539.34,0.00161362},46.6127},
				{{3578.95,9084.37,0.00143051},32.6012},
				{{4037.02,9090.67,0.00135231},45.3719},
				{{5799.14,12992.6,0.0014143},282.974},
				{{5880.95,13075.9,0.00153637},62.874},
				{{5304.57,14480.5,0.00149012},129.926},
				{{5529.74,14535.8,0.00167322},126.317},
				{{7791.72,14825.3,0.00128937},82.0768},
				{{8093.14,14819.5,-0.204538},244.784},
				{{7948.93,14940.3,0.00137052},351.922},
				{{10529.7,14602.9,0.0017122},255.219},
				{{11243.6,14533.2,0.00168276},272.314},
				{{11522.1,14356.2,0.00135088},66.8374},
				{{12864.6,5448.41,0.00158596},263.807},
				{{13409.9,5191.95,0.00161362},266.665},
				{{8870.03,1133.24,0.000878334},358.017},
				{{8363.41,1284.3,0.00184631},232.859},
				{{8301.42,1130.7,0.00193357},131.691},
				{{5620.4,1989.59,0.00172424},314.369},
				{{5401.67,1874.93,0.00186729},62.4257},
				{{4719.29,1404.99,0.0016613},123.903},
				{{4813.72,1425.16,0.00150299},122.81},
				{{2267.8,1653.96,0.00150347},78.1164},
				{{1597.93,920.289,0.00141573},312.436},
				{{1337.3,2619.58,0.00151062},329.16},
				{{897.39,11294.1,0.00147057},80.7956},
				{{2809.96,8698.59,0.00162005},233.432},
				{{2604.86,8177.57,0.00146079},236.737},
				{{4623.21,7967.73,0.00141668},216.518},
				{{4601.52,7476.1,0.00143886},312.144},
				{{6537.74,6274.67,0.00127029},106.486}
			};
		};
		class reb_2: reb_1 {};
	};
};
Tanoa-Server/configs/functions.h0000777000000000000000000001152214004603013015672 0ustar  rootrootclass CfgFunctions
{

	class ServerDB
	{
		tag = "EXTDB3";
		class Functions
		{
			file = "Tanoa-Server\extDB3";
			class async {};
			class init {};
		};
	};

	class RCON
	{
		tag = "RCON";
		class Functions
		{
			file = "Tanoa-Server\RCON";
			class sendCommand {};
		};
	};

	class Server
	{
		tag = "AlysiaServer";

		class global
		{
			file = "Tanoa-Server";
			class serverSave {};
			class initServer {};
			class initHC {};
		};

		class inits
		{
			file = "Tanoa-Server\inits";
			class taxes_init {};
			class atm_init {};
			class fuel_init {};
			class buildings_init {};
			class vehicles_init {};
			class time_init {};
		};
		class saves
		{
			file = "Tanoa-Server\saves";
			class atm_save {};
			class fuel_save {};
			class taxes_save {};
			class vehicles_save {};
			class time_save {};
		};

		class Cleanups
		{
			file = "Tanoa-Server\core\Cleanups";
			class cleanup_deadVehicles {};
			class cleanup_things {};
			class cleanup_vehicles {};
			class cleanup_init {};
			class cleanup_houseStorages {};
			class cleanup_companyStorages {};
		};

		class C4
		{
			file = "Tanoa-Server\core\c4";
			class c4_bomb {};
		};

		class Fireworks
		{
			file = "Tanoa-Server\core\Fireworks";
			class fireworks {};
		};

		class Companies
		{
			file = "Tanoa-Server\core\Companies";
			class company_insert {};
			class companies_init {};
			class company_init {};
			class companies_save {};
			class company_fetch {};
			class company_build {};
			class company_perquisition {};
			class company_launder {};
			class construction_init {};
			class company_bank_handle {};
			class company_history_get {};
			class company_history_clear {};
			class company_destroy {};
		};

		class dynamicMarkers
		{
			file = "Tanoa-Server\core\dynamicMarkers";
			class dynamicMarkers_init {};
			class dynamicMarkers_update {};
			class dynamicMarkers_create {};
			class dynamicMarkers_getPos {};
		};

		class Garage
		{
			file = "Tanoa-Server\core\Garage";
			class garageVehicles {};
			class garageVehicleSpawn {};
			class garageVehicleStore {};
		};

		class Phone
		{
			file = "Tanoa-Server\core\Phone";
			class phoneInit {};
			class phoneMessageHandler {};
			class phoneMessageSave {};
		};

		class Factions
		{
			file = "Tanoa-Server\core\Factions";
			class factionsInit {};
			class factionsSave {};
			class factionHistoryGet {};
			class factionHistoryClean {};
			class factionHistoryAdd {};
			class factionMemberList {};
			class factionMemberModify {};
			class factionBankHandle {};
			class faction_mission {};
		};

		class Vehicles
		{
			file = "Tanoa-Server\core\Vehicles";
			class vehicleCreate {};
			class vehicleDelete {};
			class vehicle_update_insurrance {};
			class vehicle_update_storePos {};
			class vehicle_update_fuel {};
			class vehicle_update_name {};
			class vehicle_update_owner {};
		};

		class Systems
		{
			file = "Tanoa-Server\core\Systems";
			class clientDisconnect {};
			class keyManagement {};
			class spikeStrip {};
			class whitelistRebels {};
		};

		class Tools
		{
			file = "Tanoa-Server\core\Tools";
			class bool {};
			class mresArray {};
			class mresString {};
			class mresToArray {};
			class numberSafe {};
			class getRealTime {};
		};

		class Log
		{
			file = "Tanoa-Server\core\Log";
			class logRefund {};
			class logLaunder {};
			class logDeath {};
			class logBuypassWhitelist {};
			class logDeathDisconnect {};
			class logComa {};
			class logDeadVehicles {};
			class logTrade {};
			class logTemporyInventory {};
			class logPerquisition {};
			class logHouseSell {};
			class logHouseBuy {};
			class logSuicide {};
		};

		class MySQL
		{
			file = "Tanoa-Server\core\MySQL";
			class query_insert_inscription {};
			class query_select_connect {};
			class query_update_usual {};
			class query_update_disconnect {};
			class query_update_partial {};
			class query_delete_wipe {};
		};

		class Market
		{
			file = "Tanoa-Server\core\Market";
			class market_init {};
			class market_loop {};
			class market_save {};
			class market_setPrice {};
		};

		class Laboratories
		{
			file = "Tanoa-Server\core\Laboratories";
			class laboratory_fetch {};
			class laboratory_destroy {};
			class laboratory_insert {};
			class laboratory_build {};
			class laboratory_init_construction {};
			class laboratory_init {};
			class laboratories_init {};
			class laboratories_save {};
		};

		class Housing
		{
			file = "Tanoa-Server\core\Housing";
			class house_add {};
			class house_init {};
			class house_init_storage {};
			class house_save_storage {};
			class house_sell {};
			class house_tenants_add {};
			class house_save {};
			class house_fetch {};
			class house_perquisition {};
		};
	};
};
Tanoa-Server/core/0000777000000000000000000000000014003561131013010 5ustar  rootrootTanoa-Server/core/C4/0000777000000000000000000000000014003561130013255 5ustar  rootrootTanoa-Server/core/C4/fn_c4_bomb.sqf0000777000000000000000000000335314002277764016007 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_object", "_vehicle", "_time"];
_object = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_time = [_this, 1, 0, [0]] call BIS_fnc_param;

if (isNull _object) exitWith {};

uiSleep _time;

"R_80mm_HE" createVehicle (getPosATL _object);

_vehicle = attachedTo _object;
if (!(isNull _vehicle)) then
{
	detach _object;
	switch typeOf(_vehicle) do
	{
		case "shounka_a3_brinks_noir":
		{
			_count = [(_vehicle getVariable ["Trunk", []]), "money_transfer"] call AlysiaClient_fnc_itemTrunk;
			if (_count > 0) then
			{
				for "_i" from 1 to _count do
				{
					_position = (getPos _vehicle) findEmptyPosition [0, 20, "Land_Suitcase_F"];
					if (!(_position isEqualTo [])) then
					{
						_bag = "Land_Suitcase_F" createVehicle _position;
						_bag setVariable ["money_bank", true, true];
					};
				};
			};
			_vehicle setVariable ["Trunk", [], true];
		};
		case "Bank_Sahrani_N":
		{
			_vehicle animate ["Vault_Door", 1];
			[_vehicle, "bankAlarm"] call AlysiaClient_fnc_globalSay3d;

			[
				"Alerte !<br/>La porte de <t color='#FF8000'>la salle des coffres</t> de la banque vient d'imploser.<br/>Les braqueurs vont s'emparer de l'argent, sauvez le contribuable !",
				"BANQUE"
			] remoteExecCall ["AlysiaClient_fnc_phone_message_receive", west];
		};
		case "Bank_Sahrani_S":
		{
			_vehicle animate ["Vault_Door", 1];
			[_vehicle, "bankAlarm"] call AlysiaClient_fnc_globalSay3d;

			[
				"Alerte !<br/>La porte de <t color='#FF8000'>la salle des coffres</t> de la banque vient d'imploser.<br/>Les braqueurs vont s'emparer de l'argent, notre Leader vous ordonne de les arrêter !",
				"BANQUE"
			] remoteExecCall ["AlysiaClient_fnc_phone_message_receive", east];
		};
	};
};

deleteVehicle _object;
Tanoa-Server/core/Cleanups/0000777000000000000000000000000014004603021014556 5ustar  rootrootTanoa-Server/core/Cleanups/fn_cleanup_companyStorages.sqf0000777000000000000000000000107313535665003022665 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_targets";
_targets =  [_this, 0, [], [[]]] call BIS_fnc_param;

if (_targets isEqualTo []) then
{
	_targets = gServer_companies;
};

{
	_storage = _x getVariable ["company_storage_out", objNull];
	if (!(isNull _storage)) then
	{
		_x setVariable ["company_inv_virtual", (_storage getVariable ["Trunk", []]), true];
		_x setVariable ["company_inv_arma", ([getWeaponCargo _storage, getMagazineCargo _storage, getItemCargo _storage, getBackpackCargo _storage]), true];
		deleteVehicle _storage;
	};
} forEach _targets;
Tanoa-Server/core/Cleanups/fn_cleanup_deadVehicles.sqf0000777000000000000000000000066014002300036022046 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

{
	if ((_x isKindOf "Car") || (_x isKindOf "Ship") || (_x isKindOf "Air") || (_x isKindOf "Tank")) then
	{
		if (!(alive _x) || ((damage _x) >= 1)) then
		{
			_info = _x getVariable "info";
			if (!(isNil "_info")) then
			{
				[_x] call AlysiaServer_fnc_logDeadVehicles;
				[_info, true] call AlysiaServer_fnc_vehicleDelete;
			};

			deleteVehicle _x;
		};
	};
} forEach vehicles;
Tanoa-Server/core/Cleanups/fn_cleanup_houseStorages.sqf0000777000000000000000000000073614002300036022325 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_targets";
_targets =  [_this, 0, [], [[]]] call BIS_fnc_param;

if (_targets isEqualTo []) then
{
	_targets = gServer_houses;
};

{
	_id = (_x getVariable "house_owner") select 2;
	if (!(isNil "_id")) then
	{
		_storage = missionNamespace getVariable [format["house_storage_out_%1", _id], objNull];
		if (!(isNull _storage)) then
		{
			[_x, _storage] call AlysiaServer_fnc_house_save_storage;
		};
	};
} forEach _targets;
Tanoa-Server/core/Cleanups/fn_cleanup_init.sqf0000777000000000000000000000067214002300036020434 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[CLEANUP] Setup";

[] spawn
{
	while {!gServer_soonReboot} do
	{
		uiSleep(60 * 2);
		[] call AlysiaServer_fnc_cleanup_deadVehicles;
	};
};

[] spawn
{
	while {!gServer_soonReboot} do
	{
		diag_log "[CLEANUP] loop cleanup vehicules & items";
		[] call AlysiaServer_fnc_cleanup_things;
		[] call AlysiaServer_fnc_cleanup_vehicles;
		uiSleep(60 * 10);
	};
};

diag_log "[CLEANUP] Ready";
Tanoa-Server/core/Cleanups/fn_cleanup_things.sqf0000777000000000000000000000053513535665003021005 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

{
	if (typeOf(_x) isEqualTo "Skyline_Alysia_Boite_01_F") then
	{
		_count = _x getVariable ["afk_count", 0];
		if (_count < 1) then {
			_x setVariable ["afk_count", (_count + 1)];
		} else {
			diag_log "[CLEANUP] Suitcase removed";
			deleteVehicle _x;
		};
	};
} forEach (allMissionObjects "Thing");
Tanoa-Server/core/Cleanups/fn_cleanup_vehicles.sqf0000777000000000000000000000365114004603021021275 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

{
	if (alive _x) then
	{
		if (isNull (driver _x)) then
		{
			_pos = _x getVariable ["afk_pos", [0, 0, 0]];
			if ((_pos distance (getPos _x)) < 8) then
			{
				_count = _x getVariable ["afk_count", 0];
				if (_count >= 30) then
				{
					_storePos = switch (true) do
					{
						case (_x isKindOf "Air"): {getMarkerPos "fourriere_marker_2"};
						case (_x isKindOf "Ship"): {getMarkerPos "fourriere_marker_3"};
						default {getMarkerPos "fourriere_marker_1"};
					};

					[_x, _storePos, false] call AlysiaServer_fnc_garageVehicleStore;
					diag_log "[CLEANUP] Vehicule";
				} else {
					if (_count isEqualTo -1) then
					{
						_info = _x getVariable "info";
						if (!(isNil "_info")) then
						{
							_owner = [_info select 0] call AlysiaClient_fnc_getPlayerFromUID;
							if (!(isNull _owner)) then
							{
								[
									format
									[
											"Votre véhicule <t color='#FE9A2E'>%1</t> en <t color='#FACC2E'>%2</t> est resté inactif depuis 90 minutes.<br/>"
										+	"Si vous ne le bougez pas de plus de <t color='#01DF01'>10 mètres</t> d'ici 10 minutes, votre véhicule sera envoyé automatiquement en <t color='#AC58FA'>fourrière</t> par le serveur.<br/>"
										+	"Son inventaire ne sera <t color='#FE2E64'>pas sauvegardé</t>.",
										getText(configFile >> "CfgVehicles" >> typeof(_x) >> "displayName"),
										mapGridPosition _x
									]
								] remoteExecCall ["AlysiaClient_fnc_info", (owner _owner)];
							};
						};
					};

					_x setVariable ["afk_count", (_count + 1)];
				};
			} else {
				_x setVariable ["afk_pos", (getPos _x)];
				_x setVariable ["afk_count", 0];
			};
		} else {
			_x setVariable ["afk_pos", (getPos _x)];
			_x setVariable ["afk_count", 0];
		};
	};
} forEach ((allMissionObjects "LandVehicle") + (allMissionObjects "Air") + (allMissionObjects "Ship"));
Tanoa-Server/core/Companies/0000777000000000000000000000000014003561130014725 5ustar  rootrootTanoa-Server/core/Companies/fn_companies_init.sqf0000777000000000000000000000370714002300036021131 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[COMPANIES] Setup";

gServer_companies = [];

{
	private "_object";
	if ((_x select 9) isEqualTo 0) then
	{
		_object =
		[
			(_x select 0),
			(_x select 1),
			(_x select 2),
			(_x select 4),
			(_x select 11),
			[(_x select 5), (_x select 6), (_x select 7)],
			(_x select 8),
			[(_x select 10)] call AlysiaServer_fnc_mresToArray
		] call AlysiaServer_fnc_construction_init;
	} else {
		_object =
		[
			(_x select 0),
			(_x select 1),
			(_x select 2),
			(_x select 4),
			(_x select 11),
			[(_x select 5), (_x select 6), (_x select 7)],
			(_x select 8),
			[(_x select 12)] call AlysiaServer_fnc_mresToArray,
			(_x select 3),
			[(_x select 13)] call AlysiaServer_fnc_mresToArray,
			[(_x select 14)] call AlysiaServer_fnc_mresToArray,
			[format["SELECT TRANS_from,TRANS_date,TRANS_type,TRANS_value,TRANS_reason FROM companies_bank_transactions WHERE COMPANY_plate='%1'", (_x select 4)], 2] call ExtDB3_fnc_async,
			(_x select 15)
		] call AlysiaServer_fnc_company_init;
	};

	gServer_companies pushBack _object;
	diag_log format["Company [%1] | Type [%4] | Owner [%2] | Bank [%3]", (_x select 0), (_x select 1), (_x select 3), (_x select 2)];
} forEach (["SELECT companies.name,companies.owner,companies.type,companies.bank,companies.plate,companies.POS_x,companies.POS_y,companies.POS_z,companies.POS_direction,companies.CONSTRUCTION_built,companies.CONSTRUCTION_require,players.profileName,companies.members,companies.INV_virtual,companies.INV_arma,companies.link_percentage FROM companies INNER JOIN players ON companies.owner=players.uid", 2] call ExtDB3_fnc_async);
/*
	0 - name
	1 - owner
	2 - type
	3 - bank
	4 - plate
	5 - POS_x
	6 - POS_y
	7 - POS_z
	8 - POS_direction
	9 - CONSTRUCTION_built
	10 - CONSTRUCTION_require
	11 - owner name
	12 - members
	13 - INV_virtual
	14 - INV_arma
	15 - link_percentage
*/

diag_log format["%1 companie(s) loaded", count(gServer_companies)];

diag_log "[COMPANIES] Ready";
Tanoa-Server/core/Companies/fn_companies_save.sqf0000777000000000000000000000371514002300036021123 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[COMPANIES] Saving ...";

diag_log " Cleaning companies_bank_transactions table...";
["DELETE FROM companies_bank_transactions", 1] call ExtDB3_fnc_async;

{
	_info = _x getVariable ["company_info", []];
	if (_info isEqualTo []) then {
		diag_log format["[ERROR] Can't save company %1 (no info)", _x];
	} else {
		_bank = _x getVariable ["company_bank", 0];
		diag_log format["Saving company [%1] | Type [%2] | Owner [%3] | Bank [%4]", (_info select 0), (_info select 2), (_info select 1), _bank];

		if (_x getVariable ["construction", false]) then
		{
			[
				format
				[
					"UPDATE companies SET bank='%1',CONSTRUCTION_require='%2',CONSTRUCTION_built='0' WHERE plate='%3'",
					_bank,
					[(_x getVariable ["construction_require", []])] call AlysiaServer_fnc_mresArray,
					(_info select 3)
				], 1
			] call ExtDB3_fnc_async;
		} else {
			[
				format
				[
					"UPDATE companies SET bank='%1',CONSTRUCTION_built='1',CONSTRUCTION_require='""[]""',members='%3',INV_virtual='%4',owner='%5',INV_arma='%6',link_percentage='%7' WHERE plate='%2'",
					_bank,
					(_info select 3),
					[(_x getVariable ["company_members", []])] call AlysiaServer_fnc_mresArray,
					[(_x getVariable ["company_inv_virtual", []])] call AlysiaServer_fnc_mresArray,
					(_info select 1),
					[(_x getVariable ["company_inv_arma", []])] call AlysiaServer_fnc_mresArray,
					(_x getVariable ["company_link_percentage", 0])
				], 1
			] call ExtDB3_fnc_async;

			{
				[
					format
					[
						"INSERT INTO companies_bank_transactions (COMPANY_plate,TRANS_from,TRANS_date,TRANS_type,TRANS_value,TRANS_reason) VALUES ('%1','%2','%3','%4','%5','%6')",
						(_info select 3),
						(_x select 0),
						(_x select 1),
						(_x select 2),
						(_x select 3),
						(_x select 4)
					], 1
				] call ExtDB3_fnc_async;
			} forEach (_x getVariable ["company_bank_history", []]);
		};
	};
} forEach gServer_companies;

diag_log "[COMPANIES] Saved";
Tanoa-Server/core/Companies/fn_company_bank_handle.sqf0000777000000000000000000000207414002300036022100 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_value", "_type", "_amount", "_from", "_reason"];
_company = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_type = [_this, 1, false, [false]] call BIS_fnc_param;
_value = round([_this, 2, 0, [0]] call BIS_fnc_param);
_from = [_this, 3, "Inconnu", [""]] call BIS_fnc_param;
_reason = [_this, 4, "Inconnu", [""]] call BIS_fnc_param;

if ((isNull _company) || (_value isEqualTo 0)) exitWith {};

waitUntil {!(_company getVariable ["company_bank_active", false])};

_company setVariable ["company_bank_active", true];
_amount = _company getVariable ["company_bank", 0];
if (_type) then {
	_amount = _amount + _value;
} else {
	if (_value < _amount) then {
		_amount = _amount - _value;
	} else {
		_amount = 0;
	};
};

_company setVariable ["company_bank", _amount, true];
_company setVariable ["company_bank_history", (_company getVariable ["company_bank_history", []]) + [[_from, (call AlysiaClient_fnc_strDate), ([_type, 0] call AlysiaServer_fnc_bool), _value, _reason]]];
_company setVariable ["company_bank_active", false];
Tanoa-Server/core/Companies/fn_company_build.sqf0000777000000000000000000000137614002300036020755 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_object", "_info", "_owner", "_company"];
_object = [_this, 0, objNull, [objNull]] call BIS_fnc_param;

if (isNull _object) exitWith {};

_info = _object getVariable "company_info";

_company = [
	(_info select 0),
	(_info select 1),
	(_info select 2),
	(_info select 3),
	(_info select 4),
	getPos _object,
	getDir _object,
	[[(_info select 1)], [(_info select 4)]],
	0,
	[],
	[[],[],[],[]],
	[]
] call AlysiaServer_fnc_company_init;

gServer_companies set [(gServer_companies find _object), _company];

deleteVehicle _object;

_owner = [(_info select 1)] call AlysiaClient_fnc_getPlayerFromUID;
if (!(isNull _owner)) then {
	[_company, true] remoteExecCall ["AlysiaClient_fnc_company_member_join", _owner];
};
Tanoa-Server/core/Companies/fn_company_destroy.sqf0000777000000000000000000000133714002277764021371 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_object", "_info", "_owner"];
_object = [_this, 0, objNull, [objNull]] call BIS_fnc_param;

if (isNull _object) exitWith {};

_info = _object getVariable "company_info";
if (isNil "_info") exitWith {};

_marker = format ["Marker_Entreprise_%1", _info select 3];
deleteMarker _marker;

gServer_companies deleteAt (gServer_companies find _object);
deleteVehicle _object;

[format["DELETE FROM companies WHERE plate='%1'", (_info select 3)], 1] call ExtDB3_fnc_async;

_owner = [(_info select 1)] call AlysiaClient_fnc_getPlayerFromUID;
if (!(isNull _owner)) then {
	["Votre entreprise a été <t color='#FF8000'>supprimée</t>."] remoteExecCall ["AlysiaClient_fnc_info", _owner];
};
Tanoa-Server/core/Companies/fn_company_fetch.sqf0000777000000000000000000000056113535665003020764 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_uid", "_object"];
_uid = [_this, 0, "", [""]] call BIS_fnc_param;

if (_uid isEqualTo "") exitWith {objNull};

_object = objNull;

{
	if (
			!(_x getVariable ["construction", false]) &&
			(_uid in ((_x getVariable "company_members") select 0))
		) exitWith {_object = _x};
} forEach gServer_companies;

_object;
Tanoa-Server/core/Companies/fn_company_history_clear.sqf0000777000000000000000000000104014002277764022536 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_company", "_from", "_info"];
_company = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_from = [_this, 1, objNull, [objNull]] call BIS_fnc_param;

if (isNull _company) exitWith {};

_info = _company getVariable "company_info";
if (isNil "_info") exitWith {};

_company setVariable ["company_bank_history", []];
if (!(isNull _from)) then {
	[format["Le livre des comptes de l'entreprise %1 a été vidé.", (_info select 0)]] remoteExecCall ["AlysiaClient_fnc_info", (owner _from)];
};
Tanoa-Server/core/Companies/fn_company_history_get.sqf0000777000000000000000000000061214002277764022233 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_company", "_from"];
_company = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_from = [_this, 1, objNull, [objNull]] call BIS_fnc_param;

if ((isNull _company) || (isNull _from)) exitWith {};

[(_company getVariable ["company_bank_history", []]), _company] remoteExecCall ["AlysiaClient_fnc_company_bank_history_open", (owner _from)];
Tanoa-Server/core/Companies/fn_company_init.sqf0000777000000000000000000000445714003561203020632 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_name", "_owner", "_type", "_plate", "_owner_name", "_position", "_direction", "_members", "_cash", "_object", "_inventory_virtual", "_inventory_arma", "_bank_history", "_link_percentage"];
_name = [_this, 0, "", [""]] call BIS_fnc_param;
_owner = [_this, 1, "", [""]] call BIS_fnc_param;
_type = [_this, 2, "", [""]] call BIS_fnc_param;
_plate = [_this, 3, "", [""]] call BIS_fnc_param;
_owner_name = [_this, 4, "", [""]] call BIS_fnc_param;
_position = [_this, 5, [], [[]]] call BIS_fnc_param;
_direction = [_this, 6, 0, [0]] call BIS_fnc_param;
_members = [_this, 7, [], [[]]] call BIS_fnc_param;
_cash = [_this, 8, 0, [0]] call BIS_fnc_param;
_inventory_virtual = [_this, 9, [], [[]]] call BIS_fnc_param;
_inventory_arma = [_this, 10, [[],[],[],[]], [[]]] call BIS_fnc_param;
_bank_history = [_this, 11, [], [[]]] call BIS_fnc_param;
_link_percentage = [_this, 12, 0, [0]] call BIS_fnc_param;

_object = getText(missionConfigFile >> "ADENIS_COMPANIES_TYPES" >> _type >> "building") createVehicle _position;
_object setDir _direction;

if (_cash > 0) then {
	_object setVariable ["company_bank", _cash, true];
};

if (count(_bank_history) > 0) then {
	_object setVariable ["company_bank_history", _bank_history];
};

if (count(_inventory_virtual) > 0) then {
	_object setVariable ["company_inv_virtual", _inventory_virtual, true];
};
_object setVariable ["company_inv_arma", _inventory_arma, true];

_object setVariable ["company_members", _members, true];
_object setVariable ["company_info", [_name, _owner, _type, _plate, _owner_name], true];
/*
	0 - name
	1 - owner
	2 - type
	3 - plate
	4 - owner name
*/

if (count(getArray(missionConfigFile >> "ADENIS_COMPANIES_TYPES" >> _type >> "ressources_link")) > 0) then {
	_object setVariable ["company_link_percentage", _link_percentage, true];
};

for "_i" from 1 to getNumber(configFile >> "CfgVehicles" >> (typeOf _object) >> "numberOfDoors") do
{
	_object animate [format["door_%1_rot", _i], 0];
	_object setVariable [format["bis_disabled_Door_%1", _i], 1, true];
};

_marker = createMarker [ format ["Marker_Entreprise_%1", _plate] , _object];
_marker setMarkerShape "ICON";
_marker setMarkerType "loc_Box";
_marker setMarkerColor "ColorWhite";
_marker setMarkerText _name;
_object setVariable ["status_entreprise", false, true];

_object;
Tanoa-Server/core/Companies/fn_company_insert.sqf0000777000000000000000000000244614003561203021167 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_type", "_position", "_object", "_owner", "_plate", "_name", "_dir", "_require"];
_type = [_this, 0, "", [""]] call BIS_fnc_param;
_object = [_this, 1, objNull, [objNull]] call BIS_fnc_param;
_owner = [_this, 2, objNull, [objNull]] call BIS_fnc_param;
_name = [_this, 3, "", [""]] call BIS_fnc_param;

if ((_type isEqualTo "") || (isNull _object) || (isNull _owner) || (_name isEqualTo "")) exitWith {};

_position = getPos _object;
_dir = getDir _object;
_require = getArray(missionConfigFile >> "ADENIS_COMPANIES_BUILDINGS" >> typeOf(_object) >> "construction");
_plate = str(round(random(999999)));

[
	format
	[
		"INSERT INTO companies (name,owner,type,plate,POS_x,POS_y,POS_z,POS_direction,members,CONSTRUCTION_require,INV_virtual,INV_arma) VALUES ('%1','%2','%3','%4','%5','%6','%7','%8','""[[],[]]""','%9','""[]""','""[[],[],[],[]]""')",
		_name,
		getPlayerUID _owner,
		_type,
		_plate,
		_position select 0,
		_position select 1,
		_position select 2,
		_dir,
		[_require] call AlysiaServer_fnc_mresArray
	], 1
] call ExtDB3_fnc_async;

gServer_companies pushBack ([_name, (getPlayerUID _owner), _type, _plate, (_owner getVariable ["realname", (name _owner)]), _position, _dir, _require] call AlysiaServer_fnc_construction_init);
deleteVehicle _object;
Tanoa-Server/core/Companies/fn_company_launder.sqf0000777000000000000000000000113214002300036021276 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_amount", "_target", "_from", "_reason"];
_target = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_amount = [_this, 1, 0, [0]] call BIS_fnc_param;
_from = [_this, 2, "Inconnu", [""]] call BIS_fnc_param;
_reason = [_this, 3, "Inconnu", [""]] call BIS_fnc_param;

if ((_amount isEqualTo 0) || (isNull _target)) exitWith {};

_target setVariable ["launder", true, true];
uiSleep(round(random(20) * 60) + (4 * 60));
_target setVariable ["launder", false, true];

[_target, true, _amount, _from, _reason] call AlysiaServer_fnc_company_bank_handle;
Tanoa-Server/core/Companies/fn_company_perquisition.sqf0000777000000000000000000000125214002300036022402 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_company", "_from"];
_company = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_from = [_this, 1, objNull, [objNull]] call BIS_fnc_param;

if ((isNull _company) || (isNull _from)) exitWith {};

_this call AlysiaServer_fnc_logPerquisition;
_company setVariable ["perquisition", true, true];

uiSleep(60 * 10);

_company setVariable ["perquisition", false, true];

if ((_company getVariable ["trunk_in_use_ID", ""]) != "") then {
	_company setVariable ["trunk_in_use_ID", "", true];
};

if (!(isNull _from)) then {
	["Perquisition <t color='#FF8000'>terminé</t>."] remoteExecCall ["AlysiaClient_fnc_info", (owner _from)];
};
Tanoa-Server/core/Companies/fn_construction_init.sqf0000777000000000000000000000174314003561203021711 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_name", "_owner", "_type", "_plate", "_owner_name", "_position", "_direction", "_object", "_require"];
_name = [_this, 0, "", [""]] call BIS_fnc_param;
_owner = [_this, 1, "", [""]] call BIS_fnc_param;
_type = [_this, 2, "", [""]] call BIS_fnc_param;
_plate = [_this, 3, "", [""]] call BIS_fnc_param;
_owner_name = [_this, 4, "", [""]] call BIS_fnc_param;
_position = [_this, 5, [], [[]]] call BIS_fnc_param;
_direction = [_this, 6, 0, [0]] call BIS_fnc_param;
_require = [_this, 7, [], [[]]] call BIS_fnc_param;

_object = getText(missionConfigFile >> "ADENIS_COMPANIES_BUILDINGS" >> getText(missionConfigFile >> "ADENIS_COMPANIES_TYPES" >> _type >> "building") >> "bedrock") createVehicle _position;
_object setDir _direction;

_object setVariable ["construction_require", _require, true];
_object setVariable ["company_info", [_name, _owner, _type, _plate, _owner_name], true];
_object setVariable ["construction", true, true];

_object;
Tanoa-Server/core/dynamicMarkers/0000777000000000000000000000000014003561130015760 5ustar  rootrootTanoa-Server/core/dynamicMarkers/fn_dynamicMarkers_create.sqf0000777000000000000000000000304714003561203023462 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_marker", "_name", "_config", "_position", "_linked"];
_name = [_this, 0, "", [""]] call BIS_fnc_param;
_position = [_this, 1, [], [[]]] call BIS_fnc_param;

if (_position isEqualTo []) exitWith {};

_config = missionConfigFile >> "ADENIS_DYN_MARKERS" >> _name;
if (!isClass _config) exitWith {};

_marker = createmarker [_name, _position];
diag_log format["Creating dynamic marker %1", _name];

_marker setMarkerShape getText(_config >> "shape");
_marker setMarkerType getText(_config >> "type");
_marker setMarkerColor getText(_config >> "color");
_marker setMarkerText getText(_config >> "text");
_marker setMarkerSize [getNumber(_config >> "size"), getNumber(_config >> "size")];

_linked = getText(_config >> "linked");
if (_linked != "") then
{
	private "_object";
	_object = call compile _linked;
	if (isNil "_object") then {
		diag_log format["[ERROR] Can't find linked object for %1 (variable nil)", _name];
	} else {
		if (isNull _object) then {
			diag_log format["[ERROR] Can't find linked object for %1 (objet null)", _name];
		} else {
			_object setPosATL _position;
			missionNamespace setVariable [format["dyn_marker_linked_%1", _marker], _object];
			diag_log format["Linked object for %1 placed", _name];
		};
	};
};

{
	_object = _x createVehicle ([_position, 8] call CBA_fnc_randPos);
	missionNamespace setVariable [format["dyn_marker_supp_%1", _marker], (missionNamespace getVariable [format["dyn_marker_supp_%1", _marker], []]) + [_object]];
} forEach getArray(_config >> "nearObjects");

_marker;
Tanoa-Server/core/dynamicMarkers/fn_dynamicMarkers_getPos.sqf0000777000000000000000000000101414003561203023450 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_new";

_new = [0,0,0];

{
	_position = _x;
	if (count((format["((%1 distance (getMarkerPos (configName _x))) < getNumber(_x >> 'distance'))", _position]) configClasses (missionConfigFile >> "ADENIS_DYN_MARKERS")) isEqualTo 0) exitWith {
		_new = _x;
	};
} forEach ([getArray(configFile >> "Cfg_Server" >> "dynamic_markers" >> getText(missionConfigFile >> "ADENIS_DYN_MARKERS" >> ([_this, 0, "", [""]] call BIS_fnc_param) >> "positions"))] call CBA_fnc_shuffle);

_new;
Tanoa-Server/core/dynamicMarkers/fn_dynamicMarkers_init.sqf0000777000000000000000000000250114003561203023154 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_positions", "_missing"];

diag_log "[DYNAMIC MARKERS] Initializing";

_missing = [];

{
	_name = configName _x;
	_result = [format["SELECT POS_X, POS_Y, POS_Z FROM dynamic_markers WHERE name='%1'", _name], 2] call ExtDB3_fnc_async;

	if (_result isEqualTo []) then
	{
		_missing pushBack _name;
		diag_log format["[ERROR] Dynamic marker %1 is not saved into DB.", _name];
		diag_log format["Cannot create dynamic marker %1", _name];
	} else {
		_result = _result select 0;
		_marker = [_name, [(_result select 0), (_result select 1), (_result select 2)]] call AlysiaServer_fnc_dynamicMarkers_create;
	};
} forEach ("true" configClasses (missionConfigFile >> "ADENIS_DYN_MARKERS"));

{
	_pos = [_x] call AlysiaServer_fnc_dynamicMarkers_getPos;
	if (_pos isEqualTo [0,0,0]) then {
		diag_log format["[ERROR] Dynamic marker %1 has no possible positions", _x];
	} else {
		[
			format
			[
				"INSERT INTO dynamic_markers (name,POS_X,POS_Y,POS_Z) VALUES ('%1','%2','%3','%4')",
				_x,
				(_pos select 0),
				(_pos select 1),
				(_pos select 2)
			], 1
		] call ExtDB3_fnc_async;
		diag_log format["[ERROR] Dynamic marker %1 was not saved into DB. Fixed", _x];
		_marker = [_x, _pos] call AlysiaServer_fnc_dynamicMarkers_create;
	};
} forEach _missing;

diag_log "[DYNAMIC MARKERS] Ready";
Tanoa-Server/core/dynamicMarkers/fn_dynamicMarkers_update.sqf0000777000000000000000000000215314002300036023470 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_object", "_marker", "_new"];
_marker = [_this, 0, "", [""]] call BIS_fnc_param;

if (_marker isEqualTo "") exitWith {};

_marker setMarkerAlpha 0;
_new = [_marker] call AlysiaServer_fnc_dynamicMarkers_getPos;
if (_new isEqualTo [0,0,0]) exitWith
{
	diag_log format["[ERROR] Dynamic marker %1 has no possible positions", _marker];
	deleteMarker _marker;
	_object = missionNamespace getVariable [format["dyn_marker_linked_%1", _marker], objNull];
	if (!(isNull _object)) then {deleteVehicle _object};
};

_marker setMarkerPos _new;
_object = missionNamespace getVariable [format["dyn_marker_linked_%1", _marker], objNull];
if (!(isNull _object)) then {_object setPosATL _new};

{
	_x setPos ([_new, 8] call CBA_fnc_randPos);
} forEach (missionNamespace getVariable [format["dyn_marker_supp_%1", _marker], []]);

[
	format
	[
		"UPDATE dynamic_markers SET POS_X='%1',POS_Y='%2',POS_Z='%3' WHERE name='%4'",
		(_new select 0),
		(_new select 1),
		(_new select 2),
		_marker
	], 1
] call ExtDB3_fnc_async;

[_marker] remoteExecCall ["AlysiaClient_fnc_dynamicMarkers_update", -2];
Tanoa-Server/core/Factions/0000777000000000000000000000000014003561130014555 5ustar  rootrootTanoa-Server/core/Factions/fn_factionBankHandle.sqf0000777000000000000000000000324713535665003021334 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_amount";
_amount = abs(round([_this, 2, 0, [0]] call BIS_fnc_param));

if (_amount isEqualTo 0) exitWith {};

switch ([_this, 0, sideUnknown, [sideUnknown]] call BIS_fnc_param) do
{
	case independent:
	{
		if ([_this, 1, false, [false]] call BIS_fnc_param) then {
			gServer_faction_GUER_bank = gServer_faction_GUER_bank + _amount;
		} else {
			gServer_faction_GUER_bank = gServer_faction_GUER_bank - _amount;
			if (gServer_faction_GUER_bank < 0) then {
				gServer_faction_GUER_bank = 0;
			};
		};

		publicVariable "gServer_faction_GUER_bank";
	};

	case west:
	{
		if ([_this, 1, false, [false]] call BIS_fnc_param) then {
			gServer_faction_WEST_bank = gServer_faction_WEST_bank + _amount;
		} else {
			gServer_faction_WEST_bank = gServer_faction_WEST_bank - _amount;
			if (gServer_faction_WEST_bank < 0) then {
				gServer_faction_WEST_bank = 0;
			};
		};

		publicVariable "gServer_faction_WEST_bank";
	};

	case east:
	{
		if ([_this, 1, false, [false]] call BIS_fnc_param) then {
			gServer_faction_EAST_bank = gServer_faction_EAST_bank + _amount;
		} else {
			gServer_faction_EAST_bank = gServer_faction_EAST_bank - _amount;
			if (gServer_faction_EAST_bank < 0) then {
				gServer_faction_EAST_bank = 0;
			};
		};

		publicVariable "gServer_faction_EAST_bank";
	};

	case civilian:
	{
		if ([_this, 1, false, [false]] call BIS_fnc_param) then {
			gServer_faction_CIV_bank = gServer_faction_CIV_bank + _amount;
		} else {
			gServer_faction_CIV_bank = gServer_faction_CIV_bank - _amount;
			if (gServer_faction_CIV_bank < 0) then {
				gServer_faction_CIV_bank = 0;
			};
		};

		publicVariable "gServer_faction_CIV_bank";
	};
};
Tanoa-Server/core/Factions/fn_factionHistoryAdd.sqf0000777000000000000000000000154214002277764021416 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_name", "_item", "_side"];
_name = [_this, 0, "", [""]] call BIS_fnc_param;
_item = [_this, 1, "", [""]] call BIS_fnc_param;
_side = [_this, 2, sideUnknown, [sideUnknown]] call BIS_fnc_param;

if ((_name isEqualTo "") || (_item isEqualTo "") || (_side isEqualTo sideUnknown)) exitWith {};

switch (_side) do
{
	case east:
	{
		gServer_faction_EAST_history pushBack [_name, _item, format["%1 %2", ([] call AlysiaClient_fnc_strDate), ([] call AlysiaClient_fnc_strTime)]];
	};
	case west:
	{
		gServer_faction_WEST_history pushBack [_name, _item, format["%1 %2", ([] call AlysiaClient_fnc_strDate), ([] call AlysiaClient_fnc_strTime)]];
	};
	case independent:
	{
		gServer_faction_GUER_history pushBack [_name, _item, format["%1 %2", ([] call AlysiaClient_fnc_strDate), ([] call AlysiaClient_fnc_strTime)]];
	};
};
Tanoa-Server/core/Factions/fn_factionHistoryClean.sqf0000777000000000000000000000055613535665003021751 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_player"];
_player = [_this, 0, objNull, [objNull]] call BIS_fnc_param;

if (isNull _player) exitWith {};

switch (side _player) do
{
	case east:
	{
		gServer_faction_EAST_history = [];
	};
	case west:
	{
		gServer_faction_WEST_history = [];
	};
	case independent:
	{
		gServer_faction_GUER_history = [];
	};
};
Tanoa-Server/core/Factions/fn_factionHistoryGet.sqf0000777000000000000000000000074414002277764021450 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_player", "_history"];
_player = [_this, 0, objNull, [objNull]] call BIS_fnc_param;

if (isNull _player) exitWith {};

_history = switch (side _player) do
{
	case east: {gServer_faction_EAST_history};
	case west: {gServer_faction_WEST_history};
	case independent: {gServer_faction_GUER_history};
};
if (isNil "_history") exitWith {};

[_history] remoteExec ["AlysiaClient_fnc_APP_faction_leader_history", (owner _player), false];
Tanoa-Server/core/Factions/fn_factionMemberList.sqf0000777000000000000000000000137314002277764021411 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_player", "_list"];
_player = [_this, 0, objNull, [objNull]] call BIS_fnc_param;

if (isNull _player) exitWith {};

_list = switch (side _player) do
{
	case east: {["SELECT EAST_level, profileName, uid FROM players WHERE EAST_level>'0' ORDER BY EAST_level DESC", 2] call ExtDB3_fnc_async};
	case west: {["SELECT WEST_level, profileName, uid FROM players WHERE WEST_level>'0' ORDER BY WEST_level DESC", 2] call ExtDB3_fnc_async};
	case independent: {["SELECT GUER_level, profileName, uid FROM players WHERE GUER_level>'0' ORDER BY GUER_level DESC", 2] call ExtDB3_fnc_async};
};
if (isNil "_list") exitWith {};

[_list] remoteExec ["AlysiaClient_fnc_APP_faction_leader_officeHandler", (owner _player), false];
Tanoa-Server/core/Factions/fn_factionMemberModify.sqf0000777000000000000000000000131413535665003021715 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_uid", "_rank", "_side"];
_uid = [_this, 0, "", [""]] call BIS_fnc_param;
_rank = [_this, 1, -1, [-1]] call BIS_fnc_param;
_side = [_this, 2, sideUnknown, [sideUnknown]] call BIS_fnc_param;

if ((_uid isEqualTo "") || (_rank isEqualTo -1) || (_side isEqualTo sideUnknown)) exitWith {};

switch (_side) do
{
	case east: {[format["UPDATE players SET EAST_level='%1' WHERE uid='%2'", _rank, _uid], 1] call ExtDB3_fnc_async};
	case west: {[format["UPDATE players SET WEST_level='%1' WHERE uid='%2'", _rank, _uid], 1] call ExtDB3_fnc_async};
	case independent: {[format["UPDATE players SET GUER_level='%1' WHERE uid='%2'", _rank, _uid], 1] call ExtDB3_fnc_async};
};
Tanoa-Server/core/Factions/fn_factionsInit.sqf0000777000000000000000000000277114002300036020412 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[FACTION] Setup";

{
	_handle = switch (_x select 0) do
	{
		case "WEST":
		{
			gServer_faction_WEST_bank = _x select 1;
			gServer_faction_WEST_history = [(_x select 2)] call AlysiaServer_fnc_mresToArray;
			gServer_faction_WEST_bank_HISTORY = gServer_faction_WEST_bank;
			publicVariable "gServer_faction_WEST_bank";
			true;
		};
		case "GUER":
		{
			gServer_faction_GUER_bank = _x select 1;
			gServer_faction_GUER_history = [(_x select 2)] call AlysiaServer_fnc_mresToArray;
			gServer_faction_GUER_bank_HISTORY = gServer_faction_GUER_bank;
			publicVariable "gServer_faction_GUER_bank";
			true;
		};
		case "EAST":
		{
			gServer_faction_EAST_bank = _x select 1;
			gServer_faction_EAST_history = [(_x select 2)] call AlysiaServer_fnc_mresToArray;
			gServer_faction_EAST_bank_HISTORY = gServer_faction_EAST_bank;
			publicVariable "gServer_faction_EAST_bank";
			true;
		};
		case "CIV":
		{
			gServer_faction_CIV_bank = _x select 1;
			gServer_faction_CIV_history = [(_x select 2)] call AlysiaServer_fnc_mresToArray;
			gServer_faction_CIV_bank_HISTORY = gServer_faction_CIV_bank;
			publicVariable "gServer_faction_CIV_bank";
			true;
		};
		default {false};
	};

	if (_handle) then {
		diag_log format["Faction %1 | Bank=%2", (_x select 0), (_x select 1)];
	} else {
		diag_log format["[ERROR] Invalid faction %1 : cannot load", (_x select 0)];
	};
} forEach (["SELECT name,bank,history FROM factions", 2] call ExtDB3_fnc_async);

diag_log "[FACTION] Ready";
Tanoa-Server/core/Factions/fn_factionsSave.sqf0000777000000000000000000000361514002300036020403 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[FACTION] Saving";

[
	format
	[
		"UPDATE factions SET bank='%1',history='%2' WHERE name='GUER'",
		gServer_faction_GUER_bank,
		[gServer_faction_GUER_history] call AlysiaServer_fnc_mresArray
	], 1
] call ExtDB3_fnc_async;
diag_log format["Saving faction GUER - money : %1", [gServer_faction_GUER_bank] call AlysiaClient_fnc_numberText];
diag_log format["Math : %1", ([gServer_faction_GUER_bank - gServer_faction_GUER_bank_HISTORY] call AlysiaClient_fnc_numberText)];

[
	format
	[
		"UPDATE factions SET bank='%1',history='%2' WHERE name='EAST'",
		gServer_faction_EAST_bank,
		[gServer_faction_EAST_history] call AlysiaServer_fnc_mresArray
	], 1
] call ExtDB3_fnc_async;
diag_log format["Saving faction EAST - money : %1", [gServer_faction_EAST_bank] call AlysiaClient_fnc_numberText];
diag_log format["Math : %1", ([gServer_faction_EAST_bank - gServer_faction_EAST_bank_HISTORY] call AlysiaClient_fnc_numberText)];

[
	format
	[
		"UPDATE factions SET bank='%1',history='%2' WHERE name='WEST'",
		gServer_faction_WEST_bank,
		[gServer_faction_WEST_history] call AlysiaServer_fnc_mresArray
	], 1
] call ExtDB3_fnc_async;
diag_log format["Saving faction WEST - money : %1", [gServer_faction_WEST_bank] call AlysiaClient_fnc_numberText];
diag_log format["Math : %1", ([gServer_faction_WEST_bank - gServer_faction_WEST_bank_HISTORY] call AlysiaClient_fnc_numberText)];


// [
// 	format
// 	[
// 		"UPDATE factions SET bank='%1',history='%2' WHERE name='CIV'",
// 		gServer_faction_CIV_bank,
// 		[gServer_faction_CIV_history] call AlysiaServer_fnc_mresArray
// 	], 1
// ] call ExtDB3_fnc_async;
// diag_log format["Saving faction CIVILIAN - money : %1", [gServer_faction_CIV_bank] call AlysiaClient_fnc_numberText];
// diag_log format["Math : %1", ([gServer_faction_CIV_bank - gServer_faction_CIV_bank_HISTORY] call AlysiaClient_fnc_numberText)];

diag_log "[FACTION] Saved";
Tanoa-Server/core/Factions/fn_faction_mission.sqf0000777000000000000000000000641314003561203021147 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_vehicle", "_data", "_position", "_try", "_type", "_time", "_from", "_loop_count", "_types"];
_from = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_type = [_this, 1, "", [""]] call BIS_fnc_param;
_time = [_this, 2, 0, [0]] call BIS_fnc_param;

if (isNull _from) exitWith {};

_config = missionConfigFile >> "ADENIS_MISSIONS" >> _type;
if (getNumber(_config >> "count_per_reboot") != -1) then
{
	_count = call compile format["mission_reboot_%1_mission", _type];
	if (isNil "_count") then {
		call compile format["mission_reboot_%1_mission=1;publicVariable""mission_reboot_%1_mission"";", _type];
	} else {
		call compile format["mission_reboot_%1_mission=%2+1;publicVariable""mission_reboot_%1_mission"";", _type, _count];
	};
};

_data = ([getArray(configFile >> "Cfg_Server" >> "mission" >> _type >> "positions")] call CBA_fnc_shuffle) call BIS_fnc_selectRandom;
_position = _data select 0;

[
	format
	[
		"La livraison arrivera en <t color='#04B45F'>%1</t> dans <t color='#FF8000'>%2</t>.",
		(mapGridPosition _position),
		[_time, "H:MM:SS"] call CBA_fnc_formatElapsedTime
	],
	"LIVRAISON"
] remoteExecCall ["AlysiaClient_fnc_phone_message_receive", _from];

uiSleep _time;

_try = 1;
while {(count(nearestObjects[_position, ["Car", "Air", "Ship", "Tank"], 8]) > 0)} do
{
	[format["Un véhicule bloque l'apparition de la mission.<br/>Tentative n°%1<br/>Nouvel essaie dans 10 secondes...", _try]] remoteExecCall ["AlysiaClient_fnc_error", _from];
	uiSleep 10;
	_try = _try + 1;
};

if (getNumber(_config >> "loop_count_random") isEqualTo -1) then {
	_loop_count = getNumber(_config >> "loop_count_min");
} else {
	_loop_count = round(random(getNumber(_config >> "loop_count_random")) + getNumber(_config >> "loop_count_min"));
};

_types = [];
{
	if (count(getArray(_config >> "stock" >> _x)) > 0) then {
		_types pushBack _x;
	};
} forEach (["weapons", "magazines", "items", "backpacks", "virtuals"]);

_vehicle = getText(_config >> "vehicle") createVehicle _position;
_vehicle setDir (_data select 1);
[_vehicle] call AlysiaClient_fnc_clearVehicleAmmo;

if (!isNull(_from)) then
{
	[
		format
		[
			"La livraison est arrivée en <t color='#04B45F'>%1</t>.",
			(mapGridPosition _position)
		],
		"LIVRAISON"
	] remoteExecCall ["AlysiaClient_fnc_phone_message_receive", _from];
};

for "_i" from 0 to _loop_count do
{
	_type = ([_types] call CBA_fnc_shuffle) call BIS_fnc_selectRandom;

	_item = ([getArray(_config >> "stock" >> _type)] call CBA_fnc_shuffle) call BIS_fnc_selectRandom;
	switch _type do
	{
		case "weapons": {_vehicle addWeaponCargoGlobal [_item, 1]};
		case "magazines": {_vehicle addMagazineCargoGlobal [_item, 4]};
		case "backpacks": {_vehicle addBackpackCargoGlobal [_item, 1]};
		case "items": {_vehicle addItemCargoGlobal [_item, 1]};
		case "virtuals": {[true, _vehicle, "Trunk", _item, 1] call AlysiaClient_fnc_handleTrunk};
	};
};

if ((_vehicle isKindOf "Car") || (_vehicle isKindOf "Ship") || (_vehicle isKindOf "Air") || (_vehicle isKindOf "Tank")) then
{
	if (local _vehicle) then {
		_vehicle lock 2;
	} else {
		[_vehicle, 2] remoteExecCall ["lock", _vehicle];
	};
} else {
	["Le coffre sera supprimé dans <t color='#FF8000'>20 minutes</t>."] remoteExecCall ["AlysiaClient_fnc_info", _from];
	uiSleep (60 * 20);
	deleteVehicle _vehicle;
};
Tanoa-Server/core/Fireworks/0000777000000000000000000000000014003561130014762 5ustar  rootrootTanoa-Server/core/Fireworks/fn_fireworks.sqf0000777000000000000000000001003114002277764020211 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by nomisum
*/

_firing_position = _this select 0;
_type = _this select 1;
_color = _this select 2;

_explosion_power = 50;
_glitter_count = 20;
_initial_velocity = [(random 10) -5,(random 10)-5, 300];

_colorArray = [[0.42,0.81,0.1],[0.8,0.1,0.35],[0.2,0.73,0.85],[1,1,1]];
_explosion_fragments_array = [];
_explosion_subfragments_array = [];

_randomLaunch = (random 4.5) - 2.3;
_randomSleep = (random 0.5) - 0.25;
_randomSleepLong = (random 8) - 4;
_randomSleepShort = (random 0.1) - 0.05;

_color = switch (_color) do
{
	case "random": {_colorArray call BIS_fnc_selectRandom};
	case "green": {[0.42,0.81,0.1]};
	case "red": {[0.8,0.1,0.35]};
	case "blue": {[0.2,0.73,0.85]};
	case "white": {[1,1,1]};
	default {[1,1,1]};
};

_launchSound =
[
	"launch1",
	"launch2",
	"launch3",
	"launch4",
	"launch5",
	"launch6",
	"launch7"
] call BIS_fnc_selectRandom;

_whistlingSound =
[
	"whistling1",
	"whistling2",
	"whistling3",
	"whistling4"
] call BIS_fnc_selectRandom;

_bangSound =
[
	"bang01",
	"bang02",
	"bang03",
	"bang04",
	"bang05",
	"bang06",
	"bang07",
	"bang08",
	"bang10",
	"bang11"
] call BIS_fnc_selectRandom;

_singleFizz =
[
	"fizz_single_type1_1",
	"fizz_single_type1_2",
	"fizz_single_type1_3",
	"fizz_single_type1_4",
	"fizz_single_type2_1",
	"fizz_single_type2_2",
	"fizz_single_type2_3",
	"fizz_single_type2_4"
];

_groupFizz =
[
	"fizz_group1",
	"fizz_group2",
	"fizz_group3",
	"fizz_group4"
];

_type = switch (_type) do
{
	case "random": {["fizzer","normal","rain"] call BIS_fnc_selectRandom};
	case "normal": {"normal"};
	case "fizzer": {"fizzer"};
	case "rain": {"rain"};
	default {["fizzer","normal","rain"] call BIS_fnc_selectRandom};
};

if (_type isEqualTo "normal") then
{
	_glitter_count = _glitter_count * 2;
	_explosion_power = _explosion_power / 2;
};

for [{_i = 0}, {_i < _glitter_count}, {_i = _i + 1}] do
{
	_rand_expl_power1 = ((random _explosion_power)*2) - _explosion_power;
	_rand_expl_power2 = ((random _explosion_power)*2) - _explosion_power;
	_rand_expl_power3 = ((random _explosion_power)*2) - _explosion_power;
	_explosion_fragments_array = _explosion_fragments_array +
	[[(_rand_expl_power1) -_rand_expl_power1/2,(_rand_expl_power2) -_rand_expl_power2/2, (_rand_expl_power3) -_rand_expl_power3/2]];

	if (_i < _glitter_count/3) then
	{
		_rand_subexpl_power1 = ((random _explosion_power)/2) - _explosion_power/2;
		_rand_subexpl_power2 = ((random _explosion_power)/2) - _explosion_power/2;
		_rand_subexpl_power3 = ((random _explosion_power)/2) - _explosion_power/2;
		_explosion_subfragments_array = _explosion_subfragments_array + [[(_rand_subexpl_power1/4) -_rand_subexpl_power1/8,(_rand_subexpl_power2/4) -_rand_subexpl_power2/8, (_rand_subexpl_power3/4) -_rand_subexpl_power3/8]];
	};
};

if (_type isEqualTo "rain") then
{
	_color = [1,0.9,0.6];

	for [{_i = 0}, {_i < _glitter_count}, {_i = _i + 1}] do
	{
		_rand_expl_power1 = ((random _explosion_power)*2) - _explosion_power;
		_rand_expl_power2 = ((random _explosion_power)*2) - _explosion_power;
		_rand_expl_power3 = ((random _explosion_power)*2);
		_explosion_fragments_array = _explosion_fragments_array +
		[[(_rand_expl_power1) -_rand_expl_power1/2,(_rand_expl_power2) -_rand_expl_power2/2, (_rand_expl_power3) -_rand_expl_power3/2]];

		if (_i < _glitter_count/3) then
		{
			_rand_subexpl_power1 = ((random _explosion_power)/2) - _explosion_power/2;
			_rand_subexpl_power2 = ((random _explosion_power)/2) - _explosion_power/2;
			_rand_subexpl_power3 = ((random _explosion_power)/2);
			_explosion_subfragments_array = _explosion_subfragments_array +
			[[(_rand_subexpl_power1/4) -_rand_subexpl_power1/8,(_rand_subexpl_power2/4) -_rand_subexpl_power2/8, (_rand_subexpl_power3/4) -_rand_subexpl_power3/8]];
		};
	};
};

[
	_firing_position,
	_type,
	_initial_velocity,
	_explosion_power,
	_glitter_count,
	_color,
	_explosion_fragments_array,
	_explosion_subfragments_array,
	_randomSleep,
	_randomSleepLong,
	_randomLaunch,
	_launchSound,
	_whistlingSound,
	_bangSound,
	_singleFizz,
	_groupFizz,
	_randomSleepShort
] remoteExec ["AlysiaClient_fnc_fireworks_effects", -2];
Tanoa-Server/core/Garage/0000777000000000000000000000000014003561130014175 5ustar  rootrootTanoa-Server/core/Garage/fn_garageVehicles.sqf0000777000000000000000000000255614002300036020312 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_types", "_unit", "_queryResult", "_types_formated"];
_unit = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_types = [_this, 1, [], [[]]] call BIS_fnc_param;

if ((isNull _unit) || (_types isEqualTo "")) exitWith {};

_types_formated = "";
{
	_types_formated = format["%1%2'%3'", _types_formated, if (_forEachIndex isEqualTo 0) then {""} else {","}, _x];
} forEach _types;

if (_types_formated isEqualTo "") exitWith {
	[[]] remoteExecCall ["AlysiaClient_fnc_garageOpen", (owner _unit)];
};

_queryResult =
[
	format
	[
		"SELECT classname,plate,assurance,fuel,inventory,displayname,POS_store_x,POS_store_y,POS_store_z,type,HitPointsDamage,fuel_type FROM vehicles WHERE pid='%1' AND active='0' AND side='%2' AND type IN (%3) AND occuped='0'",
		(getPlayerUID _unit),
		str(side _unit),
		_types_formated
	], 2
] call ExtDB3_fnc_async;

{
	(_queryResult select _forEachIndex) set [4, [(_x select 4)] call AlysiaServer_fnc_mresToArray];// inventory
	(_queryResult select _forEachIndex) set [10, [(_x select 10)] call AlysiaServer_fnc_mresToArray];// HitPointsDamage
} forEach _queryResult;

[_queryResult] remoteExecCall ["AlysiaClient_fnc_garageOpen", (owner _unit)];
/*
	0 classname
	1 plate
	2 assurance
	3 fuel
	4 inventory
	5 displayname
	6 POS_store_x
	7 POS_store_y
	8 POS_store_z
	9 type
	10 HitPointsDamage
	11 fuel_type
*/
Tanoa-Server/core/Garage/fn_garageVehicleSpawn.sqf0000777000000000000000000000077314002300036021137 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_vid", "_unit", "_vehicle"];
_vid = [_this, 0, -1, [-1]] call BIS_fnc_param;
_vehicle = [_this, 1, objNull, [objNull]] call BIS_fnc_param;
_unit = [_this, 2, objNull, [objNull]] call BIS_fnc_param;

if ((_vid isEqualTo -1) || (isNull _unit) || (isNull _vehicle)) exitWith {};

[(getPlayerUID _unit), (side _unit), _vehicle] call AlysiaServer_fnc_keyManagement;
[format["UPDATE vehicles SET active='1' WHERE plate='%1'", _vid], 1] call ExtDB3_fnc_async;
Tanoa-Server/core/Garage/fn_garageVehicleStore.sqf0000777000000000000000000000211514002300036021133 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_vehicle", "_storeInventory", "_vInfo", "_storePos"];
_vehicle = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_storePos = [_this, 1, [0, 0, 0], [[]]] call BIS_fnc_param;
_storeInventory = [_this, 2, false, [false]] call BIS_fnc_param;

if (isNull _vehicle) exitWith {};

_vInfo = _vehicle getVariable "info";
if (!(isNil "_vInfo")) then
{
	[
		format
		[
			"UPDATE vehicles SET active='0',fuel='%1',inventory='%2',POS_x='0',POS_y='0',POS_z='0',POS_store_x='%3',POS_store_y='%4',POS_store_z='%5',HitPointsDamage='%8',fuel_type='%9' WHERE pid='%6' AND plate='%7'",
			((fuel _vehicle) * 100),
			if (_storeInventory) then {[(_vehicle getVariable ["Trunk", []])] call AlysiaServer_fnc_mresArray} else {"""[]"""},
			(_storePos select 0),
			(_storePos select 1),
			(_storePos select 2),
			(_vInfo select 0),
			(_vInfo select 2),
			[([_vehicle] call AlysiaClient_fnc_getAllHitPointsDamage) select 2] call AlysiaServer_fnc_mresArray,
			(_vehicle getVariable ["refuel_type", ""])
		], 1
	] call ExtDB3_fnc_async;
};

deleteVehicle _vehicle;
Tanoa-Server/core/Housing/0000777000000000000000000000000014003561130014423 5ustar  rootrootTanoa-Server/core/Housing/fn_house_add.sqf0000777000000000000000000000225214002300036017553 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_housePos", "_rand", "_house", "_player"];
_house = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_player = [_this, 1, objNull, [objNull]] call BIS_fnc_param;

if ((isNull _house) || (isNull _player)) exitWith {};
if (_house in gServer_houses) exitWith
{
	diag_log format["Error: (_house in gServer_houses) in AlysiaServer_fnc_house_add.sqf (%1)", getPlayerUID _player];
	["Cette maison n'est pas en vente."] remoteExecCall ["AlysiaClient_fnc_info", owner _player];
};

_housePos = getPosATL _house;
_rand = round(random(999999));

_house setVariable ["house_owner", [(getPlayerUID _player), (_player getVariable "realname"), _rand], true];
gServer_houses pushBack _house;

[
	format
	[
		"INSERT INTO houses (pid,POS_x,POS_y,POS_z,STOCK_virtual,STOCK_arma,tenants,plate,classname) VALUES ('%1','%2','%3','%4','""[]""','""[[],[],[],[]]""','""[]""','%5','%6')",
		(getPlayerUID _player),
		(_housePos select 0),
		(_housePos select 1),
		(_housePos select 2),
		_rand,
		typeOf(_house)
	], 1
] call ExtDB3_fnc_async;

_this call AlysiaServer_fnc_logHouseBuy;

[_house] remoteExecCall ["AlysiaClient_fnc_houseReceive", (owner _player)];
Tanoa-Server/core/Housing/fn_house_fetch.sqf0000777000000000000000000000056313535665003020141 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_uid", "_houses"];
_uid = [_this, 0, "", [""]] call BIS_fnc_param;

if (_uid isEqualTo "") exitWith {[]};

_houses = [];

{
	if ((_uid in (_x getVariable ["house_tenants", []])) || (_uid isEqualTo ((_x getVariable ["house_owner", ["", ""]]) select 0))) then {_houses pushBack _x};
} forEach gServer_houses;

_houses;
Tanoa-Server/core/Housing/fn_house_init.sqf0000777000000000000000000000371214003561203017776 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_countFail", "_countOk"];

diag_log "[HOUSE] Setup";

["DELETE houses.* FROM houses INNER JOIN players ON houses.pid=players.uid WHERE DATEDIFF(NOW(),players.STATS_last_update)>31", 1] call ExtDB3_fnc_async;
uiSleep 1;

_countFail = 0;
_countOk = 0;
gServer_houses = [];

{
	_house = nearestObject [[(_x select 2), (_x select 3), (_x select 4)], (_x select 7)];
	if (isNull _house) then
	{
		diag_log format["[ERROR] Can't load house [%1] owner [%2] (objNull)", (_x select 7), (_x select 1)];
		[format["DELETE FROM houses WHERE plate='%1'", (_x select 0)], 1] call ExtDB3_fnc_async;
		_countFail = _countFail + 1;
	} else {
		if (_house in gServer_houses) then {
			diag_log format["[ERROR] Can't load house [%1] owner [%2] (already in gServer_houses)", (_x select 7), (_x select 1)];
		} else {
			_house setVariable ["house_owner", [(_x select 1), (_x select 5), (_x select 0)], true];
			_house setVariable ["house_tenants", ([(_x select 6)] call AlysiaServer_fnc_mresToArray), false];

			if (getNumber(missionConfigFile >> "ADENIS_HOUSES" >> typeOf(_house) >> "disableLockDoorOnStartup") isEqualTo 0) then
			{
				for "_i" from 1 to getNumber(configFile >> "CfgVehicles" >> (typeOf _house) >> "numberOfDoors") do
				{
					_house animate [format["door_%1_rot", _i], 0];
					_house setVariable [format["bis_disabled_Door_%1", _i], 1, true];
				};
			};

			_countOk = _countOk + 1;
			gServer_houses pushBack _house;
		};
	};
} forEach (["SELECT houses.plate,houses.pid,houses.POS_x,houses.POS_y,houses.POS_z,players.profileName,houses.tenants,houses.classname FROM houses INNER JOIN players ON houses.pid=players.uid", 2] call ExtDB3_fnc_async);
/*
	0:houses.plate
	1:houses.pid
	2:houses.POS_x
	3:houses.POS_y
	4:houses.POS_z
	5:players.profileName
	6:houses.tenants
	7:houses.classname
*/

diag_log format["%1 house(s) loaded succefully", _countOk];
diag_log format["%1 house(s) failed", _countFail];

diag_log "[HOUSE] Ready";
Tanoa-Server/core/Housing/fn_house_init_storage.sqf0000777000000000000000000000120114002300036021503 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_house", "_ret", "_from"];
_house = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_from = [_this, 1, objNull, [objNull]] call BIS_fnc_param;

if ((isNull _house) || (isNull _from)) exitWith {};

_ret = [format["SELECT STOCK_virtual,STOCK_arma FROM houses WHERE plate='%1'", (_house getVariable "house_owner") select 2], 2] call ExtDB3_fnc_async;

if (count(_ret) > 0) then
{
	_ret = _ret select 0;
	[_house, ([(_ret select 0)] call AlysiaServer_fnc_mresToArray), ([(_ret select 1)] call AlysiaServer_fnc_mresToArray)] remoteExec ["AlysiaClient_fnc_house_storage_create", _from];
};
Tanoa-Server/core/Housing/fn_house_perquisition.sqf0000777000000000000000000000115214002300036021554 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_house", "_storage", "_from"];
_house = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_from = [_this, 1, objNull, [objNull]] call BIS_fnc_param;

if ((isNull _house) || (isNull _from)) exitWith {};

_this call AlysiaServer_fnc_logPerquisition;
_house setVariable ["perquisition", true, true];

uiSleep(60 * 10);

_house setVariable ["perquisition", false, true];

[[_house]] call AlysiaServer_fnc_cleanup_houseStorages;
if (!(isNull _from)) then {
	["Perquisition <t color='#FF8000'>terminé</t>."] remoteExecCall ["AlysiaClient_fnc_info", (owner _from)];
};
Tanoa-Server/core/Housing/fn_house_save.sqf0000777000000000000000000000117514002300036017764 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[HOUSE] Saving ...";

{
	if (isNull _x) then {
		diag_log format["Can't save at index %1 : objNull", _forEachIndex];
	} else {
		_id = (_x getVariable "house_owner") select 2;
		if (isNil "_id") then {
			diag_log format["Can't save : %1 : _id nil", _x];
		} else {
			[
				format
				[
					"UPDATE houses SET tenants='%1' WHERE plate='%2'",
					[(_x getVariable ["house_tenants", []])] call AlysiaServer_fnc_mresArray,
					_id
				], 1
			] call ExtDB3_fnc_async;

			diag_log format["Saving house ID : %1", _id];
		};
	};
} forEach gServer_houses;

diag_log "[HOUSE] Saved";
Tanoa-Server/core/Housing/fn_house_save_storage.sqf0000777000000000000000000000123114002300036021501 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_target", "_storage"];
_target = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_storage = [_this, 1, objNull, [objNull]] call BIS_fnc_param;

if ((isNull _storage) || (isNull _target)) exitWith {};

[
	format
	[
		"UPDATE houses SET STOCK_virtual='%1',STOCK_arma='%2' WHERE plate='%3'",
		[(_storage getVariable ["Trunk", []])] call AlysiaServer_fnc_mresArray,
		[([getWeaponCargo _storage, getMagazineCargo _storage, getItemCargo _storage, getBackpackCargo _storage])] call AlysiaServer_fnc_mresArray,
		(_target getVariable "house_owner") select 2
	], 1
] call ExtDB3_fnc_async;

deleteVehicle _storage;
Tanoa-Server/core/Housing/fn_house_sell.sqf0000777000000000000000000000172414002300036017765 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_house", "_player"];
_house = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_player = [_this, 1, objNull, [objNull]] call BIS_fnc_param;

if ((isNull _house) || (isNull _player)) exitWith {};

_this call AlysiaServer_fnc_logHouseSell;
[[_house]] call AlysiaServer_fnc_cleanup_houseStorages;
[_house] remoteExecCall ["AlysiaClient_fnc_house_menu_action_keys_change_update", -2];
[format["DELETE FROM houses WHERE plate='%1'", (_house getVariable "house_owner") select 2], 1] call ExtDB3_fnc_async;

gServer_houses deleteAt (gServer_houses find _house);

_house setVariable ["house_tenants", []];
_house setVariable ["house_sold", true, true];
for "_i" from 1 to getNumber(configFile >> "CfgVehicles" >> (typeOf _house) >> "numberOfDoors") do
{
	_house animate [format["door_%1_rot", _i], 0];
	_house setVariable [format["bis_disabled_Door_%1", _i], 0, true];
};

uiSleep 2;

_house setVariable ["house_owner", nil, true];
Tanoa-Server/core/Housing/fn_house_tenants_add.sqf0000777000000000000000000000106513535665003021332 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_houses", "_uid", "_side"];
_houses = [_this, 0, [], [[]]] call BIS_fnc_param;
_uid = [_this, 1, "", [""]] call BIS_fnc_param;
_side = [_this, 2, sideUnknown, [sideUnknown]] call BIS_fnc_param;

if ((_houses isEqualTo []) || (_uid isEqualTo "") || (_side isEqualTo sideUnknown)) exitWith {};

{
	if (!(isNull _x)) then
	{
		_tenants = _x getVariable ["house_tenants", []];
		if (!(_uid in _tenants)) then
		{
			_tenants pushBack _uid;
			_x setVariable ["house_tenants", _tenants];
		};
	};
} forEach _houses;
Tanoa-Server/core/Laboratories/0000777000000000000000000000000014003561130015435 5ustar  rootrootTanoa-Server/core/Laboratories/fn_laboratories_init.sqf0000777000000000000000000000264114002300036022345 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_object";

diag_log "[LABORATORIES] Setup";

["DELETE labo.* FROM labo INNER JOIN players ON labo.owner=players.uid WHERE DATEDIFF(NOW(),players.STATS_last_update)>31", 1] call ExtDB3_fnc_async;
uiSleep 1;

gServer_laboratories = [];

{

	if ((_x select 8) isEqualTo 1) then {
		_object = [(_x select 1), (_x select 2), (_x select 0), [(_x select 3), (_x select 4), (_x select 5)], (_x select 6), ([_x select 7] call AlysiaServer_fnc_mresToArray), ([_x select 10] call AlysiaServer_fnc_mresToArray)] call AlysiaServer_fnc_laboratory_init;
	} else {
		_object = [(_x select 1), (_x select 2), (_x select 0), [(_x select 3), (_x select 4), (_x select 5)], (_x select 6), ([_x select 9] call AlysiaServer_fnc_mresToArray)] call AlysiaServer_fnc_laboratory_init_construction;
	};

	diag_log format["Loading laboratory [%1] owner [%2] plate [%3]", (_x select 2), (_x select 1), (_x select 0)];
	gServer_laboratories pushBack _object;
} forEach (["SELECT plate,owner,type,POS_x,POS_y,POS_z,POS_direction,EXTRA_process,CONSTRUCTION_BUILT,CONSTRUCTION_REQUIRE,INV_virtual FROM labo", 2] call ExtDB3_fnc_async);
/*
	0 - plate
	1 - owner
	2 - type
	3 - POS_x
	4 - POS_y
	5 - POS_z
	6 - POS_direction
	7 - EXTRA_process
	8 - CONSTRUCTION_BUILT
	9 - CONSTRUCTION_REQUIRE
	10 - INV_virtual
*/

diag_log format["%1 laboratory(s) loaded", count gServer_laboratories];

diag_log "[LABORATORIES] Ready";
Tanoa-Server/core/Laboratories/fn_laboratories_save.sqf0000777000000000000000000000150114002300036022332 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[LABORATORIES] Saving laboratories ...";

{
	if (!(isNull _x)) then
	{
		_info = _x getVariable "laboratory_info";
		if (!(isNil "_info")) then
		{
			[
				format
				[
					"UPDATE labo SET EXTRA_process='%1',CONSTRUCTION_BUILT='%2',CONSTRUCTION_REQUIRE='%3',INV_virtual='%5' WHERE plate='%4'",
					[(_x getVariable ["extra_process", []])] call AlysiaServer_fnc_mresArray,
					[!(_x getVariable ["construction", false]), 0] call AlysiaServer_fnc_bool,
					[(_x getVariable ["construction_require", []])] call AlysiaServer_fnc_mresArray,
					(_info select 0),
					[(_x getVariable ["laboratory_inv_virtual", []])] call AlysiaServer_fnc_mresArray
				], 1
			] call ExtDB3_fnc_async;
		};
	};
} forEach gServer_laboratories;

diag_log "[LABORATORIES] Laboratories saved";
Tanoa-Server/core/Laboratories/fn_laboratory_build.sqf0000777000000000000000000000121514002300036022165 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_object", "_info", "_labo", "_owner"];
_object = [_this, 0, objNull, [objNull]] call BIS_fnc_param;

if (isNull _object) exitWith {};

_info = _object getVariable "laboratory_info";

_labo = [
	_info select 1,
	_info select 2,
	_info select 0,
	getPosATL _object,
	getDir _object,
	[],
	[]
] call AlysiaServer_fnc_laboratory_init;

gServer_laboratories set [(gServer_laboratories find _object), _labo];
deleteVehicle _object;

_owner = [(_info select 1)] call AlysiaClient_fnc_getPlayerFromUID;
if (!(isNull _owner)) then {
	[_labo] remoteExecCall ["AlysiaClient_fnc_labo_update_build", _owner];
};
Tanoa-Server/core/Laboratories/fn_laboratory_destroy.sqf0000777000000000000000000000065613535665003022611 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_info", "_object"];
_object = [_this, 0, objNull, [objNull]] call BIS_fnc_param;

if (isNull _object) exitWith {};

_info = _object getVariable "laboratory_info";
if (isNil "_info") exitWith {};

gServer_laboratories deleteAt (gServer_laboratories find _object);
[format["DELETE FROM labo WHERE plate='%1'", (_info select 0)], 1] call ExtDB3_fnc_async;
deleteVehicle _object;
Tanoa-Server/core/Laboratories/fn_laboratory_fetch.sqf0000777000000000000000000000051613535665003022204 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_uid", "_object"];
_uid = [_this, 0, "", [""]] call BIS_fnc_param;

if (_uid isEqualTo "") exitWith {objNull};

_object = objNull;

{
	if (((_x getVariable ["laboratory_info", ["", ""]]) select 1) isEqualTo _uid) exitWith {_object = _x};
} forEach gServer_laboratories;

_object;
Tanoa-Server/core/Laboratories/fn_laboratory_init.sqf0000777000000000000000000000175714003561203022052 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_owner", "_type", "_plate", "_position", "_direction", "_extra_process", "_object"];
_owner = [_this, 0, "", [""]] call BIS_fnc_param;
_type = [_this, 1, "", [""]] call BIS_fnc_param;
_plate = [_this, 2, -1, [-1]] call BIS_fnc_param;
_position = [_this, 3, [0,0,0], [[]]] call BIS_fnc_param;
_direction = [_this, 4, 0, [0]] call BIS_fnc_param;
_extra_process = [_this, 5, [], [[]]] call BIS_fnc_param;
_inv_virtual =[_this, 6, [], [[]]] call BIS_fnc_param;

_object = getText(missionConfigFile >> "ADENIS_LABORATORIES" >> _type >> "object") createVehicle [0,0,0];
_object setPosATL _position;
_object setDir _direction;

if (count(_extra_process) > 0) then {
	_object setVariable ["extra_process", _extra_process, true];
};
if (count(_inv_virtual) > 0) then {
	_object setVariable ["laboratory_inv_virtual", _inv_virtual, true];
};

_object setVariable ["laboratory_info", [_plate, _owner, _type], true];
/*
	0 - plate
	1 - owner
	2 - type
*/

_object;
Tanoa-Server/core/Laboratories/fn_laboratory_init_construction.sqf0000777000000000000000000000146414003561203024657 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_owner", "_type", "_plate", "_position", "_direction", "_require", "_object"];
_owner = [_this, 0, "", [""]] call BIS_fnc_param;
_type = [_this, 1, "", [""]] call BIS_fnc_param;
_plate = [_this, 2, -1, [-1]] call BIS_fnc_param;
_position = [_this, 3, [0,0,0], [[]]] call BIS_fnc_param;
_direction = [_this, 4, 0, [0]] call BIS_fnc_param;
_require = [_this, 5, [], [[]]] call BIS_fnc_param;

_object = getText(missionConfigFile >> "ADENIS_LABORATORIES" >> _type >> "construction" >> "object") createVehicle [0,0,0];
_object setPosATL _position;
_object setDir _direction;

_object setVariable ["construction_require", _require, true];
_object setVariable ["laboratory_info", [_plate, _owner, _type], true];
_object setVariable ["construction", true, true];

_object;
Tanoa-Server/core/Laboratories/fn_laboratory_insert.sqf0000777000000000000000000000206714003561203022406 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_uid", "_object", "_plate", "_type", "_require"];
_uid = [_this, 0, "", [""]] call BIS_fnc_param;
_object = [_this, 1, ObjNull, [ObjNull]] call BIS_fnc_param;
_type = [_this, 2, "", [""]] call BIS_fnc_param;

if ((_uid isEqualTo "") || (isNull _object) || (_type isEqualTo "")) exitWith {};

uiSleep 3;

_plate = round(random(999999));
_require = getArray(missionConfigFile >> "ADENIS_LABORATORIES" >> _type >> "construction" >> "require");
_pos = getPosATL _object;

[
	format
	[
		"INSERT INTO labo (owner,plate,POS_x,POS_y,POS_z,POS_direction,type,EXTRA_process,CONSTRUCTION_require,CONSTRUCTION_built,INV_virtual) VALUES ('%1','%2','%3','%4','%5','%6','%7','""[]""','%8',0,'""[]""')",
		_uid,
		_plate,
		_pos select 0,
		_pos select 1,
		_pos select 2,
		getDir _object,
		_type,
		[_require] call AlysiaServer_fnc_mresArray
	], 1
] call ExtDB3_fnc_async;

gServer_laboratories pushBack ([_uid, _type, _plate, _pos, (getdir _object), _require] call AlysiaServer_fnc_laboratory_init_construction);
deleteVehicle _object;
Tanoa-Server/core/Log/0000777000000000000000000000000014003561130013530 5ustar  rootrootTanoa-Server/core/Log/fn_logBuypassWhitelist.sqf0000777000000000000000000000043313535665003020773 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_uid", "_name"];
_uid =  [_this, 0, "", [""]] call BIS_fnc_param;
_name =  [_this, 1, "", [""]] call BIS_fnc_param;

"extLOG" callExtension format["1:SERVER_WHITELIST_BUYPASS_LOG:[%1] Player %2 is not whitelisted", _uid, _name];
Tanoa-Server/core/Log/fn_logComa.sqf0000777000000000000000000000136013535665003016327 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_bloodInfo", "_victim", "_direct_killer"];
_victim = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_bloodInfo = [_this, 1, [], [[]]] call BIS_fnc_param;
_direct_killer = [_this, 2, objNull, [objNull]] call BIS_fnc_param;

if (isNull _victim) exitWith {};

"extLOG" callExtension format
[
	"1:SERVER_PLAYER_COMA_LOG:%1 [%2] coma in %3 | %4 | %5",
	_victim getVariable "realname",
	getPlayerUID _victim,
	mapGridPosition _victim,
	if (_bloodInfo isEqualTo []) then {"No players damage info"} else {format["Players damage info %1", _bloodInfo]},
	if (isNull _direct_killer) then {"No direct killer"} else {format["%1 [%2]", _direct_killer getVariable "realname", getPlayerUID _direct_killer]}
];
Tanoa-Server/core/Log/fn_logDeadVehicles.sqf0000777000000000000000000000053513535665003017773 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_vehicle";
_vehicle = [_this, 0, objNull, [objNull]] call BIS_fnc_param;

if (isNull _vehicle) exitWith {};

"extLOG" callExtension format
[
	"1:SERVER_VEHICLES_DEAD_LOG: %1 | Info : %2 | Trunk : %3",
	typeOf(_vehicle),
	_vehicle getVariable ["info", []],
	_vehicle getVariable ["Trunk", []]
];
Tanoa-Server/core/Log/fn_logDeath.sqf0000777000000000000000000000101213535665003016467 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_killer", "_victim"];
_killer = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_victim = [_this, 1, objNull, [objNull]] call BIS_fnc_param;

if ((isNull _killer) || (isNull _victim)) exitWith {};

"extLOG" callExtension format
[
	"1:SERVER_PLAYER_DEATH_LOG:%1 [%2] killed %3 [%4] in %5",
	_killer getVariable ["realname", (name _killer)],
	getPlayerUID _killer,
	_victim getVariable ["realname", (name _victim)],
	getPlayerUID _victim,
	mapGridPosition _victim
];
Tanoa-Server/core/Log/fn_logDeathDisconnect.sqf0000777000000000000000000000133513535665003020511 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_unit", "_uid"];
_unit = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_uid = [_this, 1, "", [""]] call BIS_fnc_param;

if (gServer_soonReboot || (isNull _unit)) exitWith {};

"extLOG" callExtension format
[
	"1:SERVER_PLAYER_DEATH_DISCONNECT_LOG:%1 [%2] disconnect in %3 during coma | PrimaryWeapon [%4] | HandgunWeapon [%5]",
	_unit getVariable "realname",
	_uid,
	mapGridPosition _unit,
	if ((primaryWeapon _unit) isEqualTo "") then {"None"} else {getText(configFile >> "CfgWeapons" >> (primaryWeapon _unit) >> "displayName")},
	if ((handgunWeapon _unit) isEqualTo "") then {"None"} else {getText(configFile >> "CfgWeapons" >> (handgunWeapon _unit) >> "displayName")}
];
Tanoa-Server/core/Log/fn_logHouseBuy.sqf0000777000000000000000000000054413535665003017216 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

"extLOG" callExtension format
[
	"1:SERVER_HOUSE_BUY: %1 [%2] bought a building | Target : %3 | Classname : %4 | position : %5",
	(_this select 1) getVariable "realname",
	getPlayerUID (_this select 1),
	(_this select 0) getVariable "house_owner",
	typeOf(_this select 0),
	mapGridPosition (_this select 0)
];
Tanoa-Server/core/Log/fn_logHouseSell.sqf0000777000000000000000000000054513535665003017357 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

"extLOG" callExtension format
[
	"1:SERVER_HOUSE_SELL: %1 [%2] sold his building | Target : %3 | Classname : %4 | position : %5",
	(_this select 1) getVariable "realname",
	getPlayerUID (_this select 1),
	(_this select 0) getVariable "house_owner",
	typeOf(_this select 0),
	mapGridPosition (_this select 0)
];
Tanoa-Server/core/Log/fn_logLaunder.sqf0000777000000000000000000000115614002277764017050 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_player", "_illegal_money", "_dollars_amount", "_type"];
_player =  [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_illegal_money =  [_this, 1, 0, [0]] call BIS_fnc_param;
_dollars_amount =  [_this, 2, 0, [0]] call BIS_fnc_param;
_type = [_this, 3, "", [""]] call BIS_fnc_param;

"extLOG" callExtension format
[
	"1:SERVER_LAUNDER_LOG:Player %1 [%2] launder %3$ and received %4$ (type : %5)",
	_player getVariable "realname",
	getPlayerUID _player,
	[_illegal_money] call AlysiaClient_fnc_numberText,
	[_dollars_amount] call AlysiaClient_fnc_numberText,
	_type
];
Tanoa-Server/core/Log/fn_logPerquisition.sqf0000777000000000000000000000063113535665003020143 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_info";

_info = (_this select 0) getVariable "house_owner";
if (isNil "_info") then {
	_info = (_this select 0) getVariable "company_info";
};

if (isNil "_info") exitWith {};

"extLOG" callExtension format
[
	"1:SERVER_PERQUISITION: %1 [%2] perquisition. Target : %3",
	(_this select 1) getVariable "realname",
	getPlayerUID (_this select 1),
	_info
];
Tanoa-Server/core/Log/fn_logRefund.sqf0000777000000000000000000000102214002277764016671 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_from", "_to", "_amount"];
_from = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_to = [_this, 1, objNull, [objNull]] call BIS_fnc_param;
_amount = [_this, 2, 0, [0]] call BIS_fnc_param;

if ((isNull _from) || (isNull _to)) exitWith {};

"extLOG" callExtension format
[
	"1:SERVER_REFUND_LOG:%1 [%2] refund %3$ to %4 [%5]",
	_from getVariable "realname",
	getPlayerUID _from,
	[_amount] call AlysiaClient_fnc_numberText,
	_to getVariable "realname",
	getPlayerUID _to
];
Tanoa-Server/core/Log/fn_logSuicide.sqf0000777000000000000000000000051213535665003017033 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_player";
_player = [_this, 0, objNull, [objNull]] call BIS_fnc_param;

if (isNull _player) exitWith {};

"extLOG" callExtension format
[
	"1:SERVER_PLAYER_SUICIDE_LOG:%1 [%2] suicide in %3",
	_player getVariable "realname",
	getPlayerUID _player,
	mapGridPosition _player
];
Tanoa-Server/core/Log/fn_logTemporyInventory.sqf0000777000000000000000000000074213535665003021030 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_name", "_uid", "_actual", "_last"];
_name = [_this, 0, "", [""]] call BIS_fnc_param;
_uid = [_this, 1, "", [""]] call BIS_fnc_param;
_actual = [_this, 2, [], [[]]] call BIS_fnc_param;
_last = [_this, 3, [], [[]]] call BIS_fnc_param;

if ((_name isEqualTo "") || (_uid isEqualTo "")) exitWith {};

"extLOG" callExtension format["1:SERVER_DUPLI_LOG:%1 [%2] possible duplication | %3 instead of %4", _name, _uid, _actual, _last];
Tanoa-Server/core/Log/fn_logTrade.sqf0000777000000000000000000000116714002277764016517 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_player", "_from", "_money"];
_player = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_from = [_this, 1, objNull, [objNull]] call BIS_fnc_param;
_money = [_this, 2, 0, [0]] call BIS_fnc_param;
_inventory = [_this, 3, [], [[]]] call BIS_fnc_param;

if ((isNull _player) || (isNull _from)) exitWith {};

"extLOG" callExtension format
[
	"1:SERVER_PLAYER_TRADE_LOG:%1 [%2] received %3$ and %4 from %5 [%6]",
	_player getVariable "realname",
	getPlayerUID _player,
	[_money] call AlysiaClient_fnc_numberText,
	_inventory,
	_from getVariable "realname",
	getPlayerUID _from
];
Tanoa-Server/core/Market/0000777000000000000000000000000014003561130014232 5ustar  rootrootTanoa-Server/core/Market/fn_market_init.sqf0000777000000000000000000000173714003561203017752 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[BOURSE] Setup";

gServer_market_event_next = 60 * 5;
publicVariable "gServer_market_event_next";

{
	private["_ressourceName", "_ressourcePrice", "_query"];
	_ressourceName = configName _x;

	_query = [format["SELECT price FROM ressources WHERE name='%1'", _ressourceName], 2] call ExtDB3_fnc_async;
	if (_query isEqualTo []) then
	{
		diag_log format["[ERROR] Market ressource %1 was not saved into DB. Fixed", _ressourceName];
		[format["INSERT INTO ressources (name,price) VALUES ('%1','%2')", _ressourceName, getNumber(_x >> "market" >> "max")], 1] call ExtDB3_fnc_async;
		_ressourcePrice = getNumber(_x >> "market" >> "max");
	} else {
		_ressourcePrice = (_query select 0) select 0;
	};

	[_ressourceName, _ressourcePrice, true] call AlysiaServer_fnc_market_setPrice;
} foreach ("isClass(_x >> 'market')" configClasses (missionConfigFile >> "ADENIS_ITEMS"));

[] spawn AlysiaServer_fnc_market_loop;

diag_log "[BOURSE] Ready";
Tanoa-Server/core/Market/fn_market_loop.sqf0000777000000000000000000000204214003561203017746 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[BOURSE] Starting market loop...";

uiSleep(60 * 5);

while {!gServer_soonReboot} do
{
	diag_log "[BOURSE] Market event ...";

	{
		_ressource = configName _x;
		_actualPrice = [_ressource] call AlysiaClient_fnc_market_getPrice;
		_percent = round(random(20) + 10);
		if (random(100) < 45) then
		{
			if (_actualPrice != getNumber(_x >> "market" >> "min")) then
			{
				_newPrice = _actualPrice - (getNumber(_x >> "market" >> "max") * (_percent / 100));
				[_ressource, _newPrice, true] call AlysiaServer_fnc_market_setPrice;
			};
		} else {
			if (_actualPrice != getNumber(_x >> "market" >> "max")) then
			{
				_newPrice = _actualPrice + (getNumber(_x >> "market" >> "max") * (_percent / 100));
				[_ressource, _newPrice, true] call AlysiaServer_fnc_market_setPrice;
			};
		};
	} foreach ("isClass(_x >> 'market')" configClasses (missionConfigFile >> "ADENIS_ITEMS"));

	gServer_market_event_next = serverTime + (60 * 30);
	publicVariable "gServer_market_event_next";

	uiSleep (60 * 30);
};
Tanoa-Server/core/Market/fn_market_save.sqf0000777000000000000000000000061714003561203017741 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[BOURSE] Saving";

{
	_ressource = configName _x;

	[
		format
		[
			"UPDATE ressources SET price='%1' WHERE name='%2'",
			[_ressource] call AlysiaClient_fnc_market_getPrice,
			_ressource
		], 1
	] call ExtDB3_fnc_async;
} foreach ("isClass(_x >> 'market')" configClasses (missionConfigFile >> "ADENIS_ITEMS"));

diag_log "[BOURSE] Saved";
Tanoa-Server/core/Market/fn_market_setPrice.sqf0000777000000000000000000000120414003561203020552 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_price", "_max", "_min", "_config", "_item"];
_item = [_this, 0, "", [""]] call BIS_fnc_param;

if (_item isEqualTo "") exitWith {};

_config = missionConfigFile >> "ADENIS_ITEMS" >> _item;
if (!isClass(_config)) exitWith {};

_price = round([_this, 1, 1, [0]] call BIS_fnc_param);

_max = getNumber(_config >> "market" >> "max");
if (_price > _max) then {
	_price = _max;
};

_min = getNumber(_config >> "market" >> "min");
if (_price < _min) then {
	_price = _min;
};

missionNamespace setVariable [
	format["market_%1", _item],
	_price,
	[_this, 2, false, [false]] call BIS_fnc_param
];
Tanoa-Server/core/MySQL/0000777000000000000000000000000014003561130013754 5ustar  rootrootTanoa-Server/core/MySQL/fn_query_delete_wipe.sqf0000777000000000000000000000101514002300036020660 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_uid";
_uid = [_this, 0, "", [""]] call BIS_fnc_param;

if (_uid isEqualTo "") exitWith {};

[format["DELETE FROM players WHERE uid='%1'", _uid], 1] call ExtDB3_fnc_async;
[format["DELETE FROM vehicles WHERE pid='%1'", _uid], 1] call ExtDB3_fnc_async;
[format["DELETE FROM labo WHERE owner='%1'", _uid], 1] call ExtDB3_fnc_async;

{
	_x setVariable ["house_tenants", (_x getVariable ["house_tenants", []]) - [_uid]];
} forEach ([_uid] call AlysiaServer_fnc_house_fetch);
Tanoa-Server/core/MySQL/fn_query_insert_inscription.sqf0000777000000000000000000000312314002300036022321 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_player", "_profileName", "_firstName", "_lastName", "_birth", "_nationality", "_sexe"];
_player = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_profileName = [_this, 1, "", [""]] call BIS_fnc_param;
_firstName = [_this, 2, "", [""]] call BIS_fnc_param;
_lastName = [_this, 3, "", [""]] call BIS_fnc_param;
_birth = [_this, 4, [], [[]]] call BIS_fnc_param;
_nationality = [_this, 5, "", [""]] call BIS_fnc_param;
_sexe = [_this, 6, "", [""]] call BIS_fnc_param;

if (
		(isNull _player) ||
		(_profileName isEqualTo "") ||
		(_firstName isEqualTo "") ||
		(_lastName isEqualTo "") ||
		(_birth isEqualTo []) ||
		(_nationality isEqualTo "") ||
		(_sexe isEqualTo "")
) exitWith {
	diag_log "Error in fn_query_insert_inscription.sqf : arg null";
};

[
	format
	[
		"INSERT INTO players (uid,profileName,HEALTH_deseases,PHONE_messages,PHONE_contacts,PHONE_blacklist,TABLET_apps,RP_firstname,RP_lastname,RP_birth,RP_nationality,RP_sexe,CIV_gear,CIV_inventory,CIV_licenses,WEST_gear,WEST_inventory,WEST_licenses,EAST_gear,EAST_inventory,EAST_licenses,GUER_gear,GUER_inventory,GUER_licenses,JAIL_gear,RP_face,DYN_markers,CIV_cash,CIV_atm) VALUES ('%2','%3','""[[],[],[]]""','%1','%1','%1','%1','%4','%5','%6','%7','%8','%1','%1','%1','%1','%1','%1','%1','%1','%1','%1','%1','%1','%1','%9','%1','2500','1000')",
		"""[]""",
		(getPlayerUID _player),
		_profileName,
		_firstName,
		_lastName,
		[_birth] call AlysiaServer_fnc_mresArray,
		_nationality,
		_sexe,
		(face _player)
	], 1
] call ExtDB3_fnc_async;

[_player] call AlysiaServer_fnc_query_select_connect;
Tanoa-Server/core/MySQL/fn_query_select_connect.sqf0000777000000000000000000000766714002300036021405 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

#define BASE_REQUEST "\
uid,\
profileName,\
RP_firstname,\
RP_lastname,\
RP_birth,\
RP_nationality,\
RP_sexe,\
DYN_markers,\
LEVEL_donator,\
HEALTH_blood,\
HEALTH_bleed,\
HEALTH_coma,\
POS_x,\
POS_y,\
POS_z,\
POS_alive,\
HEALTH_deseases,\
HEALTH_hunger,\
HEALTH_thirst,\
WEST_level,\
GUER_level,\
EAST_level,\
CIV_level,\
JAIL_prison,\
JAIL_cell,\
JAIL_time,\
JAIL_caution,\
JAIL_reason,\
JAIL_escape,\
JAIL_gear,\
PHONE_number,\
PHONE_contacts,\
PHONE_messages,\
PHONE_forfait,\
PHONE_blacklist,\
TABLET_apps,\
RP_face,\
RP_face,\
HEALTH_alcool,\
HEALTH_hurt,\
PHONE_annuaire"

#define CIV_REQUEST ",\
CIV_licenses,\
CIV_cash,\
CIV_atm,\
CIV_inventory,\
CIV_gear"

#define EAST_REQUEST ",\
EAST_licenses,\
EAST_cash,\
EAST_atm,\
EAST_inventory,\
EAST_gear"

#define GUER_REQUEST ",\
GUER_licenses,\
GUER_cash,\
GUER_atm,\
GUER_inventory,\
GUER_gear"

#define WEST_REQUEST ",\
WEST_licenses,\
WEST_cash,\
WEST_atm,\
WEST_inventory,\
WEST_gear"

private["_player", "_side", "_uid", "_queryResult"];
_player = [_this, 0, ObjNull, [ObjNull]] call BIS_fnc_param;

if (isNull _player) exitWith {};

_uid = getPlayerUID _player;

_side = side _player;
_queryResult = switch (_side) do
{
	case civilian: {[format["SELECT %1 %2 FROM players WHERE uid='%3'", BASE_REQUEST, CIV_REQUEST, _uid], 2] call ExtDB3_fnc_async};
	case east: {[format["SELECT %1 %2 FROM players WHERE uid='%3'", BASE_REQUEST, EAST_REQUEST, _uid], 2] call ExtDB3_fnc_async};
	case independent: {[format["SELECT %1 %2 FROM players WHERE uid='%3'", BASE_REQUEST, GUER_REQUEST, _uid], 2] call ExtDB3_fnc_async};
	case west: {[format["SELECT %1 %2 FROM players WHERE uid='%3'", BASE_REQUEST, WEST_REQUEST, _uid], 2] call ExtDB3_fnc_async};
};

if (_queryResult isEqualTo []) exitWith {
	[] remoteExec ["AlysiaClient_fnc_welcomeInit", (owner _player)];
};

_queryResult = _queryResult select 0;
_queryResult set [4, ([(_queryResult select 4)] call AlysiaServer_fnc_mresToArray)];//birth
_queryResult set [7, ([(_queryResult select 7)] call AlysiaServer_fnc_mresToArray)];//dynamic markers
_queryResult set [11, ([(_queryResult select 11), 1] call AlysiaServer_fnc_bool)];//coma
_queryResult set [15, ([(_queryResult select 15), 1] call AlysiaServer_fnc_bool)];//alive
_queryResult set [16, ([(_queryResult select 16)] call AlysiaServer_fnc_mresToArray)];//deseases
_queryResult set [28, ([(_queryResult select 28), 1] call AlysiaServer_fnc_bool)];//escape
_queryResult set [29, ([(_queryResult select 29)] call AlysiaServer_fnc_mresToArray)];//prison gear
_queryResult set [31, ([(_queryResult select 31)] call AlysiaServer_fnc_mresToArray)];//phone_contacts
_queryResult set [32, ([(_queryResult select 32)] call AlysiaServer_fnc_mresToArray)];//phone_messages
_queryResult set [34, ([(_queryResult select 34)] call AlysiaServer_fnc_mresToArray)];//phone_blacklist
_queryResult set [35, ([(_queryResult select 35)] call AlysiaServer_fnc_mresToArray)];//apps
_queryResult set [40, ([(_queryResult select 40), 1] call AlysiaServer_fnc_bool)];//annuaire
_queryResult set [41, ([(_queryResult select 41)] call AlysiaServer_fnc_mresToArray)];//licenses
_queryResult set [44, ([(_queryResult select 44)] call AlysiaServer_fnc_mresToArray)];//inventory
_queryResult set [45, ([(_queryResult select 45)] call AlysiaServer_fnc_mresToArray)];//gear

// buffer messages handler
_messages = missionNamespace getVariable [format["SERVER_MESSAGES_%1", (_queryResult select 30)], []];
if (count(_messages) > 0) then
{
	gServer_phone_messages_buffer deleteAt (gServer_phone_messages_buffer find (_queryResult select 30));
	missionNamespace setVariable [format["SERVER_MESSAGES_%1", (_queryResult select 30)], []];
};

[
	_queryResult,
	([_uid] call AlysiaServer_fnc_house_fetch),
	(missionNamespace getVariable [format["%1_KEYS_%2", _uid, _side], []]),
	_messages,
	([_uid] call AlysiaServer_fnc_company_fetch),
	([_uid] call AlysiaServer_fnc_laboratory_fetch)
] remoteExecCall ["AlysiaDB_fnc_query_select_receive", (owner _player)];
Tanoa-Server/core/MySQL/fn_query_update_disconnect.sqf0000777000000000000000000000343614002300036022076 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

[
	format
	[
		"UPDATE players SET POS_alive='%1',HEALTH_deseases='%2',STATS_global_played=STATS_global_played+'%3',HEALTH_blood='%4',HEALTH_bleed='%5',HEALTH_hunger='%6',HEALTH_thirst='%7',PHONE_contacts='%8',PHONE_messages='%9',PHONE_forfait='%10',PHONE_blacklist='%11',TABLET_apps='%12',%13_cash='%14',%13_atm='%15',%13_inventory='%16',%13_licenses='%17',DYN_markers='%19',HEALTH_alcool='%20',PHONE_annuaire='%21' WHERE uid='%18'",
		([[_this, 5, false, [false]] call BIS_fnc_param] call AlysiaServer_fnc_bool),
		([[_this, 6, [], [[]]] call BIS_fnc_param] call AlysiaServer_fnc_mresArray),
		([_this, 7, 0, [0]] call BIS_fnc_param),
		([_this, 8, 4000, [0]] call BIS_fnc_param),
		([_this, 9, 0, [0]] call BIS_fnc_param),
		([_this, 10, 100, [0]] call BIS_fnc_param),
		([_this, 11, 100, [0]] call BIS_fnc_param),
		([[_this, 12, [], [[]]] call BIS_fnc_param] call AlysiaServer_fnc_mresArray),
		([[_this, 13, [], [[]]] call BIS_fnc_param] call AlysiaServer_fnc_mresArray),
		([_this, 14, "none", [""]] call BIS_fnc_param),
		([[_this, 15, [], [[]]] call BIS_fnc_param] call AlysiaServer_fnc_mresArray),
		([[_this, 16, [], [[]]] call BIS_fnc_param] call AlysiaServer_fnc_mresArray),
		str([_this, 1, sideUnknown, [civilian]] call BIS_fnc_param),
		([_this, 2, 0, [0]] call BIS_fnc_param),
		([_this, 3, 0, [0]] call BIS_fnc_param),
		([[_this, 4, [], [[]]] call BIS_fnc_param] call AlysiaServer_fnc_mresArray),
		([[_this, 17, [], [[]]] call BIS_fnc_param] call AlysiaServer_fnc_mresArray),
		([_this, 0, "", [""]] call BIS_fnc_param),
		([[_this, 18, [], [[]]] call BIS_fnc_param] call AlysiaServer_fnc_mresArray),
		([_this, 19, 0, [0]] call BIS_fnc_param),
		([[_this, 20, false, [false]] call BIS_fnc_param] call AlysiaServer_fnc_bool)
	], 1
] call ExtDB3_fnc_async;
Tanoa-Server/core/MySQL/fn_query_update_partial.sqf0000777000000000000000000000416414002300036021400 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_uid", "_side", "_value", "_mode", "_query"];
_uid = [_this, 0, "", [""]] call BIS_fnc_param;
_side = [_this, 1, sideUnknown, [civilian]] call BIS_fnc_param;
_mode = [_this, 3, -1, [0]] call BIS_fnc_param;

if ((_uid isEqualTo "") || (_side isEqualTo sideUnknown) || (_mode isEqualTo -1)) exitWith {};

_value = _this select 2;

_query = switch (_mode) do
{
	case 0:
	{
		switch (_side) do
		{
			case civilian: {format["CIV_cash='%1',CIV_atm='%2'", (_value select 0), (_value select 1)]};
			case west: {format["WEST_cash='%1',WEST_atm='%2'", (_value select 0), (_value select 1)]};
			case east: {format["EAST_cash='%1',EAST_atm='%2'", (_value select 0), (_value select 1)]};
			case independent: {format["GUER_cash='%1',GUER_atm='%2'", (_value select 0), (_value select 1)]};
		};
	};

	case 1:
	{
		switch (_side) do
		{
			case civilian: {format["CIV_inventory='%1',CIV_gear='%2'", [(_value select 0)] call AlysiaServer_fnc_mresArray, [(_value select 1)] call AlysiaServer_fnc_mresArray]};
			case west: {format["WEST_inventory='%1',WEST_gear='%2'", [(_value select 0)] call AlysiaServer_fnc_mresArray, [(_value select 1)] call AlysiaServer_fnc_mresArray]};
			case east: {format["EAST_inventory='%1',EAST_gear='%2'", [(_value select 0)] call AlysiaServer_fnc_mresArray, [(_value select 1)] call AlysiaServer_fnc_mresArray]};
			case independent: {format["GUER_inventory='%1',GUER_gear='%2'", [(_value select 0)] call AlysiaServer_fnc_mresArray, [(_value select 1)] call AlysiaServer_fnc_mresArray]};
		};
	};

	case 3:
	{
		format
		[
			"JAIL_time='%1',JAIL_prison='%2',JAIL_cell='%3',JAIL_caution='%4',JAIL_gear='%5',JAIL_reason='%6',JAIL_escape='%7'",
			(_value select 0),
			(_value select 1),
			(_value select 2),
			(_value select 3),
			([_value select 4] call AlysiaServer_fnc_mresArray),
			(_value select 5),
			([_value select 6] call AlysiaServer_fnc_bool)
		]
	};
	default {""};
};

if (_query != "") then {
	[format["UPDATE players SET %1 WHERE uid='%2'", _query, _uid], 1] call ExtDB3_fnc_async;
} else {
	diag_log format["[ERROR] %1 : cannot find _query for partial update", _this];
};
Tanoa-Server/core/MySQL/fn_query_update_usual.sqf0000777000000000000000000000214614002300036021073 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_uid"];
_uid = [_this, 0, "", [""]] call BIS_fnc_param;

if (_uid isEqualTo "") exitWith {};

[
	format
	[
		"UPDATE players SET POS_alive='%1',HEALTH_blood='%2',HEALTH_bleed='%3',HEALTH_hunger='%4',HEALTH_thirst='%5',PHONE_forfait='%6',%7_cash='%8',%7_atm='%9',%7_inventory='%10',%7_licenses='%11' WHERE uid='%12'",
		([[_this, 5, false, [false]] call BIS_fnc_param] call AlysiaServer_fnc_bool),
		([_this, 6, 4000, [0]] call BIS_fnc_param),
		([_this, 7, 0, [0]] call BIS_fnc_param),
		([_this, 8, 100, [0]] call BIS_fnc_param),
		([_this, 9, 100, [0]] call BIS_fnc_param),
		([_this, 10, "none", [""]] call BIS_fnc_param),
		str([_this, 1, sideUnknown, [civilian]] call BIS_fnc_param),
		([_this, 2, 0, [0]] call BIS_fnc_param),
		([_this, 3, 0, [0]] call BIS_fnc_param),
		([[_this, 4, [], [[]]] call BIS_fnc_param] call AlysiaServer_fnc_mresArray),
		([[_this, 11, [], [[]]] call BIS_fnc_param] call AlysiaServer_fnc_mresArray),
		_uid
	], 1
] call ExtDB3_fnc_async;

if (player getVariable ["arrested", false]) then
{
	[3] call AlysiaDB_fnc_query_update_partial;
};
Tanoa-Server/core/Phone/0000777000000000000000000000000014003561131014061 5ustar  rootrootTanoa-Server/core/Phone/fn_phoneInit.sqf0000777000000000000000000000133313535665003017233 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[PHONE] Setup";

["UPDATE players SET PHONE_number='', PHONE_contacts='""[]""', PHONE_messages='""[]""',PHONE_forfait='lite' WHERE DATEDIFF(NOW(),STATS_last_update)>31", 1] call ExtDB3_fnc_async;
uiSleep 1;

gServer_phone_messages_buffer = [];
gServer_phone_numbers = [];

{
	gServer_phone_numbers pushBack (_x select 0);
} forEach (["SELECT PHONE_number FROM players WHERE PHONE_number!=''", 2] call ExtDB3_fnc_async);
publicVariable "gServer_phone_numbers";

gServer_phone_annuaire = ["SELECT profileName,PHONE_number FROM players WHERE PHONE_number!='' AND PHONE_annuaire='1'", 2] call ExtDB3_fnc_async;
publicVariable "gServer_phone_annuaire";

diag_log "[PHONE] Ready";
Tanoa-Server/core/Phone/fn_phoneMessageHandler.sqf0000777000000000000000000000144214002277764021216 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_msg", "_from", "_to", "_hide", "_messages"];
_msg = [_this, 0, "", [""]] call BIS_fnc_param;
_from = [_this, 1, "", [""]] call BIS_fnc_param;
_to = [_this, 2, "", [""]] call BIS_fnc_param;
_hide = [_this, 3, false, [false]] call BIS_fnc_param;

if ((_msg isEqualTo "") || (_from isEqualTo "") || (_to isEqualTo "")) exitWith {};

_messages = missionNamespace getVariable [format["SERVER_MESSAGES_%1", _to], []];
_messages pushBack [[_from, (format["Le %1 à %2", ([] call AlysiaClient_fnc_strDate), ([] call AlysiaClient_fnc_strTime)]), 0, _msg], _hide];
missionNamespace setVariable [format["SERVER_MESSAGES_%1", _to], _messages];

if ((gServer_phone_messages_buffer find _to) isEqualTo -1) then {
	gServer_phone_messages_buffer pushBack _to;
};
Tanoa-Server/core/Phone/fn_phoneMessageSave.sqf0000777000000000000000000000126714002300036020517 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

{
	_new_messages = (missionNamespace getVariable[format["SERVER_MESSAGES_%1", _x], []]);
	if (!(_new_messages isEqualTo [])) then
	{
		_queryResult = [format["SELECT PHONE_messages FROM players WHERE PHONE_number='%1'", _x], 2] call ExtDB3_fnc_async;
		if (!(_queryResult isEqualTo [])) then
		{
			_old_messages = ([(_queryResult select 0)] call AlysiaServer_fnc_mresArray);

			{
				_old_messages pushBack _x;
			} forEach _new_messages;

			[format["UPDATE players SET PHONE_messages='%1' WHERE PHONE_number='%2'", [_old_messages] call AlysiaServer_fnc_mresArray, _x], 1] call ExtDB3_fnc_async;
		};
	};
} forEach gServer_phone_messages_buffer;
Tanoa-Server/core/Systems/0000777000000000000000000000000014004603013014454 5ustar  rootrootTanoa-Server/core/Systems/fn_clientDisconnect.sqf0000777000000000000000000000420714002300036021145 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_unit", "_id", "_uid", "_name"];
_unit = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_id = [_this, 1, -1, [0]] call BIS_fnc_param;
_uid = [_this, 2, "", [""]] call BIS_fnc_param;
_name = [_this, 3, "", [""]] call BIS_fnc_param;

if ((isNull _unit) || (_id isEqualTo -1)) exitWith {};

_name = _unit getVariable "realname";
if (!(isNil "_name")) then
{
	private["_gear", "_pos", "_query"];
	_gear = [_unit] call AlysiaClient_fnc_getGear;

	_query = switch (side _unit) do
	{
		case west: {format["WEST_gear='%1',", ([_gear] call AlysiaServer_fnc_mresArray)]};
		case east: {format["EAST_gear='%1',", ([_gear] call AlysiaServer_fnc_mresArray)]};
		case independent: {format["GUER_gear='%1',", ([_gear] call AlysiaServer_fnc_mresArray)]};
		default {format["CIV_gear='%1',", ([_gear] call AlysiaServer_fnc_mresArray)]};
	};

	_pos = getPosATL _unit;
	[
		format
		[
			"UPDATE players SET %1 POS_x='%3',POS_y='%4',POS_z='%5',POS_direction='%6',HEALTH_fatigue='%7',PHONE_number='%8',HEALTH_coma='%9',HEALTH_hurt='%10' WHERE uid='%2'",
			_query,
			_uid,
			(_pos select 0),
			(_pos select 1),
			(_pos select 2),
			(getDir _unit),
			(getFatigue _unit),
			(_unit getVariable ["number", ""]),
			([(_unit getVariable ["is_coma", false])] call AlysiaServer_fnc_bool),
			([(_unit getVariable ["bullet_check", false])] call AlysiaServer_fnc_bool)
		], 1
	] call ExtDB3_fnc_async;

	{
		if (!(isNull _x)) then
		{
			if (!(_x getVariable ["ready", false])) then
			{
				diag_log format["[lyeed] CLEANING %1", _x];
				deleteVehicle _x;
			};
		};
	} forEach (missionNamespace getVariable [format["%1_PLANTS", _uid], []]);

	{
		if (typeOf(_x) in ["Alsatian_Sand_F", "Alsatian_Black_F", "Alsatian_Sandblack_F"]) then {deleteVehicle _x};
	} forEach (units (group _unit));

	if (_unit getVariable ["is_coma", false]) then {
		[_unit, _uid] call AlysiaServer_fnc_logDeathDisconnect;
	};
};

{
	deleteVehicle _x;
} forEach (nearestObjects [_unit, ["WeaponHolderSimulated", "GroundWeaponHolder"], 3]);

if ((units (group _unit)) isEqualTo []) then
{
	diag_log "DELETING GROUP";
	deleteGroup (group _unit);
};

deleteVehicle _unit;
Tanoa-Server/core/Systems/fn_keyManagement.sqf0000777000000000000000000000111413535665003020456 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_uid", "_side", "_vehicle"];
_uid = [_this, 0, "", [""]] call BIS_fnc_param;
_side = [_this, 1, sideUnknown, [sideUnknown]] call BIS_fnc_param;
_vehicle = [_this, 2, objNull, [objNull]] call BIS_fnc_param;

if ((_uid isEqualTo "") || (_side isEqualTo sideUnknown) || (isNull _vehicle)) exitWith {};

_arr = missionNamespace getVariable [format["%1_KEYS_%2", _uid, _side], []];
_arr = _arr - [ObjNull];
if (!(_vehicle in _arr)) then {
	_arr pushBack _vehicle;
};

missionNamespace setVariable[format["%1_KEYS_%2", _uid, _side], _arr];
Tanoa-Server/core/Systems/fn_spikeStrip.sqf0000777000000000000000000000136214002277764020036 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_nearVehicles", "_spikeStrip", "_vehicle"];
_spikeStrip = [_this, 0, ObjNull, [ObjNull]] call BIS_fnc_param;

if (isNull _spikeStrip) exitWith {};

waitUntil
{
	_nearVehicles = nearestObjects[(getPos _spikeStrip), ["Car"], 2.9];
	((count _nearVehicles > 0) || (isNull _spikeStrip))
};

if (isNull _spikeStrip) exitWith {};

_vehicle = _nearVehicles select 0;
if (isNil "_vehicle") exitWith {};

[_vehicle, "HitLFWheel", 1] call AlysiaClient_fnc_setHitPointDamage;
[_vehicle, "HitLF2Wheel", 1] call AlysiaClient_fnc_setHitPointDamage;
[_vehicle, "HitRFWheel", 1] call AlysiaClient_fnc_setHitPointDamage;
[_vehicle, "HitRF2Wheel", 1] call AlysiaClient_fnc_setHitPointDamage;
deleteVehicle _spikeStrip;
Tanoa-Server/core/Systems/fn_whitelistRebels.sqf0000777000000000000000000000170314002277764021051 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_target", "_level", "_from"];
_target = [_this, 0, objNull, [objNull]] call BIS_fnc_param;
_level = [_this, 1, 0, [0]] call BIS_fnc_param;
_from = [_this, 2, objNull, [objNull]] call BIS_fnc_param;

if ((isNull _target) || (isNull _from)) exitWith {};

[
	format
	[
		"<t color='#FF8000'>%1</t><br/>Nouveau niveau d'accréditation rebelle : <t color='#00FF00'>%2</t>",
		_target getVariable "realname",
		_level
	]
] remoteExecCall ["AlysiaClient_fnc_info", (owner _from)];

[
	format
	[
		"Votre niveau d'accréditation rebelle a été <t color='#FF8000'>mis à jour</t>.<br/><br/>Nouveau niveau : <t color='#00FF00'>%1</t>.<br/>Veuillez vous reconnecter.",
		_level
	]
] remoteExecCall ["AlysiaClient_fnc_info", (owner _target)];

_target setVariable ["rank", _level, true];

[
	format
	[
		"UPDATE players SET CIV_level='%1' WHERE uid='%2'",
		_level,
		getPlayerUID _target
	], 1
] call ExtDB3_fnc_async;
Tanoa-Server/core/Tools/0000777000000000000000000000000014003561131014110 5ustar  rootrootTanoa-Server/core/Tools/fn_bool.sqf0000777000000000000000000000113513535665003016260 0ustar  rootroot/*
	File: fn_bool.sqf
	Author: TAW_Tonic
	
	Description:
	Handles bool conversion for MySQL since MySQL doesn't support 'true' or 'false'
	instead MySQL uses Tinyint for BOOLEAN (0 = false, 1 = true)
*/
private["_bool", "_mode"];
_bool = [_this, 0, 0, [false, 0]] call BIS_fnc_param;
_mode = [_this, 1, 0, [0]] call BIS_fnc_param;

switch (_mode) do
{
	case 0:
	{
		if ((typeName _bool) isEqualTo "SCALAR") exitWith {0};
		if (_bool) then {1} else {0};
	};
		
	case 1:
	{
		if ((typeName _bool) isEqualTo "BOOL") exitWith {false};
		switch (_bool) do
		{
			case 0: {false};
			case 1: {true};
		};
	};
};Tanoa-Server/core/Tools/fn_getRealTime.sqf0000777000000000000000000000036413535665003017532 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
(["SELECT HOUR(CURTIME()), MINUTE(CURTIME()), MONTH(CURDATE()), YEAR(CURDATE()), DAYOFMONTH(CURDATE())", 2] call ExtDB3_fnc_async) select 0;
/*	0 : Month
	1 : Minute
	2 : Month
	3 : Year
	4 : Day
*/
Tanoa-Server/core/Tools/fn_mresArray.sqf0000777000000000000000000000100613535665003017267 0ustar  rootroot/*
	File: fn_mresArray.sqf
	Author: Bryan "Tonic" Boardwine";
	
	Description:
	Acts as a mres (MySQL Real Escape) for arrays so they
	can be properly inserted into the database without causing
	any problems. The return method is 'hacky' but it's effective.
*/
private["_array"];
_array = [_this, 0, [], [[]]] call BIS_fnc_param;

if (_array isEqualTo []) exitWith {"""[]"""};

_array = toArray(str(_array));
{
	if (_x isEqualTo 34) then {
		_array set[_forEachIndex, 96];
	};
} forEach (_array);
str(toString(_array));Tanoa-Server/core/Tools/fn_mresString.sqf0000777000000000000000000000045513535665003017466 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_string", "_filter"];
_string = toArray ([_this, 0, "", [""]] call BIS_fnc_param);
_filter = toArray "'/\`:|;,{}-""<>";

{
	if (_x in _filter) then {_string set [_forEachIndex, -1]};
} foreach _string;

_string = _string - [-1];
toString _string;
Tanoa-Server/core/Tools/fn_mresToArray.sqf0000777000000000000000000000104013535665003017570 0ustar  rootroot/*
	File: fn_mresToArray.sqf
	Author: Bryan "Tonic" Boardwine";
	
	Description:
	Acts as a mres (MySQL Real Escape) for arrays so they
	can be properly inserted into the database without causing
	any problems. The return method is 'hacky' but it's effective.
*/
private["_array"];
_array = [_this, 0, """[]""", [""]] call BIS_fnc_param;

if (_array isEqualTo """[]""") exitWith {[]};

_array = toArray(_array);
{
	if (_x isEqualTo 96) then {
		_array set[_forEachIndex, 39];
	};
} forEach (_array);
call compile format["%1", toString(_array)];
Tanoa-Server/core/Tools/fn_numberSafe.sqf0000777000000000000000000000120313535665003017410 0ustar  rootroot/*
	Author: Karel Moricky

	Description:
	Convert a number into string (avoiding scientific notation)

	Parameter(s):
	_this: NUMBER

	Returns:
	STRING
*/
private ["_number","_mod","_digots","_digitsCount","_modBase","_numberText"];

_number = [_this,0,0,[0]] call bis_fnc_param;
_mod = [_this,1,3,[0]] call bis_fnc_param;

_digits = _number call bis_fnc_numberDigits;
_digitsCount = count _digits - 1;

_modBase = _digitsCount % _mod;
_numberText = "";
{
	_numberText = _numberText + str _x;
	if ((_foreachindex - _modBase) % (_mod) == 0 && _foreachindex != _digitsCount) then {_numberText = _numberText + "";};
} foreach _digits;
_numberTextTanoa-Server/core/Vehicles/0000777000000000000000000000000014003561131014552 5ustar  rootrootTanoa-Server/core/Vehicles/fn_vehicleCreate.sqf0000777000000000000000000000306614003561203020523 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_player", "_vehicle", "_plate", "_insurance", "_active", "_className", "_type"];
_player = [_this, 0, ObjNull, [ObjNull]] call BIS_fnc_param;
_vehicle = [_this, 1, ObjNull, [ObjNull]] call BIS_fnc_param;
_className = [_this, 2, "", [""]] call BIS_fnc_param;

if ((isNull _player) || (_className isEqualTo "")) exitWith {};

_plate = round(random(999999));
_insurance = getNumber(missionConfigFile >> "ADENIS_VEHICLES" >> _className >> "insurance");

if (isNull _vehicle) then
{
	_active = 0;
	_type = switch (true) do
	{
		case (_className isKindOf "Tank"): {"Tank"};
		case (_className isKindOf "Air"): {"Air"};
		case (_className isKindOf "Ship"): {"Ship"};
		default {"Car"};
	};
} else {
	_active = 1;
	_vehicle setVariable ["info", [(getPlayerUID _player), (_player getVariable "realname"), _plate, _insurance], true];
	[(getPlayerUID _player), (side _player), _vehicle] call AlysiaServer_fnc_keyManagement;
	_type = switch (true) do
	{
		case (_vehicle isKindOf "Tank"): {"Tank"};
		case (_vehicle isKindOf "Air"): {"Air"};
		case (_vehicle isKindOf "Ship"): {"Ship"};
		default {"Car"};
	};
};

[
	format
	[
		"INSERT INTO vehicles (side,classname,type,pid,inventory,plate,displayname,HitPointsDamage,active,assurance) VALUES ('%1','%2','%3','%4','""[]""','%5','%6','""[]""','%7','%8')",
		str(side _player),
		_className,
		_type,
		(getPlayerUID _player),
		_plate,
		[getText(configFile >> "CfgVehicles" >> _className >> "displayName")] call AlysiaServer_fnc_mresString,
		_active,
		_insurance
	], 1
] call ExtDB3_fnc_async;
Tanoa-Server/core/Vehicles/fn_vehicleDelete.sqf0000777000000000000000000000123613535665003020533 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_info", "_apply_insurance"];
_info = [_this, 0, [], [[]]] call BIS_fnc_param;
_apply_insurance = [_this, 1, true, [true]] call BIS_fnc_param;

if (_info isEqualTo []) exitWith {};

if (_apply_insurance && ((_info select 3) isEqualTo 1)) then {
	[format["UPDATE vehicles SET assurance='0',inventory='""[]""',fuel='100',fuel_type='',active='0',POS_store_x='0',POS_store_y='0',POS_store_z='0',POS_x='0',POS_y='0',POS_z='0',HitPointsDamage='""[]""' WHERE plate='%1'", (_info select 2)], 1] call ExtDB3_fnc_async;
} else {
	[format["DELETE FROM vehicles WHERE plate='%1'", (_info select 2)], 1] call ExtDB3_fnc_async;
};
Tanoa-Server/core/Vehicles/fn_vehicle_update_fuel.sqf0000777000000000000000000000047013535665003021764 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_plate", "_fuel"];
_plate = [_this, 0, -1, [-1]] call BIS_fnc_param;
_fuel = [_this, 1, 100, [0]] call BIS_fnc_param;

if (_plate isEqualTo -1) exitWith {};

[format["UPDATE vehicles SET fuel='%1' WHERE plate='%2'", _fuel, _plate], 1] call ExtDB3_fnc_async;
Tanoa-Server/core/Vehicles/fn_vehicle_update_insurrance.sqf0000777000000000000000000000051513535665003023202 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_plate", "_insurrance"];
_plate = [_this, 0, -1, [-1]] call BIS_fnc_param;
_insurrance = [_this, 1, 0, [0]] call BIS_fnc_param;

if (_plate isEqualTo -1) exitWith {};

[format["UPDATE vehicles SET assurance='%1' WHERE plate='%2'", _insurrance, _plate], 1] call ExtDB3_fnc_async;
Tanoa-Server/core/Vehicles/fn_vehicle_update_name.sqf0000777000000000000000000000053113535665003021747 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_plate", "_name"];
_plate = [_this, 0, -1, [-1]] call BIS_fnc_param;
_name = [_this, 1, "", [""]] call BIS_fnc_param;

if ((_plate isEqualTo -1) || (_name isEqualTo "")) exitWith {};

[format["UPDATE vehicles SET displayname='%1' WHERE plate='%2'", _name, _plate], 1] call ExtDB3_fnc_async;
Tanoa-Server/core/Vehicles/fn_vehicle_update_owner.sqf0000777000000000000000000000065313776347133022176 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Loann
*/
private["_plate", "_owner","_side"];
_plate = [_this, 0, -1, [-1]] call BIS_fnc_param;
_owner = [_this, 1, "", [""]] call BIS_fnc_param;
_side = [_this, 2, "", [""]] call BIS_fnc_param;

if ((_plate isEqualTo -1) || (_name isEqualTo "")) exitWith {};

[format["UPDATE vehicles SET pid='%1', side='%3' WHERE plate='%2'", _owner, _plate, _side], 1] call ExtDB3_fnc_async;
Tanoa-Server/core/Vehicles/fn_vehicle_update_storePos.sqf0000777000000000000000000000070413535665003022647 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private["_plate", "_position"];
_plate = [_this, 0, -1, [-1]] call BIS_fnc_param;
_position = [_this, 1, [], [[]]] call BIS_fnc_param;

if ((_plate isEqualTo -1) || (_position isEqualTo [])) exitWith {};

[format["UPDATE vehicles SET POS_store_x='%1', POS_store_y='%2', POS_store_z='%3' WHERE plate='%4'", (_position select 0), (_position select 1), (_position select 2), _plate], 1] call ExtDB3_fnc_async;
Tanoa-Server/extDB3/0000777000000000000000000000000014003561131013151 5ustar  rootrootTanoa-Server/extDB3/fn_async.sqf0000777000000000000000000000274113535665003015507 0ustar  rootroot/*
	File: asyncCall.sqf
	Author: Bryan "Tonic" Boardwine

	Description:
	Commits an asynchronous call to extDB
	Gets result via extDB  4:x + uses 5:x if message is Multi-Part

	Parameters:
		0: STRING (Query to be ran).
		1: INTEGER (1 = ASYNC + not return for update/insert, 2 = ASYNC + return for query's).
*/

if (!params [
	["_queryStmt", "", [""]],
	["_mode", 0, [0]]
]) exitWith {};

private _key = "extDB3" callExtension format["%1:%2:%3",_mode, "SQL", _queryStmt];
if(_mode isEqualTo 1) exitWith {true};

_key = call compile format["%1",_key];
_key = _key select 1;

uisleep (random .03);

private _queryResult = "";
private _loop = true;
while{_loop} do
{
	_queryResult = "extDB3" callExtension format["4:%1", _key];
	if (_queryResult isEqualTo "[5]") then {
		// extDB3 returned that result is Multi-Part Message
		_queryResult = "";
		while{true} do {
			_pipe = "extDB3" callExtension format["5:%1", _key];
			if(_pipe isEqualTo "") exitWith {_loop = false};
			_queryResult = _queryResult + _pipe;
		};
	}
	else
	{
		if (_queryResult isEqualTo "[3]") then
		{
			diag_log format ["extDB3: uisleep [4]: %1", diag_tickTime];
			uisleep 0.1;
		} else {
			_loop = false;
		};
	};
};


_queryResult = call compile _queryResult;

// Not needed, its SQF Code incase extDB3 ever returns error message i.e Database Connection Died
if ((_queryResult select 0) isEqualTo 0) exitWith {diag_log format ["extDB3: Protocol Error: %1", _queryResult]; []};
private _return = (_queryResult select 1);
_return
Tanoa-Server/extDB3/fn_init.sqf0000777000000000000000000000360713535665003015337 0ustar  rootroot/*
	File: init.sqf
	Author: torndeco
	Modified by Lyeed

	Description:
	Initializes extDB, loads Protocol + options if any + Locks extDB

	Parameters:
		0: STRING Database name as in extdb-conf.ini
		1: STRING Protocol to enable
		2: STRING Optional Protocol Options
*/

params [
	["_database", "", [""]],
	["_protocol", "", [""]],
	["_options", "", [""]]
];

// Possible Options
//TEXT = Wraps Text Datatypes (not VARCHAR) with "<insert result>"
//TEXT2 = Wraps Text Datatypes (not VARCHAR) with '<insert result>'
//NULL = Convert NULL Value to objNull, otherwise it is "" by default.
// examples
//   private _options = "TEXT";
//   private _options = "TEXT-NULL";
//   private _options = "TEXT2";
//   private _options = "TEXT2-NULL";

private _return = false;

if ( isNil {uiNamespace getVariable "extDB_SQL_CUSTOM_ID"}) then
{
	// extDB3 Version Check
	private _result = "extDB3" callExtension "9:VERSION";
	diag_log format ["extDB3: Version: %1", _result];
	if (_result isEqualTo "") exitWith {diag_log "extDB3: Failed to Load Extension"; false};
	if ((parseNumber _result) < 1.026) exitWith {diag_log "Error: extDB3 version 1.026 or Higher Required";};

	// extDB3 Connect to Database
	_result = call compile ("extDB3" callExtension format ["9:ADD_DATABASE:%1", _database]);
	if (_result select 0 isEqualTo 0) exitWith {diag_log format ["extDB3: Error Failed to Connect to Database: %1", _result]; false};
	diag_log "extDB3: Connected to Database";

	_result = call compile ("extDB3" callExtension format ["9:ADD_DATABASE_PROTOCOL:%1:%3:%3:%2", _database, _options, _protocol]);
	if ((_result select 0) isEqualTo 0) exitWith {diag_log format ["extDB3: Error Database Setup: %1", _result]; false};

	diag_log "extDB3: Initalized SQL_CUSTOM Protocol";

	// extDB3 Lock
	"extDB3" callExtension "9:LOCK";
	diag_log "extDB3: Locked";
	_return = true;
}
else
{
	diag_log "extDB3: Already Setup";
	_return = true;
};

_return;
Tanoa-Server/fn_initHC.sqf0000777000000000000000000000000013535665003014441 0ustar  rootrootTanoa-Server/fn_initServer.sqf0000777000000000000000000001234414004603021015413 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_timeStamp";
diag_log "-------------------------------------------------------------";
diag_log "-------------------- Starting Server Init -------------------";
diag_log "-------------------------------------------------------------";
_timeStamp = diag_tickTime;

"#lock" call RCON_fnc_sendCommand;
gServer_server_isReady = false;

[] spawn
{
	diag_log " :: [RCON:ALL-KICK] Loop begin ::";
	while {!gServer_server_isReady} do
	{
		{
			for "_i" from 0 to ((playableSlotsNumber _x) - 1) do
			{
				if (serverCommandExecutable (format["#kick %1", _i])) then
				{
					(format["#kick %1", _i]) call RCON_fnc_sendCommand;
				};
			};
		} forEach ([west, east, independent, civilian]);
		sleep 0.5;
	};
	diag_log " :: [RCON:ALL-KICK] Loop end ::";
};

finishMissionInit;

gServer_soonReboot = false;

tf_radio_channel_password = getText(configFile >> "Cfg_Server" >> "TFR_password");
publicVariable "tf_radio_channel_password";

east setFriend [independent, 1];
east setFriend [west, 1];
east setFriend [civilian, 1];
civilian setFriend [independent, 1];
civilian setFriend [east, 1];
civilian setFriend [west, 1];
west setFriend [civilian, 1];
west setFriend [east, 1];
west setFriend [independent, 1];
independent setFriend [east, 1];
independent setFriend [civilian, 1];
independent setFriend [west, 1];

if (!(["tanoa", "SQL", "TEXT2"] call ExtDB3_fnc_init)) exitWith {};

addMissionEventHandler ["HandleDisconnect", {_this call AlysiaServer_fnc_clientDisconnect}];

[] call AlysiaServer_fnc_dynamicMarkers_init;
[] call AlysiaServer_fnc_phoneInit;
[] call AlysiaServer_fnc_laboratories_init;
[] call AlysiaServer_fnc_vehicles_init;
[] call AlysiaServer_fnc_market_init;
[] call AlysiaServer_fnc_house_init;
[] call AlysiaServer_fnc_factionsInit;
[] call AlysiaServer_fnc_buildings_init;
[] call AlysiaServer_fnc_companies_init;
[] call AlysiaServer_fnc_atm_init;
[] call AlysiaServer_fnc_taxes_init;
[] call AlysiaServer_fnc_fuel_init;
[] call AlysiaServer_fnc_time_init;
[] call AlysiaServer_fnc_cleanup_init;

private["_hour", "_min", "_time", "_calc", "_best", "_bestTime"];
_time = call AlysiaServer_fnc_getRealTime;
_hour = _time select 0;
_min = _time select 1;
gServer_rebootHour_txt = "";

{
	_calc = _x - _hour;
	if (_calc > 0) then
	{
		if (isNil "_best") then
		{
			_best = _x;
			_bestTime = _calc;
		} else {
			if ((_calc < _bestTime) && (_x > _hour)) then
			{
				_best = _x;
				_bestTime = _calc;
			};
		};
	};

	gServer_rebootHour_txt = format["%1%2:00 ", gServer_rebootHour_txt, _x];
} forEach getArray(configFile >> "Cfg_Server" >> "rebootHours");
if (isNil "_best") then
{
	{
		if (isNil "_best") then {
			_best = _x;
		} else {
			if (_x < _best) then {
				_best = _x;
			};
		};
	} forEach getArray(configFile >> "Cfg_Server" >> "rebootHours");
	gServer_rebootHour = (((_best + 24) - _hour) * 60) - _min;
} else {
	gServer_rebootHour = ((_best - _hour) * 60) - _min;
};

diag_log format["Prochain redémarrage à %1:00 (~ %2 minutes).", _best, gServer_rebootHour];
diag_log format["Il est %1:%2", _hour, _min];

publicVariable "gServer_rebootHour";
publicVariable "gServer_rebootHour_txt";

/* PBO CHECK */
gServer_mods = [];
{
	_pbo = configName _x;
	if !(_pbo in getArray(configFile >> "Cfg_Server" >> "serverMods")) then {
		gServer_mods pushBack _pbo;
	};
} forEach ("true" configClasses (configFile >> "CfgPatches"));
publicVariable "gServer_mods";

/* Tell clients that the server is ready and is accepting queries */
gServer_server_isReady = true;
publicVariable "gServer_server_isReady";

"#unlock" call RCON_fnc_sendCommand;

[] spawn {
	while {true} do {
		60 setFog 0;
		sleep 5 * 60;
	};
};

diag_log "---------------------------------------------------------------------------------------------------------";
diag_log format["Total Execution Time %1 seconds", (diag_tickTime - _timeStamp)];
diag_log "---------------------------------------------------------------------------------------------------------";

_nextAnnounceTime = (random(10) + 1) * 60;
while {true} do
{
	if ((daytime > 18) || (daytime < 6)) then
	{
		if (timeMultiplier != getNumber(configFile >> "Cfg_Server" >> "TimeMultiplier_night")) then {
			setTimeMultiplier getNumber(configFile >> "Cfg_Server" >> "TimeMultiplier_night");
		};
	} else {
		if (timeMultiplier != getNumber(configFile >> "Cfg_Server" >> "TimeMultiplier_day")) then {
			setTimeMultiplier getNumber(configFile >> "Cfg_Server" >> "TimeMultiplier_day");
		};
	};

	uiSleep 60;

	if (((_hour + 1) isEqualTo _best) && (_min >= 55)) exitWith
	{
		"#lock" call RCON_fnc_sendCommand;
		[] spawn AlysiaServer_fnc_serverSave;
	};

	_min = _min + 1;
	if (_min > 59) then
	{
		_time = call AlysiaServer_fnc_getRealTime;
		_hour = _time select 0;
		_min = _time select 1;
	};

	/*if (time >= _nextAnnounceTime) then
	{
		_nextAnnounceTime = time + (round(random(10) + 1) * 60);

		[
			([
				"contacter_madame_towisky",
				"dette_pti",
				"message_banca_di_monti",
				"rejoindre_guardia",
				"rejoindre_PTI",
				"volcan"
			] call BIS_fnc_selectRandom)
		] remoteExecCall ["AlysiaClient_fnc_border_south_sounds", -2];
	};*/
};Tanoa-Server/fn_serverSave.sqf0000777000000000000000000000271714002300036015407 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

if (gServer_soonReboot) exitWith {};

private["_timeStamp", "_time"];
diag_log "-------------------------------------------------------------";
diag_log "-------------------- Starting Server Save -------------------";
diag_log "-------------------------------------------------------------";
_timeStamp = diag_tickTime;

[] call AlysiaServer_fnc_cleanup_houseStorages;
[] spawn AlysiaServer_fnc_cleanup_companyStorages;

gServer_soonReboot = true;
publicVariable "gServer_soonReboot";

[] remoteExec ["AlysiaClient_fnc_endGame", -2];
uiSleep 100;

[] call AlysiaServer_fnc_cleanup_deadVehicles;

[] call AlysiaServer_fnc_house_save;
[] call AlysiaServer_fnc_vehicles_save;
[] call AlysiaServer_fnc_factionsSave;
[] call AlysiaServer_fnc_market_save;
[] call AlysiaServer_fnc_taxes_save;
[] call AlysiaServer_fnc_laboratories_save;
[] call AlysiaServer_fnc_companies_save;
[] call AlysiaServer_fnc_atm_save;
[] call AlysiaServer_fnc_fuel_save;
[] call AlysiaServer_fnc_time_save;
// [] call AlysiaServer_fnc_phoneMessageSave;

diag_log "---------------------------------------------------------------------------------------------------------";
_time = call AlysiaServer_fnc_getRealTime;
diag_log format[" Total Execution Time %1 seconds at %2:%3", ((diag_tickTime - _timeStamp) - 100), (_time select 0), (_time select 1)];
diag_log "---------------------------------------------------------------------------------------------------------";
Tanoa-Server/inits/0000777000000000000000000000000014003561131013206 5ustar  rootrootTanoa-Server/inits/fn_atm_init.sqf0000777000000000000000000000140514003561203016213 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[ATM] Setup";

{
	_atm = nearestObject [[(_x select 1), (_x select 2), (_x select 3)], (_x select 0)];
	if (isNull _atm) then
	{
		diag_log format["Error can't find %1 at [%2,%3,%4]", (_x select 0), (_x select 1), (_x select 2), (_x select 3)];
	} else {
		_amount = _x select 4;
		_max = getNumber(missionConfigFile >> "ADENIS_ATM" >> (_x select 0) >> "money_stock");
		if (_amount > _max) then {
			_atm setVariable ["money", _max, true];
		} else {
			_atm setVariable ["money", _amount, true];
		};
	};
	if (!(isNull _atm)) then {};
} forEach (["SELECT type,POS_X,POS_Y,POS_Z,amount FROM land_atms", 2] call ExtDB3_fnc_async);
/*
	0 - type
	1 - POS_X
	2 - POS_Y
	3 - POS_Z
	4 - amount
*/

diag_log "[ATM] Ready";
Tanoa-Server/inits/fn_buildings_init.sqf0000777000000000000000000000125013535665003017424 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[BUILDINGS] Init";

east_base_plot_1 animate ["plot_1_translation", 1];
east_base_plot_2 animate ["plot_1_translation", 1];
east_base_plot_3 animate ["plot_1_translation", 1];
east_base_plot_4 animate ["plot_1_translation", 1];
east_base_plot_5 animate ["plot_1_translation", 1];
east_base_plot_6 animate ["plot_1_translation", 1];

west_base_plot_1 animate ["plot_1_translation", 1];
west_base_plot_2 animate ["plot_1_translation", 1];
west_base_plot_3 animate ["plot_1_translation", 1];
west_base_plot_4 animate ["plot_1_translation", 1];
west_base_plot_5 animate ["plot_1_translation", 1];

diag_log "[BUILDINGS] Ready";
Tanoa-Server/inits/fn_fuel_init.sqf0000777000000000000000000000547314003561203016376 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_classes";

diag_log "[FUEL STATIONS] Loading ...";

_classes = [];

{
	_classes pushBack (configName _x);
} forEach ("true" configClasses (missionConfigFile >> "ADENIS_FUEL_STATION"));

gServer_fuelStations = [];

{
	_x setFuelCargo 0;
	_x enableSimulationGlobal false;
	gServer_fuelStations pushBack _x;
} forEach (nearestObjects [[8083.2,8099.16,0.00122833], _classes, 50000]);

{
	_fuel = nearestObject [[(_x select 1), (_x select 2), (_x select 3)], (_x select 0)];
	if (!(isNull _fuel)) then
	{
		_config = missionConfigFile >> "ADENIS_FUEL_STATION" >> typeOf(_fuel);
		if (isClass _config) then
		{
			if (isClass(_config >> "stock" >> "Diesel")) then
			{
				if ((_x select 4) >= getNumber(_config >> "stock" >> "Diesel" >> "max")) then {
					_fuel setVariable ["Diesel", getNumber(_config >> "stock" >> "Diesel" >> "max"), true];
				} else {
					_fuel setVariable ["Diesel", (_x select 4), true];
				};
			};
			if (isClass(_config >> "stock" >> "SP95")) then
			{
				if ((_x select 5) >= getNumber(_config >> "stock" >> "SP95" >> "max")) then {
					_fuel setVariable ["SP95", getNumber(_config >> "stock" >> "SP95" >> "max"), true];
				} else {
					_fuel setVariable ["SP95", (_x select 5), true];
				};
			};
			if (isClass(_config >> "stock" >> "SP98")) then
			{
				if ((_x select 6) >= getNumber(_config >> "stock" >> "SP98" >> "max")) then {
					_fuel setVariable ["SP98", getNumber(_config >> "stock" >> "SP98" >> "max"), true];
				} else {
					_fuel setVariable ["SP98", (_x select 6), true];
				};
			};
			if (isClass(_config >> "stock" >> "Kerosene")) then
			{
				if ((_x select 7) >= getNumber(_config >> "stock" >> "Kerosene" >> "max")) then {
					_fuel setVariable ["Kerosene", getNumber(_config >> "stock" >> "Kerosene" >> "max"), true];
				} else {
					_fuel setVariable ["Kerosene", (_x select 7), true];
				};
			};
			if (isClass(_config >> "stock" >> "GPL")) then
			{
				if ((_x select 8) >= getNumber(_config >> "stock" >> "GPL" >> "max")) then {
					_fuel setVariable ["GPL", getNumber(_config >> "stock" >> "GPL" >> "max"), true];
				} else {
					_fuel setVariable ["GPL", (_x select 8), true];
				};
			};
			if (isClass(_config >> "stock" >> "Bio")) then
			{
				if ((_x select 9) >= getNumber(_config >> "stock" >> "Bio" >> "max")) then {
					_fuel setVariable ["Bio", getNumber(_config >> "stock" >> "Bio" >> "max"), true];
				} else {
					_fuel setVariable ["Bio", (_x select 9), true];
				};
			};
		};
	};
} forEach (["SELECT type,POS_X,POS_Y,POS_Z,fuel_Diesel,fuel_SP95,fuel_SP98,fuel_Kerosene,fuel_GPL,fuel_BIO FROM land_fuels", 2] call ExtDB3_fnc_async);
/*
	0 - type
	1 - POS_X
	2 - POS_Y
	3 - POS_Z
	4 - fuel_Diesel
	5 - fuel_SP95
	6 - fuel_SP98
	7 - fuel_Kerozene
	8 - fuel_GPL
	9 - fuel_BIO
*/

diag_log "[FUEL STATIONS] Fuel Stations Ready";
Tanoa-Server/inits/fn_taxes_init.sqf0000777000000000000000000000103014003561203016550 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[TAXES] Setup";

{
	_config = missionConfigFile >> "ADENIS_TAXES" >> (_x select 0);
	if (isClass(_config)) then
	{
		[(_x select 0), (_x select 1)] call CBA_fnc_publicVariable;
		diag_log format["Loading taxe [%1] : %2%3", getText(_config >> "name"), (_x select 1) * 100, "%"];
	} else {
		diag_log format["[ERROR] Taxe [%1] is not defined in ADENIS_TAXES", (_x select 0)];
	};
} forEach (["SELECT variable,value FROM taxes", 2] call ExtDB3_fnc_async);

diag_log "[TAXES] Ready";
Tanoa-Server/inits/fn_time_init.sqf0000777000000000000000000000164014002277764016410 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/
private "_queryResult";

diag_log "[TIME] Setup";

_queryResult = ["SELECT year,month,day,hour,minute FROM serverinfo", 2] call ExtDB3_fnc_async;
if (_queryResult isEqualTo []) then
{
	private "_start";
	_start = getArray(configFile >> "Cfg_Server" >> "starting_time");

	[
		format
		[
			"INSERT INTO serverinfo (year,month,day,hour,minute) VALUES ('%1','%2','%3','%4','%5')",
			_start select 0,
			_start select 1,
			_start select 2,
			_start select 3,
			_start select 4
		], 1
	] call ExtDB3_fnc_async;
	_queryResult = _start;
} else {
	_queryResult = _queryResult select 0;
};

setDate [(_queryResult select 0), (_queryResult select 1), (_queryResult select 2), (_queryResult select 3), (_queryResult select 4)];

gServer_year = _queryResult select 0;
publicVariable "gServer_year";

diag_log format["Date : %1", [] call AlysiaClient_fnc_strDate];

diag_log "[TIME] Ready";
Tanoa-Server/inits/fn_vehicles_init.sqf0000777000000000000000000000541514002300036017233 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[VEHICLES] Loading";

["DELETE vehicles.* FROM vehicles INNER JOIN players ON vehicles.pid=players.uid WHERE DATEDIFF(NOW(),players.STATS_last_update)>31", 1] call ExtDB3_fnc_async;
uiSleep 1;

{
	diag_log format["Loading vehicle -%1- %2", (_x select 4), (_x select 2)];

	_position = [(_x select 5), (_x select 6), (_x select 7)];
	if (_position isEqualTo [0,0,0]) then
	{
		diag_log "[ERROR] Cannot spawn : no position";
		[format["UPDATE vehicles SET active='0',POS_store_x='0',POS_store_y='0',POS_store_z='0' WHERE plate='%1'", (_x select 4)], 1] call ExtDB3_fnc_async;
	} else {
		_vehicle = createVehicle [(_x select 2), [0, 0, 0], [], 0, "NONE"];
		waitUntil {!(isNull _vehicle)};
		diag_log "Vehicle spawned";

		_vehicle allowDamage false;

		if (surfaceIsWater _position) then {
			_vehicle setPosASL (ATLToASL _position);
		} else {
			_vehicle setPosATL _position;
		};

		_vehicle setDir (_x select 8);
		_vehicle setFuel ((_x select 11) / 100);
		_vehicle lock 2;

		_hitpoints = ([_vehicle] call AlysiaClient_fnc_getAllHitPointsDamage) select 0;

		{
			if ((_x > 0) && !(isNil {(_hitpoints select _forEachIndex)}) && {(_hitpoints select _forEachIndex) != ""}) then
			{
				if (local _vehicle) then {
					_vehicle setHitIndex [_forEachIndex, _x];
				} else {
					[_vehicle, [_forEachIndex, _x]] remoteExecCall ["setHitIndex", _vehicle];
				};
			};
		} forEach ([_x select 0] call AlysiaServer_fnc_mresToArray);

		[(_x select 3), ([(_x select 1)] call AlysiaClient_fnc_strToSide), _vehicle] call AlysiaServer_fnc_keyManagement;
		[_vehicle] call AlysiaClient_fnc_clearVehicleAmmo;

		/*
		0 - pid
		1 - playerName
		2 - plate
		3 - assurance
		*/
		_vehicle setVariable ["info", [(_x select 3), (_x select 9), (_x select 4), (_x select 10)], true];

		_trunk = [(_x select 12)] call AlysiaServer_fnc_mresToArray;
		if (!(_trunk isEqualTo [])) then {
			_vehicle setVariable ["Trunk", _trunk, true];
		};

		_fuel_type = _x select 13;
		if (_fuel_type != "") then {
			_vehicle setVariable ["refuel_type", _fuel_type, true];
		};

		_vehicle allowDamage true;
	};
} forEach ((["SELECT vehicles.HitPointsDamage,vehicles.side,vehicles.classname,vehicles.pid,vehicles.plate,vehicles.POS_x,vehicles.POS_y,vehicles.POS_z,vehicles.POS_direction,players.profileName,vehicles.assurance,vehicles.fuel,vehicles.inventory,vehicles.fuel_type FROM vehicles INNER JOIN players ON vehicles.pid=players.uid WHERE active='1'", 2] call ExtDB3_fnc_async));

diag_log "[VEHICLES] Ready";

/*
0	vehicles.HitPointsDamage
1	vehicles.side
2	vehicles.classname
3	vehicles.pid
4	vehicles.plate
5	vehicles.POS_x
6	vehicles.POS_y
7	vehicles.POS_z
8	vehicles.POS_direction
9	players.profileName
10	vehicles.assurance
11	vehicles.fuel
12	vehicles.inventory
13  vehicles.fuel_type
*/
Tanoa-Server/RCON/0000777000000000000000000000000014003561131012621 5ustar  rootrootTanoa-Server/RCON/fn_sendCommand.sqf0000777000000000000000000000017214002277615016264 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

getText(configFile >> "Cfg_Server" >> "rcon_password") serverCommand _this;
Tanoa-Server/saves/0000777000000000000000000000000014003561131013201 5ustar  rootrootTanoa-Server/saves/fn_atm_save.sqf0000777000000000000000000000125414003561203016203 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[ATM] Saving ...";

["DELETE FROM land_atms", 1] call ExtDB3_fnc_async;

uiSleep 1;

{
	_config = missionConfigFile >> "ADENIS_ATM" >> typeOf(_x);
	if (isClass(_config)) then
	{
		if (getNumber(_config >> "save") isEqualTo 1) then
		{
			[
				format
				[
					"INSERT INTO land_atms (type,amount,POS_X,POS_Y,POS_Z) VALUES ('%1','%2','%3','%4','%5')",
					typeOf(_x),
					(_x getVariable ["money", getNumber(_config >> "money_stock")]),
					(getPos _x) select 0,
					(getPos _x) select 1,
					(getPos _x) select 2
				], 1
			] call ExtDB3_fnc_async;
		};
	};
} forEach (allMissionObjects "All");

diag_log "[ATM] Saved";
Tanoa-Server/saves/fn_fuel_save.sqf0000777000000000000000000000177414002277764016403 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[FUEL] Saving ...";

diag_log "Cleaning land_fuels table...";
["DELETE FROM land_fuels", 1] call ExtDB3_fnc_async;

if (count(gServer_fuelStations) > 0) then
{
	uiSleep 1;

	{
		[
			format
			[
				"INSERT INTO land_fuels (type,POS_X,POS_Y,POS_Z,fuel_Diesel,fuel_SP95,fuel_SP98,fuel_Kerosene,fuel_GPL,fuel_BIO) VALUES ('%1','%2','%3','%4','%5','%6','%7','%8','%9','%10')",
				typeOf(_x),
				(getPos _x) select 0,
				(getPos _x) select 1,
				(getPos _x) select 2,
				[_x, "Diesel"] call AlysiaClient_fnc_fuelStation_fuel_getStock,
				[_x, "SP95"] call AlysiaClient_fnc_fuelStation_fuel_getStock,
				[_x, "SP98"] call AlysiaClient_fnc_fuelStation_fuel_getStock,
				[_x, "Kerosene"] call AlysiaClient_fnc_fuelStation_fuel_getStock,
				[_x, "GPL"] call AlysiaClient_fnc_fuelStation_fuel_getStock,
				[_x, "Bio"] call AlysiaClient_fnc_fuelStation_fuel_getStock
			], 1
		] call ExtDB3_fnc_async;
	} forEach gServer_fuelStations;
};

diag_log "[FUEL] Saved";
Tanoa-Server/saves/fn_taxes_save.sqf0000777000000000000000000000060614003561203016546 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[TAXES] Saving...";

{
	[
		format
		[
			"INSERT INTO taxes (variable,value) VALUES ('%1','%2') ON DUPLICATE KEY UPDATE variable='%1',value='%2'",
			(configName _x),
			(call compile (configName _x))
		], 1
	] call ExtDB3_fnc_async;
} forEach ("true" configClasses (missionConfigFile >> "ADENIS_TAXES"));

diag_log "[TAXES] Saved";
Tanoa-Server/saves/fn_time_save.sqf0000777000000000000000000000050413535665003016371 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[TIME] Saving ...";

[
	format
	[
		"UPDATE serverinfo SET minute='%1',hour='%2',day='%3',month='%4',year='%5' WHERE id='1'",
		date select 4,
		date select 3,
		date select 2,
		date select 1,
		date select 0
	],
	1
] call ExtDB3_fnc_async;

diag_log "[TIME] Saved";
Tanoa-Server/saves/fn_vehicles_save.sqf0000777000000000000000000000206014002300036017212 0ustar  rootroot/*
	Tanoa-Life RPG
	Code written by Lyeed
*/

diag_log "[VEHICLES] Saving...";

{
	if (alive _x) then
	{
		_info = _x getVariable "info";
		if (!(isNil "_info")) then
		{
			diag_log format["Saving vehicle -%1- [%2:%3]", typeOf(_x), (_info select 0), (_info select 1)];

			[
				format
				[
					"UPDATE vehicles SET active='1',POS_x='%1',POS_y='%2',POS_z='%3',POS_direction='%4',inventory='%5',fuel='%8',HitPointsDamage='%9',fuel_type='%10' WHERE pid='%6' AND plate='%7'",
					(getPosATL _x) select 0,
					(getPosATL _x) select 1,
					(getPosATL _x) select 2,
					(getDir _x),
					([(_x getVariable ["Trunk", []])] call AlysiaServer_fnc_mresArray),
					(_info select 0),
					(_info select 2),
					((fuel _x) * 100),
					([([_x] call AlysiaClient_fnc_getAllHitPointsDamage) select 2] call AlysiaServer_fnc_mresArray),
					(_x getVariable ["refuel_type", ""])
				], 1
			] call ExtDB3_fnc_async;
			deleteVehicle _x;
		};
	};
} forEach ((allMissionObjects "LandVehicle") + (allMissionObjects "Air") + (allMissionObjects "Ship"));

diag_log "[VEHICLES] Saved";