Generate all treasures of certain value beforehand and try to place them all, don't interrupt at first failure.

lib/rmg/RmgObject.cpp

@@ -161,17 +161,21 @@ const CGObjectInstance & Object::Instance::object() const
 	return dObject;
 }
 
-Object::Object(CGObjectInstance & object, const int3 & position)
+Object::Object(CGObjectInstance & object, const int3 & position):
+	guarded(false)
 {
 	addInstance(object, position);
 }
 
-Object::Object(CGObjectInstance & object)
+Object::Object(CGObjectInstance & object):
+	guarded(false)
 {
 	addInstance(object);
 }
 
-Object::Object(const Object & object): dStrength(object.dStrength)
+Object::Object(const Object & object):
+	dStrength(object.dStrength),
+	guarded(false)
 {
 	for(const auto & i : object.dInstances)
 		addInstance(const_cast<CGObjectInstance &>(i.object()), i.getPosition());
@@ -197,7 +201,9 @@ std::list<const Object::Instance*> Object::instances() const
 void Object::addInstance(Instance & object)
 {
 	//assert(object.dParent == *this);
+	setGuardedIfMonster(object);
 	dInstances.push_back(object);
+
 	dFullAreaCache.clear();
 	dAccessibleAreaCache.clear();
 	dAccessibleAreaFullCache.clear();
@@ -206,6 +212,8 @@ void Object::addInstance(Instance & object)
 Object::Instance & Object::addInstance(CGObjectInstance & object)
 {
 	dInstances.emplace_back(*this, object);
+	setGuardedIfMonster(dInstances.back());
+
 	dFullAreaCache.clear();
 	dAccessibleAreaCache.clear();
 	dAccessibleAreaFullCache.clear();
@@ -215,6 +223,8 @@ Object::Instance & Object::addInstance(CGObjectInstance & object)
 Object::Instance & Object::addInstance(CGObjectInstance & object, const int3 & position)
 {
 	dInstances.emplace_back(*this, object, position);
+	setGuardedIfMonster(dInstances.back());
+
 	dFullAreaCache.clear();
 	dAccessibleAreaCache.clear();
 	dAccessibleAreaFullCache.clear();
@@ -302,6 +312,19 @@ const int3 Object::getVisibleTop() const
 	return topTile;
 }
 
+bool rmg::Object::isGuarded() const
+{
+	return guarded;
+}
+
+void rmg::Object::setGuardedIfMonster(const Instance& object)
+{
+	if (object.object().ID == Obj::MONSTER)
+	{
+		guarded = true;
+	}
+}
+
 void Object::Instance::finalize(RmgMap & map)
 {
 	if(!map.isOnMap(getPosition(true)))

lib/rmg/RmgObject.h

@@ -78,6 +78,9 @@ public:
 	const Area & getArea() const;  //lazy cache invalidation
 	const int3 getVisibleTop() const;
 
+	bool isGuarded() const;
+	void setGuardedIfMonster(const Instance & object);
+	
 	void finalize(RmgMap & map);
 	void clear();
 	
@@ -87,6 +90,7 @@ private:
 	mutable Area dAccessibleAreaCache, dAccessibleAreaFullCache;
 	int3 dPosition;
 	ui32 dStrength;
+	bool guarded;
 };
 }
 

lib/rmg/modificators/TreasurePlacer.cpp

@@ -704,6 +704,7 @@ ObjectInfo * TreasurePlacer::getRandomObject(ui32 desiredValue, ui32 currentValu
 void TreasurePlacer::createTreasures(ObjectManager& manager)
 {
 	const int maxAttempts = 2;
+	const int minDistance = 2;
 
 	int mapMonsterStrength = map.getMapGenOptions().getMonsterStrength();
 	int monsterStrength = (zone.monsterStrength == EMonsterStrength::ZONE_NONE ? 0 : zone.monsterStrength + mapMonsterStrength - 1); //array index from 0 to 4; pick any correct value for ZONE_NONE, minGuardedValue won't be used in this case anyway
@@ -733,9 +734,18 @@ void TreasurePlacer::createTreasures(ObjectManager & manager)
 		return oi1.value < oi2.value;
 	});
 
+	size_t size = 0;
+	{
+		Zone::Lock lock(zone.areaMutex);
+		size = zone.areaPossible().getTiles().size();
+	}
+
 	int totalDensity = 0;
+
 	for (auto t : treasureInfo)
 	{
+		std::vector<rmg::Object> treasures;
+
 		//discard objects with too high value to be ever placed
 		vstd::erase_if(possibleObjects, [t](const ObjectInfo& oi) -> bool
 		{
@@ -744,25 +754,32 @@ void TreasurePlacer::createTreasures(ObjectManager & manager)
 
 		totalDensity += t.density;
 
+		const size_t count = size * t.density / 300;
+
 		//treasure density is inversely proportional to zone size but must be scaled back to map size
 		//also, normalize it to zone count - higher count means relatively smaller zones
 		
 		//this is squared distance for optimization purposes
-		const float minDistance = std::max<float>((125.f / totalDensity), 2.0f);
-		//distance lower than 2 causes objects to overlap and crash
+		const float minDistance = std::max<float>((125.f / totalDensity), 1.0f);
 
-		for(int attempt = 0; attempt <= maxAttempts;)
+		for (size_t i = 0; i < count;)
 		{
 			auto treasurePileInfos = prepareTreasurePile(t);
 			if (treasurePileInfos.empty())
 			{
-				++attempt;
 				continue;
 			}
+			else
+			{
+				i++;
+			}
 
 			int value = std::accumulate(treasurePileInfos.begin(), treasurePileInfos.end(), 0, [](int v, const ObjectInfo* oi) {return v + oi->value; });
 
+			for (ui32 attempt = 0; attempt <= 2; attempt++)
+			{
 				auto rmgObject = constructTreasurePile(treasurePileInfos, attempt == maxAttempts);
+
 				if (rmgObject.instances().empty()) //handle incorrect placement
 				{
 					restoreZoneLimits(treasurePileInfos);
@@ -774,11 +791,22 @@ void TreasurePlacer::createTreasures(ObjectManager & manager)
 				if (guarded)
 					guarded = manager.addGuard(rmgObject, value);
 
+				treasures.push_back(rmgObject);
+				break;
+			}
+		}
+
+		for (auto& rmgObject : treasures)
+		{
+			const bool guarded = rmgObject.isGuarded();
+
+			for (int attempt = 0; attempt <= maxAttempts;)
+			{
+				auto path = rmg::Path::invalid();
+
 				Zone::Lock lock(zone.areaMutex); //We are going to subtract this area
-			//TODO: Don't place 
 				auto possibleArea = zone.areaPossible();
 
-			auto path = rmg::Path::invalid();
 				if (guarded)
 				{
 					path = manager.placeAndConnectObject(possibleArea, rmgObject, [this, &rmgObject, &minDistance, &manager](const int3& tile)
@@ -821,17 +849,16 @@ void TreasurePlacer::createTreasures(ObjectManager & manager)
 					}
 					zone.connectPath(path);
 					manager.placeObject(rmgObject, guarded, true);
-				attempt = 0;
+					break;
 				}
 				else
 				{
-				restoreZoneLimits(treasurePileInfos);
-				rmgObject.clear();
 					++attempt;
 				}
 			}
 		}
 	}
+}
 
 char TreasurePlacer::dump(const int3 & t)
 {