Renamed src to backend

backend/core/include/aircraft.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "airunit.h"
+
+#define AIRCRAFT_DEST_DIST_THR 2000	// Meters
+
+class Aircraft : public AirUnit
+{
+public:
+	Aircraft(json::value json, unsigned int ID);
+
+	static void loadDatabase(string path);
+
+	virtual void changeSpeed(string change);
+	virtual void changeAltitude(string change);
+
+	virtual double getDestinationReachedThreshold() { return AIRCRAFT_DEST_DIST_THR; }
+
+protected:
+	static json::value database;
+};

backend/core/include/airunit.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "framework.h"
+#include "utils.h"
+#include "dcstools.h"
+#include "luatools.h"
+#include "Unit.h"
+
+#define AIR_DEST_DIST_THR 2000	// Meters
+
+class AirUnit : public Unit
+{
+public:
+	AirUnit(json::value json, unsigned int ID);
+
+	virtual void setDefaults(bool force = false);
+	virtual void setState(unsigned char newState);
+
+	virtual void changeSpeed(string change) = 0;
+	virtual void changeAltitude(string change) = 0;
+	virtual double getDestinationReachedThreshold() { return AIR_DEST_DIST_THR;  }
+	
+protected:
+	virtual void AIloop();
+};

backend/core/include/commands.h

@@ -0,0 +1,432 @@
+#pragma once
+#include "framework.h"
+#include "luatools.h"
+#include "utils.h"
+#include "logger.h"
+#include "datatypes.h"
+
+namespace CommandPriority {
+	enum CommandPriorities { LOW, MEDIUM, HIGH, IMMEDIATE };
+};
+
+namespace SetCommandType {
+	enum SetCommandTypes {
+		ROE = 0,
+		REACTION_ON_THREAT = 1,
+		RADAR_USING = 3,
+		FLARE_USING = 4,
+		FORMATION = 5,
+		RTB_ON_BINGO = 6,
+		SILENCE = 7,
+		RTB_ON_OUT_OF_AMMO = 10,
+		ECM_USING = 13,
+		PROHIBIT_AA = 14,
+		PROHIBIT_JETT = 15,
+		PROHIBIT_AB = 16,
+		PROHIBIT_AG = 17,
+		MISSILE_ATTACK = 18,
+		PROHIBIT_WP_PASS_REPORT = 19,
+		ENGAGE_AIR_WEAPONS = 20,
+		OPTION_RADIO_USAGE_CONTACT = 21,
+		OPTION_RADIO_USAGE_ENGAGE = 22,
+		OPTION_RADIO_USAGE_KILL = 23,
+		JETT_TANKS_IF_EMPTY = 25,
+		FORCED_ATTACK = 26
+	};
+}
+
+namespace ROE {
+	enum ROEs {
+		WEAPON_FREE = 0,
+		OPEN_FIRE_WEAPON_FREE = 1,
+		OPEN_FIRE = 2,
+		RETURN_FIRE = 3,
+		WEAPON_HOLD = 4,
+	};
+}
+
+namespace ReactionToThreat {
+	enum ReactionsToThreat {
+		NO_REACTION = 0,
+		PASSIVE_DEFENCE = 1,
+		EVADE_FIRE = 2,
+		BYPASS_AND_ESCAPE = 3,
+		ALLOW_ABORT_MISSION = 4
+	};
+}
+
+namespace EmissionCountermeasure {
+	enum ReactionsToThreat {
+		SILENT = 0,
+		ATTACK = 1,
+		DEFEND = 2,
+		FREE = 3
+	};
+}
+
+namespace RadarUse {
+	enum RadarUses {
+		NEVER = 0,
+		FOR_ATTACK_ONLY = 1,
+		FOR_SEARCH_IF_REQUIRED = 2,
+		FOR_CONTINUOUS_SEARCH = 3
+	};
+}
+
+namespace FlareUse {
+	enum FlareUses {
+		NEVER = 0,
+		AGAINST_FIRED_MISSILE = 1,
+		WHEN_FLYING_IN_SAM_WEZ = 2,
+		WHEN_FLYING_NEAR_ENEMIES = 3
+	};
+}
+
+namespace ECMUse {
+	enum ECMUses {
+		NEVER_USE = 0,
+		USE_IF_ONLY_LOCK_BY_RADAR = 1,
+		USE_IF_DETECTED_LOCK_BY_RADAR = 2,
+		ALWAYS_USE = 3
+	};
+}
+
+/* Base command class */
+class Command
+{
+public:
+	Command(function<void(void)> callback) : callback(callback) {};
+	unsigned int getPriority() { return priority; }
+	virtual string getString() = 0;
+	virtual unsigned int getLoad() = 0;
+	const string getHash() { return hash; }
+	void executeCallback() { callback(); }
+
+protected:
+	unsigned int priority = CommandPriority::LOW;
+	const string hash = random_string(16);
+	function<void(void)> callback;
+};
+
+/* Simple low priority move command (from user click) */
+class Move : public Command
+{
+public:
+	Move(string groupName, Coords destination, double speed, string speedType, double altitude, 
+		string altitudeType, string taskOptions, string category, bool onRoad, function<void(void)> callback = []() {}) :
+		Command(callback),
+		groupName(groupName),
+		destination(destination),
+		speed(speed),
+		speedType(speedType),
+		altitude(altitude),
+		altitudeType(altitudeType),
+		taskOptions(taskOptions),
+		category(category),
+		onRoad(onRoad)
+	{ 
+		priority = CommandPriority::MEDIUM; 
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return onRoad? 45: 5; }
+
+private:
+	const string groupName;
+	const Coords destination;
+	const double speed;
+	const string speedType;
+	const double altitude;
+	const string altitudeType;
+	const string taskOptions;
+	const string category;
+	const bool onRoad;
+};
+
+/* Smoke command */
+class Smoke : public Command
+{
+public:
+	Smoke(string color, Coords location, function<void(void)> callback = [](){}) :
+		Command(callback),
+		color(color), 
+		location(location) 
+	{ 
+		priority = CommandPriority::LOW; 
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 2; }
+
+private:
+	const string color;
+	const Coords location;
+};
+
+/* Spawn ground unit command */
+class SpawnGroundUnits : public Command
+{
+public:
+	SpawnGroundUnits(string coalition, vector<SpawnOptions> spawnOptions, string country, bool immediate, function<void(void)> callback = [](){}) :
+		Command(callback),
+		coalition(coalition), 
+		spawnOptions(spawnOptions),
+		country(country),
+		immediate(immediate)
+	{ 
+		priority = immediate? CommandPriority::IMMEDIATE: CommandPriority::LOW;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return immediate? 5: 30; }
+
+private:
+	const string coalition;
+	const vector<SpawnOptions> spawnOptions;
+	const string country;
+	const bool immediate;
+};
+
+/* Spawn navy unit command */
+class SpawnNavyUnits : public Command
+{
+public:
+	SpawnNavyUnits(string coalition, vector<SpawnOptions> spawnOptions, string country, bool immediate, function<void(void)> callback = [](){}) :
+		Command(callback),
+		coalition(coalition),
+		spawnOptions(spawnOptions),
+		country(country),
+		immediate(immediate)
+	{
+		priority = immediate ? CommandPriority::IMMEDIATE : CommandPriority::LOW;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return immediate ? 5 : 60; }
+
+private:
+	const string coalition;
+	const vector<SpawnOptions> spawnOptions;
+	const string country;
+	const bool immediate;
+};
+
+/* Spawn aircraft command */
+class SpawnAircrafts : public Command
+{
+public:
+	SpawnAircrafts(string coalition, vector<SpawnOptions> spawnOptions, string airbaseName, string country, bool immediate, function<void(void)> callback = [](){}) :
+		Command(callback),
+		coalition(coalition), 
+		spawnOptions(spawnOptions),
+		airbaseName(airbaseName),
+		country(country),
+		immediate(immediate)
+	{ 
+		priority = immediate ? CommandPriority::IMMEDIATE : CommandPriority::LOW;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return immediate ? 5 : 45; }
+
+private:
+	const string coalition;
+	const vector<SpawnOptions> spawnOptions;
+	const string airbaseName;
+	const string country;
+	const bool immediate;
+};
+
+/* Spawn helicopter command */
+class SpawnHelicopters : public Command
+{
+public:
+	SpawnHelicopters(string coalition, vector<SpawnOptions> spawnOptions, string airbaseName, string country, bool immediate, function<void(void)> callback = [](){}) :
+		Command(callback),
+		coalition(coalition),
+		spawnOptions(spawnOptions),
+		airbaseName(airbaseName),
+		country(country),
+		immediate(immediate)
+	{
+		priority = immediate ? CommandPriority::IMMEDIATE : CommandPriority::LOW;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return immediate ? 5 : 45; }
+
+private:
+	const string coalition;
+	const vector<SpawnOptions> spawnOptions;
+	const string airbaseName;
+	const string country;
+	const bool immediate;
+};
+
+/* Clone unit command */
+class Clone : public Command
+{
+public:
+	Clone(vector<CloneOptions> cloneOptions, bool deleteOriginal, function<void(void)> callback = [](){}) :
+		Command(callback),
+		cloneOptions(cloneOptions),
+		deleteOriginal(deleteOriginal)
+	{
+		priority = CommandPriority::LOW;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 30; }
+
+private:
+	const vector<CloneOptions> cloneOptions;
+	const bool deleteOriginal;
+};
+
+/* Delete unit command */
+class Delete : public Command
+{
+public:
+	Delete(unsigned int ID, bool explosion, string explosionType, bool immediate, function<void(void)> callback = [](){}) :
+		Command(callback),
+		ID(ID), 
+		explosion(explosion),
+		explosionType(explosionType),
+		immediate(immediate)
+	{
+		priority = CommandPriority::HIGH;
+		immediate = immediate;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return immediate? 1: 30; }
+
+private:
+	const unsigned int ID;
+	const bool explosion;
+	const string explosionType;
+	const bool immediate;
+};
+
+/* SetTask command */
+class SetTask : public Command
+{
+public:
+	SetTask(string groupName, string task, function<void(void)> callback = [](){}) :
+		Command(callback),
+		groupName(groupName),
+		task(task)
+	{
+		priority = CommandPriority::MEDIUM;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 5; }
+
+private:
+	const string groupName;
+	const string task;
+};
+
+/* Reset task command */
+class ResetTask : public Command
+{
+public:
+	ResetTask(string groupName, function<void(void)> callback = [](){}) :
+		Command(callback),
+		groupName(groupName)
+	{
+		priority = CommandPriority::HIGH;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 5; }
+
+private:
+	const string groupName;
+};
+
+/* Set command */
+class SetCommand : public Command
+{
+public:
+	SetCommand(string groupName, string command, function<void(void)> callback = [](){}) :
+		Command(callback),
+		groupName(groupName),
+		command(command)
+	{
+		priority = CommandPriority::HIGH;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 5; }
+
+private:
+	const string groupName;
+	const string command;
+};
+
+/* Set option command */
+class SetOption : public Command
+{
+public:
+	SetOption(string groupName, unsigned int optionID, unsigned int optionValue, function<void(void)> callback = [](){}) :
+		Command(callback),
+		groupName(groupName),
+		optionID(optionID),
+		optionValue(optionValue),
+		optionBool(false),
+		isBoolean(false)
+	{
+		priority = CommandPriority::HIGH;
+	};
+
+	SetOption(string groupName, unsigned int optionID, bool optionBool, function<void(void)> callback = [](){}) :
+		Command(callback),
+		groupName(groupName),
+		optionID(optionID),
+		optionValue(0),
+		optionBool(optionBool),
+		isBoolean(true)
+	{
+		priority = CommandPriority::HIGH;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 5; }
+
+private:
+	const string groupName;
+	const unsigned int optionID;
+	const unsigned int optionValue;
+	const bool optionBool;
+	const bool isBoolean;
+};
+
+/* Set on off */
+class SetOnOff : public Command
+{
+public:
+	SetOnOff(string groupName, bool onOff, function<void(void)> callback = [](){}) :
+		Command(callback),
+		groupName(groupName),
+		onOff(onOff)
+	{
+		priority = CommandPriority::HIGH;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 5; }
+
+private:
+	const string groupName;
+	const bool onOff;
+};
+
+/* Make a ground explosion */
+class Explosion : public Command
+{
+public:
+	Explosion(unsigned int intensity, string explosionType, Coords location, function<void(void)> callback = [](){}) :
+		Command(callback),
+		location(location),
+		intensity(intensity),
+		explosionType(explosionType)
+	{
+		priority = CommandPriority::MEDIUM;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 5; }
+
+private:
+	const Coords location;
+	const unsigned int intensity;
+	const string explosionType;
+};

backend/core/include/datatypes.h

@@ -0,0 +1,161 @@
+#pragma once
+#include "framework.h"
+#include "utils.h"
+
+namespace DataIndex {
+	enum DataIndexes {
+		startOfData = 0,
+		category,
+		alive,
+		human,
+		controlled,
+		coalition,
+		country,
+		name,
+		unitName,
+		groupName,
+		state,
+		task,
+		hasTask,
+		position,
+		speed,
+		horizontalVelocity,
+		verticalVelocity,
+		heading,
+		track,
+		isActiveTanker,
+		isActiveAWACS,
+		onOff,
+		followRoads,
+		fuel,
+		desiredSpeed,
+		desiredSpeedType,
+		desiredAltitude,
+		desiredAltitudeType,
+		leaderID,
+		formationOffset,
+		targetID,
+		targetPosition,
+		ROE,
+		reactionToThreat,
+		emissionsCountermeasures,
+		TACAN,
+		radio,
+		generalSettings,
+		ammo,
+		contacts,
+		activePath,
+		isLeader,
+		operateAs,
+		shotsScatter,
+		shotsIntensity,
+		health,
+		lastIndex,
+		endOfData = 255
+	};
+}
+
+namespace State
+{
+	enum States
+	{
+		NONE = 0,
+		IDLE,
+		REACH_DESTINATION,
+		ATTACK,
+		FOLLOW,
+		LAND,
+		REFUEL,
+		AWACS,
+		TANKER,
+		BOMB_POINT,
+		CARPET_BOMB,
+		BOMB_BUILDING,
+		FIRE_AT_AREA,
+		SIMULATE_FIRE_FIGHT,
+		SCENIC_AAA,
+		MISS_ON_PURPOSE,
+		LAND_AT_POINT
+	};
+};
+
+namespace ShotsScatter
+{
+	enum ShotsScatters
+	{
+		NONE = 0,
+		HIGH,
+		MEDIUM,
+		LOW
+	};
+};
+
+namespace ShotsIntensity
+{
+	enum ShotsIntensities
+	{
+		NONE = 0,
+		LOW,
+		MEDIUM,
+		HIGH
+	};
+};
+
+#pragma pack(push, 1)
+namespace DataTypes {
+	struct TACAN
+	{
+		bool isOn = false;
+		unsigned char channel = 40;
+		char XY = 'X';
+		char callsign[4];
+	};
+
+	struct Radio
+	{
+		unsigned int frequency = 124000000;	// MHz
+		unsigned char callsign = 1;
+		unsigned char callsignNumber = 1;
+	};
+
+	struct GeneralSettings
+	{
+		bool prohibitJettison = false;
+		bool prohibitAA = false;
+		bool prohibitAG = false;
+		bool prohibitAfterburner = false;
+		bool prohibitAirWpn = false;
+	};
+
+	struct Ammo {
+		unsigned short quantity = 0;
+		char name[33];
+		unsigned char guidance = 0;
+		unsigned char category = 0;
+		unsigned char missileCategory = 0;
+	};
+
+	struct Contact {
+		unsigned int ID = 0;
+		unsigned char detectionMethod = 0;
+	};
+}
+#pragma pack(pop)
+
+bool operator==(const DataTypes::TACAN& lhs, const DataTypes::TACAN& rhs);
+bool operator==(const DataTypes::Radio& lhs, const DataTypes::Radio& rhs);
+bool operator==(const DataTypes::GeneralSettings& lhs, const DataTypes::GeneralSettings& rhs);
+bool operator==(const DataTypes::Ammo& lhs, const DataTypes::Ammo& rhs);
+bool operator==(const DataTypes::Contact& lhs, const DataTypes::Contact& rhs);
+
+struct SpawnOptions {
+	string unitType;
+	Coords location;
+	string loadout;
+	string liveryID;
+};
+
+struct CloneOptions {
+	unsigned int ID;
+	Coords location;
+};

backend/core/include/groundunit.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "unit.h"
+
+#define GROUND_DEST_DIST_THR 10
+
+class GroundUnit : public Unit
+{
+public:
+	GroundUnit(json::value json, unsigned int ID);
+
+	static void loadDatabase(string path);
+
+	virtual void setState(unsigned char newState);
+	virtual void setDefaults(bool force = false);
+
+	virtual void changeSpeed(string change);
+	virtual void setOnOff(bool newOnOff, bool force = false);
+	virtual void setFollowRoads(bool newFollowRoads, bool force = false);
+
+	void aimAtPoint(Coords aimTarget);
+
+protected:
+	virtual void AIloop();
+	static json::value database;
+};

backend/core/include/helicopter.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "airunit.h"
+
+#define HELICOPTER_DEST_DIST_THR 500	// Meters
+
+class Helicopter : public AirUnit
+{
+public:
+	Helicopter(json::value json, unsigned int ID);
+
+	static void loadDatabase(string path);
+
+	virtual void changeSpeed(string change);
+	virtual void changeAltitude(string change);
+
+	virtual double getDestinationReachedThreshold() { return HELICOPTER_DEST_DIST_THR; }
+
+protected:
+	static json::value database;
+};

backend/core/include/navyunit.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "unit.h"
+
+#define NAVY_DEST_DIST_THR 100
+
+class NavyUnit : public Unit
+{
+public:
+	NavyUnit(json::value json, unsigned int ID);
+
+	static void loadDatabase(string path);
+
+	virtual void setState(unsigned char newState);
+	virtual void setDefaults(bool force = false);
+
+	virtual void changeSpeed(string change);
+	virtual void setOnOff(bool newOnOff, bool force = false);
+
+protected:
+	virtual void AIloop();
+	static json::value database;
+};

backend/core/include/scheduler.h

@@ -0,0 +1,50 @@
+#pragma once
+#include "framework.h"
+#include "luatools.h"
+#include "commands.h"
+
+class Scheduler
+{
+public:
+	Scheduler(lua_State* L);
+	~Scheduler();
+
+	void appendCommand(Command* command);
+	void execute(lua_State* L);
+	void handleRequest(string key, json::value value, string username, json::value& answer);
+	bool checkSpawnPoints(int spawnPoints, string coalition);
+	bool isCommandExecuted(string commandHash) { return (find(executedCommandsHashes.begin(), executedCommandsHashes.end(), commandHash) != executedCommandsHashes.end()); }
+	
+	void setFrameRate(double newFrameRate) { frameRate = newFrameRate; }
+	void setRestrictSpawns(bool newRestrictSpawns) { restrictSpawns = newRestrictSpawns; }
+	void setRestrictToCoalition(bool newRestrictToCoalition) { restrictToCoalition = newRestrictToCoalition; }
+	void setSetupTime(unsigned int newSetupTime) { setupTime = newSetupTime; }
+	void setBlueSpawnPoints(int newBlueSpawnPoints) { blueSpawnPoints = newBlueSpawnPoints; }
+	void setRedSpawnPoints(int newRedSpawnPoints) { redSpawnPoints = newRedSpawnPoints; }
+	void setEras(vector<string> newEras) { eras = newEras; }
+	void setCommandModeOptions(json::value newOptions);
+
+	int getFrameRate() { return static_cast<int>(round(frameRate)); };
+	int getLoad();
+	bool getRestrictSpawns() { return restrictSpawns; }
+	bool getRestrictToCoalition() { return restrictToCoalition; }
+	unsigned int getSetupTime() { return setupTime; }
+	int getBlueSpawnPoints() { return blueSpawnPoints; }
+	int getRedSpawnPoints() { return redSpawnPoints; }
+	vector<string> getEras() { return eras; }
+	json::value getCommandModeOptions();
+
+private:
+	list<Command*> commands;
+	list<string> executedCommandsHashes;
+	unsigned int load = 0;
+	double frameRate = 0;
+	
+	bool restrictSpawns = false;
+	bool restrictToCoalition = false;
+	unsigned int setupTime = 300;
+	int blueSpawnPoints = 10000;
+	int redSpawnPoints = 10000;
+	vector<string> eras = { "WW2", "Early Cold War", "Mid Cold War", "Late Cold War", "Modern" };
+};
+

backend/core/include/scriptloader.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "framework.h"
+
+#define PROTECTED_CALL "Olympus = {}\n \
+                        function Olympus.protectedCall(...)\n\n \
+                            local status, retval = pcall(...)\n \
+                            if not status then\n \
+                                if Olympus.log ~= nil then\n \
+                                    Olympus.log:error(retval)\n \
+                                else\n \
+                                    trigger.action.outText(\"Olympus critical error: \" ..retval, 20)\n \
+                                end\n \
+                            end\n \
+                        end\n \
+                        trigger.action.outText(\"Olympus.protectedCall registered successfully\", 10)\n"
+
+void registerLuaFunctions(lua_State* L);

backend/core/include/server.h

@@ -0,0 +1,40 @@
+#pragma once
+#include "framework.h"
+#include "luatools.h"
+
+using namespace web::http;
+using namespace web::http::experimental::listener;
+
+class UnitsManager;
+class Scheduler;
+
+class Server
+{
+public:
+	Server(lua_State* L);
+
+    void start(lua_State* L);
+    void stop(lua_State* L);
+
+private:
+	std::thread* serverThread;
+
+    void handle_options(http_request request);
+    void handle_get(http_request request);
+    void handle_request(http_request request, function<void(json::value const&, json::value&)> action);
+    void handle_put(http_request request);
+
+    string extractUsername(http_request& request);
+    string extractPassword(http_request& request);
+
+    void task();
+
+    atomic<bool> runListener;
+
+    string gameMasterPassword = "";
+    string blueCommanderPassword = "";
+    string redCommanderPassword = "";
+    string atcPassword = "";
+    string observerPassword = "";
+};
+

backend/core/include/unit.h

@@ -0,0 +1,265 @@
+#pragma once
+#include "framework.h"
+#include "utils.h"
+#include "dcstools.h"
+#include "luatools.h"
+#include "logger.h"
+#include "commands.h"
+#include "datatypes.h"
+
+#include <chrono>
+using namespace std::chrono;
+
+#define TASK_CHECK_INIT_VALUE 10
+
+class Unit
+{
+public:
+	Unit(json::value json, unsigned int ID);
+	~Unit();
+
+	/********** Methods **********/
+	void initialize(json::value json);
+	virtual void setDefaults(bool force = false);
+
+	void runAILoop();
+
+	void update(json::value json, double dt);
+	void refreshLeaderData(unsigned long long time);
+
+	unsigned int getID() { return ID; }
+	void getData(stringstream& ss, unsigned long long time);
+	Coords getActiveDestination() { return activeDestination; }
+
+	virtual void changeSpeed(string change) {};
+	virtual void changeAltitude(string change) {};
+	bool setActiveDestination();
+	void resetActiveDestination();
+	void landAt(Coords loc);
+
+	bool updateActivePath(bool looping);
+	void clearActivePath();
+	void pushActivePathFront(Coords newActivePathFront);
+	void pushActivePathBack(Coords newActivePathBack);
+	void popActivePathFront();
+	void goToDestination(string enrouteTask = "nil");
+	bool isDestinationReached(double threshold);
+
+	string getTargetName();
+	string getLeaderName();
+	bool isTargetAlive();
+	bool isLeaderAlive();
+
+	void resetTask();
+	bool checkTaskFailed();
+	void resetTaskFailedCounter();
+	void setHasTaskAssigned(bool newHasTaskAssigned);
+	void setEnableTaskCheckFailed(bool newEnableTaskCheckFailed) { enableTaskFailedCheck = newEnableTaskCheckFailed; }
+	bool getEnableTaskCheckFailed() { return enableTaskFailedCheck; }
+
+	void triggerUpdate(unsigned char datumIndex);
+
+	bool hasFreshData(unsigned long long time);
+	bool checkFreshness(unsigned char datumIndex, unsigned long long time);
+
+	/********** Setters **********/
+	virtual void setCategory(string newValue) { updateValue(category, newValue, DataIndex::category); }
+	virtual void setAlive(bool newValue) { updateValue(alive, newValue, DataIndex::alive); }
+	virtual void setHuman(bool newValue) { updateValue(human, newValue, DataIndex::human); }
+	virtual void setControlled(bool newValue) { updateValue(controlled, newValue, DataIndex::controlled); }
+	virtual void setCoalition(unsigned char newValue) { updateValue(coalition, newValue, DataIndex::coalition); }
+	virtual void setCountry(unsigned char newValue) { updateValue(country, newValue, DataIndex::country); }
+	virtual void setName(string newValue) { updateValue(name, newValue, DataIndex::name); }
+	virtual void setUnitName(string newValue) { updateValue(unitName, newValue, DataIndex::unitName); }
+	virtual void setGroupName(string newValue) { updateValue(groupName, newValue, DataIndex::groupName); }
+	virtual void setState(unsigned char newValue) { updateValue(state, newValue, DataIndex::state); };
+	virtual void setTask(string newValue) { updateValue(task, newValue, DataIndex::task); }
+	virtual void setHasTask(bool newValue);
+	virtual void setPosition(Coords newValue) { updateValue(position, newValue, DataIndex::position); }
+	virtual void setSpeed(double newValue) { updateValue(speed, newValue, DataIndex::speed); }
+	virtual void setHorizontalVelocity(double newValue) { updateValue(horizontalVelocity, newValue, DataIndex::horizontalVelocity); }
+	virtual void setVerticalVelocity(double newValue) { updateValue(verticalVelocity, newValue, DataIndex::verticalVelocity); }
+	virtual void setHeading(double newValue) { updateValue(heading, newValue, DataIndex::heading); }
+	virtual void setTrack(double newValue) { updateValue(track, newValue, DataIndex::track); }
+	virtual void setIsActiveTanker(bool newValue);
+	virtual void setIsActiveAWACS(bool newValue);
+	virtual void setOnOff(bool newValue, bool force = false) { updateValue(onOff, newValue, DataIndex::onOff); };
+	virtual void setFollowRoads(bool newValue, bool force = false) { updateValue(followRoads, newValue, DataIndex::followRoads); };
+	virtual void setFuel(unsigned short newValue) { updateValue(fuel, newValue, DataIndex::fuel); }
+	virtual void setDesiredSpeed(double newValue);
+	virtual void setDesiredSpeedType(string newValue);
+	virtual void setDesiredAltitude(double newValue);
+	virtual void setDesiredAltitudeType(string newValue);
+	virtual void setLeaderID(unsigned int newValue) { updateValue(leaderID, newValue, DataIndex::leaderID); }
+	virtual void setFormationOffset(Offset formationOffset);
+	virtual void setTargetID(unsigned int newValue) { updateValue(targetID, newValue, DataIndex::targetID); }
+	virtual void setTargetPosition(Coords newValue) { updateValue(targetPosition, newValue, DataIndex::targetPosition); }
+	virtual void setROE(unsigned char newValue, bool force = false);
+	virtual void setReactionToThreat(unsigned char newValue, bool force = false);
+	virtual void setEmissionsCountermeasures(unsigned char newValue, bool force = false);
+	virtual void setTACAN(DataTypes::TACAN newValue, bool force = false);
+	virtual void setRadio(DataTypes::Radio newValue, bool force = false);
+	virtual void setGeneralSettings(DataTypes::GeneralSettings newValue, bool force = false);
+	virtual void setAmmo(vector<DataTypes::Ammo> newValue);
+	virtual void setContacts(vector<DataTypes::Contact> newValue);
+	virtual void setActivePath(list<Coords> newValue);
+	virtual void setIsLeader(bool newValue) { updateValue(isLeader, newValue, DataIndex::isLeader); }
+	virtual void setOperateAs(unsigned char newValue) { updateValue(operateAs, newValue, DataIndex::operateAs); }
+	virtual void setShotsScatter(unsigned char newValue) { updateValue(shotsScatter, newValue, DataIndex::shotsScatter); }
+	virtual void setShotsIntensity(unsigned char newValue) { updateValue(shotsIntensity, newValue, DataIndex::shotsIntensity); }
+	virtual void setHealth(unsigned char newValue) { updateValue(health, newValue, DataIndex::health); }
+
+	/********** Getters **********/
+	virtual string getCategory() { return category; };
+	virtual bool getAlive() { return alive; }
+	virtual bool getHuman() { return human; }
+	virtual bool getControlled() { return controlled; }
+	virtual unsigned char getCoalition() { return coalition; }
+	virtual unsigned char getCountry() { return country; }
+	virtual string getName() { return name; }
+	virtual string getUnitName() { return unitName; }
+	virtual string getGroupName() { return groupName; }
+	virtual unsigned char getState() { return state; }
+	virtual string getTask() { return task; }
+	virtual bool getHasTask() { return hasTask; }
+	virtual Coords getPosition() { return position; }
+	virtual double getSpeed() { return speed; }
+	virtual double getHorizontalVelocity() { return horizontalVelocity; }
+	virtual double getVerticalVelocity() { return verticalVelocity; }
+	virtual double getHeading() { return heading; }
+	virtual double getTrack() { return track; }
+	virtual bool getIsActiveTanker() { return isActiveTanker; }
+	virtual bool getIsActiveAWACS() { return isActiveAWACS; }
+	virtual bool getOnOff() { return onOff; };
+	virtual bool getFollowRoads() { return followRoads; };
+	virtual unsigned short getFuel() { return fuel; }
+	virtual double getDesiredSpeed() { return desiredSpeed; };
+	virtual bool getDesiredSpeedType() { return desiredSpeedType; };
+	virtual double getDesiredAltitude() { return desiredAltitude; };
+	virtual bool getDesiredAltitudeType() { return desiredAltitudeType; };
+	virtual unsigned int getLeaderID() { return leaderID; }
+	virtual Offset getFormationOffset() { return formationOffset; }
+	virtual unsigned int getTargetID() { return targetID; }
+	virtual Coords getTargetPosition() { return targetPosition; }
+	virtual unsigned char getROE() { return ROE; }
+	virtual unsigned char getReactionToThreat() { return reactionToThreat; }
+	virtual unsigned char getEmissionsCountermeasures() { return emissionsCountermeasures; };
+	virtual DataTypes::TACAN getTACAN() { return TACAN; }
+	virtual DataTypes::Radio getRadio() { return radio; }
+	virtual DataTypes::GeneralSettings getGeneralSettings() { return generalSettings; }
+	virtual vector<DataTypes::Ammo> getAmmo() { return ammo; }
+	virtual vector<DataTypes::Contact> getContacts() { return contacts; }
+	virtual list<Coords> getActivePath() { return activePath; }
+	virtual bool getIsLeader() { return isLeader; }
+	virtual unsigned char getOperateAs() { return operateAs;  }
+	virtual unsigned char getShotsScatter() { return shotsScatter; }
+	virtual unsigned char getShotsIntensity() { return shotsIntensity; }
+	virtual unsigned char getHealth() { return health; }
+
+protected:
+	unsigned int ID;
+
+	string category;
+	bool alive = false;
+	bool human = false;
+	bool controlled = false;
+	unsigned char coalition = NULL;
+	unsigned char country = NULL;
+	string name = "";
+	string unitName = "";
+	string groupName = "";
+	unsigned char state = State::NONE;
+	string task = "";
+	bool hasTask = false;
+	Coords position = Coords(NULL);
+	double speed = NULL;
+	double horizontalVelocity = NULL;
+	double verticalVelocity = NULL;
+	double heading = NULL;
+	double track = NULL;
+	bool isActiveTanker = false;
+	bool isActiveAWACS = false;
+	bool onOff = true;
+	bool followRoads = false;
+	unsigned short fuel = 0;
+	double desiredSpeed = 0;
+	bool desiredSpeedType = 0;	/* CAS */
+	double desiredAltitude = 1;
+	bool desiredAltitudeType = 0; /* ASL */
+	unsigned int leaderID = NULL;
+	Offset formationOffset = Offset(NULL);
+	unsigned int targetID = NULL;
+	Coords targetPosition = Coords(NULL);
+	unsigned char ROE = ROE::OPEN_FIRE_WEAPON_FREE;
+	unsigned char reactionToThreat = ReactionToThreat::EVADE_FIRE;
+	unsigned char emissionsCountermeasures = EmissionCountermeasure::DEFEND;
+	DataTypes::TACAN TACAN;
+	DataTypes::Radio radio;
+	DataTypes::GeneralSettings generalSettings;
+	vector<DataTypes::Ammo> ammo;
+	vector<DataTypes::Contact> contacts;
+	list<Coords> activePath;
+	bool isLeader = false;
+	unsigned char operateAs = 2;
+	Coords activeDestination = Coords(NULL);
+	unsigned char shotsScatter = 2;
+	unsigned char shotsIntensity = 2;
+	unsigned char health = 100;
+
+	/********** Other **********/
+	unsigned int taskCheckCounter = 0;
+	unsigned int internalCounter = 0;
+	Unit* missOnPurposeTarget = nullptr;
+	bool hasTaskAssigned = false;
+	double initialFuel = 0;
+	map<unsigned char, unsigned long long> updateTimeMap;
+	unsigned long long lastLoopTime = 0;
+	bool enableTaskFailedCheck = false;
+
+	/********** Private methods **********/
+	virtual void AIloop() = 0;
+
+	void appendString(stringstream& ss, const unsigned char& datumIndex, const string& datumValue) {
+		const unsigned short size = static_cast<unsigned short>(datumValue.size());
+		ss.write((const char*)&datumIndex, sizeof(unsigned char));
+		ss.write((const char*)&size, sizeof(unsigned short));
+		ss << datumValue;
+	}
+
+	/********** Template methods **********/
+	template <typename T>
+	void updateValue(T& value, T& newValue, unsigned char datumIndex)
+	{
+		if (newValue != value)
+		{
+			triggerUpdate(datumIndex);
+			value = newValue;
+		}
+	}
+
+	template <typename T>
+	void appendNumeric(stringstream& ss, const unsigned char& datumIndex, T& datumValue) {
+		ss.write((const char*)&datumIndex, sizeof(unsigned char));
+		ss.write((const char*)&datumValue, sizeof(T));
+	}
+
+	template <typename T>
+	void appendVector(stringstream& ss, const unsigned char& datumIndex, vector<T>& datumValue) {
+		const unsigned short size = static_cast<unsigned short>(datumValue.size());
+		ss.write((const char*)&datumIndex, sizeof(unsigned char));
+		ss.write((const char*)&size, sizeof(unsigned short));
+
+		for (auto& el : datumValue)
+			ss.write((const char*)&el, sizeof(T));
+	}
+
+	template <typename T>
+	void appendList(stringstream& ss, const unsigned char& datumIndex, list<T>& datumValue) {
+		const unsigned short size = static_cast<unsigned short>(datumValue.size());;
+		ss.write((const char*)&datumIndex, sizeof(unsigned char));
+		ss.write((const char*)&size, sizeof(unsigned short));
+
+		for (auto& el: datumValue)
+			ss.write((const char*)&el, sizeof(T));
+	}
+};

backend/core/include/unitsmanager.h

@@ -0,0 +1,34 @@
+#pragma once
+#include "framework.h"
+#include "dcstools.h"
+
+class Unit;
+
+class UnitsManager
+{
+public:
+	UnitsManager(lua_State* L);
+	~UnitsManager();
+
+	map<unsigned int, Unit*>& getUnits() { return units; };
+	Unit* getUnit(unsigned int ID);
+	bool isUnitInGroup(Unit* unit);
+	bool isUnitGroupLeader(Unit* unit, Unit*& leader);
+	Unit* getGroupLeader(unsigned int ID);
+	Unit* getGroupLeader(Unit* unit);
+	vector<Unit*> getGroupMembers(string groupName);
+	void update(json::value& missionData, double dt);
+	void runAILoop();
+	void getUnitData(stringstream &ss, unsigned long long time);
+	void deleteUnit(unsigned int ID, bool explosion, string explosionType, bool immediate);
+	void acquireControl(unsigned int ID);
+	void loadDatabases();
+	Unit* getClosestUnit(Unit* unit, unsigned char coalition, vector<string> categories, double &distance);
+	map<Unit*, double> getUnitsInRange(Unit* unit, unsigned char coalition, vector<string> categories, double range);
+
+private:
+	map<unsigned int, Unit*> units;
+	json::value missionDB;
+
+};
+

backend/core/include/weapon.h

@@ -0,0 +1,116 @@
+#pragma once
+#include "framework.h"
+#include "utils.h"
+#include "dcstools.h"
+#include "luatools.h"
+#include "logger.h"
+#include "commands.h"
+#include "datatypes.h"
+
+#include <chrono>
+using namespace std::chrono;
+
+class Weapon
+{
+public:
+	Weapon(json::value json, unsigned int ID);
+	~Weapon();
+
+	/********** Methods **********/
+	void initialize(json::value json);
+	void update(json::value json, double dt);
+	unsigned int getID() { return ID; }
+	void getData(stringstream& ss, unsigned long long time);
+	void triggerUpdate(unsigned char datumIndex);
+	bool hasFreshData(unsigned long long time);
+	bool checkFreshness(unsigned char datumIndex, unsigned long long time);
+
+	/********** Setters **********/
+	virtual void setCategory(string newValue) { updateValue(category, newValue, DataIndex::category); }
+	virtual void setAlive(bool newValue) { updateValue(alive, newValue, DataIndex::alive); }
+	virtual void setCoalition(unsigned char newValue) { updateValue(coalition, newValue, DataIndex::coalition); }
+	virtual void setName(string newValue) { updateValue(name, newValue, DataIndex::name); }
+	virtual void setPosition(Coords newValue) { updateValue(position, newValue, DataIndex::position); }
+	virtual void setSpeed(double newValue) { updateValue(speed, newValue, DataIndex::speed); }
+	virtual void setHeading(double newValue) { updateValue(heading, newValue, DataIndex::heading); }
+
+	/********** Getters **********/
+	virtual string getCategory() { return category; };
+	virtual bool getAlive() { return alive; }
+	virtual unsigned char getCoalition() { return coalition; }
+	virtual string getName() { return name; }
+	virtual Coords getPosition() { return position; }
+	virtual double getSpeed() { return speed; }
+	virtual double getHeading() { return heading; }
+	
+protected:
+	unsigned int ID;
+
+	string category;
+	bool alive = false;
+	unsigned char coalition = NULL;
+	string name = "";
+	Coords position = Coords(NULL);
+	double speed = NULL;
+	double heading = NULL;
+	
+	/********** Other **********/
+	map<unsigned char, unsigned long long> updateTimeMap;
+
+	/********** Private methods **********/
+	void appendString(stringstream& ss, const unsigned char& datumIndex, const string& datumValue) {
+		const unsigned short size = static_cast<unsigned short>(datumValue.size());
+		ss.write((const char*)&datumIndex, sizeof(unsigned char));
+		ss.write((const char*)&size, sizeof(unsigned short));
+		ss << datumValue;
+	}
+
+	/********** Template methods **********/
+	template <typename T>
+	void updateValue(T& value, T& newValue, unsigned char datumIndex)
+	{
+		if (newValue != value)
+		{
+			triggerUpdate(datumIndex);
+			value = newValue;
+		}
+	}
+
+	template <typename T>
+	void appendNumeric(stringstream& ss, const unsigned char& datumIndex, T& datumValue) {
+		ss.write((const char*)&datumIndex, sizeof(unsigned char));
+		ss.write((const char*)&datumValue, sizeof(T));
+	}
+
+	template <typename T>
+	void appendVector(stringstream& ss, const unsigned char& datumIndex, vector<T>& datumValue) {
+		const unsigned short size = datumValue.size();
+		ss.write((const char*)&datumIndex, sizeof(unsigned char));
+		ss.write((const char*)&size, sizeof(unsigned short));
+
+		for (auto& el : datumValue)
+			ss.write((const char*)&el, sizeof(T));
+	}
+
+	template <typename T>
+	void appendList(stringstream& ss, const unsigned char& datumIndex, list<T>& datumValue) {
+		const unsigned short size = datumValue.size();
+		ss.write((const char*)&datumIndex, sizeof(unsigned char));
+		ss.write((const char*)&size, sizeof(unsigned short));
+
+		for (auto& el : datumValue)
+			ss.write((const char*)&el, sizeof(T));
+	}
+};
+
+class Missile : public Weapon
+{
+public:
+	Missile(json::value json, unsigned int ID);
+};
+
+class Bomb : public Weapon
+{
+public:
+	Bomb(json::value json, unsigned int ID);
+};

backend/core/include/weaponsmanager.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "framework.h"
+#include "dcstools.h"
+
+class Weapon;
+
+class WeaponsManager
+{
+public:
+	WeaponsManager(lua_State* L);
+	~WeaponsManager();
+
+	map<unsigned int, Weapon*>& getWeapons() { return weapons; };
+	Weapon* getWeapon(unsigned int ID);
+	void update(json::value& missionData, double dt);
+	void getWeaponData(stringstream& ss, unsigned long long time);
+
+private:
+	map<unsigned int, Weapon*> weapons;
+};
+