std::sort instead of boost::sort

AI/BattleAI/PotentialTargets.cpp

@@ -84,7 +84,7 @@ PotentialTargets::PotentialTargets(
 		}
 	}
 
-	boost::sort(possibleAttacks, [](const AttackPossibility & lhs, const AttackPossibility & rhs) -> bool
+	std::sort(possibleAttacks.begin(), possibleAttacks.end(), [](const AttackPossibility & lhs, const AttackPossibility & rhs) -> bool
 	{
 		return lhs.damageDiff() > rhs.damageDiff();
 	});

AI/Nullkiller/Analyzers/ArmyManager.cpp

@@ -105,7 +105,7 @@ std::vector<SlotInfo> ArmyManager::getSortedSlots(const CCreatureSet * target, c
 	for(auto & pair : creToPower)
 		resultingArmy.push_back(pair.second);
 
-	boost::sort(resultingArmy, [](const SlotInfo & left, const SlotInfo & right) -> bool
+	std::sort(resultingArmy.begin(), resultingArmy.end(), [](const SlotInfo & left, const SlotInfo & right) -> bool
 	{
 		return left.power > right.power;
 	});

AI/Nullkiller/Helpers/ArmyFormation.cpp

@@ -53,8 +53,9 @@ void ArmyFormation::rearrangeArmyForSiege(const CGTownInstance * town, const CGH
 		for(auto slot : attacker->Slots())
 			stacks.push_back(slot.second);
 
-		boost::sort(
-			stacks,
+		std::sort(
+			stacks.begin(),
+			stacks.end(),
 			[](CStackInstance * slot1, CStackInstance * slot2) -> bool
 			{
 				auto cre1 = slot1->getCreatureID().toCreature();

AI/Nullkiller/Pathfinding/AINodeStorage.cpp

@@ -1234,7 +1234,7 @@ void AINodeStorage::calculateTownPortalTeleportations(std::vector<CGPathNode *>
 			maskMap[basicActor->hero] = basicActor->chainMask;
 	}
 
-	boost::sort(initialNodes, NodeComparer<CGPathNode>());
+	std::sort(initialNodes.begin(), initialNodes.end(), NodeComparer<CGPathNode>());
 
 	std::vector<const ChainActor *> actorsVector(actorsOfInitial.begin(), actorsOfInitial.end());
 	tbb::concurrent_vector<CGPathNode *> output;

AI/VCAI/ArmyManager.cpp

@@ -48,7 +48,7 @@ std::vector<SlotInfo> ArmyManager::getSortedSlots(const CCreatureSet * target, c
 	for(auto pair : creToPower)
 		resultingArmy.push_back(pair.second);
 
-	boost::sort(resultingArmy, [](const SlotInfo & left, const SlotInfo & right) -> bool
+	std::sort(resultingArmy.begin(), resultingArmy.end(), [](const SlotInfo & left, const SlotInfo & right) -> bool
 	{
 		return left.power > right.power;
 	});

AI/VCAI/FuzzyHelper.cpp

@@ -37,7 +37,7 @@ Goals::TSubgoal FuzzyHelper::chooseSolution(Goals::TGoalVec vec)
 	{
 		return lhs->hero.h < rhs->hero.h;
 	};
-	boost::sort(vec, sortByHeroes);
+	std::sort(vec.begin(), vec.end(), sortByHeroes);
 
 	for(auto g : vec)
 	{

AI/VCAI/Goals/CollectRes.cpp

@@ -139,7 +139,7 @@ TSubgoal CollectRes::whatToDoToTrade()
 		}
 	}
 
-	boost::sort(markets, [](const IMarket * m1, const IMarket * m2) -> bool
+	std::sort(markets.begin(), markets.end(), [](const IMarket * m1, const IMarket * m2) -> bool
 	{
 		return m1->getMarketEfficiency() < m2->getMarketEfficiency();
 	});

AI/VCAI/Goals/Explore.cpp

@@ -433,7 +433,7 @@ TSubgoal Explore::exploreNearestNeighbour(HeroPtr h) const
 	if(nearbyVisitableObjs.size())
 	{
 		vstd::removeDuplicates(nearbyVisitableObjs); //one object may occupy multiple tiles
-		boost::sort(nearbyVisitableObjs, CDistanceSorter(h.get()));
+		std::sort(nearbyVisitableObjs.begin(), nearbyVisitableObjs.end(), CDistanceSorter(h.get()));
 
 		TSubgoal pickupNearestObj = fh->chooseSolution(ai->ah->howToVisitObj(h, nearbyVisitableObjs.back(), false));
 

AI/VCAI/Goals/Win.cpp

@@ -97,7 +97,7 @@ TSubgoal Win::whatToDoToAchieve()
 								return vstd::contains(t->forbiddenBuildings, BuildingID::GRAIL);
 							}),
 								towns.end());
-						boost::sort(towns, CDistanceSorter(h.get()));
+						std::sort(towns.begin(), towns.end(), CDistanceSorter(h.get()));
 						if(towns.size())
 						{
 							return sptr(VisitTile(towns.front()->visitablePos()).sethero(h));

AI/VCAI/VCAI.cpp

@@ -1038,7 +1038,7 @@ void VCAI::mainLoop()
 				vstd::erase_if_present(basicGoals, goal);
 
 			//add abstract goals
-			boost::sort(goalsToAdd, [](const Goals::TSubgoal & lhs, const Goals::TSubgoal & rhs) -> bool
+			std::sort(goalsToAdd.begin(), goalsToAdd.end(), [](const Goals::TSubgoal & lhs, const Goals::TSubgoal & rhs) -> bool
 			{
 				return lhs->priority > rhs->priority; //highest priority at the beginning
 			});

client/windows/CCastleInterface.cpp

@@ -725,7 +725,7 @@ void CCastleBuildings::recreate()
 		return (*b1)<(*b2);
 	};
 
-	boost::sort(children, buildSorter); //TODO: create building in blit order
+	std::sort(children.begin(), children.end(), buildSorter); //TODO: create building in blit order
 }
 
 void CCastleBuildings::drawOverlays(Canvas & to, std::vector<std::shared_ptr<CBuildingRect>> buildingRects)

lib/battle/CBattleInfoCallback.cpp

@@ -527,14 +527,14 @@ void CBattleInfoCallback::battleGetTurnOrder(std::vector<battle::Units> & turns,
 		phases[unitPhase].push_back(unit);
 	}
 
-	boost::sort(phases[BattlePhases::SIEGE], CMP_stack(BattlePhases::SIEGE, actualTurn, sideThatLastMoved));
+	std::sort(phases[BattlePhases::SIEGE].begin(), phases[BattlePhases::SIEGE].end(), CMP_stack(BattlePhases::SIEGE, actualTurn, sideThatLastMoved));
 	std::copy(phases[BattlePhases::SIEGE].begin(), phases[BattlePhases::SIEGE].end(), std::back_inserter(turns.back()));
 
 	if(turnsIsFull())
 		return;
 
 	for(uint8_t phase = BattlePhases::NORMAL; phase < BattlePhases::NUMBER_OF_PHASES; phase++)
-		boost::sort(phases[phase], CMP_stack(phase, actualTurn, sideThatLastMoved));
+		std::sort(phases[phase].begin(), phases[phase].end(), CMP_stack(phase, actualTurn, sideThatLastMoved));
 
 	uint8_t phase = BattlePhases::NORMAL;
 	while(!turnsIsFull() && phase < BattlePhases::NUMBER_OF_PHASES)

lib/bonuses/BonusList.cpp

@@ -16,7 +16,7 @@ VCMI_LIB_NAMESPACE_BEGIN
 
 void BonusList::stackBonuses()
 {
-	boost::sort(bonuses, [](const std::shared_ptr<Bonus> & b1, const std::shared_ptr<Bonus> & b2) -> bool
+	std::sort(bonuses.begin(), bonuses.end(), [](const std::shared_ptr<Bonus> & b1, const std::shared_ptr<Bonus> & b2) -> bool
 	{
 		if(b1 == b2)
 			return false;

lib/mapping/ObstacleProxy.cpp

@@ -49,7 +49,7 @@ void ObstacleProxy::sortObstacles()
 	{
 		possibleObstacles.emplace_back(o);
 	}
-	boost::sort(possibleObstacles, [](const ObstaclePair &p1, const ObstaclePair &p2) -> bool
+	std::sort(possibleObstacles.begin(), possibleObstacles.end(), [](const ObstaclePair &p1, const ObstaclePair &p2) -> bool
 	{
 		return p1.first > p2.first; //bigger obstacles first
 	});

lib/rmg/CZonePlacer.cpp

@@ -709,7 +709,7 @@ void CZonePlacer::moveOneZone(TZoneMap& zones, TForceVector& totalForces, TDista
 	if (misplacedZones.empty())
 		return;
 
-	boost::sort(misplacedZones, [](const Misplacement& lhs, Misplacement& rhs)
+	std::sort(misplacedZones.begin(), misplacedZones.end(), [](const Misplacement& lhs, Misplacement& rhs)
 	{
 		return lhs.first > rhs.first; //Largest displacement first
 	});

lib/rmg/modificators/TreasurePlacer.cpp

@@ -939,7 +939,7 @@ void TreasurePlacer::createTreasures(ObjectManager& manager)
 
 	//place biggest treasures first at large distance, place smaller ones inbetween
 	auto treasureInfo = zone.getTreasureInfo();
-	boost::sort(treasureInfo, valueComparator);
+	std::sort(treasureInfo.begin(), treasureInfo.end(), valueComparator);
 
 	//sort treasures by ascending value so we can stop checking treasures with too high value
 	objects.sortPossibleObjects();
@@ -1202,7 +1202,7 @@ std::vector<ObjectInfo> & TreasurePlacer::ObjectPool::getPossibleObjects()
 
 void TreasurePlacer::ObjectPool::sortPossibleObjects()
 {
-	boost::sort(possibleObjects, [](const ObjectInfo& oi1, const ObjectInfo& oi2) -> bool
+	std::sort(possibleObjects.begin(), possibleObjects.end(), [](const ObjectInfo& oi1, const ObjectInfo& oi2) -> bool
 	{
 		return oi1.value < oi2.value;
 	});