diff -Nru vcmi-0.94+svn3312/AI/VCAI/VCAI.cpp vcmi-0.94+svn3315/AI/VCAI/VCAI.cpp
--- vcmi-0.94+svn3312/AI/VCAI/VCAI.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/AI/VCAI/VCAI.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -959,13 +959,13 @@
 	TResources currentRes = cb->getResourceAmount();
 	TResources income = estimateIncome();
 	//TODO: calculate if we have enough resources to build it in maxDays
-
-	for(const auto & buildID : toBuild)
-	{
-		const CBuilding *b = t->town->buildings[buildID];
-
-		EBuildingState::EBuildingState canBuild = cb->canBuildStructure(t, buildID);
-		if(canBuild == EBuildingState::ALLOWED)
+
+	for(const auto & buildID : toBuild)
+	{
+		const CBuilding *b = t->town->buildings.at(buildID);
+
+		EBuildingState::EBuildingState canBuild = cb->canBuildStructure(t, buildID);
+		if(canBuild == EBuildingState::ALLOWED)
 		{
 			if(!containsSavedRes(b->resources))
 			{
@@ -974,13 +974,13 @@
 				return true;
 			}
 			continue;
-		}
-		else if(canBuild == EBuildingState::NO_RESOURCES)
-		{
-			TResources cost = t->town->buildings[buildID]->resources;
-			for (int i = 0; i < GameConstants::RESOURCE_QUANTITY; i++)
-			{
-				int diff = currentRes[i] - cost[i] + income[i];
+		}
+		else if(canBuild == EBuildingState::NO_RESOURCES)
+		{
+			TResources cost = t->town->buildings.at(buildID)->resources;
+			for (int i = 0; i < GameConstants::RESOURCE_QUANTITY; i++)
+			{
+				int diff = currentRes[i] - cost[i] + income[i];
 				if(diff < 0)
 					saving[i] = 1;
 			}
diff -Nru vcmi-0.94+svn3312/Global.h vcmi-0.94+svn3315/Global.h
--- vcmi-0.94+svn3312/Global.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/Global.h	2013-11-12 17:30:43.000000000 +0000
@@ -222,59 +222,12 @@
 // should be used for variables that becomes unused in release builds (e.g. only used for assert checks)
 #define UNUSED(VAR) ((void)VAR)
 
-/* ---------------------------------------------------------------------------- */
-/* VCMI standard library */
-/* ---------------------------------------------------------------------------- */
-//a normal std::map with a const operator[] for sanity
-template<typename KeyT, typename ValT>
-class bmap : public std::map<KeyT, ValT>
-{
-public:
-	const ValT & operator[](KeyT key) const
-	{
-		return this->find(key)->second;
-	}
-	ValT & operator[](KeyT key)
-	{
-		return static_cast<std::map<KeyT, ValT> &>(*this)[key];
-	}
-	template <typename Handler> void serialize(Handler &h, const int version)
-	{
-		h & static_cast<std::map<KeyT, ValT> &>(*this);
-	}
-
-	bmap()
-	{}
-	explicit bmap(const typename std::map<KeyT, ValT>::key_compare& _Pred)
-		: std::map<KeyT, ValT>(_Pred)
-	{}
-
-	bmap(const typename std::map<KeyT, ValT>::key_compare& _Pred, const typename std::map<KeyT, ValT>::allocator_type& _Al)
-		: std::map<KeyT, ValT>(_Pred, _Al)
-	{}
-
-	template<class _Iter>
-	bmap(_Iter _First, _Iter _Last)
-		: std::map<KeyT, ValT>(_First, _Last)
-	{}
-
-	template<class _Iter>
-	bmap(_Iter _First, _Iter _Last,
-		const typename std::map<KeyT, ValT>::key_compare& _Pred)
-		: std::map<KeyT, ValT>(_First, _Last, _Pred)
-	{}
-
-	template<class _Iter>
-	bmap(_Iter _First, _Iter _Last,
-		const typename std::map<KeyT, ValT>::key_compare& _Pred, const typename std::map<KeyT, ValT>::allocator_type& _Al)
-		: std::map<KeyT, ValT>(_First, _Last, _Pred, _Al)
-	{}
-
-};
-
-template<typename T>
-std::ostream &operator<<(std::ostream &out, const boost::optional<T> &opt)
-{
+/* ---------------------------------------------------------------------------- */
+/* VCMI standard library */
+/* ---------------------------------------------------------------------------- */
+template<typename T>
+std::ostream &operator<<(std::ostream &out, const boost::optional<T> &opt)
+{
 	if(opt)
 		return out << *opt;
 	else
@@ -311,19 +264,12 @@
 	template <typename V, typename Item, typename Item2>
 	bool contains(const std::map<Item,V> & c, const Item2 &i)
 	{
-		return c.find(i)!=c.end();
-	}
-
-	//returns true if bmap c contains item i
-	template <typename V, typename Item, typename Item2>
-	bool contains(const bmap<Item,V> & c, const Item2 &i)
-	{
-		return c.find(i)!=c.end();
-	}
-
-	//returns true if unordered set c contains item i
-	template <typename Item>
-	bool contains(const std::unordered_set<Item> & c, const Item &i)
+		return c.find(i)!=c.end();
+	}
+
+	//returns true if unordered set c contains item i
+	template <typename Item>
+	bool contains(const std::unordered_set<Item> & c, const Item &i)
 	{
 		return c.find(i)!=c.end();
 	}
@@ -517,13 +463,13 @@
 			auto tmpItr = itr++;
 			if(pred(*tmpItr))
 				setContainer.erase(tmpItr);
-		}
-	}
-
-	//works for map and bmap, maybe something else
-	template<typename Key, typename Val, typename Predicate>
-	void erase_if(std::map<Key, Val> &container, Predicate pred)
-	{
+		}
+	}
+
+	//works for map and std::map, maybe something else
+	template<typename Key, typename Val, typename Predicate>
+	void erase_if(std::map<Key, Val> &container, Predicate pred)
+	{
 		auto itr = container.begin();
 		auto endItr = container.end(); 
 		while(itr != endItr)
diff -Nru vcmi-0.94+svn3312/client/CCastleInterface.cpp vcmi-0.94+svn3315/client/CCastleInterface.cpp
--- vcmi-0.94+svn3312/client/CCastleInterface.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/client/CCastleInterface.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -40,13 +40,13 @@
 const CBuilding * CBuildingRect::getBuilding()
 {
 	if (!str->building)
-		return nullptr;
-
-	if (str->hiddenUpgrade) // hidden upgrades, e.g. hordes - return base (dwelling for hordes)
-		return town->town->buildings[str->building->getBase()];
-
-	return str->building;
-}
+		return nullptr;
+
+	if (str->hiddenUpgrade) // hidden upgrades, e.g. hordes - return base (dwelling for hordes)
+		return town->town->buildings.at(str->building->getBase());
+
+	return str->building;
+}
 
 CBuildingRect::CBuildingRect(CCastleBuildings * Par, const CGTownInstance *Town, const CStructure *Str)
 	:CShowableAnim(0, 0, Str->defName, CShowableAnim::BASE | CShowableAnim::USE_RLE),
@@ -114,13 +114,13 @@
 {
 	if((!area) || (!((bool)down)) || (this!=parent->selectedBuilding) || getBuilding() == nullptr)
 		return;
-	if( !CSDL_Ext::isTransparent(area, GH.current->motion.x-pos.x, GH.current->motion.y-pos.y) ) //inside building image
-	{
-		BuildingID bid = getBuilding()->bid;
-		const CBuilding *bld = town->town->buildings[bid];
-		if (bid < BuildingID::DWELL_FIRST)
-		{
-			CRClickPopup::createAndPush(CInfoWindow::genText(bld->Name(), bld->Description()),
+	if( !CSDL_Ext::isTransparent(area, GH.current->motion.x-pos.x, GH.current->motion.y-pos.y) ) //inside building image
+	{
+		BuildingID bid = getBuilding()->bid;
+		const CBuilding *bld = town->town->buildings.at(bid);
+		if (bid < BuildingID::DWELL_FIRST)
+		{
+			CRClickPopup::createAndPush(CInfoWindow::genText(bld->Name(), bld->Description()),
 			                            new CComponent(CComponent::building, bld->town->faction->index, bld->bid));
 		}
 		else
@@ -209,20 +209,20 @@
 	if (!getBuilding())
 		return "";
 
-	int bid = getBuilding()->bid;
-
-	if (bid<30)//non-dwellings - only buiding name
-		return town->town->buildings[getBuilding()->bid]->Name();
-	else//dwellings - recruit %creature%
-	{
-		auto & availableCreatures = town->creatures[(bid-30)%GameConstants::CREATURES_PER_TOWN].second;
-		if(availableCreatures.size())
-		{
-			int creaID = availableCreatures.back();//taking last of available creatures
-			return CGI->generaltexth->allTexts[16] + " " + CGI->creh->creatures[creaID]->namePl;
-		}
-		else
-		{
+	int bid = getBuilding()->bid;
+
+	if (bid<30)//non-dwellings - only buiding name
+		return town->town->buildings.at(getBuilding()->bid)->Name();
+	else//dwellings - recruit %creature%
+	{
+		auto & availableCreatures = town->creatures[(bid-30)%GameConstants::CREATURES_PER_TOWN].second;
+		if(availableCreatures.size())
+		{
+			int creaID = availableCreatures.back();//taking last of available creatures
+			return CGI->generaltexth->allTexts[16] + " " + CGI->creh->creatures.at(creaID)->namePl;
+		}
+		else
+		{
             logGlobal->warnStream() << "Problem: dwelling with id " << bid << " offers no creatures!";
 			return "#ERROR#";
 		}
@@ -255,18 +255,18 @@
 
 CDwellingInfoBox::CDwellingInfoBox(int centerX, int centerY, const CGTownInstance *Town, int level):
     CWindowObject(RCLICK_POPUP | PLAYER_COLORED, "CRTOINFO", Point(centerX, centerY))
-{
-	OBJ_CONSTRUCTION_CAPTURING_ALL;
-
-	const CCreature * creature = CGI->creh->creatures[Town->creatures[level].second.back()];
-
-	title = new CLabel(80, 30, FONT_SMALL, CENTER, Colors::WHITE, creature->namePl);
-	animation =  new CCreaturePic(30, 44, creature, true, true);
-	
-	std::string text = boost::lexical_cast<std::string>(Town->creatures[level].first);
-	available = new CLabel(80,190, FONT_SMALL, CENTER, Colors::WHITE, CGI->generaltexth->allTexts[217] + text);
-	costPerTroop = new CLabel(80, 227, FONT_SMALL, CENTER, Colors::WHITE, CGI->generaltexth->allTexts[346]);
-	
+{
+	OBJ_CONSTRUCTION_CAPTURING_ALL;
+
+	const CCreature * creature = CGI->creh->creatures.at(Town->creatures.at(level).second.back());
+
+	title = new CLabel(80, 30, FONT_SMALL, CENTER, Colors::WHITE, creature->namePl);
+	animation =  new CCreaturePic(30, 44, creature, true, true);
+	
+	std::string text = boost::lexical_cast<std::string>(Town->creatures.at(level).first);
+	available = new CLabel(80,190, FONT_SMALL, CENTER, Colors::WHITE, CGI->generaltexth->allTexts[217] + text);
+	costPerTroop = new CLabel(80, 227, FONT_SMALL, CENTER, Colors::WHITE, CGI->generaltexth->allTexts[346]);
+	
 	for(int i = 0; i<GameConstants::RESOURCE_QUANTITY; i++)
 	{
 		if(creature->cost[i])
@@ -503,13 +503,13 @@
 			groups[structure->building->getBase()].push_back(structure);
 		}
 	}
-
-	for(auto & entry : groups)
-	{
-		const CBuilding * build = town->town->buildings[entry.first];
-
-		const CStructure * toAdd = *boost::max_element(entry.second, [=](const CStructure * a, const CStructure * b)
-		{
+
+	for(auto & entry : groups)
+	{
+		const CBuilding * build = town->town->buildings.at(entry.first);
+
+		const CStructure * toAdd = *boost::max_element(entry.second, [=](const CStructure * a, const CStructure * b)
+		{
 			return build->getDistance(a->building->bid)
 			     < build->getDistance(b->building->bid);
 		});
@@ -526,17 +526,17 @@
 {
 }
 
-void CCastleBuildings::addBuilding(BuildingID building)
-{
-	//FIXME: implement faster method without complete recreation of town
-	BuildingID base = town->town->buildings[building]->getBase();
-
-	recreate();
-
-	auto & structures = groups[base];
-
-	for(CBuildingRect * rect : buildings)
-	{
+void CCastleBuildings::addBuilding(BuildingID building)
+{
+	//FIXME: implement faster method without complete recreation of town
+	BuildingID base = town->town->buildings.at(building)->getBase();
+
+	recreate();
+
+	auto & structures = groups.at(base);
+
+	for(CBuildingRect * rect : buildings)
+	{
 		if (vstd::contains(structures, rect->str))
 		{
 			//reset animation
@@ -1111,13 +1111,13 @@
 	{
 		buildID = 6 + town->fortLevel();
 		if (buildID == 6)
-			return;
-		picture = new CAnimImage("ITMCL.DEF", town->fortLevel()-1);
-	}
-	building = town->town->buildings[BuildingID(buildID)];
-	pos = picture->pos;
-}
-
+			return;
+		picture = new CAnimImage("ITMCL.DEF", town->fortLevel()-1);
+	}
+	building = town->town->buildings.at(BuildingID(buildID));
+	pos = picture->pos;
+}
+
 void CTownInfo::hover(bool on)
 {
 	if(on)
@@ -1295,13 +1295,13 @@
 	resdatabar = new CMinorResDataBar;
 	resdatabar->pos.x += pos.x;
 	resdatabar->pos.y += pos.y;
-	Rect barRect(5, 556, 740, 18);
-	statusBar = new CGStatusBar(new CPicture(*background, barRect, 5, 556, false));
-
-	title = new CLabel(399, 12, FONT_MEDIUM, CENTER, Colors::WHITE, town->town->buildings[BuildingID(town->hallLevel()+BuildingID::VILLAGE_HALL)]->Name());
-	exit = new CAdventureMapButton(CGI->generaltexth->hcommands[8], "", 
-	           boost::bind(&CHallInterface::close,this), 748, 556, "TPMAGE1.DEF", SDLK_RETURN);
-	exit->assignedKeys.insert(SDLK_ESCAPE);
+	Rect barRect(5, 556, 740, 18);
+	statusBar = new CGStatusBar(new CPicture(*background, barRect, 5, 556, false));
+
+	title = new CLabel(399, 12, FONT_MEDIUM, CENTER, Colors::WHITE, town->town->buildings.at(BuildingID(town->hallLevel()+BuildingID::VILLAGE_HALL))->Name());
+	exit = new CAdventureMapButton(CGI->generaltexth->hcommands[8], "", 
+	           boost::bind(&CHallInterface::close,this), 748, 556, "TPMAGE1.DEF", SDLK_RETURN);
+	exit->assignedKeys.insert(SDLK_ESCAPE);
 
 	auto & boxList = town->town->clientInfo.hallSlots;
 	boxes.resize(boxList.size());
@@ -1310,13 +1310,13 @@
 		for(size_t col=0; col<boxList[row].size(); col++) //for each box
 		{
 			const CBuilding *building = nullptr;
-			for(auto & elem : boxList[row][col])//we are looking for the first not build structure
-			{
-				auto buildingID = elem;
-				building = town->town->buildings[buildingID];
-
-				if(!vstd::contains(town->builtBuildings,buildingID))
-					break;
+			for(auto & elem : boxList[row][col])//we are looking for the first not build structure
+			{
+				auto buildingID = elem;
+				building = town->town->buildings.at(buildingID);
+
+				if(!vstd::contains(town->builtBuildings,buildingID))
+					break;
 			}
 			int posX = pos.w/2 - boxList[row].size()*154/2 - (boxList[row].size()-1)*20 + 194*col,
 			    posY = 35 + 104*row;
@@ -1351,13 +1351,13 @@
 			std::set<BuildingID> reqs= LOCPLINT->cb->getBuildingRequiments(town, building->bid);
 
 			for(const auto & i : reqs)
-			{
-				if (vstd::contains(town->builtBuildings, i))
-					continue;//skipping constructed buildings
-				ret+= town->town->buildings[i]->Name() + ", ";
-			}
-			ret.erase(ret.size()-2);
-		}
+			{
+				if (vstd::contains(town->builtBuildings, i))
+					continue;//skipping constructed buildings
+				ret+= town->town->buildings.at(i)->Name() + ", ";
+			}
+			ret.erase(ret.size()-2);
+		}
 	}
 	return ret;
 }
@@ -1423,13 +1423,13 @@
 {
 	OBJ_CONSTRUCTION_CAPTURING_ALL;
 	ui32 fortSize = town->creatures.size();
-	if (fortSize > GameConstants::CREATURES_PER_TOWN && town->creatures.back().second.empty())
-		fortSize--;
-	
-	const CBuilding *fortBuilding = town->town->buildings[BuildingID(town->fortLevel()+6)];
-	title = new CLabel(400, 12, FONT_BIG, CENTER, Colors::WHITE, fortBuilding->Name());
-	
-	std::string text = boost::str(boost::format(CGI->generaltexth->fcommands[6]) % fortBuilding->Name());
+	if (fortSize > GameConstants::CREATURES_PER_TOWN && town->creatures.back().second.empty())
+		fortSize--;
+	
+	const CBuilding *fortBuilding = town->town->buildings.at(BuildingID(town->fortLevel()+6));
+	title = new CLabel(400, 12, FONT_BIG, CENTER, Colors::WHITE, fortBuilding->Name());
+	
+	std::string text = boost::str(boost::format(CGI->generaltexth->fcommands[6]) % fortBuilding->Name());
 	exit = new CAdventureMapButton(text, "", boost::bind(&CFortScreen::close,this) ,748, 556, "TPMAGE1", SDLK_RETURN);
 	exit->assignedKeys.insert(SDLK_ESCAPE);
 
@@ -1555,13 +1555,13 @@
 	sizes.y+=21;
 	values.push_back(new LabeledValue(sizes, CGI->generaltexth->allTexts[193], CGI->generaltexth->fcommands[4], creature->valOfBonuses(Bonus::STACKS_SPEED)));
 	sizes.y+=20;
-	values.push_back(new LabeledValue(sizes, CGI->generaltexth->allTexts[194], CGI->generaltexth->fcommands[5], town->creatureGrowth(level)));
-
-	creatureName = new CLabel(78,  11, FONT_SMALL, CENTER, Colors::WHITE, creature->namePl);
-	dwellingName = new CLabel(78, 101, FONT_SMALL, CENTER, Colors::WHITE, town->town->buildings[buildingID]->Name());
-
-	if (vstd::contains(town->builtBuildings, buildingID))
-	{
+	values.push_back(new LabeledValue(sizes, CGI->generaltexth->allTexts[194], CGI->generaltexth->fcommands[5], town->creatureGrowth(level)));
+
+	creatureName = new CLabel(78,  11, FONT_SMALL, CENTER, Colors::WHITE, creature->namePl);
+	dwellingName = new CLabel(78, 101, FONT_SMALL, CENTER, Colors::WHITE, town->town->buildings.at(buildingID)->Name());
+
+	if (vstd::contains(town->builtBuildings, buildingID))
+	{
 		ui32 available = town->creatures[level].first;
 		std::string availableText = CGI->generaltexth->allTexts[217]+ boost::lexical_cast<std::string>(available);
 		availableCount = new CLabel(78, 119, FONT_SMALL, CENTER, Colors::WHITE, availableText);
diff -Nru vcmi-0.94+svn3312/client/NetPacksClient.cpp vcmi-0.94+svn3315/client/NetPacksClient.cpp
--- vcmi-0.94+svn3312/client/NetPacksClient.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/client/NetPacksClient.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -409,30 +409,30 @@
 {
 	CGTownInstance *town = GS(cl)->getTown(tid);
 	for(const auto & id : bid)
-	{
-		if(id == BuildingID::CAPITOL) //fort or capitol
-		{
-			town->defInfo = const_cast<CGDefInfo*>(CGI->dobjinfo->capitols[town->subID].get());
-		}
-		if(id == BuildingID::FORT)
-		{
-			town->defInfo = const_cast<CGDefInfo*>(CGI->dobjinfo->gobjs[Obj::TOWN][town->subID].get());
-		}
-		if(vstd::contains(cl->playerint,town->tempOwner))
-			cl->playerint[town->tempOwner]->buildChanged(town,id,1);
+	{
+		if(id == BuildingID::CAPITOL) //fort or capitol
+		{
+			town->defInfo = const_cast<CGDefInfo*>(CGI->dobjinfo->capitols.at(town->subID).get());
+		}
+		if(id == BuildingID::FORT)
+		{
+			town->defInfo = const_cast<CGDefInfo*>(CGI->dobjinfo->gobjs.at(Obj::TOWN).at(town->subID).get());
+		}
+		if(vstd::contains(cl->playerint,town->tempOwner))
+			cl->playerint[town->tempOwner]->buildChanged(town,id,1);
 	}
 }
 void RazeStructures::applyCl (CClient *cl)
 {
 	CGTownInstance *town = GS(cl)->getTown(tid);
 	for(const auto & id : bid)
-	{
-		if (id == BuildingID::CAPITOL) //fort or capitol
-		{
-			town->defInfo = const_cast<CGDefInfo*>(CGI->dobjinfo->gobjs[Obj::TOWN][town->subID].get());
-		}
-		if(vstd::contains (cl->playerint,town->tempOwner))
-			cl->playerint[town->tempOwner]->buildChanged (town,id,2);
+	{
+		if (id == BuildingID::CAPITOL) //fort or capitol
+		{
+			town->defInfo = const_cast<CGDefInfo*>(CGI->dobjinfo->gobjs.at(Obj::TOWN).at(town->subID).get());
+		}
+		if(vstd::contains (cl->playerint,town->tempOwner))
+			cl->playerint[town->tempOwner]->buildChanged (town,id,2);
 	}
 }
 
@@ -532,13 +532,13 @@
 		comps.push_back(&elem);
 	}
 	std::string str;
-	text.toString(str);
-
-	if(vstd::contains(cl->playerint,player))
-		cl->playerint[player]->showInfoDialog(str,comps,(soundBase::soundID)soundID);
-	else
-        logNetwork->warnStream() << "We received InfoWindow for not our player...";
-}
+	text.toString(str);
+
+	if(vstd::contains(cl->playerint,player))
+		cl->playerint.at(player)->showInfoDialog(str,comps,(soundBase::soundID)soundID);
+	else
+        logNetwork->warnStream() << "We received InfoWindow for not our player...";
+}
 
 void SetObjectProperty::applyCl( CClient *cl )
 {
@@ -575,26 +575,26 @@
 void BlockingDialog::applyCl( CClient *cl )
 {
 	std::string str;
-	text.toString(str);
-
-	if(vstd::contains(cl->playerint,player))
-		cl->playerint[player]->showBlockingDialog(str,components,queryID,(soundBase::soundID)soundID,selection(),cancel());
-	else
-        logNetwork->warnStream() << "We received YesNoDialog for not our player...";
-}
+	text.toString(str);
+
+	if(vstd::contains(cl->playerint,player))
+		cl->playerint.at(player)->showBlockingDialog(str,components,queryID,(soundBase::soundID)soundID,selection(),cancel());
+	else
+        logNetwork->warnStream() << "We received YesNoDialog for not our player...";
+}
 
 void GarrisonDialog::applyCl(CClient *cl)
 {
 	const CGHeroInstance *h = cl->getHero(hid);
 	const CArmedInstance *obj = static_cast<const CArmedInstance*>(cl->getObj(objid));
 
-	if(!vstd::contains(cl->playerint,h->getOwner()))
-		return;
-
-	cl->playerint[h->getOwner()]->showGarrisonDialog(obj,h,removableUnits,queryID);
-}
-
-void ExchangeDialog::applyCl(CClient *cl)
+	if(!vstd::contains(cl->playerint,h->getOwner()))
+		return;
+
+	cl->playerint.at(h->getOwner())->showGarrisonDialog(obj,h,removableUnits,queryID);
+}
+
+void ExchangeDialog::applyCl(CClient *cl)
 {
 	assert(heroes[0] && heroes[1]);
 	INTERFACE_CALL_IF_PRESENT(heroes[0]->tempOwner, heroExchangeStarted, heroes[0]->id, heroes[1]->id, queryID);
@@ -945,13 +945,13 @@
 		INTERFACE_CALL_IF_PRESENT(cl->getTile(bm->visitablePos())->visitableObjects.back()->tempOwner, availableArtifactsChanged, bm);
 	}
 }
-
-void TradeComponents::applyCl(CClient *cl)
-{///Shop handler
-	switch (CGI->mh->map->objects[objectid]->ID)
-	{
-	case Obj::BLACK_MARKET:
-		break;
+
+void TradeComponents::applyCl(CClient *cl)
+{///Shop handler
+	switch (CGI->mh->map->objects.at(objectid)->ID)
+	{
+	case Obj::BLACK_MARKET:
+		break;
 	case Obj::TAVERN:
 		break;
 	case Obj::DEN_OF_THIEVES:
diff -Nru vcmi-0.94+svn3312/debian/bzr-builder.manifest vcmi-0.94+svn3315/debian/bzr-builder.manifest
--- vcmi-0.94+svn3312/debian/bzr-builder.manifest	2013-11-11 17:12:22.000000000 +0000
+++ vcmi-0.94+svn3315/debian/bzr-builder.manifest	2013-11-12 17:30:45.000000000 +0000
@@ -1,2 +1,2 @@
-# bzr-builder format 0.3 deb-version {debupstream}+svn3312-0
-lp:vcmi revid:svn-v4:4dfc6b2a-8b31-0410-aa91-d6c70e3ac834:trunk:3613
+# bzr-builder format 0.3 deb-version {debupstream}+svn3315-0
+lp:vcmi revid:svn-v4:4dfc6b2a-8b31-0410-aa91-d6c70e3ac834:trunk:3616
diff -Nru vcmi-0.94+svn3312/debian/changelog vcmi-0.94+svn3315/debian/changelog
--- vcmi-0.94+svn3312/debian/changelog	2013-11-11 17:12:22.000000000 +0000
+++ vcmi-0.94+svn3315/debian/changelog	2013-11-12 17:30:45.000000000 +0000
@@ -1,8 +1,8 @@
-vcmi (0.94+svn3312-0~ubuntu12.10.1) quantal; urgency=low
+vcmi (0.94+svn3315-0~ubuntu12.10.1) quantal; urgency=low
 
   * Auto build.
 
- -- Launchpad Package Builder <noreply@launchpad.net>  Mon, 11 Nov 2013 17:12:22 +0000
+ -- Launchpad Package Builder <noreply@launchpad.net>  Tue, 12 Nov 2013 17:30:45 +0000
 
 vcmi (0.94) precise; urgency=low
 
diff -Nru vcmi-0.94+svn3312/editor/Editor.cpp vcmi-0.94+svn3315/editor/Editor.cpp
--- vcmi-0.94+svn3312/editor/Editor.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/editor/Editor.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -2,7 +2,7 @@
 #include "Editor.h"
 #include "../lib/VCMI_Lib.h"
 #include "../lib/VCMIDirs.h"
-#include "../lib/filesystem/CResourceLoader.h"
+#include "../lib/filesystem/Filesystem.h"
 #include "../lib/CGeneralTextHandler.h"
 #include "../lib/mapping/CMap.h"
 #include "../lib/mapping/CMapService.h"
@@ -13,7 +13,7 @@
 {
 	// Setup default logging(enough for now)
 	console = new CConsoleHandler;
-	CBasicLogConfigurator logConfig(VCMIDirs::get().localPath() + "/VCMI_Editor_log.txt", console);
+	CBasicLogConfigurator logConfig(VCMIDirs::get().userCachePath() + "/VCMI_Editor_log.txt", console);
 	logConfig.configureDefault();
 
 	preinitDLL(console);
diff -Nru vcmi-0.94+svn3312/lib/CArtHandler.cpp vcmi-0.94+svn3315/lib/CArtHandler.cpp
--- vcmi-0.94+svn3312/lib/CArtHandler.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/CArtHandler.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -686,13 +686,13 @@
 	id = static_cast<ArtifactInstanceID>(ArtifactID::NONE); //to be randomized
 	setNodeType(ARTIFACT_INSTANCE);
 }
-
-ArtifactPosition CArtifactInstance::firstAvailableSlot(const CArtifactSet *h) const
-{
-	for(auto slot : artType->possibleSlots[h->bearerType()])
-	{
-		if(canBePutAt(h, slot)) //if(artType->fitsAt(h->artifWorn, slot))
-		{
+
+ArtifactPosition CArtifactInstance::firstAvailableSlot(const CArtifactSet *h) const
+{
+	for(auto slot : artType->possibleSlots.at(h->bearerType()))
+	{
+		if(canBePutAt(h, slot)) //if(artType->fitsAt(h->artifWorn, slot))
+		{
 			//we've found a free suitable slot.
 			return slot;
 		}
@@ -1092,13 +1092,13 @@
 	return getArtPos(aid, onlyWorn) != ArtifactPosition::PRE_FIRST;
 }
 
-const ArtSlotInfo * CArtifactSet::getSlot(ArtifactPosition pos) const
-{
-	if(vstd::contains(artifactsWorn, pos))
-		return &artifactsWorn[pos];
-	if(pos >= ArtifactPosition::AFTER_LAST )
-	{
-		int backpackPos = (int)pos - GameConstants::BACKPACK_START;
+const ArtSlotInfo * CArtifactSet::getSlot(ArtifactPosition pos) const
+{
+	if(vstd::contains(artifactsWorn, pos))
+		return &artifactsWorn.at(pos);
+	if(pos >= ArtifactPosition::AFTER_LAST )
+	{
+		int backpackPos = (int)pos - GameConstants::BACKPACK_START;
 		if(backpackPos < 0 || backpackPos >= artifactsInBackpack.size())
 			return nullptr;
 		else
diff -Nru vcmi-0.94+svn3312/lib/CArtHandler.h vcmi-0.94+svn3315/lib/CArtHandler.h
--- vcmi-0.94+svn3312/lib/CArtHandler.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/CArtHandler.h	2013-11-12 17:30:43.000000000 +0000
@@ -63,13 +63,13 @@
 	std::string nodeName() const override;
 	void addNewBonus(Bonus *b) override;
 
-	virtual void levelUpArtifact (CArtifactInstance * art){};
-
-	ui32 price;
-	bmap<ArtBearer::ArtBearer, std::vector<ArtifactPosition> > possibleSlots; //Bearer Type => ids of slots where artifact can be placed
-	std::unique_ptr<std::vector<CArtifact *> > constituents; // Artifacts IDs a combined artifact consists of, or nullptr.
-	std::vector<CArtifact *> constituentOf; // Reverse map of constituents - combined arts that include this art
-	EartClass aClass;
+	virtual void levelUpArtifact (CArtifactInstance * art){};
+
+	ui32 price;
+	std::map<ArtBearer::ArtBearer, std::vector<ArtifactPosition> > possibleSlots; //Bearer Type => ids of slots where artifact can be placed
+	std::unique_ptr<std::vector<CArtifact *> > constituents; // Artifacts IDs a combined artifact consists of, or nullptr.
+	std::vector<CArtifact *> constituentOf; // Reverse map of constituents - combined arts that include this art
+	EartClass aClass;
 	ArtifactID id;
 
 	template <typename Handler> void serialize(Handler &h, const int version)
@@ -263,13 +263,13 @@
 };
 
 class DLL_LINKAGE CArtifactSet
-{
-public:
-	std::vector<ArtSlotInfo> artifactsInBackpack; //hero's artifacts from bag
-	bmap<ArtifactPosition, ArtSlotInfo> artifactsWorn; //map<position,artifact_id>; positions: 0 - head; 1 - shoulders; 2 - neck; 3 - right hand; 4 - left hand; 5 - torso; 6 - right ring; 7 - left ring; 8 - feet; 9 - misc1; 10 - misc2; 11 - misc3; 12 - misc4; 13 - mach1; 14 - mach2; 15 - mach3; 16 - mach4; 17 - spellbook; 18 - misc5
-
-	ArtSlotInfo &retreiveNewArtSlot(ArtifactPosition slot);
-	void setNewArtSlot(ArtifactPosition slot, CArtifactInstance *art, bool locked);
+{
+public:
+	std::vector<ArtSlotInfo> artifactsInBackpack; //hero's artifacts from bag
+	std::map<ArtifactPosition, ArtSlotInfo> artifactsWorn; //map<position,artifact_id>; positions: 0 - head; 1 - shoulders; 2 - neck; 3 - right hand; 4 - left hand; 5 - torso; 6 - right ring; 7 - left ring; 8 - feet; 9 - misc1; 10 - misc2; 11 - misc3; 12 - misc4; 13 - mach1; 14 - mach2; 15 - mach3; 16 - mach4; 17 - spellbook; 18 - misc5
+
+	ArtSlotInfo &retreiveNewArtSlot(ArtifactPosition slot);
+	void setNewArtSlot(ArtifactPosition slot, CArtifactInstance *art, bool locked);
 	void eraseArtSlot(ArtifactPosition slot);
 
 	const ArtSlotInfo *getSlot(ArtifactPosition pos) const;
diff -Nru vcmi-0.94+svn3312/lib/CDefObjInfoHandler.h vcmi-0.94+svn3315/lib/CDefObjInfoHandler.h
--- vcmi-0.94+svn3312/lib/CDefObjInfoHandler.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/CDefObjInfoHandler.h	2013-11-12 17:30:43.000000000 +0000
@@ -46,16 +46,16 @@
 	CGDefInfo();
 void fetchInfoFromMSK();
 };
-class DLL_LINKAGE CDefObjInfoHandler
-{
-public:
-	bmap<int, bmap<int, ConstTransitivePtr<CGDefInfo> > > gobjs;
-
-	bmap<TFaction, ConstTransitivePtr<CGDefInfo> > capitols;
-	bmap<TFaction, ConstTransitivePtr<CGDefInfo> > villages;
-
-	CDefObjInfoHandler();
-	~CDefObjInfoHandler();
+class DLL_LINKAGE CDefObjInfoHandler
+{
+public:
+	std::map<int, std::map<int, ConstTransitivePtr<CGDefInfo> > > gobjs;
+
+	std::map<TFaction, ConstTransitivePtr<CGDefInfo> > capitols;
+	std::map<TFaction, ConstTransitivePtr<CGDefInfo> > villages;
+
+	CDefObjInfoHandler();
+	~CDefObjInfoHandler();
 
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
diff -Nru vcmi-0.94+svn3312/lib/CGameState.cpp vcmi-0.94+svn3315/lib/CGameState.cpp
--- vcmi-0.94+svn3312/lib/CGameState.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/CGameState.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -1,3297 +1,3285 @@
-#include "StdInc.h"
-#include "CGameState.h"
-
-#include "mapping/CCampaignHandler.h"
-#include "CDefObjInfoHandler.h"
-#include "CArtHandler.h"
-#include "CBuildingHandler.h"
-#include "CGeneralTextHandler.h"
-#include "CTownHandler.h"
-#include "CSpellHandler.h"
-#include "CHeroHandler.h"
-#include "CObjectHandler.h"
-#include "CCreatureHandler.h"
-#include "CModHandler.h"
-#include "VCMI_Lib.h"
-#include "Connection.h"
-#include "mapping/CMap.h"
-#include "mapping/CMapService.h"
-#include "StartInfo.h"
-#include "NetPacks.h"
-#include "RegisterTypes.h"
-#include "mapping/CMapInfo.h"
-#include "BattleState.h"
-#include "JsonNode.h"
-#include "filesystem/Filesystem.h"
-#include "GameConstants.h"
-#include "rmg/CMapGenerator.h"
-#include "CStopWatch.h"
-
-DLL_LINKAGE std::minstd_rand ran;
-class CGObjectInstance;
-
-#ifdef min
-#undef min
-#endif
-#ifdef max
-#undef max
-#endif
-
-/*
- * CGameState.cpp, part of VCMI engine
- *
- * Authors: listed in file AUTHORS in main folder
- *
- * License: GNU General Public License v2.0 or later
- * Full text of license available in license.txt file, in main folder
- *
- */
-
-template <typename T> class CApplyOnGS;
-
-class CBaseForGSApply
-{
-public:
-	virtual void applyOnGS(CGameState *gs, void *pack) const =0;
-	virtual ~CBaseForGSApply(){};
-	template<typename U> static CBaseForGSApply *getApplier(const U * t=nullptr)
-	{
-		return new CApplyOnGS<U>;
-	}
-};
-
-template <typename T> class CApplyOnGS : public CBaseForGSApply
-{
-public:
-	void applyOnGS(CGameState *gs, void *pack) const
-	{
-		T *ptr = static_cast<T*>(pack);
-
-		boost::unique_lock<boost::shared_mutex> lock(*gs->mx);
-		ptr->applyGs(gs);
-	}
-};
-
-static CApplier<CBaseForGSApply> *applierGs = nullptr;
-
-class IObjectCaller
-{
-public:
-	virtual ~IObjectCaller(){};
-	virtual void preInit()=0;
-	virtual void postInit()=0;
-};
-
-template <typename T>
-class CObjectCaller : public IObjectCaller
-{
-public:
-	void preInit()
-	{
-		//T::preInit();
-	}
-	void postInit()
-	{
-		//T::postInit();
-	}
-};
-
-class CObjectCallersHandler
-{
-public:
-	std::vector<IObjectCaller*> apps;
-
-	template<typename T> void registerType(const T * t=nullptr)
-	{
-		apps.push_back(new CObjectCaller<T>);
-	}
-
-	CObjectCallersHandler()
-	{
-		registerTypes1(*this);
-	}
-
-	~CObjectCallersHandler()
-	{
-		for (auto & elem : apps)
-			delete elem;
-	}
-
-	void preInit()
-	{
-// 		for (size_t i = 0; i < apps.size(); i++)
-// 			apps[i]->preInit();
-	}
-
-	void postInit()
-	{
-	//for (size_t i = 0; i < apps.size(); i++)
-	//apps[i]->postInit();
-	}
-} *objCaller = nullptr;
-
-void MetaString::getLocalString(const std::pair<ui8,ui32> &txt, std::string &dst) const
-{
-	int type = txt.first, ser = txt.second;
-
-	if(type == ART_NAMES)
-	{
-		dst = VLC->arth->artifacts[ser]->Name();
-	}
-	else if(type == CRE_PL_NAMES)
-	{
-		dst = VLC->creh->creatures[ser]->namePl;
-	}
-	else if(type == MINE_NAMES)
-	{
-		dst = VLC->generaltexth->mines[ser].first;
-	}
-	else if(type == MINE_EVNTS)
-	{
-		dst = VLC->generaltexth->mines[ser].second;
-	}
-	else if(type == SPELL_NAME)
-	{
-		dst = SpellID(ser).toSpell()->name;
-	}
-	else if(type == CRE_SING_NAMES)
-	{
-		dst = VLC->creh->creatures[ser]->nameSing;
-	}
-	else if(type == ART_DESCR)
-	{
-		dst = VLC->arth->artifacts[ser]->Description();
-	}
-	else if (type == ART_EVNTS)
-	{
-		dst = VLC->arth->artifacts[ser]->EventText();
-	}
-	else
-	{
-		std::vector<std::string> *vec;
-		switch(type)
-		{
-		case GENERAL_TXT:
-			vec = &VLC->generaltexth->allTexts;
-			break;
-		case XTRAINFO_TXT:
-			vec = &VLC->generaltexth->xtrainfo;
-			break;
-		case OBJ_NAMES:
-			vec = &VLC->generaltexth->names;
-			break;
-		case RES_NAMES:
-			vec = &VLC->generaltexth->restypes;
-			break;
-		case ARRAY_TXT:
-			vec = &VLC->generaltexth->arraytxt;
-			break;
-		case CREGENS:
-			vec = &VLC->generaltexth->creGens;
-			break;
-		case CREGENS4:
-			vec = &VLC->generaltexth->creGens4;
-			break;
-		case ADVOB_TXT:
-			vec = &VLC->generaltexth->advobtxt;
-			break;
-		case SEC_SKILL_NAME:
-			vec = &VLC->generaltexth->skillName;
-			break;
-		case COLOR:
-			vec = &VLC->generaltexth->capColors;
-			break;
-		default:
-            logGlobal->errorStream() << "Failed string substitution because type is " << type;
-			dst = "#@#";
-			return;
-		}
-		if(vec->size() <= ser)
-		{
-            logGlobal->errorStream() << "Failed string substitution with type " << type << " because index " << ser << " is out of bounds!";
-			dst = "#!#";
-		}
-		else
-			dst = (*vec)[ser];
-	}
-}
-
-DLL_LINKAGE void MetaString::toString(std::string &dst) const
-{
-	size_t exSt = 0, loSt = 0, nums = 0;
-	dst.clear();
-
-	for(auto & elem : message)
-	{//TEXACT_STRING, TLOCAL_STRING, TNUMBER, TREPLACE_ESTRING, TREPLACE_LSTRING, TREPLACE_NUMBER
-		switch(elem)
-		{
-		case TEXACT_STRING:
-			dst += exactStrings[exSt++];
-			break;
-		case TLOCAL_STRING:
-			{
-				std::string hlp;
-				getLocalString(localStrings[loSt++], hlp);
-				dst += hlp;
-			}
-			break;
-		case TNUMBER:
-			dst += boost::lexical_cast<std::string>(numbers[nums++]);
-			break;
-		case TREPLACE_ESTRING:
-			boost::replace_first(dst, "%s", exactStrings[exSt++]);
-			break;
-		case TREPLACE_LSTRING:
-			{
-				std::string hlp;
-				getLocalString(localStrings[loSt++], hlp);
-				boost::replace_first(dst, "%s", hlp);
-			}
-			break;
-		case TREPLACE_NUMBER:
-			boost::replace_first(dst, "%d", boost::lexical_cast<std::string>(numbers[nums++]));
-			break;
-		case TREPLACE_PLUSNUMBER:
-			boost::replace_first(dst, "%+d", '+' + boost::lexical_cast<std::string>(numbers[nums++]));
-			break;
-		default:
-            logGlobal->errorStream() << "MetaString processing error!";
-			break;
-		}
-	}
-}
-
-DLL_LINKAGE std::string MetaString::toString() const
-{
-	std::string ret;
-	toString(ret);
-	return ret;
-}
-
-DLL_LINKAGE std::string MetaString::buildList () const
-///used to handle loot from creature bank
-{
-
-	size_t exSt = 0, loSt = 0, nums = 0;
-	std::string lista;
-	for (int i = 0; i < message.size(); ++i)
-	{
-		if (i > 0 && (message[i] == TEXACT_STRING || message[i] == TLOCAL_STRING))
-		{
-			if (exSt == exactStrings.size() - 1)
-				lista += VLC->generaltexth->allTexts[141]; //" and "
-			else
-				lista += ", ";
-		}
-		switch (message[i])
-		{
-			case TEXACT_STRING:
-				lista += exactStrings[exSt++];
-				break;
-			case TLOCAL_STRING:
-			{
-				std::string hlp;
-				getLocalString (localStrings[loSt++], hlp);
-				lista += hlp;
-			}
-				break;
-			case TNUMBER:
-				lista += boost::lexical_cast<std::string>(numbers[nums++]);
-				break;
-			case TREPLACE_ESTRING:
-				lista.replace (lista.find("%s"), 2, exactStrings[exSt++]);
-				break;
-			case TREPLACE_LSTRING:
-			{
-				std::string hlp;
-				getLocalString (localStrings[loSt++], hlp);
-				lista.replace (lista.find("%s"), 2, hlp);
-			}
-				break;
-			case TREPLACE_NUMBER:
-				lista.replace (lista.find("%d"), 2, boost::lexical_cast<std::string>(numbers[nums++]));
-				break;
-			default:
-                logGlobal->errorStream() << "MetaString processing error!";
-		}
-
-	}
-	return lista;
-}
-
-
-void  MetaString::addCreReplacement(CreatureID id, TQuantity count) //adds sing or plural name;
-{
-	if (!count)
-		addReplacement (CRE_PL_NAMES, id); //no creatures - just empty name (eg. defeat Angels)
-	else if (count == 1)
-		addReplacement (CRE_SING_NAMES, id);
-	else
-		addReplacement (CRE_PL_NAMES, id);
-}
-
-void MetaString::addReplacement(const CStackBasicDescriptor &stack)
-{
-	assert(stack.type); //valid type
-	addCreReplacement(stack.type->idNumber, stack.count);
-}
-
-static CGObjectInstance * createObject(Obj id, int subid, int3 pos, PlayerColor owner)
-{
-	CGObjectInstance * nobj;
-	switch(id)
-	{
-	case Obj::HERO:
-		{
-			auto  nobj = new CGHeroInstance();
-			nobj->pos = pos;
-			nobj->tempOwner = owner;
-			nobj->subID = subid;
-			//nobj->initHero(ran);
-			return nobj;
-		}
-	case Obj::TOWN:
-		nobj = new CGTownInstance;
-		break;
-	default: //rest of objects
-		nobj = new CGObjectInstance;
-		nobj->defInfo = id.toDefObjInfo()[subid];
-		break;
-	}
-	nobj->ID = id;
-	nobj->subID = subid;
-	if(!nobj->defInfo)
-        logGlobal->warnStream() <<"No def declaration for " <<id <<" "<<subid;
-	nobj->pos = pos;
-	//nobj->state = nullptr;//new CLuaObjectScript();
-	nobj->tempOwner = owner;
-	nobj->defInfo->id = id;
-	nobj->defInfo->subid = subid;
-
-	//assigning defhandler
-	if(nobj->ID==Obj::HERO || nobj->ID==Obj::TOWN)
-		return nobj;
-	nobj->defInfo = id.toDefObjInfo()[subid];
-	return nobj;
-}
-
-CGHeroInstance * CGameState::HeroesPool::pickHeroFor(bool native, PlayerColor player, const CTown *town, bmap<ui32, ConstTransitivePtr<CGHeroInstance> > &available, const CHeroClass *bannedClass /*= nullptr*/) const
-{
-	CGHeroInstance *ret = nullptr;
-
-	if(player>=PlayerColor::PLAYER_LIMIT)
-	{
-        logGlobal->errorStream() << "Cannot pick hero for " << town->faction->index << ". Wrong owner!";
-		return nullptr;
-	}
-
-	std::vector<CGHeroInstance *> pool;
-
-	if(native)
-	{
-		for(auto & elem : available)
-		{
-			if(pavailable.find(elem.first)->second & 1<<player.getNum()
-				&& elem.second->type->heroClass->faction == town->faction->index)
-			{
-				pool.push_back(elem.second); //get all available heroes
-			}
-		}
-		if(!pool.size())
-		{
-            logGlobal->errorStream() << "Cannot pick native hero for " << player << ". Picking any...";
-			return pickHeroFor(false, player, town, available);
-		}
-		else
-		{
-			ret = pool[rand()%pool.size()];
-		}
-	}
-	else
-	{
-		int sum=0, r;
-
-		for(auto & elem : available)
-		{
-			if (pavailable.find(elem.first)->second & (1<<player.getNum()) &&    // hero is available
-			    ( !bannedClass || elem.second->type->heroClass != bannedClass) ) // and his class is not same as other hero
-			{
-				pool.push_back(elem.second);
-				sum += elem.second->type->heroClass->selectionProbability[town->faction->index]; //total weight
-			}
-		}
-		if(!pool.size() || sum == 0)
-		{
-            logGlobal->errorStream() << "There are no heroes available for player " << player<<"!";
-			return nullptr;
-		}
-
-		r = rand()%sum;
-		for (auto & elem : pool)
-		{
-			r -= elem->type->heroClass->selectionProbability[town->faction->index];
-			if(r < 0)
-			{
-				ret = elem;
-				break;
-			}
-		}
-		if(!ret)
-			ret = pool.back();
-	}
-
-	available.erase(ret->subID);
-	return ret;
-}
-
-int CGameState::pickHero(PlayerColor owner)
-{
-	const PlayerSettings &ps = scenarioOps->getIthPlayersSettings(owner);
-    if(!isUsedHero(HeroTypeID(ps.hero)) &&  ps.hero >= 0) //we haven't used selected hero
-		return ps.hero;
-
-	if(scenarioOps->mode == StartInfo::CAMPAIGN)
-	{
-		auto bonus = scenarioOps->campState->getBonusForCurrentMap();
-		if(bonus && bonus->type == CScenarioTravel::STravelBonus::HERO && owner == PlayerColor(bonus->info1))
-		{
-			//TODO what if hero chosen as bonus is placed in the prison on map
-			if(bonus->info2 != 0xffff && !isUsedHero(HeroTypeID(bonus->info2))) //not random and not taken
-			{
-				return bonus->info2;
-			}
-		}
-	}
-
-	//list of heroes for this faction and others
-	std::vector<HeroTypeID> factionHeroes, otherHeroes;
-
-	const size_t firstHero = ps.castle*GameConstants::HEROES_PER_TYPE*2;
-	const size_t lastHero  = std::min(firstHero + GameConstants::HEROES_PER_TYPE*2, VLC->heroh->heroes.size()) - 1;
-	const auto heroesToConsider = getUnusedAllowedHeroes();
-
-	for(auto hid : heroesToConsider)
-	{
-		if(vstd::iswithin(hid.getNum(), firstHero, lastHero))
-			factionHeroes.push_back(hid);
-		else
-			otherHeroes.push_back(hid);
-	}
-
-	// we need random order to select hero
-	auto randGen = [](size_t range)
-	{
-		return ran() % range;
-	};
-	boost::random_shuffle(factionHeroes, randGen); // generator must be reference
-
-	if(factionHeroes.size())
-		return factionHeroes.front().getNum();
-
-	logGlobal->warnStream() << "Cannot find free hero of appropriate faction for player " << owner << " - trying to get first available...";
-	if(otherHeroes.size())
-		return otherHeroes.front().getNum();
-
-
-	logGlobal->errorStream() << "No free allowed heroes!";
-	auto notAllowedHeroesButStillBetterThanCrash = getUnusedAllowedHeroes(true);
-	if(notAllowedHeroesButStillBetterThanCrash.size())
-		return notAllowedHeroesButStillBetterThanCrash.begin()->getNum();
-
-	logGlobal->errorStream() << "No free heroes at all!";
-	assert(0); //current code can't handle this situation
-	return -1; // no available heroes at all
-}
-
-
-std::pair<Obj,int> CGameState::pickObject (CGObjectInstance *obj)
-{
-	switch(obj->ID)
-	{
-	case Obj::RANDOM_ART:
-		return std::make_pair(Obj::ARTIFACT, VLC->arth->getRandomArt (CArtifact::ART_TREASURE | CArtifact::ART_MINOR | CArtifact::ART_MAJOR | CArtifact::ART_RELIC));
-	case Obj::RANDOM_TREASURE_ART:
-		return std::make_pair(Obj::ARTIFACT, VLC->arth->getRandomArt (CArtifact::ART_TREASURE));
-	case Obj::RANDOM_MINOR_ART:
-		return std::make_pair(Obj::ARTIFACT, VLC->arth->getRandomArt (CArtifact::ART_MINOR));
-	case Obj::RANDOM_MAJOR_ART:
-		return std::make_pair(Obj::ARTIFACT, VLC->arth->getRandomArt (CArtifact::ART_MAJOR));
-	case Obj::RANDOM_RELIC_ART:
-		return std::make_pair(Obj::ARTIFACT, VLC->arth->getRandomArt (CArtifact::ART_RELIC));
-	case Obj::RANDOM_HERO:
-		return std::make_pair(Obj::HERO, pickHero(obj->tempOwner));
-	case Obj::RANDOM_MONSTER:
-		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran)));
-	case Obj::RANDOM_MONSTER_L1:
-		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 1));
-	case Obj::RANDOM_MONSTER_L2:
-		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 2));
-	case Obj::RANDOM_MONSTER_L3:
-		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 3));
-	case Obj::RANDOM_MONSTER_L4:
-		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 4));
-	case Obj::RANDOM_RESOURCE:
-		return std::make_pair(Obj::RESOURCE,ran()%7); //now it's OH3 style, use %8 for mithril
-	case Obj::RANDOM_TOWN:
-		{
-			PlayerColor align = PlayerColor((static_cast<CGTownInstance*>(obj))->alignment);
-			si32 f; // can be negative (for random)
-			if(align >= PlayerColor::PLAYER_LIMIT)//same as owner / random
-			{
-				if(obj->tempOwner >= PlayerColor::PLAYER_LIMIT)
-					f = -1; //random
-				else
-					f = scenarioOps->getIthPlayersSettings(obj->tempOwner).castle;
-			}
-			else
-			{
-				f = scenarioOps->getIthPlayersSettings(align).castle;
-			}
-			if(f<0)
-			{
-				do
-				{
-					f = ran()%VLC->townh->factions.size();
-				}
-				while (VLC->townh->factions[f]->town == nullptr); // find playable faction
-			}
-			return std::make_pair(Obj::TOWN,f);
-		}
-	case Obj::RANDOM_MONSTER_L5:
-		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 5));
-	case Obj::RANDOM_MONSTER_L6:
-		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 6));
-	case Obj::RANDOM_MONSTER_L7:
-		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 7));
-	case Obj::RANDOM_DWELLING:
-	case Obj::RANDOM_DWELLING_LVL:
-	case Obj::RANDOM_DWELLING_FACTION:
-		{
-			CGDwelling * dwl = static_cast<CGDwelling*>(obj);
-			int faction;
-
-			//if castle alignment available
-			if (auto info = dynamic_cast<CCreGenAsCastleInfo*>(dwl->info))
-			{
-				faction = ran() % VLC->townh->factions.size();
-				if (info->asCastle)
-				{
-					for(auto & elem : map->objects)
-					{
-						if(!elem)
-							continue;
-
-						if(elem->ID==Obj::RANDOM_TOWN
-							&& dynamic_cast<CGTownInstance*>(elem.get())->identifier == info->identifier)
-						{
-							randomizeObject(elem); //we have to randomize the castle first
-							faction = elem->subID;
-							break;
-						}
-						else if(elem->ID==Obj::TOWN
-							&& dynamic_cast<CGTownInstance*>(elem.get())->identifier == info->identifier)
-						{
-							faction = elem->subID;
-							break;
-						}
-					}
-				}
-				else
-				{
-					while((!(info->castles[0]&(1<<faction))))
-					{
-						if((faction>7) && (info->castles[1]&(1<<(faction-8))))
-							break;
-						faction = ran()%GameConstants::F_NUMBER;
-					}
-				}
-			}
-			else // castle alignment fixed
-				faction = obj->subID;
-
-			int level;
-
-			//if level set to range
-			if (auto info = dynamic_cast<CCreGenLeveledInfo*>(dwl->info))
-				level = ((info->maxLevel-info->minLevel) ? (ran()%(info->maxLevel-info->minLevel)+info->minLevel) : (info->minLevel));
-			else // fixed level
-				level = obj->subID;
-
-			delete dwl->info;
-			dwl->info = nullptr;
-
-			std::pair<Obj, int> result(Obj::NO_OBJ, -1);
-			CreatureID cid = VLC->townh->factions[faction]->town->creatures[level][0];
-
-			//golem factory is not in list of cregens but can be placed as random object
-			static const CreatureID factoryCreatures[] = {CreatureID::STONE_GOLEM, CreatureID::IRON_GOLEM,
-				CreatureID::GOLD_GOLEM, CreatureID::DIAMOND_GOLEM};
-			std::vector<CreatureID> factory(factoryCreatures, factoryCreatures + ARRAY_COUNT(factoryCreatures));
-			if (vstd::contains(factory, cid))
-				result = std::make_pair(Obj::CREATURE_GENERATOR4, 1);
-
-			//NOTE: this will pick last dwelling with this creature (Mantis #900)
-			//check for block map equality is better but more complex solution
-			for(auto &iter : VLC->objh->cregens)
-				if (iter.second == cid)
-					result = std::make_pair(Obj::CREATURE_GENERATOR1, iter.first);
-
-			if (result.first == Obj::NO_OBJ)
-			{
-                logGlobal->errorStream() << "Error: failed to find creature for dwelling of "<< int(faction) << " of level " << int(level);
-				auto iter = VLC->objh->cregens.begin();
-				std::advance(iter, ran() % VLC->objh->cregens.size() );
-				result = std::make_pair(Obj::CREATURE_GENERATOR1, iter->first);
-			}
-
-			return result;
-		}
-	}
-	return std::make_pair(Obj::NO_OBJ,-1);
-}
-
-void CGameState::randomizeObject(CGObjectInstance *cur)
-{
-	std::pair<Obj,int> ran = pickObject(cur);
-	if(ran.first == Obj::NO_OBJ || ran.second<0) //this is not a random object, or we couldn't find anything
-	{
-		if(cur->ID==Obj::TOWN) //town - set def
-		{
-			CGTownInstance *t = dynamic_cast<CGTownInstance*>(cur);
-			t->town = VLC->townh->factions[t->subID]->town;
-			if(t->hasCapitol())
-				t->defInfo = VLC->dobjinfo->capitols[t->subID];
-			else if(t->hasFort())
-				t->defInfo = VLC->dobjinfo->gobjs[Obj::TOWN][t->subID];
-			else
-				t->defInfo = VLC->dobjinfo->villages[t->subID];
-		}
-		return;
-	}
-	else if(ran.first==Obj::HERO)//special code for hero
-	{
-		CGHeroInstance *h = dynamic_cast<CGHeroInstance *>(cur);
-        if(!h) {logGlobal->warnStream()<<"Wrong random hero at "<<cur->pos; return;}
-		cur->ID = ran.first;
-		cur->subID = ran.second;
-		h->type = VLC->heroh->heroes[ran.second];
-		h->portrait = h->type->imageIndex;
-		h->randomizeArmy(h->type->heroClass->faction);
-		map->heroesOnMap.push_back(h);
-		return; //TODO: maybe we should do something with definfo?
-	}
-	else if(ran.first==Obj::TOWN)//special code for town
-	{
-		CGTownInstance *t = dynamic_cast<CGTownInstance*>(cur);
-        if(!t) {logGlobal->warnStream()<<"Wrong random town at "<<cur->pos; return;}
-		cur->ID = ran.first;
-		cur->subID = ran.second;
-		//FIXME: copy-pasted from above
-		t->town = VLC->townh->factions[t->subID]->town;
-		if(t->hasCapitol())
-			t->defInfo = VLC->dobjinfo->capitols[t->subID];
-		else if(t->hasFort())
-			t->defInfo = VLC->dobjinfo->gobjs[Obj::TOWN][t->subID];
-		else
-			t->defInfo = VLC->dobjinfo->villages[t->subID];
-		t->randomizeArmy(t->subID);
-		map->towns.push_back(t);
-		return;
-	}
-	//we have to replace normal random object
-	cur->ID = ran.first;
-	cur->subID = ran.second;
-	map->removeBlockVisTiles(cur); //recalculate blockvis tiles - picked object might have different than random placeholder
-	map->customDefs.push_back(cur->defInfo = ran.first.toDefObjInfo()[ran.second]);
-	if(!cur->defInfo)
-	{
-        logGlobal->errorStream()<<"*BIG* WARNING: Missing def declaration for "<<cur->ID<<" "<<cur->subID;
-		return;
-	}
-
-	map->addBlockVisTiles(cur);
-}
-
-int CGameState::getDate(Date::EDateType mode) const
-{
-	int temp;
-	switch (mode)
-	{
-	case Date::DAY:
-		return day;
-	case Date::DAY_OF_WEEK: //day of week
-		temp = (day)%7; // 1 - Monday, 7 - Sunday
-		return temp ? temp : 7;
-	case Date::WEEK:  //current week
-		temp = ((day-1)/7)+1;
-		if (!(temp%4))
-			return 4;
-		else
-			return (temp%4);
-	case Date::MONTH: //current month
-		return ((day-1)/28)+1;
-	case Date::DAY_OF_MONTH: //day of month
-		temp = (day)%28;
-		if (temp)
-			return temp;
-		else return 28;
-	}
-	return 0;
-}
-CGameState::CGameState()
-{
-	gs = this;
-	mx = new boost::shared_mutex();
-	applierGs = new CApplier<CBaseForGSApply>;
-	registerTypes2(*applierGs);
-	objCaller = new CObjectCallersHandler;
-	globalEffects.setDescription("Global effects");
-}
-CGameState::~CGameState()
-{
-	//delete mx;//TODO: crash on Linux (mutex must be unlocked before destruction)
-	map.dellNull();
-	curB.dellNull();
-	//delete scenarioOps; //TODO: fix for loading ind delete
-	//delete initialOpts;
-	delete applierGs;
-	delete objCaller;
-
-	for(auto ptr : hpool.heroesPool) // clean hero pool
-		ptr.second.dellNull();
-}
-
-BattleInfo * CGameState::setupBattle(int3 tile, const CArmedInstance *armies[2], const CGHeroInstance * heroes[2], bool creatureBank, const CGTownInstance *town)
-{
-	const TerrainTile &t = map->getTile(tile);
-    ETerrainType terrain = t.terType;
-	if(t.isCoastal() && !t.isWater())
-        terrain = ETerrainType::SAND;
-
-	BFieldType terType = battleGetBattlefieldType(tile);
-	return BattleInfo::setupBattle(tile, terrain, terType, armies, heroes, creatureBank, town);
-}
-
-void CGameState::init(StartInfo * si)
-{
-	auto giveCampaignBonusToHero = [&](CGHeroInstance * hero)
-	{
-		const boost::optional<CScenarioTravel::STravelBonus> & curBonus = scenarioOps->campState->getBonusForCurrentMap();
-		if(!curBonus)
-			return;
-
-		if(curBonus->isBonusForHero())
-		{
-			//apply bonus
-			switch (curBonus->type)
-			{
-			case CScenarioTravel::STravelBonus::SPELL:
-				hero->spells.insert(SpellID(curBonus->info2));
-				break;
-			case CScenarioTravel::STravelBonus::MONSTER:
-				{
-					for(int i=0; i<GameConstants::ARMY_SIZE; i++)
-					{
-						if(hero->slotEmpty(SlotID(i)))
-						{
-							hero->addToSlot(SlotID(i), CreatureID(curBonus->info2), curBonus->info3);
-							break;
-						}
-					}
-				}
-				break;
-			case CScenarioTravel::STravelBonus::ARTIFACT:
-				gs->giveHeroArtifact(hero, static_cast<ArtifactID>(curBonus->info2));
-				break;
-			case CScenarioTravel::STravelBonus::SPELL_SCROLL:
-				{
-					CArtifactInstance * scroll = CArtifactInstance::createScroll(SpellID(curBonus->info2).toSpell());
-					scroll->putAt(ArtifactLocation(hero, scroll->firstAvailableSlot(hero)));
-				}
-				break;
-			case CScenarioTravel::STravelBonus::PRIMARY_SKILL:
-				{
-					const ui8* ptr = reinterpret_cast<const ui8*>(&curBonus->info2);
-					for (int g=0; g<GameConstants::PRIMARY_SKILLS; ++g)
-					{
-						int val = ptr[g];
-						if (val == 0)
-						{
-							continue;
-						}
-						auto bb = new Bonus(Bonus::PERMANENT, Bonus::PRIMARY_SKILL, Bonus::CAMPAIGN_BONUS, val, scenarioOps->campState->currentMap, g);
-						hero->addNewBonus(bb);
-					}
-				}
-				break;
-			case CScenarioTravel::STravelBonus::SECONDARY_SKILL:
-				hero->setSecSkillLevel(SecondarySkill(curBonus->info2), curBonus->info3, true);
-				break;
-			}
-		}
-	};
-
-	auto getHumanPlayerInfo = [&]() -> std::vector<const PlayerSettings *>
-	{
-		std::vector<const PlayerSettings *> ret;
-		for(auto it = scenarioOps->playerInfos.cbegin();
-			it != scenarioOps->playerInfos.cend(); ++it)
-		{
-			if(it->second.playerID != PlayerSettings::PLAYER_AI)
-				ret.push_back(&it->second);
-		}
-
-		return ret;
-	};
-
-    logGlobal->infoStream() << "\tUsing random seed: "<< si->seedToBeUsed;
-	ran.seed((boost::int32_t)si->seedToBeUsed);
-	scenarioOps = new StartInfo(*si);
-	initialOpts = new StartInfo(*si);
-	si = nullptr;
-
-	switch(scenarioOps->mode)
-	{
-	case StartInfo::NEW_GAME:
-		{
-			if(scenarioOps->createRandomMap())
-			{
-                logGlobal->infoStream() << "Create random map.";
-				CStopWatch sw;
-
-				// Gen map
-				CMapGenerator mapGenerator;
-				map = mapGenerator.generate(scenarioOps->mapGenOptions.get(), scenarioOps->seedToBeUsed).release();
-
-				// Update starting options
-				for(int i = 0; i < map->players.size(); ++i)
-				{
-                    const auto & playerInfo = map->players[i];
-                    if(playerInfo.canAnyonePlay())
-					{
-                        PlayerSettings & playerSettings = scenarioOps->playerInfos[PlayerColor(i)];
-                        playerSettings.compOnly = !playerInfo.canHumanPlay;
-                        playerSettings.team = playerInfo.team;
-                        playerSettings.castle = playerInfo.defaultCastle();
-                        if(playerSettings.playerID == PlayerSettings::PLAYER_AI && playerSettings.name.empty())
-						{
-                            playerSettings.name = VLC->generaltexth->allTexts[468];
-						}
-                        playerSettings.color = PlayerColor(i);
-					}
-					else
-					{
-						scenarioOps->playerInfos.erase(PlayerColor(i));
-					}
-				}
-
-				logGlobal->infoStream() << boost::format("Generated random map in %i ms.") % sw.getDiff();
-			}
-			else
-			{
-                logGlobal->infoStream() << "Open map file: " << scenarioOps->mapname;
-				map = CMapService::loadMap(scenarioOps->mapname).release();
-			}
-		}
-		break;
-	case StartInfo::CAMPAIGN:
-		{
-            logGlobal->infoStream() << "Open campaign map file: " << scenarioOps->campState->currentMap;
-			auto campaign = scenarioOps->campState;
-			assert(vstd::contains(campaign->camp->mapPieces, scenarioOps->campState->currentMap));
-
-			std::string & mapContent = campaign->camp->mapPieces[scenarioOps->campState->currentMap];
-			auto buffer = reinterpret_cast<const ui8 *>(mapContent.data());
-			map = CMapService::loadMap(buffer, mapContent.size()).release();
-		}
-		break;
-	case StartInfo::DUEL:
-		initDuel();
-		return;
-	default:
-        logGlobal->errorStream() << "Wrong mode: " << (int)scenarioOps->mode;
-		return;
-	}
-	VLC->arth->initAllowedArtifactsList(map->allowedArtifact);
-    logGlobal->infoStream() << "Map loaded!";
-
-    logGlobal->infoStream() << "\tOur checksum for the map: "<< map->checksum;
-	if(scenarioOps->mapfileChecksum)
-	{
-        logGlobal->infoStream() << "\tServer checksum for " << scenarioOps->mapname <<": "<< scenarioOps->mapfileChecksum;
-		if(map->checksum != scenarioOps->mapfileChecksum)
-		{
-            logGlobal->errorStream() << "Wrong map checksum!!!";
-			throw std::runtime_error("Wrong checksum");
-		}
-	}
-	else
-		scenarioOps->mapfileChecksum = map->checksum;
-
-	day = 0;
-
-    logGlobal->debugStream() << "Initialization:";
-    logGlobal->debugStream() << "\tPicking grail position";
- 	//pick grail location
- 	if(map->grailPos.x < 0 || map->grailRadious) //grail not set or set within a radius around some place
- 	{
-		if(!map->grailRadious) //radius not given -> anywhere on map
-			map->grailRadious = map->width * 2;
-
- 		std::vector<int3> allowedPos;
-		static const int BORDER_WIDTH = 9; // grail must be at least 9 tiles away from border
-
-		// add all not blocked tiles in range
-		for (int i = BORDER_WIDTH; i < map->width - BORDER_WIDTH ; i++)
-		{
-			for (int j = BORDER_WIDTH; j < map->height - BORDER_WIDTH; j++)
-			{
-				for (int k = 0; k < (map->twoLevel ? 2 : 1); k++)
-				{
-					const TerrainTile &t = map->getTile(int3(i, j, k));
-					if(!t.blocked
-						&& !t.visitable
-                        && t.terType != ETerrainType::WATER
-                        && t.terType != ETerrainType::ROCK
-						&& map->grailPos.dist2d(int3(i,j,k)) <= map->grailRadious)
- 						allowedPos.push_back(int3(i,j,k));
- 				}
- 			}
- 		}
-
-		//remove tiles with holes
-		for(auto & elem : map->objects)
-			if(elem && elem->ID == Obj::HOLE)
-				allowedPos -= elem->pos;
-
-		if(allowedPos.size())
-			map->grailPos = allowedPos[ran() % allowedPos.size()];
-		else
-            logGlobal->warnStream() << "Warning: Grail cannot be placed, no appropriate tile found!";
-	}
-
-	//picking random factions for players
-    logGlobal->debugStream() << "\tPicking random factions for players";
-	for(auto & elem : scenarioOps->playerInfos)
-	{
-		if(elem.second.castle==-1)
-		{
-			int randomID = ran() % map->players[elem.first.getNum()].allowedFactions.size();
-			auto iter = map->players[elem.first.getNum()].allowedFactions.begin();
-			std::advance(iter, randomID);
-
-			elem.second.castle = *iter;
-		}
-	}
-
-	//randomizing objects
-    logGlobal->debugStream() << "\tRandomizing objects";
-	for(CGObjectInstance *obj : map->objects)
-	{
-		if(!obj)
-			continue;
-
-		randomizeObject(obj);
-		obj->hoverName = VLC->generaltexth->names[obj->ID];
-
-		//handle Favouring Winds - mark tiles under it
-		if(obj->ID == Obj::FAVORABLE_WINDS)
-			for (int i = 0; i < obj->getWidth() ; i++)
-				for (int j = 0; j < obj->getHeight() ; j++)
-				{
-					int3 pos = obj->pos - int3(i,j,0);
-					if(map->isInTheMap(pos))
-                        map->getTile(pos).extTileFlags |= 128;
-				}
-	}
-
-	/*********creating players entries in gs****************************************/
-    logGlobal->debugStream() << "\tCreating player entries in gs";
-	for(auto & elem : scenarioOps->playerInfos)
-	{
-		std::pair<PlayerColor, PlayerState> ins(elem.first,PlayerState());
-		ins.second.color=ins.first;
-		ins.second.human = elem.second.playerID;
-		ins.second.team = map->players[ins.first.getNum()].team;
-		teams[ins.second.team].id = ins.second.team;//init team
-		teams[ins.second.team].players.insert(ins.first);//add player to team
-		players.insert(ins);
-	}
-
-	/*************************replace hero placeholders*****************************/
-	if (scenarioOps->campState)
-	{
-		logGlobal->debugStream() << "\tReplacing hero placeholders";
-		std::vector<std::pair<CGHeroInstance*, ObjectInstanceID> > campHeroReplacements = campaignHeroesToReplace();
-		//Replace placeholders with heroes from previous missions
-		logGlobal->debugStream() << "\tSetting up heroes";
-		placeCampaignHeroes(campHeroReplacements);
-	}
-
-
-	/*********give starting hero****************************************/
-    logGlobal->debugStream() << "\tGiving starting hero";
-	{
-		bool campaignGiveHero = false;
-		if(scenarioOps->campState)
-		{
-			if(auto bonus = scenarioOps->campState->getBonusForCurrentMap())
-			{
-				campaignGiveHero =  scenarioOps->mode == StartInfo::CAMPAIGN &&
-					bonus.get().type == CScenarioTravel::STravelBonus::HERO;
-			}
-		}
-
-		for(auto it = scenarioOps->playerInfos.begin(); it != scenarioOps->playerInfos.end(); ++it)
-		{
-			const PlayerInfo &p = map->players[it->first.getNum()];
-			bool generateHero = (p.generateHeroAtMainTown ||
-			                     (it->second.playerID != PlayerSettings::PLAYER_AI && campaignGiveHero)) && p.hasMainTown;
-			if(generateHero && vstd::contains(scenarioOps->playerInfos, it->first))
-			{
-				int3 hpos = p.posOfMainTown;
-				hpos.x+=1;
-
-				int h = pickHero(it->first);
-				if(it->second.hero == -1)
-					it->second.hero = h;
-
-				CGHeroInstance * nnn =  static_cast<CGHeroInstance*>(createObject(Obj::HERO,h,hpos,it->first));
-				nnn->id = ObjectInstanceID(map->objects.size());
-				nnn->initHero();
-				map->heroesOnMap.push_back(nnn);
-				map->objects.push_back(nnn);
-				map->addBlockVisTiles(nnn);
-			}
-		}
-	}
-
-	/******************RESOURCES****************************************************/
-    logGlobal->debugStream() << "\tSetting up resources";
-	const JsonNode config(ResourceID("config/startres.json"));
-	const JsonVector &vector = config["difficulty"].Vector();
-	const JsonNode &level = vector[scenarioOps->difficulty];
-
-	TResources startresAI(level["ai"]);
-	TResources startresHuman(level["human"]);
-
-	for (auto & elem : players)
-	{
-		PlayerState &p = elem.second;
-
-		if (p.human)
-			p.resources = startresHuman;
-		else
-			p.resources = startresAI;
-	}
-
-	//give start resource bonus in case of campaign
-	if (scenarioOps->mode == StartInfo::CAMPAIGN)
-	{
-		auto chosenBonus = scenarioOps->campState->getBonusForCurrentMap();
-		if(chosenBonus && chosenBonus->type == CScenarioTravel::STravelBonus::RESOURCE)
-		{
-			std::vector<const PlayerSettings *> people = getHumanPlayerInfo(); //players we will give resource bonus
-			for(const PlayerSettings *ps : people)
-			{
-				std::vector<int> res; //resources we will give
-				switch (chosenBonus->info1)
-				{
-				case 0: case 1: case 2: case 3: case 4: case 5: case 6:
-					res.push_back(chosenBonus->info1);
-					break;
-				case 0xFD: //wood+ore
-					res.push_back(Res::WOOD); res.push_back(Res::ORE);
-					break;
-				case 0xFE:  //rare
-					res.push_back(Res::MERCURY); res.push_back(Res::SULFUR); res.push_back(Res::CRYSTAL); res.push_back(Res::GEMS);
-					break;
-				default:
-					assert(0);
-					break;
-				}
-				//increasing resource quantity
-				for (auto & re : res)
-				{
-					players[ps->color].resources[re] += chosenBonus->info2;
-				}
-			}
-		}
-	}
-
-
-	/*************************HEROES INIT / POOL************************************************/
-	for(auto hero : map->heroesOnMap)  //heroes instances initialization
-	{
-		if (hero->getOwner() == PlayerColor::UNFLAGGABLE)
-		{
-            logGlobal->warnStream() << "Warning - hero with uninitialized owner!";
-			continue;
-		}
-
-		hero->initHero();
-		getPlayer(hero->getOwner())->heroes.push_back(hero);
-		map->allHeroes[hero->type->ID.getNum()] = hero;
-	}
-
-	for(auto obj : map->objects) //prisons
-	{
-		if(obj && obj->ID == Obj::PRISON)
-			map->allHeroes[obj->subID] = dynamic_cast<CGHeroInstance*>(obj.get());
-	}
-
-	std::set<HeroTypeID> heroesToCreate = getUnusedAllowedHeroes(); //ids of heroes to be created and put into the pool
-	for(auto ph : map->predefinedHeroes)
-	{
-		if(!vstd::contains(heroesToCreate, HeroTypeID(ph->subID)))
-			continue;
-		ph->initHero();
-		hpool.heroesPool[ph->subID] = ph;
-		hpool.pavailable[ph->subID] = 0xff;
-		heroesToCreate.erase(ph->type->ID);
-
-		map->allHeroes[ph->subID] = ph;
-	}
-
-	for(HeroTypeID htype : heroesToCreate) //all not used allowed heroes go with default state into the pool
-	{
-		auto  vhi = new CGHeroInstance();
-		vhi->initHero(htype);
-
-		int typeID = htype.getNum();
-		map->allHeroes[typeID] = vhi;
-		hpool.heroesPool[typeID] = vhi;
-		hpool.pavailable[typeID] = 0xff;
-	}
-
-	for(auto & elem : map->disposedHeroes)
-	{
-        hpool.pavailable[elem.heroId] = elem.players;
-	}
-
-	if (scenarioOps->mode == StartInfo::CAMPAIGN) //give campaign bonuses for specific / best hero
-	{
-		auto chosenBonus = scenarioOps->campState->getBonusForCurrentMap();
-		if (chosenBonus && chosenBonus->isBonusForHero() && chosenBonus->info1 != 0xFFFE) //exclude generated heroes
-		{
-			//find human player
-			PlayerColor humanPlayer=PlayerColor::NEUTRAL;
-			for (auto & elem : players)
-			{
-				if(elem.second.human)
-				{
-					humanPlayer = elem.first;
-					break;
-				}
-			}
-			assert(humanPlayer != PlayerColor::NEUTRAL);
-
-			std::vector<ConstTransitivePtr<CGHeroInstance> > & heroes = players[humanPlayer].heroes;
-
-			if (chosenBonus->info1 == 0xFFFD) //most powerful
-			{
-				int maxB = -1;
-				for (int b=0; b<heroes.size(); ++b)
-				{
-					if (maxB == -1 || heroes[b]->getTotalStrength() > heroes[maxB]->getTotalStrength())
-					{
-						maxB = b;
-					}
-				}
-				if(maxB < 0)
-                    logGlobal->warnStream() << "Warning - cannot give bonus to hero cause there are no heroes!";
-				else
-					giveCampaignBonusToHero(heroes[maxB]);
-			}
-			else //specific hero
-			{
-				for (auto & heroe : heroes)
-				{
-					if (heroe->subID == chosenBonus->info1)
-					{
-						giveCampaignBonusToHero(heroe);
-						break;
-					}
-				}
-			}
-		}
-	}
-
-	/*************************FOG**OF**WAR******************************************/
-    logGlobal->debugStream() << "\tFog of war"; //FIXME: should be initialized after all bonuses are set
-	for(auto & elem : teams)
-	{
-		elem.second.fogOfWarMap.resize(map->width);
-		for(int g=0; g<map->width; ++g)
-			elem.second.fogOfWarMap[g].resize(map->height);
-
-		for(int g=-0; g<map->width; ++g)
-			for(int h=0; h<map->height; ++h)
-				elem.second.fogOfWarMap[g][h].resize(map->twoLevel ? 2 : 1, 0);
-
-		for(int g=0; g<map->width; ++g)
-			for(int h=0; h<map->height; ++h)
-				for(int v = 0; v < (map->twoLevel ? 2 : 1); ++v)
-					elem.second.fogOfWarMap[g][h][v] = 0;
-
-		for(CGObjectInstance *obj : map->objects)
-		{
-			if(!obj || !vstd::contains(elem.second.players, obj->tempOwner)) continue; //not a flagged object
-
-			std::unordered_set<int3, ShashInt3> tiles;
-			obj->getSightTiles(tiles);
-			for(int3 tile : tiles)
-			{
-				elem.second.fogOfWarMap[tile.x][tile.y][tile.z] = 1;
-			}
-		}
-	}
-
-    logGlobal->debugStream() << "\tStarting bonuses";
-	for(auto & elem : players)
-	{
-		//starting bonus
-		if(scenarioOps->playerInfos[elem.first].bonus==PlayerSettings::RANDOM)
-			scenarioOps->playerInfos[elem.first].bonus = static_cast<PlayerSettings::Ebonus>(ran()%3);
-		switch(scenarioOps->playerInfos[elem.first].bonus)
-		{
-		case PlayerSettings::GOLD:
-			elem.second.resources[Res::GOLD] += 500 + (ran()%6)*100;
-			break;
-		case PlayerSettings::RESOURCE:
-			{
-				int res = VLC->townh->factions[scenarioOps->playerInfos[elem.first].castle]->town->primaryRes;
-				if(res == Res::WOOD_AND_ORE)
-				{
-					elem.second.resources[Res::WOOD] += 5 + ran()%6;
-					elem.second.resources[Res::ORE] += 5 + ran()%6;
-				}
-				else
-				{
-					elem.second.resources[res] += 3 + ran()%4;
-				}
-				break;
-			}
-		case PlayerSettings::ARTIFACT:
-			{
- 				if(!elem.second.heroes.size())
-				{
-                    logGlobal->debugStream() << "Cannot give starting artifact - no heroes!";
-					break;
-				}
- 				CArtifact *toGive;
- 				toGive = VLC->arth->artifacts[VLC->arth->getRandomArt (CArtifact::ART_TREASURE)];
-
-				CGHeroInstance *hero = elem.second.heroes[0];
- 				giveHeroArtifact(hero, toGive->id);
-			}
-			break;
-		}
-	}
-	/****************************TOWNS************************************************/
-    logGlobal->debugStream() << "\tTowns";
-
-	//campaign bonuses for towns
-	if (scenarioOps->mode == StartInfo::CAMPAIGN)
-	{
-		auto chosenBonus = scenarioOps->campState->getBonusForCurrentMap();
-
-		if (chosenBonus && chosenBonus->type == CScenarioTravel::STravelBonus::BUILDING)
-		{
-			for (int g=0; g<map->towns.size(); ++g)
-			{
-				PlayerState * owner = getPlayer(map->towns[g]->getOwner());
-				if (owner)
-				{
-					PlayerInfo & pi = map->players[owner->color.getNum()];
-
-					if (owner->human && //human-owned
-						map->towns[g]->pos == pi.posOfMainTown + int3(2, 0, 0))
-					{
-						map->towns[g]->builtBuildings.insert(
-							CBuildingHandler::campToERMU(chosenBonus->info1, map->towns[g]->subID, map->towns[g]->builtBuildings));
-						break;
-					}
-				}
-			}
-		}
-	}
-
-	CGTownInstance::universitySkills.clear();
-	for ( int i=0; i<4; i++)
-		CGTownInstance::universitySkills.push_back(14+i);//skills for university
-
-	for (auto & elem : map->towns)
-	{
-		CGTownInstance * vti =(elem);
-		if(!vti->town)
-			vti->town = VLC->townh->factions[vti->subID]->town;
-		if (vti->name.length()==0) // if town hasn't name we draw it
-			vti->name = vti->town->names[ran()%vti->town->names.size()];
-
-		//init buildings
-		if(vstd::contains(vti->builtBuildings, BuildingID::DEFAULT)) //give standard set of buildings
-		{
-			vti->builtBuildings.erase(BuildingID::DEFAULT);
-			vti->builtBuildings.insert(BuildingID::VILLAGE_HALL);
-			vti->builtBuildings.insert(BuildingID::TAVERN);
-			vti->builtBuildings.insert(BuildingID::DWELL_FIRST);
-			if(ran()%2)
-				vti->builtBuildings.insert(BuildingID::DWELL_LVL_2);
-		}
-
-		//#1444 - remove entries that don't have buildings defined (like some unused extra town hall buildings)
-		vstd::erase_if(vti->builtBuildings, [vti](BuildingID bid){  
-			return !vti->town->buildings.count(bid) || !vti->town->buildings.at(bid); });
-
-		if (vstd::contains(vti->builtBuildings, BuildingID::SHIPYARD) && vti->shipyardStatus()==IBoatGenerator::TILE_BLOCKED)
-			vti->builtBuildings.erase(BuildingID::SHIPYARD);//if we have harbor without water - erase it (this is H3 behaviour)
-
-		//init hordes
-		for (int i = 0; i<GameConstants::CREATURES_PER_TOWN; i++)
-			if (vstd::contains(vti->builtBuildings,(-31-i))) //if we have horde for this level
-			{
-				vti->builtBuildings.erase(BuildingID(-31-i));//remove old ID
-				if (vti->town->hordeLvl[0] == i)//if town first horde is this one
-				{
-					vti->builtBuildings.insert(BuildingID::HORDE_1);//add it
-					if (vstd::contains(vti->builtBuildings,(BuildingID::DWELL_UP_FIRST+i)))//if we have upgraded dwelling as well
-						vti->builtBuildings.insert(BuildingID::HORDE_1_UPGR);//add it as well
-				}
-				if (vti->town->hordeLvl[1] == i)//if town second horde is this one
-				{
-					vti->builtBuildings.insert(BuildingID::HORDE_2);
-					if (vstd::contains(vti->builtBuildings,(BuildingID::DWELL_UP_FIRST+i)))
-						vti->builtBuildings.insert(BuildingID::HORDE_2_UPGR);
-				}
-			}
-
-		//Early check for #1444-like problems
-		for(auto building : vti->builtBuildings)
-		{
-			assert(vti->town->buildings[building]);
-			UNUSED(building);
-		}
-
-		//town events
-		for(CCastleEvent &ev : vti->events)
-		{
-			for (int i = 0; i<GameConstants::CREATURES_PER_TOWN; i++)
-				if (vstd::contains(ev.buildings,(-31-i))) //if we have horde for this level
-				{
-					ev.buildings.erase(BuildingID(-31-i));
-					if (vti->town->hordeLvl[0] == i)
-						ev.buildings.insert(BuildingID::HORDE_1);
-					if (vti->town->hordeLvl[1] == i)
-						ev.buildings.insert(BuildingID::HORDE_2);
-				}
-		}
-		//init spells
-		vti->spells.resize(GameConstants::SPELL_LEVELS);
-
-		for(ui32 z=0; z<vti->obligatorySpells.size();z++)
-		{
-			CSpell *s = vti->obligatorySpells[z].toSpell();
-			vti->spells[s->level-1].push_back(s->id);
-			vti->possibleSpells -= s->id;
-		}
-		while(vti->possibleSpells.size())
-		{
-			ui32 total=0;
-			int sel = -1;
-
-			for(ui32 ps=0;ps<vti->possibleSpells.size();ps++)
-				total += vti->possibleSpells[ps].toSpell()->probabilities[vti->subID];
-
-			if (total == 0) // remaining spells have 0 probability
-				break;
-
-			int r = ran()%total;
-			for(ui32 ps=0; ps<vti->possibleSpells.size();ps++)
-			{
-				r -= vti->possibleSpells[ps].toSpell()->probabilities[vti->subID];
-				if(r<0)
-				{
-					sel = ps;
-					break;
-				}
-			}
-			if(sel<0)
-				sel=0;
-
-			CSpell *s = vti->possibleSpells[sel].toSpell();
-			vti->spells[s->level-1].push_back(s->id);
-			vti->possibleSpells -= s->id;
-		}
-		vti->possibleSpells.clear();
-		if(vti->getOwner() != PlayerColor::NEUTRAL)
-			getPlayer(vti->getOwner())->towns.push_back(vti);
-	}
-
-    logGlobal->debugStream() << "\tObject initialization";
-	objCaller->preInit();
-	for(CGObjectInstance *obj : map->objects)
-	{
-		if(obj)
-			obj->initObj();
-	}
-	for(CGObjectInstance *obj : map->objects)
-	{
-		if(!obj)
-			continue;
-
-		switch (obj->ID)
-		{
-			case Obj::QUEST_GUARD:
-			case Obj::SEER_HUT:
-			{
-				auto q = static_cast<CGSeerHut*>(obj);
-				assert (q);
-				q->setObjToKill();
-			}
-		}
-	}
-	CGTeleport::postInit(); //pairing subterranean gates
-
-	buildBonusSystemTree();
-
-	for(auto k=players.begin(); k!=players.end(); ++k)
-	{
-		if(k->first==PlayerColor::NEUTRAL)
-			continue;
-
-		//init visiting and garrisoned heroes
-		for(CGHeroInstance *h : k->second.heroes)
-		{
-			for(CGTownInstance *t : k->second.towns)
-			{
-				int3 vistile = t->pos; vistile.x--; //tile next to the entrance
-				if(vistile == h->pos || h->pos==t->pos)
-				{
-					t->setVisitingHero(h);
-					if(h->pos == t->pos) //visiting hero placed in the editor has same pos as the town - we need to correct it
-					{
-						map->removeBlockVisTiles(h);
-						h->pos.x -= 1;
-						map->addBlockVisTiles(h);
-					}
-					break;
-				}
-			}
-		}
-	}
-
-
-    logGlobal->debugStream() << "\tChecking objectives";
-	map->checkForObjectives(); //needs to be run when all objects are properly placed
-
-	int seedAfterInit = ran();
-    logGlobal->infoStream() << "Seed after init is " << seedAfterInit << " (before was " << scenarioOps->seedToBeUsed << ")";
-	if(scenarioOps->seedPostInit > 0)
-	{
-		//RNG must be in the same state on all machines when initialization is done (otherwise we have desync)
-		assert(scenarioOps->seedPostInit == seedAfterInit);
-	}
-	else
-	{
-		scenarioOps->seedPostInit = seedAfterInit; //store the post init "seed"
-	}
-}
-
-void CGameState::initDuel()
-{
-	DuelParameters dp;
-	try //CLoadFile likes throwing
-	{
-		if(boost::algorithm::ends_with(scenarioOps->mapname, ".json"))
-		{
-            logGlobal->infoStream() << "Loading duel settings from JSON file: " << scenarioOps->mapname;
-			dp = DuelParameters::fromJSON(scenarioOps->mapname);
-            logGlobal->infoStream() << "JSON file has been successfully read!";
-		}
-		else
-		{
-			CLoadFile lf(scenarioOps->mapname);
-			lf >> dp;
-		}
-	}
-	catch(...)
-	{
-        logGlobal->errorStream() << "Cannot load duel settings from " << scenarioOps->mapname;
-		throw;
-	}
-
-	const CArmedInstance *armies[2] = {nullptr};
-	const CGHeroInstance *heroes[2] = {nullptr};
-	CGTownInstance *town = nullptr;
-
-	for(int i = 0; i < 2; i++)
-	{
-		CArmedInstance *obj = nullptr;
-		if(dp.sides[i].heroId >= 0)
-		{
-			const DuelParameters::SideSettings &ss = dp.sides[i];
-			auto h = new CGHeroInstance();
-			armies[i] = heroes[i] = h;
-			obj = h;
-			h->subID = ss.heroId;
-			for(int i = 0; i < ss.heroPrimSkills.size(); i++)
-				h->pushPrimSkill(static_cast<PrimarySkill::PrimarySkill>(i), ss.heroPrimSkills[i]);
-
-			if(!ss.spells.empty())
-			{
-				h->putArtifact(ArtifactPosition::SPELLBOOK, CArtifactInstance::createNewArtifactInstance(0));
-				boost::copy(ss.spells, std::inserter(h->spells, h->spells.begin()));
-			}
-
-			for(auto &parka : ss.artifacts)
-			{
-				h->putArtifact(ArtifactPosition(parka.first), parka.second);
-			}
-
-			typedef const std::pair<si32, si8> &TSecSKill;
-			for(TSecSKill secSkill : ss.heroSecSkills)
-				h->setSecSkillLevel(SecondarySkill(secSkill.first), secSkill.second, 1);
-
-			h->initHero(HeroTypeID(h->subID));
-			obj->initObj();
-		}
-		else
-		{
-			auto c = new CGCreature();
-			armies[i] = obj = c;
-			//c->subID = 34;
-		}
-
-		obj->setOwner(PlayerColor(i));
-
-		for(int j = 0; j < ARRAY_COUNT(dp.sides[i].stacks); j++)
-		{
-			CreatureID cre = dp.sides[i].stacks[j].type;
-			TQuantity count = dp.sides[i].stacks[j].count;
-			if(count || obj->hasStackAtSlot(SlotID(j)))
-				obj->setCreature(SlotID(j), cre, count);
-		}
-
-		for(const DuelParameters::CusomCreature &cc : dp.creatures)
-		{
-			CCreature *c = VLC->creh->creatures[cc.id];
-			if(cc.attack >= 0)
-				c->getBonusLocalFirst(Selector::typeSubtype(Bonus::PRIMARY_SKILL, PrimarySkill::ATTACK))->val = cc.attack;
-			if(cc.defense >= 0)
-				c->getBonusLocalFirst(Selector::typeSubtype(Bonus::PRIMARY_SKILL, PrimarySkill::DEFENSE))->val = cc.defense;
-			if(cc.speed >= 0)
-				c->getBonusLocalFirst(Selector::type(Bonus::STACKS_SPEED))->val = cc.speed;
-			if(cc.HP >= 0)
-				c->getBonusLocalFirst(Selector::type(Bonus::STACK_HEALTH))->val = cc.HP;
-			if(cc.dmg >= 0)
-			{
-				c->getBonusLocalFirst(Selector::typeSubtype(Bonus::CREATURE_DAMAGE, 1))->val = cc.dmg;
-				c->getBonusLocalFirst(Selector::typeSubtype(Bonus::CREATURE_DAMAGE, 2))->val = cc.dmg;
-			}
-			if(cc.shoots >= 0)
-				c->getBonusLocalFirst(Selector::type(Bonus::SHOTS))->val = cc.shoots;
-		}
-	}
-
-	curB = BattleInfo::setupBattle(int3(), dp.terType, dp.bfieldType, armies, heroes, false, town);
-	curB->obstacles = dp.obstacles;
-	curB->localInit();
-	return;
-}
-
-BFieldType CGameState::battleGetBattlefieldType(int3 tile) const
-{
-	if(tile==int3() && curB)
-		tile = curB->tile;
-	else if(tile==int3() && !curB)
-		return BFieldType::NONE;
-
-	const TerrainTile &t = map->getTile(tile);
-	//fight in mine -> subterranean
-	if(dynamic_cast<const CGMine *>(t.visitableObjects.front()))
-		return BFieldType::SUBTERRANEAN;
-
-	for(auto &obj : map->objects)
-	{
-		//look only for objects covering given tile
-		if( !obj || obj->pos.z != tile.z
-		  || !obj->coveringAt(tile.x - obj->pos.x, tile.y - obj->pos.y))
-			continue;
-
-		switch(obj->ID)
-		{
-		case Obj::CLOVER_FIELD:
-			return BFieldType::CLOVER_FIELD;
-		case Obj::CURSED_GROUND1: case Obj::CURSED_GROUND2:
-			return BFieldType::CURSED_GROUND;
-		case Obj::EVIL_FOG:
-			return BFieldType::EVIL_FOG;
-		case Obj::FAVORABLE_WINDS:
-			return BFieldType::FAVOURABLE_WINDS;
-		case Obj::FIERY_FIELDS:
-			return BFieldType::FIERY_FIELDS;
-		case Obj::HOLY_GROUNDS:
-			return BFieldType::HOLY_GROUND;
-		case Obj::LUCID_POOLS:
-			return BFieldType::LUCID_POOLS;
-		case Obj::MAGIC_CLOUDS:
-			return BFieldType::MAGIC_CLOUDS;
-		case Obj::MAGIC_PLAINS1: case Obj::MAGIC_PLAINS2:
-			return BFieldType::MAGIC_PLAINS;
-		case Obj::ROCKLANDS:
-			return BFieldType::ROCKLANDS;
-		}
-	}
-
-	if(!t.isWater() && t.isCoastal())
-		return BFieldType::SAND_SHORE;
-
-    switch(t.terType)
-	{
-    case ETerrainType::DIRT:
-		return BFieldType(rand()%3+3);
-    case ETerrainType::SAND:
-		return BFieldType::SAND_MESAS; //TODO: coast support
-    case ETerrainType::GRASS:
-		return BFieldType(rand()%2+6);
-    case ETerrainType::SNOW:
-		return BFieldType(rand()%2+10);
-    case ETerrainType::SWAMP:
-		return BFieldType::SWAMP_TREES;
-    case ETerrainType::ROUGH:
-		return BFieldType::ROUGH;
-    case ETerrainType::SUBTERRANEAN:
-		return BFieldType::SUBTERRANEAN;
-    case ETerrainType::LAVA:
-		return BFieldType::LAVA;
-    case ETerrainType::WATER:
-		return BFieldType::SHIP;
-    case ETerrainType::ROCK:
-		return BFieldType::ROCKLANDS;
-	default:
-		return BFieldType::NONE;
-	}
-}
-
-UpgradeInfo CGameState::getUpgradeInfo(const CStackInstance &stack)
-{
-	UpgradeInfo ret;
-	const CCreature *base = stack.type;
-
-	const CGHeroInstance *h = stack.armyObj->ID == Obj::HERO ? static_cast<const CGHeroInstance*>(stack.armyObj) : nullptr;
-	const CGTownInstance *t = nullptr;
-
-	if(stack.armyObj->ID == Obj::TOWN)
-		t = static_cast<const CGTownInstance *>(stack.armyObj);
-	else if(h)
-	{	//hero specialty
-		TBonusListPtr lista = h->getBonuses(Selector::typeSubtype(Bonus::SPECIAL_UPGRADE, base->idNumber));
-		for(const Bonus *it : *lista)
-		{
-			auto nid = CreatureID(it->additionalInfo);
-			if (nid != base->idNumber) //in very specific case the upgrade is available by default (?)
-			{
-				ret.newID.push_back(nid);
-				ret.cost.push_back(VLC->creh->creatures[nid]->cost - base->cost);
-			}
-		}
-		t = h->visitedTown;
-	}
-	if(t)
-	{
-		for(const CGTownInstance::TCreaturesSet::value_type & dwelling : t->creatures)
-		{
-			if (vstd::contains(dwelling.second, base->idNumber)) //Dwelling with our creature
-			{
-				for(auto upgrID : dwelling.second)
-				{
-					if(vstd::contains(base->upgrades, upgrID)) //possible upgrade
-					{
-						ret.newID.push_back(upgrID);
-						ret.cost.push_back(VLC->creh->creatures[upgrID]->cost - base->cost);
-					}
-				}
-			}
-		}
-	}
-
-	//hero is visiting Hill Fort
-	if(h && map->getTile(h->visitablePos()).visitableObjects.front()->ID == Obj::HILL_FORT)
-	{
-		static const int costModifiers[] = {0, 25, 50, 75, 100}; //we get cheaper upgrades depending on level
-		const int costModifier = costModifiers[std::min<int>(std::max((int)base->level - 1, 0), ARRAY_COUNT(costModifiers) - 1)];
-
-		for(auto nid : base->upgrades)
-		{
-			ret.newID.push_back(nid);
-			ret.cost.push_back((VLC->creh->creatures[nid]->cost - base->cost) * costModifier / 100);
-		}
-	}
-
-	if(ret.newID.size())
-		ret.oldID = base->idNumber;
-
-	for (Res::ResourceSet &cost : ret.cost)
-		cost.positive(); //upgrade cost can't be negative, ignore missing resources
-
-	return ret;
-}
-
-PlayerRelations::PlayerRelations CGameState::getPlayerRelations( PlayerColor color1, PlayerColor color2 )
-{
-	if ( color1 == color2 )
-		return PlayerRelations::SAME_PLAYER;
-	if(color1 == PlayerColor::NEUTRAL || color2 == PlayerColor::NEUTRAL) //neutral player has no friends
-		return PlayerRelations::ENEMIES;
-
-	const TeamState * ts = getPlayerTeam(color1);
-	if (ts && vstd::contains(ts->players, color2))
-		return PlayerRelations::ALLIES;
-	return PlayerRelations::ENEMIES;
-}
-
-void CGameState::getNeighbours(const TerrainTile &srct, int3 tile, std::vector<int3> &vec, const boost::logic::tribool &onLand, bool limitCoastSailing)
-{
-	static const 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)
-	{
-		const int3 hlp = tile + dir;
-		if(!map->isInTheMap(hlp))
-			continue;
-
-		const TerrainTile &hlpt = map->getTile(hlp);
-
-// 		//we cannot visit things from blocked tiles
-// 		if(srct.blocked && !srct.visitable && hlpt.visitable && srct.blockingObjects.front()->ID != HEROI_TYPE)
-// 		{
-// 			continue;
-// 		}
-
-        if(srct.terType == ETerrainType::WATER && limitCoastSailing && hlpt.terType == ETerrainType::WATER && dir.x && dir.y) //diagonal move through water
-		{
-			int3 hlp1 = tile,
-				hlp2 = tile;
-			hlp1.x += dir.x;
-			hlp2.y += dir.y;
-
-            if(map->getTile(hlp1).terType != ETerrainType::WATER || map->getTile(hlp2).terType != ETerrainType::WATER)
-				continue;
-		}
-
-        if((indeterminate(onLand)  ||  onLand == (hlpt.terType!=ETerrainType::WATER) )
-            && hlpt.terType != ETerrainType::ROCK)
-		{
-			vec.push_back(hlp);
-		}
-	}
-}
-
-int CGameState::getMovementCost(const CGHeroInstance *h, const int3 &src, const int3 &dest, int remainingMovePoints, bool checkLast)
-{
-	if(src == dest) //same tile
-		return 0;
-
-	TerrainTile &s = map->getTile(src),
-		&d = map->getTile(dest);
-
-	//get basic cost
-	int ret = h->getTileCost(d,s);
-
-	if(d.blocked && h->hasBonusOfType(Bonus::FLYING_MOVEMENT))
-	{
-		bool freeFlying = h->getBonusesCount(Selector::typeSubtype(Bonus::FLYING_MOVEMENT, 1)) > 0;
-
-		if(!freeFlying)
-		{
-			ret *= 1.4; //40% penalty for movement over blocked tile
-		}
-	}
-    else if (d.terType == ETerrainType::WATER)
-	{
-		if(h->boat && s.hasFavourableWinds() && d.hasFavourableWinds()) //Favourable Winds
-			ret *= 0.666;
-		else if (!h->boat && h->getBonusesCount(Selector::typeSubtype(Bonus::WATER_WALKING, 1)) > 0)
-			ret *= 1.4; //40% penalty for water walking
-	}
-
-	if(src.x != dest.x  &&  src.y != dest.y) //it's diagonal move
-	{
-		int old = ret;
-		ret *= 1.414213;
-		//diagonal move costs too much but normal move is possible - allow diagonal move for remaining move points
-		if(ret > remainingMovePoints  &&  remainingMovePoints >= old)
-		{
-			return remainingMovePoints;
-		}
-	}
-
-
-	int left = remainingMovePoints-ret;
-	if(checkLast  &&  left > 0  &&  remainingMovePoints-ret < 250) //it might be the last tile - if no further move possible we take all move points
-	{
-		std::vector<int3> vec;
-        getNeighbours(d, dest, vec, s.terType != ETerrainType::WATER, true);
-		for(auto & elem : vec)
-		{
-			int fcost = getMovementCost(h,dest,elem,left,false);
-			if(fcost <= left)
-			{
-				return ret;
-			}
-		}
-		ret = remainingMovePoints;
-	}
-	return ret;
-}
-
-void CGameState::apply(CPack *pack)
-{
-	ui16 typ = typeList.getTypeID(pack);
-	applierGs->apps[typ]->applyOnGS(this,pack);
-}
-
-void CGameState::calculatePaths(const CGHeroInstance *hero, CPathsInfo &out, int3 src, int movement)
-{
-	CPathfinder pathfinder(out, this, hero);
-	pathfinder.calculatePaths(src, movement);
-}
-
-/**
- * Tells if the tile is guarded by a monster as well as the position
- * of the monster that will attack on it.
- *
- * @return int3(-1, -1, -1) if the tile is unguarded, or the position of
- * the monster guarding the tile.
- */
-std::vector<CGObjectInstance*> CGameState::guardingCreatures (int3 pos) const
-{
-	std::vector<CGObjectInstance*> guards;
-	const int3 originalPos = pos;
-	if (!map->isInTheMap(pos))
-		return guards;
-
-	const TerrainTile &posTile = map->getTile(pos);
-	if (posTile.visitable)
-	{
-		for (CGObjectInstance* obj : posTile.visitableObjects)
-		{
-			if(obj->blockVisit)
-			{
-				if (obj->ID == Obj::MONSTER) // Monster
-					guards.push_back(obj);
-			}
-		}
-	}
-	pos -= int3(1, 1, 0); // Start with top left.
-	for (int dx = 0; dx < 3; dx++)
-	{
-		for (int dy = 0; dy < 3; dy++)
-		{
-			if (map->isInTheMap(pos))
-			{
-				const auto & tile = map->getTile(pos);
-                if (tile.visitable && (tile.isWater() == posTile.isWater()))
-				{
-					for (CGObjectInstance* obj : tile.visitableObjects)
-					{
-						if (obj->ID == Obj::MONSTER  &&  checkForVisitableDir(pos, &map->getTile(originalPos), originalPos)) // Monster being able to attack investigated tile
-						{
-							guards.push_back(obj);
-						}
-					}
-				}
-			}
-
-			pos.y++;
-		}
-		pos.y -= 3;
-		pos.x++;
-	}
-	return guards;
-
-}
-
-int3 CGameState::guardingCreaturePosition (int3 pos) const
-{
-	const int3 originalPos = pos;
-	// Give monster at position priority.
-	if (!map->isInTheMap(pos))
-		return int3(-1, -1, -1);
-	const TerrainTile &posTile = map->getTile(pos);
-	if (posTile.visitable)
-	{
-		for (CGObjectInstance* obj : posTile.visitableObjects)
-		{
-			if(obj->blockVisit)
-			{
-				if (obj->ID == Obj::MONSTER) // Monster
-					return pos;
-				else
-					return int3(-1, -1, -1); //blockvis objects are not guarded by neighbouring creatures
-			}
-		}
-	}
-
-	// See if there are any monsters adjacent.
-	pos -= int3(1, 1, 0); // Start with top left.
-	for (int dx = 0; dx < 3; dx++)
-	{
-		for (int dy = 0; dy < 3; dy++)
-		{
-			if (map->isInTheMap(pos))
-			{
-				const auto & tile = map->getTile(pos);
-                if (tile.visitable && (tile.isWater() == posTile.isWater()))
-				{
-					for (CGObjectInstance* obj : tile.visitableObjects)
-					{
-						if (obj->ID == Obj::MONSTER  &&  checkForVisitableDir(pos, &map->getTile(originalPos), originalPos)) // Monster being able to attack investigated tile
-						{
-							return pos;
-						}
-					}
-				}
-			}
-
-			pos.y++;
-		}
-		pos.y -= 3;
-		pos.x++;
-	}
-
-	return int3(-1, -1, -1);
-}
-
-bool CGameState::isVisible(int3 pos, PlayerColor player)
-{
-	if(player == PlayerColor::NEUTRAL)
-		return false;
-	return getPlayerTeam(player)->fogOfWarMap[pos.x][pos.y][pos.z];
-}
-
-bool CGameState::isVisible( const CGObjectInstance *obj, boost::optional<PlayerColor> player )
-{
-	if(!player)
-		return true;
-
-	if(*player == PlayerColor::NEUTRAL) //-> TODO ??? needed?
-		return false;
-	//object is visible when at least one blocked tile is visible
-	for(int fx=0; fx<8; ++fx)
-	{
-		for(int fy=0; fy<6; ++fy)
-		{
-			int3 pos = obj->pos + int3(fx-7,fy-5,0);
-			if(map->isInTheMap(pos)
-				&& !((obj->defInfo->blockMap[fy] >> (7 - fx)) & 1)
-				&& isVisible(pos, *player)  )
-				return true;
-		}
-	}
-	return false;
-}
-
-bool CGameState::checkForVisitableDir(const int3 & src, const int3 & dst) const
-{
-	const TerrainTile * pom = &map->getTile(dst);
-	return checkForVisitableDir(src, pom, dst);
-}
-
-bool CGameState::checkForVisitableDir( const int3 & src, const TerrainTile *pom, const int3 & dst ) const
-{
-	for(ui32 b=0; b<pom->visitableObjects.size(); ++b) //checking destination tile
-	{
-		if(!vstd::contains(pom->blockingObjects, pom->visitableObjects[b])) //this visitable object is not blocking, ignore
-			continue;
-
-		CGDefInfo * di = pom->visitableObjects[b]->defInfo;
-		if( (dst.x == src.x-1 && dst.y == src.y-1) && !(di->visitDir & (1<<4)) )
-		{
-			return false;
-		}
-		if( (dst.x == src.x && dst.y == src.y-1) && !(di->visitDir & (1<<5)) )
-		{
-			return false;
-		}
-		if( (dst.x == src.x+1 && dst.y == src.y-1) && !(di->visitDir & (1<<6)) )
-		{
-			return false;
-		}
-		if( (dst.x == src.x+1 && dst.y == src.y) && !(di->visitDir & (1<<7)) )
-		{
-			return false;
-		}
-		if( (dst.x == src.x+1 && dst.y == src.y+1) && !(di->visitDir & (1<<0)) )
-		{
-			return false;
-		}
-		if( (dst.x == src.x && dst.y == src.y+1) && !(di->visitDir & (1<<1)) )
-		{
-			return false;
-		}
-		if( (dst.x == src.x-1 && dst.y == src.y+1) && !(di->visitDir & (1<<2)) )
-		{
-			return false;
-		}
-		if( (dst.x == src.x-1 && dst.y == src.y) && !(di->visitDir & (1<<3)) )
-		{
-			return false;
-		}
-	}
-	return true;
-}
-
-
-int CGameState::victoryCheck( PlayerColor player ) const
-{
-	const PlayerState *p = CGameInfoCallback::getPlayer(player);
-	if(map->victoryCondition.condition == EVictoryConditionType::WINSTANDARD  ||  map->victoryCondition.allowNormalVictory
-		|| (!p->human && !map->victoryCondition.appliesToAI)) //if the special victory condition applies only to human, AI has the standard)
-	{
-		if(player == checkForStandardWin())
-			return -1;
-	}
-
-	if (p->enteredWinningCheatCode)
-	{ //cheater or tester, but has entered the code...
-		if(map->victoryCondition.condition == EVictoryConditionType::WINSTANDARD)
-			return -1;
-		else
-			return 1;
-	}
-
-	if(p->human || map->victoryCondition.appliesToAI)
-	{
- 		switch(map->victoryCondition.condition)
-		{
-		case EVictoryConditionType::ARTIFACT:
-			//check if any hero has winning artifact
-			for(auto & elem : p->heroes)
-                if(elem->hasArt(map->victoryCondition.objectId))
-					return 1;
-
-			break;
-
-		case EVictoryConditionType::GATHERTROOP:
-			{
-				//check if in players armies there is enough creatures
-				int total = 0; //creature counter
-				for(size_t i = 0; i < map->objects.size(); i++)
-				{
-					const CArmedInstance *ai = nullptr;
-					if(map->objects[i]
-						&& map->objects[i]->tempOwner == player //object controlled by player
-						&&  (ai = dynamic_cast<const CArmedInstance*>(map->objects[i].get()))) //contains army
-					{
-						for(auto & elem : ai->Slots()) //iterate through army
-                            if(elem.second->type->idNumber == map->victoryCondition.objectId) //it's searched creature
-								total += elem.second->count;
-					}
-				}
-
-				if(total >= map->victoryCondition.count)
-					return 1;
-			}
-			break;
-
-		case EVictoryConditionType::GATHERRESOURCE:
-            if(p->resources[map->victoryCondition.objectId] >= map->victoryCondition.count)
-				return 1;
-
-			break;
-
-		case EVictoryConditionType::BUILDCITY:
-			{
-				const CGTownInstance *t = static_cast<const CGTownInstance *>(map->victoryCondition.obj);
-                if(t->tempOwner == player && t->fortLevel()-1 >= map->victoryCondition.objectId && t->hallLevel()-1 >= map->victoryCondition.count)
-					return 1;
-			}
-			break;
-
-		case EVictoryConditionType::BUILDGRAIL:
-			for(const CGTownInstance *t : map->towns)
-				if((t == map->victoryCondition.obj || !map->victoryCondition.obj)
-					&& t->tempOwner == player
-					&& t->hasBuilt(BuildingID::GRAIL))
-					return 1;
-			break;
-
-		case EVictoryConditionType::BEATHERO:
-			if(map->victoryCondition.obj->tempOwner >= PlayerColor::PLAYER_LIMIT) //target hero not present on map
-				return 1;
-			break;
-		case EVictoryConditionType::CAPTURECITY:
-			{
-				if(map->victoryCondition.obj->tempOwner == player)
-					return 1;
-			}
-			break;
-		case EVictoryConditionType::BEATMONSTER:
-			if(!getObj(map->victoryCondition.obj->id)) //target monster not present on map
-				return 1;
-			break;
-		case EVictoryConditionType::TAKEDWELLINGS:
-			for(auto & elem : map->objects)
-			{
-				if(elem && elem->tempOwner != player) //check not flagged objs
-				{
-					switch(elem->ID)
-					{
-					case Obj::CREATURE_GENERATOR1: case Obj::CREATURE_GENERATOR2:
-					case Obj::CREATURE_GENERATOR3: case Obj::CREATURE_GENERATOR4:
-					case Obj::RANDOM_DWELLING: case Obj::RANDOM_DWELLING_LVL: case Obj::RANDOM_DWELLING_FACTION:
-						return 0; //found not flagged dwelling - player not won
-					}
-				}
-			}
-			return 1;
-		case EVictoryConditionType::TAKEMINES:
-			for(auto & elem : map->objects)
-			{
-				if(elem && elem->tempOwner != player) //check not flagged objs
-				{
-					switch(elem->ID)
-					{
-					case Obj::MINE: case Obj::ABANDONED_MINE:
-						return 0; //found not flagged mine - player not won
-					}
-				}
-			}
-			return 1;
-		case EVictoryConditionType::TRANSPORTITEM:
-			{
-				const CGTownInstance *t = static_cast<const CGTownInstance *>(map->victoryCondition.obj);
-                if((t->visitingHero && t->visitingHero->hasArt(map->victoryCondition.objectId))
-                    || (t->garrisonHero && t->garrisonHero->hasArt(map->victoryCondition.objectId)))
-				{
-					return 1;
-				}
-			}
-			break;
- 		}
-	}
-
-	return 0;
-}
-
-PlayerColor CGameState::checkForStandardWin() const
-{
-	//std victory condition is:
-	//all enemies lost
-	PlayerColor supposedWinner = PlayerColor::NEUTRAL;
-	TeamID winnerTeam = TeamID::NO_TEAM;
-	for(auto & elem : players)
-	{
-		if(elem.second.status == EPlayerStatus::INGAME && elem.first < PlayerColor::PLAYER_LIMIT)
-		{
-			if(supposedWinner == PlayerColor::NEUTRAL)
-			{
-				//first player remaining ingame - candidate for victory
-				supposedWinner = elem.second.color;
-				winnerTeam = elem.second.team;
-			}
-			else if(winnerTeam != elem.second.team)
-			{
-				//current candidate has enemy remaining in game -> no vicotry
-				return PlayerColor::NEUTRAL;
-			}
-		}
-	}
-
-	return supposedWinner;
-}
-
-bool CGameState::checkForStandardLoss( PlayerColor player ) const
-{
-	//std loss condition is: player lost all towns and heroes
-	const PlayerState &p = *CGameInfoCallback::getPlayer(player);
-	return !p.heroes.size() && !p.towns.size();
-}
-
-struct statsHLP
-{
-	typedef std::pair< PlayerColor, si64 > TStat;
-	//converts [<player's color, value>] to vec[place] -> platers
-	static std::vector< std::vector< PlayerColor > > getRank( std::vector<TStat> stats )
-	{
-		std::sort(stats.begin(), stats.end(), statsHLP());
-
-		//put first element
-		std::vector< std::vector<PlayerColor> > ret;
-		std::vector<PlayerColor> tmp;
-		tmp.push_back( stats[0].first );
-		ret.push_back( tmp );
-
-		//the rest of elements
-		for(int g=1; g<stats.size(); ++g)
-		{
-			if(stats[g].second == stats[g-1].second)
-			{
-				(ret.end()-1)->push_back( stats[g].first );
-			}
-			else
-			{
-				//create next occupied rank
-				std::vector<PlayerColor> tmp;
-				tmp.push_back(stats[g].first);
-				ret.push_back(tmp);
-			}
-		}
-
-		return ret;
-	}
-
-	bool operator()(const TStat & a, const TStat & b) const
-	{
-		return a.second > b.second;
-	}
-
-	static const CGHeroInstance * findBestHero(CGameState * gs, PlayerColor color)
-	{
-		std::vector<ConstTransitivePtr<CGHeroInstance> > &h = gs->players[color].heroes;
-		if(!h.size())
-			return nullptr;
-		//best hero will be that with highest exp
-		int best = 0;
-		for(int b=1; b<h.size(); ++b)
-		{
-			if(h[b]->exp > h[best]->exp)
-			{
-				best = b;
-			}
-		}
-		return h[best];
-	}
-
-	//calculates total number of artifacts that belong to given player
-	static int getNumberOfArts(const PlayerState * ps)
-	{
-		int ret = 0;
-		for(auto h : ps->heroes)
-		{
-			ret += h->artifactsInBackpack.size() + h->artifactsWorn.size();
-		}
-		return ret;
-	}
-
-	// get total strength of player army
-	static si64 getArmyStrength(const PlayerState * ps)
-	{
-		si64 str = 0;
-
-		for(auto h : ps->heroes)
-		{
-			if(!h->inTownGarrison)		//original h3 behavior
-				str += h->getArmyStrength();
-		}
-		return str;
-	}
-};
-
-void CGameState::obtainPlayersStats(SThievesGuildInfo & tgi, int level)
-{
-#define FILL_FIELD(FIELD, VAL_GETTER) \
-	{ \
-		std::vector< std::pair< PlayerColor, si64 > > stats; \
-		for(auto g = players.begin(); g != players.end(); ++g) \
-		{ \
-			if(g->second.color == PlayerColor::NEUTRAL) \
-				continue; \
-			std::pair< PlayerColor, si64 > stat; \
-			stat.first = g->second.color; \
-			stat.second = VAL_GETTER; \
-			stats.push_back(stat); \
-		} \
-		tgi.FIELD = statsHLP::getRank(stats); \
-	}
-
-	for(auto & elem : players)
-	{
-		if(elem.second.color != PlayerColor::NEUTRAL)
-			tgi.playerColors.push_back(elem.second.color);
-	}
-
-	if(level >= 1) //num of towns & num of heroes
-	{
-		//num of towns
-		FILL_FIELD(numOfTowns, g->second.towns.size())
-		//num of heroes
-		FILL_FIELD(numOfHeroes, g->second.heroes.size())
-		//best hero's portrait
-		for(auto g = players.cbegin(); g != players.cend(); ++g)
-		{
-			if(g->second.color == PlayerColor::NEUTRAL)
-				continue;
-			const CGHeroInstance * best = statsHLP::findBestHero(this, g->second.color);
-			InfoAboutHero iah;
-			iah.initFromHero(best, level >= 8);
-			iah.army.clear();
-			tgi.colorToBestHero[g->second.color] = iah;
-		}
-	}
-	if(level >= 2) //gold
-	{
-		FILL_FIELD(gold, g->second.resources[Res::GOLD])
-	}
-	if(level >= 2) //wood & ore
-	{
-		FILL_FIELD(woodOre, g->second.resources[Res::WOOD] + g->second.resources[Res::ORE])
-	}
-	if(level >= 3) //mercury, sulfur, crystal, gems
-	{
-		FILL_FIELD(mercSulfCrystGems, g->second.resources[Res::MERCURY] + g->second.resources[Res::SULFUR] + g->second.resources[Res::CRYSTAL] + g->second.resources[Res::GEMS])
-	}
-	if(level >= 4) //obelisks found
-	{
-		FILL_FIELD(obelisks, CGObelisk::visited[gs->getPlayerTeam(g->second.color)->id])
-	}
-	if(level >= 5) //artifacts
-	{
-		FILL_FIELD(artifacts, statsHLP::getNumberOfArts(&g->second))
-	}
-	if(level >= 6) //army strength
-	{
-		FILL_FIELD(army, statsHLP::getArmyStrength(&g->second))
-	}
-	if(level >= 7) //income
-	{
-		//TODO:obtainPlayersStats - income
-	}
-	if(level >= 8) //best hero's stats
-	{
-		//already set in  lvl 1 handling
-	}
-	if(level >= 9) //personality
-	{
-		for(auto g = players.cbegin(); g != players.cend(); ++g)
-		{
-			if(g->second.color == PlayerColor::NEUTRAL) //do nothing for neutral player
-				continue;
-			if(g->second.human)
-			{
-                tgi.personality[g->second.color] = EAiTactic::NONE;
-			}
-			else //AI
-			{
-                tgi.personality[g->second.color] = map->players[g->second.color.getNum()].aiTactic;
-			}
-
-		}
-	}
-	if(level >= 10) //best creature
-	{
-		//best creatures belonging to player (highest AI value)
-		for(auto g = players.cbegin(); g != players.cend(); ++g)
-		{
-			if(g->second.color == PlayerColor::NEUTRAL) //do nothing for neutral player
-				continue;
-			int bestCre = -1; //best creature's ID
-			for(auto & elem : g->second.heroes)
-			{
-				for(auto it = elem->Slots().begin(); it != elem->Slots().end(); ++it)
-				{
-					int toCmp = it->second->type->idNumber; //ID of creature we should compare with the best one
-					if(bestCre == -1 || VLC->creh->creatures[bestCre]->AIValue < VLC->creh->creatures[toCmp]->AIValue)
-					{
-						bestCre = toCmp;
-					}
-				}
-			}
-			tgi.bestCreature[g->second.color] = bestCre;
-		}
-	}
-
-#undef FILL_FIELD
-}
-
-int CGameState::lossCheck( PlayerColor player ) const
-{
-	const PlayerState *p = CGameInfoCallback::getPlayer(player);
-	//if(map->lossCondition.typeOfLossCon == lossStandard)
-		if(checkForStandardLoss(player))
-			return -1;
-
-	if (p->enteredLosingCheatCode)
-	{
-		return 1;
-	}
-
-	if(p->human) //special loss condition applies only to human player
-	{
-		switch(map->lossCondition.typeOfLossCon)
-		{
-		case ELossConditionType::LOSSCASTLE:
-		case ELossConditionType::LOSSHERO:
-			{
-				const CGObjectInstance *obj = map->lossCondition.obj;
-				assert(obj);
-				if(obj->tempOwner != player)
-					return 1;
-			}
-			break;
-		case ELossConditionType::TIMEEXPIRES:
-			if(map->lossCondition.timeLimit < day)
-				return 1;
-			break;
-		}
-	}
-
-	if(!p->towns.size() && p->daysWithoutCastle >= 7)
-		return 2;
-
-	return false;
-}
-
-bmap<ui32, ConstTransitivePtr<CGHeroInstance> > CGameState::unusedHeroesFromPool()
-{
-	bmap<ui32, ConstTransitivePtr<CGHeroInstance> > pool = hpool.heroesPool;
-	for ( auto i = players.cbegin() ; i != players.cend();i++)
-		for(auto j = i->second.availableHeroes.cbegin(); j != i->second.availableHeroes.cend(); j++)
-			if(*j)
-				pool.erase((**j).subID);
-
-	return pool;
-}
-
-void CGameState::buildBonusSystemTree()
-{
-	buildGlobalTeamPlayerTree();
-	attachArmedObjects();
-
-	for(CGTownInstance *t : map->towns)
-	{
-		t->deserializationFix();
-	}
-	// CStackInstance <-> CCreature, CStackInstance <-> CArmedInstance, CArtifactInstance <-> CArtifact
-	// are provided on initializing / deserializing
-}
-
-void CGameState::deserializationFix()
-{
-	buildGlobalTeamPlayerTree();
-	attachArmedObjects();
-}
-
-void CGameState::buildGlobalTeamPlayerTree()
-{
-	for(auto k=teams.begin(); k!=teams.end(); ++k)
-	{
-		TeamState *t = &k->second;
-		t->attachTo(&globalEffects);
-
-		for(PlayerColor teamMember : k->second.players)
-		{
-			PlayerState *p = getPlayer(teamMember);
-			assert(p);
-			p->attachTo(t);
-		}
-	}
-}
-
-void CGameState::attachArmedObjects()
-{
-	for(CGObjectInstance *obj : map->objects)
-	{
-		if(CArmedInstance *armed = dynamic_cast<CArmedInstance*>(obj))
-			armed->whatShouldBeAttached()->attachTo(armed->whereShouldBeAttached(this));
-	}
-}
-
-void CGameState::giveHeroArtifact(CGHeroInstance *h, ArtifactID aid)
-{
-	 CArtifact * const artifact = VLC->arth->artifacts[aid]; //pointer to constant object
-	 CArtifactInstance *ai = CArtifactInstance::createNewArtifactInstance(artifact);
-	 map->addNewArtifactInstance(ai);
-	 ai->putAt(ArtifactLocation(h, ai->firstAvailableSlot(h)));
-}
-
-std::set<HeroTypeID> CGameState::getUnusedAllowedHeroes(bool alsoIncludeNotAllowed /*= false*/) const
-{
-	std::set<HeroTypeID> ret;
-	for(int i = 0; i < map->allowedHeroes.size(); i++)
-		if(map->allowedHeroes[i] || alsoIncludeNotAllowed)
-			ret.insert(HeroTypeID(i));
-
-	for(auto hero : map->heroesOnMap)  //heroes instances initialization
-	{
-		if(hero->type)
-			ret -= hero->type->ID;
-		else
-			ret -= HeroTypeID(hero->subID);
-	}
-
-	for(auto obj : map->objects) //prisons
-		if(obj && obj->ID == Obj::PRISON)
-			ret -= HeroTypeID(obj->subID);
-
-	return ret;
-}
-
-std::vector<std::pair<CGHeroInstance*, ObjectInstanceID> > CGameState::campaignHeroesToReplace()
-{
-	std::vector<std::pair<CGHeroInstance*, ObjectInstanceID> > ret;
-	auto replaceHero = [&](ObjectInstanceID objId, CGHeroInstance * ghi)
-	{
-		ret.push_back(std::make_pair(ghi, objId));
-		// 			ghi->tempOwner = getHumanPlayerInfo()[0]->color;
-		// 			ghi->id = objId;
-		// 			gs->map->objects[objId] = ghi;
-		// 			gs->map->heroes.push_back(ghi);
-	};
-
-	auto campaign = scenarioOps->campState;
-	if(auto bonus = campaign->getBonusForCurrentMap())
-	{
-		std::vector<CGHeroInstance*> Xheroes;
-		if (bonus->type == CScenarioTravel::STravelBonus::PLAYER_PREV_SCENARIO)
-		{
-			Xheroes = campaign->camp->scenarios[bonus->info2].crossoverHeroes;
-		}
-
-		//selecting heroes by type
-		for(int g=0; g<map->objects.size(); ++g)
-		{
-			const ObjectInstanceID gid = ObjectInstanceID(g);
-			CGObjectInstance * obj = map->objects[g];
-			if (obj->ID != Obj::HERO_PLACEHOLDER)
-			{
-				continue;
-			}
-			CGHeroPlaceholder * hp = static_cast<CGHeroPlaceholder*>(obj);
-
-			if(hp->subID != 0xFF) //select by type
-			{
-				bool found = false;
-				for(auto ghi : Xheroes)
-				{
-					if (ghi->subID == hp->subID)
-					{
-						found = true;
-						replaceHero(gid, ghi);
-						Xheroes -= ghi;
-						break;
-					}
-				}
-				if (!found)
-				{
-					auto  nh = new CGHeroInstance();
-					nh->initHero(HeroTypeID(hp->subID));
-					replaceHero(gid, nh);
-				}
-			}
-		}
-
-		//selecting heroes by power
-
-		std::sort(Xheroes.begin(), Xheroes.end(), [](const CGHeroInstance * a, const CGHeroInstance * b)
-		{
-			return a->getHeroStrength() > b->getHeroStrength();
-		}); //sort, descending strength
-
-		for(int g=0; g<map->objects.size(); ++g)
-		{
-			const ObjectInstanceID gid = ObjectInstanceID(g);
-			CGObjectInstance * obj = map->objects[g];
-			if (obj->ID != Obj::HERO_PLACEHOLDER)
-			{
-				continue;
-			}
-			CGHeroPlaceholder * hp = static_cast<CGHeroPlaceholder*>(obj);
-
-			if (hp->subID == 0xFF) //select by power
-			{
-				if(Xheroes.size() > hp->power - 1)
-					replaceHero(gid, Xheroes[hp->power - 1]);
-				else
-				{
-					logGlobal->warnStream() << "Warning, no hero to replace!";
-					map->removeBlockVisTiles(hp, true);
-					delete hp;
-					map->objects[g] = nullptr;
-				}
-				//we don't have to remove hero from Xheroes because it would destroy the order and duplicates shouldn't happen
-			}
-		}
-	}
-
-	return ret;
-}
-
-void CGameState::placeCampaignHeroes(const std::vector<std::pair<CGHeroInstance*, ObjectInstanceID> > &campHeroReplacements)
-{
-	for(auto obj : campHeroReplacements)
-	{
-		CGHeroPlaceholder *placeholder = dynamic_cast<CGHeroPlaceholder*>(getObjInstance(obj.second));
-
-		CGHeroInstance *heroToPlace = obj.first;
-		heroToPlace->id = obj.second;
-		heroToPlace->tempOwner = placeholder->tempOwner;
-		heroToPlace->pos = placeholder->pos;
-		heroToPlace->type = VLC->heroh->heroes[heroToPlace->type->ID.getNum()]; //TODO is this reasonable? either old type can be still used or it can be deleted?
-
-		for(auto &&i : heroToPlace->stacks)
-			i.second->type = VLC->creh->creatures[i.second->getCreatureID()];
-
-		auto fixArtifact = [&](CArtifactInstance * art)
-		{
-			art->artType = VLC->arth->artifacts[art->artType->id];
-			gs->map->artInstances.push_back(art);
-			art->id = ArtifactInstanceID(gs->map->artInstances.size() - 1);
-		};
-
-		for(auto &&i : heroToPlace->artifactsWorn)
-			fixArtifact(i.second.artifact);
-		for(auto &&i : heroToPlace->artifactsInBackpack)
-			fixArtifact(i.artifact);
-
-		map->heroesOnMap.push_back(heroToPlace);
-		map->objects[heroToPlace->id.getNum()] = heroToPlace;
-		map->addBlockVisTiles(heroToPlace);
-
-		//const auto & travelOptions = scenarioOps->campState->getCurrentScenario().travelOptions;
-	}
-}
-
-bool CGameState::isUsedHero(HeroTypeID hid) const
-{
-	for(auto hero : map->heroesOnMap)  //heroes instances initialization
-		if(hero->subID == hid.getNum())
-			return true;
-
-	for(auto obj : map->objects) //prisons
-		if(obj && obj->ID == Obj::PRISON  && obj->subID == hid.getNum())
-			return true;
-
-	return false;
-}
-
-CGPathNode::CGPathNode()
-:coord(-1,-1,-1)
-{
-	accessible = NOT_SET;
-	land = 0;
-	moveRemains = 0;
-	turns = 255;
-	theNodeBefore = nullptr;
-}
-
-bool CGPathNode::reachable() const
-{
-	return turns < 255;
-}
-
-bool CPathsInfo::getPath( const int3 &dst, CGPath &out )
-{
-	assert(isValid);
-
-	out.nodes.clear();
-	const CGPathNode *curnode = &nodes[dst.x][dst.y][dst.z];
-	if(!curnode->theNodeBefore)
-		return false;
-
-
-	while(curnode)
-	{
-		CGPathNode cpn = *curnode;
-		curnode = curnode->theNodeBefore;
-		out.nodes.push_back(cpn);
-	}
-	return true;
-}
-
-CPathsInfo::CPathsInfo( const int3 &Sizes )
-:sizes(Sizes)
-{
-	hero = nullptr;
-	nodes = new CGPathNode**[sizes.x];
-	for(int i = 0; i < sizes.x; i++)
-	{
-		nodes[i] = new CGPathNode*[sizes.y];
-		for (int j = 0; j < sizes.y; j++)
-		{
-			nodes[i][j] = new CGPathNode[sizes.z];
-		}
-	}
-}
-
-CPathsInfo::~CPathsInfo()
-{
-	for(int i = 0; i < sizes.x; i++)
-	{
-		for (int j = 0; j < sizes.y; j++)
-		{
-			delete [] nodes[i][j];
-		}
-		delete [] nodes[i];
-	}
-	delete [] nodes;
-}
-
-int3 CGPath::startPos() const
-{
-	return nodes[nodes.size()-1].coord;
-}
-
-int3 CGPath::endPos() const
-{
-	return nodes[0].coord;
-}
-
-void CGPath::convert( ui8 mode )
-{
-	if(mode==0)
-	{
-		for(auto & elem : nodes)
-		{
-			elem.coord = CGHeroInstance::convertPosition(elem.coord,true);
-		}
-	}
-}
-
-PlayerState::PlayerState()
- : color(-1), currentSelection(0xffffffff), enteredWinningCheatCode(0),
-   enteredLosingCheatCode(0), status(EPlayerStatus::INGAME), daysWithoutCastle(0)
-{
-	setNodeType(PLAYER);
-}
-
-std::string PlayerState::nodeName() const
-{
-	return "Player " + (color.getNum() < VLC->generaltexth->capColors.size() ? VLC->generaltexth->capColors[color.getNum()] : boost::lexical_cast<std::string>(color));
-}
-
-InfoAboutArmy::InfoAboutArmy():
-    owner(PlayerColor::NEUTRAL)
-{}
-
-InfoAboutArmy::InfoAboutArmy(const CArmedInstance *Army, bool detailed)
-{
-	initFromArmy(Army, detailed);
-}
-
-void InfoAboutArmy::initFromArmy(const CArmedInstance *Army, bool detailed)
-{
-	army = ArmyDescriptor(Army, detailed);
-	owner = Army->tempOwner;
-	name = Army->getHoverText();
-}
-
-void InfoAboutHero::assign(const InfoAboutHero & iah)
-{
-	InfoAboutArmy::operator = (iah);
-
-	details = (iah.details ? new Details(*iah.details) : nullptr);
-	hclass = iah.hclass;
-	portrait = iah.portrait;
-}
-
-InfoAboutHero::InfoAboutHero():
-    details(nullptr),
-    hclass(nullptr),
-    portrait(-1)
-{}
-
-InfoAboutHero::InfoAboutHero(const InfoAboutHero & iah):
-    InfoAboutArmy()
-{
-	assign(iah);
-}
-
-InfoAboutHero::InfoAboutHero(const CGHeroInstance *h, bool detailed)
-	: details(nullptr),
-	hclass(nullptr),
-	portrait(-1)
-{
-	initFromHero(h, detailed);
-}
-
-InfoAboutHero::~InfoAboutHero()
-{
-	delete details;
-}
-
-InfoAboutHero & InfoAboutHero::operator=(const InfoAboutHero & iah)
-{
-	assign(iah);
-	return *this;
-}
-
-void InfoAboutHero::initFromHero(const CGHeroInstance *h, bool detailed)
-{
-	if(!h)
-		return;
-
-	initFromArmy(h, detailed);
-
-	hclass = h->type->heroClass;
-	name = h->name;
-	portrait = h->portrait;
-
-	if(detailed)
-	{
-		//include details about hero
-		details = new Details;
-		details->luck = h->LuckVal();
-		details->morale = h->MoraleVal();
-		details->mana = h->mana;
-		details->primskills.resize(GameConstants::PRIMARY_SKILLS);
-
-		for (int i = 0; i < GameConstants::PRIMARY_SKILLS ; i++)
-		{
-			details->primskills[i] = h->getPrimSkillLevel(static_cast<PrimarySkill::PrimarySkill>(i));
-		}
-	}
-}
-
-InfoAboutTown::InfoAboutTown():
-    details(nullptr),
-    tType(nullptr),
-    built(0),
-    fortLevel(0)
-{
-
-}
-
-InfoAboutTown::InfoAboutTown(const CGTownInstance *t, bool detailed)
-{
-	initFromTown(t, detailed);
-}
-
-InfoAboutTown::~InfoAboutTown()
-{
-	delete details;
-}
-
-void InfoAboutTown::initFromTown(const CGTownInstance *t, bool detailed)
-{
-	initFromArmy(t, detailed);
-	army = ArmyDescriptor(t->getUpperArmy(), detailed);
-	built = t->builded;
-	fortLevel = t->fortLevel();
-	name = t->name;
-	tType = t->town;
-
-	if(detailed)
-	{
-		//include details about hero
-		details = new Details;
-		details->goldIncome = t->dailyIncome();
-		details->customRes = t->hasBuilt(BuildingID::RESOURCE_SILO);
-		details->hallLevel = t->hallLevel();
-		details->garrisonedHero = t->garrisonHero;
-	}
-}
-
-ArmyDescriptor::ArmyDescriptor(const CArmedInstance *army, bool detailed)
-    : isDetailed(detailed)
-{
-	for(auto & elem : army->Slots())
-	{
-		if(detailed)
-			(*this)[elem.first] = *elem.second;
-		else
-			(*this)[elem.first] = CStackBasicDescriptor(elem.second->type, elem.second->getQuantityID());
-	}
-}
-
-ArmyDescriptor::ArmyDescriptor()
-    : isDetailed(false)
-{
-
-}
-
-int ArmyDescriptor::getStrength() const
-{
-	ui64 ret = 0;
-	if(isDetailed)
-	{
-		for(auto & elem : *this)
-			ret += elem.second.type->AIValue * elem.second.count;
-	}
-	else
-	{
-		for(auto & elem : *this)
-			ret += elem.second.type->AIValue * CCreature::estimateCreatureCount(elem.second.count);
-	}
-	return ret;
-}
-
-DuelParameters::SideSettings::StackSettings::StackSettings()
-	: type(CreatureID::NONE), count(0)
-{
-}
-
-DuelParameters::SideSettings::StackSettings::StackSettings(CreatureID Type, si32 Count)
-	: type(Type), count(Count)
-{
-}
-
-DuelParameters::SideSettings::SideSettings()
-{
-	heroId = -1;
-}
-
-DuelParameters::DuelParameters():
-    terType(ETerrainType::DIRT),
-    bfieldType(BFieldType::ROCKLANDS)
-{
-}
-
-DuelParameters DuelParameters::fromJSON(const std::string &fname)
-{
-	DuelParameters ret;
-
-	const JsonNode duelData(ResourceID("DATA/" + fname, EResType::TEXT));
-	ret.terType = ETerrainType((int)duelData["terType"].Float());
-	ret.bfieldType = BFieldType((int)duelData["bfieldType"].Float());
-	for(const JsonNode &n : duelData["sides"].Vector())
-	{
-		SideSettings &ss = ret.sides[(int)n["side"].Float()];
-		int i = 0;
-		for(const JsonNode &stackNode : n["army"].Vector())
-		{
-			ss.stacks[i].type = CreatureID((si32)stackNode.Vector()[0].Float());
-			ss.stacks[i].count = stackNode.Vector()[1].Float();
-			i++;
-		}
-
-		if(n["heroid"].getType() == JsonNode::DATA_FLOAT)
-			ss.heroId = n["heroid"].Float();
-		else
-			ss.heroId = -1;
-
-		for(const JsonNode &n : n["heroPrimSkills"].Vector())
-			ss.heroPrimSkills.push_back(n.Float());
-
-		for(const JsonNode &skillNode : n["heroSecSkills"].Vector())
-		{
-			std::pair<si32, si8> secSkill;
-			secSkill.first = skillNode.Vector()[0].Float();
-			secSkill.second = skillNode.Vector()[1].Float();
-			ss.heroSecSkills.push_back(secSkill);
-		}
-
-		assert(ss.heroPrimSkills.empty() || ss.heroPrimSkills.size() == GameConstants::PRIMARY_SKILLS);
-
-		if(ss.heroId != -1)
-		{
-			const JsonNode & spells = n["spells"];
-			if(spells.getType() == JsonNode::DATA_STRING  &&  spells.String() == "all")
-			{
-				for(auto spell : VLC->spellh->spells)
-					if(spell->id <= SpellID::SUMMON_AIR_ELEMENTAL)
-						ss.spells.insert(spell->id);
-			}
-			else
-				for(const JsonNode &spell : n["spells"].Vector())
-					ss.spells.insert(SpellID(spell.Float()));
-		}
-	}
-
-	for(const JsonNode &n : duelData["obstacles"].Vector())
-	{
-		auto oi = make_shared<CObstacleInstance>();
-		if(n.getType() == JsonNode::DATA_VECTOR)
-		{
-			oi->ID = n.Vector()[0].Float();
-			oi->pos = n.Vector()[1].Float();
-		}
-		else
-		{
-			assert(n.getType() == JsonNode::DATA_FLOAT);
-			oi->ID = 21;
-			oi->pos = n.Float();
-		}
-		oi->uniqueID = ret.obstacles.size();
-		ret.obstacles.push_back(oi);
-	}
-
-	for(const JsonNode &n : duelData["creatures"].Vector())
-	{
-		CusomCreature cc;
-		cc.id = n["id"].Float();
-
-#define retreive(name)								\
-	if(n[ #name ].getType() == JsonNode::DATA_FLOAT)\
-	cc.name = n[ #name ].Float();			\
-	else											\
-	cc.name = -1;
-
-		retreive(attack);
-		retreive(defense);
-		retreive(HP);
-		retreive(dmg);
-		retreive(shoots);
-		retreive(speed);
-		ret.creatures.push_back(cc);
-	}
-
-	return ret;
-}
-
-TeamState::TeamState()
-{
-	setNodeType(TEAM);
-}
-
-void CPathfinder::initializeGraph()
-{
-	CGPathNode ***graph = out.nodes;
-	for(size_t i=0; i < out.sizes.x; ++i)
-	{
-		for(size_t j=0; j < out.sizes.y; ++j)
-		{
-			for(size_t k=0; k < out.sizes.z; ++k)
-			{
-				curPos = int3(i,j,k);
-				const TerrainTile *tinfo = &gs->map->getTile(int3(i, j, k));
-				CGPathNode &node = graph[i][j][k];
-				node.accessible = evaluateAccessibility(tinfo);
-				node.turns = 0xff;
-				node.moveRemains = 0;
-				node.coord.x = i;
-				node.coord.y = j;
-				node.coord.z = k;
-                node.land = tinfo->terType != ETerrainType::WATER;
-				node.theNodeBefore = nullptr;
-			}
-		}
-	}
-}
-
-void CPathfinder::calculatePaths(int3 src /*= int3(-1,-1,-1)*/, int movement /*= -1*/)
-{
-	assert(hero);
-	assert(hero == getHero(hero->id));
-	if(src.x < 0)
-		src = hero->getPosition(false);
-	if(movement < 0)
-		movement = hero->movement;
-
-	out.hero = hero;
-	out.hpos = src;
-
-	if(!gs->map->isInTheMap(src)/* || !gs->map->isInTheMap(dest)*/) //check input
-	{
-        logGlobal->errorStream() << "CGameState::calculatePaths: Hero outside the gs->map? How dare you...";
-		return;
-	}
-
-	initializeGraph();
-
-
-	//initial tile - set cost on 0 and add to the queue
-	CGPathNode &initialNode = *getNode(src);
-	initialNode.turns = 0;
-	initialNode.moveRemains = movement;
-	mq.push_back(&initialNode);
-
-	std::vector<int3> neighbours;
-	neighbours.reserve(16);
-	while(!mq.empty())
-	{
-		cp = mq.front();
-		mq.pop_front();
-
-		const int3 sourceGuardPosition = guardingCreaturePosition(cp->coord);
-		bool guardedSource = (sourceGuardPosition != int3(-1, -1, -1) && cp->coord != src);
-		ct = &gs->map->getTile(cp->coord);
-
-		int movement = cp->moveRemains, turn = cp->turns;
-		if(!movement)
-		{
-			movement = hero->maxMovePoints(cp->land);
-			turn++;
-		}
-
-
-		//add accessible neighbouring nodes to the queue
-		neighbours.clear();
-
-		//handling subterranean gate => it's exit is the only neighbour
-        bool subterraneanEntry = (ct->topVisitableId() == Obj::SUBTERRANEAN_GATE && useSubterraneanGates);
-		if(subterraneanEntry)
-		{
-			//try finding the exit gate
-			if(const CGObjectInstance *outGate = getObj(CGTeleport::getMatchingGate(ct->visitableObjects.back()->id), false))
-			{
-				const int3 outPos = outGate->visitablePos();
-				//gs->getNeighbours(*getTile(outPos), outPos, neighbours, boost::logic::indeterminate, !cp->land);
-				neighbours.push_back(outPos);
-			}
-			else
-			{
-				//gate with no exit (blocked) -> do nothing with this node
-				continue;
-			}
-		}
-
-		gs->getNeighbours(*ct, cp->coord, neighbours, boost::logic::indeterminate, !cp->land);
-
-		for(auto & neighbour : neighbours)
-		{
-			const int3 &n = neighbour; //current neighbor
-			dp = getNode(n);
-			dt = &gs->map->getTile(n);
-            destTopVisObjID = dt->topVisitableId();
-
-			useEmbarkCost = 0; //0 - usual movement; 1 - embark; 2 - disembark
-
-			int turnAtNextTile = turn;
-
-
-			const bool destIsGuardian = sourceGuardPosition == n;
-
-			if(!goodForLandSeaTransition())
-				continue;
-
-			if(!canMoveBetween(cp->coord, dp->coord) || dp->accessible == CGPathNode::BLOCKED )
-				continue;
-
-			//special case -> hero embarked a boat standing on a guarded tile -> we must allow to move away from that tile
-            if(cp->accessible == CGPathNode::VISITABLE && guardedSource && cp->theNodeBefore->land && ct->topVisitableId() == Obj::BOAT)
-				guardedSource = false;
-
-			int cost = gs->getMovementCost(hero, cp->coord, dp->coord, movement);
-
-			//special case -> moving from src Subterranean gate to dest gate -> it's free
-			if(subterraneanEntry && destTopVisObjID == Obj::SUBTERRANEAN_GATE && cp->coord.z != dp->coord.z)
-				cost = 0;
-
-			int remains = movement - cost;
-
-			if(useEmbarkCost)
-			{
-				remains = hero->movementPointsAfterEmbark(movement, cost, useEmbarkCost - 1);
-				cost = movement - remains;
-			}
-
-			if(remains < 0)
-			{
-				//occurs rarely, when hero with low movepoints tries to leave the road
-				turnAtNextTile++;
-				int moveAtNextTile = hero->maxMovePoints(cp->land);
-				cost = gs->getMovementCost(hero, cp->coord, dp->coord, moveAtNextTile); //cost must be updated, movement points changed :(
-				remains = moveAtNextTile - cost;
-			}
-
-			if((dp->turns==0xff		//we haven't been here before
-				|| dp->turns > turnAtNextTile
-				|| (dp->turns >= turnAtNextTile  &&  dp->moveRemains < remains)) //this route is faster
-				&& (!guardedSource || destIsGuardian)) // Can step into tile of guard
-			{
-
-				assert(dp != cp->theNodeBefore); //two tiles can't point to each other
-				dp->moveRemains = remains;
-				dp->turns = turnAtNextTile;
-				dp->theNodeBefore = cp;
-
-				const bool guardedDst = guardingCreaturePosition(dp->coord) != int3(-1, -1, -1)
-										&& dp->accessible == CGPathNode::BLOCKVIS;
-
-				if (dp->accessible == CGPathNode::ACCESSIBLE
-					|| (useEmbarkCost && allowEmbarkAndDisembark)
-					|| destTopVisObjID == Obj::SUBTERRANEAN_GATE
-					|| (guardedDst && !guardedSource)) // Can step into a hostile tile once.
-				{
-					mq.push_back(dp);
-				}
-			}
-		} //neighbours loop
-	} //queue loop
-
-	out.isValid = true;
-}
-
-CGPathNode *CPathfinder::getNode(const int3 &coord)
-{
-	return &out.nodes[coord.x][coord.y][coord.z];
-}
-
-bool CPathfinder::canMoveBetween(const int3 &a, const int3 &b) const
-{
-	return gs->checkForVisitableDir(a, b) && gs->checkForVisitableDir(b, a);
-}
-
-CGPathNode::EAccessibility CPathfinder::evaluateAccessibility(const TerrainTile *tinfo) const
-{
-	CGPathNode::EAccessibility ret = (tinfo->blocked ? CGPathNode::BLOCKED : CGPathNode::ACCESSIBLE);
-
-
-    if(tinfo->terType == ETerrainType::ROCK || !FoW[curPos.x][curPos.y][curPos.z])
-		return CGPathNode::BLOCKED;
-
-	if(tinfo->visitable)
-	{
-		if(tinfo->visitableObjects.front()->ID == Obj::SANCTUARY && tinfo->visitableObjects.back()->ID == Obj::HERO && tinfo->visitableObjects.back()->tempOwner != hero->tempOwner) //non-owned hero stands on Sanctuary
-		{
-			return CGPathNode::BLOCKED;
-		}
-		else
-		{
-			for(const CGObjectInstance *obj : tinfo->visitableObjects)
-			{
-				if(obj->passableFor(hero->tempOwner)) //special object instance specific passableness flag - overwrites other accessibility flags
-				{
-					ret = CGPathNode::ACCESSIBLE;
-				}
-				else if(obj->blockVisit)
-				{
-					return CGPathNode::BLOCKVIS;
-				}
-				else if(obj->ID != Obj::EVENT) //pathfinder should ignore placed events
-				{
-					ret =  CGPathNode::VISITABLE;
-				}
-			}
-		}
-	}
-	else if (gs->map->isInTheMap(guardingCreaturePosition(curPos))
-		&& !tinfo->blocked)
-	{
-		// Monster close by; blocked visit for battle.
-		return CGPathNode::BLOCKVIS;
-	}
-
-	return ret;
-}
-
-bool CPathfinder::goodForLandSeaTransition()
-{
-	if(cp->land != dp->land) //hero can traverse land<->sea only in special circumstances
-	{
-		if(cp->land) //from land to sea -> embark or assault hero on boat
-		{
-			if(dp->accessible == CGPathNode::ACCESSIBLE || destTopVisObjID < 0) //cannot enter empty water tile from land -> it has to be visitable
-				return false;
-			if(destTopVisObjID != Obj::HERO && destTopVisObjID != Obj::BOAT) //only boat or hero can be accessed from land
-				return false;
-			if(destTopVisObjID == Obj::BOAT)
-				useEmbarkCost = 1;
-		}
-		else //disembark
-		{
-			//can disembark only on coastal tiles
-			if(!dt->isCoastal())
-				return false;
-
-			//tile must be accessible -> exception: unblocked blockvis tiles -> clear but guarded by nearby monster coast
-			if( (dp->accessible != CGPathNode::ACCESSIBLE && (dp->accessible != CGPathNode::BLOCKVIS || dt->blocked))
-				|| dt->visitable)  //TODO: passableness problem -> town says it's passable (thus accessible) but we obviously can't disembark onto town gate
-				return false;;
-
-			useEmbarkCost = 2;
-		}
-	}
-
-	return true;
-}
-
-CPathfinder::CPathfinder(CPathsInfo &_out, CGameState *_gs, const CGHeroInstance *_hero) : CGameInfoCallback(_gs, boost::optional<PlayerColor>()), out(_out), hero(_hero), FoW(getPlayerTeam(hero->tempOwner)->fogOfWarMap)
-{
-	useSubterraneanGates = true;
-	allowEmbarkAndDisembark = true;
-}
+#include "StdInc.h"
+#include "CGameState.h"
+
+#include "mapping/CCampaignHandler.h"
+#include "CDefObjInfoHandler.h"
+#include "CArtHandler.h"
+#include "CBuildingHandler.h"
+#include "CGeneralTextHandler.h"
+#include "CTownHandler.h"
+#include "CSpellHandler.h"
+#include "CHeroHandler.h"
+#include "CObjectHandler.h"
+#include "CCreatureHandler.h"
+#include "CModHandler.h"
+#include "VCMI_Lib.h"
+#include "Connection.h"
+#include "mapping/CMap.h"
+#include "mapping/CMapService.h"
+#include "StartInfo.h"
+#include "NetPacks.h"
+#include "RegisterTypes.h"
+#include "mapping/CMapInfo.h"
+#include "BattleState.h"
+#include "JsonNode.h"
+#include "filesystem/Filesystem.h"
+#include "GameConstants.h"
+#include "rmg/CMapGenerator.h"
+#include "CStopWatch.h"
+
+DLL_LINKAGE std::minstd_rand ran;
+class CGObjectInstance;
+
+#ifdef min
+#undef min
+#endif
+#ifdef max
+#undef max
+#endif
+
+/*
+ * CGameState.cpp, part of VCMI engine
+ *
+ * Authors: listed in file AUTHORS in main folder
+ *
+ * License: GNU General Public License v2.0 or later
+ * Full text of license available in license.txt file, in main folder
+ *
+ */
+
+template <typename T> class CApplyOnGS;
+
+class CBaseForGSApply
+{
+public:
+	virtual void applyOnGS(CGameState *gs, void *pack) const =0;
+	virtual ~CBaseForGSApply(){};
+	template<typename U> static CBaseForGSApply *getApplier(const U * t=nullptr)
+	{
+		return new CApplyOnGS<U>;
+	}
+};
+
+template <typename T> class CApplyOnGS : public CBaseForGSApply
+{
+public:
+	void applyOnGS(CGameState *gs, void *pack) const
+	{
+		T *ptr = static_cast<T*>(pack);
+
+		boost::unique_lock<boost::shared_mutex> lock(*gs->mx);
+		ptr->applyGs(gs);
+	}
+};
+
+static CApplier<CBaseForGSApply> *applierGs = nullptr;
+
+class IObjectCaller
+{
+public:
+	virtual ~IObjectCaller(){};
+	virtual void preInit()=0;
+	virtual void postInit()=0;
+};
+
+template <typename T>
+class CObjectCaller : public IObjectCaller
+{
+public:
+	void preInit()
+	{
+		//T::preInit();
+	}
+	void postInit()
+	{
+		//T::postInit();
+	}
+};
+
+class CObjectCallersHandler
+{
+public:
+	std::vector<IObjectCaller*> apps;
+
+	template<typename T> void registerType(const T * t=nullptr)
+	{
+		apps.push_back(new CObjectCaller<T>);
+	}
+
+	CObjectCallersHandler()
+	{
+		registerTypes1(*this);
+	}
+
+	~CObjectCallersHandler()
+	{
+		for (auto & elem : apps)
+			delete elem;
+	}
+
+	void preInit()
+	{
+// 		for (size_t i = 0; i < apps.size(); i++)
+// 			apps[i]->preInit();
+	}
+
+	void postInit()
+	{
+	//for (size_t i = 0; i < apps.size(); i++)
+	//apps[i]->postInit();
+	}
+} *objCaller = nullptr;
+
+void MetaString::getLocalString(const std::pair<ui8,ui32> &txt, std::string &dst) const
+{
+	int type = txt.first, ser = txt.second;
+
+	if(type == ART_NAMES)
+	{
+		dst = VLC->arth->artifacts[ser]->Name();
+	}
+	else if(type == CRE_PL_NAMES)
+	{
+		dst = VLC->creh->creatures[ser]->namePl;
+	}
+	else if(type == MINE_NAMES)
+	{
+		dst = VLC->generaltexth->mines[ser].first;
+	}
+	else if(type == MINE_EVNTS)
+	{
+		dst = VLC->generaltexth->mines[ser].second;
+	}
+	else if(type == SPELL_NAME)
+	{
+		dst = SpellID(ser).toSpell()->name;
+	}
+	else if(type == CRE_SING_NAMES)
+	{
+		dst = VLC->creh->creatures[ser]->nameSing;
+	}
+	else if(type == ART_DESCR)
+	{
+		dst = VLC->arth->artifacts[ser]->Description();
+	}
+	else if (type == ART_EVNTS)
+	{
+		dst = VLC->arth->artifacts[ser]->EventText();
+	}
+	else
+	{
+		std::vector<std::string> *vec;
+		switch(type)
+		{
+		case GENERAL_TXT:
+			vec = &VLC->generaltexth->allTexts;
+			break;
+		case XTRAINFO_TXT:
+			vec = &VLC->generaltexth->xtrainfo;
+			break;
+		case OBJ_NAMES:
+			vec = &VLC->generaltexth->names;
+			break;
+		case RES_NAMES:
+			vec = &VLC->generaltexth->restypes;
+			break;
+		case ARRAY_TXT:
+			vec = &VLC->generaltexth->arraytxt;
+			break;
+		case CREGENS:
+			vec = &VLC->generaltexth->creGens;
+			break;
+		case CREGENS4:
+			vec = &VLC->generaltexth->creGens4;
+			break;
+		case ADVOB_TXT:
+			vec = &VLC->generaltexth->advobtxt;
+			break;
+		case SEC_SKILL_NAME:
+			vec = &VLC->generaltexth->skillName;
+			break;
+		case COLOR:
+			vec = &VLC->generaltexth->capColors;
+			break;
+		default:
+            logGlobal->errorStream() << "Failed string substitution because type is " << type;
+			dst = "#@#";
+			return;
+		}
+		if(vec->size() <= ser)
+		{
+            logGlobal->errorStream() << "Failed string substitution with type " << type << " because index " << ser << " is out of bounds!";
+			dst = "#!#";
+		}
+		else
+			dst = (*vec)[ser];
+	}
+}
+
+DLL_LINKAGE void MetaString::toString(std::string &dst) const
+{
+	size_t exSt = 0, loSt = 0, nums = 0;
+	dst.clear();
+
+	for(auto & elem : message)
+	{//TEXACT_STRING, TLOCAL_STRING, TNUMBER, TREPLACE_ESTRING, TREPLACE_LSTRING, TREPLACE_NUMBER
+		switch(elem)
+		{
+		case TEXACT_STRING:
+			dst += exactStrings[exSt++];
+			break;
+		case TLOCAL_STRING:
+			{
+				std::string hlp;
+				getLocalString(localStrings[loSt++], hlp);
+				dst += hlp;
+			}
+			break;
+		case TNUMBER:
+			dst += boost::lexical_cast<std::string>(numbers[nums++]);
+			break;
+		case TREPLACE_ESTRING:
+			boost::replace_first(dst, "%s", exactStrings[exSt++]);
+			break;
+		case TREPLACE_LSTRING:
+			{
+				std::string hlp;
+				getLocalString(localStrings[loSt++], hlp);
+				boost::replace_first(dst, "%s", hlp);
+			}
+			break;
+		case TREPLACE_NUMBER:
+			boost::replace_first(dst, "%d", boost::lexical_cast<std::string>(numbers[nums++]));
+			break;
+		case TREPLACE_PLUSNUMBER:
+			boost::replace_first(dst, "%+d", '+' + boost::lexical_cast<std::string>(numbers[nums++]));
+			break;
+		default:
+            logGlobal->errorStream() << "MetaString processing error!";
+			break;
+		}
+	}
+}
+
+DLL_LINKAGE std::string MetaString::toString() const
+{
+	std::string ret;
+	toString(ret);
+	return ret;
+}
+
+DLL_LINKAGE std::string MetaString::buildList () const
+///used to handle loot from creature bank
+{
+
+	size_t exSt = 0, loSt = 0, nums = 0;
+	std::string lista;
+	for (int i = 0; i < message.size(); ++i)
+	{
+		if (i > 0 && (message[i] == TEXACT_STRING || message[i] == TLOCAL_STRING))
+		{
+			if (exSt == exactStrings.size() - 1)
+				lista += VLC->generaltexth->allTexts[141]; //" and "
+			else
+				lista += ", ";
+		}
+		switch (message[i])
+		{
+			case TEXACT_STRING:
+				lista += exactStrings[exSt++];
+				break;
+			case TLOCAL_STRING:
+			{
+				std::string hlp;
+				getLocalString (localStrings[loSt++], hlp);
+				lista += hlp;
+			}
+				break;
+			case TNUMBER:
+				lista += boost::lexical_cast<std::string>(numbers[nums++]);
+				break;
+			case TREPLACE_ESTRING:
+				lista.replace (lista.find("%s"), 2, exactStrings[exSt++]);
+				break;
+			case TREPLACE_LSTRING:
+			{
+				std::string hlp;
+				getLocalString (localStrings[loSt++], hlp);
+				lista.replace (lista.find("%s"), 2, hlp);
+			}
+				break;
+			case TREPLACE_NUMBER:
+				lista.replace (lista.find("%d"), 2, boost::lexical_cast<std::string>(numbers[nums++]));
+				break;
+			default:
+                logGlobal->errorStream() << "MetaString processing error!";
+		}
+
+	}
+	return lista;
+}
+
+
+void  MetaString::addCreReplacement(CreatureID id, TQuantity count) //adds sing or plural name;
+{
+	if (!count)
+		addReplacement (CRE_PL_NAMES, id); //no creatures - just empty name (eg. defeat Angels)
+	else if (count == 1)
+		addReplacement (CRE_SING_NAMES, id);
+	else
+		addReplacement (CRE_PL_NAMES, id);
+}
+
+void MetaString::addReplacement(const CStackBasicDescriptor &stack)
+{
+	assert(stack.type); //valid type
+	addCreReplacement(stack.type->idNumber, stack.count);
+}
+
+static CGObjectInstance * createObject(Obj id, int subid, int3 pos, PlayerColor owner)
+{
+	CGObjectInstance * nobj;
+	switch(id)
+	{
+	case Obj::HERO:
+		{
+			auto  nobj = new CGHeroInstance();
+			nobj->pos = pos;
+			nobj->tempOwner = owner;
+			nobj->subID = subid;
+			//nobj->initHero(ran);
+			return nobj;
+		}
+	case Obj::TOWN:
+		nobj = new CGTownInstance;
+		break;
+	default: //rest of objects
+		nobj = new CGObjectInstance;
+		nobj->defInfo = id.toDefObjInfo()[subid];
+		break;
+	}
+	nobj->ID = id;
+	nobj->subID = subid;
+	if(!nobj->defInfo)
+        logGlobal->warnStream() <<"No def declaration for " <<id <<" "<<subid;
+	nobj->pos = pos;
+	//nobj->state = nullptr;//new CLuaObjectScript();
+	nobj->tempOwner = owner;
+	nobj->defInfo->id = id;
+	nobj->defInfo->subid = subid;
+
+	//assigning defhandler
+	if(nobj->ID==Obj::HERO || nobj->ID==Obj::TOWN)
+		return nobj;
+	nobj->defInfo = id.toDefObjInfo()[subid];
+	return nobj;
+}
+
+CGHeroInstance * CGameState::HeroesPool::pickHeroFor(bool native, PlayerColor player, const CTown *town, std::map<ui32, ConstTransitivePtr<CGHeroInstance> > &available, const CHeroClass *bannedClass /*= nullptr*/) const
+{
+	CGHeroInstance *ret = nullptr;
+
+	if(player>=PlayerColor::PLAYER_LIMIT)
+	{
+        logGlobal->errorStream() << "Cannot pick hero for " << town->faction->index << ". Wrong owner!";
+		return nullptr;
+	}
+
+	std::vector<CGHeroInstance *> pool;
+
+	if(native)
+	{
+		for(auto & elem : available)
+		{
+			if(pavailable.find(elem.first)->second & 1<<player.getNum()
+				&& elem.second->type->heroClass->faction == town->faction->index)
+			{
+				pool.push_back(elem.second); //get all available heroes
+			}
+		}
+		if(!pool.size())
+		{
+            logGlobal->errorStream() << "Cannot pick native hero for " << player << ". Picking any...";
+			return pickHeroFor(false, player, town, available);
+		}
+		else
+		{
+			ret = pool[rand()%pool.size()];
+		}
+	}
+	else
+	{
+		int sum=0, r;
+
+		for(auto & elem : available)
+		{
+			if (pavailable.find(elem.first)->second & (1<<player.getNum()) &&    // hero is available
+			    ( !bannedClass || elem.second->type->heroClass != bannedClass) ) // and his class is not same as other hero
+			{
+				pool.push_back(elem.second);
+				sum += elem.second->type->heroClass->selectionProbability[town->faction->index]; //total weight
+			}
+		}
+		if(!pool.size() || sum == 0)
+		{
+            logGlobal->errorStream() << "There are no heroes available for player " << player<<"!";
+			return nullptr;
+		}
+
+		r = rand()%sum;
+		for (auto & elem : pool)
+		{
+			r -= elem->type->heroClass->selectionProbability[town->faction->index];
+			if(r < 0)
+			{
+				ret = elem;
+				break;
+			}
+		}
+		if(!ret)
+			ret = pool.back();
+	}
+
+	available.erase(ret->subID);
+	return ret;
+}
+
+int CGameState::pickHero(PlayerColor owner)
+{
+	const PlayerSettings &ps = scenarioOps->getIthPlayersSettings(owner);
+    if(!isUsedHero(HeroTypeID(ps.hero)) &&  ps.hero >= 0) //we haven't used selected hero
+		return ps.hero;
+
+	if(scenarioOps->mode == StartInfo::CAMPAIGN)
+	{
+		auto bonus = scenarioOps->campState->getBonusForCurrentMap();
+		if(bonus && bonus->type == CScenarioTravel::STravelBonus::HERO && owner == PlayerColor(bonus->info1))
+		{
+			//TODO what if hero chosen as bonus is placed in the prison on map
+			if(bonus->info2 != 0xffff && !isUsedHero(HeroTypeID(bonus->info2))) //not random and not taken
+			{
+				return bonus->info2;
+			}
+		}
+	}
+
+	//list of available heroes for this faction and others
+	std::vector<HeroTypeID> factionHeroes, otherHeroes;
+
+	for(HeroTypeID hid : getUnusedAllowedHeroes())
+	{
+		if(VLC->heroh->heroes[hid.getNum()]->heroClass->faction == ps.castle)
+			factionHeroes.push_back(hid);
+		else
+			otherHeroes.push_back(hid);
+	}
+
+	// select random hero native to "our" faction
+	if (!factionHeroes.empty())
+		return factionHeroes.at(ran() % factionHeroes.size()).getNum();
+
+	logGlobal->warnStream() << "Cannot find free hero of appropriate faction for player " << owner << " - trying to get first available...";
+	if(!otherHeroes.empty())
+		return otherHeroes.at(ran() % otherHeroes.size()).getNum();
+
+	logGlobal->errorStream() << "No free allowed heroes!";
+	auto notAllowedHeroesButStillBetterThanCrash = getUnusedAllowedHeroes(true);
+	if(notAllowedHeroesButStillBetterThanCrash.size())
+		return notAllowedHeroesButStillBetterThanCrash.begin()->getNum();
+
+	logGlobal->errorStream() << "No free heroes at all!";
+	assert(0); //current code can't handle this situation
+	return -1; // no available heroes at all
+}
+
+std::pair<Obj,int> CGameState::pickObject (CGObjectInstance *obj)
+{
+	switch(obj->ID)
+	{
+	case Obj::RANDOM_ART:
+		return std::make_pair(Obj::ARTIFACT, VLC->arth->getRandomArt (CArtifact::ART_TREASURE | CArtifact::ART_MINOR | CArtifact::ART_MAJOR | CArtifact::ART_RELIC));
+	case Obj::RANDOM_TREASURE_ART:
+		return std::make_pair(Obj::ARTIFACT, VLC->arth->getRandomArt (CArtifact::ART_TREASURE));
+	case Obj::RANDOM_MINOR_ART:
+		return std::make_pair(Obj::ARTIFACT, VLC->arth->getRandomArt (CArtifact::ART_MINOR));
+	case Obj::RANDOM_MAJOR_ART:
+		return std::make_pair(Obj::ARTIFACT, VLC->arth->getRandomArt (CArtifact::ART_MAJOR));
+	case Obj::RANDOM_RELIC_ART:
+		return std::make_pair(Obj::ARTIFACT, VLC->arth->getRandomArt (CArtifact::ART_RELIC));
+	case Obj::RANDOM_HERO:
+		return std::make_pair(Obj::HERO, pickHero(obj->tempOwner));
+	case Obj::RANDOM_MONSTER:
+		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran)));
+	case Obj::RANDOM_MONSTER_L1:
+		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 1));
+	case Obj::RANDOM_MONSTER_L2:
+		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 2));
+	case Obj::RANDOM_MONSTER_L3:
+		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 3));
+	case Obj::RANDOM_MONSTER_L4:
+		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 4));
+	case Obj::RANDOM_RESOURCE:
+		return std::make_pair(Obj::RESOURCE,ran()%7); //now it's OH3 style, use %8 for mithril
+	case Obj::RANDOM_TOWN:
+		{
+			PlayerColor align = PlayerColor((static_cast<CGTownInstance*>(obj))->alignment);
+			si32 f; // can be negative (for random)
+			if(align >= PlayerColor::PLAYER_LIMIT)//same as owner / random
+			{
+				if(obj->tempOwner >= PlayerColor::PLAYER_LIMIT)
+					f = -1; //random
+				else
+					f = scenarioOps->getIthPlayersSettings(obj->tempOwner).castle;
+			}
+			else
+			{
+				f = scenarioOps->getIthPlayersSettings(align).castle;
+			}
+			if(f<0)
+			{
+				do
+				{
+					f = ran()%VLC->townh->factions.size();
+				}
+				while (VLC->townh->factions[f]->town == nullptr); // find playable faction
+			}
+			return std::make_pair(Obj::TOWN,f);
+		}
+	case Obj::RANDOM_MONSTER_L5:
+		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 5));
+	case Obj::RANDOM_MONSTER_L6:
+		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 6));
+	case Obj::RANDOM_MONSTER_L7:
+		return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(std::ref(ran), 7));
+	case Obj::RANDOM_DWELLING:
+	case Obj::RANDOM_DWELLING_LVL:
+	case Obj::RANDOM_DWELLING_FACTION:
+		{
+			CGDwelling * dwl = static_cast<CGDwelling*>(obj);
+			int faction;
+
+			//if castle alignment available
+			if (auto info = dynamic_cast<CCreGenAsCastleInfo*>(dwl->info))
+			{
+				faction = ran() % VLC->townh->factions.size();
+				if (info->asCastle)
+				{
+					for(auto & elem : map->objects)
+					{
+						if(!elem)
+							continue;
+
+						if(elem->ID==Obj::RANDOM_TOWN
+							&& dynamic_cast<CGTownInstance*>(elem.get())->identifier == info->identifier)
+						{
+							randomizeObject(elem); //we have to randomize the castle first
+							faction = elem->subID;
+							break;
+						}
+						else if(elem->ID==Obj::TOWN
+							&& dynamic_cast<CGTownInstance*>(elem.get())->identifier == info->identifier)
+						{
+							faction = elem->subID;
+							break;
+						}
+					}
+				}
+				else
+				{
+					while((!(info->castles[0]&(1<<faction))))
+					{
+						if((faction>7) && (info->castles[1]&(1<<(faction-8))))
+							break;
+						faction = ran()%GameConstants::F_NUMBER;
+					}
+				}
+			}
+			else // castle alignment fixed
+				faction = obj->subID;
+
+			int level;
+
+			//if level set to range
+			if (auto info = dynamic_cast<CCreGenLeveledInfo*>(dwl->info))
+				level = ((info->maxLevel-info->minLevel) ? (ran()%(info->maxLevel-info->minLevel)+info->minLevel) : (info->minLevel));
+			else // fixed level
+				level = obj->subID;
+
+			delete dwl->info;
+			dwl->info = nullptr;
+
+			std::pair<Obj, int> result(Obj::NO_OBJ, -1);
+			CreatureID cid = VLC->townh->factions[faction]->town->creatures[level][0];
+
+			//golem factory is not in list of cregens but can be placed as random object
+			static const CreatureID factoryCreatures[] = {CreatureID::STONE_GOLEM, CreatureID::IRON_GOLEM,
+				CreatureID::GOLD_GOLEM, CreatureID::DIAMOND_GOLEM};
+			std::vector<CreatureID> factory(factoryCreatures, factoryCreatures + ARRAY_COUNT(factoryCreatures));
+			if (vstd::contains(factory, cid))
+				result = std::make_pair(Obj::CREATURE_GENERATOR4, 1);
+
+			//NOTE: this will pick last dwelling with this creature (Mantis #900)
+			//check for block map equality is better but more complex solution
+			for(auto &iter : VLC->objh->cregens)
+				if (iter.second == cid)
+					result = std::make_pair(Obj::CREATURE_GENERATOR1, iter.first);
+
+			if (result.first == Obj::NO_OBJ)
+			{
+                logGlobal->errorStream() << "Error: failed to find creature for dwelling of "<< int(faction) << " of level " << int(level);
+				auto iter = VLC->objh->cregens.begin();
+				std::advance(iter, ran() % VLC->objh->cregens.size() );
+				result = std::make_pair(Obj::CREATURE_GENERATOR1, iter->first);
+			}
+
+			return result;
+		}
+	}
+	return std::make_pair(Obj::NO_OBJ,-1);
+}
+
+void CGameState::randomizeObject(CGObjectInstance *cur)
+{
+	std::pair<Obj,int> ran = pickObject(cur);
+	if(ran.first == Obj::NO_OBJ || ran.second<0) //this is not a random object, or we couldn't find anything
+	{
+		if(cur->ID==Obj::TOWN) //town - set def
+		{
+			CGTownInstance *t = dynamic_cast<CGTownInstance*>(cur);
+			t->town = VLC->townh->factions[t->subID]->town;
+			if(t->hasCapitol())
+				t->defInfo = VLC->dobjinfo->capitols[t->subID];
+			else if(t->hasFort())
+				t->defInfo = VLC->dobjinfo->gobjs[Obj::TOWN][t->subID];
+			else
+				t->defInfo = VLC->dobjinfo->villages[t->subID];
+		}
+		return;
+	}
+	else if(ran.first==Obj::HERO)//special code for hero
+	{
+		CGHeroInstance *h = dynamic_cast<CGHeroInstance *>(cur);
+        if(!h) {logGlobal->warnStream()<<"Wrong random hero at "<<cur->pos; return;}
+		cur->ID = ran.first;
+		cur->subID = ran.second;
+		h->type = VLC->heroh->heroes[ran.second];
+		h->portrait = h->type->imageIndex;
+		h->randomizeArmy(h->type->heroClass->faction);
+		map->heroesOnMap.push_back(h);
+		return; //TODO: maybe we should do something with definfo?
+	}
+	else if(ran.first==Obj::TOWN)//special code for town
+	{
+		CGTownInstance *t = dynamic_cast<CGTownInstance*>(cur);
+        if(!t) {logGlobal->warnStream()<<"Wrong random town at "<<cur->pos; return;}
+		cur->ID = ran.first;
+		cur->subID = ran.second;
+		//FIXME: copy-pasted from above
+		t->town = VLC->townh->factions[t->subID]->town;
+		if(t->hasCapitol())
+			t->defInfo = VLC->dobjinfo->capitols[t->subID];
+		else if(t->hasFort())
+			t->defInfo = VLC->dobjinfo->gobjs[Obj::TOWN][t->subID];
+		else
+			t->defInfo = VLC->dobjinfo->villages[t->subID];
+		t->randomizeArmy(t->subID);
+		map->towns.push_back(t);
+		return;
+	}
+	//we have to replace normal random object
+	cur->ID = ran.first;
+	cur->subID = ran.second;
+	map->removeBlockVisTiles(cur); //recalculate blockvis tiles - picked object might have different than random placeholder
+	map->customDefs.push_back(cur->defInfo = ran.first.toDefObjInfo()[ran.second]);
+	if(!cur->defInfo)
+	{
+        logGlobal->errorStream()<<"*BIG* WARNING: Missing def declaration for "<<cur->ID<<" "<<cur->subID;
+		return;
+	}
+
+	map->addBlockVisTiles(cur);
+}
+
+int CGameState::getDate(Date::EDateType mode) const
+{
+	int temp;
+	switch (mode)
+	{
+	case Date::DAY:
+		return day;
+	case Date::DAY_OF_WEEK: //day of week
+		temp = (day)%7; // 1 - Monday, 7 - Sunday
+		return temp ? temp : 7;
+	case Date::WEEK:  //current week
+		temp = ((day-1)/7)+1;
+		if (!(temp%4))
+			return 4;
+		else
+			return (temp%4);
+	case Date::MONTH: //current month
+		return ((day-1)/28)+1;
+	case Date::DAY_OF_MONTH: //day of month
+		temp = (day)%28;
+		if (temp)
+			return temp;
+		else return 28;
+	}
+	return 0;
+}
+CGameState::CGameState()
+{
+	gs = this;
+	mx = new boost::shared_mutex();
+	applierGs = new CApplier<CBaseForGSApply>;
+	registerTypes2(*applierGs);
+	objCaller = new CObjectCallersHandler;
+	globalEffects.setDescription("Global effects");
+}
+CGameState::~CGameState()
+{
+	//delete mx;//TODO: crash on Linux (mutex must be unlocked before destruction)
+	map.dellNull();
+	curB.dellNull();
+	//delete scenarioOps; //TODO: fix for loading ind delete
+	//delete initialOpts;
+	delete applierGs;
+	delete objCaller;
+
+	for(auto ptr : hpool.heroesPool) // clean hero pool
+		ptr.second.dellNull();
+}
+
+BattleInfo * CGameState::setupBattle(int3 tile, const CArmedInstance *armies[2], const CGHeroInstance * heroes[2], bool creatureBank, const CGTownInstance *town)
+{
+	const TerrainTile &t = map->getTile(tile);
+    ETerrainType terrain = t.terType;
+	if(t.isCoastal() && !t.isWater())
+        terrain = ETerrainType::SAND;
+
+	BFieldType terType = battleGetBattlefieldType(tile);
+	return BattleInfo::setupBattle(tile, terrain, terType, armies, heroes, creatureBank, town);
+}
+
+void CGameState::init(StartInfo * si)
+{
+	auto giveCampaignBonusToHero = [&](CGHeroInstance * hero)
+	{
+		const boost::optional<CScenarioTravel::STravelBonus> & curBonus = scenarioOps->campState->getBonusForCurrentMap();
+		if(!curBonus)
+			return;
+
+		if(curBonus->isBonusForHero())
+		{
+			//apply bonus
+			switch (curBonus->type)
+			{
+			case CScenarioTravel::STravelBonus::SPELL:
+				hero->spells.insert(SpellID(curBonus->info2));
+				break;
+			case CScenarioTravel::STravelBonus::MONSTER:
+				{
+					for(int i=0; i<GameConstants::ARMY_SIZE; i++)
+					{
+						if(hero->slotEmpty(SlotID(i)))
+						{
+							hero->addToSlot(SlotID(i), CreatureID(curBonus->info2), curBonus->info3);
+							break;
+						}
+					}
+				}
+				break;
+			case CScenarioTravel::STravelBonus::ARTIFACT:
+				gs->giveHeroArtifact(hero, static_cast<ArtifactID>(curBonus->info2));
+				break;
+			case CScenarioTravel::STravelBonus::SPELL_SCROLL:
+				{
+					CArtifactInstance * scroll = CArtifactInstance::createScroll(SpellID(curBonus->info2).toSpell());
+					scroll->putAt(ArtifactLocation(hero, scroll->firstAvailableSlot(hero)));
+				}
+				break;
+			case CScenarioTravel::STravelBonus::PRIMARY_SKILL:
+				{
+					const ui8* ptr = reinterpret_cast<const ui8*>(&curBonus->info2);
+					for (int g=0; g<GameConstants::PRIMARY_SKILLS; ++g)
+					{
+						int val = ptr[g];
+						if (val == 0)
+						{
+							continue;
+						}
+						auto bb = new Bonus(Bonus::PERMANENT, Bonus::PRIMARY_SKILL, Bonus::CAMPAIGN_BONUS, val, scenarioOps->campState->currentMap, g);
+						hero->addNewBonus(bb);
+					}
+				}
+				break;
+			case CScenarioTravel::STravelBonus::SECONDARY_SKILL:
+				hero->setSecSkillLevel(SecondarySkill(curBonus->info2), curBonus->info3, true);
+				break;
+			}
+		}
+	};
+
+	auto getHumanPlayerInfo = [&]() -> std::vector<const PlayerSettings *>
+	{
+		std::vector<const PlayerSettings *> ret;
+		for(auto it = scenarioOps->playerInfos.cbegin();
+			it != scenarioOps->playerInfos.cend(); ++it)
+		{
+			if(it->second.playerID != PlayerSettings::PLAYER_AI)
+				ret.push_back(&it->second);
+		}
+
+		return ret;
+	};
+
+    logGlobal->infoStream() << "\tUsing random seed: "<< si->seedToBeUsed;
+	ran.seed((boost::int32_t)si->seedToBeUsed);
+	scenarioOps = new StartInfo(*si);
+	initialOpts = new StartInfo(*si);
+	si = nullptr;
+
+	switch(scenarioOps->mode)
+	{
+	case StartInfo::NEW_GAME:
+		{
+			if(scenarioOps->createRandomMap())
+			{
+                logGlobal->infoStream() << "Create random map.";
+				CStopWatch sw;
+
+				// Gen map
+				CMapGenerator mapGenerator;
+				map = mapGenerator.generate(scenarioOps->mapGenOptions.get(), scenarioOps->seedToBeUsed).release();
+
+				// Update starting options
+				for(int i = 0; i < map->players.size(); ++i)
+				{
+                    const auto & playerInfo = map->players[i];
+                    if(playerInfo.canAnyonePlay())
+					{
+                        PlayerSettings & playerSettings = scenarioOps->playerInfos[PlayerColor(i)];
+                        playerSettings.compOnly = !playerInfo.canHumanPlay;
+                        playerSettings.team = playerInfo.team;
+                        playerSettings.castle = playerInfo.defaultCastle();
+                        if(playerSettings.playerID == PlayerSettings::PLAYER_AI && playerSettings.name.empty())
+						{
+                            playerSettings.name = VLC->generaltexth->allTexts[468];
+						}
+                        playerSettings.color = PlayerColor(i);
+					}
+					else
+					{
+						scenarioOps->playerInfos.erase(PlayerColor(i));
+					}
+				}
+
+				logGlobal->infoStream() << boost::format("Generated random map in %i ms.") % sw.getDiff();
+			}
+			else
+			{
+                logGlobal->infoStream() << "Open map file: " << scenarioOps->mapname;
+				map = CMapService::loadMap(scenarioOps->mapname).release();
+			}
+		}
+		break;
+	case StartInfo::CAMPAIGN:
+		{
+            logGlobal->infoStream() << "Open campaign map file: " << scenarioOps->campState->currentMap;
+			auto campaign = scenarioOps->campState;
+			assert(vstd::contains(campaign->camp->mapPieces, scenarioOps->campState->currentMap));
+
+			std::string & mapContent = campaign->camp->mapPieces[scenarioOps->campState->currentMap];
+			auto buffer = reinterpret_cast<const ui8 *>(mapContent.data());
+			map = CMapService::loadMap(buffer, mapContent.size()).release();
+		}
+		break;
+	case StartInfo::DUEL:
+		initDuel();
+		return;
+	default:
+        logGlobal->errorStream() << "Wrong mode: " << (int)scenarioOps->mode;
+		return;
+	}
+	VLC->arth->initAllowedArtifactsList(map->allowedArtifact);
+    logGlobal->infoStream() << "Map loaded!";
+
+    logGlobal->infoStream() << "\tOur checksum for the map: "<< map->checksum;
+	if(scenarioOps->mapfileChecksum)
+	{
+        logGlobal->infoStream() << "\tServer checksum for " << scenarioOps->mapname <<": "<< scenarioOps->mapfileChecksum;
+		if(map->checksum != scenarioOps->mapfileChecksum)
+		{
+            logGlobal->errorStream() << "Wrong map checksum!!!";
+			throw std::runtime_error("Wrong checksum");
+		}
+	}
+	else
+		scenarioOps->mapfileChecksum = map->checksum;
+
+	day = 0;
+
+    logGlobal->debugStream() << "Initialization:";
+    logGlobal->debugStream() << "\tPicking grail position";
+ 	//pick grail location
+ 	if(map->grailPos.x < 0 || map->grailRadious) //grail not set or set within a radius around some place
+ 	{
+		if(!map->grailRadious) //radius not given -> anywhere on map
+			map->grailRadious = map->width * 2;
+
+ 		std::vector<int3> allowedPos;
+		static const int BORDER_WIDTH = 9; // grail must be at least 9 tiles away from border
+
+		// add all not blocked tiles in range
+		for (int i = BORDER_WIDTH; i < map->width - BORDER_WIDTH ; i++)
+		{
+			for (int j = BORDER_WIDTH; j < map->height - BORDER_WIDTH; j++)
+			{
+				for (int k = 0; k < (map->twoLevel ? 2 : 1); k++)
+				{
+					const TerrainTile &t = map->getTile(int3(i, j, k));
+					if(!t.blocked
+						&& !t.visitable
+                        && t.terType != ETerrainType::WATER
+                        && t.terType != ETerrainType::ROCK
+						&& map->grailPos.dist2d(int3(i,j,k)) <= map->grailRadious)
+ 						allowedPos.push_back(int3(i,j,k));
+ 				}
+ 			}
+ 		}
+
+		//remove tiles with holes
+		for(auto & elem : map->objects)
+			if(elem && elem->ID == Obj::HOLE)
+				allowedPos -= elem->pos;
+
+		if(allowedPos.size())
+			map->grailPos = allowedPos[ran() % allowedPos.size()];
+		else
+            logGlobal->warnStream() << "Warning: Grail cannot be placed, no appropriate tile found!";
+	}
+
+	//picking random factions for players
+    logGlobal->debugStream() << "\tPicking random factions for players";
+	for(auto & elem : scenarioOps->playerInfos)
+	{
+		if(elem.second.castle==-1)
+		{
+			int randomID = ran() % map->players[elem.first.getNum()].allowedFactions.size();
+			auto iter = map->players[elem.first.getNum()].allowedFactions.begin();
+			std::advance(iter, randomID);
+
+			elem.second.castle = *iter;
+		}
+	}
+
+	//randomizing objects
+    logGlobal->debugStream() << "\tRandomizing objects";
+	for(CGObjectInstance *obj : map->objects)
+	{
+		if(!obj)
+			continue;
+
+		randomizeObject(obj);
+		obj->hoverName = VLC->generaltexth->names[obj->ID];
+
+		//handle Favouring Winds - mark tiles under it
+		if(obj->ID == Obj::FAVORABLE_WINDS)
+			for (int i = 0; i < obj->getWidth() ; i++)
+				for (int j = 0; j < obj->getHeight() ; j++)
+				{
+					int3 pos = obj->pos - int3(i,j,0);
+					if(map->isInTheMap(pos))
+                        map->getTile(pos).extTileFlags |= 128;
+				}
+	}
+
+	/*********creating players entries in gs****************************************/
+    logGlobal->debugStream() << "\tCreating player entries in gs";
+	for(auto & elem : scenarioOps->playerInfos)
+	{
+		std::pair<PlayerColor, PlayerState> ins(elem.first,PlayerState());
+		ins.second.color=ins.first;
+		ins.second.human = elem.second.playerID;
+		ins.second.team = map->players[ins.first.getNum()].team;
+		teams[ins.second.team].id = ins.second.team;//init team
+		teams[ins.second.team].players.insert(ins.first);//add player to team
+		players.insert(ins);
+	}
+
+	/*************************replace hero placeholders*****************************/
+	if (scenarioOps->campState)
+	{
+		logGlobal->debugStream() << "\tReplacing hero placeholders";
+		std::vector<std::pair<CGHeroInstance*, ObjectInstanceID> > campHeroReplacements = campaignHeroesToReplace();
+		//Replace placeholders with heroes from previous missions
+		logGlobal->debugStream() << "\tSetting up heroes";
+		placeCampaignHeroes(campHeroReplacements);
+	}
+
+
+	/*********give starting hero****************************************/
+    logGlobal->debugStream() << "\tGiving starting hero";
+	{
+		bool campaignGiveHero = false;
+		if(scenarioOps->campState)
+		{
+			if(auto bonus = scenarioOps->campState->getBonusForCurrentMap())
+			{
+				campaignGiveHero =  scenarioOps->mode == StartInfo::CAMPAIGN &&
+					bonus.get().type == CScenarioTravel::STravelBonus::HERO;
+			}
+		}
+
+		for(auto it = scenarioOps->playerInfos.begin(); it != scenarioOps->playerInfos.end(); ++it)
+		{
+			const PlayerInfo &p = map->players[it->first.getNum()];
+			bool generateHero = (p.generateHeroAtMainTown ||
+			                     (it->second.playerID != PlayerSettings::PLAYER_AI && campaignGiveHero)) && p.hasMainTown;
+			if(generateHero && vstd::contains(scenarioOps->playerInfos, it->first))
+			{
+				int3 hpos = p.posOfMainTown;
+				hpos.x+=1;
+
+				int h = pickHero(it->first);
+				if(it->second.hero == -1)
+					it->second.hero = h;
+
+				CGHeroInstance * nnn =  static_cast<CGHeroInstance*>(createObject(Obj::HERO,h,hpos,it->first));
+				nnn->id = ObjectInstanceID(map->objects.size());
+				nnn->initHero();
+				map->heroesOnMap.push_back(nnn);
+				map->objects.push_back(nnn);
+				map->addBlockVisTiles(nnn);
+			}
+		}
+	}
+
+	/******************RESOURCES****************************************************/
+    logGlobal->debugStream() << "\tSetting up resources";
+	const JsonNode config(ResourceID("config/startres.json"));
+	const JsonVector &vector = config["difficulty"].Vector();
+	const JsonNode &level = vector[scenarioOps->difficulty];
+
+	TResources startresAI(level["ai"]);
+	TResources startresHuman(level["human"]);
+
+	for (auto & elem : players)
+	{
+		PlayerState &p = elem.second;
+
+		if (p.human)
+			p.resources = startresHuman;
+		else
+			p.resources = startresAI;
+	}
+
+	//give start resource bonus in case of campaign
+	if (scenarioOps->mode == StartInfo::CAMPAIGN)
+	{
+		auto chosenBonus = scenarioOps->campState->getBonusForCurrentMap();
+		if(chosenBonus && chosenBonus->type == CScenarioTravel::STravelBonus::RESOURCE)
+		{
+			std::vector<const PlayerSettings *> people = getHumanPlayerInfo(); //players we will give resource bonus
+			for(const PlayerSettings *ps : people)
+			{
+				std::vector<int> res; //resources we will give
+				switch (chosenBonus->info1)
+				{
+				case 0: case 1: case 2: case 3: case 4: case 5: case 6:
+					res.push_back(chosenBonus->info1);
+					break;
+				case 0xFD: //wood+ore
+					res.push_back(Res::WOOD); res.push_back(Res::ORE);
+					break;
+				case 0xFE:  //rare
+					res.push_back(Res::MERCURY); res.push_back(Res::SULFUR); res.push_back(Res::CRYSTAL); res.push_back(Res::GEMS);
+					break;
+				default:
+					assert(0);
+					break;
+				}
+				//increasing resource quantity
+				for (auto & re : res)
+				{
+					players[ps->color].resources[re] += chosenBonus->info2;
+				}
+			}
+		}
+	}
+
+
+	/*************************HEROES INIT / POOL************************************************/
+	for(auto hero : map->heroesOnMap)  //heroes instances initialization
+	{
+		if (hero->getOwner() == PlayerColor::UNFLAGGABLE)
+		{
+            logGlobal->warnStream() << "Warning - hero with uninitialized owner!";
+			continue;
+		}
+
+		hero->initHero();
+		getPlayer(hero->getOwner())->heroes.push_back(hero);
+		map->allHeroes[hero->type->ID.getNum()] = hero;
+	}
+
+	for(auto obj : map->objects) //prisons
+	{
+		if(obj && obj->ID == Obj::PRISON)
+			map->allHeroes[obj->subID] = dynamic_cast<CGHeroInstance*>(obj.get());
+	}
+
+	std::set<HeroTypeID> heroesToCreate = getUnusedAllowedHeroes(); //ids of heroes to be created and put into the pool
+	for(auto ph : map->predefinedHeroes)
+	{
+		if(!vstd::contains(heroesToCreate, HeroTypeID(ph->subID)))
+			continue;
+		ph->initHero();
+		hpool.heroesPool[ph->subID] = ph;
+		hpool.pavailable[ph->subID] = 0xff;
+		heroesToCreate.erase(ph->type->ID);
+
+		map->allHeroes[ph->subID] = ph;
+	}
+
+	for(HeroTypeID htype : heroesToCreate) //all not used allowed heroes go with default state into the pool
+	{
+		auto  vhi = new CGHeroInstance();
+		vhi->initHero(htype);
+
+		int typeID = htype.getNum();
+		map->allHeroes[typeID] = vhi;
+		hpool.heroesPool[typeID] = vhi;
+		hpool.pavailable[typeID] = 0xff;
+	}
+
+	for(auto & elem : map->disposedHeroes)
+	{
+        hpool.pavailable[elem.heroId] = elem.players;
+	}
+
+	if (scenarioOps->mode == StartInfo::CAMPAIGN) //give campaign bonuses for specific / best hero
+	{
+		auto chosenBonus = scenarioOps->campState->getBonusForCurrentMap();
+		if (chosenBonus && chosenBonus->isBonusForHero() && chosenBonus->info1 != 0xFFFE) //exclude generated heroes
+		{
+			//find human player
+			PlayerColor humanPlayer=PlayerColor::NEUTRAL;
+			for (auto & elem : players)
+			{
+				if(elem.second.human)
+				{
+					humanPlayer = elem.first;
+					break;
+				}
+			}
+			assert(humanPlayer != PlayerColor::NEUTRAL);
+
+			std::vector<ConstTransitivePtr<CGHeroInstance> > & heroes = players[humanPlayer].heroes;
+
+			if (chosenBonus->info1 == 0xFFFD) //most powerful
+			{
+				int maxB = -1;
+				for (int b=0; b<heroes.size(); ++b)
+				{
+					if (maxB == -1 || heroes[b]->getTotalStrength() > heroes[maxB]->getTotalStrength())
+					{
+						maxB = b;
+					}
+				}
+				if(maxB < 0)
+                    logGlobal->warnStream() << "Warning - cannot give bonus to hero cause there are no heroes!";
+				else
+					giveCampaignBonusToHero(heroes[maxB]);
+			}
+			else //specific hero
+			{
+				for (auto & heroe : heroes)
+				{
+					if (heroe->subID == chosenBonus->info1)
+					{
+						giveCampaignBonusToHero(heroe);
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	/*************************FOG**OF**WAR******************************************/
+    logGlobal->debugStream() << "\tFog of war"; //FIXME: should be initialized after all bonuses are set
+	for(auto & elem : teams)
+	{
+		elem.second.fogOfWarMap.resize(map->width);
+		for(int g=0; g<map->width; ++g)
+			elem.second.fogOfWarMap[g].resize(map->height);
+
+		for(int g=-0; g<map->width; ++g)
+			for(int h=0; h<map->height; ++h)
+				elem.second.fogOfWarMap[g][h].resize(map->twoLevel ? 2 : 1, 0);
+
+		for(int g=0; g<map->width; ++g)
+			for(int h=0; h<map->height; ++h)
+				for(int v = 0; v < (map->twoLevel ? 2 : 1); ++v)
+					elem.second.fogOfWarMap[g][h][v] = 0;
+
+		for(CGObjectInstance *obj : map->objects)
+		{
+			if(!obj || !vstd::contains(elem.second.players, obj->tempOwner)) continue; //not a flagged object
+
+			std::unordered_set<int3, ShashInt3> tiles;
+			obj->getSightTiles(tiles);
+			for(int3 tile : tiles)
+			{
+				elem.second.fogOfWarMap[tile.x][tile.y][tile.z] = 1;
+			}
+		}
+	}
+
+    logGlobal->debugStream() << "\tStarting bonuses";
+	for(auto & elem : players)
+	{
+		//starting bonus
+		if(scenarioOps->playerInfos[elem.first].bonus==PlayerSettings::RANDOM)
+			scenarioOps->playerInfos[elem.first].bonus = static_cast<PlayerSettings::Ebonus>(ran()%3);
+		switch(scenarioOps->playerInfos[elem.first].bonus)
+		{
+		case PlayerSettings::GOLD:
+			elem.second.resources[Res::GOLD] += 500 + (ran()%6)*100;
+			break;
+		case PlayerSettings::RESOURCE:
+			{
+				int res = VLC->townh->factions[scenarioOps->playerInfos[elem.first].castle]->town->primaryRes;
+				if(res == Res::WOOD_AND_ORE)
+				{
+					elem.second.resources[Res::WOOD] += 5 + ran()%6;
+					elem.second.resources[Res::ORE] += 5 + ran()%6;
+				}
+				else
+				{
+					elem.second.resources[res] += 3 + ran()%4;
+				}
+				break;
+			}
+		case PlayerSettings::ARTIFACT:
+			{
+ 				if(!elem.second.heroes.size())
+				{
+                    logGlobal->debugStream() << "Cannot give starting artifact - no heroes!";
+					break;
+				}
+ 				CArtifact *toGive;
+ 				toGive = VLC->arth->artifacts[VLC->arth->getRandomArt (CArtifact::ART_TREASURE)];
+
+				CGHeroInstance *hero = elem.second.heroes[0];
+ 				giveHeroArtifact(hero, toGive->id);
+			}
+			break;
+		}
+	}
+	/****************************TOWNS************************************************/
+    logGlobal->debugStream() << "\tTowns";
+
+	//campaign bonuses for towns
+	if (scenarioOps->mode == StartInfo::CAMPAIGN)
+	{
+		auto chosenBonus = scenarioOps->campState->getBonusForCurrentMap();
+
+		if (chosenBonus && chosenBonus->type == CScenarioTravel::STravelBonus::BUILDING)
+		{
+			for (int g=0; g<map->towns.size(); ++g)
+			{
+				PlayerState * owner = getPlayer(map->towns[g]->getOwner());
+				if (owner)
+				{
+					PlayerInfo & pi = map->players[owner->color.getNum()];
+
+					if (owner->human && //human-owned
+						map->towns[g]->pos == pi.posOfMainTown + int3(2, 0, 0))
+					{
+						map->towns[g]->builtBuildings.insert(
+							CBuildingHandler::campToERMU(chosenBonus->info1, map->towns[g]->subID, map->towns[g]->builtBuildings));
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	CGTownInstance::universitySkills.clear();
+	for ( int i=0; i<4; i++)
+		CGTownInstance::universitySkills.push_back(14+i);//skills for university
+
+	for (auto & elem : map->towns)
+	{
+		CGTownInstance * vti =(elem);
+		if(!vti->town)
+			vti->town = VLC->townh->factions[vti->subID]->town;
+		if (vti->name.length()==0) // if town hasn't name we draw it
+			vti->name = vti->town->names[ran()%vti->town->names.size()];
+
+		//init buildings
+		if(vstd::contains(vti->builtBuildings, BuildingID::DEFAULT)) //give standard set of buildings
+		{
+			vti->builtBuildings.erase(BuildingID::DEFAULT);
+			vti->builtBuildings.insert(BuildingID::VILLAGE_HALL);
+			vti->builtBuildings.insert(BuildingID::TAVERN);
+			vti->builtBuildings.insert(BuildingID::DWELL_FIRST);
+			if(ran()%2)
+				vti->builtBuildings.insert(BuildingID::DWELL_LVL_2);
+		}
+
+		//#1444 - remove entries that don't have buildings defined (like some unused extra town hall buildings)
+		vstd::erase_if(vti->builtBuildings, [vti](BuildingID bid){  
+			return !vti->town->buildings.count(bid) || !vti->town->buildings.at(bid); });
+
+		if (vstd::contains(vti->builtBuildings, BuildingID::SHIPYARD) && vti->shipyardStatus()==IBoatGenerator::TILE_BLOCKED)
+			vti->builtBuildings.erase(BuildingID::SHIPYARD);//if we have harbor without water - erase it (this is H3 behaviour)
+
+		//init hordes
+		for (int i = 0; i<GameConstants::CREATURES_PER_TOWN; i++)
+			if (vstd::contains(vti->builtBuildings,(-31-i))) //if we have horde for this level
+			{
+				vti->builtBuildings.erase(BuildingID(-31-i));//remove old ID
+				if (vti->town->hordeLvl.at(0) == i)//if town first horde is this one
+				{
+					vti->builtBuildings.insert(BuildingID::HORDE_1);//add it
+					if (vstd::contains(vti->builtBuildings,(BuildingID::DWELL_UP_FIRST+i)))//if we have upgraded dwelling as well
+						vti->builtBuildings.insert(BuildingID::HORDE_1_UPGR);//add it as well
+				}
+				if (vti->town->hordeLvl.at(1) == i)//if town second horde is this one
+				{
+					vti->builtBuildings.insert(BuildingID::HORDE_2);
+					if (vstd::contains(vti->builtBuildings,(BuildingID::DWELL_UP_FIRST+i)))
+						vti->builtBuildings.insert(BuildingID::HORDE_2_UPGR);
+				}
+			}
+
+		//Early check for #1444-like problems
+		for(auto building : vti->builtBuildings)
+		{
+			assert(vti->town->buildings.at(building) != nullptr);
+			UNUSED(building);
+		}
+
+		//town events
+		for(CCastleEvent &ev : vti->events)
+		{
+			for (int i = 0; i<GameConstants::CREATURES_PER_TOWN; i++)
+				if (vstd::contains(ev.buildings,(-31-i))) //if we have horde for this level
+				{
+					ev.buildings.erase(BuildingID(-31-i));
+					if (vti->town->hordeLvl.at(0) == i)
+						ev.buildings.insert(BuildingID::HORDE_1);
+					if (vti->town->hordeLvl.at(1) == i)
+						ev.buildings.insert(BuildingID::HORDE_2);
+				}
+		}
+		//init spells
+		vti->spells.resize(GameConstants::SPELL_LEVELS);
+
+		for(ui32 z=0; z<vti->obligatorySpells.size();z++)
+		{
+			CSpell *s = vti->obligatorySpells[z].toSpell();
+			vti->spells[s->level-1].push_back(s->id);
+			vti->possibleSpells -= s->id;
+		}
+		while(vti->possibleSpells.size())
+		{
+			ui32 total=0;
+			int sel = -1;
+
+			for(ui32 ps=0;ps<vti->possibleSpells.size();ps++)
+				total += vti->possibleSpells[ps].toSpell()->probabilities[vti->subID];
+
+			if (total == 0) // remaining spells have 0 probability
+				break;
+
+			int r = ran()%total;
+			for(ui32 ps=0; ps<vti->possibleSpells.size();ps++)
+			{
+				r -= vti->possibleSpells[ps].toSpell()->probabilities[vti->subID];
+				if(r<0)
+				{
+					sel = ps;
+					break;
+				}
+			}
+			if(sel<0)
+				sel=0;
+
+			CSpell *s = vti->possibleSpells[sel].toSpell();
+			vti->spells[s->level-1].push_back(s->id);
+			vti->possibleSpells -= s->id;
+		}
+		vti->possibleSpells.clear();
+		if(vti->getOwner() != PlayerColor::NEUTRAL)
+			getPlayer(vti->getOwner())->towns.push_back(vti);
+	}
+
+    logGlobal->debugStream() << "\tObject initialization";
+	objCaller->preInit();
+	for(CGObjectInstance *obj : map->objects)
+	{
+		if(obj)
+			obj->initObj();
+	}
+	for(CGObjectInstance *obj : map->objects)
+	{
+		if(!obj)
+			continue;
+
+		switch (obj->ID)
+		{
+			case Obj::QUEST_GUARD:
+			case Obj::SEER_HUT:
+			{
+				auto q = static_cast<CGSeerHut*>(obj);
+				assert (q);
+				q->setObjToKill();
+			}
+		}
+	}
+	CGTeleport::postInit(); //pairing subterranean gates
+
+	buildBonusSystemTree();
+
+	for(auto k=players.begin(); k!=players.end(); ++k)
+	{
+		if(k->first==PlayerColor::NEUTRAL)
+			continue;
+
+		//init visiting and garrisoned heroes
+		for(CGHeroInstance *h : k->second.heroes)
+		{
+			for(CGTownInstance *t : k->second.towns)
+			{
+				int3 vistile = t->pos; vistile.x--; //tile next to the entrance
+				if(vistile == h->pos || h->pos==t->pos)
+				{
+					t->setVisitingHero(h);
+					if(h->pos == t->pos) //visiting hero placed in the editor has same pos as the town - we need to correct it
+					{
+						map->removeBlockVisTiles(h);
+						h->pos.x -= 1;
+						map->addBlockVisTiles(h);
+					}
+					break;
+				}
+			}
+		}
+	}
+
+
+    logGlobal->debugStream() << "\tChecking objectives";
+	map->checkForObjectives(); //needs to be run when all objects are properly placed
+
+	int seedAfterInit = ran();
+    logGlobal->infoStream() << "Seed after init is " << seedAfterInit << " (before was " << scenarioOps->seedToBeUsed << ")";
+	if(scenarioOps->seedPostInit > 0)
+	{
+		//RNG must be in the same state on all machines when initialization is done (otherwise we have desync)
+		assert(scenarioOps->seedPostInit == seedAfterInit);
+	}
+	else
+	{
+		scenarioOps->seedPostInit = seedAfterInit; //store the post init "seed"
+	}
+}
+
+void CGameState::initDuel()
+{
+	DuelParameters dp;
+	try //CLoadFile likes throwing
+	{
+		if(boost::algorithm::ends_with(scenarioOps->mapname, ".json"))
+		{
+            logGlobal->infoStream() << "Loading duel settings from JSON file: " << scenarioOps->mapname;
+			dp = DuelParameters::fromJSON(scenarioOps->mapname);
+            logGlobal->infoStream() << "JSON file has been successfully read!";
+		}
+		else
+		{
+			CLoadFile lf(scenarioOps->mapname);
+			lf >> dp;
+		}
+	}
+	catch(...)
+	{
+        logGlobal->errorStream() << "Cannot load duel settings from " << scenarioOps->mapname;
+		throw;
+	}
+
+	const CArmedInstance *armies[2] = {nullptr};
+	const CGHeroInstance *heroes[2] = {nullptr};
+	CGTownInstance *town = nullptr;
+
+	for(int i = 0; i < 2; i++)
+	{
+		CArmedInstance *obj = nullptr;
+		if(dp.sides[i].heroId >= 0)
+		{
+			const DuelParameters::SideSettings &ss = dp.sides[i];
+			auto h = new CGHeroInstance();
+			armies[i] = heroes[i] = h;
+			obj = h;
+			h->subID = ss.heroId;
+			for(int i = 0; i < ss.heroPrimSkills.size(); i++)
+				h->pushPrimSkill(static_cast<PrimarySkill::PrimarySkill>(i), ss.heroPrimSkills[i]);
+
+			if(!ss.spells.empty())
+			{
+				h->putArtifact(ArtifactPosition::SPELLBOOK, CArtifactInstance::createNewArtifactInstance(0));
+				boost::copy(ss.spells, std::inserter(h->spells, h->spells.begin()));
+			}
+
+			for(auto &parka : ss.artifacts)
+			{
+				h->putArtifact(ArtifactPosition(parka.first), parka.second);
+			}
+
+			typedef const std::pair<si32, si8> &TSecSKill;
+			for(TSecSKill secSkill : ss.heroSecSkills)
+				h->setSecSkillLevel(SecondarySkill(secSkill.first), secSkill.second, 1);
+
+			h->initHero(HeroTypeID(h->subID));
+			obj->initObj();
+		}
+		else
+		{
+			auto c = new CGCreature();
+			armies[i] = obj = c;
+			//c->subID = 34;
+		}
+
+		obj->setOwner(PlayerColor(i));
+
+		for(int j = 0; j < ARRAY_COUNT(dp.sides[i].stacks); j++)
+		{
+			CreatureID cre = dp.sides[i].stacks[j].type;
+			TQuantity count = dp.sides[i].stacks[j].count;
+			if(count || obj->hasStackAtSlot(SlotID(j)))
+				obj->setCreature(SlotID(j), cre, count);
+		}
+
+		for(const DuelParameters::CusomCreature &cc : dp.creatures)
+		{
+			CCreature *c = VLC->creh->creatures[cc.id];
+			if(cc.attack >= 0)
+				c->getBonusLocalFirst(Selector::typeSubtype(Bonus::PRIMARY_SKILL, PrimarySkill::ATTACK))->val = cc.attack;
+			if(cc.defense >= 0)
+				c->getBonusLocalFirst(Selector::typeSubtype(Bonus::PRIMARY_SKILL, PrimarySkill::DEFENSE))->val = cc.defense;
+			if(cc.speed >= 0)
+				c->getBonusLocalFirst(Selector::type(Bonus::STACKS_SPEED))->val = cc.speed;
+			if(cc.HP >= 0)
+				c->getBonusLocalFirst(Selector::type(Bonus::STACK_HEALTH))->val = cc.HP;
+			if(cc.dmg >= 0)
+			{
+				c->getBonusLocalFirst(Selector::typeSubtype(Bonus::CREATURE_DAMAGE, 1))->val = cc.dmg;
+				c->getBonusLocalFirst(Selector::typeSubtype(Bonus::CREATURE_DAMAGE, 2))->val = cc.dmg;
+			}
+			if(cc.shoots >= 0)
+				c->getBonusLocalFirst(Selector::type(Bonus::SHOTS))->val = cc.shoots;
+		}
+	}
+
+	curB = BattleInfo::setupBattle(int3(), dp.terType, dp.bfieldType, armies, heroes, false, town);
+	curB->obstacles = dp.obstacles;
+	curB->localInit();
+	return;
+}
+
+BFieldType CGameState::battleGetBattlefieldType(int3 tile) const
+{
+	if(tile==int3() && curB)
+		tile = curB->tile;
+	else if(tile==int3() && !curB)
+		return BFieldType::NONE;
+
+	const TerrainTile &t = map->getTile(tile);
+	//fight in mine -> subterranean
+	if(dynamic_cast<const CGMine *>(t.visitableObjects.front()))
+		return BFieldType::SUBTERRANEAN;
+
+	for(auto &obj : map->objects)
+	{
+		//look only for objects covering given tile
+		if( !obj || obj->pos.z != tile.z
+		  || !obj->coveringAt(tile.x - obj->pos.x, tile.y - obj->pos.y))
+			continue;
+
+		switch(obj->ID)
+		{
+		case Obj::CLOVER_FIELD:
+			return BFieldType::CLOVER_FIELD;
+		case Obj::CURSED_GROUND1: case Obj::CURSED_GROUND2:
+			return BFieldType::CURSED_GROUND;
+		case Obj::EVIL_FOG:
+			return BFieldType::EVIL_FOG;
+		case Obj::FAVORABLE_WINDS:
+			return BFieldType::FAVOURABLE_WINDS;
+		case Obj::FIERY_FIELDS:
+			return BFieldType::FIERY_FIELDS;
+		case Obj::HOLY_GROUNDS:
+			return BFieldType::HOLY_GROUND;
+		case Obj::LUCID_POOLS:
+			return BFieldType::LUCID_POOLS;
+		case Obj::MAGIC_CLOUDS:
+			return BFieldType::MAGIC_CLOUDS;
+		case Obj::MAGIC_PLAINS1: case Obj::MAGIC_PLAINS2:
+			return BFieldType::MAGIC_PLAINS;
+		case Obj::ROCKLANDS:
+			return BFieldType::ROCKLANDS;
+		}
+	}
+
+	if(!t.isWater() && t.isCoastal())
+		return BFieldType::SAND_SHORE;
+
+    switch(t.terType)
+	{
+    case ETerrainType::DIRT:
+		return BFieldType(rand()%3+3);
+    case ETerrainType::SAND:
+		return BFieldType::SAND_MESAS; //TODO: coast support
+    case ETerrainType::GRASS:
+		return BFieldType(rand()%2+6);
+    case ETerrainType::SNOW:
+		return BFieldType(rand()%2+10);
+    case ETerrainType::SWAMP:
+		return BFieldType::SWAMP_TREES;
+    case ETerrainType::ROUGH:
+		return BFieldType::ROUGH;
+    case ETerrainType::SUBTERRANEAN:
+		return BFieldType::SUBTERRANEAN;
+    case ETerrainType::LAVA:
+		return BFieldType::LAVA;
+    case ETerrainType::WATER:
+		return BFieldType::SHIP;
+    case ETerrainType::ROCK:
+		return BFieldType::ROCKLANDS;
+	default:
+		return BFieldType::NONE;
+	}
+}
+
+UpgradeInfo CGameState::getUpgradeInfo(const CStackInstance &stack)
+{
+	UpgradeInfo ret;
+	const CCreature *base = stack.type;
+
+	const CGHeroInstance *h = stack.armyObj->ID == Obj::HERO ? static_cast<const CGHeroInstance*>(stack.armyObj) : nullptr;
+	const CGTownInstance *t = nullptr;
+
+	if(stack.armyObj->ID == Obj::TOWN)
+		t = static_cast<const CGTownInstance *>(stack.armyObj);
+	else if(h)
+	{	//hero specialty
+		TBonusListPtr lista = h->getBonuses(Selector::typeSubtype(Bonus::SPECIAL_UPGRADE, base->idNumber));
+		for(const Bonus *it : *lista)
+		{
+			auto nid = CreatureID(it->additionalInfo);
+			if (nid != base->idNumber) //in very specific case the upgrade is available by default (?)
+			{
+				ret.newID.push_back(nid);
+				ret.cost.push_back(VLC->creh->creatures[nid]->cost - base->cost);
+			}
+		}
+		t = h->visitedTown;
+	}
+	if(t)
+	{
+		for(const CGTownInstance::TCreaturesSet::value_type & dwelling : t->creatures)
+		{
+			if (vstd::contains(dwelling.second, base->idNumber)) //Dwelling with our creature
+			{
+				for(auto upgrID : dwelling.second)
+				{
+					if(vstd::contains(base->upgrades, upgrID)) //possible upgrade
+					{
+						ret.newID.push_back(upgrID);
+						ret.cost.push_back(VLC->creh->creatures[upgrID]->cost - base->cost);
+					}
+				}
+			}
+		}
+	}
+
+	//hero is visiting Hill Fort
+	if(h && map->getTile(h->visitablePos()).visitableObjects.front()->ID == Obj::HILL_FORT)
+	{
+		static const int costModifiers[] = {0, 25, 50, 75, 100}; //we get cheaper upgrades depending on level
+		const int costModifier = costModifiers[std::min<int>(std::max((int)base->level - 1, 0), ARRAY_COUNT(costModifiers) - 1)];
+
+		for(auto nid : base->upgrades)
+		{
+			ret.newID.push_back(nid);
+			ret.cost.push_back((VLC->creh->creatures[nid]->cost - base->cost) * costModifier / 100);
+		}
+	}
+
+	if(ret.newID.size())
+		ret.oldID = base->idNumber;
+
+	for (Res::ResourceSet &cost : ret.cost)
+		cost.positive(); //upgrade cost can't be negative, ignore missing resources
+
+	return ret;
+}
+
+PlayerRelations::PlayerRelations CGameState::getPlayerRelations( PlayerColor color1, PlayerColor color2 )
+{
+	if ( color1 == color2 )
+		return PlayerRelations::SAME_PLAYER;
+	if(color1 == PlayerColor::NEUTRAL || color2 == PlayerColor::NEUTRAL) //neutral player has no friends
+		return PlayerRelations::ENEMIES;
+
+	const TeamState * ts = getPlayerTeam(color1);
+	if (ts && vstd::contains(ts->players, color2))
+		return PlayerRelations::ALLIES;
+	return PlayerRelations::ENEMIES;
+}
+
+void CGameState::getNeighbours(const TerrainTile &srct, int3 tile, std::vector<int3> &vec, const boost::logic::tribool &onLand, bool limitCoastSailing)
+{
+	static const 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)
+	{
+		const int3 hlp = tile + dir;
+		if(!map->isInTheMap(hlp))
+			continue;
+
+		const TerrainTile &hlpt = map->getTile(hlp);
+
+// 		//we cannot visit things from blocked tiles
+// 		if(srct.blocked && !srct.visitable && hlpt.visitable && srct.blockingObjects.front()->ID != HEROI_TYPE)
+// 		{
+// 			continue;
+// 		}
+
+        if(srct.terType == ETerrainType::WATER && limitCoastSailing && hlpt.terType == ETerrainType::WATER && dir.x && dir.y) //diagonal move through water
+		{
+			int3 hlp1 = tile,
+				hlp2 = tile;
+			hlp1.x += dir.x;
+			hlp2.y += dir.y;
+
+            if(map->getTile(hlp1).terType != ETerrainType::WATER || map->getTile(hlp2).terType != ETerrainType::WATER)
+				continue;
+		}
+
+        if((indeterminate(onLand)  ||  onLand == (hlpt.terType!=ETerrainType::WATER) )
+            && hlpt.terType != ETerrainType::ROCK)
+		{
+			vec.push_back(hlp);
+		}
+	}
+}
+
+int CGameState::getMovementCost(const CGHeroInstance *h, const int3 &src, const int3 &dest, int remainingMovePoints, bool checkLast)
+{
+	if(src == dest) //same tile
+		return 0;
+
+	TerrainTile &s = map->getTile(src),
+		&d = map->getTile(dest);
+
+	//get basic cost
+	int ret = h->getTileCost(d,s);
+
+	if(d.blocked && h->hasBonusOfType(Bonus::FLYING_MOVEMENT))
+	{
+		bool freeFlying = h->getBonusesCount(Selector::typeSubtype(Bonus::FLYING_MOVEMENT, 1)) > 0;
+
+		if(!freeFlying)
+		{
+			ret *= 1.4; //40% penalty for movement over blocked tile
+		}
+	}
+    else if (d.terType == ETerrainType::WATER)
+	{
+		if(h->boat && s.hasFavourableWinds() && d.hasFavourableWinds()) //Favourable Winds
+			ret *= 0.666;
+		else if (!h->boat && h->getBonusesCount(Selector::typeSubtype(Bonus::WATER_WALKING, 1)) > 0)
+			ret *= 1.4; //40% penalty for water walking
+	}
+
+	if(src.x != dest.x  &&  src.y != dest.y) //it's diagonal move
+	{
+		int old = ret;
+		ret *= 1.414213;
+		//diagonal move costs too much but normal move is possible - allow diagonal move for remaining move points
+		if(ret > remainingMovePoints  &&  remainingMovePoints >= old)
+		{
+			return remainingMovePoints;
+		}
+	}
+
+
+	int left = remainingMovePoints-ret;
+	if(checkLast  &&  left > 0  &&  remainingMovePoints-ret < 250) //it might be the last tile - if no further move possible we take all move points
+	{
+		std::vector<int3> vec;
+        getNeighbours(d, dest, vec, s.terType != ETerrainType::WATER, true);
+		for(auto & elem : vec)
+		{
+			int fcost = getMovementCost(h,dest,elem,left,false);
+			if(fcost <= left)
+			{
+				return ret;
+			}
+		}
+		ret = remainingMovePoints;
+	}
+	return ret;
+}
+
+void CGameState::apply(CPack *pack)
+{
+	ui16 typ = typeList.getTypeID(pack);
+	applierGs->apps[typ]->applyOnGS(this,pack);
+}
+
+void CGameState::calculatePaths(const CGHeroInstance *hero, CPathsInfo &out, int3 src, int movement)
+{
+	CPathfinder pathfinder(out, this, hero);
+	pathfinder.calculatePaths(src, movement);
+}
+
+/**
+ * Tells if the tile is guarded by a monster as well as the position
+ * of the monster that will attack on it.
+ *
+ * @return int3(-1, -1, -1) if the tile is unguarded, or the position of
+ * the monster guarding the tile.
+ */
+std::vector<CGObjectInstance*> CGameState::guardingCreatures (int3 pos) const
+{
+	std::vector<CGObjectInstance*> guards;
+	const int3 originalPos = pos;
+	if (!map->isInTheMap(pos))
+		return guards;
+
+	const TerrainTile &posTile = map->getTile(pos);
+	if (posTile.visitable)
+	{
+		for (CGObjectInstance* obj : posTile.visitableObjects)
+		{
+			if(obj->blockVisit)
+			{
+				if (obj->ID == Obj::MONSTER) // Monster
+					guards.push_back(obj);
+			}
+		}
+	}
+	pos -= int3(1, 1, 0); // Start with top left.
+	for (int dx = 0; dx < 3; dx++)
+	{
+		for (int dy = 0; dy < 3; dy++)
+		{
+			if (map->isInTheMap(pos))
+			{
+				const auto & tile = map->getTile(pos);
+                if (tile.visitable && (tile.isWater() == posTile.isWater()))
+				{
+					for (CGObjectInstance* obj : tile.visitableObjects)
+					{
+						if (obj->ID == Obj::MONSTER  &&  checkForVisitableDir(pos, &map->getTile(originalPos), originalPos)) // Monster being able to attack investigated tile
+						{
+							guards.push_back(obj);
+						}
+					}
+				}
+			}
+
+			pos.y++;
+		}
+		pos.y -= 3;
+		pos.x++;
+	}
+	return guards;
+
+}
+
+int3 CGameState::guardingCreaturePosition (int3 pos) const
+{
+	const int3 originalPos = pos;
+	// Give monster at position priority.
+	if (!map->isInTheMap(pos))
+		return int3(-1, -1, -1);
+	const TerrainTile &posTile = map->getTile(pos);
+	if (posTile.visitable)
+	{
+		for (CGObjectInstance* obj : posTile.visitableObjects)
+		{
+			if(obj->blockVisit)
+			{
+				if (obj->ID == Obj::MONSTER) // Monster
+					return pos;
+				else
+					return int3(-1, -1, -1); //blockvis objects are not guarded by neighbouring creatures
+			}
+		}
+	}
+
+	// See if there are any monsters adjacent.
+	pos -= int3(1, 1, 0); // Start with top left.
+	for (int dx = 0; dx < 3; dx++)
+	{
+		for (int dy = 0; dy < 3; dy++)
+		{
+			if (map->isInTheMap(pos))
+			{
+				const auto & tile = map->getTile(pos);
+                if (tile.visitable && (tile.isWater() == posTile.isWater()))
+				{
+					for (CGObjectInstance* obj : tile.visitableObjects)
+					{
+						if (obj->ID == Obj::MONSTER  &&  checkForVisitableDir(pos, &map->getTile(originalPos), originalPos)) // Monster being able to attack investigated tile
+						{
+							return pos;
+						}
+					}
+				}
+			}
+
+			pos.y++;
+		}
+		pos.y -= 3;
+		pos.x++;
+	}
+
+	return int3(-1, -1, -1);
+}
+
+bool CGameState::isVisible(int3 pos, PlayerColor player)
+{
+	if(player == PlayerColor::NEUTRAL)
+		return false;
+	return getPlayerTeam(player)->fogOfWarMap[pos.x][pos.y][pos.z];
+}
+
+bool CGameState::isVisible( const CGObjectInstance *obj, boost::optional<PlayerColor> player )
+{
+	if(!player)
+		return true;
+
+	if(*player == PlayerColor::NEUTRAL) //-> TODO ??? needed?
+		return false;
+	//object is visible when at least one blocked tile is visible
+	for(int fx=0; fx<8; ++fx)
+	{
+		for(int fy=0; fy<6; ++fy)
+		{
+			int3 pos = obj->pos + int3(fx-7,fy-5,0);
+			if(map->isInTheMap(pos)
+				&& !((obj->defInfo->blockMap[fy] >> (7 - fx)) & 1)
+				&& isVisible(pos, *player)  )
+				return true;
+		}
+	}
+	return false;
+}
+
+bool CGameState::checkForVisitableDir(const int3 & src, const int3 & dst) const
+{
+	const TerrainTile * pom = &map->getTile(dst);
+	return checkForVisitableDir(src, pom, dst);
+}
+
+bool CGameState::checkForVisitableDir( const int3 & src, const TerrainTile *pom, const int3 & dst ) const
+{
+	for(ui32 b=0; b<pom->visitableObjects.size(); ++b) //checking destination tile
+	{
+		if(!vstd::contains(pom->blockingObjects, pom->visitableObjects[b])) //this visitable object is not blocking, ignore
+			continue;
+
+		CGDefInfo * di = pom->visitableObjects[b]->defInfo;
+		if( (dst.x == src.x-1 && dst.y == src.y-1) && !(di->visitDir & (1<<4)) )
+		{
+			return false;
+		}
+		if( (dst.x == src.x && dst.y == src.y-1) && !(di->visitDir & (1<<5)) )
+		{
+			return false;
+		}
+		if( (dst.x == src.x+1 && dst.y == src.y-1) && !(di->visitDir & (1<<6)) )
+		{
+			return false;
+		}
+		if( (dst.x == src.x+1 && dst.y == src.y) && !(di->visitDir & (1<<7)) )
+		{
+			return false;
+		}
+		if( (dst.x == src.x+1 && dst.y == src.y+1) && !(di->visitDir & (1<<0)) )
+		{
+			return false;
+		}
+		if( (dst.x == src.x && dst.y == src.y+1) && !(di->visitDir & (1<<1)) )
+		{
+			return false;
+		}
+		if( (dst.x == src.x-1 && dst.y == src.y+1) && !(di->visitDir & (1<<2)) )
+		{
+			return false;
+		}
+		if( (dst.x == src.x-1 && dst.y == src.y) && !(di->visitDir & (1<<3)) )
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+
+int CGameState::victoryCheck( PlayerColor player ) const
+{
+	const PlayerState *p = CGameInfoCallback::getPlayer(player);
+	if(map->victoryCondition.condition == EVictoryConditionType::WINSTANDARD  ||  map->victoryCondition.allowNormalVictory
+		|| (!p->human && !map->victoryCondition.appliesToAI)) //if the special victory condition applies only to human, AI has the standard)
+	{
+		if(player == checkForStandardWin())
+			return -1;
+	}
+
+	if (p->enteredWinningCheatCode)
+	{ //cheater or tester, but has entered the code...
+		if(map->victoryCondition.condition == EVictoryConditionType::WINSTANDARD)
+			return -1;
+		else
+			return 1;
+	}
+
+	if(p->human || map->victoryCondition.appliesToAI)
+	{
+ 		switch(map->victoryCondition.condition)
+		{
+		case EVictoryConditionType::ARTIFACT:
+			//check if any hero has winning artifact
+			for(auto & elem : p->heroes)
+                if(elem->hasArt(map->victoryCondition.objectId))
+					return 1;
+
+			break;
+
+		case EVictoryConditionType::GATHERTROOP:
+			{
+				//check if in players armies there is enough creatures
+				int total = 0; //creature counter
+				for(size_t i = 0; i < map->objects.size(); i++)
+				{
+					const CArmedInstance *ai = nullptr;
+					if(map->objects[i]
+						&& map->objects[i]->tempOwner == player //object controlled by player
+						&&  (ai = dynamic_cast<const CArmedInstance*>(map->objects[i].get()))) //contains army
+					{
+						for(auto & elem : ai->Slots()) //iterate through army
+                            if(elem.second->type->idNumber == map->victoryCondition.objectId) //it's searched creature
+								total += elem.second->count;
+					}
+				}
+
+				if(total >= map->victoryCondition.count)
+					return 1;
+			}
+			break;
+
+		case EVictoryConditionType::GATHERRESOURCE:
+            if(p->resources[map->victoryCondition.objectId] >= map->victoryCondition.count)
+				return 1;
+
+			break;
+
+		case EVictoryConditionType::BUILDCITY:
+			{
+				const CGTownInstance *t = static_cast<const CGTownInstance *>(map->victoryCondition.obj);
+                if(t->tempOwner == player && t->fortLevel()-1 >= map->victoryCondition.objectId && t->hallLevel()-1 >= map->victoryCondition.count)
+					return 1;
+			}
+			break;
+
+		case EVictoryConditionType::BUILDGRAIL:
+			for(const CGTownInstance *t : map->towns)
+				if((t == map->victoryCondition.obj || !map->victoryCondition.obj)
+					&& t->tempOwner == player
+					&& t->hasBuilt(BuildingID::GRAIL))
+					return 1;
+			break;
+
+		case EVictoryConditionType::BEATHERO:
+			if(map->victoryCondition.obj->tempOwner >= PlayerColor::PLAYER_LIMIT) //target hero not present on map
+				return 1;
+			break;
+		case EVictoryConditionType::CAPTURECITY:
+			{
+				if(map->victoryCondition.obj->tempOwner == player)
+					return 1;
+			}
+			break;
+		case EVictoryConditionType::BEATMONSTER:
+			if(!getObj(map->victoryCondition.obj->id)) //target monster not present on map
+				return 1;
+			break;
+		case EVictoryConditionType::TAKEDWELLINGS:
+			for(auto & elem : map->objects)
+			{
+				if(elem && elem->tempOwner != player) //check not flagged objs
+				{
+					switch(elem->ID)
+					{
+					case Obj::CREATURE_GENERATOR1: case Obj::CREATURE_GENERATOR2:
+					case Obj::CREATURE_GENERATOR3: case Obj::CREATURE_GENERATOR4:
+					case Obj::RANDOM_DWELLING: case Obj::RANDOM_DWELLING_LVL: case Obj::RANDOM_DWELLING_FACTION:
+						return 0; //found not flagged dwelling - player not won
+					}
+				}
+			}
+			return 1;
+		case EVictoryConditionType::TAKEMINES:
+			for(auto & elem : map->objects)
+			{
+				if(elem && elem->tempOwner != player) //check not flagged objs
+				{
+					switch(elem->ID)
+					{
+					case Obj::MINE: case Obj::ABANDONED_MINE:
+						return 0; //found not flagged mine - player not won
+					}
+				}
+			}
+			return 1;
+		case EVictoryConditionType::TRANSPORTITEM:
+			{
+				const CGTownInstance *t = static_cast<const CGTownInstance *>(map->victoryCondition.obj);
+                if((t->visitingHero && t->visitingHero->hasArt(map->victoryCondition.objectId))
+                    || (t->garrisonHero && t->garrisonHero->hasArt(map->victoryCondition.objectId)))
+				{
+					return 1;
+				}
+			}
+			break;
+ 		}
+	}
+
+	return 0;
+}
+
+PlayerColor CGameState::checkForStandardWin() const
+{
+	//std victory condition is:
+	//all enemies lost
+	PlayerColor supposedWinner = PlayerColor::NEUTRAL;
+	TeamID winnerTeam = TeamID::NO_TEAM;
+	for(auto & elem : players)
+	{
+		if(elem.second.status == EPlayerStatus::INGAME && elem.first < PlayerColor::PLAYER_LIMIT)
+		{
+			if(supposedWinner == PlayerColor::NEUTRAL)
+			{
+				//first player remaining ingame - candidate for victory
+				supposedWinner = elem.second.color;
+				winnerTeam = elem.second.team;
+			}
+			else if(winnerTeam != elem.second.team)
+			{
+				//current candidate has enemy remaining in game -> no vicotry
+				return PlayerColor::NEUTRAL;
+			}
+		}
+	}
+
+	return supposedWinner;
+}
+
+bool CGameState::checkForStandardLoss( PlayerColor player ) const
+{
+	//std loss condition is: player lost all towns and heroes
+	const PlayerState &p = *CGameInfoCallback::getPlayer(player);
+	return !p.heroes.size() && !p.towns.size();
+}
+
+struct statsHLP
+{
+	typedef std::pair< PlayerColor, si64 > TStat;
+	//converts [<player's color, value>] to vec[place] -> platers
+	static std::vector< std::vector< PlayerColor > > getRank( std::vector<TStat> stats )
+	{
+		std::sort(stats.begin(), stats.end(), statsHLP());
+
+		//put first element
+		std::vector< std::vector<PlayerColor> > ret;
+		std::vector<PlayerColor> tmp;
+		tmp.push_back( stats[0].first );
+		ret.push_back( tmp );
+
+		//the rest of elements
+		for(int g=1; g<stats.size(); ++g)
+		{
+			if(stats[g].second == stats[g-1].second)
+			{
+				(ret.end()-1)->push_back( stats[g].first );
+			}
+			else
+			{
+				//create next occupied rank
+				std::vector<PlayerColor> tmp;
+				tmp.push_back(stats[g].first);
+				ret.push_back(tmp);
+			}
+		}
+
+		return ret;
+	}
+
+	bool operator()(const TStat & a, const TStat & b) const
+	{
+		return a.second > b.second;
+	}
+
+	static const CGHeroInstance * findBestHero(CGameState * gs, PlayerColor color)
+	{
+		std::vector<ConstTransitivePtr<CGHeroInstance> > &h = gs->players[color].heroes;
+		if(!h.size())
+			return nullptr;
+		//best hero will be that with highest exp
+		int best = 0;
+		for(int b=1; b<h.size(); ++b)
+		{
+			if(h[b]->exp > h[best]->exp)
+			{
+				best = b;
+			}
+		}
+		return h[best];
+	}
+
+	//calculates total number of artifacts that belong to given player
+	static int getNumberOfArts(const PlayerState * ps)
+	{
+		int ret = 0;
+		for(auto h : ps->heroes)
+		{
+			ret += h->artifactsInBackpack.size() + h->artifactsWorn.size();
+		}
+		return ret;
+	}
+
+	// get total strength of player army
+	static si64 getArmyStrength(const PlayerState * ps)
+	{
+		si64 str = 0;
+
+		for(auto h : ps->heroes)
+		{
+			if(!h->inTownGarrison)		//original h3 behavior
+				str += h->getArmyStrength();
+		}
+		return str;
+	}
+};
+
+void CGameState::obtainPlayersStats(SThievesGuildInfo & tgi, int level)
+{
+#define FILL_FIELD(FIELD, VAL_GETTER) \
+	{ \
+		std::vector< std::pair< PlayerColor, si64 > > stats; \
+		for(auto g = players.begin(); g != players.end(); ++g) \
+		{ \
+			if(g->second.color == PlayerColor::NEUTRAL) \
+				continue; \
+			std::pair< PlayerColor, si64 > stat; \
+			stat.first = g->second.color; \
+			stat.second = VAL_GETTER; \
+			stats.push_back(stat); \
+		} \
+		tgi.FIELD = statsHLP::getRank(stats); \
+	}
+
+	for(auto & elem : players)
+	{
+		if(elem.second.color != PlayerColor::NEUTRAL)
+			tgi.playerColors.push_back(elem.second.color);
+	}
+
+	if(level >= 1) //num of towns & num of heroes
+	{
+		//num of towns
+		FILL_FIELD(numOfTowns, g->second.towns.size())
+		//num of heroes
+		FILL_FIELD(numOfHeroes, g->second.heroes.size())
+		//best hero's portrait
+		for(auto g = players.cbegin(); g != players.cend(); ++g)
+		{
+			if(g->second.color == PlayerColor::NEUTRAL)
+				continue;
+			const CGHeroInstance * best = statsHLP::findBestHero(this, g->second.color);
+			InfoAboutHero iah;
+			iah.initFromHero(best, level >= 8);
+			iah.army.clear();
+			tgi.colorToBestHero[g->second.color] = iah;
+		}
+	}
+	if(level >= 2) //gold
+	{
+		FILL_FIELD(gold, g->second.resources[Res::GOLD])
+	}
+	if(level >= 2) //wood & ore
+	{
+		FILL_FIELD(woodOre, g->second.resources[Res::WOOD] + g->second.resources[Res::ORE])
+	}
+	if(level >= 3) //mercury, sulfur, crystal, gems
+	{
+		FILL_FIELD(mercSulfCrystGems, g->second.resources[Res::MERCURY] + g->second.resources[Res::SULFUR] + g->second.resources[Res::CRYSTAL] + g->second.resources[Res::GEMS])
+	}
+	if(level >= 4) //obelisks found
+	{
+		FILL_FIELD(obelisks, CGObelisk::visited[gs->getPlayerTeam(g->second.color)->id])
+	}
+	if(level >= 5) //artifacts
+	{
+		FILL_FIELD(artifacts, statsHLP::getNumberOfArts(&g->second))
+	}
+	if(level >= 6) //army strength
+	{
+		FILL_FIELD(army, statsHLP::getArmyStrength(&g->second))
+	}
+	if(level >= 7) //income
+	{
+		//TODO:obtainPlayersStats - income
+	}
+	if(level >= 8) //best hero's stats
+	{
+		//already set in  lvl 1 handling
+	}
+	if(level >= 9) //personality
+	{
+		for(auto g = players.cbegin(); g != players.cend(); ++g)
+		{
+			if(g->second.color == PlayerColor::NEUTRAL) //do nothing for neutral player
+				continue;
+			if(g->second.human)
+			{
+                tgi.personality[g->second.color] = EAiTactic::NONE;
+			}
+			else //AI
+			{
+                tgi.personality[g->second.color] = map->players[g->second.color.getNum()].aiTactic;
+			}
+
+		}
+	}
+	if(level >= 10) //best creature
+	{
+		//best creatures belonging to player (highest AI value)
+		for(auto g = players.cbegin(); g != players.cend(); ++g)
+		{
+			if(g->second.color == PlayerColor::NEUTRAL) //do nothing for neutral player
+				continue;
+			int bestCre = -1; //best creature's ID
+			for(auto & elem : g->second.heroes)
+			{
+				for(auto it = elem->Slots().begin(); it != elem->Slots().end(); ++it)
+				{
+					int toCmp = it->second->type->idNumber; //ID of creature we should compare with the best one
+					if(bestCre == -1 || VLC->creh->creatures[bestCre]->AIValue < VLC->creh->creatures[toCmp]->AIValue)
+					{
+						bestCre = toCmp;
+					}
+				}
+			}
+			tgi.bestCreature[g->second.color] = bestCre;
+		}
+	}
+
+#undef FILL_FIELD
+}
+
+int CGameState::lossCheck( PlayerColor player ) const
+{
+	const PlayerState *p = CGameInfoCallback::getPlayer(player);
+	//if(map->lossCondition.typeOfLossCon == lossStandard)
+		if(checkForStandardLoss(player))
+			return -1;
+
+	if (p->enteredLosingCheatCode)
+	{
+		return 1;
+	}
+
+	if(p->human) //special loss condition applies only to human player
+	{
+		switch(map->lossCondition.typeOfLossCon)
+		{
+		case ELossConditionType::LOSSCASTLE:
+		case ELossConditionType::LOSSHERO:
+			{
+				const CGObjectInstance *obj = map->lossCondition.obj;
+				assert(obj);
+				if(obj->tempOwner != player)
+					return 1;
+			}
+			break;
+		case ELossConditionType::TIMEEXPIRES:
+			if(map->lossCondition.timeLimit < day)
+				return 1;
+			break;
+		}
+	}
+
+	if(!p->towns.size() && p->daysWithoutCastle >= 7)
+		return 2;
+
+	return false;
+}
+
+std::map<ui32, ConstTransitivePtr<CGHeroInstance> > CGameState::unusedHeroesFromPool()
+{
+	std::map<ui32, ConstTransitivePtr<CGHeroInstance> > pool = hpool.heroesPool;
+	for ( auto i = players.cbegin() ; i != players.cend();i++)
+		for(auto j = i->second.availableHeroes.cbegin(); j != i->second.availableHeroes.cend(); j++)
+			if(*j)
+				pool.erase((**j).subID);
+
+	return pool;
+}
+
+void CGameState::buildBonusSystemTree()
+{
+	buildGlobalTeamPlayerTree();
+	attachArmedObjects();
+
+	for(CGTownInstance *t : map->towns)
+	{
+		t->deserializationFix();
+	}
+	// CStackInstance <-> CCreature, CStackInstance <-> CArmedInstance, CArtifactInstance <-> CArtifact
+	// are provided on initializing / deserializing
+}
+
+void CGameState::deserializationFix()
+{
+	buildGlobalTeamPlayerTree();
+	attachArmedObjects();
+}
+
+void CGameState::buildGlobalTeamPlayerTree()
+{
+	for(auto k=teams.begin(); k!=teams.end(); ++k)
+	{
+		TeamState *t = &k->second;
+		t->attachTo(&globalEffects);
+
+		for(PlayerColor teamMember : k->second.players)
+		{
+			PlayerState *p = getPlayer(teamMember);
+			assert(p);
+			p->attachTo(t);
+		}
+	}
+}
+
+void CGameState::attachArmedObjects()
+{
+	for(CGObjectInstance *obj : map->objects)
+	{
+		if(CArmedInstance *armed = dynamic_cast<CArmedInstance*>(obj))
+			armed->whatShouldBeAttached()->attachTo(armed->whereShouldBeAttached(this));
+	}
+}
+
+void CGameState::giveHeroArtifact(CGHeroInstance *h, ArtifactID aid)
+{
+	 CArtifact * const artifact = VLC->arth->artifacts[aid]; //pointer to constant object
+	 CArtifactInstance *ai = CArtifactInstance::createNewArtifactInstance(artifact);
+	 map->addNewArtifactInstance(ai);
+	 ai->putAt(ArtifactLocation(h, ai->firstAvailableSlot(h)));
+}
+
+std::set<HeroTypeID> CGameState::getUnusedAllowedHeroes(bool alsoIncludeNotAllowed /*= false*/) const
+{
+	std::set<HeroTypeID> ret;
+	for(int i = 0; i < map->allowedHeroes.size(); i++)
+		if(map->allowedHeroes[i] || alsoIncludeNotAllowed)
+			ret.insert(HeroTypeID(i));
+
+	for(auto hero : map->heroesOnMap)  //heroes instances initialization
+	{
+		if(hero->type)
+			ret -= hero->type->ID;
+		else
+			ret -= HeroTypeID(hero->subID);
+	}
+
+	for(auto obj : map->objects) //prisons
+		if(obj && obj->ID == Obj::PRISON)
+			ret -= HeroTypeID(obj->subID);
+
+	return ret;
+}
+
+std::vector<std::pair<CGHeroInstance*, ObjectInstanceID> > CGameState::campaignHeroesToReplace()
+{
+	std::vector<std::pair<CGHeroInstance*, ObjectInstanceID> > ret;
+	auto replaceHero = [&](ObjectInstanceID objId, CGHeroInstance * ghi)
+	{
+		ret.push_back(std::make_pair(ghi, objId));
+		// 			ghi->tempOwner = getHumanPlayerInfo()[0]->color;
+		// 			ghi->id = objId;
+		// 			gs->map->objects[objId] = ghi;
+		// 			gs->map->heroes.push_back(ghi);
+	};
+
+	auto campaign = scenarioOps->campState;
+	if(auto bonus = campaign->getBonusForCurrentMap())
+	{
+		std::vector<CGHeroInstance*> Xheroes;
+		if (bonus->type == CScenarioTravel::STravelBonus::PLAYER_PREV_SCENARIO)
+		{
+			Xheroes = campaign->camp->scenarios[bonus->info2].crossoverHeroes;
+		}
+
+		//selecting heroes by type
+		for(int g=0; g<map->objects.size(); ++g)
+		{
+			const ObjectInstanceID gid = ObjectInstanceID(g);
+			CGObjectInstance * obj = map->objects[g];
+			if (obj->ID != Obj::HERO_PLACEHOLDER)
+			{
+				continue;
+			}
+			CGHeroPlaceholder * hp = static_cast<CGHeroPlaceholder*>(obj);
+
+			if(hp->subID != 0xFF) //select by type
+			{
+				bool found = false;
+				for(auto ghi : Xheroes)
+				{
+					if (ghi->subID == hp->subID)
+					{
+						found = true;
+						replaceHero(gid, ghi);
+						Xheroes -= ghi;
+						break;
+					}
+				}
+				if (!found)
+				{
+					auto  nh = new CGHeroInstance();
+					nh->initHero(HeroTypeID(hp->subID));
+					replaceHero(gid, nh);
+				}
+			}
+		}
+
+		//selecting heroes by power
+
+		std::sort(Xheroes.begin(), Xheroes.end(), [](const CGHeroInstance * a, const CGHeroInstance * b)
+		{
+			return a->getHeroStrength() > b->getHeroStrength();
+		}); //sort, descending strength
+
+		for(int g=0; g<map->objects.size(); ++g)
+		{
+			const ObjectInstanceID gid = ObjectInstanceID(g);
+			CGObjectInstance * obj = map->objects[g];
+			if (obj->ID != Obj::HERO_PLACEHOLDER)
+			{
+				continue;
+			}
+			CGHeroPlaceholder * hp = static_cast<CGHeroPlaceholder*>(obj);
+
+			if (hp->subID == 0xFF) //select by power
+			{
+				if(Xheroes.size() > hp->power - 1)
+					replaceHero(gid, Xheroes[hp->power - 1]);
+				else
+				{
+					logGlobal->warnStream() << "Warning, no hero to replace!";
+					map->removeBlockVisTiles(hp, true);
+					delete hp;
+					map->objects[g] = nullptr;
+				}
+				//we don't have to remove hero from Xheroes because it would destroy the order and duplicates shouldn't happen
+			}
+		}
+	}
+
+	return ret;
+}
+
+void CGameState::placeCampaignHeroes(const std::vector<std::pair<CGHeroInstance*, ObjectInstanceID> > &campHeroReplacements)
+{
+	for(auto obj : campHeroReplacements)
+	{
+		CGHeroPlaceholder *placeholder = dynamic_cast<CGHeroPlaceholder*>(getObjInstance(obj.second));
+
+		CGHeroInstance *heroToPlace = obj.first;
+		heroToPlace->id = obj.second;
+		heroToPlace->tempOwner = placeholder->tempOwner;
+		heroToPlace->pos = placeholder->pos;
+		heroToPlace->type = VLC->heroh->heroes[heroToPlace->type->ID.getNum()]; //TODO is this reasonable? either old type can be still used or it can be deleted?
+
+		for(auto &&i : heroToPlace->stacks)
+			i.second->type = VLC->creh->creatures[i.second->getCreatureID()];
+
+		auto fixArtifact = [&](CArtifactInstance * art)
+		{
+			art->artType = VLC->arth->artifacts[art->artType->id];
+			gs->map->artInstances.push_back(art);
+			art->id = ArtifactInstanceID(gs->map->artInstances.size() - 1);
+		};
+
+		for(auto &&i : heroToPlace->artifactsWorn)
+			fixArtifact(i.second.artifact);
+		for(auto &&i : heroToPlace->artifactsInBackpack)
+			fixArtifact(i.artifact);
+
+		map->heroesOnMap.push_back(heroToPlace);
+		map->objects[heroToPlace->id.getNum()] = heroToPlace;
+		map->addBlockVisTiles(heroToPlace);
+
+		//const auto & travelOptions = scenarioOps->campState->getCurrentScenario().travelOptions;
+	}
+}
+
+bool CGameState::isUsedHero(HeroTypeID hid) const
+{
+	for(auto hero : map->heroesOnMap)  //heroes instances initialization
+		if(hero->subID == hid.getNum())
+			return true;
+
+	for(auto obj : map->objects) //prisons
+		if(obj && obj->ID == Obj::PRISON  && obj->subID == hid.getNum())
+			return true;
+
+	return false;
+}
+
+CGPathNode::CGPathNode()
+:coord(-1,-1,-1)
+{
+	accessible = NOT_SET;
+	land = 0;
+	moveRemains = 0;
+	turns = 255;
+	theNodeBefore = nullptr;
+}
+
+bool CGPathNode::reachable() const
+{
+	return turns < 255;
+}
+
+bool CPathsInfo::getPath( const int3 &dst, CGPath &out )
+{
+	assert(isValid);
+
+	out.nodes.clear();
+	const CGPathNode *curnode = &nodes[dst.x][dst.y][dst.z];
+	if(!curnode->theNodeBefore)
+		return false;
+
+
+	while(curnode)
+	{
+		CGPathNode cpn = *curnode;
+		curnode = curnode->theNodeBefore;
+		out.nodes.push_back(cpn);
+	}
+	return true;
+}
+
+CPathsInfo::CPathsInfo( const int3 &Sizes )
+:sizes(Sizes)
+{
+	hero = nullptr;
+	nodes = new CGPathNode**[sizes.x];
+	for(int i = 0; i < sizes.x; i++)
+	{
+		nodes[i] = new CGPathNode*[sizes.y];
+		for (int j = 0; j < sizes.y; j++)
+		{
+			nodes[i][j] = new CGPathNode[sizes.z];
+		}
+	}
+}
+
+CPathsInfo::~CPathsInfo()
+{
+	for(int i = 0; i < sizes.x; i++)
+	{
+		for (int j = 0; j < sizes.y; j++)
+		{
+			delete [] nodes[i][j];
+		}
+		delete [] nodes[i];
+	}
+	delete [] nodes;
+}
+
+int3 CGPath::startPos() const
+{
+	return nodes[nodes.size()-1].coord;
+}
+
+int3 CGPath::endPos() const
+{
+	return nodes[0].coord;
+}
+
+void CGPath::convert( ui8 mode )
+{
+	if(mode==0)
+	{
+		for(auto & elem : nodes)
+		{
+			elem.coord = CGHeroInstance::convertPosition(elem.coord,true);
+		}
+	}
+}
+
+PlayerState::PlayerState()
+ : color(-1), currentSelection(0xffffffff), enteredWinningCheatCode(0),
+   enteredLosingCheatCode(0), status(EPlayerStatus::INGAME), daysWithoutCastle(0)
+{
+	setNodeType(PLAYER);
+}
+
+std::string PlayerState::nodeName() const
+{
+	return "Player " + (color.getNum() < VLC->generaltexth->capColors.size() ? VLC->generaltexth->capColors[color.getNum()] : boost::lexical_cast<std::string>(color));
+}
+
+InfoAboutArmy::InfoAboutArmy():
+    owner(PlayerColor::NEUTRAL)
+{}
+
+InfoAboutArmy::InfoAboutArmy(const CArmedInstance *Army, bool detailed)
+{
+	initFromArmy(Army, detailed);
+}
+
+void InfoAboutArmy::initFromArmy(const CArmedInstance *Army, bool detailed)
+{
+	army = ArmyDescriptor(Army, detailed);
+	owner = Army->tempOwner;
+	name = Army->getHoverText();
+}
+
+void InfoAboutHero::assign(const InfoAboutHero & iah)
+{
+	InfoAboutArmy::operator = (iah);
+
+	details = (iah.details ? new Details(*iah.details) : nullptr);
+	hclass = iah.hclass;
+	portrait = iah.portrait;
+}
+
+InfoAboutHero::InfoAboutHero():
+    details(nullptr),
+    hclass(nullptr),
+    portrait(-1)
+{}
+
+InfoAboutHero::InfoAboutHero(const InfoAboutHero & iah):
+    InfoAboutArmy()
+{
+	assign(iah);
+}
+
+InfoAboutHero::InfoAboutHero(const CGHeroInstance *h, bool detailed)
+	: details(nullptr),
+	hclass(nullptr),
+	portrait(-1)
+{
+	initFromHero(h, detailed);
+}
+
+InfoAboutHero::~InfoAboutHero()
+{
+	delete details;
+}
+
+InfoAboutHero & InfoAboutHero::operator=(const InfoAboutHero & iah)
+{
+	assign(iah);
+	return *this;
+}
+
+void InfoAboutHero::initFromHero(const CGHeroInstance *h, bool detailed)
+{
+	if(!h)
+		return;
+
+	initFromArmy(h, detailed);
+
+	hclass = h->type->heroClass;
+	name = h->name;
+	portrait = h->portrait;
+
+	if(detailed)
+	{
+		//include details about hero
+		details = new Details;
+		details->luck = h->LuckVal();
+		details->morale = h->MoraleVal();
+		details->mana = h->mana;
+		details->primskills.resize(GameConstants::PRIMARY_SKILLS);
+
+		for (int i = 0; i < GameConstants::PRIMARY_SKILLS ; i++)
+		{
+			details->primskills[i] = h->getPrimSkillLevel(static_cast<PrimarySkill::PrimarySkill>(i));
+		}
+	}
+}
+
+InfoAboutTown::InfoAboutTown():
+    details(nullptr),
+    tType(nullptr),
+    built(0),
+    fortLevel(0)
+{
+
+}
+
+InfoAboutTown::InfoAboutTown(const CGTownInstance *t, bool detailed)
+{
+	initFromTown(t, detailed);
+}
+
+InfoAboutTown::~InfoAboutTown()
+{
+	delete details;
+}
+
+void InfoAboutTown::initFromTown(const CGTownInstance *t, bool detailed)
+{
+	initFromArmy(t, detailed);
+	army = ArmyDescriptor(t->getUpperArmy(), detailed);
+	built = t->builded;
+	fortLevel = t->fortLevel();
+	name = t->name;
+	tType = t->town;
+
+	if(detailed)
+	{
+		//include details about hero
+		details = new Details;
+		details->goldIncome = t->dailyIncome();
+		details->customRes = t->hasBuilt(BuildingID::RESOURCE_SILO);
+		details->hallLevel = t->hallLevel();
+		details->garrisonedHero = t->garrisonHero;
+	}
+}
+
+ArmyDescriptor::ArmyDescriptor(const CArmedInstance *army, bool detailed)
+    : isDetailed(detailed)
+{
+	for(auto & elem : army->Slots())
+	{
+		if(detailed)
+			(*this)[elem.first] = *elem.second;
+		else
+			(*this)[elem.first] = CStackBasicDescriptor(elem.second->type, elem.second->getQuantityID());
+	}
+}
+
+ArmyDescriptor::ArmyDescriptor()
+    : isDetailed(false)
+{
+
+}
+
+int ArmyDescriptor::getStrength() const
+{
+	ui64 ret = 0;
+	if(isDetailed)
+	{
+		for(auto & elem : *this)
+			ret += elem.second.type->AIValue * elem.second.count;
+	}
+	else
+	{
+		for(auto & elem : *this)
+			ret += elem.second.type->AIValue * CCreature::estimateCreatureCount(elem.second.count);
+	}
+	return ret;
+}
+
+DuelParameters::SideSettings::StackSettings::StackSettings()
+	: type(CreatureID::NONE), count(0)
+{
+}
+
+DuelParameters::SideSettings::StackSettings::StackSettings(CreatureID Type, si32 Count)
+	: type(Type), count(Count)
+{
+}
+
+DuelParameters::SideSettings::SideSettings()
+{
+	heroId = -1;
+}
+
+DuelParameters::DuelParameters():
+    terType(ETerrainType::DIRT),
+    bfieldType(BFieldType::ROCKLANDS)
+{
+}
+
+DuelParameters DuelParameters::fromJSON(const std::string &fname)
+{
+	DuelParameters ret;
+
+	const JsonNode duelData(ResourceID("DATA/" + fname, EResType::TEXT));
+	ret.terType = ETerrainType((int)duelData["terType"].Float());
+	ret.bfieldType = BFieldType((int)duelData["bfieldType"].Float());
+	for(const JsonNode &n : duelData["sides"].Vector())
+	{
+		SideSettings &ss = ret.sides[(int)n["side"].Float()];
+		int i = 0;
+		for(const JsonNode &stackNode : n["army"].Vector())
+		{
+			ss.stacks[i].type = CreatureID((si32)stackNode.Vector()[0].Float());
+			ss.stacks[i].count = stackNode.Vector()[1].Float();
+			i++;
+		}
+
+		if(n["heroid"].getType() == JsonNode::DATA_FLOAT)
+			ss.heroId = n["heroid"].Float();
+		else
+			ss.heroId = -1;
+
+		for(const JsonNode &n : n["heroPrimSkills"].Vector())
+			ss.heroPrimSkills.push_back(n.Float());
+
+		for(const JsonNode &skillNode : n["heroSecSkills"].Vector())
+		{
+			std::pair<si32, si8> secSkill;
+			secSkill.first = skillNode.Vector()[0].Float();
+			secSkill.second = skillNode.Vector()[1].Float();
+			ss.heroSecSkills.push_back(secSkill);
+		}
+
+		assert(ss.heroPrimSkills.empty() || ss.heroPrimSkills.size() == GameConstants::PRIMARY_SKILLS);
+
+		if(ss.heroId != -1)
+		{
+			const JsonNode & spells = n["spells"];
+			if(spells.getType() == JsonNode::DATA_STRING  &&  spells.String() == "all")
+			{
+				for(auto spell : VLC->spellh->spells)
+					if(spell->id <= SpellID::SUMMON_AIR_ELEMENTAL)
+						ss.spells.insert(spell->id);
+			}
+			else
+				for(const JsonNode &spell : n["spells"].Vector())
+					ss.spells.insert(SpellID(spell.Float()));
+		}
+	}
+
+	for(const JsonNode &n : duelData["obstacles"].Vector())
+	{
+		auto oi = make_shared<CObstacleInstance>();
+		if(n.getType() == JsonNode::DATA_VECTOR)
+		{
+			oi->ID = n.Vector()[0].Float();
+			oi->pos = n.Vector()[1].Float();
+		}
+		else
+		{
+			assert(n.getType() == JsonNode::DATA_FLOAT);
+			oi->ID = 21;
+			oi->pos = n.Float();
+		}
+		oi->uniqueID = ret.obstacles.size();
+		ret.obstacles.push_back(oi);
+	}
+
+	for(const JsonNode &n : duelData["creatures"].Vector())
+	{
+		CusomCreature cc;
+		cc.id = n["id"].Float();
+
+#define retreive(name)								\
+	if(n[ #name ].getType() == JsonNode::DATA_FLOAT)\
+	cc.name = n[ #name ].Float();			\
+	else											\
+	cc.name = -1;
+
+		retreive(attack);
+		retreive(defense);
+		retreive(HP);
+		retreive(dmg);
+		retreive(shoots);
+		retreive(speed);
+		ret.creatures.push_back(cc);
+	}
+
+	return ret;
+}
+
+TeamState::TeamState()
+{
+	setNodeType(TEAM);
+}
+
+void CPathfinder::initializeGraph()
+{
+	CGPathNode ***graph = out.nodes;
+	for(size_t i=0; i < out.sizes.x; ++i)
+	{
+		for(size_t j=0; j < out.sizes.y; ++j)
+		{
+			for(size_t k=0; k < out.sizes.z; ++k)
+			{
+				curPos = int3(i,j,k);
+				const TerrainTile *tinfo = &gs->map->getTile(int3(i, j, k));
+				CGPathNode &node = graph[i][j][k];
+				node.accessible = evaluateAccessibility(tinfo);
+				node.turns = 0xff;
+				node.moveRemains = 0;
+				node.coord.x = i;
+				node.coord.y = j;
+				node.coord.z = k;
+                node.land = tinfo->terType != ETerrainType::WATER;
+				node.theNodeBefore = nullptr;
+			}
+		}
+	}
+}
+
+void CPathfinder::calculatePaths(int3 src /*= int3(-1,-1,-1)*/, int movement /*= -1*/)
+{
+	assert(hero);
+	assert(hero == getHero(hero->id));
+	if(src.x < 0)
+		src = hero->getPosition(false);
+	if(movement < 0)
+		movement = hero->movement;
+
+	out.hero = hero;
+	out.hpos = src;
+
+	if(!gs->map->isInTheMap(src)/* || !gs->map->isInTheMap(dest)*/) //check input
+	{
+        logGlobal->errorStream() << "CGameState::calculatePaths: Hero outside the gs->map? How dare you...";
+		return;
+	}
+
+	initializeGraph();
+
+
+	//initial tile - set cost on 0 and add to the queue
+	CGPathNode &initialNode = *getNode(src);
+	initialNode.turns = 0;
+	initialNode.moveRemains = movement;
+	mq.push_back(&initialNode);
+
+	std::vector<int3> neighbours;
+	neighbours.reserve(16);
+	while(!mq.empty())
+	{
+		cp = mq.front();
+		mq.pop_front();
+
+		const int3 sourceGuardPosition = guardingCreaturePosition(cp->coord);
+		bool guardedSource = (sourceGuardPosition != int3(-1, -1, -1) && cp->coord != src);
+		ct = &gs->map->getTile(cp->coord);
+
+		int movement = cp->moveRemains, turn = cp->turns;
+		if(!movement)
+		{
+			movement = hero->maxMovePoints(cp->land);
+			turn++;
+		}
+
+
+		//add accessible neighbouring nodes to the queue
+		neighbours.clear();
+
+		//handling subterranean gate => it's exit is the only neighbour
+        bool subterraneanEntry = (ct->topVisitableId() == Obj::SUBTERRANEAN_GATE && useSubterraneanGates);
+		if(subterraneanEntry)
+		{
+			//try finding the exit gate
+			if(const CGObjectInstance *outGate = getObj(CGTeleport::getMatchingGate(ct->visitableObjects.back()->id), false))
+			{
+				const int3 outPos = outGate->visitablePos();
+				//gs->getNeighbours(*getTile(outPos), outPos, neighbours, boost::logic::indeterminate, !cp->land);
+				neighbours.push_back(outPos);
+			}
+			else
+			{
+				//gate with no exit (blocked) -> do nothing with this node
+				continue;
+			}
+		}
+
+		gs->getNeighbours(*ct, cp->coord, neighbours, boost::logic::indeterminate, !cp->land);
+
+		for(auto & neighbour : neighbours)
+		{
+			const int3 &n = neighbour; //current neighbor
+			dp = getNode(n);
+			dt = &gs->map->getTile(n);
+            destTopVisObjID = dt->topVisitableId();
+
+			useEmbarkCost = 0; //0 - usual movement; 1 - embark; 2 - disembark
+
+			int turnAtNextTile = turn;
+
+
+			const bool destIsGuardian = sourceGuardPosition == n;
+
+			if(!goodForLandSeaTransition())
+				continue;
+
+			if(!canMoveBetween(cp->coord, dp->coord) || dp->accessible == CGPathNode::BLOCKED )
+				continue;
+
+			//special case -> hero embarked a boat standing on a guarded tile -> we must allow to move away from that tile
+            if(cp->accessible == CGPathNode::VISITABLE && guardedSource && cp->theNodeBefore->land && ct->topVisitableId() == Obj::BOAT)
+				guardedSource = false;
+
+			int cost = gs->getMovementCost(hero, cp->coord, dp->coord, movement);
+
+			//special case -> moving from src Subterranean gate to dest gate -> it's free
+			if(subterraneanEntry && destTopVisObjID == Obj::SUBTERRANEAN_GATE && cp->coord.z != dp->coord.z)
+				cost = 0;
+
+			int remains = movement - cost;
+
+			if(useEmbarkCost)
+			{
+				remains = hero->movementPointsAfterEmbark(movement, cost, useEmbarkCost - 1);
+				cost = movement - remains;
+			}
+
+			if(remains < 0)
+			{
+				//occurs rarely, when hero with low movepoints tries to leave the road
+				turnAtNextTile++;
+				int moveAtNextTile = hero->maxMovePoints(cp->land);
+				cost = gs->getMovementCost(hero, cp->coord, dp->coord, moveAtNextTile); //cost must be updated, movement points changed :(
+				remains = moveAtNextTile - cost;
+			}
+
+			if((dp->turns==0xff		//we haven't been here before
+				|| dp->turns > turnAtNextTile
+				|| (dp->turns >= turnAtNextTile  &&  dp->moveRemains < remains)) //this route is faster
+				&& (!guardedSource || destIsGuardian)) // Can step into tile of guard
+			{
+
+				assert(dp != cp->theNodeBefore); //two tiles can't point to each other
+				dp->moveRemains = remains;
+				dp->turns = turnAtNextTile;
+				dp->theNodeBefore = cp;
+
+				const bool guardedDst = guardingCreaturePosition(dp->coord) != int3(-1, -1, -1)
+										&& dp->accessible == CGPathNode::BLOCKVIS;
+
+				if (dp->accessible == CGPathNode::ACCESSIBLE
+					|| (useEmbarkCost && allowEmbarkAndDisembark)
+					|| destTopVisObjID == Obj::SUBTERRANEAN_GATE
+					|| (guardedDst && !guardedSource)) // Can step into a hostile tile once.
+				{
+					mq.push_back(dp);
+				}
+			}
+		} //neighbours loop
+	} //queue loop
+
+	out.isValid = true;
+}
+
+CGPathNode *CPathfinder::getNode(const int3 &coord)
+{
+	return &out.nodes[coord.x][coord.y][coord.z];
+}
+
+bool CPathfinder::canMoveBetween(const int3 &a, const int3 &b) const
+{
+	return gs->checkForVisitableDir(a, b) && gs->checkForVisitableDir(b, a);
+}
+
+CGPathNode::EAccessibility CPathfinder::evaluateAccessibility(const TerrainTile *tinfo) const
+{
+	CGPathNode::EAccessibility ret = (tinfo->blocked ? CGPathNode::BLOCKED : CGPathNode::ACCESSIBLE);
+
+
+    if(tinfo->terType == ETerrainType::ROCK || !FoW[curPos.x][curPos.y][curPos.z])
+		return CGPathNode::BLOCKED;
+
+	if(tinfo->visitable)
+	{
+		if(tinfo->visitableObjects.front()->ID == Obj::SANCTUARY && tinfo->visitableObjects.back()->ID == Obj::HERO && tinfo->visitableObjects.back()->tempOwner != hero->tempOwner) //non-owned hero stands on Sanctuary
+		{
+			return CGPathNode::BLOCKED;
+		}
+		else
+		{
+			for(const CGObjectInstance *obj : tinfo->visitableObjects)
+			{
+				if(obj->passableFor(hero->tempOwner)) //special object instance specific passableness flag - overwrites other accessibility flags
+				{
+					ret = CGPathNode::ACCESSIBLE;
+				}
+				else if(obj->blockVisit)
+				{
+					return CGPathNode::BLOCKVIS;
+				}
+				else if(obj->ID != Obj::EVENT) //pathfinder should ignore placed events
+				{
+					ret =  CGPathNode::VISITABLE;
+				}
+			}
+		}
+	}
+	else if (gs->map->isInTheMap(guardingCreaturePosition(curPos))
+		&& !tinfo->blocked)
+	{
+		// Monster close by; blocked visit for battle.
+		return CGPathNode::BLOCKVIS;
+	}
+
+	return ret;
+}
+
+bool CPathfinder::goodForLandSeaTransition()
+{
+	if(cp->land != dp->land) //hero can traverse land<->sea only in special circumstances
+	{
+		if(cp->land) //from land to sea -> embark or assault hero on boat
+		{
+			if(dp->accessible == CGPathNode::ACCESSIBLE || destTopVisObjID < 0) //cannot enter empty water tile from land -> it has to be visitable
+				return false;
+			if(destTopVisObjID != Obj::HERO && destTopVisObjID != Obj::BOAT) //only boat or hero can be accessed from land
+				return false;
+			if(destTopVisObjID == Obj::BOAT)
+				useEmbarkCost = 1;
+		}
+		else //disembark
+		{
+			//can disembark only on coastal tiles
+			if(!dt->isCoastal())
+				return false;
+
+			//tile must be accessible -> exception: unblocked blockvis tiles -> clear but guarded by nearby monster coast
+			if( (dp->accessible != CGPathNode::ACCESSIBLE && (dp->accessible != CGPathNode::BLOCKVIS || dt->blocked))
+				|| dt->visitable)  //TODO: passableness problem -> town says it's passable (thus accessible) but we obviously can't disembark onto town gate
+				return false;;
+
+			useEmbarkCost = 2;
+		}
+	}
+
+	return true;
+}
+
+CPathfinder::CPathfinder(CPathsInfo &_out, CGameState *_gs, const CGHeroInstance *_hero) : CGameInfoCallback(_gs, boost::optional<PlayerColor>()), out(_out), hero(_hero), FoW(getPlayerTeam(hero->tempOwner)->fogOfWarMap)
+{
+	useSubterraneanGates = true;
+	allowEmbarkAndDisembark = true;
+}
diff -Nru vcmi-0.94+svn3312/lib/CGameState.h vcmi-0.94+svn3315/lib/CGameState.h
--- vcmi-0.94+svn3312/lib/CGameState.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/CGameState.h	2013-11-12 17:30:43.000000000 +0000
@@ -361,22 +361,22 @@
 public:
 	ConstTransitivePtr<StartInfo> scenarioOps, initialOpts; //second one is a copy of settings received from pregame (not randomized)
 	PlayerColor currentPlayer; //ID of player currently having turn
-	ConstTransitivePtr<BattleInfo> curB; //current battle
-	ui32 day; //total number of days in game
-	ConstTransitivePtr<CMap> map;
-	bmap<PlayerColor, PlayerState> players;
-	bmap<TeamID, TeamState> teams;
-	CBonusSystemNode globalEffects;
-
-	struct DLL_LINKAGE HeroesPool
-	{
-		bmap<ui32, ConstTransitivePtr<CGHeroInstance> > heroesPool; //[subID] - heroes available to buy; nullptr if not available
-		bmap<ui32,ui8> pavailable; // [subid] -> which players can recruit hero (binary flags)
-
-		CGHeroInstance * pickHeroFor(bool native, PlayerColor player, const CTown *town, bmap<ui32, ConstTransitivePtr<CGHeroInstance> > &available, const CHeroClass *bannedClass = nullptr) const;
-
-		template <typename Handler> void serialize(Handler &h, const int version)
-		{
+	ConstTransitivePtr<BattleInfo> curB; //current battle
+	ui32 day; //total number of days in game
+	ConstTransitivePtr<CMap> map;
+	std::map<PlayerColor, PlayerState> players;
+	std::map<TeamID, TeamState> teams;
+	CBonusSystemNode globalEffects;
+
+	struct DLL_LINKAGE HeroesPool
+	{
+		std::map<ui32, ConstTransitivePtr<CGHeroInstance> > heroesPool; //[subID] - heroes available to buy; nullptr if not available
+		std::map<ui32,ui8> pavailable; // [subid] -> which players can recruit hero (binary flags)
+
+		CGHeroInstance * pickHeroFor(bool native, PlayerColor player, const CTown *town, std::map<ui32, ConstTransitivePtr<CGHeroInstance> > &available, const CHeroClass *bannedClass = nullptr) const;
+
+		template <typename Handler> void serialize(Handler &h, const int version)
+		{
 			h & heroesPool & pavailable;
 		}
 	} hpool; //we have here all heroes available on this map that are not hired
@@ -406,13 +406,13 @@
 	std::vector<CGObjectInstance*> guardingCreatures (int3 pos) const;
 	int victoryCheck(PlayerColor player) const; //checks if given player is winner; -1 if std victory, 1 if special victory, 0 else
 	int lossCheck(PlayerColor player) const; //checks if given player is loser;  -1 if std loss, 1 if special, 0 else
-	PlayerColor checkForStandardWin() const; //returns color of player that accomplished standard victory conditions or 255 (NEUTRAL) if no winner
-	bool checkForStandardLoss(PlayerColor player) const; //checks if given player lost the game
-	void obtainPlayersStats(SThievesGuildInfo & tgi, int level); //fills tgi with info about other players that is available at given level of thieves' guild
-	bmap<ui32, ConstTransitivePtr<CGHeroInstance> > unusedHeroesFromPool(); //heroes pool without heroes that are available in taverns
-	BattleInfo * setupBattle(int3 tile, const CArmedInstance *armies[2], const CGHeroInstance * heroes[2], bool creatureBank, const CGTownInstance *town);
-
-	void buildBonusSystemTree();
+	PlayerColor checkForStandardWin() const; //returns color of player that accomplished standard victory conditions or 255 (NEUTRAL) if no winner
+	bool checkForStandardLoss(PlayerColor player) const; //checks if given player lost the game
+	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
+	BattleInfo * setupBattle(int3 tile, const CArmedInstance *armies[2], const CGHeroInstance * heroes[2], bool creatureBank, const CGTownInstance *town);
+
+	void buildBonusSystemTree();
 	void attachArmedObjects();
 	void buildGlobalTeamPlayerTree();
 	void deserializationFix();
diff -Nru vcmi-0.94+svn3312/lib/CModHandler.cpp vcmi-0.94+svn3315/lib/CModHandler.cpp
--- vcmi-0.94+svn3312/lib/CModHandler.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/CModHandler.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -321,6 +321,41 @@
 	}
 }
 
+void CContentHandler::preloadData(CModInfo & mod)
+{
+	bool validate = (mod.validation != CModInfo::PASSED);
+
+	// print message in format [<8-symbols checksum>] <modname>
+	logGlobal->infoStream() << "\t\t[" << std::noshowbase << std::hex << std::setw(8) << std::setfill('0')
+							<< mod.checksum << "] " << mod.name;
+
+	if (validate && mod.identifier != "core")
+	{
+		if (!JsonUtils::validate(mod.config, "vcmi:mod", mod.identifier))
+			mod.validation = CModInfo::FAILED;
+	}
+	if (!preloadModData(mod.identifier, mod.config, validate))
+		mod.validation = CModInfo::FAILED;
+}
+
+void CContentHandler::load(CModInfo & mod)
+{
+	bool validate = (mod.validation != CModInfo::PASSED);
+
+	if (!loadMod(mod.identifier, validate))
+		mod.validation = CModInfo::FAILED;
+
+	if (validate)
+	{
+		if (mod.validation != CModInfo::FAILED)
+			logGlobal->infoStream()  << "\t\t[DONE] " << mod.name;
+		else
+			logGlobal->errorStream() << "\t\t[FAIL] " << mod.name;
+	}
+	else
+		logGlobal->infoStream()  << "\t\t[SKIP] " << mod.name;
+}
+
 CModHandler::CModHandler()
 {
 	for (int i = 0; i < GameConstants::RESOURCE_QUANTITY; ++i)
@@ -479,30 +514,58 @@
 	return JsonNode();
 }
 
-/// loads mod info data from mod.json
-static void loadModInfoJson(CModInfo & mod, const JsonNode & config)
+CModInfo::CModInfo(std::string identifier,const JsonNode & local, const JsonNode & config):
+	identifier(identifier),
+	name(config["name"].String()),
+	description(config["description"].String()),
+	dependencies(config["depends"].convertTo<std::set<std::string> >()),
+	conflicts(config["conflicts"].convertTo<std::set<std::string> >()),
+	validation(PENDING),
+	config(config)
+{
+	loadLocalData(local);
+}
+
+JsonNode CModInfo::saveLocalData()
 {
-	mod.name = config["name"].String();
-	mod.description =  config["description"].String();
-	mod.dependencies = config["depends"].convertTo<std::set<std::string> >();
-	mod.conflicts =    config["conflicts"].convertTo<std::set<std::string> >();
+	std::ostringstream stream;
+	stream << std::noshowbase << std::hex << std::setw(8) << std::setfill('0') << checksum;
+
+	JsonNode conf;
+	conf["active"].Bool() = enabled;
+	conf["validated"].Bool() = validation != FAILED;
+	conf["checksum"].String() = stream.str();
+	return conf;
 }
 
-/// load mod info from local config
-static void loadModInfoConfig(CModInfo & mod, const JsonNode & config)
+void CModInfo::updateChecksum(ui32 newChecksum)
 {
-	if (config.isNull())
+	if (newChecksum != checksum)
 	{
-		mod.enabled = true;
-		mod.validated = false;
-		mod.checksum = 0;
+		checksum = newChecksum;
+		validation = PENDING;
+	}
+}
+
+void CModInfo::loadLocalData(const JsonNode & data)
+{
+	bool validated = false;
+	if (data.isNull())
+	{
+		enabled = true;
+		checksum = 0;
 	}
 	else
 	{
-		mod.enabled   = config["active"].Bool();
-		mod.validated = config["validated"].Bool();
-		mod.checksum  = strtol(config["checksum"].String().c_str(), nullptr, 16);
+		enabled   = data["active"].Bool();
+		validated = data["validated"].Bool();
+		checksum  = strtol(data["checksum"].String().c_str(), nullptr, 16);
 	}
+
+	if (enabled)
+		validation = validated ? PASSED : PENDING;
+	else
+		validation = validated ? PASSED : FAILED;
 }
 
 void CModHandler::initializeMods(std::vector<std::string> availableMods)
@@ -519,21 +582,17 @@
 
 		if (CResourceHandler::get()->existsResource(ResourceID(modFileName)))
 		{
-			const JsonNode config = JsonNode(ResourceID(modFileName));
-			assert(!config.isNull());
-
-			CModInfo & mod = allMods[name];
-
-			mod.identifier = name;
-			loadModInfoJson(mod, config);
-			loadModInfoConfig(mod, modList[name]);
+			CModInfo mod(name, modList[name], JsonNode(ResourceID(modFileName)));
 
+			allMods[name] = mod;
 			if (mod.enabled)
 				detectedMods.push_back(name);
 		}
 		else
             logGlobal->warnStream() << "\t\t Directory " << name << " does not contains VCMI mod";
 	}
+	coreMod = CModInfo("core", modConfig["core"], JsonNode(ResourceID("config/gameConfig.json")));
+	coreMod.name = "Original game files";
 
 	if (!checkDependencies(detectedMods))
 	{
@@ -574,16 +633,25 @@
 	modChecksum.process_bytes(reinterpret_cast<const void*>(GameConstants::VCMI_VERSION.data()), GameConstants::VCMI_VERSION.size());
 
 	// second - add mod.json into checksum because filesystem does not contains this file
-	ResourceID modConfFile("mods/" + modName + "/mod", EResType::TEXT);
-	ui32 configChecksum = CResourceHandler::getInitial()->load(modConfFile)->calculateCRC32();
-	modChecksum.process_bytes(reinterpret_cast<const void *>(&configChecksum), sizeof(configChecksum));
-
-	// third - add all loaded files from this mod into checksum
+	// FIXME: remove workaround for core mod
+	if (modName != "core")
+	{
+		ResourceID modConfFile("mods/" + modName + "/mod", EResType::TEXT);
+		ui32 configChecksum = CResourceHandler::getInitial()->load(modConfFile)->calculateCRC32();
+		modChecksum.process_bytes(reinterpret_cast<const void *>(&configChecksum), sizeof(configChecksum));
+	}
+	// third - add all detected text files from this mod into checksum
 	auto files = filesystem->getFilteredFiles([](const ResourceID & resID)
 	{
-		return resID.getType() == EResType::TEXT;
+		return resID.getType() == EResType::TEXT &&
+			   ( boost::starts_with(resID.getName(), "DATA") ||
+				 boost::starts_with(resID.getName(), "CONFIG"));
 	});
 
+	// these two files may change between two runs of vcmi and must be handled separately
+	files.erase(ResourceID("CONFIG/SETTINGS", EResType::TEXT));
+	files.erase(ResourceID("CONFIG/MODSETTINGS", EResType::TEXT));
+
 	for (const ResourceID & file : files)
 	{
 		ui32 fileChecksum = filesystem->load(file)->calculateCRC32();
@@ -594,22 +662,16 @@
 
 void CModHandler::loadModFilesystems()
 {
+	coreMod.updateChecksum(calculateModChecksum("core", CResourceHandler::getCoreData()));
+
 	for(std::string & modName : activeMods)
 	{
-		ResourceID modConfFile("mods/" + modName + "/mod", EResType::TEXT);
-		auto fsConfigData = CResourceHandler::getInitial()->load(modConfFile)->readAll();
-		const JsonNode fsConfig((char*)fsConfigData.first.get(), fsConfigData.second);
-
-		auto filesystem = genModFilesystem(modName, fsConfig);
+		CModInfo & mod = allMods[modName];
+		auto filesystem = genModFilesystem(modName, mod.config);
 
 		CResourceHandler::get()->addLoader(filesystem, false);
 		logGlobal->traceStream() << "Generating checksum for " << modName;
-		ui32 newChecksum = calculateModChecksum(modName, filesystem);
-		if (allMods[modName].checksum != newChecksum)
-		{
-			allMods[modName].checksum = newChecksum;
-			allMods[modName].validated = false; // force (re-)validation
-		}
+		mod.updateChecksum(calculateModChecksum(modName, filesystem));
 	}
 }
 
@@ -629,57 +691,20 @@
 {
 	CStopWatch totalTime, timer;
 
-	std::set<std::string> modsForValidation;
-	for (auto & mod : allMods)
-	{
-		if (mod.second.enabled && !mod.second.validated)
-			modsForValidation.insert(mod.first);
-	}
-
 	CContentHandler content;
 	logGlobal->infoStream() << "\tInitializing content handler: " << timer.getDiff() << " ms";
 
 	// first - load virtual "core" mod that contains all data
 	// TODO? move all data into real mods? RoE, AB, SoD, WoG
-	content.preloadModData("core", JsonNode(ResourceID("config/gameConfig.json")), true);
-	logGlobal->infoStream() << "\tParsing original game data: " << timer.getDiff() << " ms";
-
+	content.preloadData(coreMod);
 	for(const TModID & modName : activeMods)
-	{
-		bool needsValidation = modsForValidation.count(modName);
-
-		// print message in format [<8-symbols checksum>] <modname>
-		logGlobal->infoStream() << "\t\t[" << std::noshowbase << std::hex << std::setw(8) << std::setfill('0')
-								<< allMods[modName].checksum << "] " << allMods[modName].name;
-
-		std::string modFileName = "mods/" + modName + "/mod.json";
-
-		const JsonNode config = JsonNode(ResourceID(modFileName));
-		if (needsValidation)
-			allMods[modName].validated = JsonUtils::validate(config, "vcmi:mod", modName);
-
-		allMods[modName].validated &= content.preloadModData(modName, config, needsValidation);
-	}
+		content.preloadData(allMods[modName]);
 	logGlobal->infoStream() << "\tParsing mod data: " << timer.getDiff() << " ms";
 
-	content.loadMod("core", true);
-	logGlobal->infoStream() << "\tLoading original game data: " << timer.getDiff() << " ms";
-
+	content.load(coreMod);
 	for(const TModID & modName : activeMods)
-	{
-		bool needsValidation = modsForValidation.count(modName);
+		content.load(allMods[modName]);
 
-		allMods[modName].validated &= content.loadMod(modName, needsValidation);
-		if (needsValidation)
-		{
-			if (allMods[modName].validated)
-				logGlobal->infoStream()  << "\t\t[DONE] " << allMods[modName].name;
-			else
-				logGlobal->errorStream() << "\t\t[FAIL] " << allMods[modName].name;
-		}
-		else
-			logGlobal->infoStream()  << "\t\t[SKIP] " << allMods[modName].name;
-	}
 	logGlobal->infoStream() << "\tLoading mod data: " << timer.getDiff() << "ms";
 
 	VLC->creh->loadCrExpBon();
@@ -690,27 +715,15 @@
 
 	content.afterLoadFinalization();
 	logGlobal->infoStream() << "\tHandlers post-load finalization: " << timer.getDiff() << " ms";
-
 	logGlobal->infoStream() << "\tAll game content loaded in " << totalTime.getDiff() << " ms";
 }
 
-static JsonNode modInfoToJson(const CModInfo & mod)
-{
-	std::ostringstream stream;
-	stream << std::noshowbase << std::hex << std::setw(8) << std::setfill('0') << mod.checksum;
-
-	JsonNode conf;
-	conf["active"].Bool() = mod.enabled;
-	conf["validated"].Bool() = mod.validated;
-	conf["checksum"].String() = stream.str();
-	return conf;
-}
-
 void CModHandler::afterLoad()
 {
 	JsonNode modSettings;
 	for (auto & modEntry : allMods)
-		modSettings["activeMods"][modEntry.first] = modInfoToJson(modEntry.second);
+		modSettings["activeMods"][modEntry.first] = modEntry.second.saveLocalData();
+	modSettings["core"] = coreMod.saveLocalData();
 
 	std::ofstream file(*CResourceHandler::get()->getResourceName(ResourceID("config/modSettings.json")), std::ofstream::trunc);
 	file << modSettings;
diff -Nru vcmi-0.94+svn3312/lib/CModHandler.h vcmi-0.94+svn3315/lib/CModHandler.h
--- vcmi-0.94+svn3312/lib/CModHandler.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/CModHandler.h	2013-11-12 17:30:43.000000000 +0000
@@ -97,18 +97,22 @@
 		void afterLoadFinalization();
 	};
 
+	/// preloads all data from fileList as data from modName.
+	bool preloadModData(std::string modName, JsonNode modConfig, bool validate);
+
+	/// actually loads data in mod
+	bool loadMod(std::string modName, bool validate);
+
 	std::map<std::string, ContentTypeHandler> handlers;
 public:
 	/// fully initialize object. Will cause reading of H3 config files
 	CContentHandler();
 
 	/// preloads all data from fileList as data from modName.
-	/// returns true if loading was successfull
-	bool preloadModData(std::string modName, JsonNode modConfig, bool validate);
+	void preloadData(CModInfo & mod);
 
 	/// actually loads data in mod
-	/// returns true if loading was successfull
-	bool loadMod(std::string modName, bool validate);
+	void load(CModInfo & mod);
 
 	/// all data was loaded, time for final validation / integration
 	void afterLoadFinalization();
@@ -119,6 +123,13 @@
 class DLL_LINKAGE CModInfo
 {
 public:
+	enum EValidationStatus
+	{
+		PENDING,
+		FAILED,
+		PASSED
+	};
+
 	/// identifier, identical to name of folder with mod
 	std::string identifier;
 
@@ -135,25 +146,34 @@
 	/// CRC-32 checksum of the mod
 	ui32 checksum;
 
-	/// true if mod has passed validation successfully
-	bool validated;
-
 	/// true if mod is enabled
 	bool enabled;
 
-	// mod configuration (mod.json). (no need to store it right now)
-	// std::shared_ptr<JsonNode> config; //TODO: unique_ptr can't be serialized
+	EValidationStatus validation;
+
+	JsonNode config;
+
+	CModInfo(){}
+	CModInfo(std::string identifier, const JsonNode & local, const JsonNode & config);
+
+	JsonNode saveLocalData();
+	void updateChecksum(ui32 newChecksum);
 
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
-		h & identifier & description & name & dependencies & conflicts & checksum & validated & enabled;
+		h & identifier & description & name;
+		h & dependencies & conflicts & config;
+		h & checksum & validation & enabled;
 	}
+private:
+	void loadLocalData(const JsonNode & data);
 };
 
 class DLL_LINKAGE CModHandler
 {
 	std::map <TModID, CModInfo> allMods;
 	std::vector <TModID> activeMods;//active mods, in order in which they were loaded
+	CModInfo coreMod;
 
 	void loadConfigFromFile(std::string name);
 	void loadModFilesystems();
diff -Nru vcmi-0.94+svn3312/lib/CObjectHandler.cpp vcmi-0.94+svn3315/lib/CObjectHandler.cpp
--- vcmi-0.94+svn3312/lib/CObjectHandler.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/CObjectHandler.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -2112,13 +2112,13 @@
 		if (!hasBuilt(BuildingID(BuildingID::DWELL_FIRST+dwelling+i*GameConstants::CREATURES_PER_TOWN)))
 			return i-1;
 	}
-}
-int CGTownInstance::getHordeLevel(const int & HID)  const//HID - 0 or 1; returns creature level or -1 if that horde structure is not present
-{
-	return town->hordeLvl[HID];
-}
-int CGTownInstance::creatureGrowth(const int & level) const
-{
+}
+int CGTownInstance::getHordeLevel(const int & HID)  const//HID - 0 or 1; returns creature level or -1 if that horde structure is not present
+{
+	return town->hordeLvl.at(HID);
+}
+int CGTownInstance::creatureGrowth(const int & level) const
+{
 	return getGrowthInfo(level).totalGrowth();
 }
 
@@ -2139,17 +2139,17 @@
 
 	if (hasBuilt(BuildingID::CASTLE))
 		ret.entries.push_back(GrowthInfo::Entry(subID, BuildingID::CASTLE, castleBonus = base));
-	else if (hasBuilt(BuildingID::CITADEL))
-		ret.entries.push_back(GrowthInfo::Entry(subID, BuildingID::CITADEL, castleBonus = base / 2));
-
-	if(town->hordeLvl[0] == level)//horde 1
-		if(hasBuilt(BuildingID::HORDE_1))
-			ret.entries.push_back(GrowthInfo::Entry(subID, BuildingID::HORDE_1, creature->hordeGrowth));
-
-	if(town->hordeLvl[1] == level)//horde 2
-		if(hasBuilt(BuildingID::HORDE_2))
-			ret.entries.push_back(GrowthInfo::Entry(subID, BuildingID::HORDE_2, creature->hordeGrowth));
-
+	else if (hasBuilt(BuildingID::CITADEL))
+		ret.entries.push_back(GrowthInfo::Entry(subID, BuildingID::CITADEL, castleBonus = base / 2));
+
+	if(town->hordeLvl.at(0) == level)//horde 1
+		if(hasBuilt(BuildingID::HORDE_1))
+			ret.entries.push_back(GrowthInfo::Entry(subID, BuildingID::HORDE_1, creature->hordeGrowth));
+
+	if(town->hordeLvl.at(1) == level)//horde 2
+		if(hasBuilt(BuildingID::HORDE_2))
+			ret.entries.push_back(GrowthInfo::Entry(subID, BuildingID::HORDE_2, creature->hordeGrowth));
+
 	int dwellingBonus = 0;
 	if(const PlayerState *p = cb->getPlayer(tempOwner, false))
 	{
@@ -2617,13 +2617,13 @@
 
 bool CGTownInstance::addBonusIfBuilt(BuildingID building, Bonus::BonusType type, int val, TPropagatorPtr & prop, int subtype /*= -1*/)
 {
-	if(hasBuilt(building))
-	{
-		std::ostringstream descr;
-		descr << town->buildings[building]->Name() << " ";
-		if(val > 0)
-			descr << "+";
-		else if(val < 0)
+	if(hasBuilt(building))
+	{
+		std::ostringstream descr;
+		descr << town->buildings.at(building)->Name() << " ";
+		if(val > 0)
+			descr << "+";
+		else if(val < 0)
 			descr << "-";
 		descr << val;
 
@@ -2692,13 +2692,13 @@
 
 int CGTownInstance::getTownLevel() const
 {
-	// count all buildings that are not upgrades
-	return boost::range::count_if(builtBuildings, [&](const BuildingID & build)
-	{
-		return town->buildings[build] && town->buildings[build]->upgrade == -1;
-	});
-}
-
+	// count all buildings that are not upgrades
+	return boost::range::count_if(builtBuildings, [&](const BuildingID & build)
+	{
+		return town->buildings.at(build) && town->buildings.at(build)->upgrade == -1;
+	});
+}
+
 CBonusSystemNode * CGTownInstance::whatShouldBeAttached()
 {
 	return &townAndVis;
diff -Nru vcmi-0.94+svn3312/lib/CTownHandler.h vcmi-0.94+svn3315/lib/CTownHandler.h
--- vcmi-0.94+svn3312/lib/CTownHandler.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/CTownHandler.h	2013-11-12 17:30:43.000000000 +0000
@@ -134,19 +134,19 @@
 	std::vector<std::string> names; //names of the town instances
 
 	/// level -> list of creatures on this tier
-	// TODO: replace with pointers to CCreature
-	std::vector<std::vector<CreatureID> > creatures;
-
-	bmap<BuildingID, ConstTransitivePtr<CBuilding> > buildings;
-
-	std::vector<std::string> dwellings; //defs for adventure map dwellings for new towns, [0] means tier 1 creatures etc.
-	std::vector<std::string> dwellingNames;
-
-	// should be removed at least from configs in favor of auto-detection
-	bmap<int,int> hordeLvl; //[0] - first horde building creature level; [1] - second horde building (-1 if not present)
-	ui32 mageLevel; //max available mage guild level
-	ui16 primaryRes;
-	ArtifactID warMachine;
+	// TODO: replace with pointers to CCreature
+	std::vector<std::vector<CreatureID> > creatures;
+
+	std::map<BuildingID, ConstTransitivePtr<CBuilding> > buildings;
+
+	std::vector<std::string> dwellings; //defs for adventure map dwellings for new towns, [0] means tier 1 creatures etc.
+	std::vector<std::string> dwellingNames;
+
+	// should be removed at least from configs in favor of auto-detection
+	std::map<int,int> hordeLvl; //[0] - first horde building creature level; [1] - second horde building (-1 if not present)
+	ui32 mageLevel; //max available mage guild level
+	ui16 primaryRes;
+	ArtifactID warMachine;
 	si32 moatDamage;
 	// default chance for hero of specific class to appear in tavern, if field "tavern" was not set
 	// resulting chance = sqrt(town.chance * heroClass.chance)
diff -Nru vcmi-0.94+svn3312/lib/GameConstants.cpp vcmi-0.94+svn3315/lib/GameConstants.cpp
--- vcmi-0.94+svn3312/lib/GameConstants.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/GameConstants.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -73,13 +73,13 @@
 
 ID_LIKE_OPERATORS(BuildingID, BuildingID::EBuildingID)
 
-ID_LIKE_OPERATORS(BFieldType, BFieldType::EBFieldType)
-
-
-bmap<int, ConstTransitivePtr<CGDefInfo> > & Obj::toDefObjInfo() const
-{
-	return VLC->dobjinfo->gobjs[*this];
-}
+ID_LIKE_OPERATORS(BFieldType, BFieldType::EBFieldType)
+
+
+std::map<int, ConstTransitivePtr<CGDefInfo> > & Obj::toDefObjInfo() const
+{
+	return VLC->dobjinfo->gobjs[*this];
+}
 
 CArtifact * ArtifactID::toArtifact() const
 {
diff -Nru vcmi-0.94+svn3312/lib/GameConstants.h vcmi-0.94+svn3315/lib/GameConstants.h
--- vcmi-0.94+svn3312/lib/GameConstants.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/GameConstants.h	2013-11-12 17:30:43.000000000 +0000
@@ -606,13 +606,13 @@
 	};
 	Obj(EObj _num = NO_OBJ) : num(_num)
 	{}
-
-	ID_LIKE_CLASS_COMMON(Obj, EObj)
-
-	bmap<int, ConstTransitivePtr<CGDefInfo> > & toDefObjInfo() const;
-
-	EObj num;
-};
+
+	ID_LIKE_CLASS_COMMON(Obj, EObj)
+
+	std::map<int, ConstTransitivePtr<CGDefInfo> > & toDefObjInfo() const;
+
+	EObj num;
+};
 
 ID_LIKE_OPERATORS_DECLS(Obj, Obj::EObj)
 
diff -Nru vcmi-0.94+svn3312/lib/HeroBonus.cpp vcmi-0.94+svn3315/lib/HeroBonus.cpp
--- vcmi-0.94+svn3312/lib/HeroBonus.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/HeroBonus.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -55,18 +55,18 @@
 const std::map<std::string, Bonus::LimitEffect> bonusLimitEffect = boost::assign::map_list_of
 	BONUS_ITEM(NO_LIMIT)
 	BONUS_ITEM(ONLY_DISTANCE_FIGHT)
-	BONUS_ITEM(ONLY_MELEE_FIGHT)
-	BONUS_ITEM(ONLY_ENEMY_ARMY);
-
-const bmap<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 bmap<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))
+	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));
 
 
diff -Nru vcmi-0.94+svn3312/lib/HeroBonus.h vcmi-0.94+svn3315/lib/HeroBonus.h
--- vcmi-0.94+svn3312/lib/HeroBonus.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/HeroBonus.h	2013-11-12 17:30:43.000000000 +0000
@@ -964,14 +964,14 @@
 
 extern DLL_LINKAGE const std::map<std::string, Bonus::BonusType> bonusNameMap;
 extern DLL_LINKAGE const std::map<std::string, Bonus::ValueType> bonusValueMap;
-extern DLL_LINKAGE const std::map<std::string, Bonus::BonusSource> bonusSourceMap;
-extern DLL_LINKAGE const std::map<std::string, ui16> bonusDurationMap;
-extern DLL_LINKAGE const std::map<std::string, Bonus::LimitEffect> bonusLimitEffect;
-extern DLL_LINKAGE const bmap<std::string, TLimiterPtr> bonusLimiterMap;
-extern DLL_LINKAGE const bmap<std::string, TPropagatorPtr> bonusPropagatorMap;
-
-
-// BonusList template that requires full interface of CBonusSystemNode
+extern DLL_LINKAGE const std::map<std::string, Bonus::BonusSource> bonusSourceMap;
+extern DLL_LINKAGE const std::map<std::string, ui16> bonusDurationMap;
+extern DLL_LINKAGE const std::map<std::string, Bonus::LimitEffect> bonusLimitEffect;
+extern DLL_LINKAGE const std::map<std::string, TLimiterPtr> bonusLimiterMap;
+extern DLL_LINKAGE const std::map<std::string, TPropagatorPtr> bonusPropagatorMap;
+
+
+// BonusList template that requires full interface of CBonusSystemNode
 template <class InputIterator>
 void BonusList::insert(const int position, InputIterator first, InputIterator last)
 {
diff -Nru vcmi-0.94+svn3312/lib/IGameCallback.cpp vcmi-0.94+svn3315/lib/IGameCallback.cpp
--- vcmi-0.94+svn3312/lib/IGameCallback.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/IGameCallback.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -567,13 +567,13 @@
 {
 	ERROR_RET_VAL_IF(!canGetFullInfo(t), "Town is not owned!", EBuildingState::TOWN_NOT_OWNED);
 
-	if(!t->town->buildings.count(ID))
-		return EBuildingState::BUILDING_ERROR;
-
-	const CBuilding * pom = t->town->buildings[ID];
-
-
-	if(t->hasBuilt(ID))	//already built
+	if(!t->town->buildings.count(ID))
+		return EBuildingState::BUILDING_ERROR;
+
+	const CBuilding * pom = t->town->buildings.at(ID);
+
+
+	if(t->hasBuilt(ID))	//already built
 		return EBuildingState::ALREADY_PRESENT;
 
 	//can we build it?
@@ -634,24 +634,24 @@
 {
 	ERROR_RET_VAL_IF(!canGetFullInfo(t), "Town is not owned!", std::set<BuildingID>());
 	ERROR_RET_VAL_IF(!t->town->buildings.count(ID), "No such building!", std::set<BuildingID>());
-
-	std::set<int> used;
-	used.insert(ID);
-	auto reqs = t->town->buildings[ID]->requirements;
-
-	bool found;
-	do
+
+	std::set<int> used;
+	used.insert(ID);
+	auto reqs = t->town->buildings.at(ID)->requirements;
+
+	bool found;
+	do
 	{
 		found = false;
 		for(auto i=reqs.begin();i!=reqs.end();i++)
 		{
-			if(used.find(*i)==used.end()) //we haven't added requirements for this building
-			{
-				found = true;
-				auto & requires = t->town->buildings[*i]->requirements;
-
-				used.insert(*i);
-				for(auto & require : requires)
+			if(used.find(*i)==used.end()) //we haven't added requirements for this building
+			{
+				found = true;
+				auto & requires = t->town->buildings.at(*i)->requirements;
+
+				used.insert(*i);
+				for(auto & require : requires)
 					reqs.insert(require);//creating full list of requirements
 			}
 		}
diff -Nru vcmi-0.94+svn3312/lib/NetPacksLib.cpp vcmi-0.94+svn3315/lib/NetPacksLib.cpp
--- vcmi-0.94+svn3312/lib/NetPacksLib.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/NetPacksLib.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -453,7 +453,7 @@
 	CGTownInstance *t = gs->getTown(tid);
 	for(const auto & id : bid)
 	{
-		assert(t->town->buildings[id]);
+		assert(t->town->buildings.at(id) != nullptr);
 		t->builtBuildings.insert(id);
 	}
 	t->builded = builded;
diff -Nru vcmi-0.94+svn3312/lib/StartInfo.h vcmi-0.94+svn3315/lib/StartInfo.h
--- vcmi-0.94+svn3312/lib/StartInfo.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/StartInfo.h	2013-11-12 17:30:43.000000000 +0000
@@ -70,13 +70,13 @@
 {
 	enum EMode {NEW_GAME, LOAD_GAME, CAMPAIGN, DUEL, INVALID = 255};
 
-	EMode mode;
-	ui8 difficulty; //0=easy; 4=impossible
-
-	typedef bmap<PlayerColor, PlayerSettings> TPlayerInfos;
-	TPlayerInfos playerInfos; //color indexed
-
-	ui32 seedToBeUsed; //0 if not sure (client requests server to decide, will be send in reply pack)
+	EMode mode;
+	ui8 difficulty; //0=easy; 4=impossible
+
+	typedef std::map<PlayerColor, PlayerSettings> TPlayerInfos;
+	TPlayerInfos playerInfos; //color indexed
+
+	ui32 seedToBeUsed; //0 if not sure (client requests server to decide, will be send in reply pack)
 	ui32 seedPostInit; //so we know that game is correctly synced at the start; 0 if not known yet
 	ui32 mapfileChecksum; //0 if not relevant
 	ui8 turnTime; //in minutes, 0=unlimited
diff -Nru vcmi-0.94+svn3312/lib/filesystem/Filesystem.cpp vcmi-0.94+svn3315/lib/filesystem/Filesystem.cpp
--- vcmi-0.94+svn3312/lib/filesystem/Filesystem.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/filesystem/Filesystem.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -16,6 +16,7 @@
 
 CFilesystemList * CResourceHandler::resourceLoader = nullptr;
 CFilesystemList * CResourceHandler::initialLoader = nullptr;
+CFilesystemList * CResourceHandler::coreDataLoader = nullptr;
 
 CFilesystemGenerator::CFilesystemGenerator(std::string prefix):
 	filesystem(new CFilesystemList()),
@@ -162,13 +163,21 @@
 	return initialLoader;
 }
 
+CFilesystemList * CResourceHandler::getCoreData()
+{
+	assert(coreDataLoader);
+	return coreDataLoader;
+}
+
 void CResourceHandler::load(const std::string &fsConfigURI)
 {
 	auto fsConfigData = initialLoader->load(ResourceID(fsConfigURI, EResType::TEXT))->readAll();
 
 	const JsonNode fsConfig((char*)fsConfigData.first.get(), fsConfigData.second);
 
-	resourceLoader = createFileSystem("", fsConfig["filesystem"]);
+	coreDataLoader = createFileSystem("", fsConfig["filesystem"]);
+	resourceLoader = new CFilesystemList();
+	resourceLoader->addLoader(coreDataLoader, false);
 
 	// hardcoded system-specific path, may not be inside any of data directories
 	resourceLoader->addLoader(new CFilesystemLoader("SAVES/", VCMIDirs::get().userSavePath()), true);
diff -Nru vcmi-0.94+svn3312/lib/filesystem/Filesystem.h vcmi-0.94+svn3315/lib/filesystem/Filesystem.h
--- vcmi-0.94+svn3312/lib/filesystem/Filesystem.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/filesystem/Filesystem.h	2013-11-12 17:30:43.000000000 +0000
@@ -61,6 +61,7 @@
 	 */
 	static CFilesystemList * get();
 	static CFilesystemList * getInitial();
+	static CFilesystemList * getCoreData();
 
 	/**
 	 * Creates instance of initial resource loader.
@@ -99,4 +100,5 @@
 	/** Instance of resource loader */
 	static CFilesystemList * resourceLoader;
 	static CFilesystemList * initialLoader;
+	static CFilesystemList * coreDataLoader;
 };
diff -Nru vcmi-0.94+svn3312/lib/mapping/CCampaignHandler.cpp vcmi-0.94+svn3315/lib/mapping/CCampaignHandler.cpp
--- vcmi-0.94+svn3312/lib/mapping/CCampaignHandler.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/mapping/CCampaignHandler.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -453,13 +453,13 @@
 {
 	return camp->scenarios[currentMap];
 }
-
-ui8 CCampaignState::currentBonusID() const
-{
-	return chosenCampaignBonuses[currentMap];
-}
-
-CCampaignState::CCampaignState()
+
+ui8 CCampaignState::currentBonusID() const
+{
+	return chosenCampaignBonuses.at(currentMap);
+}
+
+CCampaignState::CCampaignState()
 {}
 
 CCampaignState::CCampaignState( unique_ptr<CCampaign> _camp ) : camp(std::move(_camp))
diff -Nru vcmi-0.94+svn3312/lib/mapping/CCampaignHandler.h vcmi-0.94+svn3315/lib/mapping/CCampaignHandler.h
--- vcmi-0.94+svn3312/lib/mapping/CCampaignHandler.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/mapping/CCampaignHandler.h	2013-11-12 17:30:43.000000000 +0000
@@ -148,13 +148,13 @@
 public:
 	unique_ptr<CCampaign> camp;
 	std::string campaignName; 
-	std::vector<ui8> mapsConquered, mapsRemaining;
-	ui8 currentMap; 
-
-	bmap<ui8, ui8> chosenCampaignBonuses; //used only for mode CAMPAIGN
-
-	//void initNewCampaign(const StartInfo &si);
-	void mapConquered(const std::vector<CGHeroInstance*> & heroes);
+	std::vector<ui8> mapsConquered, mapsRemaining;
+	ui8 currentMap; 
+
+	std::map<ui8, ui8> chosenCampaignBonuses; //used only for mode CAMPAIGN
+
+	//void initNewCampaign(const StartInfo &si);
+	void mapConquered(const std::vector<CGHeroInstance*> & heroes);
 	boost::optional<CScenarioTravel::STravelBonus> getBonusForCurrentMap() const;
 	const CCampaignScenario &getCurrentScenario() const;
 	ui8 currentBonusID() const;
diff -Nru vcmi-0.94+svn3312/lib/mapping/CMap.h vcmi-0.94+svn3315/lib/mapping/CMap.h
--- vcmi-0.94+svn3312/lib/mapping/CMap.h	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/lib/mapping/CMap.h	2013-11-12 17:30:43.000000000 +0000
@@ -375,13 +375,13 @@
 	std::vector< ConstTransitivePtr<CGHeroInstance> > allHeroes; //indexed by [hero_type_id]; on map, disposed, prisons, etc.
 
 	//Helper lists
-	std::vector< ConstTransitivePtr<CGHeroInstance> > heroesOnMap;
-
-	/// associative list to identify which hero/creature id belongs to which object id(index for objects)
-	bmap<si32, ObjectInstanceID> questIdentifierToId;
-
-	unique_ptr<CMapEditManager> editManager;
-
+	std::vector< ConstTransitivePtr<CGHeroInstance> > heroesOnMap;
+
+	/// associative list to identify which hero/creature id belongs to which object id(index for objects)
+	std::map<si32, ObjectInstanceID> questIdentifierToId;
+
+	unique_ptr<CMapEditManager> editManager;
+
 private:
 	TerrainTile*** terrain;
 
diff -Nru vcmi-0.94+svn3312/server/CGameHandler.cpp vcmi-0.94+svn3315/server/CGameHandler.cpp
--- vcmi-0.94+svn3312/server/CGameHandler.cpp	2013-11-11 17:12:20.000000000 +0000
+++ vcmi-0.94+svn3315/server/CGameHandler.cpp	2013-11-12 17:30:43.000000000 +0000
@@ -99,22 +99,22 @@
 static void giveExp(BattleResult &r)
 {
 	r.exp[0] = 0;
-	r.exp[1] = 0;
-	for(auto i = r.casualties[!r.winner].begin(); i!=r.casualties[!r.winner].end(); i++)
-	{
-		r.exp[r.winner] += VLC->creh->creatures[i->first]->valOfBonuses(Bonus::STACK_HEALTH) * i->second;
-	}
-}
-
+	r.exp[1] = 0;
+	for(auto i = r.casualties[!r.winner].begin(); i!=r.casualties[!r.winner].end(); i++)
+	{
+		r.exp[r.winner] += VLC->creh->creatures.at(i->first)->valOfBonuses(Bonus::STACK_HEALTH) * i->second;
+	}
+}
+
 PlayerStatus PlayerStatuses::operator[](PlayerColor player)
 {
-	boost::unique_lock<boost::mutex> l(mx);
-	if(players.find(player) != players.end())
-	{
-		return players[player];
-	}
-	else
-	{
+	boost::unique_lock<boost::mutex> l(mx);
+	if(players.find(player) != players.end())
+	{
+		return players.at(player);
+	}
+	else
+	{
 		throw std::runtime_error("No such player!");
 	}
 }
@@ -244,13 +244,13 @@
 	{
 		scp.which = SetCommanderProperty::BONUS;
 
-		auto difference = [](std::vector< std::vector <ui8> > skillLevels, std::vector <ui8> secondarySkills, int skill)->int
-		{
-			int s = std::min (skill, (int)ECommander::SPELL_POWER); //spell power level controls also casts and resistance
-			return skillLevels[skill][secondarySkills[s]] - (secondarySkills[s] ? skillLevels[skill][secondarySkills[s]-1] : 0);
-		};
-
-		switch (skill)
+		auto difference = [](std::vector< std::vector <ui8> > skillLevels, std::vector <ui8> secondarySkills, int skill)->int
+		{
+			int s = std::min (skill, (int)ECommander::SPELL_POWER); //spell power level controls also casts and resistance
+			return skillLevels.at(skill).at(secondarySkills.at(s)) - (secondarySkills.at(s) ? skillLevels.at(skill).at(secondarySkills.at(s)-1) : 0);
+		};
+
+		switch (skill)
 		{
 			case ECommander::ATTACK:
 				scp.accumulatedBonus.type = Bonus::PRIMARY_SKILL;
@@ -288,19 +288,19 @@
 
 		scp.accumulatedBonus.val = difference (VLC->creh->skillLevels, c->secondarySkills, skill);
 		sendAndApply (&scp);
-
-		scp.which = SetCommanderProperty::SECONDARY_SKILL;
-		scp.additionalInfo = skill;
-		scp.amount = c->secondarySkills[skill] + 1;
-		sendAndApply (&scp);
-	}
-	else if (skill >= 100)
-	{
-		scp.which = SetCommanderProperty::SPECIAL_SKILL;
-		scp.accumulatedBonus = *VLC->creh->skillRequirements[skill-100].first;
-		scp.additionalInfo = skill; //unnormalized
-		sendAndApply (&scp);
-	}
+
+		scp.which = SetCommanderProperty::SECONDARY_SKILL;
+		scp.additionalInfo = skill;
+		scp.amount = c->secondarySkills.at(skill) + 1;
+		sendAndApply (&scp);
+	}
+	else if (skill >= 100)
+	{
+		scp.which = SetCommanderProperty::SPECIAL_SKILL;
+		scp.accumulatedBonus = *VLC->creh->skillRequirements.at(skill-100).first;
+		scp.additionalInfo = skill; //unnormalized
+		sendAndApply (&scp);
+	}
 	expGiven(hero);
 }
 
@@ -322,20 +322,20 @@
 	}
 
 	//picking sec. skills for choice
-
-	for (int i = 0; i <= ECommander::SPELL_POWER; ++i)
-	{
-		if (c->secondarySkills[i] < ECommander::MAX_SKILL_LEVEL)
-			clu.skills.push_back(i);
-	}
-	int i = 100;
-	for (auto specialSkill : VLC->creh->skillRequirements)
-	{
-		if (c->secondarySkills[specialSkill.second.first] == ECommander::MAX_SKILL_LEVEL 
-			&&  c->secondarySkills[specialSkill.second.second] == ECommander::MAX_SKILL_LEVEL 
-			&&  !vstd::contains (c->specialSKills, i))
-			clu.skills.push_back (i);
-		++i;
+
+	for (int i = 0; i <= ECommander::SPELL_POWER; ++i)
+	{
+		if (c->secondarySkills.at(i) < ECommander::MAX_SKILL_LEVEL)
+			clu.skills.push_back(i);
+	}
+	int i = 100;
+	for (auto specialSkill : VLC->creh->skillRequirements)
+	{
+		if (c->secondarySkills.at(specialSkill.second.first) == ECommander::MAX_SKILL_LEVEL
+			&&  c->secondarySkills.at(specialSkill.second.second) == ECommander::MAX_SKILL_LEVEL
+			&&  !vstd::contains (c->specialSKills, i))
+			clu.skills.push_back (i);
+		++i;
 	}
 	int skillAmount = clu.skills.size();
 
@@ -430,14 +430,14 @@
 
 	if (hero1)
 		battleResult.data->exp[0] = hero1->calculateXp(battleResult.data->exp[0]);//scholar skill
-	if (hero2)
-		battleResult.data->exp[1] = hero2->calculateXp(battleResult.data->exp[1]);
-
-	const CArmedInstance *bEndArmy1 = gs->curB->sides[0].armyObject;
-	const CArmedInstance *bEndArmy2 = gs->curB->sides[1].armyObject;
-	const BattleResult::EResult result = battleResult.get()->result;
-
-	auto findBattleQuery = [this] () -> shared_ptr<CBattleQuery>
+	if (hero2)
+		battleResult.data->exp[1] = hero2->calculateXp(battleResult.data->exp[1]);
+
+	const CArmedInstance *bEndArmy1 = gs->curB->sides.at(0).armyObject;
+	const CArmedInstance *bEndArmy2 = gs->curB->sides.at(1).armyObject;
+	const BattleResult::EResult result = battleResult.get()->result;
+
+	auto findBattleQuery = [this] () -> shared_ptr<CBattleQuery>
 	{
 		for(auto &q : queries.allQueries())
 		{
@@ -482,13 +482,13 @@
 	if(finishingBattle->winnerHero)
 	{
 		if(int eagleEyeLevel = finishingBattle->winnerHero->getSecSkillLevel(SecondarySkill::EAGLE_EYE))
-		{
-			int maxLevel = eagleEyeLevel + 1;
-			double eagleEyeChance = finishingBattle->winnerHero->valOfBonuses(Bonus::SECONDARY_SKILL_PREMY, SecondarySkill::EAGLE_EYE);
-			for(const CSpell *sp : gs->curB->sides[!battleResult.data->winner].usedSpellsHistory)
-				if(sp->level <= maxLevel && !vstd::contains(finishingBattle->winnerHero->spells, sp->id) && rand() % 100 < eagleEyeChance)
-					cs.spells.insert(sp->id);
-		}
+		{
+			int maxLevel = eagleEyeLevel + 1;
+			double eagleEyeChance = finishingBattle->winnerHero->valOfBonuses(Bonus::SECONDARY_SKILL_PREMY, SecondarySkill::EAGLE_EYE);
+			for(const CSpell *sp : gs->curB->sides.at(!battleResult.data->winner).usedSpellsHistory)
+				if(sp->level <= maxLevel && !vstd::contains(finishingBattle->winnerHero->spells, sp->id) && rand() % 100 < eagleEyeChance)
+					cs.spells.insert(sp->id);
+		}
 	}
 
 
@@ -692,16 +692,16 @@
 		SetAvailableHeroes sah;
 		sah.player = finishingBattle->loser;
 		sah.hid[0] = finishingBattle->loserHero->subID;
-		if(result.result == BattleResult::ESCAPE) //retreat
-		{
-			sah.army[0].clear();
-			sah.army[0].setCreature(SlotID(0), finishingBattle->loserHero->type->initialArmy[0].creature, 1);
-		}
-
-		if(const CGHeroInstance *another =  getPlayer(finishingBattle->loser)->availableHeroes[1])
-			sah.hid[1] = another->subID;
-		else
-			sah.hid[1] = -1;
+		if(result.result == BattleResult::ESCAPE) //retreat
+		{
+			sah.army[0].clear();
+			sah.army[0].setCreature(SlotID(0), finishingBattle->loserHero->type->initialArmy.at(0).creature, 1);
+		}
+
+		if(const CGHeroInstance *another =  getPlayer(finishingBattle->loser)->availableHeroes.at(1))
+			sah.hid[1] = another->subID;
+		else
+			sah.hid[1] = -1;
 
 		sendAndApply(&sah);
 	}
@@ -762,13 +762,13 @@
 	}
 
 	const Bonus * bonus = att->getBonusLocalFirst(Selector::type(Bonus::SPELL_LIKE_ATTACK));
-	if (bonus && (bat.shot())) //TODO: make it work in meele?
-	{
-		bat.bsa.front().flags |= BattleStackAttacked::EFFECT;
-		bat.bsa.front().effect = VLC->spellh->spells[bonus->subtype]->mainEffectAnim; //hopefully it does not interfere with any other effect?
-
-		std::set<const CStack*> attackedCreatures = gs->curB->getAffectedCreatures(SpellID(bonus->subtype).toSpell(), bonus->val, att->owner, targetHex);
-		//TODO: get exact attacked hex for defender
+	if (bonus && (bat.shot())) //TODO: make it work in meele?
+	{
+		bat.bsa.front().flags |= BattleStackAttacked::EFFECT;
+		bat.bsa.front().effect = VLC->spellh->spells.at(bonus->subtype)->mainEffectAnim; //hopefully it does not interfere with any other effect?
+
+		std::set<const CStack*> attackedCreatures = gs->curB->getAffectedCreatures(SpellID(bonus->subtype).toSpell(), bonus->val, att->owner, targetHex);
+		//TODO: get exact attacked hex for defender
 
 		for(const CStack * stack : attackedCreatures)
 		{
@@ -1066,13 +1066,13 @@
 	if(!p)
 	{
         logGlobal->warnStream() << "There is no player owner of town " << town->name << " at " << town->pos;
-		return;
-	}
-
-	if (forced || town->creatures[GameConstants::CREATURES_PER_TOWN].second.empty())//we need to change creature
-		{
-			SetAvailableCreatures ssi;
-			ssi.tid = town->id;
+		return;
+	}
+
+	if (forced || town->creatures.at(GameConstants::CREATURES_PER_TOWN).second.empty())//we need to change creature
+		{
+			SetAvailableCreatures ssi;
+			ssi.tid = town->id;
 			ssi.creatures = town->creatures;
 			ssi.creatures[GameConstants::CREATURES_PER_TOWN].second.clear();//remove old one
 
@@ -1081,19 +1081,19 @@
 			{
 				sendAndApply(&ssi);
 				return;
-			}
-
-			ui32 dwellpos = rand()%dwellings.size();//take random dwelling
-			ui32 creapos = rand()%dwellings[dwellpos]->creatures.size();//for multi-creature dwellings like Golem Factory
-			CreatureID creature = dwellings[dwellpos]->creatures[creapos].second[0];
-
-			if (clear)
-				ssi.creatures[GameConstants::CREATURES_PER_TOWN].first = std::max((ui32)1, (VLC->creh->creatures[creature]->growth)/2);
-			else
-				ssi.creatures[GameConstants::CREATURES_PER_TOWN].first = VLC->creh->creatures[creature]->growth;
-			ssi.creatures[GameConstants::CREATURES_PER_TOWN].second.push_back(creature);
-			sendAndApply(&ssi);
-		}
+			}
+
+			ui32 dwellpos = rand()%dwellings.size();//take random dwelling
+			ui32 creapos = rand()%dwellings.at(dwellpos)->creatures.size();//for multi-creature dwellings like Golem Factory
+			CreatureID creature = dwellings.at(dwellpos)->creatures.at(creapos).second[0];
+
+			if (clear)
+				ssi.creatures[GameConstants::CREATURES_PER_TOWN].first = std::max((ui32)1, (VLC->creh->creatures.at(creature)->growth)/2);
+			else
+				ssi.creatures[GameConstants::CREATURES_PER_TOWN].first = VLC->creh->creatures.at(creature)->growth;
+			ssi.creatures[GameConstants::CREATURES_PER_TOWN].second.push_back(creature);
+			sendAndApply(&ssi);
+		}
 }
 
 void CGameHandler::newTurn()
@@ -1177,22 +1177,22 @@
 					n.creatureid = newMonster.second;
 				}
 			}
-		}
-	}
-
-	bmap<ui32, ConstTransitivePtr<CGHeroInstance> > pool = gs->hpool.heroesPool;
-
-	for (auto & elem : gs->players)
-	{
+		}
+	}
+
+	std::map<ui32, ConstTransitivePtr<CGHeroInstance> > pool = gs->hpool.heroesPool;
+
+	for (auto & elem : gs->players)
+	{
 		if(elem.first == PlayerColor::NEUTRAL)
 			continue;
-		else if(elem.first >= PlayerColor::PLAYER_LIMIT)
-			assert(0); //illegal player number!
-
-		std::pair<PlayerColor, si32> playerGold(elem.first, elem.second.resources[Res::GOLD]);
-		hadGold.insert(playerGold);
-
-		if(newWeek) //new heroes in tavern
+		else if(elem.first >= PlayerColor::PLAYER_LIMIT)
+			assert(0); //illegal player number!
+
+		std::pair<PlayerColor, si32> playerGold(elem.first, elem.second.resources.at(Res::GOLD));
+		hadGold.insert(playerGold);
+
+		if(newWeek) //new heroes in tavern
 		{
 			SetAvailableHeroes sah;
 			sah.player = elem.first;
@@ -1251,39 +1251,39 @@
 		{
 			if(t->hasBuilt(BuildingID::PORTAL_OF_SUMMON, ETownType::DUNGEON))
 				setPortalDwelling(t, true, (n.specialWeek == NewTurn::PLAGUE ? true : false)); //set creatures for Portal of Summoning
-
-			if(!firstTurn)
-				if (t->hasBuilt(BuildingID::TREASURY, ETownType::RAMPART) && player < PlayerColor::PLAYER_LIMIT)
-						n.res[player][Res::GOLD] += hadGold[player]/10; //give 10% of starting gold
-
-			if (!vstd::contains(n.cres, t->id))
-			{
-				n.cres[t->id].tid = t->id;
-				n.cres[t->id].creatures = t->creatures;
-			}
-			auto & sac = n.cres[t->id];
-
-			for (int k=0; k < GameConstants::CREATURES_PER_TOWN; k++) //creature growths
-			{
-				if(t->creatureDwellingLevel(k) >= 0)//there is dwelling (k-level)
-				{
-					ui32 &availableCount = sac.creatures[k].first;
-					const CCreature *cre = VLC->creh->creatures[t->creatures[k].second.back()];
-
-					if (n.specialWeek == NewTurn::PLAGUE)
-						availableCount = t->creatures[k].first / 2; //halve their number, no growth
-					else
-					{
-						if(firstTurn) //first day of game: use only basic growths
+
+			if(!firstTurn)
+				if (t->hasBuilt(BuildingID::TREASURY, ETownType::RAMPART) && player < PlayerColor::PLAYER_LIMIT)
+						n.res[player][Res::GOLD] += hadGold.at(player)/10; //give 10% of starting gold
+
+			if (!vstd::contains(n.cres, t->id))
+			{
+				n.cres[t->id].tid = t->id;
+				n.cres[t->id].creatures = t->creatures;
+			}
+			auto & sac = n.cres.at(t->id);
+
+			for (int k=0; k < GameConstants::CREATURES_PER_TOWN; k++) //creature growths
+			{
+				if(t->creatureDwellingLevel(k) >= 0)//there is dwelling (k-level)
+				{
+					ui32 &availableCount = sac.creatures.at(k).first;
+					const CCreature *cre = VLC->creh->creatures.at(t->creatures.at(k).second.back());
+
+					if (n.specialWeek == NewTurn::PLAGUE)
+						availableCount = t->creatures.at(k).first / 2; //halve their number, no growth
+					else
+					{
+						if(firstTurn) //first day of game: use only basic growths
 							availableCount = cre->growth;
 						else
-							availableCount += t->creatureGrowth(k);
-
-						//Deity of fire week - upgrade both imps and upgrades
-						if (n.specialWeek == NewTurn::DEITYOFFIRE && vstd::contains(t->creatures[k].second, n.creatureid))
-							availableCount += 15;
-
-						if( cre->idNumber == n.creatureid ) //bonus week, effect applies only to identical creatures
+							availableCount += t->creatureGrowth(k);
+
+						//Deity of fire week - upgrade both imps and upgrades
+						if (n.specialWeek == NewTurn::DEITYOFFIRE && vstd::contains(t->creatures.at(k).second, n.creatureid))
+							availableCount += 15;
+
+						if( cre->idNumber == n.creatureid ) //bonus week, effect applies only to identical creatures
 						{
 							if(n.specialWeek == NewTurn::DOUBLE_GROWTH)
 								availableCount *= 2;
@@ -1318,17 +1318,17 @@
 			if (player != PlayerColor::NEUTRAL) //do not reveal fow for neutral player
 			{
 				FoWChange fw;
-				fw.mode = 1;
-				fw.player = player;
-				// find all hidden tiles
-				auto & fow = gs->getPlayerTeam(player)->fogOfWarMap;
-				for (size_t i=0; i<fow.size(); i++)
-					for (size_t j=0; j<fow[i].size(); j++)
-						for (size_t k=0; k<fow[i][j].size(); k++)
-							if (!fow[i][j][k])
-								fw.tiles.insert(int3(i,j,k));
-
-				sendAndApply (&fw);
+				fw.mode = 1;
+				fw.player = player;
+				// find all hidden tiles
+				const auto & fow = gs->getPlayerTeam(player)->fogOfWarMap;
+				for (size_t i=0; i<fow.size(); i++)
+					for (size_t j=0; j<fow.at(i).size(); j++)
+						for (size_t k=0; k<fow.at(i).at(j).size(); k++)
+							if (!fow.at(i).at(j).at(k))
+								fw.tiles.insert(int3(i,j,k));
+
+				sendAndApply (&fw);
 			}
 		}
 		if (t->hasBonusOfType (Bonus::DARKNESS))
@@ -1528,13 +1528,13 @@
 				yt.player = i->first;
 				applyAndSend(&yt);
 			}
-
-			//wait till turn is done
-			boost::unique_lock<boost::mutex> lock(states.mx);
-			while(states.players[i->first].makingTurn && !end2)
-			{
-				static time_duration p = milliseconds(200);
-				states.cv.timed_wait(lock,p);
+
+			//wait till turn is done
+			boost::unique_lock<boost::mutex> lock(states.mx);
+			while(states.players.at(i->first).makingTurn && !end2)
+			{
+				static time_duration p = milliseconds(200);
+				states.cv.timed_wait(lock,p);
 
 			}
 		}
@@ -1576,16 +1576,16 @@
 			getAllowedSpells(spells, i);
 			for (auto & spell : spells)
 				cs.spells.insert(spell);
-		}
-		else
-		{
-			for(int j=0; j<t->spellsAtLevel(i+1,true) && j<t->spells[i].size(); j++)
-			{
-				if(!vstd::contains(h->spells,t->spells[i][j]))
-					cs.spells.insert(t->spells[i][j]);
-			}
-		}
-	}
+		}
+		else
+		{
+			for(int j=0; j<t->spellsAtLevel(i+1,true) && j<t->spells.at(i).size(); j++)
+			{
+				if(!vstd::contains(h->spells,t->spells.at(i).at(j)))
+					cs.spells.insert(t->spells.at(i).at(j));
+			}
+		}
+	}
 	if(!cs.spells.empty())
 		sendAndApply(&cs);
 }
@@ -1856,13 +1856,13 @@
 void CGameHandler::giveResource(PlayerColor player, Res::ERes which, int val) //TODO: cap according to Bersy's suggestion
 {
 	if(!val) return; //don't waste time on empty call
-	SetResource sr;
-	sr.player = player;
-	sr.resid = which;
-	sr.val = gs->players.find(player)->second.resources[which] + val;
-	sendAndApply(&sr);
-}
-
+	SetResource sr;
+	sr.player = player;
+	sr.resid = which;
+	sr.val = gs->players.find(player)->second.resources.at(which) + val;
+	sendAndApply(&sr);
+}
+
 void CGameHandler::giveResources(PlayerColor player, TResources resources)
 {
 	for(TResources::nziterator i(resources); i.valid(); i++)
@@ -2380,13 +2380,13 @@
 	const CGTownInstance * t = getTown(tid);
 	if(!t)
 		COMPLAIN_RETF("No such town (ID=%s)!", tid);
-	if(!t->town->buildings.count(requestedID))
-		COMPLAIN_RETF("Town of faction %s does not have info about building ID=%s!", t->town->faction->name % tid);
-
-	const CBuilding * requestedBuilding = t->town->buildings[requestedID];
-
-	//Vector with future list of built building and buildings in auto-mode that are not yet built.
-	std::vector<const CBuilding*> buildingsThatWillBe, remainingAutoBuildings;
+	if(!t->town->buildings.count(requestedID))
+		COMPLAIN_RETF("Town of faction %s does not have info about building ID=%s!", t->town->faction->name % tid);
+
+	const CBuilding * requestedBuilding = t->town->buildings.at(requestedID);
+
+	//Vector with future list of built building and buildings in auto-mode that are not yet built.
+	std::vector<const CBuilding*> buildingsThatWillBe, remainingAutoBuildings;
 
 	//Check validity of request
 	if(!force)
@@ -2419,21 +2419,21 @@
 	{
 		if(buildingID >= BuildingID::DWELL_FIRST) //dwelling
 		{
-			int level = (buildingID - BuildingID::DWELL_FIRST) % GameConstants::CREATURES_PER_TOWN;
-			int upgradeNumber = (buildingID - BuildingID::DWELL_FIRST) / GameConstants::CREATURES_PER_TOWN;
-
-			if (upgradeNumber >= t->town->creatures[level].size())
-			{
-				complain(boost::str(boost::format("Error ecountered when building dwelling (bid=%s):"
-													"no creature found (upgrade number %d, level %d!")
+			int level = (buildingID - BuildingID::DWELL_FIRST) % GameConstants::CREATURES_PER_TOWN;
+			int upgradeNumber = (buildingID - BuildingID::DWELL_FIRST) / GameConstants::CREATURES_PER_TOWN;
+
+			if (upgradeNumber >= t->town->creatures.at(level).size())
+			{
+				complain(boost::str(boost::format("Error ecountered when building dwelling (bid=%s):"
+													"no creature found (upgrade number %d, level %d!")
 												% buildingID % upgradeNumber % level));
-				return;
-			}
-
-			CCreature * crea = VLC->creh->creatures[t->town->creatures[level][upgradeNumber]];
-
-			SetAvailableCreatures ssi;
-			ssi.tid = t->id;
+				return;
+			}
+
+			CCreature * crea = VLC->creh->creatures.at(t->town->creatures.at(level).at(upgradeNumber));
+
+			SetAvailableCreatures ssi;
+			ssi.tid = t->id;
 			ssi.creatures = t->creatures;
 			if (buildingID <= BuildingID::DWELL_LAST)
 				ssi.creatures[level].first = crea->growth;
@@ -2455,13 +2455,13 @@
 	};
 
 	//Checks if all requirements will be met with expected building list "buildingsThatWillBe"
-	auto allRequirementsFullfilled = [&buildingsThatWillBe, t](const CBuilding *b)
-	{
-		for(auto requirementID : b->requirements)
-			if(!vstd::contains(buildingsThatWillBe, t->town->buildings[requirementID]))
-				return false;
-
-		return true;
+	auto allRequirementsFullfilled = [&buildingsThatWillBe, t](const CBuilding *b)
+	{
+		for(auto requirementID : b->requirements)
+			if(!vstd::contains(buildingsThatWillBe, t->town->buildings.at(requirementID)))
+				return false;
+
+		return true;
 	};
 
 	//Init the vectors
@@ -2559,13 +2559,13 @@
 }
 
 bool CGameHandler::recruitCreatures( ObjectInstanceID objid, CreatureID crid, ui32 cram, si32 fromLvl )
-{
-	const CGDwelling *dw = static_cast<const CGDwelling*>(gs->getObj(objid));
-	const CArmedInstance *dst = nullptr;
-	const CCreature *c = VLC->creh->creatures[crid];
-	bool warMachine = c->hasBonusOfType(Bonus::SIEGE_WEAPON);
-
-	//TODO: test for owning
+{
+	const CGDwelling *dw = static_cast<const CGDwelling*>(gs->getObj(objid));
+	const CArmedInstance *dst = nullptr;
+	const CCreature *c = VLC->creh->creatures.at(crid);
+	bool warMachine = c->hasBonusOfType(Bonus::SIEGE_WEAPON);
+
+	//TODO: test for owning
 
 	if(dw->ID == Obj::TOWN)
 		dst = (static_cast<const CGTownInstance *>(dw))->getUpperArmy();
@@ -2582,29 +2582,29 @@
 	int level = 0;
 
 	for(; level < dw->creatures.size(); level++) //iterate through all levels
-	{
-		if ( (fromLvl != -1) && ( level !=fromLvl ) )
-			continue;
-		const auto &cur = dw->creatures[level]; //current level info <amount, list of cr. ids>
-		int i = 0;
-		for(; i < cur.second.size(); i++) //look for crid among available creatures list on current level
-			if(cur.second[i] == crid)
-				break;
-
-		if(i < cur.second.size())
+	{
+		if ( (fromLvl != -1) && ( level !=fromLvl ) )
+			continue;
+		const auto &cur = dw->creatures.at(level); //current level info <amount, list of cr. ids>
+		int i = 0;
+		for(; i < cur.second.size(); i++) //look for crid among available creatures list on current level
+			if(cur.second.at(i) == crid)
+				break;
+
+		if(i < cur.second.size())
 		{
 			found = true;
 			cram = std::min(cram, cur.first); //reduce recruited amount up to available amount
 			break;
 		}
 	}
-	SlotID slot = dst->getSlotFor(crid);
-
-	if( (!found && complain("Cannot recruit: no such creatures!"))
-		|| (cram  >  VLC->creh->creatures[crid]->maxAmount(gs->getPlayer(dst->tempOwner)->resources) && complain("Cannot recruit: lack of resources!"))
-		|| (cram<=0  &&  complain("Cannot recruit: cram <= 0!"))
-		|| (!slot.validSlot()  && !warMachine && complain("Cannot recruit: no available slot!")))
-	{
+	SlotID slot = dst->getSlotFor(crid);
+
+	if( (!found && complain("Cannot recruit: no such creatures!"))
+		|| (cram  >  VLC->creh->creatures.at(crid)->maxAmount(gs->getPlayer(dst->tempOwner)->resources) && complain("Cannot recruit: lack of resources!"))
+		|| (cram<=0  &&  complain("Cannot recruit: cram <= 0!"))
+		|| (!slot.validSlot()  && !warMachine && complain("Cannot recruit: no available slot!")))
+	{
 		return false;
 	}
 
@@ -2654,34 +2654,34 @@
 {
 	CArmedInstance *obj = static_cast<CArmedInstance*>(gs->getObjInstance(objid));
 	assert(obj->hasStackAtSlot(pos));
-	UpgradeInfo ui = gs->getUpgradeInfo(obj->getStack(pos));
-	PlayerColor player = obj->tempOwner;
-	const PlayerState *p = getPlayer(player);
-	int crQuantity = obj->stacks[pos]->count;
-	int newIDpos= vstd::find_pos(ui.newID, upgID);//get position of new id in UpgradeInfo
-
-	//check if upgrade is possible
+	UpgradeInfo ui = gs->getUpgradeInfo(obj->getStack(pos));
+	PlayerColor player = obj->tempOwner;
+	const PlayerState *p = getPlayer(player);
+	int crQuantity = obj->stacks.at(pos)->count;
+	int newIDpos= vstd::find_pos(ui.newID, upgID);//get position of new id in UpgradeInfo
+
+	//check if upgrade is possible
 	if( (ui.oldID<0 || newIDpos == -1 ) && complain("That upgrade is not possible!"))
-	{
-		return false;
-	}
-	TResources totalCost = ui.cost[newIDpos] * crQuantity;
-
-	//check if player has enough resources
-	if(!p->resources.canAfford(totalCost))
+	{
+		return false;
+	}
+	TResources totalCost = ui.cost.at(newIDpos) * crQuantity;
+
+	//check if player has enough resources
+	if(!p->resources.canAfford(totalCost))
 		COMPLAIN_RET("Cannot upgrade, not enough resources!");
 
 	//take resources
 	SetResources sr;
 	sr.player = player;
 	sr.res = p->resources - totalCost;
-	sendAndApply(&sr);
-
-	//upgrade creature
-	changeStackType(StackLocation(obj, pos), VLC->creh->creatures[upgID]);
-	return true;
-}
-
+	sendAndApply(&sr);
+
+	//upgrade creature
+	changeStackType(StackLocation(obj, pos), VLC->creh->creatures.at(upgID));
+	return true;
+}
+
 bool CGameHandler::changeStackType(const StackLocation &sl, CCreature *c)
 {
 	if(!sl.army->hasStackAtSlot(sl.slot))
@@ -2849,13 +2849,13 @@
 
 	if(!destArtifact)
 		COMPLAIN_RET("assembleArtifacts: there is no such artifact instance!");
-
-	if(assemble)
-	{
-		CArtifact *combinedArt = VLC->arth->artifacts[assembleTo];
-		if(!combinedArt->constituents)
-			COMPLAIN_RET("assembleArtifacts: Artifact being attempted to assemble is not a combined artifacts!");
-		if(!vstd::contains(destArtifact->assemblyPossibilities(hero), combinedArt))
+
+	if(assemble)
+	{
+		CArtifact *combinedArt = VLC->arth->artifacts.at(assembleTo);
+		if(!combinedArt->constituents)
+			COMPLAIN_RET("assembleArtifacts: Artifact being attempted to assemble is not a combined artifacts!");
+		if(!vstd::contains(destArtifact->assemblyPossibilities(hero), combinedArt))
 			COMPLAIN_RET("assembleArtifacts: It's impossible to assemble requested artifact!");
 
 		AssembledArtifact aa;
@@ -2893,24 +2893,24 @@
 		assert(hero->getArt(ArtifactPosition::SPELLBOOK));
 		giveSpells(town,hero);
 		return true;
-	}
-	else if(aid < 7  &&  aid > 3) //war machine
-	{
-		int price = VLC->arth->artifacts[aid]->price;
-
-		if(( hero->getArt(ArtifactPosition(9+aid)) && complain("Hero already has this machine!"))
-		 || (gs->getPlayer(hero->getOwner())->resources[Res::GOLD] < price && complain("Not enough gold!")))
-		{
-			return false;
-		}
+	}
+	else if(aid < 7  &&  aid > 3) //war machine
+	{
+		int price = VLC->arth->artifacts.at(aid)->price;
+
+		if(( hero->getArt(ArtifactPosition(9+aid)) && complain("Hero already has this machine!"))
+		 || (gs->getPlayer(hero->getOwner())->resources.at(Res::GOLD) < price && complain("Not enough gold!")))
+		{
+			return false;
+		}
 		if  ((town->hasBuilt(BuildingID::BLACKSMITH) && town->town->warMachine == aid )
-		 || ((town->hasBuilt(BuildingID::BALLISTA_YARD, ETownType::STRONGHOLD)) && aid == ArtifactID::BALLISTA))
-		{
-			giveResource(hero->getOwner(),Res::GOLD,-price);
-			giveHeroNewArtifact(hero, VLC->arth->artifacts[aid], ArtifactPosition(9+aid));
-			return true;
-		}
-		else
+		 || ((town->hasBuilt(BuildingID::BALLISTA_YARD, ETownType::STRONGHOLD)) && aid == ArtifactID::BALLISTA))
+		{
+			giveResource(hero->getOwner(),Res::GOLD,-price);
+			giveHeroNewArtifact(hero, VLC->arth->artifacts.at(aid), ArtifactPosition(9+aid));
+			return true;
+		}
+		else
 			COMPLAIN_RET("This machine is unavailable here!");
 	}
 	return false;
@@ -2961,13 +2961,13 @@
 
 	if(!found)
 		COMPLAIN_RET("Cannot find selected artifact on the list");
-
-	sendAndApply(&saa);
-
-	giveHeroNewArtifact(h, VLC->arth->artifacts[aid], ArtifactPosition::FIRST_AVAILABLE);
-	return true;
-}
-
+
+	sendAndApply(&saa);
+
+	giveHeroNewArtifact(h, VLC->arth->artifacts.at(aid), ArtifactPosition::FIRST_AVAILABLE);
+	return true;
+}
+
 bool CGameHandler::sellArtifact( const IMarket *m, const CGHeroInstance *h, ArtifactInstanceID aid, Res::ERes rid )
 {
 	const CArtifactInstance *art = h->getArtByInstanceId(aid);
@@ -3000,13 +3000,13 @@
 	if (h->getSecSkillLevel(SecondarySkill(skill)))
 		COMPLAIN_RET("Hero already know this skill");
 
-	if (!h->canLearnSkill())
-		COMPLAIN_RET("Hero can't learn any more skills");
-
-	if (h->type->heroClass->secSkillProbability[skill]==0)//can't learn this skill (like necromancy for most of non-necros)
-		COMPLAIN_RET("The hero can't learn this skill!");
-
-	if(!vstd::contains(m->availableItemsIds(EMarketMode::RESOURCE_SKILL), skill))
+	if (!h->canLearnSkill())
+		COMPLAIN_RET("Hero can't learn any more skills");
+
+	if (h->type->heroClass->secSkillProbability.at(skill)==0)//can't learn this skill (like necromancy for most of non-necros)
+		COMPLAIN_RET("The hero can't learn this skill!");
+
+	if(!vstd::contains(m->availableItemsIds(EMarketMode::RESOURCE_SKILL), skill))
 		COMPLAIN_RET("That skill is unavailable!");
 
 	if(getResource(h->tempOwner, Res::GOLD) < 2000)//TODO: remove hardcoded resource\summ?
@@ -3021,14 +3021,14 @@
 	changeSecSkill(h, skill, 1, true);
 	return true;
 }
-
-bool CGameHandler::tradeResources(const IMarket *market, ui32 val, PlayerColor player, ui32 id1, ui32 id2)
-{
-	int r1 = gs->getPlayer(player)->resources[id1],
-		r2 = gs->getPlayer(player)->resources[id2];
-
-	vstd::amin(val, r1); //can't trade more resources than have
-
+
+bool CGameHandler::tradeResources(const IMarket *market, ui32 val, PlayerColor player, ui32 id1, ui32 id2)
+{
+	int r1 = gs->getPlayer(player)->resources.at(id1),
+		r2 = gs->getPlayer(player)->resources.at(id2);
+
+	vstd::amin(val, r1); //can't trade more resources than have
+
 	int b1, b2; //base quantities for trade
 	market->getOffer(id1, id2, b1, b2, EMarketMode::RESOURCE_RESOURCE);
 	int units = val / b1; //how many base quantities we trade
@@ -3105,26 +3105,27 @@
 
 	if	(s.hasBonusOfType(Bonus::DRAGON_NATURE))
 		resCreature = 68;
-	else
-		resCreature = 56;
-
-	changeStackType(StackLocation(army, slot), VLC->creh->creatures[resCreature]);
-	return true;
-}
-
+	else
+		resCreature = 56;
+
+	changeStackType(StackLocation(army, slot), VLC->creh->creatures.at(resCreature));
+	return true;
+}
+
 bool CGameHandler::sendResources(ui32 val, PlayerColor player, Res::ERes r1, PlayerColor r2)
 {
 	const PlayerState *p2 = gs->getPlayer(r2, false);
 	if(!p2  ||  p2->status != EPlayerStatus::INGAME)
 	{
 		complain("Dest player must be in game!");
-		return false;
-	}
-
-	si32 curRes1 = gs->getPlayer(player)->resources[r1], curRes2 = gs->getPlayer(r2)->resources[r1];
-	val = std::min(si32(val),curRes1);
-
-	SetResource sr;
+		return false;
+	}
+
+	si32 curRes1 = gs->getPlayer(player)->resources.at(r1),
+	     curRes2 = gs->getPlayer(r2)->resources.at(r1);
+	val = std::min(si32(val),curRes1);
+
+	SetResource sr;
 	sr.player = player;
 	sr.resid = r1;
 	sr.val = curRes1 - val;
@@ -3147,13 +3148,13 @@
 {
 	const PlayerState *p = gs->getPlayer(player);
 	const CGTownInstance *t = gs->getTown(obj->id);
-	static const int GOLD_NEEDED = 2500;
-
-	//common preconditions
-	if( (p->resources[Res::GOLD]<GOLD_NEEDED  && complain("Not enough gold for buying hero!"))
-		|| (getHeroCount(player, false) >= GameConstants::MAX_HEROES_PER_PLAYER && complain("Cannot hire hero, only 8 wandering heroes are allowed!")))
-		return false;
-
+	static const int GOLD_NEEDED = 2500;
+
+	//common preconditions
+	if( (p->resources.at(Res::GOLD)<GOLD_NEEDED  && complain("Not enough gold for buying hero!"))
+		|| (getHeroCount(player, false) >= GameConstants::MAX_HEROES_PER_PLAYER && complain("Cannot hire hero, only 8 wandering heroes are allowed!")))
+		return false;
+
 	if(t) //tavern in town
 	{
 		if(    (!t->hasBuilt(BuildingID::TAVERN)  && complain("No tavern!"))
@@ -3164,13 +3165,13 @@
 	{
 		if(getTile(obj->visitablePos())->visitableObjects.back() != obj  &&  complain("Tavern entry must be unoccupied!"))
 			return false;
-	}
-
-
-	const CGHeroInstance *nh = p->availableHeroes[hid];
-	if (!nh)
-	{
-		complain ("Hero is not available for hiring!");
+	}
+
+
+	const CGHeroInstance *nh = p->availableHeroes.at(hid);
+	if (!nh)
+	{
+		complain ("Hero is not available for hiring!");
 		return false;
 	}
 
@@ -3179,15 +3180,15 @@
 	hr.hid = nh->subID;
 	hr.player = player;
 	hr.tile = obj->visitablePos() + nh->getVisitableOffset();
-	sendAndApply(&hr);
-
-
-	bmap<ui32, ConstTransitivePtr<CGHeroInstance> > pool = gs->unusedHeroesFromPool();
-
-	const CGHeroInstance *theOtherHero = p->availableHeroes[!hid];
-	const CGHeroInstance *newHero = nullptr;
-	if (theOtherHero) //on XXL maps all heroes can be imprisoned :(
-		newHero = gs->hpool.pickHeroFor(false, player, getNativeTown(player), pool, theOtherHero->type->heroClass);
+	sendAndApply(&hr);
+
+
+	std::map<ui32, ConstTransitivePtr<CGHeroInstance> > pool = gs->unusedHeroesFromPool();
+
+	const CGHeroInstance *theOtherHero = p->availableHeroes.at(!hid);
+	const CGHeroInstance *newHero = nullptr;
+	if (theOtherHero) //on XXL maps all heroes can be imprisoned :(
+		newHero = gs->hpool.pickHeroFor(false, player, getNativeTown(player), pool, theOtherHero->type->heroClass);
 
 	SetAvailableHeroes sah;
 	sah.player = player;
@@ -3204,13 +3205,13 @@
 	sah.hid[!hid] = theOtherHero ? theOtherHero->subID : -1;
 	sendAndApply(&sah);
 
-	SetResource sr;
-	sr.player = player;
-	sr.resid = Res::GOLD;
-	sr.val = p->resources[Res::GOLD] - GOLD_NEEDED;
-	sendAndApply(&sr);
-
-	if(t)
+	SetResource sr;
+	sr.player = player;
+	sr.resid = Res::GOLD;
+	sr.val = p->resources.at(Res::GOLD) - GOLD_NEEDED;
+	sendAndApply(&sr);
+
+	if(t)
 	{
 		vistiCastleObjects (t, nh);
 		giveSpells (t,nh);
@@ -3316,13 +3317,13 @@
 		}
 	case Battle::DEFEND:
 		{
-			//defensive stance //TODO: remove this bonus when stack becomes active
-			SetStackEffect sse;
-			sse.effect.push_back( Bonus(Bonus::STACK_GETS_TURN, Bonus::PRIMARY_SKILL, Bonus::OTHER, 20, -1, PrimarySkill::DEFENSE, Bonus::PERCENT_TO_ALL) );
-			sse.effect.push_back( Bonus(Bonus::STACK_GETS_TURN, Bonus::PRIMARY_SKILL, Bonus::OTHER, gs->curB->stacks[ba.stackNumber]->valOfBonuses(Bonus::DEFENSIVE_STANCE),
-				 -1, PrimarySkill::DEFENSE, Bonus::ADDITIVE_VALUE));
-			sse.stacks.push_back(ba.stackNumber);
-			sendAndApply(&sse);
+			//defensive stance //TODO: remove this bonus when stack becomes active
+			SetStackEffect sse;
+			sse.effect.push_back( Bonus(Bonus::STACK_GETS_TURN, Bonus::PRIMARY_SKILL, Bonus::OTHER, 20, -1, PrimarySkill::DEFENSE, Bonus::PERCENT_TO_ALL) );
+			sse.effect.push_back( Bonus(Bonus::STACK_GETS_TURN, Bonus::PRIMARY_SKILL, Bonus::OTHER, gs->curB->stacks.at(ba.stackNumber)->valOfBonuses(Bonus::DEFENSIVE_STANCE),
+				 -1, PrimarySkill::DEFENSE, Bonus::ADDITIVE_VALUE));
+			sse.stacks.push_back(ba.stackNumber);
+			sendAndApply(&sse);
 
 			//don't break - we share code with next case
 		}
@@ -3332,21 +3333,21 @@
 			sendAndApply(&start_action);
 			sendAndApply(&end_action);
 			break;
-		}
-	case Battle::RETREAT: //retreat/flee
-		{
-			if(!gs->curB->battleCanFlee(gs->curB->sides[ba.side].color))
-				complain("Cannot retreat!");
-			else
-				setBattleResult(BattleResult::ESCAPE, !ba.side); //surrendering side loses
+		}
+	case Battle::RETREAT: //retreat/flee
+		{
+			if(!gs->curB->battleCanFlee(gs->curB->sides.at(ba.side).color))
+				complain("Cannot retreat!");
+			else
+				setBattleResult(BattleResult::ESCAPE, !ba.side); //surrendering side loses
 			break;
-		}
-	case Battle::SURRENDER:
-		{
-			PlayerColor player = gs->curB->sides[ba.side].color;
-			int cost = gs->curB->battleGetSurrenderCost(player);
-			if(cost < 0)
-				complain("Cannot surrender!");
+		}
+	case Battle::SURRENDER:
+		{
+			PlayerColor player = gs->curB->sides.at(ba.side).color;
+			int cost = gs->curB->battleGetSurrenderCost(player);
+			if(cost < 0)
+				complain("Cannot surrender!");
 			else if(getResource(player, Res::GOLD) < cost)
 				complain("Not enough gold to surrender!");
 			else
@@ -3532,55 +3533,55 @@
 
 			StartAction start_action(ba);
 			sendAndApply(&start_action);
-			auto onExit = vstd::makeScopeGuard([&]{ sendAndApply(&end_action); }); //if we started than we have to finish
-
-			const CGHeroInstance * attackingHero = gs->curB->battleGetFightingHero(ba.side);
-			CHeroHandler::SBallisticsLevelInfo sbi = VLC->heroh->ballistics[attackingHero->getSecSkillLevel(SecondarySkill::BALLISTICS)];
-
-			EWallParts::EWallParts desiredTarget = gs->curB->battleHexToWallPart(ba.destinationTile);
-			if(desiredTarget < 0)
+			auto onExit = vstd::makeScopeGuard([&]{ sendAndApply(&end_action); }); //if we started than we have to finish
+
+			const CGHeroInstance * attackingHero = gs->curB->battleGetFightingHero(ba.side);
+			CHeroHandler::SBallisticsLevelInfo sbi = VLC->heroh->ballistics.at(attackingHero->getSecSkillLevel(SecondarySkill::BALLISTICS));
+
+			EWallParts::EWallParts desiredTarget = gs->curB->battleHexToWallPart(ba.destinationTile);
+			if(desiredTarget < 0)
 			{
 				complain("catapult tried to attack non-catapultable hex!");
 				break;
 			}
 
-			//in successive iterations damage is dealt but not yet subtracted from wall's HPs
-			auto &currentHP = gs->curB->si.wallState;
-
-			if (currentHP[desiredTarget] == EWallState::DESTROYED  ||  currentHP[desiredTarget] == EWallState::NONE)
-			{
-				complain("catapult tried to attack already destroyed wall part!");
-				break;
+			//in successive iterations damage is dealt but not yet subtracted from wall's HPs
+			auto &currentHP = gs->curB->si.wallState;
+
+			if (currentHP.at(desiredTarget) == EWallState::DESTROYED  ||  currentHP.at(desiredTarget) == EWallState::NONE)
+			{
+				complain("catapult tried to attack already destroyed wall part!");
+				break;
 			}
 
 			for(int g=0; g<sbi.shots; ++g)
 			{
 				bool hitSuccessfull = false;
 				EWallParts::EWallParts attackedPart = desiredTarget;
-
-				do // catapult has chance to attack desired target. Othervice - attacks randomly
-				{
-					if(currentHP[attackedPart] != EWallState::DESTROYED && // this part can be hit
-					   currentHP[attackedPart] != EWallState::NONE &&
-					   rand()%100 < getCatapultHitChance(attackedPart, sbi))//hit is successful
-					{
-						hitSuccessfull = true;
+
+				do // catapult has chance to attack desired target. Othervice - attacks randomly
+				{
+					if(currentHP.at(attackedPart) != EWallState::DESTROYED && // this part can be hit
+					   currentHP.at(attackedPart) != EWallState::NONE &&
+					   rand()%100 < getCatapultHitChance(attackedPart, sbi))//hit is successful
+					{
+						hitSuccessfull = true;
 					}
 					else // select new target
 					{
-						std::vector<EWallParts::EWallParts> allowedTargets;
-						for (size_t i=0; i< currentHP.size(); i++)
-						{
-							if (currentHP[i] != EWallState::DESTROYED &&
-							    currentHP[i] != EWallState::NONE)
-								allowedTargets.push_back(EWallParts::EWallParts(i));
-						}
-						if (allowedTargets.empty())
-							break;
-						attackedPart = allowedTargets[rand()%allowedTargets.size()];
-					}
-				}
-				while (!hitSuccessfull);
+						std::vector<EWallParts::EWallParts> allowedTargets;
+						for (size_t i=0; i< currentHP.size(); i++)
+						{
+							if (currentHP.at(i) != EWallState::DESTROYED &&
+							    currentHP.at(i) != EWallState::NONE)
+								allowedTargets.push_back(EWallParts::EWallParts(i));
+						}
+						if (allowedTargets.empty())
+							break;
+						attackedPart = allowedTargets.at(rand()%allowedTargets.size());
+					}
+				}
+				while (!hitSuccessfull);
 
 				if (!hitSuccessfull) // break triggered - no target to shoot at
 					break;
@@ -3599,13 +3600,13 @@
 				dmgChance[2] += dmgChance[1];
 				//calculating dealt damage
 				for(int damage = 0; damage < ARRAY_COUNT(dmgChance); ++damage)
-				{
-					if(dmgRand <= dmgChance[damage])
-					{
-						currentHP[attackedPart] = SiegeInfo::applyDamage(EWallState::EWallState(currentHP[attackedPart]), damage);
-
-						attack.damageDealt = damage;
-						break;
+				{
+					if(dmgRand <= dmgChance[damage])
+					{
+						currentHP[attackedPart] = SiegeInfo::applyDamage(EWallState::EWallState(currentHP.at(attackedPart)), damage);
+
+						attack.damageDealt = damage;
+						break;
 					}
 				}
 				// attacked tile may have changed - update destination
@@ -3708,13 +3709,13 @@
 
 			bsa.creID = CreatureID(summoner->getBonusLocalFirst(Selector::type(Bonus::DAEMON_SUMMONING))->subtype); //in case summoner can summon more than one type of monsters... scream!
 			ui64 risedHp = summoner->count * summoner->valOfBonuses(Bonus::DAEMON_SUMMONING, bsa.creID.toEnum());
-			ui64 targetHealth = destStack->getCreature()->MaxHealth() * destStack->baseAmount;
-
-			ui64 canRiseHp = std::min(targetHealth, risedHp);
-			ui32 canRiseAmount = canRiseHp / VLC->creh->creatures[bsa.creID]->MaxHealth();
-
-			bsa.amount = std::min(canRiseAmount, destStack->baseAmount);
-
+			ui64 targetHealth = destStack->getCreature()->MaxHealth() * destStack->baseAmount;
+
+			ui64 canRiseHp = std::min(targetHealth, risedHp);
+			ui32 canRiseAmount = canRiseHp / VLC->creh->creatures.at(bsa.creID)->MaxHealth();
+
+			bsa.amount = std::min(canRiseAmount, destStack->baseAmount);
+
 			bsa.pos = gs->curB->getAvaliableHex(bsa.creID, bsa.attacker, destStack->position);
 			bsa.summoned = false;
 
@@ -3802,13 +3803,13 @@
 		}
 
 		//give mana
-		sm.val = 999;
-
-		if(!h->hasSpellbook()) //hero doesn't have spellbook
-			giveHeroNewArtifact(h, VLC->arth->artifacts[0], ArtifactPosition::SPELLBOOK); //give spellbook
-
-		sendAndApply(&cs);
-		sendAndApply(&sm);
+		sm.val = 999;
+
+		if(!h->hasSpellbook()) //hero doesn't have spellbook
+			giveHeroNewArtifact(h, VLC->arth->artifacts.at(0), ArtifactPosition::SPELLBOOK); //give spellbook
+
+		sendAndApply(&cs);
+		sendAndApply(&sm);
 	}
 	else if (message == "vcmiarmenelos") //build all buildings in selected town
 	{
@@ -3833,40 +3834,40 @@
 			}
 		}
 	}
-	else if(message == "vcmiainur") //gives 5 archangels into each slot
-	{
-		CGHeroInstance *hero = gs->getHero(gs->getPlayer(player)->currentSelection);
-		const CCreature *archangel = VLC->creh->creatures[13];
-		if(!hero) return;
-
-		for(int i = 0; i < GameConstants::ARMY_SIZE; i++)
+	else if(message == "vcmiainur") //gives 5 archangels into each slot
+	{
+		CGHeroInstance *hero = gs->getHero(gs->getPlayer(player)->currentSelection);
+		const CCreature *archangel = VLC->creh->creatures.at(13);
+		if(!hero) return;
+
+		for(int i = 0; i < GameConstants::ARMY_SIZE; i++)
 			if(!hero->hasStackAtSlot(SlotID(i)))
 				insertNewStack(StackLocation(hero, SlotID(i)), archangel, 5);
 	}
-	else if(message == "vcmiangband") //gives 10 black knight into each slot
-	{
-		CGHeroInstance *hero = gs->getHero(gs->getPlayer(player)->currentSelection);
-		const CCreature *blackKnight = VLC->creh->creatures[66];
-		if(!hero) return;
-
-		for(int i = 0; i < GameConstants::ARMY_SIZE; i++)
+	else if(message == "vcmiangband") //gives 10 black knight into each slot
+	{
+		CGHeroInstance *hero = gs->getHero(gs->getPlayer(player)->currentSelection);
+		const CCreature *blackKnight = VLC->creh->creatures.at(66);
+		if(!hero) return;
+
+		for(int i = 0; i < GameConstants::ARMY_SIZE; i++)
 			if(!hero->hasStackAtSlot(SlotID(i)))
 				insertNewStack(StackLocation(hero, SlotID(i)), blackKnight, 10);
 	}
 	else if(message == "vcminoldor") //all war machines
 	{
 		CGHeroInstance *hero = gs->getHero(gs->getPlayer(player)->currentSelection);
-		if(!hero) return;
-
-		if(!hero->getArt(ArtifactPosition::MACH1))
-			giveHeroNewArtifact(hero, VLC->arth->artifacts[4], ArtifactPosition::MACH1);
-		if(!hero->getArt(ArtifactPosition::MACH2))
-			giveHeroNewArtifact(hero, VLC->arth->artifacts[5], ArtifactPosition::MACH2);
-		if(!hero->getArt(ArtifactPosition::MACH3))
-			giveHeroNewArtifact(hero, VLC->arth->artifacts[6], ArtifactPosition::MACH3);
-	}
-	else if(message == "vcminahar") //1000000 movement points
-	{
+		if(!hero) return;
+
+		if(!hero->getArt(ArtifactPosition::MACH1))
+			giveHeroNewArtifact(hero, VLC->arth->artifacts.at(4), ArtifactPosition::MACH1);
+		if(!hero->getArt(ArtifactPosition::MACH2))
+			giveHeroNewArtifact(hero, VLC->arth->artifacts.at(5), ArtifactPosition::MACH2);
+		if(!hero->getArt(ArtifactPosition::MACH3))
+			giveHeroNewArtifact(hero, VLC->arth->artifacts.at(6), ArtifactPosition::MACH3);
+	}
+	else if(message == "vcminahar") //1000000 movement points
+	{
 		CGHeroInstance *hero = gs->getHero(gs->getPlayer(player)->currentSelection);
 		if(!hero) return;
 		SetMovePoints smp;
@@ -3891,13 +3892,13 @@
 		fc.player = player;
 		auto  hlp_tab = new int3[gs->map->width * gs->map->height * (gs->map->twoLevel ? 2 : 1)];
 		int lastUnc = 0;
-		for(int i=0;i<gs->map->width;i++)
-			for(int j=0;j<gs->map->height;j++)
-				for(int k = 0; k < (gs->map->twoLevel ? 2 : 1); k++)
-					if(!gs->getPlayerTeam(fc.player)->fogOfWarMap[i][j][k])
-						hlp_tab[lastUnc++] = int3(i,j,k);
-		fc.tiles.insert(hlp_tab, hlp_tab + lastUnc);
-		delete [] hlp_tab;
+		for(int i=0;i<gs->map->width;i++)
+			for(int j=0;j<gs->map->height;j++)
+				for(int k = 0; k < (gs->map->twoLevel ? 2 : 1); k++)
+					if(!gs->getPlayerTeam(fc.player)->fogOfWarMap.at(i).at(j).at(k))
+						hlp_tab[lastUnc++] = int3(i,j,k);
+		fc.tiles.insert(hlp_tab, hlp_tab + lastUnc);
+		delete [] hlp_tab;
 		sendAndApply(&fc);
 	}
 	else if(message == "vcmiglorfindel") //selected hero gains a new level
@@ -3915,19 +3916,19 @@
 	}
 	else if (message == "vcmiforgeofnoldorking") //hero gets all artifacts except war machines, spell scrolls and spell book
 	{
-		CGHeroInstance *hero = gs->getHero(gs->getPlayer(player)->currentSelection);
-		if(!hero) return;
-		for (int g = 7; g < VLC->arth->artifacts.size(); ++g) //including artifacts from mods
-			giveHeroNewArtifact(hero, VLC->arth->artifacts[g], ArtifactPosition::PRE_FIRST);
-	}
-	else
-		cheated = false;
-	if(cheated)
-	{
-		SystemMessage temp_message(VLC->generaltexth->allTexts[260]);
-		sendAndApply(&temp_message);
-		checkLossVictory(player);//Player enter win code or got required art\creature
-	}
+		CGHeroInstance *hero = gs->getHero(gs->getPlayer(player)->currentSelection);
+		if(!hero) return;
+		for (int g = 7; g < VLC->arth->artifacts.size(); ++g) //including artifacts from mods
+			giveHeroNewArtifact(hero, VLC->arth->artifacts.at(g), ArtifactPosition::PRE_FIRST);
+	}
+	else
+		cheated = false;
+	if(cheated)
+	{
+		SystemMessage temp_message(VLC->generaltexth->allTexts.at(260));
+		sendAndApply(&temp_message);
+		checkLossVictory(player);//Player enter win code or got required art\creature
+	}
 }
 
 void CGameHandler::handleSpellCasting( SpellID spellID, int spellLvl, BattleHex destination, ui8 casterSide, PlayerColor casterColor, const CGHeroInstance * caster, const CGHeroInstance * secHero,
@@ -4074,13 +4075,13 @@
 			for(auto & attackedCre : attackedCres)
 			{
 				if(vstd::contains(sc.resisted, (attackedCre)->ID)) //this creature resisted the spell
-					continue;
-
-				BattleStackAttacked bsa;
-				if ((destination > -1 && (attackedCre)->coversPos(destination)) || (spell->range[spellLvl] == "X" || mode == ECastingMode::ENCHANTER_CASTING))
-					//display effect only upon primary target of area spell
-					//FIXME: if no stack is attacked, ther eis no animation and interface freezes
-				{
+					continue;
+
+				BattleStackAttacked bsa;
+				if ((destination > -1 && (attackedCre)->coversPos(destination)) || (spell->range.at(spellLvl) == "X" || mode == ECastingMode::ENCHANTER_CASTING))
+					//display effect only upon primary target of area spell
+					//FIXME: if no stack is attacked, ther eis no animation and interface freezes
+				{
 					bsa.flags |= BattleStackAttacked::EFFECT;
 					bsa.effect = spell->mainEffectAnim;
 				}
@@ -4268,13 +4269,13 @@
 
 			const int patchesForSkill[] = {4, 4, 6, 8};
 			const int patchesToPut = std::min<int>(patchesForSkill[spellLvl], availableTiles.size());
-
-			//land mines or quicksand patches are handled as spell created obstacles
-			for (int i = 0; i < patchesToPut; i++)
-				placeObstacle(availableTiles[i]);
-		}
-
-		break;
+
+			//land mines or quicksand patches are handled as spell created obstacles
+			for (int i = 0; i < patchesToPut; i++)
+				placeObstacle(availableTiles.at(i));
+		}
+
+		break;
 	case SpellID::FORCE_FIELD:
 		placeObstacle(destination);
 		break;
@@ -4327,13 +4328,13 @@
 			bsa.pos = gs->curB->getAvaliableHex(creID, !(bool)casterSide); //TODO: unify it
 
 			//TODO stack casting -> probably power will be zero; set the proper number of creatures manually
-			int percentBonus = caster ? caster->valOfBonuses(Bonus::SPECIFIC_SPELL_DAMAGE, spellID.toEnum()) : 0;
-
-			bsa.amount = usedSpellPower
-				* SpellID(spellID).toSpell()->powers[spellLvl]
-				* (100 + percentBonus) / 100.0; //new feature - percentage bonus
-			if(bsa.amount)
-				sendAndApply(&bsa);
+			int percentBonus = caster ? caster->valOfBonuses(Bonus::SPECIFIC_SPELL_DAMAGE, spellID.toEnum()) : 0;
+
+			bsa.amount = usedSpellPower
+				* SpellID(spellID).toSpell()->powers.at(spellLvl)
+				* (100 + percentBonus) / 100.0; //new feature - percentage bonus
+			if(bsa.amount)
+				sendAndApply(&bsa);
 			else
 				complain("Summoning elementals didn't summon any!");
 		}
@@ -4427,32 +4428,32 @@
 		ssp.val = -1;
 		ssp.absolute = false;
 		sendAndApply(&ssp);
-	}
-
-	//Magic Mirror effect
-	if (spell->isNegative() && mode != ECastingMode::MAGIC_MIRROR && spell->level && spell->range[0] == "0") //it is actual spell and can be reflected to single target, no recurrence
-	{
-		for(auto & attackedCre : attackedCres)
-		{
+	}
+
+	//Magic Mirror effect
+	if (spell->isNegative() && mode != ECastingMode::MAGIC_MIRROR && spell->level && spell->range.at(0) == "0") //it is actual spell and can be reflected to single target, no recurrence
+	{
+		for(auto & attackedCre : attackedCres)
+		{
 			int mirrorChance = (attackedCre)->valOfBonuses(Bonus::MAGIC_MIRROR);
 			if(mirrorChance > rand()%100)
 			{
 				std::vector<CStack *> mirrorTargets;
-				std::vector<CStack *> & battleStacks = gs->curB->stacks;
-				for (auto & battleStack : battleStacks)
-				{
-					if(battleStack->owner == gs->curB->sides[casterSide].color) //get enemy stacks which can be affected by this spell
-					{
-						if (!gs->curB->battleIsImmune(nullptr, spell, ECastingMode::MAGIC_MIRROR, battleStack->position))
-							mirrorTargets.push_back(battleStack);
-					}
-				}
-				if (mirrorTargets.size())
-				{
-					int targetHex = mirrorTargets[rand() % mirrorTargets.size()]->position;
-					handleSpellCasting(spellID, 0, targetHex, 1 - casterSide, (attackedCre)->owner, nullptr, (caster ? caster : nullptr), usedSpellPower, ECastingMode::MAGIC_MIRROR, (attackedCre));
-				}
-			}
+				std::vector<CStack *> & battleStacks = gs->curB->stacks;
+				for (auto & battleStack : battleStacks)
+				{
+					if(battleStack->owner == gs->curB->sides.at(casterSide).color) //get enemy stacks which can be affected by this spell
+					{
+						if (!gs->curB->battleIsImmune(nullptr, spell, ECastingMode::MAGIC_MIRROR, battleStack->position))
+							mirrorTargets.push_back(battleStack);
+					}
+				}
+				if (!mirrorTargets.empty())
+				{
+					int targetHex = mirrorTargets.at(rand() % mirrorTargets.size())->position;
+					handleSpellCasting(spellID, 0, targetHex, 1 - casterSide, (attackedCre)->owner, nullptr, (caster ? caster : nullptr), usedSpellPower, ECastingMode::MAGIC_MIRROR, (attackedCre));
+				}
+			}
 		}
 	}
 }
@@ -4623,13 +4624,13 @@
 					sendAndApply(&bte);
 				}
 			}
-		}
-		BonusList bl = *(st->getBonuses(Selector::type(Bonus::ENCHANTER)));
-		int side = gs->curB->whatSide(st->owner);
-		if (bl.size() && st->casts && !gs->curB->sides[side].enchanterCounter)
-		{
-			int index = rand() % bl.size();
-			SpellID spellID = SpellID(bl[index]->subtype);
+		}
+		BonusList bl = *(st->getBonuses(Selector::type(Bonus::ENCHANTER)));
+		int side = gs->curB->whatSide(st->owner);
+		if (bl.size() && st->casts && !gs->curB->sides.at(side).enchanterCounter)
+		{
+			int index = rand() % bl.size();
+			SpellID spellID = SpellID(bl[index]->subtype);
 			if (gs->curB->battleCanCastThisSpell(st->owner, SpellID(spellID).toSpell(), ECastingMode::ENCHANTER_CASTING) == ESpellCastProblem::OK) //TODO: select another available?
 			{
 				int spellLeveL = bl[index]->val; //spell level
@@ -4756,14 +4757,14 @@
 				InfoWindow iw;
 				iw.player = PlayerColor(player);
 				iw.text << ev.message;
-
-				for (int i=0; i<ev.resources.size(); i++)
-				{
-					if(ev.resources[i]) //if resource is changed, we add it to the dialog
-						iw.components.push_back(Component(Component::RESOURCE,i,ev.resources[i],0));
-				}
-
-				if (iw.components.size())
+
+				for (int i=0; i<ev.resources.size(); i++)
+				{
+					if(ev.resources.at(i)) //if resource is changed, we add it to the dialog
+						iw.components.push_back(Component(Component::RESOURCE,i,ev.resources.at(i),0));
+				}
+
+				if (iw.components.size())
 				{
 					sr.res.amax(0); // If removing too much resources, adjust the amount so the total doesn't become negative.
 					sendAndApply(&sr); //update player resources if changed
@@ -4820,14 +4821,14 @@
 			{
 				TResources was = n.res[player];
 				n.res[player] += ev.resources;
-				n.res[player].amax(0);
-
-				for (int i=0; i<ev.resources.size(); i++)
-					if(ev.resources[i] && pinfo->resources[i] != n.res[player][i]) //if resource had changed, we add it to the dialog
-						iw.components.push_back(Component(Component::RESOURCE,i,n.res[player][i]-was[i],0));
-
-			}
-
+				n.res[player].amax(0);
+
+				for (int i=0; i<ev.resources.size(); i++)
+					if(ev.resources.at(i) && pinfo->resources.at(i) != n.res.at(player).at(i)) //if resource had changed, we add it to the dialog
+						iw.components.push_back(Component(Component::RESOURCE,i,n.res.at(player).at(i)-was.at(i),0));
+
+			}
+
 			for(auto & i : ev.buildings)
 			{
 				if ( town->hasBuilt(i))
@@ -4843,17 +4844,17 @@
 				n.cres[town->id].creatures = town->creatures;
 			}
 			auto & sac = n.cres[town->id];
-
-			for(si32 i=0;i<ev.creatures.size();i++) //creature growths
-			{
-				if(town->creatureDwellingLevel(i) >= 0 && ev.creatures[i])//there is dwelling
-				{
-					sac.creatures[i].first += ev.creatures[i];
-					iw.components.push_back(Component(Component::CREATURE,
-							town->creatures[i].second.back(), ev.creatures[i], 0));
-				}
-			}
-			sendAndApply(&iw); //show dialog
+
+			for(si32 i=0;i<ev.creatures.size();i++) //creature growths
+			{
+				if(town->creatureDwellingLevel(i) >= 0 && ev.creatures.at(i))//there is dwelling
+				{
+					sac.creatures[i].first += ev.creatures.at(i);
+					iw.components.push_back(Component(Component::CREATURE,
+							town->creatures.at(i).second.back(), ev.creatures.at(i), 0));
+				}
+			}
+			sendAndApply(&iw); //show dialog
 		}
 
 		if(ev.nextOccurence)
@@ -4949,16 +4950,16 @@
 				return true;
 		}
 
-		//Ongoing garrison exchange
-		if(auto dialog = std::dynamic_pointer_cast<CGarrisonDialogQuery>(queries.topQuery(o1->tempOwner)))
-		{
-			if(dialog->exchangingArmies[0] == o1 && dialog->exchangingArmies[1] == o2)
-				return true;
-
-			if(dialog->exchangingArmies[1] == o1 && dialog->exchangingArmies[0] == o2)
-				return true;
-		}
-	}
+		//Ongoing garrison exchange
+		if(auto dialog = std::dynamic_pointer_cast<CGarrisonDialogQuery>(queries.topQuery(o1->tempOwner)))
+		{
+			if(dialog->exchangingArmies.at(0) == o1 && dialog->exchangingArmies.at(1) == o2)
+				return true;
+
+			if(dialog->exchangingArmies.at(1) == o1 && dialog->exchangingArmies.at(0) == o2)
+				return true;
+		}
+	}
 
 	return false;
 }
@@ -5301,13 +5302,13 @@
 	iw.player = h->tempOwner;
 	if(gs->map->grailPos == h->getPosition())
 	{
-		iw.text.addTxt(MetaString::GENERAL_TXT, 58); //"Congratulations! After spending many hours digging here, your hero has uncovered the "
-		iw.text.addTxt(MetaString::ART_NAMES, 2);
-		iw.soundID = soundBase::ULTIMATEARTIFACT;
-		giveHeroNewArtifact(h, VLC->arth->artifacts[2], ArtifactPosition::PRE_FIRST); //give grail
-		sendAndApply(&iw);
-
-		iw.soundID = soundBase::invalid;
+		iw.text.addTxt(MetaString::GENERAL_TXT, 58); //"Congratulations! After spending many hours digging here, your hero has uncovered the "
+		iw.text.addTxt(MetaString::ART_NAMES, 2);
+		iw.soundID = soundBase::ULTIMATEARTIFACT;
+		giveHeroNewArtifact(h, VLC->arth->artifacts.at(2), ArtifactPosition::PRE_FIRST); //give grail
+		sendAndApply(&iw);
+
+		iw.soundID = soundBase::invalid;
 		iw.text.clear();
 		iw.text.addTxt(MetaString::ART_DESCR, 2);
 		sendAndApply(&iw);
@@ -5384,13 +5385,13 @@
 {
 	const CStack * attacker = gs->curB->battleGetStackByID(bat.stackAttacking);
 	if (!attacker) //could be already dead
-		return;
-	attackCasting(bat, Bonus::SPELL_AFTER_ATTACK, attacker);
-
-	if(bat.bsa[0].newAmount <= 0)
-	{
-		//don't try death stare or acid breath on dead stack (crash!)
-		return;
+		return;
+	attackCasting(bat, Bonus::SPELL_AFTER_ATTACK, attacker);
+
+	if(bat.bsa.at(0).newAmount <= 0)
+	{
+		//don't try death stare or acid breath on dead stack (crash!)
+		return;
 	}
 
 	if (attacker->hasBonusOfType(Bonus::DEATH_STARE) && bat.bsa.size())
@@ -5408,17 +5409,17 @@
 		int staredCreatures = distr(rng);
 
 		double cap = 1 / std::max(chanceToKill, (double)(0.01));//don't divide by 0
-		int maxToKill = (attacker->count + cap - 1) / cap; //not much more than chance * count
-		vstd::amin(staredCreatures, maxToKill);
-
-		staredCreatures += (attacker->level() * attacker->valOfBonuses(Bonus::DEATH_STARE, 1)) / gs->curB->battleGetStackByID(bat.bsa[0].stackAttacked)->level();
-		if (staredCreatures)
-		{
-			if (bat.bsa[0].newAmount > 0) //TODO: death stare was not originally available for multiple-hex attacks, but...
-			handleSpellCasting(SpellID::DEATH_STARE, 0, gs->curB->battleGetStackByID(bat.bsa[0].stackAttacked)->position,
-				!attacker->attackerOwned, attacker->owner, nullptr, nullptr, staredCreatures, ECastingMode::AFTER_ATTACK_CASTING, attacker);
-		}
-	}
+		int maxToKill = (attacker->count + cap - 1) / cap; //not much more than chance * count
+		vstd::amin(staredCreatures, maxToKill);
+
+		staredCreatures += (attacker->level() * attacker->valOfBonuses(Bonus::DEATH_STARE, 1)) / gs->curB->battleGetStackByID(bat.bsa.at(0).stackAttacked)->level();
+		if (staredCreatures)
+		{
+			if (bat.bsa.at(0).newAmount > 0) //TODO: death stare was not originally available for multiple-hex attacks, but...
+			handleSpellCasting(SpellID::DEATH_STARE, 0, gs->curB->battleGetStackByID(bat.bsa.at(0).stackAttacked)->position,
+				!attacker->attackerOwned, attacker->owner, nullptr, nullptr, staredCreatures, ECastingMode::AFTER_ATTACK_CASTING, attacker);
+		}
+	}
 
 	int acidDamage = 0;
 	TBonusListPtr acidBreath = attacker->getBonuses(Selector::type(Bonus::ACID_BREATH));
@@ -5426,13 +5427,13 @@
 	{
 		if (b->additionalInfo > rand()%100)
 			acidDamage += b->val;
-	}
-	if (acidDamage)
-	{
-		handleSpellCasting(SpellID::ACID_BREATH_DAMAGE, 0, gs->curB->battleGetStackByID(bat.bsa[0].stackAttacked)->position,
-				!attacker->attackerOwned, attacker->owner, nullptr, nullptr,
-				acidDamage * attacker->count, ECastingMode::AFTER_ATTACK_CASTING, attacker);
-	}
+	}
+	if (acidDamage)
+	{
+		handleSpellCasting(SpellID::ACID_BREATH_DAMAGE, 0, gs->curB->battleGetStackByID(bat.bsa.at(0).stackAttacked)->position,
+				!attacker->attackerOwned, attacker->owner, nullptr, nullptr,
+				acidDamage * attacker->count, ECastingMode::AFTER_ATTACK_CASTING, attacker);
+	}
 }
 
 bool CGameHandler::castSpell(const CGHeroInstance *h, SpellID spellID, const int3 &pos)
@@ -5455,13 +5456,13 @@
 
 	switch(spellID)
 	{
-	case SpellID::SUMMON_BOAT:
-		{
-			//check if spell works at all
-			if(rand() % 100 >= s->powers[schoolLevel]) //power is % chance of success
-			{
-				InfoWindow iw;
-				iw.player = h->tempOwner;
+	case SpellID::SUMMON_BOAT:
+		{
+			//check if spell works at all
+			if(rand() % 100 >= s->powers.at(schoolLevel)) //power is % chance of success
+			{
+				InfoWindow iw;
+				iw.player = h->tempOwner;
 				iw.text.addTxt(MetaString::GENERAL_TXT, 336); //%s tried to summon a boat, but failed.
 				iw.text.addReplacement(h->name);
 				sendAndApply(&iw);
@@ -5517,13 +5518,13 @@
 			break;
 		}
 
-	case SpellID::SCUTTLE_BOAT:
-		{
-			//check if spell works at all
-			if(rand() % 100 >= s->powers[schoolLevel]) //power is % chance of success
-			{
-				InfoWindow iw;
-				iw.player = h->tempOwner;
+	case SpellID::SCUTTLE_BOAT:
+		{
+			//check if spell works at all
+			if(rand() % 100 >= s->powers.at(schoolLevel)) //power is % chance of success
+			{
+				InfoWindow iw;
+				iw.player = h->tempOwner;
 				iw.text.addTxt(MetaString::GENERAL_TXT, 337); //%s tried to scuttle the boat, but failed
 				iw.text.addReplacement(h->name);
 				sendAndApply(&iw);
@@ -5548,13 +5549,13 @@
 			const TerrainTile *curr = getTile(h->getSightCenter());
 
 			if(!dest)
-				COMPLAIN_RET("Destination tile doesn't exist!");
-			if(!h->movement)
-				COMPLAIN_RET("Hero needs movement points to cast Dimension Door!");
-			if(h->getBonusesCount(Bonus::SPELL_EFFECT, SpellID::DIMENSION_DOOR) >= s->powers[schoolLevel]) //limit casts per turn
-			{
-				InfoWindow iw;
-				iw.player = h->tempOwner;
+				COMPLAIN_RET("Destination tile doesn't exist!");
+			if(!h->movement)
+				COMPLAIN_RET("Hero needs movement points to cast Dimension Door!");
+			if(h->getBonusesCount(Bonus::SPELL_EFFECT, SpellID::DIMENSION_DOOR) >= s->powers.at(schoolLevel)) //limit casts per turn
+			{
+				InfoWindow iw;
+				iw.player = h->tempOwner;
 				iw.text.addTxt(MetaString::GENERAL_TXT, 338); //%s is not skilled enough to cast this spell again today.
 				iw.text.addReplacement(h->name);
 				sendAndApply(&iw);
@@ -6211,13 +6212,13 @@
 	std::vector<int3>::iterator tile;
 	std::vector<int3> tiles;
 	getFreeTiles(tiles);
-	ui32 amount = tiles.size() / 200; //Chance is 0.5% for each tile
-	std::random_shuffle(tiles.begin(), tiles.end());
-    logGlobal->traceStream() << "Spawning wandering monsters. Found " << tiles.size() << " free tiles. Creature type: " << creatureID;
-	const CCreature *cre = VLC->creh->creatures[creatureID];
-	for (int i = 0; i < amount; ++i)
-	{
-		tile = tiles.begin();
+	ui32 amount = tiles.size() / 200; //Chance is 0.5% for each tile
+	std::random_shuffle(tiles.begin(), tiles.end());
+    logGlobal->traceStream() << "Spawning wandering monsters. Found " << tiles.size() << " free tiles. Creature type: " << creatureID;
+	const CCreature *cre = VLC->creh->creatures.at(creatureID);
+	for (int i = 0; i < amount; ++i)
+	{
+		tile = tiles.begin();
         logGlobal->traceStream() << "\tSpawning monster at " << *tile;
 		putNewMonster(creatureID, cre->getRandomAmount(std::rand), *tile);
 		tiles.erase(tile); //not use it again
@@ -6289,13 +6290,13 @@
 	return true;
 }
 
-void CGameHandler::duelFinished()
-{
-	auto si = getStartInfo();
-	auto getName = [&](int i){ return si->getIthPlayersSettings(gs->curB->sides[i].color).name; };
-
-	int casualtiesPoints = 0;
-	logGlobal->debugStream() << boost::format("Winner side %d\nWinner casualties:") 
+void CGameHandler::duelFinished()
+{
+	auto si = getStartInfo();
+	auto getName = [&](int i){ return si->getIthPlayersSettings(gs->curB->sides.at(i).color).name; };
+
+	int casualtiesPoints = 0;
+	logGlobal->debugStream() << boost::format("Winner side %d\nWinner casualties:") 
 		% (int)battleResult.data->winner;
 
 	for(auto & elem : battleResult.data->casualties[battleResult.data->winner])