Merge branch 'main' into release-candidate

fix(unit): unit and group id are now of the correct type;

.github/workflows/build_package.yml

@@ -2,7 +2,7 @@ name: Build & package
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "main", "release-candidate" ]
 
 permissions:
   contents: read
@@ -23,7 +23,7 @@ jobs:
         vcpkg integrate install
 
     - name: Setup Node.js
-      uses: actions/setup-node@v2
+      uses: actions/setup-node@v4
         
     - name: Build
       working-directory: .
@@ -31,8 +31,16 @@ jobs:
       shell: cmd
 
     - name: Upload a Build Artifact
-      uses: actions/upload-artifact@v3.1.3
+      uses: actions/upload-artifact@v4.6.1
       with:
-        name: latest
-        path: installer/Output/*.exe
+        name: development_build_not_a_release
+        path: ./package
+
+    - name: Upload a Build Artifact
+      uses: actions/upload-artifact@v4.6.1
+      with:
+        name: zip_only_package
+        path: ./zip
+        include-hidden-files: true 
+      
       

.github/workflows/documentation.yml

@@ -1,42 +0,0 @@
-# ci.yml file for GitHub Actions
-name: Documentation
-
-on: [push]
-
-# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
-permissions:
-  contents: write
-  pages: write
-  id-token: write
-
-jobs:
-  build_docs:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v2
-        
-      - name: Setup Node.js
-        uses: actions/setup-node@v2
-        
-      - name: Install dependencies
-        run: npm ci
-        working-directory: ./client
-
-      - name: Create the docs directory locally in CI
-        run: npx typedoc --out ../docs/client @types/*.d.ts src/**/*.ts
-        working-directory: ./client
-
-      - name: Install Doxygen
-        run: sudo apt-get install doxygen -y
-        shell: bash
-
-      - name: Generate Doxygen Documentation
-        run: doxygen docs
-        shell: bash
-        working-directory: ./src
-        
-      - name: Deploy 🚀
-        uses: JamesIves/github-pages-deploy-action@v4
-        with:
-          folder: docs 

.gitignore

@@ -1,25 +1,45 @@
 bin
 .vs
 x64
-/src/vcpkg_installed
-*.user
 Output
-*.aps
 node_modules
-/client/TODO.txt
-/client/public/javascripts/bundle.js
-!client/bin
-/client/public/plugins
-/client/plugins/controltips/index.js
 hgt
-/client/public/databases/units/old
-/client/plugins/databasemanager/index.js
+
+/backend/vcpkg_installed
+
+/frontend/server/TODO.txt
+/frontend/server/public/javascripts/bundle.js
+/frontend/server/public/plugins
+/frontend/server/plugins/controltips/index.js
+/frontend/server/public/databases/units/old
+/frontend/server/plugins/databasemanager/index.js
 
 /src/html
 /src/latex
-client/public/stylesheets/leaflet/leaflet-gesture-handling.css
-client/public/javascripts/leaflet.nauticscale.js
-client/public/javascripts/L.Path.Drag.js
-/installer/archive/Scripts
-/installer/archive/Mods
-/installer/installer/DCSOlympus*.exe
+
+/package
+/build
+/DCS Olympus backups
+/zip
+
+*.user
+*.aps
+
+L.Path.Drag.js
+leaflet-gesture-handling.css
+leaflet.nauticscale.js
+leaflet.css
+package-lock.json
+
+!frontend/server/bin
+/mock-dcs
+/frontend/setup
+frontend/server/public/plugins/controltipsplugin/index.js
+frontend/website/plugins/controltips/index.js
+/frontend/server/public/maps
+*.pyc
+/scripts/**/*.jpg
+manager/manager.log
+/frontend/server/public
+/frontend/server/build
+/frontend/react/.vite

INSTRUCTIONS.txt

@@ -0,0 +1,59 @@
+  _____   _____  _____    ____  _                                 
+ |  __ \ / ____|/ ____|  / __ \| |                                
+ | |  | | |    | (___   | |  | | |_   _ _ __ ___  _ __  _   _ ___ 
+ | |  | | |     \___ \  | |  | | | | | | '_ ` _ \| '_ \| | | / __|
+ | |__| | |____ ____) | | |__| | | |_| | | | | | | |_) | |_| \__ \
+ |_____/ \_____|_____/   \____/|_|\__, |_| |_| |_| .__/ \__,_|___/
+                                   __/ |         | |              
+                                  |___/          |_|              
+
+{{OLYMPUS_VERSION_NUMBER}}
+
+==========================================
+INSTALLATION INSTRUCTIONS
+
+1) Close any applications which may interfere with installation, including Digital Combat Simulator (DCS) and previous versions of Olympus.
+
+2) If you DO NOT have Olympus already installed, SKIP THIS STEP. If you have already installed Olympus, do the following:
+    	NOTE: If you made any changes to your unit databases or mods.lua file (e.g. to support a third party mod) make a backup of the edited files before proceeding or changes will be lost;
+    	a) If you installed DCS Olympus v1.0.3 using the installer, simply remove it using Windows's "Add or remove programs" application. 
+    	b) If you installed DCS Olympus v1.0.3 using the archived version, remove it by deleting the "...<DCS Saved Games folder>\Mods\Services\Olympus" folder. Do this for every DCS instance you installed Olympus in. 
+       	   Remember to delete any shortcuts you created. Don't worry, they will be created automatically again by the installation script provided in this package.
+
+3) Create a folder named "DCS Olympus" in your "Saved Games" directory and extract all the contents of the downloaded package into it.
+	NOTE:
+    	a) Do not extract the contents of the package directly in your Saved Games folder or in your DCS Saved Games folder. 
+        b) Unlike previous version of Olympus, it is no longer necessary to copy the packaged files into each DCS instance folder.
+
+4) Execute the "installer.bat" script by double-clicking on it. It is located in the folder you created in step 3. Wait for the installation script to complete. Installation may take a couple of minutes, after which the Manager will start automatically.
+	NOTE: depending on your Windows configuration, the script may be called "installer" (without .bat at the end).
+
+5) The Olympus Manager will open. This will allow you to add/remove Olympus to individual DCS instances.
+	Use the Olympus Manager and follow the instructions to install and setup Olympus.
+
+6) Start DCS and run a mission. Make sure it is UNPAUSED.
+
+7) Open Olympus via the shortcut and login using any username and the Game Master password set using the Manager. (NOTE: not your DCS server password).
+	Local installation: run the client from the provided desktop shortcut or start it using the "View and manage instances" page of the Manager. 
+	Dedicated server: users must first start the Olympus server from the provided desktop shortcut or using the "View and manage instances" page of the Manager. 
+			  Then log in using any browser and visiting "http:\\<server IP>:<frontend port>" (frontend port is 3000 by default, but can be edited using the Manager)
+
+8) You can use the manager at any time to change the ports and/or passwords. If you do, REMEMBER TO RESTART OLYMPUS AND DCS.
+
+
+NOTES:
+a) when launching the Manager you will be prompted to allow Electron to create a firewall rule. This is optional and can be denied without effect on the operation of the Manager;
+b) if you are using Olympus on a dedicated server with a router, you must enable port forwarding on the frontend port (3000 by default);
+c) unlike Olympus v1.0.3, running the netsh command is no longer required. It is also no longer required to create firewall rules or port forwarding for the backend port. (Optional) If you already performed this steps in the past you can delete the firewall and netsh rules.
+
+
+==========================================
+UPDATING INSTRUCTIONS
+
+IF YOU ARE UPDATING FROM DCS OLYMPUS v1.0.3, FOLLOW THE "INSTALLATION INSTRUCTIONS".
+
+To update your Olympus installation you have two options:
+a) download the new package from the GitHub releases page, delete the old unpacked package folder, then follow the INSTALLATION INSTRUCTIONS;
+b) run the Olympus Manager. If an update is available you will be given the option to automatically update Olympus from there.
+
+For either options a) or b), remember to close any applications which may interfere with installation, including Digital Combat Simulator (DCS) and previous versions of Olympus.

README.md

@@ -1,4 +1,3 @@
-## Important note: DCS Olympus is in beta state. No official release has been produced yet. The first public version is planned for mid december 2023.
 <img align="left" width="30" src="https://github.com/Pax1601/DCSOlympus/assets/103559271/0ecff279-a87c-4e2d-a4c7-da98c74adf38">
 
 [**Join our Discord**](https://discord.gg/kNAQkhUHnQ)
@@ -10,8 +9,6 @@
 
 # DCS Olympus
 
-![alt text](https://github.com/Pax1601/DCSOlympus/blob/main/client/sample.png?raw=true)
-
 ### What is this?
 DCS: Olympus is a free and open-source mod for DCS that enables dynamic real-time control through a map interface. The user is able to spawn units/groups, deploy a variety of effects such as smoke, flares, or explosions, and waypoints/tasks can be given to AI units in real-time in a way similar to a classic RTS game. 
 
@@ -24,18 +21,28 @@ Even better it requires no client mods be installed if used on a server
 The full feature list is simply too long to enumerate in a short summary but needless to say Olympus offers up a lot of unique gameplay that has previously not existed, and enhances many other elements of DCS in exciting ways 
 
 ### Installing DCS Olympus
-A prebuilt installer will soon be released and available here
+Check the [Wiki](https://github.com/Pax1601/DCSOlympus/wiki) for installation instructions
 
 # Frequently Asked Questions
-### Can I join up and help out with the project? ###
-We are currently running towards first release in the very near future so we are not looking to add more people to the core team for the moment. However that does not mean we are not open to collaborations and help going forward, if you want to help for now we are committed to the free and open source model so feel free to check out the github, familiarize yourself with the project and maybe even start submitting pull requests for open issues.
 
-Post-release we will be more interested in developing partnerships/collaborations with other teams/projects and potentially bringing in more team members, we will update this after release on how that will be managed!
+### I need troubleshooting guidance, please help? ###
+Read through the [Installation Guide](https://github.com/Pax1601/DCSOlympus/wiki) to ensure you have setup Olympus correctly.
+
+Read through [Setup Troubleshooting](https://github.com/Pax1601/DCSOlympus/wiki/3.-Setup-FAQ-and-Troubleshooting) for common issues and solutions.
+
+If you're still having issues after trying the steps above, please post in the ⁠community-support channel with the following:
+
+A detailed description of your issue
+Your Olympus log file \user home folder\AppData\Local\Temp\Olympus_log.txt for some it might be in \DCS Saved Games folder\Logs\Olympus_log.txt
+Your DCS log file \DCS Saved Games folder\Logs\dcs.log
+
+Screenshots of any relevant screens or issues and any other pertinent information.
+
+### Can I join up and help out with the project? ###
+Absolutely, join the discord and ping any of the developers to get briefed.
 
 ### Can I be a beta/alpha-tester? ###
-With first public release planned for the very-near future we are fully committed to the final sprint, as such we will not be formally recruiting more people to test pre-release. 
-
-Post-release we will be eager to hear feedback of all forms and take in bug-reports, at this time after release we will begin considering bringing in more team members to test in development versions as we go.
+Same as above!
 
 ### Do you have a roadmap? ###
 We do not have a roadmap no, we have a laundry list of things we are hoping to do. 
@@ -72,9 +79,5 @@ A and B never communicate when you connect the client you download the web page
 Olympus by itself should not have a noticeable impact on server performance, however the ability for the user to spawn arbitrary units and command engagements means Olympus can be used in such a way that brings the game to it's knees.
 
 Be cognizant of how you play, whether it's done through Olympus or the mission editor 500 MLRS units firing at once is not going to go over well with most servers
- 
-    
-    
-    
 
     

backend/core/core.rc

@@ -61,8 +61,8 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_UK
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
- PRODUCTVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
+ FILEVERSION 2,0,0,0
+ PRODUCTVERSION 1,0,3,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -79,12 +79,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "DCS Olympus"
             VALUE "FileDescription", "DCS Olympus"
-            VALUE "FileVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "FileVersion", "2.0.0.0"
             VALUE "InternalName", "core.dll"
             VALUE "LegalCopyright", "Copyright (C) 2023"
             VALUE "OriginalFilename", "core.dll"
             VALUE "ProductName", "DCS Olympus"
-            VALUE "ProductVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "ProductVersion", "2.0.0.0"
         END
     END
     BLOCK "VarFileInfo"

backend/core/core.vcxproj

@@ -110,26 +110,26 @@
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <OutDir>.\..\..\bin\$(Platform)\$(Configuration)\</OutDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <OutDir>.\..\..\bin\</OutDir>
+    <OutDir>.\..\..\build\backend\bin\</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>

backend/core/include/airunit.h

@@ -18,6 +18,10 @@ public:
 	virtual void changeSpeed(string change) = 0;
 	virtual void changeAltitude(string change) = 0;
 	virtual double getDestinationReachedThreshold() { return AIR_DEST_DIST_THR;  }
+
+	virtual void setRacetrackLength(double newValue);
+	virtual void setRacetrackAnchor(Coords newValue);
+	virtual void setRacetrackBearing(double newValue);
 	
 protected:
 	virtual void AIloop();

backend/core/include/commands.h

@@ -18,6 +18,7 @@ namespace SetCommandType {
 		FORMATION = 5,
 		RTB_ON_BINGO = 6,
 		SILENCE = 7,
+		ALARM_STATE = 9,
 		RTB_ON_OUT_OF_AMMO = 10,
 		ECM_USING = 13,
 		PROHIBIT_AA = 14,
@@ -45,6 +46,14 @@ namespace ROE {
 	};
 }
 
+namespace AlarmState {
+	enum AlarmStates {
+		AUTO   = 0,
+		GREEN  = 1,
+		RED    = 2,
+	};
+}
+
 namespace ReactionToThreat {
 	enum ReactionsToThreat {
 		NO_REACTION = 0,
@@ -430,3 +439,98 @@ private:
 	const unsigned int intensity;
 	const string explosionType;
 };
+
+/* Shine a laser with a specific code */
+class FireLaser : public Command
+{
+public:
+	FireLaser(unsigned int ID, unsigned int code, Coords destination, function<void(void)> callback = []() {}) :
+		Command(callback),
+		ID(ID),
+		destination(destination),
+		code(code)
+	{
+		priority = CommandPriority::LOW;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 5; }
+
+private:
+	const unsigned int ID;
+	const unsigned int code;
+	const Coords destination;
+};
+
+/* Shine a infrared light */
+class FireInfrared : public Command
+{
+public:
+	FireInfrared(unsigned int ID, Coords destination, function<void(void)> callback = []() {}) :
+		Command(callback),
+		ID(ID),
+		destination(destination)
+	{
+		priority = CommandPriority::LOW;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 5; }
+
+private:
+	const unsigned int ID;
+	const Coords destination;
+};
+
+/* Change a laser code */
+class SetLaserCode : public Command
+{
+public:
+	SetLaserCode(unsigned int spotID, unsigned int code, function<void(void)> callback = []() {}) :
+		Command(callback),
+		spotID(spotID),
+		code(code)
+	{
+		priority = CommandPriority::LOW;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 5; }
+
+private:
+	const unsigned int spotID;
+	const unsigned int code;
+};
+
+/* Delete a spot code */
+class DeleteSpot : public Command
+{
+public:
+	DeleteSpot(unsigned int spotID, function<void(void)> callback = []() {}) :
+		Command(callback),
+		spotID(spotID)
+	{
+		priority = CommandPriority::LOW;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 5; }
+
+private:
+	const unsigned int spotID;
+};
+
+/* Move spot to a new target */
+class MoveSpot : public Command
+{
+public:
+	MoveSpot(unsigned int spotID, Coords destination, function<void(void)> callback = []() {}) :
+		Command(callback),
+		spotID(spotID),
+		destination(destination)
+	{
+		priority = CommandPriority::LOW;
+	};
+	virtual string getString();
+	virtual unsigned int getLoad() { return 5; }
+
+private:
+	const unsigned int spotID;
+	const Coords destination;
+};

backend/core/include/datatypes.h

@@ -7,12 +7,17 @@ namespace DataIndex {
 		startOfData = 0,
 		category,
 		alive,
+		alarmState,
+		radarState,
 		human,
 		controlled,
 		coalition,
 		country,
 		name,
 		unitName,
+		callsign,
+		unitID,
+		groupID,
 		groupName,
 		state,
 		task,
@@ -50,6 +55,21 @@ namespace DataIndex {
 		shotsScatter,
 		shotsIntensity,
 		health,
+		racetrackLength,
+		racetrackAnchor,
+		racetrackBearing,
+		timeToNextTasking,
+		barrelHeight, 
+		muzzleVelocity,
+		aimTime, 
+		shotsToFire,
+		shotsBaseInterval, 
+		shotsBaseScatter, 
+		engagementRange, 
+		targetingRange, 
+		aimMethodRange,
+		acquisitionRange,
+		airborne,
 		lastIndex,
 		endOfData = 255
 	};
@@ -152,7 +172,9 @@ struct SpawnOptions {
 	string unitType;
 	Coords location;
 	string loadout;
+	string skill;
 	string liveryID;
+	double heading;
 };
 
 struct CloneOptions {

backend/core/include/groundunit.h

@@ -17,7 +17,7 @@ public:
 	virtual void setOnOff(bool newOnOff, bool force = false);
 	virtual void setFollowRoads(bool newFollowRoads, bool force = false);
 
-	void aimAtPoint(Coords aimTarget);
+	string aimAtPoint(Coords aimTarget);
 
 protected:
 	virtual void AIloop();

backend/core/include/unit.h

@@ -19,12 +19,12 @@ public:
 	~Unit();
 
 	/********** Methods **********/
-	void initialize(json::value json);
+	virtual void initialize(json::value json) final;
 	virtual void setDefaults(bool force = false);
 
 	void runAILoop();
 
-	void update(json::value json, double dt);
+	virtual void update(json::value json, double dt) final;
 	void refreshLeaderData(unsigned long long time);
 
 	unsigned int getID() { return ID; }
@@ -62,15 +62,21 @@ public:
 	bool hasFreshData(unsigned long long time);
 	bool checkFreshness(unsigned char datumIndex, unsigned long long time);
 
+	unsigned int computeTotalAmmo();
+
 	/********** Setters **********/
 	virtual void setCategory(string newValue) { updateValue(category, newValue, DataIndex::category); }
 	virtual void setAlive(bool newValue) { updateValue(alive, newValue, DataIndex::alive); }
+	virtual void setAlarmState(unsigned char newValue, bool force = false);
 	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 setCallsign(string newValue) { updateValue(callsign, newValue, DataIndex::callsign); }
+	virtual void setUnitID(unsigned int newValue) { updateValue(unitID, newValue, DataIndex::unitID); }
+	virtual void setGroupID(unsigned int newValue) { updateValue(groupID, newValue, DataIndex::groupID); }
 	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); }
@@ -108,17 +114,37 @@ public:
 	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); }
+	virtual void setRacetrackLength(double newValue) { updateValue(racetrackLength, newValue, DataIndex::racetrackLength); }
+	virtual void setRacetrackAnchor(Coords newValue) { updateValue(racetrackAnchor, newValue, DataIndex::racetrackAnchor); }
+	virtual void setRacetrackBearing(double newValue) { updateValue(racetrackBearing, newValue, DataIndex::racetrackBearing); }
+	virtual void setTimeToNextTasking(double newValue) { updateValue(timeToNextTasking, newValue, DataIndex::timeToNextTasking); }
+	virtual void setBarrelHeight(double newValue) { updateValue(barrelHeight, newValue, DataIndex::barrelHeight); }
+	virtual void setMuzzleVelocity(double newValue) { updateValue(muzzleVelocity, newValue, DataIndex::muzzleVelocity); }
+	virtual void setAimTime(double newValue) { updateValue(aimTime, newValue, DataIndex::aimTime); }
+	virtual void setShotsToFire(unsigned int newValue) { updateValue(shotsToFire, newValue, DataIndex::shotsToFire); }
+	virtual void setShotsBaseInterval(double newValue) { updateValue(shotsBaseInterval, newValue, DataIndex::shotsBaseInterval); }
+	virtual void setShotsBaseScatter(double newValue) { updateValue(shotsBaseScatter, newValue, DataIndex::shotsBaseScatter); }
+	virtual void setEngagementRange(double newValue) { updateValue(engagementRange, newValue, DataIndex::engagementRange); }
+	virtual void setTargetingRange(double newValue) { updateValue(targetingRange, newValue, DataIndex::targetingRange); }
+	virtual void setAimMethodRange(double newValue) { updateValue(aimMethodRange, newValue, DataIndex::aimMethodRange); }
+	virtual void setAcquisitionRange(double newValue) { updateValue(acquisitionRange, newValue, DataIndex::acquisitionRange); }
+	virtual void setRadarState(bool newValue) { updateValue(radarState, newValue, DataIndex::radarState); }
+	virtual void setAirborne(bool newValue) { updateValue(airborne, newValue, DataIndex::airborne); }
 
 	/********** Getters **********/
 	virtual string getCategory() { return category; };
 	virtual bool getAlive() { return alive; }
+	virtual unsigned char getAlarmState() { return alarmState; }
 	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 getCallsign() { return callsign; }
 	virtual string getUnitName() { return unitName; }
 	virtual string getGroupName() { return groupName; }
+	virtual unsigned int getUnitID() { return unitID; }
+	virtual unsigned int getGroupID() { return groupID; }
 	virtual unsigned char getState() { return state; }
 	virtual string getTask() { return task; }
 	virtual bool getHasTask() { return hasTask; }
@@ -155,6 +181,22 @@ public:
 	virtual unsigned char getShotsScatter() { return shotsScatter; }
 	virtual unsigned char getShotsIntensity() { return shotsIntensity; }
 	virtual unsigned char getHealth() { return health; }
+	virtual double getRacetrackLength() { return racetrackLength; }
+	virtual Coords getRacetrackAnchor() { return racetrackAnchor; }
+	virtual double getRacetrackBearing() { return racetrackBearing; }
+	virtual double getTimeToNextTasking() { return timeToNextTasking; }
+	virtual double getBarrelHeight() { return barrelHeight; }
+	virtual double getMuzzleVelocity() { return muzzleVelocity; }
+	virtual double getAimTime() { return aimTime; }
+	virtual unsigned int getShotsToFire() { return shotsToFire; }
+	virtual double getShotsBaseInterval() { return shotsBaseInterval; }
+	virtual double getShotsBaseScatter() { return shotsBaseScatter; }
+	virtual double getEngagementRange() { return engagementRange; }
+	virtual double getTargetingRange() { return targetingRange; }
+	virtual double getAimMethodRange() { return aimMethodRange; }
+	virtual double getAcquisitionRange() { return acquisitionRange; }
+	virtual bool getRadarState() { return radarState; }
+	virtual bool getAirborne() { return airborne; }
 
 protected:
 	unsigned int ID;
@@ -167,8 +209,13 @@ protected:
 	unsigned char country = NULL;
 	string name = "";
 	string unitName = "";
+	string callsign = "";
+	unsigned int unitID = NULL;
+	unsigned int groupID = NULL;
 	string groupName = "";
 	unsigned char state = State::NONE;
+	unsigned char alarmState = AlarmState::AUTO;
+	bool radarState = false;
 	string task = "";
 	bool hasTask = false;
 	Coords position = Coords(NULL);
@@ -187,6 +234,9 @@ protected:
 	double desiredAltitude = 1;
 	bool desiredAltitudeType = 0; /* ASL */
 	unsigned int leaderID = NULL;
+	double racetrackLength = NULL;
+	Coords racetrackAnchor = Coords(NULL);
+	double racetrackBearing = NULL;
 	Offset formationOffset = Offset(NULL);
 	unsigned int targetID = NULL;
 	Coords targetPosition = Coords(NULL);
@@ -205,16 +255,31 @@ protected:
 	unsigned char shotsScatter = 2;
 	unsigned char shotsIntensity = 2;
 	unsigned char health = 100;
+	double timeToNextTasking = 0;
+	double barrelHeight = 0; 
+	double muzzleVelocity = 0; 
+	double aimTime = 0;
+	unsigned int shotsToFire = 0;
+	double shotsBaseInterval = 0;
+	double shotsBaseScatter = 0; 
+	double engagementRange = 0;
+	double targetingRange = 0;
+	double aimMethodRange = 0; 
+	double acquisitionRange = 0; 
+	bool airborne = false;
 
 	/********** 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;
+	unsigned long nextTaskingMilliseconds = 0;
+	unsigned int totalShellsFired = 0;
+	unsigned int shellsFiredAtTasking = 0;
+	unsigned int oldAmmo = 0;
 
 	/********** Private methods **********/
 	virtual void AIloop() = 0;

backend/core/include/unitsmanager.h

@@ -23,8 +23,8 @@ public:
 	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);
+	Unit* getClosestUnit(Unit* unit, unsigned char coalition, vector<string> categories, double &distance, bool airborneOnly = true);
+	map<Unit*, double> getUnitsInRange(Unit* unit, unsigned char coalition, vector<string> categories, double range, bool airborneOnly = true);
 
 private:
 	map<unsigned int, Unit*> units;

backend/core/include/weapon.h

@@ -113,4 +113,10 @@ class Bomb : public Weapon
 {
 public:
 	Bomb(json::value json, unsigned int ID);
+};
+
+class Shell : public Weapon
+{
+public:
+	Shell(json::value json, unsigned int ID);
 };

backend/core/src/airunit.cpp

@@ -154,6 +154,13 @@ void AirUnit::AIloop()
 {
 	srand(static_cast<unsigned int>(time(NULL)) + ID);
 
+	/* Reset the anchor */
+	if (state != State::IDLE) {
+		setRacetrackAnchor(Coords(NULL));
+		setRacetrackBearing(NULL);
+		setRacetrackLength(NULL);
+	}
+
 	/* State machine */
 	switch (state) {
 		case State::IDLE: {
@@ -166,21 +173,27 @@ void AirUnit::AIloop()
 			
 			if (!getHasTask())
 			{
+				if (racetrackAnchor == Coords(NULL)) setRacetrackAnchor(position);
+				if (racetrackBearing == NULL) setRacetrackBearing(heading);
+
 				std::ostringstream taskSS;
 				if (isActiveTanker) {
 					taskSS << "{ [1] = { id = 'Tanker' }, [2] = { id = 'Orbit', pattern = 'Race-Track', altitude = " << 
-						desiredAltitude << ", speed = " << desiredSpeed << ", altitudeType = '" << 
-						(desiredAltitudeType ? "AGL" : "ASL") << "', speedType = '" << (desiredSpeedType ? "GS" : "CAS") << "' }}";
+						desiredAltitude << ", lat = " << racetrackAnchor.lat << ", lng = " << racetrackAnchor.lng << ", speed = " << desiredSpeed << ", altitudeType = '" <<
+						(desiredAltitudeType ? "AGL" : "ASL") << "', speedType = '" << (desiredSpeedType ? "GS" : "CAS") << "', heading = " << 
+						racetrackBearing << ", length = " << (racetrackLength != NULL ? racetrackLength : (50000 * 1.852)) << " }}";
 				}
 				else if (isActiveAWACS) {
-					taskSS << "{ [1] = { id = 'AWACS' }, [2] = { id = 'Orbit', pattern = 'Circle', altitude = " << 
-						desiredAltitude << ", speed = " << desiredSpeed << ", altitudeType = '" << 
-						(desiredAltitudeType ? "AGL" : "ASL") << "', speedType = '" << (desiredSpeedType ? "GS" : "CAS") << "' }}";
+					taskSS << "{ [1] = { id = 'AWACS' }, [2] = { id = 'Orbit', pattern = 'Race-Track', altitude = " <<
+						desiredAltitude << ", lat = " << racetrackAnchor.lat << ", lng = " << racetrackAnchor.lng << ", speed = " << desiredSpeed << ", altitudeType = '" <<
+						(desiredAltitudeType ? "AGL" : "ASL") << "', speedType = '" << (desiredSpeedType ? "GS" : "CAS") << "', heading = " <<
+						racetrackBearing << ", length = " << (racetrackLength != NULL ? racetrackLength : (desiredSpeed * 30)) << " }}";
 				}
 				else {
-					taskSS << "{ id = 'Orbit', pattern = 'Circle', altitude = " << 
-						desiredAltitude << ", speed = " << desiredSpeed << ", altitudeType = '" << 
-						(desiredAltitudeType ? "AGL" : "ASL") << "', speedType = '" << (desiredSpeedType ? "GS" : "CAS") << "'}";
+					taskSS << "{ id = 'Orbit', pattern = 'Race-Track', altitude = " << 
+						desiredAltitude << ", lat = " << racetrackAnchor.lat << ", lng = " << racetrackAnchor.lng << ", speed = " << desiredSpeed << ", altitudeType = '" <<
+						(desiredAltitudeType ? "AGL" : "ASL") << "', speedType = '" << (desiredSpeedType ? "GS" : "CAS") << "', heading = " <<
+						racetrackBearing << ", length = " << (racetrackLength != NULL ? racetrackLength: (desiredSpeed * 30)) << " }";
 				}
 				Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
 				scheduler->appendCommand(command);
@@ -376,4 +389,43 @@ void AirUnit::AIloop()
 		default:
 			break;
 	}
+}
+
+void AirUnit::setRacetrackLength(double newRacetrackLength) { 
+	if (racetrackLength != newRacetrackLength) {
+		racetrackLength = newRacetrackLength;
+
+		/* Apply the change */
+		setHasTask(false);
+		resetTaskFailedCounter();
+		AIloop();
+
+		triggerUpdate(DataIndex::racetrackLength);
+	}
+}
+
+void AirUnit::setRacetrackAnchor(Coords newRacetrackAnchor) { 
+	if (racetrackAnchor != newRacetrackAnchor) {
+		racetrackAnchor = newRacetrackAnchor;
+
+		/* Apply the change */
+		setHasTask(false);
+		resetTaskFailedCounter();
+		AIloop();
+
+		triggerUpdate(DataIndex::racetrackAnchor);
+	}
+}
+
+void AirUnit::setRacetrackBearing(double newRacetrackBearing) { 
+	if (racetrackBearing != newRacetrackBearing) {
+		racetrackBearing = newRacetrackBearing;
+
+		/* Apply the change */
+		setHasTask(false);
+		resetTaskFailedCounter();
+		AIloop();
+
+		triggerUpdate(DataIndex::racetrackBearing);
+	}
 }

backend/core/src/commands.cpp

@@ -46,7 +46,10 @@ string SpawnGroundUnits::getString()
             << "unitType = " << "\"" << spawnOptions[i].unitType << "\"" << ", "
             << "lat = " << spawnOptions[i].location.lat << ", "
             << "lng = " << spawnOptions[i].location.lng << ", "
-            << "liveryID = " << "\"" << spawnOptions[i].liveryID << "\"" << " }, ";
+            << "heading = " << spawnOptions[i].heading << ", "
+            << "liveryID = " << "\"" << spawnOptions[i].liveryID << "\"" << ", "
+            << "skill =  \"" << spawnOptions[i].skill << "\"" << "}, ";
+
     }
 
     std::ostringstream commandSS;
@@ -70,7 +73,9 @@ string SpawnNavyUnits::getString()
             << "unitType = " << "\"" << spawnOptions[i].unitType << "\"" << ", "
             << "lat = " << spawnOptions[i].location.lat << ", "
             << "lng = " << spawnOptions[i].location.lng << ", "
-            << "liveryID = " << "\"" << spawnOptions[i].liveryID << "\"" << " }, ";
+            << "heading = " << spawnOptions[i].heading << ", "
+            << "liveryID = " << "\"" << spawnOptions[i].liveryID << "\"" << ", "
+            << "skill =  \"" << spawnOptions[i].skill << "\"" << "}, ";
     }
 
     std::ostringstream commandSS;
@@ -94,8 +99,10 @@ string SpawnAircrafts::getString()
             << "lat = " << spawnOptions[i].location.lat << ", "
             << "lng = " << spawnOptions[i].location.lng << ", "
             << "alt = " << spawnOptions[i].location.alt << ", "
+            << "heading = " << spawnOptions[i].heading << ", "
             << "loadout = \"" << spawnOptions[i].loadout << "\"" << ", "
-            << "liveryID = " << "\"" << spawnOptions[i].liveryID << "\"" << " }, ";
+            << "liveryID = " << "\"" << spawnOptions[i].liveryID << "\"" << ", "
+            << "skill =  \"" << spawnOptions[i].skill << "\"" << "}, ";
     }
 
     std::ostringstream commandSS;
@@ -121,8 +128,10 @@ string SpawnHelicopters::getString()
             << "lat = " << spawnOptions[i].location.lat << ", "
             << "lng = " << spawnOptions[i].location.lng << ", "
             << "alt = " << spawnOptions[i].location.alt << ", "
+            << "heading = " << spawnOptions[i].heading << ", "
             << "loadout = \"" << spawnOptions[i].loadout << "\"" << ", "
-            << "liveryID = " << "\"" << spawnOptions[i].liveryID << "\"" << " }, ";
+            << "liveryID = " << "\"" << spawnOptions[i].liveryID << "\"" << ", "
+            << "skill =  \"" << spawnOptions[i].skill << "\"" << "}, ";
     }
 
     std::ostringstream commandSS;
@@ -248,4 +257,62 @@ string Explosion::getString()
         << location.lat << ", "
         << location.lng;
     return commandSS.str();
+}
+
+/* FireLaser command */
+string FireLaser::getString()
+{
+    std::ostringstream commandSS;
+    commandSS.precision(10);
+    commandSS << "Olympus.fireLaser, "
+        << ID << ", "
+        << code << ", "
+        << destination.lat << ", "
+        << destination.lng;
+    return commandSS.str();
+}
+
+/* FireInfrared command */
+string FireInfrared::getString()
+{
+    std::ostringstream commandSS;
+    commandSS.precision(10);
+    commandSS << "Olympus.fireInfrared, "
+        << ID << ", "
+        << destination.lat << ", "
+        << destination.lng;
+    return commandSS.str();
+}
+
+/* SetLaserCode command */
+string SetLaserCode::getString()
+{
+    std::ostringstream commandSS;
+    commandSS.precision(10);
+    commandSS << "Olympus.setLaserCode, "
+        << spotID << ", "
+        << code;
+    return commandSS.str();
+}
+
+/* MoveSpot command */
+string MoveSpot::getString()
+{
+    std::ostringstream commandSS;
+    commandSS.precision(10);
+    commandSS << "Olympus.moveSpot, "
+        << spotID << ", "
+        << destination.lat << ", "
+        << destination.lng;
+    return commandSS.str();
+}
+
+/* DeleteSpot command */
+string DeleteSpot::getString()
+{
+    std::ostringstream commandSS;
+    commandSS.precision(10);
+    commandSS << "Olympus.deleteSpot, "
+        << spotID;
+    return commandSS.str();
 }

backend/core/src/core.cpp

@@ -22,6 +22,7 @@ Scheduler* scheduler = nullptr;
 
 /* Data jsons */
 json::value missionData = json::value::object();
+json::value drawingsByLayer = json::value::object();
 
 mutex mutexLock;
 string sessionHash;
@@ -161,3 +162,17 @@ extern "C" DllExport int coreMissionData(lua_State * L)
 
     return(0);
 }
+
+extern "C" DllExport int coreDrawingsData(lua_State* L)
+{
+    log("Olympus coreDrawingsData called successfully");
+
+    /* Lock for thread safety */
+    lock_guard<mutex> guard(mutexLock);
+
+    lua_getglobal(L, "Olympus");
+    lua_getfield(L, -1, "drawingsByLayer");
+    luaTableToJSON(L, -1, drawingsByLayer);
+
+    return(0);
+}

backend/core/src/groundunit.cpp

@@ -0,0 +1,657 @@
+#include "groundunit.h"
+#include "utils.h"
+#include "logger.h"
+#include "commands.h"
+#include "scheduler.h"
+#include "defines.h"
+#include "unitsmanager.h"
+
+#include <GeographicLib/Geodesic.hpp>
+using namespace GeographicLib;
+
+extern Scheduler* scheduler;
+extern UnitsManager* unitsManager;
+json::value GroundUnit::database = json::value();
+extern string instancePath;
+
+#define RANDOM_ZERO_TO_ONE (double)(rand()) / (double)(RAND_MAX)
+#define RANDOM_MINUS_ONE_TO_ONE (((double)(rand()) / (double)(RAND_MAX) - 0.5) * 2)
+
+void GroundUnit::loadDatabase(string path) {
+	std::ifstream ifstream(instancePath + path);
+	std::stringstream ss;
+	ss << ifstream.rdbuf();
+	std::error_code errorCode;
+	database = json::value::parse(ss.str(), errorCode);
+	if (database.is_object())
+		log("GroundUnits database loaded correctly from " + instancePath + path);
+	else
+		log("Error reading GroundUnits database file");
+}
+
+/* Ground unit */
+GroundUnit::GroundUnit(json::value json, unsigned int ID) : Unit(json, ID)
+{
+	log("New Ground Unit created with ID: " + to_string(ID));
+
+	setCategory("GroundUnit");
+	setDesiredSpeed(10);
+};
+
+void GroundUnit::setDefaults(bool force)
+{
+	/* Load gun values from database */
+	if (database.has_object_field(to_wstring(name))) {
+		json::value databaseEntry = database[to_wstring(name)];
+		if (databaseEntry.has_number_field(L"barrelHeight"))
+			setBarrelHeight(databaseEntry[L"barrelHeight"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"muzzleVelocity"))
+			setMuzzleVelocity(databaseEntry[L"muzzleVelocity"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"aimTime"))
+			setAimTime(databaseEntry[L"aimTime"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"shotsToFire"))
+			setShotsToFire(databaseEntry[L"shotsToFire"].as_number().to_uint32());
+		if (databaseEntry.has_number_field(L"engagementRange"))
+			setEngagementRange(databaseEntry[L"engagementRange"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"shotsBaseInterval"))
+			setShotsBaseInterval(databaseEntry[L"shotsBaseInterval"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"shotsBaseScatter"))
+			setShotsBaseScatter(databaseEntry[L"shotsBaseScatter"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"targetingRange"))
+			setTargetingRange(databaseEntry[L"targetingRange"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"aimMethodRange"))
+			setAimMethodRange(databaseEntry[L"aimMethodRange"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"acquisitionRange"))
+			setAcquisitionRange(databaseEntry[L"acquisitionRange"].as_number().to_double());
+	}
+	
+	if (!getAlive() || !getControlled() || getHuman() || !getIsLeader()) return;
+
+	/* Set the default IDLE state */
+	setState(State::IDLE);
+
+	/* Set the default options */
+	setROE(ROE::OPEN_FIRE_WEAPON_FREE, force);
+	setOnOff(onOff, force);
+	setFollowRoads(followRoads, force);	
+}
+
+void GroundUnit::setState(unsigned char newState)
+{
+	Coords currentTargetPosition = getTargetPosition();
+
+	/************ Perform any action required when LEAVING a state ************/
+	if (newState != state) {
+		switch (state) {
+		case State::IDLE: {
+			break;
+		}
+		case State::REACH_DESTINATION: {
+			break;
+		}
+		case State::ATTACK: {
+			setTargetID(NULL);
+			break;
+		}
+		case State::FIRE_AT_AREA: 
+		case State::SIMULATE_FIRE_FIGHT: 
+		case State::SCENIC_AAA:
+		case State::MISS_ON_PURPOSE: {
+			setTargetPosition(Coords(NULL));
+			break;
+		}
+		default:
+			break;
+		}
+	}
+
+	/************ Perform any action required when ENTERING a state ************/
+	switch (newState) {
+	case State::IDLE: {
+		setTask("Idle");
+		setEnableTaskCheckFailed(false);
+		clearActivePath();
+		resetActiveDestination();
+		break;
+	}
+	case State::REACH_DESTINATION: {
+		setTask("Reaching destination");
+		setEnableTaskCheckFailed(true);
+		resetActiveDestination();
+		break;
+	}
+	case State::ATTACK: {
+		setEnableTaskCheckFailed(true);
+		clearActivePath();
+		resetActiveDestination();
+		break;
+	}
+	case State::FIRE_AT_AREA: {
+		setTask("Firing at area");
+		setTargetPosition(currentTargetPosition);
+		setEnableTaskCheckFailed(true);
+		clearActivePath();
+		resetActiveDestination();
+		break;
+	}
+	case State::SIMULATE_FIRE_FIGHT: {
+		setTask("Simulating fire fight");
+		setTargetPosition(currentTargetPosition);
+		setEnableTaskCheckFailed(false);
+		clearActivePath();
+		resetActiveDestination();
+		break;
+	}
+	case State::SCENIC_AAA: {
+		setTask("Scenic AAA");
+		setEnableTaskCheckFailed(false);
+		clearActivePath();
+		resetActiveDestination();
+		break;
+	}
+	case State::MISS_ON_PURPOSE: {
+		setTask("Miss on purpose");
+		setEnableTaskCheckFailed(false);
+		clearActivePath();
+		resetActiveDestination();
+		break;
+	}
+	default:
+		break;
+	}
+
+	setHasTask(false);
+	resetTaskFailedCounter();
+	nextTaskingMilliseconds = 0;
+
+	log(unitName + " setting state from " + to_string(state) + " to " + to_string(newState));
+	state = newState;
+
+	triggerUpdate(DataIndex::state);
+
+	AIloop();
+}
+
+void GroundUnit::AIloop()
+{
+	srand(static_cast<unsigned int>(time(NULL)) + ID);
+	unsigned long timeNow = std::chrono::system_clock::now().time_since_epoch() / std::chrono::milliseconds(1);
+
+	double currentAmmo = computeTotalAmmo();
+	/* Out of ammo */
+	if (shotsToFire > 0 && currentAmmo < shotsToFire && state != State::IDLE && state != State::REACH_DESTINATION) 
+		setState(State::IDLE);
+	
+	/* Account for unit reloading */
+	if (currentAmmo < oldAmmo)
+		totalShellsFired += oldAmmo - currentAmmo;
+	oldAmmo = currentAmmo;
+
+	switch (state) {
+	case State::IDLE: {
+		if (getHasTask())
+			resetTask();
+
+		break;
+	}
+	case State::REACH_DESTINATION: {
+		string enrouteTask = "";
+		bool looping = false;
+
+		std::ostringstream taskSS;
+		taskSS << "{ id = 'FollowRoads', value = " << (getFollowRoads() ? "true" : "false") << " }";
+		enrouteTask = taskSS.str();
+
+		if (activeDestination == NULL || !getHasTask())
+		{
+			if (!setActiveDestination())
+				setState(State::IDLE);
+			else
+				goToDestination(enrouteTask);
+		}
+		else {
+			if (isDestinationReached(GROUND_DEST_DIST_THR)) {
+				if (updateActivePath(looping) && setActiveDestination())
+					goToDestination(enrouteTask);
+				else
+					setState(State::IDLE);
+			}
+		}
+		break;
+	}
+	case State::ATTACK: {
+		Unit* target = unitsManager->getUnit(getTargetID());
+		if (target != nullptr) {
+			setTask("Attacking " + target->getUnitName());
+
+			if (!getHasTask()) {
+				/* Send the command */
+				std::ostringstream taskSS;
+				taskSS.precision(10);
+				taskSS << "{id = 'AttackUnit', unitID = " << target->getID() << " }";
+				Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
+				scheduler->appendCommand(command);
+				setHasTask(true);
+			}
+		}
+		else {
+			setState(State::IDLE);
+		}
+
+		break;
+	}
+	case State::FIRE_AT_AREA: {
+		if (!getHasTask()) {
+			std::ostringstream taskSS;
+			taskSS.precision(10);
+			if (targetPosition.alt == NULL) {
+				taskSS << "{id = 'FireAtPoint', lat = " << targetPosition.lat << ", lng = " << targetPosition.lng << ", radius = 100}";
+			}
+			else {
+				taskSS << "{id = 'FireAtPoint', lat = " << targetPosition.lat << ", lng = " << targetPosition.lng << ", alt = " << targetPosition.alt << ", radius = 100}";
+			}
+			Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
+			scheduler->appendCommand(command);
+			setHasTask(true);
+		}
+
+		break;
+	}
+	case State::SIMULATE_FIRE_FIGHT: {
+		string taskString = "";
+
+		if ((totalShellsFired - shellsFiredAtTasking >= shotsToFire || timeNow >= nextTaskingMilliseconds) && targetPosition != Coords(NULL)) {
+			if (scheduler->getLoad() > 100) {
+				taskString = "Excessive load, skipping tasking of unit";
+				setTargetPosition(Coords(NULL));
+				if (getHasTask())
+					resetTask();
+			}
+			else {
+				/* Get the distance and bearing to the target */
+				Coords scatteredTargetPosition = targetPosition;
+				double distance;
+				double bearing1;
+				double bearing2;
+				Geodesic::WGS84().Inverse(getPosition().lat, getPosition().lng, scatteredTargetPosition.lat, scatteredTargetPosition.lng, distance, bearing1, bearing2);
+
+				/* Apply a scatter to the aim */
+				bearing1 += RANDOM_MINUS_ONE_TO_ONE * (ShotsScatter::LOW - shotsScatter + 1) * 10;
+
+				/* Compute the scattered position applying a random scatter to the shot */
+				double scatterDistance = distance * tan(10 /* degs */ * (ShotsScatter::LOW - shotsScatter) / 57.29577 + 2 / 57.29577 /* degs */) * RANDOM_MINUS_ONE_TO_ONE;
+				Geodesic::WGS84().Direct(scatteredTargetPosition.lat, scatteredTargetPosition.lng, bearing1, scatterDistance, scatteredTargetPosition.lat, scatteredTargetPosition.lng);
+
+				/* Recover the data from the database */
+				bool indirectFire = false;
+				if (database.has_object_field(to_wstring(name))) {
+					json::value databaseEntry = database[to_wstring(name)];
+					if (databaseEntry.has_boolean_field(L"indirectFire"))
+						indirectFire = databaseEntry[L"indirectFire"].as_bool();
+				}
+
+				/* If the unit is of the indirect fire type, like a mortar, simply shoot at the target */
+				if (indirectFire) {
+					taskString += "Simulating fire fight with indirect fire";
+					log(unitName + "(" + name + ")" + " simulating fire fight with indirect fire");
+					std::ostringstream taskSS;
+					taskSS.precision(10);
+					taskSS << "{id = 'FireAtPoint', lat = " << scatteredTargetPosition.lat << ", lng = " << scatteredTargetPosition.lng << ", radius = 0.01}";
+					Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
+					scheduler->appendCommand(command);
+					shellsFiredAtTasking = totalShellsFired;
+					setHasTask(true);
+				}
+				/* Otherwise use the aim method */
+				else {
+					taskString += "Simulating fire fight with aim point method. ";
+					log(unitName + "(" + name + ")" + " simulating fire fight with aim at point method");
+					string aimTaskString = aimAtPoint(scatteredTargetPosition);
+					taskString += aimTaskString;
+				}
+
+				/* Wait an amout of time depending on the shots intensity */
+				nextTaskingMilliseconds = timeNow + static_cast<unsigned long>(2 * aimTime * 1000);
+			}
+		}
+
+		if (targetPosition == Coords(NULL))
+			setState(State::IDLE);
+
+		/* Fallback if something went wrong */
+		if (timeNow >= nextTaskingMilliseconds)
+			nextTaskingMilliseconds = timeNow + static_cast<unsigned long>(3 * 1000);
+
+		setTimeToNextTasking(((nextTaskingMilliseconds - timeNow) / 1000.0));
+
+		if (taskString.length() > 0)
+			setTask(taskString);
+
+		break;
+	}
+	case State::SCENIC_AAA: {
+		string taskString = "";
+
+		/* Only perform scenic functions when the scheduler is "free" */
+		if (totalShellsFired - shellsFiredAtTasking >= shotsToFire || timeNow >= nextTaskingMilliseconds) {
+			if (scheduler->getLoad() > 100) {
+				taskString = "Excessive load, skipping tasking of unit";
+				setTargetPosition(Coords(NULL));
+				if (getHasTask())
+					resetTask();
+			}
+			else {
+				double distance = 0;
+				unsigned char unitCoalition = coalition == 0 ? getOperateAs() : coalition;
+				unsigned char targetCoalition = unitCoalition == 2 ? 1 : 2;
+				Unit* target = unitsManager->getClosestUnit(this, targetCoalition, { "Aircraft", "Helicopter" }, distance);
+
+				/* Recover the data from the database */
+				bool flak = false;
+				if (database.has_object_field(to_wstring(name))) {
+					json::value databaseEntry = database[to_wstring(name)];
+					if (databaseEntry.has_boolean_field(L"flak"))
+						flak = databaseEntry[L"flak"].as_bool();
+				}
+
+				/* Only run if an enemy air unit is closer than 20km to avoid useless load */
+				double activationDistance = 20000;
+				if (2 * engagementRange > activationDistance)
+					activationDistance = 2 * engagementRange;
+
+				if (target != nullptr && distance < activationDistance /* m */) {
+					double r = 15; /* m */
+					double barrelElevation = position.alt + barrelHeight + r * tan(acos(((double)(rand()) / (double)(RAND_MAX))));
+
+					double lat = 0;
+					double lng = 0;
+					double randomBearing = ((double)(rand()) / (double)(RAND_MAX)) * 360;
+					Geodesic::WGS84().Direct(position.lat, position.lng, randomBearing, r, lat, lng);
+
+					if (flak) {
+						lat = position.lat + RANDOM_MINUS_ONE_TO_ONE * (1 + (ShotsScatter::LOW - shotsScatter)) * 0.01;
+						lng = position.lng + RANDOM_MINUS_ONE_TO_ONE * (1 + (ShotsScatter::LOW - shotsScatter)) * 0.01;
+						barrelElevation = target->getPosition().alt + RANDOM_MINUS_ONE_TO_ONE * (ShotsScatter::LOW - shotsScatter) * 1000;
+						taskString += "Flak box mode";
+					}
+					else {
+						taskString += "Scenic AAA. Bearing: " + to_string((int)round(randomBearing)) + "deg";
+					}
+
+					taskString += ". Aim point elevation " + to_string((int)round(barrelElevation - position.alt)) + "m AGL";
+
+					std::ostringstream taskSS;
+					taskSS.precision(10);
+					taskSS << "{id = 'FireAtPoint', lat = " << lat << ", lng = " << lng << ", alt = " << barrelElevation << ", radius = 0.001 }";
+					Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
+					scheduler->appendCommand(command);
+					shellsFiredAtTasking = totalShellsFired;
+					setHasTask(true);
+
+					/* Wait an amout of time depending on the shots intensity */
+					nextTaskingMilliseconds = timeNow + static_cast<unsigned long>(2 * aimTime * 1000);
+				}
+				else {
+					setTargetPosition(Coords(NULL));
+					if (target == nullptr)
+						taskString += "Scenic AAA. No valid target.";
+					else
+						taskString += "Scenic AAA. Target outside max range: " + to_string((int)round(distance)) + "m.";
+
+					if (getHasTask())
+						resetTask();
+				}
+			}
+		}
+
+		if (timeNow >= nextTaskingMilliseconds)
+			nextTaskingMilliseconds = timeNow + static_cast<unsigned long>(3 * 1000);
+
+		setTimeToNextTasking((nextTaskingMilliseconds - timeNow) / 1000.0);
+		if (taskString.length() > 0)
+			setTask(taskString);
+
+		break;
+	}
+	case State::MISS_ON_PURPOSE: {
+		string taskString = "";
+
+		/* Check that the unit can perform AAA duties */
+		bool canAAA = false;
+		if (database.has_object_field(to_wstring(name))) {
+			json::value databaseEntry = database[to_wstring(name)];
+			if (databaseEntry.has_boolean_field(L"canAAA"))
+				canAAA = databaseEntry[L"canAAA"].as_bool();
+		}
+
+		/* Recover the data from the database */
+		bool flak = false;
+		if (database.has_object_field(to_wstring(name))) {
+			json::value databaseEntry = database[to_wstring(name)];
+			if (databaseEntry.has_boolean_field(L"flak"))
+				flak = databaseEntry[L"flak"].as_bool();
+		}
+
+		if (canAAA) {
+			/* Only perform scenic functions when the scheduler is "free" */
+			/* Only run this when the internal counter reaches 0 to avoid excessive computations when no nearby target */
+			if (totalShellsFired - shellsFiredAtTasking >= shotsToFire || timeNow >= nextTaskingMilliseconds) {
+				if (scheduler->getLoad() > 100) {
+					taskString = "Excessive load, skipping tasking of unit";
+					setTargetPosition(Coords(NULL));
+					if (getHasTask())
+						resetTask();
+				}
+				else {
+					double distance = 0;
+					unsigned char unitCoalition = coalition == 0 ? getOperateAs() : coalition;
+					unsigned char targetCoalition = unitCoalition == 2 ? 1 : 2;
+
+					/* Get all the units in range and select one at random */
+					double range = max(max(engagementRange, aimMethodRange), acquisitionRange);
+					map<Unit*, double> targets = unitsManager->getUnitsInRange(this, targetCoalition, { "Aircraft", "Helicopter" }, range);
+
+					Unit* target = nullptr;
+					unsigned int index = static_cast<unsigned int>((RANDOM_ZERO_TO_ONE * (targets.size() - 1)));
+					for (auto const& p : targets) {
+						if (index-- == 0) {
+							target = p.first;
+							distance = p.second;
+						}
+					}
+
+					/* Only do if we have a valid target close enough for AAA */
+					if (target != nullptr) {
+						taskString += "Missing on purpose. Valid target at range: " + to_string((int)round(distance)) + "m";
+
+						// Very simplified algorithm ignoring drag
+						double correctedAimTime = aimTime + distance / muzzleVelocity;
+
+						/* If the target is in targeting range and we are in highest precision mode, target it */
+						if (distance < targetingRange && shotsScatter == ShotsScatter::LOW) {
+							taskString += ". Range is less than targeting range (" + to_string((int)round(targetingRange)) + "m) and scatter is LOW, aiming at target.";
+
+							/* Send the command */
+							std::ostringstream taskSS;
+							taskSS.precision(10);
+							taskSS << "{id = 'AttackUnit', unitID = " << target->getID() << " }";
+							Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
+							scheduler->appendCommand(command);
+							shellsFiredAtTasking = totalShellsFired;
+							setHasTask(true);
+
+							nextTaskingMilliseconds = timeNow + static_cast<unsigned long>(2 * aimTime * 1000);
+						}
+						/* Else, do miss on purpose */
+						else {
+							/* Compute where the target will be in aimTime seconds. */
+							double aimDistance = target->getHorizontalVelocity() * correctedAimTime;
+							double aimLat = 0;
+							double aimLng = 0;
+							Geodesic::WGS84().Direct(target->getPosition().lat, target->getPosition().lng, target->getTrack() * 57.29577, aimDistance, aimLat, aimLng); /* TODO make util to convert degrees and radians function */
+							double aimAlt = target->getPosition().alt + target->getVerticalVelocity();
+
+							if (flak) {
+								aimLat += RANDOM_MINUS_ONE_TO_ONE * (1 + (ShotsScatter::LOW - shotsScatter)) * 0.01;
+								aimLng += RANDOM_MINUS_ONE_TO_ONE * (1 + (ShotsScatter::LOW - shotsScatter)) * 0.01;
+								aimAlt += RANDOM_MINUS_ONE_TO_ONE * (1 + (ShotsScatter::LOW - shotsScatter)) * 1000;
+							}
+
+							/* Send the command */
+							if (distance < engagementRange) {
+								taskString += ". Range is less than engagement range (" + to_string((int)round(engagementRange)) + "m), using FIRE AT POINT method";
+
+								/* If the unit is closer than the engagement range, use the fire at point method */
+								std::ostringstream taskSS;
+								taskSS.precision(10);
+								taskSS << "{id = 'FireAtPoint', lat = " << aimLat << ", lng = " << aimLng << ", alt = " << aimAlt << ", radius = 0.001 }";
+
+								taskString += ". Aiming altitude " + to_string((int)round((aimAlt - position.alt) / 0.3048)) + "ft AGL";
+								Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
+								scheduler->appendCommand(command);
+								shellsFiredAtTasking = totalShellsFired;
+								setHasTask(true);
+								setTargetPosition(Coords(aimLat, aimLng, target->getPosition().alt));
+								nextTaskingMilliseconds = timeNow + static_cast<unsigned long>(2 * aimTime * 1000);
+							}
+							else if (distance < aimMethodRange) {
+								taskString += ". Range is less than aim method range (" + to_string((int)round(aimMethodRange / 0.3048)) + "ft), using AIM method.";
+
+								/* If the unit is closer than the aim method range, use the aim method range */
+								string aimMethodTask = aimAtPoint(Coords(aimLat, aimLng, aimAlt));
+								taskString += aimMethodTask;
+
+								setTargetPosition(Coords(aimLat, aimLng, target->getPosition().alt));
+								nextTaskingMilliseconds = timeNow + static_cast<unsigned long>(2 * aimTime * 1000);
+							}
+							else {
+								taskString += ". Target is not in range of weapon, waking up unit to get ready for tasking.";
+
+								/* Else just wake the unit up with an impossible command */
+								std::ostringstream taskSS;
+								taskSS.precision(10);
+								taskSS << "{id = 'FireAtPoint', lat = " << 0 << ", lng = " << 0 << ", alt = " << 0 << ", radius = 0.001, expendQty = " << 0 << " }";
+								Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
+								scheduler->appendCommand(command);
+								shellsFiredAtTasking = totalShellsFired;
+								setHasTask(true);
+								setTargetPosition(Coords(NULL));
+
+								/* Don't wait too long before checking again */
+								nextTaskingMilliseconds = timeNow + static_cast<unsigned long>(5 * 1000);
+							}
+						}
+						missOnPurposeTarget = target;
+					}
+					else {
+						taskString += "Missing on purpose. No target in range.";
+						setTargetPosition(Coords(NULL));
+						if (getHasTask())
+							resetTask();
+					}
+				}
+			}
+
+			/* If no valid target was detected */
+			if (timeNow >= nextTaskingMilliseconds) {
+				double alertnessTimeConstant = 10; /* s */
+				if (database.has_object_field(to_wstring(name))) {
+					json::value databaseEntry = database[to_wstring(name)];
+					if (databaseEntry.has_number_field(L"alertnessTimeConstant"))
+						alertnessTimeConstant = databaseEntry[L"alertnessTimeConstant"].as_number().to_double();
+				}
+				nextTaskingMilliseconds = timeNow + static_cast<unsigned long>((5 + RANDOM_ZERO_TO_ONE * alertnessTimeConstant) * 1000L);
+				missOnPurposeTarget = nullptr;
+				setTargetPosition(Coords(NULL));
+			}
+			
+		}
+		else {
+			setState(State::IDLE);
+		}
+
+		setTimeToNextTasking((nextTaskingMilliseconds - timeNow) / 1000.0);
+
+		if (taskString.length() > 0)
+			setTask(taskString);
+
+		break;
+	}
+	default:
+		break;
+	}
+}
+
+
+string GroundUnit::aimAtPoint(Coords aimTarget) {
+	string taskString = "";
+	double dist;
+	double bearing1;
+	double bearing2;
+	Geodesic::WGS84().Inverse(position.lat, position.lng, aimTarget.lat, aimTarget.lng, dist, bearing1, bearing2);
+
+	/* Aim point distance */
+	double r = 15; /* m */
+
+	/* Compute the elevation angle of the gun*/
+	double deltaHeight = (aimTarget.alt - (position.alt + barrelHeight));
+	double alpha = 9.81 / 2 * dist * dist / (muzzleVelocity * muzzleVelocity);
+	double inner = dist * dist - 4 * alpha * (alpha + deltaHeight);
+
+	/* Check we can reach the target*/
+	if (inner > 0) {
+		/* Compute elevation and bearing */
+		double barrelElevation = r * (dist - sqrt(inner)) / (2 * alpha);
+
+		double lat = 0;
+		double lng = 0;
+		Geodesic::WGS84().Direct(position.lat, position.lng, bearing1, r, lat, lng);
+
+		taskString = +"Barrel elevation: " + to_string((int) round(barrelElevation)) + "m, bearing: " + to_string((int) round(bearing1)) + "deg";
+		log(unitName + "(" + name + ")" + " shooting with aim at point method. Barrel elevation: " + to_string(barrelElevation) + "m, bearing: " + to_string(bearing1) + "<EFBFBD>");
+
+		std::ostringstream taskSS;
+		taskSS.precision(10);
+		taskSS << "{id = 'FireAtPoint', lat = " << lat << ", lng = " << lng << ", alt = " << position.alt + barrelElevation + barrelHeight << ", radius = 0.001}";
+		Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
+		scheduler->appendCommand(command);
+		shellsFiredAtTasking = totalShellsFired;
+		setHasTask(true);
+	}
+	else {
+		log("Target out of range for " + unitName + "(" + name + ")");
+		taskString = +"Target out of range";
+	}
+
+	return taskString;
+}
+
+void GroundUnit::changeSpeed(string change)
+{
+	if (change.compare("stop") == 0)
+		setState(State::IDLE);
+	else if (change.compare("slow") == 0)
+		setDesiredSpeed(getDesiredSpeed() - knotsToMs(5));
+	else if (change.compare("fast") == 0)
+		setDesiredSpeed(getDesiredSpeed() + knotsToMs(5));
+
+	if (getDesiredSpeed() < 0)
+		setDesiredSpeed(0);
+}
+
+void GroundUnit::setOnOff(bool newOnOff, bool force) 
+{
+	if (newOnOff != onOff || force) {
+		Unit::setOnOff(newOnOff, force);
+		Command* command = dynamic_cast<Command*>(new SetOnOff(groupName, onOff));
+		scheduler->appendCommand(command);
+	}
+}
+
+void GroundUnit::setFollowRoads(bool newFollowRoads, bool force)
+{
+	if (newFollowRoads != followRoads || force) {
+		Unit::setFollowRoads(newFollowRoads, force);
+		resetActiveDestination(); /* Reset active destination to apply option*/
+	}
+}

backend/core/src/navyunit.cpp

@@ -37,13 +37,38 @@ NavyUnit::NavyUnit(json::value json, unsigned int ID) : Unit(json, ID)
 
 void NavyUnit::setDefaults(bool force)
 {
+	/* Load gun values from database */
+	if (database.has_object_field(to_wstring(name))) {
+		json::value databaseEntry = database[to_wstring(name)];
+		if (databaseEntry.has_number_field(L"barrelHeight"))
+			setBarrelHeight(databaseEntry[L"barrelHeight"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"muzzleVelocity"))
+			setMuzzleVelocity(databaseEntry[L"muzzleVelocity"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"aimTime"))
+			setAimTime(databaseEntry[L"aimTime"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"shotsToFire"))
+			setShotsToFire(databaseEntry[L"shotsToFire"].as_number().to_uint32());
+		if (databaseEntry.has_number_field(L"engagementRange"))
+			setEngagementRange(databaseEntry[L"engagementRange"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"shotsBaseInterval"))
+			setShotsBaseInterval(databaseEntry[L"shotsBaseInterval"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"shotsBaseScatter"))
+			setShotsBaseScatter(databaseEntry[L"shotsBaseScatter"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"targetingRange"))
+			setTargetingRange(databaseEntry[L"targetingRange"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"aimMethodRange"))
+			setAimMethodRange(databaseEntry[L"aimMethodRange"].as_number().to_double());
+		if (databaseEntry.has_number_field(L"acquisitionRange"))
+			setAcquisitionRange(databaseEntry[L"acquisitionRange"].as_number().to_double());
+	}
+	
 	if (!getAlive() || !getControlled() || getHuman() || !getIsLeader()) return;
 
 	/* Set the default IDLE state */
 	setState(State::IDLE);
 
 	/* Set the default options */
-	setROE(ROE::WEAPON_FREE, force);
+	setROE(ROE::OPEN_FIRE_WEAPON_FREE, force);
 	setOnOff(onOff, force);
 	setFollowRoads(followRoads, force);
 }
@@ -167,6 +192,7 @@ void NavyUnit::AIloop()
 					setState(State::IDLE);
 			}
 		}
+
 		break;
 	}
 	case State::ATTACK: {
@@ -187,6 +213,8 @@ void NavyUnit::AIloop()
 		else {
 			setState(State::IDLE);
 		}
+
+		break;
 	}
 	case State::FIRE_AT_AREA: {
 		setTask("Firing at area");
@@ -200,6 +228,8 @@ void NavyUnit::AIloop()
 			scheduler->appendCommand(command);
 			setHasTask(true);
 		}
+
+		break;
 	}
 	case State::SIMULATE_FIRE_FIGHT: {
 		setTask("Simulating fire fight");
@@ -207,6 +237,7 @@ void NavyUnit::AIloop()
 		// TODO 
 
 		setState(State::IDLE);
+		break;
 	}
 	default:
 		break;

backend/core/src/scheduler.cpp

@@ -192,8 +192,12 @@ void Scheduler::handleRequest(string key, json::value value, string username, js
 		string airbaseName = to_string(value[L"airbaseName"]);
 		string country = to_string(value[L"country"]);
 
+
 		int spawnPoints = value[L"spawnPoints"].as_number().to_int32();
-		if (!checkSpawnPoints(spawnPoints, coalition)) return;
+		if (!checkSpawnPoints(spawnPoints, coalition)) {
+			log(username + " insufficient spawn points ", true);
+			return;
+		}
 
 		vector<SpawnOptions> spawnOptions;
 		for (auto unit : value[L"units"].as_array()) {
@@ -201,12 +205,17 @@ void Scheduler::handleRequest(string key, json::value value, string username, js
 			double lat = unit[L"location"][L"lat"].as_double();
 			double lng = unit[L"location"][L"lng"].as_double();
 			double alt = unit[L"altitude"].as_double();
+			double heading = 0;
+			if (unit.has_number_field(L"heading"))
+				heading = unit[L"heading"].as_double();
+
 			Coords location; location.lat = lat; location.lng = lng; location.alt = alt;
 			string loadout = to_string(unit[L"loadout"]);
 			string liveryID = to_string(unit[L"liveryID"]);
+			string skill = to_string(unit[L"skill"]);
 
-			spawnOptions.push_back({unitType, location, loadout, liveryID});
-			log(username + " spawned a " + coalition + " " + unitType, true);
+			spawnOptions.push_back({unitType, location, loadout, skill, liveryID, heading});
+			log(username + " spawned a " + coalition + " " + unitType , true);
 		}
 
 		if (key.compare("spawnAircrafts") == 0)
@@ -222,17 +231,25 @@ void Scheduler::handleRequest(string key, json::value value, string username, js
 		string country = to_string(value[L"country"]);
 
 		int spawnPoints = value[L"spawnPoints"].as_number().to_int32();
-		if (!checkSpawnPoints(spawnPoints, coalition)) return;
+		if (!checkSpawnPoints(spawnPoints, coalition)) {
+			log(username + " insufficient spawn points ", true);
+			return;
+		}
 
 		vector<SpawnOptions> spawnOptions;
 		for (auto unit : value[L"units"].as_array()) {
 			string unitType = to_string(unit[L"unitType"]);
 			double lat = unit[L"location"][L"lat"].as_double();
 			double lng = unit[L"location"][L"lng"].as_double();
+			double heading = 0;
+			if (unit.has_number_field(L"heading"))
+				heading = unit[L"heading"].as_double();
+
 			Coords location; location.lat = lat; location.lng = lng;
 			string liveryID = to_string(unit[L"liveryID"]);
+			string skill = to_string(unit[L"skill"]);
 			
-			spawnOptions.push_back({ unitType, location, "", liveryID });
+			spawnOptions.push_back({ unitType, location, "", skill, liveryID, heading});
 			log(username + " spawned a " + coalition + " " + unitType, true);
 		}
 
@@ -342,12 +359,37 @@ void Scheduler::handleRequest(string key, json::value value, string username, js
 			unit->setDesiredAltitudeType(to_string(value[L"altitudeType"]));
 			log(username + " set " + unit->getUnitName() + "(" + unit->getName() + ") altitude type: " + to_string(value[L"altitudeType"]), true);
 		}
+	}/************************/
+	else if (key.compare("setRacetrack") == 0)
+	{
+		unsigned int ID = value[L"ID"].as_integer();
+		unitsManager->acquireControl(ID);
+		Unit* unit = unitsManager->getGroupLeader(ID);
+		if (unit != nullptr) {
+			unit->setRacetrackLength(value[L"length"].as_double());
+
+			double lat = value[L"location"][L"lat"].as_double();
+			double lng = value[L"location"][L"lng"].as_double();
+			Coords location; location.lat = lat; location.lng = lng;
+			unit->setRacetrackAnchor(location);
+
+			unit->setRacetrackBearing(value[L"bearing"].as_double());
+
+			log(username + " set " + unit->getUnitName() + "(" + unit->getName() + ")  racetrack length: " + to_string(value[L"length"].as_double()) + " racetrack bearing: " + to_string(value[L"bearing"].as_double()), true);
+		}
 	}
 	/************************/
 	else if (key.compare("cloneUnits") == 0)
 	{
 		vector<CloneOptions> cloneOptions;
 		bool deleteOriginal = value[L"deleteOriginal"].as_bool();
+		string coalition = to_string(value[L"coalition"]);
+
+		int spawnPoints = value[L"spawnPoints"].as_number().to_int32();
+		if (coalition.compare("all") != 0 && !checkSpawnPoints(spawnPoints, coalition)) {
+			log(username + " insufficient spawn points ", true);
+			return;
+		}
 
 		for (auto unit : value[L"units"].as_array()) {
 			unsigned int ID = unit[L"ID"].as_integer();
@@ -373,6 +415,19 @@ void Scheduler::handleRequest(string key, json::value value, string username, js
 			log(username + " set unit " + unit->getUnitName() + "(" + unit->getName() + ") ROE to " + to_string(ROE), true);
 		}
 	}
+	else if (key.compare("setAlarmState") == 0)
+	{
+		unsigned int ID = value[L"ID"].as_integer();
+		unitsManager->acquireControl(ID);
+		Unit* unit = unitsManager->getGroupLeader(ID);
+		if (unit != nullptr) {
+			unsigned char alarmState = value[L"alarmState"].as_number().to_uint32();
+			unit->setAlarmState(alarmState);
+			log(username + " set unit " + unit->getUnitName() + "(" + unit->getName() + ") alarm state to " + to_string(alarmState), true);
+		} else {
+			log("Error while setting setAlarmState. Unit does not exist.");
+		}
+	}
 	/************************/
 	else if (key.compare("setReactionToThreat") == 0)
 	{
@@ -480,6 +535,29 @@ void Scheduler::handleRequest(string key, json::value value, string username, js
 		}
 	}
 	/************************/
+	else if (key.compare("setEngagementProperties") == 0)
+	{
+		unsigned int ID = value[L"ID"].as_integer();
+		unitsManager->acquireControl(ID);
+		Unit* unit = unitsManager->getGroupLeader(ID);
+		if (unit != nullptr)
+		{
+			/* Engagement properties tasking */
+			unit->setBarrelHeight(value[L"barrelHeight"].as_number().to_double());
+			unit->setMuzzleVelocity(value[L"muzzleVelocity"].as_number().to_double());
+			unit->setAimTime(value[L"aimTime"].as_number().to_double());
+			unit->setShotsToFire(value[L"shotsToFire"].as_number().to_uint32());
+			unit->setShotsBaseInterval(value[L"shotsBaseInterval"].as_number().to_double());
+			unit->setShotsBaseScatter(value[L"shotsBaseScatter"].as_number().to_double());
+			unit->setEngagementRange(value[L"engagementRange"].as_number().to_double());
+			unit->setTargetingRange(value[L"targetingRange"].as_number().to_double());
+			unit->setAimMethodRange(value[L"aimMethodRange"].as_number().to_double());
+			unit->setAcquisitionRange(value[L"acquisitionRange"].as_number().to_double());
+			
+			log(username + " updated unit " + unit->getUnitName() + "(" + unit->getName() + ") engagementProperties", true);
+		}
+	}
+	/************************/
 	else if (key.compare("setFollowRoads") == 0)
 	{
 		unsigned int ID = value[L"ID"].as_integer();
@@ -567,6 +645,11 @@ void Scheduler::handleRequest(string key, json::value value, string username, js
 		double lat = value[L"location"][L"lat"].as_double();
 		double lng = value[L"location"][L"lng"].as_double();
 		Coords loc; loc.lat = lat; loc.lng = lng;
+
+		if (value[L"location"].has_number_field(L"alt")) {
+			loc.alt = value[L"location"][L"alt"].as_double();
+		}
+
 		Unit* unit = unitsManager->getGroupLeader(ID);
 		if (unit != nullptr) {
 			unit->setTargetPosition(loc);
@@ -666,6 +749,65 @@ void Scheduler::handleRequest(string key, json::value value, string username, js
 		}
 	}
 	/************************/
+	else if (key.compare("fireLaser") == 0)
+	{
+		unsigned int ID = value[L"ID"].as_integer();
+		Unit* unit = unitsManager->getUnit(ID);
+		if (unit != nullptr) {
+			double lat = value[L"location"][L"lat"].as_double();
+			double lng = value[L"location"][L"lng"].as_double();
+			Coords loc; loc.lat = lat; loc.lng = lng;
+			unsigned int code = value[L"code"].as_integer();
+
+			log("Firing laser with code " + to_string(code) + " from unit " + unit->getUnitName() + " to (" + to_string(lat) + ", " + to_string(lng) + ")");
+
+			command = dynamic_cast<Command*>(new FireLaser(ID, code, loc));
+		}
+	}
+	/************************/
+	else if (key.compare("fireInfrared") == 0)
+	{
+		unsigned int ID = value[L"ID"].as_integer();
+		Unit* unit = unitsManager->getUnit(ID);
+		if (unit != nullptr) {
+			double lat = value[L"location"][L"lat"].as_double();
+			double lng = value[L"location"][L"lng"].as_double();
+			Coords loc; loc.lat = lat; loc.lng = lng;
+
+			log("Firing infrared from unit " + unit->getUnitName() + " to (" + to_string(lat) + ", " + to_string(lng) + ")");
+
+			command = dynamic_cast<Command*>(new FireInfrared(ID, loc));
+		}
+	}
+	/************************/
+	else if (key.compare("setLaserCode") == 0)
+	{
+		unsigned int spotID = value[L"spotID"].as_integer();
+		unsigned int code = value[L"code"].as_integer();
+
+		log("Setting laser code " + to_string(code) + " to spot with ID " + to_string(spotID));
+		command = dynamic_cast<Command*>(new SetLaserCode(spotID, code));
+	}
+	/************************/
+	else if (key.compare("moveSpot") == 0)
+	{
+		unsigned int spotID = value[L"spotID"].as_integer();
+
+		double lat = value[L"location"][L"lat"].as_double();
+		double lng = value[L"location"][L"lng"].as_double();
+		Coords loc; loc.lat = lat; loc.lng = lng;
+
+		log("Moving spot with ID " + to_string(spotID) + " to (" + to_string(lat) + ", " + to_string(lng) + ")");
+		command = dynamic_cast<Command*>(new MoveSpot(spotID, loc));
+	}
+	/************************/
+	else if (key.compare("deleteSpot") == 0)
+	{
+		unsigned int spotID = value[L"spotID"].as_integer();
+		log("Deleting spot with ID " + to_string(spotID));
+		command = dynamic_cast<Command*>(new DeleteSpot(spotID));
+	}
+	/************************/
 	else if (key.compare("setCommandModeOptions") == 0) 
 	{
 		setCommandModeOptions(value);

backend/core/src/scriptloader.cpp

@@ -2,6 +2,7 @@
 #include "logger.h"
 #include "luatools.h"
 #include "dcstools.h"
+#include "defines.h"
 
 #include <algorithm>
 
@@ -38,9 +39,9 @@ void registerLuaFunctions(lua_State* L)
         log("protectedCall registered successfully");
     }
 
-    executeLuaScript(L, instancePath + "..\\Scripts\\mist.lua");
-    executeLuaScript(L, instancePath + "..\\Scripts\\OlympusCommand.lua");
-    executeLuaScript(L, instancePath + "..\\Scripts\\unitPayloads.lua");
-    executeLuaScript(L, instancePath + "..\\Scripts\\templates.lua");
-    executeLuaScript(L, instancePath + "..\\Scripts\\mods.lua");
+    executeLuaScript(L, instancePath + MIST_SCRIPT);
+    executeLuaScript(L, instancePath + OLYMPUS_COMMAND_SCRIPT);
+    executeLuaScript(L, instancePath + UNIT_PAYLOADS_SCRIPT);
+    executeLuaScript(L, instancePath + TEMPLATES_SCRIPT);
+    executeLuaScript(L, instancePath + MODS_SCRIPT);
 }

backend/core/src/server.cpp

@@ -17,6 +17,7 @@ extern UnitsManager* unitsManager;
 extern WeaponsManager* weaponsManager;
 extern Scheduler* scheduler;
 extern json::value missionData;
+extern json::value drawingsByLayer;
 extern mutex mutexLock;
 extern string sessionHash;
 extern string instancePath;
@@ -128,6 +129,9 @@ void Server::handle_get(http_request request)
                     /* Bullseyes data */
                     else if (URI.compare(BULLSEYE_URI) == 0 && missionData.has_object_field(L"bullseyes")) 
                         answer[L"bullseyes"] = missionData[L"bullseyes"];
+                    /* Spots (laser/IR) data */
+                    else if (URI.compare(SPOTS_URI) == 0 && missionData.has_object_field(L"spots"))
+                        answer[L"spots"] = missionData[L"spots"];
                     /* Mission data */
                     else if (URI.compare(MISSION_URI) == 0 && missionData.has_object_field(L"mission")) {
                         answer[L"mission"] = missionData[L"mission"];
@@ -146,6 +150,10 @@ void Server::handle_get(http_request request)
                     else if (URI.compare(COMMANDS_URI) == 0 && query.find(L"commandHash") != query.end()) {
                         answer[L"commandExecuted"] = json::value(scheduler->isCommandExecuted(to_string(query[L"commandHash"])));
                     }
+                    /* Drawings data*/
+                    else if (URI.compare(DRAWINGS_URI) == 0 && drawingsByLayer.has_object_field(L"drawings")) {
+                        answer[L"drawings"] = drawingsByLayer[L"drawings"];
+                    }
                     
                     /* Common data */
                     answer[L"time"] = json::value::string(to_wstring(ms.count()));
@@ -296,14 +304,14 @@ void Server::task()
     ss << ifstream.rdbuf();
     std::error_code errorCode;
     json::value config = json::value::parse(ss.str(), errorCode);
-    if (config.is_object() && config.has_object_field(L"server") &&
-        config[L"server"].has_string_field(L"address") && config[L"server"].has_number_field(L"port"))
+    if (config.is_object() && config.has_object_field(L"backend") &&
+        config[L"backend"].has_string_field(L"address") && config[L"backend"].has_number_field(L"port"))
     {
-        address = "http://" + to_string(config[L"server"][L"address"]) + ":" + to_string(config[L"server"][L"port"].as_number().to_int32());
-        log("Starting server on " + address);
+        address = "http://" + to_string(config[L"backend"][L"address"]) + ":" + to_string(config[L"backend"][L"port"].as_number().to_int32());
+        log("Starting backend on " + address);
     }
     else
-        log("Error reading configuration file. Starting server on " + address);
+        log("Error reading configuration file. Starting backend on " + address);
 
     if (config.is_object() && config.has_object_field(L"authentication"))
     {

backend/core/src/unit.cpp

@@ -28,25 +28,6 @@ Unit::~Unit()
 
 void Unit::initialize(json::value json)
 {
-	if (json.has_string_field(L"name"))
-		setName(to_string(json[L"name"]));
-
-	if (json.has_string_field(L"unitName"))
-		setUnitName(to_string(json[L"unitName"]));
-
-	if (json.has_string_field(L"groupName"))
-		setGroupName(to_string(json[L"groupName"]));
-
-	if (json.has_number_field(L"coalitionID"))
-		setCoalition(json[L"coalitionID"].as_number().to_int32());
-
-	//if (json.has_number_field(L"Country"))
-	//	setCountry(json[L"Country"].as_number().to_int32());
-
-	/* All units which contain the name "Olympus" are automatically under AI control */
-	if (getUnitName().find("Olympus") != string::npos)
-		setControlled(true);
-
 	update(json, 0);
 	setDefaults();
 }
@@ -54,6 +35,32 @@ void Unit::initialize(json::value json)
 
 void Unit::update(json::value json, double dt)
 {
+	if (json.has_string_field(L"name"))
+		setName(to_string(json[L"name"]));
+
+	if (json.has_string_field(L"unitName"))
+		setUnitName(to_string(json[L"unitName"]));
+
+	if (json.has_number_field(L"groupID"))
+		setGroupID(json[L"groupID"].as_number().to_uint32());
+	if (json.has_number_field(L"unitID"))
+		setUnitID(json[L"unitID"].as_number().to_uint32());
+
+	if (json.has_string_field(L"groupName"))
+		setGroupName(to_string(json[L"groupName"]));
+
+	if (json.has_string_field(L"callsign"))
+		setCallsign(to_string(json[L"callsign"]));
+
+	if (json.has_number_field(L"coalitionID"))
+		setCoalition(json[L"coalitionID"].as_number().to_int32());
+	if (json.has_number_field(L"country"))
+		setCountry(json[L"country"].as_number().to_int32());
+	
+	/* All units which contain the name "Olympus" are automatically under AI control */
+	if (getUnitName().find("Olympus") != string::npos)
+		setControlled(true);
+
 	if (json.has_object_field(L"position"))
 	{
 		setPosition({
@@ -81,6 +88,9 @@ void Unit::update(json::value json, double dt)
 	if (json.has_boolean_field(L"isAlive"))
 		setAlive(json[L"isAlive"].as_bool());
 
+	if (json.has_boolean_field(L"radarState")) 
+		setRadarState(json[L"radarState"].as_bool());
+
 	if (json.has_boolean_field(L"isHuman"))
 		setHuman(json[L"isHuman"].as_bool());
 
@@ -143,12 +153,15 @@ void Unit::update(json::value json, double dt)
 	if (json.has_number_field(L"health"))
 		setHealth(static_cast<unsigned char>(json[L"health"].as_number().to_uint32()));
 
+	if (json.has_boolean_field(L"airborne"))
+		setAirborne(json[L"airborne"].as_bool());
+
 	runAILoop();
 }
 
 void Unit::setDefaults(bool force)
 {
-
+	setAlarmState(AlarmState::AUTO, force);
 }
 
 void Unit::runAILoop() {
@@ -206,6 +219,7 @@ void Unit::refreshLeaderData(unsigned long long time) {
 					case DataIndex::operateAs:					updateValue(operateAs, leader->operateAs, datumIndex); break;
 					case DataIndex::shotsScatter:				updateValue(shotsScatter, leader->shotsScatter, datumIndex); break;
 					case DataIndex::shotsIntensity:				updateValue(shotsIntensity, leader->shotsIntensity, datumIndex); break;
+					case DataIndex::alarmState:					updateValue(alarmState, leader->alarmState, datumIndex); break;
 					}
 				}
 			}
@@ -241,6 +255,8 @@ void Unit::getData(stringstream& ss, unsigned long long time)
 		appendString(ss, datumIndex, category);
 		datumIndex = DataIndex::alive;
 		appendNumeric(ss, datumIndex, alive);
+		datumIndex = DataIndex::unitID;
+		appendNumeric(ss, datumIndex, unitID);
 	}
 	else {
 		for (unsigned char datumIndex = DataIndex::startOfData + 1; datumIndex < DataIndex::lastIndex; datumIndex++)
@@ -249,12 +265,17 @@ void Unit::getData(stringstream& ss, unsigned long long time)
 				switch (datumIndex) {
 					case DataIndex::category:					appendString(ss, datumIndex, category); break;
 					case DataIndex::alive:						appendNumeric(ss, datumIndex, alive); break;
+					case DataIndex::alarmState:					appendNumeric(ss, datumIndex, alarmState); break;
+					case DataIndex::radarState:					appendNumeric(ss, datumIndex, radarState); break;
 					case DataIndex::human:						appendNumeric(ss, datumIndex, human); break;
 					case DataIndex::controlled:					appendNumeric(ss, datumIndex, controlled); break;
 					case DataIndex::coalition:					appendNumeric(ss, datumIndex, coalition); break;
 					case DataIndex::country:					appendNumeric(ss, datumIndex, country); break;
 					case DataIndex::name:						appendString(ss, datumIndex, name); break;
 					case DataIndex::unitName:					appendString(ss, datumIndex, unitName); break;
+					case DataIndex::callsign:					appendString(ss, datumIndex, callsign); break;
+					case DataIndex::unitID:						appendNumeric(ss, datumIndex, unitID); break;
+					case DataIndex::groupID:					appendNumeric(ss, datumIndex, groupID); break;
 					case DataIndex::groupName:					appendString(ss, datumIndex, groupName); break;
 					case DataIndex::state:						appendNumeric(ss, datumIndex, state); break;
 					case DataIndex::task:						appendString(ss, datumIndex, task); break;
@@ -292,6 +313,21 @@ void Unit::getData(stringstream& ss, unsigned long long time)
 					case DataIndex::shotsScatter:				appendNumeric(ss, datumIndex, shotsScatter); break;
 					case DataIndex::shotsIntensity:				appendNumeric(ss, datumIndex, shotsIntensity); break;
 					case DataIndex::health:						appendNumeric(ss, datumIndex, health); break;
+					case DataIndex::racetrackLength:			appendNumeric(ss, datumIndex, racetrackLength); break;
+					case DataIndex::racetrackAnchor:			appendNumeric(ss, datumIndex, racetrackAnchor); break;
+					case DataIndex::racetrackBearing:			appendNumeric(ss, datumIndex, racetrackBearing); break;
+					//case DataIndex::timeToNextTasking:			appendNumeric(ss, datumIndex, timeToNextTasking); break;	Useful for debugging, but useless in production and very data hungry
+					case DataIndex::barrelHeight:				appendNumeric(ss, datumIndex, barrelHeight); break;
+					case DataIndex::muzzleVelocity:				appendNumeric(ss, datumIndex, muzzleVelocity); break;
+					case DataIndex::aimTime:					appendNumeric(ss, datumIndex, aimTime); break;
+					case DataIndex::shotsToFire:				appendNumeric(ss, datumIndex, shotsToFire); break;
+					case DataIndex::shotsBaseInterval:			appendNumeric(ss, datumIndex, shotsBaseInterval); break;
+					case DataIndex::shotsBaseScatter:			appendNumeric(ss, datumIndex, shotsBaseScatter); break;
+					case DataIndex::engagementRange:			appendNumeric(ss, datumIndex, engagementRange); break;
+					case DataIndex::targetingRange:				appendNumeric(ss, datumIndex, targetingRange); break;
+					case DataIndex::aimMethodRange:				appendNumeric(ss, datumIndex, aimMethodRange); break;
+					case DataIndex::acquisitionRange:			appendNumeric(ss, datumIndex, acquisitionRange); break;
+					case DataIndex::airborne:					appendNumeric(ss, datumIndex, airborne); break;
 				}
 			}
 		}
@@ -450,6 +486,17 @@ void Unit::setROE(unsigned char newROE, bool force)
 	}
 }
 
+void Unit::setAlarmState(unsigned char newAlarmState, bool force)
+{
+	if (alarmState != newAlarmState || force) {
+		alarmState = newAlarmState;
+		Command* command = dynamic_cast<Command*>(new SetOption(groupName, SetCommandType::ALARM_STATE, static_cast<unsigned int>(newAlarmState)));
+		scheduler->appendCommand(command);
+
+		triggerUpdate(DataIndex::alarmState);
+	}
+}
+
 void Unit::setReactionToThreat(unsigned char newReactionToThreat, bool force)
 {
 	if (reactionToThreat != newReactionToThreat || force) {
@@ -808,3 +855,11 @@ void Unit::setHasTaskAssigned(bool newHasTaskAssigned) {
 void Unit::triggerUpdate(unsigned char datumIndex) {
 	updateTimeMap[datumIndex] = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
 }
+
+unsigned int Unit::computeTotalAmmo()
+{
+	unsigned int totalShells = 0;
+	for (auto const& ammoItem : ammo)
+		totalShells += ammoItem.quantity;
+	return totalShells;
+}

backend/core/src/unitsmanager.cpp

@@ -151,7 +151,7 @@ void UnitsManager::deleteUnit(unsigned int ID, bool explosion, string explosionT
 	}
 }
 
-Unit* UnitsManager::getClosestUnit(Unit* unit, unsigned char coalition, vector<string> categories, double &distance) {
+Unit* UnitsManager::getClosestUnit(Unit* unit, unsigned char coalition, vector<string> categories, double &distance, bool airborneOnly) {
 	Unit* closestUnit = nullptr;
 	distance = 0;
 
@@ -167,6 +167,9 @@ Unit* UnitsManager::getClosestUnit(Unit* unit, unsigned char coalition, vector<s
 
 		/* Check if the unit belongs to the desired coalition, is alive, and is of the category requested */
 		if (requestedCategory && p.second->getCoalition() == coalition && p.second->getAlive()) {
+			/* Check if the unit is airborne */
+			if (airborneOnly && !p.second->getAirborne())
+				continue;
 			/* Compute the distance from the unit to the tested unit */
 			double dist;
 			double bearing1;
@@ -194,10 +197,13 @@ Unit* UnitsManager::getClosestUnit(Unit* unit, unsigned char coalition, vector<s
 	return closestUnit;
 }
 
-map<Unit*, double> UnitsManager::getUnitsInRange(Unit* unit, unsigned char coalition, vector<string> categories, double range) {
+map<Unit*, double> UnitsManager::getUnitsInRange(Unit* unit, unsigned char coalition, vector<string> categories, double range, bool airborneOnly) {
 	map<Unit*, double> unitsInRange;
 
 	for (auto const& p : units) {
+		if (airborneOnly && !p.second->getAirborne())
+			continue;			
+
 		/* Check if the units category is of the correct type */
 		bool requestedCategory = false;
 		for (auto const& category : categories) {

backend/core/src/weapon.cpp

@@ -113,4 +113,11 @@ Bomb::Bomb(json::value json, unsigned int ID) : Weapon(json, ID)
 {
 	log("New Bomb created with ID: " + to_string(ID));
 	setCategory("Bomb");
+};
+
+/* Shell */
+Shell::Shell(json::value json, unsigned int ID) : Weapon(json, ID)
+{
+	log("New Shell created with ID: " + to_string(ID));
+	setCategory("Shell");
 };

backend/core/src/weaponsmanager.cpp

@@ -41,6 +41,8 @@ void WeaponsManager::update(json::value& json, double dt)
 					weapons[ID] = dynamic_cast<Weapon*>(new Missile(p.second, ID));
 				else if (category.compare("Bomb") == 0)
 					weapons[ID] = dynamic_cast<Weapon*>(new Bomb(p.second, ID));
+				else if (category.compare("Shell") == 0)
+					weapons[ID] = dynamic_cast<Weapon*>(new Shell(p.second, ID));
 
 				/* Initialize the weapon if creation was successfull */
 				if (weapons.count(ID) != 0) {

backend/dcstools/dcstools.rc

@@ -61,8 +61,8 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_UK
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
- PRODUCTVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
+ FILEVERSION 2,0,0,0
+ PRODUCTVERSION 1,0,3,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -79,12 +79,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "DCS Olympus"
             VALUE "FileDescription", "DCS Olympus"
-            VALUE "FileVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "FileVersion", "2.0.0.0"
             VALUE "InternalName", "dcstools.dll"
             VALUE "LegalCopyright", "Copyright (C) 2023"
             VALUE "OriginalFilename", "dcstools.dll"
             VALUE "ProductName", "DCS Olympus"
-            VALUE "ProductVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "ProductVersion", "2.0.0.0"
         END
     END
     BLOCK "VarFileInfo"

backend/dcstools/dcstools.vcxproj

@@ -77,23 +77,23 @@
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <OutDir>.\..\..\bin\</OutDir>
+    <OutDir>.\..\..\build\backend\bin\</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>

backend/logger/include/interface.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "framework.h"
 
+void DllExport setLogDirectory(std::string m_dirPath);
 void DllExport log(const std::string& sMessage, bool addToJSON = false);
 void DllExport log(const std::wstring& sMessage, bool addToJSON = false);
 void DllExport getLogsJSON(json::value& json, unsigned long long time);

backend/logger/include/logger.h

@@ -8,6 +8,7 @@ public:
     void log(const string& sMessage, bool addToJSON);
     void log(const wstring& sMessage, bool addToJSON);
     void toJSON(json::value& json, unsigned long long time);
+    void setDirectory(string newDirPath);
 
     static Logger* GetLogger();
 
@@ -20,9 +21,11 @@ private:
     static Logger* m_pThis;
     static ofstream m_Logfile;
     static std::map<unsigned long long, std::string> m_logs;
+    static string m_dirPath;
 
     mutex mutexLock;
 
+    void Clear();
     void Open();
     void Close();
 };

backend/logger/logger.rc

@@ -61,8 +61,8 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_UK
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
- PRODUCTVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
+ FILEVERSION 2,0,0,0
+ PRODUCTVERSION 1,0,3,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -79,12 +79,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "DCS Olympus"
             VALUE "FileDescription", "DCS Olympus"
-            VALUE "FileVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "FileVersion", "2.0.0.0"
             VALUE "InternalName", "logger.dll"
             VALUE "LegalCopyright", "Copyright (C) 2023"
             VALUE "OriginalFilename", "logger.dll"
             VALUE "ProductName", "DCS Olympus"
-            VALUE "ProductVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "ProductVersion", "2.0.0.0"
         END
     END
     BLOCK "VarFileInfo"

backend/logger/logger.vcxproj

@@ -76,23 +76,23 @@
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <OutDir>.\..\..\bin\</OutDir>
+    <OutDir>.\..\..\build\backend\bin\</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>

backend/logger/src/interface.cpp

@@ -4,6 +4,11 @@
 
 #define LOGGER Logger::GetLogger()
 
+void setLogDirectory(string m_dirPath) 
+{
+	LOGGER->setDirectory(m_dirPath);
+}
+
 void log(const string& message, bool addToJSON)
 {
 	LOGGER->log(message, addToJSON);

backend/logger/src/logger.cpp

@@ -8,25 +8,51 @@ const string Logger::m_sFileName = LOG_NAME;
 Logger* Logger::m_pThis = NULL;
 ofstream Logger::m_Logfile;
 std::map<unsigned long long, std::string> Logger::m_logs;
+std::string Logger::m_dirPath;
 
 Logger::Logger()
 {
 
 }
+
 Logger* Logger::GetLogger()
 {
     if (m_pThis == NULL) {
         m_pThis = new Logger();
-        std::filesystem::path dirPath = std::filesystem::temp_directory_path();
-        m_Logfile.open((dirPath.string() + m_sFileName).c_str(), ios::out);
+        m_pThis->Clear();
     }
     return m_pThis;
 }
 
+void Logger::setDirectory(string newDirPath)
+{
+    m_dirPath = newDirPath;
+    Clear();
+}
+
+void Logger::Clear()
+{
+    lock_guard<mutex> guard(mutexLock);
+    try {
+        m_Logfile.open((m_dirPath + m_sFileName).c_str(), ios::out | ios::trunc);
+    }
+    catch (...) {
+        std::filesystem::path m_dirPath = std::filesystem::temp_directory_path();
+        m_Logfile.open((m_dirPath.string() + m_sFileName).c_str(), ios::out | ios::trunc);
+    }
+    m_Logfile << "Creating a new log instance\n";
+    m_pThis->Close();
+}
+
 void Logger::Open()
 {
-    std::filesystem::path dirPath = std::filesystem::temp_directory_path();
-    m_Logfile.open((dirPath.string() + m_sFileName).c_str(), ios::out | ios::app);
+    try {
+        m_Logfile.open((m_dirPath + m_sFileName).c_str(), ios::out | std::ios::app);
+    }
+    catch (...) {
+        std::filesystem::path m_dirPath = std::filesystem::temp_directory_path();
+        m_Logfile.open((m_dirPath.string() + m_sFileName).c_str(), ios::out | std::ios::app);
+    }
 }
 
 void Logger::Close()

backend/luatools/luatools.rc

@@ -61,8 +61,8 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_UK
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
- PRODUCTVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
+ FILEVERSION 2,0,0,0
+ PRODUCTVERSION 1,0,3,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -79,12 +79,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "DCS Olympus"
             VALUE "FileDescription", "DCS Olympus"
-            VALUE "FileVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "FileVersion", "2.0.0.0"
             VALUE "InternalName", "luatools.dll"
             VALUE "LegalCopyright", "Copyright (C) 2023"
             VALUE "OriginalFilename", "luatools.dll"
             VALUE "ProductName", "DCS Olympus"
-            VALUE "ProductVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "ProductVersion", "2.0.0.0"
         END
     END
     BLOCK "VarFileInfo"

backend/luatools/luatools.vcxproj

@@ -60,23 +60,23 @@
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <OutDir>.\..\..\bin\</OutDir>
+    <OutDir>.\..\..\build\backend\bin\</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>

backend/olympus/olympus.rc

@@ -61,8 +61,8 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_UK
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
- PRODUCTVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
+ FILEVERSION 2,0,0,0
+ PRODUCTVERSION 1,0,3,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -79,12 +79,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "DCS Olympus"
             VALUE "FileDescription", "DCS Olympus"
-            VALUE "FileVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "FileVersion", "2.0.0.0"
             VALUE "InternalName", "olympus.dll"
             VALUE "LegalCopyright", "Copyright (C) 2023"
             VALUE "OriginalFilename", "olympus.dll"
             VALUE "ProductName", "DCS Olympus"
-            VALUE "ProductVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "ProductVersion", "2.0.0.0"
         END
     END
     BLOCK "VarFileInfo"

backend/olympus/olympus.vcxproj

@@ -62,11 +62,11 @@
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-	<Import Project="..\DCSOlympus.props" />
+    <Import Project="..\DCSOlympus.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -75,7 +75,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
-    <OutDir>.\..\..\bin\</OutDir>
+    <OutDir>.\..\..\build\backend\bin\</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>

backend/olympus/src/olympus.cpp

@@ -11,12 +11,14 @@ typedef int(__stdcall* f_coreFrame)(lua_State* L);
 typedef int(__stdcall* f_coreUnitsData)(lua_State* L);
 typedef int(__stdcall* f_coreWeaponsData)(lua_State* L);
 typedef int(__stdcall* f_coreMissionData)(lua_State* L);
+typedef int(__stdcall* f_coreDrawingsData)(lua_State* L);
 f_coreInit coreInit = nullptr;
 f_coreDeinit coreDeinit = nullptr;
 f_coreFrame coreFrame = nullptr;
 f_coreUnitsData coreUnitsData = nullptr;
 f_coreWeaponsData coreWeaponsData = nullptr;
 f_coreMissionData coreMissionData = nullptr;
+f_coreDrawingsData coreDrawingsData = nullptr;
 
 string modPath;
 
@@ -49,6 +51,9 @@ static int onSimulationStart(lua_State* L)
 {
     LogInfo(L, "Trying to load core.dll from " + modPath);
     SetDllDirectoryA(modPath.c_str());
+
+    setLogDirectory(modPath);
+
     log("onSimulationStart callback called successfully");
 
     string dllLocation = modPath + "\\core.dll";
@@ -105,6 +110,13 @@ static int onSimulationStart(lua_State* L)
         goto error;
     }
 
+    coreDrawingsData = (f_coreDrawingsData)GetProcAddress(hGetProcIDDLL, "coreDrawingsData");
+    if (!coreDrawingsData)
+    {
+        LogError(L, "Error getting coreDrawingsData ProcAddress from DLL");
+        goto error;
+    }
+
     coreInit(L, modPath.c_str());
 
     LogInfo(L, "Module loaded and started successfully.");
@@ -152,6 +164,8 @@ static int onSimulationStop(lua_State* L)
         coreUnitsData = nullptr;
         coreWeaponsData = nullptr;
         coreMissionData = nullptr;
+
+        coreDrawingsData = nullptr;
     }
 
     hGetProcIDDLL = NULL;
@@ -190,6 +204,15 @@ static int setMissionData(lua_State* L)
     return 0;
 }
 
+static int setDrawingsData(lua_State* L)
+{
+    if (coreDrawingsData)
+    {
+        coreDrawingsData(L);
+    }
+    return 0;
+}
+
 static const luaL_Reg Map[] = {
 	{"onSimulationStart", onSimulationStart},
     {"onSimulationFrame", onSimulationFrame},
@@ -197,6 +220,7 @@ static const luaL_Reg Map[] = {
     {"setUnitsData", setUnitsData },
     {"setWeaponsData", setWeaponsData },
     {"setMissionData", setMissionData },
+    {"setDrawingsData", setDrawingsData },
 	{NULL, NULL}
 };
 

backend/shared/include/defines.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#define VERSION "{{OLYMPUS_VERSION_NUMBER}}.{{OLYMPUS_COMMIT_HASH}}"
+#define LOG_NAME "..\\..\\..\\..\\Logs\\Olympus_log.txt"
+
+#define REST_ADDRESS "http://localhost:3001"
+#define REST_URI "olympus"
+#define UNITS_URI "units"
+#define WEAPONS_URI "weapons"
+#define LOGS_URI "logs"
+#define AIRBASES_URI "airbases"
+#define BULLSEYE_URI "bullseyes"
+#define SPOTS_URI "spots"
+#define MISSION_URI "mission"
+#define COMMANDS_URI "commands"
+#define DRAWINGS_URI "drawings"
+
+#define FRAMERATE_TIME_INTERVAL 0.05
+
+#define OLYMPUS_JSON_PATH "..\\..\\..\\..\\Config\\olympus.json"
+#define AIRCRAFT_DATABASE_PATH "..\\databases\\units\\aircraftdatabase.json"
+#define HELICOPTER_DATABASE_PATH "..\\databases\\units\\helicopterdatabase.json"
+#define GROUNDUNIT_DATABASE_PATH "..\\databases\\units\\groundunitdatabase.json"
+#define NAVYUNIT_DATABASE_PATH "..\\databases\\units\\navyunitdatabase.json"
+
+#define MIST_SCRIPT "..\\Scripts\\mist.lua"
+#define OLYMPUS_COMMAND_SCRIPT "..\\Scripts\\OlympusCommand.lua"
+#define UNIT_PAYLOADS_SCRIPT "..\\Scripts\\unitPayloads.lua"
+#define TEMPLATES_SCRIPT "..\\Scripts\\templates.lua"
+#define MODS_SCRIPT "..\\Scripts\\mods.lua"

backend/utils/utils.rc

@@ -61,8 +61,8 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_UK
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
- PRODUCTVERSION {{OLYMPUS_VS_VERSION_NUMBER_1}},0
+ FILEVERSION 2,0,0,0
+ PRODUCTVERSION 1,0,3,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -79,12 +79,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "DCS Olympus"
             VALUE "FileDescription", "DCS Olympus"
-            VALUE "FileVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "FileVersion", "2.0.0.0"
             VALUE "InternalName", "utils.dll"
             VALUE "LegalCopyright", "Copyright (C) 2023"
             VALUE "OriginalFilename", "utils.dll"
             VALUE "ProductName", "TODO: <Product name>"
-            VALUE "ProductVersion", "{{OLYMPUS_VS_VERSION_NUMBER_2}}.0"
+            VALUE "ProductVersion", "2.0.0.0"
         END
     END
     BLOCK "VarFileInfo"

backend/utils/utils.vcxproj

@@ -85,7 +85,7 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <OutDir>.\..\..\bin\</OutDir>
+    <OutDir>.\..\..\build\backend\bin\</OutDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <OutDir>.\..\..\bin\$(Platform)\$(Configuration)\</OutDir>

backend/vcpkg-configuration.json

@@ -0,0 +1,14 @@
+{
+  "default-registry": {
+    "kind": "git",
+    "baseline": "7f9f0e44db287e8e67c0e888141bfa200ab45121",
+    "repository": "https://github.com/microsoft/vcpkg"
+  },
+  "registries": [
+    {
+      "kind": "artifact",
+      "location": "https://github.com/microsoft/vcpkg-ce-catalog/archive/refs/heads/main.zip",
+      "name": "microsoft"
+    }
+  ]
+}

backend/vcpkg.json

@@ -0,0 +1,6 @@
+{
+    "dependencies": [
+        "cpprestsdk",
+        "geographiclib"
+    ]
+}

build.bat

@@ -1,23 +0,0 @@
-call node increase_version.js
-
-cd src
-msbuild olympus.sln /t:Build /p:Configuration=Release
-cd ..
-
-cd client
-rmdir /s /q "hgt"
-call npm install
-call npm run emit-declarations
-call npm run build-release
-
-cd "plugins\controltips"
-call npm install
-call npm run build-release
-cd "..\.."
-
-cd "plugins\databasemanager"
-call npm install
-call npm run build-release
-cd "..\.."
-
-cd..

build_package.bat

@@ -1,2 +1,2 @@
-call build.bat
-call package.bat
+call .\scripts\batch\build.bat
+call .\scripts\batch\package.bat

client/.vscode/settings.json

@@ -1,2 +0,0 @@
-{
-}

client/app.js

@@ -1,49 +0,0 @@
-var express = require('express');
-var path = require('path');
-var cookieParser = require('cookie-parser');
-var logger = require('morgan');
-var fs = require('fs');
-var bodyParser = require('body-parser');
-
-var atcRouter       = require('./routes/api/atc');
-var airbasesRouter  = require('./routes/api/airbases');
-var elevationRouter = require('./routes/api/elevation');
-var databasesRouter = require('./routes/api/databases');
-var indexRouter     = require('./routes/index');
-var uikitRouter     = require('./routes/uikit');
-var usersRouter     = require('./routes/users');
-var resourcesRouter = require('./routes/resources');
-var pluginsRouter   = require('./routes/plugins');
-
-var app = express();
-
-app.use(logger('dev'));
-app.use(bodyParser.json({limit: '50mb'}));
-app.use(bodyParser.urlencoded({limit: '50mb', extended: true}));
-app.use(cookieParser());
-app.use(express.static(path.join(__dirname, 'public')));
-
-app.use('/', indexRouter);
-app.use('/api/atc', atcRouter);
-app.use('/api/airbases', airbasesRouter);
-app.use('/api/elevation', elevationRouter);
-app.use('/api/databases', databasesRouter);
-app.use('/plugins', pluginsRouter)
-app.use('/users', usersRouter);
-app.use('/uikit', uikitRouter);
-app.use('/resources', resourcesRouter);
-
-app.set('view engine', 'ejs');
-
-let rawdata = fs.readFileSync('../olympus.json');
-let config = JSON.parse(rawdata);
-if (config["server"] != undefined)
-    app.get('/config', (req, res) => res.send(config["server"]));
-
-module.exports = app;
-
-const DemoDataGenerator = require('./demo.js');
-var demoDataGenerator = new DemoDataGenerator(app, config);
-
-
-

client/bin/www

@@ -1,118 +0,0 @@
-#!/usr/bin/env node
-
-console.log('\x1b[36m%s\x1b[0m', "*********************************************************************");
-console.log('\x1b[36m%s\x1b[0m', "*  _____   _____  _____    ____  _                                  *");
-console.log('\x1b[36m%s\x1b[0m', "* |  __ \\ / ____|/ ____|  / __ \\| |                                 *");
-console.log('\x1b[36m%s\x1b[0m', "* | |  | | |    | (___   | |  | | |_   _ _ __ ___  _ __  _   _ ___  *");
-console.log('\x1b[36m%s\x1b[0m', "* | |  | | |     \\___ \\  | |  | | | | | | '_ ` _ \\| '_ \\| | | / __| *");
-console.log('\x1b[36m%s\x1b[0m', "* | |__| | |____ ____) | | |__| | | |_| | | | | | | |_) | |_| \\__ \\ *");
-console.log('\x1b[36m%s\x1b[0m', "* |_____/ \\_____|_____/   \\____/|_|\\__, |_| |_| |_| .__/ \\__,_|___/ *");
-console.log('\x1b[36m%s\x1b[0m', "*                                   __/ |         | |               *");
-console.log('\x1b[36m%s\x1b[0m', "*                                  |___/          |_|               *");
-console.log('\x1b[36m%s\x1b[0m', "*********************************************************************");
-console.log('\x1b[36m%s\x1b[0m', "");
-console.log("Please wait while DCS Olympus Server starts up...");
-
-var fs = require('fs');
-let rawdata = fs.readFileSync('../olympus.json');
-let config = JSON.parse(rawdata);
-
-/**
- * Module dependencies.
- */
-
-var app = require('../app');
-var debug = require('debug')('client:server');
-var http = require('http');
-
-/**
- * Get port from environment and store in Express.
- */
-
-var configPort = null;
-if (config["client"] != undefined && config["client"]["port"] != undefined) {
-	configPort = config["client"]["port"];
-}
-
-var port = normalizePort(configPort || '3000');
-app.set('port', port);
-console.log("Express server listening on port: " + port)
-
-/**
- * Create HTTP server.
- */
-
-var server = http.createServer(app);
-
-/**
- * Listen on provided port, on all network interfaces.
- */
-
-server.listen(port);
-server.on('error', onError);
-server.on('listening', onListening);
-
-/**
- * Normalize a port into a number, string, or false.
- */
-
-function normalizePort(val) {
-  var port = parseInt(val, 10);
-
-  if (isNaN(port)) {
-    // named pipe
-    return val;
-  }
-
-  if (port >= 0) {
-    // port number
-    return port;
-  }
-
-  return false;
-}
-
-/**
- * Event listener for HTTP server "error" event.
- */
-
-function onError(error) {
-  if (error.syscall !== 'listen') {
-    throw error;
-  }
-
-  var bind = typeof port === 'string'
-    ? 'Pipe ' + port
-    : 'Port ' + port;
-
-  // handle specific listen errors with friendly messages
-  switch (error.code) {
-    case 'EACCES':
-      console.error(bind + ' requires elevated privileges');
-      process.exit(1);
-      break;
-    case 'EADDRINUSE':
-      console.error(bind + ' is already in use');
-      process.exit(1);
-      break;
-    default:
-      throw error;
-  }
-}
-
-/**
- * Event listener for HTTP server "listening" event.
- */
-
-function onListening() {
-  var addr = server.address();
-  var bind = typeof addr === 'string'
-    ? 'pipe ' + addr
-    : 'port ' + addr.port;
-  debug('Listening on ' + bind);
-}
-
-console.log("DCS Olympus server {{OLYMPUS_VERSION_NUMBER}}.{{OLYMPUS_COMMIT_HASH}} started correctly!")
-console.log("Waiting for connections...")
-
-process.title = `DCS Olympus server {{OLYMPUS_VERSION_NUMBER}} (${port})`;

client/configurator.js

@@ -1,117 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const yargs = require('yargs');
-const prompt = require('prompt-sync')({sigint: true});
-const sha256 = require('sha256');
-const jsonPath = path.join('..', 'olympus.json');
-
-/* Set the acceptable values */
-yargs.alias('a', 'address').describe('a', 'Backend address').string('a');
-yargs.alias('b', 'backendPort').describe('b', 'Backend port').number('b');
-yargs.alias('c', 'clientPort').describe('c', 'Client port').number('c');
-yargs.alias('p', 'gameMasterPassword').describe('p', 'Game Master password').string('p');
-yargs.alias('bp', 'blueCommanderPassword').describe('bp', 'Blue Commander password').string('bp');
-yargs.alias('rp', 'redCommanderPassword').describe('rp', 'Red Commander password').string('rp');
-args = yargs.argv;
-
-async function run() {
-    /* Check that we can read the json */
-    if (fs.existsSync(jsonPath)) {
-        var json = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
-
-        var address = args.address ?? json["server"]["address"];
-        var clientPort = args.clientPort ?? json["client"]["port"];
-        var backendPort = args.backendPort ?? json["server"]["port"];
-        var gameMasterPassword = args.gameMasterPassword? sha256(args.gameMasterPassword): json["authentication"]["gameMasterPassword"];
-        var blueCommanderPassword = args.blueCommanderPassword? sha256(args.blueCommanderPassword): json["authentication"]["blueCommanderPassword"];
-        var redCommanderPassword = args.redCommanderPassword? sha256(args.redCommanderPassword): json["authentication"]["redCommanderPassword"];
-
-        /* Run in interactive mode */
-        if (args.address === undefined && args.clientPort === undefined && args.backendPort === undefined &&
-            args.gameMasterPassword === undefined && args.blueCommanderPassword === undefined && args.redCommanderPassword === undefined) {
-
-            console.log('\x1b[36m%s\x1b[0m', "*********************************************************************");
-            console.log('\x1b[36m%s\x1b[0m', "*  _____   _____  _____    ____  _                                  *");
-            console.log('\x1b[36m%s\x1b[0m', "* |  __ \\ / ____|/ ____|  / __ \\| |                                 *");
-            console.log('\x1b[36m%s\x1b[0m', "* | |  | | |    | (___   | |  | | |_   _ _ __ ___  _ __  _   _ ___  *");
-            console.log('\x1b[36m%s\x1b[0m', "* | |  | | |     \\___ \\  | |  | | | | | | '_ ` _ \\| '_ \\| | | / __| *");
-            console.log('\x1b[36m%s\x1b[0m', "* | |__| | |____ ____) | | |__| | | |_| | | | | | | |_) | |_| \\__ \\ *");
-            console.log('\x1b[36m%s\x1b[0m', "* |_____/ \\_____|_____/   \\____/|_|\\__, |_| |_| |_| .__/ \\__,_|___/ *");
-            console.log('\x1b[36m%s\x1b[0m', "*                                   __/ |         | |               *");
-            console.log('\x1b[36m%s\x1b[0m', "*                                  |___/          |_|               *");
-            console.log('\x1b[36m%s\x1b[0m', "*********************************************************************");
-            console.log('\x1b[36m%s\x1b[0m', "");
-
-            console.log("DCS Olympus configurator {{OLYMPUS_VERSION_NUMBER}}.{{OLYMPUS_COMMIT_HASH}}");
-            console.log("");
-
-            var newValue;
-            var result;
-
-            /* Get the new address */
-            newValue = prompt(`Insert an address or press Enter to keep current value ${address}. Use * for any address: `);
-            address = newValue !== ""? newValue: address;
-
-            /* Get the new client port */
-            while (true) {
-                newValue = prompt(`Insert a client port or press Enter to keep current value ${clientPort}. Integers between 1025 and 65535: `);
-                if (newValue === "")
-                    break;
-                result = Number(newValue);
-                
-                if (!isNaN(result) && Number.isInteger(result) && result > 1024 && result <= 65535)
-                    break;
-            }
-            clientPort = newValue? result: clientPort;
-
-            /* Get the new backend port */
-            while (true) {
-                newValue = prompt(`Insert a backend port or press Enter to keep current value ${backendPort}. Integers between 1025 and 65535: `);
-                if (newValue === "")
-                    break;
-                result = Number(newValue);
-                
-                if (!isNaN(result) && Number.isInteger(result) && result > 1024 && result <= 65535 && result != clientPort)
-                    break;
-
-                if (result === clientPort)
-                    console.log("Client port and backend port must be different.");
-            }
-            backendPort = newValue? result: backendPort;
-
-            /* Get the new Game Master password */
-            newValue = prompt(`Insert a new Game Master password or press Enter to keep current value: `, {echo: "*"});
-            gameMasterPassword = newValue !== ""? sha256(newValue): gameMasterPassword;
-
-            /* Get the new Blue Commander password */
-            newValue = prompt(`Insert a new Blue Commander password or press Enter to keep current value: `, {echo: "*"});
-            blueCommanderPassword = newValue !== ""? sha256(newValue): blueCommanderPassword;
-            
-            /* Get the new Red Commander password */
-            newValue = prompt(`Insert a new Red Commander password or press Enter to keep current value: `, {echo: "*"});
-            redCommanderPassword = newValue !== ""? sha256(newValue): redCommanderPassword;
-        }
-
-        /* Apply the inputs */
-        json["server"]["address"] = address;
-        json["client"]["port"] = clientPort;
-        json["server"]["port"] = backendPort;
-        json["authentication"]["gameMasterPassword"] = gameMasterPassword;
-        json["authentication"]["blueCommanderPassword"] = blueCommanderPassword;
-        json["authentication"]["redCommanderPassword"] = redCommanderPassword;
-
-        /* Write the result to disk */
-        const serialized = JSON.stringify(json, null, 4);
-        fs.writeFileSync(jsonPath, serialized, 'utf8');
-        console.log("Olympus.json updated correctly, goodbye!");
-    }
-    else {
-        console.error("Error, could not read olympus.json file!")
-    }
-
-    /* Wait a bit before closing the window */
-    await new Promise(resolve => setTimeout(resolve, 3000));
-}
-
-/* Run the configurator */
-run();

client/copy.bat

@@ -1,4 +0,0 @@
-copy .\\node_modules\\leaflet\\dist\\leaflet.css .\\public\\stylesheets\\leaflet\\leaflet.css 
-copy .\\node_modules\\leaflet-gesture-handling\\dist\\leaflet-gesture-handling.css .\\public\\stylesheets\\leaflet\\leaflet-gesture-handling.css
-copy .\\node_modules\\leaflet.nauticscale\\dist\\leaflet.nauticscale.js .\\public\\javascripts\\leaflet.nauticscale.js
-copy .\\node_modules\\leaflet-path-drag\\dist\\L.Path.Drag.js .\\public\\javascripts\\L.Path.Drag.js

client/debug.bat

@@ -1,2 +0,0 @@
-start cmd /k "npm run start"
-start cmd /k "watchify .\src\index.ts --debug -o .\public\javascripts\bundle.js -t [ babelify --global true --presets [ @babel/preset-env ] --extensions '.js'] -p [ tsify --noImplicitAny ]

client/demo.js

@@ -1,514 +0,0 @@
-const { random } = require('@turf/turf');
-var basicAuth = require('express-basic-auth')
-var enc = new TextEncoder();
-
-const aircraftDatabase = require('./public/databases/units/aircraftDatabase.json');
-const helicopterDatabase = require('./public/databases/units/helicopterDatabase.json');
-const groundUnitDatabase = require('./public/databases/units/groundUnitDatabase.json');
-const navyUnitDatabase = require('./public/databases/units/navyUnitDatabase.json');
-
-const DEMO_UNIT_DATA = {}
-
-const DEMO_WEAPONS_DATA = {
-    /*["1001"]:{ category: "Missile", alive: true, coalition: 2, name: "", position: { lat: 37.1, lng: -116, alt: 1000 }, speed: 200, heading: 45 * Math.PI / 180 }, */
-}
-
-class DemoDataGenerator {
-    constructor(app, config)
-    { 
-        app.get('/demo/units', (req, res) => this.units(req, res));
-        app.get('/demo/weapons', (req, res) => this.weapons(req, res));
-        app.get('/demo/logs', (req, res) => this.logs(req, res));
-        app.get('/demo/bullseyes', (req, res) => this.bullseyes(req, res));
-        app.get('/demo/airbases', (req, res) => this.airbases(req, res));
-        app.get('/demo/mission', (req, res) => this.mission(req, res));
-        app.get('/demo/commands', (req, res) => this.command(req, res));
-        app.put('/demo', (req, res) => this.put(req, res));
-
-        app.use('/demo', basicAuth({
-            users: { 
-                'admin': config["authentication"]["gameMasterPassword"],
-                'blue': config["authentication"]["blueCommanderPassword"],
-                'red': config["authentication"]["redCommanderPassword"]
-            },
-        }))
-
-        
-        let baseData = { alive: true, human: false, controlled: true, coalition: 2, country: 0, unitName: "Cool guy", groupName: "Cool group 1", state: 13, task: "Being cool!",
-            hasTask: true, position: { lat: 37, lng: -116, alt: 1000 }, speed: 200, horizontalVelocity: 200, verticalVelicity: 0, heading: 45, track: 45, isActiveTanker: false, isActiveAWACS: false, onOff: true, followRoads: false, fuel: 50, 
-            desiredSpeed: 300, desiredSpeedType: 1, desiredAltitude: 1000, desiredAltitudeType: 1, leaderID: 0,
-            formationOffset: { x: 0, y: 0, z: 0 },
-            targetID: 0,
-            targetPosition: { lat: 0, lng: 0, alt: 0 },
-            ROE: 1,
-            reactionToThreat: 1,
-            emissionsCountermeasures: 1,
-            TACAN: { isOn: false, XY: 'Y', callsign: 'TKR', channel: 40 },
-            radio: { frequency: 124000000, callsign: 1, callsignNumber: 1 },
-            generalSettings: { prohibitAA: false, prohibitAfterburner: false, prohibitAG: false, prohibitAirWpn: false, prohibitJettison: false },
-            ammo:  [],
-            contacts: [],
-            activePath: [],
-            isLeader: true
-        }
-
-        
-        
-        // UNCOMMENT TO TEST ALL UNITS ****************
-        /*
-        var databases = Object.assign({}, aircraftDatabase, helicopterDatabase, groundUnitDatabase, navyUnitDatabase);
-        var t = Object.keys(databases).length;
-        var l = Math.floor(Math.sqrt(t));
-        let latIdx = 0;
-        let lngIdx = 0;
-        let idx = 1;
-        console.log(l)
-        for (let name in databases) {
-            if (databases[name].enabled) {
-                DEMO_UNIT_DATA[idx] = JSON.parse(JSON.stringify(baseData));
-                DEMO_UNIT_DATA[idx].name = name;
-                DEMO_UNIT_DATA[idx].groupName = `Group-${idx}`;
-                DEMO_UNIT_DATA[idx].position.lat += latIdx / 5;
-                DEMO_UNIT_DATA[idx].position.lng += lngIdx / 5;
-                DEMO_UNIT_DATA[idx].coalition = Math.floor(Math.random() * 3)
-                
-                latIdx += 1;
-                if (latIdx === l) {
-                    latIdx = 0;
-                    lngIdx += 1;
-                }
-
-                if (name in aircraftDatabase)
-                    DEMO_UNIT_DATA[idx].category = "Aircraft";
-                else if (name in helicopterDatabase)
-                    DEMO_UNIT_DATA[idx].category = "Helicopter";
-                else if (name in groundUnitDatabase)
-                    DEMO_UNIT_DATA[idx].category = "GroundUnit";
-                else if (name in navyUnitDatabase)
-                    DEMO_UNIT_DATA[idx].category = "NavyUnit";
-
-                idx += 1;
-            }
-        }
-        
-
-        */
-        let idx = 1;
-        DEMO_UNIT_DATA[idx] = JSON.parse(JSON.stringify(baseData));
-        DEMO_UNIT_DATA[idx].name = "S_75M_Volhov";
-        DEMO_UNIT_DATA[idx].groupName = `Group`;
-        DEMO_UNIT_DATA[idx].position.lat += idx / 100;
-        DEMO_UNIT_DATA[idx].category = "GroundUnit";
-        DEMO_UNIT_DATA[idx].isLeader = true;
-
-        idx += 1;
-        DEMO_UNIT_DATA[idx] = JSON.parse(JSON.stringify(baseData));
-        DEMO_UNIT_DATA[idx].name = "SNR_75V";
-        DEMO_UNIT_DATA[idx].groupName = `Group`;
-        DEMO_UNIT_DATA[idx].position.lat += idx / 100;
-        DEMO_UNIT_DATA[idx].category = "GroundUnit";
-        DEMO_UNIT_DATA[idx].isLeader = false;
-
-        idx += 1;
-        DEMO_UNIT_DATA[idx] = JSON.parse(JSON.stringify(baseData));
-        DEMO_UNIT_DATA[idx].name = "Ural-4320 APA-5D";
-        DEMO_UNIT_DATA[idx].groupName = `Group`;
-        DEMO_UNIT_DATA[idx].position.lat += idx / 100;
-        DEMO_UNIT_DATA[idx].category = "GroundUnit";
-        DEMO_UNIT_DATA[idx].isLeader = false;
-    
-        
-        idx += 1;
-        DEMO_UNIT_DATA[idx] = JSON.parse(JSON.stringify(baseData));
-        DEMO_UNIT_DATA[idx].name = "F-14B";
-        DEMO_UNIT_DATA[idx].groupName = `Group-1`;
-        DEMO_UNIT_DATA[idx].position.lat += idx / 100;
-        DEMO_UNIT_DATA[idx].category = "Aircraft";
-        DEMO_UNIT_DATA[idx].isLeader = false;
-
-        idx += 1;
-        DEMO_UNIT_DATA[idx] = JSON.parse(JSON.stringify(baseData));
-        DEMO_UNIT_DATA[idx].name = "Infantry AK";
-        DEMO_UNIT_DATA[idx].groupName = `Group-2`;
-        DEMO_UNIT_DATA[idx].position.lat += idx / 100;
-        DEMO_UNIT_DATA[idx].category = "GroundUnit";
-        DEMO_UNIT_DATA[idx].isLeader = true;
-        DEMO_UNIT_DATA[idx].coalition = 0;
-        DEMO_UNIT_DATA[idx].operateAs = 2;
-
-        idx += 1;
-        DEMO_UNIT_DATA[idx] = JSON.parse(JSON.stringify(baseData));
-        DEMO_UNIT_DATA[idx].name = "Infantry AK";
-        DEMO_UNIT_DATA[idx].groupName = `Group-3`;
-        DEMO_UNIT_DATA[idx].position.lat += idx / 100;
-        DEMO_UNIT_DATA[idx].category = "GroundUnit";
-        DEMO_UNIT_DATA[idx].isLeader = true;
-        DEMO_UNIT_DATA[idx].coalition = 0;
-        DEMO_UNIT_DATA[idx].operateAs = 1;
-
-        idx += 1;
-        DEMO_UNIT_DATA[idx] = JSON.parse(JSON.stringify(baseData));
-        DEMO_UNIT_DATA[idx].name = "KC-135";
-        DEMO_UNIT_DATA[idx].groupName = `Group-4`;
-        DEMO_UNIT_DATA[idx].position.lat += idx / 100;
-        DEMO_UNIT_DATA[idx].category = "Aircraft";
-        DEMO_UNIT_DATA[idx].isLeader = true;
-        
-
-        this.startTime = Date.now();
-    }
-    
-    units(req, res){
-        var array = new Uint8Array();
-        var time = Date.now();
-        array = this.concat(array, this.uint64ToByteArray(BigInt(time)));
-        if (req.query["time"] == 0){
-            for (let idx in DEMO_UNIT_DATA) {
-                const unit = DEMO_UNIT_DATA[idx];
-                var dataIndex = 1;
-                array = this.concat(array, this.uint32ToByteArray(idx));
-                array = this.appendString(array, unit.category, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.alive, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.human, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.controlled, dataIndex); dataIndex++;
-                array = this.appendUint16(array, unit.coalition, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.country, dataIndex); dataIndex++;
-                array = this.appendString(array, unit.name, dataIndex); dataIndex++;
-                array = this.appendString(array, unit.unitName, dataIndex); dataIndex++;
-                array = this.appendString(array, unit.groupName, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.state, dataIndex); dataIndex++;
-                array = this.appendString(array, unit.task, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.hasTask, dataIndex); dataIndex++;
-                array = this.appendCoordinates(array, unit.position, dataIndex); dataIndex++;
-                array = this.appendDouble(array, unit.speed, dataIndex); dataIndex++;
-                array = this.appendDouble(array, unit.horizontalVelocity, dataIndex); dataIndex++;
-                array = this.appendDouble(array, unit.verticalVelicity, dataIndex); dataIndex++;
-                array = this.appendDouble(array, unit.heading, dataIndex); dataIndex++;
-                array = this.appendDouble(array, unit.track, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.isActiveTanker, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.isActiveAWACS, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.onOff, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.followRoads, dataIndex); dataIndex++;
-                array = this.appendUint16(array, unit.fuel, dataIndex); dataIndex++;
-                array = this.appendDouble(array, unit.desiredSpeed, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.desiredSpeedType, dataIndex); dataIndex++;
-                array = this.appendDouble(array, unit.desiredAltitude, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.desiredAltitudeType, dataIndex); dataIndex++;
-                array = this.appendUint32(array, unit.leaderID, dataIndex); dataIndex++;
-                array = this.appendOffset(array, unit.formationOffset, dataIndex); dataIndex++;
-                array = this.appendUint32(array, unit.targetID, dataIndex); dataIndex++;
-                array = this.appendCoordinates(array, unit.targetPosition, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.ROE, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.reactionToThreat, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.emissionsCountermeasures, dataIndex); dataIndex++;
-                array = this.appendTACAN(array, unit.TACAN, dataIndex); dataIndex++;
-                array = this.appendRadio(array, unit.radio, dataIndex); dataIndex++;
-                array = this.appendRadio(array, unit.generalSettings, dataIndex); dataIndex++;
-                array = this.appendAmmo(array, unit.ammo, dataIndex); dataIndex++;
-                array = this.appendContacts(array, unit.contacts, dataIndex); dataIndex++;
-                array = this.appendActivePath(array, unit.activePath, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.isLeader, dataIndex); dataIndex++;
-                array = this.appendUint8(array, unit.operateAs, dataIndex); dataIndex++;
-                array = this.concat(array, this.uint8ToByteArray(255));
-            }
-        }
-        res.end(Buffer.from(array, 'binary'));
-    };
-
-    weapons(req, res){
-        var array = new Uint8Array();
-        var time = Date.now();
-        array = this.concat(array, this.uint64ToByteArray(BigInt(time)));
-        for (let idx in DEMO_WEAPONS_DATA) {
-            const weapon = DEMO_WEAPONS_DATA[idx];
-            array = this.concat(array, this.uint32ToByteArray(idx));
-            array = this.appendString(array, weapon.category, 1);
-            array = this.appendUint8(array, weapon.alive, 2);
-            array = this.appendUint16(array, weapon.coalition, 5);
-            array = this.appendString(array, weapon.name, 7);
-            array = this.appendCoordinates(array, weapon.position, 13);
-            array = this.appendDouble(array, weapon.speed, 14);
-            array = this.appendDouble(array, weapon.heading, 15);
-            array = this.concat(array, this.uint8ToByteArray(255));
-        }
-        res.end(Buffer.from(array, 'binary'));
-    };
-
-    concat(array1, array2) {
-        var mergedArray = new Uint8Array(array1.length + array2.length);
-        mergedArray.set(array1);
-        mergedArray.set(array2, array1.length);
-        return mergedArray;
-    }
-    
-    uint8ToByteArray(number) {
-        var buffer = new ArrayBuffer(1);         
-        var longNum = new Uint8Array(buffer);  
-        longNum[0] = number;
-        return Array.from(new Uint8Array(buffer));
-    }
-    
-    uint16ToByteArray(number) {
-        var buffer = new ArrayBuffer(2);         
-        var longNum = new Uint16Array(buffer);  
-        longNum[0] = number;
-        return Array.from(new Uint8Array(buffer));
-    }
-    
-    uint32ToByteArray(number) {
-        var buffer = new ArrayBuffer(4);         
-        var longNum = new Uint32Array(buffer);  
-        longNum[0] = number;
-        return Array.from(new Uint8Array(buffer));
-    }
-    
-    uint64ToByteArray(number) {
-        var buffer = new ArrayBuffer(8);         
-        var longNum = new BigUint64Array(buffer);  
-        longNum[0] = number;
-        return Array.from(new Uint8Array(buffer));
-    }
-    
-    doubleToByteArray(number) {
-        var buffer = new ArrayBuffer(8);         
-        var longNum = new Float64Array(buffer);  
-        longNum[0] = number;
-        return Array.from(new Uint8Array(buffer));
-    }
-    
-    appendUint8(array, number, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.uint8ToByteArray(number));
-        return array;
-    }
-    
-    appendUint16(array, number, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.uint16ToByteArray(number));
-        return array;
-    }
-    
-    appendUint32(array, number, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.uint32ToByteArray(number));
-        return array;
-    }
-    
-    appendDouble(array, number, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.doubleToByteArray(number));
-        return array;
-    }
-    
-    appendCoordinates(array, coordinates, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.doubleToByteArray(coordinates.lat));
-        array = this.concat(array, this.doubleToByteArray(coordinates.lng));
-        array = this.concat(array, this.doubleToByteArray(coordinates.alt));
-        return array;
-    }
-    
-    appendOffset(array, offset, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.doubleToByteArray(offset.x));
-        array = this.concat(array, this.doubleToByteArray(offset.y));
-        array = this.concat(array, this.doubleToByteArray(offset.z));
-        return array;
-    }
-    
-    appendString(array, string, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.uint16ToByteArray(string.length));
-        array = this.concat(array, enc.encode(string));
-        return array;
-    }
-
-    padString(string, length) {
-        while (string.length < length)
-            string += " ";
-        return string.substring(0, length);
-    }
-    
-    appendTACAN(array, TACAN, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.uint8ToByteArray(TACAN.isOn));
-        array = this.concat(array, this.uint8ToByteArray(TACAN.channel));
-        array = this.concat(array, enc.encode(TACAN.XY));
-        array = this.concat(array, enc.encode(this.padString(TACAN.callsign, 4)));
-        return array;
-    }
-    
-    appendRadio(array, radio, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.uint32ToByteArray(radio.frequency));
-        array = this.concat(array, this.uint8ToByteArray(radio.callsign));
-        array = this.concat(array, this.uint8ToByteArray(radio.callsignNumber));
-        return array;
-    }
-    
-    appendGeneralSettings(array, generalSettings, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.uint8ToByteArray(generalSettings.prohibitAA));
-        array = this.concat(array, this.uint8ToByteArray(generalSettings.prohibitAfterburner));
-        array = this.concat(array, this.uint8ToByteArray(generalSettings.prohibitAG));
-        array = this.concat(array, this.uint8ToByteArray(generalSettings.prohibitAirWpn));
-        array = this.concat(array, this.uint8ToByteArray(generalSettings.prohibitJettison));
-        return array;
-    }
-
-    appendAmmo(array, ammo, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.uint16ToByteArray(ammo.length));
-        ammo.forEach((element) => {
-            array = this.concat(array, this.uint16ToByteArray(element.quantity));
-            array = this.concat(array, enc.encode(this.padString(element.name, 33)));
-            array = this.concat(array, this.uint8ToByteArray(element.guidance));
-            array = this.concat(array, this.uint8ToByteArray(element.category));
-            array = this.concat(array, this.uint8ToByteArray(element.missileCategory));
-        })
-        return array;
-    }
-
-    appendContacts(array, contacts, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.uint16ToByteArray(contacts.length));
-        contacts.forEach((element) => {
-            array = this.concat(array, this.uint32ToByteArray(element.ID));
-            array = this.concat(array, this.uint8ToByteArray(element.detectionMethod));
-        })
-        return array;
-    }
-
-    appendActivePath(array, activePath, datumIndex) {
-        array = this.concat(array, this.uint8ToByteArray(datumIndex));
-        array = this.concat(array, this.uint16ToByteArray(activePath.length));
-        activePath.forEach((element) => {
-            array = this.concat(array, this.doubleToByteArray(element.lat));
-            array = this.concat(array, this.doubleToByteArray(element.lng));
-            array = this.concat(array, this.doubleToByteArray(element.alt));
-        })
-        return array;
-    }
-    
-    logs(req, res){
-        var ret = {logs: {"1": "I'm a log!", "2": "I'm a different log!"}};
-        ret.time = Date.now();
-        ret.frameRate = 60;
-        ret.load = 0;
-        res.send(JSON.stringify(ret));
-    };
-    
-    airbases(req, res){
-        var ret = {airbases: {
-            ["0"]: {
-                callsign: "Nellis",
-                latitude: 37.3,
-                longitude: -115.8,
-                coalition: "neutral"
-            },
-            ["1"]: {
-                callsign: "Red",
-                latitude: 37.3,
-                longitude: -115.75,
-                coalition: "red"
-            },
-            ["2"]: {
-                callsign: "Blue",
-                latitude: 37.3,
-                longitude: -115.7,
-                coalition: "blue"
-            }
-        }};
-        ret.time = Date.now();
-        res.send(JSON.stringify(ret));
-    };
-    
-    bullseyes(req, res){
-        var ret = {bullseyes: {
-            "0": {
-                latitude: 37.25,
-                longitude: -115.8,
-                coalition: "neutral"
-            },
-            "1": {
-                latitude: 37.25,
-                longitude: -115.75,
-                coalition: "red"
-            },
-            "2": {
-                latitude: 37.25,
-                longitude: -115.7,
-                coalition: "blue"
-            }
-        }};
-        ret.time = Date.now();
-        res.send(JSON.stringify(ret));
-    };
-
-    mission(req, res){
-        var ret = {mission: {theatre: "Nevada"}};
-        ret.time = Date.now();
-
-        ret.mission.dateAndTime = {
-            time: { h: 10, m: 15, s: 34 },
-            date: "",
-            elapsedTime: (Date.now() - this.startTime) / 1000,
-            startTime: 0
-        }
-
-        ret.mission.coalitions = {
-            red: [ 
-                'RUSSIA',
-                'CHINA'
-            ],
-            blue: [
-                'UK',
-                'USA'
-            ],
-            neutral: [
-                'ITALY'
-            ]
-        }
-
-        ret.mission.commandModeOptions = {
-            restrictSpawns: true,
-            restrictToCoalition: true,
-            setupTime: 0,
-            spawnPoints: {
-                red: 400,
-                blue: 400
-            }, 
-            eras: ["WW2", "Early Cold War", "Late Cold War", "Modern"]
-        }
-
-        var auth = req.get("Authorization");
-        if (auth) {
-            var username = Buffer.from(auth.replace("Basic ", ""), 'base64').toString('binary').split(":")[0];
-            switch (username) {
-                case "admin":
-                    ret.mission.commandModeOptions.commandMode = "Game master";
-                    break
-                case "blue": 
-                    ret.mission.commandModeOptions.commandMode = "Blue commander";
-                    break;
-                case "red": 
-                    ret.mission.commandModeOptions.commandMode = "Red commander";
-                    break;
-            }
-        }
-        res.send(JSON.stringify(ret));
-    }
-
-    command(req, res) {
-        var ret = {commandExecuted: Math.random() > 0.5};
-        res.send(JSON.stringify(ret));
-    }
-    
-    put(req, res) {
-        var ret = {commandHash: Math.random().toString(36).slice(2, 19)}
-        res.send(JSON.stringify(ret));
-    }
-
-}
-
-module.exports = DemoDataGenerator;

client/install.bat

@@ -1,2 +0,0 @@
-call npm install --omit=dev
-call npm install yargs prompt-sync sha256 tcp-ping-port

client/package.json

@@ -1,67 +0,0 @@
-{
-  "name": "DCSOlympus",
-  "node-main": "./bin/www",
-  "main": "http://localhost:3000",
-  "version": "{{OLYMPUS_VERSION_NUMBER}}",
-  "private": true,
-  "scripts": {
-    "build": "browserify .\\src\\index.ts --debug -o .\\public\\javascripts\\bundle.js -t [ babelify --global true --presets [ @babel/preset-env ] --extensions '.js'] -p [ tsify --noImplicitAny ] && copy.bat",
-    "build-release": "browserify .\\src\\index.ts -o .\\public\\javascripts\\bundle.js -t [ babelify --global true --presets [ @babel/preset-env ] --extensions '.js'] -p [ tsify --noImplicitAny ] && copy.bat",
-    "emit-declarations": "tsc --project tsconfig.json --declaration --emitDeclarationOnly --outfile ./@types/olympus/index.d.ts",
-    "copy": "copy.bat",
-    "start": "node ./bin/www",
-    "debug": "npm run copy & concurrently --kill-others \"npm run watch\" \"nodemon --ignore ./public/databases/ ./bin/www\"",
-    "watch": "watchify .\\src\\index.ts --debug -o .\\public\\javascripts\\bundle.js -t [ babelify --global true --presets [ @babel/preset-env ] --extensions '.js'] -p [ tsify --noImplicitAny ]"
-  },
-  "dependencies": {
-    "@turf/turf": "^6.5.0",
-    "body-parser": "^1.20.2",
-    "cookie-parser": "~1.4.4",
-    "debug": "~2.6.9",
-    "ejs": "^3.1.8",
-    "express": "~4.16.1",
-    "express-basic-auth": "^1.2.1",
-    "js-sha256": "^0.10.1",
-    "leaflet-gesture-handling": "^1.2.2",
-    "morgan": "~1.9.1",
-    "save": "^2.9.0",
-    "srtm-elevation": "^2.1.2",
-    "uuid": "^9.0.1"
-  },
-  "devDependencies": {
-    "@babel/preset-env": "^7.21.4",
-    "@tanem/svg-injector": "^10.1.68",
-    "@types/formatcoords": "^1.1.0",
-    "@types/geojson": "^7946.0.10",
-    "@types/leaflet": "^1.9.0",
-    "@types/node": "^18.16.1",
-    "@types/sortablejs": "^1.15.0",
-    "@types/svg-injector": "^0.0.29",
-    "babelify": "^10.0.0",
-    "browserify": "^17.0.0",
-    "concurrently": "^7.6.0",
-    "cp": "^0.2.0",
-    "esmify": "^2.1.1",
-    "formatcoords": "^1.1.3",
-    "geodesy": "^1.1.2",
-    "leaflet": "^1.9.3",
-    "leaflet-control-mini-map": "^0.4.0",
-    "leaflet-path-drag": "*",
-    "leaflet.nauticscale": "^1.1.0",
-    "nodemon": "^2.0.20",
-    "requirejs": "^2.3.6",
-    "sortablejs": "^1.15.0",
-    "tinyify": "^4.0.0",
-    "tsify": "^5.0.4",
-    "tslib": "latest",
-    "typescript": "^4.9.4",
-    "usng.js": "^0.4.5",
-    "watchify": "^4.0.0"
-  },
-  "window": {
-    "width": 1000,
-    "height": 800,
-    "position": "center",
-    "icon": "public/images/icon.png"
-  }
-}

client/plugins/_boilerplate/copy.bat

@@ -1,8 +0,0 @@
-mkdir .\\..\\DCSOlympus\\client\\public\\plugins\\boilerplateplugin
-
-copy .\\index.js .\\..\\DCSOlympus\\client\\public\\plugins\\boilerplateplugin\\index.js
-copy .\\plugin.json .\\..\\DCSOlympus\\client\\public\\plugins\\boilerplateplugin\\plugin.json
-copy .\\style.css .\\..\\DCSOlympus\\client\\public\\plugins\\boilerplateplugin\\style.css
-
-mkdir .\\..\\DCSOlympus\\client\\public\\plugins\\boilerplateplugin\\images
-copy .\\images\\*.* .\\..\\DCSOlympus\\client\\public\\plugins\\boilerplateplugin\\images\\

client/plugins/_boilerplate/package.json

@@ -1,14 +0,0 @@
-{
-  "name": "boilerplateplugin",
-  "version": "v0.0.1",
-  "private": true,
-  "scripts": {
-    "build": "browserify ./src/index.ts -p [ tsify --noImplicitAny] > index.js && copy.bat"
-  },
-  "devDependencies": {
-    "@types/sortablejs": "^1.15.4",
-    "browserify": "^17.0.0",
-    "sortablejs": "^1.15.0",
-    "tsify": "^5.0.4"
-  }
-}

client/plugins/_boilerplate/plugin.json

@@ -1,7 +0,0 @@
-{
-    "name": "Boilerplate",
-    "version": "0.0.1",
-    "description": "Base plugin starter",
-    "authorName": "",
-    "authorContact": ""
-}

client/plugins/_boilerplate/readme.md

@@ -1,3 +0,0 @@
-# Boilerplate plugin
-
-See: https://github.com/Pax1601/DCSOlympus/wiki/Developer-Guide

client/plugins/_boilerplate/src/boilerplate.ts

@@ -1,27 +0,0 @@
-import { OlympusPlugin } from "interfaces";
-import { OlympusApp } from "olympusapp";
-
-
-export class BoilerplatePlugin implements OlympusPlugin {
-    #app!: OlympusApp;
-    
-    constructor() {
-    }
-
-    /**
-     * @param app <OlympusApp>
-     * 
-     * @returns boolean on success/fail
-     */
-
-    initialize(app: OlympusApp) : boolean {
-        this.#app = app;
-
-        return true;  //  Return true on success
-    }
-
-    getName() {
-        return "Boilerplate";
-    }
-
-}

client/plugins/_boilerplate/src/index.ts

@@ -1,5 +0,0 @@
-import { BoilerplatePlugin } from "./boilerplate";
-
-globalThis.getOlympusPlugin = () => {
-    return new BoilerplatePlugin();
-}