1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-16 10:19:47 +02:00
vcmi/lib/mapping/CMapOperation.cpp
2024-04-03 14:48:04 +02:00

695 lines
17 KiB
C++

/*
* CMapOperation.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 "CMapOperation.h"
#include "../VCMI_Lib.h"
#include "../CRandomGenerator.h"
#include "../TerrainHandler.h"
#include "../mapObjects/CGObjectInstance.h"
#include "CMap.h"
#include "MapEditUtils.h"
VCMI_LIB_NAMESPACE_BEGIN
CMapOperation::CMapOperation(CMap* map) : map(map)
{
}
std::string CMapOperation::getLabel() const
{
return "";
}
MapRect CMapOperation::extendTileAround(const int3 & centerPos) const
{
return MapRect(int3(centerPos.x - 1, centerPos.y - 1, centerPos.z), 3, 3);
}
MapRect CMapOperation::extendTileAroundSafely(const int3& centerPos) const
{
return extendTileAround(centerPos) & MapRect(int3(0, 0, centerPos.z), map->width, map->height);
}
CComposedOperation::CComposedOperation(CMap* map) : CMapOperation(map)
{
}
void CComposedOperation::execute()
{
// FIXME: Only reindex objects at the end of composite operation
for(auto & operation : operations)
{
operation->execute();
}
}
void CComposedOperation::undo()
{
//reverse order
for(auto operation = operations.rbegin(); operation != operations.rend(); operation++)
{
operation->get()->undo();
}
}
void CComposedOperation::redo()
{
for(auto & operation : operations)
{
operation->redo();
}
}
std::string CComposedOperation::getLabel() const
{
std::string ret = "Composed operation: ";
for(const auto & operation : operations)
{
ret.append(operation->getLabel() + ";");
}
return ret;
}
void CComposedOperation::addOperation(std::unique_ptr<CMapOperation>&& operation)
{
operations.push_back(std::move(operation));
}
CDrawTerrainOperation::CDrawTerrainOperation(CMap * map, CTerrainSelection terrainSel, TerrainId terType, int decorationsPercentage, CRandomGenerator * gen):
CMapOperation(map),
terrainSel(std::move(terrainSel)),
terType(terType),
decorationsPercentage(decorationsPercentage),
gen(gen)
{
}
void CDrawTerrainOperation::execute()
{
for(const auto & pos : terrainSel.getSelectedItems())
{
auto & tile = map->getTile(pos);
tile.terType = const_cast<TerrainType*>(VLC->terrainTypeHandler->getById(terType));
invalidateTerrainViews(pos);
}
updateTerrainTypes();
updateTerrainViews();
}
void CDrawTerrainOperation::undo()
{
//TODO
}
void CDrawTerrainOperation::redo()
{
//TODO
}
std::string CDrawTerrainOperation::getLabel() const
{
return "Draw Terrain";
}
void CDrawTerrainOperation::updateTerrainTypes()
{
auto positions = terrainSel.getSelectedItems();
while(!positions.empty())
{
const auto & centerPos = *(positions.begin());
auto centerTile = map->getTile(centerPos);
//logGlobal->debug("Set terrain tile at pos '%s' to type '%s'", centerPos, centerTile.terType);
auto tiles = getInvalidTiles(centerPos);
auto updateTerrainType = [&](const int3& pos)
{
map->getTile(pos).terType = centerTile.terType;
positions.insert(pos);
invalidateTerrainViews(pos);
//logGlobal->debug("Set additional terrain tile at pos '%s' to type '%s'", pos, centerTile.terType);
};
// Fill foreign invalid tiles
for(const auto & tile : tiles.foreignTiles)
{
updateTerrainType(tile);
}
tiles = getInvalidTiles(centerPos);
if(tiles.nativeTiles.find(centerPos) != tiles.nativeTiles.end())
{
// Blow up
auto rect = extendTileAroundSafely(centerPos);
std::set<int3> suitableTiles;
int invalidForeignTilesCnt = std::numeric_limits<int>::max();
int invalidNativeTilesCnt = 0;
bool centerPosValid = false;
rect.forEach([&](const int3& posToTest)
{
auto & terrainTile = map->getTile(posToTest);
if(centerTile.terType->getId() != terrainTile.terType->getId())
{
const auto * formerTerType = terrainTile.terType;
terrainTile.terType = centerTile.terType;
auto testTile = getInvalidTiles(posToTest);
int nativeTilesCntNorm = testTile.nativeTiles.empty() ? std::numeric_limits<int>::max() : static_cast<int>(testTile.nativeTiles.size());
bool putSuitableTile = false;
bool addToSuitableTiles = false;
if(testTile.centerPosValid)
{
if(!centerPosValid)
{
centerPosValid = true;
putSuitableTile = true;
}
else
{
if(testTile.foreignTiles.size() < invalidForeignTilesCnt)
{
putSuitableTile = true;
}
else
{
addToSuitableTiles = true;
}
}
}
else if(!centerPosValid)
{
if((nativeTilesCntNorm > invalidNativeTilesCnt) ||
(nativeTilesCntNorm == invalidNativeTilesCnt && testTile.foreignTiles.size() < invalidForeignTilesCnt))
{
putSuitableTile = true;
}
else if(nativeTilesCntNorm == invalidNativeTilesCnt && testTile.foreignTiles.size() == invalidForeignTilesCnt)
{
addToSuitableTiles = true;
}
}
if(putSuitableTile)
{
//if(!suitableTiles.empty())
//{
// logGlobal->debug("Clear suitables tiles.");
//}
invalidNativeTilesCnt = nativeTilesCntNorm;
invalidForeignTilesCnt = static_cast<int>(testTile.foreignTiles.size());
suitableTiles.clear();
addToSuitableTiles = true;
}
if(addToSuitableTiles)
{
suitableTiles.insert(posToTest);
}
terrainTile.terType = formerTerType;
}
});
if(suitableTiles.size() == 1)
{
updateTerrainType(*suitableTiles.begin());
}
else
{
static const int3 directions[] = { int3(0, -1, 0), int3(-1, 0, 0), int3(0, 1, 0), int3(1, 0, 0),
int3(-1, -1, 0), int3(-1, 1, 0), int3(1, 1, 0), int3(1, -1, 0) };
for(const auto & direction : directions)
{
auto it = suitableTiles.find(centerPos + direction);
if (it != suitableTiles.end())
{
updateTerrainType(*it);
break;
}
}
}
}
else
{
// add invalid native tiles which are not in the positions list
for(const auto & nativeTile : tiles.nativeTiles)
{
if (positions.find(nativeTile) == positions.end())
{
positions.insert(nativeTile);
}
}
positions.erase(centerPos);
}
}
}
void CDrawTerrainOperation::updateTerrainViews()
{
for(const auto & pos : invalidatedTerViews)
{
const auto & patterns = VLC->terviewh->getTerrainViewPatterns(map->getTile(pos).terType->getId());
// Detect a pattern which fits best
int bestPattern = -1;
ValidationResult valRslt(false);
for(int k = 0; k < patterns.size(); ++k)
{
const auto & pattern = patterns[k];
//(ETerrainGroup::ETerrainGroup terGroup, const std::string & id)
valRslt = validateTerrainView(pos, &pattern);
if (valRslt.result)
{
bestPattern = k;
break;
}
}
//assert(bestPattern != -1);
if(bestPattern == -1)
{
// This shouldn't be the case
logGlobal->warn("No pattern detected at pos '%s'.", pos.toString());
CTerrainViewPatternUtils::printDebuggingInfoAboutTile(map, pos);
continue;
}
// Get mapping
const TerrainViewPattern& pattern = patterns[bestPattern][valRslt.flip];
std::pair<int, int> mapping;
mapping = pattern.mapping[0];
if(pattern.decoration)
{
if (pattern.mapping.size() < 2 || gen->nextInt(100) > decorationsPercentage)
mapping = pattern.mapping[0];
else
mapping = pattern.mapping[1];
}
if (!valRslt.transitionReplacement.empty())
mapping = valRslt.transitionReplacement == TerrainViewPattern::RULE_DIRT ? pattern.mapping[0] : pattern.mapping[1];
// Set terrain view
auto & tile = map->getTile(pos);
if(!pattern.diffImages)
{
tile.terView = gen->nextInt(mapping.first, mapping.second);
tile.extTileFlags = valRslt.flip;
}
else
{
const int framesPerRot = (mapping.second - mapping.first + 1) / pattern.rotationTypesCount;
int flip = (pattern.rotationTypesCount == 2 && valRslt.flip == 2) ? 1 : valRslt.flip;
int firstFrame = mapping.first + flip * framesPerRot;
tile.terView = gen->nextInt(firstFrame, firstFrame + framesPerRot - 1);
tile.extTileFlags = 0;
}
}
}
CDrawTerrainOperation::ValidationResult CDrawTerrainOperation::validateTerrainView(const int3& pos, const std::vector<TerrainViewPattern>* pattern, int recDepth) const
{
for(int flip = 0; flip < 4; ++flip)
{
auto valRslt = validateTerrainViewInner(pos, pattern->at(flip), recDepth);
if(valRslt.result)
{
valRslt.flip = flip;
return valRslt;
}
}
return ValidationResult(false);
}
CDrawTerrainOperation::ValidationResult CDrawTerrainOperation::validateTerrainViewInner(const int3& pos, const TerrainViewPattern& pattern, int recDepth) const
{
const auto * centerTerType = map->getTile(pos).terType;
int totalPoints = 0;
std::string transitionReplacement;
for(int i = 0; i < 9; ++i)
{
// The center, middle cell can be skipped
if(i == 4)
{
continue;
}
// Get terrain group of the current cell
int cx = pos.x + (i % 3) - 1;
int cy = pos.y + (i / 3) - 1;
int3 currentPos(cx, cy, pos.z);
bool isAlien = false;
const TerrainType * terType = nullptr;
if(!map->isInTheMap(currentPos))
{
// position is not in the map, so take the ter type from the neighbor tile
bool widthTooHigh = currentPos.x >= map->width;
bool widthTooLess = currentPos.x < 0;
bool heightTooHigh = currentPos.y >= map->height;
bool heightTooLess = currentPos.y < 0;
if((widthTooHigh && heightTooHigh) || (widthTooHigh && heightTooLess) || (widthTooLess && heightTooHigh) || (widthTooLess && heightTooLess))
{
terType = centerTerType;
}
else if(widthTooHigh)
{
terType = map->getTile(int3(currentPos.x - 1, currentPos.y, currentPos.z)).terType;
}
else if(heightTooHigh)
{
terType = map->getTile(int3(currentPos.x, currentPos.y - 1, currentPos.z)).terType;
}
else if(widthTooLess)
{
terType = map->getTile(int3(currentPos.x + 1, currentPos.y, currentPos.z)).terType;
}
else if(heightTooLess)
{
terType = map->getTile(int3(currentPos.x, currentPos.y + 1, currentPos.z)).terType;
}
}
else
{
terType = map->getTile(currentPos).terType;
if(terType != centerTerType && (terType->isPassable() || centerTerType->isPassable()))
{
isAlien = true;
}
}
// Validate all rules per cell
int topPoints = -1;
for(const auto & elem : pattern.data[i])
{
TerrainViewPattern::WeightedRule rule = elem;
if(!rule.isStandardRule())
{
if(recDepth == 0 && map->isInTheMap(currentPos))
{
if(terType->getId() == centerTerType->getId())
{
const auto patternForRule = VLC->terviewh->getTerrainViewPatternsById(centerTerType->getId(), rule.name);
if(auto p = patternForRule)
{
auto rslt = validateTerrainView(currentPos, &(p->get()), 1);
if(rslt.result) topPoints = std::max(topPoints, rule.points);
}
}
continue;
}
else
{
rule.setNative();
}
}
auto applyValidationRslt = [&](bool rslt)
{
if(rslt)
{
topPoints = std::max(topPoints, rule.points);
}
};
// Validate cell with the ruleset of the pattern
bool nativeTestOk = false;
bool nativeTestStrongOk = false;
nativeTestOk = nativeTestStrongOk = (rule.isNativeStrong() || rule.isNativeRule()) && !isAlien;
if(centerTerType->getId() == ETerrainId::DIRT)
{
nativeTestOk = rule.isNativeRule() && !terType->isTransitionRequired();
bool sandTestOk = (rule.isSandRule() || rule.isTransition())
&& terType->isTransitionRequired();
applyValidationRslt(rule.isAnyRule() || sandTestOk || nativeTestOk || nativeTestStrongOk);
}
else if(centerTerType->getId() == ETerrainId::SAND)
{
applyValidationRslt(true);
}
else if(centerTerType->isTransitionRequired()) //water, rock and some special terrains require sand transition
{
bool sandTestOk = (rule.isSandRule() || rule.isTransition())
&& isAlien;
applyValidationRslt(rule.isAnyRule() || sandTestOk || nativeTestOk);
}
else
{
bool dirtTestOk = (rule.isDirtRule() || rule.isTransition())
&& isAlien && !terType->isTransitionRequired();
bool sandTestOk = (rule.isSandRule() || rule.isTransition())
&& terType->isTransitionRequired();
if(transitionReplacement.empty() && rule.isTransition()
&& (dirtTestOk || sandTestOk))
{
transitionReplacement = dirtTestOk ? TerrainViewPattern::RULE_DIRT : TerrainViewPattern::RULE_SAND;
}
if(rule.isTransition())
{
applyValidationRslt((dirtTestOk && transitionReplacement != TerrainViewPattern::RULE_SAND) ||
(sandTestOk && transitionReplacement != TerrainViewPattern::RULE_DIRT));
}
else
{
applyValidationRslt(rule.isAnyRule() || dirtTestOk || sandTestOk || nativeTestOk);
}
}
}
if(topPoints == -1)
{
return ValidationResult(false);
}
else
{
totalPoints += topPoints;
}
}
if(totalPoints >= pattern.minPoints && totalPoints <= pattern.maxPoints)
{
return ValidationResult(true, transitionReplacement);
}
else
{
return ValidationResult(false);
}
}
void CDrawTerrainOperation::invalidateTerrainViews(const int3& centerPos)
{
auto rect = extendTileAroundSafely(centerPos);
rect.forEach([&](const int3& pos)
{
invalidatedTerViews.insert(pos);
});
}
CDrawTerrainOperation::InvalidTiles CDrawTerrainOperation::getInvalidTiles(const int3& centerPos) const
{
//TODO: this is very expensive function for RMG, needs optimization
InvalidTiles tiles;
const auto * centerTerType = map->getTile(centerPos).terType;
auto rect = extendTileAround(centerPos);
rect.forEach([&](const int3& pos)
{
if(map->isInTheMap(pos))
{
const auto * terType = map->getTile(pos).terType;
auto valid = validateTerrainView(pos, VLC->terviewh->getTerrainTypePatternById("n1")).result;
// Special validity check for rock & water
if(valid && (terType->isWater() || !terType->isPassable()))
{
static const std::string patternIds[] = { "s1", "s2" };
for(const auto & patternId : patternIds)
{
valid = !validateTerrainView(pos, VLC->terviewh->getTerrainTypePatternById(patternId)).result;
if(!valid) break;
}
}
// Additional validity check for non rock OR water
else if(!valid && (terType->isLand() && terType->isPassable()))
{
static const std::string patternIds[] = { "n2", "n3" };
for(const auto & patternId : patternIds)
{
valid = validateTerrainView(pos, VLC->terviewh->getTerrainTypePatternById(patternId)).result;
if(valid) break;
}
}
if(!valid)
{
if(terType == centerTerType) tiles.nativeTiles.insert(pos);
else tiles.foreignTiles.insert(pos);
}
else if(centerPos == pos)
{
tiles.centerPosValid = true;
}
}
});
return tiles;
}
CDrawTerrainOperation::ValidationResult::ValidationResult(bool result, std::string transitionReplacement)
: result(result)
, transitionReplacement(std::move(transitionReplacement))
, flip(0)
{
}
CClearTerrainOperation::CClearTerrainOperation(CMap* map, CRandomGenerator* gen) : CComposedOperation(map)
{
CTerrainSelection terrainSel(map);
terrainSel.selectRange(MapRect(int3(0, 0, 0), map->width, map->height));
addOperation(std::make_unique<CDrawTerrainOperation>(map, terrainSel, ETerrainId::WATER, 0, gen));
if(map->twoLevel)
{
terrainSel.clearSelection();
terrainSel.selectRange(MapRect(int3(0, 0, 1), map->width, map->height));
addOperation(std::make_unique<CDrawTerrainOperation>(map, terrainSel, ETerrainId::ROCK, 0, gen));
}
}
std::string CClearTerrainOperation::getLabel() const
{
return "Clear Terrain";
}
CInsertObjectOperation::CInsertObjectOperation(CMap* map, CGObjectInstance* obj)
: CMapOperation(map), obj(obj)
{
}
void CInsertObjectOperation::execute()
{
obj->id = ObjectInstanceID(map->objects.size());
do
{
map->setUniqueInstanceName(obj);
} while(vstd::contains(map->instanceNames, obj->instanceName));
map->addNewObject(obj);
}
void CInsertObjectOperation::undo()
{
map->removeObject(obj);
}
void CInsertObjectOperation::redo()
{
execute();
}
std::string CInsertObjectOperation::getLabel() const
{
return "Insert Object";
}
CMoveObjectOperation::CMoveObjectOperation(CMap* map, CGObjectInstance* obj, const int3& targetPosition)
: CMapOperation(map),
obj(obj),
initialPos(obj->pos),
targetPos(targetPosition)
{
}
void CMoveObjectOperation::execute()
{
map->moveObject(obj, targetPos);
}
void CMoveObjectOperation::undo()
{
map->moveObject(obj, initialPos);
}
void CMoveObjectOperation::redo()
{
execute();
}
std::string CMoveObjectOperation::getLabel() const
{
return "Move Object";
}
CRemoveObjectOperation::CRemoveObjectOperation(CMap* map, CGObjectInstance* obj)
: CMapOperation(map), obj(obj)
{
}
CRemoveObjectOperation::~CRemoveObjectOperation()
{
//when operation is destroyed and wasn't undone, the object is lost forever
if(!obj)
{
return;
}
//do not destroy an object that belongs to map
if(!vstd::contains(map->instanceNames, obj->instanceName))
{
delete obj;
obj = nullptr;
}
}
void CRemoveObjectOperation::execute()
{
map->removeObject(obj);
}
void CRemoveObjectOperation::undo()
{
try
{
//set new id, but do not rename object
obj->id = ObjectInstanceID(static_cast<si32>(map->objects.size()));
map->addNewObject(obj);
}
catch(const std::exception& e)
{
logGlobal->error(e.what());
}
}
void CRemoveObjectOperation::redo()
{
execute();
}
std::string CRemoveObjectOperation::getLabel() const
{
return "Remove Object";
}
VCMI_LIB_NAMESPACE_END