Merge remote-tracking branch 'origin/release-candidate' into features/redgreen-unit

backend/core/include/datatypes.h

@@ -55,6 +55,17 @@ namespace DataIndex {
 		racetrackLength,
 		racetrackAnchor,
 		racetrackBearing,
+		timeToNextTasking,
+		barrelHeight, 
+		muzzleVelocity,
+		aimTime, 
+		shotsToFire,
+		shotsBaseInterval, 
+		shotsBaseScatter, 
+		engagementRange, 
+		targetingRange, 
+		aimMethodRange,
+		acquisitionRange,
 		lastIndex,
 		endOfData = 255
 	};

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

@@ -62,6 +62,8 @@ 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); }
@@ -113,6 +115,17 @@ public:
 	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 setAlarmState(string newValue) { updateValue(alarmState, newValue, DataIndex::alarmState); }
 
 	/********** Getters **********/
@@ -166,6 +179,17 @@ public:
 	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; }
 
 protected:
 	unsigned int ID;
@@ -221,16 +245,30 @@ 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; 
 
 	/********** 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/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/groundunit.cpp

@@ -49,6 +49,31 @@ void GroundUnit::setDefaults(bool force)
 	setROE(ROE::WEAPON_FREE, force);
 	setOnOff(onOff, force);
 	setFollowRoads(followRoads, 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());
+	}
 }
 
 void GroundUnit::setState(unsigned char newState)
@@ -83,12 +108,14 @@ void GroundUnit::setState(unsigned char newState)
 	/************ 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;
@@ -100,6 +127,7 @@ void GroundUnit::setState(unsigned char newState)
 		break;
 	}
 	case State::FIRE_AT_AREA: {
+		setTask("Firing at area");
 		setTargetPosition(currentTargetPosition);
 		setEnableTaskCheckFailed(true);
 		clearActivePath();
@@ -107,6 +135,7 @@ void GroundUnit::setState(unsigned char newState)
 		break;
 	}
 	case State::SIMULATE_FIRE_FIGHT: {
+		setTask("Simulating fire fight");
 		setTargetPosition(currentTargetPosition);
 		setEnableTaskCheckFailed(false);
 		clearActivePath();
@@ -114,12 +143,14 @@ void GroundUnit::setState(unsigned char newState)
 		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();
@@ -131,6 +162,7 @@ void GroundUnit::setState(unsigned char newState)
 
 	setHasTask(false);
 	resetTaskFailedCounter();
+	nextTaskingMilliseconds = 0;
 
 	log(unitName + " setting state from " + to_string(state) + " to " + to_string(newState));
 	state = newState;
@@ -143,17 +175,27 @@ void GroundUnit::setState(unsigned char newState)
 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 (currentAmmo <= shotsToFire && state != State::IDLE) {
+		setState(State::IDLE);
+	}
+
+	/* Account for unit reloading */
+	if (currentAmmo < oldAmmo)
+		totalShellsFired += oldAmmo - currentAmmo;
+	oldAmmo = currentAmmo;
 
 	switch (state) {
 	case State::IDLE: {
-		setTask("Idle");
 		if (getHasTask())
 			resetTask();
+
 		break;
 	}
 	case State::REACH_DESTINATION: {
-		setTask("Reaching destination");
-
 		string enrouteTask = "";
 		bool looping = false;
 
@@ -200,12 +242,15 @@ void GroundUnit::AIloop()
 		break;
 	}
 	case State::FIRE_AT_AREA: {
-		setTask("Firing at area");
-
 		if (!getHasTask()) {
 			std::ostringstream taskSS;
 			taskSS.precision(10);
-			taskSS << "{id = 'FireAtPoint', lat = " << targetPosition.lat << ", lng = " << targetPosition.lng << ", radius = 100}";
+			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);
@@ -214,115 +259,163 @@ void GroundUnit::AIloop()
 		break;
 	}
 	case State::SIMULATE_FIRE_FIGHT: {
-		setTask("Simulating fire fight");
+		string taskString = "";
 
-		if (internalCounter == 0 && targetPosition != Coords(NULL) && scheduler->getLoad() < 30) {
-			/* 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);
-
-			/* 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 + 90, scatterDistance, scatteredTargetPosition.lat, scatteredTargetPosition.lng);
-			
-			/* Recover the data from the database */
-			double aimTime = 2; /* s */
-			bool indirectFire = false;
-			double shotsBaseInterval = 15; /* s */
-			if (database.has_object_field(to_wstring(name))) {
-				json::value databaseEntry = database[to_wstring(name)];
-				if (databaseEntry.has_number_field(L"aimTime"))
-					aimTime = databaseEntry[L"aimTime"].as_number().to_double();
-				if (databaseEntry.has_boolean_field(L"indirectFire"))
-					indirectFire = databaseEntry[L"indirectFire"].as_bool();
-				if (databaseEntry.has_number_field(L"shotsBaseInterval"))
-					shotsBaseInterval = databaseEntry[L"shotsBaseInterval"].as_number().to_double();
+		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();
 			}
-
-			/* If the unit is of the indirect fire type, like a mortar, simply shoot at the target */
-			if (indirectFire) {
-				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 = 100}";
-				Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
-				scheduler->appendCommand(command);
-				setHasTask(true);
-			}
-			/* Otherwise use the aim method */
 			else {
-				log(unitName + "(" + name + ")" + " simulating fire fight with aim at point method");
-				aimAtPoint(scatteredTargetPosition);
-			}
+				/* 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);
 
-			/* Wait an amout of time depending on the shots intensity */
-			internalCounter = static_cast<unsigned int>(((ShotsIntensity::HIGH - shotsIntensity) * shotsBaseInterval + aimTime) / FRAMERATE_TIME_INTERVAL);
+				/* 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 (internalCounter == 0)
-			internalCounter = static_cast<unsigned int>(3 / FRAMERATE_TIME_INTERVAL);
-		internalCounter--;
+		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: {
-		setTask("Scenic AAA");
+		string taskString = "";
 
 		/* Only perform scenic functions when the scheduler is "free" */
-		if (((!getHasTask() && scheduler->getLoad() < 30) || internalCounter == 0)) {
-			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 */
-			double aimTime = 2; /* s */
-			double shotsBaseInterval = 15; /* s */
-			if (database.has_object_field(to_wstring(name))) {
-				json::value databaseEntry = database[to_wstring(name)];
-				if (databaseEntry.has_number_field(L"aimTime"))
-					aimTime = databaseEntry[L"aimTime"].as_number().to_double();
-				if (databaseEntry.has_number_field(L"shotsBaseInterval"))
-					shotsBaseInterval = databaseEntry[L"shotsBaseInterval"].as_number().to_double();
+		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);
 
-			/* Only run if an enemy air unit is closer than 20km to avoid useless load */
-			if (target != nullptr && distance < 20000 /* m */) {
-				double r = 15; /* m */
-				double barrelElevation = r * tan(acos(((double)(rand()) / (double)(RAND_MAX))));
+				/* 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();
+				}
 
-				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);
+				/* 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;
 
-				std::ostringstream taskSS;
-				taskSS.precision(10);
-				taskSS << "{id = 'FireAtPoint', lat = " << lat << ", lng = " << lng << ", alt = " << position.alt + barrelElevation << ", radius = 0.001}";
-				Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
-				scheduler->appendCommand(command);
-				setHasTask(true);
+				if (target != nullptr && distance < activationDistance /* m */) {
+					double r = 15; /* m */
+					double barrelElevation = position.alt + barrelHeight + r * tan(acos(((double)(rand()) / (double)(RAND_MAX))));
 
-				/* Wait an amout of time depending on the shots intensity */
-				internalCounter = static_cast<unsigned int>(((ShotsIntensity::HIGH - shotsIntensity) * shotsBaseInterval + aimTime) / FRAMERATE_TIME_INTERVAL);
+					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 (internalCounter == 0)
-			internalCounter = static_cast<unsigned int>(3 / FRAMERATE_TIME_INTERVAL);
-		internalCounter--;
+		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: {
-		setTask("Missing on purpose");
+		string taskString = "";
 
 		/* Check that the unit can perform AAA duties */
 		bool canAAA = false;
@@ -332,150 +425,157 @@ void GroundUnit::AIloop()
 				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 (scheduler->getLoad() < 30 && internalCounter == 0) {
-				double distance = 0;
-				unsigned char unitCoalition = coalition == 0 ? getOperateAs() : coalition;
-				unsigned char targetCoalition = unitCoalition == 2 ? 1 : 2;
-				
-				/* Default gun values */
-				double barrelHeight = 1.0; /* m */
-				double muzzleVelocity = 860; /* m/s */
-				double aimTime = 10; /* s */
-				unsigned int shotsToFire = 10;
-				double shotsBaseInterval = 15; /* s */
-				double shotsBaseScatter = 2; /* degs */
-				double engagementRange = 10000; /* m */
-				double targetingRange = 0; /* m */
-				double aimMethodRange = 0; /* m */
-				double acquisitionRange = 0; /* m */
-
-				/* 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"))
-						barrelHeight = databaseEntry[L"barrelHeight"].as_number().to_double();
-					if (databaseEntry.has_number_field(L"muzzleVelocity"))
-						muzzleVelocity = databaseEntry[L"muzzleVelocity"].as_number().to_double();
-					if (databaseEntry.has_number_field(L"aimTime"))
-						aimTime = databaseEntry[L"aimTime"].as_number().to_double();
-					if (databaseEntry.has_number_field(L"shotsToFire"))
-						shotsToFire = databaseEntry[L"shotsToFire"].as_number().to_uint32();
-					if (databaseEntry.has_number_field(L"engagementRange"))
-						engagementRange = databaseEntry[L"engagementRange"].as_number().to_double();
-					if (databaseEntry.has_number_field(L"shotsBaseInterval"))
-						shotsBaseInterval = databaseEntry[L"shotsBaseInterval"].as_number().to_double();
-					if (databaseEntry.has_number_field(L"shotsBaseScatter"))
-						shotsBaseScatter = databaseEntry[L"shotsBaseScatter"].as_number().to_double();
-					if (databaseEntry.has_number_field(L"targetingRange"))
-						targetingRange = databaseEntry[L"targetingRange"].as_number().to_double();
-					if (databaseEntry.has_number_field(L"aimMethodRange"))
-						aimMethodRange = databaseEntry[L"aimMethodRange"].as_number().to_double();
-					if (databaseEntry.has_number_field(L"acquisitionRange"))
-						acquisitionRange = databaseEntry[L"acquisitionRange"].as_number().to_double();
-				}
-
-				/* 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) {
-					/* Approximate the flight time */
-					if (muzzleVelocity != 0)
-						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) {
-						/* 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);
-
-						internalCounter = static_cast<unsigned int>((aimTime + (ShotsIntensity::HIGH - shotsIntensity) * shotsBaseInterval + 2) / FRAMERATE_TIME_INTERVAL);
-					}
-					/* Else, do miss on purpose */
-					else {
-						/* Compute where the target will be in aimTime seconds, plus the effect of scatter. */
-						double scatterDistance = distance * tan(shotsBaseScatter * (ShotsScatter::LOW - shotsScatter) / 57.29577) * (RANDOM_ZERO_TO_ONE - 0.1);
-						double aimDistance = target->getHorizontalVelocity() * aimTime + scatterDistance;
-						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() * aimTime + distance * tan(shotsBaseScatter * (ShotsScatter::LOW - shotsScatter) / 57.29577) * RANDOM_ZERO_TO_ONE; // Force to always miss high never low
-
-						/* Send the command */
-						if (distance < engagementRange) {
-							/* 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, expendQty = " << shotsToFire << " }";
-							Command* command = dynamic_cast<Command*>(new SetTask(groupName, taskSS.str(), [this]() { this->setHasTaskAssigned(true); }));
-							scheduler->appendCommand(command);
-							setHasTask(true);
-							setTargetPosition(Coords(aimLat, aimLng, target->getPosition().alt));
-							internalCounter = static_cast<unsigned int>((aimTime + (ShotsIntensity::HIGH - shotsIntensity) * shotsBaseInterval + 2) / FRAMERATE_TIME_INTERVAL);
-						}
-						else if (distance < aimMethodRange) {
-							/* If the unit is closer than the aim method range, use the aim method range */
-							aimAtPoint(Coords(aimLat, aimLng, aimAlt));
-							setTargetPosition(Coords(aimLat, aimLng, target->getPosition().alt));
-							internalCounter = static_cast<unsigned int>((aimTime + (ShotsIntensity::HIGH - shotsIntensity) * shotsBaseInterval + 2) / FRAMERATE_TIME_INTERVAL);
-						}
-						else {
-							/* 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);
-							setHasTask(true);
-							setTargetPosition(Coords(NULL));
-
-							/* Don't wait too long before checking again */
-							internalCounter = static_cast<unsigned int>(5 / FRAMERATE_TIME_INTERVAL);
-						}
-					}
-					missOnPurposeTarget = target;
-				}
-				else {
+			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 (internalCounter == 0) {
+			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();
 				}
-				internalCounter = static_cast<unsigned int>((5 + RANDOM_ZERO_TO_ONE * alertnessTimeConstant * 0 /* TODO: remove to enable alertness again */) / FRAMERATE_TIME_INTERVAL);
+				nextTaskingMilliseconds = timeNow + static_cast<unsigned long>((5 + RANDOM_ZERO_TO_ONE * alertnessTimeConstant) * 1000L);
 				missOnPurposeTarget = nullptr;
 				setTargetPosition(Coords(NULL));
 			}
-			internalCounter--;
+			
 		}
 		else {
 			setState(State::IDLE);
 		}
 
+		setTimeToNextTasking((nextTaskingMilliseconds - timeNow) / 1000.0);
+
+		if (taskString.length() > 0)
+			setTask(taskString);
+
 		break;
 	}
 	default:
@@ -484,7 +584,8 @@ void GroundUnit::AIloop()
 }
 
 
-void GroundUnit::aimAtPoint(Coords aimTarget) {
+string GroundUnit::aimAtPoint(Coords aimTarget) {
+	string taskString = "";
 	double dist;
 	double bearing1;
 	double bearing2;
@@ -493,20 +594,6 @@ void GroundUnit::aimAtPoint(Coords aimTarget) {
 	/* Aim point distance */
 	double r = 15; /* m */
 
-	/* Default gun values */
-	double barrelHeight = 1.0; /* m */
-	double muzzleVelocity = 860; /* m/s */
-	double shotsBaseScatter = 5; /* degs */
-	if (database.has_object_field(to_wstring(name))) {
-		json::value databaseEntry = database[to_wstring(name)];
-		if (databaseEntry.has_number_field(L"barrelHeight") && databaseEntry.has_number_field(L"muzzleVelocity")) {
-			barrelHeight = databaseEntry[L"barrelHeight"].as_number().to_double();
-			muzzleVelocity = databaseEntry[L"muzzleVelocity"].as_number().to_double();
-		}
-		if (databaseEntry.has_number_field(L"shotsBaseScatter"))
-			shotsBaseScatter = databaseEntry[L"shotsBaseScatter"].as_number().to_double();
-	}
-
 	/* Compute the elevation angle of the gun*/
 	double deltaHeight = (aimTarget.alt - (position.alt + barrelHeight));
 	double alpha = 9.81 / 2 * dist * dist / (muzzleVelocity * muzzleVelocity);
@@ -521,18 +608,23 @@ void GroundUnit::aimAtPoint(Coords aimTarget) {
 		double lng = 0;
 		Geodesic::WGS84().Direct(position.lat, position.lng, bearing1, r, lat, lng);
 
-		log(unitName + "(" + name + ")" + " shooting with aim at point method. Barrel elevation: " + to_string(barrelElevation * 57.29577) + "°, bearing: " + to_string(bearing1) + "°");
+		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) + "°");
 
 		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)

backend/core/src/scheduler.cpp

@@ -390,6 +390,10 @@ void Scheduler::handleRequest(string key, json::value value, string username, js
 	{
 		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 (!checkSpawnPoints(spawnPoints, coalition)) return;
 
 		for (auto unit : value[L"units"].as_array()) {
 			unsigned int ID = unit[L"ID"].as_integer();
@@ -536,6 +540,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();
@@ -623,6 +650,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);

backend/core/src/unit.cpp

@@ -305,6 +305,17 @@ void Unit::getData(stringstream& ss, unsigned long long time)
 					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;
+					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;
 				}
 			}
 		}
@@ -828,3 +839,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/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) {