Formatting

lib/mapping/MapFormatJson.cpp

@@ -17,95 +17,95 @@
 #include "../CModHandler.h"
 #include "../VCMI_Lib.h"
 
-namespace TriggeredEventsDetail{
-
-static const std::array<std::string, 12> conditionNames = {
-"haveArtifact", "haveCreatures",   "haveResources",   "haveBuilding",
-"control",      "destroy",         "transport",       "daysPassed",
-"isHuman",      "daysWithoutTown", "standardWin",     "constValue"
-};
-
-static const std::array<std::string, 2> typeNames = { "victory", "defeat" };
-
-static EventCondition JsonToCondition(const JsonNode & node)
+namespace TriggeredEventsDetail
 {
-	EventCondition event;
-	event.condition = EventCondition::EWinLoseType(vstd::find_pos(conditionNames, node.Vector()[0].String()));
-	if (node.Vector().size() > 1)
+	static const std::array<std::string, 12> conditionNames =
 	{
-		const JsonNode & data = node.Vector()[1];
-		if (data["type"].getType() == JsonNode::DATA_STRING)
-			event.objectType = VLC->modh->identifiers.getIdentifier(data["type"]).get();
-		if (data["type"].getType() == JsonNode::DATA_FLOAT)
-			event.objectType = data["type"].Float();
+		"haveArtifact", "haveCreatures",   "haveResources",   "haveBuilding",
+		"control",      "destroy",         "transport",       "daysPassed",
+		"isHuman",      "daysWithoutTown", "standardWin",     "constValue"
+	};
 
-		if (!data["value"].isNull())
-			event.value = data["value"].Float();
+	static const std::array<std::string, 2> typeNames = { "victory", "defeat" };
 
-		if (!data["position"].isNull())
+	static EventCondition JsonToCondition(const JsonNode & node)
+	{
+		EventCondition event;
+		event.condition = EventCondition::EWinLoseType(vstd::find_pos(conditionNames, node.Vector()[0].String()));
+		if (node.Vector().size() > 1)
 		{
-			auto & position = data["position"].Vector();			
-			event.position.x = position.at(0).Float();
-			event.position.y = position.at(1).Float();
-			event.position.z = position.at(2).Float();
+			const JsonNode & data = node.Vector()[1];
+			if (data["type"].getType() == JsonNode::DATA_STRING)
+				event.objectType = VLC->modh->identifiers.getIdentifier(data["type"]).get();
+			if (data["type"].getType() == JsonNode::DATA_FLOAT)
+				event.objectType = data["type"].Float();
+
+			if (!data["value"].isNull())
+				event.value = data["value"].Float();
+
+			if (!data["position"].isNull())
+			{
+				auto & position = data["position"].Vector();
+				event.position.x = position.at(0).Float();
+				event.position.y = position.at(1).Float();
+				event.position.z = position.at(2).Float();
+			}
 		}
+		return event;
 	}
-	return event;
-}
 
-static JsonNode ConditionToJson(const EventCondition& event)
-{
-	JsonNode json;
-	
-	JsonVector& asVector = json.Vector();
-	
-	JsonNode condition;
-	condition.String() = conditionNames.at(event.condition);
-	asVector.push_back(condition);
-	
-	JsonNode data;
-	
-	//todo: save identifier
-	
-	if(event.value != -1)
-		data["value"].Float() = event.value;
-	
-	if(event.position != int3(-1,-1,-1))
+	static JsonNode ConditionToJson(const EventCondition& event)
 	{
-		auto & position = data["position"].Vector();
-		position.resize(3);
-		position[0].Float() = event.position.x; 
-		position[1].Float() = event.position.y; 
-		position[2].Float() = event.position.z;	
-	}		
-	
-	asVector.push_back(data);
-			
-	return std::move(json);
-}
+		JsonNode json;
+
+		JsonVector& asVector = json.Vector();
+
+		JsonNode condition;
+		condition.String() = conditionNames.at(event.condition);
+		asVector.push_back(condition);
+
+		JsonNode data;
+
+		//todo: save identifier
+
+		if(event.value != -1)
+			data["value"].Float() = event.value;
+
+		if(event.position != int3(-1,-1,-1))
+		{
+			auto & position = data["position"].Vector();
+			position.resize(3);
+			position[0].Float() = event.position.x;
+			position[1].Float() = event.position.y;
+			position[2].Float() = event.position.z;
+		}
+
+		asVector.push_back(data);
 
+		return std::move(json);
+	}
 }//namespace TriggeredEventsDetail
 
-namespace TerrainDetail{
-	static const std::array<std::string, 10> terrainCodes = 
+namespace TerrainDetail
+{
+	static const std::array<std::string, 10> terrainCodes =
 	{
 		"dt", "sa", "gr", "sn", "sw", "rg", "sb", "lv", "wt", "rc"
 	};
-	static const std::array<std::string, 4> roadCodes = 
+	static const std::array<std::string, 4> roadCodes =
 	{
 		"", "pd", "pg", "pc"
 	};
-	
-	static const std::array<std::string, 5> riverCodes = 
+
+	static const std::array<std::string, 5> riverCodes =
 	{
 		"", "rw", "ri", "rm", "rl"
 	};
-	
-	static const std::array<char, 10> flipCodes = 
+
+	static const std::array<char, 10> flipCodes =
 	{
 		'_', '-', '|', '+'
-	};	
- 
+	};
 }
 
 ///CMapFormatJson
@@ -120,8 +120,8 @@ void CMapFormatJson::readTriggeredEvents(const JsonNode & input)
 	mapHeader->victoryIconIndex = input["victoryIconIndex"].Float();
 
 	mapHeader->defeatMessage = input["defeatString"].String();
-	mapHeader->defeatIconIndex = input["defeatIconIndex"].Float();	
-	
+	mapHeader->defeatIconIndex = input["defeatIconIndex"].Float();
+
 	mapHeader->triggeredEvents.clear();
 
 	for (auto & entry : input["triggeredEvents"].Struct())
@@ -151,9 +151,9 @@ void CMapFormatJson::writeTriggeredEvents(JsonNode& output)
 
 	output["defeatString"].String() = map->defeatMessage;
 	output["defeatIconIndex"].Float() = map->defeatIconIndex;
-	
+
 	JsonMap & triggeredEvents = output["triggeredEvents"].Struct();
-	
+
 	for(auto event : map->triggeredEvents)
 		writeTriggeredEvent(event, triggeredEvents[event.identifier]);
 }
@@ -164,10 +164,10 @@ void CMapFormatJson::writeTriggeredEvent(const TriggeredEvent& event, JsonNode&
 
 	dest["message"].String() = event.onFulfill;
 	dest["description"].String() = event.description;
-	
+
 	dest["effect"]["type"].String() = typeNames.at(size_t(event.effect.type));
 	dest["effect"]["messageToSend"].String() = event.effect.toOtherMessage;
-	
+
 	dest["condition"] = event.trigger.toJson(ConditionToJson);
 }
 
@@ -197,16 +197,16 @@ CMapFormatZip::CMapFormatZip(CInputOutputStream * stream):
 	buffer(stream),
 	ioApi(new CProxyIOApi(buffer))
 {
-	
+
 }
 
 
 ///CMapLoaderJson
 CMapLoaderJson::CMapLoaderJson(CInputOutputStream * stream):
 	CMapFormatZip(stream),
-	loader("", "_", ioApi)	
+	loader("", "_", ioApi)
 {
-	
+
 }
 
 std::unique_ptr<CMap> CMapLoaderJson::loadMap()
@@ -227,14 +227,14 @@ std::unique_ptr<CMapHeader> CMapLoaderJson::loadMapHeader()
 const JsonNode CMapLoaderJson::readJson(const std::string & archiveFilename)
 {
 	ResourceID resource(archiveFilename, EResType::TEXT);
-	
+
 	if(!loader.existsResource(resource))
 		throw new std::runtime_error(archiveFilename+" not found");
-	
+
 	auto data = loader.load(resource)->readAll();
-	
+
 	JsonNode res(reinterpret_cast<char*>(data.first.get()), data.second);
-	
+
 	return std::move(res);
 }
 
@@ -255,34 +255,34 @@ void CMapLoaderJson::readHeader()
 	//TODO: read such data like map name & size
 	//mapHeader->version = ??? //todo: new version field
 
-	//todo: multilevel map load support	
-	const JsonNode levels = header["mapLevels"];	
+	//todo: multilevel map load support
+	const JsonNode levels = header["mapLevels"];
 	mapHeader->height = levels["surface"]["height"].Float();
-	mapHeader->width = levels["surface"]["width"].Float();	
+	mapHeader->width = levels["surface"]["width"].Float();
 	mapHeader->twoLevel = !levels["underground"].isNull();
 
 	mapHeader->name = header["name"].String();
 	mapHeader->description = header["description"].String();
-	
+
 	//todo: support arbitrary percentage
-	
+
 	static const std::map<std::string, ui8> difficultyMap =
 	{
 		{"", 1},
 		{"EASY", 0},
-		{"NORMAL", 1}, 
-		{"HARD", 2}, 
+		{"NORMAL", 1},
+		{"HARD", 2},
 		{"EXPERT", 3},
-		{"IMPOSSIBLE", 4}		
+		{"IMPOSSIBLE", 4}
 	};
-	
-	mapHeader->difficulty = difficultyMap.at(header["difficulty"].String()); 
+
+	mapHeader->difficulty = difficultyMap.at(header["difficulty"].String());
 	mapHeader->levelLimit = header["levelLimit"].Float();
-	
+
 
 //	std::vector<bool> allowedHeroes;
-//	std::vector<ui16> placeholdedHeroes;	
-	
+//	std::vector<ui16> placeholdedHeroes;
+
 	readTriggeredEvents(header);
 	readPlayerInfo();
 	//TODO: readHeader
@@ -306,26 +306,26 @@ void CMapLoaderJson::readTerrainTile(const std::string& src, TerrainTile& tile)
 			throw new std::runtime_error("Invalid terrain type code in "+src);
 
 		tile.terType = ETerrainType(rawType);
-	}	
+	}
 	int startPos = 2; //0+typeCode fixed length
 	{//terrain view
-		int pos = startPos;			
+		int pos = startPos;
 		while(isdigit(src.at(pos)))
-			pos++;		
-		int len = pos - startPos;		
+			pos++;
+		int len = pos - startPos;
 		if(len<=0)
-			throw new std::runtime_error("Invalid terrain view in "+src);		
-		const std::string rawCode = src.substr(startPos,len);		
-		tile.terView = atoi(rawCode.c_str());		
-		startPos+=len;		
+			throw new std::runtime_error("Invalid terrain view in "+src);
+		const std::string rawCode = src.substr(startPos,len);
+		tile.terView = atoi(rawCode.c_str());
+		startPos+=len;
 	}
 	{//terrain flip
-		int terrainFlip = vstd::find_pos(flipCodes, src.at(startPos++));		
+		int terrainFlip = vstd::find_pos(flipCodes, src.at(startPos++));
 		if(terrainFlip < 0)
 			throw new std::runtime_error("Invalid terrain flip in "+src);
 		else
-			tile.extTileFlags = terrainFlip;		
-	}	
+			tile.extTileFlags = terrainFlip;
+	}
 	if(startPos >= src.size())
 		return;
 	bool hasRoad = true;
@@ -342,81 +342,81 @@ void CMapLoaderJson::readTerrainTile(const std::string& src, TerrainTile& tile)
 			{
 				tile.riverType = ERiverType::ERiverType(rawType);
 				hasRoad = false;
-			}				
-		}			
-		else	
-			tile.roadType = ERoadType::ERoadType(rawType);			
+			}
+		}
+		else
+			tile.roadType = ERoadType::ERoadType(rawType);
 	}
 	if(hasRoad)
 	{//road dir
 		int pos = startPos;
 		while(isdigit(src.at(pos)))
-			pos++;		
-		int len = pos - startPos;		
+			pos++;
+		int len = pos - startPos;
 		if(len<=0)
-			throw new std::runtime_error("Invalid road dir in "+src);		
-		const std::string rawCode = src.substr(startPos,len);		
-		tile.roadDir = atoi(rawCode.c_str());		
-		startPos+=len;		
+			throw new std::runtime_error("Invalid road dir in "+src);
+		const std::string rawCode = src.substr(startPos,len);
+		tile.roadDir = atoi(rawCode.c_str());
+		startPos+=len;
 	}
 	if(hasRoad)
 	{//road flip
-		int flip = vstd::find_pos(flipCodes, src.at(startPos++));		
+		int flip = vstd::find_pos(flipCodes, src.at(startPos++));
 		if(flip < 0)
 			throw new std::runtime_error("Invalid road flip in "+src);
 		else
-			tile.extTileFlags |= (flip<<4);		
+			tile.extTileFlags |= (flip<<4);
 	}
 	if(startPos >= src.size())
-		return;	
+		return;
 	if(hasRoad)
 	{//river type
 		const std::string typeCode = src.substr(startPos,2);
-		startPos+=2;		
+		startPos+=2;
 		int rawType = vstd::find_pos(riverCodes, typeCode);
 		if(rawType < 0)
 			throw new std::runtime_error("Invalid river type in "+src);
-		tile.riverType = ERiverType::ERiverType(rawType);					
+		tile.riverType = ERiverType::ERiverType(rawType);
 	}
 	{//river dir
 		int pos = startPos;
 		while(isdigit(src.at(pos)))
-			pos++;		
-		int len = pos - startPos;		
+			pos++;
+		int len = pos - startPos;
 		if(len<=0)
-			throw new std::runtime_error("Invalid river dir in "+src);		
-		const std::string rawCode = src.substr(startPos,len);		
-		tile.riverDir = atoi(rawCode.c_str());		
-		startPos+=len;		
+			throw new std::runtime_error("Invalid river dir in "+src);
+		const std::string rawCode = src.substr(startPos,len);
+		tile.riverDir = atoi(rawCode.c_str());
+		startPos+=len;
 	}
 	{//river flip
 		int flip = vstd::find_pos(flipCodes, src.at(startPos++));
 		if(flip < 0)
 			throw new std::runtime_error("Invalid road flip in "+src);
 		else
-			tile.extTileFlags |= (flip<<2);		
-	}	
+			tile.extTileFlags |= (flip<<2);
+	}
 }
 
 void CMapLoaderJson::readTerrainLevel(const JsonNode& src, const int index)
 {
 	int3 pos(0,0,index);
-	
+
 	const JsonVector & rows = src.Vector();
-	
+
 	if(rows.size() != map->height)
 		throw new std::runtime_error("Invalid terrain data");
-	
+
 	for(pos.y = 0; pos.y < map->height; pos.y++)
 	{
 		const JsonVector & tiles = rows[pos.y].Vector();
-		
+
 		if(tiles.size() != map->width)
-			throw new std::runtime_error("Invalid terrain data");		
-		
+			throw new std::runtime_error("Invalid terrain data");
+
 		for(pos.x = 0; pos.x < map->width; pos.x++)
 			readTerrainTile(tiles[pos.x].String(), map->getTile(pos));
-	}	
+	}
 }
 
 
@@ -424,14 +424,14 @@ void CMapLoaderJson::readTerrain()
 {
 	{
 		const JsonNode surface = readJson("surface.json");
-		readTerrainLevel(surface, 0);		
+		readTerrainLevel(surface, 0);
 	}
 	if(map->twoLevel)
 	{
 		const JsonNode underground = readJson("underground.json");
-		readTerrainLevel(underground, 1);			
+		readTerrainLevel(underground, 1);
 	}
-		
+
 }
 
 ///CMapSaverJson
@@ -439,12 +439,12 @@ CMapSaverJson::CMapSaverJson(CInputOutputStream * stream):
 	CMapFormatZip(stream),
 	saver(ioApi, "_")
 {
-	
+
 }
 
 CMapSaverJson::~CMapSaverJson()
 {
-	
+
 }
 
 void CMapSaverJson::addToArchive(const JsonNode& data, const std::string& filename)
@@ -452,21 +452,21 @@ void CMapSaverJson::addToArchive(const JsonNode& data, const std::string& filena
 	std::ostringstream out;
 	out << data;
 	out.flush();
-	
+
 	{
 		auto s = out.str();
 		std::unique_ptr<COutputStream> stream = saver.addFile(filename);
-		
+
 		if (stream->write((const ui8*)s.c_str(), s.size()) != s.size())
 			throw new std::runtime_error("CMapSaverJson::saveHeader() zip compression failed.");
-	}		
+	}
 }
 
 void CMapSaverJson::saveMap(const std::unique_ptr<CMap>& map)
 {
 	//TODO: saveMap
 	this->map = map.get();
-	writeHeader();	
+	writeHeader();
 	writeTerrain();
 }
 
@@ -474,26 +474,26 @@ void CMapSaverJson::writeHeader()
 {
 	JsonNode header;
 	header["versionMajor"].Float() = VERSION_MAJOR;
-	header["versionMinor"].Float() = VERSION_MINOR;	
-	
-	//todo: multilevel map save support	
+	header["versionMinor"].Float() = VERSION_MINOR;
+
+	//todo: multilevel map save support
 	JsonNode & levels = header["mapLevels"];
-	levels["surface"]["height"].Float() = map->height;	
+	levels["surface"]["height"].Float() = map->height;
 	levels["surface"]["width"].Float() = map->width;
 	levels["surface"]["index"].Float() = 0;
-	
+
 	if(map->twoLevel)
 	{
-		levels["underground"]["height"].Float() = map->height;	
-		levels["underground"]["width"].Float() = map->width;	
+		levels["underground"]["height"].Float() = map->height;
+		levels["underground"]["width"].Float() = map->width;
 		levels["underground"]["index"].Float() = 1;
 	}
-	
+
 	header["name"].String() = map->name;
 	header["description"].String() = map->description;
-	
-	
-	//todo: support arbitrary percentage	
+
+
+	//todo: support arbitrary percentage
 	static const std::map<ui8, std::string> difficultyMap =
 	{
 		{0, "EASY"},
@@ -502,17 +502,17 @@ void CMapSaverJson::writeHeader()
 		{3, "EXPERT"},
 		{4, "IMPOSSIBLE"}
 	};
-	
-	header["difficulty"].String() = difficultyMap.at(map->difficulty);	
+
+	header["difficulty"].String() = difficultyMap.at(map->difficulty);
 	header["levelLimit"].Float() = map->levelLimit;
-	
+
 	writeTriggeredEvents(header);
-	
+
 	//todo: player info
-	
+
 	//todo:	allowedHeroes;
-	//todo: placeholdedHeroes;	
-	
+	//todo: placeholdedHeroes;
+
 	addToArchive(header, HEADER_FILE_NAME);
 }
 
@@ -543,32 +543,32 @@ JsonNode CMapSaverJson::writeTerrainLevel(const int index)
 {
 	JsonNode data;
 	int3 pos(0,0,index);
-	
+
 	data.Vector().resize(map->height);
-	
+
 	for(pos.y = 0; pos.y < map->height; pos.y++)
 	{
 		JsonNode & row = data.Vector()[pos.y];
-		
+
 		row.Vector().resize(map->width);
-		
+
 		for(pos.x = 0; pos.x < map->width; pos.x++)
 			row.Vector()[pos.x].String() = writeTerrainTile(map->getTile(pos));
 	}
-	
+
 	return std::move(data);
 }
 
 void CMapSaverJson::writeTerrain()
 {
-	//todo: multilevel map save support	
-	
+	//todo: multilevel map save support
+
 	JsonNode surface = writeTerrainLevel(0);
 	addToArchive(surface, "surface.json");
-	
+
 	if(map->twoLevel)
 	{
 		JsonNode underground = writeTerrainLevel(1);
-		addToArchive(underground, "underground.json");		
+		addToArchive(underground, "underground.json");
 	}
 }

test/CMapFormatTest.cpp

@@ -30,18 +30,18 @@ static std::unique_ptr<CMap> initialMap;
 
 class CMapTestFixture
 {
-public:	
+public:
 	CMapTestFixture()
 	{
 		CMapGenOptions opt;
-		
+
 		opt.setHeight(CMapHeader::MAP_SIZE_SMALL);
 		opt.setWidth(CMapHeader::MAP_SIZE_SMALL);
 		opt.setHasTwoLevels(true);
 		opt.setPlayerCount(2);
-		
+
 		CMapGenerator gen;
-		
+
 		initialMap = gen.generate(&opt, TEST_RANDOM_SEED);
 		initialMap->name = "Test";
 	};
@@ -61,10 +61,10 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 		CMapSaverJson saver(&serializeBuffer);
 		saver.saveMap(initialMap);
 	}
-	
+
 	#if 1
 	{
-		auto path = VCMIDirs::get().userDataPath()/"temp.zip";
+		auto path = VCMIDirs::get().userDataPath()/"test.zip";
 		boost::filesystem::remove(path);
 		boost::filesystem::ofstream tmp(path, boost::filesystem::ofstream::binary);
 
@@ -72,10 +72,10 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 		tmp.flush();
 		tmp.close();
 	}
-	
-	
+
+
 	#endif // 1
-	
+
 	serializeBuffer.seek(0);
 	{
 		CMapLoaderJson loader(&serializeBuffer);

test/MapComparer.cpp

@@ -30,23 +30,23 @@ template <class Element>
 void checkEqual(const std::vector<Element> & actual, const std::vector<Element> & expected)
 {
 	BOOST_CHECK_EQUAL(actual.size(), expected.size());
-	
+
 	for(auto actualIt = actual.begin(), expectedIt = expected.begin(); actualIt != actual.end() && expectedIt != expected.end(); actualIt++, expectedIt++)
 	{
 		checkEqual(*actualIt, *expectedIt);
-	}		
+	}
 }
 
 template <class Element>
 void checkEqual(const std::set<Element> & actual, const std::set<Element> & expected)
 {
 	BOOST_CHECK_EQUAL(actual.size(), expected.size());
-	
+
 	for(auto elem : expected)
 	{
 		if(!vstd::contains(actual, elem))
 			BOOST_ERROR("Required element not found "+boost::to_string(elem));
-	}		
+	}
 }
 
 void checkEqual(const PlayerInfo & actual, const PlayerInfo & expected)
@@ -54,17 +54,17 @@ void checkEqual(const PlayerInfo & actual, const PlayerInfo & expected)
 	VCMI_CHECK_FIELD_EQUAL(canHumanPlay);
 	VCMI_CHECK_FIELD_EQUAL(canComputerPlay);
 	VCMI_CHECK_FIELD_EQUAL(aiTactic);
-	
+
 	checkEqual(actual.allowedFactions, expected.allowedFactions);
-	
+
 	VCMI_CHECK_FIELD_EQUAL(isFactionRandom);
-	VCMI_CHECK_FIELD_EQUAL(mainCustomHeroPortrait);	
+	VCMI_CHECK_FIELD_EQUAL(mainCustomHeroPortrait);
 	VCMI_CHECK_FIELD_EQUAL(mainCustomHeroName);
-	
+
 	VCMI_CHECK_FIELD_EQUAL(mainCustomHeroId);
-	
+
 	//todo:heroesNames
-	
+
 	VCMI_CHECK_FIELD_EQUAL(hasMainTown);
 	VCMI_CHECK_FIELD_EQUAL(generateHeroAtMainTown);
 	VCMI_CHECK_FIELD_EQUAL(posOfMainTown);
@@ -84,9 +84,9 @@ void checkEqual(const TriggeredEvent & actual,  const TriggeredEvent & expected)
 	VCMI_CHECK_FIELD_EQUAL(description);
 	VCMI_CHECK_FIELD_EQUAL(onFulfill);
 	VCMI_CHECK_FIELD_EQUAL(effect.type);
-	VCMI_CHECK_FIELD_EQUAL(effect.toOtherMessage);	
+	VCMI_CHECK_FIELD_EQUAL(effect.toOtherMessage);
 
-	checkEqual(actual.trigger, expected.trigger);	
+	checkEqual(actual.trigger, expected.trigger);
 }
 
 void checkEqual(const TerrainTile & actual, const TerrainTile & expected)
@@ -103,7 +103,7 @@ void checkEqual(const TerrainTile & actual, const TerrainTile & expected)
 
 void MapComparer::compareHeader()
 {
-	//map size parameters are vital for further checks 
+	//map size parameters are vital for further checks
 	VCMI_REQUIRE_FIELD_EQUAL_P(height);
 	VCMI_REQUIRE_FIELD_EQUAL_P(width);
 	VCMI_REQUIRE_FIELD_EQUAL_P(twoLevel);
@@ -117,23 +117,23 @@ void MapComparer::compareHeader()
 	VCMI_CHECK_FIELD_EQUAL_P(defeatMessage);
 	VCMI_CHECK_FIELD_EQUAL_P(victoryIconIndex);
 	VCMI_CHECK_FIELD_EQUAL_P(defeatIconIndex);
-	
-	checkEqual(actual->players, expected->players);	
-	
+
+	checkEqual(actual->players, expected->players);
+
 	//todo: allowedHeroes, placeholdedHeroes
-	
-	
+
+
 	std::vector<TriggeredEvent> actualEvents = actual->triggeredEvents;
 	std::vector<TriggeredEvent> expectedEvents = expected->triggeredEvents;
-	
+
 	auto sortByIdentifier = [](const TriggeredEvent & lhs, const TriggeredEvent & rhs) -> bool
 	{
 		return lhs.identifier  < rhs.identifier;
 	};
 	boost::sort (actualEvents, sortByIdentifier);
 	boost::sort (expectedEvents, sortByIdentifier);
-	
-	checkEqual(actualEvents, expectedEvents);	
+
+	checkEqual(actualEvents, expectedEvents);
 }
 
 void MapComparer::compareOptions()
@@ -144,7 +144,7 @@ void MapComparer::compareOptions()
 	//allowedSpell
 	//allowedArtifact
 	//allowedAbilities
-	
+
 	BOOST_ERROR("Not implemented compareOptions()");
 }
 
@@ -157,13 +157,13 @@ void MapComparer::compareTerrain()
 {
 	//assume map dimensions check passed
 	//todo: separate check for underground
-	
+
 	for(int x = 0; x < expected->width; x++)
 		for(int y = 0; y < expected->height; y++)
 		{
 			int3 coord(x,y,0);
 			BOOST_TEST_CHECKPOINT(coord);
-			
+
 			checkEqual(actual->getTile(coord), expected->getTile(coord));
 		}
 }