games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-20 20:23:03 +02:00
Code Issues Releases Activity

vcmi: use std::optional

Browse Source
This commit is contained in:
Konstantin 2023-04-16 20:42:56 +03:00
parent 0d35606a44
commit 7a5775a9f9
135 changed files with 552 additions and 585 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
AI/BattleAI/BattleAI.cpp
View File

@ -134,7 +134,7 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
//evaluate casting spell for spellcasting stack
boost::optional<PossibleSpellcast> bestSpellcast(boost::none);
std::optional<PossibleSpellcast> bestSpellcast(std::nullopt);
//TODO: faerie dragon type spell should be selected by server
SpellID creatureSpellToCast = cb->battleGetRandomStackSpell(CRandomGenerator::getDefault(), stack, CBattleInfoCallback::RANDOM_AIMED);
if(stack->hasBonusOfType(Bonus::SPELLCASTER) && stack->canCast() && creatureSpellToCast != SpellID::NONE)
@ -157,7 +157,7 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
std::sort(possibleCasts.begin(), possibleCasts.end(), [&](const PossibleSpellcast & lhs, const PossibleSpellcast & rhs) { return lhs.value > rhs.value; });
if(!possibleCasts.empty() && possibleCasts.front().value > 0)
{
bestSpellcast = boost::optional<PossibleSpellcast>(possibleCasts.front());
bestSpellcast = std::optional<PossibleSpellcast>(possibleCasts.front());
}
}
}
@ -180,7 +180,7 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
auto & bestAttack = evaluationResult.bestAttack;
//TODO: consider more complex spellcast evaluation, f.e. because "re-retaliation" during enemy move in same turn for melee attack etc.
if(bestSpellcast.is_initialized() && bestSpellcast->value > bestAttack.damageDiff())
if(bestSpellcast.has_value() && bestSpellcast->value > bestAttack.damageDiff())
{
// return because spellcast value is damage dealt and score is dps reduce
movesSkippedByDefense = 0;
@ -219,7 +219,7 @@ BattleAction CBattleAI::activeStack( const CStack * stack )
);
}
}
else if(bestSpellcast.is_initialized())
else if(bestSpellcast.has_value())
{
movesSkippedByDefense = 0;
return BattleAction::makeCreatureSpellcast(stack, bestSpellcast->dest, bestSpellcast->spell->id);
@ -801,7 +801,7 @@ void CBattleAI::print(const std::string &text) const
logAi->trace("%s Battle AI[%p]: %s", playerID.getStr(), this, text);
}
boost::optional<BattleAction> CBattleAI::considerFleeingOrSurrendering()
std::optional<BattleAction> CBattleAI::considerFleeingOrSurrendering()
{
BattleStateInfoForRetreat bs;
@ -829,7 +829,7 @@ boost::optional<BattleAction> CBattleAI::considerFleeingOrSurrendering()
if(!bs.canFlee || !bs.canSurrender)
{
return boost::none;
return std::nullopt;
}
auto result = cb->makeSurrenderRetreatDecision(bs);

2
AI/BattleAI/BattleAI.h
View File

@ -73,7 +73,7 @@ public:
BattleAction activeStack(const CStack * stack) override; //called when it's turn of that stack
boost::optional<BattleAction> considerFleeingOrSurrendering();
std::optional<BattleAction> considerFleeingOrSurrendering();
void print(const std::string &text) const;
BattleAction useCatapult(const CStack *stack);

5
AI/Nullkiller/AIGateway.cpp
View File

@ -501,8 +501,7 @@ void AIGateway::showWorldViewEx(const std::vector<ObjectPosInfo> & objectPositio
NET_EVENT_HANDLER;
}
boost::optional<BattleAction> AIGateway::makeSurrenderRetreatDecision(
const BattleStateInfoForRetreat & battleState)
std::optional<BattleAction> AIGateway::makeSurrenderRetreatDecision(const BattleStateInfoForRetreat & battleState)
{
LOG_TRACE(logAi);
NET_EVENT_HANDLER;
@ -516,7 +515,7 @@ boost::optional<BattleAction> AIGateway::makeSurrenderRetreatDecision(
return BattleAction::makeRetreat(battleState.ourSide);
}
return boost::none;
return std::nullopt;
}

2
AI/Nullkiller/AIGateway.h
View File

@ -166,7 +166,7 @@ public:
void heroBonusChanged(const CGHeroInstance * hero, const Bonus & bonus, bool gain) override;
void showMarketWindow(const IMarket * market, const CGHeroInstance * visitor) override;
void showWorldViewEx(const std::vector<ObjectPosInfo> & objectPositions, bool showTerrain) override;
boost::optional<BattleAction> makeSurrenderRetreatDecision(const BattleStateInfoForRetreat & battleState) override;
std::optional<BattleAction> makeSurrenderRetreatDecision(const BattleStateInfoForRetreat & battleState) override;
void battleStart(const CCreatureSet * army1, const CCreatureSet * army2, int3 tile, const CGHeroInstance * hero1, const CGHeroInstance * hero2, bool side) override;
void battleEnd(const BattleResult * br, QueryID queryID) override;

14
AI/Nullkiller/Goals/Build.cpp
View File

@ -42,10 +42,10 @@ TGoalVec Build::getAllPossibleSubgoals()
auto expensiveBuilding = ai->ah->expensiveBuilding();
//handling for early town development to save money and focus on income
if(!t->hasBuilt(ai->ah->getMaxPossibleGoldBuilding(t)) && expensiveBuilding.is_initialized())
if(!t->hasBuilt(ai->ah->getMaxPossibleGoldBuilding(t)) && expensiveBuilding.has_value())
{
auto potentialBuilding = expensiveBuilding.get();
switch(expensiveBuilding.get().bid)
auto potentialBuilding = expensiveBuilding.value();
switch(expensiveBuilding.value().bid)
{
case BuildingID::TOWN_HALL:
case BuildingID::CITY_HALL:
@ -61,15 +61,15 @@ TGoalVec Build::getAllPossibleSubgoals()
}
}
if(immediateBuilding.is_initialized())
if(immediateBuilding.has_value())
{
ret.push_back(sptr(BuildThis(immediateBuilding.get().bid, t).setpriority(2))); //prioritize buildings we can build quick
ret.push_back(sptr(BuildThis(immediateBuilding.value().bid, t).setpriority(2))); //prioritize buildings we can build quick
}
else //try build later
{
if(expensiveBuilding.is_initialized())
if(expensiveBuilding.has_value())
{
auto potentialBuilding = expensiveBuilding.get(); //gather resources for any we can't afford
auto potentialBuilding = expensiveBuilding.value(); //gather resources for any we can't afford
auto goal = ai->ah->whatToDo(potentialBuilding.price, sptr(BuildThis(potentialBuilding.bid, t).setpriority(0.5)));
ret.push_back(goal);
}

2
AI/Nullkiller/Goals/GatherArmy.cpp
View File

@ -97,7 +97,7 @@ TGoalVec GatherArmy::getAllPossibleSubgoals()
//Do not use below code for now, rely on generic Build. Code below needs to know a lot of town/resource context to do more good than harm
/*auto bid = ai->ah->canBuildAnyStructure(t, std::vector<BuildingID>(unitsSource, unitsSource + ARRAY_COUNT(unitsSource)), 1);
if (bid.is_initialized())
if (bid.has_value())
{
auto goal = sptr(BuildThis(bid.get(), t).setpriority(priority));
if (!ai->ah->containsObjective(goal)) //avoid loops caused by reserving same objective twice

26
AI/Nullkiller/Pathfinding/AINodeStorage.cpp
View File

@ -120,7 +120,7 @@ void AINodeStorage::clear()
turnDistanceLimit[HeroRole::SCOUT] = 255;
}
boost::optional<AIPathNode *> AINodeStorage::getOrCreateNode(
std::optional<AIPathNode *> AINodeStorage::getOrCreateNode(
const int3 & pos,
const EPathfindingLayer layer,
const ChainActor * actor)
@ -131,7 +131,7 @@ boost::optional<AIPathNode *> AINodeStorage::getOrCreateNode(
if(chains[0].blocked())
{
return boost::none;
return std::nullopt;
}
for(auto i = AIPathfinding::BUCKET_SIZE - 1; i >= 0; i--)
@ -151,7 +151,7 @@ boost::optional<AIPathNode *> AINodeStorage::getOrCreateNode(
}
}
return boost::none;
return std::nullopt;
}
std::vector<CGPathNode *> AINodeStorage::getInitialNodes()
@ -175,7 +175,7 @@ std::vector<CGPathNode *> AINodeStorage::getInitialNodes()
if(!allocated)
continue;
AIPathNode * initialNode = allocated.get();
AIPathNode * initialNode = allocated.value();
initialNode->inPQ = false;
initialNode->pq = nullptr;
@ -289,10 +289,10 @@ std::vector<CGPathNode *> AINodeStorage::calculateNeighbours(
{
auto nextNode = getOrCreateNode(neighbour, i, srcNode->actor);
if(!nextNode || nextNode.get()->accessible == CGPathNode::NOT_SET)
if(!nextNode || nextNode.value()->accessible == CGPathNode::NOT_SET)
continue;
neighbours.push_back(nextNode.get());
neighbours.push_back(nextNode.value());
}
}
@ -722,7 +722,7 @@ void HeroChainCalculationTask::addHeroChain(const std::vector<ExchangeCandidate>
continue;
}
auto exchangeNode = chainNodeOptional.get();
auto exchangeNode = chainNodeOptional.value();
if(exchangeNode->action != CGPathNode::ENodeAction::UNKNOWN)
{
@ -946,7 +946,7 @@ std::vector<CGPathNode *> AINodeStorage::calculateTeleportations(
if(!node)
continue;
neighbours.push_back(node.get());
neighbours.push_back(node.value());
}
}
@ -1017,19 +1017,19 @@ struct TowmPortalFinder
return nullptr;
}
boost::optional<AIPathNode *> createTownPortalNode(const CGTownInstance * targetTown)
std::optional<AIPathNode *> createTownPortalNode(const CGTownInstance * targetTown)
{
auto bestNode = getBestInitialNodeForTownPortal(targetTown);
if(!bestNode)
return boost::none;
return std::nullopt;
auto nodeOptional = nodeStorage->getOrCreateNode(targetTown->visitablePos(), EPathfindingLayer::LAND, actor->castActor);
if(!nodeOptional)
return boost::none;
return std::nullopt;
AIPathNode * node = nodeOptional.get();
AIPathNode * node = nodeOptional.value();
float movementCost = (float)movementNeeded / (float)hero->maxMovePoints(EPathfindingLayer::LAND);
movementCost += bestNode->getCost();
@ -1095,7 +1095,7 @@ void AINodeStorage::calculateTownPortal(
#if NKAI_PATHFINDER_TRACE_LEVEL >= 1
logAi->trace("Adding town portal node at %s", targetTown->name);
#endif
output.push_back(nodeOptional.get());
output.push_back(nodeOptional.value());
}
}
}

2
AI/Nullkiller/Pathfinding/AINodeStorage.h
View File

@ -232,7 +232,7 @@ public:
const AIPathNode * destinationNode,
const NodeRange & chains) const;
boost::optional<AIPathNode *> getOrCreateNode(const int3 & coord, const EPathfindingLayer layer, const ChainActor * actor);
std::optional<AIPathNode *> getOrCreateNode(const int3 & coord, const EPathfindingLayer layer, const ChainActor * actor);
std::vector<AIPath> getChainInfo(const int3 & pos, bool isOnLand) const;
bool isTileAccessible(const HeroPtr & hero, const int3 & pos, const EPathfindingLayer layer) const;
void setHeroes(std::map<const CGHeroInstance *, HeroRole> heroes);

2
AI/Nullkiller/Pathfinding/Rules/AILayerTransitionRule.cpp
View File

@ -131,7 +131,7 @@ namespace AIPathfinding
if(boatNodeOptional)
{
AIPathNode * boatNode = boatNodeOptional.get();
AIPathNode * boatNode = boatNodeOptional.value();
if(boatNode->action == CGPathNode::UNKNOWN)
{

8
AI/Nullkiller/Pathfinding/Rules/AIMovementAfterDestinationRule.cpp
View File

@ -139,17 +139,17 @@ namespace AIPathfinding
{
if(!destinationNode->actor->allowUseResources)
{
boost::optional<AIPathNode *> questNode = nodeStorage->getOrCreateNode(
std::optional<AIPathNode *> questNode = nodeStorage->getOrCreateNode(
destination.coord,
destination.node->layer,
destinationNode->actor->resourceActor);
if(!questNode || questNode.get()->getCost() < destination.cost)
if(!questNode || questNode.value()->getCost() < destination.cost)
{
return false;
}
destination.node = questNode.get();
destination.node = questNode.value();
nodeStorage->commit(destination, source);
AIPreviousNodeRule(nodeStorage).process(source, destination, pathfinderConfig, pathfinderHelper);
@ -259,7 +259,7 @@ namespace AIPathfinding
return false;
}
AIPathNode * battleNode = battleNodeOptional.get();
auto * battleNode = battleNodeOptional.value();
if(battleNode->locked)
{

6
AI/VCAI/AIhelper.cpp
View File

@ -50,17 +50,17 @@ BuildingID AIhelper::getMaxPossibleGoldBuilding(const CGTownInstance * t)
return buildingManager->getMaxPossibleGoldBuilding(t);
}
boost::optional<PotentialBuilding> AIhelper::immediateBuilding() const
std::optional<PotentialBuilding> AIhelper::immediateBuilding() const
{
return buildingManager->immediateBuilding();
}
boost::optional<PotentialBuilding> AIhelper::expensiveBuilding() const
std::optional<PotentialBuilding> AIhelper::expensiveBuilding() const
{
return buildingManager->expensiveBuilding();
}
boost::optional<BuildingID> AIhelper::canBuildAnyStructure(const CGTownInstance * t, const std::vector<BuildingID> & buildList, unsigned int maxDays) const
std::optional<BuildingID> AIhelper::canBuildAnyStructure(const CGTownInstance * t, const std::vector<BuildingID> & buildList, unsigned int maxDays) const
{
return buildingManager->canBuildAnyStructure(t, buildList, maxDays);
}

6
AI/VCAI/AIhelper.h
View File

@ -52,9 +52,9 @@ public:
bool getBuildingOptions(const CGTownInstance * t) override;
BuildingID getMaxPossibleGoldBuilding(const CGTownInstance * t);
boost::optional<PotentialBuilding> immediateBuilding() const override;
boost::optional<PotentialBuilding> expensiveBuilding() const override;
boost::optional<BuildingID> canBuildAnyStructure(const CGTownInstance * t, const std::vector<BuildingID> & buildList, unsigned int maxDays = 7) const override;
std::optional<PotentialBuilding> immediateBuilding() const override;
std::optional<PotentialBuilding> expensiveBuilding() const override;
std::optional<BuildingID> canBuildAnyStructure(const CGTownInstance * t, const std::vector<BuildingID> & buildList, unsigned int maxDays = 7) const override;
Goals::TGoalVec howToVisitTile(const HeroPtr & hero, const int3 & tile, bool allowGatherArmy = true) const override;
Goals::TGoalVec howToVisitObj(const HeroPtr & hero, ObjectIdRef obj, bool allowGatherArmy = true) const override;

18
AI/VCAI/BuildingManager.cpp
View File

@ -99,7 +99,7 @@ bool BuildingManager::tryBuildAnyStructure(const CGTownInstance * t, std::vector
return false; //Can't build anything
}
boost::optional<BuildingID> BuildingManager::canBuildAnyStructure(const CGTownInstance * t, const std::vector<BuildingID> & buildList, unsigned int maxDays) const
std::optional<BuildingID> BuildingManager::canBuildAnyStructure(const CGTownInstance * t, const std::vector<BuildingID> & buildList, unsigned int maxDays) const
{
for (const auto & building : buildList)
{
@ -109,11 +109,11 @@ boost::optional<BuildingID> BuildingManager::canBuildAnyStructure(const CGTownIn
{
case EBuildingState::ALLOWED:
case EBuildingState::NO_RESOURCES: //TODO: allow this via optional parameter?
return boost::optional<BuildingID>(building);
return std::optional<BuildingID>(building);
break;
}
}
return boost::optional<BuildingID>(); //Can't build anything
return std::optional<BuildingID>(); //Can't build anything
}
bool BuildingManager::tryBuildNextStructure(const CGTownInstance * t, std::vector<BuildingID> buildList, unsigned int maxDays)
@ -240,18 +240,18 @@ BuildingID BuildingManager::getMaxPossibleGoldBuilding(const CGTownInstance * t)
return BuildingID::VILLAGE_HALL;
}
boost::optional<PotentialBuilding> BuildingManager::immediateBuilding() const
std::optional<PotentialBuilding> BuildingManager::immediateBuilding() const
{
if (immediateBuildings.size())
return boost::optional<PotentialBuilding>(immediateBuildings.front()); //back? whatever
return std::optional<PotentialBuilding>(immediateBuildings.front()); //back? whatever
else
return boost::optional<PotentialBuilding>();
return std::optional<PotentialBuilding>();
}
boost::optional<PotentialBuilding> BuildingManager::expensiveBuilding() const
std::optional<PotentialBuilding> BuildingManager::expensiveBuilding() const
{
if (expensiveBuildings.size())
return boost::optional<PotentialBuilding>(expensiveBuildings.front());
return std::optional<PotentialBuilding>(expensiveBuildings.front());
else
return boost::optional<PotentialBuilding>();
return std::optional<PotentialBuilding>();
}

12
AI/VCAI/BuildingManager.h
View File

@ -33,9 +33,9 @@ public:
virtual void setAI(VCAI * AI) = 0;
virtual bool getBuildingOptions(const CGTownInstance * t) = 0;
virtual boost::optional<PotentialBuilding> immediateBuilding() const = 0;
virtual boost::optional<PotentialBuilding> expensiveBuilding() const = 0;
virtual boost::optional<BuildingID> canBuildAnyStructure(const CGTownInstance * t, const std::vector<BuildingID> & buildList, unsigned int maxDays) const = 0;
virtual std::optional<PotentialBuilding> immediateBuilding() const = 0;
virtual std::optional<PotentialBuilding> expensiveBuilding() const = 0;
virtual std::optional<BuildingID> canBuildAnyStructure(const CGTownInstance * t, const std::vector<BuildingID> & buildList, unsigned int maxDays) const = 0;
};
class DLL_EXPORT BuildingManager : public IBuildingManager
@ -52,9 +52,9 @@ public:
//try build anything in given town, and execute resulting Goal if any
bool getBuildingOptions(const CGTownInstance * t) override;
BuildingID getMaxPossibleGoldBuilding(const CGTownInstance * t);
boost::optional<PotentialBuilding> immediateBuilding() const override;
boost::optional<PotentialBuilding> expensiveBuilding() const override;
boost::optional<BuildingID> canBuildAnyStructure(const CGTownInstance * t, const std::vector<BuildingID> & buildList, unsigned int maxDays = 7) const override;
std::optional<PotentialBuilding> immediateBuilding() const override;
std::optional<PotentialBuilding> expensiveBuilding() const override;
std::optional<BuildingID> canBuildAnyStructure(const CGTownInstance * t, const std::vector<BuildingID> & buildList, unsigned int maxDays = 7) const override;
protected:

6
AI/VCAI/FuzzyEngines.cpp
View File

@ -399,12 +399,12 @@ float VisitObjEngine::evaluate(Goals::VisitObj & goal)
return -100; // FIXME: Added check when goal was used for hero instead of VisitHero, but crashes are bad anyway
}
boost::optional<int> objValueKnownByAI = MapObjectsEvaluator::getInstance().getObjectValue(obj);
std::optional<int> objValueKnownByAI = MapObjectsEvaluator::getInstance().getObjectValue(obj);
int objValue = 0;
if(objValueKnownByAI != boost::none) //consider adding value manipulation based on object instances on map
if(objValueKnownByAI != std::nullopt) //consider adding value manipulation based on object instances on map
{
objValue = std::min(std::max(objValueKnownByAI.get(), 0), 20000);
objValue = std::min(std::max(objValueKnownByAI.value(), 0), 20000);
}
else
{

14
AI/VCAI/Goals/Build.cpp
View File

@ -39,10 +39,10 @@ TGoalVec Build::getAllPossibleSubgoals()
auto expensiveBuilding = ai->ah->expensiveBuilding();
//handling for early town development to save money and focus on income
if(!t->hasBuilt(ai->ah->getMaxPossibleGoldBuilding(t)) && expensiveBuilding.is_initialized())
if(!t->hasBuilt(ai->ah->getMaxPossibleGoldBuilding(t)) && expensiveBuilding.has_value())
{
auto potentialBuilding = expensiveBuilding.get();
switch(expensiveBuilding.get().bid)
auto potentialBuilding = expensiveBuilding.value();
switch(expensiveBuilding.value().bid)
{
case BuildingID::TOWN_HALL:
case BuildingID::CITY_HALL:
@ -58,15 +58,15 @@ TGoalVec Build::getAllPossibleSubgoals()
}
}
if(immediateBuilding.is_initialized())
if(immediateBuilding.has_value())
{
ret.push_back(sptr(BuildThis(immediateBuilding.get().bid, t).setpriority(2))); //prioritize buildings we can build quick
ret.push_back(sptr(BuildThis(immediateBuilding.value().bid, t).setpriority(2))); //prioritize buildings we can build quick
}
else //try build later
{
if(expensiveBuilding.is_initialized())
if(expensiveBuilding.has_value())
{
auto potentialBuilding = expensiveBuilding.get(); //gather resources for any we can't afford
auto potentialBuilding = expensiveBuilding.value(); //gather resources for any we can't afford
auto goal = ai->ah->whatToDo(potentialBuilding.price, sptr(BuildThis(potentialBuilding.bid, t).setpriority(0.5)));
ret.push_back(goal);
}

2
AI/VCAI/Goals/GatherArmy.cpp
View File

@ -94,7 +94,7 @@ TGoalVec GatherArmy::getAllPossibleSubgoals()
//Do not use below code for now, rely on generic Build. Code below needs to know a lot of town/resource context to do more good than harm
/*auto bid = ai->ah->canBuildAnyStructure(t, std::vector<BuildingID>(unitsSource, unitsSource + std::size(unitsSource)), 1);
if (bid.is_initialized())
if (bid.has_value())
{
auto goal = sptr(BuildThis(bid.get(), t).setpriority(priority));
if (!ai->ah->containsObjective(goal)) //avoid loops caused by reserving same objective twice

10
AI/VCAI/MapObjectsEvaluator.cpp
View File

@ -28,9 +28,9 @@ MapObjectsEvaluator::MapObjectsEvaluator()
auto handler = VLC->objtypeh->getHandlerFor(primaryID, secondaryID);
if(handler && !handler->isStaticObject())
{
if(handler->getAiValue() != boost::none)
if(handler->getAiValue() != std::nullopt)
{
objectDatabase[CompoundMapObjectID(primaryID, secondaryID)] = handler->getAiValue().get();
objectDatabase[CompoundMapObjectID(primaryID, secondaryID)] = handler->getAiValue().value();
}
else //some default handling when aiValue not found, objects that require advanced properties (unavailable from handler) get their value calculated in getObjectValue
{
@ -41,7 +41,7 @@ MapObjectsEvaluator::MapObjectsEvaluator()
}
}
boost::optional<int> MapObjectsEvaluator::getObjectValue(int primaryID, int secondaryID) const
std::optional<int> MapObjectsEvaluator::getObjectValue(int primaryID, int secondaryID) const
{
CompoundMapObjectID internalIdentifier = CompoundMapObjectID(primaryID, secondaryID);
auto object = objectDatabase.find(internalIdentifier);
@ -49,10 +49,10 @@ boost::optional<int> MapObjectsEvaluator::getObjectValue(int primaryID, int seco
return object->second;
logGlobal->trace("Unknown object for AI, ID: " + std::to_string(primaryID) + ", SubID: " + std::to_string(secondaryID));
return boost::optional<int>();
return std::optional<int>();
}
boost::optional<int> MapObjectsEvaluator::getObjectValue(const CGObjectInstance * obj) const
std::optional<int> MapObjectsEvaluator::getObjectValue(const CGObjectInstance * obj) const
{
if(obj->ID == Obj::HERO)
{

4
AI/VCAI/MapObjectsEvaluator.h
View File

@ -18,8 +18,8 @@ private:
public:
MapObjectsEvaluator();
static MapObjectsEvaluator & getInstance();
boost::optional<int> getObjectValue(int primaryID, int secondaryID) const;
boost::optional<int> getObjectValue(const CGObjectInstance * obj) const;
std::optional<int> getObjectValue(int primaryID, int secondaryID) const;
std::optional<int> getObjectValue(const CGObjectInstance * obj) const;
void addObjectData(int primaryID, int secondaryID, int value);
void removeObjectData(int primaryID, int secondaryID);
};

16
AI/VCAI/Pathfinding/AINodeStorage.cpp
View File

@ -83,7 +83,7 @@ bool AINodeStorage::isBattleNode(const CGPathNode * node) const
return (getAINode(node)->chainMask & BATTLE_CHAIN) > 0;
}
boost::optional<AIPathNode *> AINodeStorage::getOrCreateNode(const int3 & pos, const EPathfindingLayer layer, int chainNumber)
std::optional<AIPathNode *> AINodeStorage::getOrCreateNode(const int3 & pos, const EPathfindingLayer layer, int chainNumber)
{
auto chains = nodes[layer][pos.z][pos.x][pos.y];
@ -102,15 +102,13 @@ boost::optional<AIPathNode *> AINodeStorage::getOrCreateNode(const int3 & pos, c
}
}
return boost::none;
return std::nullopt;
}
std::vector<CGPathNode *> AINodeStorage::getInitialNodes()
{
auto hpos = hero->visitablePos();
auto initialNode =
getOrCreateNode(hpos, hero->boat ? EPathfindingLayer::SAIL : EPathfindingLayer::LAND, NORMAL_CHAIN)
.get();
auto initialNode = getOrCreateNode(hpos, hero->boat ? EPathfindingLayer::SAIL : EPathfindingLayer::LAND, NORMAL_CHAIN).value();
initialNode->turns = 0;
initialNode->moveRemains = hero->movement;
@ -171,10 +169,10 @@ std::vector<CGPathNode *> AINodeStorage::calculateNeighbours(
{
auto nextNode = getOrCreateNode(neighbour, i, srcNode->chainMask);
if(!nextNode || nextNode.get()->accessible == CGPathNode::NOT_SET)
if(!nextNode || nextNode.value()->accessible == CGPathNode::NOT_SET)
continue;
neighbours.push_back(nextNode.get());
neighbours.push_back(nextNode.value());
}
}
@ -207,7 +205,7 @@ std::vector<CGPathNode *> AINodeStorage::calculateTeleportations(
if(!node)
continue;
neighbours.push_back(node.get());
neighbours.push_back(node.value());
}
}
@ -273,7 +271,7 @@ void AINodeStorage::calculateTownPortalTeleportations(
logAi->trace("Adding town portal node at %s", targetTown->name);
#endif
AIPathNode * node = nodeOptional.get();
AIPathNode * node = nodeOptional.value();
node->theNodeBefore = source.node;
node->specialAction.reset(new AIPathfinding::TownPortalAction(targetTown));

2
AI/VCAI/Pathfinding/AINodeStorage.h
View File

@ -107,7 +107,7 @@ public:
bool isBattleNode(const CGPathNode * node) const;
bool hasBetterChain(const PathNodeInfo & source, CDestinationNodeInfo & destination) const;
boost::optional<AIPathNode *> getOrCreateNode(const int3 & coord, const EPathfindingLayer layer, int chainNumber);
std::optional<AIPathNode *> getOrCreateNode(const int3 & coord, const EPathfindingLayer layer, int chainNumber);
std::vector<AIPath> getChainInfo(const int3 & pos, bool isOnLand) const;
bool isTileAccessible(const int3 & pos, const EPathfindingLayer layer) const;

6
AI/VCAI/Pathfinding/PathfindingManager.cpp
View File

@ -114,7 +114,7 @@ Goals::TGoalVec PathfindingManager::findPath(
const std::function<Goals::TSubgoal(int3)> doVisitTile) const
{
Goals::TGoalVec result;
boost::optional<uint64_t> armyValueRequired;
std::optional<uint64_t> armyValueRequired;
uint64_t danger;
std::vector<AIPath> chainInfo = pathfinder->getPathInfo(hero, dest);
@ -165,12 +165,12 @@ Goals::TGoalVec PathfindingManager::findPath(
if(!armyValueRequired || armyValueRequired > danger)
{
armyValueRequired = boost::make_optional(danger);
armyValueRequired = std::make_optional(danger);
}
}
}
danger = armyValueRequired.get_value_or(0);
danger = armyValueRequired.value_or(0);
if(allowGatherArmy && danger > 0)
{

2
AI/VCAI/Pathfinding/Rules/AILayerTransitionRule.cpp
View File

@ -120,7 +120,7 @@ namespace AIPathfinding
if(boatNodeOptional)
{
AIPathNode * boatNode = boatNodeOptional.get();
AIPathNode * boatNode = boatNodeOptional.value();
if(boatNode->action == CGPathNode::UNKNOWN)
{

2
AI/VCAI/Pathfinding/Rules/AIMovementAfterDestinationRule.cpp
View File

@ -106,7 +106,7 @@ namespace AIPathfinding
return;
}
AIPathNode * battleNode = battleNodeOptional.get();
auto * battleNode = battleNodeOptional.value();
if(battleNode->locked)
{

13
AI/VCAI/VCAI.cpp
View File

@ -1241,14 +1241,14 @@ void VCAI::recruitCreatures(const CGDwelling * d, const CArmedInstance * recruit
}
}
bool VCAI::isGoodForVisit(const CGObjectInstance * obj, HeroPtr h, boost::optional<float> movementCostLimit)
bool VCAI::isGoodForVisit(const CGObjectInstance * obj, HeroPtr h, std::optional<float> movementCostLimit)
{
int3 op = obj->visitablePos();
auto paths = ah->getPathsToTile(h, op);
for(const auto & path : paths)
{
if(movementCostLimit && movementCostLimit.get() < path.movementCost())
if(movementCostLimit && movementCostLimit.value() < path.movementCost())
return false;
if(isGoodForVisit(obj, h, path))
@ -1363,18 +1363,13 @@ void VCAI::wander(HeroPtr h)
});
int pass = 0;
std::vector<boost::optional<float>> distanceLimits =
{
1.0,
2.0,
boost::none
};
std::vector<std::optional<float>> distanceLimits = {1.0, 2.0, std::nullopt};
while(!dests.size() && pass < distanceLimits.size())
{
auto & distanceLimit = distanceLimits[pass];
logAi->debug("Looking for wander destination pass=%i, cost limit=%f", pass, distanceLimit.get_value_or(-1.0));
logAi->debug("Looking for wander destination pass=%i, cost limit=%f", pass, distanceLimit.value_or(-1.0));
vstd::copy_if(visitableObjs, std::back_inserter(dests), [&](ObjectIdRef obj) -> bool
{

2
AI/VCAI/VCAI.h
View File

@ -217,7 +217,7 @@ public:
void completeGoal(Goals::TSubgoal goal); //safely removes goal from reserved hero
void recruitHero(const CGTownInstance * t, bool throwing = false);
bool isGoodForVisit(const CGObjectInstance * obj, HeroPtr h, boost::optional<float> movementCostLimit = boost::none);
bool isGoodForVisit(const CGObjectInstance * obj, HeroPtr h, std::optional<float> movementCostLimit = std::nullopt);
bool isGoodForVisit(const CGObjectInstance * obj, HeroPtr h, const AIPath & path) const;
//void recruitCreatures(const CGTownInstance * t);
void recruitCreatures(const CGDwelling * d, const CArmedInstance * recruiter);

13
CCallback.cpp
View File

@ -90,7 +90,7 @@ bool CCallback::upgradeCreature(const CArmedInstance *obj, SlotID stackPos, Crea
void CCallback::endTurn()
{
logGlobal->trace("Player %d ended his turn.", player.get().getNum());
logGlobal->trace("Player %d ended his turn.", player->getNum());
EndTurn pack;
sendRequest(&pack);
}
@ -306,8 +306,8 @@ void CCallback::buildBoat( const IShipyard *obj )
sendRequest(&bb);
}
CCallback::CCallback(CGameState * GS, boost::optional<PlayerColor> Player, CClient * C)
: CBattleCallback(Player, C)
CCallback::CCallback(CGameState * GS, std::optional<PlayerColor> Player, CClient * C):
CBattleCallback(Player, C)
{
gs = GS;
@ -380,7 +380,7 @@ scripting::Pool * CBattleCallback::getContextPool() const
}
#endif
CBattleCallback::CBattleCallback(boost::optional<PlayerColor> Player, CClient *C )
CBattleCallback::CBattleCallback(std::optional<PlayerColor> Player, CClient * C)
{
player = Player;
cl = C;
@ -395,8 +395,7 @@ bool CBattleCallback::battleMakeTacticAction( BattleAction * action )
return true;
}
boost::optional<BattleAction> CBattleCallback::makeSurrenderRetreatDecision(
const BattleStateInfoForRetreat & battleState)
std::optional<BattleAction> CBattleCallback::makeSurrenderRetreatDecision(const BattleStateInfoForRetreat & battleState)
{
return cl->playerint[getPlayerID().get()]->makeSurrenderRetreatDecision(battleState);
return cl->playerint[getPlayerID().value()]->makeSurrenderRetreatDecision(battleState);
}

8
CCallback.h
View File

@ -54,7 +54,7 @@ public:
//battle
virtual int battleMakeAction(const BattleAction * action) = 0;//for casting spells by hero - DO NOT use it for moving active stack
virtual bool battleMakeTacticAction(BattleAction * action) = 0; // performs tactic phase actions
virtual boost::optional<BattleAction> makeSurrenderRetreatDecision(const BattleStateInfoForRetreat & battleState) = 0;
virtual std::optional<BattleAction> makeSurrenderRetreatDecision(const BattleStateInfoForRetreat & battleState) = 0;
};
class IGameActionCallback
@ -113,10 +113,10 @@ protected:
CClient *cl;
public:
CBattleCallback(boost::optional<PlayerColor> Player, CClient *C);
CBattleCallback(std::optional<PlayerColor> Player, CClient * C);
int battleMakeAction(const BattleAction * action) override;//for casting spells by hero - DO NOT use it for moving active stack
bool battleMakeTacticAction(BattleAction * action) override; // performs tactic phase actions
boost::optional<BattleAction> makeSurrenderRetreatDecision(const BattleStateInfoForRetreat & battleState) override;
std::optional<BattleAction> makeSurrenderRetreatDecision(const BattleStateInfoForRetreat & battleState) override;
#if SCRIPTING_ENABLED
scripting::Pool * getContextPool() const override;
@ -131,7 +131,7 @@ class CCallback : public CPlayerSpecificInfoCallback,
public CBattleCallback
{
public:
CCallback(CGameState * GS, boost::optional<PlayerColor> Player, CClient *C);
CCallback(CGameState * GS, std::optional<PlayerColor> Player, CClient * C);
virtual ~CCallback();
//client-specific functionalities (pathfinding)

16
Global.h
View File

@ -577,8 +577,8 @@ namespace vstd
return i >= 0 && i < c.size();
}
template <typename Container, typename Index>
boost::optional<typename Container::const_reference> tryAt(const Container &c, Index i)
template<typename Container, typename Index>
std::optional<typename Container::value_type> tryAt(const Container & c, Index i)
{
if(isValidIndex(c, i))
{
@ -586,15 +586,15 @@ namespace vstd
std::advance(itr, i);
return *itr;
}
return boost::none;
return std::nullopt;
}
template <typename Container, typename Pred>
static boost::optional<typename Container::const_reference> tryFindIf(const Container &r, const Pred &t)
template<typename Container, typename Pred>
static std::optional<typename Container::const_reference> tryFindIf(const Container & r, const Pred & t)
{
auto pos = range::find_if(r, t);
if(pos == boost::end(r))
return boost::none;
return std::nullopt;
else
return *pos;
}
@ -669,8 +669,8 @@ namespace vstd
return false;
}
template <class M, class Key, class F>
typename M::mapped_type & getOrCompute(M & m, Key const & k, F f)
template<class M, class Key, class F>
typename M::mapped_type & getOrCompute(M & m, const Key & k, F f)
{
typedef typename M::mapped_type V;

8
client/CPlayerInterface.cpp
View File

@ -328,7 +328,7 @@ void CPlayerInterface::heroMoved(const TryMoveHero & details, bool verbose)
if (details.result == TryMoveHero::EMBARK || details.result == TryMoveHero::DISEMBARK)
{
if(hero->getRemovalSound() && hero->tempOwner == playerID)
CCS->soundh->playSound(hero->getRemovalSound().get());
CCS->soundh->playSound(hero->getRemovalSound().value());
}
adventureInt->minimap->updateTile(hero->convertToVisitablePos(details.start));
@ -463,7 +463,7 @@ void CPlayerInterface::heroVisit(const CGHeroInstance * visitor, const CGObjectI
if(start && visitedObj)
{
if(visitedObj->getVisitSound())
CCS->soundh->playSound(visitedObj->getVisitSound().get());
CCS->soundh->playSound(visitedObj->getVisitSound().value());
}
}
@ -1530,7 +1530,7 @@ void CPlayerInterface::objectRemoved(const CGObjectInstance * obj)
if(LOCPLINT->cb->getCurrentPlayer() == playerID && obj->getRemovalSound())
{
waitWhileDialog();
CCS->soundh->playSound(obj->getRemovalSound().get());
CCS->soundh->playSound(obj->getRemovalSound().value());
}
CGI->mh->waitForOngoingAnimations();
@ -1758,7 +1758,7 @@ void CPlayerInterface::acceptTurn()
if(optDaysWithoutCastle)
{
auto daysWithoutCastle = optDaysWithoutCastle.get();
auto daysWithoutCastle = optDaysWithoutCastle.value();
if (daysWithoutCastle < 6)
{
text.addTxt(MetaString::ARRAY_TXT,128); //%s, you only have %d days left to capture a town or you will be banished from this land.

4
client/Client.cpp
View File

@ -421,7 +421,7 @@ void CClient::initPlayerEnvironments()
if(settings["session"]["spectate"].Bool())
{
playerEnvironments[PlayerColor::SPECTATOR] = std::make_shared<CPlayerEnvironment>(PlayerColor::SPECTATOR, this, std::make_shared<CCallback>(gs, boost::none, this));
playerEnvironments[PlayerColor::SPECTATOR] = std::make_shared<CPlayerEnvironment>(PlayerColor::SPECTATOR, this, std::make_shared<CCallback>(gs, std::nullopt, this));
}
}
@ -626,7 +626,7 @@ void CClient::commenceTacticPhaseForInt(std::shared_ptr<CBattleGameInterface> ba
battleInt->yourTacticPhase(gs->curB->tacticDistance);
if(gs && !!gs->curB && gs->curB->tacticDistance) //while awaiting for end of tactics phase, many things can happen (end of battle... or game)
{
MakeAction ma(BattleAction::makeEndOFTacticPhase(gs->curB->playerToSide(battleInt->playerID).get()));
MakeAction ma(BattleAction::makeEndOFTacticPhase(gs->curB->playerToSide(battleInt->playerID).value()));
sendRequest(&ma, battleInt->playerID);
}
}

2
client/Client.h
View File

@ -140,7 +140,7 @@ public:
std::map<PlayerColor, std::vector<std::shared_ptr<IBattleEventsReceiver>>> additionalBattleInts;
boost::optional<BattleAction> curbaction;
std::optional<BattleAction> curbaction;
CClient();
~CClient();

2
client/NetPacksClient.cpp
View File

@ -762,7 +762,7 @@ void ApplyClientNetPackVisitor::visitBattleAttack(BattleAttack & pack)
void ApplyFirstClientNetPackVisitor::visitStartAction(StartAction & pack)
{
cl.curbaction = boost::make_optional(pack.ba);
cl.curbaction = std::make_optional(pack.ba);
callBattleInterfaceIfPresentForBothSides(cl, &IBattleEventsReceiver::actionStarted, pack.ba);
}

4
client/adventureMap/CAdvMapInt.cpp
View File

@ -853,7 +853,7 @@ void CAdvMapInt::keyPressed(const SDL_Keycode & key)
}
}
boost::optional<Point> CAdvMapInt::keyToMoveDirection(const SDL_Keycode & key)
std::optional<Point> CAdvMapInt::keyToMoveDirection(const SDL_Keycode & key)
{
switch (key) {
case SDLK_DOWN: return Point( 0, +1);
@ -871,7 +871,7 @@ boost::optional<Point> CAdvMapInt::keyToMoveDirection(const SDL_Keycode & key)
case SDLK_KP_8: return Point( 0, -1);
case SDLK_KP_9: return Point(+1, -1);
}
return boost::none;
return std::nullopt;
}
void CAdvMapInt::select(const CArmedInstance *sel, bool centerView)

2
client/adventureMap/CAdvMapInt.h
View File

@ -143,7 +143,7 @@ private:
const CGObjectInstance *getActiveObject(const int3 &tile);
boost::optional<Point> keyToMoveDirection(const SDL_Keycode & key);
std::optional<Point> keyToMoveDirection(const SDL_Keycode & key);
public:
CAdvMapInt();

2
client/adventureMap/MapAudioPlayer.cpp
View File

@ -136,7 +136,7 @@ std::vector<std::string> MapAudioPlayer::getAmbientSounds(const int3 & tile)
logGlobal->warn("Already removed object %d found on tile! (%d %d %d)", objectID.getNum(), tile.x, tile.y, tile.z);
if(object && object->getAmbientSound())
result.push_back(object->getAmbientSound().get());
result.push_back(object->getAmbientSound().value());
}
if(CGI->mh->getMap()->isCoastalTile(tile))

2
client/battle/BattleInterface.cpp
View File

@ -252,7 +252,7 @@ void BattleInterface::giveCommand(EActionType action, BattleHex tile, si32 addit
}
auto ba = new BattleAction(); //is deleted in CPlayerInterface::stacksController->getActiveStack()()
ba->side = side.get();
ba->side = side.value();
ba->actionType = action;
ba->aimToHex(tile);
ba->actionSubtype = additional;

12
client/battle/BattleInterfaceClasses.cpp
View File

@ -68,7 +68,7 @@ void BattleConsole::showAll(SDL_Surface * to)
std::vector<std::string> BattleConsole::getVisibleText()
{
// high priority texts that hide battle log entries
for (auto const & text : {consoleText, hoverText} )
for(const auto & text : {consoleText, hoverText})
{
if (text.empty())
continue;
@ -94,7 +94,7 @@ std::vector<std::string> BattleConsole::splitText(const std::string &text)
boost::split(lines, text, boost::is_any_of("\n"));
for (auto const & line : lines)
for(const auto & line : lines)
{
if (graphics->fonts[FONT_SMALL]->getStringWidth(text) < pos.w)
{
@ -679,7 +679,7 @@ int32_t StackQueue::getSiegeShooterIconID()
return owner.siegeController->getSiegedTown()->town->faction->getIndex();
}
boost::optional<uint32_t> StackQueue::getHoveredUnitIdIfAny() const
std::optional<uint32_t> StackQueue::getHoveredUnitIdIfAny() const
{
for(const auto & stackBox : stackBoxes)
{
@ -689,7 +689,7 @@ boost::optional<uint32_t> StackQueue::getHoveredUnitIdIfAny() const
}
}
return boost::none;
return std::nullopt;
}
StackQueue::StackBox::StackBox(StackQueue * owner):
@ -758,7 +758,7 @@ void StackQueue::StackBox::setUnit(const battle::Unit * unit, size_t turn)
}
else
{
boundUnitID = boost::none;
boundUnitID = std::nullopt;
background->colorize(PlayerColor::NEUTRAL);
icon->visible = false;
icon->setFrame(0);
@ -769,7 +769,7 @@ void StackQueue::StackBox::setUnit(const battle::Unit * unit, size_t turn)
}
}
boost::optional<uint32_t> StackQueue::StackBox::getBoundUnitID() const
std::optional<uint32_t> StackQueue::StackBox::getBoundUnitID() const
{
return boundUnitID;
}

6
client/battle/BattleInterfaceClasses.h
View File

@ -166,7 +166,7 @@ class StackQueue : public CIntObject
class StackBox : public CIntObject
{
StackQueue * owner;
boost::optional<uint32_t> boundUnitID;
std::optional<uint32_t> boundUnitID;
bool highlighted = false;
public:
@ -178,7 +178,7 @@ class StackQueue : public CIntObject
StackBox(StackQueue * owner);
void setUnit(const battle::Unit * unit, size_t turn = 0);
void toggleHighlight(bool value);
boost::optional<uint32_t> getBoundUnitID() const;
std::optional<uint32_t> getBoundUnitID() const;
void show(SDL_Surface * to) override;
};
@ -197,7 +197,7 @@ public:
StackQueue(bool Embedded, BattleInterface & owner);
void update();
boost::optional<uint32_t> getHoveredUnitIdIfAny() const;
std::optional<uint32_t> getHoveredUnitIdIfAny() const;
void show(SDL_Surface * to) override;
};

6
client/battle/BattleObstacleController.cpp
View File

@ -66,7 +66,7 @@ void BattleObstacleController::loadObstacleImage(const CObstacleInstance & oi)
void BattleObstacleController::obstacleRemoved(const std::vector<ObstacleChanges> & obstacles)
{
for (auto const & oi : obstacles)
for(const auto & oi : obstacles)
{
auto & obstacle = oi.data["obstacle"];
@ -97,11 +97,11 @@ void BattleObstacleController::obstacleRemoved(const std::vector<ObstacleChanges
void BattleObstacleController::obstaclePlaced(const std::vector<std::shared_ptr<const CObstacleInstance>> & obstacles)
{
for (auto const & oi : obstacles)
for(const auto & oi : obstacles)
{
auto side = owner.curInt->cb->playerToSide(owner.curInt->playerID);
if(!oi->visibleForSide(side.get(),owner.curInt->cb->battleHasNativeStack(side.get())))
if(!oi->visibleForSide(side.value(), owner.curInt->cb->battleHasNativeStack(side.value())))
continue;
auto animation = std::make_shared<CAnimation>(oi->getAppearAnimation());

12
client/battle/BattleStacksController.cpp
View File

@ -281,7 +281,7 @@ std::shared_ptr<IImage> BattleStacksController::getStackAmountBox(const CStack *
int effectsPositivness = 0;
for ( auto const & spellID : activeSpells)
for(const auto & spellID : activeSpells)
effectsPositivness += CGI->spellh->objects.at(spellID)->positiveness;
if (effectsPositivness > 0)
@ -336,7 +336,7 @@ void BattleStacksController::showStackAmountBox(Canvas & canvas, const CStack *
void BattleStacksController::showStack(Canvas & canvas, const CStack * stack)
{
ColorFilter fullFilter = ColorFilter::genEmptyShifter();
for (auto const & filter : stackFilterEffects)
for(const auto & filter : stackFilterEffects)
{
if (filter.target == stack)
fullFilter = ColorFilter::genCombined(fullFilter, filter.effect);
@ -814,7 +814,7 @@ void BattleStacksController::updateHoveredStacks()
{
auto newStacks = selectHoveredStacks();
for (auto const * stack : mouseHoveredStacks)
for(const auto * stack : mouseHoveredStacks)
{
if (vstd::contains(newStacks, stack))
continue;
@ -825,7 +825,7 @@ void BattleStacksController::updateHoveredStacks()
stackAnimation[stack->ID]->setBorderColor(AnimationControls::getNoBorder());
}
for (auto const * stack : newStacks)
for(const auto * stack : newStacks)
{
if (vstd::contains(mouseHoveredStacks, stack))
continue;
@ -848,7 +848,7 @@ std::vector<const CStack *> BattleStacksController::selectHoveredStacks()
return {};
auto hoveredQueueUnitId = owner.windowObject->getQueueHoveredUnitId();
if(hoveredQueueUnitId.is_initialized())
if(hoveredQueueUnitId.has_value())
{
return { owner.curInt->cb->battleGetStackByID(hoveredQueueUnitId.value(), true) };
}
@ -889,7 +889,7 @@ std::vector<const CStack *> BattleStacksController::selectHoveredStacks()
const std::vector<uint32_t> BattleStacksController::getHoveredStacksUnitIds() const
{
auto result = std::vector<uint32_t>();
for (auto const * stack : mouseHoveredStacks)
for(const auto * stack : mouseHoveredStacks)
{
result.push_back(stack->unitId());
}

2
client/battle/BattleWindow.cpp
View File

@ -590,7 +590,7 @@ void BattleWindow::blockUI(bool on)
}
}
boost::optional<uint32_t> BattleWindow::getQueueHoveredUnitId()
std::optional<uint32_t> BattleWindow::getQueueHoveredUnitId()
{
return queue->getHoveredUnitIdIfAny();
}

2
client/battle/BattleWindow.h
View File

@ -80,7 +80,7 @@ public:
void updateQueue();
/// Get mouse-hovered battle queue unit ID if any found
boost::optional<uint32_t> getQueueHoveredUnitId();
std::optional<uint32_t> getQueueHoveredUnitId();
void activate() override;
void deactivate() override;

12
client/widgets/Buttons.cpp
View File

@ -57,15 +57,15 @@ void CButton::update()
redraw();
}
void CButton::setBorderColor(boost::optional<SDL_Color> borderColor)
void CButton::setBorderColor(std::optional<SDL_Color> borderColor)
{
setBorderColor(borderColor, borderColor, borderColor, borderColor);
}
void CButton::setBorderColor(boost::optional<SDL_Color> normalBorderColor,
boost::optional<SDL_Color> pressedBorderColor,
boost::optional<SDL_Color> blockedBorderColor,
boost::optional<SDL_Color> highlightedBorderColor)
void CButton::setBorderColor(std::optional<SDL_Color> normalBorderColor,
std::optional<SDL_Color> pressedBorderColor,
std::optional<SDL_Color> blockedBorderColor,
std::optional<SDL_Color> highlightedBorderColor)
{
stateToBorderColor[NORMAL] = normalBorderColor;
stateToBorderColor[PRESSED] = pressedBorderColor;
@ -591,7 +591,7 @@ void CSlider::setScrollBounds(const Rect & bounds )
void CSlider::clearScrollBounds()
{
scrollBounds = boost::none;
scrollBounds = std::nullopt;
}
int CSlider::getAmount() const

14
client/widgets/Buttons.h
View File

@ -52,7 +52,7 @@ private:
std::array<int, 4> stateToIndex; // mapping of button state to index of frame in animation
std::array<std::string, 4> hoverTexts; //texts for statusbar, if empty - first entry will be used
std::array<boost::optional<SDL_Color>, 4> stateToBorderColor; // mapping of button state to border color
std::array<std::optional<SDL_Color>, 4> stateToBorderColor; // mapping of button state to border color
std::string helpBox; //for right-click help
std::shared_ptr<CAnimImage> image; //image for this button
@ -73,13 +73,13 @@ public:
// sets border color for each button state;
// if it's set, the button will have 1-px border around it with this color
void setBorderColor(boost::optional<SDL_Color> normalBorderColor,
boost::optional<SDL_Color> pressedBorderColor,
boost::optional<SDL_Color> blockedBorderColor,
boost::optional<SDL_Color> highlightedBorderColor);
void setBorderColor(std::optional<SDL_Color> normalBorderColor,
std::optional<SDL_Color> pressedBorderColor,
std::optional<SDL_Color> blockedBorderColor,
std::optional<SDL_Color> highlightedBorderColor);
// sets the same border color for all button states.
void setBorderColor(boost::optional<SDL_Color> borderColor);
void setBorderColor(std::optional<SDL_Color> borderColor);
/// adds one more callback to on-click actions
void addCallback(std::function<void()> callback);
@ -229,7 +229,7 @@ class CSlider : public CIntObject
std::shared_ptr<CButton> right;
std::shared_ptr<CButton> slider;
boost::optional<Rect> scrollBounds;
std::optional<Rect> scrollBounds;
int capacity;//how many elements can be active at same time (e.g. hero list = 5)
int positions; //number of highest position (0 if there is only one)

2
client/widgets/Images.cpp
View File

@ -85,7 +85,7 @@ void CPicture::show(SDL_Surface * to)
void CPicture::showAll(SDL_Surface * to)
{
if(bg && visible)
bg->draw(to, pos.x, pos.y, srcRect.get_ptr());
bg->draw(to, pos.x, pos.y, srcRect.has_value() ? &srcRect.value() : nullptr);
}
void CPicture::setAlpha(int value)

2
client/widgets/Images.h
View File

@ -30,7 +30,7 @@ class CPicture : public CIntObject
public:
/// if set, only specified section of internal image will be rendered
boost::optional<Rect> srcRect;
std::optional<Rect> srcRect;
/// If set to true, iamge will be redrawn on each frame
bool needRefresh;

22
client/windows/CCreatureWindow.cpp
View File

@ -64,9 +64,9 @@ public:
const CGHeroInstance * owner;
// temporary objects which should be kept as copy if needed
boost::optional<CommanderLevelInfo> levelupInfo;
boost::optional<StackDismissInfo> dismissInfo;
boost::optional<StackUpgradeInfo> upgradeInfo;
std::optional<CommanderLevelInfo> levelupInfo;
std::optional<StackDismissInfo> dismissInfo;
std::optional<StackUpgradeInfo> upgradeInfo;
// misc fields
unsigned int creatureCount;
@ -246,8 +246,8 @@ CStackWindow::BonusLineSection::BonusLineSection(CStackWindow * owner, size_t li
}
}
CStackWindow::BonusesSection::BonusesSection(CStackWindow * owner, int yOffset, boost::optional<size_t> preferredSize)
: CWindowSection(owner, "", yOffset)
CStackWindow::BonusesSection::BonusesSection(CStackWindow * owner, int yOffset, std::optional<size_t> preferredSize):
CWindowSection(owner, "", yOffset)
{
OBJECT_CONSTRUCTION_CAPTURING(255-DISPOSE);
@ -255,7 +255,7 @@ CStackWindow::BonusesSection::BonusesSection(CStackWindow * owner, int yOffset,
static const int itemHeight = 59;
size_t totalSize = (owner->activeBonuses.size() + 1) / 2;
size_t visibleSize = preferredSize ? preferredSize.get() : std::min<size_t>(3, totalSize);
size_t visibleSize = preferredSize.value_or(std::min<size_t>(3, totalSize));
pos.w = owner->pos.w;
pos.h = itemHeight * (int)visibleSize;
@ -292,7 +292,7 @@ CStackWindow::ButtonsSection::ButtonsSection(CStackWindow * owner, int yOffset)
// used space overlaps with commander switch button
// besides - should commander really be upgradeable?
UnitView::StackUpgradeInfo & upgradeInfo = parent->info->upgradeInfo.get();
auto & upgradeInfo = parent->info->upgradeInfo.value();
const size_t buttonsToCreate = std::min<size_t>(upgradeInfo.info.newID.size(), upgrade.size());
for(size_t buttonIndex = 0; buttonIndex < buttonsToCreate; buttonIndex++)
@ -686,8 +686,8 @@ CStackWindow::CStackWindow(const CStackInstance * stack, std::function<void()> d
info->creature = stack->type;
info->creatureCount = stack->count;
info->upgradeInfo = boost::make_optional(UnitView::StackUpgradeInfo());
info->dismissInfo = boost::make_optional(UnitView::StackDismissInfo());
info->upgradeInfo = std::make_optional(UnitView::StackUpgradeInfo());
info->dismissInfo = std::make_optional(UnitView::StackDismissInfo());
info->upgradeInfo->info = upgradeInfo;
info->upgradeInfo->callback = callback;
info->dismissInfo->callback = dismiss;
@ -716,7 +716,7 @@ CStackWindow::CStackWindow(const CCommanderInstance * commander, std::vector<ui3
info->creature = commander->type;
info->commander = commander;
info->creatureCount = 1;
info->levelupInfo = boost::make_optional(UnitView::CommanderLevelInfo());
info->levelupInfo = std::make_optional(UnitView::CommanderLevelInfo());
info->levelupInfo->skills = skills;
info->levelupInfo->callback = callback;
info->owner = dynamic_cast<const CGHeroInstance *> (commander->armyObj);
@ -814,7 +814,7 @@ void CStackWindow::initSections()
commanderMainSection = std::make_shared<CommanderMainSection>(this, 0);
auto size = boost::make_optional<size_t>((info->levelupInfo) ? 4 : 3);
auto size = std::make_optional<size_t>((info->levelupInfo) ? 4 : 3);
commanderBonusesSection = std::make_shared<BonusesSection>(this, 0, size);
deactivateObj(commanderBonusesSection);

2
client/windows/CCreatureWindow.h
View File

@ -83,7 +83,7 @@ class CStackWindow : public CWindowObject
{
std::shared_ptr<CListBox> lines;
public:
BonusesSection(CStackWindow * owner, int yOffset, boost::optional<size_t> preferredSize = boost::optional<size_t>());
BonusesSection(CStackWindow * owner, int yOffset, std::optional<size_t> preferredSize = std::optional<size_t>());
};
class ButtonsSection : public CWindowSection

25
lib/CArtHandler.cpp
View File

@ -740,15 +740,16 @@ void CArtHandler::erasePickedArt(const ArtifactID & id)
{
CArtifact *art = objects[id];
if(auto artifactList = listFromClass(art->aClass))
if(auto artl = listFromClass(art->aClass))
{
if(artifactList->empty())
fillList(*artifactList, art->aClass);
auto & artifactList = artl->get();
if(artifactList.empty())
fillList(artifactList, art->aClass);
auto itr = vstd::find(*artifactList, art);
if(itr != artifactList->end())
auto itr = vstd::find(artifactList, art);
if(itr != artifactList.end())
{
artifactList->erase(itr);
artifactList.erase(itr);
}
else
logMod->warn("Problem: cannot erase artifact %s from list, it was not present", art->getNameTranslated());
@ -758,20 +759,20 @@ void CArtHandler::erasePickedArt(const ArtifactID & id)
logMod->warn("Problem: cannot find list for artifact %s, strange class. (special?)", art->getNameTranslated());
}
boost::optional<std::vector<CArtifact*>&> CArtHandler::listFromClass( CArtifact::EartClass artifactClass )
std::optional<std::reference_wrapper<std::vector<CArtifact *>>> CArtHandler::listFromClass(CArtifact::EartClass artifactClass)
{
switch(artifactClass)
{
case CArtifact::ART_TREASURE:
return treasures;
return {std::ref(treasures)};
case CArtifact::ART_MINOR:
return minors;
return {std::ref(minors)};
case CArtifact::ART_MAJOR:
return majors;
return {std::ref(majors)};
case CArtifact::ART_RELIC:
return relics;
return {std::ref(relics)};
default: //special artifacts should not be erased
return boost::optional<std::vector<CArtifact*>&>();
return {};
}
}

2
lib/CArtHandler.h
View File

@ -244,7 +244,7 @@ public:
void fillList(std::vector<CArtifact*> &listToBeFilled, CArtifact::EartClass artifactClass); //fills given empty list with allowed artifacts of given class. No side effects
boost::optional<std::vector<CArtifact*>&> listFromClass(CArtifact::EartClass artifactClass);
std::optional<std::reference_wrapper<std::vector<CArtifact *>>> listFromClass(CArtifact::EartClass artifactClass);
static CArtifact::EartClass stringToClass(const std::string & className); //TODO: rework EartClass to make this a constructor

2
lib/CCreatureHandler.cpp
View File

@ -408,7 +408,7 @@ CCreatureHandler::CCreatureHandler()
const CCreature * CCreatureHandler::getCreature(const std::string & scope, const std::string & identifier) const
{
boost::optional<si32> index = VLC->modh->identifiers.getIdentifier(scope, "creature", identifier);
std::optional<si32> index = VLC->modh->identifiers.getIdentifier(scope, "creature", identifier);
if(!index)
throw std::runtime_error("Creature not found "+identifier);

4
lib/CCreatureSet.cpp
View File

@ -624,7 +624,7 @@ void CCreatureSet::armyChanged()
}
void CCreatureSet::serializeJson(JsonSerializeFormat & handler, const std::string & fieldName, const boost::optional<int> fixedSize)
void CCreatureSet::serializeJson(JsonSerializeFormat & handler, const std::string & fieldName, const std::optional<int> fixedSize)
{
if(handler.saving && stacks.empty())
return;
@ -640,7 +640,7 @@ void CCreatureSet::serializeJson(JsonSerializeFormat & handler, const std::strin
vstd::amax(sz, p.first.getNum()+1);
if(fixedSize)
vstd::amax(sz, fixedSize.get());
vstd::amax(sz, fixedSize.value());
a.resize(sz, JsonNode::JsonType::DATA_STRUCT);

4
lib/CCreatureSet.h
View File

@ -75,7 +75,7 @@ public:
uint8_t upgrade;
};
// helper variable used during loading map, when object (hero or town) have creatures that must have same alignment.
boost::optional<RandomStackInfo> randomStack;
std::optional<RandomStackInfo> randomStack;
const CArmedInstance * const & armyObj; //stack must be part of some army, army must be part of some object
TExpType experience;//commander needs same amount of exp as hero
@ -286,7 +286,7 @@ public:
h & formation;
}
void serializeJson(JsonSerializeFormat & handler, const std::string & fieldName, const boost::optional<int> fixedSize = boost::none);
void serializeJson(JsonSerializeFormat & handler, const std::string & fieldName, const std::optional<int> fixedSize = std::nullopt);
operator bool() const
{

18
lib/CGameInfoCallback.cpp
View File

@ -401,7 +401,7 @@ int CGameInfoCallback::getDate(Date::EDateType mode) const
return gs->getDate(mode);
}
bool CGameInfoCallback::isVisible(int3 pos, const boost::optional<PlayerColor> & Player) const
bool CGameInfoCallback::isVisible(int3 pos, const std::optional<PlayerColor> & Player) const
{
//boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
return gs->isVisible(pos, Player);
@ -412,7 +412,7 @@ bool CGameInfoCallback::isVisible(int3 pos) const
return isVisible(pos, player);
}
bool CGameInfoCallback::isVisible( const CGObjectInstance *obj,const boost::optional<PlayerColor> & Player) const
bool CGameInfoCallback::isVisible(const CGObjectInstance * obj, const std::optional<PlayerColor> & Player) const
{
return gs->isVisible(obj, Player);
}
@ -521,8 +521,8 @@ EDiggingStatus CGameInfoCallback::getTileDigStatus(int3 tile, bool verbose) cons
//TODO: typedef?
std::shared_ptr<const boost::multi_array<TerrainTile*, 3>> CGameInfoCallback::getAllVisibleTiles() const
{
assert(player.is_initialized());
const auto * team = getPlayerTeam(player.get());
assert(player.has_value());
const auto * team = getPlayerTeam(player.value());
size_t width = gs->map->width;
size_t height = gs->map->height;
@ -619,9 +619,9 @@ const CMapHeader * CGameInfoCallback::getMapHeader() const
return gs->map;
}
bool CGameInfoCallback::hasAccess(boost::optional<PlayerColor> playerId) const
bool CGameInfoCallback::hasAccess(std::optional<PlayerColor> playerId) const
{
return !player || player.get().isSpectator() || gs->getPlayerRelations( *playerId, *player ) != PlayerRelations::ENEMIES;
return !player || player->isSpectator() || gs->getPlayerRelations(*playerId, *player) != PlayerRelations::ENEMIES;
}
EPlayerStatus::EStatus CGameInfoCallback::getPlayerStatus(PlayerColor player, bool verbose) const
@ -703,7 +703,7 @@ PlayerColor CGameInfoCallback::getCurrentPlayer() const
return gs->currentPlayer;
}
CGameInfoCallback::CGameInfoCallback(CGameState * GS, boost::optional<PlayerColor> Player):
CGameInfoCallback::CGameInfoCallback(CGameState * GS, std::optional<PlayerColor> Player):
gs(GS)
{
player = std::move(Player);
@ -754,7 +754,7 @@ std::vector < const CGHeroInstance *> CPlayerSpecificInfoCallback::getHeroesInfo
return ret;
}
boost::optional<PlayerColor> CPlayerSpecificInfoCallback::getMyColor() const
std::optional<PlayerColor> CPlayerSpecificInfoCallback::getMyColor() const
{
return player;
}
@ -882,7 +882,7 @@ const TeamState * CGameInfoCallback::getTeam( TeamID teamID ) const
if (team != gs->teams.end())
{
const TeamState *ret = &team->second;
if (!player.is_initialized()) //neutral (or invalid) player
if(!player.has_value()) //neutral (or invalid) player
return ret;
else
{

12
lib/CGameInfoCallback.h
View File

@ -133,8 +133,8 @@ protected:
CGameState * gs;//todo: replace with protected const getter, only actual Server and Client objects should hold game state
CGameInfoCallback() = default;
CGameInfoCallback(CGameState *GS, boost::optional<PlayerColor> Player);
bool hasAccess(boost::optional<PlayerColor> playerId) const;
CGameInfoCallback(CGameState * GS, std::optional<PlayerColor> Player);
bool hasAccess(std::optional<PlayerColor> playerId) const;
bool canGetFullInfo(const CGObjectInstance *obj) const; //true we player owns obj or ally owns obj or privileged mode
bool isOwnedOrVisited(const CGObjectInstance *obj) const;
@ -157,9 +157,9 @@ public:
virtual const PlayerSettings * getPlayerSettings(PlayerColor color) const;
//map
virtual bool isVisible(int3 pos, const boost::optional<PlayerColor> & Player) const;
virtual bool isVisible(const CGObjectInstance *obj, const boost::optional<PlayerColor> & Player) const;
virtual bool isVisible(const CGObjectInstance *obj) const;
virtual bool isVisible(int3 pos, const std::optional<PlayerColor> & Player) const;
virtual bool isVisible(const CGObjectInstance * obj, const std::optional<PlayerColor> & Player) const;
virtual bool isVisible(const CGObjectInstance * obj) const;
virtual bool isVisible(int3 pos) const;
@ -234,7 +234,7 @@ public:
virtual int howManyTowns() const;
virtual int howManyHeroes(bool includeGarrisoned = true) const;
virtual int3 getGrailPos(double *outKnownRatio);
virtual boost::optional<PlayerColor> getMyColor() const;
virtual std::optional<PlayerColor> getMyColor() const;
virtual std::vector <const CGTownInstance *> getTownsInfo(bool onlyOur = true) const; //true -> only owned; false -> all visible
virtual int getHeroSerial(const CGHeroInstance * hero, bool includeGarrisoned=true) const;

4
lib/CGameInterface.h
View File

@ -110,9 +110,9 @@ public:
virtual void showWorldViewEx(const std::vector<ObjectPosInfo> & objectPositions, bool showTerrain){};
virtual boost::optional<BattleAction> makeSurrenderRetreatDecision(const BattleStateInfoForRetreat & battleState)
virtual std::optional<BattleAction> makeSurrenderRetreatDecision(const BattleStateInfoForRetreat & battleState)
{
return boost::none;
return std::nullopt;
}
virtual void saveGame(BinarySerializer & h, const int version) = 0;

12
lib/CGameState.cpp
View File

@ -925,7 +925,7 @@ void CGameState::initNewGame(const IMapService * mapService, bool allowSavingRan
void CGameState::initCampaign()
{
logGlobal->info("Open campaign map file: %d", scenarioOps->campState->currentMap.get());
logGlobal->info("Open campaign map file: %d", scenarioOps->campState->currentMap.value());
map = scenarioOps->campState->getMap();
}
@ -1068,7 +1068,7 @@ void CGameState::placeCampaignHeroes()
{
// place bonus hero
auto campaignBonus = scenarioOps->campState->getBonusForCurrentMap();
bool campaignGiveHero = campaignBonus && campaignBonus.get().type == CScenarioTravel::STravelBonus::HERO;
bool campaignGiveHero = campaignBonus && campaignBonus->type == CScenarioTravel::STravelBonus::HERO;
if(campaignGiveHero)
{
@ -1568,7 +1568,7 @@ void CGameState::initHeroes()
void CGameState::giveCampaignBonusToHero(CGHeroInstance * hero)
{
const boost::optional<CScenarioTravel::STravelBonus> & curBonus = scenarioOps->campState->getBonusForCurrentMap();
const std::optional<CScenarioTravel::STravelBonus> & curBonus = scenarioOps->campState->getBonusForCurrentMap();
if(!curBonus)
return;
@ -2234,7 +2234,7 @@ void CGameState::updateRumor()
while(!rumor.update(rumorId, rumorExtra));
}
bool CGameState::isVisible(int3 pos, const boost::optional<PlayerColor> & player) const
bool CGameState::isVisible(int3 pos, const std::optional<PlayerColor> & player) const
{
if (!map->isInTheMap(pos))
return false;
@ -2248,7 +2248,7 @@ bool CGameState::isVisible(int3 pos, const boost::optional<PlayerColor> & player
return (*getPlayerTeam(*player)->fogOfWarMap)[pos.z][pos.x][pos.y];
}
bool CGameState::isVisible( const CGObjectInstance *obj, const boost::optional<PlayerColor> & player) const
bool CGameState::isVisible(const CGObjectInstance * obj, const std::optional<PlayerColor> & player) const
{
if(!player)
return true;
@ -2433,7 +2433,7 @@ bool CGameState::checkForVictory(const PlayerColor & player, const EventConditio
case EventCondition::DAYS_WITHOUT_TOWN:
{
if (p->daysWithoutCastle)
return p->daysWithoutCastle.get() >= condition.value;
return p->daysWithoutCastle >= condition.value;
else
return false;
}

5
lib/CGameState.h
View File

@ -202,9 +202,8 @@ public:
void obtainPlayersStats(SThievesGuildInfo & tgi, int level); //fills tgi with info about other players that is available at given level of thieves' guild
std::map<ui32, ConstTransitivePtr<CGHeroInstance> > unusedHeroesFromPool(); //heroes pool without heroes that are available in taverns
bool isVisible(int3 pos, const boost::optional<PlayerColor> & player) const override;
bool isVisible(const CGObjectInstance *obj, const boost::optional<PlayerColor> & player) const override;
bool isVisible(int3 pos, const std::optional<PlayerColor> & player) const override;
bool isVisible(const CGObjectInstance * obj, const std::optional<PlayerColor> & player) const override;
int getDate(Date::EDateType mode=Date::DAY) const override; //mode=0 - total days in game, mode=1 - day of week, mode=2 - current week, mode=3 - current month

16
lib/CModHandler.cpp
View File

@ -156,7 +156,7 @@ void CIdentifierStorage::tryRequestIdentifier(const std::string & type, const Js
requestIdentifier(ObjectCallback::fromNameAndType(name.meta, type, name.String(), callback, true));
}
boost::optional<si32> CIdentifierStorage::getIdentifier(const std::string & scope, const std::string & type, const std::string & name, bool silent)
std::optional<si32> CIdentifierStorage::getIdentifier(const std::string & scope, const std::string & type, const std::string & name, bool silent)
{
auto idList = getPossibleIdentifiers(ObjectCallback::fromNameAndType(scope, type, name, std::function<void(si32)>(), silent));
@ -165,10 +165,10 @@ boost::optional<si32> CIdentifierStorage::getIdentifier(const std::string & scop
if (!silent)
logMod->error("Failed to resolve identifier %s of type %s from mod %s", name , type ,scope);
return boost::optional<si32>();
return std::optional<si32>();
}
boost::optional<si32> CIdentifierStorage::getIdentifier(const std::string & type, const JsonNode & name, bool silent)
std::optional<si32> CIdentifierStorage::getIdentifier(const std::string & type, const JsonNode & name, bool silent)
{
auto idList = getPossibleIdentifiers(ObjectCallback::fromNameAndType(name.meta, type, name.String(), std::function<void(si32)>(), silent));
@ -177,10 +177,10 @@ boost::optional<si32> CIdentifierStorage::getIdentifier(const std::string & type
if (!silent)
logMod->error("Failed to resolve identifier %s of type %s from mod %s", name.String(), type, name.meta);
return boost::optional<si32>();
return std::optional<si32>();
}
boost::optional<si32> CIdentifierStorage::getIdentifier(const JsonNode & name, bool silent)
std::optional<si32> CIdentifierStorage::getIdentifier(const JsonNode & name, bool silent)
{
auto idList = getPossibleIdentifiers(ObjectCallback::fromNameWithType(name.meta, name.String(), std::function<void(si32)>(), silent));
@ -189,10 +189,10 @@ boost::optional<si32> CIdentifierStorage::getIdentifier(const JsonNode & name, b
if (!silent)
logMod->error("Failed to resolve identifier %s from mod %s", name.String(), name.meta);
return boost::optional<si32>();
return std::optional<si32>();
}
boost::optional<si32> CIdentifierStorage::getIdentifier(const std::string & scope, const std::string & fullName, bool silent)
std::optional<si32> CIdentifierStorage::getIdentifier(const std::string & scope, const std::string & fullName, bool silent)
{
auto idList = getPossibleIdentifiers(ObjectCallback::fromNameWithType(scope, fullName, std::function<void(si32)>(), silent));
@ -201,7 +201,7 @@ boost::optional<si32> CIdentifierStorage::getIdentifier(const std::string & scop
if (!silent)
logMod->error("Failed to resolve identifier %s from mod %s", fullName, scope);
return boost::optional<si32>();
return std::optional<si32>();
}
void CIdentifierStorage::registerObject(const std::string & scope, const std::string & type, const std::string & name, si32 identifier)

8
lib/CModHandler.h
View File

@ -99,10 +99,10 @@ public:
void tryRequestIdentifier(const std::string & type, const JsonNode & name, const std::function<void(si32)> & callback);
/// get identifier immediately. If identifier is not know and not silent call will result in error message
boost::optional<si32> getIdentifier(const std::string & scope, const std::string & type, const std::string & name, bool silent = false);
boost::optional<si32> getIdentifier(const std::string & type, const JsonNode & name, bool silent = false);
boost::optional<si32> getIdentifier(const JsonNode & name, bool silent = false);
boost::optional<si32> getIdentifier(const std::string & scope, const std::string & fullName, bool silent = false);
std::optional<si32> getIdentifier(const std::string & scope, const std::string & type, const std::string & name, bool silent = false);
std::optional<si32> getIdentifier(const std::string & type, const JsonNode & name, bool silent = false);
std::optional<si32> getIdentifier(const JsonNode & name, bool silent = false);
std::optional<si32> getIdentifier(const std::string & scope, const std::string & fullName, bool silent = false);
/// registers new object
void registerObject(const std::string & scope, const std::string & type, const std::string & name, si32 identifier);

10
lib/CPathfinder.cpp
View File

@ -897,7 +897,7 @@ void CPathfinderHelper::initializePatrol()
if(hero->patrol.patrolRadius)
{
state = PATROL_RADIUS;
gs->getTilesInRange(patrolTiles, hero->patrol.initialPos, hero->patrol.patrolRadius, boost::optional<PlayerColor>(), 0, int3::DIST_MANHATTAN);
gs->getTilesInRange(patrolTiles, hero->patrol.initialPos, hero->patrol.patrolRadius, std::optional<PlayerColor>(), 0, int3::DIST_MANHATTAN);
}
else
state = PATROL_LOCKED;
@ -1100,8 +1100,12 @@ void TurnInfo::updateHeroBonuses(Bonus::BonusType type, const CSelector& sel) co
}
}
CPathfinderHelper::CPathfinderHelper(CGameState * gs, const CGHeroInstance * Hero, const PathfinderOptions & Options)
: CGameInfoCallback(gs, boost::optional<PlayerColor>()), turn(-1), hero(Hero), options(Options), owner(Hero->tempOwner)
CPathfinderHelper::CPathfinderHelper(CGameState * gs, const CGHeroInstance * Hero, const PathfinderOptions & Options):
CGameInfoCallback(gs, std::optional<PlayerColor>()),
turn(-1),
hero(Hero),
options(Options),
owner(Hero->tempOwner)
{
turnsInfo.reserve(16);
updateTurnInfo();

2
lib/CPlayerState.h
View File

@ -38,7 +38,7 @@ public:
bool enteredWinningCheatCode, enteredLosingCheatCode; //if true, this player has entered cheat codes for loss / victory
EPlayerStatus::EStatus status;
boost::optional<ui8> daysWithoutCastle;
std::optional<ui8> daysWithoutCastle;
PlayerState();
PlayerState(PlayerState && other) noexcept;

2
lib/CSkillHandler.cpp
View File

@ -262,7 +262,7 @@ si32 CSkillHandler::decodeSkill(const std::string & identifier)
{
auto rawId = VLC->modh->identifiers.getIdentifier(CModHandler::scopeMap(), "skill", identifier);
if(rawId)
return rawId.get();
return rawId.value();
else
return -1;
}

4
lib/CTownHandler.cpp
View File

@ -1151,7 +1151,7 @@ void CTownHandler::initializeRequirements()
logMod->warn("Entry contains: ");
logMod->warn(node.toJson());
}
return BuildingID(VLC->modh->identifiers.getIdentifier(requirement.town->getBuildingScope(), node.Vector()[0]).get());
return BuildingID(VLC->modh->identifiers.getIdentifier(requirement.town->getBuildingScope(), node.Vector()[0]).value());
});
}
requirementsToLoad.clear();
@ -1166,7 +1166,7 @@ void CTownHandler::initializeOverridden()
for(const auto & b : jsonNode.Vector())
{
auto bid = BuildingID(VLC->modh->identifiers.getIdentifier(scope, b).get());
auto bid = BuildingID(VLC->modh->identifiers.getIdentifier(scope, b).value());
bidHelper.building->overrideBids.insert(bid);
}
}

14
lib/GameConstants.cpp
View File

@ -64,7 +64,7 @@ si32 HeroTypeID::decode(const std::string & identifier)
{
auto rawId = VLC->modh->identifiers.getIdentifier(CModHandler::scopeMap(), "hero", identifier);
if(rawId)
return rawId.get();
return rawId.value();
else
return -1;
}
@ -88,7 +88,7 @@ si32 ArtifactID::decode(const std::string & identifier)
{
auto rawId = VLC->modh->identifiers.getIdentifier(CModHandler::scopeGame(), "artifact", identifier);
if(rawId)
return rawId.get();
return rawId.value();
else
return -1;
}
@ -112,7 +112,7 @@ si32 CreatureID::decode(const std::string & identifier)
{
auto rawId = VLC->modh->identifiers.getIdentifier(CModHandler::scopeGame(), "creature", identifier);
if(rawId)
return rawId.get();
return rawId.value();
else
return -1;
}
@ -141,7 +141,7 @@ si32 SpellID::decode(const std::string & identifier)
{
auto rawId = VLC->modh->identifiers.getIdentifier(CModHandler::scopeGame(), "spell", identifier);
if(rawId)
return rawId.get();
return rawId.value();
else
return -1;
}
@ -204,7 +204,7 @@ si32 FactionID::decode(const std::string & identifier)
{
auto rawId = VLC->modh->identifiers.getIdentifier(CModHandler::scopeGame(), "faction", identifier);
if(rawId)
return rawId.get();
return rawId.value();
else
return FactionID::DEFAULT;
}
@ -292,7 +292,7 @@ BattleField BattleField::fromString(const std::string & identifier)
auto rawId = VLC->modh->identifiers.getIdentifier(CModHandler::scopeBuiltin(), "battlefield", identifier);
if(rawId)
return BattleField(rawId.get());
return BattleField(rawId.value());
else
return BattleField::NONE;
}
@ -312,7 +312,7 @@ Obstacle Obstacle::fromString(const std::string & identifier)
auto rawId = VLC->modh->identifiers.getIdentifier(CModHandler::scopeBuiltin(), "obstacle", identifier);
if(rawId)
return Obstacle(rawId.get());
return Obstacle(rawId.value());
else
return Obstacle(-1);
}

2
lib/HeroBonus.cpp
View File

@ -1520,7 +1520,7 @@ int64_t CBonusSystemNode::getTreeVersion() const
return treeChanged;
}
std::string Bonus::Description(boost::optional<si32> customValue) const
std::string Bonus::Description(std::optional<si32> customValue) const
{
std::ostringstream str;

2
lib/HeroBonus.h
View File

@ -533,7 +533,7 @@ struct DLL_LINKAGE Bonus : public std::enable_shared_from_this<Bonus>
return sid & 0x0000FFFF;
}
std::string Description(boost::optional<si32> customValue = {}) const;
std::string Description(std::optional<si32> customValue = {}) const;
JsonNode toJsonNode() const;
std::string nameForBonus() const; // generate suitable name for bonus - e.g. for storing in json struct

4
lib/IGameCallback.cpp
View File

@ -66,7 +66,7 @@ void CPrivilegedInfoCallback::getFreeTiles(std::vector<int3> & tiles) const
void CPrivilegedInfoCallback::getTilesInRange(std::unordered_set<int3, ShashInt3> & tiles,
const int3 & pos,
int radious,
boost::optional<PlayerColor> player,
std::optional<PlayerColor> player,
int mode,
int3::EDistanceFormula distanceFormula) const
{
@ -100,7 +100,7 @@ void CPrivilegedInfoCallback::getTilesInRange(std::unordered_set<int3, ShashInt3
}
}
void CPrivilegedInfoCallback::getAllTiles(std::unordered_set<int3, ShashInt3> & tiles, boost::optional<PlayerColor> Player, int level, MapTerrainFilterMode tileFilterMode) const
void CPrivilegedInfoCallback::getAllTiles(std::unordered_set<int3, ShashInt3> & tiles, std::optional<PlayerColor> Player, int level, MapTerrainFilterMode tileFilterMode) const
{
if(!!Player && *Player >= PlayerColor::PLAYER_LIMIT)
{

4
lib/IGameCallback.h
View File

@ -62,12 +62,12 @@ public:
void getTilesInRange(std::unordered_set<int3, ShashInt3> & tiles,
const int3 & pos,
int radious,
boost::optional<PlayerColor> player = boost::optional<PlayerColor>(),
std::optional<PlayerColor> player = std::optional<PlayerColor>(),
int mode = 0,
int3::EDistanceFormula formula = int3::DIST_2D) const;
//returns all tiles on given level (-1 - both levels, otherwise number of level)
void getAllTiles(std::unordered_set<int3, ShashInt3> &tiles, boost::optional<PlayerColor> player = boost::optional<PlayerColor>(),
void getAllTiles(std::unordered_set<int3, ShashInt3> &tiles, std::optional<PlayerColor> player = std::optional<PlayerColor>(),
int level = -1, MapTerrainFilterMode tileFilterMode = MapTerrainFilterMode::NONE) const;
//gives 3 treasures, 3 minors, 1 major -> used by Black Market and Artifact Merchant

12
lib/NetPacks.h
View File

@ -145,7 +145,7 @@ struct DLL_LINKAGE YourTurn : public CPackForClient
void applyGs(CGameState * gs) const;
PlayerColor player;
boost::optional<ui8> daysWithoutCastle;
std::optional<ui8> daysWithoutCastle;
virtual void visitTyped(ICPackVisitor & visitor) override;
@ -591,7 +591,7 @@ struct DLL_LINKAGE TryMoveHero : public CPackForClient
EResult result = FAILED; //uses EResult
int3 start, end; //h3m format
std::unordered_set<int3, ShashInt3> fowRevealed; //revealed tiles
boost::optional<int3> attackedFrom; // Set when stepping into endangered tile.
std::optional<int3> attackedFrom; // Set when stepping into endangered tile.
virtual void visitTyped(ICPackVisitor & visitor) override;
@ -930,17 +930,17 @@ struct DLL_LINKAGE BulkSmartRebalanceStacks : CGarrisonOperationPack
}
};
struct GetEngagedHeroIds : boost::static_visitor<boost::optional<ObjectInstanceID>>
struct GetEngagedHeroIds: boost::static_visitor<std::optional<ObjectInstanceID>>
{
boost::optional<ObjectInstanceID> operator()(const ConstTransitivePtr<CGHeroInstance> & h) const
std::optional<ObjectInstanceID> operator()(const ConstTransitivePtr<CGHeroInstance> & h) const
{
return h->id;
}
boost::optional<ObjectInstanceID> operator()(const ConstTransitivePtr<CStackInstance> & s) const
std::optional<ObjectInstanceID> operator()(const ConstTransitivePtr<CStackInstance> & s) const
{
if(s->armyObj && s->armyObj->ID == Obj::HERO)
return s->armyObj->id;
return boost::optional<ObjectInstanceID>();
return std::optional<ObjectInstanceID>();
}
};

6
lib/NetPacksLib.cpp
View File

@ -2050,11 +2050,11 @@ void NewTurn::applyGs(CGameState *gs)
if (playerState.daysWithoutCastle)
++(*playerState.daysWithoutCastle);
else
playerState.daysWithoutCastle = boost::make_optional(0);
playerState.daysWithoutCastle = std::make_optional(0);
}
else
{
playerState.daysWithoutCastle = boost::none;
playerState.daysWithoutCastle = std::nullopt;
}
}
}
@ -2085,7 +2085,7 @@ void SetObjectProperty::applyGs(CGameState * gs) const
//reset counter before NewTurn to avoid no town message if game loaded at turn when one already captured
if(p->daysWithoutCastle)
p->daysWithoutCastle = boost::none;
p->daysWithoutCastle = std::nullopt;
}
}

2
lib/battle/BattleHex.h
View File

@ -29,7 +29,7 @@ namespace GameConstants
const int BFIELD_SIZE = BFIELD_WIDTH * BFIELD_HEIGHT;
}
using BattleSideOpt = boost::optional<ui8>;
using BattleSideOpt = std::optional<ui8>;
// for battle stacks' positions
struct DLL_LINKAGE BattleHex //TODO: decide if this should be changed to class for better code design

14
lib/battle/CBattleInfoCallback.cpp
View File

@ -106,7 +106,7 @@ ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastSpell(con
const auto side = playerToSide(player);
if(!side)
return ESpellCastProblem::INVALID;
if(!battleDoWeKnowAbout(side.get()))
if(!battleDoWeKnowAbout(side.value()))
{
logGlobal->warn("You can't check if enemy can cast given spell!");
return ESpellCastProblem::INVALID;
@ -119,7 +119,7 @@ ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastSpell(con
{
case spells::Mode::HERO:
{
if(battleCastSpells(side.get()) > 0)
if(battleCastSpells(side.value()) > 0)
return ESpellCastProblem::CASTS_PER_TURN_LIMIT;
const auto * hero = dynamic_cast<const CGHeroInstance *>(caster);
@ -229,7 +229,7 @@ std::vector<PossiblePlayerBattleAction> CBattleInfoCallback::getClientActionsFor
{
if(stack->hasBonusOfType(Bonus::SPELLCASTER))
{
for (auto const & spellID : data.creatureSpellsToCast)
for(const auto & spellID : data.creatureSpellsToCast)
{
const CSpell *spell = spellID.toSpell();
PossiblePlayerBattleAction act = getCasterAction(spell, stack, spells::Mode::CREATURE_ACTIVE);
@ -767,7 +767,7 @@ DamageEstimation CBattleInfoCallback::battleEstimateDamage(const BattleAttackInf
//TODO: rewrite using boost::numeric::interval
//TODO: rewire once more using interval-based fuzzy arithmetic
auto const & estimateRetaliation = [&]( int64_t damage)
const auto & estimateRetaliation = [&](int64_t damage)
{
auto retaliationAttack = bai.reverse();
auto state = retaliationAttack.attacker->acquireState();
@ -1763,7 +1763,7 @@ int CBattleInfoCallback::battleGetSurrenderCost(const PlayerColor & Player) cons
const auto sideOpt = playerToSide(Player);
if(!sideOpt)
return -1;
const auto side = sideOpt.get();
const auto side = sideOpt.value();
int ret = 0;
double discount = 0;
@ -1816,7 +1816,7 @@ si8 CBattleInfoCallback::battleMaxSpellLevel(ui8 side) const
return GameConstants::SPELL_LEVELS;
}
boost::optional<int> CBattleInfoCallback::battleIsFinished() const
std::optional<int> CBattleInfoCallback::battleIsFinished() const
{
auto units = battleGetUnitsIf([=](const battle::Unit * unit)
{
@ -1831,7 +1831,7 @@ boost::optional<int> CBattleInfoCallback::battleIsFinished() const
hasUnit.at(unit->unitSide()) = true;
if(hasUnit[0] && hasUnit[1])
return boost::none;
return std::nullopt;
}
hasUnit = {false, false};

2
lib/battle/CBattleInfoCallback.h
View File

@ -58,7 +58,7 @@ public:
RANDOM_GENIE, RANDOM_AIMED
};
boost::optional<int> battleIsFinished() const override; //return none if battle is ongoing; otherwise the victorious side (0/1) or 2 if it is a draw
std::optional<int> battleIsFinished() const override; //return none if battle is ongoing; otherwise the victorious side (0/1) or 2 if it is a draw
std::vector<std::shared_ptr<const CObstacleInstance>> battleGetAllObstaclesOnPos(BattleHex tile, bool onlyBlocking = true) const override;
std::vector<std::shared_ptr<const CObstacleInstance>> getAllAffectedObstaclesByStack(const battle::Unit * unit, const std::set<BattleHex> & passed) const override;

24
lib/battle/CBattleInfoEssentials.cpp
View File

@ -34,7 +34,7 @@ int32_t CBattleInfoEssentials::battleGetEnchanterCounter(ui8 side) const
return getBattle()->getEnchanterCounter(side);
}
std::vector<std::shared_ptr<const CObstacleInstance>> CBattleInfoEssentials::battleGetAllObstacles(boost::optional<BattlePerspective::BattlePerspective> perspective) const
std::vector<std::shared_ptr<const CObstacleInstance>> CBattleInfoEssentials::battleGetAllObstacles(std::optional<BattlePerspective::BattlePerspective> perspective) const
{
std::vector<std::shared_ptr<const CObstacleInstance> > ret;
RETURN_IF_NOT_BATTLE(ret);
@ -42,7 +42,7 @@ std::vector<std::shared_ptr<const CObstacleInstance>> CBattleInfoEssentials::bat
if(!perspective)
{
//if no particular perspective request, use default one
perspective = boost::make_optional(battleGetMySide());
perspective = std::make_optional(battleGetMySide());
}
else
{
@ -156,7 +156,7 @@ const CGTownInstance * CBattleInfoEssentials::battleGetDefendedTown() const
BattlePerspective::BattlePerspective CBattleInfoEssentials::battleGetMySide() const
{
RETURN_IF_NOT_BATTLE(BattlePerspective::INVALID);
if(!player || player.get().isSpectator())
if(!player || player->isSpectator())
return BattlePerspective::ALL_KNOWING;
if(*player == getBattle()->getSidePlayer(BattleSide::ATTACKER))
return BattlePerspective::LEFT_SIDE;
@ -264,7 +264,7 @@ bool CBattleInfoEssentials::battleCanFlee(const PlayerColor & player) const
if(!side)
return false;
const CGHeroInstance *myHero = battleGetFightingHero(side.get());
const CGHeroInstance * myHero = battleGetFightingHero(side.value());
//current player have no hero
if(!myHero)
@ -275,7 +275,7 @@ bool CBattleInfoEssentials::battleCanFlee(const PlayerColor & player) const
return false;
//we are besieged defender
if(side.get() == BattleSide::DEFENDER && battleGetSiegeLevel())
if(side == BattleSide::DEFENDER && battleGetSiegeLevel())
{
const auto * town = battleGetDefendedTown();
if(!town->hasBuilt(BuildingSubID::ESCAPE_TUNNEL))
@ -287,7 +287,7 @@ bool CBattleInfoEssentials::battleCanFlee(const PlayerColor & player) const
BattleSideOpt CBattleInfoEssentials::playerToSide(const PlayerColor & player) const
{
RETURN_IF_NOT_BATTLE(boost::none);
RETURN_IF_NOT_BATTLE(std::nullopt);
if(getBattle()->getSidePlayer(BattleSide::ATTACKER) == player)
return BattleSideOpt(BattleSide::ATTACKER);
@ -297,7 +297,7 @@ BattleSideOpt CBattleInfoEssentials::playerToSide(const PlayerColor & player) co
logGlobal->warn("Cannot find side for player %s", player.getStr());
return boost::none;
return std::nullopt;
}
PlayerColor CBattleInfoEssentials::sideToPlayer(ui8 side) const
@ -322,7 +322,7 @@ PlayerColor CBattleInfoEssentials::otherPlayer(const PlayerColor & player) const
if(!side)
return PlayerColor::CANNOT_DETERMINE;
return getBattle()->getSidePlayer(otherSide(side.get()));
return getBattle()->getSidePlayer(otherSide(side.value()));
}
bool CBattleInfoEssentials::playerHasAccessToHeroInfo(const PlayerColor & player, const CGHeroInstance * h) const
@ -331,7 +331,7 @@ bool CBattleInfoEssentials::playerHasAccessToHeroInfo(const PlayerColor & player
const auto side = playerToSide(player);
if(side)
{
auto opponentSide = otherSide(side.get());
auto opponentSide = otherSide(side.value());
if(getBattle()->getSideHero(opponentSide) == h)
return true;
}
@ -350,9 +350,9 @@ bool CBattleInfoEssentials::battleCanSurrender(const PlayerColor & player) const
const auto side = playerToSide(player);
if(!side)
return false;
bool iAmSiegeDefender = (side.get() == BattleSide::DEFENDER && battleGetSiegeLevel());
bool iAmSiegeDefender = (side.value() == BattleSide::DEFENDER && battleGetSiegeLevel());
//conditions like for fleeing (except escape tunnel presence) + enemy must have a hero
return battleCanFlee(player) && !iAmSiegeDefender && battleHasHero(otherSide(side.get()));
return battleCanFlee(player) && !iAmSiegeDefender && battleHasHero(otherSide(side.value()));
}
bool CBattleInfoEssentials::battleHasHero(ui8 side) const
@ -409,7 +409,7 @@ const CGHeroInstance * CBattleInfoEssentials::battleGetOwnerHero(const battle::U
const auto side = playerToSide(battleGetOwner(unit));
if(!side)
return nullptr;
return getBattle()->getSideHero(side.get());
return getBattle()->getSideHero(side.value());
}
bool CBattleInfoEssentials::battleMatchOwner(const battle::Unit * attacker, const battle::Unit * defender, const boost::logic::tribool positivness) const

2
lib/battle/CBattleInfoEssentials.h
View File

@ -52,7 +52,7 @@ public:
BattleField battleGetBattlefieldType() const override;
int32_t battleGetEnchanterCounter(ui8 side) const;
std::vector<std::shared_ptr<const CObstacleInstance> > battleGetAllObstacles(boost::optional<BattlePerspective::BattlePerspective> perspective = boost::none) const; //returns all obstacles on the battlefield
std::vector<std::shared_ptr<const CObstacleInstance> > battleGetAllObstacles(std::optional<BattlePerspective::BattlePerspective> perspective = std::nullopt) const; //returns all obstacles on the battlefield
std::shared_ptr<const CObstacleInstance> battleGetObstacleByID(uint32_t ID) const;

4
lib/battle/CCallbackBase.cpp
View File

@ -23,7 +23,7 @@ const IBattleInfo * CCallbackBase::getBattle() const
return battle;
}
CCallbackBase::CCallbackBase(boost::optional<PlayerColor> Player):
CCallbackBase::CCallbackBase(std::optional<PlayerColor> Player):
player(std::move(Player))
{
}
@ -33,7 +33,7 @@ void CCallbackBase::setBattle(const IBattleInfo * B)
battle = B;
}
boost::optional<PlayerColor> CCallbackBase::getPlayerID() const
std::optional<PlayerColor> CCallbackBase::getPlayerID() const
{
return player;
}

6
lib/battle/CCallbackBase.h
View File

@ -26,9 +26,9 @@ class DLL_LINKAGE CCallbackBase
const IBattleInfo * battle = nullptr; //battle to which the player is engaged, nullptr if none or not applicable
protected:
boost::optional<PlayerColor> player; // not set gives access to all information, otherwise callback provides only information "visible" for player
std::optional<PlayerColor> player; // not set gives access to all information, otherwise callback provides only information "visible" for player
CCallbackBase(boost::optional<PlayerColor> Player);
CCallbackBase(std::optional<PlayerColor> Player);
CCallbackBase() = default;
const IBattleInfo * getBattle() const;
@ -36,7 +36,7 @@ protected:
bool duringBattle() const;
public:
boost::optional<PlayerColor> getPlayerID() const;
std::optional<PlayerColor> getPlayerID() const;
friend class CBattleInfoEssentials;
};

2
lib/battle/IBattleInfoCallback.h
View File

@ -58,7 +58,7 @@ public:
virtual BattleField battleGetBattlefieldType() const = 0;
///return none if battle is ongoing; otherwise the victorious side (0/1) or 2 if it is a draw
virtual boost::optional<int> battleIsFinished() const = 0;
virtual std::optional<int> battleIsFinished() const = 0;
virtual si8 battleTacticDist() const = 0; //returns tactic distance in current tactics phase; 0 if not in tactics phase
virtual si8 battleGetTacticsSide() const = 0; //returns which side is in tactics phase, undefined if none (?)

6
lib/filesystem/AdapterLoaders.cpp
View File

@ -39,7 +39,7 @@ std::string CMappedFileLoader::getMountPoint() const
return ""; // does not have any meaning with this type of data source
}
boost::optional<boost::filesystem::path> CMappedFileLoader::getResourceName(const ResourceID & resourceName) const
std::optional<boost::filesystem::path> CMappedFileLoader::getResourceName(const ResourceID & resourceName) const
{
return CResourceHandler::get()->getResourceName(fileList.at(resourceName));
}
@ -90,11 +90,11 @@ std::string CFilesystemList::getMountPoint() const
return "";
}
boost::optional<boost::filesystem::path> CFilesystemList::getResourceName(const ResourceID & resourceName) const
std::optional<boost::filesystem::path> CFilesystemList::getResourceName(const ResourceID & resourceName) const
{
if (existsResource(resourceName))
return getResourcesWithName(resourceName).back()->getResourceName(resourceName);
return boost::optional<boost::filesystem::path>();
return std::optional<boost::filesystem::path>();
}
std::set<boost::filesystem::path> CFilesystemList::getResourceNames(const ResourceID & resourceName) const

4
lib/filesystem/AdapterLoaders.h
View File

@ -41,7 +41,7 @@ public:
std::unique_ptr<CInputStream> load(const ResourceID & resourceName) const override;
bool existsResource(const ResourceID & resourceName) const override;
std::string getMountPoint() const override;
boost::optional<boost::filesystem::path> getResourceName(const ResourceID & resourceName) const override;
std::optional<boost::filesystem::path> getResourceName(const ResourceID & resourceName) const override;
void updateFilteredFiles(std::function<bool(const std::string &)> filter) const override {}
std::unordered_set<ResourceID> getFilteredFiles(std::function<bool(const ResourceID &)> filter) const override;
@ -71,7 +71,7 @@ public:
std::unique_ptr<CInputStream> load(const ResourceID & resourceName) const override;
bool existsResource(const ResourceID & resourceName) const override;
std::string getMountPoint() const override;
boost::optional<boost::filesystem::path> getResourceName(const ResourceID & resourceName) const override;
std::optional<boost::filesystem::path> getResourceName(const ResourceID & resourceName) const override;
std::set<boost::filesystem::path> getResourceNames(const ResourceID & resourceName) const override;
void updateFilteredFiles(std::function<bool(const std::string &)> filter) const override;
std::unordered_set<ResourceID> getFilteredFiles(std::function<bool(const ResourceID &)> filter) const override;

2
lib/filesystem/CFilesystemLoader.cpp
View File

@ -44,7 +44,7 @@ std::string CFilesystemLoader::getMountPoint() const
return mountPoint;
}
boost::optional<boost::filesystem::path> CFilesystemLoader::getResourceName(const ResourceID & resourceName) const
std::optional<boost::filesystem::path> CFilesystemLoader::getResourceName(const ResourceID & resourceName) const
{
assert(existsResource(resourceName));

2
lib/filesystem/CFilesystemLoader.h
View File

@ -38,7 +38,7 @@ public:
bool existsResource(const ResourceID & resourceName) const override;
std::string getMountPoint() const override;
bool createResource(std::string filename, bool update = false) override;
boost::optional<boost::filesystem::path> getResourceName(const ResourceID & resourceName) const override;
std::optional<boost::filesystem::path> getResourceName(const ResourceID & resourceName) const override;
void updateFilteredFiles(std::function<bool(const std::string &)> filter) const override;
std::unordered_set<ResourceID> getFilteredFiles(std::function<bool(const ResourceID &)> filter) const override;

4
lib/filesystem/ISimpleResourceLoader.h
View File

@ -49,9 +49,9 @@ public:
*
* @return path or empty optional if file can't be accessed independently (e.g. file in archive)
*/
virtual boost::optional<boost::filesystem::path> getResourceName(const ResourceID & resourceName) const
virtual std::optional<boost::filesystem::path> getResourceName(const ResourceID & resourceName) const
{
return boost::optional<boost::filesystem::path>();
return std::optional<boost::filesystem::path>();
}
/**

2
lib/mapObjects/CArmedInstance.cpp
View File

@ -29,7 +29,7 @@ void CArmedInstance::randomizeArmy(int type)
int upgrade = elem.second->randomStack->upgrade;
elem.second->setType((*VLC->townh)[type]->town->creatures[level][upgrade]);
elem.second->randomStack = boost::none;
elem.second->randomStack = std::nullopt;
}
assert(elem.second->valid(false));
assert(elem.second->armyObj == this);

10
lib/mapObjects/CGHeroInstance.cpp
View File

@ -1280,11 +1280,11 @@ PrimarySkill::PrimarySkill CGHeroInstance::nextPrimarySkill(CRandomGenerator & r
return static_cast<PrimarySkill::PrimarySkill>(primarySkill);
}
boost::optional<SecondarySkill> CGHeroInstance::nextSecondarySkill(CRandomGenerator & rand) const
std::optional<SecondarySkill> CGHeroInstance::nextSecondarySkill(CRandomGenerator & rand) const
{
assert(gainsLevel());
boost::optional<SecondarySkill> chosenSecondarySkill;
std::optional<SecondarySkill> chosenSecondarySkill;
const auto proposedSecondarySkills = getLevelUpProposedSecondarySkills();
if(!proposedSecondarySkills.empty())
{
@ -1300,12 +1300,12 @@ boost::optional<SecondarySkill> CGHeroInstance::nextSecondarySkill(CRandomGenera
if(learnedSecondarySkills.empty())
{
// there are only new skills to learn, so choose anyone of them
chosenSecondarySkill = boost::make_optional(*RandomGeneratorUtil::nextItem(proposedSecondarySkills, rand));
chosenSecondarySkill = std::make_optional(*RandomGeneratorUtil::nextItem(proposedSecondarySkills, rand));
}
else
{
// preferably upgrade a already learned secondary skill
chosenSecondarySkill = boost::make_optional(*RandomGeneratorUtil::nextItem(learnedSecondarySkills, rand));
chosenSecondarySkill = std::make_optional(*RandomGeneratorUtil::nextItem(learnedSecondarySkills, rand));
}
}
return chosenSecondarySkill;
@ -1441,7 +1441,7 @@ void CGHeroInstance::setHeroTypeName(const std::string & identifier)
auto rawId = VLC->modh->identifiers.getIdentifier(CModHandler::scopeMap(), "hero", identifier);
if(rawId)
subID = rawId.get();
subID = rawId.value();
else
{
throw std::runtime_error("Couldn't resolve hero identifier " + identifier);

2
lib/mapObjects/CGHeroInstance.h
View File

@ -182,7 +182,7 @@ public:
PrimarySkill::PrimarySkill nextPrimarySkill(CRandomGenerator & rand) const;
/// Returns the next secondary skill randomly on level up. Can only be called if hero can gain a level up.
boost::optional<SecondarySkill> nextSecondarySkill(CRandomGenerator & rand) const;
std::optional<SecondarySkill> nextSecondarySkill(CRandomGenerator & rand) const;
/// Gets 0, 1 or 2 secondary skills which are proposed on hero level up.
std::vector<SecondarySkill> getLevelUpProposedSecondarySkills() const;

2
lib/mapObjects/CGTownInstance.cpp
View File

@ -1507,7 +1507,7 @@ void CGTownInstance::serializeJsonOptions(JsonSerializeFormat & handler)
auto rawId = VLC->modh->identifiers.getIdentifier(CModHandler::scopeMap(), getTown()->getBuildingScope(), identifier);
if(rawId)
return rawId.get();
return rawId.value();
else
return -1;
};

24
lib/mapObjects/CObjectClassesHandler.cpp
View File

@ -165,7 +165,7 @@ void CObjectClassesHandler::loadSubObject(const std::string & scope, const std::
obj->objects.push_back(object);
registerObject(scope, obj->getJsonKey(), object->getSubTypeName(), object->subtype);
for (auto const & compatID : entry["compatibilityIdentifiers"].Vector())
for(const auto & compatID : entry["compatibilityIdentifiers"].Vector())
registerObject(scope, obj->getJsonKey(), compatID.String(), object->subtype);
}
@ -178,7 +178,7 @@ void CObjectClassesHandler::loadSubObject(const std::string & scope, const std::
obj->objects[index] = object;
registerObject(scope, obj->getJsonKey(), object->getSubTypeName(), object->subtype);
for (auto const & compatID : entry["compatibilityIdentifiers"].Vector())
for(const auto & compatID : entry["compatibilityIdentifiers"].Vector())
registerObject(scope, obj->getJsonKey(), compatID.String(), object->subtype);
}
@ -313,14 +313,14 @@ TObjectTypeHandler CObjectClassesHandler::getHandlerFor(si32 type, si32 subtype)
TObjectTypeHandler CObjectClassesHandler::getHandlerFor(const std::string & scope, const std::string & type, const std::string & subtype) const
{
boost::optional<si32> id = VLC->modh->identifiers.getIdentifier(scope, "object", type);
std::optional<si32> id = VLC->modh->identifiers.getIdentifier(scope, "object", type);
if(id)
{
auto * object = objects[id.get()];
boost::optional<si32> subID = VLC->modh->identifiers.getIdentifier(scope, object->getJsonKey(), subtype);
auto * object = objects[id.value()];
std::optional<si32> subID = VLC->modh->identifiers.getIdentifier(scope, object->getJsonKey(), subtype);
if (subID)
return object->objects[subID.get()];
return object->objects[subID.value()];
}
std::string errorString = "Failed to find object of type " + type + "::" + subtype;
@ -515,7 +515,7 @@ void AObjectTypeHandler::init(const JsonNode & input)
const JsonNode & mapLimit = input["rmg"]["mapLimit"];
if (!mapLimit.isNull())
rmgInfo.mapLimit.reset(static_cast<ui32>(mapLimit.Float()));
rmgInfo.mapLimit = static_cast<ui32>(mapLimit.Float());
rmgInfo.zoneLimit = loadJsonOrMax(input["rmg"]["zoneLimit"]);
rmgInfo.rarity = static_cast<ui32>(input["rmg"]["rarity"].Float());
@ -551,14 +551,14 @@ void AObjectTypeHandler::init(const JsonNode & input)
sounds.removal.push_back(node.String());
if(input["aiValue"].isNull())
aiValue = boost::none;
aiValue = std::nullopt;
else
aiValue = static_cast<boost::optional<si32>>(input["aiValue"].Integer());
aiValue = static_cast<std::optional<si32>>(input["aiValue"].Integer());
if(input["battleground"].getType() == JsonNode::JsonType::DATA_STRING)
battlefield = input["battleground"].String();
else
battlefield = boost::none;
battlefield = std::nullopt;
initTypeData(input);
}
@ -625,7 +625,7 @@ std::vector<std::shared_ptr<const ObjectTemplate>> AObjectTypeHandler::getTempla
BattleField AObjectTypeHandler::getBattlefield() const
{
return battlefield ? BattleField::fromString(battlefield.get()) : BattleField::NONE;
return battlefield ? BattleField::fromString(battlefield.value()) : BattleField::NONE;
}
std::vector<std::shared_ptr<const ObjectTemplate>>AObjectTypeHandler::getTemplates(TerrainId terrainType) const
@ -661,7 +661,7 @@ const RandomMapInfo & AObjectTypeHandler::getRMGInfo()
return rmgInfo;
}
boost::optional<si32> AObjectTypeHandler::getAiValue() const
std::optional<si32> AObjectTypeHandler::getAiValue() const
{
return aiValue;
}

10
lib/mapObjects/CObjectClassesHandler.h
View File

@ -43,7 +43,7 @@ struct DLL_LINKAGE RandomMapInfo
ui32 value;
/// How many of such objects can be placed on map, 0 = object can not be placed by RMG
boost::optional<ui32> mapLimit;
std::optional<ui32> mapLimit;
/// How many of such objects can be placed in one zone, 0 = unplaceable
ui32 zoneLimit;
@ -57,7 +57,7 @@ struct DLL_LINKAGE RandomMapInfo
rarity(0)
{}
void setMapLimit(ui32 val) { mapLimit.reset(val); }
void setMapLimit(ui32 val) { mapLimit = val; }
template <typename Handler> void serialize(Handler &h, const int version)
{
@ -150,8 +150,8 @@ class DLL_LINKAGE AObjectTypeHandler : public boost::noncopyable
SObjectSounds sounds;
boost::optional<si32> aiValue;
boost::optional<std::string> battlefield;
std::optional<si32> aiValue;
std::optional<std::string> battlefield;
std::string modScope;
std::string typeName;
@ -200,7 +200,7 @@ public:
const RandomMapInfo & getRMGInfo();
boost::optional<si32> getAiValue() const;
std::optional<si32> getAiValue() const;
/// returns true if this class provides custom text ID's instead of generic per-object name
virtual bool hasNameTextID() const;

14
lib/mapObjects/CObjectHandler.cpp
View File

@ -288,31 +288,31 @@ std::string CGObjectInstance::getObjectName() const
return VLC->objtypeh->getObjectName(ID, subID);
}
boost::optional<std::string> CGObjectInstance::getAmbientSound() const
std::optional<std::string> CGObjectInstance::getAmbientSound() const
{
const auto & sounds = VLC->objtypeh->getObjectSounds(ID, subID).ambient;
if(!sounds.empty())
return sounds.front(); // TODO: Support randomization of ambient sounds
return boost::none;
return std::nullopt;
}
boost::optional<std::string> CGObjectInstance::getVisitSound() const
std::optional<std::string> CGObjectInstance::getVisitSound() const
{
const auto & sounds = VLC->objtypeh->getObjectSounds(ID, subID).visit;
if(!sounds.empty())
return *RandomGeneratorUtil::nextItem(sounds, CRandomGenerator::getDefault());
return boost::none;
return std::nullopt;
}
boost::optional<std::string> CGObjectInstance::getRemovalSound() const
std::optional<std::string> CGObjectInstance::getRemovalSound() const
{
const auto & sounds = VLC->objtypeh->getObjectSounds(ID, subID).removal;
if(!sounds.empty())
return *RandomGeneratorUtil::nextItem(sounds, CRandomGenerator::getDefault());
return boost::none;
return std::nullopt;
}
std::string CGObjectInstance::getHoverText(PlayerColor player) const
@ -384,7 +384,7 @@ void CGObjectInstance::serializeJson(JsonSerializeFormat & handler)
handler.serializeInt("l", pos.z);
JsonNode app;
appearance->writeJson(app, false);
handler.serializeRaw("template",app, boost::none);
handler.serializeRaw("template", app, std::nullopt);
}
{

7
lib/mapObjects/CObjectHandler.h
View File

@ -171,10 +171,9 @@ public:
virtual bool isTile2Terrain() const { return false; }
boost::optional<std::string> getAmbientSound() const;
boost::optional<std::string> getVisitSound() const;
boost::optional<std::string> getRemovalSound() const;
std::optional<std::string> getAmbientSound() const;
std::optional<std::string> getVisitSound() const;
std::optional<std::string> getRemovalSound() const;
/** VIRTUAL METHODS **/

2
lib/mapObjects/CQuest.cpp
View File

@ -1067,7 +1067,7 @@ void CGSeerHut::serializeJsonOptions(JsonSerializeFormat & handler)
if(rawId)
{
rID = rawId.get();
rID = rawId.value();
}
else
{

4
lib/mapObjects/CRewardableConstructor.cpp
View File

@ -140,8 +140,8 @@ void CRandomRewardObjectInfo::configureReward(CRewardableObject * object, CRando
for ( auto node : source["changeCreatures"].Struct() )
{
CreatureID from (VLC->modh->identifiers.getIdentifier (node.second.meta, "creature", node.first) .get());
CreatureID dest (VLC->modh->identifiers.getIdentifier (node.second.meta, "creature", node.second.String()).get());
CreatureID from(VLC->modh->identifiers.getIdentifier(node.second.meta, "creature", node.first).value());
CreatureID dest(VLC->modh->identifiers.getIdentifier(node.second.meta, "creature", node.second.String()).value());
reward.extraComponents.emplace_back(Component::EComponentType::CREATURE, dest.getNum(), 0, 0);

4
lib/mapObjects/CommonConstructors.cpp
View File

@ -50,7 +50,7 @@ void CTownInstanceConstructor::afterLoadFinalization()
{
filters[entry.first] = LogicalExpression<BuildingID>(entry.second, [this](const JsonNode & node)
{
return BuildingID(VLC->modh->identifiers.getIdentifier("building." + faction->getJsonKey(), node.Vector()[0]).get());
return BuildingID(VLC->modh->identifiers.getIdentifier("building." + faction->getJsonKey(), node.Vector()[0]).value());
});
}
}
@ -98,7 +98,7 @@ void CHeroInstanceConstructor::afterLoadFinalization()
{
filters[entry.first] = LogicalExpression<HeroTypeID>(entry.second, [](const JsonNode & node)
{
return HeroTypeID(VLC->modh->identifiers.getIdentifier("hero", node.Vector()[0]).get());
return HeroTypeID(VLC->modh->identifiers.getIdentifier("hero", node.Vector()[0]).value());
});
}
}

14
lib/mapObjects/JsonRandom.cpp
View File

@ -99,7 +99,7 @@ namespace JsonRandom
std::string resourceName = loadKey(value, rng, defaultResources);
si32 resourceAmount = loadValue(value, rng, 0);
si32 resourceID(VLC->modh->identifiers.getIdentifier(value.meta, "resource", resourceName).get());
si32 resourceID(VLC->modh->identifiers.getIdentifier(value.meta, "resource", resourceName).value());
TResources ret;
ret[resourceID] = resourceAmount;
@ -138,7 +138,7 @@ namespace JsonRandom
{
for(const auto & pair : value.Struct())
{
SecondarySkill id(VLC->modh->identifiers.getIdentifier(pair.second.meta, "skill", pair.first).get());
SecondarySkill id(VLC->modh->identifiers.getIdentifier(pair.second.meta, "skill", pair.first).value());
ret[id] = loadValue(pair.second, rng);
}
}
@ -153,7 +153,7 @@ namespace JsonRandom
for(const auto & element : value.Vector())
{
SecondarySkill id(VLC->modh->identifiers.getIdentifier(element.meta, "skill", loadKey(element, rng, defaultSkills)).get());
SecondarySkill id(VLC->modh->identifiers.getIdentifier(element.meta, "skill", loadKey(element, rng, defaultSkills)).value());
ret[id] = loadValue(element, rng);
}
}
@ -163,7 +163,7 @@ namespace JsonRandom
ArtifactID loadArtifact(const JsonNode & value, CRandomGenerator & rng)
{
if (value.getType() == JsonNode::JsonType::DATA_STRING)
return ArtifactID(VLC->modh->identifiers.getIdentifier("artifact", value).get());
return ArtifactID(VLC->modh->identifiers.getIdentifier("artifact", value).value());
std::set<CArtifact::EartClass> allowedClasses;
std::set<ArtifactPosition> allowedPositions;
@ -224,7 +224,7 @@ namespace JsonRandom
SpellID loadSpell(const JsonNode & value, CRandomGenerator & rng, std::vector<SpellID> spells)
{
if (value.getType() == JsonNode::JsonType::DATA_STRING)
return SpellID(VLC->modh->identifiers.getIdentifier("spell", value).get());
return SpellID(VLC->modh->identifiers.getIdentifier("spell", value).value());
vstd::erase_if(spells, [=](const SpellID & spell)
{
@ -252,7 +252,7 @@ namespace JsonRandom
CStackBasicDescriptor loadCreature(const JsonNode & value, CRandomGenerator & rng)
{
CStackBasicDescriptor stack;
stack.type = VLC->creh->objects[VLC->modh->identifiers.getIdentifier("creature", value["type"]).get()];
stack.type = VLC->creh->objects[VLC->modh->identifiers.getIdentifier("creature", value["type"]).value()];
stack.count = loadValue(value, rng);
if (!value["upgradeChance"].isNull() && !stack.type->upgrades.empty())
{
@ -288,7 +288,7 @@ namespace JsonRandom
info.minAmount = static_cast<si32>(node["min"].Float());
info.maxAmount = static_cast<si32>(node["max"].Float());
}
const CCreature * crea = VLC->creh->objects[VLC->modh->identifiers.getIdentifier("creature", node["type"]).get()];
const CCreature * crea = VLC->creh->objects[VLC->modh->identifiers.getIdentifier("creature", node["type"]).value()];
info.allowedCreatures.push_back(crea);
if (node["upgradeChance"].Float() > 0)
{

8
lib/mapObjects/MiscObjects.cpp
View File

@ -762,7 +762,7 @@ void CGMine::serializeJsonOptions(JsonSerializeFormat & handler)
one.String() = GameConstants::RESOURCE_NAMES[resID];
node.Vector().push_back(one);
}
handler.serializeRaw("possibleResources", node, boost::none);
handler.serializeRaw("possibleResources", node, std::nullopt);
}
else
{
@ -1737,7 +1737,7 @@ void CGScholar::serializeJsonOptions(JsonSerializeFormat & handler)
if(raw)
{
bonusType = PRIM_SKILL;
bonusID = raw.get();
bonusID = raw.value();
}
}
else if(!json["rewardSkill"].String().empty())
@ -1746,7 +1746,7 @@ void CGScholar::serializeJsonOptions(JsonSerializeFormat & handler)
if(raw)
{
bonusType = SECONDARY_SKILL;
bonusID = raw.get();
bonusID = raw.value();
}
}
else if(!json["rewardSpell"].String().empty())
@ -1755,7 +1755,7 @@ void CGScholar::serializeJsonOptions(JsonSerializeFormat & handler)
if(raw)
{
bonusType = SPELL;
bonusID = raw.get();
bonusID = raw.value();
}
}
}

10
lib/mapping/CCampaignHandler.cpp
View File

@ -450,13 +450,13 @@ void CCampaignState::setCurrentMapAsConquered(const std::vector<CGHeroInstance *
camp->scenarios[*currentMap].conquered = true;
}
boost::optional<CScenarioTravel::STravelBonus> CCampaignState::getBonusForCurrentMap() const
std::optional<CScenarioTravel::STravelBonus> CCampaignState::getBonusForCurrentMap() const
{
auto bonuses = getCurrentScenario().travelOptions.bonusesToChoose;
assert(chosenCampaignBonuses.count(*currentMap) || bonuses.size() == 0);
if(bonuses.empty())
return boost::optional<CScenarioTravel::STravelBonus>();
return std::optional<CScenarioTravel::STravelBonus>();
else
return bonuses[currentBonusID()];
}
@ -489,7 +489,7 @@ CMap * CCampaignState::getMap(int scenarioId) const
{
// FIXME: there is certainly better way to handle maps inside campaigns
if(scenarioId == -1)
scenarioId = currentMap.get();
scenarioId = currentMap.value();
std::string scenarioName = camp->header.filename.substr(0, camp->header.filename.find('.'));
boost::to_lower(scenarioName);
scenarioName += ':' + std::to_string(scenarioId);
@ -502,7 +502,7 @@ CMap * CCampaignState::getMap(int scenarioId) const
std::unique_ptr<CMapHeader> CCampaignState::getHeader(int scenarioId) const
{
if(scenarioId == -1)
scenarioId = currentMap.get();
scenarioId = currentMap.value();
std::string scenarioName = camp->header.filename.substr(0, camp->header.filename.find('.'));
boost::to_lower(scenarioName);
@ -516,7 +516,7 @@ std::unique_ptr<CMapHeader> CCampaignState::getHeader(int scenarioId) const
std::shared_ptr<CMapInfo> CCampaignState::getMapInfo(int scenarioId) const
{
if(scenarioId == -1)
scenarioId = currentMap.get();
scenarioId = currentMap.value();
auto mapInfo = std::make_shared<CMapInfo>();
mapInfo->fileURI = camp->header.filename;

4
lib/mapping/CCampaignHandler.h
View File

@ -186,12 +186,12 @@ public:
std::unique_ptr<CCampaign> camp;
std::string fileEncoding;
std::vector<ui8> mapsConquered, mapsRemaining;
boost::optional<si32> currentMap;
std::optional<si32> currentMap;
std::map<ui8, ui8> chosenCampaignBonuses;
void setCurrentMapAsConquered(const std::vector<CGHeroInstance*> & heroes);
boost::optional<CScenarioTravel::STravelBonus> getBonusForCurrentMap() const;
std::optional<CScenarioTravel::STravelBonus> getBonusForCurrentMap() const;
const CCampaignScenario & getCurrentScenario() const;
CCampaignScenario & getCurrentScenario();
ui8 currentBonusID() const;

Some files were not shown because too many files have changed in this diff Show More