Merge pull request #41 from vcmi/refactoring/initializers

Works under Visual, merging.

AI/StupidAI/StupidAI.cpp

@@ -108,7 +108,7 @@ BattleAction CStupidAI::activeStack( const CStack * stack )
 	if(stack->type->idNumber == CreatureID::CATAPULT)
 	{
 		BattleAction attack;
-		static const std::vector<int> wallHexes = boost::assign::list_of(50)(183)(182)(130)(62)(29)(12)(95);
+		static const std::vector<int> wallHexes = {50, 183, 182, 130, 62, 29, 12, 95};
 
 		attack.destinationTile = *RandomGeneratorUtil::nextItem(wallHexes, CRandomGenerator::getDefault());
 		attack.actionType = Battle::CATAPULT;

AI/VCAI/Fuzzy.cpp

@@ -27,7 +27,6 @@ class FuzzyEngine;
 class InputLVar;
 class CGTownInstance;
 
-using namespace boost::assign;
 using namespace vstd;
 //using namespace Goals;
 
@@ -118,9 +117,6 @@ void FuzzyHelper::initTacticalAdvantage()
 {
 	try
 	{
-		//Tactical advantage calculation
-		std::vector<fl::InputLVar*> helper;
-
 		ta.ourShooters = new fl::InputLVar("OurShooters");
 		ta.ourWalkers = new fl::InputLVar("OurWalkers");
 		ta.ourFlyers = new fl::InputLVar("OurFlyers");
@@ -128,7 +124,11 @@ void FuzzyHelper::initTacticalAdvantage()
 		ta.enemyWalkers = new fl::InputLVar("EnemyWalkers");
 		ta.enemyFlyers = new fl::InputLVar("EnemyFlyers");
 
-		helper += ta.ourShooters, ta.ourWalkers, ta.ourFlyers, ta.enemyShooters, ta.enemyWalkers, ta.enemyFlyers;
+		//Tactical advantage calculation
+		std::vector<fl::InputLVar*> helper =
+		{
+			ta.ourShooters, ta.ourWalkers, ta.ourFlyers, ta.enemyShooters, ta.enemyWalkers, ta.enemyFlyers
+		};
 
 		for (auto val : helper)
 		{
@@ -136,12 +136,11 @@ void FuzzyHelper::initTacticalAdvantage()
 			val->addTerm (new fl::ShoulderTerm("FEW", 0, 0.6, true));
 			val->addTerm (new fl::ShoulderTerm("MANY", 0.4, 1, false));
 		}
-		helper.clear();
 
 		ta.ourSpeed =  new fl::InputLVar("OurSpeed");
 		ta.enemySpeed = new fl::InputLVar("EnemySpeed");
 
-		helper += ta.ourSpeed, ta.enemySpeed;
+		helper = {ta.ourSpeed, ta.enemySpeed};
 
 		for (auto val : helper)
 		{
@@ -334,15 +333,13 @@ void FuzzyHelper::initVisitTile()
 {
 	try
 	{
-		std::vector<fl::InputLVar*> helper;
-
 		vt.strengthRatio = new fl::InputLVar("strengthRatio"); //hero must be strong enough to defeat guards
 		vt.heroStrength = new fl::InputLVar("heroStrength"); //we want to use weakest possible hero
 		vt.turnDistance = new fl::InputLVar("turnDistance"); //we want to use hero who is near
 		vt.missionImportance = new fl::InputLVar("lockedMissionImportance"); //we may want to preempt hero with low-priority mission
 		vt.value = new fl::OutputLVar("Value");
 
-		helper += vt.strengthRatio, vt.heroStrength, vt.turnDistance, vt.missionImportance;
+		std::vector<fl::InputLVar*> helper = {vt.strengthRatio, vt.heroStrength, vt.turnDistance, vt.missionImportance};
 		for (auto val : helper)
 		{
 			engine.addInputLVar(val);

Global.h

@@ -16,10 +16,6 @@
 // Fixed width bool data type is important for serialization
 static_assert(sizeof(bool) == 1, "Bool needs to be 1 byte in size.");
 
-#if defined _M_X64 && defined _WIN32 //Win64 -> cannot load 32-bit DLLs for video handling
-#  define DISABLE_VIDEO
-#endif
-
 #ifdef __GNUC__
 #  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__ * 10 + __GNUC_PATCHLEVEL__)
 #endif
@@ -32,16 +28,6 @@ static_assert(sizeof(bool) == 1, "Bool needs to be 1 byte in size.");
 #  error This GCC version has buggy std::array::at version and should not be used. Please update to 4.7.2 or later
 #endif
 
-/* ---------------------------------------------------------------------------- */
-/* Guarantee compiler features */
-/* ---------------------------------------------------------------------------- */
-//defining available c++11 features
-
-//initialization lists - gcc or clang
-#if defined(__clang__) || defined(__GNUC__)
-#  define CPP11_USE_INITIALIZERS_LIST
-#endif
-
 /* ---------------------------------------------------------------------------- */
 /* Suppress some compiler warnings */
 /* ---------------------------------------------------------------------------- */
@@ -140,7 +126,6 @@ static_assert(sizeof(bool) == 1, "Bool needs to be 1 byte in size.");
 #define BOOST_BIND_NO_PLACEHOLDERS
 
 #include <boost/algorithm/string.hpp>
-#include <boost/assign.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/current_function.hpp>
 #include <boost/crc.hpp>
@@ -690,6 +675,13 @@ namespace vstd
 		boost::sort(vec);
 		vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
 	}
+	
+	template <typename T>
+	void concatenate(std::vector<T> &dest, const std::vector<T> &src)
+	{
+		dest.reserve(dest.size() + src.size());
+		dest.insert(dest.end(), src.begin(), src.end());	
+	}
 
 	using boost::math::round;
 }

client/CMusicHandler.cpp

@@ -21,8 +21,6 @@
  *
  */
 
-using namespace boost::assign;
-
 #define VCMI_SOUND_NAME(x)
 #define VCMI_SOUND_FILE(y) #y,
 
@@ -88,18 +86,26 @@ CSoundHandler::CSoundHandler():
 	listener(std::bind(&CSoundHandler::onVolumeChange, this, _1));
 
 	// Vectors for helper(s)
-	pickupSounds += soundBase::pickup01, soundBase::pickup02, soundBase::pickup03,
-		soundBase::pickup04, soundBase::pickup05, soundBase::pickup06, soundBase::pickup07;
+	pickupSounds = 
+	{
+		soundBase::pickup01, soundBase::pickup02, soundBase::pickup03,
+		soundBase::pickup04, soundBase::pickup05, soundBase::pickup06, soundBase::pickup07
+	};
 
-    horseSounds +=  // must be the same order as terrains (see ETerrainType);
+    horseSounds =  // must be the same order as terrains (see ETerrainType);
+    {
 		soundBase::horseDirt, soundBase::horseSand, soundBase::horseGrass,
 		soundBase::horseSnow, soundBase::horseSwamp, soundBase::horseRough,
 		soundBase::horseSubterranean, soundBase::horseLava,
-		soundBase::horseWater, soundBase::horseRock;
+		soundBase::horseWater, soundBase::horseRock
+    };
 
-	battleIntroSounds +=     soundBase::battle00, soundBase::battle01,
+	battleIntroSounds =
+	{
+		soundBase::battle00, soundBase::battle01,
 	    soundBase::battle02, soundBase::battle03, soundBase::battle04,
-	    soundBase::battle05, soundBase::battle06, soundBase::battle07;
+	    soundBase::battle05, soundBase::battle06, soundBase::battle07
+	};
 };
 
 void CSoundHandler::init()

client/CPlayerInterface.cpp

@@ -71,7 +71,6 @@
 		return;						\
 	RETURN_IF_QUICK_COMBAT
 
-using namespace boost::assign;
 using namespace CSDL_Ext;
 
 void processCommand(const std::string &message, CClient *&client);
@@ -1438,7 +1437,7 @@ void CPlayerInterface::initializeHeroTownList()
 
 	for (auto & allHeroe : allHeroes)
 		if (!allHeroe->inTownGarrison)
-			wanderingHeroes += allHeroe;
+			wanderingHeroes.push_back(allHeroe);
 
 	std::vector<const CGTownInstance*> allTowns = cb->getTownsInfo();
 	/*

client/CPreGame.cpp

@@ -306,11 +306,11 @@ void CMenuScreen::switchToTab(size_t index)
 //funciton for std::string -> std::function conversion for main menu
 static std::function<void()> genCommand(CMenuScreen* menu, std::vector<std::string> menuType, const std::string &string)
 {
-	static const std::vector<std::string> commandType  = boost::assign::list_of
-		("to")("campaigns")("start")("load")("exit")("highscores");
+	static const std::vector<std::string> commandType  = 
+		{"to", "campaigns", "start", "load", "exit", "highscores"};
 
-	static const std::vector<std::string> gameType = boost::assign::list_of
-		("single")("multi")("campaign")("tutorial");
+	static const std::vector<std::string> gameType = 
+		{"single", "multi", "campaign", "tutorial"};
 
 	std::list<std::string> commands;
 	boost::split(commands, string, boost::is_any_of("\t "));
@@ -1624,13 +1624,12 @@ CRandomMapTab::CRandomMapTab()
 	mapSizeBtnGroup = new CToggleGroup(0);
 	mapSizeBtnGroup->pos.y += 81;
 	mapSizeBtnGroup->pos.x += 158;
-	const std::vector<std::string> mapSizeBtns = boost::assign::list_of("RANSIZS")("RANSIZM")("RANSIZL")("RANSIZX");
+	const std::vector<std::string> mapSizeBtns = {"RANSIZS", "RANSIZM","RANSIZL","RANSIZX"};
 	addButtonsToGroup(mapSizeBtnGroup, mapSizeBtns, 0, 3, 47, 198);
 	mapSizeBtnGroup->setSelected(1);
 	mapSizeBtnGroup->addCallback([&](int btnId)
 	{
-		const std::vector<int> mapSizeVal = boost::assign::list_of(CMapHeader::MAP_SIZE_SMALL)(CMapHeader::MAP_SIZE_MIDDLE)
-				(CMapHeader::MAP_SIZE_LARGE)(CMapHeader::MAP_SIZE_XLARGE);
+		const std::vector<int> mapSizeVal = {CMapHeader::MAP_SIZE_SMALL,CMapHeader::MAP_SIZE_MIDDLE,CMapHeader::MAP_SIZE_LARGE,CMapHeader::MAP_SIZE_XLARGE};
 		mapGenOptions.setWidth(mapSizeVal[btnId]);
 		mapGenOptions.setHeight(mapSizeVal[btnId]);
 		updateMapInfo();
@@ -1706,7 +1705,7 @@ CRandomMapTab::CRandomMapTab()
 	waterContentGroup = new CToggleGroup(0);
 	waterContentGroup->pos.y += 419;
 	waterContentGroup->pos.x += BTNS_GROUP_LEFT_MARGIN;
-	const std::vector<std::string> waterContentBtns = boost::assign::list_of("RANNONE")("RANNORM")("RANISLD");
+	const std::vector<std::string> waterContentBtns = {"RANNONE","RANNORM","RANISLD"};
 	addButtonsWithRandToGroup(waterContentGroup, waterContentBtns, 0, 2, WIDE_BTN_WIDTH, 243, 246);
 	waterContentGroup->addCallback([&](int btnId)
 	{
@@ -1717,7 +1716,7 @@ CRandomMapTab::CRandomMapTab()
 	monsterStrengthGroup = new CToggleGroup(0);
 	monsterStrengthGroup->pos.y += 485;
 	monsterStrengthGroup->pos.x += BTNS_GROUP_LEFT_MARGIN;
-	const std::vector<std::string> monsterStrengthBtns = boost::assign::list_of("RANWEAK")("RANNORM")("RANSTRG");
+	const std::vector<std::string> monsterStrengthBtns = {"RANWEAK","RANNORM","RANSTRG"};
 	addButtonsWithRandToGroup(monsterStrengthGroup, monsterStrengthBtns, 0, 2, WIDE_BTN_WIDTH, 248, 251);
 	monsterStrengthGroup->addCallback([&](int btnId)
 	{

client/Graphics.cpp

@@ -23,7 +23,6 @@
 #include "../lib/CStopWatch.h"
 #include "../lib/mapObjects/CObjectClassesHandler.h"
 
-using namespace boost::assign;
 using namespace CSDL_Ext;
 #ifdef min
 #undef min
@@ -157,9 +156,12 @@ Graphics::Graphics()
 
 void Graphics::loadHeroAnims()
 {
-	std::vector<std::pair<int,int> > rotations; //first - group number to be rotated1, second - group number after rotation1
-	rotations += std::make_pair(6,10), std::make_pair(7,11), std::make_pair(8,12), std::make_pair(1,13),
-		std::make_pair(2,14), std::make_pair(3,15);
+	//first - group number to be rotated1, second - group number after rotation1
+	std::vector<std::pair<int,int> > rotations = 
+	{
+		{6,10}, {7,11}, {8,12}, {1,13},
+		{2,14}, {3,15}
+	};
 
 	for(auto & elem : CGI->heroh->classes.heroClasses)
 	{
@@ -216,8 +218,12 @@ void Graphics::loadHeroFlagsDetail(std::pair<std::vector<CDefEssential *> Graphi
 {
 	for(int i=0;i<8;i++)
 		(this->*pr.first).push_back(CDefHandler::giveDefEss(pr.second[i]));
-	std::vector<std::pair<int,int> > rotations; //first - group number to be rotated1, second - group number after rotation1
-	rotations += std::make_pair(6,10), std::make_pair(7,11), std::make_pair(8,12);
+	//first - group number to be rotated1, second - group number after rotation1
+	std::vector<std::pair<int,int> > rotations = 
+	{
+		{6,10}, {7,11}, {8,12}
+	};
+	
 	for(int q=0; q<8; ++q)
 	{
 		std::vector<Cimage> &curImgs = (this->*pr.first)[q]->ourImages;
@@ -269,21 +275,32 @@ void Graphics::loadHeroFlagsDetail(std::pair<std::vector<CDefEssential *> Graphi
 
 void Graphics::loadHeroFlags()
 {
-	using namespace boost::assign;
 	CStopWatch th;
-	std::pair<std::vector<CDefEssential *> Graphics::*, std::vector<const char *> > pr[4];
-	pr[0].first = &Graphics::flags1;
-	pr[0].second+=("ABF01L.DEF"),("ABF01G.DEF"),("ABF01R.DEF"),("ABF01D.DEF"),("ABF01B.DEF"),
-		("ABF01P.DEF"),("ABF01W.DEF"),("ABF01K.DEF");
-	pr[1].first = &Graphics::flags2;
-	pr[1].second+=("ABF02L.DEF"),("ABF02G.DEF"),("ABF02R.DEF"),("ABF02D.DEF"),("ABF02B.DEF"),
-		("ABF02P.DEF"),("ABF02W.DEF"),("ABF02K.DEF");
-	pr[2].first = &Graphics::flags3;
-	pr[2].second+=("ABF03L.DEF"),("ABF03G.DEF"),("ABF03R.DEF"),("ABF03D.DEF"),("ABF03B.DEF"),
-		("ABF03P.DEF"),("ABF03W.DEF"),("ABF03K.DEF");
-	pr[3].first = &Graphics::flags4;
-	pr[3].second+=("AF00.DEF"),("AF01.DEF"),("AF02.DEF"),("AF03.DEF"),("AF04.DEF"),
-		("AF05.DEF"),("AF06.DEF"),("AF07.DEF");
+	std::pair<std::vector<CDefEssential *> Graphics::*, std::vector<const char *> > pr[4] =
+	{
+		{
+			&Graphics::flags1, 
+			{"ABF01L.DEF","ABF01G.DEF","ABF01R.DEF","ABF01D.DEF","ABF01B.DEF",
+			"ABF01P.DEF","ABF01W.DEF","ABF01K.DEF"} 
+		},
+		{
+			&Graphics::flags2,
+			{"ABF02L.DEF","ABF02G.DEF","ABF02R.DEF","ABF02D.DEF","ABF02B.DEF",
+			"ABF02P.DEF","ABF02W.DEF","ABF02K.DEF"}
+			
+		},
+		{
+			&Graphics::flags3,
+			{"ABF03L.DEF","ABF03G.DEF","ABF03R.DEF","ABF03D.DEF","ABF03B.DEF",
+			"ABF03P.DEF","ABF03W.DEF","ABF03K.DEF"}
+		},
+		{
+			&Graphics::flags4,
+			{"AF00.DEF","AF01.DEF","AF02.DEF","AF03.DEF","AF04.DEF",
+			"AF05.DEF","AF06.DEF","AF07.DEF"}
+		}		
+	};
+
 	#if 0
 	boost::thread_group grupa;
 	for(int g=3; g>=0; --g)

client/battle/CBattleInterface.cpp

@@ -35,7 +35,6 @@
 #include "../../lib/NetPacks.h"
 #include "../../lib/UnlockGuard.h"
 
-using namespace boost::assign;
 
 /*
  * CBattleInterface.cpp, part of VCMI engine
@@ -1737,7 +1736,8 @@ void CBattleInterface::getPossibleActionsForStack(const CStack * stack)
 	possibleActions.clear();
 	if (tacticsMode)
 	{
-		possibleActions += MOVE_TACTICS, CHOOSE_TACTICS_STACK;
+		possibleActions.push_back(MOVE_TACTICS);
+		possibleActions.push_back(CHOOSE_TACTICS_STACK);
 	}
 	else
 	{

client/widgets/CArtifactHolder.cpp

@@ -692,8 +692,6 @@ CArtifactsOfHero::CArtifactsOfHero(std::vector<CArtPlace *> ArtWorn, std::vector
 CArtifactsOfHero::CArtifactsOfHero(const Point& position, bool createCommonPart /*= false*/)
  : curHero(nullptr), backpackPos(0), commonInfo(nullptr), updateState(false), allowedAssembling(true), highlightModeCallback(nullptr)
 {
-	using namespace boost::assign;
-
 	if(createCommonPart)
 	{
 		commonInfo = new CArtifactsOfHero::SCommonPart;
@@ -704,14 +702,16 @@ CArtifactsOfHero::CArtifactsOfHero(const Point& position, bool createCommonPart
 	pos += position;
 	artWorn.resize(19);
 
-	std::vector<Point> slotPos;
-	slotPos += Point(509,30),  Point(567,240), Point(509,80),
-	           Point(383,68),  Point(564,183), Point(509,130),
-	           Point(431,68),  Point(610,183), Point(515,295),
-	           Point(383,143), Point(399,194), Point(415,245),
-	           Point(431,296), Point(564,30),  Point(610,30),
-	           Point(610,76),  Point(610,122), Point(610,310),
-	           Point(381,296);
+	std::vector<Point> slotPos =
+	{
+		Point(509,30),  Point(567,240), Point(509,80),
+		Point(383,68),  Point(564,183), Point(509,130),
+		Point(431,68),  Point(610,183), Point(515,295),
+		Point(383,143), Point(399,194), Point(415,245),
+		Point(431,296), Point(564,30),  Point(610,30),
+		Point(610,76),  Point(610,122), Point(610,310),
+		Point(381,296)
+	};
 
 	// Create slots for worn artifacts.
 	for (size_t g = 0; g < GameConstants::BACKPACK_START ; g++)

client/windows/CAdvmapInterface.cpp

@@ -55,7 +55,6 @@
 
 #define ADVOPT (conf.go()->ac)
 using namespace boost::logic;
-using namespace boost::assign;
 using namespace CSDL_Ext;
 
 CAdvMapInt *adventureInt;
@@ -692,7 +691,7 @@ bool CAdvMapInt::isHeroSleeping(const CGHeroInstance *hero)
 void CAdvMapInt::setHeroSleeping(const CGHeroInstance *hero, bool sleep)
 {
 	if (sleep)
-		LOCPLINT->sleepingHeroes += hero;
+		LOCPLINT->sleepingHeroes.push_back(hero); //FIXME: should we check for existence?
 	else
 		LOCPLINT->sleepingHeroes -= hero;
 	updateNextHero(nullptr);

client/windows/CCastleInterface.cpp

@@ -32,8 +32,6 @@
 #include "../../lib/mapObjects/CGHeroInstance.h"
 #include "../../lib/mapObjects/CGTownInstance.h"
 
-using namespace boost::assign;
-
 /*
  * CCastleInterface.cpp, part of VCMI engine
  *
@@ -1449,15 +1447,20 @@ CFortScreen::CFortScreen(const CGTownInstance * town):
 	exit = new CButton(Point(748, 556), "TPMAGE1", CButton::tooltip(text), [&]{ close(); }, SDLK_RETURN);
 	exit->assignedKeys.insert(SDLK_ESCAPE);
 
-	std::vector<Point> positions;
-	positions += Point(10,  22), Point(404, 22),
-	             Point(10, 155), Point(404,155),
-	             Point(10, 288), Point(404,288);
+	std::vector<Point> positions =
+	{
+		Point(10,  22), Point(404, 22),
+		Point(10, 155), Point(404,155),
+		Point(10, 288), Point(404,288)
+	};
 
 	if (fortSize == GameConstants::CREATURES_PER_TOWN)
-		positions += Point(206,421);
+		positions.push_back(Point(206,421));
 	else
-		positions += Point(10, 421), Point(404,421);
+	{
+		positions.push_back(Point(10, 421));
+		positions.push_back(Point(404,421));
+	}		
 
 	for (ui32 i=0; i<fortSize; i++)
 	{
@@ -1658,14 +1661,14 @@ CMageGuildScreen::CMageGuildScreen(CCastleInterface * owner,std::string imagem)
 	exit = new CButton(Point(748, 556), "TPMAGE1.DEF", CButton::tooltip(CGI->generaltexth->allTexts[593]), [&]{ close(); }, SDLK_RETURN);
 	exit->assignedKeys.insert(SDLK_ESCAPE);
 
-	std::vector<std::vector<Point> > positions;
-
-	positions.resize(5);
-	positions[0] += Point(222,445), Point(312,445), Point(402,445), Point(520,445), Point(610,445), Point(700,445);
-	positions[1] += Point(48,53),   Point(48,147),  Point(48,241),  Point(48,335),  Point(48,429);
-	positions[2] += Point(570,82),  Point(672,82),  Point(570,157), Point(672,157);
-	positions[3] += Point(183,42),  Point(183,148), Point(183,253);
-	positions[4] += Point(491,325), Point(591,325);
+	static const std::vector<std::vector<Point> > positions = 
+	{
+		{Point(222,445), Point(312,445), Point(402,445), Point(520,445), Point(610,445), Point(700,445)},
+		{Point(48,53),   Point(48,147),  Point(48,241),  Point(48,335),  Point(48,429)},
+		{Point(570,82),  Point(672,82),  Point(570,157), Point(672,157)},
+		{Point(183,42),  Point(183,148), Point(183,253)},
+		{Point(491,325), Point(591,325)}
+	};
 
 	for(size_t i=0; i<owner->town->town->mageLevel; i++)
 	{

client/windows/CHeroWindow.cpp

@@ -39,7 +39,6 @@
  *
  */
 
-using namespace boost::assign;
 
 const TBonusListPtr CHeroWithMaybePickedArtifact::getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root /*= nullptr*/, const std::string &cachingStr /*= ""*/) const
 {

client/windows/CTradeWindow.cpp

@@ -471,8 +471,6 @@ std::vector<int> *CTradeWindow::getItemsIds(bool Left)
 
 void CTradeWindow::getPositionsFor(std::vector<Rect> &poss, bool Left, EType type) const
 {
-	using namespace boost::assign;
-
 	if(mode == EMarketMode::ARTIFACT_EXP && !Left)
 	{
 		//22 boxes, 5 in row, last row: two boxes centered
@@ -484,10 +482,10 @@ void CTradeWindow::getPositionsFor(std::vector<Rect> &poss, bool Left, EType typ
 		dy = 70;
 		for (int i = 0; i < 4 ; i++)
 			for (int j = 0; j < 5 ; j++)
-				poss += Rect(x + dx*j, y + dy*i, w, h);
+				poss.push_back(Rect(x + dx*j, y + dy*i, w, h));
 
-		poss += Rect(x + dx*1.5, y + dy*4, w, h);
-		poss += Rect(x + dx*2.5, y + dy*4, w, h);
+		poss.push_back(Rect(x + dx*1.5, y + dy*4, w, h));
+		poss.push_back(Rect(x + dx*2.5, y + dy*4, w, h));
 	}
 	else
 	{
@@ -498,10 +496,15 @@ void CTradeWindow::getPositionsFor(std::vector<Rect> &poss, bool Left, EType typ
 		int h, w, x, y, dx, dy;
 		int leftToRightOffset;
 		getBaseForPositions(type, dx, dy, x, y, h, w, !Left, leftToRightOffset);
-
-		poss += genRect(h, w, x, y), genRect(h, w, x + dx, y), genRect(h, w, x + 2*dx, y),
+		
+		const std::vector<Rect> tmp = 
+		{
+			genRect(h, w, x, y), genRect(h, w, x + dx, y), genRect(h, w, x + 2*dx, y),
 			genRect(h, w, x, y + dy), genRect(h, w, x + dx, y + dy), genRect(h, w, x + 2*dx, y + dy),
-			genRect(h, w, x + dx, y + 2*dy);
+			genRect(h, w, x + dx, y + 2*dy)			
+		};
+		
+		vstd::concatenate(poss, tmp);
 
 		if(!Left)
 		{

client/windows/GUIClasses.cpp

@@ -61,7 +61,6 @@
  *
  */
 
-using namespace boost::assign;
 using namespace CSDL_Ext;
 
 std::list<CFocusable*> CFocusable::focusables;

lib/BattleState.cpp

@@ -761,18 +761,20 @@ shared_ptr<CObstacleInstance> BattleInfo::getObstacleOnTile(BattleHex tile) cons
 
 BattlefieldBI::BattlefieldBI BattleInfo::battlefieldTypeToBI(BFieldType bfieldType)
 {
-	static const std::map<BFieldType, BattlefieldBI::BattlefieldBI> theMap = boost::assign::map_list_of
-		(BFieldType::CLOVER_FIELD, BattlefieldBI::CLOVER_FIELD)
-		(BFieldType::CURSED_GROUND, BattlefieldBI::CURSED_GROUND)
-		(BFieldType::EVIL_FOG, BattlefieldBI::EVIL_FOG)
-		(BFieldType::FAVOURABLE_WINDS, BattlefieldBI::NONE)
-		(BFieldType::FIERY_FIELDS, BattlefieldBI::FIERY_FIELDS)
-		(BFieldType::HOLY_GROUND, BattlefieldBI::HOLY_GROUND)
-		(BFieldType::LUCID_POOLS, BattlefieldBI::LUCID_POOLS)
-		(BFieldType::MAGIC_CLOUDS, BattlefieldBI::MAGIC_CLOUDS)
-		(BFieldType::MAGIC_PLAINS, BattlefieldBI::MAGIC_PLAINS)
-		(BFieldType::ROCKLANDS, BattlefieldBI::ROCKLANDS)
-		(BFieldType::SAND_SHORE, BattlefieldBI::COASTAL);
+	static const std::map<BFieldType, BattlefieldBI::BattlefieldBI> theMap = 
+	{
+		{BFieldType::CLOVER_FIELD, BattlefieldBI::CLOVER_FIELD},
+		{BFieldType::CURSED_GROUND, BattlefieldBI::CURSED_GROUND},
+		{BFieldType::EVIL_FOG, BattlefieldBI::EVIL_FOG},
+		{BFieldType::FAVOURABLE_WINDS, BattlefieldBI::NONE},
+		{BFieldType::FIERY_FIELDS, BattlefieldBI::FIERY_FIELDS},
+		{BFieldType::HOLY_GROUND, BattlefieldBI::HOLY_GROUND},
+		{BFieldType::LUCID_POOLS, BattlefieldBI::LUCID_POOLS},
+		{BFieldType::MAGIC_CLOUDS, BattlefieldBI::MAGIC_CLOUDS},
+		{BFieldType::MAGIC_PLAINS, BattlefieldBI::MAGIC_PLAINS},
+		{BFieldType::ROCKLANDS, BattlefieldBI::ROCKLANDS},
+		{BFieldType::SAND_SHORE, BattlefieldBI::COASTAL}
+	};
 
 	auto itr = theMap.find(bfieldType);
 	if(itr != theMap.end())

lib/CArtHandler.cpp

@@ -23,8 +23,6 @@
 
 #include "mapObjects/CObjectClassesHandler.h"
 
-using namespace boost::assign;
-
 // Note: list must match entries in ArtTraits.txt
 #define ART_POS_LIST    \
 	ART_POS(SPELLBOOK)  \
@@ -45,7 +43,7 @@ using namespace boost::assign;
 	ART_POS(RIGHT_HAND) \
 	ART_POS(NECK)       \
 	ART_POS(SHOULDERS)  \
-	ART_POS(HEAD);
+	ART_POS(HEAD)
 
 const std::string & CArtifact::Name() const
 {
@@ -157,12 +155,12 @@ std::vector<JsonNode> CArtHandler::loadLegacyData(size_t dataSize)
 	std::vector<JsonNode> h3Data;
 	h3Data.reserve(dataSize);
 
-	#define ART_POS(x) (  #x)
-	const std::vector<std::string> artSlots = boost::assign::list_of ART_POS_LIST;
+	#define ART_POS(x) #x ,
+	const std::vector<std::string> artSlots = { ART_POS_LIST };
 	#undef ART_POS
 
 	static std::map<char, std::string> classes =
-	  map_list_of('S',"SPECIAL")('T',"TREASURE")('N',"MINOR")('J',"MAJOR")('R',"RELIC");
+		{{'S',"SPECIAL"}, {'T',"TREASURE"},{'N',"MINOR"},{'J',"MAJOR"},{'R',"RELIC"},};
 
 	CLegacyConfigParser parser("DATA/ARTRAITS.TXT");
 	CLegacyConfigParser events("DATA/ARTEVENT.TXT");
@@ -264,8 +262,8 @@ CArtifact * CArtHandler::loadFromJson(const JsonNode & node)
 
 ArtifactPosition CArtHandler::stringToSlot(std::string slotName)
 {
-#define ART_POS(x) ( #x, ArtifactPosition::x )
-	static const std::map<std::string, ArtifactPosition> artifactPositionMap = boost::assign::map_list_of ART_POS_LIST;
+#define ART_POS(x) { #x, ArtifactPosition::x },
+	static const std::map<std::string, ArtifactPosition> artifactPositionMap = { ART_POS_LIST };
 #undef ART_POS
 	auto it = artifactPositionMap.find (slotName);
 	if (it != artifactPositionMap.end())
@@ -277,13 +275,23 @@ ArtifactPosition CArtHandler::stringToSlot(std::string slotName)
 
 void CArtHandler::addSlot(CArtifact * art, const std::string & slotID)
 {
+	static const std::vector<ArtifactPosition> miscSlots = 
+	{
+		ArtifactPosition::MISC1, ArtifactPosition::MISC2, ArtifactPosition::MISC3, ArtifactPosition::MISC4, ArtifactPosition::MISC5
+	};
+	
+	static const std::vector<ArtifactPosition> ringSlots =
+	{
+		ArtifactPosition::LEFT_RING, ArtifactPosition::RIGHT_RING
+	};
+	
 	if (slotID == "MISC")
 	{
-		art->possibleSlots[ArtBearer::HERO] += ArtifactPosition::MISC1, ArtifactPosition::MISC2, ArtifactPosition::MISC3, ArtifactPosition::MISC4, ArtifactPosition::MISC5;
+		vstd::concatenate(art->possibleSlots[ArtBearer::HERO], miscSlots);
 	}
 	else if (slotID == "RING")
 	{
-		art->possibleSlots[ArtBearer::HERO] += ArtifactPosition::LEFT_RING, ArtifactPosition::RIGHT_RING;
+		vstd::concatenate(art->possibleSlots[ArtBearer::HERO], ringSlots);
 	}
 	else
 	{
@@ -309,12 +317,14 @@ void CArtHandler::loadSlots(CArtifact * art, const JsonNode & node)
 
 CArtifact::EartClass CArtHandler::stringToClass(std::string className)
 {
-	static const std::map<std::string, CArtifact::EartClass> artifactClassMap = boost::assign::map_list_of
-		("TREASURE", CArtifact::ART_TREASURE)
-		("MINOR", CArtifact::ART_MINOR)
-		("MAJOR", CArtifact::ART_MAJOR)
-		("RELIC", CArtifact::ART_RELIC)
-		("SPECIAL", CArtifact::ART_SPECIAL);
+	static const std::map<std::string, CArtifact::EartClass> artifactClassMap =
+	{	
+		{"TREASURE", CArtifact::ART_TREASURE},
+		{"MINOR", CArtifact::ART_MINOR},
+		{"MAJOR", CArtifact::ART_MAJOR},
+		{"RELIC", CArtifact::ART_RELIC},
+		{"SPECIAL", CArtifact::ART_SPECIAL}
+	};
 
 	auto it = artifactClassMap.find (className);
 	if (it != artifactClassMap.end())
@@ -331,8 +341,8 @@ void CArtHandler::loadClass(CArtifact * art, const JsonNode & node)
 
 void CArtHandler::loadType(CArtifact * art, const JsonNode & node)
 {
-#define ART_BEARER(x) ( #x, ArtBearer::x )
-	static const std::map<std::string, int> artifactBearerMap = boost::assign::map_list_of ART_BEARER_LIST;
+#define ART_BEARER(x) { #x, ArtBearer::x },
+	static const std::map<std::string, int> artifactBearerMap = { ART_BEARER_LIST };
 #undef ART_BEARER
 
 	for (const JsonNode & b : node["type"].Vector())

lib/CBuildingHandler.cpp

@@ -14,22 +14,26 @@
 
 BuildingID CBuildingHandler::campToERMU( int camp, int townType, std::set<BuildingID> builtBuildings )
 {
-	using namespace boost::assign;
-	static const std::vector<BuildingID> campToERMU = list_of(BuildingID::TOWN_HALL)(BuildingID::CITY_HALL)
-		(BuildingID::CAPITOL)(BuildingID::FORT)(BuildingID::CITADEL)(BuildingID::CASTLE)(BuildingID::TAVERN)
-		(BuildingID::BLACKSMITH)(BuildingID::MARKETPLACE)(BuildingID::RESOURCE_SILO)(BuildingID::NONE)
-		(BuildingID::MAGES_GUILD_1)(BuildingID::MAGES_GUILD_2)(BuildingID::MAGES_GUILD_3)(BuildingID::MAGES_GUILD_4)
-		(BuildingID::MAGES_GUILD_5)
-		(BuildingID::SHIPYARD)(BuildingID::GRAIL)
-		(BuildingID::SPECIAL_1)(BuildingID::SPECIAL_2)(BuildingID::SPECIAL_3)(BuildingID::SPECIAL_4)
-		; //creature generators with banks - handled separately
+	static const std::vector<BuildingID> campToERMU = 
+	{
+		BuildingID::TOWN_HALL, BuildingID::CITY_HALL,
+		BuildingID::CAPITOL, BuildingID::FORT, BuildingID::CITADEL, BuildingID::CASTLE, BuildingID::TAVERN,
+		BuildingID::BLACKSMITH, BuildingID::MARKETPLACE, BuildingID::RESOURCE_SILO, BuildingID::NONE,
+		BuildingID::MAGES_GUILD_1, BuildingID::MAGES_GUILD_2, BuildingID::MAGES_GUILD_3, BuildingID::MAGES_GUILD_4,
+		BuildingID::MAGES_GUILD_5,
+		BuildingID::SHIPYARD, BuildingID::GRAIL,
+		BuildingID::SPECIAL_1, BuildingID::SPECIAL_2, BuildingID::SPECIAL_3, BuildingID::SPECIAL_4	
+	}; //creature generators with banks - handled separately
+	
 	if (camp < campToERMU.size())
 	{
 		return campToERMU[camp];
 	}
 
-	static const std::vector<int> hordeLvlsPerTType[GameConstants::F_NUMBER] = {list_of(2), list_of(1), list_of(1)(4), list_of(0)(2),
-		list_of(0), list_of(0), list_of(0), list_of(0), list_of(0)};
+	static const std::vector<int> hordeLvlsPerTType[GameConstants::F_NUMBER] = 
+	{
+		{2}, {1}, {1,4}, {0,2},	{0}, {0}, {0}, {0}, {0}
+	};
 
 	int curPos = campToERMU.size();
 	for (int i=0; i<GameConstants::CREATURES_PER_TOWN; ++i)

lib/CCreatureHandler.cpp

@@ -11,8 +11,6 @@
 
 #include "mapObjects/CObjectClassesHandler.h"
 
-using namespace boost::assign;
-
 /*
  * CCreatureHandler.cpp, part of VCMI engine
  *
@@ -232,22 +230,23 @@ void CCreatureHandler::loadBonuses(JsonNode & creature, std::string bonuses)
 	};
 
 	static const std::map<std::string, JsonNode> abilityMap =
-	  boost::assign::map_list_of
-	    ("FLYING_ARMY",            makeBonusNode("FLYING"))
-	    ("SHOOTING_ARMY",          makeBonusNode("SHOOTER"))
-	    ("SIEGE_WEAPON",           makeBonusNode("SIEGE_WEAPON"))
-	    ("const_free_attack",      makeBonusNode("BLOCKS_RETALIATION"))
-	    ("IS_UNDEAD",              makeBonusNode("UNDEAD"))
-	    ("const_no_melee_penalty", makeBonusNode("NO_MELEE_PENALTY"))
-	    ("const_jousting",         makeBonusNode("JOUSTING"))
-	    ("KING_1",                 makeBonusNode("KING1"))
-	    ("KING_2",                 makeBonusNode("KING2"))
-		("KING_3",                 makeBonusNode("KING3"))
-		("const_no_wall_penalty",  makeBonusNode("NO_WALL_PENALTY"))
-		("CATAPULT",               makeBonusNode("CATAPULT"))
-		("MULTI_HEADED",           makeBonusNode("ATTACKS_ALL_ADJACENT"))
-		("IMMUNE_TO_MIND_SPELLS",  makeBonusNode("MIND_IMMUNITY"))
-		("HAS_EXTENDED_ATTACK",    makeBonusNode("TWO_HEX_ATTACK_BREATH"));
+	{
+	    {"FLYING_ARMY",            makeBonusNode("FLYING")},
+	    {"SHOOTING_ARMY",          makeBonusNode("SHOOTER")},
+	    {"SIEGE_WEAPON",           makeBonusNode("SIEGE_WEAPON")},
+	    {"const_free_attack",      makeBonusNode("BLOCKS_RETALIATION")},
+	    {"IS_UNDEAD",              makeBonusNode("UNDEAD")},
+	    {"const_no_melee_penalty", makeBonusNode("NO_MELEE_PENALTY")},
+	    {"const_jousting",         makeBonusNode("JOUSTING")},
+	    {"KING_1",                 makeBonusNode("KING1")},
+	    {"KING_2",                 makeBonusNode("KING2")},
+		{"KING_3",                 makeBonusNode("KING3")},
+		{"const_no_wall_penalty",  makeBonusNode("NO_WALL_PENALTY")},
+		{"CATAPULT",               makeBonusNode("CATAPULT")},
+		{"MULTI_HEADED",           makeBonusNode("ATTACKS_ALL_ADJACENT")},
+		{"IMMUNE_TO_MIND_SPELLS",  makeBonusNode("MIND_IMMUNITY")},
+		{"HAS_EXTENDED_ATTACK",    makeBonusNode("TWO_HEX_ATTACK_BREATH")}
+	};
 
 	auto hasAbility = [&](const std::string name) -> bool
 	{

lib/CSpellHandler.cpp

@@ -26,8 +26,6 @@ namespace SpellConfig
 
 }
 
-using namespace boost::assign;
-
 namespace SRSLPraserHelpers
 {
 	static int XYToHex(int x, int y)

lib/GameConstants.cpp

@@ -100,23 +100,25 @@ bool PlayerColor::isValidPlayer() const
 
 std::ostream & operator<<(std::ostream & os, const Battle::ActionType actionType)
 {
-	static const std::map<Battle::ActionType, std::string> actionTypeToString = boost::assign::map_list_of
-			(Battle::END_TACTIC_PHASE, "End tactic phase")
-			(Battle::INVALID, "Invalid")
-			(Battle::NO_ACTION, "No action")
-			(Battle::HERO_SPELL, "Hero spell")
-			(Battle::WALK, "Walk")
-			(Battle::DEFEND, "Defend")
-			(Battle::RETREAT, "Retreat")
-			(Battle::SURRENDER, "Surrender")
-			(Battle::WALK_AND_ATTACK, "Walk and attack")
-			(Battle::SHOOT, "Shoot")
-			(Battle::WAIT, "Wait")
-			(Battle::CATAPULT, "Catapult")
-			(Battle::MONSTER_SPELL, "Monster spell")
-			(Battle::BAD_MORALE, "Bad morale")
-			(Battle::STACK_HEAL, "Stack heal")
-			(Battle::DAEMON_SUMMONING, "Daemon summoning");
+	static const std::map<Battle::ActionType, std::string> actionTypeToString =
+	{
+		{Battle::END_TACTIC_PHASE, "End tactic phase"},
+		{Battle::INVALID, "Invalid"},
+		{Battle::NO_ACTION, "No action"},
+		{Battle::HERO_SPELL, "Hero spell"},
+		{Battle::WALK, "Walk"},
+		{Battle::DEFEND, "Defend"},
+		{Battle::RETREAT, "Retreat"},
+		{Battle::SURRENDER, "Surrender"},
+		{Battle::WALK_AND_ATTACK, "Walk and attack"},
+		{Battle::SHOOT, "Shoot"},
+		{Battle::WAIT, "Wait"},
+		{Battle::CATAPULT, "Catapult"},
+		{Battle::MONSTER_SPELL, "Monster spell"},
+		{Battle::BAD_MORALE, "Bad morale"},
+		{Battle::STACK_HEAL, "Stack heal"},
+		{Battle::DAEMON_SUMMONING, "Daemon summoning"}
+	};
 
 	auto it = actionTypeToString.find(actionType);
 	if (it == actionTypeToString.end()) return os << "<Unknown type>";

lib/HeroBonus.cpp

@@ -26,21 +26,22 @@
 #define FOREACH_RED_CHILD(pname) 	TNodes lchildren; getRedChildren(lchildren); for(CBonusSystemNode *pname : lchildren)
 #define FOREACH_RED_PARENT(pname) 	TNodes lparents; getRedParents(lparents); for(CBonusSystemNode *pname : lparents)
 
-#define BONUS_NAME(x) ( #x, Bonus::x )
-	const std::map<std::string, Bonus::BonusType> bonusNameMap = boost::assign::map_list_of BONUS_LIST;
+#define BONUS_NAME(x) { #x, Bonus::x },
+	const std::map<std::string, Bonus::BonusType> bonusNameMap = { BONUS_LIST };
 #undef BONUS_NAME
 
-#define BONUS_VALUE(x) ( #x, Bonus::x )
-	const std::map<std::string, Bonus::ValueType> bonusValueMap = boost::assign::map_list_of BONUS_VALUE_LIST;
+#define BONUS_VALUE(x) { #x, Bonus::x },
+	const std::map<std::string, Bonus::ValueType> bonusValueMap = { BONUS_VALUE_LIST };
 #undef BONUS_VALUE
 
-#define BONUS_SOURCE(x) ( #x, Bonus::x )
-	const std::map<std::string, Bonus::BonusSource> bonusSourceMap = boost::assign::map_list_of BONUS_SOURCE_LIST;
+#define BONUS_SOURCE(x) { #x, Bonus::x },
+	const std::map<std::string, Bonus::BonusSource> bonusSourceMap = { BONUS_SOURCE_LIST };
 #undef BONUS_SOURCE
 
-#define BONUS_ITEM(x) ( #x, Bonus::x )
+#define BONUS_ITEM(x) { #x, Bonus::x },
 
-const std::map<std::string, ui16> bonusDurationMap = boost::assign::map_list_of
+const std::map<std::string, ui16> bonusDurationMap = 
+{
 	BONUS_ITEM(PERMANENT)
 	BONUS_ITEM(ONE_BATTLE)
 	BONUS_ITEM(ONE_DAY)
@@ -50,26 +51,33 @@ const std::map<std::string, ui16> bonusDurationMap = boost::assign::map_list_of
 	BONUS_ITEM(UNITL_BEING_ATTACKED)
 	BONUS_ITEM(UNTIL_ATTACK)
 	BONUS_ITEM(STACK_GETS_TURN)
-	BONUS_ITEM(COMMANDER_KILLED);
+	BONUS_ITEM(COMMANDER_KILLED)
+};
 
-const std::map<std::string, Bonus::LimitEffect> bonusLimitEffect = boost::assign::map_list_of
+const std::map<std::string, Bonus::LimitEffect> bonusLimitEffect = 
+{
 	BONUS_ITEM(NO_LIMIT)
 	BONUS_ITEM(ONLY_DISTANCE_FIGHT)
 	BONUS_ITEM(ONLY_MELEE_FIGHT)
-	BONUS_ITEM(ONLY_ENEMY_ARMY);
-
-const std::map<std::string, TLimiterPtr> bonusLimiterMap = boost::assign::map_list_of
-	("SHOOTER_ONLY", make_shared<HasAnotherBonusLimiter>(Bonus::SHOOTER))
-	("DRAGON_NATURE", make_shared<HasAnotherBonusLimiter>(Bonus::DRAGON_NATURE))
-	("IS_UNDEAD", make_shared<HasAnotherBonusLimiter>(Bonus::UNDEAD));
-
-const std::map<std::string, TPropagatorPtr> bonusPropagatorMap = boost::assign::map_list_of
-	("BATTLE_WIDE", make_shared<CPropagatorNodeType>(CBonusSystemNode::BATTLE))
-	("VISITED_TOWN_AND_VISITOR", make_shared<CPropagatorNodeType>(CBonusSystemNode::TOWN_AND_VISITOR))
-	("PLAYER_PROPAGATOR", make_shared<CPropagatorNodeType>(CBonusSystemNode::PLAYER))
-	("HERO", make_shared<CPropagatorNodeType>(CBonusSystemNode::HERO))
-	("TEAM_PROPAGATOR", make_shared<CPropagatorNodeType>(CBonusSystemNode::TEAM)) //untested
-	("GLOBAL_EFFECT", make_shared<CPropagatorNodeType>(CBonusSystemNode::GLOBAL_EFFECTS)); //untested
+	BONUS_ITEM(ONLY_ENEMY_ARMY)
+};
+
+const std::map<std::string, TLimiterPtr> bonusLimiterMap =
+{
+	{"SHOOTER_ONLY", make_shared<HasAnotherBonusLimiter>(Bonus::SHOOTER)},
+	{"DRAGON_NATURE", make_shared<HasAnotherBonusLimiter>(Bonus::DRAGON_NATURE)},
+	{"IS_UNDEAD", make_shared<HasAnotherBonusLimiter>(Bonus::UNDEAD)}
+};
+
+const std::map<std::string, TPropagatorPtr> bonusPropagatorMap =
+{
+	{"BATTLE_WIDE", make_shared<CPropagatorNodeType>(CBonusSystemNode::BATTLE)},
+	{"VISITED_TOWN_AND_VISITOR", make_shared<CPropagatorNodeType>(CBonusSystemNode::TOWN_AND_VISITOR)},
+	{"PLAYER_PROPAGATOR", make_shared<CPropagatorNodeType>(CBonusSystemNode::PLAYER)},
+	{"HERO", make_shared<CPropagatorNodeType>(CBonusSystemNode::HERO)},
+	{"TEAM_PROPAGATOR", make_shared<CPropagatorNodeType>(CBonusSystemNode::TEAM)}, //untested
+	{"GLOBAL_EFFECT", make_shared<CPropagatorNodeType>(CBonusSystemNode::GLOBAL_EFFECTS)}
+}; //untested
 
 
 #define BONUS_LOG_LINE(x) logBonus->traceStream() << x

lib/JsonDetail.cpp

@@ -507,10 +507,14 @@ bool JsonParser::error(const std::string &message, bool warning)
 ///////////////////////////////////////////////////////////////////////////////
 
 static const std::unordered_map<std::string, JsonNode::JsonType> stringToType =
-	boost::assign::map_list_of
-		("null",   JsonNode::DATA_NULL)   ("boolean", JsonNode::DATA_BOOL)
-		("number", JsonNode::DATA_FLOAT)  ("string",  JsonNode::DATA_STRING)
-		("array",  JsonNode::DATA_VECTOR) ("object",  JsonNode::DATA_STRUCT);
+{
+	{"null",   JsonNode::DATA_NULL},   
+	{"boolean", JsonNode::DATA_BOOL},
+	{"number", JsonNode::DATA_FLOAT},  
+	{"string",  JsonNode::DATA_STRING},
+	{"array",  JsonNode::DATA_VECTOR}, 
+	{"object",  JsonNode::DATA_STRUCT}
+};
 
 namespace
 {

lib/filesystem/ResourceID.cpp

@@ -86,42 +86,43 @@ EResType::Type EResTypeHelper::getTypeFromExtension(std::string extension)
 #endif
 
 	static const std::map<std::string, EResType::Type> stringToRes =
-			boost::assign::map_list_of
-			(".TXT",   EResType::TEXT)
-			(".JSON",  EResType::TEXT)
-			(".DEF",   EResType::ANIMATION)
-			(".MSK",   EResType::MASK)
-			(".MSG",   EResType::MASK)
-			(".H3C",   EResType::CAMPAIGN)
-			(".H3M",   EResType::MAP)
-			(".FNT",   EResType::BMP_FONT)
-			(".TTF",   EResType::TTF_FONT)
-			(".BMP",   EResType::IMAGE)
-			(".JPG",   EResType::IMAGE)
-			(".PCX",   EResType::IMAGE)
-			(".PNG",   EResType::IMAGE)
-			(".TGA",   EResType::IMAGE)
-			(".WAV",   EResType::SOUND)
-			(".82M",   EResType::SOUND)
-			(".SMK",   EResType::VIDEO)
-			(".BIK",   EResType::VIDEO)
-			(".MJPG",  EResType::VIDEO)
-			(".MPG",   EResType::VIDEO)
-			(".AVI",   EResType::VIDEO)
-			(".MP3",   EResType::MUSIC)
-			(".OGG",   EResType::MUSIC)
-			(".FLAC",  EResType::MUSIC)
-			(".ZIP",   EResType::ARCHIVE_ZIP)
-			(".LOD",   EResType::ARCHIVE_LOD)
-			(".PAC",   EResType::ARCHIVE_LOD)
-			(".VID",   EResType::ARCHIVE_VID)
-			(".SND",   EResType::ARCHIVE_SND)
-			(".PAL",   EResType::PALETTE)
-			(".VCGM1", EResType::CLIENT_SAVEGAME)
-			(".VSGM1", EResType::SERVER_SAVEGAME)
-			(".ERM",   EResType::ERM)
-			(".ERT",   EResType::ERT)
-			(".ERS",   EResType::ERS);
+	{
+		{".TXT",   EResType::TEXT},
+		{".JSON",  EResType::TEXT},
+		{".DEF",   EResType::ANIMATION},
+		{".MSK",   EResType::MASK},
+		{".MSG",   EResType::MASK},
+		{".H3C",   EResType::CAMPAIGN},
+		{".H3M",   EResType::MAP},
+		{".FNT",   EResType::BMP_FONT},
+		{".TTF",   EResType::TTF_FONT},
+		{".BMP",   EResType::IMAGE},
+		{".JPG",   EResType::IMAGE},
+		{".PCX",   EResType::IMAGE},
+		{".PNG",   EResType::IMAGE},
+		{".TGA",   EResType::IMAGE},
+		{".WAV",   EResType::SOUND},
+		{".82M",   EResType::SOUND},
+		{".SMK",   EResType::VIDEO},
+		{".BIK",   EResType::VIDEO},
+		{".MJPG",  EResType::VIDEO},
+		{".MPG",   EResType::VIDEO},
+		{".AVI",   EResType::VIDEO},
+		{".MP3",   EResType::MUSIC},
+		{".OGG",   EResType::MUSIC},
+		{".FLAC",  EResType::MUSIC},
+		{".ZIP",   EResType::ARCHIVE_ZIP},
+		{".LOD",   EResType::ARCHIVE_LOD},
+		{".PAC",   EResType::ARCHIVE_LOD},
+		{".VID",   EResType::ARCHIVE_VID},
+		{".SND",   EResType::ARCHIVE_SND},
+		{".PAL",   EResType::PALETTE},
+		{".VCGM1", EResType::CLIENT_SAVEGAME},
+		{".VSGM1", EResType::SERVER_SAVEGAME},
+		{".ERM",   EResType::ERM},
+		{".ERT",   EResType::ERT},
+		{".ERS",   EResType::ERS}
+	};
 
 	auto iter = stringToRes.find(extension);
 	if (iter == stringToRes.end())
@@ -131,9 +132,10 @@ EResType::Type EResTypeHelper::getTypeFromExtension(std::string extension)
 
 std::string EResTypeHelper::getEResTypeAsString(EResType::Type type)
 {
-#define MAP_ENUM(value) (EResType::value, #value)
+#define MAP_ENUM(value) {EResType::value, #value},
 
-	static const std::map<EResType::Type, std::string> stringToRes = boost::assign::map_list_of
+	static const std::map<EResType::Type, std::string> stringToRes =
+	{
 		MAP_ENUM(TEXT)
 		MAP_ENUM(ANIMATION)
 		MAP_ENUM(MASK)
@@ -156,7 +158,8 @@ std::string EResTypeHelper::getEResTypeAsString(EResType::Type type)
 		MAP_ENUM(ERM)
 		MAP_ENUM(ERT)
 		MAP_ENUM(ERS)
-		MAP_ENUM(OTHER);
+		MAP_ENUM(OTHER)
+	};
 
 #undef MAP_ENUM
 

lib/logging/CBasicLogConfigurator.cpp

@@ -87,12 +87,14 @@ void CBasicLogConfigurator::configure()
 
 ELogLevel::ELogLevel CBasicLogConfigurator::getLogLevel(const std::string & level)
 {
-	static const std::map<std::string, ELogLevel::ELogLevel> levelMap = boost::assign::map_list_of
-			("trace", ELogLevel::TRACE)
-			("debug", ELogLevel::DEBUG)
-			("info", ELogLevel::INFO)
-			("warn", ELogLevel::WARN)
-			("error", ELogLevel::ERROR);
+	static const std::map<std::string, ELogLevel::ELogLevel> levelMap =
+	{
+		{"trace", ELogLevel::TRACE},
+		{"debug", ELogLevel::DEBUG},
+		{"info", ELogLevel::INFO},
+		{"warn", ELogLevel::WARN},
+		{"error", ELogLevel::ERROR},
+	};
 	
 	const auto & levelPair = levelMap.find(level);
 	if(levelPair != levelMap.end())
@@ -103,15 +105,17 @@ ELogLevel::ELogLevel CBasicLogConfigurator::getLogLevel(const std::string & leve
 
 EConsoleTextColor::EConsoleTextColor CBasicLogConfigurator::getConsoleColor(const std::string & colorName)
 {
-	static const std::map<std::string, EConsoleTextColor::EConsoleTextColor> colorMap = boost::assign::map_list_of
-			("default", EConsoleTextColor::DEFAULT)
-			("green", EConsoleTextColor::GREEN)
-			("red", EConsoleTextColor::RED)
-			("magenta", EConsoleTextColor::MAGENTA)
-			("yellow", EConsoleTextColor::YELLOW)
-			("white", EConsoleTextColor::WHITE)
-			("gray", EConsoleTextColor::GRAY)
-			("teal", EConsoleTextColor::TEAL);
+	static const std::map<std::string, EConsoleTextColor::EConsoleTextColor> colorMap =
+	{
+		{"default", EConsoleTextColor::DEFAULT},
+		{"green", EConsoleTextColor::GREEN},
+		{"red", EConsoleTextColor::RED},
+		{"magenta", EConsoleTextColor::MAGENTA},
+		{"yellow", EConsoleTextColor::YELLOW},
+		{"white", EConsoleTextColor::WHITE},
+		{"gray", EConsoleTextColor::GRAY},
+		{"teal", EConsoleTextColor::TEAL},
+	};
 
 	const auto & colorPair = colorMap.find(colorName);
 	if(colorPair != colorMap.end())

lib/mapObjects/CArmedInstance.cpp

@@ -16,8 +16,6 @@
 #include "../CGeneralTextHandler.h"
 #include "../CGameState.h"
 
-using namespace boost::assign;
-
 void CArmedInstance::randomizeArmy(int type)
 {
 	for (auto & elem : stacks)

lib/mapObjects/CBank.cpp

@@ -19,8 +19,6 @@
 #include "../IGameCallback.h"
 #include "../CGameState.h"
 
-using namespace boost::assign;
-
 ///helpers
 static std::string & visitedTxt(const bool visited)
 {

lib/mapObjects/CGHeroInstance.cpp

@@ -22,8 +22,6 @@
 #include "../CGameState.h"
 #include "../CCreatureHandler.h"
 
-using namespace boost::assign;
-
 ///helpers
 static void showInfoDialog(const PlayerColor playerID, const ui32 txtID, const ui16 soundID)
 {
@@ -1050,9 +1048,10 @@ int CGHeroInstance::getBoatType() const
 
 void CGHeroInstance::getOutOffsets(std::vector<int3> &offsets) const
 {
-	static int3 dirs[] = { int3(0,1,0),int3(0,-1,0),int3(-1,0,0),int3(+1,0,0), int3(1,1,0),int3(-1,1,0),int3(1,-1,0),int3(-1,-1,0) };
-	for (auto & dir : dirs)
-		offsets += dir;
+	offsets = 
+	{ 
+		int3(0,1,0), int3(0,-1,0), int3(-1,0,0), int3(+1,0,0), int3(1,1,0), int3(-1,1,0), int3(1,-1,0), int3(-1,-1,0) 
+	};
 }
 
 int CGHeroInstance::getSpellCost(const CSpell *sp) const
@@ -1162,8 +1161,10 @@ std::vector<SecondarySkill> CGHeroInstance::getLevelUpProposedSecondarySkills()
 	}
 	if (!skillsInfo.magicSchoolCounter)
 	{
-		std::vector<SecondarySkill> ss;
-		ss += SecondarySkill::FIRE_MAGIC, SecondarySkill::AIR_MAGIC, SecondarySkill::WATER_MAGIC, SecondarySkill::EARTH_MAGIC;
+		std::vector<SecondarySkill> ss =
+		{
+			SecondarySkill::FIRE_MAGIC, SecondarySkill::AIR_MAGIC, SecondarySkill::WATER_MAGIC, SecondarySkill::EARTH_MAGIC
+		};
 
 		std::shuffle(ss.begin(), ss.end(), skillsInfo.rand.getStdGenerator());
 

lib/mapObjects/CGMarket.cpp

@@ -18,8 +18,6 @@
 #include "../CCreatureHandler.h"
 #include "../CGameState.h"
 
-using namespace boost::assign;
-
 ///helpers
 static void openWindow(const OpenWindow::EWindow type, const int id1, const int id2 = -1)
 {

lib/mapObjects/CGPandoraBox.cpp

@@ -18,8 +18,6 @@
 #include "../StartInfo.h"
 #include "../IGameCallback.h"
 
-using namespace boost::assign;
-
 ///helpers
 static void showInfoDialog(const PlayerColor playerID, const ui32 txtID, const ui16 soundID)
 {

lib/mapObjects/CGTownInstance.cpp

@@ -18,8 +18,6 @@
 #include "../IGameCallback.h"
 #include "../CGameState.h"
 
-using namespace boost::assign;
-
 std::vector<const CArtifact *> CGTownInstance::merchantArtifacts;
 std::vector<int> CGTownInstance::universitySkills;
 
@@ -676,7 +674,7 @@ bool CGTownInstance::passableFor(PlayerColor color) const
 
 void CGTownInstance::getOutOffsets( std::vector<int3> &offsets ) const
 {
-	offsets += int3(-1,2,0), int3(-3,2,0);
+	offsets = {int3(-1,2,0), int3(-3,2,0)};
 }
 
 void CGTownInstance::removeCapitols (PlayerColor owner) const

lib/mapObjects/CGTownInstance.h

@@ -205,7 +205,7 @@ public:
 	//int3 getSightCenter() const override; //"center" tile from which the sight distance is calculated
 	int getSightRadious() const override; //returns sight distance
 	int getBoatType() const; //0 - evil (if a ship can be evil...?), 1 - good, 2 - neutral
-	void getOutOffsets(std::vector<int3> &offsets) const; //offsets to obj pos when we boat can be placed
+	void getOutOffsets(std::vector<int3> &offsets) const; //offsets to obj pos when we boat can be placed. Parameter will be cleared
 	int getMarketEfficiency() const override; //=market count
 	bool allowsTrade(EMarketMode::EMarketMode mode) const;
 	std::vector<int> availableItemsIds(EMarketMode::EMarketMode mode) const;

lib/mapObjects/CObjectHandler.cpp

@@ -21,8 +21,6 @@
 
 #include "CObjectClassesHandler.h"
 
-using namespace boost::assign;
-
 IGameCallback * IObjectInterface::cb = nullptr;
 
 ///helpers

lib/mapObjects/CQuest.cpp

@@ -20,8 +20,6 @@
 #include "../IGameCallback.h"
 #include "../CGameState.h"
 
-using namespace boost::assign;
-
 std::map <PlayerColor, std::set <ui8> > CGKeys::playerKeyMap;
 
 ///helpers

lib/mapObjects/MiscObjects.cpp

@@ -21,8 +21,6 @@
 #include "../IGameCallback.h"
 #include "../CGameState.h"
 
-using namespace boost::assign;
-
 std::map<Obj, std::map<int, std::vector<ObjectInstanceID> > > CGTeleport::objs;
 std::vector<std::pair<ObjectInstanceID, ObjectInstanceID> > CGTeleport::gates;
 std::map <si32, std::vector<ObjectInstanceID> > CGMagi::eyelist;
@@ -1419,9 +1417,11 @@ void CGShipyard::getOutOffsets( std::vector<int3> &offsets ) const
 	// H J L K I
 	// A x S x B
 	// C E G F D
-	offsets += int3(-3,0,0), int3(1,0,0), //AB
+	offsets = {
+		int3(-3,0,0), int3(1,0,0), //AB
 		int3(-3,1,0), int3(1,1,0), int3(-2,1,0), int3(0,1,0), int3(-1,1,0), //CDEFG
-		int3(-3,-1,0), int3(1,-1,0), int3(-2,-1,0), int3(0,-1,0), int3(-1,-1,0); //HIJKL
+		int3(-3,-1,0), int3(1,-1,0), int3(-2,-1,0), int3(0,-1,0), int3(-1,-1,0) //HIJKL
+	}; 
 }
 
 void CGShipyard::onHeroVisit( const CGHeroInstance * h ) const

lib/mapping/CMapEditManager.cpp

@@ -402,9 +402,14 @@ CTerrainViewPatternConfig::~CTerrainViewPatternConfig()
 
 ETerrainGroup::ETerrainGroup CTerrainViewPatternConfig::getTerrainGroup(const std::string & terGroup) const
 {
-	static const std::map<std::string, ETerrainGroup::ETerrainGroup> terGroups
-			= boost::assign::map_list_of("normal", ETerrainGroup::NORMAL)("dirt", ETerrainGroup::DIRT)
-			("sand", ETerrainGroup::SAND)("water", ETerrainGroup::WATER)("rock", ETerrainGroup::ROCK);
+	static const std::map<std::string, ETerrainGroup::ETerrainGroup> terGroups =
+	{
+		{"normal", ETerrainGroup::NORMAL},
+		{"dirt", ETerrainGroup::DIRT},
+		{"sand", ETerrainGroup::SAND},
+		{"water", ETerrainGroup::WATER},
+		{"rock", ETerrainGroup::ROCK},
+	};
 	auto it = terGroups.find(terGroup);
 	if(it == terGroups.end()) throw std::runtime_error(boost::str(boost::format("Terrain group '%s' does not exist.") % terGroup));
 	return it->second;

lib/rmg/CRmgTemplateStorage.cpp

@@ -199,8 +199,13 @@ CRmgTemplate::CSize CJsonRmgTemplateLoader::parseMapTemplateSize(const std::stri
 
 	std::vector<std::string> parts;
 	boost::split(parts, text, boost::is_any_of("+"));
-	static const std::map<std::string, int> mapSizeMapping = boost::assign::map_list_of("s", CMapHeader::MAP_SIZE_SMALL)
-			("m", CMapHeader::MAP_SIZE_MIDDLE)("l", CMapHeader::MAP_SIZE_LARGE)("xl", CMapHeader::MAP_SIZE_XLARGE);
+	static const std::map<std::string, int> mapSizeMapping = 
+	{ 
+		{"s", CMapHeader::MAP_SIZE_SMALL},
+		{"m", CMapHeader::MAP_SIZE_MIDDLE},
+		{"l", CMapHeader::MAP_SIZE_LARGE},
+		{"xl", CMapHeader::MAP_SIZE_XLARGE},
+	};
 	auto it = mapSizeMapping.find(parts[0]);
 	if(it == mapSizeMapping.end())
 	{
@@ -224,9 +229,13 @@ CRmgTemplate::CSize CJsonRmgTemplateLoader::parseMapTemplateSize(const std::stri
 
 ETemplateZoneType::ETemplateZoneType CJsonRmgTemplateLoader::parseZoneType(const std::string & type) const
 {
-	static const std::map<std::string, ETemplateZoneType::ETemplateZoneType> zoneTypeMapping = boost::assign::map_list_of
-			("playerStart", ETemplateZoneType::PLAYER_START)("cpuStart", ETemplateZoneType::CPU_START)
-			("treasure", ETemplateZoneType::TREASURE)("junction", ETemplateZoneType::JUNCTION);
+	static const std::map<std::string, ETemplateZoneType::ETemplateZoneType> zoneTypeMapping = 
+	{
+		{"playerStart", ETemplateZoneType::PLAYER_START},
+		{"cpuStart", ETemplateZoneType::CPU_START},
+		{"treasure", ETemplateZoneType::TREASURE},
+		{"junction", ETemplateZoneType::JUNCTION},		
+	};
 	auto it = zoneTypeMapping.find(type);
 	if(it == zoneTypeMapping.end()) throw std::runtime_error("Zone type unknown.");
 	return it->second;
@@ -333,4 +342,4 @@ CRmgTemplateStorage::CRmgTemplateStorage()
 CRmgTemplateStorage::~CRmgTemplateStorage()
 {
 	for (auto & pair : templates) delete pair.second;
-}
+}

scripting/erm/ERMInterpreter.cpp

@@ -2,8 +2,8 @@
 #include "ERMInterpreter.h"
 
 #include <cctype>
-#include "../../lib/mapObjects/CObjectHandler.h"
-#include "../../lib/mapObjects/MapObjects.h"
+#include "../../lib/mapObjects/CObjectHandler.h"
+#include "../../lib/mapObjects/MapObjects.h"
 #include "../../lib/CHeroHandler.h"
 #include "../../lib/CCreatureHandler.h"
 #include "../../lib/VCMIDirs.h"
@@ -2394,15 +2394,9 @@ void ERMInterpreter::heroVisit(const CGHeroInstance *visitor, const CGObjectInst
 		return;
 	setCurrentlyVisitedObj(visitedObj->pos);
 	TIDPattern tip;
-#ifdef CPP11_USE_INITIALIZERS_LIST
 	tip[1] = {visitedObj->ID};
 	tip[2] = {visitedObj->ID, visitedObj->subID};
 	tip[3] = {visitedObj->pos.x, visitedObj->pos.y, visitedObj->pos.z};
-#else
-	tip[1] = list_of(visitedObj->ID);
-	tip[2] = list_of((int)visitedObj->ID)(visitedObj->subID);
-	tip[3] = list_of(visitedObj->pos.x)(visitedObj->pos.y)(visitedObj->pos.z);
-#endif
 	executeTriggerType(VERMInterpreter::TriggerType("OB"), start, tip);
 }
 

server/CGameHandler.cpp

@@ -704,7 +704,7 @@ void CGameHandler::battleAfterLevelUp( const BattleResult &result )
 	visitObjectAfterVictory = false;
 
 	//handle victory/loss of engaged players
-	std::set<PlayerColor> playerColors = boost::assign::list_of(finishingBattle->loser)(finishingBattle->victor);
+	std::set<PlayerColor> playerColors = {finishingBattle->loser, finishingBattle->victor};
 	checkVictoryLossConditions(playerColors);
 
 	if(result.result == BattleResult::SURRENDER || result.result == BattleResult::ESCAPE) //loser has escaped or surrendered
@@ -1819,7 +1819,7 @@ void CGameHandler::setOwner(const CGObjectInstance * obj, PlayerColor owner)
 	SetObjectProperty sop(obj->id, 1, owner.getNum());
 	sendAndApply(&sop);
 
-	std::set<PlayerColor> playerColors = boost::assign::list_of(owner)(oldOwner);
+	std::set<PlayerColor> playerColors = {owner, oldOwner};
 	checkVictoryLossConditions(playerColors);
 
 	if(owner < PlayerColor::PLAYER_LIMIT && dynamic_cast<const CGTownInstance *>(obj)) //town captured