1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-12 10:03:53 +02:00
vcmi/lib/rmg/modificators/RoadPlacer.cpp

253 lines
5.4 KiB
C++
Raw Normal View History

/*
* RoadPlacer.cpp, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#include "StdInc.h"
#include "RoadPlacer.h"
#include "ObjectManager.h"
#include "ObstaclePlacer.h"
#include "RockFiller.h"
2023-05-20 10:17:37 +02:00
#include "../Functions.h"
#include "../CMapGenerator.h"
#include "../threadpool/MapProxy.h"
2023-05-24 01:05:59 +02:00
#include "../../mapping/CMapEditManager.h"
#include "../../mapObjects/CGObjectInstance.h"
#include "../../modding/IdentifierStorage.h"
#include "../../modding/ModScope.h"
#include "../../TerrainHandler.h"
VCMI_LIB_NAMESPACE_BEGIN
class TerrainType;
void RoadPlacer::process()
{
if(generator.getConfig().defaultRoadType.empty() && generator.getConfig().secondaryRoadType.empty())
return; //do not generate roads at all
connectRoads();
}
2024-05-01 09:16:10 +02:00
void RoadPlacer::postProcess()
{
//Draw dirt roads if there are only mines
drawRoads(noRoadNodes);
}
void RoadPlacer::init()
{
}
rmg::Area & RoadPlacer::areaForRoads()
{
return areaRoads;
}
rmg::Area & RoadPlacer::areaIsolated()
{
return isolated;
}
rmg::Area & RoadPlacer::areaVisitable()
{
return visitableTiles;
}
const rmg::Area & RoadPlacer::getRoads() const
{
return roads;
}
bool RoadPlacer::createRoad(const int3 & dst)
{
auto searchArea = zone.areaPossible() + zone.freePaths() + areaRoads + roads;
2024-05-10 15:35:33 +02:00
rmg::Area border(zone.area()->getBorder());
rmg::Path path(searchArea);
path.connect(roads);
const float VISITABLE_PENALTY = 1.33f;
2024-05-10 15:35:33 +02:00
auto simpleRoutig = [this, &border, &VISITABLE_PENALTY](const int3& src, const int3& dst)
{
if(areaIsolated().contains(dst))
{
2024-05-01 12:15:07 +02:00
return 1000.0f; //Do not route road behind objects that are not visitable from top, such as Monoliths
}
else
{
2024-05-10 15:35:33 +02:00
float ret = dst.dist2d(src);
// TODO: Prefer zig-zag connections
2024-05-01 12:15:07 +02:00
if (visitableTiles.contains(src) || visitableTiles.contains(dst))
{
ret *= VISITABLE_PENALTY;
}
2024-05-10 15:35:33 +02:00
float dist = border.distance(dst);
if(dist > 1)
{
ret /= dist;
}
return ret;
}
};
auto res = path.search(dst, true, simpleRoutig);
if(!res.valid())
{
2024-05-10 15:35:33 +02:00
auto desperateRoutig = [this, &border, &VISITABLE_PENALTY](const int3& src, const int3& dst) -> float
{
//Do not allow connections straight up through object not visitable from top
if(std::abs((src - dst).y) == 1)
{
if(areaIsolated().contains(dst) || areaIsolated().contains(src))
{
2023-12-07 13:57:39 +02:00
return 1e12;
}
}
else
{
if(areaIsolated().contains(dst))
{
return 1e6;
}
}
2024-05-10 15:35:33 +02:00
auto ret = dst.dist2d(src);
if (visitableTiles.contains(src) || visitableTiles.contains(dst))
{
ret *= VISITABLE_PENALTY;
}
2024-05-10 15:35:33 +02:00
float dist = border.distance(dst);
if(dist > 1)
{
ret /= dist;
}
return ret;
};
res = path.search(dst, false, desperateRoutig);
if(!res.valid())
{
logGlobal->warn("Failed to create road to node %s", dst.toString());
return false;
}
}
roads.unite(res.getPathArea());
return true;
}
void RoadPlacer::drawRoads(bool secondary)
{
2024-05-01 13:58:24 +02:00
//Do not draw roads on underground rock or water
roads.erase_if([this](const int3& pos) -> bool
{
2024-05-01 13:58:24 +02:00
const auto* terrain = map.getTile(pos).terType;
return !terrain->isPassable() || !terrain->isLand();
});
2023-07-21 14:55:49 +02:00
if(!generator.getMapGenOptions().isRoadEnabled())
{
return;
}
2023-07-07 20:17:20 +02:00
if((secondary && generator.getConfig().secondaryRoadType.empty())
|| (!secondary && generator.getConfig().defaultRoadType.empty()))
return;
//TODO: Allow custom road type for object
//TODO: Remove these default types
auto tiles = roads.getTilesVector();
std::string roadName = (secondary ? generator.getConfig().secondaryRoadType : generator.getConfig().defaultRoadType);
RoadId roadType(*VLC->identifiers()->getIdentifier(ModScope::scopeGame(), "road", roadName));
//If our road type is not enabled, choose highest below it
for (int8_t bestRoad = roadType.getNum(); bestRoad > RoadId(Road::NO_ROAD).getNum(); bestRoad--)
{
2023-07-21 14:55:49 +02:00
if(generator.getMapGenOptions().isRoadEnabled(RoadId(bestRoad)))
{
mapProxy->drawRoads(zone.getRand(), tiles, RoadId(bestRoad));
return;
}
}
}
void RoadPlacer::addRoadNode(const int3& node)
{
RecursiveLock lock(externalAccessMutex);
roadNodes.insert(node);
}
void RoadPlacer::connectRoads()
{
//Assumes objects are already placed
2023-07-21 14:55:49 +02:00
if(roadNodes.size() < 2)
{
//If there are no nodes, draw roads to mines
noRoadNodes = true;
2023-07-21 14:55:49 +02:00
if(auto* m = zone.getModificator<ObjectManager>())
{
2023-02-11 18:05:02 +02:00
for(auto * object : m->getMines())
{
addRoadNode(object->visitablePos());
}
}
}
if(roadNodes.size() < 2)
return;
//take any tile from road nodes as destination zone for all other road nodes
RecursiveLock lock(externalAccessMutex);
if(roads.empty())
roads.add(*roadNodes.begin());
2023-02-11 18:05:02 +02:00
for(const auto & node : roadNodes)
{
try
{
createRoad(node);
}
catch (const rmgException& e)
{
logGlobal->warn("Handled exception while drawing road to node %s: %s", node.toString(), e.what());
}
catch (const std::exception & e)
{
logGlobal->error("Unhandled exception while drawing road to node %s: %s", node.toString(), e.what());
throw;
}
}
2024-05-01 09:16:10 +02:00
if (!zone.isUnderground())
{
// Otherwise roads will be drawn only after rock is placed
postProcess();
}
}
char RoadPlacer::dump(const int3 & t)
{
2024-05-01 09:16:10 +02:00
if(vstd::contains(roadNodes, t))
return '@';
if(roads.contains(t))
return '+';
if(isolated.contains(t))
return 'i';
return Modificator::dump(t);
}
VCMI_LIB_NAMESPACE_END