Merge pull request #1576 from OutpostUniverse/miscTransitiveHeaders

Reduce misc transitive headers

Author: DanRStevens

appOPHD/Map/TileMap.cpp

@@ -13,6 +13,7 @@
 
 #include <algorithm>
 #include <functional>
+#include <numeric>
 #include <array>
 
 

appOPHD/MapObjects/Structures/StorageTanks.cpp

@@ -30,10 +30,10 @@ StringTable StorageTanks::createInspectorViewTable()
 		1,
 		{
 			std::to_string(storage().total()) + " / " + std::to_string(storageCapacity()),
-			storage().resources[0],
-			storage().resources[1],
-			storage().resources[2],
-			storage().resources[3]
+			std::to_string(storage().resources[0]),
+			std::to_string(storage().resources[1]),
+			std::to_string(storage().resources[2]),
+			std::to_string(storage().resources[3]),
 		});
 
 	return stringTable;

appOPHD/ProductPool.cpp

@@ -3,6 +3,7 @@
 #include "Constants/Numbers.h"
 #include "Constants/Strings.h"
 
+#include <NAS2D/Dictionary.h>
 #include <NAS2D/ParserHelper.h>
 
 #include <algorithm>

appOPHD/ProductPool.h

@@ -2,11 +2,15 @@
 
 #include <libOPHD/EnumProductType.h>
 
-#include <NAS2D/Dictionary.h>
-
 #include <array>
 
 
+namespace NAS2D
+{
+	class Dictionary;
+}
+
+
 int storageRequiredPerUnit(ProductType type);
 
 class ProductPool

appOPHD/States/CrimeExecution.cpp

@@ -39,6 +39,22 @@ namespace
 	}
 
 
+	std::vector<std::size_t> getIndicesWithStock(const StorableResources& storabeResources)
+	{
+		std::vector<std::size_t> indicesWithStock;
+
+		for (std::size_t i = 0; i < storabeResources.resources.size(); ++i)
+		{
+			if (storabeResources.resources[i] > 0)
+			{
+				indicesWithStock.push_back(i);
+			}
+		}
+
+		return indicesWithStock;
+	}
+
+
 	int calcAmountForStealing(Difficulty difficulty, int low, int high, int max)
 	{
 		auto stealRandom = randomNumber.generate(low, high);
@@ -118,16 +134,17 @@ void CrimeExecution::stealRawResources(Structure& structure)
 
 void CrimeExecution::stealResources(Structure& structure, const std::array<std::string, 4>& resourceNames)
 {
-	if (structure.storage().isEmpty())
+	auto& storage = structure.storage();
+	if (storage.isEmpty())
 	{
 		return;
 	}
 
-	auto resourceIndicesWithStock = structure.storage().getIndicesWithStock();
+	auto resourceIndicesWithStock = getIndicesWithStock(storage);
 	auto indexToStealFrom = randomNumber.generate<std::size_t>(0, resourceIndicesWithStock.size() - 1);
 
-	int amountStolen = calcAmountForStealing(mDifficulty, 2, 5, structure.storage().resources[indexToStealFrom]);
-	structure.storage().resources[indexToStealFrom] -= amountStolen;
+	int amountStolen = calcAmountForStealing(mDifficulty, 2, 5, storage.resources[indexToStealFrom]);
+	storage.resources[indexToStealFrom] -= amountStolen;
 
 	mCrimeEventSignal.emit(
 		"Resources Stolen",

appOPHD/StorableResources.cpp

@@ -0,0 +1,142 @@
+#include "StorableResources.h"
+
+#include <algorithm>
+#include <numeric>
+
+
+StorableResources StorableResources::operator*(int multiplier) const
+{
+	StorableResources result = *this;
+	for (size_t i = 0; i < resources.size(); ++i)
+	{
+		result.resources[i] *= multiplier;
+	}
+	return result;
+}
+
+
+StorableResources StorableResources::operator/(int divisor) const
+{
+	StorableResources result = *this;
+	for (size_t i = 0; i < resources.size(); ++i)
+	{
+		result.resources[i] /= divisor;
+	}
+	return result;
+}
+
+
+StorableResources& StorableResources::operator+=(const StorableResources& other)
+{
+	for (size_t i = 0; i < resources.size(); ++i)
+	{
+		resources[i] += other.resources[i];
+	}
+
+	return *this;
+}
+
+
+StorableResources& StorableResources::operator-=(const StorableResources& other)
+{
+	for (size_t i = 0; i < resources.size(); ++i)
+	{
+		resources[i] -= other.resources[i];
+	}
+
+	return *this;
+}
+
+
+bool StorableResources::operator<=(const StorableResources& other) const
+{
+	for (size_t i = 0; i < resources.size(); ++i)
+	{
+		if (!(resources[i] <= other.resources[i]))
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+
+bool StorableResources::operator<(const StorableResources& other) const
+{
+	for (size_t i = 0; i < resources.size(); ++i)
+	{
+		if (!(resources[i] < other.resources[i]))
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+
+bool StorableResources::operator>=(const StorableResources& other) const
+{
+	return other <= *this;
+}
+
+
+bool StorableResources::operator>(const StorableResources& other) const
+{
+	return other < *this;
+}
+
+
+StorableResources StorableResources::cap(const StorableResources& other) const
+{
+	StorableResources out;
+	for (std::size_t i = 0; i < resources.size(); ++i)
+	{
+		out.resources[i] = std::clamp(resources[i], 0, other.resources[i]);
+	}
+
+	return out;
+}
+
+
+StorableResources StorableResources::cap(int max) const
+{
+	StorableResources out;
+	for (std::size_t i = 0; i < resources.size(); ++i)
+	{
+		out.resources[i] = std::clamp(resources[i], 0, max);
+	}
+
+	return out;
+}
+
+
+bool StorableResources::isEmpty() const
+{
+	for (size_t i = 0; i < resources.size(); ++i)
+	{
+		if (resources[i] > 0)
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+
+// Sum of all resource types
+int StorableResources::total() const
+{
+	return std::accumulate(resources.begin(), resources.end(), 0);
+}
+
+
+StorableResources operator+(StorableResources lhs, const StorableResources& rhs)
+{
+	return lhs += rhs;
+}
+
+
+StorableResources operator-(StorableResources lhs, const StorableResources& rhs)
+{
+	return lhs -= rhs;
+}