From 36f4d8684461de5c589bcd87bbba93b929dda32e Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Mon, 27 Jul 2015 08:33:47 +0300
Subject: [PATCH 001/105] Test drafts

---
 test/CMapEditManagerTest.cpp |  8 ++---
 test/CMapFormatTest.cpp      | 63 ++++++++++++++++++++++++++++++++++++
 test/Test.cbp                |  2 ++
 3 files changed, 69 insertions(+), 4 deletions(-)
 create mode 100644 test/CMapFormatTest.cpp

diff --git a/test/CMapEditManagerTest.cpp b/test/CMapEditManagerTest.cpp
index 394bdaded..cccf7356d 100644
--- a/test/CMapEditManagerTest.cpp
+++ b/test/CMapEditManagerTest.cpp
@@ -110,11 +110,11 @@ BOOST_AUTO_TEST_CASE(CMapEditManager_DrawTerrain_View)
 	{
 		// Load maps and json config
 
-		#if defined(__MINGW32__)
+//		#if defined(__MINGW32__)
 		const std::string TEST_DATA_DIR = "test/";
-		#else
-		const std::string TEST_DATA_DIR = ".";
-		#endif // defined
+//		#else
+//		const std::string TEST_DATA_DIR = ".";
+//		#endif // defined
 
 
 		auto loader = new CFilesystemLoader("test/", TEST_DATA_DIR);
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
new file mode 100644
index 000000000..6d6cbff98
--- /dev/null
+++ b/test/CMapFormatTest.cpp
@@ -0,0 +1,63 @@
+
+/*
+ * CMapFormatTest.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
+ *
+ */
+
+
+#include "StdInc.h"
+#include <boost/test/unit_test.hpp>
+
+#include "../lib/mapping/CMap.h"
+#include "../lib/rmg/CMapGenOptions.h"
+#include "../lib/rmg/CMapGenerator.h"
+
+static const int TEST_RANDOM_SEED = 1337;
+
+static CMap * initialMap;
+
+class CMapTestFixture
+{
+public:	
+	CMapTestFixture()
+	{
+		CMapGenOptions opt;
+		
+		opt.setHeight(72);
+		opt.setWidth(72);
+		opt.setHasTwoLevels(false);
+		opt.setPlayerCount(2);
+		
+		CMapGenerator gen;
+		
+		initialMap = gen.generate(&opt, TEST_RANDOM_SEED).release();
+	};
+	~CMapTestFixture()
+	{
+		delete initialMap;
+	};
+};
+
+BOOST_GLOBAL_FIXTURE(CMapTestFixture);
+
+BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
+{
+	try
+	{
+
+		//TODO: serialize map
+		//TODO: deserialize map
+		//TODO: compare results
+		
+	}
+	catch(const std::exception & e)
+	{
+		logGlobal-> errorStream() << e.what();
+		throw;
+	}
+}
diff --git a/test/Test.cbp b/test/Test.cbp
index 67ace151e..be4d35ad6 100644
--- a/test/Test.cbp
+++ b/test/Test.cbp
@@ -10,6 +10,7 @@
 				<Option platforms="Windows;" />
 				<Option output="../Test" prefix_auto="1" extension_auto="1" />
 				<Option object_output="obj/Debug/x86/" />
+				<Option working_dir="../." />
 				<Option type="1" />
 				<Option compiler="gcc" />
 				<Compiler>
@@ -57,6 +58,7 @@
 			<Add directory="../" />
 		</Linker>
 		<Unit filename="CMapEditManagerTest.cpp" />
+		<Unit filename="CMapFormatTest.cpp" />
 		<Unit filename="CVcmiTestConfig.cpp" />
 		<Unit filename="CVcmiTestConfig.h" />
 		<Unit filename="StdInc.cpp">

From adc271d7b3567d468d4602f68e295eb25212abec Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Fri, 7 Aug 2015 22:33:44 +0300
Subject: [PATCH 002/105] Draft on classes hierarchy. * patcher and loader uses
 diferent input (JsonNode and binary stream of zipped map archive), dicided to
 split them

---
 lib/mapping/CMapService.cpp   |   2 +-
 lib/mapping/CMapService.h     |   2 +-
 lib/mapping/MapFormatJson.cpp | 145 ++++++++++++++++++----------------
 lib/mapping/MapFormatJson.h   |  89 +++++++++++++--------
 4 files changed, 136 insertions(+), 102 deletions(-)

diff --git a/lib/mapping/CMapService.cpp b/lib/mapping/CMapService.cpp
index fc4efb2e3..335e190da 100644
--- a/lib/mapping/CMapService.cpp
+++ b/lib/mapping/CMapService.cpp
@@ -103,5 +103,5 @@ std::unique_ptr<IMapPatcher> CMapService::getMapPatcher(std::string scenarioName
 
 	boost::to_lower(scenarioName);
 	logGlobal->debugStream() << "Request to patch map " << scenarioName;
-	return std::unique_ptr<IMapPatcher>(new CMapLoaderJson(node[scenarioName]));
+	return std::unique_ptr<IMapPatcher>(new CMapPatcher(node[scenarioName]));
 }
diff --git a/lib/mapping/CMapService.h b/lib/mapping/CMapService.h
index 82333e9ae..a633be859 100644
--- a/lib/mapping/CMapService.h
+++ b/lib/mapping/CMapService.h
@@ -126,7 +126,7 @@ public:
 	virtual std::unique_ptr<CMapHeader> loadMapHeader() = 0;
 };
 
-class DLL_LINKAGE IMapPatcher : public IMapLoader
+class DLL_LINKAGE IMapPatcher
 {
 public:
 	/**
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 9e2189ef4..272a58f75 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -23,12 +23,88 @@ static const std::string conditionNames[] = {
 
 static const std::string typeNames[] = { "victory", "defeat" };
 
-CMapLoaderJson::CMapLoaderJson(JsonNode stream):
+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)
+	{
+		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())
+		{
+			event.position.x = data["position"].Vector()[0].Float();
+			event.position.y = data["position"].Vector()[1].Float();
+			event.position.z = data["position"].Vector()[2].Float();
+		}
+	}
+	return event;
+}
+
+///CMapFormatJson
+void CMapFormatJson::readTriggeredEvents(const JsonNode & input)
+{
+	mapHeader->victoryMessage = input["victoryString"].String();
+	mapHeader->victoryIconIndex = input["victoryIconIndex"].Float();
+
+	mapHeader->defeatMessage = input["defeatString"].String();
+	mapHeader->defeatIconIndex = input["defeatIconIndex"].Float();	
+	
+	mapHeader->triggeredEvents.clear();
+
+	for (auto & entry : input["triggeredEvents"].Struct())
+	{
+		TriggeredEvent event;
+		event.identifier = entry.first;
+		readTriggeredEvent(event, entry.second);
+		mapHeader->triggeredEvents.push_back(event);
+	}
+}
+
+
+void CMapFormatJson::readTriggeredEvent(TriggeredEvent & event, const JsonNode & source)
+{
+	event.onFulfill = source["message"].String();
+	event.description = source["description"].String();
+	event.effect.type = vstd::find_pos(typeNames, source["effect"]["type"].String());
+	event.effect.toOtherMessage = source["effect"]["messageToSend"].String();
+	event.trigger = EventExpression(source["condition"], JsonToCondition); // logical expression
+}
+
+///CMapPatcher
+CMapPatcher::CMapPatcher(JsonNode stream):
 	input(stream)
 {
 
 }
 
+void CMapPatcher::patchMapHeader(std::unique_ptr<CMapHeader> & header)
+{
+	header.swap(mapHeader);
+	if (!input.isNull())
+		readPatchData();
+	header.swap(mapHeader);
+}
+
+void CMapPatcher::readPatchData()
+{
+	readTriggeredEvents(input);
+}
+
+///CMapLoaderJson
+CMapLoaderJson::CMapLoaderJson(CInputStream * stream):
+	input(stream)
+{
+	
+}
+
 std::unique_ptr<CMap> CMapLoaderJson::loadMap()
 {
 	map = new CMap();
@@ -85,13 +161,6 @@ JsonNode eventToJson(const EventCondition & cond)
 	return ret;
 }
 */
-void CMapLoaderJson::patchMapHeader(std::unique_ptr<CMapHeader> & header)
-{
-	header.swap(mapHeader);
-	if (!input.isNull())
-		readPatchData();
-	header.swap(mapHeader);
-}
 
 void CMapLoaderJson::readMap()
 {
@@ -102,69 +171,11 @@ void CMapLoaderJson::readMap()
 void CMapLoaderJson::readHeader()
 {
 	//TODO: read such data like map name & size
-	readPatchData();
+//	readTriggeredEvents();
 	readPlayerInfo();
 	assert(0); // Not implemented
 }
 
-void CMapLoaderJson::readPatchData()
-{
-	mapHeader->victoryMessage = input["victoryString"].String();
-	mapHeader->victoryIconIndex = input["victoryIconIndex"].Float();
-
-	mapHeader->defeatMessage = input["defeatString"].String();
-	mapHeader->defeatIconIndex = input["defeatIconIndex"].Float();
-
-	readTriggeredEvents();
-}
-
-void CMapLoaderJson::readTriggeredEvents()
-{
-	mapHeader->triggeredEvents.clear();
-
-	for (auto & entry : input["triggeredEvents"].Struct())
-	{
-		TriggeredEvent event;
-		event.identifier = entry.first;
-		readTriggeredEvent(event, entry.second);
-		mapHeader->triggeredEvents.push_back(event);
-	}
-}
-
-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)
-	{
-		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())
-		{
-			event.position.x = data["position"].Vector()[0].Float();
-			event.position.y = data["position"].Vector()[1].Float();
-			event.position.z = data["position"].Vector()[2].Float();
-		}
-	}
-	return event;
-}
-
-void CMapLoaderJson::readTriggeredEvent(TriggeredEvent & event, const JsonNode & source)
-{
-	event.onFulfill = source["message"].String();
-	event.description = source["description"].String();
-	event.effect.type = vstd::find_pos(typeNames, source["effect"]["type"].String());
-	event.effect.toOtherMessage = source["effect"]["messageToSend"].String();
-	event.trigger = EventExpression(source["condition"], JsonToCondition); // logical expression
-}
-
 void CMapLoaderJson::readPlayerInfo()
 {
 	assert(0); // Not implemented
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 3a75dff35..31bfc3fa4 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -15,8 +15,61 @@
 #include "../JsonNode.h"
 
 class TriggeredEvent;
+class CInputStream;
 
-class DLL_LINKAGE CMapLoaderJson : public IMapPatcher
+class DLL_LINKAGE CMapFormatJson
+{
+
+protected:
+	
+	/** ptr to the map object which gets filled by data from the buffer or written to buffer */
+	CMap * map;
+
+	/**
+	 * ptr to the map header object which gets filled by data from the buffer or written to buffer.
+	 * (when loading map and mapHeader point to the same object)
+	 */
+	std::unique_ptr<CMapHeader> mapHeader;	
+	
+	/**
+	 * Reads triggered events, including victory/loss conditions
+	 */
+	void readTriggeredEvents(const JsonNode & input);
+
+	/**
+	 * Reads one of triggered events
+	 */
+	void readTriggeredEvent(TriggeredEvent & event, const JsonNode & source);		
+};
+
+class DLL_LINKAGE CMapPatcher : public CMapFormatJson, public IMapPatcher
+{
+public:
+	/**
+	 * Default constructor.
+	 *
+	 * @param stream. A stream containing the map data.
+	 */
+	CMapPatcher(JsonNode stream);
+		
+public: //IMapPatcher
+	/**
+	 * Modifies supplied map header using Json data
+	 *
+	 */
+	void patchMapHeader(std::unique_ptr<CMapHeader> & header) override;
+	
+private:
+	/**
+	 * Reads subset of header that can be replaced by patching.
+	 */
+	void readPatchData();
+
+
+	const JsonNode input;	
+};
+
+class DLL_LINKAGE CMapLoaderJson :  public CMapFormatJson, public IMapLoader
 {
 public:
 	/**
@@ -24,7 +77,7 @@ public:
 	 *
 	 * @param stream a stream containing the map data
 	 */
-	CMapLoaderJson(JsonNode stream);
+	CMapLoaderJson(CInputStream * stream);
 
 	/**
 	 * Loads the VCMI/Json map file.
@@ -40,12 +93,6 @@ public:
 	 */
 	std::unique_ptr<CMapHeader> loadMapHeader() override;
 
-	/**
-	 * Modifies supplied map header using Json data
-	 *
-	 */
-	void patchMapHeader(std::unique_ptr<CMapHeader> & header) override;
-
 private:
 	/**
 	 * Reads complete map.
@@ -57,35 +104,11 @@ private:
 	 */
 	void readHeader();
 
-	/**
-	 * Reads subset of header that can be replaced by patching.
-	 */
-	void readPatchData();
-
 	/**
 	 * Reads player information.
 	 */
 	void readPlayerInfo();
 
-	/**
-	 * Reads triggered events, including victory/loss conditions
-	 */
-	void readTriggeredEvents();
 
-	/**
-	 * Reads one of triggered events
-	 */
-	void readTriggeredEvent(TriggeredEvent & event, const JsonNode & source);
-
-
-	/** ptr to the map object which gets filled by data from the buffer */
-	CMap * map;
-
-	/**
-	 * ptr to the map header object which gets filled by data from the buffer.
-	 * (when loading map and mapHeader point to the same object)
-	 */
-	std::unique_ptr<CMapHeader> mapHeader;
-
-	const JsonNode input;
+	CInputStream * input;
 };

From 221ec55f51c5dee519df768b2e02235daa9b0170 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sat, 8 Aug 2015 17:30:19 +0300
Subject: [PATCH 003/105] Define basic design of output streams

---
 lib/filesystem/CInputStream.h  | 34 ++---------------------
 lib/filesystem/COutputStream.h | 34 +++++++++++++++++++++++
 lib/filesystem/CStream.h       | 50 ++++++++++++++++++++++++++++++++++
 lib/mapping/CMapService.h      | 13 +++++++++
 lib/mapping/MapFormatJson.cpp  |  7 +++++
 lib/mapping/MapFormatJson.h    |  8 +++++-
 6 files changed, 114 insertions(+), 32 deletions(-)
 create mode 100644 lib/filesystem/COutputStream.h
 create mode 100644 lib/filesystem/CStream.h

diff --git a/lib/filesystem/CInputStream.h b/lib/filesystem/CInputStream.h
index d20a197bd..eab845f75 100644
--- a/lib/filesystem/CInputStream.h
+++ b/lib/filesystem/CInputStream.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "CStream.h"
+
 /*
  * CInputStream.h, part of VCMI engine
  *
@@ -13,7 +15,7 @@
 /**
  * Abstract class which provides method definitions for reading from a stream.
  */
-class DLL_LINKAGE CInputStream : private boost::noncopyable
+class DLL_LINKAGE CInputStream : public virtual CStream
 {
 public:
 	/**
@@ -30,36 +32,6 @@ public:
 	 */
 	virtual si64 read(ui8 * data, si64 size) = 0;
 
-	/**
-	 * Seeks the internal read pointer to the specified position.
-	 *
-	 * @param position The read position from the beginning.
-	 * @return the position actually moved to, -1 on error.
-	 */
-	virtual si64 seek(si64 position) = 0;
-
-	/**
-	 * Gets the current read position in the stream.
-	 *
-	 * @return the read position.
-	 */
-	virtual si64 tell() = 0;
-
-	/**
-	 * Skips delta numbers of bytes.
-	 *
-	 * @param delta The count of bytes to skip.
-	 * @return the count of bytes skipped actually.
-	 */
-	virtual si64 skip(si64 delta) = 0;
-
-	/**
-	 * Gets the length in bytes of the stream.
-	 *
-	 * @return the length in bytes of the stream.
-	 */
-	virtual si64 getSize() = 0;
-
 	/**
 	 * @brief for convenience, reads whole stream at once
 	 *
diff --git a/lib/filesystem/COutputStream.h b/lib/filesystem/COutputStream.h
new file mode 100644
index 000000000..ba4a70f13
--- /dev/null
+++ b/lib/filesystem/COutputStream.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "CStream.h"
+
+/*
+ * COutputStream.h, 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
+ *
+ */
+
+/**
+ * Abstract class which provides method definitions for writing into a stream.
+ */
+class DLL_LINKAGE COutputStream : public virtual CStream
+{
+public:
+	/**
+	 * D-tor.
+	 */
+	virtual ~COutputStream() {}
+
+	/**
+	 * Write n bytes from the stream into the data buffer.
+	 *
+	 * @param data A pointer to the destination data array.
+	 * @param size The number of bytes to write.
+	 * @return the number of bytes written actually.
+	 */
+	virtual si64 write(ui8 * data, si64 size) = 0;
+};
diff --git a/lib/filesystem/CStream.h b/lib/filesystem/CStream.h
new file mode 100644
index 000000000..d085eec72
--- /dev/null
+++ b/lib/filesystem/CStream.h
@@ -0,0 +1,50 @@
+#pragma once
+
+/*
+ * CStream.h, 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
+ *
+ */
+
+class DLL_LINKAGE CStream : private boost::noncopyable
+{
+public:
+	/**
+	 * D-tor.
+	 */
+	virtual ~CStream() {}
+
+	/**
+	 * Seeks to the specified position.
+	 *
+	 * @param position The position from the beginning.
+	 * @return the position actually moved to, -1 on error.
+	 */
+	virtual si64 seek(si64 position) = 0;
+
+	/**
+	 * Gets the current position in the stream.
+	 *
+	 * @return the position.
+	 */
+	virtual si64 tell() = 0;
+
+	/**
+	 * Relative seeks to the specified position.
+	 *
+	 * @param delta The count of bytes to seek from current position.
+	 * @return the count of bytes skipped actually.
+	 */
+	virtual si64 skip(si64 delta) = 0;
+
+	/**
+	 * Gets the length in bytes of the stream.
+	 *
+	 * @return the length in bytes of the stream.
+	 */
+	virtual si64 getSize() = 0;	
+};
diff --git a/lib/mapping/CMapService.h b/lib/mapping/CMapService.h
index a633be859..9ce4da6e4 100644
--- a/lib/mapping/CMapService.h
+++ b/lib/mapping/CMapService.h
@@ -135,3 +135,16 @@ public:
 	 */
 	virtual void patchMapHeader(std::unique_ptr<CMapHeader> & header) = 0;
 };
+
+/**
+ * Interface for saving a map.
+ */
+class DLL_LINKAGE IMapSaver
+{
+public:
+	/**
+	 * Saves the VCMI/H3 map file.
+	 *
+	 */	
+	 virtual void saveMap(const std::unique_ptr<CMap> & map) = 0;
+};
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 272a58f75..8f130a092 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -180,3 +180,10 @@ void CMapLoaderJson::readPlayerInfo()
 {
 	assert(0); // Not implemented
 }
+
+///CMapSaverJson
+void CMapSaverJson::saveMap(const std::unique_ptr<CMap>& map)
+{
+	
+}
+
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 31bfc3fa4..0e44389a7 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -69,7 +69,7 @@ private:
 	const JsonNode input;	
 };
 
-class DLL_LINKAGE CMapLoaderJson :  public CMapFormatJson, public IMapLoader
+class DLL_LINKAGE CMapLoaderJson : public CMapFormatJson, public IMapLoader
 {
 public:
 	/**
@@ -112,3 +112,9 @@ private:
 
 	CInputStream * input;
 };
+
+class DLL_LINKAGE CMapSaverJson : public CMapFormatJson, public IMapSaver
+{
+public:
+	void saveMap(const std::unique_ptr<CMap> & map) override;	
+};

From c965f9d02dac14a6701180fb38e28f0471c7dc94 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sat, 8 Aug 2015 18:21:50 +0300
Subject: [PATCH 004/105] Added draft of IO memeory buffer

---
 lib/CMakeLists.txt               |  3 +-
 lib/filesystem/CMemoryBuffer.cpp | 66 ++++++++++++++++++++++++
 lib/filesystem/CMemoryBuffer.h   | 87 ++++++++++++++++++++++++++++++++
 lib/filesystem/CMemoryStream.h   |  3 +-
 4 files changed, 157 insertions(+), 2 deletions(-)
 create mode 100644 lib/filesystem/CMemoryBuffer.cpp
 create mode 100644 lib/filesystem/CMemoryBuffer.h

diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 6657e0b91..dacb58b81 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -12,7 +12,8 @@ set(lib_SRCS
 		filesystem/CFilesystemLoader.cpp
 		filesystem/CArchiveLoader.cpp
 		filesystem/CFileInfo.cpp
-		filesystem/CMemoryStream.cpp
+                filesystem/CMemoryBuffer.cpp
+                filesystem/CMemoryStream.cpp
 		filesystem/CBinaryReader.cpp
 		filesystem/CFileInputStream.cpp
 		filesystem/CZipLoader.cpp
diff --git a/lib/filesystem/CMemoryBuffer.cpp b/lib/filesystem/CMemoryBuffer.cpp
new file mode 100644
index 000000000..659458ede
--- /dev/null
+++ b/lib/filesystem/CMemoryBuffer.cpp
@@ -0,0 +1,66 @@
+/*
+ * CMemoryBuffer.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
+ *
+ */
+ 
+#include "StdInc.h"
+#include "CMemoryBuffer.h"
+
+///CMemoryBuffer
+CMemoryBuffer::CMemoryBuffer():
+	position(0)
+{
+	
+}
+
+si64 CMemoryBuffer::write(ui8 * data, si64 size)
+{
+	buffer.reserve(tell()+size);
+	
+	std::copy(data, data + size, buffer.data() + position);
+	position += size;
+	
+	return size;		
+}
+
+si64 CMemoryBuffer::read(ui8 * data, si64 size)
+{
+	si64 toRead = std::min(getSize() - tell(), size);
+	
+	std::copy(buffer.data() + position, buffer.data() + position + toRead, data);
+	position += toRead;
+	
+	return toRead;	
+}
+
+si64 CMemoryBuffer::seek(si64 position)
+{
+	this->position = position;
+	if (this->position >=getSize())
+		this->position = getSize()-1;
+	return this->position;
+}
+
+si64 CMemoryBuffer::tell()
+{
+	return position;
+}
+
+si64 CMemoryBuffer::skip(si64 delta)
+{
+	auto old_position = tell();
+	
+	return seek(old_position + delta) - old_position; 
+}
+
+si64 CMemoryBuffer::getSize()
+{
+	return buffer.size();
+}
+
+
diff --git a/lib/filesystem/CMemoryBuffer.h b/lib/filesystem/CMemoryBuffer.h
new file mode 100644
index 000000000..04a028966
--- /dev/null
+++ b/lib/filesystem/CMemoryBuffer.h
@@ -0,0 +1,87 @@
+#pragma once
+
+/*
+ * CMemoryBuffer.h, 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
+ *
+ */
+ 
+
+#include "CInputStream.h"
+#include "COutputStream.h"
+
+/**
+ * A class which provides IO memory buffer.
+ */
+ 
+class DLL_LINKAGE CMemoryBuffer : public CInputStream, public COutputStream
+{
+public:
+	typedef std::vector<ui8> TBuffer;
+
+	/**
+	 * C-tor.
+	 *
+	 */
+	CMemoryBuffer();
+	
+	/**
+	 * Write n bytes from the stream into the data buffer.
+	 *
+	 * @param data A pointer to the destination data array.
+	 * @param size The number of bytes to write.
+	 * @return the number of bytes written actually.
+	 */
+	si64 write(ui8 * data, si64 size) override;	
+
+	/**
+	 * Reads n bytes from the stream into the data buffer.
+	 *
+	 * @param data A pointer to the destination data array.
+	 * @param size The number of bytes to read.
+	 * @return the number of bytes read actually.
+	 */
+	si64 read(ui8 * data, si64 size) override;
+
+	/**
+	 * Seeks the internal read pointer to the specified position.
+	 *
+	 * @param position The read position from the beginning.
+	 * @return the position actually moved to, -1 on error.
+	 */
+	si64 seek(si64 position) override;
+
+	/**
+	 * Gets the current read position in the stream.
+	 *
+	 * @return the read position.
+	 */
+	si64 tell() override;
+
+	/**
+	 * Skips delta numbers of bytes.
+	 *
+	 * @param delta The count of bytes to skip.
+	 * @return the count of bytes skipped actually.
+	 */
+	si64 skip(si64 delta) override;
+
+	/**
+	 * Gets the length in bytes of the stream.
+	 *
+	 * @return the length in bytes of the stream.
+	 */
+	si64 getSize() override;
+
+private:
+	/** Actual data. */
+	TBuffer buffer;
+	
+	/** Current reading position of the stream. */
+	si64 position;
+};
+
diff --git a/lib/filesystem/CMemoryStream.h b/lib/filesystem/CMemoryStream.h
index 55d1447ee..5b039db12 100644
--- a/lib/filesystem/CMemoryStream.h
+++ b/lib/filesystem/CMemoryStream.h
@@ -14,7 +14,8 @@
 
 /**
  * A class which provides method definitions for reading from memory.
- */
+ * @deprecated use CMemoryBuffer
+ */ 
 class DLL_LINKAGE CMemoryStream : public CInputStream
 {
 public:

From 7d16585f896080a7596206813d33f300b90ee8ec Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sat, 8 Aug 2015 18:35:54 +0300
Subject: [PATCH 005/105] Use COutputStream in CMapSaverJson

---
 lib/mapping/MapFormatJson.cpp | 11 ++++++++++-
 lib/mapping/MapFormatJson.h   | 14 ++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 8f130a092..768e5ad41 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -11,6 +11,8 @@
 #include "StdInc.h"
 #include "MapFormatJson.h"
 
+#include "../filesystem/CInputStream.h"
+#include "../filesystem/COutputStream.h"
 #include "CMap.h"
 #include "../CModHandler.h"
 #include "../VCMI_Lib.h"
@@ -182,8 +184,15 @@ void CMapLoaderJson::readPlayerInfo()
 }
 
 ///CMapSaverJson
-void CMapSaverJson::saveMap(const std::unique_ptr<CMap>& map)
+CMapSaverJson::CMapSaverJson(COutputStream * stream):
+	output(stream)
 {
 	
 }
 
+
+void CMapSaverJson::saveMap(const std::unique_ptr<CMap>& map)
+{
+	assert(0); // Not implemented	
+}
+
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 0e44389a7..e6ee10272 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -16,6 +16,7 @@
 
 class TriggeredEvent;
 class CInputStream;
+class COutputStream;
 
 class DLL_LINKAGE CMapFormatJson
 {
@@ -116,5 +117,18 @@ private:
 class DLL_LINKAGE CMapSaverJson : public CMapFormatJson, public IMapSaver
 {
 public:
+	/**
+	 * Default constructor.
+	 *
+	 * @param stream a stream to save the map to
+	 */
+	CMapSaverJson(COutputStream * stream);	
+	
+	/**
+	 * Actually saves the VCMI/Json map into stream.
+	 *
+	 */	
 	void saveMap(const std::unique_ptr<CMap> & map) override;	
+private:
+	COutputStream * output;		
 };

From 0cc47f00c51cbaa9d4d1da7c0e28b55a33c5fe88 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sat, 8 Aug 2015 19:16:33 +0300
Subject: [PATCH 006/105] Advance map format simple test

---
 lib/mapping/MapFormatJson.cpp | 13 ++++++-------
 lib/mapping/MapFormatJson.h   |  3 +--
 test/CMakeLists.txt           |  2 ++
 test/CMapFormatTest.cpp       | 29 ++++++++++++++++++++---------
 test/MapComparer.cpp          | 20 ++++++++++++++++++++
 test/MapComparer.h            | 20 ++++++++++++++++++++
 6 files changed, 69 insertions(+), 18 deletions(-)
 create mode 100644 test/MapComparer.cpp
 create mode 100644 test/MapComparer.h

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 768e5ad41..11151d9e8 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -110,10 +110,9 @@ CMapLoaderJson::CMapLoaderJson(CInputStream * stream):
 std::unique_ptr<CMap> CMapLoaderJson::loadMap()
 {
 	map = new CMap();
-	mapHeader.reset(map);
+	mapHeader = std::unique_ptr<CMapHeader>(dynamic_cast<CMapHeader *>(map));
 	readMap();
-	mapHeader.reset();
-	return std::unique_ptr<CMap>(map);
+	return std::unique_ptr<CMap>(dynamic_cast<CMap *>(mapHeader.release()));
 }
 
 std::unique_ptr<CMapHeader> CMapLoaderJson::loadMapHeader()
@@ -167,7 +166,7 @@ JsonNode eventToJson(const EventCondition & cond)
 void CMapLoaderJson::readMap()
 {
 	readHeader();
-	assert(0); // Not implemented, vcmi does not have its own map format right now
+	//TODO:readMap
 }
 
 void CMapLoaderJson::readHeader()
@@ -175,12 +174,12 @@ void CMapLoaderJson::readHeader()
 	//TODO: read such data like map name & size
 //	readTriggeredEvents();
 	readPlayerInfo();
-	assert(0); // Not implemented
+	//TODO: readHeader
 }
 
 void CMapLoaderJson::readPlayerInfo()
 {
-	assert(0); // Not implemented
+	//TODO: readPlayerInfo
 }
 
 ///CMapSaverJson
@@ -193,6 +192,6 @@ CMapSaverJson::CMapSaverJson(COutputStream * stream):
 
 void CMapSaverJson::saveMap(const std::unique_ptr<CMap>& map)
 {
-	assert(0); // Not implemented	
+	//TODO: saveMap
 }
 
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index e6ee10272..9ac1bcfa0 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -1,6 +1,5 @@
-
 /*
- * MapFormatH3M.h, part of VCMI engine
+ * MapFormatJSON.h, part of VCMI engine
  *
  * Authors: listed in file AUTHORS in main folder
  *
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 70ef021f4..43827ecad 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -8,6 +8,8 @@ set(test_SRCS
 		StdInc.cpp
 		CVcmiTestConfig.cpp
 		CMapEditManagerTest.cpp
+                MapComparer.cpp
+                CMapFormatTest.cpp
 )
 
 add_executable(vcmitest ${test_SRCS})
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index 6d6cbff98..0ee617ea7 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -8,18 +8,22 @@
  * Full text of license available in license.txt file, in main folder
  *
  */
-
-
 #include "StdInc.h"
+
 #include <boost/test/unit_test.hpp>
 
+#include "../lib/filesystem/CMemoryBuffer.h"
+
 #include "../lib/mapping/CMap.h"
 #include "../lib/rmg/CMapGenOptions.h"
 #include "../lib/rmg/CMapGenerator.h"
+#include "../lib/mapping/MapFormatJSON.h"
+
+#include "MapComparer.h"
 
 static const int TEST_RANDOM_SEED = 1337;
 
-static CMap * initialMap;
+static std::unique_ptr<CMap> initialMap;
 
 class CMapTestFixture
 {
@@ -35,11 +39,11 @@ public:
 		
 		CMapGenerator gen;
 		
-		initialMap = gen.generate(&opt, TEST_RANDOM_SEED).release();
+		initialMap = gen.generate(&opt, TEST_RANDOM_SEED);
 	};
 	~CMapTestFixture()
 	{
-		delete initialMap;
+		initialMap.reset();
 	};
 };
 
@@ -49,11 +53,18 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 {
 	try
 	{
-
-		//TODO: serialize map
-		//TODO: deserialize map
-		//TODO: compare results
+		CMemoryBuffer serializeBuffer;
+		CMapSaverJson saver(&serializeBuffer);
+		saver.saveMap(initialMap);
 		
+		CMapLoaderJson loader(&serializeBuffer);
+		serializeBuffer.seek(0);		
+		std::unique_ptr<CMap> serialized = loader.loadMap();
+		
+		
+		MapComparer c;
+		
+		BOOST_REQUIRE_MESSAGE(c(initialMap, serialized), "Serialize cycle failed");
 	}
 	catch(const std::exception & e)
 	{
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
new file mode 100644
index 000000000..c2806f648
--- /dev/null
+++ b/test/MapComparer.cpp
@@ -0,0 +1,20 @@
+/*
+ * MapComparer.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
+ *
+ */
+#include "StdInc.h"
+
+#include <boost/test/unit_test.hpp>
+
+#include "MapComparer.h"
+
+bool MapComparer::operator() (const std::unique_ptr<CMap>& lhs, const std::unique_ptr<CMap>&  rhs)
+{
+	BOOST_ERROR(" MapComparer::operator() not implemented");
+	return false;
+}
diff --git a/test/MapComparer.h b/test/MapComparer.h
new file mode 100644
index 000000000..9e1e26424
--- /dev/null
+++ b/test/MapComparer.h
@@ -0,0 +1,20 @@
+/*
+ * MapComparer.h, 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
+ *
+ */
+ 
+#pragma once
+ 
+#include "../lib/mapping/CMap.h"
+
+struct MapComparer
+{
+	bool operator() (const std::unique_ptr<CMap>& lhs, const std::unique_ptr<CMap>& rhs);
+};
+
+

From 0798ef4b2a107a028d32d55434de318c09aab65e Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sat, 8 Aug 2015 21:04:07 +0300
Subject: [PATCH 007/105] Advance MapComparer

---
 test/CMapFormatTest.cpp |  5 ++-
 test/MapComparer.cpp    | 72 +++++++++++++++++++++++++++++++++++++++--
 test/MapComparer.h      | 12 ++++++-
 3 files changed, 82 insertions(+), 7 deletions(-)

diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index 0ee617ea7..d74288f4f 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -62,9 +62,8 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 		std::unique_ptr<CMap> serialized = loader.loadMap();
 		
 		
-		MapComparer c;
-		
-		BOOST_REQUIRE_MESSAGE(c(initialMap, serialized), "Serialize cycle failed");
+		MapComparer c;		
+		c(initialMap, serialized);
 	}
 	catch(const std::exception & e)
 	{
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index c2806f648..75730b26b 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -13,8 +13,74 @@
 
 #include "MapComparer.h"
 
-bool MapComparer::operator() (const std::unique_ptr<CMap>& lhs, const std::unique_ptr<CMap>&  rhs)
+#define VCMI_CHECK_FIELD_EQUAL(field) BOOST_CHECK_EQUAL(actual->field, expected->field)
+
+std::ostream& operator<< (std::ostream& os, const PlayerInfo & p)
 {
-	BOOST_ERROR(" MapComparer::operator() not implemented");
-	return false;
+	os << "PlayerInfo"; 
+	return os;
+}
+
+bool operator!=(const PlayerInfo & actual, const PlayerInfo & expected)
+{
+	
+	
+	return true;
+}
+
+void MapComparer::compareHeader()
+{
+	VCMI_CHECK_FIELD_EQUAL(name);
+	VCMI_CHECK_FIELD_EQUAL(description);
+	VCMI_CHECK_FIELD_EQUAL(difficulty);
+	VCMI_CHECK_FIELD_EQUAL(levelLimit);
+
+	VCMI_CHECK_FIELD_EQUAL(victoryMessage);
+	VCMI_CHECK_FIELD_EQUAL(defeatMessage);
+	VCMI_CHECK_FIELD_EQUAL(victoryIconIndex);
+	VCMI_CHECK_FIELD_EQUAL(defeatIconIndex);
+	
+	BOOST_CHECK_EQUAL_COLLECTIONS(actual->players.begin(), actual->players.end(), expected->players.begin(), expected->players.end());
+
+
+	//map size parameters are vital for further checks 
+	BOOST_REQUIRE_EQUAL(actual->height, expected->height);
+	BOOST_REQUIRE_EQUAL(actual->width, expected->width);
+	BOOST_REQUIRE_EQUAL(actual->twoLevel, expected->twoLevel);
+
+	BOOST_FAIL("Not implemented");
+}
+
+void MapComparer::compareOptions()
+{
+	BOOST_FAIL("Not implemented");
+}
+
+void MapComparer::compareObjects()
+{
+	BOOST_FAIL("Not implemented");
+}
+
+void MapComparer::compareTerrain()
+{
+	BOOST_FAIL("Not implemented");
+}
+
+void MapComparer::compare()
+{
+	BOOST_REQUIRE_NE((void *) actual, (void *) expected); //should not point to the same object
+	BOOST_REQUIRE_MESSAGE(actual != nullptr, "Actual map is not defined");
+	BOOST_REQUIRE_MESSAGE(actual != nullptr, "Expected map is not defined");
+
+	compareHeader();
+	compareObjects();
+	compareOptions();
+	compareTerrain();
+}
+
+void MapComparer::operator() (const std::unique_ptr<CMap>& actual, const std::unique_ptr<CMap>&  expected)
+{
+	this->actual = actual.get();
+	this->expected = expected.get();
+	compare();
 }
diff --git a/test/MapComparer.h b/test/MapComparer.h
index 9e1e26424..4720a37f1 100644
--- a/test/MapComparer.h
+++ b/test/MapComparer.h
@@ -14,7 +14,17 @@
 
 struct MapComparer
 {
-	bool operator() (const std::unique_ptr<CMap>& lhs, const std::unique_ptr<CMap>& rhs);
+	const CMap * actual;
+	const CMap * expected;
+	
+	void compareHeader();
+	void compareOptions();
+	void compareObjects();
+	void compareTerrain();	
+	
+	void compare(); 
+	
+	void operator() (const std::unique_ptr<CMap>& actual, const std::unique_ptr<CMap>& expected);
 };
 
 

From c53718a0d5113b792c2acf793419a7c953f06952 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sat, 8 Aug 2015 21:10:33 +0300
Subject: [PATCH 008/105] Enabled unit test by default

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 11262196d..e80e22064 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,7 +19,7 @@ set(VCMI_VERSION_PATCH 0)
 option(ENABLE_ERM "Enable compilation of ERM scripting module" OFF)
 option(ENABLE_EDITOR "Enable compilation of map editor" OFF)
 option(ENABLE_LAUNCHER "Enable compilation of launcher" ON)
-option(ENABLE_TEST "Enable compilation of unit tests" OFF)
+option(ENABLE_TEST "Enable compilation of unit tests" ON)
 option(ENABLE_PCH "Enable compilation using precompiled headers" ON)
 
 ############################################

From a2b4b8a6dea69a79d96659aab7042fe9d466c5a9 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sat, 8 Aug 2015 22:08:19 +0300
Subject: [PATCH 009/105] Fix filename

---
 test/CMapFormatTest.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index d74288f4f..6f8e625b1 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -17,7 +17,7 @@
 #include "../lib/mapping/CMap.h"
 #include "../lib/rmg/CMapGenOptions.h"
 #include "../lib/rmg/CMapGenerator.h"
-#include "../lib/mapping/MapFormatJSON.h"
+#include "../lib/mapping/MapFormatJson.h"
 
 #include "MapComparer.h"
 

From 3d265f94dc42b9f5d60ee9e30a47f3cfeee71dcf Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sun, 9 Aug 2015 14:03:57 +0300
Subject: [PATCH 010/105] Update projects

---
 lib/VCMI_lib.cbp | 4 ++++
 test/Test.cbp    | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/lib/VCMI_lib.cbp b/lib/VCMI_lib.cbp
index 1fb794a0c..6914feb79 100644
--- a/lib/VCMI_lib.cbp
+++ b/lib/VCMI_lib.cbp
@@ -223,8 +223,12 @@
 		<Unit filename="filesystem/CFilesystemLoader.cpp" />
 		<Unit filename="filesystem/CFilesystemLoader.h" />
 		<Unit filename="filesystem/CInputStream.h" />
+		<Unit filename="filesystem/CMemoryBuffer.cpp" />
+		<Unit filename="filesystem/CMemoryBuffer.h" />
 		<Unit filename="filesystem/CMemoryStream.cpp" />
 		<Unit filename="filesystem/CMemoryStream.h" />
+		<Unit filename="filesystem/COutputStream.h" />
+		<Unit filename="filesystem/CStream.h" />
 		<Unit filename="filesystem/CZipLoader.cpp" />
 		<Unit filename="filesystem/CZipLoader.h" />
 		<Unit filename="filesystem/Filesystem.cpp" />
diff --git a/test/Test.cbp b/test/Test.cbp
index be4d35ad6..a6a485353 100644
--- a/test/Test.cbp
+++ b/test/Test.cbp
@@ -61,6 +61,8 @@
 		<Unit filename="CMapFormatTest.cpp" />
 		<Unit filename="CVcmiTestConfig.cpp" />
 		<Unit filename="CVcmiTestConfig.h" />
+		<Unit filename="MapComparer.cpp" />
+		<Unit filename="MapComparer.h" />
 		<Unit filename="StdInc.cpp">
 			<Option weight="0" />
 		</Unit>

From 8f209b17b67bbe5b4fbe07d0eda310caa2949cd0 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sun, 9 Aug 2015 14:04:26 +0300
Subject: [PATCH 011/105] Few more checks

---
 test/MapComparer.cpp | 46 ++++++++++++++++++++++++++++----------------
 1 file changed, 29 insertions(+), 17 deletions(-)

diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 75730b26b..2ba2878fb 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -13,40 +13,52 @@
 
 #include "MapComparer.h"
 
-#define VCMI_CHECK_FIELD_EQUAL(field) BOOST_CHECK_EQUAL(actual->field, expected->field)
+#define VCMI_CHECK_FIELD_EQUAL_P(field) BOOST_CHECK_EQUAL(actual->field, expected->field)
 
-std::ostream& operator<< (std::ostream& os, const PlayerInfo & p)
+#define VCMI_CHECK_FIELD_EQUAL(field) BOOST_CHECK_EQUAL(actual.field, expected.field)
+
+#define VCMI_REQUIRE_FIELD_EQUAL(field) BOOST_REQUIRE_EQUAL(actual->field, expected->field)
+
+std::ostream& operator<< (std::ostream& os, const PlayerInfo & value)
 {
 	os << "PlayerInfo"; 
 	return os;
 }
 
+//std::ostream& operator<< (std::ostream& os, const std::set<ui8> & value)
+//{
+//	os << "'Set'"; 
+//	return os;
+//}
+
 bool operator!=(const PlayerInfo & actual, const PlayerInfo & expected)
 {
-	
-	
-	return true;
+	VCMI_CHECK_FIELD_EQUAL(canHumanPlay);
+	VCMI_CHECK_FIELD_EQUAL(canComputerPlay);
+	VCMI_CHECK_FIELD_EQUAL(aiTactic);
+	//VCMI_CHECK_FIELD_EQUAL(allowedFactions);
+	return false;
 }
 
 void MapComparer::compareHeader()
 {
-	VCMI_CHECK_FIELD_EQUAL(name);
-	VCMI_CHECK_FIELD_EQUAL(description);
-	VCMI_CHECK_FIELD_EQUAL(difficulty);
-	VCMI_CHECK_FIELD_EQUAL(levelLimit);
+	VCMI_CHECK_FIELD_EQUAL_P(name);
+	VCMI_CHECK_FIELD_EQUAL_P(description);
+	VCMI_CHECK_FIELD_EQUAL_P(difficulty);
+	VCMI_CHECK_FIELD_EQUAL_P(levelLimit);
 
-	VCMI_CHECK_FIELD_EQUAL(victoryMessage);
-	VCMI_CHECK_FIELD_EQUAL(defeatMessage);
-	VCMI_CHECK_FIELD_EQUAL(victoryIconIndex);
-	VCMI_CHECK_FIELD_EQUAL(defeatIconIndex);
+	VCMI_CHECK_FIELD_EQUAL_P(victoryMessage);
+	VCMI_CHECK_FIELD_EQUAL_P(defeatMessage);
+	VCMI_CHECK_FIELD_EQUAL_P(victoryIconIndex);
+	VCMI_CHECK_FIELD_EQUAL_P(defeatIconIndex);
 	
 	BOOST_CHECK_EQUAL_COLLECTIONS(actual->players.begin(), actual->players.end(), expected->players.begin(), expected->players.end());
 
 
 	//map size parameters are vital for further checks 
-	BOOST_REQUIRE_EQUAL(actual->height, expected->height);
-	BOOST_REQUIRE_EQUAL(actual->width, expected->width);
-	BOOST_REQUIRE_EQUAL(actual->twoLevel, expected->twoLevel);
+	VCMI_REQUIRE_FIELD_EQUAL(height);
+	VCMI_REQUIRE_FIELD_EQUAL(width);
+	VCMI_REQUIRE_FIELD_EQUAL(twoLevel);
 
 	BOOST_FAIL("Not implemented");
 }
@@ -73,8 +85,8 @@ void MapComparer::compare()
 	BOOST_REQUIRE_MESSAGE(actual != nullptr, "Expected map is not defined");
 
 	compareHeader();
-	compareObjects();
 	compareOptions();
+	compareObjects();
 	compareTerrain();
 }
 

From b3ac146ba9bf2c00c7cc1d813b2a3e1f49286e51 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Tue, 11 Aug 2015 14:44:47 +0300
Subject: [PATCH 012/105] Define bridge interface to minizip IOAPI

---
 lib/CMakeLists.txt                   |   1 +
 lib/VCMI_lib.cbp                     |   3 +
 lib/filesystem/CInputOutputStream.h  |   9 +++
 lib/filesystem/CMemoryBuffer.cpp     |   2 +-
 lib/filesystem/CMemoryBuffer.h       |   8 +-
 lib/filesystem/COutputStream.h       |   2 +-
 lib/filesystem/MinizipExtensions.cpp | 106 +++++++++++++++++++++++++++
 lib/filesystem/MinizipExtensions.h   |  34 +++++++++
 8 files changed, 159 insertions(+), 6 deletions(-)
 create mode 100644 lib/filesystem/CInputOutputStream.h
 create mode 100644 lib/filesystem/MinizipExtensions.cpp
 create mode 100644 lib/filesystem/MinizipExtensions.h

diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index dacb58b81..f70513ad6 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -19,6 +19,7 @@ set(lib_SRCS
 		filesystem/CZipLoader.cpp
 		filesystem/Filesystem.cpp
 		filesystem/ResourceID.cpp
+                filesystem/MinizipExtensions.cpp
 
 		mapObjects/CArmedInstance.cpp
 		mapObjects/CBank.cpp
diff --git a/lib/VCMI_lib.cbp b/lib/VCMI_lib.cbp
index 6914feb79..d3409c191 100644
--- a/lib/VCMI_lib.cbp
+++ b/lib/VCMI_lib.cbp
@@ -222,6 +222,7 @@
 		<Unit filename="filesystem/CFileInputStream.h" />
 		<Unit filename="filesystem/CFilesystemLoader.cpp" />
 		<Unit filename="filesystem/CFilesystemLoader.h" />
+		<Unit filename="filesystem/CInputOutputStream.h" />
 		<Unit filename="filesystem/CInputStream.h" />
 		<Unit filename="filesystem/CMemoryBuffer.cpp" />
 		<Unit filename="filesystem/CMemoryBuffer.h" />
@@ -234,6 +235,8 @@
 		<Unit filename="filesystem/Filesystem.cpp" />
 		<Unit filename="filesystem/Filesystem.h" />
 		<Unit filename="filesystem/ISimpleResourceLoader.h" />
+		<Unit filename="filesystem/MinizipExtensions.cpp" />
+		<Unit filename="filesystem/MinizipExtensions.h" />
 		<Unit filename="filesystem/ResourceID.cpp" />
 		<Unit filename="filesystem/ResourceID.h" />
 		<Unit filename="int3.h" />
diff --git a/lib/filesystem/CInputOutputStream.h b/lib/filesystem/CInputOutputStream.h
new file mode 100644
index 000000000..55c88b360
--- /dev/null
+++ b/lib/filesystem/CInputOutputStream.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "CInputStream.h"
+#include "COutputStream.h"
+
+class CInputOutputStream: public CInputStream, public COutputStream
+{
+	
+};
diff --git a/lib/filesystem/CMemoryBuffer.cpp b/lib/filesystem/CMemoryBuffer.cpp
index 659458ede..8acbf586a 100644
--- a/lib/filesystem/CMemoryBuffer.cpp
+++ b/lib/filesystem/CMemoryBuffer.cpp
@@ -18,7 +18,7 @@ CMemoryBuffer::CMemoryBuffer():
 	
 }
 
-si64 CMemoryBuffer::write(ui8 * data, si64 size)
+si64 CMemoryBuffer::write(const ui8 * data, si64 size)
 {
 	buffer.reserve(tell()+size);
 	
diff --git a/lib/filesystem/CMemoryBuffer.h b/lib/filesystem/CMemoryBuffer.h
index 04a028966..74f8f2c58 100644
--- a/lib/filesystem/CMemoryBuffer.h
+++ b/lib/filesystem/CMemoryBuffer.h
@@ -11,14 +11,14 @@
  */
  
 
-#include "CInputStream.h"
-#include "COutputStream.h"
+#include "CInputOutputStream.h"
+
 
 /**
  * A class which provides IO memory buffer.
  */
  
-class DLL_LINKAGE CMemoryBuffer : public CInputStream, public COutputStream
+class DLL_LINKAGE CMemoryBuffer : public CInputOutputStream
 {
 public:
 	typedef std::vector<ui8> TBuffer;
@@ -36,7 +36,7 @@ public:
 	 * @param size The number of bytes to write.
 	 * @return the number of bytes written actually.
 	 */
-	si64 write(ui8 * data, si64 size) override;	
+	si64 write(const ui8 * data, si64 size) override;	
 
 	/**
 	 * Reads n bytes from the stream into the data buffer.
diff --git a/lib/filesystem/COutputStream.h b/lib/filesystem/COutputStream.h
index ba4a70f13..86181a20e 100644
--- a/lib/filesystem/COutputStream.h
+++ b/lib/filesystem/COutputStream.h
@@ -30,5 +30,5 @@ public:
 	 * @param size The number of bytes to write.
 	 * @return the number of bytes written actually.
 	 */
-	virtual si64 write(ui8 * data, si64 size) = 0;
+	virtual si64 write(const ui8 * data, si64 size) = 0;
 };
diff --git a/lib/filesystem/MinizipExtensions.cpp b/lib/filesystem/MinizipExtensions.cpp
new file mode 100644
index 000000000..3c8f86ee6
--- /dev/null
+++ b/lib/filesystem/MinizipExtensions.cpp
@@ -0,0 +1,106 @@
+/*
+ * MinizipExtensions.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
+ *
+ */
+#include "StdInc.h"
+
+#include "MinizipExtensions.h"
+
+static voidpf ZCALLBACK openFileProxy(voidpf opaque, const void * filename, int mode)
+{
+	assert(opaque != nullptr);
+	
+	std::string filename_s;
+	
+	if(filename != nullptr)
+		filename_s = (const char *)filename;
+	
+	return ((CIOApi *)opaque)->openFile(filename_s, mode);
+}
+
+static uLong ZCALLBACK readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size)
+{
+	assert(opaque != nullptr);
+	assert(stream != nullptr);
+	
+	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
+	
+	return actualStream->read((ui8 *)buf, size);
+}
+
+static uLong ZCALLBACK writeFileProxy(voidpf opaque, voidpf stream, const void * buf, uLong size)
+{
+	assert(opaque != nullptr);
+	assert(stream != nullptr);
+
+	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
+    return (uLong)actualStream->write((const ui8 *)buf, size);
+}
+
+static ZPOS64_T ZCALLBACK tellFileProxy(voidpf opaque, voidpf stream)
+{
+	assert(opaque != nullptr);
+	assert(stream != nullptr);
+	
+	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);	
+    return actualStream->tell();
+}
+
+static long ZCALLBACK seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin)
+{
+	assert(opaque != nullptr);
+	assert(stream != nullptr);
+		
+	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);	
+
+    long ret = 0;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        actualStream->skip(offset);//TODO: should we check actual skipped? 
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+    	ret = -1;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+    	ret = actualStream->seek(offset);
+        break;
+    default: ret = -1;
+    }
+    return ret;
+}
+
+static int ZCALLBACK closeFileProxy(voidpf opaque, voidpf stream)
+{
+	assert(opaque != nullptr);
+	assert(stream != nullptr);
+		
+	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
+	
+	delete actualStream;
+	
+    return 0;
+}
+
+static int ZCALLBACK errorFileProxy(voidpf opaque, voidpf stream)
+{
+    return 0;
+}
+
+void CIOApi::fillApiStructure(zlib_filefunc64_def & api)
+{
+	api.opaque = this;
+	api.zopen64_file = &openFileProxy;
+	api.zread_file = &readFileProxy;
+	api.zwrite_file = &writeFileProxy;
+	api.ztell64_file = &tellFileProxy;
+	api.zseek64_file = &seekFileProxy;
+	api.zclose_file = &closeFileProxy;
+	api.zerror_file = &errorFileProxy;	
+}
+
diff --git a/lib/filesystem/MinizipExtensions.h b/lib/filesystem/MinizipExtensions.h
new file mode 100644
index 000000000..f5289e906
--- /dev/null
+++ b/lib/filesystem/MinizipExtensions.h
@@ -0,0 +1,34 @@
+#pragma once
+
+/*
+ * MinizipExtensions.h, 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
+ *
+ */
+
+#ifdef USE_SYSTEM_MINIZIP
+#include <minizip/unzip.h>
+#include <minizip/zip.h>
+#include <minizip/ioapi.h>
+#else
+#include "../minizip/unzip.h"
+#include "../minizip/zip.h"
+#include "../minizip/ioapi.h"
+#endif
+
+#include "CInputOutputStream.h"
+
+class CIOApi
+{
+public:
+	virtual ~CIOApi(){};
+	
+	void fillApiStructure(zlib_filefunc64_def & api);
+	
+	virtual CInputOutputStream * openFile(const std::string & filename, int mode) = 0;	
+
+};

From 0040b459c3454616b6816ef8cb457abd6fff69cb Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Tue, 11 Aug 2015 16:56:07 +0300
Subject: [PATCH 013/105] Add support of CIOApi to CZipStream and CZipLoader
 (unused, untested)

---
 lib/filesystem/CZipLoader.cpp        | 18 ++++++---
 lib/filesystem/CZipLoader.h          | 18 ++++-----
 lib/filesystem/MinizipExtensions.cpp | 55 +++++++++++++++++++++++-----
 lib/filesystem/MinizipExtensions.h   | 40 ++++++++++++++++++--
 4 files changed, 103 insertions(+), 28 deletions(-)

diff --git a/lib/filesystem/CZipLoader.cpp b/lib/filesystem/CZipLoader.cpp
index 3b8676de0..0a98672da 100644
--- a/lib/filesystem/CZipLoader.cpp
+++ b/lib/filesystem/CZipLoader.cpp
@@ -14,11 +14,15 @@
  *
  */
 
-CZipStream::CZipStream(const std::string & archive, unz_file_pos filepos)
+CZipStream::CZipStream(std::shared_ptr<CIOApi> api, const std::string & archive, unz_file_pos filepos)
 {
-	file = unzOpen(archive.c_str());
+	zlib_filefunc64_def zlibApi;
+	
+	zlibApi = api->getApiStructure();
+	
+	file = unzOpen2_64(archive.c_str(), &zlibApi);
 	unzGoToFilePos(file, &filepos);
-	unzOpenCurrentFile(file);
+	unzOpenCurrentFile(file);	
 }
 
 CZipStream::~CZipStream()
@@ -46,7 +50,9 @@ ui32 CZipStream::calculateCRC32()
 	return info.crc;
 }
 
-CZipLoader::CZipLoader(const std::string & mountPoint, const std::string & archive):
+CZipLoader::CZipLoader(const std::string & mountPoint, const std::string & archive, std::shared_ptr<CIOApi> api):
+	ioApi(api),
+    zlibApi(ioApi->getApiStructure()),	
     archiveName(archive),
     mountPoint(mountPoint),
     files(listFiles(mountPoint, archive))
@@ -58,7 +64,7 @@ std::unordered_map<ResourceID, unz_file_pos> CZipLoader::listFiles(const std::st
 {
 	std::unordered_map<ResourceID, unz_file_pos> ret;
 
-	unzFile file = unzOpen(archive.c_str());
+	unzFile file = unzOpen2_64(archive.c_str(), &zlibApi);
 
 	if (unzGoToFirstFile(file) == UNZ_OK)
 	{
@@ -85,7 +91,7 @@ std::unordered_map<ResourceID, unz_file_pos> CZipLoader::listFiles(const std::st
 
 std::unique_ptr<CInputStream> CZipLoader::load(const ResourceID & resourceName) const
 {
-	return std::unique_ptr<CInputStream>(new CZipStream(archiveName, files.at(resourceName)));
+	return std::unique_ptr<CInputStream>(new CZipStream(ioApi, archiveName, files.at(resourceName)));	
 }
 
 bool CZipLoader::existsResource(const ResourceID & resourceName) const
diff --git a/lib/filesystem/CZipLoader.h b/lib/filesystem/CZipLoader.h
index cccab7007..ee0077aa6 100644
--- a/lib/filesystem/CZipLoader.h
+++ b/lib/filesystem/CZipLoader.h
@@ -15,12 +15,7 @@
 #include "ResourceID.h"
 #include "CCompressedStream.h"
 
-// Necessary here in order to get all types
-#ifdef USE_SYSTEM_MINIZIP
-#include <minizip/unzip.h>
-#else
-#include "../minizip/unzip.h"
-#endif
+#include "MinizipExtensions.h"
 
 class DLL_LINKAGE CZipStream : public CBufferedStream
 {
@@ -29,10 +24,12 @@ class DLL_LINKAGE CZipStream : public CBufferedStream
 public:
 	/**
 	 * @brief constructs zip stream from already opened file
+	 * @param api virtual filesystem interface
 	 * @param archive path to archive to open
 	 * @param filepos position of file to open
 	 */
-	CZipStream(const std::string & archive, unz_file_pos filepos);
+	CZipStream(std::shared_ptr<CIOApi> api, const std::string & archive, unz_file_pos filepos);
+		
 	~CZipStream();
 
 	si64 getSize() override;
@@ -44,6 +41,9 @@ protected:
 
 class DLL_LINKAGE CZipLoader : public ISimpleResourceLoader
 {
+	std::shared_ptr<CIOApi> ioApi;
+	zlib_filefunc64_def zlibApi;
+	
 	std::string archiveName;
 	std::string mountPoint;
 
@@ -51,8 +51,8 @@ class DLL_LINKAGE CZipLoader : public ISimpleResourceLoader
 
 	std::unordered_map<ResourceID, unz_file_pos> listFiles(const std::string & mountPoint, const std::string &archive);
 public:
-	CZipLoader(const std::string & mountPoint, const std::string & archive);
-
+	CZipLoader(const std::string & mountPoint, const std::string & archive, std::shared_ptr<CIOApi> api = std::shared_ptr<CIOApi>(new CDefaultIOApi()));
+	
 	/// Interface implementation
 	/// @see ISimpleResourceLoader
 	std::unique_ptr<CInputStream> load(const ResourceID & resourceName) const override;
diff --git a/lib/filesystem/MinizipExtensions.cpp b/lib/filesystem/MinizipExtensions.cpp
index 3c8f86ee6..9c29c5998 100644
--- a/lib/filesystem/MinizipExtensions.cpp
+++ b/lib/filesystem/MinizipExtensions.cpp
@@ -11,7 +11,7 @@
 
 #include "MinizipExtensions.h"
 
-static voidpf ZCALLBACK openFileProxy(voidpf opaque, const void * filename, int mode)
+voidpf ZCALLBACK CIOApi::openFileProxy(voidpf opaque, const void * filename, int mode)
 {
 	assert(opaque != nullptr);
 	
@@ -23,7 +23,7 @@ static voidpf ZCALLBACK openFileProxy(voidpf opaque, const void * filename, int
 	return ((CIOApi *)opaque)->openFile(filename_s, mode);
 }
 
-static uLong ZCALLBACK readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size)
+uLong ZCALLBACK CIOApi::readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
@@ -33,7 +33,7 @@ static uLong ZCALLBACK readFileProxy(voidpf opaque, voidpf stream, void * buf, u
 	return actualStream->read((ui8 *)buf, size);
 }
 
-static uLong ZCALLBACK writeFileProxy(voidpf opaque, voidpf stream, const void * buf, uLong size)
+uLong ZCALLBACK CIOApi::writeFileProxy(voidpf opaque, voidpf stream, const void * buf, uLong size)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
@@ -42,7 +42,7 @@ static uLong ZCALLBACK writeFileProxy(voidpf opaque, voidpf stream, const void *
     return (uLong)actualStream->write((const ui8 *)buf, size);
 }
 
-static ZPOS64_T ZCALLBACK tellFileProxy(voidpf opaque, voidpf stream)
+ZPOS64_T ZCALLBACK CIOApi::tellFileProxy(voidpf opaque, voidpf stream)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
@@ -51,7 +51,7 @@ static ZPOS64_T ZCALLBACK tellFileProxy(voidpf opaque, voidpf stream)
     return actualStream->tell();
 }
 
-static long ZCALLBACK seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin)
+long ZCALLBACK CIOApi::seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
@@ -75,7 +75,7 @@ static long ZCALLBACK seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T offs
     return ret;
 }
 
-static int ZCALLBACK closeFileProxy(voidpf opaque, voidpf stream)
+int ZCALLBACK CIOApi::closeFileProxy(voidpf opaque, voidpf stream)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
@@ -87,14 +87,16 @@ static int ZCALLBACK closeFileProxy(voidpf opaque, voidpf stream)
     return 0;
 }
 
-static int ZCALLBACK errorFileProxy(voidpf opaque, voidpf stream)
+int ZCALLBACK CIOApi::errorFileProxy(voidpf opaque, voidpf stream)
 {
     return 0;
 }
 
-void CIOApi::fillApiStructure(zlib_filefunc64_def & api)
+///CIOApi
+zlib_filefunc64_def CIOApi::getApiStructure() const
 {
-	api.opaque = this;
+	zlib_filefunc64_def api;
+	api.opaque = (void *) this;
 	api.zopen64_file = &openFileProxy;
 	api.zread_file = &readFileProxy;
 	api.zwrite_file = &writeFileProxy;
@@ -102,5 +104,40 @@ void CIOApi::fillApiStructure(zlib_filefunc64_def & api)
 	api.zseek64_file = &seekFileProxy;
 	api.zclose_file = &closeFileProxy;
 	api.zerror_file = &errorFileProxy;	
+	
+	return api;
 }
 
+CDefaultIOApi::CDefaultIOApi()
+{
+	
+}
+
+CDefaultIOApi::~CDefaultIOApi()
+{
+	
+}
+
+zlib_filefunc64_def CDefaultIOApi::getApiStructure() const
+{
+	zlib_filefunc64_def api;
+	
+	fill_fopen64_filefunc(&api);
+	
+	return api;	
+}
+
+CInputOutputStream * CDefaultIOApi::openFile(const std::string& filename, int mode) const
+{
+	throw new std::runtime_error("CDefaultIOApi::openFile call not expected.");	
+}
+
+CZipArchive::CZipArchive(const CIOApi* api)
+{
+	
+}
+
+CZipArchive::~CZipArchive()
+{
+	
+}
diff --git a/lib/filesystem/MinizipExtensions.h b/lib/filesystem/MinizipExtensions.h
index f5289e906..0f6d99280 100644
--- a/lib/filesystem/MinizipExtensions.h
+++ b/lib/filesystem/MinizipExtensions.h
@@ -22,13 +22,45 @@
 
 #include "CInputOutputStream.h"
 
-class CIOApi
+class DLL_LINKAGE CIOApi
 {
 public:
 	virtual ~CIOApi(){};
 	
-	void fillApiStructure(zlib_filefunc64_def & api);
-	
-	virtual CInputOutputStream * openFile(const std::string & filename, int mode) = 0;	
+	virtual zlib_filefunc64_def getApiStructure() const;
 
+protected:	
+	virtual CInputOutputStream * openFile(const std::string & filename, int mode) const = 0;
+	
+private:
+	static voidpf ZCALLBACK openFileProxy(voidpf opaque, const void * filename, int mode);
+	static uLong ZCALLBACK readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size);
+	static uLong ZCALLBACK writeFileProxy(voidpf opaque, voidpf stream, const void * buf, uLong size);
+	static ZPOS64_T ZCALLBACK tellFileProxy(voidpf opaque, voidpf stream);	
+	static long ZCALLBACK seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin);
+	static int ZCALLBACK closeFileProxy(voidpf opaque, voidpf stream);
+	static int ZCALLBACK errorFileProxy(voidpf opaque, voidpf stream);
+};
+
+
+class DLL_LINKAGE CDefaultIOApi: public CIOApi
+{
+public:
+	CDefaultIOApi();
+	~CDefaultIOApi();
+	
+	zlib_filefunc64_def getApiStructure() const override;
+	
+protected:
+	CInputOutputStream * openFile(const std::string & filename, int mode) const override;
+};
+
+class CZipArchive
+{
+public:
+	explicit CZipArchive(const CIOApi * api);
+	virtual ~CZipArchive();
+	
+private:
+	
 };

From 1a8faeb0b91d45e5937cccf352a890f16edbe3c3 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Tue, 11 Aug 2015 21:20:13 +0300
Subject: [PATCH 014/105] Start implementing map saver

---
 lib/VCMI_lib.cbp                     |  2 +
 lib/filesystem/CMemoryBuffer.h       |  1 -
 lib/filesystem/CStream.h             |  4 +-
 lib/filesystem/CZipLoader.cpp        |  3 +-
 lib/filesystem/CZipLoader.h          |  1 -
 lib/filesystem/CZipSaver.cpp         | 79 ++++++++++++++++++++++++++++
 lib/filesystem/CZipSaver.h           | 53 +++++++++++++++++++
 lib/filesystem/MinizipExtensions.cpp | 34 ++++++++++--
 lib/filesystem/MinizipExtensions.h   | 22 +++++---
 lib/mapping/MapFormatJson.cpp        | 31 ++++++++++-
 lib/mapping/MapFormatJson.h          | 18 +++++--
 test/Test.cbp                        |  1 +
 12 files changed, 226 insertions(+), 23 deletions(-)
 create mode 100644 lib/filesystem/CZipSaver.cpp
 create mode 100644 lib/filesystem/CZipSaver.h

diff --git a/lib/VCMI_lib.cbp b/lib/VCMI_lib.cbp
index d3409c191..d966248a1 100644
--- a/lib/VCMI_lib.cbp
+++ b/lib/VCMI_lib.cbp
@@ -232,6 +232,8 @@
 		<Unit filename="filesystem/CStream.h" />
 		<Unit filename="filesystem/CZipLoader.cpp" />
 		<Unit filename="filesystem/CZipLoader.h" />
+		<Unit filename="filesystem/CZipSaver.cpp" />
+		<Unit filename="filesystem/CZipSaver.h" />
 		<Unit filename="filesystem/Filesystem.cpp" />
 		<Unit filename="filesystem/Filesystem.h" />
 		<Unit filename="filesystem/ISimpleResourceLoader.h" />
diff --git a/lib/filesystem/CMemoryBuffer.h b/lib/filesystem/CMemoryBuffer.h
index 74f8f2c58..10e43fa6a 100644
--- a/lib/filesystem/CMemoryBuffer.h
+++ b/lib/filesystem/CMemoryBuffer.h
@@ -13,7 +13,6 @@
 
 #include "CInputOutputStream.h"
 
-
 /**
  * A class which provides IO memory buffer.
  */
diff --git a/lib/filesystem/CStream.h b/lib/filesystem/CStream.h
index d085eec72..21026b72b 100644
--- a/lib/filesystem/CStream.h
+++ b/lib/filesystem/CStream.h
@@ -42,9 +42,9 @@ public:
 	virtual si64 skip(si64 delta) = 0;
 
 	/**
-	 * Gets the length in bytes of the stream.
+	 * Gets the length of the stream.
 	 *
-	 * @return the length in bytes of the stream.
+	 * @return the length in bytes
 	 */
 	virtual si64 getSize() = 0;	
 };
diff --git a/lib/filesystem/CZipLoader.cpp b/lib/filesystem/CZipLoader.cpp
index 0a98672da..47dc621d0 100644
--- a/lib/filesystem/CZipLoader.cpp
+++ b/lib/filesystem/CZipLoader.cpp
@@ -1,5 +1,4 @@
 #include "StdInc.h"
-#include "../../Global.h"
 #include "CZipLoader.h"
 
 #include "../ScopeGuard.h"
@@ -14,6 +13,7 @@
  *
  */
 
+///CZipStream
 CZipStream::CZipStream(std::shared_ptr<CIOApi> api, const std::string & archive, unz_file_pos filepos)
 {
 	zlib_filefunc64_def zlibApi;
@@ -50,6 +50,7 @@ ui32 CZipStream::calculateCRC32()
 	return info.crc;
 }
 
+///CZipLoader
 CZipLoader::CZipLoader(const std::string & mountPoint, const std::string & archive, std::shared_ptr<CIOApi> api):
 	ioApi(api),
     zlibApi(ioApi->getApiStructure()),	
diff --git a/lib/filesystem/CZipLoader.h b/lib/filesystem/CZipLoader.h
index ee0077aa6..d5393ea2b 100644
--- a/lib/filesystem/CZipLoader.h
+++ b/lib/filesystem/CZipLoader.h
@@ -61,7 +61,6 @@ public:
 	std::unordered_set<ResourceID> getFilteredFiles(std::function<bool(const ResourceID &)> filter) const override;
 };
 
-
 namespace ZipArchive
 {
 	/// List all files present in archive
diff --git a/lib/filesystem/CZipSaver.cpp b/lib/filesystem/CZipSaver.cpp
new file mode 100644
index 000000000..f3c3c2076
--- /dev/null
+++ b/lib/filesystem/CZipSaver.cpp
@@ -0,0 +1,79 @@
+/*
+ * CZipSaver.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
+ *
+ */
+ 
+#include "StdInc.h"
+#include "CZipSaver.h"
+
+///CZipOutputStream
+CZipOutputStream::CZipOutputStream(zipFile archive, const std::string & archiveFilename):
+	handle(archive)
+{
+	//zip_fileinfo fileInfo;
+	
+	zipOpenNewFileInZip(handle,
+                       archiveFilename.c_str(),
+                       nullptr,//todo: use fileInfo,
+                       nullptr,
+                       0,
+                       nullptr,
+                       0,
+                       "",
+                       Z_DEFLATED,
+                       Z_DEFAULT_COMPRESSION);
+}
+
+CZipOutputStream::~CZipOutputStream()
+{
+	zipCloseFileInZip(handle);
+}
+
+
+si64 CZipOutputStream::write(const ui8 * data, si64 size)
+{
+	int ret = zipWriteInFileInZip(handle, (const void*)data, (unsigned)size);
+	
+	if (ret == ZIP_OK)
+		return size;
+	else
+		return 0;
+}
+
+///CZipSaver
+CZipSaver::CZipSaver(std::shared_ptr<CIOApi> api, const std::string & path):
+	ioApi(api),
+	zipApi(ioApi->getApiStructure()),
+	handle(nullptr)	
+{
+	
+	
+	handle = zipOpen2_64(path.c_str(), APPEND_STATUS_CREATE, nullptr, &zipApi);
+	
+	if (handle == nullptr)
+		throw new std::runtime_error("Failed to create archive");
+}
+
+CZipSaver::~CZipSaver()
+{
+	if(handle != nullptr)
+		zipClose(handle, nullptr);
+}
+
+std::unique_ptr<COutputStream> CZipSaver::addFile(const std::string & archiveFilename)
+{
+	if(activeStream != nullptr)
+		throw new std::runtime_error("CZipSaver::addFile: stream already opened");
+	
+	std::unique_ptr<COutputStream> stream(new CZipOutputStream(handle, archiveFilename));
+	
+	activeStream = stream.get();
+	
+	return stream;
+}
+
diff --git a/lib/filesystem/CZipSaver.h b/lib/filesystem/CZipSaver.h
new file mode 100644
index 000000000..3a0cb9752
--- /dev/null
+++ b/lib/filesystem/CZipSaver.h
@@ -0,0 +1,53 @@
+#pragma once
+
+/*
+ * CZipSaver.h, 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
+ *
+ */
+
+#include "COutputStream.h"
+
+#include "MinizipExtensions.h"
+
+class DLL_LINKAGE CZipOutputStream: public COutputStream
+{
+public:
+	/**
+	 * @brief constructs zip stream from already opened file
+	 * @param archive archive handle, must be opened
+	 * @param archiveFilename name of file to write
+	 */	
+	explicit CZipOutputStream(zipFile archive, const std::string & archiveFilename);
+	~CZipOutputStream();
+	
+	si64 write(const ui8 * data, si64 size) override;
+
+	si64 seek(si64 position) override {return -1;};
+	si64 tell() override {return 0;};
+	si64 skip(si64 delta) override {return 0;};
+	si64 getSize() override {return 0;};	
+private:
+	zipFile handle;
+};
+
+class DLL_LINKAGE CZipSaver
+{
+public:	
+	explicit CZipSaver(std::shared_ptr<CIOApi> api, const std::string & path);
+	virtual ~CZipSaver();
+	
+	std::unique_ptr<COutputStream> addFile(const std::string & archiveFilename);
+private:
+	std::shared_ptr<CIOApi> ioApi;
+	zlib_filefunc64_def zipApi;	
+	
+	zipFile handle;
+	
+	///due to minizip design only one file stream may opened at a time
+	COutputStream * activeStream;
+};
diff --git a/lib/filesystem/MinizipExtensions.cpp b/lib/filesystem/MinizipExtensions.cpp
index 9c29c5998..d07098957 100644
--- a/lib/filesystem/MinizipExtensions.cpp
+++ b/lib/filesystem/MinizipExtensions.cpp
@@ -8,9 +8,12 @@
  *
  */
 #include "StdInc.h"
-
 #include "MinizipExtensions.h"
 
+#include "CMemoryBuffer.h"
+
+
+///CIOApi
 voidpf ZCALLBACK CIOApi::openFileProxy(voidpf opaque, const void * filename, int mode)
 {
 	assert(opaque != nullptr);
@@ -82,7 +85,7 @@ int ZCALLBACK CIOApi::closeFileProxy(voidpf opaque, voidpf stream)
 		
 	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
 	
-	delete actualStream;
+	((CIOApi *)opaque)->closeFile(actualStream);
 	
     return 0;
 }
@@ -92,7 +95,6 @@ int ZCALLBACK CIOApi::errorFileProxy(voidpf opaque, voidpf stream)
     return 0;
 }
 
-///CIOApi
 zlib_filefunc64_def CIOApi::getApiStructure() const
 {
 	zlib_filefunc64_def api;
@@ -108,6 +110,12 @@ zlib_filefunc64_def CIOApi::getApiStructure() const
 	return api;
 }
 
+void CIOApi::closeFile(CInputOutputStream * stream) const
+{
+	delete stream;
+}
+
+///CDefaultIOApi
 CDefaultIOApi::CDefaultIOApi()
 {
 	
@@ -132,12 +140,28 @@ CInputOutputStream * CDefaultIOApi::openFile(const std::string& filename, int mo
 	throw new std::runtime_error("CDefaultIOApi::openFile call not expected.");	
 }
 
-CZipArchive::CZipArchive(const CIOApi* api)
+///CProxyIOApi
+CProxyIOApi::CProxyIOApi(CInputOutputStream * buffer):
+	data(buffer)
 {
 	
 }
 
-CZipArchive::~CZipArchive()
+CProxyIOApi::~CProxyIOApi()
 {
 	
 }
+
+CInputOutputStream * CProxyIOApi::openFile(const std::string& filename, int mode) const
+{
+	logGlobal->traceStream() << "CProxyIOApi: stream opened for" <<filename<<" with mode "<<mode; 
+	
+	data->seek(0);
+	return data;//todo: check that only one "copy" is opened
+}
+
+void CProxyIOApi::closeFile(CInputOutputStream * stream) const
+{
+	logGlobal->traceStream() << "CProxyIOApi: stream closed";
+	stream->seek(0);//stream is local singleton and even not owned, just seek
+}
diff --git a/lib/filesystem/MinizipExtensions.h b/lib/filesystem/MinizipExtensions.h
index 0f6d99280..a88e3db7e 100644
--- a/lib/filesystem/MinizipExtensions.h
+++ b/lib/filesystem/MinizipExtensions.h
@@ -20,7 +20,8 @@
 #include "../minizip/ioapi.h"
 #endif
 
-#include "CInputOutputStream.h"
+class CInputOutputStream;
+class CMemoryBuffer;
 
 class DLL_LINKAGE CIOApi
 {
@@ -32,6 +33,9 @@ public:
 protected:	
 	virtual CInputOutputStream * openFile(const std::string & filename, int mode) const = 0;
 	
+	///default implementation deletes stream object
+	virtual void closeFile(CInputOutputStream * stream) const;
+	
 private:
 	static voidpf ZCALLBACK openFileProxy(voidpf opaque, const void * filename, int mode);
 	static uLong ZCALLBACK readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size);
@@ -42,7 +46,8 @@ private:
 	static int ZCALLBACK errorFileProxy(voidpf opaque, voidpf stream);
 };
 
-
+///redirects back to minizip ioapi
+//todo: replace with Virtual FileSystem interface
 class DLL_LINKAGE CDefaultIOApi: public CIOApi
 {
 public:
@@ -55,12 +60,15 @@ protected:
 	CInputOutputStream * openFile(const std::string & filename, int mode) const override;
 };
 
-class CZipArchive
+///redirects all file IO to single stream
+class DLL_LINKAGE CProxyIOApi: public CIOApi
 {
 public:
-	explicit CZipArchive(const CIOApi * api);
-	virtual ~CZipArchive();
-	
+	CProxyIOApi(CInputOutputStream * buffer);
+	~CProxyIOApi();
+protected:
+	CInputOutputStream * openFile(const std::string & filename, int mode) const override;
+	void closeFile(CInputOutputStream * stream) const override;
 private:
-	
+	CInputOutputStream * data;
 };
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 11151d9e8..09c5ebf94 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -51,6 +51,8 @@ static EventCondition JsonToCondition(const JsonNode & node)
 }
 
 ///CMapFormatJson
+const std::string CMapFormatJson::HEADER_FILE_NAME = "header.json";
+
 void CMapFormatJson::readTriggeredEvents(const JsonNode & input)
 {
 	mapHeader->victoryMessage = input["victoryString"].String();
@@ -183,15 +185,40 @@ void CMapLoaderJson::readPlayerInfo()
 }
 
 ///CMapSaverJson
-CMapSaverJson::CMapSaverJson(COutputStream * stream):
-	output(stream)
+CMapSaverJson::CMapSaverJson(CInputOutputStream * stream):
+	output(stream),
+	ioApi(new CProxyIOApi(output)),
+	saver(ioApi, "_")
 {
 	
 }
 
+CMapSaverJson::~CMapSaverJson()
+{
+	
+}
 
 void CMapSaverJson::saveMap(const std::unique_ptr<CMap>& map)
 {
 	//TODO: saveMap
+	this->map = map.get();
 }
 
+void CMapSaverJson::saveHeader()
+{
+	JsonNode header;
+	//TODO: save header
+	
+	header["name"].String() = map->name;
+	
+	std::ostringstream out;
+	out << header;
+	out.flush();
+	
+	{
+		auto s = out.str();
+		auto stream = saver.addFile(HEADER_FILE_NAME);
+		
+		stream->write((const ui8*)s.c_str(), s.size());
+	}	
+}
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 9ac1bcfa0..114c6c51a 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -13,12 +13,16 @@
 #include "CMapService.h"
 #include "../JsonNode.h"
 
+#include "../filesystem/CZipSaver.h"
+#include "../filesystem/CZipLoader.h"
+
 class TriggeredEvent;
-class CInputStream;
-class COutputStream;
+
 
 class DLL_LINKAGE CMapFormatJson
 {
+public:	
+	static const std::string HEADER_FILE_NAME;
 
 protected:
 	
@@ -121,7 +125,9 @@ public:
 	 *
 	 * @param stream a stream to save the map to
 	 */
-	CMapSaverJson(COutputStream * stream);	
+	CMapSaverJson(CInputOutputStream * stream);	
+	
+	~CMapSaverJson();
 	
 	/**
 	 * Actually saves the VCMI/Json map into stream.
@@ -129,5 +135,9 @@ public:
 	 */	
 	void saveMap(const std::unique_ptr<CMap> & map) override;	
 private:
-	COutputStream * output;		
+	void saveHeader();
+	
+	CInputOutputStream * output;
+	std::shared_ptr<CIOApi> ioApi;		
+	CZipSaver saver;	
 };
diff --git a/test/Test.cbp b/test/Test.cbp
index a6a485353..6665380f5 100644
--- a/test/Test.cbp
+++ b/test/Test.cbp
@@ -47,6 +47,7 @@
 			<Add option="-Wno-unused-parameter" />
 			<Add option="-Wno-overloaded-virtual" />
 			<Add option="-Wno-unused-local-typedefs" />
+			<Add directory="$(#zlib.include)" />
 			<Add directory="$(#boost.include)" />
 		</Compiler>
 		<Linker>

From 580263201a529e1569ce1183f3402ab2d4920ef0 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Tue, 11 Aug 2015 22:50:08 +0300
Subject: [PATCH 015/105] Cleanup old tests

---
 test/CMapEditManagerTest.cpp | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/test/CMapEditManagerTest.cpp b/test/CMapEditManagerTest.cpp
index cccf7356d..c7a59fcad 100644
--- a/test/CMapEditManagerTest.cpp
+++ b/test/CMapEditManagerTest.cpp
@@ -25,11 +25,12 @@
 
 BOOST_AUTO_TEST_CASE(CMapEditManager_DrawTerrain_Type)
 {
+	logGlobal->infoStream() << "CMapEditManager_DrawTerrain_Type start";
 	try
 	{
 		auto map = make_unique<CMap>();
-		map->width = 100;
-		map->height = 100;
+		map->width = 52;
+		map->height = 52;
 		map->initTerrain();
 		auto editManager = map->getEditManager();
 		editManager->clearTerrain();
@@ -81,6 +82,9 @@ BOOST_AUTO_TEST_CASE(CMapEditManager_DrawTerrain_Type)
 		editManager->drawTerrain(ETerrainType::ROCK);
 		BOOST_CHECK(map->getTile(int3(5, 6, 1)).terType == ETerrainType::ROCK || map->getTile(int3(7, 8, 1)).terType == ETerrainType::ROCK);
 
+		//todo: add checks here and enable, also use smaller size
+		#if 0 
+		
 		// next check
 		auto map2 = make_unique<CMap>();
 		map2->width = 128;
@@ -96,26 +100,24 @@ BOOST_AUTO_TEST_CASE(CMapEditManager_DrawTerrain_Type)
 									int3(98, 46, 1), int3(99, 46, 1)});
 		editManager2->getTerrainSelection().setSelection(selection);
 		editManager2->drawTerrain(ETerrainType::ROCK);
+		#endif // 0
 
 	}
 	catch(const std::exception & e)
 	{
-		logGlobal-> errorStream() << e.what();
-	}
+		logGlobal->errorStream() << "CMapEditManager_DrawTerrain_Type crash" << "\n" << e.what();	
+		throw;
+	}	
+	logGlobal->infoStream() << "CMapEditManager_DrawTerrain_Type finish";
 }
 
 BOOST_AUTO_TEST_CASE(CMapEditManager_DrawTerrain_View)
 {
+	logGlobal->infoStream() << "CMapEditManager_DrawTerrain_View start";	
 	try
 	{
 		// Load maps and json config
-
-//		#if defined(__MINGW32__)
 		const std::string TEST_DATA_DIR = "test/";
-//		#else
-//		const std::string TEST_DATA_DIR = ".";
-//		#endif // defined
-
 
 		auto loader = new CFilesystemLoader("test/", TEST_DATA_DIR);
 		dynamic_cast<CFilesystemList*>(CResourceHandler::get())->addLoader(loader, false);
@@ -171,6 +173,8 @@ BOOST_AUTO_TEST_CASE(CMapEditManager_DrawTerrain_View)
 	}
 	catch(const std::exception & e)
 	{
-		logGlobal-> errorStream() << e.what();
+		logGlobal->infoStream() << "CMapEditManager_DrawTerrain_View crash"<< "\n" << e.what();
+		throw;
 	}
+	logGlobal->infoStream() << "CMapEditManager_DrawTerrain_View finish";
 }

From 27a29bd035987fd8e87108621bdb02cb5fa99e3c Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Wed, 12 Aug 2015 03:31:06 +0300
Subject: [PATCH 016/105] Start implementing actulal json serialization

---
 lib/filesystem/CMemoryBuffer.cpp     |  15 ++--
 lib/filesystem/CZipSaver.cpp         |  29 ++++----
 lib/filesystem/CZipSaver.h           |   6 +-
 lib/filesystem/MinizipExtensions.cpp |   2 +-
 lib/mapping/MapFormatJson.cpp        | 101 +++++++++++++++++++++++++--
 lib/mapping/MapFormatJson.h          |  27 ++++---
 test/CMapFormatTest.cpp              |  27 ++++---
 7 files changed, 163 insertions(+), 44 deletions(-)

diff --git a/lib/filesystem/CMemoryBuffer.cpp b/lib/filesystem/CMemoryBuffer.cpp
index 8acbf586a..39b25dc9c 100644
--- a/lib/filesystem/CMemoryBuffer.cpp
+++ b/lib/filesystem/CMemoryBuffer.cpp
@@ -20,7 +20,10 @@ CMemoryBuffer::CMemoryBuffer():
 
 si64 CMemoryBuffer::write(const ui8 * data, si64 size)
 {
-	buffer.reserve(tell()+size);
+	//do not shrink
+	const si64 newSize = tell()+size;
+	if(newSize>getSize())
+		buffer.resize(newSize);
 	
 	std::copy(data, data + size, buffer.data() + position);
 	position += size;
@@ -32,8 +35,12 @@ si64 CMemoryBuffer::read(ui8 * data, si64 size)
 {
 	si64 toRead = std::min(getSize() - tell(), size);
 	
-	std::copy(buffer.data() + position, buffer.data() + position + toRead, data);
-	position += toRead;
+	if(toRead > 0)
+	{
+		std::copy(buffer.data() + position, buffer.data() + position + toRead, data);
+		position += toRead;		
+	}
+	
 	
 	return toRead;	
 }
@@ -42,7 +49,7 @@ si64 CMemoryBuffer::seek(si64 position)
 {
 	this->position = position;
 	if (this->position >=getSize())
-		this->position = getSize()-1;
+		this->position = getSize();
 	return this->position;
 }
 
diff --git a/lib/filesystem/CZipSaver.cpp b/lib/filesystem/CZipSaver.cpp
index f3c3c2076..937bcfa04 100644
--- a/lib/filesystem/CZipSaver.cpp
+++ b/lib/filesystem/CZipSaver.cpp
@@ -12,8 +12,9 @@
 #include "CZipSaver.h"
 
 ///CZipOutputStream
-CZipOutputStream::CZipOutputStream(zipFile archive, const std::string & archiveFilename):
-	handle(archive)
+CZipOutputStream::CZipOutputStream(CZipSaver * owner_, zipFile archive, const std::string & archiveFilename):
+	handle(archive),
+	owner(owner_)
 {
 	//zip_fileinfo fileInfo;
 	
@@ -27,14 +28,15 @@ CZipOutputStream::CZipOutputStream(zipFile archive, const std::string & archiveF
                        "",
                        Z_DEFLATED,
                        Z_DEFAULT_COMPRESSION);
+	owner->activeStream = this;
 }
 
 CZipOutputStream::~CZipOutputStream()
 {
 	zipCloseFileInZip(handle);
+	owner->activeStream = nullptr;
 }
 
-
 si64 CZipOutputStream::write(const ui8 * data, si64 size)
 {
 	int ret = zipWriteInFileInZip(handle, (const void*)data, (unsigned)size);
@@ -49,18 +51,24 @@ si64 CZipOutputStream::write(const ui8 * data, si64 size)
 CZipSaver::CZipSaver(std::shared_ptr<CIOApi> api, const std::string & path):
 	ioApi(api),
 	zipApi(ioApi->getApiStructure()),
-	handle(nullptr)	
+	handle(nullptr),
+	activeStream(nullptr)
 {
-	
-	
 	handle = zipOpen2_64(path.c_str(), APPEND_STATUS_CREATE, nullptr, &zipApi);
 	
 	if (handle == nullptr)
-		throw new std::runtime_error("Failed to create archive");
+		throw new std::runtime_error("Failed to create archive");	
 }
 
 CZipSaver::~CZipSaver()
 {
+	if(activeStream != nullptr)
+	{
+		logGlobal->error("CZipSaver::~CZipSaver: active stream found");	
+		zipCloseFileInZip(handle);
+	}
+		
+	
 	if(handle != nullptr)
 		zipClose(handle, nullptr);
 }
@@ -70,10 +78,7 @@ std::unique_ptr<COutputStream> CZipSaver::addFile(const std::string & archiveFil
 	if(activeStream != nullptr)
 		throw new std::runtime_error("CZipSaver::addFile: stream already opened");
 	
-	std::unique_ptr<COutputStream> stream(new CZipOutputStream(handle, archiveFilename));
-	
-	activeStream = stream.get();
-	
-	return stream;
+	std::unique_ptr<COutputStream> stream(new CZipOutputStream(this, handle, archiveFilename));
+	return std::move(stream);
 }
 
diff --git a/lib/filesystem/CZipSaver.h b/lib/filesystem/CZipSaver.h
index 3a0cb9752..06a4c1717 100644
--- a/lib/filesystem/CZipSaver.h
+++ b/lib/filesystem/CZipSaver.h
@@ -14,6 +14,8 @@
 
 #include "MinizipExtensions.h"
 
+class CZipSaver;
+
 class DLL_LINKAGE CZipOutputStream: public COutputStream
 {
 public:
@@ -22,7 +24,7 @@ public:
 	 * @param archive archive handle, must be opened
 	 * @param archiveFilename name of file to write
 	 */	
-	explicit CZipOutputStream(zipFile archive, const std::string & archiveFilename);
+	explicit CZipOutputStream(CZipSaver * owner_, zipFile archive, const std::string & archiveFilename);
 	~CZipOutputStream();
 	
 	si64 write(const ui8 * data, si64 size) override;
@@ -33,6 +35,7 @@ public:
 	si64 getSize() override {return 0;};	
 private:
 	zipFile handle;
+	CZipSaver * owner;
 };
 
 class DLL_LINKAGE CZipSaver
@@ -50,4 +53,5 @@ private:
 	
 	///due to minizip design only one file stream may opened at a time
 	COutputStream * activeStream;
+	friend class CZipOutputStream;
 };
diff --git a/lib/filesystem/MinizipExtensions.cpp b/lib/filesystem/MinizipExtensions.cpp
index d07098957..013e57560 100644
--- a/lib/filesystem/MinizipExtensions.cpp
+++ b/lib/filesystem/MinizipExtensions.cpp
@@ -154,7 +154,7 @@ CProxyIOApi::~CProxyIOApi()
 
 CInputOutputStream * CProxyIOApi::openFile(const std::string& filename, int mode) const
 {
-	logGlobal->traceStream() << "CProxyIOApi: stream opened for" <<filename<<" with mode "<<mode; 
+	logGlobal->traceStream() << "CProxyIOApi: stream opened for " <<filename<<" with mode "<<mode; 
 	
 	data->seek(0);
 	return data;//todo: check that only one "copy" is opened
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 09c5ebf94..991a1b30b 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -51,6 +51,9 @@ static EventCondition JsonToCondition(const JsonNode & node)
 }
 
 ///CMapFormatJson
+const int CMapFormatJson::VERSION_MAJOR = 1;
+const int CMapFormatJson::VERSION_MINOR = 0;
+
 const std::string CMapFormatJson::HEADER_FILE_NAME = "header.json";
 
 void CMapFormatJson::readTriggeredEvents(const JsonNode & input)
@@ -102,9 +105,19 @@ void CMapPatcher::readPatchData()
 	readTriggeredEvents(input);
 }
 
+///CMapFormatZip
+CMapFormatZip::CMapFormatZip(CInputOutputStream * stream):
+	buffer(stream),
+	ioApi(new CProxyIOApi(buffer))
+{
+	
+}
+
+
 ///CMapLoaderJson
-CMapLoaderJson::CMapLoaderJson(CInputStream * stream):
-	input(stream)
+CMapLoaderJson::CMapLoaderJson(CInputOutputStream * stream):
+	CMapFormatZip(stream),
+	loader("", "_", ioApi)	
 {
 	
 }
@@ -168,26 +181,66 @@ JsonNode eventToJson(const EventCondition & cond)
 void CMapLoaderJson::readMap()
 {
 	readHeader();
+	map->initTerrain();
 	//TODO:readMap
 }
 
 void CMapLoaderJson::readHeader()
 {
+	//do not use map field here, use only mapHeader
+	ResourceID headerID(HEADER_FILE_NAME, EResType::TEXT);
+
+	if(!loader.existsResource(headerID))
+		throw new std::runtime_error(HEADER_FILE_NAME+" not found");
+
+	auto headerData = loader.load(headerID)->readAll();
+
+	const JsonNode header(reinterpret_cast<char*>(headerData.first.get()), headerData.second);
+
 	//TODO: read such data like map name & size
-//	readTriggeredEvents();
+	//mapHeader->version = ??? //todo: new version field
+
+	//todo: multilevel map load support	
+	const JsonNode levels = header["mapLevels"];	
+	mapHeader->height = levels["surface"]["height"].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 =
+	{
+		{"EASY", 0},
+		{"NORMAL", 1}, 
+		{"HARD", 2}, 
+		{"EXPERT", 3},
+		{"IMPOSSIBLE", 4}		
+	};
+	
+	mapHeader->difficulty = difficultyMap.at(header["difficulty"].String()); 
+	mapHeader->levelLimit = header["levelLimit"].Float();
+	
+
+//	std::vector<bool> allowedHeroes;
+//	std::vector<ui16> placeholdedHeroes;	
+	
+	readTriggeredEvents(header);
 	readPlayerInfo();
 	//TODO: readHeader
 }
 
 void CMapLoaderJson::readPlayerInfo()
 {
+	//ui8 howManyTeams;
 	//TODO: readPlayerInfo
 }
 
 ///CMapSaverJson
 CMapSaverJson::CMapSaverJson(CInputOutputStream * stream):
-	output(stream),
-	ioApi(new CProxyIOApi(output)),
+	CMapFormatZip(stream),
 	saver(ioApi, "_")
 {
 	
@@ -202,14 +255,48 @@ void CMapSaverJson::saveMap(const std::unique_ptr<CMap>& map)
 {
 	//TODO: saveMap
 	this->map = map.get();
+	saveHeader();	
+	
 }
 
 void CMapSaverJson::saveHeader()
 {
 	JsonNode header;
-	//TODO: save header
+	header["versionMajor"].Float() = VERSION_MAJOR;
+	header["versionMinor"].Float() = VERSION_MINOR;	
+	
+	//todo: multilevel map save support	
+	JsonNode levels = header["mapLevels"];
+	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"]["index"].Float() = 1;
+	}
 	
 	header["name"].String() = map->name;
+	header["description"].String() = map->description;
+	
+	
+	//todo: support arbitrary percentage	
+	static const std::map<ui8, std::string> difficultyMap =
+	{
+		{0, "EASY"},
+		{1, "NORMAL"},
+		{2, "HARD"},
+		{3, "EXPERT"},
+		{4, "IMPOSSIBLE"}
+	};
+	
+	header["difficulty"].String() = difficultyMap.at(map->difficulty);	
+	header["levelLimit"].Float() = map->levelLimit;
+	
+	//todo:	allowedHeroes;
+	//todo: placeholdedHeroes;	
 	
 	std::ostringstream out;
 	out << header;
@@ -217,7 +304,7 @@ void CMapSaverJson::saveHeader()
 	
 	{
 		auto s = out.str();
-		auto stream = saver.addFile(HEADER_FILE_NAME);
+		std::unique_ptr<COutputStream> stream = saver.addFile(HEADER_FILE_NAME);
 		
 		stream->write((const ui8*)s.c_str(), s.size());
 	}	
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 114c6c51a..877e510a4 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -22,6 +22,9 @@ class TriggeredEvent;
 class DLL_LINKAGE CMapFormatJson
 {
 public:	
+	static const int VERSION_MAJOR;
+	static const int VERSION_MINOR;	
+	
 	static const std::string HEADER_FILE_NAME;
 
 protected:
@@ -73,7 +76,16 @@ private:
 	const JsonNode input;	
 };
 
-class DLL_LINKAGE CMapLoaderJson : public CMapFormatJson, public IMapLoader
+class DLL_LINKAGE CMapFormatZip : public CMapFormatJson
+{
+public:
+	CMapFormatZip(CInputOutputStream * stream);
+protected:
+	CInputOutputStream * buffer;
+	std::shared_ptr<CIOApi> ioApi;
+};
+
+class DLL_LINKAGE CMapLoaderJson : public CMapFormatZip, public IMapLoader
 {
 public:
 	/**
@@ -81,7 +93,7 @@ public:
 	 *
 	 * @param stream a stream containing the map data
 	 */
-	CMapLoaderJson(CInputStream * stream);
+	CMapLoaderJson(CInputOutputStream * stream);
 
 	/**
 	 * Loads the VCMI/Json map file.
@@ -112,12 +124,11 @@ private:
 	 * Reads player information.
 	 */
 	void readPlayerInfo();
-
-
-	CInputStream * input;
+	
+	CZipLoader loader;
 };
 
-class DLL_LINKAGE CMapSaverJson : public CMapFormatJson, public IMapSaver
+class DLL_LINKAGE CMapSaverJson : public CMapFormatZip, public IMapSaver
 {
 public:
 	/**
@@ -136,8 +147,6 @@ public:
 	void saveMap(const std::unique_ptr<CMap> & map) override;	
 private:
 	void saveHeader();
-	
-	CInputOutputStream * output;
-	std::shared_ptr<CIOApi> ioApi;		
+		
 	CZipSaver saver;	
 };
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index 6f8e625b1..593fc3902 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -40,6 +40,7 @@ public:
 		CMapGenerator gen;
 		
 		initialMap = gen.generate(&opt, TEST_RANDOM_SEED);
+		initialMap->name = "Test";
 	};
 	~CMapTestFixture()
 	{
@@ -53,20 +54,26 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 {
 	try
 	{
+		logGlobal->info("CMapFormatVCMI_Simple start");
 		CMemoryBuffer serializeBuffer;
-		CMapSaverJson saver(&serializeBuffer);
-		saver.saveMap(initialMap);
-		
-		CMapLoaderJson loader(&serializeBuffer);
-		serializeBuffer.seek(0);		
-		std::unique_ptr<CMap> serialized = loader.loadMap();
-		
-		
-		MapComparer c;		
-		c(initialMap, serialized);
+		{
+			CMapSaverJson saver(&serializeBuffer);
+			saver.saveMap(initialMap);
+		}
+		serializeBuffer.seek(0);
+		{
+			CMapLoaderJson loader(&serializeBuffer);
+			std::unique_ptr<CMap> serialized = loader.loadMap();
+
+			MapComparer c;
+			c(initialMap, serialized);
+		}
+
+		logGlobal->info("CMapFormatVCMI_Simple finish");
 	}
 	catch(const std::exception & e)
 	{
+		logGlobal->info("CMapFormatVCMI_Simple crash");
 		logGlobal-> errorStream() << e.what();
 		throw;
 	}

From f2164abf1b57faa1147852ee8c620665356b41f3 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Thu, 13 Aug 2015 03:29:13 +0300
Subject: [PATCH 017/105] Wip on zip serialize fixes

---
 lib/filesystem/CMemoryBuffer.h       |  2 ++
 lib/filesystem/CZipLoader.cpp        |  3 +++
 lib/filesystem/CZipSaver.cpp         |  8 ++++++--
 lib/filesystem/MinizipExtensions.cpp |  4 ++--
 lib/mapping/MapFormatJson.cpp        |  3 ++-
 test/CMapFormatTest.cpp              | 21 +++++++++++++++++----
 6 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/lib/filesystem/CMemoryBuffer.h b/lib/filesystem/CMemoryBuffer.h
index 10e43fa6a..1ceeaff69 100644
--- a/lib/filesystem/CMemoryBuffer.h
+++ b/lib/filesystem/CMemoryBuffer.h
@@ -75,6 +75,8 @@ public:
 	 * @return the length in bytes of the stream.
 	 */
 	si64 getSize() override;
+	
+	const TBuffer & getBuffer(){return buffer;}
 
 private:
 	/** Actual data. */
diff --git a/lib/filesystem/CZipLoader.cpp b/lib/filesystem/CZipLoader.cpp
index 47dc621d0..10d7120f4 100644
--- a/lib/filesystem/CZipLoader.cpp
+++ b/lib/filesystem/CZipLoader.cpp
@@ -66,6 +66,9 @@ std::unordered_map<ResourceID, unz_file_pos> CZipLoader::listFiles(const std::st
 	std::unordered_map<ResourceID, unz_file_pos> ret;
 
 	unzFile file = unzOpen2_64(archive.c_str(), &zlibApi);
+	
+	if(file == nullptr)
+		logGlobal->errorStream() << archive << " failed to open";
 
 	if (unzGoToFirstFile(file) == UNZ_OK)
 	{
diff --git a/lib/filesystem/CZipSaver.cpp b/lib/filesystem/CZipSaver.cpp
index 937bcfa04..8cf029abc 100644
--- a/lib/filesystem/CZipSaver.cpp
+++ b/lib/filesystem/CZipSaver.cpp
@@ -18,7 +18,7 @@ CZipOutputStream::CZipOutputStream(CZipSaver * owner_, zipFile archive, const st
 {
 	//zip_fileinfo fileInfo;
 	
-	zipOpenNewFileInZip(handle,
+	int status = zipOpenNewFileInZip(handle,
                        archiveFilename.c_str(),
                        nullptr,//todo: use fileInfo,
                        nullptr,
@@ -28,6 +28,10 @@ CZipOutputStream::CZipOutputStream(CZipSaver * owner_, zipFile archive, const st
                        "",
                        Z_DEFLATED,
                        Z_DEFAULT_COMPRESSION);
+    
+    if(status != ZIP_OK)
+		throw new std::runtime_error("CZipOutputStream: zipOpenNewFileInZip failed");
+	
 	owner->activeStream = this;
 }
 
@@ -57,7 +61,7 @@ CZipSaver::CZipSaver(std::shared_ptr<CIOApi> api, const std::string & path):
 	handle = zipOpen2_64(path.c_str(), APPEND_STATUS_CREATE, nullptr, &zipApi);
 	
 	if (handle == nullptr)
-		throw new std::runtime_error("Failed to create archive");	
+		throw new std::runtime_error("CZipSaver: Failed to create archive");	
 }
 
 CZipSaver::~CZipSaver()
diff --git a/lib/filesystem/MinizipExtensions.cpp b/lib/filesystem/MinizipExtensions.cpp
index 013e57560..8057a907f 100644
--- a/lib/filesystem/MinizipExtensions.cpp
+++ b/lib/filesystem/MinizipExtensions.cpp
@@ -68,10 +68,10 @@ long ZCALLBACK CIOApi::seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T off
         actualStream->skip(offset);//TODO: should we check actual skipped? 
         break;
     case ZLIB_FILEFUNC_SEEK_END :
-    	ret = -1;
+    	actualStream->seek(actualStream->getSize() - offset);
         break;
     case ZLIB_FILEFUNC_SEEK_SET :
-    	ret = actualStream->seek(offset);
+    	actualStream->seek(offset);
         break;
     default: ret = -1;
     }
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 991a1b30b..027719301 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -306,6 +306,7 @@ void CMapSaverJson::saveHeader()
 		auto s = out.str();
 		std::unique_ptr<COutputStream> stream = saver.addFile(HEADER_FILE_NAME);
 		
-		stream->write((const ui8*)s.c_str(), s.size());
+		if (stream->write((const ui8*)s.c_str(), s.size()) != s.size())
+			throw new std::runtime_error("CMapSaverJson::saveHeader() zip compression failed.");
 	}	
 }
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index 593fc3902..c37352e40 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -19,8 +19,11 @@
 #include "../lib/rmg/CMapGenerator.h"
 #include "../lib/mapping/MapFormatJson.h"
 
+#include "../lib/VCMIDirs.h"
+
 #include "MapComparer.h"
 
+
 static const int TEST_RANDOM_SEED = 1337;
 
 static std::unique_ptr<CMap> initialMap;
@@ -60,6 +63,17 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 			CMapSaverJson saver(&serializeBuffer);
 			saver.saveMap(initialMap);
 		}
+		
+		#if 1
+		{
+			std::ofstream tmp((VCMIDirs::get().userDataPath()/"temp.zip").string());
+			tmp.write((const char *)&serializeBuffer.getBuffer()[0],serializeBuffer.getSize());
+			tmp.flush();
+		}
+		
+		
+		#endif // 1
+		
 		serializeBuffer.seek(0);
 		{
 			CMapLoaderJson loader(&serializeBuffer);
@@ -71,10 +85,9 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 
 		logGlobal->info("CMapFormatVCMI_Simple finish");
 	}
-	catch(const std::exception & e)
+	catch(...)
 	{
-		logGlobal->info("CMapFormatVCMI_Simple crash");
-		logGlobal-> errorStream() << e.what();
-		throw;
+		handleException();
+		BOOST_FAIL("Test case crashed");
 	}
 }

From ff18944088a698a2614135551cf39fc921c6b15c Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Thu, 13 Aug 2015 03:45:42 +0300
Subject: [PATCH 018/105] Fix writing escaped string json fields

---
 lib/JsonDetail.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/JsonDetail.cpp b/lib/JsonDetail.cpp
index fb70d8b93..af41bce47 100644
--- a/lib/JsonDetail.cpp
+++ b/lib/JsonDetail.cpp
@@ -61,17 +61,18 @@ void JsonWriter::writeEntry(JsonVector::const_iterator entry)
 void JsonWriter::writeString(const std::string &string)
 {
 	static const std::string escaped = "\"\\\b\f\n\r\t";
-
+	static const std::string escaped_code = "\"\\bfnrt";	
+	
 	out <<'\"';
 	size_t pos=0, start=0;
 	for (; pos<string.size(); pos++)
 	{
-		size_t escapedChar = escaped.find(string[pos]);
+		size_t escapedPos = escaped.find(string[pos]);
 
-		if (escapedChar != std::string::npos)
+		if (escapedPos != std::string::npos)
 		{
 			out.write(string.data()+start, pos - start);
-			out << '\\' << escaped[escapedChar];
+			out << '\\' << escaped_code[escapedPos];
 			start = pos;
 		}
 	}

From fc2cbc841a911094eaddca0e67aeee494601d8a6 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Fri, 14 Aug 2015 00:14:00 +0300
Subject: [PATCH 019/105] Another fix for JsonWriter::writeString * RMG
 description check passed

---
 lib/JsonDetail.cpp | 26 +++++++++++++++++++-------
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/lib/JsonDetail.cpp b/lib/JsonDetail.cpp
index af41bce47..6b01614d2 100644
--- a/lib/JsonDetail.cpp
+++ b/lib/JsonDetail.cpp
@@ -61,20 +61,32 @@ void JsonWriter::writeEntry(JsonVector::const_iterator entry)
 void JsonWriter::writeString(const std::string &string)
 {
 	static const std::string escaped = "\"\\\b\f\n\r\t";
-	static const std::string escaped_code = "\"\\bfnrt";	
+	
+	static const std::array<char, 7> escaped_code = {'\"', '\\', 'b', 'f', 'n', 'r', 't'};
 	
 	out <<'\"';
 	size_t pos=0, start=0;
 	for (; pos<string.size(); pos++)
 	{
-		size_t escapedPos = escaped.find(string[pos]);
-
-		if (escapedPos != std::string::npos)
+		//we need to check if special character was been already escaped		
+		if((string[pos] == '\\') 
+			&& (pos+1 < string.size()) 
+			&& (std::find(escaped_code.begin(), escaped_code.end(), string[pos+1]) != escaped_code.end()) )
 		{
-			out.write(string.data()+start, pos - start);
-			out << '\\' << escaped_code[escapedPos];
-			start = pos;
+			pos++; //write unchanged, next simbol also checked
 		}
+		else
+		{
+			size_t escapedPos = escaped.find(string[pos]);
+
+			if (escapedPos != std::string::npos)
+			{
+				out.write(string.data()+start, pos - start);
+				out << '\\' << escaped_code[escapedPos];
+				start = pos+1;
+			}			
+		}
+
 	}
 	out.write(string.data()+start, pos - start);
 	out <<'\"';

From 0cc7213a278a27ab88762691d98ec1bbfeab1dbb Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Fri, 14 Aug 2015 00:16:31 +0300
Subject: [PATCH 020/105] WiP on zip serialization (-) still not works
 correctly

---
 lib/filesystem/CMemoryBuffer.cpp     |  4 +-
 lib/filesystem/MinizipExtensions.cpp | 16 ++++++--
 lib/mapping/MapFormatJson.cpp        |  1 +
 test/CMapFormatTest.cpp              | 55 ++++++++++++----------------
 test/CMemoryBufferTest.cpp           | 52 ++++++++++++++++++++++++++
 test/MapComparer.cpp                 |  2 +-
 test/Test.cbp                        |  1 +
 7 files changed, 93 insertions(+), 38 deletions(-)
 create mode 100644 test/CMemoryBufferTest.cpp

diff --git a/lib/filesystem/CMemoryBuffer.cpp b/lib/filesystem/CMemoryBuffer.cpp
index 39b25dc9c..849502e7a 100644
--- a/lib/filesystem/CMemoryBuffer.cpp
+++ b/lib/filesystem/CMemoryBuffer.cpp
@@ -15,7 +15,7 @@
 CMemoryBuffer::CMemoryBuffer():
 	position(0)
 {
-	
+	buffer.reserve(4096);
 }
 
 si64 CMemoryBuffer::write(const ui8 * data, si64 size)
@@ -48,7 +48,7 @@ si64 CMemoryBuffer::read(ui8 * data, si64 size)
 si64 CMemoryBuffer::seek(si64 position)
 {
 	this->position = position;
-	if (this->position >=getSize())
+	if (this->position >getSize())
 		this->position = getSize();
 	return this->position;
 }
diff --git a/lib/filesystem/MinizipExtensions.cpp b/lib/filesystem/MinizipExtensions.cpp
index 8057a907f..5810babe9 100644
--- a/lib/filesystem/MinizipExtensions.cpp
+++ b/lib/filesystem/MinizipExtensions.cpp
@@ -65,16 +65,24 @@ long ZCALLBACK CIOApi::seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T off
     switch (origin)
     {
     case ZLIB_FILEFUNC_SEEK_CUR :
-        actualStream->skip(offset);//TODO: should we check actual skipped? 
+        if(actualStream->skip(offset) != offset)
+			ret = -1;
         break;
-    case ZLIB_FILEFUNC_SEEK_END :
-    	actualStream->seek(actualStream->getSize() - offset);
+    case ZLIB_FILEFUNC_SEEK_END:
+    	{
+    		const si64 pos = actualStream->getSize() - offset;
+    		if(actualStream->seek(pos) != pos)
+				ret = -1;
+    	}    	
         break;
     case ZLIB_FILEFUNC_SEEK_SET :
-    	actualStream->seek(offset);
+		if(actualStream->seek(offset) != offset)
+			ret = -1;
         break;
     default: ret = -1;
     }
+    if(ret == -1)
+		logGlobal->error("CIOApi::seekFileProxy: seek failed");			
     return ret;
 }
 
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 027719301..285393236 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -213,6 +213,7 @@ void CMapLoaderJson::readHeader()
 	
 	static const std::map<std::string, ui8> difficultyMap =
 	{
+		{"", 1},
 		{"EASY", 0},
 		{"NORMAL", 1}, 
 		{"HARD", 2}, 
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index c37352e40..6d9d9353d 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -55,39 +55,32 @@ BOOST_GLOBAL_FIXTURE(CMapTestFixture);
 
 BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 {
-	try
+	logGlobal->info("CMapFormatVCMI_Simple start");
+	CMemoryBuffer serializeBuffer;
 	{
-		logGlobal->info("CMapFormatVCMI_Simple start");
-		CMemoryBuffer serializeBuffer;
-		{
-			CMapSaverJson saver(&serializeBuffer);
-			saver.saveMap(initialMap);
-		}
-		
-		#if 1
-		{
-			std::ofstream tmp((VCMIDirs::get().userDataPath()/"temp.zip").string());
-			tmp.write((const char *)&serializeBuffer.getBuffer()[0],serializeBuffer.getSize());
-			tmp.flush();
-		}
-		
-		
-		#endif // 1
-		
-		serializeBuffer.seek(0);
-		{
-			CMapLoaderJson loader(&serializeBuffer);
-			std::unique_ptr<CMap> serialized = loader.loadMap();
-
-			MapComparer c;
-			c(initialMap, serialized);
-		}
-
-		logGlobal->info("CMapFormatVCMI_Simple finish");
+		CMapSaverJson saver(&serializeBuffer);
+		saver.saveMap(initialMap);
 	}
-	catch(...)
+	
+	#if 1
 	{
-		handleException();
-		BOOST_FAIL("Test case crashed");
+		auto path = VCMIDirs::get().userDataPath()/"temp.zip";
+		boost::filesystem::remove(path);
+		boost::filesystem::ofstream tmp(path);
+		tmp.write((const char *)serializeBuffer.getBuffer().data(),serializeBuffer.getSize());
 	}
+	
+	
+	#endif // 1
+	
+	serializeBuffer.seek(0);
+	{
+		CMapLoaderJson loader(&serializeBuffer);
+		std::unique_ptr<CMap> serialized = loader.loadMap();
+
+		MapComparer c;
+		c(serialized, initialMap);
+	}
+
+	logGlobal->info("CMapFormatVCMI_Simple finish");
 }
diff --git a/test/CMemoryBufferTest.cpp b/test/CMemoryBufferTest.cpp
new file mode 100644
index 000000000..a4935be51
--- /dev/null
+++ b/test/CMemoryBufferTest.cpp
@@ -0,0 +1,52 @@
+
+/*
+ * CMemoryBufferTest.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
+ *
+ */
+#include "StdInc.h"
+
+#include <boost/test/unit_test.hpp>
+
+#include "../lib/filesystem/CMemoryBuffer.h"
+
+
+struct CMemoryBufferFixture
+{
+	CMemoryBuffer subject;
+};
+
+BOOST_FIXTURE_TEST_CASE(CMemoryBuffer_Empty, CMemoryBufferFixture)
+{
+	BOOST_REQUIRE_EQUAL(0, subject.tell());
+	BOOST_REQUIRE_EQUAL(0, subject.getSize());
+	
+	si32 dummy = 1337;
+	
+	auto ret = subject.read((ui8 *)&dummy, sizeof(si32));
+	
+	BOOST_CHECK_EQUAL(0, ret);	
+	BOOST_CHECK_EQUAL(1337, dummy);
+	BOOST_CHECK_EQUAL(0, subject.tell());
+}
+
+BOOST_FIXTURE_TEST_CASE(CMemoryBuffer_Write, CMemoryBufferFixture)
+{
+	const si32 initial = 1337;
+	
+	subject.write((const ui8 *)&initial, sizeof(si32));
+	
+	BOOST_CHECK_EQUAL(4, subject.tell());
+	subject.seek(0);
+	BOOST_CHECK_EQUAL(0, subject.tell());
+	
+	si32 current = 0;
+	auto ret = subject.read((ui8 *)&current, sizeof(si32));
+	BOOST_CHECK_EQUAL(sizeof(si32), ret);	
+	BOOST_CHECK_EQUAL(initial, current);
+	BOOST_CHECK_EQUAL(4, subject.tell());	
+}
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 2ba2878fb..7e0544c6f 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -82,7 +82,7 @@ void MapComparer::compare()
 {
 	BOOST_REQUIRE_NE((void *) actual, (void *) expected); //should not point to the same object
 	BOOST_REQUIRE_MESSAGE(actual != nullptr, "Actual map is not defined");
-	BOOST_REQUIRE_MESSAGE(actual != nullptr, "Expected map is not defined");
+	BOOST_REQUIRE_MESSAGE(expected != nullptr, "Expected map is not defined");
 
 	compareHeader();
 	compareOptions();
diff --git a/test/Test.cbp b/test/Test.cbp
index 6665380f5..d9fdb6e93 100644
--- a/test/Test.cbp
+++ b/test/Test.cbp
@@ -60,6 +60,7 @@
 		</Linker>
 		<Unit filename="CMapEditManagerTest.cpp" />
 		<Unit filename="CMapFormatTest.cpp" />
+		<Unit filename="CMemoryBufferTest.cpp" />
 		<Unit filename="CVcmiTestConfig.cpp" />
 		<Unit filename="CVcmiTestConfig.h" />
 		<Unit filename="MapComparer.cpp" />

From f6e2cd16edf857c1eeed2fbee326b1828454e423 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Fri, 14 Aug 2015 00:42:01 +0300
Subject: [PATCH 021/105] Fix header.mapLevels saving

---
 lib/mapping/MapFormatJson.cpp | 2 +-
 test/MapComparer.cpp          | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 285393236..15897422f 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -267,7 +267,7 @@ void CMapSaverJson::saveHeader()
 	header["versionMinor"].Float() = VERSION_MINOR;	
 	
 	//todo: multilevel map save support	
-	JsonNode levels = header["mapLevels"];
+	JsonNode & levels = header["mapLevels"];
 	levels["surface"]["height"].Float() = map->height;	
 	levels["surface"]["width"].Float() = map->width;
 	levels["surface"]["index"].Float() = 0;
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 7e0544c6f..6d900bdd1 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -60,22 +60,22 @@ void MapComparer::compareHeader()
 	VCMI_REQUIRE_FIELD_EQUAL(width);
 	VCMI_REQUIRE_FIELD_EQUAL(twoLevel);
 
-	BOOST_FAIL("Not implemented");
+	BOOST_ERROR("Not implemented");
 }
 
 void MapComparer::compareOptions()
 {
-	BOOST_FAIL("Not implemented");
+	BOOST_ERROR("Not implemented");
 }
 
 void MapComparer::compareObjects()
 {
-	BOOST_FAIL("Not implemented");
+	BOOST_ERROR("Not implemented");
 }
 
 void MapComparer::compareTerrain()
 {
-	BOOST_FAIL("Not implemented");
+	BOOST_ERROR("Not implemented");
 }
 
 void MapComparer::compare()

From b683c29b6e3585705f5346040ef762c287e9168f Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Fri, 14 Aug 2015 01:42:52 +0300
Subject: [PATCH 022/105] Added modification time to zip. * it is required to
 consider archive valid (by some tools)

---
 lib/filesystem/CZipSaver.cpp | 20 +++++++++++++++++---
 test/CMapFormatTest.cpp      |  2 ++
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/lib/filesystem/CZipSaver.cpp b/lib/filesystem/CZipSaver.cpp
index 8cf029abc..41a6bbf4e 100644
--- a/lib/filesystem/CZipSaver.cpp
+++ b/lib/filesystem/CZipSaver.cpp
@@ -16,16 +16,30 @@ CZipOutputStream::CZipOutputStream(CZipSaver * owner_, zipFile archive, const st
 	handle(archive),
 	owner(owner_)
 {
-	//zip_fileinfo fileInfo;
+	zip_fileinfo fileInfo;
+	
+	std::time_t t = time(nullptr);
+	fileInfo.dosDate = 0;	
+	
+	struct tm * localTime = std::localtime(&t);
+	fileInfo.tmz_date.tm_hour = localTime->tm_hour;
+	fileInfo.tmz_date.tm_mday = localTime->tm_mday;
+	fileInfo.tmz_date.tm_min  = localTime->tm_min;
+	fileInfo.tmz_date.tm_mon  = localTime->tm_mon;
+	fileInfo.tmz_date.tm_sec  = localTime->tm_sec;
+	fileInfo.tmz_date.tm_year = localTime->tm_year;
+		
+	fileInfo.external_fa = 0; //??? 
+	fileInfo.internal_fa = 0;	
 	
 	int status = zipOpenNewFileInZip(handle,
                        archiveFilename.c_str(),
-                       nullptr,//todo: use fileInfo,
+                       &fileInfo,
                        nullptr,
                        0,
                        nullptr,
                        0,
-                       "",
+                       nullptr,
                        Z_DEFLATED,
                        Z_DEFAULT_COMPRESSION);
     
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index 6d9d9353d..758812635 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -68,6 +68,8 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 		boost::filesystem::remove(path);
 		boost::filesystem::ofstream tmp(path);
 		tmp.write((const char *)serializeBuffer.getBuffer().data(),serializeBuffer.getSize());
+		tmp.flush();
+		tmp.close();
 	}
 	
 	

From 11af00bcdf2246b83f2b252e4e6555294bdfb85b Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Fri, 14 Aug 2015 05:22:24 +0300
Subject: [PATCH 023/105] Start working on Triggered Events

---
 lib/mapping/MapFormatJson.cpp | 39 +++++++++++++++++++++++++++++++++--
 lib/mapping/MapFormatJson.h   | 14 +++++++++++--
 test/MapComparer.cpp          | 11 +++++-----
 3 files changed, 54 insertions(+), 10 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 15897422f..fff745ad6 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -17,13 +17,13 @@
 #include "../CModHandler.h"
 #include "../VCMI_Lib.h"
 
-static const std::string conditionNames[] = {
+static const std::array<std::string, 12> conditionNames = {
 "haveArtifact", "haveCreatures",   "haveResources",   "haveBuilding",
 "control",      "destroy",         "transport",       "daysPassed",
 "isHuman",      "daysWithoutTown", "standardWin",     "constValue"
 };
 
-static const std::string typeNames[] = { "victory", "defeat" };
+static const std::array<std::string, 2> typeNames = { "victory", "defeat" };
 
 static EventCondition JsonToCondition(const JsonNode & node)
 {
@@ -50,6 +50,11 @@ static EventCondition JsonToCondition(const JsonNode & node)
 	return event;
 }
 
+static void ConditionToJson(const EventCondition& event, JsonNode& dest)
+{
+	
+}
+
 ///CMapFormatJson
 const int CMapFormatJson::VERSION_MAJOR = 1;
 const int CMapFormatJson::VERSION_MINOR = 0;
@@ -85,6 +90,32 @@ void CMapFormatJson::readTriggeredEvent(TriggeredEvent & event, const JsonNode &
 	event.trigger = EventExpression(source["condition"], JsonToCondition); // logical expression
 }
 
+void CMapFormatJson::writeTriggeredEvents(JsonNode& output)
+{
+	output["victoryString"].String() = map->victoryMessage;
+	output["victoryIconIndex"].Float() = map->victoryIconIndex;
+
+	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]);
+}
+
+void CMapFormatJson::writeTriggeredEvent(const TriggeredEvent& event, JsonNode& dest)
+{
+	dest["message"].String() = event.onFulfill;
+	dest["description"].String() = event.description;
+	
+	dest["effect"]["type"].String() = typeNames.at(event.effect.type);
+	dest["effect"]["messageToSend"].String() = event.effect.toOtherMessage;
+	
+
+}
+
+
 ///CMapPatcher
 CMapPatcher::CMapPatcher(JsonNode stream):
 	input(stream)
@@ -296,6 +327,10 @@ void CMapSaverJson::saveHeader()
 	header["difficulty"].String() = difficultyMap.at(map->difficulty);	
 	header["levelLimit"].Float() = map->levelLimit;
 	
+	writeTriggeredEvents(header);
+	
+	//todo: player info
+	
 	//todo:	allowedHeroes;
 	//todo: placeholdedHeroes;	
 	
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 877e510a4..63d8a591a 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -33,7 +33,7 @@ protected:
 	CMap * map;
 
 	/**
-	 * ptr to the map header object which gets filled by data from the buffer or written to buffer.
+	 * ptr to the map header object which gets filled by data from the buffer.
 	 * (when loading map and mapHeader point to the same object)
 	 */
 	std::unique_ptr<CMapHeader> mapHeader;	
@@ -43,10 +43,20 @@ protected:
 	 */
 	void readTriggeredEvents(const JsonNode & input);
 
+	/**
+	 * Writes triggered events, including victory/loss conditions
+	 */
+	void writeTriggeredEvents(JsonNode & output);
+
 	/**
 	 * Reads one of triggered events
 	 */
-	void readTriggeredEvent(TriggeredEvent & event, const JsonNode & source);		
+	void readTriggeredEvent(TriggeredEvent & event, const JsonNode & source);
+	
+	/**
+	 * Writes one of triggered events
+	 */
+	void writeTriggeredEvent(const TriggeredEvent & event, JsonNode & dest);			
 };
 
 class DLL_LINKAGE CMapPatcher : public CMapFormatJson, public IMapPatcher
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 6d900bdd1..da47ba757 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -42,6 +42,11 @@ bool operator!=(const PlayerInfo & actual, const PlayerInfo & expected)
 
 void MapComparer::compareHeader()
 {
+	//map size parameters are vital for further checks 
+	VCMI_REQUIRE_FIELD_EQUAL(height);
+	VCMI_REQUIRE_FIELD_EQUAL(width);
+	VCMI_REQUIRE_FIELD_EQUAL(twoLevel);
+
 	VCMI_CHECK_FIELD_EQUAL_P(name);
 	VCMI_CHECK_FIELD_EQUAL_P(description);
 	VCMI_CHECK_FIELD_EQUAL_P(difficulty);
@@ -54,12 +59,6 @@ void MapComparer::compareHeader()
 	
 	BOOST_CHECK_EQUAL_COLLECTIONS(actual->players.begin(), actual->players.end(), expected->players.begin(), expected->players.end());
 
-
-	//map size parameters are vital for further checks 
-	VCMI_REQUIRE_FIELD_EQUAL(height);
-	VCMI_REQUIRE_FIELD_EQUAL(width);
-	VCMI_REQUIRE_FIELD_EQUAL(twoLevel);
-
 	BOOST_ERROR("Not implemented");
 }
 

From 27bf2524a372e285bf33bc284847c55c777cd11e Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sat, 15 Aug 2015 18:09:39 +0300
Subject: [PATCH 024/105] Advance triggered events serialization (-) missing
 indentifier serialization (unimplemented in engine) (-) missing tests

---
 lib/LogicalExpression.h       |  2 +-
 lib/mapping/MapFormatJson.cpp | 41 ++++++++++++++++++++++++++++++-----
 2 files changed, 36 insertions(+), 7 deletions(-)

diff --git a/lib/LogicalExpression.h b/lib/LogicalExpression.h
index c31288eb5..0c9e94b86 100644
--- a/lib/LogicalExpression.h
+++ b/lib/LogicalExpression.h
@@ -262,7 +262,7 @@ namespace LogicalExpressionDetail
 		}
 	};
 
-	/// Prints expression in human-readable format
+	/// Serializes expression in JSON format. Part of map format.
 	template <typename ContainedClass>
 	class Writer : public boost::static_visitor<JsonNode>
 	{
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index fff745ad6..f45af3f39 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -50,9 +50,38 @@ static EventCondition JsonToCondition(const JsonNode & node)
 	return event;
 }
 
-static void ConditionToJson(const EventCondition& event, JsonNode& dest)
+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))
+	{
+		auto & position = data["position"].Vector();
+		JsonNode coord;
+		coord.Float() = event.position.x; 
+		position.push_back(coord);
+		coord.Float() = event.position.y; 
+		position.push_back(coord);
+		coord.Float() = event.position.z; 
+		position.push_back(coord);		
+	}		
+	
+	asVector.push_back(data);
+			
+	return std::move(json);
 }
 
 ///CMapFormatJson
@@ -98,10 +127,10 @@ 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]);
+	JsonMap & triggeredEvents = output["triggeredEvents"].Struct();
+	
+	for(auto event : map->triggeredEvents)
+		writeTriggeredEvent(event, triggeredEvents[event.identifier]);
 }
 
 void CMapFormatJson::writeTriggeredEvent(const TriggeredEvent& event, JsonNode& dest)
@@ -112,7 +141,7 @@ void CMapFormatJson::writeTriggeredEvent(const TriggeredEvent& event, JsonNode&
 	dest["effect"]["type"].String() = typeNames.at(event.effect.type);
 	dest["effect"]["messageToSend"].String() = event.effect.toOtherMessage;
 	
-
+	dest["condition"] = event.trigger.toJson(ConditionToJson);
 }
 
 

From 8bc242d002ba595da6e4144b108a20db39c6e4ed Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sat, 15 Aug 2015 18:46:29 +0300
Subject: [PATCH 025/105] Cleanup

---
 lib/mapping/MapFormatJson.cpp | 62 +++++------------------------------
 1 file changed, 9 insertions(+), 53 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index f45af3f39..0419462ad 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -42,9 +42,10 @@ static EventCondition JsonToCondition(const JsonNode & node)
 
 		if (!data["position"].isNull())
 		{
-			event.position.x = data["position"].Vector()[0].Float();
-			event.position.y = data["position"].Vector()[1].Float();
-			event.position.z = data["position"].Vector()[2].Float();
+			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;
@@ -70,13 +71,10 @@ static JsonNode ConditionToJson(const EventCondition& event)
 	if(event.position != int3(-1,-1,-1))
 	{
 		auto & position = data["position"].Vector();
-		JsonNode coord;
-		coord.Float() = event.position.x; 
-		position.push_back(coord);
-		coord.Float() = event.position.y; 
-		position.push_back(coord);
-		coord.Float() = event.position.z; 
-		position.push_back(coord);		
+		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);
@@ -109,7 +107,6 @@ void CMapFormatJson::readTriggeredEvents(const JsonNode & input)
 	}
 }
 
-
 void CMapFormatJson::readTriggeredEvent(TriggeredEvent & event, const JsonNode & source)
 {
 	event.onFulfill = source["message"].String();
@@ -138,7 +135,7 @@ void CMapFormatJson::writeTriggeredEvent(const TriggeredEvent& event, JsonNode&
 	dest["message"].String() = event.onFulfill;
 	dest["description"].String() = event.description;
 	
-	dest["effect"]["type"].String() = typeNames.at(event.effect.type);
+	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,47 +194,6 @@ std::unique_ptr<CMapHeader> CMapLoaderJson::loadMapHeader()
 	return std::move(mapHeader);
 }
 
-/*
-	//This code can be used to write map header to console or file in its Json representation
-
-	JsonNode out;
-	JsonNode data;
-	data["victoryString"].String() = mapHeader->victoryMessage;
-	data["defeatString"].String() = mapHeader->defeatMessage;
-
-	data["victoryIconIndex"].Float() = mapHeader->victoryIconIndex;
-	data["defeatIconIndex"].Float() = mapHeader->defeatIconIndex;
-
-	for (const TriggeredEvent & entry : mapHeader->triggeredEvents)
-	{
-		JsonNode event;
-		event["message"].String() = entry.onFulfill;
-		event["effect"]["messageToSend"].String() = entry.effect.toOtherMessage;
-		event["effect"]["type"].String() = typeNames[entry.effect.type];
-		event["condition"] = entry.trigger.toJson(eventToJson);
-		data["triggeredEvents"][entry.identifier] = event;
-	}
-
-	out[mapHeader->name] = data;
-	logGlobal->errorStream() << out;
-
-JsonNode eventToJson(const EventCondition & cond)
-{
-	JsonNode ret;
-	ret.Vector().resize(2);
-	ret.Vector()[0].String() = conditionNames[size_t(cond.condition)];
-	JsonNode & data = ret.Vector()[1];
-	data["type"].Float() = cond.objectType;
-	data["value"].Float() = cond.value;
-	data["position"].Vector().resize(3);
-	data["position"].Vector()[0].Float() = cond.position.x;
-	data["position"].Vector()[1].Float() = cond.position.y;
-	data["position"].Vector()[2].Float() = cond.position.z;
-
-	return ret;
-}
-*/
-
 void CMapLoaderJson::readMap()
 {
 	readHeader();

From a3c3f935b911a9f36adab2d1d44c3d85faf0643c Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sat, 15 Aug 2015 20:25:40 +0300
Subject: [PATCH 026/105] Advance map checks

---
 test/MapComparer.cpp | 83 +++++++++++++++++++++++++++++++++++++-------
 1 file changed, 70 insertions(+), 13 deletions(-)

diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index da47ba757..6afb570b2 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -19,25 +19,73 @@
 
 #define VCMI_REQUIRE_FIELD_EQUAL(field) BOOST_REQUIRE_EQUAL(actual->field, expected->field)
 
-std::ostream& operator<< (std::ostream& os, const PlayerInfo & value)
+template <class T>
+void checkEqual(const T & actual, const T & expected)
 {
-	os << "PlayerInfo"; 
-	return os;
+	BOOST_CHECK_EQUAL(actual, expected)	;
 }
 
-//std::ostream& operator<< (std::ostream& os, const std::set<ui8> & value)
-//{
-//	os << "'Set'"; 
-//	return os;
-//}
+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);
+	}		
+}
 
-bool operator!=(const PlayerInfo & actual, const PlayerInfo & expected)
+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)
 {
 	VCMI_CHECK_FIELD_EQUAL(canHumanPlay);
 	VCMI_CHECK_FIELD_EQUAL(canComputerPlay);
 	VCMI_CHECK_FIELD_EQUAL(aiTactic);
-	//VCMI_CHECK_FIELD_EQUAL(allowedFactions);
-	return false;
+	
+	checkEqual(actual.allowedFactions, expected.allowedFactions);
+	
+	VCMI_CHECK_FIELD_EQUAL(isFactionRandom);
+	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);
+	VCMI_CHECK_FIELD_EQUAL(team);
+	VCMI_CHECK_FIELD_EQUAL(hasRandomHero);
+
+}
+
+void checkEqual(const EventExpression & actual,  const EventExpression & expected)
+{
+	//todo: checkEventExpression
+}
+
+void checkEqual(const TriggeredEvent & actual,  const TriggeredEvent & expected)
+{
+	VCMI_CHECK_FIELD_EQUAL(identifier);
+	VCMI_CHECK_FIELD_EQUAL(description);
+	VCMI_CHECK_FIELD_EQUAL(onFulfill);
+	VCMI_CHECK_FIELD_EQUAL(effect.type);
+	VCMI_CHECK_FIELD_EQUAL(effect.toOtherMessage);	
+
+	checkEqual(actual.trigger, expected.trigger);	
 }
 
 void MapComparer::compareHeader()
@@ -57,13 +105,22 @@ void MapComparer::compareHeader()
 	VCMI_CHECK_FIELD_EQUAL_P(victoryIconIndex);
 	VCMI_CHECK_FIELD_EQUAL_P(defeatIconIndex);
 	
-	BOOST_CHECK_EQUAL_COLLECTIONS(actual->players.begin(), actual->players.end(), expected->players.begin(), expected->players.end());
+	checkEqual(actual->players, expected->players);	
+	
+	//todo: allowedHeroes, placeholdedHeroes
 
-	BOOST_ERROR("Not implemented");
+	checkEqual(actual->triggeredEvents, expected->triggeredEvents);	
 }
 
 void MapComparer::compareOptions()
 {
+	//rumors
+	//disposedHeroes
+	//predefinedHeroes
+	//allowedSpell
+	//allowedArtifact
+	//allowedAbilities
+	
 	BOOST_ERROR("Not implemented");
 }
 

From 6552acdff61422757d1754867f30956e4cddef92 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sat, 15 Aug 2015 21:46:28 +0300
Subject: [PATCH 027/105] Check coastal tile OTF

---
 lib/CGameState.cpp              |  4 ++--
 lib/CPathfinder.cpp             |  2 +-
 lib/mapping/CMap.cpp            | 36 +++++++++++++++++++++++++++------
 lib/mapping/CMap.h              |  2 ++
 lib/mapping/CMapDefines.h       |  1 -
 lib/mapping/CMapEditManager.cpp |  1 -
 6 files changed, 35 insertions(+), 11 deletions(-)

diff --git a/lib/CGameState.cpp b/lib/CGameState.cpp
index 1bb5bb809..f4ed46441 100644
--- a/lib/CGameState.cpp
+++ b/lib/CGameState.cpp
@@ -736,7 +736,7 @@ BattleInfo * CGameState::setupBattle(int3 tile, const CArmedInstance *armies[2],
 {
 	const TerrainTile &t = map->getTile(tile);
 	ETerrainType terrain = t.terType;
-	if(t.isCoastal() && !t.isWater())
+	if(map->isCoastalTile(tile)) //coastal tile is always ground
 		terrain = ETerrainType::SAND;
 
 	BFieldType terType = battleGetBattlefieldType(tile);
@@ -1955,7 +1955,7 @@ BFieldType CGameState::battleGetBattlefieldType(int3 tile)
 		}
 	}
 
-	if(!t.isWater() && t.isCoastal())
+	if(map->isCoastalTile(tile)) //coastal tile is always ground
 		return BFieldType::SAND_SHORE;
 
 	switch(t.terType)
diff --git a/lib/CPathfinder.cpp b/lib/CPathfinder.cpp
index 8858fdc3a..b291eeb55 100644
--- a/lib/CPathfinder.cpp
+++ b/lib/CPathfinder.cpp
@@ -275,7 +275,7 @@ bool CPathfinder::isLayerTransitionPossible(const ELayer destLayer) const
 		break;
 
 	case ELayer::SAIL:
-		if(destLayer == ELayer::LAND && dt->isCoastal())
+		if(destLayer == ELayer::LAND && gs->map->isCoastalTile(dp->coord))
 			return true;
 
 		break;
diff --git a/lib/mapping/CMap.cpp b/lib/mapping/CMap.cpp
index ddc620332..820efbc57 100644
--- a/lib/mapping/CMap.cpp
+++ b/lib/mapping/CMap.cpp
@@ -141,11 +141,6 @@ CGObjectInstance * TerrainTile::topVisitableObj(bool excludeTop) const
 	return visitableObjects.back();
 }
 
-bool TerrainTile::isCoastal() const
-{
-	return extTileFlags & 64;
-}
-
 EDiggingStatus TerrainTile::getDiggingStatus(const bool excludeTop) const
 {
 	if(terType == ETerrainType::WATER || terType == ETerrainType::ROCK)
@@ -322,6 +317,35 @@ CGHeroInstance * CMap::getHero(int heroID)
 	return nullptr;
 }
 
+bool CMap::isCoastalTile(const int3 & pos) const
+{
+	//todo: refactoring: extract neighbor tile iterator and use it in GameState
+	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) };
+
+	if(!isInTheMap(pos))
+	{
+		logGlobal->errorStream() << "Coastal check outside of map :"<<pos;
+		return false;	
+	}
+
+	if(isWaterTile(pos))
+		return false;
+
+	for (auto & dir : dirs)
+	{
+		const int3 hlp = pos + dir;		
+		
+		if(!isInTheMap(hlp))
+			continue;
+		const TerrainTile &hlpt = getTile(hlp);
+		if(hlpt.isWater())
+			return true;		
+	}	
+
+	return false;
+}
+
 bool CMap::isInTheMap(const int3 & pos) const
 {
 	if(pos.x < 0 || pos.y < 0 || pos.z < 0 || pos.x >= width || pos.y >= height
@@ -349,7 +373,7 @@ const TerrainTile & CMap::getTile(const int3 & tile) const
 
 bool CMap::isWaterTile(const int3 &pos) const
 {
-	return isInTheMap(pos) && getTile(pos).terType == ETerrainType::WATER;
+	return isInTheMap(pos) && getTile(pos).isWater();
 }
 
 bool CMap::checkForVisitableDir(const int3 & src, const TerrainTile *pom, const int3 & dst ) const
diff --git a/lib/mapping/CMap.h b/lib/mapping/CMap.h
index 8fea38cf3..76deaaed9 100644
--- a/lib/mapping/CMap.h
+++ b/lib/mapping/CMap.h
@@ -277,8 +277,10 @@ public:
 	CMapEditManager * getEditManager();
 	TerrainTile & getTile(const int3 & tile);
 	const TerrainTile & getTile(const int3 & tile) const;
+	bool isCoastalTile(const int3 & pos) const;
 	bool isInTheMap(const int3 & pos) const;
 	bool isWaterTile(const int3 & pos) const;
+
 	bool checkForVisitableDir( const int3 & src, const TerrainTile *pom, const int3 & dst ) const;
 	int3 guardingCreaturePosition (int3 pos) const;
 
diff --git a/lib/mapping/CMapDefines.h b/lib/mapping/CMapDefines.h
index 77f9bf0be..d7a35c253 100644
--- a/lib/mapping/CMapDefines.h
+++ b/lib/mapping/CMapDefines.h
@@ -70,7 +70,6 @@ struct DLL_LINKAGE TerrainTile
 	Obj topVisitableId(bool excludeTop = false) const;
 	CGObjectInstance * topVisitableObj(bool excludeTop = false) const;
 	bool isWater() const;
-	bool isCoastal() const;
 	EDiggingStatus getDiggingStatus(const bool excludeTop = true) const;
 	bool hasFavourableWinds() const;
 
diff --git a/lib/mapping/CMapEditManager.cpp b/lib/mapping/CMapEditManager.cpp
index 8f5648c83..cdec9d2f1 100644
--- a/lib/mapping/CMapEditManager.cpp
+++ b/lib/mapping/CMapEditManager.cpp
@@ -478,7 +478,6 @@ void CDrawTerrainOperation::execute()
 
 	updateTerrainTypes();
 	updateTerrainViews();
-	//TODO add coastal bit to extTileFlags appropriately
 }
 
 void CDrawTerrainOperation::undo()

From b828f8fa9be24947e8c504920f38a75e9421c090 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sun, 16 Aug 2015 01:29:21 +0300
Subject: [PATCH 028/105] Added checks fro terrain

---
 test/MapComparer.cpp | 37 ++++++++++++++++++++++++++++++-------
 vcmi.workspace       |  4 ++--
 2 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 6afb570b2..9e287cc46 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -17,7 +17,8 @@
 
 #define VCMI_CHECK_FIELD_EQUAL(field) BOOST_CHECK_EQUAL(actual.field, expected.field)
 
-#define VCMI_REQUIRE_FIELD_EQUAL(field) BOOST_REQUIRE_EQUAL(actual->field, expected->field)
+#define VCMI_REQUIRE_FIELD_EQUAL_P(field) BOOST_REQUIRE_EQUAL(actual->field, expected->field)
+#define VCMI_REQUIRE_FIELD_EQUAL(field) BOOST_REQUIRE_EQUAL(actual.field, expected.field)
 
 template <class T>
 void checkEqual(const T & actual, const T & expected)
@@ -88,12 +89,24 @@ void checkEqual(const TriggeredEvent & actual,  const TriggeredEvent & expected)
 	checkEqual(actual.trigger, expected.trigger);	
 }
 
+void checkEqual(const TerrainTile & actual, const TerrainTile & expected)
+{
+	//fatal fail here on any error
+	VCMI_REQUIRE_FIELD_EQUAL(terType);
+	VCMI_REQUIRE_FIELD_EQUAL(terView);
+	VCMI_REQUIRE_FIELD_EQUAL(riverType);
+	VCMI_REQUIRE_FIELD_EQUAL(riverDir);
+	VCMI_REQUIRE_FIELD_EQUAL(roadType);
+	VCMI_REQUIRE_FIELD_EQUAL(roadDir);
+	VCMI_REQUIRE_FIELD_EQUAL(extTileFlags);
+}
+
 void MapComparer::compareHeader()
 {
 	//map size parameters are vital for further checks 
-	VCMI_REQUIRE_FIELD_EQUAL(height);
-	VCMI_REQUIRE_FIELD_EQUAL(width);
-	VCMI_REQUIRE_FIELD_EQUAL(twoLevel);
+	VCMI_REQUIRE_FIELD_EQUAL_P(height);
+	VCMI_REQUIRE_FIELD_EQUAL_P(width);
+	VCMI_REQUIRE_FIELD_EQUAL_P(twoLevel);
 
 	VCMI_CHECK_FIELD_EQUAL_P(name);
 	VCMI_CHECK_FIELD_EQUAL_P(description);
@@ -121,17 +134,27 @@ void MapComparer::compareOptions()
 	//allowedArtifact
 	//allowedAbilities
 	
-	BOOST_ERROR("Not implemented");
+	BOOST_ERROR("Not implemented compareOptions()");
 }
 
 void MapComparer::compareObjects()
 {
-	BOOST_ERROR("Not implemented");
+	BOOST_ERROR("Not implemented compareObjects()");
 }
 
 void MapComparer::compareTerrain()
 {
-	BOOST_ERROR("Not implemented");
+	//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));
+		}
 }
 
 void MapComparer::compare()
diff --git a/vcmi.workspace b/vcmi.workspace
index 674989792..029cea45f 100644
--- a/vcmi.workspace
+++ b/vcmi.workspace
@@ -27,13 +27,13 @@
 			<Depends filename="lib/VCMI_lib.cbp" />
 		</Project>
 		<Project filename="test/Test.cbp">
+			<Depends filename="lib/VCMI_lib.cbp" />
+			<Depends filename="client/VCMI_client.cbp" />
 			<Depends filename="server/VCMI_server.cbp" />
 			<Depends filename="AI/EmptyAI/EmptyAI.cbp" />
 			<Depends filename="AI/VCAI/VCAI.cbp" />
 			<Depends filename="AI/StupidAI/StupidAI.cbp" />
 			<Depends filename="AI/BattleAI/BattleAI.cbp" />
-			<Depends filename="lib/VCMI_lib.cbp" />
-			<Depends filename="client/VCMI_client.cbp" />
 		</Project>
 		<Project filename="scripting/erm/ERM.cbp">
 			<Depends filename="lib/VCMI_lib.cbp" />

From 3d63a97cf9a29f7c832ce14f21f7eaf854412304 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Sun, 16 Aug 2015 01:46:58 +0300
Subject: [PATCH 029/105] Fix TriggeredEvent check

---
 test/MapComparer.cpp | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 9e287cc46..9d0f21048 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -121,8 +121,19 @@ void MapComparer::compareHeader()
 	checkEqual(actual->players, expected->players);	
 	
 	//todo: allowedHeroes, placeholdedHeroes
-
-	checkEqual(actual->triggeredEvents, expected->triggeredEvents);	
+	
+	
+	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);	
 }
 
 void MapComparer::compareOptions()

From 3af255d1b9f07370f276697ada95b0865024b381 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Tue, 18 Aug 2015 01:56:16 +0300
Subject: [PATCH 030/105] Implemented terrain serialisation * with test

---
 lib/filesystem/CZipSaver.cpp         |  42 ++--
 lib/filesystem/MinizipExtensions.cpp |   2 +-
 lib/mapping/MapFormatJson.cpp        | 285 ++++++++++++++++++++++++---
 lib/mapping/MapFormatJson.h          |  24 ++-
 test/CMapFormatTest.cpp              |   9 +-
 5 files changed, 321 insertions(+), 41 deletions(-)

diff --git a/lib/filesystem/CZipSaver.cpp b/lib/filesystem/CZipSaver.cpp
index 41a6bbf4e..3475f9b7f 100644
--- a/lib/filesystem/CZipSaver.cpp
+++ b/lib/filesystem/CZipSaver.cpp
@@ -32,16 +32,27 @@ CZipOutputStream::CZipOutputStream(CZipSaver * owner_, zipFile archive, const st
 	fileInfo.external_fa = 0; //??? 
 	fileInfo.internal_fa = 0;	
 	
-	int status = zipOpenNewFileInZip(handle,
-                       archiveFilename.c_str(),
-                       &fileInfo,
-                       nullptr,
-                       0,
-                       nullptr,
-                       0,
-                       nullptr,
-                       Z_DEFLATED,
-                       Z_DEFAULT_COMPRESSION);
+	int status = zipOpenNewFileInZip4_64(
+						handle,
+						archiveFilename.c_str(),
+						&fileInfo,
+						nullptr,//extrafield_local
+						0,
+						nullptr,//extrafield_global
+						0,
+						nullptr,//comment
+						Z_DEFLATED,
+						Z_DEFAULT_COMPRESSION,
+						0,//raw
+						-15,//windowBits
+						9,//memLevel
+						Z_DEFAULT_STRATEGY,//strategy
+						nullptr,//password
+						0,//crcForCrypting
+						20,//versionMadeBy
+						0,//flagBase
+						0//zip64
+						);
     
     if(status != ZIP_OK)
 		throw new std::runtime_error("CZipOutputStream: zipOpenNewFileInZip failed");
@@ -51,7 +62,9 @@ CZipOutputStream::CZipOutputStream(CZipSaver * owner_, zipFile archive, const st
 
 CZipOutputStream::~CZipOutputStream()
 {
-	zipCloseFileInZip(handle);
+	int status = zipCloseFileInZip(handle);
+	if (status != ZIP_OK)
+		logGlobal->errorStream() << "CZipOutputStream: stream finalize failed: "<<status;
 	owner->activeStream = nullptr;
 }
 
@@ -88,7 +101,12 @@ CZipSaver::~CZipSaver()
 		
 	
 	if(handle != nullptr)
-		zipClose(handle, nullptr);
+	{
+		int status = zipClose(handle, nullptr);
+		if (status != ZIP_OK)
+			logGlobal->errorStream() << "CZipSaver: archive finalize failed: "<<status;		
+	}
+		
 }
 
 std::unique_ptr<COutputStream> CZipSaver::addFile(const std::string & archiveFilename)
diff --git a/lib/filesystem/MinizipExtensions.cpp b/lib/filesystem/MinizipExtensions.cpp
index 5810babe9..d4c694fe7 100644
--- a/lib/filesystem/MinizipExtensions.cpp
+++ b/lib/filesystem/MinizipExtensions.cpp
@@ -165,7 +165,7 @@ CInputOutputStream * CProxyIOApi::openFile(const std::string& filename, int mode
 	logGlobal->traceStream() << "CProxyIOApi: stream opened for " <<filename<<" with mode "<<mode; 
 	
 	data->seek(0);
-	return data;//todo: check that only one "copy" is opened
+	return data;
 }
 
 void CProxyIOApi::closeFile(CInputOutputStream * stream) const
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 0419462ad..7523efce2 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -17,6 +17,8 @@
 #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",
@@ -82,6 +84,30 @@ static JsonNode ConditionToJson(const EventCondition& event)
 	return std::move(json);
 }
 
+}//namespace TriggeredEventsDetail
+
+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 = 
+	{
+		"", "pd", "pg", "pc"
+	};
+	
+	static const std::array<std::string, 5> riverCodes = 
+	{
+		"", "rw", "ri", "rm", "rl"
+	};
+	
+	static const std::array<char, 10> flipCodes = 
+	{
+		'_', '-', '|', '+'
+	};	
+ 
+}
+
 ///CMapFormatJson
 const int CMapFormatJson::VERSION_MAJOR = 1;
 const int CMapFormatJson::VERSION_MINOR = 0;
@@ -109,6 +135,8 @@ void CMapFormatJson::readTriggeredEvents(const JsonNode & input)
 
 void CMapFormatJson::readTriggeredEvent(TriggeredEvent & event, const JsonNode & source)
 {
+	using namespace TriggeredEventsDetail;
+
 	event.onFulfill = source["message"].String();
 	event.description = source["description"].String();
 	event.effect.type = vstd::find_pos(typeNames, source["effect"]["type"].String());
@@ -132,6 +160,8 @@ void CMapFormatJson::writeTriggeredEvents(JsonNode& output)
 
 void CMapFormatJson::writeTriggeredEvent(const TriggeredEvent& event, JsonNode& dest)
 {
+	using namespace TriggeredEventsDetail;
+
 	dest["message"].String() = event.onFulfill;
 	dest["description"].String() = event.description;
 	
@@ -194,24 +224,33 @@ std::unique_ptr<CMapHeader> CMapLoaderJson::loadMapHeader()
 	return std::move(mapHeader);
 }
 
+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);
+}
+
+
 void CMapLoaderJson::readMap()
 {
 	readHeader();
 	map->initTerrain();
+	readTerrain();
 	//TODO:readMap
 }
 
 void CMapLoaderJson::readHeader()
 {
 	//do not use map field here, use only mapHeader
-	ResourceID headerID(HEADER_FILE_NAME, EResType::TEXT);
-
-	if(!loader.existsResource(headerID))
-		throw new std::runtime_error(HEADER_FILE_NAME+" not found");
-
-	auto headerData = loader.load(headerID)->readAll();
-
-	const JsonNode header(reinterpret_cast<char*>(headerData.first.get()), headerData.second);
+	const JsonNode header = readJson(HEADER_FILE_NAME);
 
 	//TODO: read such data like map name & size
 	//mapHeader->version = ??? //todo: new version field
@@ -255,6 +294,146 @@ void CMapLoaderJson::readPlayerInfo()
 	//TODO: readPlayerInfo
 }
 
+void CMapLoaderJson::readTerrainTile(const std::string& src, TerrainTile& tile)
+{
+	using namespace TerrainDetail;
+	{//terrain type
+		const std::string typeCode = src.substr(0,2);
+
+		int rawType = vstd::find_pos(terrainCodes, typeCode);
+
+		if(rawType < 0)
+			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;			
+		while(isdigit(src.at(pos)))
+			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;		
+	}
+	{//terrain flip
+		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;		
+	}	
+	if(startPos >= src.size())
+		return;
+	bool hasRoad = true;
+	{//road type
+		const std::string typeCode = src.substr(startPos,2);
+		startPos+=2;
+		int rawType = vstd::find_pos(roadCodes, typeCode);
+		if(rawType < 0)
+		{
+			rawType = vstd::find_pos(riverCodes, typeCode);
+			if(rawType < 0)
+				throw new std::runtime_error("Invalid river type in "+src);
+			else
+			{
+				tile.riverType = ERiverType::ERiverType(rawType);
+				hasRoad = false;
+			}				
+		}			
+		else	
+			tile.roadType = ERoadType::ERoadType(rawType);			
+	}
+	if(hasRoad)
+	{//road dir
+		int pos = startPos;
+		while(isdigit(src.at(pos)))
+			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;		
+	}
+	if(hasRoad)
+	{//road 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<<4);		
+	}
+	if(startPos >= src.size())
+		return;	
+	if(hasRoad)
+	{//river type
+		const std::string typeCode = src.substr(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);					
+	}
+	{//river dir
+		int pos = startPos;
+		while(isdigit(src.at(pos)))
+			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;		
+	}
+	{//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);		
+	}	
+}
+
+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");		
+		
+		for(pos.x = 0; pos.x < map->width; pos.x++)
+			readTerrainTile(tiles[pos.x].String(), map->getTile(pos));
+	}	
+}
+
+
+void CMapLoaderJson::readTerrain()
+{
+	{
+		const JsonNode surface = readJson("surface.json");
+		readTerrainLevel(surface, 0);		
+	}
+	if(map->twoLevel)
+	{
+		const JsonNode underground = readJson("underground.json");
+		readTerrainLevel(underground, 1);			
+	}
+		
+}
+
 ///CMapSaverJson
 CMapSaverJson::CMapSaverJson(CInputOutputStream * stream):
 	CMapFormatZip(stream),
@@ -268,15 +447,30 @@ CMapSaverJson::~CMapSaverJson()
 	
 }
 
+void CMapSaverJson::addToArchive(const JsonNode& data, const std::string& filename)
+{
+	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();
-	saveHeader();	
-	
+	writeHeader();	
+	writeTerrain();
 }
 
-void CMapSaverJson::saveHeader()
+void CMapSaverJson::writeHeader()
 {
 	JsonNode header;
 	header["versionMajor"].Float() = VERSION_MAJOR;
@@ -319,15 +513,62 @@ void CMapSaverJson::saveHeader()
 	//todo:	allowedHeroes;
 	//todo: placeholdedHeroes;	
 	
-	std::ostringstream out;
-	out << header;
-	out.flush();
-	
-	{
-		auto s = out.str();
-		std::unique_ptr<COutputStream> stream = saver.addFile(HEADER_FILE_NAME);
-		
-		if (stream->write((const ui8*)s.c_str(), s.size()) != s.size())
-			throw new std::runtime_error("CMapSaverJson::saveHeader() zip compression failed.");
-	}	
+	addToArchive(header, HEADER_FILE_NAME);
+}
+
+const std::string CMapSaverJson::writeTerrainTile(const TerrainTile & tile)
+{
+	using namespace TerrainDetail;
+
+	std::ostringstream out;
+	out.setf(std::ios::dec, std::ios::basefield);
+	out.unsetf(std::ios::showbase);
+
+	out << terrainCodes.at(int(tile.terType)) << (int)tile.terView << flipCodes[tile.extTileFlags % 4];
+
+	if(tile.roadType != ERoadType::NO_ROAD)
+	{
+		out << roadCodes.at(int(tile.roadType)) << (int)tile.roadDir << flipCodes[(tile.extTileFlags >> 4) % 4];
+	}
+
+	if(tile.riverType != ERiverType::NO_RIVER)
+	{
+		out << riverCodes.at(int(tile.riverType)) << (int)tile.riverDir << flipCodes[(tile.extTileFlags >> 2) % 4];
+	}
+
+	return out.str();
+}
+
+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	
+	
+	JsonNode surface = writeTerrainLevel(0);
+	addToArchive(surface, "surface.json");
+	
+	if(map->twoLevel)
+	{
+		JsonNode underground = writeTerrainLevel(1);
+		addToArchive(underground, "underground.json");		
+	}
 }
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 63d8a591a..2107723ca 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -17,7 +17,7 @@
 #include "../filesystem/CZipLoader.h"
 
 class TriggeredEvent;
-
+struct TerrainTile;
 
 class DLL_LINKAGE CMapFormatJson
 {
@@ -135,6 +135,14 @@ private:
 	 */
 	void readPlayerInfo();
 	
+	void readTerrainTile(const std::string & src, TerrainTile & tile);
+	
+	void readTerrainLevel(const JsonNode & src, const int index);	
+	
+	void readTerrain();
+	
+	const JsonNode readJson(const std::string & archiveFilename);
+	
 	CZipLoader loader;
 };
 
@@ -156,7 +164,19 @@ public:
 	 */	
 	void saveMap(const std::unique_ptr<CMap> & map) override;	
 private:
-	void saveHeader();
+	/**
+	 * Save @data as json file with specified @filename
+	 *
+	 */		
+	void addToArchive(const JsonNode & data, const std::string & filename);
+	
+	void writeHeader();
+	
+	const std::string writeTerrainTile(const TerrainTile & tile);
+	
+	JsonNode writeTerrainLevel(const int index);
+		
+	void writeTerrain();
 		
 	CZipSaver saver;	
 };
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index 758812635..6aa901bff 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -35,9 +35,9 @@ public:
 	{
 		CMapGenOptions opt;
 		
-		opt.setHeight(72);
-		opt.setWidth(72);
-		opt.setHasTwoLevels(false);
+		opt.setHeight(CMapHeader::MAP_SIZE_SMALL);
+		opt.setWidth(CMapHeader::MAP_SIZE_SMALL);
+		opt.setHasTwoLevels(true);
 		opt.setPlayerCount(2);
 		
 		CMapGenerator gen;
@@ -66,7 +66,8 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 	{
 		auto path = VCMIDirs::get().userDataPath()/"temp.zip";
 		boost::filesystem::remove(path);
-		boost::filesystem::ofstream tmp(path);
+		boost::filesystem::ofstream tmp(path, boost::filesystem::ofstream::binary);
+
 		tmp.write((const char *)serializeBuffer.getBuffer().data(),serializeBuffer.getSize());
 		tmp.flush();
 		tmp.close();

From f5b348a1d1f5694dab4c7e8fcf99606f6327818a Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Tue, 18 Aug 2015 02:21:35 +0300
Subject: [PATCH 031/105] Formatting

---
 lib/mapping/MapFormatJson.cpp | 338 +++++++++++++++++-----------------
 test/CMapFormatTest.cpp       |  18 +-
 test/MapComparer.cpp          |  48 ++---
 3 files changed, 202 insertions(+), 202 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 7523efce2..80b5a58e9 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/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");
 	}
 }
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index 6aa901bff..c8105de25 100644
--- a/test/CMapFormatTest.cpp
+++ b/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);
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 9d0f21048..511c773bc 100644
--- a/test/MapComparer.cpp
+++ b/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));
 		}
 }

From 7c8d29b871e7a0f47d288b05abee18264733951b Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Wed, 19 Aug 2015 21:02:30 +0300
Subject: [PATCH 032/105] Start implementing player info serialization

---
 lib/mapping/MapFormatJson.cpp | 22 +++++++++++++++++++++-
 lib/mapping/MapFormatJson.h   | 13 ++++++++++++-
 2 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 80b5a58e9..7ebdf6c3c 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -16,6 +16,7 @@
 #include "CMap.h"
 #include "../CModHandler.h"
 #include "../VCMI_Lib.h"
+#include "../StringConstants.h"
 
 namespace TriggeredEventsDetail
 {
@@ -508,7 +509,7 @@ void CMapSaverJson::writeHeader()
 
 	writeTriggeredEvents(header);
 
-	//todo: player info
+	writePlayerInfo(header);
 
 	//todo:	allowedHeroes;
 	//todo: placeholdedHeroes;
@@ -516,6 +517,25 @@ void CMapSaverJson::writeHeader()
 	addToArchive(header, HEADER_FILE_NAME);
 }
 
+void CMapSaverJson::writePlayerInfo(JsonNode & output)
+{
+	JsonNode & dest = output["players"];
+	dest.setType(JsonNode::DATA_STRUCT);
+	
+	for(int player = 0; player < PlayerColor::PLAYER_LIMIT_I; player++)
+	{
+		const PlayerInfo & info = map->players[player];
+		
+		if(info.canAnyonePlay())
+			writePlayerInfo(info, dest[GameConstants::PLAYER_COLOR_NAMES[player]);
+	}
+}
+
+void CMapSaverJson::writePlayerInfo(const PlayerInfo & info, JsonNode & output)
+{
+	
+}
+
 const std::string CMapSaverJson::writeTerrainTile(const TerrainTile & tile)
 {
 	using namespace TerrainDetail;
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 2107723ca..5d045bcd5 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -171,7 +171,18 @@ private:
 	void addToArchive(const JsonNode & data, const std::string & filename);
 	
 	void writeHeader();
-	
+
+	/**
+	 * Save all players info to header
+	 * @param output serialized header	 
+	 */	
+	void writePlayerInfo(JsonNode & output);
+	/**
+	 * Save one player info
+	 * @param output empty object	 
+	 */	
+	void writePlayerInfo(const PlayerInfo & info, JsonNode & output);	
+
 	const std::string writeTerrainTile(const TerrainTile & tile);
 	
 	JsonNode writeTerrainLevel(const int index);

From 2f67e015e18f581431f35530bb5ddb4c61cc4520 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Thu, 20 Aug 2015 06:16:31 +0300
Subject: [PATCH 033/105] Fix build

---
 lib/mapping/MapFormatJson.cpp | 10 +++++-----
 lib/mapping/MapFormatJson.h   |  1 +
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 7ebdf6c3c..1797f40d4 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -424,12 +424,12 @@ void CMapLoaderJson::readTerrainLevel(const JsonNode& src, const int index)
 void CMapLoaderJson::readTerrain()
 {
 	{
-		const JsonNode surface = readJson("surface.json");
+		const JsonNode surface = readJson("surface_terrain.json");
 		readTerrainLevel(surface, 0);
 	}
 	if(map->twoLevel)
 	{
-		const JsonNode underground = readJson("underground.json");
+		const JsonNode underground = readJson("underground_terrain.json");
 		readTerrainLevel(underground, 1);
 	}
 
@@ -527,7 +527,7 @@ void CMapSaverJson::writePlayerInfo(JsonNode & output)
 		const PlayerInfo & info = map->players[player];
 		
 		if(info.canAnyonePlay())
-			writePlayerInfo(info, dest[GameConstants::PLAYER_COLOR_NAMES[player]);
+			writePlayerInfo(info, dest[GameConstants::PLAYER_COLOR_NAMES[player]]);
 	}
 }
 
@@ -584,11 +584,11 @@ void CMapSaverJson::writeTerrain()
 	//todo: multilevel map save support
 
 	JsonNode surface = writeTerrainLevel(0);
-	addToArchive(surface, "surface.json");
+	addToArchive(surface, "surface_terrain.json");
 
 	if(map->twoLevel)
 	{
 		JsonNode underground = writeTerrainLevel(1);
-		addToArchive(underground, "underground.json");
+		addToArchive(underground, "underground_terrain.json");
 	}
 }
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 5d045bcd5..e41c1d2a5 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -18,6 +18,7 @@
 
 class TriggeredEvent;
 struct TerrainTile;
+struct PlayerInfo;
 
 class DLL_LINKAGE CMapFormatJson
 {

From 60825fbbd3b82614a11fb080ee05316da4634dcd Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@users.noreply.github.com>
Date: Mon, 24 Aug 2015 09:11:09 +0300
Subject: [PATCH 034/105] Start implementing PlayerInfo serialisation

---
 lib/mapping/MapFormatJson.cpp | 85 +++++++++++++++++++++++++++++++++--
 lib/mapping/MapFormatJson.h   | 11 ++++-
 2 files changed, 90 insertions(+), 6 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 1797f40d4..d27931555 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -210,6 +210,17 @@ CMapLoaderJson::CMapLoaderJson(CInputOutputStream * stream):
 
 }
 
+si32 CMapLoaderJson::getIdentifier(const std::string& type, const std::string& name)
+{
+	boost::optional<si32> res = VLC->modh->identifiers.getIdentifier("core", type, name, false);
+	
+	if(!res)
+	{
+		throw new std::runtime_error("Map load failed. Identifier not resolved.");
+	}
+	return res.get();
+}
+
 std::unique_ptr<CMap> CMapLoaderJson::loadMap()
 {
 	map = new CMap();
@@ -285,16 +296,61 @@ void CMapLoaderJson::readHeader()
 //	std::vector<ui16> placeholdedHeroes;
 
 	readTriggeredEvents(header);
-	readPlayerInfo();
+	readPlayerInfo(header);
 	//TODO: readHeader
 }
 
-void CMapLoaderJson::readPlayerInfo()
+void CMapLoaderJson::readPlayerInfo(const JsonNode & input)
 {
-	//ui8 howManyTeams;
-	//TODO: readPlayerInfo
+	const JsonNode & src = input["players"];
+	int howManyTeams = 0;
+
+	for(int player = 0; player < PlayerColor::PLAYER_LIMIT_I; player++)
+	{
+		PlayerInfo & info = map->players.at(player);
+
+		const JsonNode & playerSrc = src[GameConstants::PLAYER_COLOR_NAMES[player]];
+
+		if(playerSrc.isNull())
+		{
+			info.canComputerPlay = false;
+			info.canHumanPlay = false;
+		}
+		else
+		{
+			readPlayerInfo(info, playerSrc);
+			vstd::amax(howManyTeams, info.team.getNum()+1);
+		}
+	}
+	mapHeader->howManyTeams = howManyTeams;
 }
 
+void CMapLoaderJson::readPlayerInfo(PlayerInfo& info, const JsonNode& input)
+{
+	//allowed factions
+	
+	info.isFactionRandom = input["randomFaction"].Bool();
+	info.canComputerPlay = input["canComputerPlay"].Bool();	
+	info.canHumanPlay = input["canHumanPlay"].Bool();
+	
+	//plasedHeroes
+	
+	//mainTown
+	
+	info.generateHeroAtMainTown = input["generateHeroAtMainTown"].Bool();
+	
+	info.hasRandomHero = input["randomHero"].Bool();
+	
+	//mainHero
+	
+	//mainHeroPortrait
+	
+	info.mainCustomHeroName = input["mainHeroName"].String();
+	
+	info.team = TeamID(input["team"].Float());
+}
+
+
 void CMapLoaderJson::readTerrainTile(const std::string& src, TerrainTile& tile)
 {
 	using namespace TerrainDetail;
@@ -533,7 +589,28 @@ void CMapSaverJson::writePlayerInfo(JsonNode & output)
 
 void CMapSaverJson::writePlayerInfo(const PlayerInfo & info, JsonNode & output)
 {
+	//allowed factions
 	
+	output["randomFaction"].Bool() = info.isFactionRandom;
+	
+	output["canComputerPlay"].Bool() = info.canComputerPlay;
+	output["canHumanPlay"].Bool() = info.canHumanPlay;
+	
+	//plasedHeroes
+	
+	//mainTown
+	
+	output["generateHeroAtMainTown"].Bool() = info.generateHeroAtMainTown;
+	
+	output["randomHero"].Bool() = info.hasRandomHero;
+	
+	//mainHero
+	
+	//mainHeroPortrait
+	
+	output["mainHeroName"].String() =  info.mainCustomHeroName;
+	
+	output["team"].Float() = info.team.getNum();	
 }
 
 const std::string CMapSaverJson::writeTerrainTile(const TerrainTile & tile)
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index e41c1d2a5..2a7bcdd0b 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -120,7 +120,9 @@ public:
 	 */
 	std::unique_ptr<CMapHeader> loadMapHeader() override;
 
-private:
+private:	
+	si32 getIdentifier(const std::string & type, const std::string & name);
+	
 	/**
 	 * Reads complete map.
 	 */
@@ -134,7 +136,12 @@ private:
 	/**
 	 * Reads player information.
 	 */
-	void readPlayerInfo();
+	void readPlayerInfo(const JsonNode & input);
+	
+	/**
+	 * Reads one player information.
+	 */
+	void readPlayerInfo(PlayerInfo & info, const JsonNode & input);
 	
 	void readTerrainTile(const std::string & src, TerrainTile & tile);
 	

From 93c214d7a055f30a354e0a36053389ae7c50417b Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Wed, 26 Aug 2015 10:07:33 +0300
Subject: [PATCH 035/105] fix CMakeLists

---
 lib/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index f70513ad6..1dba1d0e6 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -17,6 +17,7 @@ set(lib_SRCS
 		filesystem/CBinaryReader.cpp
 		filesystem/CFileInputStream.cpp
 		filesystem/CZipLoader.cpp
+                filesystem/CZipSaver.cpp
 		filesystem/Filesystem.cpp
 		filesystem/ResourceID.cpp
                 filesystem/MinizipExtensions.cpp

From 6f203fb7e296c6b857097c551aee51d30d83bbd1 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 24 Aug 2015 11:55:45 +0300
Subject: [PATCH 036/105] Save string identifiers for all game objects

---
 lib/CArtHandler.cpp          | 12 ++++++------
 lib/CArtHandler.h            |  9 +++++++--
 lib/CCreatureHandler.cpp     | 15 ++++++++-------
 lib/CCreatureHandler.h       |  8 +++++++-
 lib/CHeroHandler.cpp         | 16 ++++++++--------
 lib/CHeroHandler.h           | 10 +++++++---
 lib/CTownHandler.cpp         |  2 +-
 lib/CTownHandler.h           |  2 +-
 lib/Connection.h             |  2 +-
 lib/IHandlerBase.h           |  6 +++---
 lib/spells/CSpellHandler.cpp |  2 +-
 lib/spells/CSpellHandler.h   |  4 ++--
 12 files changed, 52 insertions(+), 36 deletions(-)

diff --git a/lib/CArtHandler.cpp b/lib/CArtHandler.cpp
index ac4a310a9..4cc618023 100644
--- a/lib/CArtHandler.cpp
+++ b/lib/CArtHandler.cpp
@@ -201,28 +201,28 @@ std::vector<JsonNode> CArtHandler::loadLegacyData(size_t dataSize)
 
 void CArtHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
 {
-	auto object = loadFromJson(data);
+	auto object = loadFromJson(data, name);
 	object->id = ArtifactID(artifacts.size());
 	object->iconIndex = object->id + 5;
 
 	artifacts.push_back(object);
 
-	VLC->modh->identifiers.registerObject(scope, "artifact", name, object->id);
+	registerObject(scope, "artifact", object->identifier, object->id);
 }
 
 void CArtHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
 {
-	auto object = loadFromJson(data);
+	auto object = loadFromJson(data, name);
 	object->id = ArtifactID(index);
 	object->iconIndex = object->id;
 
 	assert(artifacts[index] == nullptr); // ensure that this id was not loaded before
 	artifacts[index] = object;
 
-	VLC->modh->identifiers.registerObject(scope, "artifact", name, object->id);
+	registerObject(scope, "artifact", object->identifier, object->id);
 }
 
-CArtifact * CArtHandler::loadFromJson(const JsonNode & node)
+CArtifact * CArtHandler::loadFromJson(const JsonNode & node, const std::string & identifier)
 {
 	CArtifact * art;
 
@@ -234,7 +234,7 @@ CArtifact * CArtHandler::loadFromJson(const JsonNode & node)
 		loadGrowingArt(growing, node);
 		art = growing;
 	}
-
+	art->identifier = identifier;
 	const JsonNode & text = node["text"];
 	art->name        = text["name"].String();
 	art->description = text["description"].String();
diff --git a/lib/CArtHandler.h b/lib/CArtHandler.h
index 5a6f4a841..f9d860a2c 100644
--- a/lib/CArtHandler.h
+++ b/lib/CArtHandler.h
@@ -48,7 +48,8 @@ protected:
 	std::string eventText; //short story displayed upon picking
 public:
 	enum EartClass {ART_SPECIAL=1, ART_TREASURE=2, ART_MINOR=4, ART_MAJOR=8, ART_RELIC=16}; //artifact classes
-
+	
+	std::string identifier;
 	std::string image;
 	std::string large; // big image for cutom artifacts, used in drag & drop
 	std::string advMapDef; //used for adventure map object
@@ -79,6 +80,10 @@ public:
 		h & static_cast<CBonusSystemNode&>(*this);
 		h & name & description & eventText & image & large & advMapDef & iconIndex &
 			price & possibleSlots & constituents & constituentOf & aClass & id;
+		if(version>=755)
+		{
+			h & identifier;
+		}
 	}
 
 	CArtifact();
@@ -244,7 +249,7 @@ public:
 	}
 
 private:
-	CArtifact * loadFromJson(const JsonNode & node);
+	CArtifact * loadFromJson(const JsonNode & node, const std::string & identifier);
 
 	void addSlot(CArtifact * art, const std::string & slotID);
 	void loadSlots(CArtifact * art, const JsonNode & node);
diff --git a/lib/CCreatureHandler.cpp b/lib/CCreatureHandler.cpp
index 2f30d3c48..a536b5f18 100644
--- a/lib/CCreatureHandler.cpp
+++ b/lib/CCreatureHandler.cpp
@@ -357,23 +357,23 @@ std::vector<JsonNode> CCreatureHandler::loadLegacyData(size_t dataSize)
 
 void CCreatureHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
 {
-	auto object = loadFromJson(data);
+	auto object = loadFromJson(data, name);
 	object->setId(CreatureID(creatures.size()));
 	object->iconIndex = object->idNumber + 2;
 
 	creatures.push_back(object);
 
-	VLC->modh->identifiers.registerObject(scope, "creature", name, object->idNumber);
+	registerObject(scope, "creature", name, object->idNumber);
 
 	for(auto node : data["extraNames"].Vector())
 	{
-		VLC->modh->identifiers.registerObject(scope, "creature", node.String(), object->idNumber);
+		registerObject(scope, "creature", node.String(), object->idNumber);
 	}
 }
 
 void CCreatureHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
 {
-	auto object = loadFromJson(data);
+	auto object = loadFromJson(data, name);
 	object->setId(CreatureID(index));
 	object->iconIndex = object->idNumber + 2;
 
@@ -385,10 +385,10 @@ void CCreatureHandler::loadObject(std::string scope, std::string name, const Jso
 	assert(creatures[index] == nullptr); // ensure that this id was not loaded before
 	creatures[index] = object;
 
-	VLC->modh->identifiers.registerObject(scope, "creature", name, object->idNumber);
+	registerObject(scope, "creature", name, object->idNumber);
 	for(auto & node : data["extraNames"].Vector())
 	{
-		VLC->modh->identifiers.registerObject(scope, "creature", node.String(), object->idNumber);
+		registerObject(scope, "creature", node.String(), object->idNumber);
 	}
 }
 
@@ -561,11 +561,12 @@ void CCreatureHandler::loadUnitAnimInfo(JsonNode & graphics, CLegacyConfigParser
 		graphics.Struct().erase("missile");
 }
 
-CCreature * CCreatureHandler::loadFromJson(const JsonNode & node)
+CCreature * CCreatureHandler::loadFromJson(const JsonNode & node, const std::string & identifier)
 {
 	auto  cre = new CCreature();
 
 	const JsonNode & name = node["name"];
+	cre->identifier = identifier;
 	cre->nameSing = name["singular"].String();
 	cre->namePl = name["plural"].String();
 
diff --git a/lib/CCreatureHandler.h b/lib/CCreatureHandler.h
index 12ba7e146..b78753f5d 100644
--- a/lib/CCreatureHandler.h
+++ b/lib/CCreatureHandler.h
@@ -26,6 +26,8 @@ class CCreature;
 class DLL_LINKAGE CCreature : public CBonusSystemNode
 {
 public:
+	std::string identifier;
+
 	std::string nameRef; // reference name, stringID
 	std::string nameSing;// singular name, e.g. Centaur
 	std::string namePl;  // plural name, e.g. Centaurs
@@ -136,6 +138,10 @@ public:
 		h & idNumber & faction & sounds & animation;
 
 		h & doubleWide & special;
+		if(version>=755)
+		{
+			h & identifier;
+		}		
 	}
 
 	CCreature();
@@ -148,7 +154,7 @@ private:
 	CBonusSystemNode creaturesOfLevel[GameConstants::CREATURES_PER_TOWN + 1];//index 0 is used for creatures of unknown tier or outside <1-7> range
 
 	/// load one creature from json config
-	CCreature * loadFromJson(const JsonNode & node);
+	CCreature * loadFromJson(const JsonNode & node, const std::string & identifier);
 
 	void loadJsonAnimation(CCreature * creature, const JsonNode & graphics);
 	void loadStackExperience(CCreature * creature, const JsonNode &input);
diff --git a/lib/CHeroHandler.cpp b/lib/CHeroHandler.cpp
index 25c43d4a4..5c5a73bf3 100644
--- a/lib/CHeroHandler.cpp
+++ b/lib/CHeroHandler.cpp
@@ -96,12 +96,12 @@ bool CObstacleInfo::isAppropriate(ETerrainType terrainType, int specialBattlefie
 	return vstd::contains(allowedTerrains, terrainType);
 }
 
-CHeroClass *CHeroClassHandler::loadFromJson(const JsonNode & node)
+CHeroClass * CHeroClassHandler::loadFromJson(const JsonNode & node, const std::string & identifier)
 {
 	std::string affinityStr[2] = { "might", "magic" };
 
 	auto  heroClass = new CHeroClass();
-
+	heroClass->identifier = identifier;
 	heroClass->imageBattleFemale = node["animation"]["battle"]["female"].String();
 	heroClass->imageBattleMale   = node["animation"]["battle"]["male"].String();
 	//MODS COMPATIBILITY FOR 0.96
@@ -192,7 +192,7 @@ std::vector<JsonNode> CHeroClassHandler::loadLegacyData(size_t dataSize)
 
 void CHeroClassHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
 {
-	auto object = loadFromJson(data);
+	auto object = loadFromJson(data, name);
 	object->id = heroClasses.size();
 
 	heroClasses.push_back(object);
@@ -210,7 +210,7 @@ void CHeroClassHandler::loadObject(std::string scope, std::string name, const Js
 
 void CHeroClassHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
 {
-	auto object = loadFromJson(data);
+	auto object = loadFromJson(data, name);
 	object->id = index;
 
 	assert(heroClasses[index] == nullptr); // ensure that this id was not loaded before
@@ -288,10 +288,10 @@ CHeroHandler::CHeroHandler()
 	loadExperience();
 }
 
-CHero * CHeroHandler::loadFromJson(const JsonNode & node)
+CHero * CHeroHandler::loadFromJson(const JsonNode & node, const std::string & identifier)
 {
 	auto  hero = new CHero;
-
+	hero->identifier = identifier;
 	hero->sex = node["female"].Bool();
 	hero->special = node["special"].Bool();
 
@@ -536,7 +536,7 @@ std::vector<JsonNode> CHeroHandler::loadLegacyData(size_t dataSize)
 
 void CHeroHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
 {
-	auto object = loadFromJson(data);
+	auto object = loadFromJson(data, name);
 	object->ID = HeroTypeID(heroes.size());
 	object->imageIndex = heroes.size() + 30; // 2 special frames + some extra portraits
 
@@ -547,7 +547,7 @@ void CHeroHandler::loadObject(std::string scope, std::string name, const JsonNod
 
 void CHeroHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
 {
-	auto object = loadFromJson(data);
+	auto object = loadFromJson(data, name);
 	object->ID = HeroTypeID(index);
 	object->imageIndex = index;
 
diff --git a/lib/CHeroHandler.h b/lib/CHeroHandler.h
index 6c87666d6..b0c22a4c6 100644
--- a/lib/CHeroHandler.h
+++ b/lib/CHeroHandler.h
@@ -59,7 +59,7 @@ public:
 			h & minAmount & maxAmount & creature;
 		}
 	};
-
+	std::string identifier;
 	HeroTypeID ID;
 	si32 imageIndex;
 
@@ -92,6 +92,10 @@ public:
 		h & ID & imageIndex & initialArmy & heroClass & secSkillsInit & spec & specialty & spells & haveSpellBook & sex & special;
 		h & name & biography & specName & specDescr & specTooltip;
 		h & iconSpecSmall & iconSpecLarge & portraitSmall & portraitLarge;
+		if(version>=755)
+		{
+			h & identifier;
+		}		
 	}
 };
 
@@ -169,7 +173,7 @@ struct DLL_LINKAGE CObstacleInfo
 
 class DLL_LINKAGE CHeroClassHandler : public IHandlerBase
 {
-	CHeroClass *loadFromJson(const JsonNode & node);
+	CHeroClass *loadFromJson(const JsonNode & node, const std::string & identifier);
 public:
 	std::vector< ConstTransitivePtr<CHeroClass> > heroClasses;
 
@@ -207,7 +211,7 @@ class DLL_LINKAGE CHeroHandler : public IHandlerBase
 	void loadObstacles();
 
 	/// Load single hero from json
-	CHero * loadFromJson(const JsonNode & node);
+	CHero * loadFromJson(const JsonNode & node, const std::string & identifier);
 
 public:
 	CHeroClassHandler classes;
diff --git a/lib/CTownHandler.cpp b/lib/CTownHandler.cpp
index 340deab4c..cbcda27c2 100644
--- a/lib/CTownHandler.cpp
+++ b/lib/CTownHandler.cpp
@@ -633,7 +633,7 @@ void CTownHandler::loadPuzzle(CFaction &faction, const JsonNode &source)
 	assert(faction.puzzleMap.size() == GameConstants::PUZZLE_MAP_PIECES);
 }
 
-CFaction * CTownHandler::loadFromJson(const JsonNode &source, std::string identifier)
+CFaction * CTownHandler::loadFromJson(const JsonNode &source, const std::string & identifier)
 {
 	auto  faction = new CFaction();
 
diff --git a/lib/CTownHandler.h b/lib/CTownHandler.h
index 8997b6712..e0a289b0b 100644
--- a/lib/CTownHandler.h
+++ b/lib/CTownHandler.h
@@ -250,7 +250,7 @@ class DLL_LINKAGE CTownHandler : public IHandlerBase
 
 	void loadPuzzle(CFaction & faction, const JsonNode & source);
 
-	CFaction * loadFromJson(const JsonNode & data, std::string identifier);
+	CFaction * loadFromJson(const JsonNode & data, const std::string & identifier);
 
 public:
 	std::vector<ConstTransitivePtr<CFaction> > factions;
diff --git a/lib/Connection.h b/lib/Connection.h
index 49acb9c14..07c724af1 100644
--- a/lib/Connection.h
+++ b/lib/Connection.h
@@ -27,7 +27,7 @@
 #include "mapping/CCampaignHandler.h" //for CCampaignState
 #include "rmg/CMapGenerator.h" // for CMapGenOptions
 
-const ui32 version = 754;
+const ui32 version = 755;
 const ui32 minSupportedVersion = 753;
 
 class CISer;
diff --git a/lib/IHandlerBase.h b/lib/IHandlerBase.h
index c26b6f944..eb5e68482 100644
--- a/lib/IHandlerBase.h
+++ b/lib/IHandlerBase.h
@@ -65,7 +65,7 @@ public:
 	void loadObject(std::string scope, std::string name, const JsonNode & data) override
 	{
 		auto type_name = getTypeName();
-		auto object = loadFromJson(data);
+		auto object = loadFromJson(data, name);
 		object->id = _ObjectID(objects.size());
 
 		objects.push_back(object);
@@ -75,7 +75,7 @@ public:
 	void loadObject(std::string scope, std::string name, const JsonNode & data, size_t index) override
 	{
 		auto type_name = getTypeName();
-		auto object = loadFromJson(data);
+		auto object = loadFromJson(data, name);
 		object->id = _ObjectID(index);
 
 
@@ -99,7 +99,7 @@ public:
 		return objects[raw_id];
 	}
 protected:
-	virtual _Object * loadFromJson(const JsonNode & json) = 0;
+	virtual _Object * loadFromJson(const JsonNode & json, const std::string & identifier) = 0;
 	virtual const std::string getTypeName() const = 0;
 public: //todo: make private
 	std::vector<ConstTransitivePtr<_Object>> objects;
diff --git a/lib/spells/CSpellHandler.cpp b/lib/spells/CSpellHandler.cpp
index 1beaac6e3..284be7d34 100644
--- a/lib/spells/CSpellHandler.cpp
+++ b/lib/spells/CSpellHandler.cpp
@@ -799,7 +799,7 @@ const std::string CSpellHandler::getTypeName() const
 	return "spell";
 }
 
-CSpell * CSpellHandler::loadFromJson(const JsonNode & json)
+CSpell * CSpellHandler::loadFromJson(const JsonNode & json, const std::string & identifier)
 {
 	using namespace SpellConfig;
 
diff --git a/lib/spells/CSpellHandler.h b/lib/spells/CSpellHandler.h
index 332b7396e..99fc28dda 100644
--- a/lib/spells/CSpellHandler.h
+++ b/lib/spells/CSpellHandler.h
@@ -172,7 +172,7 @@ public:
 	};
 
 	SpellID id;
-	std::string identifier; //???
+	std::string identifier;
 	std::string name;
 
 	si32 level;
@@ -366,5 +366,5 @@ public:
 	}
 
 protected:
-	CSpell * loadFromJson(const JsonNode & json) override;
+	CSpell * loadFromJson(const JsonNode & json, const std::string & identifier) override;
 };

From 8493d0cded58126335d48bb7834656843143faed Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Fri, 13 Nov 2015 04:01:14 +0300
Subject: [PATCH 037/105] Initial implementation of new team settings format

---
 lib/mapping/CMapService.h     |   2 +-
 lib/mapping/MapFormatJson.cpp | 135 +++++++++++++++++++++++++++-------
 lib/mapping/MapFormatJson.h   |   6 +-
 3 files changed, 113 insertions(+), 30 deletions(-)

diff --git a/lib/mapping/CMapService.h b/lib/mapping/CMapService.h
index 9ce4da6e4..caf9d3f75 100644
--- a/lib/mapping/CMapService.h
+++ b/lib/mapping/CMapService.h
@@ -145,6 +145,6 @@ public:
 	/**
 	 * Saves the VCMI/H3 map file.
 	 *
-	 */	
+	 */
 	 virtual void saveMap(const std::unique_ptr<CMap> & map) = 0;
 };
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index d27931555..a75324e4b 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -109,6 +109,14 @@ namespace TerrainDetail
 	};
 }
 
+namespace MapHeaderDetail
+{
+	static const std::array<std::string, PlayerColor::PLAYER_LIMIT_I>  playerColorNames =
+	{
+		"red", "blue", "tan", "green", "orange", "purple", "teal", "pink"
+	};
+}
+
 ///CMapFormatJson
 const int CMapFormatJson::VERSION_MAJOR = 1;
 const int CMapFormatJson::VERSION_MINOR = 0;
@@ -213,7 +221,7 @@ CMapLoaderJson::CMapLoaderJson(CInputOutputStream * stream):
 si32 CMapLoaderJson::getIdentifier(const std::string& type, const std::string& name)
 {
 	boost::optional<si32> res = VLC->modh->identifiers.getIdentifier("core", type, name, false);
-	
+
 	if(!res)
 	{
 		throw new std::runtime_error("Map load failed. Identifier not resolved.");
@@ -297,6 +305,7 @@ void CMapLoaderJson::readHeader()
 
 	readTriggeredEvents(header);
 	readPlayerInfo(header);
+	readTeams(header);
 	//TODO: readHeader
 }
 
@@ -319,7 +328,6 @@ void CMapLoaderJson::readPlayerInfo(const JsonNode & input)
 		else
 		{
 			readPlayerInfo(info, playerSrc);
-			vstd::amax(howManyTeams, info.team.getNum()+1);
 		}
 	}
 	mapHeader->howManyTeams = howManyTeams;
@@ -328,28 +336,63 @@ void CMapLoaderJson::readPlayerInfo(const JsonNode & input)
 void CMapLoaderJson::readPlayerInfo(PlayerInfo& info, const JsonNode& input)
 {
 	//allowed factions
-	
+
 	info.isFactionRandom = input["randomFaction"].Bool();
-	info.canComputerPlay = input["canComputerPlay"].Bool();	
+	info.canComputerPlay = input["canComputerPlay"].Bool();
 	info.canHumanPlay = input["canHumanPlay"].Bool();
-	
-	//plasedHeroes
-	
+
+	//placedHeroes
+
 	//mainTown
-	
+
 	info.generateHeroAtMainTown = input["generateHeroAtMainTown"].Bool();
-	
+
 	info.hasRandomHero = input["randomHero"].Bool();
-	
+
 	//mainHero
-	
+
 	//mainHeroPortrait
-	
+
 	info.mainCustomHeroName = input["mainHeroName"].String();
-	
-	info.team = TeamID(input["team"].Float());
 }
 
+void CMapLoaderJson::readTeams(const JsonNode& input)
+{
+	const JsonNode & src = input["teams"];
+
+    if(src.getType() != JsonNode::DATA_VECTOR)
+	{
+		// No alliances
+		if(src.getType() != JsonNode::DATA_NULL)
+			logGlobal->errorStream() << "Invalid teams field type";
+
+		mapHeader->howManyTeams = 0;
+		for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
+		{
+			if(mapHeader->players[i].canComputerPlay || mapHeader->players[i].canHumanPlay)
+			{
+				mapHeader->players[i].team = TeamID(mapHeader->howManyTeams++);
+			}
+		}
+	}
+	else
+	{
+		const JsonVector & srcVector = src.Vector();
+		mapHeader->howManyTeams = srcVector.size();
+
+		for(int team = 0; team < mapHeader->howManyTeams; team++)
+		{
+			for(const JsonNode & playerData : srcVector[team].Vector())
+			{
+				PlayerColor player = PlayerColor(vstd::find_pos(MapHeaderDetail::playerColorNames, playerData.String()));
+				if(player.isValidPlayer())
+				{
+					map->players[player.getNum()].team = TeamID(team);
+				}
+			}
+		}
+	}
+}
 
 void CMapLoaderJson::readTerrainTile(const std::string& src, TerrainTile& tile)
 {
@@ -476,7 +519,6 @@ void CMapLoaderJson::readTerrainLevel(const JsonNode& src, const int index)
 	}
 }
 
-
 void CMapLoaderJson::readTerrain()
 {
 	{
@@ -567,6 +609,8 @@ void CMapSaverJson::writeHeader()
 
 	writePlayerInfo(header);
 
+	writeTeams(header);
+
 	//todo:	allowedHeroes;
 	//todo: placeholdedHeroes;
 
@@ -577,11 +621,11 @@ void CMapSaverJson::writePlayerInfo(JsonNode & output)
 {
 	JsonNode & dest = output["players"];
 	dest.setType(JsonNode::DATA_STRUCT);
-	
+
 	for(int player = 0; player < PlayerColor::PLAYER_LIMIT_I; player++)
 	{
 		const PlayerInfo & info = map->players[player];
-		
+
 		if(info.canAnyonePlay())
 			writePlayerInfo(info, dest[GameConstants::PLAYER_COLOR_NAMES[player]]);
 	}
@@ -590,27 +634,62 @@ void CMapSaverJson::writePlayerInfo(JsonNode & output)
 void CMapSaverJson::writePlayerInfo(const PlayerInfo & info, JsonNode & output)
 {
 	//allowed factions
-	
+
 	output["randomFaction"].Bool() = info.isFactionRandom;
-	
+
 	output["canComputerPlay"].Bool() = info.canComputerPlay;
 	output["canHumanPlay"].Bool() = info.canHumanPlay;
-	
+
 	//plasedHeroes
-	
+
 	//mainTown
-	
+
 	output["generateHeroAtMainTown"].Bool() = info.generateHeroAtMainTown;
-	
+
 	output["randomHero"].Bool() = info.hasRandomHero;
-	
+
 	//mainHero
-	
+
 	//mainHeroPortrait
-	
+
 	output["mainHeroName"].String() =  info.mainCustomHeroName;
-	
-	output["team"].Float() = info.team.getNum();	
+}
+
+void CMapSaverJson::writeTeams(JsonNode& output)
+{
+	JsonNode & dest = output["teams"];
+	std::vector<std::set<PlayerColor>> teamsData;
+
+	teamsData.resize(map->howManyTeams);
+
+	//get raw data
+	for(int idx = 0; idx < map->players.size(); idx++)
+	{
+		const PlayerInfo & player = map->players.at(idx);
+		int team = player.team.getNum();
+		if(vstd::isbetween(team, 0, map->howManyTeams-1))
+			teamsData.at(team).insert(PlayerColor(idx));
+	}
+
+	//remove single-member teams
+	vstd::erase_if(teamsData, [](std::set<PlayerColor> & elem) -> bool
+	{
+		return elem.size() <= 1;
+	});
+
+	dest.setType(JsonNode::DATA_VECTOR);
+
+	for(const std::set<PlayerColor> & teamData : teamsData)
+	{
+		JsonNode team(JsonNode::DATA_VECTOR);
+		for(const PlayerColor & player : teamData)
+		{
+			JsonNode member(JsonNode::DATA_STRING);
+			member.String() = GameConstants::PLAYER_COLOR_NAMES[player.getNum()];
+			team.Vector().push_back(std::move(member));
+		}
+		dest.Vector().push_back(std::move(team));
+	}
 }
 
 const std::string CMapSaverJson::writeTerrainTile(const TerrainTile & tile)
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 2a7bcdd0b..ffaa15e07 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -143,6 +143,8 @@ private:
 	 */
 	void readPlayerInfo(PlayerInfo & info, const JsonNode & input);
 	
+	void readTeams(const JsonNode & input);
+	
 	void readTerrainTile(const std::string & src, TerrainTile & tile);
 	
 	void readTerrainLevel(const JsonNode & src, const int index);	
@@ -189,7 +191,9 @@ private:
 	 * Save one player info
 	 * @param output empty object	 
 	 */	
-	void writePlayerInfo(const PlayerInfo & info, JsonNode & output);	
+	void writePlayerInfo(const PlayerInfo & info, JsonNode & output);
+	
+	void writeTeams(JsonNode & output);	
 
 	const std::string writeTerrainTile(const TerrainTile & tile);
 	

From a5b72ce593186b611062a9fa9036334711b7b605 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Fri, 13 Nov 2015 13:08:25 +0300
Subject: [PATCH 038/105] Cleanup

---
 lib/mapping/CMap.cpp          | 12 +++++-----
 lib/mapping/CMap.h            |  2 +-
 lib/mapping/MapFormatJson.cpp | 45 +++++++++++++++++++----------------
 3 files changed, 31 insertions(+), 28 deletions(-)

diff --git a/lib/mapping/CMap.cpp b/lib/mapping/CMap.cpp
index 820efbc57..79ff1278a 100644
--- a/lib/mapping/CMap.cpp
+++ b/lib/mapping/CMap.cpp
@@ -19,7 +19,7 @@ SHeroName::SHeroName() : heroId(-1)
 
 PlayerInfo::PlayerInfo(): canHumanPlay(false), canComputerPlay(false),
 	aiTactic(EAiTactic::RANDOM), isFactionRandom(false), mainCustomHeroPortrait(-1), mainCustomHeroId(-1), hasMainTown(false),
-	generateHeroAtMainTown(false), team(255), hasRandomHero(false), /* following are unused */ generateHero(false), p7(0), powerPlaceholders(-1)
+	generateHeroAtMainTown(false), team(TeamID::NO_TEAM), hasRandomHero(false), /* following are unused */ generateHero(false), p7(0), powerPlaceholders(-1)
 {
 	allowedFactions = VLC->townh->getAllowedFactions();
 }
@@ -326,7 +326,7 @@ bool CMap::isCoastalTile(const int3 & pos) const
 	if(!isInTheMap(pos))
 	{
 		logGlobal->errorStream() << "Coastal check outside of map :"<<pos;
-		return false;	
+		return false;
 	}
 
 	if(isWaterTile(pos))
@@ -334,14 +334,14 @@ bool CMap::isCoastalTile(const int3 & pos) const
 
 	for (auto & dir : dirs)
 	{
-		const int3 hlp = pos + dir;		
-		
+		const int3 hlp = pos + dir;
+
 		if(!isInTheMap(hlp))
 			continue;
 		const TerrainTile &hlpt = getTile(hlp);
 		if(hlpt.isWater())
-			return true;		
-	}	
+			return true;
+	}
 
 	return false;
 }
diff --git a/lib/mapping/CMap.h b/lib/mapping/CMap.h
index 76deaaed9..7c88cf8fd 100644
--- a/lib/mapping/CMap.h
+++ b/lib/mapping/CMap.h
@@ -76,7 +76,7 @@ struct DLL_LINKAGE PlayerInfo
 	bool hasMainTown; /// The default value is false.
 	bool generateHeroAtMainTown; /// The default value is false.
 	int3 posOfMainTown;
-	TeamID team; /// The default value is 255 representing that the player belongs to no team.
+	TeamID team; /// The default value NO_TEAM
 	bool hasRandomHero; /// Player has a random hero
 
 	bool generateHero; /// Unused.
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index a75324e4b..729e6ad08 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -337,9 +337,10 @@ void CMapLoaderJson::readPlayerInfo(PlayerInfo& info, const JsonNode& input)
 {
 	//allowed factions
 
-	info.isFactionRandom = input["randomFaction"].Bool();
-	info.canComputerPlay = input["canComputerPlay"].Bool();
-	info.canHumanPlay = input["canHumanPlay"].Bool();
+//	info.isFactionRandom =
+
+	info.canComputerPlay = true;
+	info.canHumanPlay = input["canPlay"].String() != "AIOnly";
 
 	//placedHeroes
 
@@ -347,13 +348,11 @@ void CMapLoaderJson::readPlayerInfo(PlayerInfo& info, const JsonNode& input)
 
 	info.generateHeroAtMainTown = input["generateHeroAtMainTown"].Bool();
 
-	info.hasRandomHero = input["randomHero"].Bool();
-
 	//mainHero
 
 	//mainHeroPortrait
 
-	info.mainCustomHeroName = input["mainHeroName"].String();
+	//mainCustomHeroName
 }
 
 void CMapLoaderJson::readTeams(const JsonNode& input)
@@ -387,10 +386,20 @@ void CMapLoaderJson::readTeams(const JsonNode& input)
 				PlayerColor player = PlayerColor(vstd::find_pos(MapHeaderDetail::playerColorNames, playerData.String()));
 				if(player.isValidPlayer())
 				{
-					map->players[player.getNum()].team = TeamID(team);
+					if(map->players[player.getNum()].canAnyonePlay())
+					{
+						map->players[player.getNum()].team = TeamID(team);
+					}
 				}
 			}
 		}
+
+		for(PlayerInfo & player : map->players)
+		{
+			if(player.canAnyonePlay() && player.team == TeamID::NO_TEAM)
+				player.team = TeamID(mapHeader->howManyTeams++);
+		}
+
 	}
 }
 
@@ -635,24 +644,15 @@ void CMapSaverJson::writePlayerInfo(const PlayerInfo & info, JsonNode & output)
 {
 	//allowed factions
 
-	output["randomFaction"].Bool() = info.isFactionRandom;
-
-	output["canComputerPlay"].Bool() = info.canComputerPlay;
-	output["canHumanPlay"].Bool() = info.canHumanPlay;
-
-	//plasedHeroes
+	output["canPlay"].String() = info.canHumanPlay ? "PlayerOrAI" : "AIOnly";
 
 	//mainTown
-
 	output["generateHeroAtMainTown"].Bool() = info.generateHeroAtMainTown;
 
-	output["randomHero"].Bool() = info.hasRandomHero;
-
 	//mainHero
 
-	//mainHeroPortrait
-
-	output["mainHeroName"].String() =  info.mainCustomHeroName;
+	//towns
+	//heroes
 }
 
 void CMapSaverJson::writeTeams(JsonNode& output)
@@ -667,16 +667,19 @@ void CMapSaverJson::writeTeams(JsonNode& output)
 	{
 		const PlayerInfo & player = map->players.at(idx);
 		int team = player.team.getNum();
-		if(vstd::isbetween(team, 0, map->howManyTeams-1))
+		if(vstd::isbetween(team, 0, map->howManyTeams-1) && player.canAnyonePlay())
 			teamsData.at(team).insert(PlayerColor(idx));
 	}
-
+//just an optimization but breaks test
+#if 0
 	//remove single-member teams
 	vstd::erase_if(teamsData, [](std::set<PlayerColor> & elem) -> bool
 	{
 		return elem.size() <= 1;
 	});
+#endif
 
+	//construct output
 	dest.setType(JsonNode::DATA_VECTOR);
 
 	for(const std::set<PlayerColor> & teamData : teamsData)

From 9cc3dae5feff566b6f0337392476e767d8e48a08 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Fri, 13 Nov 2015 17:47:47 +0300
Subject: [PATCH 039/105] Started working on objects serialization

---
 lib/mapObjects/CObjectHandler.cpp |  57 +++++++++++
 lib/mapObjects/CObjectHandler.h   |  31 +++++-
 lib/mapObjects/ObjectTemplate.cpp |   6 ++
 lib/mapObjects/ObjectTemplate.h   |   1 +
 lib/mapping/MapFormatJson.cpp     |  92 +++++++++++++++++-
 lib/mapping/MapFormatJson.h       | 154 ++++++++++++++++++++----------
 test/CMapEditManagerTest.cpp      |  14 +--
 test/MapComparer.cpp              |  15 ++-
 test/MapComparer.h                |  15 +--
 9 files changed, 319 insertions(+), 66 deletions(-)

diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 88c7e6bd0..588113a67 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -136,6 +136,19 @@ CGObjectInstance::~CGObjectInstance()
 {
 }
 
+const std::string & CGObjectInstance::getStringId() const
+{
+	//todo: getStringId use real object type
+	if(stringId == "")
+	{
+		boost::format fmt("%s_%d");
+		fmt % "object" % id.getNum();
+		stringId = fmt.str();
+	}
+
+	return stringId;
+}
+
 void CGObjectInstance::setOwner(PlayerColor ow)
 {
 	tempOwner = ow;
@@ -311,6 +324,50 @@ bool CGObjectInstance::passableFor(PlayerColor color) const
 	return false;
 }
 
+void CGObjectInstance::writeJson(JsonNode & json, bool withState) const
+{
+	json.setType(JsonNode::DATA_STRUCT);
+
+	appearance.writeJson(json["template"]);
+	writeJsonOptions(json["options"]);
+	if(withState)
+		writeJsonState(json["state"]);
+}
+
+void CGObjectInstance::readJson(const JsonNode & json, bool withState)
+{
+	if(json.getType() != JsonNode::DATA_STRUCT)
+	{
+		logGlobal->error("Invalid object instance data");
+		return;
+	}
+	appearance.readJson(json["template"]);
+	readJsonOptions(json["options"]);
+	if(withState)
+		readJsonState(json["state"]);
+}
+
+void CGObjectInstance::writeJsonOptions(JsonNode & json) const
+{
+
+}
+
+void CGObjectInstance::readJsonOptions(const JsonNode & json)
+{
+
+}
+
+void CGObjectInstance::writeJsonState(JsonNode & json) const
+{
+
+}
+
+void CGObjectInstance::readJsonState(const JsonNode & json)
+{
+
+}
+
+
 CGObjectInstanceBySubIdFinder::CGObjectInstanceBySubIdFinder(CGObjectInstance * obj) : obj(obj)
 {
 
diff --git a/lib/mapObjects/CObjectHandler.h b/lib/mapObjects/CObjectHandler.h
index adc71b3d1..2a6d61c8f 100644
--- a/lib/mapObjects/CObjectHandler.h
+++ b/lib/mapObjects/CObjectHandler.h
@@ -35,7 +35,7 @@ public:
 	virtual void newTurn() const;
 	virtual void initObj(); //synchr
 	virtual void setProperty(ui8 what, ui32 val);//synchr
-	
+
 	//Called when queries created DURING HERO VISIT are resolved
 	//First parameter is always hero that visited object and triggered the query
 	virtual void battleFinished(const CGHeroInstance *hero, const BattleResult &result) const;
@@ -116,6 +116,8 @@ public:
 	CGObjectInstance();
 	~CGObjectInstance();
 
+	const std::string & getStringId() const;
+
 	/// "center" tile from which the sight distance is calculated
 	int3 getSightCenter() const;
 
@@ -164,17 +166,44 @@ public:
 
 	//friend class CGameHandler;
 
+	///Entry point of binary (de-)serialization
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
 		h & pos & ID & subID & id & tempOwner & blockVisit & appearance;
 		//definfo is handled by map serializer
 	}
+
+	///Entry point of Json serialization
+	void writeJson(JsonNode & json, bool withState = false) const;
+
+	///Entry point of Json de-serialization
+	void readJson(const JsonNode & json, bool withState = false);
+
 protected:
 	/// virtual method that allows synchronously update object state on server and all clients
 	virtual void setPropertyDer(ui8 what, ui32 val);
 
 	/// Gives dummy bonus from this object to hero. Can be used to track visited state
 	void giveDummyBonus(ObjectInstanceID heroID, ui8 duration = Bonus::ONE_DAY) const;
+
+	///Saves object-type specific options
+	///(!) do not forget to call inherited method first when overriding
+	virtual void writeJsonOptions(JsonNode & json) const;
+
+	///Loads object-type specific options
+	///(!) do not forget to call inherited method  first when overriding
+	virtual void readJsonOptions(const JsonNode & json);
+
+	///Saves object-type specific state
+	///(!) do not forget to call inherited method  first when overriding
+	virtual void writeJsonState(JsonNode & json) const;
+
+	///Loads object-type specific state
+	///(!) do not forget to call inherited method  first  when overriding
+	virtual void readJsonState(const JsonNode & json);
+
+private:
+	mutable std::string stringId;///<alternate id, dynamically generated, do not serialize
 };
 
 /// function object which can be used to find an object with an specific sub ID
diff --git a/lib/mapObjects/ObjectTemplate.cpp b/lib/mapObjects/ObjectTemplate.cpp
index ec8d9908c..b1696bf05 100644
--- a/lib/mapObjects/ObjectTemplate.cpp
+++ b/lib/mapObjects/ObjectTemplate.cpp
@@ -256,6 +256,12 @@ void ObjectTemplate::readJson(const JsonNode &node)
 		printPriority = 0; //default value
 }
 
+void ObjectTemplate::writeJson(JsonNode & node) const
+{
+	//todo: ObjectTemplate::writeJson
+}
+
+
 ui32 ObjectTemplate::getWidth() const
 {
 	return usedTiles.empty() ? 0 : usedTiles.front().size();
diff --git a/lib/mapObjects/ObjectTemplate.h b/lib/mapObjects/ObjectTemplate.h
index 8184efba1..0e175bd0f 100644
--- a/lib/mapObjects/ObjectTemplate.h
+++ b/lib/mapObjects/ObjectTemplate.h
@@ -74,6 +74,7 @@ public:
 	void readMsk();
 	void readMap(CBinaryReader & reader);
 	void readJson(const JsonNode & node);
+	void writeJson(JsonNode & node) const;
 
 	bool operator==(const ObjectTemplate& ot) const { return (id == ot.id && subid == ot.subid); }
 
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 729e6ad08..dab72dc90 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -16,6 +16,9 @@
 #include "CMap.h"
 #include "../CModHandler.h"
 #include "../VCMI_Lib.h"
+#include "../mapObjects/ObjectTemplate.h"
+#include "../mapObjects/CObjectHandler.h"
+#include "../mapObjects/CObjectClassesHandler.h"
 #include "../StringConstants.h"
 
 namespace TriggeredEventsDetail
@@ -117,11 +120,27 @@ namespace MapHeaderDetail
 	};
 }
 
+static std::string tailString(const std::string & input, char separator)
+{
+	std::string ret;
+	size_t splitPos = input.find(separator);
+	if (splitPos != std::string::npos)
+		ret = input.substr(splitPos + 1);
+	return ret;
+}
+
+static si32 extractNumber(const std::string & input, char separator)
+{
+	std::string tmp = tailString(input, separator);
+	return atoi(tmp.c_str());
+}
+
 ///CMapFormatJson
 const int CMapFormatJson::VERSION_MAJOR = 1;
 const int CMapFormatJson::VERSION_MINOR = 0;
 
 const std::string CMapFormatJson::HEADER_FILE_NAME = "header.json";
+const std::string CMapFormatJson::OBJECTS_FILE_NAME = "objects.json";
 
 void CMapFormatJson::readTriggeredEvents(const JsonNode & input)
 {
@@ -264,7 +283,7 @@ void CMapLoaderJson::readMap()
 	readHeader();
 	map->initTerrain();
 	readTerrain();
-	//TODO:readMap
+	readObjects();
 }
 
 void CMapLoaderJson::readHeader()
@@ -542,6 +561,65 @@ void CMapLoaderJson::readTerrain()
 
 }
 
+CMapLoaderJson::MapObjectLoader::MapObjectLoader(CMapLoaderJson * _owner, const JsonMap::value_type& json):
+	owner(_owner), instance(nullptr),handler(nullptr),id(-1), jsonKey(json.first), configuration(json.second), internalId(extractNumber(jsonKey, '_'))
+{
+
+}
+
+void CMapLoaderJson::MapObjectLoader::construct()
+{
+	//find type handler
+	std::string typeName = configuration["type"].String(), subTypeName = configuration["subType"].String();
+	if(typeName.empty())
+	{
+		logGlobal->errorStream() << "Object type missing";
+		return;
+	}
+	if(subTypeName.empty())
+	{
+		logGlobal->errorStream() << "Object subType missing";
+		return;
+	}
+
+	si32 type = owner->getIdentifier("object", typeName);
+
+//	VLC->objtypeh->getHandlerFor()
+//TODO:MapObjectLoader::construct()
+}
+
+void CMapLoaderJson::MapObjectLoader::configure()
+{
+//TODO:MapObjectLoader::configure()
+}
+
+void CMapLoaderJson::readObjects()
+{
+	LOG_TRACE(logGlobal);
+
+	std::vector<std::unique_ptr<MapObjectLoader>> loaders;//todo: optimize MapObjectLoader memory layout
+
+	const JsonNode data = readJson(OBJECTS_FILE_NAME);
+
+	//get raw data
+	for(const auto & p : data.Struct())
+		loaders.push_back(vstd::make_unique<MapObjectLoader>(this, p));
+
+	auto sortInfos = [](const std::unique_ptr<MapObjectLoader> & lhs, const std::unique_ptr<MapObjectLoader> & rhs) -> bool
+	{
+		return lhs->internalId < rhs->internalId;
+	};
+	boost::sort(loaders, sortInfos);//this makes instance ids consistent after save-load, needed for testing
+	//todo: use internalId in CMap
+
+	for(auto & ptr : loaders)
+		ptr->construct();
+
+	//configure objects after all objects are constructed so we may resolve internal IDs even to actual pointers OTF
+	for(auto & ptr : loaders)
+		ptr->configure();
+}
+
 ///CMapSaverJson
 CMapSaverJson::CMapSaverJson(CInputOutputStream * stream):
 	CMapFormatZip(stream),
@@ -576,6 +654,7 @@ void CMapSaverJson::saveMap(const std::unique_ptr<CMap>& map)
 	this->map = map.get();
 	writeHeader();
 	writeTerrain();
+	writeObjects();
 }
 
 void CMapSaverJson::writeHeader()
@@ -751,3 +830,14 @@ void CMapSaverJson::writeTerrain()
 		addToArchive(underground, "underground_terrain.json");
 	}
 }
+
+void CMapSaverJson::writeObjects()
+{
+	JsonNode data(JsonNode::DATA_STRUCT);
+
+	for(const CGObjectInstance * obj : map->objects)
+		obj->writeJson(data[obj->getStringId()], false);
+
+	addToArchive(data, OBJECTS_FILE_NAME);
+}
+
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index ffaa15e07..7b92594fe 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -15,21 +15,24 @@
 
 #include "../filesystem/CZipSaver.h"
 #include "../filesystem/CZipLoader.h"
+#include "../GameConstants.h"
 
 class TriggeredEvent;
 struct TerrainTile;
 struct PlayerInfo;
+class CGObjectInstance;
+class AObjectTypeHandler;
 
 class DLL_LINKAGE CMapFormatJson
 {
-public:	
+public:
 	static const int VERSION_MAJOR;
-	static const int VERSION_MINOR;	
-	
-	static const std::string HEADER_FILE_NAME;
+	static const int VERSION_MINOR;
 
+	static const std::string HEADER_FILE_NAME;
+	static const std::string OBJECTS_FILE_NAME;
 protected:
-	
+
 	/** ptr to the map object which gets filled by data from the buffer or written to buffer */
 	CMap * map;
 
@@ -37,8 +40,8 @@ protected:
 	 * ptr to the map header object which gets filled by data from the buffer.
 	 * (when loading map and mapHeader point to the same object)
 	 */
-	std::unique_ptr<CMapHeader> mapHeader;	
-	
+	std::unique_ptr<CMapHeader> mapHeader;
+
 	/**
 	 * Reads triggered events, including victory/loss conditions
 	 */
@@ -53,11 +56,11 @@ protected:
 	 * Reads one of triggered events
 	 */
 	void readTriggeredEvent(TriggeredEvent & event, const JsonNode & source);
-	
+
 	/**
 	 * Writes one of triggered events
 	 */
-	void writeTriggeredEvent(const TriggeredEvent & event, JsonNode & dest);			
+	void writeTriggeredEvent(const TriggeredEvent & event, JsonNode & dest);
 };
 
 class DLL_LINKAGE CMapPatcher : public CMapFormatJson, public IMapPatcher
@@ -69,14 +72,14 @@ public:
 	 * @param stream. A stream containing the map data.
 	 */
 	CMapPatcher(JsonNode stream);
-		
+
 public: //IMapPatcher
 	/**
 	 * Modifies supplied map header using Json data
 	 *
 	 */
 	void patchMapHeader(std::unique_ptr<CMapHeader> & header) override;
-	
+
 private:
 	/**
 	 * Reads subset of header that can be replaced by patching.
@@ -84,7 +87,7 @@ private:
 	void readPatchData();
 
 
-	const JsonNode input;	
+	const JsonNode input;
 };
 
 class DLL_LINKAGE CMapFormatZip : public CMapFormatJson
@@ -100,7 +103,7 @@ class DLL_LINKAGE CMapLoaderJson : public CMapFormatZip, public IMapLoader
 {
 public:
 	/**
-	 * Default constructor.
+	 * Constructor.
 	 *
 	 * @param stream a stream containing the map data
 	 */
@@ -120,9 +123,28 @@ public:
 	 */
 	std::unique_ptr<CMapHeader> loadMapHeader() override;
 
-private:	
+private:
+
+	struct MapObjectLoader
+	{
+		MapObjectLoader(CMapLoaderJson * _owner, const JsonMap::value_type & json);
+		CMapLoaderJson * owner;
+		CGObjectInstance * instance;
+		std::shared_ptr<AObjectTypeHandler> handler;
+		ObjectInstanceID id;
+		std::string jsonKey;//full id defined by map creator
+		const JsonNode & configuration;
+		si32 internalId;//unique part of id defined by map creator (also = quest identifier)
+		///constructs object (without configuration)
+		void construct();
+
+		///configures object
+		void configure();
+
+	};
+
 	si32 getIdentifier(const std::string & type, const std::string & name);
-	
+
 	/**
 	 * Reads complete map.
 	 */
@@ -137,69 +159,101 @@ private:
 	 * Reads player information.
 	 */
 	void readPlayerInfo(const JsonNode & input);
-	
+
 	/**
 	 * Reads one player information.
 	 */
 	void readPlayerInfo(PlayerInfo & info, const JsonNode & input);
-	
+
+	/**
+	 * Reads team settings to header
+	 * @param input serialized header
+	 */
 	void readTeams(const JsonNode & input);
-	
+
 	void readTerrainTile(const std::string & src, TerrainTile & tile);
-	
-	void readTerrainLevel(const JsonNode & src, const int index);	
-	
+
+	void readTerrainLevel(const JsonNode & src, const int index);
+
 	void readTerrain();
-	
+
+	/**
+	 * Loads all map objects from zip archive
+	 */
+	void readObjects();
+
 	const JsonNode readJson(const std::string & archiveFilename);
-	
-	CZipLoader loader;
+
+	CZipLoader loader;///< object to handle zip archive operations
 };
 
 class DLL_LINKAGE CMapSaverJson : public CMapFormatZip, public IMapSaver
 {
 public:
 	/**
-	 * Default constructor.
+	 * Constructor.
 	 *
-	 * @param stream a stream to save the map to
+	 * @param stream a stream to save the map to, will contain zip archive
 	 */
-	CMapSaverJson(CInputOutputStream * stream);	
-	
+	CMapSaverJson(CInputOutputStream * stream);
+
 	~CMapSaverJson();
-	
+
 	/**
 	 * Actually saves the VCMI/Json map into stream.
-	 *
-	 */	
-	void saveMap(const std::unique_ptr<CMap> & map) override;	
+	 */
+	void saveMap(const std::unique_ptr<CMap> & map) override;
 private:
+
 	/**
-	 * Save @data as json file with specified @filename
-	 *
-	 */		
+	 * Saves @data as json file with specified @filename
+	 */
 	void addToArchive(const JsonNode & data, const std::string & filename);
-	
+
+	/**
+	 * Saves header to zip archive
+	 */
 	void writeHeader();
 
 	/**
-	 * Save all players info to header
-	 * @param output serialized header	 
-	 */	
+	 * Saves all players info to header
+	 * @param output serialized header
+	 */
 	void writePlayerInfo(JsonNode & output);
-	/**
-	 * Save one player info
-	 * @param output empty object	 
-	 */	
-	void writePlayerInfo(const PlayerInfo & info, JsonNode & output);
-	
-	void writeTeams(JsonNode & output);	
 
+	/**
+	 * Saves one player info
+	 * @param output empty object
+	 */
+	void writePlayerInfo(const PlayerInfo & info, JsonNode & output);
+
+	/**
+	 * Saves team settings to header
+	 * @param output serialized header
+	 */
+	void writeTeams(JsonNode & output);
+
+	/**
+	 * Encodes one tile into string
+	 * @param tile tile to serialize
+	 */
 	const std::string writeTerrainTile(const TerrainTile & tile);
-	
+
+	/**
+	 * Saves map level into json
+	 * @param index z coordinate
+	 */
 	JsonNode writeTerrainLevel(const int index);
-		
+
+	/**
+	 * Saves all terrain into zip archive
+	 */
 	void writeTerrain();
-		
-	CZipSaver saver;	
+
+	/**
+	 * Saves all map objects into zip archive
+	 */
+	void writeObjects();
+
+	CZipSaver saver;///< object to handle zip archive operations
 };
diff --git a/test/CMapEditManagerTest.cpp b/test/CMapEditManagerTest.cpp
index c7a59fcad..5a045a811 100644
--- a/test/CMapEditManagerTest.cpp
+++ b/test/CMapEditManagerTest.cpp
@@ -83,8 +83,8 @@ BOOST_AUTO_TEST_CASE(CMapEditManager_DrawTerrain_Type)
 		BOOST_CHECK(map->getTile(int3(5, 6, 1)).terType == ETerrainType::ROCK || map->getTile(int3(7, 8, 1)).terType == ETerrainType::ROCK);
 
 		//todo: add checks here and enable, also use smaller size
-		#if 0 
-		
+		#if 0
+
 		// next check
 		auto map2 = make_unique<CMap>();
 		map2->width = 128;
@@ -105,15 +105,15 @@ BOOST_AUTO_TEST_CASE(CMapEditManager_DrawTerrain_Type)
 	}
 	catch(const std::exception & e)
 	{
-		logGlobal->errorStream() << "CMapEditManager_DrawTerrain_Type crash" << "\n" << e.what();	
+		logGlobal->errorStream() << "CMapEditManager_DrawTerrain_Type crash" << "\n" << e.what();
 		throw;
-	}	
+	}
 	logGlobal->infoStream() << "CMapEditManager_DrawTerrain_Type finish";
 }
 
 BOOST_AUTO_TEST_CASE(CMapEditManager_DrawTerrain_View)
 {
-	logGlobal->infoStream() << "CMapEditManager_DrawTerrain_View start";	
+	logGlobal->infoStream() << "CMapEditManager_DrawTerrain_View start";
 	try
 	{
 		// Load maps and json config
@@ -151,8 +151,10 @@ BOOST_AUTO_TEST_CASE(CMapEditManager_DrawTerrain_View)
 				const auto & posVector = posNode.Vector();
 				if(posVector.size() != 3) throw std::runtime_error("A position should consist of three values x,y,z. Continue with next position.");
 				int3 pos(posVector[0].Float(), posVector[1].Float(), posVector[2].Float());
-				logGlobal->infoStream() << boost::format("Test pattern '%s' on position x '%d', y '%d', z '%d'.") % patternStr % pos.x % pos.y % pos.z;
+#if 0
+				logGlobal->traceStream() << boost::format("Test pattern '%s' on position x '%d', y '%d', z '%d'.") % patternStr % pos.x % pos.y % pos.z;
 				CTerrainViewPatternUtils::printDebuggingInfoAboutTile(map.get(), pos);
+#endif // 0
 				const auto & originalTile = originalMap->getTile(pos);
 				editManager->getTerrainSelection().selectRange(MapRect(pos, 1, 1));
 				editManager->drawTerrain(originalTile.terType, &gen);
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 511c773bc..ac6e602be 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -148,9 +148,22 @@ void MapComparer::compareOptions()
 	BOOST_ERROR("Not implemented compareOptions()");
 }
 
+void MapComparer::compareObject(const CGObjectInstance * actual, const CGObjectInstance * expected)
+{
+	BOOST_CHECK_EQUAL(actual->getStringId(), expected->getStringId());
+	BOOST_CHECK_EQUAL(typeid(actual).name(), typeid(expected).name());//todo: remove and use just comparison
+}
+
 void MapComparer::compareObjects()
 {
-	BOOST_ERROR("Not implemented compareObjects()");
+	BOOST_CHECK_EQUAL(actual->objects.size(), expected->objects.size());
+
+	for(size_t idx = 0; idx < std::min(actual->objects.size(), expected->objects.size()); idx++)
+	{
+		BOOST_REQUIRE_EQUAL(idx, expected->objects[idx]->id.getNum());
+		BOOST_CHECK_EQUAL(idx, actual->objects[idx]->id.getNum());
+		compareObject(actual->objects[idx], expected->objects[idx]);
+	}
 }
 
 void MapComparer::compareTerrain()
diff --git a/test/MapComparer.h b/test/MapComparer.h
index 4720a37f1..a8e4b882c 100644
--- a/test/MapComparer.h
+++ b/test/MapComparer.h
@@ -7,23 +7,24 @@
  * Full text of license available in license.txt file, in main folder
  *
  */
- 
+
 #pragma once
- 
+
 #include "../lib/mapping/CMap.h"
 
 struct MapComparer
 {
 	const CMap * actual;
 	const CMap * expected;
-	
+
 	void compareHeader();
 	void compareOptions();
+	void compareObject(const CGObjectInstance * actual, const CGObjectInstance * expected);
 	void compareObjects();
-	void compareTerrain();	
-	
-	void compare(); 
-	
+	void compareTerrain();
+
+	void compare();
+
 	void operator() (const std::unique_ptr<CMap>& actual, const std::unique_ptr<CMap>& expected);
 };
 

From 2d5a366e6cba400a6951b2d80728692cb9b75d92 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 14 Nov 2015 16:50:29 +0300
Subject: [PATCH 040/105] Implemented (basic) object construction and placement
 * contain refactoring of RMG and class handling (will be more)

---
 lib/CArtHandler.cpp                       |  69 ++++---
 lib/CCreatureHandler.cpp                  |  53 ++++--
 lib/CHeroHandler.cpp                      |   7 +
 lib/CModHandler.cpp                       |  13 +-
 lib/mapObjects/CObjectClassesHandler.cpp  |  73 +++++---
 lib/mapObjects/CObjectClassesHandler.h    |  34 +++-
 lib/mapObjects/CObjectHandler.cpp         |  13 ++
 lib/mapObjects/CObjectHandler.h           |   8 +
 lib/mapObjects/CRewardableConstructor.cpp |   1 +
 lib/mapObjects/CommonConstructors.h       |   3 +-
 lib/mapping/MapFormatJson.cpp             |  17 +-
 lib/rmg/CMapGenerator.cpp                 |  29 ++-
 lib/rmg/CRmgTemplateZone.cpp              | 217 +++++++++++-----------
 test/MapComparer.cpp                      |   6 +
 14 files changed, 334 insertions(+), 209 deletions(-)

diff --git a/lib/CArtHandler.cpp b/lib/CArtHandler.cpp
index 4cc618023..905b5d99b 100644
--- a/lib/CArtHandler.cpp
+++ b/lib/CArtHandler.cpp
@@ -207,6 +207,28 @@ void CArtHandler::loadObject(std::string scope, std::string name, const JsonNode
 
 	artifacts.push_back(object);
 
+	VLC->modh->identifiers.requestIdentifier(scope, "object", "artifact", [=](si32 index)
+	{
+		JsonNode conf;
+		conf.setMeta(scope);
+
+		VLC->objtypeh->loadSubObject(object->identifier, conf, Obj::ARTIFACT, object->id.num);
+
+		if (!object->advMapDef.empty())
+		{
+			JsonNode templ;
+			templ.setMeta(scope);
+			templ["animation"].String() = object->advMapDef;
+
+			// add new template.
+			// Necessary for objects added via mods that don't have any templates in H3
+			VLC->objtypeh->getHandlerFor(Obj::ARTIFACT, object->id)->addTemplate(templ);
+		}
+		// object does not have any templates - this is not usable object (e.g. pseudo-art like lock)
+		if (VLC->objtypeh->getHandlerFor(Obj::ARTIFACT, object->id)->getTemplates().empty())
+			VLC->objtypeh->removeSubObject(Obj::ARTIFACT, object->id);
+	});
+
 	registerObject(scope, "artifact", object->identifier, object->id);
 }
 
@@ -219,6 +241,27 @@ void CArtHandler::loadObject(std::string scope, std::string name, const JsonNode
 	assert(artifacts[index] == nullptr); // ensure that this id was not loaded before
 	artifacts[index] = object;
 
+	VLC->modh->identifiers.requestIdentifier(scope, "object", "artifact", [=](si32 index)
+	{
+		JsonNode conf;
+		conf.setMeta(scope);
+
+		VLC->objtypeh->loadSubObject(object->identifier, conf, Obj::ARTIFACT, object->id.num);
+
+		if (!object->advMapDef.empty())
+		{
+			JsonNode templ;
+			templ.setMeta(scope);
+			templ["animation"].String() = object->advMapDef;
+
+			// add new template.
+			// Necessary for objects added via mods that don't have any templates in H3
+			VLC->objtypeh->getHandlerFor(Obj::ARTIFACT, object->id)->addTemplate(templ);
+		}
+		// object does not have any templates - this is not usable object (e.g. pseudo-art like lock)
+		if (VLC->objtypeh->getHandlerFor(Obj::ARTIFACT, object->id)->getTemplates().empty())
+			VLC->objtypeh->removeSubObject(Obj::ARTIFACT, object->id);
+	});
 	registerObject(scope, "artifact", object->identifier, object->id);
 }
 
@@ -280,16 +323,16 @@ ArtifactPosition CArtHandler::stringToSlot(std::string slotName)
 
 void CArtHandler::addSlot(CArtifact * art, const std::string & slotID)
 {
-	static const std::vector<ArtifactPosition> miscSlots = 
+	static const std::vector<ArtifactPosition> miscSlots =
 	{
 		ArtifactPosition::MISC1, ArtifactPosition::MISC2, ArtifactPosition::MISC3, ArtifactPosition::MISC4, ArtifactPosition::MISC5
 	};
-	
+
 	static const std::vector<ArtifactPosition> ringSlots =
 	{
 		ArtifactPosition::LEFT_RING, ArtifactPosition::RIGHT_RING
 	};
-	
+
 	if (slotID == "MISC")
 	{
 		vstd::concatenate(art->possibleSlots[ArtBearer::HERO], miscSlots);
@@ -323,7 +366,7 @@ void CArtHandler::loadSlots(CArtifact * art, const JsonNode & node)
 CArtifact::EartClass CArtHandler::stringToClass(std::string className)
 {
 	static const std::map<std::string, CArtifact::EartClass> artifactClassMap =
-	{	
+	{
 		{"TREASURE", CArtifact::ART_TREASURE},
 		{"MINOR", CArtifact::ART_MINOR},
 		{"MAJOR", CArtifact::ART_MAJOR},
@@ -694,24 +737,6 @@ void CArtHandler::afterLoadFinalization()
 			bonus->sid = art->id;
 		}
 	}
-
-	for (CArtifact * art : artifacts)
-	{
-		VLC->objtypeh->loadSubObject(art->Name(), JsonNode(), Obj::ARTIFACT, art->id.num);
-
-		if (!art->advMapDef.empty())
-		{
-			JsonNode templ;
-			templ["animation"].String() = art->advMapDef;
-
-			// add new template.
-			// Necessary for objects added via mods that don't have any templates in H3
-			VLC->objtypeh->getHandlerFor(Obj::ARTIFACT, art->id)->addTemplate(templ);
-		}
-		// object does not have any templates - this is not usable object (e.g. pseudo-art like lock)
-		if (VLC->objtypeh->getHandlerFor(Obj::ARTIFACT, art->id)->getTemplates().empty())
-			VLC->objtypeh->removeSubObject(Obj::ARTIFACT, art->id);
-	}
 }
 
 CArtifactInstance::CArtifactInstance()
diff --git a/lib/CCreatureHandler.cpp b/lib/CCreatureHandler.cpp
index a536b5f18..6661a14ae 100644
--- a/lib/CCreatureHandler.cpp
+++ b/lib/CCreatureHandler.cpp
@@ -166,12 +166,12 @@ static void AddAbility(CCreature *cre, const JsonVector &ability_vec)
 	}
 
 	nsf->type = it->second;
-	
+
 	JsonUtils::parseTypedBonusShort(ability_vec,nsf);
 
 	nsf->source = Bonus::CREATURE_ABILITY;
 	nsf->sid = cre->idNumber;
-	
+
 	cre->addNewBonus(nsf);
 }
 
@@ -363,6 +363,24 @@ void CCreatureHandler::loadObject(std::string scope, std::string name, const Jso
 
 	creatures.push_back(object);
 
+	VLC->modh->identifiers.requestIdentifier(scope, "object", "monster", [=](si32 index)
+	{
+		JsonNode conf;
+		conf.setMeta(scope);
+
+		VLC->objtypeh->loadSubObject(object->identifier, conf, Obj::MONSTER, object->idNumber.num);
+		if (!object->advMapDef.empty())
+		{
+			JsonNode templ;
+			templ["animation"].String() = object->advMapDef;
+			VLC->objtypeh->getHandlerFor(Obj::MONSTER, object->idNumber.num)->addTemplate(templ);
+		}
+
+		// object does not have any templates - this is not usable object (e.g. pseudo-creature like Arrow Tower)
+		if (VLC->objtypeh->getHandlerFor(Obj::MONSTER, object->idNumber.num)->getTemplates().empty())
+			VLC->objtypeh->removeSubObject(Obj::MONSTER, object->idNumber.num);
+	});
+
 	registerObject(scope, "creature", name, object->idNumber);
 
 	for(auto node : data["extraNames"].Vector())
@@ -385,6 +403,24 @@ void CCreatureHandler::loadObject(std::string scope, std::string name, const Jso
 	assert(creatures[index] == nullptr); // ensure that this id was not loaded before
 	creatures[index] = object;
 
+	VLC->modh->identifiers.requestIdentifier(scope, "object", "monster", [=](si32 index)
+	{
+		JsonNode conf;
+		conf.setMeta(scope);
+
+		VLC->objtypeh->loadSubObject(object->identifier, conf, Obj::MONSTER, object->idNumber.num);
+		if (!object->advMapDef.empty())
+		{
+			JsonNode templ;
+			templ["animation"].String() = object->advMapDef;
+			VLC->objtypeh->getHandlerFor(Obj::MONSTER, object->idNumber.num)->addTemplate(templ);
+		}
+
+		// object does not have any templates - this is not usable object (e.g. pseudo-creature like Arrow Tower)
+		if (VLC->objtypeh->getHandlerFor(Obj::MONSTER, object->idNumber.num)->getTemplates().empty())
+			VLC->objtypeh->removeSubObject(Obj::MONSTER, object->idNumber.num);
+	});
+
 	registerObject(scope, "creature", name, object->idNumber);
 	for(auto & node : data["extraNames"].Vector())
 	{
@@ -1124,20 +1160,7 @@ void CCreatureHandler::buildBonusTreeForTiers()
 
 void CCreatureHandler::afterLoadFinalization()
 {
-	for (CCreature * crea : creatures)
-	{
-		VLC->objtypeh->loadSubObject(crea->nameSing, JsonNode(), Obj::MONSTER, crea->idNumber.num);
-		if (!crea->advMapDef.empty())
-		{
-			JsonNode templ;
-			templ["animation"].String() = crea->advMapDef;
-			VLC->objtypeh->getHandlerFor(Obj::MONSTER, crea->idNumber)->addTemplate(templ);
-		}
 
-		// object does not have any templates - this is not usable object (e.g. pseudo-creature like Arrow Tower)
-		if (VLC->objtypeh->getHandlerFor(Obj::MONSTER, crea->idNumber.num)->getTemplates().empty())
-			VLC->objtypeh->removeSubObject(Obj::MONSTER, crea->idNumber.num);
-	}
 }
 
 void CCreatureHandler::deserializationFix()
diff --git a/lib/CHeroHandler.cpp b/lib/CHeroHandler.cpp
index 5c5a73bf3..9ba561a1c 100644
--- a/lib/CHeroHandler.cpp
+++ b/lib/CHeroHandler.cpp
@@ -205,6 +205,13 @@ void CHeroClassHandler::loadObject(std::string scope, std::string name, const Js
 		VLC->objtypeh->loadSubObject(name, classConf, index, object->id);
 	});
 
+//	VLC->modh->identifiers.requestIdentifier(scope, "object", "prison", [=](si32 index)
+//	{
+//		JsonNode conf;
+//		conf.setMeta(scope);
+//		VLC->objtypeh->loadSubObject(name, conf, index, object->id);
+//	});
+
 	VLC->modh->identifiers.registerObject(scope, "heroClass", name, object->id);
 }
 
diff --git a/lib/CModHandler.cpp b/lib/CModHandler.cpp
index 571d5c10b..292293cbe 100644
--- a/lib/CModHandler.cpp
+++ b/lib/CModHandler.cpp
@@ -101,9 +101,9 @@ void CIdentifierStorage::requestIdentifier(std::string scope, std::string type,
 
 void CIdentifierStorage::requestIdentifier(std::string scope, std::string fullName, const std::function<void(si32)>& callback)
 {
-	auto scopeAndFullName = splitString(fullName, ':');	
-	auto typeAndName = splitString(scopeAndFullName.second, '.');	
-	
+	auto scopeAndFullName = splitString(fullName, ':');
+	auto typeAndName = splitString(scopeAndFullName.second, '.');
+
 	requestIdentifier(ObjectCallback(scope, scopeAndFullName.first, typeAndName.first, typeAndName.second, callback, false));
 }
 
@@ -186,6 +186,7 @@ void CIdentifierStorage::registerObject(std::string scope, std::string type, std
 	checkIdentifier(fullID);
 
 	registeredObjects.insert(std::make_pair(fullID, data));
+	logGlobal->traceStream() << scope << "::" << fullID;
 }
 
 std::vector<CIdentifierStorage::ObjectData> CIdentifierStorage::getPossibleIdentifiers(const ObjectCallback & request)
@@ -331,11 +332,11 @@ bool CContentHandler::ContentTypeHandler::loadMod(std::string modName, bool vali
 {
 	ModInfo & modInfo = modData[modName];
 	bool result = true;
-	
+
 	auto performValidate = [&,this](JsonNode & data, const std::string & name){
 		handler->beforeValidate(data);
 		if (validate)
-			result &= JsonUtils::validate(data, "vcmi:" + objectName, name);	
+			result &= JsonUtils::validate(data, "vcmi:" + objectName, name);
 	};
 
 	// apply patches
@@ -355,7 +356,7 @@ bool CContentHandler::ContentTypeHandler::loadMod(std::string modName, bool vali
 			if (originalData.size() > index)
 			{
 				JsonUtils::merge(originalData[index], data);
-				
+
 				performValidate(originalData[index],name);
 				handler->loadObject(modName, name, originalData[index], index);
 
diff --git a/lib/mapObjects/CObjectClassesHandler.cpp b/lib/mapObjects/CObjectClassesHandler.cpp
index acfec624d..78e80d6ef 100644
--- a/lib/mapObjects/CObjectClassesHandler.cpp
+++ b/lib/mapObjects/CObjectClassesHandler.cpp
@@ -74,7 +74,6 @@ CObjectClassesHandler::CObjectClassesHandler()
 	SET_HANDLER("pandora", CGPandoraBox);
 	SET_HANDLER("pickable", CGPickable);
 	SET_HANDLER("prison", CGHeroInstance);
-	SET_HANDLER("prison", CGHeroInstance);
 	SET_HANDLER("questGuard", CGQuestGuard);
 	SET_HANDLER("resource", CGResource);
 	SET_HANDLER("scholar", CGScholar);
@@ -148,17 +147,18 @@ si32 selectNextID(const JsonNode & fixedID, const Map & map, si32 defaultID)
 	return defaultID; // some H3M objects loaded, first modded found
 }
 
-void CObjectClassesHandler::loadObjectEntry(const JsonNode & entry, ObjectContainter * obj)
+void CObjectClassesHandler::loadObjectEntry(const std::string & identifier, const JsonNode & entry, ObjectContainter * obj)
 {
 	if (!handlerConstructors.count(obj->handlerName))
 	{
 		logGlobal->errorStream() << "Handler with name " << obj->handlerName << " was not found!";
 		return;
 	}
-	si32 id = selectNextID(entry["index"], obj->objects, 1000);
+	si32 id = selectNextID(entry["index"], obj->subObjects, 1000);
 
 	auto handler = handlerConstructors.at(obj->handlerName)();
 	handler->setType(obj->id, id);
+	handler->setTypeName(obj->identifier, identifier);
 
 	if (customNames.count(obj->id) && customNames.at(obj->id).size() > id)
 		handler->init(entry, customNames.at(obj->id).at(id));
@@ -175,50 +175,49 @@ void CObjectClassesHandler::loadObjectEntry(const JsonNode & entry, ObjectContai
 		legacyTemplates.erase(range.first, range.second);
 	}
 
-	logGlobal->debugStream() << "Loaded object " << obj->id << ":" << id;
-	assert(!obj->objects.count(id)); // DO NOT override
-	obj->objects[id] = handler;
+	logGlobal->debugStream() << "Loaded object " << obj->identifier << "(" << obj->id << ")" << ":" << identifier << "(" << id << ")" ;
+	assert(!obj->subObjects.count(id)); // DO NOT override
+	obj->subObjects[id] = handler;
+	obj->subIds[identifier] = id;//todo: scope
 }
 
-CObjectClassesHandler::ObjectContainter * CObjectClassesHandler::loadFromJson(const JsonNode & json)
+CObjectClassesHandler::ObjectContainter * CObjectClassesHandler::loadFromJson(const JsonNode & json, const std::string & name)
 {
 	auto obj = new ObjectContainter();
+	obj->identifier = name;
 	obj->name = json["name"].String();
 	obj->handlerName = json["handler"].String();
 	obj->base = json["base"];
 	obj->id = selectNextID(json["index"], objects, 256);
 	for (auto entry : json["types"].Struct())
 	{
-		loadObjectEntry(entry.second, obj);
+		loadObjectEntry(entry.first, entry.second, obj);
 	}
 	return obj;
 }
 
 void CObjectClassesHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
 {
-	auto object = loadFromJson(data);
+	auto object = loadFromJson(data, name);
 	objects[object->id] = object;
-
 	VLC->modh->identifiers.registerObject(scope, "object", name, object->id);
 }
 
 void CObjectClassesHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
 {
-	auto object = loadFromJson(data);
-
+	auto object = loadFromJson(data, name);
 	assert(objects[index] == nullptr); // ensure that this id was not loaded before
 	objects[index] = object;
-
 	VLC->modh->identifiers.registerObject(scope, "object", name, object->id);
 }
 
-void CObjectClassesHandler::loadSubObject(std::string name, JsonNode config, si32 ID, boost::optional<si32> subID)
+void CObjectClassesHandler::loadSubObject(const std::string & identifier, JsonNode config, si32 ID, boost::optional<si32> subID)
 {
 	config.setType(JsonNode::DATA_STRUCT); // ensure that input is not NULL
 	assert(objects.count(ID));
 	if (subID)
 	{
-		assert(objects.at(ID)->objects.count(subID.get()) == 0);
+		assert(objects.at(ID)->subObjects.count(subID.get()) == 0);
 		assert(config["index"].isNull());
 		config["index"].Float() = subID.get();
 	}
@@ -227,14 +226,14 @@ void CObjectClassesHandler::loadSubObject(std::string name, JsonNode config, si3
 	JsonUtils::inherit(config, objects.at(ID)->base);
 	config.setMeta(oldMeta);
 
-	loadObjectEntry(config, objects[ID]);
+	loadObjectEntry(identifier, config, objects[ID]);
 }
 
 void CObjectClassesHandler::removeSubObject(si32 ID, si32 subID)
 {
 	assert(objects.count(ID));
-	assert(objects.at(ID)->objects.count(subID));
-	objects.at(ID)->objects.erase(subID);
+	assert(objects.at(ID)->subObjects.count(subID));
+	objects.at(ID)->subObjects.erase(subID); //TODO: cleanup string id map
 }
 
 std::vector<bool> CObjectClassesHandler::getDefaultAllowed() const
@@ -246,14 +245,28 @@ TObjectTypeHandler CObjectClassesHandler::getHandlerFor(si32 type, si32 subtype)
 {
 	if (objects.count(type))
 	{
-		if (objects.at(type)->objects.count(subtype))
-			return objects.at(type)->objects.at(subtype);
+		if (objects.at(type)->subObjects.count(subtype))
+			return objects.at(type)->subObjects.at(subtype);
 	}
 	logGlobal->errorStream() << "Failed to find object of type " << type << ":" << subtype;
-	assert(0); // FIXME: throw error?
+	throw std::runtime_error("Object type handler not found");
 	return nullptr;
 }
 
+TObjectTypeHandler CObjectClassesHandler::getHandlerFor(std::string type, std::string subtype) const
+{
+	boost::optional<si32> id = VLC->modh->identifiers.getIdentifier("core", "object", type, false);
+	if(id)
+	{
+		si32 subId = objects.at(id.get())->subIds.at(subtype);
+		return objects.at(id.get())->subObjects.at(subId);
+	}
+	logGlobal->errorStream() << "Failed to find object of type " << type << ":" << subtype;
+	throw std::runtime_error("Object type handler not found");
+	return nullptr;
+}
+
+
 std::set<si32> CObjectClassesHandler::knownObjects() const
 {
 	std::set<si32> ret;
@@ -270,7 +283,7 @@ std::set<si32> CObjectClassesHandler::knownSubObjects(si32 primaryID) const
 
 	if (objects.count(primaryID))
 	{
-		for (auto entry : objects.at(primaryID)->objects)
+		for (auto entry : objects.at(primaryID)->subObjects)
 			ret.insert(entry.first);
 	}
 	return ret;
@@ -292,7 +305,7 @@ void CObjectClassesHandler::afterLoadFinalization()
 {
 	for (auto entry : objects)
 	{
-		for (auto obj : entry.second->objects)
+		for (auto obj : entry.second->subObjects)
 		{
 			obj.second->afterLoadFinalization();
 			if (obj.second->getTemplates().empty())
@@ -331,6 +344,12 @@ void AObjectTypeHandler::setType(si32 type, si32 subtype)
 	this->subtype = subtype;
 }
 
+void AObjectTypeHandler::setTypeName(std::string type, std::string subtype)
+{
+	this->typeName = type;
+	this->subTypeName = subtype;
+}
+
 static ui32 loadJsonOrMax(const JsonNode & input)
 {
 	if (input.isNull())
@@ -377,6 +396,14 @@ bool AObjectTypeHandler::objectFilter(const CGObjectInstance *, const ObjectTemp
 	return false; // by default there are no overrides
 }
 
+void AObjectTypeHandler::preInitObject(CGObjectInstance * obj) const
+{
+	obj->ID = Obj(type);
+	obj->subID = subtype;
+	obj->typeName = typeName;
+	obj->subTypeName = subTypeName;
+}
+
 void AObjectTypeHandler::initTypeData(const JsonNode & input)
 {
 	// empty implementation for overrides
diff --git a/lib/mapObjects/CObjectClassesHandler.h b/lib/mapObjects/CObjectClassesHandler.h
index 526fd8ad1..eb3413239 100644
--- a/lib/mapObjects/CObjectClassesHandler.h
+++ b/lib/mapObjects/CObjectClassesHandler.h
@@ -104,11 +104,14 @@ class DLL_LINKAGE AObjectTypeHandler : public boost::noncopyable
 	si32 type;
 	si32 subtype;
 
+	std::string typeName;
+	std::string subTypeName;
+
 	JsonNode base; /// describes base template
 
 	std::vector<ObjectTemplate> templates;
 protected:
-
+	void preInitObject(CGObjectInstance * obj) const;
 	virtual bool objectFilter(const CGObjectInstance *, const ObjectTemplate &) const;
 
 	/// initialization for classes that inherit this one
@@ -117,6 +120,7 @@ public:
 	virtual ~AObjectTypeHandler(){}
 
 	void setType(si32 type, si32 subtype);
+	void setTypeName(std::string type, std::string subtype);
 
 	/// loads generic data from Json structure and passes it towards type-specific constructors
 	void init(const JsonNode & input, boost::optional<std::string> name = boost::optional<std::string>());
@@ -149,12 +153,16 @@ public:
 	/// This should set remaining properties, including randomized or depending on map
 	virtual void configureObject(CGObjectInstance * object, CRandomGenerator & rng) const = 0;
 
-	/// Returns object configuration, if available. Othervice returns NULL
+	/// Returns object configuration, if available. Otherwise returns NULL
 	virtual std::unique_ptr<IObjectInfo> getObjectInfo(ObjectTemplate tmpl) const = 0;
 
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
 		h & type & subtype & templates & rmgInfo & objectName;
+		if(version >= 755)
+		{
+			h & typeName & subTypeName;
+		}
 	}
 };
 
@@ -167,16 +175,21 @@ class DLL_LINKAGE CObjectClassesHandler : public IHandlerBase
 	struct ObjectContainter
 	{
 		si32 id;
-
+		std::string identifier;
 		std::string name; // human-readable name
-		std::string handlerName; // ID of handler that controls this object, shoul be determined using hadlerConstructor map
+		std::string handlerName; // ID of handler that controls this object, should be determined using handlerConstructor map
 
 		JsonNode base;
-		std::map<si32, TObjectTypeHandler> objects;
+		std::map<si32, TObjectTypeHandler> subObjects;
+		std::map<std::string, si32> subIds;//full id from core scope -> subtype
 
 		template <typename Handler> void serialize(Handler &h, const int version)
 		{
-			h & name & handlerName & base & objects;
+			h & name & handlerName & base & subObjects;
+			if(version >= 755)
+			{
+				h & identifier & subIds;
+			}
 		}
 	};
 
@@ -194,8 +207,8 @@ class DLL_LINKAGE CObjectClassesHandler : public IHandlerBase
 	/// format: customNames[primaryID][secondaryID] -> name
 	std::map<si32, std::vector<std::string>> customNames;
 
-	void loadObjectEntry(const JsonNode & entry, ObjectContainter * obj);
-	ObjectContainter * loadFromJson(const JsonNode & json);
+	void loadObjectEntry(const std::string & identifier, const JsonNode & entry, ObjectContainter * obj);
+	ObjectContainter * loadFromJson(const JsonNode & json, const std::string & name);
 public:
 	CObjectClassesHandler();
 
@@ -204,7 +217,7 @@ public:
 	void loadObject(std::string scope, std::string name, const JsonNode & data) override;
 	void loadObject(std::string scope, std::string name, const JsonNode & data, size_t index) override;
 
-	void loadSubObject(std::string name, JsonNode config, si32 ID, boost::optional<si32> subID = boost::optional<si32>());
+	void loadSubObject(const std::string & identifier, JsonNode config, si32 ID, boost::optional<si32> subID = boost::optional<si32>());
 	void removeSubObject(si32 ID, si32 subID);
 
 	void beforeValidate(JsonNode & object) override;
@@ -218,10 +231,11 @@ public:
 
 	/// returns handler for specified object (ID-based). ObjectHandler keeps ownership
 	TObjectTypeHandler getHandlerFor(si32 type, si32 subtype) const;
+	TObjectTypeHandler getHandlerFor(std::string type, std::string subtype) const;
 
 	std::string getObjectName(si32 type) const;
 	std::string getObjectName(si32 type, si32 subtype) const;
-	
+
 	/// Returns handler string describing the handler (for use in client)
 	std::string getObjectHandlerName(si32 type) const;
 
diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 588113a67..abb9136e4 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -326,7 +326,14 @@ bool CGObjectInstance::passableFor(PlayerColor color) const
 
 void CGObjectInstance::writeJson(JsonNode & json, bool withState) const
 {
+	logGlobal->debugStream() <<"Save: [" << pos << "] " << id << " " << ID << " " << subID << " " << typeName << " " << subTypeName;
+
 	json.setType(JsonNode::DATA_STRUCT);
+	json["type"].String() = typeName;
+	json["subType"].String() = subTypeName;
+	json["x"].Float() = pos.x;
+	json["y"].Float() = pos.y;
+	json["l"].Float() = pos.z;
 
 	appearance.writeJson(json["template"]);
 	writeJsonOptions(json["options"]);
@@ -341,10 +348,16 @@ void CGObjectInstance::readJson(const JsonNode & json, bool withState)
 		logGlobal->error("Invalid object instance data");
 		return;
 	}
+	pos.x = json["x"].Float();
+	pos.y = json["y"].Float();
+	pos.z = json["l"].Float();
+
 	appearance.readJson(json["template"]);
 	readJsonOptions(json["options"]);
 	if(withState)
 		readJsonState(json["state"]);
+
+	logGlobal->debugStream() <<"Load: [" << pos << "] " << id << " " << ID << " " << subID << " " << typeName << " " << subTypeName;
 }
 
 void CGObjectInstance::writeJsonOptions(JsonNode & json) const
diff --git a/lib/mapObjects/CObjectHandler.h b/lib/mapObjects/CObjectHandler.h
index 2a6d61c8f..c0b9a68f0 100644
--- a/lib/mapObjects/CObjectHandler.h
+++ b/lib/mapObjects/CObjectHandler.h
@@ -113,6 +113,9 @@ public:
 	/// If true hero can visit this object only from neighbouring tiles and can't stand on this object
 	bool blockVisit;
 
+	std::string typeName;
+	std::string subTypeName;
+
 	CGObjectInstance();
 	~CGObjectInstance();
 
@@ -171,6 +174,11 @@ public:
 	{
 		h & pos & ID & subID & id & tempOwner & blockVisit & appearance;
 		//definfo is handled by map serializer
+
+		if(version >= 755)
+		{
+			h & typeName & subTypeName;
+		}
 	}
 
 	///Entry point of Json serialization
diff --git a/lib/mapObjects/CRewardableConstructor.cpp b/lib/mapObjects/CRewardableConstructor.cpp
index 3835733b7..c71384a3f 100644
--- a/lib/mapObjects/CRewardableConstructor.cpp
+++ b/lib/mapObjects/CRewardableConstructor.cpp
@@ -188,6 +188,7 @@ void CRewardableConstructor::initTypeData(const JsonNode & config)
 CGObjectInstance * CRewardableConstructor::create(ObjectTemplate tmpl) const
 {
 	auto ret = new CRewardableObject();
+	preInitObject(ret);
 	ret->appearance = tmpl;
 	return ret;
 }
diff --git a/lib/mapObjects/CommonConstructors.h b/lib/mapObjects/CommonConstructors.h
index 0cdd7ca98..c6a47ec47 100644
--- a/lib/mapObjects/CommonConstructors.h
+++ b/lib/mapObjects/CommonConstructors.h
@@ -31,8 +31,7 @@ protected:
 	ObjectType * createTyped(ObjectTemplate tmpl) const
 	{
 		auto obj = new ObjectType();
-		obj->ID = tmpl.id;
-		obj->subID = tmpl.subid;
+		preInitObject(obj);
 		obj->appearance = tmpl;
 		return obj;
 	}
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index dab72dc90..409dd0d5d 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -284,6 +284,13 @@ void CMapLoaderJson::readMap()
 	map->initTerrain();
 	readTerrain();
 	readObjects();
+
+	// Calculate blocked / visitable positions
+	for(auto & elem : map->objects)
+	{
+		map->addBlockVisTiles(elem);
+	}
+	map->calculateGuardingGreaturePositions();
 }
 
 void CMapLoaderJson::readHeader()
@@ -569,6 +576,7 @@ CMapLoaderJson::MapObjectLoader::MapObjectLoader(CMapLoaderJson * _owner, const
 
 void CMapLoaderJson::MapObjectLoader::construct()
 {
+	//TODO:consider move to ObjectTypeHandler
 	//find type handler
 	std::string typeName = configuration["type"].String(), subTypeName = configuration["subType"].String();
 	if(typeName.empty())
@@ -584,13 +592,16 @@ void CMapLoaderJson::MapObjectLoader::construct()
 
 	si32 type = owner->getIdentifier("object", typeName);
 
-//	VLC->objtypeh->getHandlerFor()
-//TODO:MapObjectLoader::construct()
+	handler = VLC->objtypeh->getHandlerFor(typeName, subTypeName);
+
+	instance = handler->create(ObjectTemplate());
+	instance->id = ObjectInstanceID(owner->map->objects.size());
+	owner->map->objects.push_back(instance);
 }
 
 void CMapLoaderJson::MapObjectLoader::configure()
 {
-//TODO:MapObjectLoader::configure()
+	instance->readJson(configuration, false);
 }
 
 void CMapLoaderJson::readObjects()
diff --git a/lib/rmg/CMapGenerator.cpp b/lib/rmg/CMapGenerator.cpp
index 0c7f6c963..8a7151144 100644
--- a/lib/rmg/CMapGenerator.cpp
+++ b/lib/rmg/CMapGenerator.cpp
@@ -32,7 +32,7 @@ void CMapGenerator::foreachDirectNeighbour(const int3& pos, std::function<void(i
 		int3 n = pos + dir;
 		if(map->isInTheMap(n))
 			foo(n);
-	}	
+	}
 }
 
 
@@ -189,7 +189,7 @@ void CMapGenerator::addPlayerInfo()
 			playerCount = mapGenOptions->getCompOnlyPlayerCount();
 			teamCount = mapGenOptions->getCompOnlyTeamCount();
 		}
-		
+
 		if(playerCount == 0)
 		{
 			continue;
@@ -259,7 +259,7 @@ void CMapGenerator::genZones()
 }
 
 void CMapGenerator::fillZones()
-{	
+{
 	//init native town count with 0
 	for (auto faction : VLC->townh->getAllowedFactions())
 		zonesPerFaction[faction] = 0;
@@ -495,8 +495,8 @@ void CMapGenerator::createConnections()
 					zoneA->addMonster (this, guardPos, connection.getGuardStrength(), false, true);
 					//zones can make paths only in their own area
 					zoneA->crunchPath(this, guardPos, posA, true, zoneA->getFreePaths()); //make connection towards our zone center
-					zoneB->crunchPath(this, guardPos, posB, true, zoneB->getFreePaths()); //make connection towards other zone center		
-					
+					zoneB->crunchPath(this, guardPos, posB, true, zoneB->getFreePaths()); //make connection towards other zone center
+
 					zoneA->addRoadNode(guardPos);
 					zoneB->addRoadNode(guardPos);
 					break; //we're done with this connection
@@ -504,7 +504,7 @@ void CMapGenerator::createConnections()
 			}
 		}
 		else //create subterranean gates between two zones
-		{	
+		{
 			//find point on the path between zones
 			float3 offset (posB.x - posA.x, posB.y - posA.y, 0);
 
@@ -563,15 +563,14 @@ void CMapGenerator::createConnections()
 		}
 		if (!guardPos.valid())
 		{
-			auto teleport1 = new CGMonolith;
-			teleport1->ID = Obj::MONOLITH_TWO_WAY;
-			teleport1->subID = getNextMonlithIndex();
+			auto factory = VLC->objtypeh->getHandlerFor(Obj::MONOLITH_TWO_WAY, getNextMonlithIndex());
+			auto teleport1 = factory->create(ObjectTemplate());
 
-			auto teleport2 = new CGMonolith(*teleport1);
+			auto teleport2 = factory->create(ObjectTemplate());
 
 			zoneA->addRequiredObject (teleport1, connection.getGuardStrength());
 			zoneB->addRequiredObject (teleport2, connection.getGuardStrength());
-		}		
+		}
 	}
 }
 
@@ -590,7 +589,7 @@ void CMapGenerator::addHeaderInfo()
 void CMapGenerator::checkIsOnMap(const int3& tile) const
 {
 	if (!map->isInTheMap(tile))
-		throw  rmgException(boost::to_string(boost::format("Tile %s is outside the map") % tile));	
+		throw  rmgException(boost::to_string(boost::format("Tile %s is outside the map") % tile));
 }
 
 
@@ -633,8 +632,8 @@ bool CMapGenerator::isUsed(const int3 &tile) const
 bool CMapGenerator::isRoad(const int3& tile) const
 {
 	checkIsOnMap(tile);
-	
-	return tiles[tile.x][tile.y][tile.z].isRoad();	
+
+	return tiles[tile.x][tile.y][tile.z].isRoad();
 }
 
 void CMapGenerator::setOccupied(const int3 &tile, ETileType::ETileType state)
@@ -648,7 +647,7 @@ void CMapGenerator::setRoad(const int3& tile, ERoadType::ERoadType roadType)
 {
 	checkIsOnMap(tile);
 
-	tiles[tile.x][tile.y][tile.z].setRoadType(roadType);	
+	tiles[tile.x][tile.y][tile.z].setRoadType(roadType);
 }
 
 
diff --git a/lib/rmg/CRmgTemplateZone.cpp b/lib/rmg/CRmgTemplateZone.cpp
index 9da6366be..8225276df 100644
--- a/lib/rmg/CRmgTemplateZone.cpp
+++ b/lib/rmg/CRmgTemplateZone.cpp
@@ -86,7 +86,7 @@ void CRmgTemplateZone::CTownInfo::setCastleDensity(int value)
 	castleDensity = value;
 }
 
-CTileInfo::CTileInfo():nearestObjectDistance(INT_MAX), terrain(ETerrainType::WRONG),roadType(ERoadType::NO_ROAD) 
+CTileInfo::CTileInfo():nearestObjectDistance(INT_MAX), terrain(ETerrainType::WRONG),roadType(ERoadType::NO_ROAD)
 {
 	occupied = ETileType::POSSIBLE; //all tiles are initially possible to place objects or passages
 }
@@ -638,7 +638,7 @@ do not leave zone border
 		}
 
 		auto lastDistance = distance;
-			
+
 		auto processNeighbours = [this, gen, &currentPos, dst, &distance, &result, &end, clearedTiles](int3 &pos)
 		{
 			if (!result) //not sure if lambda is worth it...
@@ -672,19 +672,19 @@ do not leave zone border
 				}
 			}
 		};
-		
+
 		if (onlyStraight)
 			gen->foreachDirectNeighbour (currentPos, processNeighbours);
 		else
 			gen->foreach_neighbour (currentPos,processNeighbours);
-						
+
 		int3 anotherPos(-1, -1, -1);
 
 		if (!(result || distance < lastDistance)) //we do not advance, use more advanced pathfinding algorithm?
 		{
 			//try any nearby tiles, even if its not closer than current
 			float lastDistance = 2 * distance; //start with significantly larger value
-			
+
 			auto processNeighbours2 = [this, gen, &currentPos, dst, &lastDistance, &anotherPos, &end, clearedTiles](int3 &pos)
 			{
 				if (currentPos.dist2dSQ(dst) < lastDistance) //try closest tiles from all surrounding unused tiles
@@ -700,13 +700,13 @@ do not leave zone border
 						}
 					}
 				}
-			};			
+			};
 			if (onlyStraight)
 				gen->foreachDirectNeighbour(currentPos, processNeighbours2);
 			else
 				gen->foreach_neighbour(currentPos, processNeighbours2);
-						
-			
+
+
 			if (anotherPos.valid())
 			{
 				if (clearedTiles)
@@ -878,7 +878,7 @@ bool CRmgTemplateZone::connectPath(CMapGenerator* gen, const int3& src, bool onl
 
 			if (onlyStraight)
 				gen->foreachDirectNeighbour(currentNode, foo);
-			else 
+			else
 				gen->foreach_neighbour(currentNode, foo);
 		}
 
@@ -997,8 +997,8 @@ bool CRmgTemplateZone::addMonster(CMapGenerator* gen, int3 &pos, si32 strength,
 	static const float multiplier1[] = {0.5, 0.75, 1.0, 1.5, 1.5};
 	static const float multiplier2[] = {0.5, 0.75, 1.0, 1.0, 1.5};
 
-	int strength1 = std::max(0.f, (strength - value1[monsterStrength]) * multiplier1[monsterStrength]); 
-	int strength2 = std::max(0.f, (strength - value2[monsterStrength]) * multiplier2[monsterStrength]); 
+	int strength1 = std::max(0.f, (strength - value1[monsterStrength]) * multiplier1[monsterStrength]);
+	int strength2 = std::max(0.f, (strength - value2[monsterStrength]) * multiplier2[monsterStrength]);
 
 	strength = strength1 + strength2;
 	if (strength < 2000)
@@ -1031,10 +1031,9 @@ bool CRmgTemplateZone::addMonster(CMapGenerator* gen, int3 &pos, si32 strength,
 		amount = strength / VLC->creh->creatures[creId]->AIValue;
 	}
 
+	auto guardFactory = VLC->objtypeh->getHandlerFor(Obj::MONSTER, creId);
 
-	auto guard = new CGCreature();
-	guard->ID = Obj::MONSTER;
-	guard->subID = creId;
+	auto guard = (CGCreature *) guardFactory->create(ObjectTemplate());
 	guard->character = CGCreature::HOSTILE;
 	auto  hlp = new CStackInstance(creId, amount);
 	//will be set during initialization
@@ -1132,7 +1131,7 @@ bool CRmgTemplateZone::createTreasurePile(CMapGenerator* gen, int3 &pos, float m
 			info.occupiedPositions.insert(visitablePos);
 
 			currentValue += oi.value;
-		
+
 			treasures[info.nextTreasurePos] = object;
 
 			//now find place for next object
@@ -1313,19 +1312,23 @@ void CRmgTemplateZone::initTownType (CMapGenerator* gen)
 	{
 		for (int i = 0; i < count; i++)
 		{
-			auto town = new CGTownInstance();
-			town->ID = Obj::TOWN;
+			si32 subType = townType;
 
-			if (this->townsAreSameType)
-				town->subID = townType;
-			else
+			if(totalTowns>0)
 			{
-				if (townTypes.size())
-					town->subID = *RandomGeneratorUtil::nextItem(townTypes, gen->rand);
-				else
-					town->subID = *RandomGeneratorUtil::nextItem(getDefaultTownTypes(), gen->rand); //it is possible to have zone with no towns allowed
+				if(!this->townsAreSameType)
+				{
+					if (townTypes.size())
+						subType = *RandomGeneratorUtil::nextItem(townTypes, gen->rand);
+					else
+						subType = *RandomGeneratorUtil::nextItem(getDefaultTownTypes(), gen->rand); //it is possible to have zone with no towns allowed
+				}
 			}
 
+			auto townFactory = VLC->objtypeh->getHandlerFor(Obj::TOWN, subType);
+			auto town = (CGTownInstance *) townFactory->create(ObjectTemplate());
+			town->ID = Obj::TOWN;
+
 			town->tempOwner = player;
 			if (hasFort)
 				town->builtBuildings.insert(BuildingID::FORT);
@@ -1337,10 +1340,8 @@ void CRmgTemplateZone::initTownType (CMapGenerator* gen)
 					town->possibleSpells.push_back(spell->id);
 			}
 
-			if (!totalTowns) 
+			if (totalTowns <= 0)
 			{
-				//first town in zone sets the facton of entire zone
-				town->subID = townType;
 				//register MAIN town of zone
 				gen->registerZone(town->subID);
 				//first town in zone goes in the middle
@@ -1376,10 +1377,9 @@ void CRmgTemplateZone::initTownType (CMapGenerator* gen)
 			randomizeTownType(gen);
 		}
 
-		auto  town = new CGTownInstance();
-		town->ID = Obj::TOWN;
+		auto townFactory = VLC->objtypeh->getHandlerFor(Obj::TOWN, townType);
 
-		town->subID = townType;
+		CGTownInstance * town = (CGTownInstance *) townFactory->create(ObjectTemplate());
 		town->tempOwner = player;
 		town->builtBuildings.insert(BuildingID::FORT);
 		town->builtBuildings.insert(BuildingID::DEFAULT);
@@ -1490,20 +1490,25 @@ void CRmgTemplateZone::paintZoneTerrain (CMapGenerator* gen, ETerrainType terrai
 
 bool CRmgTemplateZone::placeMines (CMapGenerator* gen)
 {
-	std::vector<Res::ERes> required_mines;
-	required_mines.push_back(Res::ERes::WOOD);
-	required_mines.push_back(Res::ERes::ORE);
-
 	static const Res::ERes woodOre[] = {Res::ERes::WOOD, Res::ERes::ORE};
 	static const Res::ERes preciousResources[] = {Res::ERes::GEMS, Res::ERes::CRYSTAL, Res::ERes::MERCURY, Res::ERes::SULFUR};
 
+	std::array<TObjectTypeHandler, 7> factory =
+	{
+		VLC->objtypeh->getHandlerFor(Obj::MINE, 0),
+		VLC->objtypeh->getHandlerFor(Obj::MINE, 1),
+		VLC->objtypeh->getHandlerFor(Obj::MINE, 2),
+		VLC->objtypeh->getHandlerFor(Obj::MINE, 3),
+		VLC->objtypeh->getHandlerFor(Obj::MINE, 4),
+		VLC->objtypeh->getHandlerFor(Obj::MINE, 5),
+		VLC->objtypeh->getHandlerFor(Obj::MINE, 6)
+	};
+
 	for (const auto & res : woodOre)
 	{
 		for (int i = 0; i < mines[res]; i++)
 		{
-			auto mine = new CGMine();
-			mine->ID = Obj::MINE;
-			mine->subID = static_cast<si32>(res);
+			auto mine = (CGMine *) factory.at(static_cast<si32>(res))->create(ObjectTemplate());
 			mine->producedResource = res;
 			mine->producedQuantity = mine->defaultResProduction();
 			if (!i)
@@ -1516,9 +1521,7 @@ bool CRmgTemplateZone::placeMines (CMapGenerator* gen)
 	{
 		for (int i = 0; i < mines[res]; i++)
 		{
-			auto mine = new CGMine();
-			mine->ID = Obj::MINE;
-			mine->subID = static_cast<si32>(res);
+			auto mine = (CGMine *) factory.at(static_cast<si32>(res))->create(ObjectTemplate());
 			mine->producedResource = res;
 			mine->producedQuantity = mine->defaultResProduction();
 			addRequiredObject(mine, 3500);
@@ -1526,9 +1529,7 @@ bool CRmgTemplateZone::placeMines (CMapGenerator* gen)
 	}
 	for (int i = 0; i < mines[Res::GOLD]; i++)
 	{
-		auto mine = new CGMine();
-		mine->ID = Obj::MINE;
-		mine->subID = static_cast<si32>(Res::GOLD);
+		auto mine = (CGMine *) factory.at(Res::GOLD)->create(ObjectTemplate());
 		mine->producedResource = Res::GOLD;
 		mine->producedQuantity = mine->defaultResProduction();
 		addRequiredObject(mine, 7000);
@@ -1540,7 +1541,7 @@ bool CRmgTemplateZone::placeMines (CMapGenerator* gen)
 bool CRmgTemplateZone::createRequiredObjects(CMapGenerator* gen)
 {
 	logGlobal->traceStream() << "Creating required objects";
-	
+
 	for(const auto &object : requiredObjects)
 	{
 		auto obj = object.first;
@@ -1577,16 +1578,16 @@ bool CRmgTemplateZone::createRequiredObjects(CMapGenerator* gen)
 				break;
 		}
 
-	
+
 		placeObject(gen, obj, pos);
 		guardObject (gen, obj, object.second, (obj->ID == Obj::MONOLITH_TWO_WAY), true);
-		//paths to required objects constitute main paths of zone. otherwise they just may lead to middle and create dead zones	
+		//paths to required objects constitute main paths of zone. otherwise they just may lead to middle and create dead zones
 	}
 
 	for (const auto &obj : closeObjects)
 	{
 		std::vector<int3> tiles(possibleTiles.begin(), possibleTiles.end()); //new tiles vector after each object has been placed
-		
+
 		// smallest distance to zone center, greatest distance to nearest object
 		auto isCloser = [this, gen](const int3 & lhs, const int3 & rhs) -> bool
 		{
@@ -1675,7 +1676,7 @@ void CRmgTemplateZone::createTreasures(CMapGenerator* gen)
 				return !gen->isPossible(tile);
 			});
 
-			
+
 			int3 treasureTilePos;
 			//If we are able to place at least one object with value lower than minGuardedValue, it's ok
 			do
@@ -1722,11 +1723,11 @@ void CRmgTemplateZone::createObstacles2(CMapGenerator* gen)
 	std::vector<obstaclePair> possibleObstacles;
 
 	//get all possible obstacles for this terrain
-	for (auto primaryID : VLC->objtypeh->knownObjects()) 
-	{ 
-		for (auto secondaryID : VLC->objtypeh->knownSubObjects(primaryID)) 
-		{ 
-			auto handler = VLC->objtypeh->getHandlerFor(primaryID, secondaryID); 
+	for (auto primaryID : VLC->objtypeh->knownObjects())
+	{
+		for (auto secondaryID : VLC->objtypeh->knownSubObjects(primaryID))
+		{
+			auto handler = VLC->objtypeh->getHandlerFor(primaryID, secondaryID);
 			if (handler->isStaticObject())
 			{
 				for (auto temp : handler->getTemplates())
@@ -1735,7 +1736,7 @@ void CRmgTemplateZone::createObstacles2(CMapGenerator* gen)
 						obstaclesBySize[temp.getBlockedOffsets().size()].push_back(temp);
 				}
 			}
-		} 
+		}
 	}
 	for (auto o : obstaclesBySize)
 	{
@@ -1789,13 +1790,13 @@ void CRmgTemplateZone::createObstacles2(CMapGenerator* gen)
 void CRmgTemplateZone::connectRoads(CMapGenerator* gen)
 {
 	logGlobal->debug("Started building roads");
-	
+
 	std::set<int3> roadNodesCopy(roadNodes);
 	std::set<int3> processed;
-	
+
 	while(!roadNodesCopy.empty())
 	{
-		int3 node = *roadNodesCopy.begin(); 
+		int3 node = *roadNodesCopy.begin();
 		roadNodesCopy.erase(node);
 		int3 cross(-1, -1, -1);
 
@@ -1818,13 +1819,13 @@ void CRmgTemplateZone::connectRoads(CMapGenerator* gen)
 			processed.insert(cross); //don't draw road starting at end point which is already connected
 			vstd::erase_if_present(roadNodesCopy, cross);
 		}
-		
-		processed.insert(node); 
+
+		processed.insert(node);
 	}
 
 	drawRoads(gen);
-	
-	logGlobal->debug("Finished building roads");	
+
+	logGlobal->debug("Finished building roads");
 }
 
 void CRmgTemplateZone::drawRoads(CMapGenerator* gen)
@@ -1832,7 +1833,7 @@ void CRmgTemplateZone::drawRoads(CMapGenerator* gen)
 	std::vector<int3> tiles;
 	for (auto tile : roads)
 	{
-		if(gen->map->isInTheMap(tile))	
+		if(gen->map->isInTheMap(tile))
 			tiles.push_back (tile);
 	}
 	for (auto tile : roadNodes)
@@ -1841,8 +1842,8 @@ void CRmgTemplateZone::drawRoads(CMapGenerator* gen)
 			tiles.push_back(tile);
 	}
 
-	gen->editManager->getTerrainSelection().setSelection(tiles);	
-	gen->editManager->drawRoad(ERoadType::COBBLESTONE_ROAD, &gen->rand);	
+	gen->editManager->getTerrainSelection().setSelection(tiles);
+	gen->editManager->drawRoad(ERoadType::COBBLESTONE_ROAD, &gen->rand);
 }
 
 
@@ -1852,7 +1853,7 @@ bool CRmgTemplateZone::fill(CMapGenerator* gen)
 
 	//zone center should be always clear to allow other tiles to connect
 	gen->setOccupied(this->getPos(), ETileType::FREE);
-	freePaths.insert(pos); 
+	freePaths.insert(pos);
 
 	addAllPossibleObjects (gen);
 
@@ -1861,7 +1862,7 @@ bool CRmgTemplateZone::fill(CMapGenerator* gen)
 	placeMines(gen);
 	createRequiredObjects(gen);
 	createTreasures(gen);
-	
+
 	logGlobal->infoStream() << boost::format ("Zone %d filled successfully") %id;
 	return true;
 }
@@ -2040,7 +2041,7 @@ void CRmgTemplateZone::checkAndPlaceObject(CMapGenerator* gen, CGObjectInstance*
 		auto templates = VLC->objtypeh->getHandlerFor(object->ID, object->subID)->getTemplates(terrainType);
 		if (templates.empty())
 			throw rmgException(boost::to_string(boost::format("Did not find graphics for object (%d,%d) at %s (terrain %d)") %object->ID %object->subID %pos %terrainType));
-	
+
 		object->appearance = templates.front();
 	}
 
@@ -2059,7 +2060,7 @@ void CRmgTemplateZone::placeObject(CMapGenerator* gen, CGObjectInstance* object,
 		points.insert(pos + object->getVisitableOffset());
 	points.insert(pos);
 	for(auto p : points)
-	{		
+	{
 		if (gen->map->isInTheMap(p))
 		{
 			gen->setOccupied(p, ETileType::USED);
@@ -2068,7 +2069,7 @@ void CRmgTemplateZone::placeObject(CMapGenerator* gen, CGObjectInstance* object,
 	if (updateDistance)
 	{
 		for(auto tile : possibleTiles) //don't need to mark distance for not possible tiles
-		{		
+		{
 			si32 d = pos.dist2dSQ(tile); //optimization, only relative distance is interesting
 			gen->setNearestObjectDistance(tile, std::min<float>(d, gen->getNearestObjectDistance(tile)));
 		}
@@ -2080,7 +2081,7 @@ void CRmgTemplateZone::placeObject(CMapGenerator* gen, CGObjectInstance* object,
 		logGlobal->warnStream() << boost::format("Placed Seer Hut at %s, quest artifact %d is %s") % object->pos % artid % VLC->arth->artifacts[artid]->Name();
 	}
 
-	
+
 	switch (object->ID)
 	{
 	case Obj::TOWN:
@@ -2093,10 +2094,10 @@ void CRmgTemplateZone::placeObject(CMapGenerator* gen, CGObjectInstance* object,
 			addRoadNode(object->visitablePos());
 		}
 		break;
-	
+
 	default:
 		break;
-	}		
+	}
 }
 
 void CRmgTemplateZone::placeAndGuardObject(CMapGenerator* gen, CGObjectInstance* object, const int3 &pos, si32 str, bool zoneGuard)
@@ -2107,9 +2108,8 @@ void CRmgTemplateZone::placeAndGuardObject(CMapGenerator* gen, CGObjectInstance*
 
 void CRmgTemplateZone::placeSubterraneanGate(CMapGenerator* gen, int3 pos, si32 guardStrength)
 {
-	auto gate = new CGSubterraneanGate;
-	gate->ID = Obj::SUBTERRANEAN_GATE;
-	gate->subID = 0;
+	auto factory = VLC->objtypeh->getHandlerFor(Obj::SUBTERRANEAN_GATE, 0);
+	auto gate = factory->create(ObjectTemplate());
 	placeObject (gen, gate, pos, true);
 	addToConnectLater (getAccessibleOffset (gen, gate->appearance, pos)); //guard will be placed on accessibleOffset
 	guardObject (gen, gate, guardStrength, true);
@@ -2123,7 +2123,7 @@ std::vector<int3> CRmgTemplateZone::getAccessibleOffsets (CMapGenerator* gen, CG
 
 	auto tilesBlockedByObject = object->getBlockedPos(); //absolue value, as object is already placed
 
-	gen->foreach_neighbour(visitable, [&](int3& pos) 
+	gen->foreach_neighbour(visitable, [&](int3& pos)
 	{
 		if (gen->isPossible(pos) || gen->isFree(pos))
 		{
@@ -2166,7 +2166,7 @@ bool CRmgTemplateZone::guardObject(CMapGenerator* gen, CGObjectInstance* object,
 			if (!gen->isFree(pos))
 				gen->setOccupied(pos, ETileType::BLOCKED);
 		}
-		gen->foreach_neighbour (guardTile, [&](int3& pos) 
+		gen->foreach_neighbour (guardTile, [&](int3& pos)
 		{
 			if (gen->isPossible(pos))
 				gen->setOccupied (pos, ETileType::FREE);
@@ -2303,9 +2303,8 @@ ObjectInfo CRmgTemplateZone::getRandomObject(CMapGenerator* gen, CTreasurePileIn
 		{
 			oi.generateObject = [minValue]() -> CGObjectInstance *
 			{
-				auto obj = new CGPandoraBox();
-				obj->ID = Obj::PANDORAS_BOX;
-				obj->subID = 0;
+				auto factory = VLC->objtypeh->getHandlerFor(Obj::PANDORAS_BOX, 0);
+				auto obj = (CGPandoraBox *) factory->create(ObjectTemplate());
 				obj->resources[Res::GOLD] = minValue;
 				return obj;
 			};
@@ -2393,9 +2392,6 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 	{
 		oi.generateObject = [i, gen, this]() -> CGObjectInstance *
 		{
-			auto obj = new CGHeroInstance;
-			obj->ID = Obj::PRISON;
-
 			std::vector<ui32> possibleHeroes;
 			for (int j = 0; j < gen->map->allowedHeroes.size(); j++)
 			{
@@ -2404,6 +2400,10 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 			}
 
 			auto hid = *RandomGeneratorUtil::nextItem(possibleHeroes, gen->rand);
+			auto factory = VLC->objtypeh->getHandlerFor(Obj::PRISON, 0);
+			auto obj = (CGHeroInstance *) factory->create(ObjectTemplate());
+
+
 			obj->subID = hid; //will be initialized later
 			obj->exp = prisonExp[i];
 			obj->setOwner(PlayerColor::NEUTRAL);
@@ -2471,9 +2471,8 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 	{
 		oi.generateObject = [i, gen]() -> CGObjectInstance *
 		{
-			auto obj = new CGArtifact();
-			obj->ID = Obj::SPELL_SCROLL;
-			obj->subID = 0;
+			auto factory = VLC->objtypeh->getHandlerFor(Obj::SPELL_SCROLL, 0);
+			auto obj = (CGArtifact *) factory->create(ObjectTemplate());
 			std::vector<SpellID> out;
 
 			for (auto spell : VLC->spellh->objects) //spellh size appears to be greater (?)
@@ -2499,9 +2498,8 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 	{
 		oi.generateObject = [i]() -> CGObjectInstance *
 		{
-			auto obj = new CGPandoraBox();
-			obj->ID = Obj::PANDORAS_BOX;
-			obj->subID = 0;
+			auto factory = VLC->objtypeh->getHandlerFor(Obj::PANDORAS_BOX, 0);
+			auto obj = (CGPandoraBox *) factory->create(ObjectTemplate());
 			obj->resources[Res::GOLD] = i * 5000;
 			return obj;
 		};
@@ -2516,9 +2514,8 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 	{
 		oi.generateObject = [i]() -> CGObjectInstance *
 		{
-			auto obj = new CGPandoraBox();
-			obj->ID = Obj::PANDORAS_BOX;
-			obj->subID = 0;
+			auto factory = VLC->objtypeh->getHandlerFor(Obj::PANDORAS_BOX, 0);
+			auto obj = (CGPandoraBox *) factory->create(ObjectTemplate());
 			obj->gainedExp = i * 5000;
 			return obj;
 		};
@@ -2564,9 +2561,8 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 
 		oi.generateObject = [creature, creaturesAmount]() -> CGObjectInstance *
 		{
-			auto obj = new CGPandoraBox();
-			obj->ID = Obj::PANDORAS_BOX;
-			obj->subID = 0;
+			auto factory = VLC->objtypeh->getHandlerFor(Obj::PANDORAS_BOX, 0);
+			auto obj = (CGPandoraBox *) factory->create(ObjectTemplate());
 			auto stack = new CStackInstance(creature, creaturesAmount);
 			obj->creatures.putStack(SlotID(0), stack);
 			return obj;
@@ -2582,9 +2578,8 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 	{
 		oi.generateObject = [i, gen]() -> CGObjectInstance *
 		{
-			auto obj = new CGPandoraBox();
-			obj->ID = Obj::PANDORAS_BOX;
-			obj->subID = 0;
+			auto factory = VLC->objtypeh->getHandlerFor(Obj::PANDORAS_BOX, 0);
+			auto obj = (CGPandoraBox *) factory->create(ObjectTemplate());
 
 			std::vector <CSpell *> spells;
 			for (auto spell : VLC->spellh->objects)
@@ -2612,9 +2607,8 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 	{
 		oi.generateObject = [i,gen]() -> CGObjectInstance *
 		{
-			auto obj = new CGPandoraBox();
-			obj->ID = Obj::PANDORAS_BOX;
-			obj->subID = 0;
+			auto factory = VLC->objtypeh->getHandlerFor(Obj::PANDORAS_BOX, 0);
+			auto obj = (CGPandoraBox *) factory->create(ObjectTemplate());
 
 			std::vector <CSpell *> spells;
 			for (auto spell : VLC->spellh->objects)
@@ -2642,9 +2636,8 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 
 	oi.generateObject = [gen]() -> CGObjectInstance *
 	{
-		auto obj = new CGPandoraBox();
-		obj->ID = Obj::PANDORAS_BOX;
-		obj->subID = 0;
+		auto factory = VLC->objtypeh->getHandlerFor(Obj::PANDORAS_BOX, 0);
+		auto obj = (CGPandoraBox *) factory->create(ObjectTemplate());
 
 		std::vector <CSpell *> spells;
 		for (auto spell : VLC->spellh->objects)
@@ -2716,9 +2709,8 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 
 			oi.generateObject = [creature, creaturesAmount, randomAppearance, gen, this, generateArtInfo]() -> CGObjectInstance *
 			{
-				auto obj = new CGSeerHut();
-				obj->ID = Obj::SEER_HUT;
-				obj->subID = randomAppearance;
+				auto factory = VLC->objtypeh->getHandlerFor(Obj::SEER_HUT, randomAppearance);
+				auto obj = (CGSeerHut *) factory->create(ObjectTemplate());
 				obj->rewardType = CGSeerHut::CREATURE;
 				obj->rID = creature->idNumber;
 				obj->rVal = creaturesAmount;
@@ -2752,9 +2744,9 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 
 			oi.generateObject = [i, randomAppearance, gen, this, generateArtInfo]() -> CGObjectInstance *
 			{
-				auto obj = new CGSeerHut();
-				obj->ID = Obj::SEER_HUT;
-				obj->subID = randomAppearance;
+				auto factory = VLC->objtypeh->getHandlerFor(Obj::SEER_HUT, randomAppearance);
+				auto obj = (CGSeerHut *) factory->create(ObjectTemplate());
+
 				obj->rewardType = CGSeerHut::EXPERIENCE;
 				obj->rID = 0; //unitialized?
 				obj->rVal = seerExpGold[i];
@@ -2774,9 +2766,8 @@ void CRmgTemplateZone::addAllPossibleObjects(CMapGenerator* gen)
 
 			oi.generateObject = [i, randomAppearance, gen, this, generateArtInfo]() -> CGObjectInstance *
 			{
-				auto obj = new CGSeerHut();
-				obj->ID = Obj::SEER_HUT;
-				obj->subID = randomAppearance;
+				auto factory = VLC->objtypeh->getHandlerFor(Obj::SEER_HUT, randomAppearance);
+				auto obj = (CGSeerHut *) factory->create(ObjectTemplate());
 				obj->rewardType = CGSeerHut::RESOURCES;
 				obj->rID = Res::GOLD;
 				obj->rVal = seerExpGold[i];
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index ac6e602be..590275bfd 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -152,6 +152,12 @@ void MapComparer::compareObject(const CGObjectInstance * actual, const CGObjectI
 {
 	BOOST_CHECK_EQUAL(actual->getStringId(), expected->getStringId());
 	BOOST_CHECK_EQUAL(typeid(actual).name(), typeid(expected).name());//todo: remove and use just comparison
+
+	std::string actualFullID = boost::to_string(boost::format("%s(%d)|%s(%d)") % actual->typeName % actual->id % actual->subTypeName % actual->subID);
+	std::string expectedFullID = boost::to_string(boost::format("%s(%d)|%s(%d)") % expected->typeName % expected->id % expected->subTypeName % expected->subID);
+
+	BOOST_CHECK_EQUAL(actualFullID, expectedFullID);
+	BOOST_CHECK_EQUAL(actual->pos, expected->pos);
 }
 
 void MapComparer::compareObjects()

From 2d777ea67694363b75e7b651a12418c23362a901 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 14 Nov 2015 19:47:29 +0300
Subject: [PATCH 041/105] Small (temp) fix. Prevent nulls from serialization.

---
 lib/mapObjects/CObjectHandler.cpp | 4 ++--
 lib/mapObjects/ObjectTemplate.cpp | 2 +-
 lib/mapping/MapFormatJson.cpp     | 8 +++++---
 3 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index abb9136e4..bc4169a61 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -362,7 +362,7 @@ void CGObjectInstance::readJson(const JsonNode & json, bool withState)
 
 void CGObjectInstance::writeJsonOptions(JsonNode & json) const
 {
-
+	json.setType(JsonNode::DATA_STRUCT);
 }
 
 void CGObjectInstance::readJsonOptions(const JsonNode & json)
@@ -372,7 +372,7 @@ void CGObjectInstance::readJsonOptions(const JsonNode & json)
 
 void CGObjectInstance::writeJsonState(JsonNode & json) const
 {
-
+	json.setType(JsonNode::DATA_STRUCT);
 }
 
 void CGObjectInstance::readJsonState(const JsonNode & json)
diff --git a/lib/mapObjects/ObjectTemplate.cpp b/lib/mapObjects/ObjectTemplate.cpp
index b1696bf05..eb0bd584f 100644
--- a/lib/mapObjects/ObjectTemplate.cpp
+++ b/lib/mapObjects/ObjectTemplate.cpp
@@ -258,10 +258,10 @@ void ObjectTemplate::readJson(const JsonNode &node)
 
 void ObjectTemplate::writeJson(JsonNode & node) const
 {
+	node.setType(JsonNode::DATA_STRUCT);
 	//todo: ObjectTemplate::writeJson
 }
 
-
 ui32 ObjectTemplate::getWidth() const
 {
 	return usedTiles.empty() ? 0 : usedTiles.front().size();
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 409dd0d5d..3044fb4d8 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -72,6 +72,9 @@ namespace TriggeredEventsDetail
 
 		//todo: save identifier
 
+		if(event.objectType != -1)
+			data["type"].Float() = event.objectType;
+
 		if(event.value != -1)
 			data["value"].Float() = event.value;
 
@@ -84,7 +87,8 @@ namespace TriggeredEventsDetail
 			position[2].Float() = event.position.z;
 		}
 
-		asVector.push_back(data);
+		if(!data.isNull())
+			asVector.push_back(data);
 
 		return std::move(json);
 	}
@@ -590,8 +594,6 @@ void CMapLoaderJson::MapObjectLoader::construct()
 		return;
 	}
 
-	si32 type = owner->getIdentifier("object", typeName);
-
 	handler = VLC->objtypeh->getHandlerFor(typeName, subTypeName);
 
 	instance = handler->create(ObjectTemplate());

From 8a979d016f4c0e64f6ed4b4ddf0989c28efda0fd Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 14 Nov 2015 23:57:22 +0300
Subject: [PATCH 042/105] ObjectTemplate serialization (+) generated map
 displayed correctly in editor

---
 lib/mapObjects/CObjectHandler.cpp |  4 +-
 lib/mapObjects/ObjectTemplate.cpp | 96 +++++++++++++++++++++++++++++--
 lib/mapObjects/ObjectTemplate.h   |  4 +-
 3 files changed, 94 insertions(+), 10 deletions(-)

diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index bc4169a61..a6b3182ff 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -335,7 +335,7 @@ void CGObjectInstance::writeJson(JsonNode & json, bool withState) const
 	json["y"].Float() = pos.y;
 	json["l"].Float() = pos.z;
 
-	appearance.writeJson(json["template"]);
+	appearance.writeJson(json["template"], false);
 	writeJsonOptions(json["options"]);
 	if(withState)
 		writeJsonState(json["state"]);
@@ -352,7 +352,7 @@ void CGObjectInstance::readJson(const JsonNode & json, bool withState)
 	pos.y = json["y"].Float();
 	pos.z = json["l"].Float();
 
-	appearance.readJson(json["template"]);
+	appearance.readJson(json["template"], false);
 	readJsonOptions(json["options"]);
 	if(withState)
 		readJsonState(json["state"]);
diff --git a/lib/mapObjects/ObjectTemplate.cpp b/lib/mapObjects/ObjectTemplate.cpp
index eb0bd584f..bf87a4b2a 100644
--- a/lib/mapObjects/ObjectTemplate.cpp
+++ b/lib/mapObjects/ObjectTemplate.cpp
@@ -183,7 +183,7 @@ void ObjectTemplate::readMap(CBinaryReader & reader)
 	}
 }
 
-void ObjectTemplate::readJson(const JsonNode &node)
+void ObjectTemplate::readJson(const JsonNode &node, const bool withTerrain)
 {
 	animationFile = node["animation"].String();
 
@@ -202,7 +202,7 @@ void ObjectTemplate::readJson(const JsonNode &node)
 	else
 		visitDir = 0x00;
 
-	if (!node["allowedTerrains"].isNull())
+	if(withTerrain && !node["allowedTerrains"].isNull())
 	{
 		for (auto & entry : node["allowedTerrains"].Vector())
 			allowedTerrains.insert(ETerrainType(vstd::find_pos(GameConstants::TERRAIN_NAMES, entry.String())));
@@ -211,11 +211,14 @@ void ObjectTemplate::readJson(const JsonNode &node)
 	{
 		for (size_t i=0; i< GameConstants::TERRAIN_TYPES; i++)
 			allowedTerrains.insert(ETerrainType(i));
+
+		allowedTerrains.erase(ETerrainType::ROCK);
 	}
 
-	if (allowedTerrains.empty())
+	if(withTerrain && allowedTerrains.empty())
 		logGlobal->warnStream() << "Loaded template without allowed terrains!";
 
+
 	auto charToTile = [&](const char & ch) -> ui8
 	{
 		switch (ch)
@@ -256,10 +259,91 @@ void ObjectTemplate::readJson(const JsonNode &node)
 		printPriority = 0; //default value
 }
 
-void ObjectTemplate::writeJson(JsonNode & node) const
+void ObjectTemplate::writeJson(JsonNode & node, const bool withTerrain) const
 {
-	node.setType(JsonNode::DATA_STRUCT);
-	//todo: ObjectTemplate::writeJson
+	node["animation"].String() = animationFile;
+
+	if(visitDir != 0x0)
+	{
+		JsonVector & visitDirs = node["visitableFrom"].Vector();
+		visitDirs.resize(3);
+
+		visitDirs[0].String().resize(3);
+		visitDirs[1].String().resize(3);
+		visitDirs[2].String().resize(3);
+
+		visitDirs[0].String()[0] = (visitDir & 1)	? '+' : '-';
+		visitDirs[0].String()[1] = (visitDir & 2)	? '+' : '-';
+		visitDirs[0].String()[2] = (visitDir & 4)	? '+' : '-';
+		visitDirs[1].String()[2] = (visitDir & 8)	? '+' : '-';
+		visitDirs[2].String()[2] = (visitDir & 16)	? '+' : '-';
+		visitDirs[2].String()[1] = (visitDir & 32)	? '+' : '-';
+		visitDirs[2].String()[0] = (visitDir & 64)	? '+' : '-';
+		visitDirs[1].String()[0] = (visitDir & 128) ? '+' : '-';
+
+		visitDirs[1].String()[1] = '-';//??? center
+	}
+
+	if(withTerrain)
+	{
+		//assumed that ROCK terrain not included
+		if(allowedTerrains.size() < (GameConstants::TERRAIN_TYPES - 1))
+		{
+			JsonVector & data = node["allowedTerrains"].Vector();
+
+			for(auto type : allowedTerrains)
+			{
+				JsonNode value(JsonNode::DATA_STRING);
+				value.String() = GameConstants::TERRAIN_NAMES[type.num];
+				data.push_back(value);
+			}
+		}
+	}
+//todo: use lookup?
+	auto tileToChar = [&](const ui8 & tile) -> char
+	{
+		if(tile & VISIBLE)
+		{
+			if(tile & BLOCKED)
+			{
+				if(tile & VISITABLE)
+					return 'A';
+				else
+					return 'B';
+			}
+			else
+				return 'V';
+		}
+		else
+		{
+			if(tile & BLOCKED)
+			{
+				if(tile & VISITABLE)
+					return 'T';
+				else
+					return 'H';
+			}
+			else
+				return '0';
+		}
+	};
+
+	size_t height = getHeight();
+	size_t width  = getWidth();
+
+	JsonVector & mask = node["mask"].Vector();
+
+
+	for(size_t i=0; i < height; i++)
+	{
+		JsonNode lineNode(JsonNode::DATA_STRING);
+
+		std::string & line = lineNode.String();
+		line.resize(width);
+		for(size_t j=0; j < width; j++)
+			line[j] = tileToChar(usedTiles[height - 1 - i][width - 1 - j]);
+		mask.push_back(lineNode);
+	}
 }
 
 ui32 ObjectTemplate::getWidth() const
diff --git a/lib/mapObjects/ObjectTemplate.h b/lib/mapObjects/ObjectTemplate.h
index 0e175bd0f..bbb3522b9 100644
--- a/lib/mapObjects/ObjectTemplate.h
+++ b/lib/mapObjects/ObjectTemplate.h
@@ -73,8 +73,8 @@ public:
 	void readTxt(CLegacyConfigParser & parser);
 	void readMsk();
 	void readMap(CBinaryReader & reader);
-	void readJson(const JsonNode & node);
-	void writeJson(JsonNode & node) const;
+	void readJson(const JsonNode & node, const bool withTerrain = true);
+	void writeJson(JsonNode & node, const bool withTerrain = true) const;
 
 	bool operator==(const ObjectTemplate& ot) const { return (id == ot.id && subid == ot.subid); }
 

From e7359c9a3677d20ccb74770e397517f1bd9d8f8b Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 15 Nov 2015 18:07:15 +0300
Subject: [PATCH 043/105] Serialize tempOwner

---
 lib/mapObjects/CObjectHandler.cpp | 12 ++++++++++--
 test/MapComparer.cpp              |  1 +
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index a6b3182ff..06b6057d0 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -18,6 +18,7 @@
 #include "../filesystem/ResourceID.h"
 #include "../IGameCallback.h"
 #include "../CGameState.h"
+#include "../StringConstants.h"
 #include "../mapping/CMap.h"
 
 #include "CObjectClassesHandler.h"
@@ -363,11 +364,19 @@ void CGObjectInstance::readJson(const JsonNode & json, bool withState)
 void CGObjectInstance::writeJsonOptions(JsonNode & json) const
 {
 	json.setType(JsonNode::DATA_STRUCT);
+
+	if(tempOwner != PlayerColor::UNFLAGGABLE)
+	{
+		PlayerColor p (tempOwner);
+		if(p.isValidPlayer())
+			json["owner"].String() = GameConstants::PLAYER_COLOR_NAMES[p.getNum()];
+	}
 }
 
 void CGObjectInstance::readJsonOptions(const JsonNode & json)
 {
-
+	if(json["owner"].getType() == JsonNode::DATA_STRING)
+		tempOwner = PlayerColor(vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, json["owner"].String()));
 }
 
 void CGObjectInstance::writeJsonState(JsonNode & json) const
@@ -380,7 +389,6 @@ void CGObjectInstance::readJsonState(const JsonNode & json)
 
 }
 
-
 CGObjectInstanceBySubIdFinder::CGObjectInstanceBySubIdFinder(CGObjectInstance * obj) : obj(obj)
 {
 
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 590275bfd..1bdd638ca 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -158,6 +158,7 @@ void MapComparer::compareObject(const CGObjectInstance * actual, const CGObjectI
 
 	BOOST_CHECK_EQUAL(actualFullID, expectedFullID);
 	BOOST_CHECK_EQUAL(actual->pos, expected->pos);
+	BOOST_CHECK_EQUAL(actual->tempOwner,expected->tempOwner);
 }
 
 void MapComparer::compareObjects()

From 126a8219603a8ed4a301acd8def59890dff4da3d Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 15 Nov 2015 18:29:00 +0300
Subject: [PATCH 044/105] Tweak tests setup.

---
 test/CMapFormatTest.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index c8105de25..fdf5594bb 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -40,6 +40,9 @@ public:
 		opt.setHasTwoLevels(true);
 		opt.setPlayerCount(2);
 
+		opt.setPlayerTypeForStandardPlayer(PlayerColor(0), EPlayerType::HUMAN);
+		opt.setPlayerTypeForStandardPlayer(PlayerColor(1), EPlayerType::HUMAN);
+
 		CMapGenerator gen;
 
 		initialMap = gen.generate(&opt, TEST_RANDOM_SEED);
@@ -71,6 +74,8 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 		tmp.write((const char *)serializeBuffer.getBuffer().data(),serializeBuffer.getSize());
 		tmp.flush();
 		tmp.close();
+
+		logGlobal->infoStream() << "Test map has been saved to " << path;
 	}
 
 

From 6977fc3a14503414465c804359437c148e249baa Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 16 Nov 2015 14:43:44 +0300
Subject: [PATCH 045/105] Move test filesystem creation to global fixture

---
 lib/mapObjects/CObjectHandler.cpp | 1 +
 test/CMapEditManagerTest.cpp      | 8 +-------
 test/CVcmiTestConfig.cpp          | 8 ++++++++
 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 06b6057d0..e9a3432d8 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -365,6 +365,7 @@ void CGObjectInstance::writeJsonOptions(JsonNode & json) const
 {
 	json.setType(JsonNode::DATA_STRUCT);
 
+	//todo: move up to descendants
 	if(tempOwner != PlayerColor::UNFLAGGABLE)
 	{
 		PlayerColor p (tempOwner);
diff --git a/test/CMapEditManagerTest.cpp b/test/CMapEditManagerTest.cpp
index 5a045a811..b1e2fd735 100644
--- a/test/CMapEditManagerTest.cpp
+++ b/test/CMapEditManagerTest.cpp
@@ -12,11 +12,9 @@
 #include "StdInc.h"
 #include <boost/test/unit_test.hpp>
 
+#include "../lib/filesystem/ResourceID.h"
 #include "../lib/mapping/CMapService.h"
 #include "../lib/mapping/CMap.h"
-#include "../lib/filesystem/Filesystem.h"
-#include "../lib/filesystem/CFilesystemLoader.h"
-#include "../lib/filesystem/AdapterLoaders.h"
 #include "../lib/JsonNode.h"
 #include "../lib/mapping/CMapEditManager.h"
 #include "../lib/int3.h"
@@ -117,10 +115,6 @@ BOOST_AUTO_TEST_CASE(CMapEditManager_DrawTerrain_View)
 	try
 	{
 		// Load maps and json config
-		const std::string TEST_DATA_DIR = "test/";
-
-		auto loader = new CFilesystemLoader("test/", TEST_DATA_DIR);
-		dynamic_cast<CFilesystemList*>(CResourceHandler::get())->addLoader(loader, false);
 		const auto originalMap = CMapService::loadMap("test/TerrainViewTest");
 		auto map = CMapService::loadMap("test/TerrainViewTest");
 		logGlobal->infoStream() << "Loaded test map successfully.";
diff --git a/test/CVcmiTestConfig.cpp b/test/CVcmiTestConfig.cpp
index cbe0deced..96a36ddfd 100644
--- a/test/CVcmiTestConfig.cpp
+++ b/test/CVcmiTestConfig.cpp
@@ -18,6 +18,9 @@
 #include "../lib/VCMI_Lib.h"
 #include "../lib/logging/CLogger.h"
 #include "../lib/CConfigHandler.h"
+#include "../lib/filesystem/Filesystem.h"
+#include "../lib/filesystem/CFilesystemLoader.h"
+#include "../lib/filesystem/AdapterLoaders.h"
 
 CVcmiTestConfig::CVcmiTestConfig()
 {
@@ -29,6 +32,11 @@ CVcmiTestConfig::CVcmiTestConfig()
 	logConfig.configure();
 	loadDLLClasses();
 	logGlobal->infoStream() << "Initialized global test setup.";
+
+	const std::string TEST_DATA_DIR = "test/";
+
+	auto loader = new CFilesystemLoader("test/", TEST_DATA_DIR);
+	dynamic_cast<CFilesystemList*>(CResourceHandler::get())->addLoader(loader, false);
 }
 
 CVcmiTestConfig::~CVcmiTestConfig()

From b56b7017ba18568b7c00aa8760f8c525c366c8bc Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 16 Nov 2015 16:30:40 +0300
Subject: [PATCH 046/105] Added stubs for some Map objects serialization

---
 lib/mapObjects/CArmedInstance.cpp |  12 ++-
 lib/mapObjects/CArmedInstance.h   |   3 +
 lib/mapObjects/MiscObjects.cpp    | 142 ++++++++++++++++++++++++++----
 lib/mapObjects/MiscObjects.h      |  34 ++++++-
 4 files changed, 173 insertions(+), 18 deletions(-)

diff --git a/lib/mapObjects/CArmedInstance.cpp b/lib/mapObjects/CArmedInstance.cpp
index adc47a7a5..74eb49aea 100644
--- a/lib/mapObjects/CArmedInstance.cpp
+++ b/lib/mapObjects/CArmedInstance.cpp
@@ -107,7 +107,7 @@ void CArmedInstance::updateMoraleBonusFromArmy()
 			undeadModifier = new Bonus(Bonus::PERMANENT, Bonus::MORALE, Bonus::ARMY, -1, UNDEAD_MODIFIER_ID, VLC->generaltexth->arraytxt[116]);
 			undeadModifier->description = undeadModifier->description.substr(0, undeadModifier->description.size()-2);//trim value
 			addNewBonus(undeadModifier);
-		}			
+		}
 	}
 	else if(undeadModifier)
 		removeBonus(undeadModifier);
@@ -131,3 +131,13 @@ CBonusSystemNode * CArmedInstance::whatShouldBeAttached()
 {
 	return this;
 }
+
+void CArmedInstance::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CArmedInstance::readJsonOptions(const JsonNode& json)
+{
+
+}
diff --git a/lib/mapObjects/CArmedInstance.h b/lib/mapObjects/CArmedInstance.h
index 0ebe2abc1..bf22a527a 100644
--- a/lib/mapObjects/CArmedInstance.h
+++ b/lib/mapObjects/CArmedInstance.h
@@ -40,4 +40,7 @@ public:
 		h & static_cast<CBonusSystemNode&>(*this);
 		h & static_cast<CCreatureSet&>(*this);
 	}
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 };
diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index 025920192..f6d5947bb 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -103,16 +103,16 @@ std::string CGCreature::getHoverText(const CGHeroInstance * hero) const
 {
 	std::string hoverName;
 	if(hero->hasVisions(this, 0))
-	{		
+	{
 		MetaString ms;
 		ms << stacks.begin()->second->count;
 		ms << " " ;
 		ms.addTxt(MetaString::CRE_PL_NAMES,subID);
-		
+
 		ms << "\n";
-		
+
 		int decision = takenAction(hero, true);
-		
+
 		switch (decision)
 		{
 		case FIGHT:
@@ -123,19 +123,19 @@ std::string CGCreature::getHoverText(const CGHeroInstance * hero) const
 			break;
 		case JOIN_FOR_FREE:
 			ms.addTxt(MetaString::GENERAL_TXT,243);
-			break;					
+			break;
 		default: //decision = cost in gold
 			VLC->generaltexth->allTexts[244];
-			ms << boost::to_string(boost::format(VLC->generaltexth->allTexts[244]) % decision);			
+			ms << boost::to_string(boost::format(VLC->generaltexth->allTexts[244]) % decision);
 			break;
-		}		
+		}
 
-		ms.toString(hoverName);		
+		ms.toString(hoverName);
 	}
 	else
 	{
-		hoverName = getHoverText(hero->tempOwner);	
-	}	
+		hoverName = getHoverText(hero->tempOwner);
+	}
 
 	const JsonNode & texts = VLC->generaltexth->localizedTexts["adventureMap"]["monsterThreat"];
 
@@ -557,6 +557,17 @@ int CGCreature::getNumberOfStacks(const CGHeroInstance *hero) const
 	return split;
 }
 
+void CGCreature::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CGCreature::readJsonOptions(const JsonNode& json)
+{
+
+}
+
+//CGMine
 void CGMine::onHeroVisit( const CGHeroInstance * h ) const
 {
 	int relations = cb->gameState()->getPlayerRelations(h->tempOwner, tempOwner);
@@ -693,6 +704,17 @@ void CGMine::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) con
 		cb->startBattleI(hero, this);
 }
 
+void CGMine::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CGMine::readJsonOptions(const JsonNode& json)
+{
+
+}
+
+
 std::string CGResource::getHoverText(PlayerColor player) const
 {
 	return VLC->generaltexth->restypes[subID];
@@ -777,6 +799,17 @@ void CGResource::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer)
 		cb->startBattleI(hero, this);
 }
 
+void CGResource::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CGResource::readJsonOptions(const JsonNode& json)
+{
+
+}
+
+
 CGTeleport::CGTeleport() :
 	type(UNKNOWN), channel(TeleportChannelID())
 {
@@ -1223,6 +1256,16 @@ void CGArtifact::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer)
 		cb->startBattleI(hero, this);
 }
 
+void CGArtifact::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CGArtifact::readJsonOptions(const JsonNode& json)
+{
+
+}
+
 void CGWitchHut::initObj()
 {
 	if (allowedAbilities.empty()) //this can happen for RMG. regular maps load abilities from map file
@@ -1280,6 +1323,17 @@ std::string CGWitchHut::getHoverText(const CGHeroInstance * hero) const
 	return hoverName;
 }
 
+void CGWitchHut::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CGWitchHut::readJsonOptions(const JsonNode& json)
+{
+
+}
+
+
 void CGMagicWell::onHeroVisit( const CGHeroInstance * h ) const
 {
 	int message;
@@ -1419,6 +1473,17 @@ std::string CGShrine::getHoverText(const CGHeroInstance * hero) const
 	return hoverName;
 }
 
+void CGShrine::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CGShrine::readJsonOptions(const JsonNode& json)
+{
+
+}
+
+
 void CGSignBottle::initObj()
 {
 	//if no text is set than we pick random from the predefined ones
@@ -1445,11 +1510,15 @@ void CGSignBottle::onHeroVisit( const CGHeroInstance * h ) const
 		cb->removeObject(this);
 }
 
-//TODO: remove
-//void CGScholar::giveAnyBonus( const CGHeroInstance * h ) const
-//{
-//
-//}
+void CGSignBottle::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CGSignBottle::readJsonOptions(const JsonNode& json)
+{
+
+}
 
 void CGScholar::onHeroVisit( const CGHeroInstance * h ) const
 {
@@ -1524,6 +1593,16 @@ void CGScholar::initObj()
 	}
 }
 
+void CGScholar::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CGScholar::readJsonOptions(const JsonNode& json)
+{
+
+}
+
 void CGGarrison::onHeroVisit (const CGHeroInstance *h) const
 {
 	int ally = cb->gameState()->getPlayerRelations(h->tempOwner, tempOwner);
@@ -1560,6 +1639,16 @@ void CGGarrison::battleFinished(const CGHeroInstance *hero, const BattleResult &
 		onHeroVisit(hero);
 }
 
+void CGGarrison::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CGGarrison::readJsonOptions(const JsonNode& json)
+{
+
+}
+
 void CGMagi::initObj()
 {
 	if (ID == Obj::EYE_OF_MAGI)
@@ -1674,7 +1763,7 @@ void CGShipyard::getOutOffsets( std::vector<int3> &offsets ) const
 		int3(-3,0,0), int3(1,0,0), //AB
 		int3(-3,1,0), int3(1,1,0), int3(-2,1,0), int3(0,1,0), int3(-1,1,0), //CDEFG
 		int3(-3,-1,0), int3(1,-1,0), int3(-2,-1,0), int3(0,-1,0), int3(-1,-1,0) //HIJKL
-	}; 
+	};
 }
 
 void CGShipyard::onHeroVisit( const CGHeroInstance * h ) const
@@ -1696,6 +1785,17 @@ void CGShipyard::onHeroVisit( const CGHeroInstance * h ) const
 	}
 }
 
+void CGShipyard::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CGShipyard::readJsonOptions(const JsonNode& json)
+{
+
+}
+
+
 void CCartographer::onHeroVisit( const CGHeroInstance * h ) const
 {
 	//if player has not bought map of this subtype yet and underground exist for stalagmite cartographer
@@ -1860,3 +1960,13 @@ void CGLighthouse::giveBonusTo( PlayerColor player ) const
 	gb.bonus.sid = id.getNum();
 	cb->sendAndApply(&gb);
 }
+
+void CGLighthouse::writeJsonOptions(JsonNode& json) const
+{
+
+}
+
+void CGLighthouse::readJsonOptions(const JsonNode& json)
+{
+
+}
diff --git a/lib/mapObjects/MiscObjects.h b/lib/mapObjects/MiscObjects.h
index bff8630c4..d2387b12d 100644
--- a/lib/mapObjects/MiscObjects.h
+++ b/lib/mapObjects/MiscObjects.h
@@ -82,6 +82,9 @@ public:
 	}
 protected:
 	void setPropertyDer(ui8 what, ui32 val) override;
+
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 private:
 
 	void fight(const CGHeroInstance *h) const;
@@ -107,6 +110,9 @@ public:
 		h & static_cast<CGObjectInstance&>(*this);
 		h & message;
 	}
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 };
 
 class DLL_LINKAGE CGWitchHut : public CPlayersVisited
@@ -124,6 +130,9 @@ public:
 		h & static_cast<CPlayersVisited&>(*this);
 		h & allowedAbilities & ability;
 	}
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 };
 
 class DLL_LINKAGE CGScholar : public CGObjectInstance
@@ -133,7 +142,6 @@ public:
 	EBonusType bonusType;
 	ui16 bonusID; //ID of skill/spell
 
-//	void giveAnyBonus(const CGHeroInstance * h) const; //TODO: remove
 	CGScholar() : bonusType(EBonusType::RANDOM){};
 	void onHeroVisit(const CGHeroInstance * h) const override;
 	void initObj() override;
@@ -142,6 +150,9 @@ public:
 		h & static_cast<CGObjectInstance&>(*this);
 		h & bonusType & bonusID;
 	}
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 };
 
 class DLL_LINKAGE CGGarrison : public CArmedInstance
@@ -158,6 +169,9 @@ public:
 		h & static_cast<CArmedInstance&>(*this);
 		h & removableUnits;
 	}
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 };
 
 class DLL_LINKAGE CGArtifact : public CArmedInstance
@@ -182,6 +196,9 @@ public:
 		h & static_cast<CArmedInstance&>(*this);
 		h & message & storedArtifact;
 	}
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 };
 
 class DLL_LINKAGE CGResource : public CArmedInstance
@@ -204,6 +221,9 @@ public:
 		h & static_cast<CArmedInstance&>(*this);
 		h & amount & message;
 	}
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 };
 
 class DLL_LINKAGE CGShrine : public CPlayersVisited
@@ -220,6 +240,9 @@ public:
 		h & static_cast<CPlayersVisited&>(*this);;
 		h & spell;
 	}
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 };
 
 class DLL_LINKAGE CGMine : public CArmedInstance
@@ -247,6 +270,9 @@ public:
 		h & producedResource & producedQuantity;
 	}
 	ui32 defaultResProduction();
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 };
 
 struct DLL_LINKAGE TeleportChannel
@@ -411,6 +437,9 @@ public:
 		h & static_cast<CGObjectInstance&>(*this);
 		h & static_cast<IShipyard&>(*this);
 	}
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 };
 
 class DLL_LINKAGE CGMagi : public CGObjectInstance
@@ -477,4 +506,7 @@ public:
 		h & static_cast<CGObjectInstance&>(*this);
 	}
 	void giveBonusTo( PlayerColor player ) const;
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 };

From 3f79d001c1681e821b43b975d6f0aad031ede9e0 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 16 Nov 2015 17:38:42 +0300
Subject: [PATCH 047/105] Fix subObject identification

---
 lib/CModHandler.cpp                      | 13 +++++++++++++
 lib/CModHandler.h                        |  6 ++++--
 lib/mapObjects/CObjectClassesHandler.cpp |  9 ++++++---
 lib/mapObjects/CObjectHandler.cpp        |  2 +-
 4 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/lib/CModHandler.cpp b/lib/CModHandler.cpp
index 292293cbe..c02a520ab 100644
--- a/lib/CModHandler.cpp
+++ b/lib/CModHandler.cpp
@@ -884,3 +884,16 @@ void CModHandler::afterLoad()
 	std::ofstream file(*CResourceHandler::get()->getResourceName(ResourceID("config/modSettings.json")), std::ofstream::trunc);
 	file << modSettings;
 }
+
+std::string CModHandler::normalizeIdentifier(const std::string & scope, const std::string & remoteScope, const std::string & identifier) const
+{
+	auto p = splitString(identifier, ':');
+
+	if(p.first.empty())
+		p.first = scope;
+
+	if(p.first == remoteScope)
+		p.first.clear();
+
+	return p.first.empty() ? p.second : p.first +":"+p.second;
+}
diff --git a/lib/CModHandler.h b/lib/CModHandler.h
index 7d4f00fe5..439fcf728 100644
--- a/lib/CModHandler.h
+++ b/lib/CModHandler.h
@@ -73,7 +73,7 @@ public:
 	/// Function callback will be called during ID resolution phase of loading
 	void requestIdentifier(std::string scope, std::string type, std::string name, const std::function<void(si32)> & callback);
 	///fullName = [remoteScope:]type.name
-	void requestIdentifier(std::string scope, std::string fullName, const std::function<void(si32)> & callback);	
+	void requestIdentifier(std::string scope, std::string fullName, const std::function<void(si32)> & callback);
 	void requestIdentifier(std::string type, const JsonNode & name, const std::function<void(si32)> & callback);
 	void requestIdentifier(const JsonNode & name, const std::function<void(si32)> & callback);
 
@@ -253,7 +253,7 @@ public:
 
 		int CREEP_SIZE; // neutral stacks won't grow beyond this number
 		int WEEKLY_GROWTH; //percent
-		int NEUTRAL_STACK_EXP; 
+		int NEUTRAL_STACK_EXP;
 		int MAX_BUILDING_PER_TURN;
 		bool DWELLINGS_ACCUMULATE_CREATURES;
 		bool ALL_CREATURES_GET_DOUBLE_MONTHS;
@@ -282,6 +282,8 @@ public:
 
 	CModHandler();
 
+	std::string normalizeIdentifier(const std::string & scope, const std::string & remoteScope, const std::string & identifier) const;
+
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
 		h & allMods & activeMods & settings & modules & identifiers;
diff --git a/lib/mapObjects/CObjectClassesHandler.cpp b/lib/mapObjects/CObjectClassesHandler.cpp
index 78e80d6ef..a833034d9 100644
--- a/lib/mapObjects/CObjectClassesHandler.cpp
+++ b/lib/mapObjects/CObjectClassesHandler.cpp
@@ -154,11 +154,14 @@ void CObjectClassesHandler::loadObjectEntry(const std::string & identifier, cons
 		logGlobal->errorStream() << "Handler with name " << obj->handlerName << " was not found!";
 		return;
 	}
+
+	std::string convertedId = VLC->modh->normalizeIdentifier(entry.meta, "core", identifier);
+
 	si32 id = selectNextID(entry["index"], obj->subObjects, 1000);
 
 	auto handler = handlerConstructors.at(obj->handlerName)();
 	handler->setType(obj->id, id);
-	handler->setTypeName(obj->identifier, identifier);
+	handler->setTypeName(obj->identifier, convertedId);
 
 	if (customNames.count(obj->id) && customNames.at(obj->id).size() > id)
 		handler->init(entry, customNames.at(obj->id).at(id));
@@ -175,10 +178,10 @@ void CObjectClassesHandler::loadObjectEntry(const std::string & identifier, cons
 		legacyTemplates.erase(range.first, range.second);
 	}
 
-	logGlobal->debugStream() << "Loaded object " << obj->identifier << "(" << obj->id << ")" << ":" << identifier << "(" << id << ")" ;
+	logGlobal->debugStream() << "Loaded object " << obj->identifier << "(" << obj->id << ")" << ":" << convertedId << "(" << id << ")" ;
 	assert(!obj->subObjects.count(id)); // DO NOT override
 	obj->subObjects[id] = handler;
-	obj->subIds[identifier] = id;//todo: scope
+	obj->subIds[convertedId] = id;
 }
 
 CObjectClassesHandler::ObjectContainter * CObjectClassesHandler::loadFromJson(const JsonNode & json, const std::string & name)
diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index e9a3432d8..48f0a8048 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -143,7 +143,7 @@ const std::string & CGObjectInstance::getStringId() const
 	if(stringId == "")
 	{
 		boost::format fmt("%s_%d");
-		fmt % "object" % id.getNum();
+		fmt % typeName % id.getNum();
 		stringId = fmt.str();
 	}
 

From 3bf9696b1343663c06378780bb17544d57e8ee15 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 5 Dec 2015 12:04:00 +0300
Subject: [PATCH 048/105] Tweaks

---
 lib/mapping/MapFormatJson.cpp | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 3044fb4d8..a9e0f8d5a 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -15,6 +15,8 @@
 #include "../filesystem/COutputStream.h"
 #include "CMap.h"
 #include "../CModHandler.h"
+#include "../CHeroHandler.h"
+#include "../CTownHandler.h"
 #include "../VCMI_Lib.h"
 #include "../mapObjects/ObjectTemplate.h"
 #include "../mapObjects/CObjectHandler.h"
@@ -116,14 +118,6 @@ namespace TerrainDetail
 	};
 }
 
-namespace MapHeaderDetail
-{
-	static const std::array<std::string, PlayerColor::PLAYER_LIMIT_I>  playerColorNames =
-	{
-		"red", "blue", "tan", "green", "orange", "purple", "teal", "pink"
-	};
-}
-
 static std::string tailString(const std::string & input, char separator)
 {
 	std::string ret;
@@ -413,7 +407,7 @@ void CMapLoaderJson::readTeams(const JsonNode& input)
 		{
 			for(const JsonNode & playerData : srcVector[team].Vector())
 			{
-				PlayerColor player = PlayerColor(vstd::find_pos(MapHeaderDetail::playerColorNames, playerData.String()));
+				PlayerColor player = PlayerColor(vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, playerData.String()));
 				if(player.isValidPlayer())
 				{
 					if(map->players[player.getNum()].canAnyonePlay())
@@ -604,6 +598,16 @@ void CMapLoaderJson::MapObjectLoader::construct()
 void CMapLoaderJson::MapObjectLoader::configure()
 {
 	instance->readJson(configuration, false);
+
+	if(instance->ID == Obj::TOWN)
+	{
+		owner->map->towns.push_back(static_cast<CGTownInstance *>(instance));
+	}
+	if(instance->ID == Obj::HERO)
+	{
+		logGlobal->debugStream() << "Hero: " << VLC->heroh->heroes[instance->subID]->name << " at " << instance->pos;
+		owner->map->heroesOnMap.push_back(static_cast<CGHeroInstance*>(instance));
+	}
 }
 
 void CMapLoaderJson::readObjects()

From f33bcee84cfd3cc8d79c0cf498542f4db2c082cf Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 5 Dec 2015 13:56:38 +0300
Subject: [PATCH 049/105] post-merge fixes

---
 lib/CArtHandler.h                      | 2 +-
 lib/CCreatureHandler.h                 | 2 +-
 lib/CHeroHandler.h                     | 2 +-
 lib/Connection.h                       | 2 +-
 lib/mapObjects/CObjectClassesHandler.h | 4 ++--
 lib/mapObjects/CObjectHandler.h        | 2 +-
 lib/mapping/MapFormatJson.cpp          | 5 ++++-
 7 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/lib/CArtHandler.h b/lib/CArtHandler.h
index f9d860a2c..08317b75c 100644
--- a/lib/CArtHandler.h
+++ b/lib/CArtHandler.h
@@ -80,7 +80,7 @@ public:
 		h & static_cast<CBonusSystemNode&>(*this);
 		h & name & description & eventText & image & large & advMapDef & iconIndex &
 			price & possibleSlots & constituents & constituentOf & aClass & id;
-		if(version>=755)
+		if(version>=756)
 		{
 			h & identifier;
 		}
diff --git a/lib/CCreatureHandler.h b/lib/CCreatureHandler.h
index b78753f5d..23c480595 100644
--- a/lib/CCreatureHandler.h
+++ b/lib/CCreatureHandler.h
@@ -138,7 +138,7 @@ public:
 		h & idNumber & faction & sounds & animation;
 
 		h & doubleWide & special;
-		if(version>=755)
+		if(version>=756)
 		{
 			h & identifier;
 		}		
diff --git a/lib/CHeroHandler.h b/lib/CHeroHandler.h
index b0c22a4c6..ef037e9fd 100644
--- a/lib/CHeroHandler.h
+++ b/lib/CHeroHandler.h
@@ -92,7 +92,7 @@ public:
 		h & ID & imageIndex & initialArmy & heroClass & secSkillsInit & spec & specialty & spells & haveSpellBook & sex & special;
 		h & name & biography & specName & specDescr & specTooltip;
 		h & iconSpecSmall & iconSpecLarge & portraitSmall & portraitLarge;
-		if(version>=755)
+		if(version>=756)
 		{
 			h & identifier;
 		}		
diff --git a/lib/Connection.h b/lib/Connection.h
index 07c724af1..1af06160b 100644
--- a/lib/Connection.h
+++ b/lib/Connection.h
@@ -27,7 +27,7 @@
 #include "mapping/CCampaignHandler.h" //for CCampaignState
 #include "rmg/CMapGenerator.h" // for CMapGenOptions
 
-const ui32 version = 755;
+const ui32 version = 756;
 const ui32 minSupportedVersion = 753;
 
 class CISer;
diff --git a/lib/mapObjects/CObjectClassesHandler.h b/lib/mapObjects/CObjectClassesHandler.h
index eb3413239..6e88fdb7c 100644
--- a/lib/mapObjects/CObjectClassesHandler.h
+++ b/lib/mapObjects/CObjectClassesHandler.h
@@ -159,7 +159,7 @@ public:
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
 		h & type & subtype & templates & rmgInfo & objectName;
-		if(version >= 755)
+		if(version >= 756)
 		{
 			h & typeName & subTypeName;
 		}
@@ -186,7 +186,7 @@ class DLL_LINKAGE CObjectClassesHandler : public IHandlerBase
 		template <typename Handler> void serialize(Handler &h, const int version)
 		{
 			h & name & handlerName & base & subObjects;
-			if(version >= 755)
+			if(version >= 756)
 			{
 				h & identifier & subIds;
 			}
diff --git a/lib/mapObjects/CObjectHandler.h b/lib/mapObjects/CObjectHandler.h
index 114babff8..e4f89cc63 100644
--- a/lib/mapObjects/CObjectHandler.h
+++ b/lib/mapObjects/CObjectHandler.h
@@ -179,7 +179,7 @@ public:
 		h & pos & ID & subID & id & tempOwner & blockVisit & appearance;
 		//definfo is handled by map serializer
 
-		if(version >= 755)
+		if(version >= 756)
 		{
 			h & typeName & subTypeName;
 		}
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index a9e0f8d5a..155f14dec 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -21,6 +21,9 @@
 #include "../mapObjects/ObjectTemplate.h"
 #include "../mapObjects/CObjectHandler.h"
 #include "../mapObjects/CObjectClassesHandler.h"
+#include "../mapObjects/CGHeroInstance.h"
+#include "../mapObjects/CGTownInstance.h"
+
 #include "../StringConstants.h"
 
 namespace TriggeredEventsDetail
@@ -606,7 +609,7 @@ void CMapLoaderJson::MapObjectLoader::configure()
 	if(instance->ID == Obj::HERO)
 	{
 		logGlobal->debugStream() << "Hero: " << VLC->heroh->heroes[instance->subID]->name << " at " << instance->pos;
-		owner->map->heroesOnMap.push_back(static_cast<CGHeroInstance*>(instance));
+		owner->map->heroesOnMap.push_back(static_cast<CGHeroInstance *>(instance));
 	}
 }
 

From a638d0cd510246d98b85d98c99f2cc3868f7d8e9 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Fri, 15 Jan 2016 20:24:17 +0300
Subject: [PATCH 050/105] Creature set serialization

---
 lib/CCreatureHandler.cpp          | 10 ++++++
 lib/CCreatureHandler.h            |  4 ++-
 lib/CCreatureSet.cpp              | 59 ++++++++++++++++++++++++++++++-
 lib/CCreatureSet.h                | 18 ++++++++--
 lib/mapObjects/CArmedInstance.cpp |  6 ++--
 lib/mapObjects/CObjectHandler.cpp | 17 ++-------
 lib/mapObjects/CObjectHandler.h   | 12 ++-----
 lib/mapping/MapFormatJson.cpp     |  4 +--
 8 files changed, 97 insertions(+), 33 deletions(-)

diff --git a/lib/CCreatureHandler.cpp b/lib/CCreatureHandler.cpp
index 0ed47b201..cb356af1b 100644
--- a/lib/CCreatureHandler.cpp
+++ b/lib/CCreatureHandler.cpp
@@ -188,6 +188,16 @@ CCreatureHandler::CCreatureHandler()
 	loadCommanders();
 }
 
+const CCreature * CCreatureHandler::getCreature(const std::string & scope, const std::string & identifier) const
+{
+	boost::optional<si32> index = VLC->modh->identifiers.getIdentifier(scope, "creature", identifier);
+
+	if(!index)
+		throw std::runtime_error("Creature not found "+identifier);
+
+	return creatures[*index];
+}
+
 void CCreatureHandler::loadCommanders()
 {
 	JsonNode data(ResourceID("config/commanders.json"));
diff --git a/lib/CCreatureHandler.h b/lib/CCreatureHandler.h
index 23c480595..b97878a1c 100644
--- a/lib/CCreatureHandler.h
+++ b/lib/CCreatureHandler.h
@@ -141,7 +141,7 @@ public:
 		if(version>=756)
 		{
 			h & identifier;
-		}		
+		}
 	}
 
 	CCreature();
@@ -192,6 +192,8 @@ public:
 	std::vector< std::vector <ui8> > skillLevels; //how much of a bonus will be given to commander with every level. SPELL_POWER also gives CASTS and RESISTANCE
 	std::vector <std::pair <Bonus*, std::pair <ui8, ui8> > > skillRequirements; // first - Bonus, second - which two skills are needed to use it
 
+	const CCreature * getCreature(const std::string & scope, const std::string & identifier) const;
+
 	void deserializationFix();
 	CreatureID pickRandomMonster(CRandomGenerator & rand, int tier = -1) const; //tier <1 - CREATURES_PER_TOWN> or -1 for any
 	void addBonusForTier(int tier, Bonus *b); //tier must be <1-7>
diff --git a/lib/CCreatureSet.cpp b/lib/CCreatureSet.cpp
index 2a0d890f1..bf85fbda6 100644
--- a/lib/CCreatureSet.cpp
+++ b/lib/CCreatureSet.cpp
@@ -481,6 +481,28 @@ void CCreatureSet::armyChanged()
 {
 }
 
+void CCreatureSet::writeJson(JsonNode& json) const
+{
+	for(const auto & p : stacks)
+	{
+		JsonNode stack_node;
+		p.second->writeJson(stack_node);
+		json.Vector()[p.first.getNum()] = stack_node;
+	}
+}
+
+void CCreatureSet::readJson(const JsonNode& json)
+{
+	for(size_t idx = 0; idx < json.Vector().size(); idx++)
+	{
+		CStackInstance * new_stack = new CStackInstance();
+
+		new_stack->readJson(json.Vector()[idx]);
+
+		putStack(SlotID(idx), new_stack);
+	}
+}
+
 CStackInstance::CStackInstance()
 	: armyObj(_armyObj)
 {
@@ -605,7 +627,7 @@ std::string CStackInstance::bonusToString(const Bonus *bonus, bool description)
 	{
 		return VLC->getBth()->bonusToString(bonus, this, description);
 	}
-	
+
 }
 
 std::string CStackInstance::bonusToGraphics(const Bonus *bonus) const
@@ -700,6 +722,25 @@ ArtBearer::ArtBearer CStackInstance::bearerType() const
 	return ArtBearer::CREATURE;
 }
 
+void CStackInstance::writeJson(JsonNode& json) const
+{
+	if(idRand > -1)
+	{
+		json["level"].Float() = (int)idRand / 2;
+		json["upgraded"].Bool() = (idRand % 2) > 0;
+	}
+	CStackBasicDescriptor::writeJson(json);
+}
+
+void CStackInstance::readJson(const JsonNode& json)
+{
+	if(json["type"].String() == "")
+	{
+		idRand = json["level"].Float() * 2 + (int)json["upgraded"].Bool();
+	}
+	CStackBasicDescriptor::readJson(json);
+}
+
 CCommanderInstance::CCommanderInstance()
 {
 	init();
@@ -792,6 +833,22 @@ CStackBasicDescriptor::CStackBasicDescriptor(const CCreature *c, TQuantity Count
 {
 }
 
+void CStackBasicDescriptor::writeJson(JsonNode& json) const
+{
+	json.setType(JsonNode::DATA_STRUCT);
+	if(type)
+		json["type"].String() = type->identifier;
+	json["amount"].Float() = count;
+}
+
+void CStackBasicDescriptor::readJson(const JsonNode& json)
+{
+	auto typeName = json["type"].String();
+	if(typeName != "")
+		type = VLC->creh->getCreature("core", json["type"].String());
+	count = json["amount"].Float();
+}
+
 DLL_LINKAGE std::ostream & operator<<(std::ostream & str, const CStackInstance & sth)
 {
 	if(!sth.valid(true))
diff --git a/lib/CCreatureSet.h b/lib/CCreatureSet.h
index 08037f1dd..c1a5c8f54 100644
--- a/lib/CCreatureSet.h
+++ b/lib/CCreatureSet.h
@@ -14,7 +14,7 @@
  * Full text of license available in license.txt file, in main folder
  *
  */
-
+class JsonNode;
 class CCreature;
 class CGHeroInstance;
 class CArmedInstance;
@@ -34,6 +34,10 @@ public:
 	{
 		h & type & count;
 	}
+
+	void writeJson(JsonNode & json) const;
+
+	void readJson(const JsonNode & json);
 };
 
 class DLL_LINKAGE CStackInstance : public CBonusSystemNode, public CStackBasicDescriptor, public CArtifactSet
@@ -59,6 +63,10 @@ public:
 		BONUS_TREE_DESERIALIZATION_FIX
 	}
 
+	void writeJson(JsonNode & json) const;
+
+	void readJson(const JsonNode & json);
+
 	//overrides CBonusSystemNode
 	std::string bonusToString(const Bonus *bonus, bool description) const override; // how would bonus description look for this particular type of node
 	std::string bonusToGraphics(const Bonus *bonus) const; //file name of graphics from StackSkills , in future possibly others
@@ -110,7 +118,7 @@ public:
 	bool gainsLevel() const; //true if commander has lower level than should upon his experience
 	ui64 getPower() const override {return 0;};
 	int getExpRank() const override;
-	int getLevel() const override; 
+	int getLevel() const override;
 	ArtBearer::ArtBearer bearerType() const override; //from CArtifactSet
 
 	template <typename Handler> void serialize(Handler &h, const int version)
@@ -211,6 +219,12 @@ public:
 	{
 		h & stacks & formation;
 	}
+
+
+	void writeJson(JsonNode & json) const;
+
+	void readJson(const JsonNode & json);
+
 	operator bool() const
 	{
 		return !stacks.empty();
diff --git a/lib/mapObjects/CArmedInstance.cpp b/lib/mapObjects/CArmedInstance.cpp
index 928c35b8d..15964eb4b 100644
--- a/lib/mapObjects/CArmedInstance.cpp
+++ b/lib/mapObjects/CArmedInstance.cpp
@@ -135,10 +135,12 @@ CBonusSystemNode * CArmedInstance::whatShouldBeAttached()
 
 void CArmedInstance::writeJsonOptions(JsonNode& json) const
 {
-
+	CGObjectInstance::writeJsonOptions(json);
+	CCreatureSet::writeJson(json);
 }
 
 void CArmedInstance::readJsonOptions(const JsonNode& json)
 {
-
+	CGObjectInstance::readJsonOptions(json);
+	CCreatureSet::readJson(json);
 }
diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 5d617e714..66e2ae168 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -325,7 +325,7 @@ bool CGObjectInstance::passableFor(PlayerColor color) const
 	return false;
 }
 
-void CGObjectInstance::writeJson(JsonNode & json, bool withState) const
+void CGObjectInstance::writeJson(JsonNode & json) const
 {
 	logGlobal->debugStream() <<"Save: [" << pos << "] " << id << " " << ID << " " << subID << " " << typeName << " " << subTypeName;
 
@@ -338,11 +338,9 @@ void CGObjectInstance::writeJson(JsonNode & json, bool withState) const
 
 	appearance.writeJson(json["template"], false);
 	writeJsonOptions(json["options"]);
-	if(withState)
-		writeJsonState(json["state"]);
 }
 
-void CGObjectInstance::readJson(const JsonNode & json, bool withState)
+void CGObjectInstance::readJson(const JsonNode & json)
 {
 	if(json.getType() != JsonNode::DATA_STRUCT)
 	{
@@ -355,8 +353,6 @@ void CGObjectInstance::readJson(const JsonNode & json, bool withState)
 
 	appearance.readJson(json["template"], false);
 	readJsonOptions(json["options"]);
-	if(withState)
-		readJsonState(json["state"]);
 
 	logGlobal->debugStream() <<"Load: [" << pos << "] " << id << " " << ID << " " << subID << " " << typeName << " " << subTypeName;
 }
@@ -380,15 +376,6 @@ void CGObjectInstance::readJsonOptions(const JsonNode & json)
 		tempOwner = PlayerColor(vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, json["owner"].String()));
 }
 
-void CGObjectInstance::writeJsonState(JsonNode & json) const
-{
-	json.setType(JsonNode::DATA_STRUCT);
-}
-
-void CGObjectInstance::readJsonState(const JsonNode & json)
-{
-
-}
 
 CGObjectInstanceBySubIdFinder::CGObjectInstanceBySubIdFinder(CGObjectInstance * obj) : obj(obj)
 {
diff --git a/lib/mapObjects/CObjectHandler.h b/lib/mapObjects/CObjectHandler.h
index e4f89cc63..263a2cc1d 100644
--- a/lib/mapObjects/CObjectHandler.h
+++ b/lib/mapObjects/CObjectHandler.h
@@ -186,10 +186,10 @@ public:
 	}
 
 	///Entry point of Json serialization
-	void writeJson(JsonNode & json, bool withState = false) const;
+	void writeJson(JsonNode & json) const;
 
 	///Entry point of Json de-serialization
-	void readJson(const JsonNode & json, bool withState = false);
+	void readJson(const JsonNode & json);
 
 protected:
 	/// virtual method that allows synchronously update object state on server and all clients
@@ -206,14 +206,6 @@ protected:
 	///(!) do not forget to call inherited method  first when overriding
 	virtual void readJsonOptions(const JsonNode & json);
 
-	///Saves object-type specific state
-	///(!) do not forget to call inherited method  first when overriding
-	virtual void writeJsonState(JsonNode & json) const;
-
-	///Loads object-type specific state
-	///(!) do not forget to call inherited method  first  when overriding
-	virtual void readJsonState(const JsonNode & json);
-
 private:
 	mutable std::string stringId;///<alternate id, dynamically generated, do not serialize
 };
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 155f14dec..95684d4c0 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -600,7 +600,7 @@ void CMapLoaderJson::MapObjectLoader::construct()
 
 void CMapLoaderJson::MapObjectLoader::configure()
 {
-	instance->readJson(configuration, false);
+	instance->readJson(configuration);
 
 	if(instance->ID == Obj::TOWN)
 	{
@@ -856,7 +856,7 @@ void CMapSaverJson::writeObjects()
 	JsonNode data(JsonNode::DATA_STRUCT);
 
 	for(const CGObjectInstance * obj : map->objects)
-		obj->writeJson(data[obj->getStringId()], false);
+		obj->writeJson(data[obj->getStringId()]);
 
 	addToArchive(data, OBJECTS_FILE_NAME);
 }

From b0c4ea59470b41bb21b2a3b8b413bb87b20ccf88 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 23 Jan 2016 17:43:20 +0300
Subject: [PATCH 051/105] Fix.

---
 lib/mapObjects/CArmedInstance.cpp | 4 ++--
 lib/mapObjects/CObjectHandler.cpp | 5 +++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/mapObjects/CArmedInstance.cpp b/lib/mapObjects/CArmedInstance.cpp
index 15964eb4b..6b3b647e6 100644
--- a/lib/mapObjects/CArmedInstance.cpp
+++ b/lib/mapObjects/CArmedInstance.cpp
@@ -136,11 +136,11 @@ CBonusSystemNode * CArmedInstance::whatShouldBeAttached()
 void CArmedInstance::writeJsonOptions(JsonNode& json) const
 {
 	CGObjectInstance::writeJsonOptions(json);
-	CCreatureSet::writeJson(json);
+	CCreatureSet::writeJson(json["army"]);
 }
 
 void CArmedInstance::readJsonOptions(const JsonNode& json)
 {
 	CGObjectInstance::readJsonOptions(json);
-	CCreatureSet::readJson(json);
+	CCreatureSet::readJson(json["army"]);
 }
diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 66e2ae168..d61bcd39f 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -352,9 +352,10 @@ void CGObjectInstance::readJson(const JsonNode & json)
 	pos.z = json["l"].Float();
 
 	appearance.readJson(json["template"], false);
-	readJsonOptions(json["options"]);
 
-	logGlobal->debugStream() <<"Load: [" << pos << "] " << id << " " << ID << " " << subID << " " << typeName << " " << subTypeName;
+	logGlobal->debugStream() <<"Loading: [" << pos << "] " << id << " " << ID << " " << subID << " " << typeName << " " << subTypeName;
+
+	readJsonOptions(json["options"]);
 }
 
 void CGObjectInstance::writeJsonOptions(JsonNode & json) const

From f9d0b2023422e23cf6bbcc836b3688cce94be155 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 23 Jan 2016 19:53:02 +0300
Subject: [PATCH 052/105] CGMine, CGArtifact, CGGarrison serialization

---
 lib/mapObjects/CArmedInstance.cpp |  2 -
 lib/mapObjects/CGTownInstance.cpp | 26 +++++++---
 lib/mapObjects/CGTownInstance.h   |  4 ++
 lib/mapObjects/CObjectHandler.cpp | 21 ++++++--
 lib/mapObjects/CObjectHandler.h   |  4 +-
 lib/mapObjects/MiscObjects.cpp    | 82 ++++++++++++++++++++++++++++---
 lib/mapObjects/MiscObjects.h      |  1 +
 7 files changed, 119 insertions(+), 21 deletions(-)

diff --git a/lib/mapObjects/CArmedInstance.cpp b/lib/mapObjects/CArmedInstance.cpp
index 6b3b647e6..b9d65c791 100644
--- a/lib/mapObjects/CArmedInstance.cpp
+++ b/lib/mapObjects/CArmedInstance.cpp
@@ -135,12 +135,10 @@ CBonusSystemNode * CArmedInstance::whatShouldBeAttached()
 
 void CArmedInstance::writeJsonOptions(JsonNode& json) const
 {
-	CGObjectInstance::writeJsonOptions(json);
 	CCreatureSet::writeJson(json["army"]);
 }
 
 void CArmedInstance::readJsonOptions(const JsonNode& json)
 {
-	CGObjectInstance::readJsonOptions(json);
 	CCreatureSet::readJson(json["army"]);
 }
diff --git a/lib/mapObjects/CGTownInstance.cpp b/lib/mapObjects/CGTownInstance.cpp
index 2e13c5ce2..a498841e6 100644
--- a/lib/mapObjects/CGTownInstance.cpp
+++ b/lib/mapObjects/CGTownInstance.cpp
@@ -313,6 +313,18 @@ void CGDwelling::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer)
 	}
 }
 
+void CGDwelling::writeJsonOptions(JsonNode& json) const
+{
+	//todo:CGDwelling::writeJsonOptions
+	CGObjectInstance::writeOwner(json);
+}
+
+void CGDwelling::readJsonOptions(const JsonNode& json)
+{
+	//todo:CGDwelling::readJsonOptions
+	CGObjectInstance::readOwner(json);
+}
+
 int CGTownInstance::getSightRadious() const //returns sight distance
 {
 	if (subID == ETownType::TOWER)
@@ -360,7 +372,7 @@ CGTownInstance::EFortLevel CGTownInstance::fortLevel() const //0 - none, 1 - for
 
 int CGTownInstance::hallLevel() const // -1 - none, 0 - village, 1 - town, 2 - city, 3 - capitol
 {
-	
+
 	if (hasBuilt(BuildingID::CAPITOL))
 		return 3;
 	if (hasBuilt(BuildingID::CITY_HALL))
@@ -455,12 +467,12 @@ TResources CGTownInstance::dailyIncome() const
 {
 	TResources ret;
 
-	for (auto & p : town->buildings) 
-	{ 
+	for (auto & p : town->buildings)
+	{
 		BuildingID buildingUpgrade;
 
-		for (auto & p2 : town->buildings) 
-		{ 
+		for (auto & p2 : town->buildings)
+		{
 			if (p2.second->upgrade == p.first)
 			{
 				buildingUpgrade = p2.first;
@@ -471,7 +483,7 @@ TResources CGTownInstance::dailyIncome() const
 		{
 			ret += p.second->produce;
 		}
-	
+
 	}
 
 	return ret;
@@ -964,7 +976,7 @@ void CGTownInstance::setVisitingHero(CGHeroInstance *h)
 	//{
 	//	logGlobal->warnStream() << boost::format("Hero visiting town %s is %s ") % name % (visitingHero.get() ? visitingHero->name : "NULL");
 	//	logGlobal->warnStream() << boost::format("New hero will be %s ") % (h ? h->name : "NULL");
-	//	
+	//
 	//}
 	assert(!!visitingHero == !h);
 
diff --git a/lib/mapObjects/CGTownInstance.h b/lib/mapObjects/CGTownInstance.h
index b636b16a5..e3c3f3c48 100644
--- a/lib/mapObjects/CGTownInstance.h
+++ b/lib/mapObjects/CGTownInstance.h
@@ -52,6 +52,10 @@ public:
 	CSpecObjInfo * info; //h3m info about dewlling
 	TCreaturesSet creatures; //creatures[level] -> <vector of alternative ids (base creature and upgrades, creatures amount>
 
+protected:
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
+
 private:
 	void initObj() override;
 	void onHeroVisit(const CGHeroInstance * h) const override;
diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index d61bcd39f..4e7cbc1e0 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -362,7 +362,23 @@ void CGObjectInstance::writeJsonOptions(JsonNode & json) const
 {
 	json.setType(JsonNode::DATA_STRUCT);
 
-	//todo: move up to descendants
+//	//todo: move up to descendants
+//	if(tempOwner != PlayerColor::UNFLAGGABLE)
+//	{
+//		PlayerColor p (tempOwner);
+//		if(p.isValidPlayer())
+//			json["owner"].String() = GameConstants::PLAYER_COLOR_NAMES[p.getNum()];
+//	}
+}
+
+void CGObjectInstance::readJsonOptions(const JsonNode & json)
+{
+//	if(json["owner"].getType() == JsonNode::DATA_STRING)
+//		tempOwner = PlayerColor(vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, json["owner"].String()));
+}
+
+void CGObjectInstance::writeOwner(JsonNode & json) const
+{
 	if(tempOwner != PlayerColor::UNFLAGGABLE)
 	{
 		PlayerColor p (tempOwner);
@@ -371,13 +387,12 @@ void CGObjectInstance::writeJsonOptions(JsonNode & json) const
 	}
 }
 
-void CGObjectInstance::readJsonOptions(const JsonNode & json)
+void CGObjectInstance::readOwner(const JsonNode & json)
 {
 	if(json["owner"].getType() == JsonNode::DATA_STRING)
 		tempOwner = PlayerColor(vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, json["owner"].String()));
 }
 
-
 CGObjectInstanceBySubIdFinder::CGObjectInstanceBySubIdFinder(CGObjectInstance * obj) : obj(obj)
 {
 
diff --git a/lib/mapObjects/CObjectHandler.h b/lib/mapObjects/CObjectHandler.h
index 263a2cc1d..7fde4b5ac 100644
--- a/lib/mapObjects/CObjectHandler.h
+++ b/lib/mapObjects/CObjectHandler.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "ObjectTemplate.h"
 
@@ -206,6 +206,8 @@ protected:
 	///(!) do not forget to call inherited method  first when overriding
 	virtual void readJsonOptions(const JsonNode & json);
 
+	void writeOwner(JsonNode & json) const;
+	void readOwner(const JsonNode & json);
 private:
 	mutable std::string stringId;///<alternate id, dynamically generated, do not serialize
 };
diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index a0e5ee7be..5df0b6234 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -11,6 +11,7 @@
 #include "StdInc.h"
 #include "MiscObjects.h"
 
+#include "../StringConstants.h"
 #include "../NetPacks.h"
 #include "../CGeneralTextHandler.h"
 #include "../CSoundBase.h"
@@ -606,7 +607,7 @@ void CGMine::newTurn() const
 
 void CGMine::initObj()
 {
-	if(subID >= 7) //Abandoned Mine
+	if(isAbandoned())
 	{
 		//set guardians
 		int howManyTroglodytes = cb->gameState()->getRandomGenerator().nextInt(100, 199);
@@ -633,6 +634,11 @@ void CGMine::initObj()
 	producedQuantity = defaultResProduction();
 }
 
+bool CGMine::isAbandoned() const
+{
+	return (subID >= 7);
+}
+
 std::string CGMine::getObjectName() const
 {
 	return VLC->generaltexth->mines.at(subID).first;
@@ -690,7 +696,7 @@ void CGMine::battleFinished(const CGHeroInstance *hero, const BattleResult &resu
 {
 	if(result.winner == 0) //attacker won
 	{
-		if(subID == 7)
+		if(isAbandoned())
 		{
 			showInfoDialog(hero->tempOwner, 85, 0);
 		}
@@ -704,14 +710,68 @@ void CGMine::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) con
 		cb->startBattleI(hero, this);
 }
 
-void CGMine::writeJsonOptions(JsonNode& json) const
+void CGMine::writeJsonOptions(JsonNode & json) const
 {
+	CArmedInstance::writeJsonOptions(json);
 
+	if(isAbandoned())
+	{
+		JsonNode & node = json["possibleResources"];
+
+		for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
+			if(tempOwner.getNum() & 1<<i)
+			{
+				JsonNode one(JsonNode::DATA_STRING);
+				one.String() = GameConstants::RESOURCE_NAMES[i];
+				node.Vector().push_back(one);
+			}
+	}
+	else
+	{
+		CGObjectInstance::writeOwner(json);
+	}
 }
 
-void CGMine::readJsonOptions(const JsonNode& json)
+void CGMine::readJsonOptions(const JsonNode & json)
 {
+	CArmedInstance::readJsonOptions(json);
 
+	if(isAbandoned())
+	{
+		const JsonNode & node = json["possibleResources"];
+
+		std::set<int> possibleResources;
+
+		if(node.Vector().size() == 0)
+		{
+			//assume all allowed
+			for(int i = (int)Res::WOOD; i < (int) Res::GOLD; i++)
+				possibleResources.insert(i);
+		}
+		else
+		{
+            auto names = node.convertTo<std::vector<std::string>>();
+
+            for(const std::string & s : names)
+			{
+                int raw_res = vstd::find_pos(GameConstants::RESOURCE_NAMES, s);
+                if(raw_res < 0)
+					logGlobal->errorStream() << "Invalid resource name: "+s;
+				else
+					possibleResources.insert(raw_res);
+			}
+
+			int tmp = 0;
+
+			for(int r : possibleResources)
+				tmp |=  (1<<r);
+			tempOwner = PlayerColor(tmp);
+		}
+	}
+	else
+	{
+		CGObjectInstance::readOwner(json);
+	}
 }
 
 
@@ -1298,12 +1358,14 @@ void CGArtifact::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer)
 
 void CGArtifact::writeJsonOptions(JsonNode& json) const
 {
-
+	CCreatureSet::writeJson(json["guards"]);
+	json["guardMessage"].String() = message;
 }
 
 void CGArtifact::readJsonOptions(const JsonNode& json)
 {
-
+	CCreatureSet::readJson(json["guards"]);
+	message = json["guardMessage"].String();
 }
 
 void CGWitchHut::initObj()
@@ -1681,12 +1743,16 @@ void CGGarrison::battleFinished(const CGHeroInstance *hero, const BattleResult &
 
 void CGGarrison::writeJsonOptions(JsonNode& json) const
 {
-
+	CArmedInstance::writeJsonOptions(json);
+	CGObjectInstance::writeOwner(json);
+	json["removableUnits"].Bool() = removableUnits;
 }
 
 void CGGarrison::readJsonOptions(const JsonNode& json)
 {
-
+	CArmedInstance::readJsonOptions(json);
+	CGObjectInstance::readOwner(json);
+	removableUnits = json["removableUnits"].Bool();
 }
 
 void CGMagi::initObj()
diff --git a/lib/mapObjects/MiscObjects.h b/lib/mapObjects/MiscObjects.h
index 838efd721..e8b712edb 100644
--- a/lib/mapObjects/MiscObjects.h
+++ b/lib/mapObjects/MiscObjects.h
@@ -263,6 +263,7 @@ private:
 	std::string getObjectName() const override;
 	std::string getHoverText(PlayerColor player) const override;
 
+	bool isAbandoned() const;
 public:
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{

From 3eb9de0c0bcbc0c5ce51fea5be6eac1992d863df Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 24 Jan 2016 02:26:32 +0300
Subject: [PATCH 053/105] Grail options serialization

---
 lib/mapping/MapFormatJson.cpp | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 95684d4c0..8a65c3f04 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -591,6 +591,16 @@ void CMapLoaderJson::MapObjectLoader::construct()
 		return;
 	}
 
+	//special case for grail
+    if(typeName == "grail")
+	{
+		auto & pos = owner->map->grailPos;
+		pos.x = configuration["x"].Float();
+		pos.y = configuration["y"].Float();
+		pos.z = configuration["l"].Float();
+		owner->map->grailRadious = configuration["options"]["grailRadius"].Float();
+	}
+
 	handler = VLC->objtypeh->getHandlerFor(typeName, subTypeName);
 
 	instance = handler->create(ObjectTemplate());
@@ -600,6 +610,9 @@ void CMapLoaderJson::MapObjectLoader::construct()
 
 void CMapLoaderJson::MapObjectLoader::configure()
 {
+	if(nullptr == instance)
+		return;
+
 	instance->readJson(configuration);
 
 	if(instance->ID == Obj::TOWN)
@@ -858,6 +871,23 @@ void CMapSaverJson::writeObjects()
 	for(const CGObjectInstance * obj : map->objects)
 		obj->writeJson(data[obj->getStringId()]);
 
+	if(map->grailPos.valid())
+	{
+		JsonNode grail(JsonNode::DATA_STRUCT);
+		grail["type"].String() = "grail";
+
+		grail["x"].Float() = map->grailPos.x;
+		grail["y"].Float() = map->grailPos.y;
+		grail["l"].Float() = map->grailPos.z;
+
+		grail["options"]["radius"].Float() = map->grailRadious;
+
+		std::string grailId = boost::str(boost::format("grail_%d") % map->objects.size());
+
+		data[grailId] = grail;
+
+	}
+
 	addToArchive(data, OBJECTS_FILE_NAME);
 }
 

From 408f34654159c491361d5c852f7e0fc17f3580f4 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 24 Jan 2016 02:27:14 +0300
Subject: [PATCH 054/105] Drafts for hero serialization

---
 lib/CArtHandler.cpp               | 11 ++++++
 lib/CArtHandler.h                 |  6 +++-
 lib/StringConstants.h             | 16 ++++++++-
 lib/mapObjects/CGHeroInstance.cpp | 59 +++++++++++++++++++------------
 lib/mapObjects/CGHeroInstance.h   | 16 +++++----
 lib/mapping/MapFormatJson.cpp     |  1 -
 6 files changed, 76 insertions(+), 33 deletions(-)

diff --git a/lib/CArtHandler.cpp b/lib/CArtHandler.cpp
index 0946658f6..d613e488d 100644
--- a/lib/CArtHandler.cpp
+++ b/lib/CArtHandler.cpp
@@ -19,6 +19,7 @@
 #include "mapObjects/MapObjects.h"
 #include "NetPacksBase.h"
 #include "GameConstants.h"
+#include "StringConstants.h"
 #include "CRandomGenerator.h"
 
 #include "mapObjects/CObjectClassesHandler.h"
@@ -1258,3 +1259,13 @@ void CArtifactSet::artDeserializationFix(CBonusSystemNode *node)
 		if(elem.second.artifact && !elem.second.locked)
 			node->attachTo(elem.second.artifact);
 }
+
+void CArtifactSet::writeJson(JsonNode& json) const
+{
+
+}
+
+void CArtifactSet::readJson(const JsonNode& json)
+{
+
+}
diff --git a/lib/CArtHandler.h b/lib/CArtHandler.h
index deea66062..808193f88 100644
--- a/lib/CArtHandler.h
+++ b/lib/CArtHandler.h
@@ -48,7 +48,7 @@ protected:
 	std::string eventText; //short story displayed upon picking
 public:
 	enum EartClass {ART_SPECIAL=1, ART_TREASURE=2, ART_MINOR=4, ART_MAJOR=8, ART_RELIC=16}; //artifact classes
-	
+
 	std::string identifier;
 	std::string image;
 	std::string large; // big image for cutom artifacts, used in drag & drop
@@ -309,4 +309,8 @@ public:
 	}
 
 	void artDeserializationFix(CBonusSystemNode *node);
+
+protected:
+	void writeJson(JsonNode & json) const;
+	void readJson(const JsonNode & json);
 };
diff --git a/lib/StringConstants.h b/lib/StringConstants.h
index 3004d3afa..78fa1a8d8 100644
--- a/lib/StringConstants.h
+++ b/lib/StringConstants.h
@@ -21,7 +21,7 @@ namespace GameConstants
 	const std::string TERRAIN_NAMES [TERRAIN_TYPES] = {
 	    "dirt", "sand", "grass", "snow", "swamp", "rough", "subterra", "lava", "water", "rock"
 	};
-	
+
 	const std::string RESOURCE_NAMES [RESOURCE_QUANTITY] = {
 	    "wood", "mercury", "ore", "sulfur", "crystal", "gems", "gold", "mithril"
 	};
@@ -84,3 +84,17 @@ namespace ETownType
 		"stronghold",   "fortress",     "conflux"
 	};
 }
+
+namespace NArtifactPosition
+{
+	const std::string names [19] =
+	{
+		"head", "shoulders", "neck", "rightHand", "leftHand", "torso", //5
+		"rightRing", "leftRing", "feet", //8
+		"misc1", "misc2", "misc3", "misc4", //12
+		"mach1", "mach2", "mach3", "mach4", //16
+		"spellbook", "misc5" //18
+	};
+
+	const std::string backpack = "backpack";
+}
diff --git a/lib/mapObjects/CGHeroInstance.cpp b/lib/mapObjects/CGHeroInstance.cpp
index 2299c42a0..9633c1bda 100644
--- a/lib/mapObjects/CGHeroInstance.cpp
+++ b/lib/mapObjects/CGHeroInstance.cpp
@@ -868,18 +868,18 @@ TExpType CGHeroInstance::calculateXp(TExpType exp) const
 ui8 CGHeroInstance::getSpellSchoolLevel(const CSpell * spell, int *outSelectedSchool) const
 {
 	si16 skill = -1; //skill level
-	
+
 	spell->forEachSchool([&, this](const SpellSchoolInfo & cnf, bool & stop)
 	{
 		int thisSchool = std::max<int>(getSecSkillLevel(cnf.skill),	valOfBonuses(Bonus::MAGIC_SCHOOL_SKILL, 1 << ((ui8)cnf.id))); //FIXME: Bonus shouldn't be additive (Witchking Artifacts : Crown of Skies)
-		if(thisSchool > skill)									
-		{														
-			skill = thisSchool;									
-			if(outSelectedSchool)								
-				*outSelectedSchool = (ui8)cnf.id;				
-		}																
+		if(thisSchool > skill)
+		{
+			skill = thisSchool;
+			if(outSelectedSchool)
+				*outSelectedSchool = (ui8)cnf.id;
+		}
 	});
-	
+
 	vstd::amax(skill, valOfBonuses(Bonus::MAGIC_SCHOOL_SKILL, 0)); //any school bonus
 	vstd::amax(skill, valOfBonuses(Bonus::SPELL, spell->id.toEnum())); //given by artifact or other effect
 
@@ -904,7 +904,7 @@ ui32 CGHeroInstance::getSpellBonus(const CSpell * spell, ui32 base, const CStack
 	if (affectedStack && affectedStack->getCreature()->level) //Hero specials like Solmyr, Deemer
 		base *= (100. + ((valOfBonuses(Bonus::SPECIAL_SPELL_LEV,  spell->id.toEnum()) * level) / affectedStack->getCreature()->level)) / 100.0;
 
-	return base;	
+	return base;
 }
 
 int CGHeroInstance::getEffectLevel(const CSpell * spell) const
@@ -912,7 +912,7 @@ int CGHeroInstance::getEffectLevel(const CSpell * spell) const
 	if(hasBonusOfType(Bonus::MAXED_SPELL, spell->id))
 		return 3;//todo: recheck specialty from where this bonus is. possible bug
 	else
-		return getSpellSchoolLevel(spell);		
+		return getSpellSchoolLevel(spell);
 }
 
 int CGHeroInstance::getEffectPower(const CSpell * spell) const
@@ -922,7 +922,7 @@ int CGHeroInstance::getEffectPower(const CSpell * spell) const
 
 int CGHeroInstance::getEnchantPower(const CSpell * spell) const
 {
-	return getPrimSkillLevel(PrimarySkill::SPELL_POWER) + valOfBonuses(Bonus::SPELL_DURATION);	
+	return getPrimSkillLevel(PrimarySkill::SPELL_POWER) + valOfBonuses(Bonus::SPELL_DURATION);
 }
 
 int CGHeroInstance::getEffectValue(const CSpell * spell) const
@@ -1107,8 +1107,8 @@ void CGHeroInstance::getOutOffsets(std::vector<int3> &offsets) const
 {
 	// FIXME: Offsets need to be fixed once we get rid of convertPosition
 	// Check issue 515 for details
-	offsets = 
-	{ 
+	offsets =
+	{
 		int3(-1,1,0), int3(-1,-1,0), int3(-2,0,0), int3(0,0,0), int3(0,1,0), int3(-2,1,0), int3(0,-1,0), int3(-2,-1,0)
 	};
 }
@@ -1436,20 +1436,33 @@ void CGHeroInstance::levelUpAutomatically()
 bool CGHeroInstance::hasVisions(const CGObjectInstance * target, const int subtype) const
 {
 	//VISIONS spell support
-	
-	const std::string cached = boost::to_string((boost::format("type_%d__subtype_%d") % Bonus::VISIONS % subtype)); 
-	
+
+	const std::string cached = boost::to_string((boost::format("type_%d__subtype_%d") % Bonus::VISIONS % subtype));
+
 	const int visionsMultiplier = valOfBonuses(Selector::typeSubtype(Bonus::VISIONS,subtype), cached);
-	
+
 	int visionsRange =  visionsMultiplier * getPrimSkillLevel(PrimarySkill::SPELL_POWER);
-		
-	if (visionsMultiplier > 0) 	
+
+	if (visionsMultiplier > 0)
 		vstd::amax(visionsRange, 3); //minimum range is 3 tiles, but only if VISIONS bonus present
-	
+
 	const int distance = target->pos.dist2d(getPosition(false));
-	
+
 	//logGlobal->debug(boost::to_string(boost::format("Visions: dist %d, mult %d, range %d") % distance % visionsMultiplier % visionsRange));
-	
-	return (distance < visionsRange) && (target->pos.z == pos.z);	
+
+	return (distance < visionsRange) && (target->pos.z == pos.z);
 }
 
+void CGHeroInstance::writeJsonOptions(JsonNode& json) const
+{
+	CArmedInstance::writeJsonOptions(json);
+	CGObjectInstance::writeOwner(json);
+	CArtifactSet::writeJson(json["artifacts"]);
+}
+
+void CGHeroInstance::readJsonOptions(const JsonNode& json)
+{
+	CArmedInstance::readJsonOptions(json);
+	CGObjectInstance::readOwner(json);
+	CArtifactSet::readJson(json["artifacts"]);
+}
diff --git a/lib/mapObjects/CGHeroInstance.h b/lib/mapObjects/CGHeroInstance.h
index a6cc59cb1..0177f9336 100644
--- a/lib/mapObjects/CGHeroInstance.h
+++ b/lib/mapObjects/CGHeroInstance.h
@@ -177,7 +177,7 @@ public:
 	double getHeroStrength() const; // includes fighting and magic strength
 	ui64 getTotalStrength() const; // includes fighting strength and army strength
 	TExpType calculateXp(TExpType exp) const; //apply learning skill
-	
+
 	bool canCastThisSpell(const CSpell * spell) const; //determines if this hero can cast given spell; takes into account existing spell in spellbook, existing spellbook and artifact bonuses
 	CStackBasicDescriptor calculateNecromancy (const BattleResult &battleResult) const;
 	void showNecromancyDialog(const CStackBasicDescriptor &raisedStack) const;
@@ -201,23 +201,23 @@ public:
 	void Updatespecialty();
 	void recreateSecondarySkillsBonuses();
 	void updateSkill(SecondarySkill which, int val);
-	
+
 	bool hasVisions(const CGObjectInstance * target, const int subtype) const;
 
 	CGHeroInstance();
 	virtual ~CGHeroInstance();
-	
+
 	///ArtBearer
 	ArtBearer::ArtBearer bearerType() const override;
 
 	///IBonusBearer
 	CBonusSystemNode *whereShouldBeAttached(CGameState *gs) override;
 	std::string nodeName() const override;
-	
+
 	///ISpellCaster
 	ui8 getSpellSchoolLevel(const CSpell * spell, int *outSelectedSchool = nullptr) const override;
 	ui32 getSpellBonus(const CSpell * spell, ui32 base, const CStack * affectedStack) const override;
-	
+
 	///default spell school level for effect calculation
 	int getEffectLevel(const CSpell * spell) const override;
 
@@ -229,9 +229,9 @@ public:
 
 	///damage/heal override(ignores spell configuration, effect level and effect power)
 	int getEffectValue(const CSpell * spell) const override;
-	
+
 	const PlayerColor getOwner() const override;
-	
+
 	void deserializationFix();
 
 	void initObj() override;
@@ -239,6 +239,8 @@ public:
 	std::string getObjectName() const override;
 protected:
 	void setPropertyDer(ui8 what, ui32 val) override;//synchr
+	void writeJsonOptions(JsonNode & json) const override;
+	void readJsonOptions(const JsonNode & json) override;
 
 private:
 	void levelUpAutomatically();
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 8a65c3f04..eb8d5c2e2 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -683,7 +683,6 @@ void CMapSaverJson::addToArchive(const JsonNode& data, const std::string& filena
 
 void CMapSaverJson::saveMap(const std::unique_ptr<CMap>& map)
 {
-	//TODO: saveMap
 	this->map = map.get();
 	writeHeader();
 	writeTerrain();

From 0ec07b38ac160ca4c06013dff3c8cbe829e42544 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 24 Jan 2016 16:58:24 +0300
Subject: [PATCH 055/105] fix build

---
 lib/mapObjects/CObjectClassesHandler.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/mapObjects/CObjectClassesHandler.cpp b/lib/mapObjects/CObjectClassesHandler.cpp
index 928d6eaa9..4b87e8f18 100644
--- a/lib/mapObjects/CObjectClassesHandler.cpp
+++ b/lib/mapObjects/CObjectClassesHandler.cpp
@@ -317,7 +317,7 @@ void CObjectClassesHandler::afterLoadFinalization()
 	}
 
 	//duplicate existing two-way portals to make reserve for RMG
-	auto& portalVec = objects[Obj::MONOLITH_TWO_WAY]->objects;
+	auto& portalVec = objects[Obj::MONOLITH_TWO_WAY]->subObjects;
 	size_t portalCount = portalVec.size();
 	size_t currentIndex = portalCount;
 	while (portalVec.size() < 100)

From b176734418d6dddc616df2f09a039e9dd9b109d8 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Wed, 3 Feb 2016 04:18:03 +0300
Subject: [PATCH 056/105] CGCreature serialization

---
 lib/mapObjects/MiscObjects.cpp | 40 ++++++++++++++++++++++++++++++++--
 1 file changed, 38 insertions(+), 2 deletions(-)

diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index 68e7bfaf3..55149f903 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -589,14 +589,50 @@ void CGCreature::giveReward(const CGHeroInstance * h) const
 	}
 }
 
+static const std::string CHARACTER_JSON [] =
+{
+	"compliant", "friendly", "aggressive", "hostile", "savage"
+};
+
 void CGCreature::writeJsonOptions(JsonNode& json) const
 {
+	assert(vstd::iswithin(character, 0, 4));
+	json["character"].String() = CHARACTER_JSON[character];
 
+	if(hasStackAtSlot(SlotID(0)))
+	{
+		auto sta = getStack(SlotID(0));
+		json["amount"].Float() = sta.count;
+	}
+
+	json["noGrowing"].Bool() = notGrowingTeam;
+	json["neverFlees"].Bool() = neverFlees;
+	json["rewardMessage"].String() = message;
+	json["rewardArtifact"].String() = (gainedArtifact == ArtifactID(ArtifactID::NONE) ? "" : gainedArtifact.toArtifact()->identifier);
 }
 
 void CGCreature::readJsonOptions(const JsonNode& json)
 {
+	character = vstd::find_pos(CHARACTER_JSON,json["character"].String());
+	vstd::amin(character, 0);
 
+	auto  hlp = new CStackInstance();
+	hlp->count = json["amount"].Float();
+	//type will be set during initialization
+	putStack(SlotID(0), hlp);
+
+	notGrowingTeam = json["noGrowing"].Bool();
+	neverFlees = json["neverFlees"].Bool();
+	message = json["rewardMessage"].String();
+
+	gainedArtifact = ArtifactID(ArtifactID::NONE);
+
+	if(json["rewardArtifact"].String() != "")
+	{
+		auto artid = VLC->modh->identifiers.getIdentifier("core", "artifact", json["rewardArtifact"].String());
+		if(artid)
+			gainedArtifact = ArtifactID(artid.get());
+	}
 }
 
 //CGMine
@@ -2101,10 +2137,10 @@ void CGLighthouse::giveBonusTo( PlayerColor player ) const
 
 void CGLighthouse::writeJsonOptions(JsonNode& json) const
 {
-
+	CGObjectInstance::writeOwner(json);
 }
 
 void CGLighthouse::readJsonOptions(const JsonNode& json)
 {
-
+	CGObjectInstance::readOwner(json);
 }

From a6c719ee11394b2549c9d75fcb7e769f010fbd12 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Thu, 4 Feb 2016 08:44:46 +0300
Subject: [PATCH 057/105] CGCreature serialization. Added rewardResources.

---
 lib/mapObjects/MiscObjects.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index af0dd1be3..a32d89e1d 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -613,6 +613,12 @@ void CGCreature::writeJsonOptions(JsonNode& json) const
 	json["neverFlees"].Bool() = neverFlees;
 	json["rewardMessage"].String() = message;
 	json["rewardArtifact"].String() = (gainedArtifact == ArtifactID(ArtifactID::NONE) ? "" : gainedArtifact.toArtifact()->identifier);
+
+	if(resources.nonZero())
+	{
+		for(size_t idx = 0; idx < resources.size(); idx++)
+			json["rewardResources"][GameConstants::RESOURCE_NAMES[idx]].Float() = resources[idx];
+	}
 }
 
 void CGCreature::readJsonOptions(const JsonNode& json)
@@ -637,6 +643,9 @@ void CGCreature::readJsonOptions(const JsonNode& json)
 		if(artid)
 			gainedArtifact = ArtifactID(artid.get());
 	}
+
+	TResources tmp(json["rewardResources"]);
+	std::swap(tmp,resources);
 }
 
 //CGMine

From d8d574ed84bd857555129b8f4310527073607d24 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Thu, 4 Feb 2016 08:50:46 +0300
Subject: [PATCH 058/105] CGSignBottle serialization

---
 lib/mapObjects/MiscObjects.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index a32d89e1d..09e54094c 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -1694,12 +1694,12 @@ void CGSignBottle::onHeroVisit( const CGHeroInstance * h ) const
 
 void CGSignBottle::writeJsonOptions(JsonNode& json) const
 {
-
+	json["text"].String() = message;
 }
 
 void CGSignBottle::readJsonOptions(const JsonNode& json)
 {
-
+	message = json["text"].String();
 }
 
 void CGScholar::onHeroVisit( const CGHeroInstance * h ) const

From 97f19b517666ef2289053b56946203c1ac82554d Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Thu, 4 Feb 2016 09:22:14 +0300
Subject: [PATCH 059/105] CGResource serialization

---
 lib/mapObjects/MiscObjects.cpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index 09e54094c..cf20f6283 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -941,15 +941,18 @@ void CGResource::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer)
 
 void CGResource::writeJsonOptions(JsonNode& json) const
 {
-
+	CCreatureSet::writeJson(json["guards"]);
+	json["amount"].Float() = amount;
+	json["guardMessage"].String() = message;
 }
 
 void CGResource::readJsonOptions(const JsonNode& json)
 {
-
+	CCreatureSet::readJson(json["guards"]);
+	amount = json["amount"].Float();
+	message = json["guardMessage"].String();
 }
 
-
 CGTeleport::CGTeleport() :
 	type(UNKNOWN), channel(TeleportChannelID())
 {

From 483276b128af43a56c069fa109f026ea01d48ec1 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Thu, 4 Feb 2016 12:28:12 +0300
Subject: [PATCH 060/105] Merge fixes

---
 lib/CArtHandler.h                      |  2 +-
 lib/CCreatureHandler.h                 |  2 +-
 lib/CHeroHandler.h                     |  4 ++--
 lib/Connection.h                       |  2 +-
 lib/filesystem/CFileInputStream.cpp    | 16 +++++++++++++++-
 lib/filesystem/CZipLoader.cpp          | 12 ++++++------
 lib/filesystem/CZipLoader.h            |  2 +-
 lib/mapObjects/CObjectClassesHandler.h |  4 ++--
 lib/mapObjects/CObjectHandler.h        |  2 +-
 lib/mapping/MapFormatJson.cpp          |  4 ++--
 10 files changed, 32 insertions(+), 18 deletions(-)

diff --git a/lib/CArtHandler.h b/lib/CArtHandler.h
index 38266a81f..0efb2f4be 100644
--- a/lib/CArtHandler.h
+++ b/lib/CArtHandler.h
@@ -80,7 +80,7 @@ public:
 		h & static_cast<CBonusSystemNode&>(*this);
 		h & name & description & eventText & image & large & advMapDef & iconIndex &
 			price & possibleSlots & constituents & constituentOf & aClass & id;
-		if(version>=756)
+		if(version>=759)
 		{
 			h & identifier;
 		}
diff --git a/lib/CCreatureHandler.h b/lib/CCreatureHandler.h
index b97878a1c..acec549fe 100644
--- a/lib/CCreatureHandler.h
+++ b/lib/CCreatureHandler.h
@@ -138,7 +138,7 @@ public:
 		h & idNumber & faction & sounds & animation;
 
 		h & doubleWide & special;
-		if(version>=756)
+		if(version>=759)
 		{
 			h & identifier;
 		}
diff --git a/lib/CHeroHandler.h b/lib/CHeroHandler.h
index ef037e9fd..9adf94ba4 100644
--- a/lib/CHeroHandler.h
+++ b/lib/CHeroHandler.h
@@ -92,10 +92,10 @@ public:
 		h & ID & imageIndex & initialArmy & heroClass & secSkillsInit & spec & specialty & spells & haveSpellBook & sex & special;
 		h & name & biography & specName & specDescr & specTooltip;
 		h & iconSpecSmall & iconSpecLarge & portraitSmall & portraitLarge;
-		if(version>=756)
+		if(version>=759)
 		{
 			h & identifier;
-		}		
+		}
 	}
 };
 
diff --git a/lib/Connection.h b/lib/Connection.h
index 11ff7fede..dedc6dc69 100644
--- a/lib/Connection.h
+++ b/lib/Connection.h
@@ -27,7 +27,7 @@
 #include "mapping/CCampaignHandler.h" //for CCampaignState
 #include "rmg/CMapGenerator.h" // for CMapGenOptions
 
-const ui32 version = 758;
+const ui32 version = 759;
 const ui32 minSupportedVersion = 753;
 
 class CISer;
diff --git a/lib/filesystem/CFileInputStream.cpp b/lib/filesystem/CFileInputStream.cpp
index dcec9e76a..b95fe4f51 100644
--- a/lib/filesystem/CFileInputStream.cpp
+++ b/lib/filesystem/CFileInputStream.cpp
@@ -21,7 +21,21 @@ CFileInputStream::CFileInputStream(const boost::filesystem::path & file, si64 st
 }
 
 CFileInputStream::CFileInputStream(const CFileInfo & file, si64 start, si64 size)
-	: CFileInputStream{file.getName(), start, size} {}
+  : dataStart{start},
+	dataSize{size},
+	fileStream{file.getName(), std::ios::in | std::ios::binary}
+{
+	if (fileStream.fail())
+		throw std::runtime_error("File " + file.getName() + " isn't available.");
+
+	if (dataSize == 0)
+	{
+		fileStream.seekg(0, std::ios::end);
+		dataSize = tell();
+	}
+
+	fileStream.seekg(dataStart, std::ios::beg);
+}
 
 si64 CFileInputStream::read(ui8 * data, si64 size)
 {
diff --git a/lib/filesystem/CZipLoader.cpp b/lib/filesystem/CZipLoader.cpp
index d95b8f99b..86e6cacdb 100644
--- a/lib/filesystem/CZipLoader.cpp
+++ b/lib/filesystem/CZipLoader.cpp
@@ -14,12 +14,12 @@
  *
  */
 
-CZipStream::CZipStream(const boost::filesystem::path & archive, unz64_file_pos filepos)
+CZipStream::CZipStream(std::shared_ptr<CIOApi> api, const boost::filesystem::path & archive, unz64_file_pos filepos)
 {
 	zlib_filefunc64_def zlibApi;
-	
+
 	zlibApi = api->getApiStructure();
-	
+
 	file = unzOpen2_64(archive.c_str(), &zlibApi);
 	unzGoToFilePos64(file, &filepos);
 	unzOpenCurrentFile(file);
@@ -53,7 +53,7 @@ ui32 CZipStream::calculateCRC32()
 ///CZipLoader
 CZipLoader::CZipLoader(const std::string & mountPoint, const boost::filesystem::path & archive, std::shared_ptr<CIOApi> api):
 	ioApi(api),
-    zlibApi(ioApi->getApiStructure()),	
+    zlibApi(ioApi->getApiStructure()),
     archiveName(archive),
     mountPoint(mountPoint),
     files(listFiles(mountPoint, archive))
@@ -66,7 +66,7 @@ std::unordered_map<ResourceID, unz64_file_pos> CZipLoader::listFiles(const std::
 	std::unordered_map<ResourceID, unz64_file_pos> ret;
 
 	unzFile file = unzOpen2_64(archive.c_str(), &zlibApi);
-	
+
 	if(file == nullptr)
 		logGlobal->errorStream() << archive << " failed to open";
 
@@ -95,7 +95,7 @@ std::unordered_map<ResourceID, unz64_file_pos> CZipLoader::listFiles(const std::
 
 std::unique_ptr<CInputStream> CZipLoader::load(const ResourceID & resourceName) const
 {
-	return std::unique_ptr<CInputStream>(new CZipStream(ioApi, archiveName, files.at(resourceName)));	
+	return std::unique_ptr<CInputStream>(new CZipStream(ioApi, archiveName, files.at(resourceName)));
 }
 
 bool CZipLoader::existsResource(const ResourceID & resourceName) const
diff --git a/lib/filesystem/CZipLoader.h b/lib/filesystem/CZipLoader.h
index 372a99e1d..a81745a47 100644
--- a/lib/filesystem/CZipLoader.h
+++ b/lib/filesystem/CZipLoader.h
@@ -28,7 +28,7 @@ public:
 	 * @param archive path to archive to open
 	 * @param filepos position of file to open
 	 */
-	CZipStream(std::shared_ptr<CIOApi> api, const boost::filesystem::path & archive, unz_file_pos filepos);
+	CZipStream(std::shared_ptr<CIOApi> api, const boost::filesystem::path & archive, unz64_file_pos filepos);
 	~CZipStream();
 
 	si64 getSize() override;
diff --git a/lib/mapObjects/CObjectClassesHandler.h b/lib/mapObjects/CObjectClassesHandler.h
index 6e88fdb7c..9c7279b2f 100644
--- a/lib/mapObjects/CObjectClassesHandler.h
+++ b/lib/mapObjects/CObjectClassesHandler.h
@@ -159,7 +159,7 @@ public:
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
 		h & type & subtype & templates & rmgInfo & objectName;
-		if(version >= 756)
+		if(version >= 759)
 		{
 			h & typeName & subTypeName;
 		}
@@ -186,7 +186,7 @@ class DLL_LINKAGE CObjectClassesHandler : public IHandlerBase
 		template <typename Handler> void serialize(Handler &h, const int version)
 		{
 			h & name & handlerName & base & subObjects;
-			if(version >= 756)
+			if(version >= 759)
 			{
 				h & identifier & subIds;
 			}
diff --git a/lib/mapObjects/CObjectHandler.h b/lib/mapObjects/CObjectHandler.h
index 4c350f9f4..12fe7eda6 100644
--- a/lib/mapObjects/CObjectHandler.h
+++ b/lib/mapObjects/CObjectHandler.h
@@ -179,7 +179,7 @@ public:
 		h & pos & ID & subID & id & tempOwner & blockVisit & appearance;
 		//definfo is handled by map serializer
 
-		if(version >= 756)
+		if(version >= 759)
 		{
 			h & typeName & subTypeName;
 		}
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index eb8d5c2e2..cbad11899 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -598,7 +598,7 @@ void CMapLoaderJson::MapObjectLoader::construct()
 		pos.x = configuration["x"].Float();
 		pos.y = configuration["y"].Float();
 		pos.z = configuration["l"].Float();
-		owner->map->grailRadious = configuration["options"]["grailRadius"].Float();
+		owner->map->grailRadius = configuration["options"]["grailRadius"].Float();
 	}
 
 	handler = VLC->objtypeh->getHandlerFor(typeName, subTypeName);
@@ -879,7 +879,7 @@ void CMapSaverJson::writeObjects()
 		grail["y"].Float() = map->grailPos.y;
 		grail["l"].Float() = map->grailPos.z;
 
-		grail["options"]["radius"].Float() = map->grailRadious;
+		grail["options"]["radius"].Float() = map->grailRadius;
 
 		std::string grailId = boost::str(boost::format("grail_%d") % map->objects.size());
 

From a3f0d1a94edfef2185ddd324fec06ef635b16565 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Fri, 5 Feb 2016 09:28:36 +0300
Subject: [PATCH 061/105] More post-merge fixes

---
 lib/filesystem/MinizipExtensions.cpp | 64 +++++++++++++---------------
 lib/filesystem/MinizipExtensions.h   | 20 ++++-----
 2 files changed, 40 insertions(+), 44 deletions(-)

diff --git a/lib/filesystem/MinizipExtensions.cpp b/lib/filesystem/MinizipExtensions.cpp
index d4c694fe7..f1283e6e1 100644
--- a/lib/filesystem/MinizipExtensions.cpp
+++ b/lib/filesystem/MinizipExtensions.cpp
@@ -11,28 +11,28 @@
 #include "MinizipExtensions.h"
 
 #include "CMemoryBuffer.h"
-
+#include "FileStream.h"
 
 ///CIOApi
 voidpf ZCALLBACK CIOApi::openFileProxy(voidpf opaque, const void * filename, int mode)
 {
 	assert(opaque != nullptr);
-	
-	std::string filename_s;
-	
+
+	boost::filesystem::path path;
+
 	if(filename != nullptr)
-		filename_s = (const char *)filename;
-	
-	return ((CIOApi *)opaque)->openFile(filename_s, mode);
+		path =  static_cast<const boost::filesystem::path::value_type *>(filename);
+
+	return ((CIOApi *)opaque)->openFile(path, mode);
 }
 
 uLong ZCALLBACK CIOApi::readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
-	
+
 	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
-	
+
 	return actualStream->read((ui8 *)buf, size);
 }
 
@@ -49,8 +49,8 @@ ZPOS64_T ZCALLBACK CIOApi::tellFileProxy(voidpf opaque, voidpf stream)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
-	
-	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);	
+
+	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
     return actualStream->tell();
 }
 
@@ -58,8 +58,8 @@ long ZCALLBACK CIOApi::seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T off
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
-		
-	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);	
+
+	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
 
     long ret = 0;
     switch (origin)
@@ -73,7 +73,7 @@ long ZCALLBACK CIOApi::seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T off
     		const si64 pos = actualStream->getSize() - offset;
     		if(actualStream->seek(pos) != pos)
 				ret = -1;
-    	}    	
+    	}
         break;
     case ZLIB_FILEFUNC_SEEK_SET :
 		if(actualStream->seek(offset) != offset)
@@ -82,7 +82,7 @@ long ZCALLBACK CIOApi::seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T off
     default: ret = -1;
     }
     if(ret == -1)
-		logGlobal->error("CIOApi::seekFileProxy: seek failed");			
+		logGlobal->error("CIOApi::seekFileProxy: seek failed");
     return ret;
 }
 
@@ -90,11 +90,11 @@ int ZCALLBACK CIOApi::closeFileProxy(voidpf opaque, voidpf stream)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
-		
+
 	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
-	
+
 	((CIOApi *)opaque)->closeFile(actualStream);
-	
+
     return 0;
 }
 
@@ -113,8 +113,8 @@ zlib_filefunc64_def CIOApi::getApiStructure() const
 	api.ztell64_file = &tellFileProxy;
 	api.zseek64_file = &seekFileProxy;
 	api.zclose_file = &closeFileProxy;
-	api.zerror_file = &errorFileProxy;	
-	
+	api.zerror_file = &errorFileProxy;
+
 	return api;
 }
 
@@ -126,44 +126,40 @@ void CIOApi::closeFile(CInputOutputStream * stream) const
 ///CDefaultIOApi
 CDefaultIOApi::CDefaultIOApi()
 {
-	
+
 }
 
 CDefaultIOApi::~CDefaultIOApi()
 {
-	
+
 }
 
 zlib_filefunc64_def CDefaultIOApi::getApiStructure() const
 {
-	zlib_filefunc64_def api;
-	
-	fill_fopen64_filefunc(&api);
-	
-	return api;	
+	return * FileStream::GetMinizipFilefunc();
 }
 
-CInputOutputStream * CDefaultIOApi::openFile(const std::string& filename, int mode) const
+CInputOutputStream * CDefaultIOApi::openFile(const boost::filesystem::path & filename, int mode) const
 {
-	throw new std::runtime_error("CDefaultIOApi::openFile call not expected.");	
+	throw new std::runtime_error("CDefaultIOApi::openFile call not expected.");
 }
 
 ///CProxyIOApi
 CProxyIOApi::CProxyIOApi(CInputOutputStream * buffer):
 	data(buffer)
 {
-	
+
 }
 
 CProxyIOApi::~CProxyIOApi()
 {
-	
+
 }
 
-CInputOutputStream * CProxyIOApi::openFile(const std::string& filename, int mode) const
+CInputOutputStream * CProxyIOApi::openFile(const boost::filesystem::path & filename, int mode) const
 {
-	logGlobal->traceStream() << "CProxyIOApi: stream opened for " <<filename<<" with mode "<<mode; 
-	
+	logGlobal->traceStream() << "CProxyIOApi: stream opened for " <<filename.string() <<" with mode "<<mode;
+
 	data->seek(0);
 	return data;
 }
diff --git a/lib/filesystem/MinizipExtensions.h b/lib/filesystem/MinizipExtensions.h
index a88e3db7e..7bea0ea9a 100644
--- a/lib/filesystem/MinizipExtensions.h
+++ b/lib/filesystem/MinizipExtensions.h
@@ -27,20 +27,20 @@ class DLL_LINKAGE CIOApi
 {
 public:
 	virtual ~CIOApi(){};
-	
+
 	virtual zlib_filefunc64_def getApiStructure() const;
 
-protected:	
-	virtual CInputOutputStream * openFile(const std::string & filename, int mode) const = 0;
-	
+protected:
+	virtual CInputOutputStream * openFile(const boost::filesystem::path & filename, int mode) const = 0;
+
 	///default implementation deletes stream object
 	virtual void closeFile(CInputOutputStream * stream) const;
-	
+
 private:
 	static voidpf ZCALLBACK openFileProxy(voidpf opaque, const void * filename, int mode);
 	static uLong ZCALLBACK readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size);
 	static uLong ZCALLBACK writeFileProxy(voidpf opaque, voidpf stream, const void * buf, uLong size);
-	static ZPOS64_T ZCALLBACK tellFileProxy(voidpf opaque, voidpf stream);	
+	static ZPOS64_T ZCALLBACK tellFileProxy(voidpf opaque, voidpf stream);
 	static long ZCALLBACK seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin);
 	static int ZCALLBACK closeFileProxy(voidpf opaque, voidpf stream);
 	static int ZCALLBACK errorFileProxy(voidpf opaque, voidpf stream);
@@ -53,11 +53,11 @@ class DLL_LINKAGE CDefaultIOApi: public CIOApi
 public:
 	CDefaultIOApi();
 	~CDefaultIOApi();
-	
+
 	zlib_filefunc64_def getApiStructure() const override;
-	
+
 protected:
-	CInputOutputStream * openFile(const std::string & filename, int mode) const override;
+	CInputOutputStream * openFile(const boost::filesystem::path & filename, int mode) const override;
 };
 
 ///redirects all file IO to single stream
@@ -67,7 +67,7 @@ public:
 	CProxyIOApi(CInputOutputStream * buffer);
 	~CProxyIOApi();
 protected:
-	CInputOutputStream * openFile(const std::string & filename, int mode) const override;
+	CInputOutputStream * openFile(const boost::filesystem::path & filename, int mode) const override;
 	void closeFile(CInputOutputStream * stream) const override;
 private:
 	CInputOutputStream * data;

From 081a20d047dca0f15d9dd972ad72e66a512938f5 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Fri, 5 Feb 2016 09:40:20 +0300
Subject: [PATCH 062/105] Fix a crash.

---
 lib/mapObjects/MiscObjects.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index 872d026eb..ae64961b0 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -605,7 +605,7 @@ void CGCreature::writeJsonOptions(JsonNode& json) const
 
 	if(hasStackAtSlot(SlotID(0)))
 	{
-		auto sta = getStack(SlotID(0));
+		const auto & sta = getStack(SlotID(0));
 		json["amount"].Float() = sta.count;
 	}
 

From 401ba482570c1d684f710dbbb8aa7f4827bea240 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Tue, 9 Feb 2016 09:02:34 +0300
Subject: [PATCH 063/105] CGScholar serialization

---
 lib/mapObjects/MiscObjects.cpp | 44 ++++++++++++++++++++++++++++++++--
 1 file changed, 42 insertions(+), 2 deletions(-)

diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index ae64961b0..1cf689c64 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -1780,12 +1780,52 @@ void CGScholar::initObj()
 
 void CGScholar::writeJsonOptions(JsonNode& json) const
 {
-
+	switch(bonusType)
+	{
+	case PRIM_SKILL:
+		json["rewardPrimSkill"].String() = PrimarySkill::names[bonusID];
+		break;
+	case SECONDARY_SKILL:
+		json["rewardSkill"].String() = NSecondarySkill::names[bonusID];
+		break;
+	case SPELL:
+		json["rewardSpell"].String() = VLC->spellh->objects.at(bonusID)->identifier;
+		break;
+	case RANDOM:
+		break;
+	}
 }
 
 void CGScholar::readJsonOptions(const JsonNode& json)
 {
-
+	bonusType = RANDOM;
+	if(json["rewardPrimSkill"].String() != "")
+	{
+		auto raw = VLC->modh->identifiers.getIdentifier("core", "primSkill", json["rewardPrimSkill"].String());
+		if(raw)
+		{
+			bonusType = PRIM_SKILL;
+			bonusID = raw.get();
+		}
+	}
+	else if(json["rewardSkill"].String() != "")
+	{
+		auto raw = VLC->modh->identifiers.getIdentifier("core", "skill", json["rewardSkill"].String());
+		if(raw)
+		{
+			bonusType = SECONDARY_SKILL;
+			bonusID = raw.get();
+		}
+	}
+	else if(json["rewardSpell"].String() != "")
+	{
+		auto raw = VLC->modh->identifiers.getIdentifier("core", "spell", json["rewardSpell"].String());
+		if(raw)
+		{
+			bonusType = SPELL;
+			bonusID = raw.get();
+		}
+	}
 }
 
 void CGGarrison::onHeroVisit (const CGHeroInstance *h) const

From 53dc49e92ac2a4db60df231a2f3de28a36eb63d2 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Tue, 9 Feb 2016 09:17:20 +0300
Subject: [PATCH 064/105] CGShipyard, CGShrine serialization

---
 lib/mapObjects/CObjectHandler.cpp | 10 ----------
 lib/mapObjects/MiscObjects.cpp    | 19 +++++++++++++------
 2 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 045b24366..1d7895724 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -367,20 +367,10 @@ void CGObjectInstance::readJson(const JsonNode & json)
 void CGObjectInstance::writeJsonOptions(JsonNode & json) const
 {
 	json.setType(JsonNode::DATA_STRUCT);
-
-//	//todo: move up to descendants
-//	if(tempOwner != PlayerColor::UNFLAGGABLE)
-//	{
-//		PlayerColor p (tempOwner);
-//		if(p.isValidPlayer())
-//			json["owner"].String() = GameConstants::PLAYER_COLOR_NAMES[p.getNum()];
-//	}
 }
 
 void CGObjectInstance::readJsonOptions(const JsonNode & json)
 {
-//	if(json["owner"].getType() == JsonNode::DATA_STRING)
-//		tempOwner = PlayerColor(vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, json["owner"].String()));
 }
 
 void CGObjectInstance::writeOwner(JsonNode & json) const
diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index 1cf689c64..c8550183b 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -1660,15 +1660,23 @@ std::string CGShrine::getHoverText(const CGHeroInstance * hero) const
 
 void CGShrine::writeJsonOptions(JsonNode& json) const
 {
-
+	if(spell != SpellID::NONE)
+	{
+		json["spell"].String() = spell.toSpell()->identifier;
+	}
 }
 
 void CGShrine::readJsonOptions(const JsonNode& json)
 {
-
+	spell = SpellID::NONE;
+	if(json["spell"].String() != "")
+	{
+		auto raw = VLC->modh->identifiers.getIdentifier("core", "spell",json["spell"].String());
+		if(raw)
+			spell = SpellID(raw.get());
+	}
 }
 
-
 void CGSignBottle::initObj()
 {
 	//if no text is set than we pick random from the predefined ones
@@ -2017,15 +2025,14 @@ void CGShipyard::onHeroVisit( const CGHeroInstance * h ) const
 
 void CGShipyard::writeJsonOptions(JsonNode& json) const
 {
-
+	CGObjectInstance::writeOwner(json);
 }
 
 void CGShipyard::readJsonOptions(const JsonNode& json)
 {
-
+	CGObjectInstance::readOwner(json);
 }
 
-
 void CCartographer::onHeroVisit( const CGHeroInstance * h ) const
 {
 	//if player has not bought map of this subtype yet and underground exist for stalagmite cartographer

From 6db94ab74c0be88eab2f020dd34dde5f856aff5f Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Tue, 9 Feb 2016 10:11:59 +0300
Subject: [PATCH 065/105] Explicit army serialization - too much CArmedInstance
 descendants

---
 lib/mapObjects/CArmedInstance.cpp | 4 ++--
 lib/mapObjects/CGHeroInstance.cpp | 4 ++--
 lib/mapObjects/MiscObjects.cpp    | 8 ++++----
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/lib/mapObjects/CArmedInstance.cpp b/lib/mapObjects/CArmedInstance.cpp
index b9d65c791..b7c2aafa7 100644
--- a/lib/mapObjects/CArmedInstance.cpp
+++ b/lib/mapObjects/CArmedInstance.cpp
@@ -135,10 +135,10 @@ CBonusSystemNode * CArmedInstance::whatShouldBeAttached()
 
 void CArmedInstance::writeJsonOptions(JsonNode& json) const
 {
-	CCreatureSet::writeJson(json["army"]);
+	CGObjectInstance::writeJsonOptions(json);
 }
 
 void CArmedInstance::readJsonOptions(const JsonNode& json)
 {
-	CCreatureSet::readJson(json["army"]);
+	CGObjectInstance::readJsonOptions(json);
 }
diff --git a/lib/mapObjects/CGHeroInstance.cpp b/lib/mapObjects/CGHeroInstance.cpp
index 18f9cf2ba..bd055ff90 100644
--- a/lib/mapObjects/CGHeroInstance.cpp
+++ b/lib/mapObjects/CGHeroInstance.cpp
@@ -1472,14 +1472,14 @@ bool CGHeroInstance::hasVisions(const CGObjectInstance * target, const int subty
 
 void CGHeroInstance::writeJsonOptions(JsonNode& json) const
 {
-	CArmedInstance::writeJsonOptions(json);
+	CCreatureSet::writeJson(json["army"]);
 	CGObjectInstance::writeOwner(json);
 	CArtifactSet::writeJson(json["artifacts"]);
 }
 
 void CGHeroInstance::readJsonOptions(const JsonNode& json)
 {
-	CArmedInstance::readJsonOptions(json);
+	CCreatureSet::readJson(json["army"]);
 	CGObjectInstance::readOwner(json);
 	CArtifactSet::readJson(json["artifacts"]);
 }
diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index c8550183b..2ce4872b9 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -792,7 +792,7 @@ void CGMine::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) con
 
 void CGMine::writeJsonOptions(JsonNode & json) const
 {
-	CArmedInstance::writeJsonOptions(json);
+	CCreatureSet::writeJson(json["army"]);
 
 	if(isAbandoned())
 	{
@@ -814,7 +814,7 @@ void CGMine::writeJsonOptions(JsonNode & json) const
 
 void CGMine::readJsonOptions(const JsonNode & json)
 {
-	CArmedInstance::readJsonOptions(json);
+	CCreatureSet::readJson(json["army"]);
 
 	if(isAbandoned())
 	{
@@ -1874,14 +1874,14 @@ void CGGarrison::battleFinished(const CGHeroInstance *hero, const BattleResult &
 
 void CGGarrison::writeJsonOptions(JsonNode& json) const
 {
-	CArmedInstance::writeJsonOptions(json);
+	CCreatureSet::writeJson(json["army"]);
 	CGObjectInstance::writeOwner(json);
 	json["removableUnits"].Bool() = removableUnits;
 }
 
 void CGGarrison::readJsonOptions(const JsonNode& json)
 {
-	CArmedInstance::readJsonOptions(json);
+	CCreatureSet::readJson(json["army"]);
 	CGObjectInstance::readOwner(json);
 	removableUnits = json["removableUnits"].Bool();
 }

From 0c21efb202e4efa7b1c507378012074b4382623e Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Tue, 9 Feb 2016 20:20:03 +0300
Subject: [PATCH 066/105] Start integration of map format into engine

---
 Mods/vcmi/Sprites/ScSelC.json              |   7 ++++
 Mods/vcmi/Sprites/mapFormatIcons/vcmi1.png | Bin 0 -> 2053 bytes
 client/CPreGame.cpp                        |  30 ++++++++++------
 client/CPreGame.h                          |   2 +-
 lib/filesystem/ResourceID.cpp              |   3 +-
 lib/mapping/CMap.h                         |   3 +-
 lib/mapping/CMapService.cpp                |  39 +++++++++++++--------
 lib/mapping/MapFormatJson.cpp              |   3 +-
 lib/rmg/CMapGenerator.cpp                  |   2 +-
 9 files changed, 59 insertions(+), 30 deletions(-)
 create mode 100644 Mods/vcmi/Sprites/ScSelC.json
 create mode 100644 Mods/vcmi/Sprites/mapFormatIcons/vcmi1.png

diff --git a/Mods/vcmi/Sprites/ScSelC.json b/Mods/vcmi/Sprites/ScSelC.json
new file mode 100644
index 000000000..e07bbfc7d
--- /dev/null
+++ b/Mods/vcmi/Sprites/ScSelC.json
@@ -0,0 +1,7 @@
+{
+        "basepath" : "mapFormatIcons/",
+	"images" :
+	[
+		{ "group" : 1, "frame" : 0, "file" : "vcmi1.png"}
+	]
+}
\ No newline at end of file
diff --git a/Mods/vcmi/Sprites/mapFormatIcons/vcmi1.png b/Mods/vcmi/Sprites/mapFormatIcons/vcmi1.png
new file mode 100644
index 0000000000000000000000000000000000000000..b575cf133b307fa2c9d4bae8f608aca4c3379f67
GIT binary patch
literal 2053
zcmV+g2>SPlP)<h;3K|Lk000e1NJLTq001BW000>X1^@s6P!BAT00006VoOIv0RI60
z0RN!9r;`8x010qNS#tmY3ljhU3ljkVnw%H_000McNliru-~tH`F#r%*?MDCr2a-ud
zK~zY`rIve)TvZvsf9F2t)tP<FPP^Muc1v4=fJBR>K^_gM2x5rPrbXJsfQg1E!GA~y
zA*cx=CbH3Bs4>Jpkd#nf7HB0#6t$EJv?+Ak-F6GRot@owXJ_xs?9SXfbD!t<$Ijwz
zZHdG$IXNfi-hAKhobPpnQcBPgA;jGW-g)O4P1n*&MtGj*Pfku&tZA!Ou2k&eRMD<h
zsx`|hS3rdm6K6^Y$aQsfn6X$QlgXqrnRHt&+trrMcBV6JnRK?Zvm=>Iv<1Ge`JT(r
ziQ!Yf{>{!EN~t3N28$(8tyVR|FfdIMA&7N%FYj5pbZJlE`$SPV4+<y%lmaOwVGtl?
zL=c1ofsY^fL}5tNv8m5iky0Y1q|tB|**zDaa^%R7nM@{=G7N+9{3yBZ9=f`6baZx*
zj3)qz=Xr#IPt;N>Wi&TObL&Q<fo<E=>UCV#MW9%D(M1@BfmN<lfU_3@$QKHQN-C9F
zF*#Xe_^+>$Os44RyM*qGSCQ_>V#E`~5($LRKockgG7Ol%4xuDVk_p-~Y5Mw>)0R#%
zJ~hpZ7tof;P@F1F0JRGN6pO`TW%=^u_`U~5oMyveY<P&;^c20T*RZm$kE9l2m<EPs
zVwfgIGLB)Gb9;t~VHoI!fuU&xzE7n(OLoOdG)-glbbbhETnL~sJ~1)c)7`T%3__F<
zLj*2TO3KzWj$>0TTdZ1pDY>P~h|HD?qG+)zWQ6gldn9fUl1inRot?EOCyRNdR5))?
zI~U;8@bE`M5C(xyq??OAy3Hnq)1w?ce27m@p1`ix@H`LC^Y9l9AK&)~d=KCEK{qkY
z7^P{e2#hY&X)H)V12A0Av+A~8ab0(rG80GzLd-?G0-{J_Sr)c!Qz=`lTC<jpTn=5I
z%ba*Tj%k``o{rEogsziJx1s4eBcpi>m=Ho}N-6m%fDj@Ed;!=5bd<~GiqmK;t2!QL
z2x%Px1x`4hd|(7F-swD*Y85ThMPf-BGiGw>s$O!P?F{E9Xf#~{1=nr5g>q$v1MeP;
zwQTGbLNt_8a^3|o;Fg*F5B}=0`@i$Ovy+oE^?IG*Ki<PVJGS9UDEn~ot@{~y>qbW2
zx{-T#+)mY(Smi1=UAvCg`!no*Vk5^-jWA`Ex$=?~?D~n~`JZ0H;NTDk|Mi|c_WWH}
zKmNcyj{+U%3qr%LA3}yw=JR=Sxg2)w05VGA36o=Q+{fSFAK-)I0&w}^T{XgJD=)wN
z3SlrswR!-d`<xydC-4Kh+n3Gl8G?y%P)hoCeLN8bae!1S{^UGB2$X*JdQV~V#;M-A
zdq>;7x952K!yyh22gDKyrpw3p=MmWR`hL6!0=bnB2ggu==fh-m6@#O&_vsxxx3|RY
zHx&8D(XVjjYC(0TLcLyZl&XD+rY{y9eBK2<@aE&sy!33%5qMs~FIk5;c6tfEAu)8F
zSw|2_jbtK0($skFrB@glJcIy(5FD?M!$WaO)*);sPt6e=KGDvsBk+BnVzGF3))553
z;<VG|3Ye0u>NN4EgWZLjH^|&zJ`*}>1-IVzP0VBpy9q()<0zfF)Y-lBM{K=w8wv;`
zu$yrF6PJ%p#kuu*jaUDc!SzDyCe&-Sn(Mlj-Gm?lK%TD-xWK;tKfL&?>m@k)apZpc
z-tGRjZQJNwdl`RuFUw8q<2?D$2A+CkJs%uB#)*+}OhYG>0;efBHuwQUqu_c8p5L>V
zK<YS6L3L)P1dKXOK^Teo8($oRN+~IXr~&!+PxKW=&y3Z^#`1~v>({Tnd;4~t`q_^`
zd=1x|0+pgr^l@j$Xm87qpYYg!<YMAFj1-#0VtwdljMI~n{R0=_`~DCx@cxOu!pNDk
zh1P9L0CCQHKx;*40!VM!viXVM?%a9zRH?+zAH1LH^dwOvK`AsL&^1tzr0IDyY#YyY
ziJ}M;c$uZ7b3J&jTO9uQ<A;EKtpkTZLn-C|S1DFXNu`txRDg*+dtUqVz`)TNlw{3S
z>sS(xlTOB2l8BRt85o9vVH%`UNwV229UbkY5^-Y56ss@4ifm^mw&M%{Z?{fe0c!Kc
z&({kUf`m$`gZuXG8_JK4(0l1+n8_vRx{hw>bF-$QYZ{uaW5!I<nGEfnoqX~7P29P8
zGwaq}-6%~@zX6n5I^}!`{!D-cQh4FTm-f}_bvKnv(9ydVP16<)q3NHlbzLX7aup9e
z{3thn{T7s9AP9oD7k0mM<ud`4QvUSx^qU9XJvh*C9M)WZ1*AG!2IrcMrvC@VOr*GN
z`**qKn)P&bWgEM8?Rw?h?)SL>T5|G*-7oI89mm!+LGP7cA~I8R#up6TFj=!<BiCMk
z1Ld+sfB%yQEX#Uhp})^3i?ZN?KMB!$!*yTn|HiFf+ajY#D_LbGP98`18=xdoH(9p!
z3O3%fiOy`6GiT0@e*eB7JPf?{S=ax005ssbyS8rWUwz5N8-x%j1+%p}0J&U_p6+g9
zu^5eJbLO$ffAPz5x$<-?qxio87Q7k0wROuKkE~qL^JO6fW-La`H0S16jAo-*d3M(e
jzb_QV`;}7G|DyNb4FnAdIpW#F00000NkvXXu0mjf$l~4`

literal 0
HcmV?d00001

diff --git a/client/CPreGame.cpp b/client/CPreGame.cpp
index ff00530bc..d694b6b66 100644
--- a/client/CPreGame.cpp
+++ b/client/CPreGame.cpp
@@ -1117,8 +1117,9 @@ void SelectionTab::parseMaps(const std::unordered_set<ResourceID> &files)
 			CMapInfo mapInfo;
 			mapInfo.mapInit(file.getName());
 
-			// ignore unsupported map versions (e.g. WoG maps without WoG
-			if (mapInfo.mapHeader->version <= CGI->modh->settings.data["textData"]["mapVersion"].Float())
+			// ignore unsupported map versions (e.g. WoG maps without WoG)
+			// but accept VCMI maps
+			if((mapInfo.mapHeader->version >= EMapFormat::VCMI) || (mapInfo.mapHeader->version <= CGI->modh->settings.data["textData"]["mapVersion"].Float()))
 				allItems.push_back(std::move(mapInfo));
 		}
 		catch(std::exception & e)
@@ -1283,7 +1284,9 @@ SelectionTab::SelectionTab(CMenuScreen::EState Type, const std::function<void(CM
 
 	slider = new CSlider(Point(372, 86), tabType != CMenuScreen::saveGame ? 480 : 430, std::bind(&SelectionTab::sliderMove, this, _1), positions, curItems.size(), 0, false, CSlider::BLUE);
 	slider->addUsedEvents(WHEEL);
-	format =  CDefHandler::giveDef("SCSELC.DEF");
+
+	formatIcons = new CAnimation("SCSELC.DEF");
+	formatIcons->load();
 
 	sortingBy = _format;
 	ascending = true;
@@ -1312,7 +1315,7 @@ SelectionTab::SelectionTab(CMenuScreen::EState Type, const std::function<void(CM
 
 SelectionTab::~SelectionTab()
 {
-	delete format;
+	delete formatIcons;
 }
 
 void SelectionTab::sortBy( int criteria )
@@ -1437,27 +1440,34 @@ void SelectionTab::printMaps(SDL_Surface *to)
 			}
 			printAtMiddleLoc(temp2, 70, 128 + line * 25, FONT_SMALL, itemColor, to);
 
-			int temp=-1;
+			int frame = -1, group = 0;
 			switch (currentItem->mapHeader->version)
 			{
 			case EMapFormat::ROE:
-				temp=0;
+				frame = 0;
 				break;
 			case EMapFormat::AB:
-				temp=1;
+				frame = 1;
 				break;
 			case EMapFormat::SOD:
-				temp=2;
+				frame = 2;
 				break;
 			case EMapFormat::WOG:
-				temp=3;
+				frame = 3;
+				break;
+			case EMapFormat::VCMI:
+				frame = 0;
+				group = 1;
 				break;
 			default:
 				// Unknown version. Be safe and ignore that map
                 logGlobal->warnStream() << "Warning: " << currentItem->fileURI << " has wrong version!";
 				continue;
 			}
-			blitAtLoc(format->ourImages[temp].bitmap, 88, 117 + line * 25, to);
+			IImage * icon = formatIcons->getImage(frame,group);
+			if(icon)
+				icon->draw(to, pos.x + 88, pos.y + 117 + line * 25);
+
 
 			//victory conditions
 			blitAtLoc(CGP->victory->ourImages[currentItem->mapHeader->victoryIconIndex].bitmap, 306, 117 + line * 25, to);
diff --git a/client/CPreGame.h b/client/CPreGame.h
index 59ac607b6..05ac2648f 100644
--- a/client/CPreGame.h
+++ b/client/CPreGame.h
@@ -149,7 +149,7 @@ public:
 class SelectionTab : public CIntObject
 {
 private:
-	CDefHandler *format; //map size
+	CAnimation * formatIcons;
 
     void parseMaps(const std::unordered_set<ResourceID> &files);
 	void parseGames(const std::unordered_set<ResourceID> &files, bool multi);
diff --git a/lib/filesystem/ResourceID.cpp b/lib/filesystem/ResourceID.cpp
index 3b146a489..779bc7a1e 100644
--- a/lib/filesystem/ResourceID.cpp
+++ b/lib/filesystem/ResourceID.cpp
@@ -136,7 +136,8 @@ EResType::Type EResTypeHelper::getTypeFromExtension(std::string extension)
 		{".VSGM1", EResType::SERVER_SAVEGAME},
 		{".ERM",   EResType::ERM},
 		{".ERT",   EResType::ERT},
-		{".ERS",   EResType::ERS}
+		{".ERS",   EResType::ERS},
+		{".VMAP",  EResType::MAP}
 	};
 
 	auto iter = stringToRes.find(extension);
diff --git a/lib/mapping/CMap.h b/lib/mapping/CMap.h
index 59a01bd1c..9014b46c9 100644
--- a/lib/mapping/CMap.h
+++ b/lib/mapping/CMap.h
@@ -215,7 +215,8 @@ enum EMapFormat
 	AB  = 0x15, // 21
 	SOD = 0x1c, // 28
 // HOTA = 0x1e ... 0x20 // 28 ... 30
-	WOG = 0x33  // 51
+	WOG = 0x33,  // 51
+	VCMI = 0xF0
 };
 }
 
diff --git a/lib/mapping/CMapService.cpp b/lib/mapping/CMapService.cpp
index 335e190da..80201429f 100644
--- a/lib/mapping/CMapService.cpp
+++ b/lib/mapping/CMapService.cpp
@@ -68,21 +68,32 @@ std::unique_ptr<IMapLoader> CMapService::getMapLoader(std::unique_ptr<CInputStre
 	ui32 header = reader.readUInt32();
 	reader.getStream()->seek(0);
 
-	// Check which map format is used
-	// gzip header is 3 bytes only in size
-	switch(header & 0xffffff)
+	//check for ZIP magic. Zip files are VCMI maps
+	switch(header)
 	{
-		// gzip header magic number, reversed for LE
-		case 0x00088B1F:
-			stream = std::unique_ptr<CInputStream>(new CCompressedStream(std::move(stream), true));
-			return std::unique_ptr<IMapLoader>(new CMapLoaderH3M(stream.get()));
-		case EMapFormat::WOG :
-		case EMapFormat::AB  :
-		case EMapFormat::ROE :
-		case EMapFormat::SOD :
-			return std::unique_ptr<IMapLoader>(new CMapLoaderH3M(stream.get()));
-		default :
-			throw std::runtime_error("Unknown map format");
+	case 0x06054b50:
+	case 0x04034b50:
+	case 0x02014b50:
+		//return std::unique_ptr<IMapLoader>(new CMapLoaderJson(stream.get()));
+		throw std::runtime_error("Not implemented map format");
+		break;
+	default:
+		// Check which map format is used
+		// gzip header is 3 bytes only in size
+		switch(header & 0xffffff)
+		{
+			// gzip header magic number, reversed for LE
+			case 0x00088B1F:
+				stream = std::unique_ptr<CInputStream>(new CCompressedStream(std::move(stream), true));
+				return std::unique_ptr<IMapLoader>(new CMapLoaderH3M(stream.get()));
+			case EMapFormat::WOG :
+			case EMapFormat::AB  :
+			case EMapFormat::ROE :
+			case EMapFormat::SOD :
+				return std::unique_ptr<IMapLoader>(new CMapLoaderH3M(stream.get()));
+			default :
+				throw std::runtime_error("Unknown map format");
+		}
 	}
 }
 
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index cbad11899..0f38abf34 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -299,8 +299,7 @@ void CMapLoaderJson::readHeader()
 	//do not use map field here, use only mapHeader
 	const JsonNode header = readJson(HEADER_FILE_NAME);
 
-	//TODO: read such data like map name & size
-	//mapHeader->version = ??? //todo: new version field
+	mapHeader->version = EMapFormat::VCMI;//todo: new version field
 
 	//todo: multilevel map load support
 	const JsonNode levels = header["mapLevels"];
diff --git a/lib/rmg/CMapGenerator.cpp b/lib/rmg/CMapGenerator.cpp
index 83b649fde..fcfe4b697 100644
--- a/lib/rmg/CMapGenerator.cpp
+++ b/lib/rmg/CMapGenerator.cpp
@@ -578,7 +578,7 @@ void CMapGenerator::createConnections()
 
 void CMapGenerator::addHeaderInfo()
 {
-	map->version = EMapFormat::SOD;
+	map->version = EMapFormat::VCMI;
 	map->width = mapGenOptions->getWidth();
 	map->height = mapGenOptions->getHeight();
 	map->twoLevel = mapGenOptions->getHasTwoLevels();

From 3c78f960cd27c46e796dc7b8d3e61e5c6f007732 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Wed, 10 Feb 2016 07:28:00 +0300
Subject: [PATCH 067/105] Complete json map format integration

---
 lib/filesystem/MinizipExtensions.cpp | 217 ++++++++++++++++++---------
 lib/filesystem/MinizipExtensions.h   |  62 +++++---
 lib/mapping/CMapService.cpp          |   3 +-
 lib/mapping/MapFormatJson.cpp        |  24 ++-
 lib/mapping/MapFormatJson.h          |  20 +--
 5 files changed, 206 insertions(+), 120 deletions(-)

diff --git a/lib/filesystem/MinizipExtensions.cpp b/lib/filesystem/MinizipExtensions.cpp
index f1283e6e1..aa3b77a2d 100644
--- a/lib/filesystem/MinizipExtensions.cpp
+++ b/lib/filesystem/MinizipExtensions.cpp
@@ -13,53 +13,31 @@
 #include "CMemoryBuffer.h"
 #include "FileStream.h"
 
-///CIOApi
-voidpf ZCALLBACK CIOApi::openFileProxy(voidpf opaque, const void * filename, int mode)
-{
-	assert(opaque != nullptr);
-
-	boost::filesystem::path path;
-
-	if(filename != nullptr)
-		path =  static_cast<const boost::filesystem::path::value_type *>(filename);
-
-	return ((CIOApi *)opaque)->openFile(path, mode);
-}
-
-uLong ZCALLBACK CIOApi::readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size)
+template <class _Stream> inline uLong streamRead(voidpf opaque, voidpf stream, void * buf, uLong size)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
 
-	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
+	_Stream * actualStream = static_cast<_Stream *>(stream);
 
 	return actualStream->read((ui8 *)buf, size);
 }
 
-uLong ZCALLBACK CIOApi::writeFileProxy(voidpf opaque, voidpf stream, const void * buf, uLong size)
+template <class _Stream> inline ZPOS64_T streamTell(voidpf opaque, voidpf stream)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
 
-	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
-    return (uLong)actualStream->write((const ui8 *)buf, size);
-}
-
-ZPOS64_T ZCALLBACK CIOApi::tellFileProxy(voidpf opaque, voidpf stream)
-{
-	assert(opaque != nullptr);
-	assert(stream != nullptr);
-
-	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
+	_Stream * actualStream = static_cast<_Stream *>(stream);
     return actualStream->tell();
 }
 
-long ZCALLBACK CIOApi::seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin)
+template <class _Stream> inline long streamSeek(voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
 
-	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
+	_Stream * actualStream = static_cast<_Stream *>(stream);
 
     long ret = 0;
     switch (origin)
@@ -82,47 +60,24 @@ long ZCALLBACK CIOApi::seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T off
     default: ret = -1;
     }
     if(ret == -1)
-		logGlobal->error("CIOApi::seekFileProxy: seek failed");
+		logGlobal->error("Stream seek failed");
     return ret;
 }
 
-int ZCALLBACK CIOApi::closeFileProxy(voidpf opaque, voidpf stream)
+template <class _Stream> inline int streamProxyClose(voidpf opaque, voidpf stream)
 {
 	assert(opaque != nullptr);
 	assert(stream != nullptr);
 
-	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
+	_Stream * actualStream = static_cast<_Stream *>(stream);
 
-	((CIOApi *)opaque)->closeFile(actualStream);
+	logGlobal->traceStream() << "Proxy stream closed";
+
+	actualStream->seek(0);
 
     return 0;
 }
 
-int ZCALLBACK CIOApi::errorFileProxy(voidpf opaque, voidpf stream)
-{
-    return 0;
-}
-
-zlib_filefunc64_def CIOApi::getApiStructure() const
-{
-	zlib_filefunc64_def api;
-	api.opaque = (void *) this;
-	api.zopen64_file = &openFileProxy;
-	api.zread_file = &readFileProxy;
-	api.zwrite_file = &writeFileProxy;
-	api.ztell64_file = &tellFileProxy;
-	api.zseek64_file = &seekFileProxy;
-	api.zclose_file = &closeFileProxy;
-	api.zerror_file = &errorFileProxy;
-
-	return api;
-}
-
-void CIOApi::closeFile(CInputOutputStream * stream) const
-{
-	delete stream;
-}
-
 ///CDefaultIOApi
 CDefaultIOApi::CDefaultIOApi()
 {
@@ -134,16 +89,11 @@ CDefaultIOApi::~CDefaultIOApi()
 
 }
 
-zlib_filefunc64_def CDefaultIOApi::getApiStructure() const
+zlib_filefunc64_def CDefaultIOApi::getApiStructure()
 {
 	return * FileStream::GetMinizipFilefunc();
 }
 
-CInputOutputStream * CDefaultIOApi::openFile(const boost::filesystem::path & filename, int mode) const
-{
-	throw new std::runtime_error("CDefaultIOApi::openFile call not expected.");
-}
-
 ///CProxyIOApi
 CProxyIOApi::CProxyIOApi(CInputOutputStream * buffer):
 	data(buffer)
@@ -156,7 +106,68 @@ CProxyIOApi::~CProxyIOApi()
 
 }
 
-CInputOutputStream * CProxyIOApi::openFile(const boost::filesystem::path & filename, int mode) const
+zlib_filefunc64_def CProxyIOApi::getApiStructure()
+{
+	zlib_filefunc64_def api;
+	api.opaque = this;
+	api.zopen64_file = &openFileProxy;
+	api.zread_file = &readFileProxy;
+	api.zwrite_file = &writeFileProxy;
+	api.ztell64_file = &tellFileProxy;
+	api.zseek64_file = &seekFileProxy;
+	api.zclose_file = &closeFileProxy;
+	api.zerror_file = &errorFileProxy;
+
+	return api;
+}
+
+voidpf ZCALLBACK CProxyIOApi::openFileProxy(voidpf opaque, const void * filename, int mode)
+{
+	assert(opaque != nullptr);
+
+	boost::filesystem::path path;
+
+	if(filename != nullptr)
+		path =  static_cast<const boost::filesystem::path::value_type *>(filename);
+
+	return ((CProxyIOApi *)opaque)->openFile(path, mode);
+}
+
+uLong ZCALLBACK CProxyIOApi::readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size)
+{
+	return streamRead<CInputOutputStream>(opaque, stream, buf, size);
+}
+
+uLong ZCALLBACK CProxyIOApi::writeFileProxy(voidpf opaque, voidpf stream, const void * buf, uLong size)
+{
+	assert(opaque != nullptr);
+	assert(stream != nullptr);
+
+	CInputOutputStream * actualStream = static_cast<CInputOutputStream *>(stream);
+    return (uLong)actualStream->write((const ui8 *)buf, size);
+}
+
+ZPOS64_T ZCALLBACK CProxyIOApi::tellFileProxy(voidpf opaque, voidpf stream)
+{
+	return streamTell<CInputOutputStream>(opaque, stream);
+}
+
+long ZCALLBACK CProxyIOApi::seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin)
+{
+	return streamSeek<CInputOutputStream>(opaque, stream, offset, origin);
+}
+
+int ZCALLBACK CProxyIOApi::closeFileProxy(voidpf opaque, voidpf stream)
+{
+	return streamProxyClose<CInputOutputStream>(opaque, stream);
+}
+
+int ZCALLBACK CProxyIOApi::errorFileProxy(voidpf opaque, voidpf stream)
+{
+    return 0;
+}
+
+CInputOutputStream * CProxyIOApi::openFile(const boost::filesystem::path & filename, int mode)
 {
 	logGlobal->traceStream() << "CProxyIOApi: stream opened for " <<filename.string() <<" with mode "<<mode;
 
@@ -164,8 +175,80 @@ CInputOutputStream * CProxyIOApi::openFile(const boost::filesystem::path & filen
 	return data;
 }
 
-void CProxyIOApi::closeFile(CInputOutputStream * stream) const
+///CProxyROIOApi
+CProxyROIOApi::CProxyROIOApi(CInputStream * buffer):
+	data(buffer)
 {
-	logGlobal->traceStream() << "CProxyIOApi: stream closed";
-	stream->seek(0);//stream is local singleton and even not owned, just seek
+
+}
+
+CProxyROIOApi::~CProxyROIOApi()
+{
+
+}
+
+zlib_filefunc64_def CProxyROIOApi::getApiStructure()
+{
+	zlib_filefunc64_def api;
+	api.opaque = this;
+	api.zopen64_file = &openFileProxy;
+	api.zread_file = &readFileProxy;
+	api.zwrite_file = &writeFileProxy;
+	api.ztell64_file = &tellFileProxy;
+	api.zseek64_file = &seekFileProxy;
+	api.zclose_file = &closeFileProxy;
+	api.zerror_file = &errorFileProxy;
+
+	return api;
+}
+
+CInputStream * CProxyROIOApi::openFile(const boost::filesystem::path& filename, int mode)
+{
+	logGlobal->traceStream() << "CProxyIOApi: stream opened for " <<filename.string() <<" with mode "<<mode;
+
+	data->seek(0);
+	return data;
+}
+
+voidpf ZCALLBACK CProxyROIOApi::openFileProxy(voidpf opaque, const void* filename, int mode)
+{
+	assert(opaque != nullptr);
+
+	boost::filesystem::path path;
+
+	if(filename != nullptr)
+		path =  static_cast<const boost::filesystem::path::value_type *>(filename);
+
+	return ((CProxyROIOApi *)opaque)->openFile(path, mode);
+}
+
+uLong ZCALLBACK CProxyROIOApi::readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size)
+{
+	return streamRead<CInputStream>(opaque, stream, buf, size);
+}
+
+uLong ZCALLBACK CProxyROIOApi::writeFileProxy(voidpf opaque, voidpf stream, const void* buf, uLong size)
+{
+	logGlobal->errorStream() << "Attempt to write to read-only stream";
+	return 0;
+}
+
+ZPOS64_T ZCALLBACK CProxyROIOApi::tellFileProxy(voidpf opaque, voidpf stream)
+{
+	return streamTell<CInputStream>(opaque, stream);
+}
+
+long ZCALLBACK CProxyROIOApi::seekFileProxy(voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)
+{
+	return streamSeek<CInputStream>(opaque, stream, offset, origin);
+}
+
+int ZCALLBACK CProxyROIOApi::closeFileProxy(voidpf opaque, voidpf stream)
+{
+	return streamProxyClose<CInputStream>(opaque, stream);
+}
+
+int ZCALLBACK CProxyROIOApi::errorFileProxy(voidpf opaque, voidpf stream)
+{
+	return 0;
 }
diff --git a/lib/filesystem/MinizipExtensions.h b/lib/filesystem/MinizipExtensions.h
index 7bea0ea9a..efd54a152 100644
--- a/lib/filesystem/MinizipExtensions.h
+++ b/lib/filesystem/MinizipExtensions.h
@@ -19,7 +19,7 @@
 #include "../minizip/zip.h"
 #include "../minizip/ioapi.h"
 #endif
-
+class CInputStream;
 class CInputOutputStream;
 class CMemoryBuffer;
 
@@ -28,22 +28,7 @@ class DLL_LINKAGE CIOApi
 public:
 	virtual ~CIOApi(){};
 
-	virtual zlib_filefunc64_def getApiStructure() const;
-
-protected:
-	virtual CInputOutputStream * openFile(const boost::filesystem::path & filename, int mode) const = 0;
-
-	///default implementation deletes stream object
-	virtual void closeFile(CInputOutputStream * stream) const;
-
-private:
-	static voidpf ZCALLBACK openFileProxy(voidpf opaque, const void * filename, int mode);
-	static uLong ZCALLBACK readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size);
-	static uLong ZCALLBACK writeFileProxy(voidpf opaque, voidpf stream, const void * buf, uLong size);
-	static ZPOS64_T ZCALLBACK tellFileProxy(voidpf opaque, voidpf stream);
-	static long ZCALLBACK seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin);
-	static int ZCALLBACK closeFileProxy(voidpf opaque, voidpf stream);
-	static int ZCALLBACK errorFileProxy(voidpf opaque, voidpf stream);
+	virtual zlib_filefunc64_def getApiStructure() = 0;
 };
 
 ///redirects back to minizip ioapi
@@ -54,10 +39,7 @@ public:
 	CDefaultIOApi();
 	~CDefaultIOApi();
 
-	zlib_filefunc64_def getApiStructure() const override;
-
-protected:
-	CInputOutputStream * openFile(const boost::filesystem::path & filename, int mode) const override;
+	zlib_filefunc64_def getApiStructure() override;
 };
 
 ///redirects all file IO to single stream
@@ -66,9 +48,41 @@ class DLL_LINKAGE CProxyIOApi: public CIOApi
 public:
 	CProxyIOApi(CInputOutputStream * buffer);
 	~CProxyIOApi();
-protected:
-	CInputOutputStream * openFile(const boost::filesystem::path & filename, int mode) const override;
-	void closeFile(CInputOutputStream * stream) const override;
+
+	zlib_filefunc64_def getApiStructure() override;
 private:
+	CInputOutputStream * openFile(const boost::filesystem::path & filename, int mode);
+
 	CInputOutputStream * data;
+
+	static voidpf ZCALLBACK openFileProxy(voidpf opaque, const void * filename, int mode);
+	static uLong ZCALLBACK readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size);
+	static uLong ZCALLBACK writeFileProxy(voidpf opaque, voidpf stream, const void * buf, uLong size);
+	static ZPOS64_T ZCALLBACK tellFileProxy(voidpf opaque, voidpf stream);
+	static long ZCALLBACK seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin);
+	static int ZCALLBACK closeFileProxy(voidpf opaque, voidpf stream);
+	static int ZCALLBACK errorFileProxy(voidpf opaque, voidpf stream);
 };
+
+///redirects all file IO to single stream read-only
+class DLL_LINKAGE CProxyROIOApi: public CIOApi
+{
+public:
+	CProxyROIOApi(CInputStream * buffer);
+	~CProxyROIOApi();
+
+	zlib_filefunc64_def getApiStructure() override;
+private:
+	CInputStream * openFile(const boost::filesystem::path & filename, int mode);
+
+	CInputStream * data;
+
+	static voidpf ZCALLBACK openFileProxy(voidpf opaque, const void * filename, int mode);
+	static uLong ZCALLBACK readFileProxy(voidpf opaque, voidpf stream, void * buf, uLong size);
+	static uLong ZCALLBACK writeFileProxy(voidpf opaque, voidpf stream, const void * buf, uLong size);
+	static ZPOS64_T ZCALLBACK tellFileProxy(voidpf opaque, voidpf stream);
+	static long ZCALLBACK seekFileProxy(voidpf  opaque, voidpf stream, ZPOS64_T offset, int origin);
+	static int ZCALLBACK closeFileProxy(voidpf opaque, voidpf stream);
+	static int ZCALLBACK errorFileProxy(voidpf opaque, voidpf stream);
+};
+
diff --git a/lib/mapping/CMapService.cpp b/lib/mapping/CMapService.cpp
index 80201429f..a71245d53 100644
--- a/lib/mapping/CMapService.cpp
+++ b/lib/mapping/CMapService.cpp
@@ -74,8 +74,7 @@ std::unique_ptr<IMapLoader> CMapService::getMapLoader(std::unique_ptr<CInputStre
 	case 0x06054b50:
 	case 0x04034b50:
 	case 0x02014b50:
-		//return std::unique_ptr<IMapLoader>(new CMapLoaderJson(stream.get()));
-		throw std::runtime_error("Not implemented map format");
+		return std::unique_ptr<IMapLoader>(new CMapLoaderJson(stream.get()));
 		break;
 	default:
 		// Check which map format is used
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 0f38abf34..4c8049944 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -221,18 +221,11 @@ void CMapPatcher::readPatchData()
 	readTriggeredEvents(input);
 }
 
-///CMapFormatZip
-CMapFormatZip::CMapFormatZip(CInputOutputStream * stream):
-	buffer(stream),
-	ioApi(new CProxyIOApi(buffer))
-{
-
-}
-
 
 ///CMapLoaderJson
-CMapLoaderJson::CMapLoaderJson(CInputOutputStream * stream):
-	CMapFormatZip(stream),
+CMapLoaderJson::CMapLoaderJson(CInputStream * stream):
+	buffer(stream),
+	ioApi(new CProxyROIOApi(buffer)),
 	loader("", "_", ioApi)
 {
 
@@ -342,7 +335,7 @@ void CMapLoaderJson::readPlayerInfo(const JsonNode & input)
 
 	for(int player = 0; player < PlayerColor::PLAYER_LIMIT_I; player++)
 	{
-		PlayerInfo & info = map->players.at(player);
+		PlayerInfo & info = mapHeader->players.at(player);
 
 		const JsonNode & playerSrc = src[GameConstants::PLAYER_COLOR_NAMES[player]];
 
@@ -412,15 +405,15 @@ void CMapLoaderJson::readTeams(const JsonNode& input)
 				PlayerColor player = PlayerColor(vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, playerData.String()));
 				if(player.isValidPlayer())
 				{
-					if(map->players[player.getNum()].canAnyonePlay())
+					if(mapHeader->players[player.getNum()].canAnyonePlay())
 					{
-						map->players[player.getNum()].team = TeamID(team);
+						mapHeader->players[player.getNum()].team = TeamID(team);
 					}
 				}
 			}
 		}
 
-		for(PlayerInfo & player : map->players)
+		for(PlayerInfo & player : mapHeader->players)
 		{
 			if(player.canAnyonePlay() && player.team == TeamID::NO_TEAM)
 				player.team = TeamID(mapHeader->howManyTeams++);
@@ -654,7 +647,8 @@ void CMapLoaderJson::readObjects()
 
 ///CMapSaverJson
 CMapSaverJson::CMapSaverJson(CInputOutputStream * stream):
-	CMapFormatZip(stream),
+	buffer(stream),
+	ioApi(new CProxyIOApi(buffer)),
 	saver(ioApi, "_")
 {
 
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 7b92594fe..de3fabb45 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -90,16 +90,7 @@ private:
 	const JsonNode input;
 };
 
-class DLL_LINKAGE CMapFormatZip : public CMapFormatJson
-{
-public:
-	CMapFormatZip(CInputOutputStream * stream);
-protected:
-	CInputOutputStream * buffer;
-	std::shared_ptr<CIOApi> ioApi;
-};
-
-class DLL_LINKAGE CMapLoaderJson : public CMapFormatZip, public IMapLoader
+class DLL_LINKAGE CMapLoaderJson : public CMapFormatJson, public IMapLoader
 {
 public:
 	/**
@@ -107,7 +98,7 @@ public:
 	 *
 	 * @param stream a stream containing the map data
 	 */
-	CMapLoaderJson(CInputOutputStream * stream);
+	CMapLoaderJson(CInputStream * stream);
 
 	/**
 	 * Loads the VCMI/Json map file.
@@ -184,10 +175,13 @@ private:
 
 	const JsonNode readJson(const std::string & archiveFilename);
 
+	CInputStream * buffer;
+	std::shared_ptr<CIOApi> ioApi;
+
 	CZipLoader loader;///< object to handle zip archive operations
 };
 
-class DLL_LINKAGE CMapSaverJson : public CMapFormatZip, public IMapSaver
+class DLL_LINKAGE CMapSaverJson : public CMapFormatJson, public IMapSaver
 {
 public:
 	/**
@@ -255,5 +249,7 @@ private:
 	 */
 	void writeObjects();
 
+	CInputOutputStream * buffer;
+	std::shared_ptr<CIOApi> ioApi;
 	CZipSaver saver;///< object to handle zip archive operations
 };

From fb17914ae5c8e8247849c84acec6587ab6698fc0 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Wed, 10 Feb 2016 08:59:24 +0300
Subject: [PATCH 068/105] Debug tweaks

---
 lib/mapObjects/CObjectHandler.cpp | 2 ++
 lib/mapping/MapFormatJson.cpp     | 5 +++++
 test/CMapFormatTest.cpp           | 2 +-
 3 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 1d7895724..38271479f 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -386,7 +386,9 @@ void CGObjectInstance::writeOwner(JsonNode & json) const
 void CGObjectInstance::readOwner(const JsonNode & json)
 {
 	if(json["owner"].getType() == JsonNode::DATA_STRING)
+	{
 		tempOwner = PlayerColor(vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, json["owner"].String()));
+	}
 }
 
 CGObjectInstanceBySubIdFinder::CGObjectInstanceBySubIdFinder(CGObjectInstance * obj) : obj(obj)
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 4c8049944..b82b8b5b2 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -244,6 +244,7 @@ si32 CMapLoaderJson::getIdentifier(const std::string& type, const std::string& n
 
 std::unique_ptr<CMap> CMapLoaderJson::loadMap()
 {
+	LOG_TRACE(logGlobal);
 	map = new CMap();
 	mapHeader = std::unique_ptr<CMapHeader>(dynamic_cast<CMapHeader *>(map));
 	readMap();
@@ -252,6 +253,7 @@ std::unique_ptr<CMap> CMapLoaderJson::loadMap()
 
 std::unique_ptr<CMapHeader> CMapLoaderJson::loadMapHeader()
 {
+	LOG_TRACE(logGlobal);
 	mapHeader.reset(new CMapHeader);
 	readHeader();
 	return std::move(mapHeader);
@@ -274,6 +276,7 @@ const JsonNode CMapLoaderJson::readJson(const std::string & archiveFilename)
 
 void CMapLoaderJson::readMap()
 {
+	LOG_TRACE(logGlobal);
 	readHeader();
 	map->initTerrain();
 	readTerrain();
@@ -575,11 +578,13 @@ void CMapLoaderJson::MapObjectLoader::construct()
 	if(typeName.empty())
 	{
 		logGlobal->errorStream() << "Object type missing";
+		logGlobal->traceStream() << configuration;
 		return;
 	}
 	if(subTypeName.empty())
 	{
 		logGlobal->errorStream() << "Object subType missing";
+		logGlobal->traceStream() << configuration;
 		return;
 	}
 
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index fdf5594bb..55fa76417 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -67,7 +67,7 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 
 	#if 1
 	{
-		auto path = VCMIDirs::get().userDataPath()/"test.zip";
+		auto path = VCMIDirs::get().userDataPath()/"test.vmap";
 		boost::filesystem::remove(path);
 		boost::filesystem::ofstream tmp(path, boost::filesystem::ofstream::binary);
 

From a307d3ca40b3484dc495588673a59c21aef6f60f Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Wed, 10 Feb 2016 13:24:03 +0300
Subject: [PATCH 069/105] tweaks

---
 lib/mapping/MapFormatJson.cpp | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index b82b8b5b2..5fe5bb28b 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -39,13 +39,26 @@ namespace TriggeredEventsDetail
 
 	static EventCondition JsonToCondition(const JsonNode & node)
 	{
+		//todo: support of new condition format
 		EventCondition event;
-		event.condition = EventCondition::EWinLoseType(vstd::find_pos(conditionNames, node.Vector()[0].String()));
+
+		const auto & conditionName = node.Vector()[0].String();
+
+		auto pos = vstd::find_pos(conditionNames, conditionName);
+
+		event.condition = EventCondition::EWinLoseType(pos));
 		if (node.Vector().size() > 1)
 		{
 			const JsonNode & data = node.Vector()[1];
 			if (data["type"].getType() == JsonNode::DATA_STRING)
-				event.objectType = VLC->modh->identifiers.getIdentifier(data["type"]).get();
+			{
+				auto identifier = VLC->modh->identifiers.getIdentifier(data["type"]);
+				if(identifier)
+					event.objectType = identifier.get();
+				else
+					throw std::runtime_error("Identifier resolution failed in event condition");
+			}
+
 			if (data["type"].getType() == JsonNode::DATA_FLOAT)
 				event.objectType = data["type"].Float();
 

From 22b93106c8e4ee608e82f968b997e5ce92efb54a Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 13 Feb 2016 10:47:40 +0300
Subject: [PATCH 070/105] Experimental drafts of Json serializer

---
 Global.h                               |  18 +--
 lib/CMakeLists.txt                     |   4 +
 lib/VCMI_lib.cbp                       |   7 ++
 lib/mapping/MapFormatJson.cpp          | 151 +++++++++++++------------
 lib/mapping/MapFormatJson.h            |  13 +--
 lib/serializer/JsonDeserializer.cpp    |  23 ++++
 lib/serializer/JsonDeserializer.h      |  23 ++++
 lib/serializer/JsonSerializeFormat.cpp |  81 +++++++++++++
 lib/serializer/JsonSerializeFormat.h   |  58 ++++++++++
 lib/serializer/JsonSerializer.cpp      |  23 ++++
 lib/serializer/JsonSerializer.h        |  25 ++++
 11 files changed, 339 insertions(+), 87 deletions(-)
 create mode 100644 lib/serializer/JsonDeserializer.cpp
 create mode 100644 lib/serializer/JsonDeserializer.h
 create mode 100644 lib/serializer/JsonSerializeFormat.cpp
 create mode 100644 lib/serializer/JsonSerializeFormat.h
 create mode 100644 lib/serializer/JsonSerializer.cpp
 create mode 100644 lib/serializer/JsonSerializer.h

diff --git a/Global.h b/Global.h
index 4089f4425..43523e3d1 100644
--- a/Global.h
+++ b/Global.h
@@ -55,7 +55,7 @@ static_assert(sizeof(bool) == 1, "Bool needs to be 1 byte in size.");
 #  define VCMI_UNIX
 #  define VCMI_XDG
 #  ifdef __ANDROID__
-#    define VCMI_ANDROID 
+#    define VCMI_ANDROID
 #  endif
 #elif defined(__FreeBSD_kernel__) || defined(__FreeBSD__)
 #  define VCMI_UNIX
@@ -285,7 +285,7 @@ std::ostream & operator<<(std::ostream & out, const std::vector<T> & container)
 
 namespace vstd
 {
-	
+
 	// combine hashes. Present in boost but not in std
 	template <class T>
 	inline void hash_combine(std::size_t& seed, const T& v)
@@ -293,7 +293,7 @@ namespace vstd
 		std::hash<T> hasher;
 		seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
 	}
-	
+
 	//returns true if container c contains item i
 	template <typename Container, typename Item>
 	bool contains(const Container & c, const Item &i)
@@ -505,7 +505,7 @@ namespace vstd
 	void erase_if(std::set<Elem> &setContainer, Predicate pred)
 	{
 		auto itr = setContainer.begin();
-		auto endItr = setContainer.end(); 
+		auto endItr = setContainer.end();
 		while(itr != endItr)
 		{
 			auto tmpItr = itr++;
@@ -519,7 +519,7 @@ namespace vstd
 	void erase_if(std::map<Key, Val> &container, Predicate pred)
 	{
 		auto itr = container.begin();
-		auto endItr = container.end(); 
+		auto endItr = container.end();
 		while(itr != endItr)
 		{
 			auto tmpItr = itr++;
@@ -554,7 +554,7 @@ namespace vstd
 			return vf(lhs) < vf(rhs);
 		});
 	}
-		
+
 	//Returns iterator to the element for which the value of ValueFunction is maximal
 	template<class ForwardRange, class ValueFunction>
 	auto maxElementByFun(const ForwardRange& rng, ValueFunction vf) -> decltype(std::begin(rng))
@@ -627,7 +627,7 @@ namespace vstd
 	{
 		if(index < r.size())
 			return r[index];
-		
+
 		return defaultValue;
 	}
 
@@ -668,12 +668,12 @@ namespace vstd
 		boost::sort(vec);
 		vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
 	}
-	
+
 	template <typename T>
 	void concatenate(std::vector<T> &dest, const std::vector<T> &src)
 	{
 		dest.reserve(dest.size() + src.size());
-		dest.insert(dest.end(), src.begin(), src.end());	
+		dest.insert(dest.end(), src.begin(), src.end());
 	}
 
 	template <typename T>
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index ef5e1e9b6..be534cff8 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -104,6 +104,10 @@ set(lib_SRCS
 		Connection.cpp
 		NetPacksLib.cpp
 
+		serializer/JsonSerializer.cpp
+		serializer/JsonDeserializer.cpp
+		serializer/JsonSerializeFormat.cpp
+
 		registerTypes/RegisterTypes.cpp
 		registerTypes/TypesClientPacks1.cpp
 		registerTypes/TypesClientPacks2.cpp
diff --git a/lib/VCMI_lib.cbp b/lib/VCMI_lib.cbp
index e68ce99a8..946c88d88 100644
--- a/lib/VCMI_lib.cbp
+++ b/lib/VCMI_lib.cbp
@@ -152,6 +152,7 @@
 		<Unit filename="CGeneralTextHandler.h" />
 		<Unit filename="CHeroHandler.cpp" />
 		<Unit filename="CHeroHandler.h" />
+		<Unit filename="CMakeLists.txt" />
 		<Unit filename="CModHandler.cpp" />
 		<Unit filename="CModHandler.h" />
 		<Unit filename="CObstacleInstance.cpp" />
@@ -315,6 +316,12 @@
 		<Unit filename="rmg/CZoneGraphGenerator.h" />
 		<Unit filename="rmg/CZonePlacer.cpp" />
 		<Unit filename="rmg/CZonePlacer.h" />
+		<Unit filename="serializer/JsonDeserializer.cpp" />
+		<Unit filename="serializer/JsonDeserializer.h" />
+		<Unit filename="serializer/JsonSerializeFormat.cpp" />
+		<Unit filename="serializer/JsonSerializeFormat.h" />
+		<Unit filename="serializer/JsonSerializer.cpp" />
+		<Unit filename="serializer/JsonSerializer.h" />
 		<Unit filename="spells/AdventureSpellMechanics.cpp" />
 		<Unit filename="spells/AdventureSpellMechanics.h" />
 		<Unit filename="spells/BattleSpellMechanics.cpp" />
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 5fe5bb28b..ba227a96f 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -23,8 +23,31 @@
 #include "../mapObjects/CObjectClassesHandler.h"
 #include "../mapObjects/CGHeroInstance.h"
 #include "../mapObjects/CGTownInstance.h"
-
 #include "../StringConstants.h"
+#include "../serializer/JsonDeserializer.h"
+#include "../serializer/JsonSerializer.h"
+
+namespace HeaderDetail
+{
+	static const std::map<std::string, ui8> difficultyReverseMap =
+	{
+		{"", 1},
+		{"EASY", 0},
+		{"NORMAL", 1},
+		{"HARD", 2},
+		{"EXPERT", 3},
+		{"IMPOSSIBLE", 4}
+	};
+
+	static const std::map<ui8, std::string> difficultyForwardMap =
+	{
+		{0, "EASY"},
+		{1, "NORMAL"},
+		{2, "HARD"},
+		{3, "EXPERT"},
+		{4, "IMPOSSIBLE"}
+	};
+}
 
 namespace TriggeredEventsDetail
 {
@@ -46,7 +69,7 @@ namespace TriggeredEventsDetail
 
 		auto pos = vstd::find_pos(conditionNames, conditionName);
 
-		event.condition = EventCondition::EWinLoseType(pos));
+		event.condition = EventCondition::EWinLoseType(pos);
 		if (node.Vector().size() > 1)
 		{
 			const JsonNode & data = node.Vector()[1];
@@ -272,7 +295,7 @@ std::unique_ptr<CMapHeader> CMapLoaderJson::loadMapHeader()
 	return std::move(mapHeader);
 }
 
-const JsonNode CMapLoaderJson::readJson(const std::string & archiveFilename)
+const JsonNode CMapLoaderJson::getFromArchive(const std::string & archiveFilename)
 {
 	ResourceID resource(archiveFilename, EResType::TEXT);
 
@@ -306,93 +329,89 @@ void CMapLoaderJson::readMap()
 void CMapLoaderJson::readHeader()
 {
 	//do not use map field here, use only mapHeader
-	const JsonNode header = readJson(HEADER_FILE_NAME);
+	JsonNode header = getFromArchive(HEADER_FILE_NAME);
+	JsonDeserializer handler(header);
 
 	mapHeader->version = EMapFormat::VCMI;//todo: new version field
 
 	//todo: multilevel map load support
-	const JsonNode levels = header["mapLevels"];
-	mapHeader->height = levels["surface"]["height"].Float();
-	mapHeader->width = levels["surface"]["width"].Float();
-	mapHeader->twoLevel = !levels["underground"].isNull();
+	{
+		auto levels = handler.enterStruct("mapLevels");
+
+		{
+			auto surface = levels.enterStruct("surface");
+			mapHeader->height = surface.get()["height"].Float();
+			mapHeader->width = surface.get()["width"].Float();
+		}
+		{
+			auto underground = levels.enterStruct("underground");
+			mapHeader->twoLevel = !underground.get().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},
-		{"EXPERT", 3},
-		{"IMPOSSIBLE", 4}
-	};
-
-	mapHeader->difficulty = difficultyMap.at(header["difficulty"].String());
-	mapHeader->levelLimit = header["levelLimit"].Float();
+	mapHeader->difficulty = HeaderDetail::difficultyReverseMap.at(header["difficulty"].String());
+	mapHeader->levelLimit = header["heroLevelLimit"].Float();
 
 
 //	std::vector<bool> allowedHeroes;
 //	std::vector<ui16> placeholdedHeroes;
 
 	readTriggeredEvents(header);
-	readPlayerInfo(header);
-	readTeams(header);
+
+	readPlayerInfo(handler);
+
+	readTeams(handler);
 	//TODO: readHeader
 }
 
-void CMapLoaderJson::readPlayerInfo(const JsonNode & input)
+void CMapLoaderJson::readPlayerInfo(JsonDeserializer & handler)
 {
-	const JsonNode & src = input["players"];
-	int howManyTeams = 0;
+	auto playersData = handler.enterStruct("players");
 
 	for(int player = 0; player < PlayerColor::PLAYER_LIMIT_I; player++)
 	{
 		PlayerInfo & info = mapHeader->players.at(player);
 
-		const JsonNode & playerSrc = src[GameConstants::PLAYER_COLOR_NAMES[player]];
+		auto playerData = playersData.enterStruct(GameConstants::PLAYER_COLOR_NAMES[player]);
 
-		if(playerSrc.isNull())
+		if(playerData.get().isNull())
 		{
 			info.canComputerPlay = false;
 			info.canHumanPlay = false;
 		}
 		else
 		{
-			readPlayerInfo(info, playerSrc);
+			//allowed factions
+
+		//	info.isFactionRandom =
+
+			info.canComputerPlay = true;
+			info.canHumanPlay = playerData.get()["canPlay"].String() != "AIOnly";
+
+			//placedHeroes
+
+			//mainTown
+
+			info.generateHeroAtMainTown = playerData.get()["generateHeroAtMainTown"].Bool();
+
+			//mainHero
+
+			//mainHeroPortrait
+
+			//mainCustomHeroName
 		}
 	}
-	mapHeader->howManyTeams = howManyTeams;
 }
 
-void CMapLoaderJson::readPlayerInfo(PlayerInfo& info, const JsonNode& input)
+void CMapLoaderJson::readTeams(JsonDeserializer & handler)
 {
-	//allowed factions
-
-//	info.isFactionRandom =
-
-	info.canComputerPlay = true;
-	info.canHumanPlay = input["canPlay"].String() != "AIOnly";
-
-	//placedHeroes
-
-	//mainTown
-
-	info.generateHeroAtMainTown = input["generateHeroAtMainTown"].Bool();
-
-	//mainHero
-
-	//mainHeroPortrait
-
-	//mainCustomHeroName
-}
-
-void CMapLoaderJson::readTeams(const JsonNode& input)
-{
-	const JsonNode & src = input["teams"];
+	auto teamsData = handler.enterStruct("teams");
+	const JsonNode & src = teamsData.get();
 
     if(src.getType() != JsonNode::DATA_VECTOR)
 	{
@@ -566,12 +585,12 @@ void CMapLoaderJson::readTerrainLevel(const JsonNode& src, const int index)
 void CMapLoaderJson::readTerrain()
 {
 	{
-		const JsonNode surface = readJson("surface_terrain.json");
+		const JsonNode surface = getFromArchive("surface_terrain.json");
 		readTerrainLevel(surface, 0);
 	}
 	if(map->twoLevel)
 	{
-		const JsonNode underground = readJson("underground_terrain.json");
+		const JsonNode underground = getFromArchive("underground_terrain.json");
 		readTerrainLevel(underground, 1);
 	}
 
@@ -642,7 +661,7 @@ void CMapLoaderJson::readObjects()
 
 	std::vector<std::unique_ptr<MapObjectLoader>> loaders;//todo: optimize MapObjectLoader memory layout
 
-	const JsonNode data = readJson(OBJECTS_FILE_NAME);
+	const JsonNode data = getFromArchive(OBJECTS_FILE_NAME);
 
 	//get raw data
 	for(const auto & p : data.Struct())
@@ -703,6 +722,8 @@ void CMapSaverJson::saveMap(const std::unique_ptr<CMap>& map)
 void CMapSaverJson::writeHeader()
 {
 	JsonNode header;
+	JsonSerializer handler(header);
+
 	header["versionMajor"].Float() = VERSION_MAJOR;
 	header["versionMinor"].Float() = VERSION_MINOR;
 
@@ -724,17 +745,9 @@ void CMapSaverJson::writeHeader()
 
 
 	//todo: support arbitrary percentage
-	static const std::map<ui8, std::string> difficultyMap =
-	{
-		{0, "EASY"},
-		{1, "NORMAL"},
-		{2, "HARD"},
-		{3, "EXPERT"},
-		{4, "IMPOSSIBLE"}
-	};
 
-	header["difficulty"].String() = difficultyMap.at(map->difficulty);
-	header["levelLimit"].Float() = map->levelLimit;
+	header["difficulty"].String() = HeaderDetail::difficultyForwardMap.at(map->difficulty);
+	header["heroLevelLimit"].Float() = map->levelLimit;
 
 	writeTriggeredEvents(header);
 
@@ -789,17 +802,15 @@ void CMapSaverJson::writeTeams(JsonNode& output)
 	{
 		const PlayerInfo & player = map->players.at(idx);
 		int team = player.team.getNum();
-		if(vstd::isbetween(team, 0, map->howManyTeams-1) && player.canAnyonePlay())
+		if(vstd::iswithin(team, 0, map->howManyTeams-1) && player.canAnyonePlay())
 			teamsData.at(team).insert(PlayerColor(idx));
 	}
-//just an optimization but breaks test
-#if 0
+
 	//remove single-member teams
 	vstd::erase_if(teamsData, [](std::set<PlayerColor> & elem) -> bool
 	{
 		return elem.size() <= 1;
 	});
-#endif
 
 	//construct output
 	dest.setType(JsonNode::DATA_VECTOR);
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index de3fabb45..2289529a1 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -22,6 +22,8 @@ struct TerrainTile;
 struct PlayerInfo;
 class CGObjectInstance;
 class AObjectTypeHandler;
+class JsonDeserializer;
+class JsonSerializer;
 
 class DLL_LINKAGE CMapFormatJson
 {
@@ -149,18 +151,13 @@ private:
 	/**
 	 * Reads player information.
 	 */
-	void readPlayerInfo(const JsonNode & input);
-
-	/**
-	 * Reads one player information.
-	 */
-	void readPlayerInfo(PlayerInfo & info, const JsonNode & input);
+	void readPlayerInfo(JsonDeserializer & handler);
 
 	/**
 	 * Reads team settings to header
 	 * @param input serialized header
 	 */
-	void readTeams(const JsonNode & input);
+	void readTeams(JsonDeserializer & handler);
 
 	void readTerrainTile(const std::string & src, TerrainTile & tile);
 
@@ -173,7 +170,7 @@ private:
 	 */
 	void readObjects();
 
-	const JsonNode readJson(const std::string & archiveFilename);
+	const JsonNode getFromArchive(const std::string & archiveFilename);
 
 	CInputStream * buffer;
 	std::shared_ptr<CIOApi> ioApi;
diff --git a/lib/serializer/JsonDeserializer.cpp b/lib/serializer/JsonDeserializer.cpp
new file mode 100644
index 000000000..5f1737434
--- /dev/null
+++ b/lib/serializer/JsonDeserializer.cpp
@@ -0,0 +1,23 @@
+/*
+ * JsonDeserializer.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
+ *
+ */
+
+
+#include "StdInc.h"
+#include "JsonDeserializer.h"
+
+#include "../JsonNode.h"
+
+JsonDeserializer::JsonDeserializer(JsonNode & root_):
+	JsonSerializeFormat(root_)
+{
+
+}
+
+
diff --git a/lib/serializer/JsonDeserializer.h b/lib/serializer/JsonDeserializer.h
new file mode 100644
index 000000000..91bbae0bc
--- /dev/null
+++ b/lib/serializer/JsonDeserializer.h
@@ -0,0 +1,23 @@
+/*
+ * JsonDeserializer.h, 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
+ *
+ */
+
+#pragma once
+
+#include  "JsonSerializeFormat.h"
+
+class JsonNode;
+
+class JsonDeserializer: public JsonSerializeFormat
+{
+public:
+	static const bool saving = false;
+
+	JsonDeserializer(JsonNode & root_);
+};
diff --git a/lib/serializer/JsonSerializeFormat.cpp b/lib/serializer/JsonSerializeFormat.cpp
new file mode 100644
index 000000000..68d7c0e71
--- /dev/null
+++ b/lib/serializer/JsonSerializeFormat.cpp
@@ -0,0 +1,81 @@
+/*
+ * JsonSerializeFormat.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
+ *
+ */
+
+
+#include "StdInc.h"
+#include "JsonSerializeFormat.h"
+
+#include "../JsonNode.h"
+
+//JsonStructSerializer
+JsonStructSerializer::JsonStructSerializer(JsonStructSerializer&& other):
+	restoreState(false),
+	owner(other.owner),
+	parentNode(other.parentNode),
+	thisNode(other.thisNode)
+{
+
+}
+
+JsonStructSerializer::~JsonStructSerializer()
+{
+	if(restoreState)
+		owner.current = parentNode;
+}
+
+JsonStructSerializer::JsonStructSerializer(JsonSerializeFormat& owner_, const std::string& fieldName):
+	restoreState(true),
+	owner(owner_),
+	parentNode(owner.current),
+	thisNode(&(parentNode->operator[](fieldName)))
+{
+	owner.current = thisNode;
+}
+
+JsonStructSerializer::JsonStructSerializer(JsonStructSerializer & parent, const std::string & fieldName):
+	restoreState(true),
+	owner(parent.owner),
+	parentNode(parent.thisNode),
+	thisNode(&(parentNode->operator[](fieldName)))
+{
+	owner.current = thisNode;
+}
+
+
+JsonStructSerializer JsonStructSerializer::enterStruct(const std::string & fieldName)
+{
+	return JsonStructSerializer(*this, fieldName);
+}
+
+JsonNode& JsonStructSerializer::get()
+{
+	return *thisNode;
+}
+
+JsonSerializeFormat * JsonStructSerializer::operator->()
+{
+	return &owner;
+}
+
+
+//JsonSerializeFormat
+JsonSerializeFormat::JsonSerializeFormat(JsonNode & root_):
+	root(&root_),
+	current(root)
+{
+
+}
+
+JsonStructSerializer JsonSerializeFormat::enterStruct(const std::string & fieldName)
+{
+	JsonStructSerializer res(*this, fieldName);
+
+	return res;
+}
diff --git a/lib/serializer/JsonSerializeFormat.h b/lib/serializer/JsonSerializeFormat.h
new file mode 100644
index 000000000..d6d27e470
--- /dev/null
+++ b/lib/serializer/JsonSerializeFormat.h
@@ -0,0 +1,58 @@
+/*
+ * JsonSerializeFormat.h, 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
+ *
+ */
+
+#pragma once
+
+class JsonNode;
+
+class JsonSerializeFormat;
+
+class JsonStructSerializer: public boost::noncopyable
+{
+public:
+	JsonStructSerializer(JsonStructSerializer && other);
+	virtual ~JsonStructSerializer();
+
+	JsonStructSerializer enterStruct(const std::string & fieldName);
+
+	JsonNode & get();
+
+	JsonSerializeFormat * operator->();
+private:
+	JsonStructSerializer(JsonSerializeFormat & owner_, const std::string & fieldName);
+	JsonStructSerializer(JsonStructSerializer & parent, const std::string & fieldName);
+
+	bool restoreState;
+	JsonSerializeFormat & owner;
+	JsonNode * parentNode;
+	JsonNode * thisNode;
+	friend class JsonSerializeFormat;
+};
+
+class JsonSerializeFormat
+{
+public:
+	JsonSerializeFormat(JsonNode & root_);
+	virtual ~JsonSerializeFormat() = default;
+
+	JsonNode & getRoot()
+	{
+		return *root;
+	};
+
+	JsonStructSerializer enterStruct(const std::string & fieldName);
+
+protected:
+	JsonNode * root;
+	JsonNode * current;
+private:
+	friend class JsonStructSerializer;
+};
+
diff --git a/lib/serializer/JsonSerializer.cpp b/lib/serializer/JsonSerializer.cpp
new file mode 100644
index 000000000..21755321c
--- /dev/null
+++ b/lib/serializer/JsonSerializer.cpp
@@ -0,0 +1,23 @@
+/*
+ * JsonSerializer.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
+ *
+ */
+
+
+#include "StdInc.h"
+#include "JsonSerializer.h"
+
+#include "../JsonNode.h"
+
+JsonSerializer::JsonSerializer(JsonNode & root_):
+	JsonSerializeFormat(root_)
+{
+
+}
+
+
diff --git a/lib/serializer/JsonSerializer.h b/lib/serializer/JsonSerializer.h
new file mode 100644
index 000000000..0f4a9e925
--- /dev/null
+++ b/lib/serializer/JsonSerializer.h
@@ -0,0 +1,25 @@
+/*
+ * JsonSerializer.h, 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
+ *
+ */
+
+#pragma once
+
+#include  "JsonSerializeFormat.h"
+
+class JsonNode;
+
+class JsonSerializer: public JsonSerializeFormat
+{
+public:
+	static const bool saving = true;
+
+	JsonSerializer(JsonNode & root_);
+
+
+};

From 5a92e0de2b42886276475cc2446425697c88b9c0 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 13 Feb 2016 15:22:26 +0300
Subject: [PATCH 071/105] Small redesign

---
 lib/mapping/MapFormatJson.cpp        | 64 +++++++++++++++-------------
 lib/mapping/MapFormatJson.h          |  6 +--
 lib/serializer/JsonSerializeFormat.h |  5 +++
 3 files changed, 43 insertions(+), 32 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index ba227a96f..dbbbf36d0 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -179,8 +179,9 @@ const int CMapFormatJson::VERSION_MINOR = 0;
 const std::string CMapFormatJson::HEADER_FILE_NAME = "header.json";
 const std::string CMapFormatJson::OBJECTS_FILE_NAME = "objects.json";
 
-void CMapFormatJson::readTriggeredEvents(const JsonNode & input)
+void CMapFormatJson::readTriggeredEvents(JsonDeserializer & handler)
 {
+	const JsonNode & input = handler.getCurrent();
 	mapHeader->victoryMessage = input["victoryString"].String();
 	mapHeader->victoryIconIndex = input["victoryIconIndex"].Float();
 
@@ -211,15 +212,15 @@ void CMapFormatJson::readTriggeredEvent(TriggeredEvent & event, const JsonNode &
 
 void CMapFormatJson::writeTriggeredEvents(JsonNode& output)
 {
-	output["victoryString"].String() = map->victoryMessage;
-	output["victoryIconIndex"].Float() = map->victoryIconIndex;
+	output["victoryString"].String() = mapHeader->victoryMessage;
+	output["victoryIconIndex"].Float() = mapHeader->victoryIconIndex;
 
-	output["defeatString"].String() = map->defeatMessage;
-	output["defeatIconIndex"].Float() = map->defeatIconIndex;
+	output["defeatString"].String() = mapHeader->defeatMessage;
+	output["defeatIconIndex"].Float() = mapHeader->defeatIconIndex;
 
 	JsonMap & triggeredEvents = output["triggeredEvents"].Struct();
 
-	for(auto event : map->triggeredEvents)
+	for(auto event : mapHeader->triggeredEvents)
 		writeTriggeredEvent(event, triggeredEvents[event.identifier]);
 }
 
@@ -246,15 +247,16 @@ CMapPatcher::CMapPatcher(JsonNode stream):
 
 void CMapPatcher::patchMapHeader(std::unique_ptr<CMapHeader> & header)
 {
-	header.swap(mapHeader);
+	map = nullptr;
+	mapHeader = header.get();
 	if (!input.isNull())
 		readPatchData();
-	header.swap(mapHeader);
 }
 
 void CMapPatcher::readPatchData()
 {
-	readTriggeredEvents(input);
+	JsonDeserializer handler(input);
+	readTriggeredEvents(handler);
 }
 
 
@@ -281,18 +283,21 @@ si32 CMapLoaderJson::getIdentifier(const std::string& type, const std::string& n
 std::unique_ptr<CMap> CMapLoaderJson::loadMap()
 {
 	LOG_TRACE(logGlobal);
-	map = new CMap();
-	mapHeader = std::unique_ptr<CMapHeader>(dynamic_cast<CMapHeader *>(map));
+	std::unique_ptr<CMap> result = std::unique_ptr<CMap>(new CMap());
+	map = result.get();
+	mapHeader = map;
 	readMap();
-	return std::unique_ptr<CMap>(dynamic_cast<CMap *>(mapHeader.release()));
+	return std::move(result);
 }
 
 std::unique_ptr<CMapHeader> CMapLoaderJson::loadMapHeader()
 {
 	LOG_TRACE(logGlobal);
-	mapHeader.reset(new CMapHeader);
+	map = nullptr;
+	std::unique_ptr<CMapHeader> result = std::unique_ptr<CMapHeader>(new CMapHeader());
+	mapHeader = result.get();
 	readHeader();
-	return std::move(mapHeader);
+	return std::move(result);
 }
 
 const JsonNode CMapLoaderJson::getFromArchive(const std::string & archiveFilename)
@@ -361,7 +366,7 @@ void CMapLoaderJson::readHeader()
 //	std::vector<bool> allowedHeroes;
 //	std::vector<ui16> placeholdedHeroes;
 
-	readTriggeredEvents(header);
+	readTriggeredEvents(handler);
 
 	readPlayerInfo(handler);
 
@@ -714,6 +719,7 @@ void CMapSaverJson::addToArchive(const JsonNode& data, const std::string& filena
 void CMapSaverJson::saveMap(const std::unique_ptr<CMap>& map)
 {
 	this->map = map.get();
+	this->mapHeader = this->map;
 	writeHeader();
 	writeTerrain();
 	writeObjects();
@@ -729,25 +735,25 @@ void CMapSaverJson::writeHeader()
 
 	//todo: multilevel map save support
 	JsonNode & levels = header["mapLevels"];
-	levels["surface"]["height"].Float() = map->height;
-	levels["surface"]["width"].Float() = map->width;
+	levels["surface"]["height"].Float() = mapHeader->height;
+	levels["surface"]["width"].Float() = mapHeader->width;
 	levels["surface"]["index"].Float() = 0;
 
-	if(map->twoLevel)
+	if(mapHeader->twoLevel)
 	{
-		levels["underground"]["height"].Float() = map->height;
-		levels["underground"]["width"].Float() = map->width;
+		levels["underground"]["height"].Float() = mapHeader->height;
+		levels["underground"]["width"].Float() = mapHeader->width;
 		levels["underground"]["index"].Float() = 1;
 	}
 
-	header["name"].String() = map->name;
-	header["description"].String() = map->description;
+	header["name"].String() = mapHeader->name;
+	header["description"].String() = mapHeader->description;
 
 
 	//todo: support arbitrary percentage
 
-	header["difficulty"].String() = HeaderDetail::difficultyForwardMap.at(map->difficulty);
-	header["heroLevelLimit"].Float() = map->levelLimit;
+	header["difficulty"].String() = HeaderDetail::difficultyForwardMap.at(mapHeader->difficulty);
+	header["heroLevelLimit"].Float() = mapHeader->levelLimit;
 
 	writeTriggeredEvents(header);
 
@@ -768,7 +774,7 @@ void CMapSaverJson::writePlayerInfo(JsonNode & output)
 
 	for(int player = 0; player < PlayerColor::PLAYER_LIMIT_I; player++)
 	{
-		const PlayerInfo & info = map->players[player];
+		const PlayerInfo & info = mapHeader->players[player];
 
 		if(info.canAnyonePlay())
 			writePlayerInfo(info, dest[GameConstants::PLAYER_COLOR_NAMES[player]]);
@@ -795,14 +801,14 @@ void CMapSaverJson::writeTeams(JsonNode& output)
 	JsonNode & dest = output["teams"];
 	std::vector<std::set<PlayerColor>> teamsData;
 
-	teamsData.resize(map->howManyTeams);
+	teamsData.resize(mapHeader->howManyTeams);
 
 	//get raw data
-	for(int idx = 0; idx < map->players.size(); idx++)
+	for(int idx = 0; idx < mapHeader->players.size(); idx++)
 	{
-		const PlayerInfo & player = map->players.at(idx);
+		const PlayerInfo & player = mapHeader->players.at(idx);
 		int team = player.team.getNum();
-		if(vstd::iswithin(team, 0, map->howManyTeams-1) && player.canAnyonePlay())
+		if(vstd::iswithin(team, 0, mapHeader->howManyTeams-1) && player.canAnyonePlay())
 			teamsData.at(team).insert(PlayerColor(idx));
 	}
 
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 2289529a1..28ec987db 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -42,12 +42,12 @@ protected:
 	 * ptr to the map header object which gets filled by data from the buffer.
 	 * (when loading map and mapHeader point to the same object)
 	 */
-	std::unique_ptr<CMapHeader> mapHeader;
+	CMapHeader * mapHeader;
 
 	/**
 	 * Reads triggered events, including victory/loss conditions
 	 */
-	void readTriggeredEvents(const JsonNode & input);
+	void readTriggeredEvents(JsonDeserializer & handler);
 
 	/**
 	 * Writes triggered events, including victory/loss conditions
@@ -89,7 +89,7 @@ private:
 	void readPatchData();
 
 
-	const JsonNode input;
+	JsonNode input;
 };
 
 class DLL_LINKAGE CMapLoaderJson : public CMapFormatJson, public IMapLoader
diff --git a/lib/serializer/JsonSerializeFormat.h b/lib/serializer/JsonSerializeFormat.h
index d6d27e470..59b278fce 100644
--- a/lib/serializer/JsonSerializeFormat.h
+++ b/lib/serializer/JsonSerializeFormat.h
@@ -47,6 +47,11 @@ public:
 		return *root;
 	};
 
+	JsonNode & getCurrent()
+	{
+		return *current;
+	};
+
 	JsonStructSerializer enterStruct(const std::string & fieldName);
 
 protected:

From a59f0c23ce5b54bc1f8c22ae91c28af601320bfa Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 13 Feb 2016 17:16:00 +0300
Subject: [PATCH 072/105] Dedug tweaks

---
 lib/CGameState.cpp                |  2 +-
 lib/mapObjects/CObjectHandler.cpp |  2 --
 lib/mapping/MapFormatJson.cpp     | 20 ++++++++++++--------
 lib/mapping/MapFormatJson.h       |  1 -
 test/CMapFormatTest.cpp           | 10 ++++++----
 5 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/lib/CGameState.cpp b/lib/CGameState.cpp
index e581294c4..087783d89 100644
--- a/lib/CGameState.cpp
+++ b/lib/CGameState.cpp
@@ -1852,7 +1852,7 @@ void CGameState::initMapObjects()
 	{
 		if(obj)
 		{
-			//logGlobal->traceStream() << boost::format ("Calling Init for object %d, %d") % obj->ID % obj->subID;
+			logGlobal->traceStream() << boost::format ("Calling Init for object %d, %s, %s") % obj->id.getNum() % obj->typeName % obj->subTypeName;
 			obj->initObj();
 		}
 	}
diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 38271479f..c0d46aec9 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -359,8 +359,6 @@ void CGObjectInstance::readJson(const JsonNode & json)
 
 	appearance.readJson(json["template"], false);
 
-	logGlobal->debugStream() <<"Loading: [" << pos << "] " << id << " " << ID << " " << subID << " " << typeName << " " << subTypeName;
-
 	readJsonOptions(json["options"]);
 }
 
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index dbbbf36d0..e5661e50c 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -602,13 +602,15 @@ void CMapLoaderJson::readTerrain()
 }
 
 CMapLoaderJson::MapObjectLoader::MapObjectLoader(CMapLoaderJson * _owner, const JsonMap::value_type& json):
-	owner(_owner), instance(nullptr),handler(nullptr),id(-1), jsonKey(json.first), configuration(json.second), internalId(extractNumber(jsonKey, '_'))
+	owner(_owner), instance(nullptr),id(-1), jsonKey(json.first), configuration(json.second), internalId(extractNumber(jsonKey, '_'))
 {
 
 }
 
 void CMapLoaderJson::MapObjectLoader::construct()
 {
+	logGlobal->debugStream() <<"Loading: " <<jsonKey;
+
 	//TODO:consider move to ObjectTypeHandler
 	//find type handler
 	std::string typeName = configuration["type"].String(), subTypeName = configuration["subType"].String();
@@ -618,12 +620,7 @@ void CMapLoaderJson::MapObjectLoader::construct()
 		logGlobal->traceStream() << configuration;
 		return;
 	}
-	if(subTypeName.empty())
-	{
-		logGlobal->errorStream() << "Object subType missing";
-		logGlobal->traceStream() << configuration;
-		return;
-	}
+
 
 	//special case for grail
     if(typeName == "grail")
@@ -633,9 +630,16 @@ void CMapLoaderJson::MapObjectLoader::construct()
 		pos.y = configuration["y"].Float();
 		pos.z = configuration["l"].Float();
 		owner->map->grailRadius = configuration["options"]["grailRadius"].Float();
+		return;
+	}
+	else if(subTypeName.empty())
+	{
+		logGlobal->errorStream() << "Object subType missing";
+		logGlobal->traceStream() << configuration;
+		return;
 	}
 
-	handler = VLC->objtypeh->getHandlerFor(typeName, subTypeName);
+	auto handler = VLC->objtypeh->getHandlerFor(typeName, subTypeName);
 
 	instance = handler->create(ObjectTemplate());
 	instance->id = ObjectInstanceID(owner->map->objects.size());
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 28ec987db..50488c70b 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -123,7 +123,6 @@ private:
 		MapObjectLoader(CMapLoaderJson * _owner, const JsonMap::value_type & json);
 		CMapLoaderJson * owner;
 		CGObjectInstance * instance;
-		std::shared_ptr<AObjectTypeHandler> handler;
 		ObjectInstanceID id;
 		std::string jsonKey;//full id defined by map creator
 		const JsonNode & configuration;
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index 55fa76417..f022e1862 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -35,13 +35,15 @@ public:
 	{
 		CMapGenOptions opt;
 
-		opt.setHeight(CMapHeader::MAP_SIZE_SMALL);
-		opt.setWidth(CMapHeader::MAP_SIZE_SMALL);
+		opt.setHeight(CMapHeader::MAP_SIZE_LARGE);
+		opt.setWidth(CMapHeader::MAP_SIZE_LARGE);
 		opt.setHasTwoLevels(true);
-		opt.setPlayerCount(2);
+		opt.setPlayerCount(4);
 
 		opt.setPlayerTypeForStandardPlayer(PlayerColor(0), EPlayerType::HUMAN);
-		opt.setPlayerTypeForStandardPlayer(PlayerColor(1), EPlayerType::HUMAN);
+		opt.setPlayerTypeForStandardPlayer(PlayerColor(1), EPlayerType::AI);
+		opt.setPlayerTypeForStandardPlayer(PlayerColor(2), EPlayerType::AI);
+		opt.setPlayerTypeForStandardPlayer(PlayerColor(3), EPlayerType::AI);
 
 		CMapGenerator gen;
 

From 7106c5d1af177c70a3fc4138db43ba6efe34b5f6 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 13 Feb 2016 19:41:28 +0300
Subject: [PATCH 073/105] Fix loading of spell identifier

---
 lib/spells/CSpellHandler.cpp | 43 ++++++++++++++++++------------------
 1 file changed, 22 insertions(+), 21 deletions(-)

diff --git a/lib/spells/CSpellHandler.cpp b/lib/spells/CSpellHandler.cpp
index 284be7d34..9431da324 100644
--- a/lib/spells/CSpellHandler.cpp
+++ b/lib/spells/CSpellHandler.cpp
@@ -115,7 +115,7 @@ bool CSpell::adventureCast(const SpellCastEnvironment * env, AdventureSpellCastP
 }
 
 void CSpell::battleCast(const SpellCastEnvironment * env, BattleSpellCastParameters & parameters) const
-{	
+{
 	assert(env);
 	if(parameters.destinations.size()<1)
 	{
@@ -141,7 +141,7 @@ ui32 CSpell::calculateDamage(const ISpellCaster * caster, const CStack * affecte
 	//check if spell really does damage - if not, return 0
 	if(!isDamageSpell())
 		return 0;
-	return adjustRawDamage(caster, affectedCreature, calculateRawEffectValue(spellSchoolLevel, usedSpellPower));	
+	return adjustRawDamage(caster, affectedCreature, calculateRawEffectValue(spellSchoolLevel, usedSpellPower));
 }
 
 ESpellCastProblem::ESpellCastProblem CSpell::canBeCast(const CBattleInfoCallback * cb, PlayerColor player) const
@@ -395,7 +395,7 @@ int CSpell::adjustRawDamage(const ISpellCaster * caster, const CStack * affected
 
 int CSpell::calculateRawEffectValue(int effectLevel, int effectPower) const
 {
-	return effectPower * power + getPower(effectLevel);	
+	return effectPower * power + getPower(effectLevel);
 }
 
 ESpellCastProblem::ESpellCastProblem CSpell::internalIsImmune(const ISpellCaster * caster, const CStack *obj) const
@@ -420,7 +420,7 @@ ESpellCastProblem::ESpellCastProblem CSpell::internalIsImmune(const ISpellCaster
 		std::stringstream cachingStr;
 		cachingStr << "type_" << Bonus::LEVEL_SPELL_IMMUNITY << "source_" << Bonus::SPELL_EFFECT;
 
-		TBonusListPtr levelImmunitiesFromSpell = obj->getBonuses(Selector::type(Bonus::LEVEL_SPELL_IMMUNITY).And(Selector::sourceType(Bonus::SPELL_EFFECT)), cachingStr.str());	
+		TBonusListPtr levelImmunitiesFromSpell = obj->getBonuses(Selector::type(Bonus::LEVEL_SPELL_IMMUNITY).And(Selector::sourceType(Bonus::SPELL_EFFECT)), cachingStr.str());
 
 		if(levelImmunitiesFromSpell->size() > 0  &&  levelImmunitiesFromSpell->totalValue() >= level  &&  level)
 		{
@@ -433,19 +433,19 @@ ESpellCastProblem::ESpellCastProblem CSpell::internalIsImmune(const ISpellCaster
 		cachingStr << "type_" << Bonus::SPELL_IMMUNITY << "subtype_" << id.toEnum() << "addInfo_1";
 		if(obj->hasBonus(Selector::typeSubtypeInfo(Bonus::SPELL_IMMUNITY, id.toEnum(), 1), cachingStr.str()))
 			return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
-	}	
+	}
 
 	//check receptivity
 	if (isPositive() && obj->hasBonusOfType(Bonus::RECEPTIVE)) //accept all positive spells
 		return ESpellCastProblem::OK;
-		
+
 	//3. Check negation
 	//Orb of vulnerability
 	//FIXME: Orb of vulnerability mechanics is not such trivial (issue 1791)
 	const bool battleWideNegation = obj->hasBonusOfType(Bonus::NEGATE_ALL_NATURAL_IMMUNITIES, 0);
 	const bool heroNegation = obj->hasBonusOfType(Bonus::NEGATE_ALL_NATURAL_IMMUNITIES, 1);
 	//anyone can cast on artifact holder`s stacks
-	if(heroNegation) 
+	if(heroNegation)
 		return ESpellCastProblem::NOT_DECIDED;
 	//this stack is from other player
 	//todo: check that caster is always present (not trivial is this case)
@@ -520,9 +520,9 @@ ESpellCastProblem::ESpellCastProblem CSpell::isImmuneByStack(const ISpellCaster
 void CSpell::prepareBattleLog(const CBattleInfoCallback * cb,  const BattleSpellCast * packet, std::vector<std::string> & logLines) const
 {
 	bool displayDamage = true;
-	
+
 	std::string casterName("Something"); //todo: localize
-	
+
 	if(packet->castByHero)
 		casterName = cb->battleGetHeroInfo(packet->side).name;
 
@@ -536,13 +536,13 @@ void CSpell::prepareBattleLog(const CBattleInfoCallback * cb,  const BattleSpell
 				casterName = casterStack->type->namePl;
 		}
 	}
-	
+
 	if(packet->affectedCres.size() == 1)
 	{
 		const CStack * attackedStack = cb->battleGetStackByID(*packet->affectedCres.begin(), false);
-		
+
 		const std::string attackedNamePl = attackedStack->getCreature()->namePl;
-		
+
 		if(packet->castByHero)
 		{
 			const std::string fmt = VLC->generaltexth->allTexts[195];
@@ -550,17 +550,17 @@ void CSpell::prepareBattleLog(const CBattleInfoCallback * cb,  const BattleSpell
 		}
 		else
 		{
-			mechanics->battleLogSingleTarget(logLines, packet, casterName, attackedStack, displayDamage);		
+			mechanics->battleLogSingleTarget(logLines, packet, casterName, attackedStack, displayDamage);
 		}
 	}
 	else
 	{
 		boost::format text(VLC->generaltexth->allTexts[196]);
 		text % casterName % this->name;
-		logLines.push_back(text.str());		
+		logLines.push_back(text.str());
 	}
-	
-	
+
+
 	if(packet->dmgToDisplay > 0 && displayDamage)
 	{
 		boost::format dmgInfo(VLC->generaltexth->allTexts[376]);
@@ -611,7 +611,7 @@ void CSpell::setupMechanics()
 CSpell::AnimationItem::AnimationItem()
 	:resourceName(""),verticalPosition(VerticalPosition::TOP),pause(0)
 {
-	
+
 }
 
 
@@ -804,6 +804,7 @@ CSpell * CSpellHandler::loadFromJson(const JsonNode & json, const std::string &
 	using namespace SpellConfig;
 
 	CSpell * spell = new CSpell();
+	spell->identifier = identifier;
 
 	const auto type = json["type"].String();
 
@@ -966,7 +967,7 @@ CSpell * CSpellHandler::loadFromJson(const JsonNode & json, const std::string &
 			{
 				newItem.pause = item.Float();
 			}
-			
+
 			q.push_back(newItem);
 		}
 	};
@@ -1043,11 +1044,11 @@ void CSpellHandler::afterLoadFinalization()
 				delete bonus;
 			}
 			level.effectsTmp.clear();
-			
+
 			for(auto & bonus: level.effects)
-				bonus.sid = spell->id;	
+				bonus.sid = spell->id;
 		}
-		spell->setup();		
+		spell->setup();
 	}
 }
 

From e0af4a665ab19649f1ff1cea626bbd771b8294d5 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sat, 13 Feb 2016 19:43:05 +0300
Subject: [PATCH 074/105] Added hacks fot spell scroll support.

---
 lib/CArtHandler.cpp            | 35 ++++++++++++++++++++++++++++
 lib/CArtHandler.h              | 10 ++++++++
 lib/mapObjects/MiscObjects.cpp |  7 ++++++
 lib/mapObjects/MiscObjects.h   |  2 ++
 lib/mapping/CMapService.cpp    |  1 +
 lib/mapping/MapFormatH3M.cpp   | 42 ++++------------------------------
 lib/mapping/MapFormatH3M.h     |  9 --------
 lib/mapping/MapFormatJson.cpp  | 27 +++++++++++++++++++++-
 8 files changed, 85 insertions(+), 48 deletions(-)

diff --git a/lib/CArtHandler.cpp b/lib/CArtHandler.cpp
index 2ef62e4ba..ad1ec6ca1 100644
--- a/lib/CArtHandler.cpp
+++ b/lib/CArtHandler.cpp
@@ -23,6 +23,7 @@
 #include "CRandomGenerator.h"
 
 #include "mapObjects/CObjectClassesHandler.h"
+#include "mapping/CMap.h"
 
 // Note: list must match entries in ArtTraits.txt
 #define ART_POS_LIST    \
@@ -963,6 +964,40 @@ CArtifactInstance * CArtifactInstance::createNewArtifactInstance(int aid)
 	return createNewArtifactInstance(VLC->arth->artifacts[aid]);
 }
 
+CArtifactInstance * CArtifactInstance::createArtifact(CMap * map, int aid, int spellID)
+{
+	CArtifactInstance * a = nullptr;
+	if(aid >= 0)
+	{
+		if(spellID < 0)
+		{
+			a = CArtifactInstance::createNewArtifactInstance(aid);
+		}
+		else
+		{
+			a = CArtifactInstance::createScroll(SpellID(spellID).toSpell());
+		}
+	}
+	else //FIXME: create combined artifact instance for random combined artifacts, just in case
+	{
+		a = new CArtifactInstance(); //random, empty
+	}
+
+	map->addNewArtifactInstance(a);
+
+	//TODO make it nicer
+	if(a->artType && (!!a->artType->constituents))
+	{
+		CCombinedArtifactInstance * comb = dynamic_cast<CCombinedArtifactInstance *>(a);
+		for(CCombinedArtifactInstance::ConstituentInfo & ci : comb->constituentsInfo)
+		{
+			map->addNewArtifactInstance(ci.art);
+		}
+	}
+	return a;
+}
+
+
 void CArtifactInstance::deserializationFix()
 {
 	setType(artType);
diff --git a/lib/CArtHandler.h b/lib/CArtHandler.h
index 0efb2f4be..c76e4cdcb 100644
--- a/lib/CArtHandler.h
+++ b/lib/CArtHandler.h
@@ -25,6 +25,7 @@ struct ArtifactLocation;
 class CArtifactSet;
 class CArtifactInstance;
 class CRandomGenerator;
+class CMap;
 
 #define ART_BEARER_LIST \
 	ART_BEARER(HERO)\
@@ -152,6 +153,15 @@ public:
 	static CArtifactInstance *createScroll(SpellID sid);
 	static CArtifactInstance *createNewArtifactInstance(CArtifact *Art);
 	static CArtifactInstance *createNewArtifactInstance(int aid);
+
+	/**
+	 * Creates an artifact instance.
+	 *
+	 * @param aid the id of the artifact
+	 * @param spellID optional. the id of a spell if a spell scroll object should be created
+	 * @return the created artifact instance
+	 */
+	static CArtifactInstance * createArtifact(CMap * map, int aid, int spellID = -1);
 };
 
 class DLL_LINKAGE CCombinedArtifactInstance : public CArtifactInstance
diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index 2ce4872b9..0830f9371 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -1443,6 +1443,13 @@ void CGArtifact::writeJsonOptions(JsonNode& json) const
 {
 	CCreatureSet::writeJson(json["guards"]);
 	json["guardMessage"].String() = message;
+	if(ID == Obj::SPELL_SCROLL)
+	{
+		const Bonus * b = storedArtifact->getBonusLocalFirst(Selector::type(Bonus::SPELL));
+		SpellID spellId(b->subtype);
+
+		json["spell"].String() = SpellID(b->subtype).toSpell()->identifier;
+	}
 }
 
 void CGArtifact::readJsonOptions(const JsonNode& json)
diff --git a/lib/mapObjects/MiscObjects.h b/lib/mapObjects/MiscObjects.h
index 1eec4b6e4..22f9695ee 100644
--- a/lib/mapObjects/MiscObjects.h
+++ b/lib/mapObjects/MiscObjects.h
@@ -14,6 +14,8 @@
  *
  */
 
+class CMap;
+
 class DLL_LINKAGE CPlayersVisited: public CGObjectInstance
 {
 public:
diff --git a/lib/mapping/CMapService.cpp b/lib/mapping/CMapService.cpp
index a71245d53..4b58c7ae6 100644
--- a/lib/mapping/CMapService.cpp
+++ b/lib/mapping/CMapService.cpp
@@ -5,6 +5,7 @@
 #include "../filesystem/CBinaryReader.h"
 #include "../filesystem/CCompressedStream.h"
 #include "../filesystem/CMemoryStream.h"
+
 #include "CMap.h"
 
 #include "MapFormatH3M.h"
diff --git a/lib/mapping/MapFormatH3M.cpp b/lib/mapping/MapFormatH3M.cpp
index bdf07b9ae..496ceabc8 100644
--- a/lib/mapping/MapFormatH3M.cpp
+++ b/lib/mapping/MapFormatH3M.cpp
@@ -828,7 +828,7 @@ void CMapLoaderH3M::loadArtifactsOfHero(CGHeroInstance * hero)
 			{
 				// catapult by default
 				assert(!hero->getArt(ArtifactPosition::MACH4));
-				hero->putArtifact(ArtifactPosition::MACH4, createArtifact(ArtifactID::CATAPULT));
+				hero->putArtifact(ArtifactPosition::MACH4, CArtifactInstance::createArtifact(map, ArtifactID::CATAPULT));
 			}
 		}
 
@@ -885,7 +885,7 @@ bool CMapLoaderH3M::loadArtifactToSlot(CGHeroInstance * hero, int slot)
 		}
 
 		// this is needed, because some H3M maps (last scenario of ROE map) contain invalid data like misplaced artifacts
-		auto artifact = createArtifact(aid);
+		auto artifact =  CArtifactInstance::createArtifact(map, aid);
 		auto artifactPos = ArtifactPosition(slot);
 		if (artifact->canBePutAt(ArtifactLocation(hero, artifactPos)))
 		{
@@ -900,40 +900,6 @@ bool CMapLoaderH3M::loadArtifactToSlot(CGHeroInstance * hero, int slot)
 	return isArt;
 }
 
-CArtifactInstance * CMapLoaderH3M::createArtifact(int aid, int spellID /*= -1*/)
-{
-	CArtifactInstance * a = nullptr;
-	if(aid >= 0)
-	{
-		if(spellID < 0)
-		{
-			a = CArtifactInstance::createNewArtifactInstance(aid);
-		}
-		else
-		{
-			a = CArtifactInstance::createScroll(SpellID(spellID).toSpell());
-		}
-	}
-	else //FIXME: create combined artifact instance for random combined artifacts, just in case
-	{
-		a = new CArtifactInstance(); //random, empty
-	}
-
-	map->addNewArtifactInstance(a);
-
-	//TODO make it nicer
-	if(a->artType && (!!a->artType->constituents))
-	{
-		CCombinedArtifactInstance * comb = dynamic_cast<CCombinedArtifactInstance *>(a);
-		for(CCombinedArtifactInstance::ConstituentInfo & ci : comb->constituentsInfo)
-		{
-			map->addNewArtifactInstance(ci.art);
-		}
-	}
-
-	return a;
-}
-
 void CMapLoaderH3M::readTerrain()
 {
 	map->initTerrain();
@@ -1236,7 +1202,7 @@ void CMapLoaderH3M::readObjects()
 					artID = objTempl.subid;
 				}
 
-				art->storedArtifact = createArtifact(artID, spellID);
+				art->storedArtifact = CArtifactInstance::createArtifact(map, artID, spellID);
 				break;
 			}
 		case Obj::RANDOM_RESOURCE:
@@ -1998,7 +1964,7 @@ CGTownInstance * CMapLoaderH3M::readTown(int castleID)
 		ui8 c = reader.readUInt8();
 		for(int yy = 0; yy < 8; ++yy)
 		{
-			int spellid = i * 8 + yy; 
+			int spellid = i * 8 + yy;
 			if(spellid < GameConstants::SPELLS_QUANTITY)
 			{
 				if(c != (c | static_cast<ui8>(std::pow(2., yy))) && map->allowedSpell[spellid]) //add random spell only if it's allowed on entire map
diff --git a/lib/mapping/MapFormatH3M.h b/lib/mapping/MapFormatH3M.h
index 5d306bc06..de1c8724e 100644
--- a/lib/mapping/MapFormatH3M.h
+++ b/lib/mapping/MapFormatH3M.h
@@ -124,15 +124,6 @@ private:
 	 */
 	bool loadArtifactToSlot(CGHeroInstance * hero, int slot);
 
-	/**
-	 * Creates an artifact instance.
-	 *
-	 * @param aid the id of the artifact
-	 * @param spellID optional. the id of a spell if a spell scroll object should be created
-	 * @return the created artifact instance
-	 */
-	CArtifactInstance * createArtifact(int aid, int spellID = -1);
-
 	/**
 	 * Read rumors.
 	 */
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index e5661e50c..0d7c21d3a 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -657,11 +657,36 @@ void CMapLoaderJson::MapObjectLoader::configure()
 	{
 		owner->map->towns.push_back(static_cast<CGTownInstance *>(instance));
 	}
-	if(instance->ID == Obj::HERO)
+	else if(instance->ID == Obj::HERO)
 	{
 		logGlobal->debugStream() << "Hero: " << VLC->heroh->heroes[instance->subID]->name << " at " << instance->pos;
 		owner->map->heroesOnMap.push_back(static_cast<CGHeroInstance *>(instance));
 	}
+	else if(auto art = dynamic_cast<CGArtifact *>(instance))
+	{
+		//todo: find better place for this code
+
+		int artID = ArtifactID::NONE;
+		int spellID = -1;
+
+		if(art->ID == Obj::SPELL_SCROLL)
+		{
+			auto spellIdentifier = configuration["options"]["spell"].String();
+			auto rawId = VLC->modh->identifiers.getIdentifier("core", "spell", spellIdentifier);
+			if(rawId)
+				spellID = rawId.get();
+			else
+				spellID = 0;
+			artID = ArtifactID::SPELL_SCROLL;
+		}
+		else if(art->ID  == Obj::ARTIFACT)
+		{
+			//specific artifact
+			artID = art->subID;
+		}
+
+		art->storedArtifact = CArtifactInstance::createArtifact(owner->map, artID, spellID);
+	}
 }
 
 void CMapLoaderJson::readObjects()

From 709dd833d5344a6dec5a790d42e728c1fc648b35 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 14 Feb 2016 11:25:01 +0300
Subject: [PATCH 075/105] Added hacks for hero identification.

---
 lib/mapObjects/CGHeroInstance.cpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/lib/mapObjects/CGHeroInstance.cpp b/lib/mapObjects/CGHeroInstance.cpp
index bd055ff90..215d73460 100644
--- a/lib/mapObjects/CGHeroInstance.cpp
+++ b/lib/mapObjects/CGHeroInstance.cpp
@@ -1472,13 +1472,35 @@ bool CGHeroInstance::hasVisions(const CGObjectInstance * target, const int subty
 
 void CGHeroInstance::writeJsonOptions(JsonNode& json) const
 {
+	if(type)
+	{
+		json["type"].String() = type->identifier;
+	}
+	else
+	{
+		json["type"].String() = VLC->heroh->heroes[subID]->identifier;
+	}
+
 	CCreatureSet::writeJson(json["army"]);
 	CGObjectInstance::writeOwner(json);
 	CArtifactSet::writeJson(json["artifacts"]);
+
 }
 
 void CGHeroInstance::readJsonOptions(const JsonNode& json)
 {
+	if(ID == Obj::HERO || ID == Obj::PRISON)
+	{
+		auto typeName = json["type"].String();
+
+		auto rawId = VLC->modh->identifiers.getIdentifier("core", "hero", typeName);
+
+		if(rawId)
+			subID = rawId.get();
+		else
+			subID = 0; //fallback to Orrin, throw error instead?
+	}
+
 	CCreatureSet::readJson(json["army"]);
 	CGObjectInstance::readOwner(json);
 	CArtifactSet::readJson(json["artifacts"]);

From 800f32c4cbd8e0cbd9accfd64956942db02021d9 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 14 Feb 2016 12:13:30 +0300
Subject: [PATCH 076/105] Fix few cases of tempOwner initialization.

---
 lib/mapObjects/CGHeroInstance.cpp |  7 +++++--
 lib/mapObjects/CObjectHandler.cpp | 13 ++++++++-----
 lib/rmg/CRmgTemplateZone.cpp      |  3 +++
 test/MapComparer.cpp              |  6 +++---
 4 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/lib/mapObjects/CGHeroInstance.cpp b/lib/mapObjects/CGHeroInstance.cpp
index 215d73460..544dc2f97 100644
--- a/lib/mapObjects/CGHeroInstance.cpp
+++ b/lib/mapObjects/CGHeroInstance.cpp
@@ -1481,8 +1481,9 @@ void CGHeroInstance::writeJsonOptions(JsonNode& json) const
 		json["type"].String() = VLC->heroh->heroes[subID]->identifier;
 	}
 
-	CCreatureSet::writeJson(json["army"]);
 	CGObjectInstance::writeOwner(json);
+
+	CCreatureSet::writeJson(json["army"]);
 	CArtifactSet::writeJson(json["artifacts"]);
 
 }
@@ -1501,10 +1502,12 @@ void CGHeroInstance::readJsonOptions(const JsonNode& json)
 			subID = 0; //fallback to Orrin, throw error instead?
 	}
 
-	CCreatureSet::readJson(json["army"]);
 	CGObjectInstance::readOwner(json);
+
+	CCreatureSet::readJson(json["army"]);
 	CArtifactSet::readJson(json["artifacts"]);
 }
+
 bool CGHeroInstance::isMissionCritical() const
 {
 	for(const TriggeredEvent & event : IObjectInterface::cb->getMapHeader()->triggeredEvents)
diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index c0d46aec9..a0d9d9d87 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -373,19 +373,22 @@ void CGObjectInstance::readJsonOptions(const JsonNode & json)
 
 void CGObjectInstance::writeOwner(JsonNode & json) const
 {
-	if(tempOwner != PlayerColor::UNFLAGGABLE)
+	if(tempOwner.isValidPlayer())
 	{
-		PlayerColor p (tempOwner);
-		if(p.isValidPlayer())
-			json["owner"].String() = GameConstants::PLAYER_COLOR_NAMES[p.getNum()];
+		json["owner"].String() = GameConstants::PLAYER_COLOR_NAMES[tempOwner.getNum()];
 	}
 }
 
 void CGObjectInstance::readOwner(const JsonNode & json)
 {
+	tempOwner = PlayerColor::NEUTRAL;//this method assumes that object is ownable
 	if(json["owner"].getType() == JsonNode::DATA_STRING)
 	{
-		tempOwner = PlayerColor(vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, json["owner"].String()));
+		auto rawOwner = vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, json["owner"].String());
+		if(rawOwner >=0)
+			tempOwner = PlayerColor(rawOwner);
+		else
+			logGlobal->errorStream() << "Invalid owner :" << json["owner"].String();
 	}
 }
 
diff --git a/lib/rmg/CRmgTemplateZone.cpp b/lib/rmg/CRmgTemplateZone.cpp
index dc1760845..ab1eb6df7 100644
--- a/lib/rmg/CRmgTemplateZone.cpp
+++ b/lib/rmg/CRmgTemplateZone.cpp
@@ -1510,6 +1510,7 @@ bool CRmgTemplateZone::placeMines (CMapGenerator* gen)
 		{
 			auto mine = (CGMine *) factory.at(static_cast<si32>(res))->create(ObjectTemplate());
 			mine->producedResource = res;
+			mine->tempOwner = PlayerColor::NEUTRAL;
 			mine->producedQuantity = mine->defaultResProduction();
 			if (!i)
 				addCloseObject(mine, 1500); //only firts one is close
@@ -1523,6 +1524,7 @@ bool CRmgTemplateZone::placeMines (CMapGenerator* gen)
 		{
 			auto mine = (CGMine *) factory.at(static_cast<si32>(res))->create(ObjectTemplate());
 			mine->producedResource = res;
+			mine->tempOwner = PlayerColor::NEUTRAL;
 			mine->producedQuantity = mine->defaultResProduction();
 			addRequiredObject(mine, 3500);
 		}
@@ -1531,6 +1533,7 @@ bool CRmgTemplateZone::placeMines (CMapGenerator* gen)
 	{
 		auto mine = (CGMine *) factory.at(Res::GOLD)->create(ObjectTemplate());
 		mine->producedResource = Res::GOLD;
+		mine->tempOwner = PlayerColor::NEUTRAL;
 		mine->producedQuantity = mine->defaultResProduction();
 		addRequiredObject(mine, 7000);
 	}
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 1bdd638ca..8f7690aad 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -153,12 +153,12 @@ void MapComparer::compareObject(const CGObjectInstance * actual, const CGObjectI
 	BOOST_CHECK_EQUAL(actual->getStringId(), expected->getStringId());
 	BOOST_CHECK_EQUAL(typeid(actual).name(), typeid(expected).name());//todo: remove and use just comparison
 
-	std::string actualFullID = boost::to_string(boost::format("%s(%d)|%s(%d)") % actual->typeName % actual->id % actual->subTypeName % actual->subID);
-	std::string expectedFullID = boost::to_string(boost::format("%s(%d)|%s(%d)") % expected->typeName % expected->id % expected->subTypeName % expected->subID);
+	std::string actualFullID = boost::to_string(boost::format("%s(%d)|%s(%d) %d") % actual->typeName % actual->ID % actual->subTypeName % actual->subID % actual->tempOwner);
+	std::string expectedFullID = boost::to_string(boost::format("%s(%d)|%s(%d) %d") % expected->typeName % expected->ID % expected->subTypeName % expected->subID % expected->tempOwner);
 
 	BOOST_CHECK_EQUAL(actualFullID, expectedFullID);
 	BOOST_CHECK_EQUAL(actual->pos, expected->pos);
-	BOOST_CHECK_EQUAL(actual->tempOwner,expected->tempOwner);
+	//BOOST_CHECK_EQUAL(actual->tempOwner,expected->tempOwner);
 }
 
 void MapComparer::compareObjects()

From 67b03b9658c9e63b2433f4404b8f2cf2733ea6b4 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 14 Feb 2016 12:25:49 +0300
Subject: [PATCH 077/105] =?UTF-8?q?Fixed=20remaining=20tempOwner=20tests?=
 =?UTF-8?q?=D1=8E?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib/mapObjects/CGTownInstance.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/mapObjects/CGTownInstance.cpp b/lib/mapObjects/CGTownInstance.cpp
index aba80010d..dfa3ba2f1 100644
--- a/lib/mapObjects/CGTownInstance.cpp
+++ b/lib/mapObjects/CGTownInstance.cpp
@@ -317,13 +317,15 @@ void CGDwelling::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer)
 void CGDwelling::writeJsonOptions(JsonNode& json) const
 {
 	//todo:CGDwelling::writeJsonOptions
-	CGObjectInstance::writeOwner(json);
+	if(ID != Obj::WAR_MACHINE_FACTORY && ID != Obj::REFUGEE_CAMP)
+		CGObjectInstance::writeOwner(json);
 }
 
 void CGDwelling::readJsonOptions(const JsonNode& json)
 {
 	//todo:CGDwelling::readJsonOptions
-	CGObjectInstance::readOwner(json);
+	if(ID != Obj::WAR_MACHINE_FACTORY && ID != Obj::REFUGEE_CAMP)
+		CGObjectInstance::readOwner(json);
 }
 
 int CGTownInstance::getSightRadius() const //returns sight distance

From ec760632a62f14df32d9777618bc9197049d9183 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 14 Feb 2016 14:22:46 +0300
Subject: [PATCH 078/105] Advance Json serializer * added bool, numeric and
 string support * added some enum support * PoC implementation of logical id
 condition * Refactoring

---
 lib/CTownHandler.cpp                   |  32 +-
 lib/CTownHandler.h                     |  18 +-
 lib/mapping/MapFormatJson.cpp          | 437 ++++++++++++++-----------
 lib/mapping/MapFormatJson.h            |  61 ++--
 lib/serializer/JsonDeserializer.cpp    |  87 ++++-
 lib/serializer/JsonDeserializer.h      |  11 +-
 lib/serializer/JsonSerializeFormat.cpp |   3 +-
 lib/serializer/JsonSerializeFormat.h   |  58 +++-
 lib/serializer/JsonSerializer.cpp      |  44 ++-
 lib/serializer/JsonSerializer.h        |   9 +-
 test/CMapFormatTest.cpp                |   5 +-
 11 files changed, 517 insertions(+), 248 deletions(-)

diff --git a/lib/CTownHandler.cpp b/lib/CTownHandler.cpp
index fed90b912..69b9e9b26 100644
--- a/lib/CTownHandler.cpp
+++ b/lib/CTownHandler.cpp
@@ -526,7 +526,7 @@ void CTownHandler::loadClientData(CTown &town, const JsonNode & source)
 	    info.tavernVideo = source["tavernVideo"].String();
 	else
 		info.tavernVideo = "TAVERN.BIK";
-	//end of legacy assignment 
+	//end of legacy assignment
 
 	loadTownHall(town,   source["hallSlots"]);
 	loadStructures(town, source["structures"]);
@@ -795,3 +795,33 @@ std::set<TFaction> CTownHandler::getAllowedFactions(bool withTown /*=true*/) con
 
 	return allowedFactions;
 }
+
+si32 CTownHandler::decodeFaction(const std::string & identifier)
+{
+	auto rawId = VLC->modh->identifiers.getIdentifier("core", "faction", identifier);
+	if(rawId)
+		return rawId.get();
+	else
+		return -1;
+}
+
+std::string CTownHandler::encodeFaction(const si32 index)
+{
+	return VLC->townh->factions[index]->identifier;
+}
+
+si32 CTownHandler::decodeBuilding(const std::string & identifier)
+{
+	//FIXME: CTownHandler::decodeBuilding
+	auto rawId = VLC->modh->identifiers.getIdentifier("core", "building", identifier); //???
+	if(rawId)
+		return rawId.get();
+	else
+		return -1;
+}
+
+std::string CTownHandler::encodeBuilding(const si32 index)
+{
+	 //FIXME: CTownHandler::encodeBuilding
+	 return "";
+}
diff --git a/lib/CTownHandler.h b/lib/CTownHandler.h
index 79cef9e10..c04ad2bf9 100644
--- a/lib/CTownHandler.h
+++ b/lib/CTownHandler.h
@@ -122,8 +122,8 @@ public:
 
 	std::string creatureBg120;
 	std::string creatureBg130;
-	
-	
+
+
 
 	std::vector<SPuzzleInfo> puzzleMap;
 
@@ -142,7 +142,7 @@ public:
 	static std::vector<BattleHex> defaultMoatHexes();
 
 	CFaction * faction;
-	
+
 	std::vector<std::string> names; //names of the town instances
 
 	/// level -> list of creatures on this tier
@@ -282,6 +282,18 @@ public:
 	std::vector<bool> getDefaultAllowed() const override;
 	std::set<TFaction> getAllowedFactions(bool withTown = true) const;
 
+	//json serialization helper
+	static si32 decodeFaction(const std::string & identifier);
+
+	//json serialization helper
+	static std::string encodeFaction(const si32 index);
+
+	//json serialization helper
+	static si32 decodeBuilding(const std::string & identifier);
+
+	//json serialization helper
+	static std::string encodeBuilding(const si32 index);
+
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
 		h & factions;
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 0d7c21d3a..cd78cc6a0 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -29,23 +29,15 @@
 
 namespace HeaderDetail
 {
-	static const std::map<std::string, ui8> difficultyReverseMap =
-	{
-		{"", 1},
-		{"EASY", 0},
-		{"NORMAL", 1},
-		{"HARD", 2},
-		{"EXPERT", 3},
-		{"IMPOSSIBLE", 4}
-	};
+	static const ui8 difficultyDefault = 1;//normal
 
-	static const std::map<ui8, std::string> difficultyForwardMap =
+	static const std::vector<std::string> difficultyMap =
 	{
-		{0, "EASY"},
-		{1, "NORMAL"},
-		{2, "HARD"},
-		{3, "EXPERT"},
-		{4, "IMPOSSIBLE"}
+		"EASY",
+		"NORMAL",
+		"HARD",
+		"EXPERT",
+		"IMPOSSIBLE"
 	};
 }
 
@@ -179,14 +171,218 @@ const int CMapFormatJson::VERSION_MINOR = 0;
 const std::string CMapFormatJson::HEADER_FILE_NAME = "header.json";
 const std::string CMapFormatJson::OBJECTS_FILE_NAME = "objects.json";
 
+void CMapFormatJson::serializeAllowedFactions(JsonSerializeFormat & handler, std::set<TFaction> & value)
+{
+	//TODO: unify allowed factions with others - make them std::vector<bool>
+
+	std::vector<bool> temp;
+	temp.resize(VLC->townh->factions.size(), false);
+	auto standard = VLC->townh->getDefaultAllowed();
+
+    if(handler.saving)
+	{
+		for(auto faction : VLC->townh->factions)
+			if(faction->town && vstd::contains(value, faction->index))
+				temp[std::size_t(faction->index)] = true;
+	}
+
+	handler.serializeLIC("allowedFactions", &CTownHandler::decodeFaction, &CTownHandler::encodeFaction, standard, temp);
+
+	if(!handler.saving)
+	{
+		value.clear();
+		for (std::size_t i=0; i<temp.size(); i++)
+			if(temp[i])
+				value.insert(i);
+	}
+}
+
+void CMapFormatJson::serializeHeader(JsonSerializeFormat & handler)
+{
+	handler.serializeString("name", mapHeader->name);
+	handler.serializeString("description", mapHeader->description);
+	handler.serializeNumeric("heroLevelLimit", mapHeader->levelLimit);
+
+	//todo: support arbitrary percentage
+	handler.serializeNumericEnum("difficulty", HeaderDetail::difficultyMap, HeaderDetail::difficultyDefault, mapHeader->difficulty);
+
+	serializePlayerInfo(handler);
+}
+
+void CMapFormatJson::serializePlayerInfo(JsonSerializeFormat & handler)
+{
+	auto playersData = handler.enterStruct("players");
+
+	for(int player = 0; player < PlayerColor::PLAYER_LIMIT_I; player++)
+	{
+		PlayerInfo & info = mapHeader->players[player];
+
+		auto playerData = playersData.enterStruct(GameConstants::PLAYER_COLOR_NAMES[player]);
+
+		if(handler.saving)
+		{
+			if(!info.canAnyonePlay())
+				continue;
+		}
+		else
+		{
+			if(playerData.get().isNull())
+			{
+				info.canComputerPlay = false;
+				info.canHumanPlay = false;
+				continue;
+			}
+			info.canComputerPlay = true;
+		}
+
+		serializeAllowedFactions(handler, info.allowedFactions);
+
+		handler.serializeBoolEnum("canPlay", "PlayerOrAI", "AIOnly", info.canHumanPlay);
+
+		//mainTown
+		if(handler.saving)
+		{
+
+		}
+		else
+		{
+
+		}
+
+		handler.serializeBool("generateHeroAtMainTown", info.generateHeroAtMainTown);
+
+
+		//mainHero
+
+		//mainHeroPortrait
+
+		//mainCustomHeroName
+
+		//towns
+
+		//heroes
+		{
+			auto heroes = playersData.enterStruct("heroes");
+
+		}
+
+		if(!handler.saving)
+		{
+			//isFactionRandom indicates that player may select faction, depends on towns & heroes
+			// true if main town is random and generateHeroAtMainTown==true
+			// or main hero is random
+			//TODO: recheck mechanics
+			//	info.isFactionRandom =
+		}
+
+
+	}
+}
+
+void CMapFormatJson::readTeams(JsonDeserializer & handler)
+{
+	auto teams = handler.enterStruct("teams");
+	const JsonNode & src = teams.get();
+
+    if(src.getType() != JsonNode::DATA_VECTOR)
+	{
+		// No alliances
+		if(src.getType() != JsonNode::DATA_NULL)
+			logGlobal->errorStream() << "Invalid teams field type";
+
+		mapHeader->howManyTeams = 0;
+		for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
+		{
+			if(mapHeader->players[i].canComputerPlay || mapHeader->players[i].canHumanPlay)
+			{
+				mapHeader->players[i].team = TeamID(mapHeader->howManyTeams++);
+			}
+		}
+	}
+	else
+	{
+		const JsonVector & srcVector = src.Vector();
+		mapHeader->howManyTeams = srcVector.size();
+
+		for(int team = 0; team < mapHeader->howManyTeams; team++)
+		{
+			for(const JsonNode & playerData : srcVector[team].Vector())
+			{
+				PlayerColor player = PlayerColor(vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, playerData.String()));
+				if(player.isValidPlayer())
+				{
+					if(mapHeader->players[player.getNum()].canAnyonePlay())
+					{
+						mapHeader->players[player.getNum()].team = TeamID(team);
+					}
+				}
+			}
+		}
+
+		for(PlayerInfo & player : mapHeader->players)
+		{
+			if(player.canAnyonePlay() && player.team == TeamID::NO_TEAM)
+				player.team = TeamID(mapHeader->howManyTeams++);
+		}
+
+	}
+}
+
+
+void CMapFormatJson::writeTeams(JsonSerializer & handler)
+{
+	auto teams = handler.enterStruct("teams");
+	JsonNode & dest = teams.get();
+	std::vector<std::set<PlayerColor>> teamsData;
+
+	teamsData.resize(mapHeader->howManyTeams);
+
+	//get raw data
+	for(int idx = 0; idx < mapHeader->players.size(); idx++)
+	{
+		const PlayerInfo & player = mapHeader->players.at(idx);
+		int team = player.team.getNum();
+		if(vstd::iswithin(team, 0, mapHeader->howManyTeams-1) && player.canAnyonePlay())
+			teamsData.at(team).insert(PlayerColor(idx));
+	}
+
+	//remove single-member teams
+	vstd::erase_if(teamsData, [](std::set<PlayerColor> & elem) -> bool
+	{
+		return elem.size() <= 1;
+	});
+
+	//construct output
+	dest.setType(JsonNode::DATA_VECTOR);
+
+	for(const std::set<PlayerColor> & teamData : teamsData)
+	{
+		JsonNode team(JsonNode::DATA_VECTOR);
+		for(const PlayerColor & player : teamData)
+		{
+			JsonNode member(JsonNode::DATA_STRING);
+			member.String() = GameConstants::PLAYER_COLOR_NAMES[player.getNum()];
+			team.Vector().push_back(std::move(member));
+		}
+		dest.Vector().push_back(std::move(team));
+	}
+}
+
+void CMapFormatJson::serializeTriggeredEvents(JsonSerializeFormat & handler)
+{
+	handler.serializeString("victoryString", mapHeader->victoryMessage);
+	handler.serializeNumeric("victoryIconIndex", mapHeader->victoryIconIndex);
+
+	handler.serializeString("defeatString", mapHeader->defeatMessage);
+	handler.serializeNumeric("defeatIconIndex", mapHeader->defeatIconIndex);
+}
+
+
 void CMapFormatJson::readTriggeredEvents(JsonDeserializer & handler)
 {
 	const JsonNode & input = handler.getCurrent();
-	mapHeader->victoryMessage = input["victoryString"].String();
-	mapHeader->victoryIconIndex = input["victoryIconIndex"].Float();
 
-	mapHeader->defeatMessage = input["defeatString"].String();
-	mapHeader->defeatIconIndex = input["defeatIconIndex"].Float();
+	serializeTriggeredEvents(handler);
 
 	mapHeader->triggeredEvents.clear();
 
@@ -210,13 +406,11 @@ void CMapFormatJson::readTriggeredEvent(TriggeredEvent & event, const JsonNode &
 	event.trigger = EventExpression(source["condition"], JsonToCondition); // logical expression
 }
 
-void CMapFormatJson::writeTriggeredEvents(JsonNode& output)
+void CMapFormatJson::writeTriggeredEvents(JsonSerializer & handler)
 {
-	output["victoryString"].String() = mapHeader->victoryMessage;
-	output["victoryIconIndex"].Float() = mapHeader->victoryIconIndex;
+	JsonNode & output = handler.getCurrent();
 
-	output["defeatString"].String() = mapHeader->defeatMessage;
-	output["defeatIconIndex"].Float() = mapHeader->defeatIconIndex;
+	serializeTriggeredEvents(handler);
 
 	JsonMap & triggeredEvents = output["triggeredEvents"].Struct();
 
@@ -237,7 +431,6 @@ void CMapFormatJson::writeTriggeredEvent(const TriggeredEvent& event, JsonNode&
 	dest["condition"] = event.trigger.toJson(ConditionToJson);
 }
 
-
 ///CMapPatcher
 CMapPatcher::CMapPatcher(JsonNode stream):
 	input(stream)
@@ -335,6 +528,22 @@ void CMapLoaderJson::readHeader()
 {
 	//do not use map field here, use only mapHeader
 	JsonNode header = getFromArchive(HEADER_FILE_NAME);
+
+	int versionMajor = header["versionMajor"].Float();
+
+	if(versionMajor != VERSION_MAJOR)
+	{
+		logGlobal->errorStream() << "Unsupported map format version: " << versionMajor;
+		throw std::runtime_error("Unsupported map format version");
+	}
+
+	int versionMinor = header["versionMinor"].Float();
+
+	if(versionMinor > VERSION_MINOR)
+	{
+		logGlobal->traceStream() << "Too new map format revision: " << versionMinor << ". This map should work but some of map features may be ignored.";
+	}
+
 	JsonDeserializer handler(header);
 
 	mapHeader->version = EMapFormat::VCMI;//todo: new version field
@@ -354,13 +563,7 @@ void CMapLoaderJson::readHeader()
 		}
 	}
 
-	mapHeader->name = header["name"].String();
-	mapHeader->description = header["description"].String();
-
-	//todo: support arbitrary percentage
-
-	mapHeader->difficulty = HeaderDetail::difficultyReverseMap.at(header["difficulty"].String());
-	mapHeader->levelLimit = header["heroLevelLimit"].Float();
+	serializeHeader(handler);
 
 
 //	std::vector<bool> allowedHeroes;
@@ -368,99 +571,11 @@ void CMapLoaderJson::readHeader()
 
 	readTriggeredEvents(handler);
 
-	readPlayerInfo(handler);
 
 	readTeams(handler);
 	//TODO: readHeader
 }
 
-void CMapLoaderJson::readPlayerInfo(JsonDeserializer & handler)
-{
-	auto playersData = handler.enterStruct("players");
-
-	for(int player = 0; player < PlayerColor::PLAYER_LIMIT_I; player++)
-	{
-		PlayerInfo & info = mapHeader->players.at(player);
-
-		auto playerData = playersData.enterStruct(GameConstants::PLAYER_COLOR_NAMES[player]);
-
-		if(playerData.get().isNull())
-		{
-			info.canComputerPlay = false;
-			info.canHumanPlay = false;
-		}
-		else
-		{
-			//allowed factions
-
-		//	info.isFactionRandom =
-
-			info.canComputerPlay = true;
-			info.canHumanPlay = playerData.get()["canPlay"].String() != "AIOnly";
-
-			//placedHeroes
-
-			//mainTown
-
-			info.generateHeroAtMainTown = playerData.get()["generateHeroAtMainTown"].Bool();
-
-			//mainHero
-
-			//mainHeroPortrait
-
-			//mainCustomHeroName
-		}
-	}
-}
-
-void CMapLoaderJson::readTeams(JsonDeserializer & handler)
-{
-	auto teamsData = handler.enterStruct("teams");
-	const JsonNode & src = teamsData.get();
-
-    if(src.getType() != JsonNode::DATA_VECTOR)
-	{
-		// No alliances
-		if(src.getType() != JsonNode::DATA_NULL)
-			logGlobal->errorStream() << "Invalid teams field type";
-
-		mapHeader->howManyTeams = 0;
-		for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
-		{
-			if(mapHeader->players[i].canComputerPlay || mapHeader->players[i].canHumanPlay)
-			{
-				mapHeader->players[i].team = TeamID(mapHeader->howManyTeams++);
-			}
-		}
-	}
-	else
-	{
-		const JsonVector & srcVector = src.Vector();
-		mapHeader->howManyTeams = srcVector.size();
-
-		for(int team = 0; team < mapHeader->howManyTeams; team++)
-		{
-			for(const JsonNode & playerData : srcVector[team].Vector())
-			{
-				PlayerColor player = PlayerColor(vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, playerData.String()));
-				if(player.isValidPlayer())
-				{
-					if(mapHeader->players[player.getNum()].canAnyonePlay())
-					{
-						mapHeader->players[player.getNum()].team = TeamID(team);
-					}
-				}
-			}
-		}
-
-		for(PlayerInfo & player : mapHeader->players)
-		{
-			if(player.canAnyonePlay() && player.team == TeamID::NO_TEAM)
-				player.team = TeamID(mapHeader->howManyTeams++);
-		}
-
-	}
-}
 
 void CMapLoaderJson::readTerrainTile(const std::string& src, TerrainTile& tile)
 {
@@ -775,20 +890,11 @@ void CMapSaverJson::writeHeader()
 		levels["underground"]["index"].Float() = 1;
 	}
 
-	header["name"].String() = mapHeader->name;
-	header["description"].String() = mapHeader->description;
+	serializeHeader(handler);
 
+	writeTriggeredEvents(handler);
 
-	//todo: support arbitrary percentage
-
-	header["difficulty"].String() = HeaderDetail::difficultyForwardMap.at(mapHeader->difficulty);
-	header["heroLevelLimit"].Float() = mapHeader->levelLimit;
-
-	writeTriggeredEvents(header);
-
-	writePlayerInfo(header);
-
-	writeTeams(header);
+	writeTeams(handler);
 
 	//todo:	allowedHeroes;
 	//todo: placeholdedHeroes;
@@ -796,73 +902,6 @@ void CMapSaverJson::writeHeader()
 	addToArchive(header, HEADER_FILE_NAME);
 }
 
-void CMapSaverJson::writePlayerInfo(JsonNode & output)
-{
-	JsonNode & dest = output["players"];
-	dest.setType(JsonNode::DATA_STRUCT);
-
-	for(int player = 0; player < PlayerColor::PLAYER_LIMIT_I; player++)
-	{
-		const PlayerInfo & info = mapHeader->players[player];
-
-		if(info.canAnyonePlay())
-			writePlayerInfo(info, dest[GameConstants::PLAYER_COLOR_NAMES[player]]);
-	}
-}
-
-void CMapSaverJson::writePlayerInfo(const PlayerInfo & info, JsonNode & output)
-{
-	//allowed factions
-
-	output["canPlay"].String() = info.canHumanPlay ? "PlayerOrAI" : "AIOnly";
-
-	//mainTown
-	output["generateHeroAtMainTown"].Bool() = info.generateHeroAtMainTown;
-
-	//mainHero
-
-	//towns
-	//heroes
-}
-
-void CMapSaverJson::writeTeams(JsonNode& output)
-{
-	JsonNode & dest = output["teams"];
-	std::vector<std::set<PlayerColor>> teamsData;
-
-	teamsData.resize(mapHeader->howManyTeams);
-
-	//get raw data
-	for(int idx = 0; idx < mapHeader->players.size(); idx++)
-	{
-		const PlayerInfo & player = mapHeader->players.at(idx);
-		int team = player.team.getNum();
-		if(vstd::iswithin(team, 0, mapHeader->howManyTeams-1) && player.canAnyonePlay())
-			teamsData.at(team).insert(PlayerColor(idx));
-	}
-
-	//remove single-member teams
-	vstd::erase_if(teamsData, [](std::set<PlayerColor> & elem) -> bool
-	{
-		return elem.size() <= 1;
-	});
-
-	//construct output
-	dest.setType(JsonNode::DATA_VECTOR);
-
-	for(const std::set<PlayerColor> & teamData : teamsData)
-	{
-		JsonNode team(JsonNode::DATA_VECTOR);
-		for(const PlayerColor & player : teamData)
-		{
-			JsonNode member(JsonNode::DATA_STRING);
-			member.String() = GameConstants::PLAYER_COLOR_NAMES[player.getNum()];
-			team.Vector().push_back(std::move(member));
-		}
-		dest.Vector().push_back(std::move(team));
-	}
-}
-
 const std::string CMapSaverJson::writeTerrainTile(const TerrainTile & tile)
 {
 	using namespace TerrainDetail;
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 50488c70b..d7fa2fc8c 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -22,6 +22,8 @@ struct TerrainTile;
 struct PlayerInfo;
 class CGObjectInstance;
 class AObjectTypeHandler;
+
+class JsonSerializeFormat;
 class JsonDeserializer;
 class JsonSerializer;
 
@@ -44,6 +46,30 @@ protected:
 	 */
 	CMapHeader * mapHeader;
 
+	void serializeAllowedFactions(JsonSerializeFormat & handler, std::set<TFaction> & value);
+
+	///common part of header saving/loading
+	void serializeHeader(JsonSerializeFormat & handler);
+
+	///player information saving/loading
+	void serializePlayerInfo(JsonSerializeFormat & handler);
+
+	/**
+	 * Reads team settings to header
+	 * @param input serialized header
+	 */
+	void readTeams(JsonDeserializer & handler);
+
+	/**
+	 * Saves team settings to header
+	 * @param output serialized header
+	 */
+	void writeTeams(JsonSerializer & handler);
+
+
+	///common part triggered events of saving/loading
+	void serializeTriggeredEvents(JsonSerializeFormat & handler);
+
 	/**
 	 * Reads triggered events, including victory/loss conditions
 	 */
@@ -52,7 +78,7 @@ protected:
 	/**
 	 * Writes triggered events, including victory/loss conditions
 	 */
-	void writeTriggeredEvents(JsonNode & output);
+	void writeTriggeredEvents(JsonSerializer & handler);
 
 	/**
 	 * Reads one of triggered events
@@ -137,26 +163,15 @@ private:
 
 	si32 getIdentifier(const std::string & type, const std::string & name);
 
-	/**
-	 * Reads complete map.
-	 */
-	void readMap();
-
 	/**
 	 * Reads the map header.
 	 */
 	void readHeader();
 
 	/**
-	 * Reads player information.
+	 * Reads complete map.
 	 */
-	void readPlayerInfo(JsonDeserializer & handler);
-
-	/**
-	 * Reads team settings to header
-	 * @param input serialized header
-	 */
-	void readTeams(JsonDeserializer & handler);
+	void readMap();
 
 	void readTerrainTile(const std::string & src, TerrainTile & tile);
 
@@ -205,24 +220,6 @@ private:
 	 */
 	void writeHeader();
 
-	/**
-	 * Saves all players info to header
-	 * @param output serialized header
-	 */
-	void writePlayerInfo(JsonNode & output);
-
-	/**
-	 * Saves one player info
-	 * @param output empty object
-	 */
-	void writePlayerInfo(const PlayerInfo & info, JsonNode & output);
-
-	/**
-	 * Saves team settings to header
-	 * @param output serialized header
-	 */
-	void writeTeams(JsonNode & output);
-
 	/**
 	 * Encodes one tile into string
 	 * @param tile tile to serialize
diff --git a/lib/serializer/JsonDeserializer.cpp b/lib/serializer/JsonDeserializer.cpp
index 5f1737434..ba07f50c1 100644
--- a/lib/serializer/JsonDeserializer.cpp
+++ b/lib/serializer/JsonDeserializer.cpp
@@ -15,9 +15,94 @@
 #include "../JsonNode.h"
 
 JsonDeserializer::JsonDeserializer(JsonNode & root_):
-	JsonSerializeFormat(root_)
+	JsonSerializeFormat(root_, false)
 {
 
 }
 
+void JsonDeserializer::serializeBool(const std::string & fieldName, bool & value)
+{
+	value = current->operator[](fieldName).Bool();
+}
+
+void JsonDeserializer::serializeBoolEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value)
+{
+	const JsonNode & tmp = current->operator[](fieldName);
+
+	value = tmp.String() == trueValue;
+}
+
+void JsonDeserializer::serializeFloat(const std::string & fieldName, double & value)
+{
+	value = current->operator[](fieldName).Float();
+}
+
+void JsonDeserializer::serializeIntEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const si32 defaultValue, si32 & value)
+{
+	const std::string & valueName = current->operator[](fieldName).String();
+
+	si32 rawValue = vstd::find_pos(enumMap, valueName);
+	if(rawValue < 0)
+		value = defaultValue;
+	else
+		value = rawValue;
+}
+
+void JsonDeserializer::serializeLIC(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const std::vector<bool> & standard, std::vector<bool> & value)
+{
+	const JsonNode & field = current->operator[](fieldName);
+	if(field.isNull())
+		return;
+
+	const JsonVector & anyOf = field["anyOf"].Vector();
+	const JsonVector & allOf = field["allOf"].Vector();
+	const JsonVector & noneOf = field["noneOf"].Vector();
+
+
+	if(anyOf.empty() && allOf.empty())
+	{
+		//permissive mode
+		value = standard;
+	}
+	else
+	{
+		//restrictive mode
+		value.clear();
+		value.resize(standard.size(), false);
+
+		for(size_t index = 0; index < anyOf.size(); index++)
+		{
+			const std::string & identifier = anyOf[index].String();
+
+			si32 rawId = decoder(identifier);
+			if(rawId >= 0)
+				value[rawId] = true;
+		}
+
+
+		for(size_t index = 0; index < allOf.size(); index++)
+		{
+			const std::string & identifier = allOf[index].String();
+
+			si32 rawId = decoder(identifier);
+			if(rawId >=0)
+				value[rawId] = true;
+		}
+	}
+
+	for(size_t index = 0; index < noneOf.size(); index++)
+	{
+		const std::string & identifier = noneOf[index].String();
+
+		si32 rawId = decoder(identifier);
+		if(rawId >=0 )
+			value[rawId] = false;
+	}
+
+}
+
+void JsonDeserializer::serializeString(const std::string & fieldName, std::string & value)
+{
+	value = current->operator[](fieldName).String();
+}
 
diff --git a/lib/serializer/JsonDeserializer.h b/lib/serializer/JsonDeserializer.h
index 91bbae0bc..b05c9582a 100644
--- a/lib/serializer/JsonDeserializer.h
+++ b/lib/serializer/JsonDeserializer.h
@@ -17,7 +17,14 @@ class JsonNode;
 class JsonDeserializer: public JsonSerializeFormat
 {
 public:
-	static const bool saving = false;
-
 	JsonDeserializer(JsonNode & root_);
+
+	void serializeBool(const std::string & fieldName, bool & value) override;
+	void serializeBoolEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value) override;
+	void serializeLIC(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const std::vector<bool> & standard, std::vector<bool> & value) override;
+	void serializeString(const std::string & fieldName, std::string & value) override;
+
+protected:
+	void serializeFloat(const std::string & fieldName, double & value) override;
+	void serializeIntEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const si32 defaultValue, si32 & value) override;
 };
diff --git a/lib/serializer/JsonSerializeFormat.cpp b/lib/serializer/JsonSerializeFormat.cpp
index 68d7c0e71..11b4f947d 100644
--- a/lib/serializer/JsonSerializeFormat.cpp
+++ b/lib/serializer/JsonSerializeFormat.cpp
@@ -66,7 +66,8 @@ JsonSerializeFormat * JsonStructSerializer::operator->()
 
 
 //JsonSerializeFormat
-JsonSerializeFormat::JsonSerializeFormat(JsonNode & root_):
+JsonSerializeFormat::JsonSerializeFormat(JsonNode & root_, const bool saving_):
+	saving(saving_),
 	root(&root_),
 	current(root)
 {
diff --git a/lib/serializer/JsonSerializeFormat.h b/lib/serializer/JsonSerializeFormat.h
index 59b278fce..6b84308de 100644
--- a/lib/serializer/JsonSerializeFormat.h
+++ b/lib/serializer/JsonSerializeFormat.h
@@ -36,27 +36,77 @@ private:
 	friend class JsonSerializeFormat;
 };
 
-class JsonSerializeFormat
+class JsonSerializeFormat: public boost::noncopyable
 {
 public:
-	JsonSerializeFormat(JsonNode & root_);
+	///user-provided callback to resolve string identifier
+	///returns resolved identifier or -1 on error
+	typedef std::function<si32(const std::string &)> TDecoder;
+
+	///user-provided callback to get string identifier
+	///may assume that object index is valid
+	typedef std::function<std::string(si32)> TEncoder;
+
+	const bool saving;
+
+	JsonSerializeFormat() = delete;
 	virtual ~JsonSerializeFormat() = default;
 
 	JsonNode & getRoot()
 	{
-		return *root;
+		return * root;
 	};
 
 	JsonNode & getCurrent()
 	{
-		return *current;
+		return * current;
 	};
 
 	JsonStructSerializer enterStruct(const std::string & fieldName);
 
+	virtual void serializeBool(const std::string & fieldName, bool & value) = 0;
+	virtual void serializeBoolEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value) = 0;
+
+	/** @brief Restrictive serialization of Logical identifier condition (only "anyOf" used), full deserialization
+	 *
+	 * @param fieldName
+	 * @param decoder resolve callback, should report errors itself and do not throw
+	 * @param encoder encode callback, should report errors itself and do not throw
+	 * @param value target value, must be resized properly
+	 *
+	 */
+	virtual void serializeLIC(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const std::vector<bool> & standard, std::vector<bool> & value) = 0;
+
+
+	template <typename T>
+	void serializeNumericEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const T defaultValue, T & value)
+	{
+		si32 temp = value;
+		serializeIntEnum(fieldName, enumMap, defaultValue, temp);
+		if(!saving)
+			value = temp;
+	};
+
+	template <typename T>
+	void serializeNumeric(const std::string & fieldName, T & value)
+	{
+		double temp = value;
+		serializeFloat(fieldName, temp);
+		if(!saving)
+			value = temp;
+	};
+
+	virtual void serializeString(const std::string & fieldName, std::string & value) = 0;
+
 protected:
 	JsonNode * root;
 	JsonNode * current;
+
+	JsonSerializeFormat(JsonNode & root_, const bool saving_);
+
+	virtual void serializeFloat(const std::string & fieldName, double & value) = 0;
+
+	virtual void serializeIntEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const si32 defaultValue, si32 & value) = 0;
 private:
 	friend class JsonStructSerializer;
 };
diff --git a/lib/serializer/JsonSerializer.cpp b/lib/serializer/JsonSerializer.cpp
index 21755321c..8fff1f7af 100644
--- a/lib/serializer/JsonSerializer.cpp
+++ b/lib/serializer/JsonSerializer.cpp
@@ -15,9 +15,51 @@
 #include "../JsonNode.h"
 
 JsonSerializer::JsonSerializer(JsonNode & root_):
-	JsonSerializeFormat(root_)
+	JsonSerializeFormat(root_, true)
 {
 
 }
 
+void JsonSerializer::serializeBool(const std::string & fieldName, bool & value)
+{
+	current->operator[](fieldName).Bool() = value;
+}
+
+void JsonSerializer::serializeBoolEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value)
+{
+	current->operator[](fieldName).String() = value ? trueValue : falseValue;
+}
+
+void JsonSerializer::serializeFloat(const std::string & fieldName, double & value)
+{
+	current->operator[](fieldName).Float() = value;
+}
+
+void JsonSerializer::serializeIntEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const si32 defaultValue, si32 & value)
+{
+	current->operator[](fieldName).String() = enumMap.at(value);
+}
+
+void JsonSerializer::serializeLIC(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const std::vector<bool> & standard, std::vector<bool> & value)
+{
+	assert(standard.size() == value.size());
+	if(standard == value)
+		return;
+	auto & target = current->operator[](fieldName)["anyOf"].Vector();
+	for(si32 idx = 0; idx < value.size(); idx ++)
+	{
+		if(value[idx])
+		{
+			JsonNode val(JsonNode::DATA_STRING);
+			val.String() = encoder(idx);
+			target.push_back(std::move(val));
+		}
+	}
+}
+
+
+void JsonSerializer::serializeString(const std::string & fieldName, std::string & value)
+{
+	current->operator[](fieldName).String() = value;
+}
 
diff --git a/lib/serializer/JsonSerializer.h b/lib/serializer/JsonSerializer.h
index 0f4a9e925..6eca2cce0 100644
--- a/lib/serializer/JsonSerializer.h
+++ b/lib/serializer/JsonSerializer.h
@@ -17,9 +17,14 @@ class JsonNode;
 class JsonSerializer: public JsonSerializeFormat
 {
 public:
-	static const bool saving = true;
-
 	JsonSerializer(JsonNode & root_);
 
+	void serializeBool(const std::string & fieldName, bool & value) override;
+	void serializeBoolEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value) override;
+	void serializeLIC(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const std::vector<bool> & standard, std::vector<bool> & value) override;
+	void serializeString(const std::string & fieldName, std::string & value) override;
 
+protected:
+	void serializeFloat(const std::string & fieldName, double & value) override;
+	void serializeIntEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const si32 defaultValue, si32 & value) override;
 };
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index f022e1862..f0b1b1070 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -61,12 +61,13 @@ BOOST_GLOBAL_FIXTURE(CMapTestFixture);
 BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 {
 	logGlobal->info("CMapFormatVCMI_Simple start");
+	BOOST_TEST_CHECKPOINT("CMapFormatVCMI_Simple start");
 	CMemoryBuffer serializeBuffer;
 	{
 		CMapSaverJson saver(&serializeBuffer);
 		saver.saveMap(initialMap);
 	}
-
+	BOOST_TEST_CHECKPOINT("CMapFormatVCMI_Simple serialized");
 	#if 1
 	{
 		auto path = VCMIDirs::get().userDataPath()/"test.vmap";
@@ -79,7 +80,7 @@ BOOST_AUTO_TEST_CASE(CMapFormatVCMI_Simple)
 
 		logGlobal->infoStream() << "Test map has been saved to " << path;
 	}
-
+	BOOST_TEST_CHECKPOINT("CMapFormatVCMI_Simple saved");
 
 	#endif // 1
 

From 5a8ee32f89a687172925312607ff2ffc7f442829 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 15 Feb 2016 18:16:45 +0300
Subject: [PATCH 079/105] Tweaks

---
 lib/mapping/MapFormatJson.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index cd78cc6a0..149662b8b 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -217,14 +217,15 @@ void CMapFormatJson::serializePlayerInfo(JsonSerializeFormat & handler)
 	{
 		PlayerInfo & info = mapHeader->players[player];
 
-		auto playerData = playersData.enterStruct(GameConstants::PLAYER_COLOR_NAMES[player]);
-
 		if(handler.saving)
 		{
 			if(!info.canAnyonePlay())
 				continue;
 		}
-		else
+
+		auto playerData = playersData.enterStruct(GameConstants::PLAYER_COLOR_NAMES[player]);
+
+		if(!handler.saving)
 		{
 			if(playerData.get().isNull())
 			{
@@ -262,7 +263,7 @@ void CMapFormatJson::serializePlayerInfo(JsonSerializeFormat & handler)
 
 		//heroes
 		{
-			auto heroes = playersData.enterStruct("heroes");
+			//auto heroes = playerData.enterStruct("heroes");
 
 		}
 

From 36121696ca56a9e7a7e53ba6db427ac80de3a8eb Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Thu, 18 Feb 2016 17:48:04 +0300
Subject: [PATCH 080/105] Clenaup

---
 lib/mapping/CMap.h | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/lib/mapping/CMap.h b/lib/mapping/CMap.h
index 9014b46c9..b733b4302 100644
--- a/lib/mapping/CMap.h
+++ b/lib/mapping/CMap.h
@@ -124,7 +124,11 @@ struct DLL_LINKAGE EventCondition
 	template <typename Handler>
 	void serialize(Handler & h, const int version)
 	{
-		h & object & value & objectType & position & condition;
+		h & object;
+		h & value;
+		h & objectType;
+		h & position;
+		h & condition;
 	}
 };
 
@@ -171,7 +175,10 @@ struct DLL_LINKAGE TriggeredEvent
 	template <typename Handler>
 	void serialize(Handler & h, const int version)
 	{
-		h & identifier & trigger & description & onFulfill & effect;
+		h & identifier;
+		h & trigger;
+		h & description;
+		h & onFulfill & effect;
 	}
 };
 
@@ -207,7 +214,7 @@ struct DLL_LINKAGE DisposedHero
 
 namespace EMapFormat
 {
-enum EMapFormat
+enum EMapFormat: ui8
 {
 	INVALID = 0,
 	//    HEX     DEC

From b6103167f77f634015f6389de7d4cd93e8288f81 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Thu, 18 Feb 2016 18:08:05 +0300
Subject: [PATCH 081/105] Fix serializer backward compatibility in
 CPointerLoader

---
 lib/Connection.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Connection.h b/lib/Connection.h
index dedc6dc69..ca084e8ba 100644
--- a/lib/Connection.h
+++ b/lib/Connection.h
@@ -1100,7 +1100,7 @@ public:
 			ptr = ClassObjectCreator<npT>::invoke(); //does new npT or throws for abstract classes
 			s.ptrAllocated(ptr, pid);
 			//T is most derived known type, it's time to call actual serialize
-			ptr->serialize(s,version);
+			ptr->serialize(s,s.fileVersion);
 			return &typeid(T);
 		}
 	};

From 53b5587c2ee9fabfd44c27754c24d93bc35e6f8c Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 21 Feb 2016 20:58:09 +0300
Subject: [PATCH 082/105] Advance map header serialization

---
 lib/CArtHandler.cpp                      | 24 ++++++++---
 lib/CArtHandler.h                        |  6 +++
 lib/CCreatureHandler.cpp                 |  4 +-
 lib/CHeroHandler.cpp                     | 29 ++++++++-----
 lib/CHeroHandler.h                       |  6 +++
 lib/CModHandler.cpp                      | 31 +++++++++++---
 lib/CTownHandler.cpp                     |  8 ++--
 lib/IHandlerBase.cpp                     |  5 +++
 lib/IHandlerBase.h                       |  5 ++-
 lib/mapObjects/CObjectClassesHandler.cpp |  4 +-
 lib/mapping/MapFormatJson.cpp            | 41 ++++++++++++++++--
 lib/mapping/MapFormatJson.h              | 19 +++++++--
 lib/serializer/JsonDeserializer.cpp      | 54 ++++++++++++------------
 lib/spells/CSpellHandler.cpp             | 23 +++++++++-
 lib/spells/CSpellHandler.h               |  6 +++
 test/MapComparer.cpp                     | 40 +++++++++++++++---
 16 files changed, 230 insertions(+), 75 deletions(-)

diff --git a/lib/CArtHandler.cpp b/lib/CArtHandler.cpp
index ad1ec6ca1..293b47f32 100644
--- a/lib/CArtHandler.cpp
+++ b/lib/CArtHandler.cpp
@@ -203,7 +203,7 @@ std::vector<JsonNode> CArtHandler::loadLegacyData(size_t dataSize)
 
 void CArtHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 	object->id = ArtifactID(artifacts.size());
 	object->iconIndex = object->id + 5;
 
@@ -231,12 +231,12 @@ void CArtHandler::loadObject(std::string scope, std::string name, const JsonNode
 			VLC->objtypeh->removeSubObject(Obj::ARTIFACT, object->id);
 	});
 
-	registerObject(scope, "artifact", object->identifier, object->id);
+	registerObject(scope, "artifact", name, object->id);
 }
 
 void CArtHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 	object->id = ArtifactID(index);
 	object->iconIndex = object->id;
 
@@ -264,7 +264,7 @@ void CArtHandler::loadObject(std::string scope, std::string name, const JsonNode
 		if (VLC->objtypeh->getHandlerFor(Obj::ARTIFACT, object->id)->getTemplates().empty())
 			VLC->objtypeh->removeSubObject(Obj::ARTIFACT, object->id);
 	});
-	registerObject(scope, "artifact", object->identifier, object->id);
+	registerObject(scope, "artifact", name, object->id);
 }
 
 CArtifact * CArtHandler::loadFromJson(const JsonNode & node, const std::string & identifier)
@@ -674,7 +674,7 @@ std::vector<bool> CArtHandler::getDefaultAllowed() const
 	std::vector<bool> allowedArtifacts;
 	allowedArtifacts.resize(127, true);
 	allowedArtifacts.resize(141, false);
-	allowedArtifacts.resize(GameConstants::ARTIFACTS_QUANTITY, true);
+	allowedArtifacts.resize(artifacts.size(), true);
 	return allowedArtifacts;
 }
 
@@ -742,6 +742,20 @@ void CArtHandler::afterLoadFinalization()
 	CBonusSystemNode::treeHasChanged();
 }
 
+si32 CArtHandler::decodeArfifact(const std::string& identifier)
+{
+	auto rawId = VLC->modh->identifiers.getIdentifier("core", "artifact", identifier);
+	if(rawId)
+		return rawId.get();
+	else
+		return -1;
+}
+
+std::string CArtHandler::encodeArtifact(const si32 index)
+{
+	return VLC->arth->artifacts[index]->identifier;
+}
+
 CArtifactInstance::CArtifactInstance()
 {
 	init();
diff --git a/lib/CArtHandler.h b/lib/CArtHandler.h
index c76e4cdcb..823756fdf 100644
--- a/lib/CArtHandler.h
+++ b/lib/CArtHandler.h
@@ -255,6 +255,12 @@ public:
 
 	std::vector<bool> getDefaultAllowed() const override;
 
+	///json serialization helper
+	static si32 decodeArfifact(const std::string & identifier);
+
+	///json serialization helper
+	static std::string encodeArtifact(const si32 index);
+
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
 		h & artifacts & allowedArtifacts & treasures & minors & majors & relics
diff --git a/lib/CCreatureHandler.cpp b/lib/CCreatureHandler.cpp
index cb356af1b..2194a4fdd 100644
--- a/lib/CCreatureHandler.cpp
+++ b/lib/CCreatureHandler.cpp
@@ -368,7 +368,7 @@ std::vector<JsonNode> CCreatureHandler::loadLegacyData(size_t dataSize)
 
 void CCreatureHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 	object->setId(CreatureID(creatures.size()));
 	object->iconIndex = object->idNumber + 2;
 
@@ -402,7 +402,7 @@ void CCreatureHandler::loadObject(std::string scope, std::string name, const Jso
 
 void CCreatureHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 	object->setId(CreatureID(index));
 	object->iconIndex = object->idNumber + 2;
 
diff --git a/lib/CHeroHandler.cpp b/lib/CHeroHandler.cpp
index cd3c370fd..9347bec00 100644
--- a/lib/CHeroHandler.cpp
+++ b/lib/CHeroHandler.cpp
@@ -192,7 +192,7 @@ std::vector<JsonNode> CHeroClassHandler::loadLegacyData(size_t dataSize)
 
 void CHeroClassHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 	object->id = heroClasses.size();
 
 	heroClasses.push_back(object);
@@ -205,19 +205,12 @@ void CHeroClassHandler::loadObject(std::string scope, std::string name, const Js
 		VLC->objtypeh->loadSubObject(name, classConf, index, object->id);
 	});
 
-//	VLC->modh->identifiers.requestIdentifier(scope, "object", "prison", [=](si32 index)
-//	{
-//		JsonNode conf;
-//		conf.setMeta(scope);
-//		VLC->objtypeh->loadSubObject(name, conf, index, object->id);
-//	});
-
 	VLC->modh->identifiers.registerObject(scope, "heroClass", name, object->id);
 }
 
 void CHeroClassHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 	object->id = index;
 
 	assert(heroClasses[index] == nullptr); // ensure that this id was not loaded before
@@ -547,7 +540,7 @@ std::vector<JsonNode> CHeroHandler::loadLegacyData(size_t dataSize)
 
 void CHeroHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 	object->ID = HeroTypeID(heroes.size());
 	object->imageIndex = heroes.size() + 30; // 2 special frames + some extra portraits
 
@@ -558,7 +551,7 @@ void CHeroHandler::loadObject(std::string scope, std::string name, const JsonNod
 
 void CHeroHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 	object->ID = HeroTypeID(index);
 	object->imageIndex = index;
 
@@ -618,3 +611,17 @@ std::vector<bool> CHeroHandler::getDefaultAllowedAbilities() const
 	allowedAbilities.resize(GameConstants::SKILL_QUANTITY, true);
 	return allowedAbilities;
 }
+
+si32 CHeroHandler::decodeSkill(const std::string& identifier)
+{
+	auto rawId = VLC->modh->identifiers.getIdentifier("core", "skill", identifier);
+	if(rawId)
+		return rawId.get();
+	else
+		return -1;
+}
+
+std::string CHeroHandler::encodeSkill(const si32 index)
+{
+	return NSecondarySkill::names[index];
+}
diff --git a/lib/CHeroHandler.h b/lib/CHeroHandler.h
index 9adf94ba4..f1c778622 100644
--- a/lib/CHeroHandler.h
+++ b/lib/CHeroHandler.h
@@ -257,6 +257,12 @@ public:
 	 */
 	std::vector<bool> getDefaultAllowedAbilities() const;
 
+	///json serialization helper
+	static si32 decodeSkill(const std::string & identifier);
+
+	///json serialization helper
+	static std::string encodeSkill(const si32 index);
+
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
 		h & classes & heroes & expPerLevel & ballistics & terrCosts;
diff --git a/lib/CModHandler.cpp b/lib/CModHandler.cpp
index 6698074da..081983bc7 100644
--- a/lib/CModHandler.cpp
+++ b/lib/CModHandler.cpp
@@ -187,7 +187,6 @@ void CIdentifierStorage::registerObject(std::string scope, std::string type, std
 	checkIdentifier(fullID);
 
 	registeredObjects.insert(std::make_pair(fullID, data));
-	logGlobal->traceStream() << scope << "::" << fullID;
 }
 
 std::vector<CIdentifierStorage::ObjectData> CIdentifierStorage::getPossibleIdentifiers(const ObjectCallback & request)
@@ -206,10 +205,21 @@ std::vector<CIdentifierStorage::ObjectData> CIdentifierStorage::getPossibleIdent
 	else
 	{
 		//...unless destination mod was specified explicitly
-		auto myDeps = VLC->modh->getModData(request.localScope).dependencies;
-		if (request.remoteScope == "core" ||   // allow only available to all core mod
-		    myDeps.count(request.remoteScope)) // or dependencies
+		//note: getModData does not work for "core" by design
+
+		//for map format support core mod has access to any mod
+		//TODO: better solution for access from map?
+		if(request.localScope == "core" || request.localScope == "")
+		{
 			allowedScopes.insert(request.remoteScope);
+		}
+		else
+		{
+			// allow only available to all core mod or dependencies
+			auto myDeps = VLC->modh->getModData(request.localScope).dependencies;
+			if (request.remoteScope == "core" || myDeps.count(request.remoteScope))
+				allowedScopes.insert(request.remoteScope);
+		}
 	}
 
 	std::string fullID = request.type + '.' + request.name;
@@ -845,9 +855,16 @@ void CModHandler::loadModFilesystems()
 
 CModInfo & CModHandler::getModData(TModID modId)
 {
-	CModInfo & mod = allMods.at(modId);
-	assert(vstd::contains(activeMods, modId)); // not really necessary but won't hurt
-	return mod;
+	auto it = allMods.find(modId);
+
+	if(it == allMods.end())
+	{
+		throw std::runtime_error("Mod not found '" + modId+"'");
+	}
+	else
+	{
+		return it->second;
+	}
 }
 
 void CModHandler::initializeConfig()
diff --git a/lib/CTownHandler.cpp b/lib/CTownHandler.cpp
index 69b9e9b26..64033743f 100644
--- a/lib/CTownHandler.cpp
+++ b/lib/CTownHandler.cpp
@@ -682,7 +682,7 @@ CFaction * CTownHandler::loadFromJson(const JsonNode &source, const std::string
 
 void CTownHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 
 	object->index = factions.size();
 	factions.push_back(object);
@@ -699,7 +699,7 @@ void CTownHandler::loadObject(std::string scope, std::string name, const JsonNod
 		{
 			// register town once objects are loaded
 			JsonNode config = data["town"]["mapObject"];
-			config["faction"].String() = object->identifier;
+			config["faction"].String() = name;
 			config["faction"].meta = scope;
 			if (config.meta.empty())// MODS COMPATIBILITY FOR 0.96
 				config.meta = scope;
@@ -722,7 +722,7 @@ void CTownHandler::loadObject(std::string scope, std::string name, const JsonNod
 
 void CTownHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 	object->index = index;
 	assert(factions[index] == nullptr); // ensure that this id was not loaded before
 	factions[index] = object;
@@ -739,7 +739,7 @@ void CTownHandler::loadObject(std::string scope, std::string name, const JsonNod
 		{
 			// register town once objects are loaded
 			JsonNode config = data["town"]["mapObject"];
-			config["faction"].String() = object->identifier;
+			config["faction"].String() = name;
 			config["faction"].meta = scope;
 			VLC->objtypeh->loadSubObject(object->identifier, config, index, object->index);
 		});
diff --git a/lib/IHandlerBase.cpp b/lib/IHandlerBase.cpp
index bddbae3ba..e4bfe44e7 100644
--- a/lib/IHandlerBase.cpp
+++ b/lib/IHandlerBase.cpp
@@ -17,3 +17,8 @@ void IHandlerBase::registerObject(std::string scope, std::string type_name, std:
 {
 	return VLC->modh->identifiers.registerObject(scope, type_name, name, index);
 }
+
+std::string IHandlerBase::normalizeIdentifier(const std::string& scope, const std::string& remoteScope, const std::string& identifier) const
+{
+	return VLC->modh->normalizeIdentifier(scope, remoteScope, identifier);
+}
diff --git a/lib/IHandlerBase.h b/lib/IHandlerBase.h
index eb5e68482..c11a91be8 100644
--- a/lib/IHandlerBase.h
+++ b/lib/IHandlerBase.h
@@ -25,6 +25,7 @@ class DLL_LINKAGE IHandlerBase
 protected:
 	/// Calls modhandler. Mostly needed to avoid large number of includes in headers
 	void registerObject(std::string scope, std::string type_name, std::string name, si32 index);
+	std::string normalizeIdentifier(const std::string & scope, const std::string & remoteScope, const std::string & identifier) const;
 
 public:
 	/// loads all original game data in vector of json nodes
@@ -65,7 +66,7 @@ public:
 	void loadObject(std::string scope, std::string name, const JsonNode & data) override
 	{
 		auto type_name = getTypeName();
-		auto object = loadFromJson(data, name);
+		auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 		object->id = _ObjectID(objects.size());
 
 		objects.push_back(object);
@@ -75,7 +76,7 @@ public:
 	void loadObject(std::string scope, std::string name, const JsonNode & data, size_t index) override
 	{
 		auto type_name = getTypeName();
-		auto object = loadFromJson(data, name);
+		auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 		object->id = _ObjectID(index);
 
 
diff --git a/lib/mapObjects/CObjectClassesHandler.cpp b/lib/mapObjects/CObjectClassesHandler.cpp
index 4b87e8f18..4141edfca 100644
--- a/lib/mapObjects/CObjectClassesHandler.cpp
+++ b/lib/mapObjects/CObjectClassesHandler.cpp
@@ -201,14 +201,14 @@ CObjectClassesHandler::ObjectContainter * CObjectClassesHandler::loadFromJson(co
 
 void CObjectClassesHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 	objects[object->id] = object;
 	VLC->modh->identifiers.registerObject(scope, "object", name, object->id);
 }
 
 void CObjectClassesHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
 {
-	auto object = loadFromJson(data, name);
+	auto object = loadFromJson(data, normalizeIdentifier(scope, "core", name));
 	assert(objects[index] == nullptr); // ensure that this id was not loaded before
 	objects[index] = object;
 	VLC->modh->identifiers.registerObject(scope, "object", name, object->id);
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 149662b8b..274b0e713 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -23,6 +23,7 @@
 #include "../mapObjects/CObjectClassesHandler.h"
 #include "../mapObjects/CGHeroInstance.h"
 #include "../mapObjects/CGTownInstance.h"
+#include "../spells/CSpellHandler.h"
 #include "../StringConstants.h"
 #include "../serializer/JsonDeserializer.h"
 #include "../serializer/JsonSerializer.h"
@@ -432,6 +433,35 @@ void CMapFormatJson::writeTriggeredEvent(const TriggeredEvent& event, JsonNode&
 	dest["condition"] = event.trigger.toJson(ConditionToJson);
 }
 
+void CMapFormatJson::serializeOptions(JsonSerializeFormat & handler)
+{
+	//rumors
+
+	//disposedHeroes
+
+	//predefinedHeroes
+
+	handler.serializeLIC("allowedAbilities", &CHeroHandler::decodeSkill, &CHeroHandler::encodeSkill, VLC->heroh->getDefaultAllowedAbilities(), map->allowedAbilities);
+
+	handler.serializeLIC("allowedArtifacts", &CArtHandler::decodeArfifact, &CArtHandler::encodeArtifact, VLC->arth->getDefaultAllowed(), map->allowedArtifact);
+
+	handler.serializeLIC("allowedSpells", &CSpellHandler::decodeSpell, &CSpellHandler::encodeSpell, VLC->spellh->getDefaultAllowed(), map->allowedSpell);
+
+
+	//events
+}
+
+void CMapFormatJson::readOptions(JsonDeserializer & handler)
+{
+	serializeOptions(handler);
+}
+
+void CMapFormatJson::writeOptions(JsonSerializer & handler)
+{
+	serializeOptions(handler);
+}
+
+
 ///CMapPatcher
 CMapPatcher::CMapPatcher(JsonNode stream):
 	input(stream)
@@ -490,7 +520,7 @@ std::unique_ptr<CMapHeader> CMapLoaderJson::loadMapHeader()
 	map = nullptr;
 	std::unique_ptr<CMapHeader> result = std::unique_ptr<CMapHeader>(new CMapHeader());
 	mapHeader = result.get();
-	readHeader();
+	readHeader(false);
 	return std::move(result);
 }
 
@@ -512,7 +542,7 @@ const JsonNode CMapLoaderJson::getFromArchive(const std::string & archiveFilenam
 void CMapLoaderJson::readMap()
 {
 	LOG_TRACE(logGlobal);
-	readHeader();
+	readHeader(true);
 	map->initTerrain();
 	readTerrain();
 	readObjects();
@@ -525,7 +555,7 @@ void CMapLoaderJson::readMap()
 	map->calculateGuardingGreaturePositions();
 }
 
-void CMapLoaderJson::readHeader()
+void CMapLoaderJson::readHeader(const bool complete)
 {
 	//do not use map field here, use only mapHeader
 	JsonNode header = getFromArchive(HEADER_FILE_NAME);
@@ -575,6 +605,9 @@ void CMapLoaderJson::readHeader()
 
 	readTeams(handler);
 	//TODO: readHeader
+
+	if(complete)
+		readOptions(handler);
 }
 
 
@@ -900,6 +933,8 @@ void CMapSaverJson::writeHeader()
 	//todo:	allowedHeroes;
 	//todo: placeholdedHeroes;
 
+	writeOptions(handler);
+
 	addToArchive(header, HEADER_FILE_NAME);
 }
 
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index d7fa2fc8c..4e8f185dc 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -56,13 +56,11 @@ protected:
 
 	/**
 	 * Reads team settings to header
-	 * @param input serialized header
 	 */
 	void readTeams(JsonDeserializer & handler);
 
 	/**
 	 * Saves team settings to header
-	 * @param output serialized header
 	 */
 	void writeTeams(JsonSerializer & handler);
 
@@ -89,6 +87,21 @@ protected:
 	 * Writes one of triggered events
 	 */
 	void writeTriggeredEvent(const TriggeredEvent & event, JsonNode & dest);
+
+
+
+	///common part of map attributes saving/loading
+	void serializeOptions(JsonSerializeFormat & handler);
+
+	/**
+	 * Loads map attributes except header ones
+	 */
+	void readOptions(JsonDeserializer & handler);
+
+	/**
+	 * Saves map attributes except header ones
+	 */
+	void writeOptions(JsonSerializer & handler);
 };
 
 class DLL_LINKAGE CMapPatcher : public CMapFormatJson, public IMapPatcher
@@ -166,7 +179,7 @@ private:
 	/**
 	 * Reads the map header.
 	 */
-	void readHeader();
+	void readHeader(const bool complete);
 
 	/**
 	 * Reads complete map.
diff --git a/lib/serializer/JsonDeserializer.cpp b/lib/serializer/JsonDeserializer.cpp
index ba07f50c1..bc0f6b78f 100644
--- a/lib/serializer/JsonDeserializer.cpp
+++ b/lib/serializer/JsonDeserializer.cpp
@@ -54,11 +54,33 @@ void JsonDeserializer::serializeLIC(const std::string & fieldName, const TDecode
 	if(field.isNull())
 		return;
 
+	auto loadPart = [&](const JsonVector & part, const bool val)
+	{
+		for(size_t index = 0; index < part.size(); index++)
+		{
+			const std::string & identifier = part[index].String();
+
+			logGlobal->debugStream() << "serializeLIC: " << fieldName << " " << identifier;
+
+			si32 rawId = decoder(identifier);
+			if(rawId >= 0)
+			{
+				if(rawId < value.size())
+					value[rawId] = val;
+				else
+					logGlobal->errorStream() << "JsonDeserializer::serializeLIC: " << fieldName <<" id out of bounds " << rawId;
+			}
+			else
+			{
+				logGlobal->errorStream() << "JsonDeserializer::serializeLIC: " << fieldName <<" identifier not resolved " << identifier;
+			}
+		}
+	};
+
 	const JsonVector & anyOf = field["anyOf"].Vector();
 	const JsonVector & allOf = field["allOf"].Vector();
 	const JsonVector & noneOf = field["noneOf"].Vector();
 
-
 	if(anyOf.empty() && allOf.empty())
 	{
 		//permissive mode
@@ -70,35 +92,11 @@ void JsonDeserializer::serializeLIC(const std::string & fieldName, const TDecode
 		value.clear();
 		value.resize(standard.size(), false);
 
-		for(size_t index = 0; index < anyOf.size(); index++)
-		{
-			const std::string & identifier = anyOf[index].String();
-
-			si32 rawId = decoder(identifier);
-			if(rawId >= 0)
-				value[rawId] = true;
-		}
-
-
-		for(size_t index = 0; index < allOf.size(); index++)
-		{
-			const std::string & identifier = allOf[index].String();
-
-			si32 rawId = decoder(identifier);
-			if(rawId >=0)
-				value[rawId] = true;
-		}
-	}
-
-	for(size_t index = 0; index < noneOf.size(); index++)
-	{
-		const std::string & identifier = noneOf[index].String();
-
-		si32 rawId = decoder(identifier);
-		if(rawId >=0 )
-			value[rawId] = false;
+		loadPart(anyOf, true);
+		loadPart(allOf, true);
 	}
 
+	loadPart(noneOf, false);
 }
 
 void JsonDeserializer::serializeString(const std::string & fieldName, std::string & value)
diff --git a/lib/spells/CSpellHandler.cpp b/lib/spells/CSpellHandler.cpp
index 9431da324..e507ba2e0 100644
--- a/lib/spells/CSpellHandler.cpp
+++ b/lib/spells/CSpellHandler.cpp
@@ -1078,6 +1078,27 @@ CSpellHandler::~CSpellHandler()
 std::vector<bool> CSpellHandler::getDefaultAllowed() const
 {
 	std::vector<bool> allowedSpells;
-	allowedSpells.resize(GameConstants::SPELLS_QUANTITY, true);
+	allowedSpells.reserve(objects.size());
+
+	for(const CSpell * s : objects)
+	{
+		allowedSpells.push_back( !(s->isSpecialSpell() || s->isCreatureAbility()));
+	}
+
 	return allowedSpells;
 }
+
+si32 CSpellHandler::decodeSpell(const std::string& identifier)
+{
+	auto rawId = VLC->modh->identifiers.getIdentifier("core", "spell", identifier);
+	if(rawId)
+		return rawId.get();
+	else
+		return -1;
+}
+
+std::string CSpellHandler::encodeSpell(const si32 index)
+{
+	return VLC->spellh->objects[index]->identifier;
+}
+
diff --git a/lib/spells/CSpellHandler.h b/lib/spells/CSpellHandler.h
index 8cbbd2677..480d3ea59 100644
--- a/lib/spells/CSpellHandler.h
+++ b/lib/spells/CSpellHandler.h
@@ -360,6 +360,12 @@ public:
 
 	const std::string getTypeName() const override;
 
+	///json serialization helper
+	static si32 decodeSpell(const std::string & identifier);
+
+	///json serialization helper
+	static std::string encodeSpell(const si32 index);
+
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
 		h & objects ;
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 8f7690aad..de947e172 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -26,6 +26,16 @@ void checkEqual(const T & actual, const T & expected)
 	BOOST_CHECK_EQUAL(actual, expected)	;
 }
 
+void checkEqual(const std::vector<bool> & actual, const std::vector<bool> & 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::vector<Element> & actual, const std::vector<Element> & expected)
 {
@@ -89,6 +99,20 @@ void checkEqual(const TriggeredEvent & actual,  const TriggeredEvent & expected)
 	checkEqual(actual.trigger, expected.trigger);
 }
 
+void checkEqual(const Rumor & actual, const Rumor & expected)
+{
+	VCMI_CHECK_FIELD_EQUAL(name);
+	VCMI_CHECK_FIELD_EQUAL(text);
+}
+
+void checkEqual(const DisposedHero & actual, const DisposedHero & expected)
+{
+	VCMI_CHECK_FIELD_EQUAL(heroId);
+	VCMI_CHECK_FIELD_EQUAL(portrait);
+	VCMI_CHECK_FIELD_EQUAL(name);
+	VCMI_CHECK_FIELD_EQUAL(players);
+}
+
 void checkEqual(const TerrainTile & actual, const TerrainTile & expected)
 {
 	//fatal fail here on any error
@@ -138,14 +162,16 @@ void MapComparer::compareHeader()
 
 void MapComparer::compareOptions()
 {
-	//rumors
-	//disposedHeroes
-	//predefinedHeroes
-	//allowedSpell
-	//allowedArtifact
-	//allowedAbilities
+	checkEqual(actual->rumors, expected->rumors);
+	checkEqual(actual->disposedHeroes, expected->disposedHeroes);
+	//todo: compareOptions predefinedHeroes
 
-	BOOST_ERROR("Not implemented compareOptions()");
+	checkEqual(actual->allowedAbilities, expected->allowedAbilities);
+	checkEqual(actual->allowedArtifact, expected->allowedArtifact);
+	checkEqual(actual->allowedSpell, expected->allowedSpell);
+	//checkEqual(actual->allowedAbilities, expected->allowedAbilities);
+
+	//todo: compareOptions  events
 }
 
 void MapComparer::compareObject(const CGObjectInstance * actual, const CGObjectInstance * expected)

From 4ebafa17b47d8adc0336c8e4046341410ab91d59 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 21 Feb 2016 22:12:58 +0300
Subject: [PATCH 083/105] Remove unused placeholdedHeroes field

---
 lib/mapping/CMap.h           |  2 +-
 lib/mapping/MapFormatH3M.cpp | 13 +++++++++----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/lib/mapping/CMap.h b/lib/mapping/CMap.h
index b733b4302..979856854 100644
--- a/lib/mapping/CMap.h
+++ b/lib/mapping/CMap.h
@@ -259,7 +259,7 @@ public:
 	std::vector<PlayerInfo> players; /// The default size of the vector is PlayerColor::PLAYER_LIMIT.
 	ui8 howManyTeams;
 	std::vector<bool> allowedHeroes;
-	std::vector<ui16> placeholdedHeroes;
+
 	bool areAnyPlayers; /// Unused. True if there are any playable players on the map.
 
 	/// "main quests" of the map that describe victory and loss conditions
diff --git a/lib/mapping/MapFormatH3M.cpp b/lib/mapping/MapFormatH3M.cpp
index 496ceabc8..e4f4b8fd7 100644
--- a/lib/mapping/MapFormatH3M.cpp
+++ b/lib/mapping/MapFormatH3M.cpp
@@ -615,10 +615,15 @@ void CMapLoaderH3M::readAllowedHeroes()
 	if(mapHeader->version > EMapFormat::ROE)
 	{
 		int placeholdersQty = reader.readUInt32();
-		for(int p = 0; p < placeholdersQty; ++p)
-		{
-			mapHeader->placeholdedHeroes.push_back(reader.readUInt8());
-		}
+
+		reader.skip(placeholdersQty * 1);
+
+//		std::vector<ui16> placeholdedHeroes;
+//
+//		for(int p = 0; p < placeholdersQty; ++p)
+//		{
+//			placeholdedHeroes.push_back(reader.readUInt8());
+//		}
 	}
 }
 

From a4b6d34ebe9cd816df489dd0a527fe5799c3a6ec Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 21 Feb 2016 22:13:20 +0300
Subject: [PATCH 084/105] Advance map header serialization

---
 lib/CHeroHandler.cpp                | 16 +++++++++++++++-
 lib/CHeroHandler.h                  |  6 ++++++
 lib/mapping/MapFormatJson.cpp       | 10 ++--------
 lib/serializer/JsonDeserializer.cpp |  2 --
 test/CMapFormatTest.cpp             |  4 ++--
 test/MapComparer.cpp                |  3 +--
 6 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/lib/CHeroHandler.cpp b/lib/CHeroHandler.cpp
index 9347bec00..e21b7a05f 100644
--- a/lib/CHeroHandler.cpp
+++ b/lib/CHeroHandler.cpp
@@ -612,7 +612,21 @@ std::vector<bool> CHeroHandler::getDefaultAllowedAbilities() const
 	return allowedAbilities;
 }
 
-si32 CHeroHandler::decodeSkill(const std::string& identifier)
+si32 CHeroHandler::decodeHero(const std::string & identifier)
+{
+	auto rawId = VLC->modh->identifiers.getIdentifier("core", "hero", identifier);
+	if(rawId)
+		return rawId.get();
+	else
+		return -1;
+}
+
+std::string CHeroHandler::encodeHero(const si32 index)
+{
+	return VLC->heroh->heroes.at(index)->identifier;
+}
+
+si32 CHeroHandler::decodeSkill(const std::string & identifier)
 {
 	auto rawId = VLC->modh->identifiers.getIdentifier("core", "skill", identifier);
 	if(rawId)
diff --git a/lib/CHeroHandler.h b/lib/CHeroHandler.h
index f1c778622..709ff1255 100644
--- a/lib/CHeroHandler.h
+++ b/lib/CHeroHandler.h
@@ -257,6 +257,12 @@ public:
 	 */
 	std::vector<bool> getDefaultAllowedAbilities() const;
 
+	///json serialization helper
+	static si32 decodeHero(const std::string & identifier);
+
+	///json serialization helper
+	static std::string encodeHero(const si32 index);
+
 	///json serialization helper
 	static si32 decodeSkill(const std::string & identifier);
 
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 274b0e713..22d508db0 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -208,6 +208,8 @@ void CMapFormatJson::serializeHeader(JsonSerializeFormat & handler)
 	handler.serializeNumericEnum("difficulty", HeaderDetail::difficultyMap, HeaderDetail::difficultyDefault, mapHeader->difficulty);
 
 	serializePlayerInfo(handler);
+
+	handler.serializeLIC("allowedHeroes", &CHeroHandler::decodeHero, &CHeroHandler::encodeHero, VLC->heroh->getDefaultAllowed(), mapHeader->allowedHeroes);
 }
 
 void CMapFormatJson::serializePlayerInfo(JsonSerializeFormat & handler)
@@ -447,7 +449,6 @@ void CMapFormatJson::serializeOptions(JsonSerializeFormat & handler)
 
 	handler.serializeLIC("allowedSpells", &CSpellHandler::decodeSpell, &CSpellHandler::encodeSpell, VLC->spellh->getDefaultAllowed(), map->allowedSpell);
 
-
 	//events
 }
 
@@ -596,10 +597,6 @@ void CMapLoaderJson::readHeader(const bool complete)
 
 	serializeHeader(handler);
 
-
-//	std::vector<bool> allowedHeroes;
-//	std::vector<ui16> placeholdedHeroes;
-
 	readTriggeredEvents(handler);
 
 
@@ -930,9 +927,6 @@ void CMapSaverJson::writeHeader()
 
 	writeTeams(handler);
 
-	//todo:	allowedHeroes;
-	//todo: placeholdedHeroes;
-
 	writeOptions(handler);
 
 	addToArchive(header, HEADER_FILE_NAME);
diff --git a/lib/serializer/JsonDeserializer.cpp b/lib/serializer/JsonDeserializer.cpp
index bc0f6b78f..518758129 100644
--- a/lib/serializer/JsonDeserializer.cpp
+++ b/lib/serializer/JsonDeserializer.cpp
@@ -60,8 +60,6 @@ void JsonDeserializer::serializeLIC(const std::string & fieldName, const TDecode
 		{
 			const std::string & identifier = part[index].String();
 
-			logGlobal->debugStream() << "serializeLIC: " << fieldName << " " << identifier;
-
 			si32 rawId = decoder(identifier);
 			if(rawId >= 0)
 			{
diff --git a/test/CMapFormatTest.cpp b/test/CMapFormatTest.cpp
index f0b1b1070..9e4ace40d 100644
--- a/test/CMapFormatTest.cpp
+++ b/test/CMapFormatTest.cpp
@@ -35,8 +35,8 @@ public:
 	{
 		CMapGenOptions opt;
 
-		opt.setHeight(CMapHeader::MAP_SIZE_LARGE);
-		opt.setWidth(CMapHeader::MAP_SIZE_LARGE);
+		opt.setHeight(CMapHeader::MAP_SIZE_MIDDLE);
+		opt.setWidth(CMapHeader::MAP_SIZE_MIDDLE);
 		opt.setHasTwoLevels(true);
 		opt.setPlayerCount(4);
 
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index de947e172..a9797a121 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -144,8 +144,7 @@ void MapComparer::compareHeader()
 
 	checkEqual(actual->players, expected->players);
 
-	//todo: allowedHeroes, placeholdedHeroes
-
+	checkEqual(actual->allowedHeroes, expected->allowedHeroes);
 
 	std::vector<TriggeredEvent> actualEvents = actual->triggeredEvents;
 	std::vector<TriggeredEvent> expectedEvents = expected->triggeredEvents;

From 15a4a115603468335bc3e652f6c7ff2f35b2332f Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Sun, 21 Feb 2016 22:17:18 +0300
Subject: [PATCH 085/105] Tweak tests

---
 test/MapComparer.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index a9797a121..6aad7881e 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -59,6 +59,12 @@ void checkEqual(const std::set<Element> & actual, const std::set<Element> & expe
 	}
 }
 
+void checkEqual(const SHeroName & actual, const SHeroName & expected)
+{
+	VCMI_CHECK_FIELD_EQUAL(heroId);
+	VCMI_CHECK_FIELD_EQUAL(heroName);
+}
+
 void checkEqual(const PlayerInfo & actual, const PlayerInfo & expected)
 {
 	VCMI_CHECK_FIELD_EQUAL(canHumanPlay);
@@ -73,14 +79,13 @@ void checkEqual(const PlayerInfo & actual, const PlayerInfo & expected)
 
 	VCMI_CHECK_FIELD_EQUAL(mainCustomHeroId);
 
-	//todo:heroesNames
+	checkEqual(actual.heroesNames, expected.heroesNames);
 
 	VCMI_CHECK_FIELD_EQUAL(hasMainTown);
 	VCMI_CHECK_FIELD_EQUAL(generateHeroAtMainTown);
 	VCMI_CHECK_FIELD_EQUAL(posOfMainTown);
 	VCMI_CHECK_FIELD_EQUAL(team);
 	VCMI_CHECK_FIELD_EQUAL(hasRandomHero);
-
 }
 
 void checkEqual(const EventExpression & actual,  const EventExpression & expected)
@@ -142,6 +147,8 @@ void MapComparer::compareHeader()
 	VCMI_CHECK_FIELD_EQUAL_P(victoryIconIndex);
 	VCMI_CHECK_FIELD_EQUAL_P(defeatIconIndex);
 
+	VCMI_CHECK_FIELD_EQUAL_P(howManyTeams);
+
 	checkEqual(actual->players, expected->players);
 
 	checkEqual(actual->allowedHeroes, expected->allowedHeroes);

From dd1aabbe233043e66851b278e2af68124c29ef00 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 22 Feb 2016 02:37:19 +0300
Subject: [PATCH 086/105] Use JsonSerializeFormat for map objects

---
 lib/CCreatureSet.cpp                 |  34 ++-
 lib/CCreatureSet.h                   |   6 +-
 lib/mapObjects/CArmedInstance.cpp    |  10 -
 lib/mapObjects/CArmedInstance.h      |   3 -
 lib/mapObjects/CGHeroInstance.cpp    |  56 +++--
 lib/mapObjects/CGHeroInstance.h      |   3 +-
 lib/mapObjects/CGTownInstance.cpp    |  22 +-
 lib/mapObjects/CGTownInstance.h      |   4 +-
 lib/mapObjects/CObjectHandler.cpp    | 102 ++++----
 lib/mapObjects/CObjectHandler.h      |  17 +-
 lib/mapObjects/MiscObjects.cpp       | 346 +++++++++++----------------
 lib/mapObjects/MiscObjects.h         |  37 +--
 lib/mapping/MapFormatJson.cpp        |  23 +-
 lib/mapping/MapFormatJson.h          |   6 +-
 lib/serializer/JsonDeserializer.cpp  |  18 ++
 lib/serializer/JsonDeserializer.h    |   1 +
 lib/serializer/JsonSerializeFormat.h |  12 +
 lib/serializer/JsonSerializer.cpp    |   9 +
 lib/serializer/JsonSerializer.h      |   1 +
 19 files changed, 344 insertions(+), 366 deletions(-)

diff --git a/lib/CCreatureSet.cpp b/lib/CCreatureSet.cpp
index bf85fbda6..0247747c0 100644
--- a/lib/CCreatureSet.cpp
+++ b/lib/CCreatureSet.cpp
@@ -11,6 +11,7 @@
 #include "spells/CSpellHandler.h"
 #include "CHeroHandler.h"
 #include "IBonusTypeHandler.h"
+#include "serializer/JsonSerializeFormat.h"
 
 /*
  * CCreatureSet.cpp, part of VCMI engine
@@ -479,27 +480,34 @@ CCreatureSet & CCreatureSet::operator=(const CCreatureSet&cs)
 
 void CCreatureSet::armyChanged()
 {
+
 }
 
-void CCreatureSet::writeJson(JsonNode& json) const
+void CCreatureSet::serializeJson(JsonSerializeFormat & handler, const std::string & fieldName)
 {
-	for(const auto & p : stacks)
+	if(handler.saving && stacks.empty())
+		return;
+	JsonNode & json = handler.getCurrent()[fieldName];
+
+	if(handler.saving)
 	{
-		JsonNode stack_node;
-		p.second->writeJson(stack_node);
-		json.Vector()[p.first.getNum()] = stack_node;
+		for(const auto & p : stacks)
+		{
+			JsonNode stack_node;
+			p.second->writeJson(stack_node);
+			json.Vector()[p.first.getNum()] = stack_node;
+		}
 	}
-}
-
-void CCreatureSet::readJson(const JsonNode& json)
-{
-	for(size_t idx = 0; idx < json.Vector().size(); idx++)
+	else
 	{
-		CStackInstance * new_stack = new CStackInstance();
+		for(size_t idx = 0; idx < json.Vector().size(); idx++)
+		{
+			CStackInstance * new_stack = new CStackInstance();
 
-		new_stack->readJson(json.Vector()[idx]);
+			new_stack->readJson(json.Vector()[idx]);
 
-		putStack(SlotID(idx), new_stack);
+			putStack(SlotID(idx), new_stack);
+		}
 	}
 }
 
diff --git a/lib/CCreatureSet.h b/lib/CCreatureSet.h
index c1a5c8f54..27075e8be 100644
--- a/lib/CCreatureSet.h
+++ b/lib/CCreatureSet.h
@@ -19,6 +19,7 @@ class CCreature;
 class CGHeroInstance;
 class CArmedInstance;
 class CCreatureArtifactSet;
+class JsonSerializeFormat;
 
 class DLL_LINKAGE CStackBasicDescriptor
 {
@@ -220,10 +221,7 @@ public:
 		h & stacks & formation;
 	}
 
-
-	void writeJson(JsonNode & json) const;
-
-	void readJson(const JsonNode & json);
+	void serializeJson(JsonSerializeFormat & handler, const std::string & fieldName);
 
 	operator bool() const
 	{
diff --git a/lib/mapObjects/CArmedInstance.cpp b/lib/mapObjects/CArmedInstance.cpp
index b7c2aafa7..ecb37b01c 100644
--- a/lib/mapObjects/CArmedInstance.cpp
+++ b/lib/mapObjects/CArmedInstance.cpp
@@ -132,13 +132,3 @@ CBonusSystemNode * CArmedInstance::whatShouldBeAttached()
 {
 	return this;
 }
-
-void CArmedInstance::writeJsonOptions(JsonNode& json) const
-{
-	CGObjectInstance::writeJsonOptions(json);
-}
-
-void CArmedInstance::readJsonOptions(const JsonNode& json)
-{
-	CGObjectInstance::readJsonOptions(json);
-}
diff --git a/lib/mapObjects/CArmedInstance.h b/lib/mapObjects/CArmedInstance.h
index bf22a527a..0ebe2abc1 100644
--- a/lib/mapObjects/CArmedInstance.h
+++ b/lib/mapObjects/CArmedInstance.h
@@ -40,7 +40,4 @@ public:
 		h & static_cast<CBonusSystemNode&>(*this);
 		h & static_cast<CCreatureSet&>(*this);
 	}
-protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
 };
diff --git a/lib/mapObjects/CGHeroInstance.cpp b/lib/mapObjects/CGHeroInstance.cpp
index 544dc2f97..5ed39b9f0 100644
--- a/lib/mapObjects/CGHeroInstance.cpp
+++ b/lib/mapObjects/CGHeroInstance.cpp
@@ -25,6 +25,7 @@
 #include "../CTownHandler.h"
 #include "../mapping/CMap.h"
 #include "CGTownInstance.h"
+#include "../serializer/JsonSerializeFormat.h"
 
 ///helpers
 static void showInfoDialog(const PlayerColor playerID, const ui32 txtID, const ui16 soundID)
@@ -1470,42 +1471,47 @@ bool CGHeroInstance::hasVisions(const CGObjectInstance * target, const int subty
 	return (distance < visionsRange) && (target->pos.z == pos.z);
 }
 
-void CGHeroInstance::writeJsonOptions(JsonNode& json) const
+void CGHeroInstance::serializeJsonOptions(JsonSerializeFormat& handler)
 {
-	if(type)
+	serializeJsonOwner(handler);
+
+	if(handler.saving)
 	{
-		json["type"].String() = type->identifier;
+		if(type)
+		{
+			handler.serializeString("type", type->identifier);
+		}
+		else
+		{
+			auto temp = VLC->heroh->heroes[subID]->identifier;
+			handler.serializeString("type", temp);
+		}
 	}
 	else
 	{
-		json["type"].String() = VLC->heroh->heroes[subID]->identifier;
+		if(ID == Obj::HERO || ID == Obj::PRISON)
+		{
+			std::string typeName;
+			handler.serializeString("type", typeName);
+
+			auto rawId = VLC->modh->identifiers.getIdentifier("core", "hero", typeName);
+
+			if(rawId)
+				subID = rawId.get();
+			else
+				subID = 0; //fallback to Orrin, throw error instead?
+		}
 	}
+	CCreatureSet::serializeJson(handler, "army");
 
-	CGObjectInstance::writeOwner(json);
-
-	CCreatureSet::writeJson(json["army"]);
-	CArtifactSet::writeJson(json["artifacts"]);
-
-}
-
-void CGHeroInstance::readJsonOptions(const JsonNode& json)
-{
-	if(ID == Obj::HERO || ID == Obj::PRISON)
 	{
-		auto typeName = json["type"].String();
-
-		auto rawId = VLC->modh->identifiers.getIdentifier("core", "hero", typeName);
-
-		if(rawId)
-			subID = rawId.get();
+		auto artifacts = handler.enterStruct("artifacts");
+		if(handler.saving)
+			CArtifactSet::writeJson(handler.getCurrent());
 		else
-			subID = 0; //fallback to Orrin, throw error instead?
+			CArtifactSet::readJson(handler.getCurrent());
 	}
 
-	CGObjectInstance::readOwner(json);
-
-	CCreatureSet::readJson(json["army"]);
-	CArtifactSet::readJson(json["artifacts"]);
 }
 
 bool CGHeroInstance::isMissionCritical() const
diff --git a/lib/mapObjects/CGHeroInstance.h b/lib/mapObjects/CGHeroInstance.h
index c9781717c..3fd439854 100644
--- a/lib/mapObjects/CGHeroInstance.h
+++ b/lib/mapObjects/CGHeroInstance.h
@@ -251,8 +251,7 @@ public:
 	std::string getObjectName() const override;
 protected:
 	void setPropertyDer(ui8 what, ui32 val) override;//synchr
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 
 private:
 	void levelUpAutomatically();
diff --git a/lib/mapObjects/CGTownInstance.cpp b/lib/mapObjects/CGTownInstance.cpp
index dfa3ba2f1..808416670 100644
--- a/lib/mapObjects/CGTownInstance.cpp
+++ b/lib/mapObjects/CGTownInstance.cpp
@@ -19,6 +19,7 @@
 #include "../CGameState.h"
 #include "../mapping/CMapDefines.h"
 #include "../CPlayerState.h"
+#include "../serializer/JsonSerializeFormat.h"
 
 std::vector<const CArtifact *> CGTownInstance::merchantArtifacts;
 std::vector<int> CGTownInstance::universitySkills;
@@ -314,18 +315,11 @@ void CGDwelling::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer)
 	}
 }
 
-void CGDwelling::writeJsonOptions(JsonNode& json) const
+void CGDwelling::serializeJsonOptions(JsonSerializeFormat & handler)
 {
-	//todo:CGDwelling::writeJsonOptions
+	//todo: CGDwelling::serializeJsonOptions
 	if(ID != Obj::WAR_MACHINE_FACTORY && ID != Obj::REFUGEE_CAMP)
-		CGObjectInstance::writeOwner(json);
-}
-
-void CGDwelling::readJsonOptions(const JsonNode& json)
-{
-	//todo:CGDwelling::readJsonOptions
-	if(ID != Obj::WAR_MACHINE_FACTORY && ID != Obj::REFUGEE_CAMP)
-		CGObjectInstance::readOwner(json);
+		serializeJsonOwner(handler);
 }
 
 int CGTownInstance::getSightRadius() const //returns sight distance
@@ -1129,6 +1123,14 @@ void CGTownInstance::battleFinished(const CGHeroInstance *hero, const BattleResu
 	}
 }
 
+void CGTownInstance::serializeJsonOptions(JsonSerializeFormat& handler)
+{
+	CGObjectInstance::serializeJsonOwner(handler);
+	CCreatureSet::serializeJson(handler, "army");
+
+	//todo: CGTownInstance::serializeJsonOptions
+}
+
 COPWBonus::COPWBonus (BuildingID index, CGTownInstance *TOWN)
 {
 	ID = index;
diff --git a/lib/mapObjects/CGTownInstance.h b/lib/mapObjects/CGTownInstance.h
index 70ec532fb..9b31fd245 100644
--- a/lib/mapObjects/CGTownInstance.h
+++ b/lib/mapObjects/CGTownInstance.h
@@ -53,8 +53,7 @@ public:
 	TCreaturesSet creatures; //creatures[level] -> <vector of alternative ids (base creature and upgrades, creatures amount>
 
 protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 
 private:
 	void initObj() override;
@@ -256,4 +255,5 @@ public:
 	std::string getObjectName() const override;
 protected:
 	void setPropertyDer(ui8 what, ui32 val) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 };
diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index a0d9d9d87..7742eccb2 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -24,6 +24,8 @@
 #include "CObjectClassesHandler.h"
 #include "CGTownInstance.h"
 
+#include "../serializer/JsonSerializeFormat.h"
+
 IGameCallback * IObjectInterface::cb = nullptr;
 
 ///helpers
@@ -331,64 +333,70 @@ bool CGObjectInstance::passableFor(PlayerColor color) const
 	return false;
 }
 
-void CGObjectInstance::writeJson(JsonNode & json) const
+void CGObjectInstance::serializeJson(JsonSerializeFormat & handler)
 {
-	logGlobal->debugStream() <<"Save: [" << pos << "] " << id << " " << ID << " " << subID << " " << typeName << " " << subTypeName;
-
-	json.setType(JsonNode::DATA_STRUCT);
-	json["type"].String() = typeName;
-	json["subType"].String() = subTypeName;
-	json["x"].Float() = pos.x;
-	json["y"].Float() = pos.y;
-	json["l"].Float() = pos.z;
-
-	appearance.writeJson(json["template"], false);
-	writeJsonOptions(json["options"]);
-}
-
-void CGObjectInstance::readJson(const JsonNode & json)
-{
-	if(json.getType() != JsonNode::DATA_STRUCT)
+	if(handler.saving)
 	{
-		logGlobal->error("Invalid object instance data");
-		return;
+		handler.serializeString("type", typeName);
+		handler.serializeString("subType", subTypeName);
 	}
-	pos.x = json["x"].Float();
-	pos.y = json["y"].Float();
-	pos.z = json["l"].Float();
 
-	appearance.readJson(json["template"], false);
+	handler.serializeNumeric("x", pos.x);
+	handler.serializeNumeric("y", pos.y);
+	handler.serializeNumeric("l", pos.z);
 
-	readJsonOptions(json["options"]);
-}
-
-void CGObjectInstance::writeJsonOptions(JsonNode & json) const
-{
-	json.setType(JsonNode::DATA_STRUCT);
-}
-
-void CGObjectInstance::readJsonOptions(const JsonNode & json)
-{
-}
-
-void CGObjectInstance::writeOwner(JsonNode & json) const
-{
-	if(tempOwner.isValidPlayer())
+	if(handler.saving)
 	{
-		json["owner"].String() = GameConstants::PLAYER_COLOR_NAMES[tempOwner.getNum()];
+		appearance.writeJson(handler.getCurrent()["template"], false);
+	}
+	else
+	{
+		appearance.readJson(handler.getCurrent()["template"], false);
+	}
+
+	{
+		auto options = handler.enterStruct("options");
+		serializeJsonOptions(handler);
+	}
+
+	if(handler.saving && handler.getCurrent()["options"].isNull())
+	{
+		handler.getCurrent().Struct().erase("options");
 	}
 }
 
-void CGObjectInstance::readOwner(const JsonNode & json)
+void CGObjectInstance::serializeJsonOptions(JsonSerializeFormat & handler)
 {
-	tempOwner = PlayerColor::NEUTRAL;//this method assumes that object is ownable
-	if(json["owner"].getType() == JsonNode::DATA_STRING)
+
+}
+
+void CGObjectInstance::serializeJsonOwner(JsonSerializeFormat & handler)
+{
+	std::string temp;
+
+	//todo: use enum serialize
+	if(handler.saving)
 	{
-		auto rawOwner = vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, json["owner"].String());
-		if(rawOwner >=0)
-			tempOwner = PlayerColor(rawOwner);
-		else
-			logGlobal->errorStream() << "Invalid owner :" << json["owner"].String();
+		if(tempOwner.isValidPlayer())
+		{
+			temp = GameConstants::PLAYER_COLOR_NAMES[tempOwner.getNum()];
+			handler.serializeString("owner", temp);
+		}
+	}
+	else
+	{
+		tempOwner = PlayerColor::NEUTRAL;//this method assumes that object is ownable
+
+		handler.serializeString("owner", temp);
+
+		if(temp != "")
+		{
+			auto rawOwner = vstd::find_pos(GameConstants::PLAYER_COLOR_NAMES, temp);
+			if(rawOwner >=0)
+				tempOwner = PlayerColor(rawOwner);
+			else
+				logGlobal->errorStream() << "Invalid owner :" << temp;
+		}
 	}
 }
 
diff --git a/lib/mapObjects/CObjectHandler.h b/lib/mapObjects/CObjectHandler.h
index 12fe7eda6..d417f4763 100644
--- a/lib/mapObjects/CObjectHandler.h
+++ b/lib/mapObjects/CObjectHandler.h
@@ -21,6 +21,7 @@ class IGameCallback;
 class CGObjectInstance;
 struct MetaString;
 struct BattleResult;
+class JsonSerializeFormat;
 
 // This one teleport-specific, but has to be available everywhere in callbacks and netpacks
 // For now it's will be there till teleports code refactored and moved into own file
@@ -186,10 +187,7 @@ public:
 	}
 
 	///Entry point of Json serialization
-	void writeJson(JsonNode & json) const;
-
-	///Entry point of Json de-serialization
-	void readJson(const JsonNode & json);
+	void serializeJson(JsonSerializeFormat & handler);
 
 protected:
 	/// virtual method that allows synchronously update object state on server and all clients
@@ -198,16 +196,11 @@ protected:
 	/// Gives dummy bonus from this object to hero. Can be used to track visited state
 	void giveDummyBonus(ObjectInstanceID heroID, ui8 duration = Bonus::ONE_DAY) const;
 
-	///Saves object-type specific options
-	///(!) do not forget to call inherited method first when overriding
-	virtual void writeJsonOptions(JsonNode & json) const;
+	///Serialize object-type specific options
+	virtual void serializeJsonOptions(JsonSerializeFormat & handler);
 
-	///Loads object-type specific options
-	///(!) do not forget to call inherited method  first when overriding
-	virtual void readJsonOptions(const JsonNode & json);
+	void serializeJsonOwner(JsonSerializeFormat & handler);
 
-	void writeOwner(JsonNode & json) const;
-	void readOwner(const JsonNode & json);
 private:
 	mutable std::string stringId;///<alternate id, dynamically generated, do not serialize
 };
diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index 0830f9371..dce89f71f 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -23,6 +23,7 @@
 #include "../CGameState.h"
 #include "../mapping/CMap.h"
 #include "../CPlayerState.h"
+#include "../serializer/JsonSerializeFormat.h"
 
 std::map <si32, std::vector<ObjectInstanceID> > CGMagi::eyelist;
 ui8 CGObelisk::obeliskCount = 0; //how many obelisks are on map
@@ -593,59 +594,60 @@ void CGCreature::giveReward(const CGHeroInstance * h) const
 	}
 }
 
-static const std::string CHARACTER_JSON [] =
+static const std::vector<std::string> CHARACTER_JSON  =
 {
 	"compliant", "friendly", "aggressive", "hostile", "savage"
 };
 
-void CGCreature::writeJsonOptions(JsonNode& json) const
+void CGCreature::serializeJsonOptions(JsonSerializeFormat & handler)
 {
-	assert(vstd::iswithin(character, 0, 4));
-	json["character"].String() = CHARACTER_JSON[character];
+	handler.serializeNumericEnum("character", CHARACTER_JSON, (si8)0, character);
 
-	if(hasStackAtSlot(SlotID(0)))
+	if(handler.saving)
 	{
-		const auto & sta = getStack(SlotID(0));
-		json["amount"].Float() = sta.count;
+		if(hasStackAtSlot(SlotID(0)))
+		{
+			si32 amount = getStack(SlotID(0)).count;
+			handler.serializeNumeric("amount", amount);
+		}
+
+		if(resources.nonZero())
+		{
+			for(size_t idx = 0; idx < resources.size(); idx++)
+				handler.getCurrent()["rewardResources"][GameConstants::RESOURCE_NAMES[idx]].Float() = resources[idx];
+		}
+
+		auto tmp = (gainedArtifact == ArtifactID(ArtifactID::NONE) ? "" : gainedArtifact.toArtifact()->identifier);
+		handler.serializeString("rewardArtifact", tmp);
 	}
-
-	json["noGrowing"].Bool() = notGrowingTeam;
-	json["neverFlees"].Bool() = neverFlees;
-	json["rewardMessage"].String() = message;
-	json["rewardArtifact"].String() = (gainedArtifact == ArtifactID(ArtifactID::NONE) ? "" : gainedArtifact.toArtifact()->identifier);
-
-	if(resources.nonZero())
+	else
 	{
-		for(size_t idx = 0; idx < resources.size(); idx++)
-			json["rewardResources"][GameConstants::RESOURCE_NAMES[idx]].Float() = resources[idx];
+		si32 amount = 0;
+		handler.serializeNumeric("amount", amount);
+		auto  hlp = new CStackInstance();
+		hlp->count = amount;
+		//type will be set during initialization
+		putStack(SlotID(0), hlp);
+		{
+			TResources tmp(handler.getCurrent()["rewardResources"]);
+			std::swap(tmp,resources);
+		}
+		{
+			gainedArtifact = ArtifactID(ArtifactID::NONE);
+			std::string tmp;
+			handler.serializeString("rewardArtifact", tmp);
+
+			if(tmp != "")
+			{
+				auto artid = VLC->modh->identifiers.getIdentifier("core", "artifact", tmp);
+				if(artid)
+					gainedArtifact = ArtifactID(artid.get());
+			}
+		}
 	}
-}
-
-void CGCreature::readJsonOptions(const JsonNode& json)
-{
-	character = vstd::find_pos(CHARACTER_JSON,json["character"].String());
-	vstd::amin(character, 0);
-
-	auto  hlp = new CStackInstance();
-	hlp->count = json["amount"].Float();
-	//type will be set during initialization
-	putStack(SlotID(0), hlp);
-
-	notGrowingTeam = json["noGrowing"].Bool();
-	neverFlees = json["neverFlees"].Bool();
-	message = json["rewardMessage"].String();
-
-	gainedArtifact = ArtifactID(ArtifactID::NONE);
-
-	if(json["rewardArtifact"].String() != "")
-	{
-		auto artid = VLC->modh->identifiers.getIdentifier("core", "artifact", json["rewardArtifact"].String());
-		if(artid)
-			gainedArtifact = ArtifactID(artid.get());
-	}
-
-	TResources tmp(json["rewardResources"]);
-	std::swap(tmp,resources);
+	handler.serializeBool("noGrowing", notGrowingTeam);
+	handler.serializeBool("neverFlees", neverFlees);
+	handler.serializeString("rewardMessage", message);
 }
 
 //CGMine
@@ -790,71 +792,63 @@ void CGMine::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer) con
 		cb->startBattleI(hero, this);
 }
 
-void CGMine::writeJsonOptions(JsonNode & json) const
+void CGMine::serializeJsonOptions(JsonSerializeFormat & handler)
 {
-	CCreatureSet::writeJson(json["army"]);
+	CCreatureSet::serializeJson(handler, "army");
 
 	if(isAbandoned())
 	{
-		JsonNode & node = json["possibleResources"];
+		auto possibleResources = handler.enterStruct("possibleResources");
 
-		for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
-			if(tempOwner.getNum() & 1<<i)
-			{
-				JsonNode one(JsonNode::DATA_STRING);
-				one.String() = GameConstants::RESOURCE_NAMES[i];
-				node.Vector().push_back(one);
-			}
-	}
-	else
-	{
-		CGObjectInstance::writeOwner(json);
-	}
-}
+		JsonNode & node = handler.getCurrent();
 
-void CGMine::readJsonOptions(const JsonNode & json)
-{
-	CCreatureSet::readJson(json["army"]);
-
-	if(isAbandoned())
-	{
-		const JsonNode & node = json["possibleResources"];
-
-		std::set<int> possibleResources;
-
-		if(node.Vector().size() == 0)
+		if(handler.saving)
 		{
-			//assume all allowed
-			for(int i = (int)Res::WOOD; i < (int) Res::GOLD; i++)
-				possibleResources.insert(i);
+			for(int i = 0; i < PlayerColor::PLAYER_LIMIT_I; i++)
+				if(tempOwner.getNum() & 1<<i)
+				{
+					JsonNode one(JsonNode::DATA_STRING);
+					one.String() = GameConstants::RESOURCE_NAMES[i];
+					node.Vector().push_back(one);
+				}
 		}
 		else
 		{
-            auto names = node.convertTo<std::vector<std::string>>();
+			std::set<int> possibleResources;
 
-            for(const std::string & s : names)
+			if(node.Vector().size() == 0)
 			{
-                int raw_res = vstd::find_pos(GameConstants::RESOURCE_NAMES, s);
-                if(raw_res < 0)
-					logGlobal->errorStream() << "Invalid resource name: "+s;
-				else
-					possibleResources.insert(raw_res);
+				//assume all allowed
+				for(int i = (int)Res::WOOD; i < (int) Res::GOLD; i++)
+					possibleResources.insert(i);
 			}
+			else
+			{
+				auto names = node.convertTo<std::vector<std::string>>();
 
-			int tmp = 0;
+				for(const std::string & s : names)
+				{
+					int raw_res = vstd::find_pos(GameConstants::RESOURCE_NAMES, s);
+					if(raw_res < 0)
+						logGlobal->errorStream() << "Invalid resource name: "+s;
+					else
+						possibleResources.insert(raw_res);
+				}
 
-			for(int r : possibleResources)
-				tmp |=  (1<<r);
-			tempOwner = PlayerColor(tmp);
+				int tmp = 0;
+
+				for(int r : possibleResources)
+					tmp |=  (1<<r);
+				tempOwner = PlayerColor(tmp);
+			}
 		}
 	}
 	else
 	{
-		CGObjectInstance::readOwner(json);
+		serializeJsonOwner(handler);
 	}
 }
 
-
 std::string CGResource::getHoverText(PlayerColor player) const
 {
 	return VLC->generaltexth->restypes[subID];
@@ -939,18 +933,11 @@ void CGResource::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer)
 		cb->startBattleI(hero, this);
 }
 
-void CGResource::writeJsonOptions(JsonNode& json) const
+void CGResource::serializeJsonOptions(JsonSerializeFormat & handler)
 {
-	CCreatureSet::writeJson(json["guards"]);
-	json["amount"].Float() = amount;
-	json["guardMessage"].String() = message;
-}
-
-void CGResource::readJsonOptions(const JsonNode& json)
-{
-	CCreatureSet::readJson(json["guards"]);
-	amount = json["amount"].Float();
-	message = json["guardMessage"].String();
+	CCreatureSet::serializeJson(handler, "guards");
+	handler.serializeNumeric("amount", amount);
+	handler.serializeString("guardMessage", message);
 }
 
 CGTeleport::CGTeleport() :
@@ -1439,25 +1426,21 @@ void CGArtifact::blockingDialogAnswered(const CGHeroInstance *hero, ui32 answer)
 		cb->startBattleI(hero, this);
 }
 
-void CGArtifact::writeJsonOptions(JsonNode& json) const
+void CGArtifact::serializeJsonOptions(JsonSerializeFormat& handler)
 {
-	CCreatureSet::writeJson(json["guards"]);
-	json["guardMessage"].String() = message;
-	if(ID == Obj::SPELL_SCROLL)
+	handler.serializeString("guardMessage", message);
+	CCreatureSet::serializeJson(handler, "guards");
+
+	if(handler.saving && ID == Obj::SPELL_SCROLL)
 	{
 		const Bonus * b = storedArtifact->getBonusLocalFirst(Selector::type(Bonus::SPELL));
 		SpellID spellId(b->subtype);
 
-		json["spell"].String() = SpellID(b->subtype).toSpell()->identifier;
+		std::string spell = SpellID(b->subtype).toSpell()->identifier;
+		handler.serializeString("spell", spell);
 	}
 }
 
-void CGArtifact::readJsonOptions(const JsonNode& json)
-{
-	CCreatureSet::readJson(json["guards"]);
-	message = json["guardMessage"].String();
-}
-
 void CGWitchHut::initObj()
 {
 	if (allowedAbilities.empty()) //this can happen for RMG. regular maps load abilities from map file
@@ -1515,17 +1498,11 @@ std::string CGWitchHut::getHoverText(const CGHeroInstance * hero) const
 	return hoverName;
 }
 
-void CGWitchHut::writeJsonOptions(JsonNode& json) const
+void CGWitchHut::serializeJsonOptions(JsonSerializeFormat & handler)
 {
-
+	//todo:CGWitchHut::serializeJsonOptions
 }
 
-void CGWitchHut::readJsonOptions(const JsonNode& json)
-{
-
-}
-
-
 void CGMagicWell::onHeroVisit( const CGHeroInstance * h ) const
 {
 	int message;
@@ -1665,23 +1642,9 @@ std::string CGShrine::getHoverText(const CGHeroInstance * hero) const
 	return hoverName;
 }
 
-void CGShrine::writeJsonOptions(JsonNode& json) const
+void CGShrine::serializeJsonOptions(JsonSerializeFormat& handler)
 {
-	if(spell != SpellID::NONE)
-	{
-		json["spell"].String() = spell.toSpell()->identifier;
-	}
-}
-
-void CGShrine::readJsonOptions(const JsonNode& json)
-{
-	spell = SpellID::NONE;
-	if(json["spell"].String() != "")
-	{
-		auto raw = VLC->modh->identifiers.getIdentifier("core", "spell",json["spell"].String());
-		if(raw)
-			spell = SpellID(raw.get());
-	}
+	handler.serializeId("spell", &CSpellHandler::decodeSpell, &CSpellHandler::encodeSpell, SpellID(SpellID::NONE), spell);
 }
 
 void CGSignBottle::initObj()
@@ -1710,14 +1673,9 @@ void CGSignBottle::onHeroVisit( const CGHeroInstance * h ) const
 		cb->removeObject(this);
 }
 
-void CGSignBottle::writeJsonOptions(JsonNode& json) const
+void CGSignBottle::serializeJsonOptions(JsonSerializeFormat& handler)
 {
-	json["text"].String() = message;
-}
-
-void CGSignBottle::readJsonOptions(const JsonNode& json)
-{
-	message = json["text"].String();
+	handler.serializeString("text", message);
 }
 
 void CGScholar::onHeroVisit( const CGHeroInstance * h ) const
@@ -1793,52 +1751,55 @@ void CGScholar::initObj()
 	}
 }
 
-void CGScholar::writeJsonOptions(JsonNode& json) const
+void CGScholar::serializeJsonOptions(JsonSerializeFormat & handler)
 {
-	switch(bonusType)
+	JsonNode& json = handler.getCurrent();
+	if(handler.saving)
 	{
-	case PRIM_SKILL:
-		json["rewardPrimSkill"].String() = PrimarySkill::names[bonusID];
-		break;
-	case SECONDARY_SKILL:
-		json["rewardSkill"].String() = NSecondarySkill::names[bonusID];
-		break;
-	case SPELL:
-		json["rewardSpell"].String() = VLC->spellh->objects.at(bonusID)->identifier;
-		break;
-	case RANDOM:
-		break;
-	}
-}
-
-void CGScholar::readJsonOptions(const JsonNode& json)
-{
-	bonusType = RANDOM;
-	if(json["rewardPrimSkill"].String() != "")
-	{
-		auto raw = VLC->modh->identifiers.getIdentifier("core", "primSkill", json["rewardPrimSkill"].String());
-		if(raw)
+		switch(bonusType)
 		{
-			bonusType = PRIM_SKILL;
-			bonusID = raw.get();
+		case PRIM_SKILL:
+			json["rewardPrimSkill"].String() = PrimarySkill::names[bonusID];
+			break;
+		case SECONDARY_SKILL:
+			json["rewardSkill"].String() = NSecondarySkill::names[bonusID];
+			break;
+		case SPELL:
+			json["rewardSpell"].String() = VLC->spellh->objects.at(bonusID)->identifier;
+			break;
+		case RANDOM:
+			break;
 		}
 	}
-	else if(json["rewardSkill"].String() != "")
+	else
 	{
-		auto raw = VLC->modh->identifiers.getIdentifier("core", "skill", json["rewardSkill"].String());
-		if(raw)
+		bonusType = RANDOM;
+		if(json["rewardPrimSkill"].String() != "")
 		{
-			bonusType = SECONDARY_SKILL;
-			bonusID = raw.get();
+			auto raw = VLC->modh->identifiers.getIdentifier("core", "primSkill", json["rewardPrimSkill"].String());
+			if(raw)
+			{
+				bonusType = PRIM_SKILL;
+				bonusID = raw.get();
+			}
 		}
-	}
-	else if(json["rewardSpell"].String() != "")
-	{
-		auto raw = VLC->modh->identifiers.getIdentifier("core", "spell", json["rewardSpell"].String());
-		if(raw)
+		else if(json["rewardSkill"].String() != "")
 		{
-			bonusType = SPELL;
-			bonusID = raw.get();
+			auto raw = VLC->modh->identifiers.getIdentifier("core", "skill", json["rewardSkill"].String());
+			if(raw)
+			{
+				bonusType = SECONDARY_SKILL;
+				bonusID = raw.get();
+			}
+		}
+		else if(json["rewardSpell"].String() != "")
+		{
+			auto raw = VLC->modh->identifiers.getIdentifier("core", "spell", json["rewardSpell"].String());
+			if(raw)
+			{
+				bonusType = SPELL;
+				bonusID = raw.get();
+			}
 		}
 	}
 }
@@ -1879,18 +1840,11 @@ void CGGarrison::battleFinished(const CGHeroInstance *hero, const BattleResult &
 		onHeroVisit(hero);
 }
 
-void CGGarrison::writeJsonOptions(JsonNode& json) const
+void CGGarrison::serializeJsonOptions(JsonSerializeFormat& handler)
 {
-	CCreatureSet::writeJson(json["army"]);
-	CGObjectInstance::writeOwner(json);
-	json["removableUnits"].Bool() = removableUnits;
-}
-
-void CGGarrison::readJsonOptions(const JsonNode& json)
-{
-	CCreatureSet::readJson(json["army"]);
-	CGObjectInstance::readOwner(json);
-	removableUnits = json["removableUnits"].Bool();
+	handler.serializeBool("removableUnits", removableUnits);
+	serializeJsonOwner(handler);
+	CCreatureSet::serializeJson(handler, "army");
 }
 
 void CGMagi::initObj()
@@ -2030,14 +1984,9 @@ void CGShipyard::onHeroVisit( const CGHeroInstance * h ) const
 	}
 }
 
-void CGShipyard::writeJsonOptions(JsonNode& json) const
+void CGShipyard::serializeJsonOptions(JsonSerializeFormat& handler)
 {
-	CGObjectInstance::writeOwner(json);
-}
-
-void CGShipyard::readJsonOptions(const JsonNode& json)
-{
-	CGObjectInstance::readOwner(json);
+	serializeJsonOwner(handler);
 }
 
 void CCartographer::onHeroVisit( const CGHeroInstance * h ) const
@@ -2222,12 +2171,7 @@ void CGLighthouse::giveBonusTo( PlayerColor player ) const
 	cb->sendAndApply(&gb);
 }
 
-void CGLighthouse::writeJsonOptions(JsonNode& json) const
+void CGLighthouse::serializeJsonOptions(JsonSerializeFormat& handler)
 {
-	CGObjectInstance::writeOwner(json);
-}
-
-void CGLighthouse::readJsonOptions(const JsonNode& json)
-{
-	CGObjectInstance::readOwner(json);
+	serializeJsonOwner(handler);
 }
diff --git a/lib/mapObjects/MiscObjects.h b/lib/mapObjects/MiscObjects.h
index 22f9695ee..582d3db9e 100644
--- a/lib/mapObjects/MiscObjects.h
+++ b/lib/mapObjects/MiscObjects.h
@@ -86,11 +86,9 @@ public:
 	}
 protected:
 	void setPropertyDer(ui8 what, ui32 val) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
 private:
-
 	void fight(const CGHeroInstance *h) const;
 	void flee( const CGHeroInstance * h ) const;
 	void fleeDecision(const CGHeroInstance *h, ui32 pursue) const;
@@ -101,7 +99,6 @@ private:
 
 };
 
-
 class DLL_LINKAGE CGSignBottle : public CGObjectInstance //signs and ocean bottles
 {
 public:
@@ -116,8 +113,7 @@ public:
 		h & message;
 	}
 protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 };
 
 class DLL_LINKAGE CGWitchHut : public CPlayersVisited
@@ -136,8 +132,7 @@ public:
 		h & allowedAbilities & ability;
 	}
 protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 };
 
 class DLL_LINKAGE CGScholar : public CGObjectInstance
@@ -156,8 +151,7 @@ public:
 		h & bonusType & bonusID;
 	}
 protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 };
 
 class DLL_LINKAGE CGGarrison : public CArmedInstance
@@ -175,8 +169,7 @@ public:
 		h & removableUnits;
 	}
 protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 };
 
 class DLL_LINKAGE CGArtifact : public CArmedInstance
@@ -202,8 +195,7 @@ public:
 		h & message & storedArtifact;
 	}
 protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 };
 
 class DLL_LINKAGE CGResource : public CArmedInstance
@@ -227,8 +219,7 @@ public:
 		h & amount & message;
 	}
 protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 };
 
 class DLL_LINKAGE CGShrine : public CPlayersVisited
@@ -246,8 +237,7 @@ public:
 		h & spell;
 	}
 protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 };
 
 class DLL_LINKAGE CGMine : public CArmedInstance
@@ -277,8 +267,7 @@ public:
 	}
 	ui32 defaultResProduction();
 protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 };
 
 struct DLL_LINKAGE TeleportChannel
@@ -444,8 +433,7 @@ public:
 		h & static_cast<IShipyard&>(*this);
 	}
 protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 };
 
 class DLL_LINKAGE CGMagi : public CGObjectInstance
@@ -462,8 +450,6 @@ public:
 	}
 };
 
-
-
 class DLL_LINKAGE CCartographer : public CPlayersVisited
 {
 ///behaviour varies depending on surface and  floor
@@ -515,6 +501,5 @@ public:
 	}
 	void giveBonusTo( PlayerColor player ) const;
 protected:
-	void writeJsonOptions(JsonNode & json) const override;
-	void readJsonOptions(const JsonNode & json) override;
+	void serializeJsonOptions(JsonSerializeFormat & handler) override;
 };
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 22d508db0..17f8680f5 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -525,7 +525,7 @@ std::unique_ptr<CMapHeader> CMapLoaderJson::loadMapHeader()
 	return std::move(result);
 }
 
-const JsonNode CMapLoaderJson::getFromArchive(const std::string & archiveFilename)
+JsonNode CMapLoaderJson::getFromArchive(const std::string & archiveFilename)
 {
 	ResourceID resource(archiveFilename, EResType::TEXT);
 
@@ -747,7 +747,7 @@ void CMapLoaderJson::readTerrain()
 
 }
 
-CMapLoaderJson::MapObjectLoader::MapObjectLoader(CMapLoaderJson * _owner, const JsonMap::value_type& json):
+CMapLoaderJson::MapObjectLoader::MapObjectLoader(CMapLoaderJson * _owner, JsonMap::value_type& json):
 	owner(_owner), instance(nullptr),id(-1), jsonKey(json.first), configuration(json.second), internalId(extractNumber(jsonKey, '_'))
 {
 
@@ -797,7 +797,9 @@ void CMapLoaderJson::MapObjectLoader::configure()
 	if(nullptr == instance)
 		return;
 
-	instance->readJson(configuration);
+	JsonDeserializer handler(configuration);
+
+	instance->serializeJson(handler);
 
 	if(instance->ID == Obj::TOWN)
 	{
@@ -841,10 +843,10 @@ void CMapLoaderJson::readObjects()
 
 	std::vector<std::unique_ptr<MapObjectLoader>> loaders;//todo: optimize MapObjectLoader memory layout
 
-	const JsonNode data = getFromArchive(OBJECTS_FILE_NAME);
+	JsonNode data = getFromArchive(OBJECTS_FILE_NAME);
 
 	//get raw data
-	for(const auto & p : data.Struct())
+	for(auto & p : data.Struct())
 		loaders.push_back(vstd::make_unique<MapObjectLoader>(this, p));
 
 	auto sortInfos = [](const std::unique_ptr<MapObjectLoader> & lhs, const std::unique_ptr<MapObjectLoader> & rhs) -> bool
@@ -993,8 +995,14 @@ void CMapSaverJson::writeObjects()
 {
 	JsonNode data(JsonNode::DATA_STRUCT);
 
-	for(const CGObjectInstance * obj : map->objects)
-		obj->writeJson(data[obj->getStringId()]);
+	JsonSerializer handler(data);
+
+	for(CGObjectInstance * obj : map->objects)
+	{
+		auto temp = handler.enterStruct(obj->getStringId());
+
+		obj->serializeJson(handler);
+	}
 
 	if(map->grailPos.valid())
 	{
@@ -1010,7 +1018,6 @@ void CMapSaverJson::writeObjects()
 		std::string grailId = boost::str(boost::format("grail_%d") % map->objects.size());
 
 		data[grailId] = grail;
-
 	}
 
 	addToArchive(data, OBJECTS_FILE_NAME);
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 4e8f185dc..17d8b2a31 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -159,12 +159,12 @@ private:
 
 	struct MapObjectLoader
 	{
-		MapObjectLoader(CMapLoaderJson * _owner, const JsonMap::value_type & json);
+		MapObjectLoader(CMapLoaderJson * _owner, JsonMap::value_type & json);
 		CMapLoaderJson * owner;
 		CGObjectInstance * instance;
 		ObjectInstanceID id;
 		std::string jsonKey;//full id defined by map creator
-		const JsonNode & configuration;
+		JsonNode & configuration;
 		si32 internalId;//unique part of id defined by map creator (also = quest identifier)
 		///constructs object (without configuration)
 		void construct();
@@ -197,7 +197,7 @@ private:
 	 */
 	void readObjects();
 
-	const JsonNode getFromArchive(const std::string & archiveFilename);
+	JsonNode getFromArchive(const std::string & archiveFilename);
 
 	CInputStream * buffer;
 	std::shared_ptr<CIOApi> ioApi;
diff --git a/lib/serializer/JsonDeserializer.cpp b/lib/serializer/JsonDeserializer.cpp
index 518758129..72af19bb0 100644
--- a/lib/serializer/JsonDeserializer.cpp
+++ b/lib/serializer/JsonDeserializer.cpp
@@ -48,6 +48,24 @@ void JsonDeserializer::serializeIntEnum(const std::string & fieldName, const std
 		value = rawValue;
 }
 
+void JsonDeserializer::serializeIntId(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const si32 defaultValue, si32 & value)
+{
+	std::string identifier;
+	serializeString(fieldName, identifier);
+
+	if(identifier == "")
+	{
+		value = defaultValue;
+		return;
+	}
+
+	si32 rawId = decoder(identifier);
+	if(rawId >= 0)
+		value = rawId;
+	else
+		value = defaultValue;
+}
+
 void JsonDeserializer::serializeLIC(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const std::vector<bool> & standard, std::vector<bool> & value)
 {
 	const JsonNode & field = current->operator[](fieldName);
diff --git a/lib/serializer/JsonDeserializer.h b/lib/serializer/JsonDeserializer.h
index b05c9582a..2130b3812 100644
--- a/lib/serializer/JsonDeserializer.h
+++ b/lib/serializer/JsonDeserializer.h
@@ -27,4 +27,5 @@ public:
 protected:
 	void serializeFloat(const std::string & fieldName, double & value) override;
 	void serializeIntEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const si32 defaultValue, si32 & value) override;
+	void serializeIntId(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const si32 defaultValue, si32 & value) override;
 };
diff --git a/lib/serializer/JsonSerializeFormat.h b/lib/serializer/JsonSerializeFormat.h
index 6b84308de..424f2d9aa 100644
--- a/lib/serializer/JsonSerializeFormat.h
+++ b/lib/serializer/JsonSerializeFormat.h
@@ -98,6 +98,16 @@ public:
 
 	virtual void serializeString(const std::string & fieldName, std::string & value) = 0;
 
+	template <typename T>
+	void serializeId(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const T & defaultValue, T & value)
+	{
+		const si32 tempDefault = defaultValue.num;
+		si32 tempValue = value.num;
+		serializeIntId(fieldName, decoder, encoder, tempDefault, tempValue);
+		if(!saving)
+			value = T(tempValue);
+	}
+
 protected:
 	JsonNode * root;
 	JsonNode * current;
@@ -107,6 +117,8 @@ protected:
 	virtual void serializeFloat(const std::string & fieldName, double & value) = 0;
 
 	virtual void serializeIntEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const si32 defaultValue, si32 & value) = 0;
+
+	virtual void serializeIntId(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const si32 defaultValue, si32 & value) = 0;
 private:
 	friend class JsonStructSerializer;
 };
diff --git a/lib/serializer/JsonSerializer.cpp b/lib/serializer/JsonSerializer.cpp
index 8fff1f7af..e0b339487 100644
--- a/lib/serializer/JsonSerializer.cpp
+++ b/lib/serializer/JsonSerializer.cpp
@@ -40,6 +40,15 @@ void JsonSerializer::serializeIntEnum(const std::string & fieldName, const std::
 	current->operator[](fieldName).String() = enumMap.at(value);
 }
 
+void JsonSerializer::serializeIntId(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const si32 defaultValue, si32& value)
+{
+	if(defaultValue == value)
+		return;
+
+	std::string identifier = encoder(value);
+	serializeString(fieldName, identifier);
+}
+
 void JsonSerializer::serializeLIC(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const std::vector<bool> & standard, std::vector<bool> & value)
 {
 	assert(standard.size() == value.size());
diff --git a/lib/serializer/JsonSerializer.h b/lib/serializer/JsonSerializer.h
index 6eca2cce0..ad19fe782 100644
--- a/lib/serializer/JsonSerializer.h
+++ b/lib/serializer/JsonSerializer.h
@@ -27,4 +27,5 @@ public:
 protected:
 	void serializeFloat(const std::string & fieldName, double & value) override;
 	void serializeIntEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const si32 defaultValue, si32 & value) override;
+	void serializeIntId(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const si32 defaultValue, si32 & value) override;
 };

From 939e0128fd7d4dad1a3507c07ed54e8979f743ec Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 22 Feb 2016 02:50:06 +0300
Subject: [PATCH 087/105] Do not save default json values

---
 lib/serializer/JsonSerializer.cpp | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/lib/serializer/JsonSerializer.cpp b/lib/serializer/JsonSerializer.cpp
index e0b339487..8f4d37640 100644
--- a/lib/serializer/JsonSerializer.cpp
+++ b/lib/serializer/JsonSerializer.cpp
@@ -22,7 +22,8 @@ JsonSerializer::JsonSerializer(JsonNode & root_):
 
 void JsonSerializer::serializeBool(const std::string & fieldName, bool & value)
 {
-	current->operator[](fieldName).Bool() = value;
+	if(value)
+		current->operator[](fieldName).Bool() = true;
 }
 
 void JsonSerializer::serializeBoolEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value)
@@ -32,21 +33,23 @@ void JsonSerializer::serializeBoolEnum(const std::string & fieldName, const std:
 
 void JsonSerializer::serializeFloat(const std::string & fieldName, double & value)
 {
-	current->operator[](fieldName).Float() = value;
+	if(value != 0)
+		current->operator[](fieldName).Float() = value;
 }
 
 void JsonSerializer::serializeIntEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const si32 defaultValue, si32 & value)
 {
-	current->operator[](fieldName).String() = enumMap.at(value);
+	if(defaultValue != value)
+		current->operator[](fieldName).String() = enumMap.at(value);
 }
 
-void JsonSerializer::serializeIntId(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const si32 defaultValue, si32& value)
+void JsonSerializer::serializeIntId(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const si32 defaultValue, si32 & value)
 {
-	if(defaultValue == value)
-		return;
-
-	std::string identifier = encoder(value);
-	serializeString(fieldName, identifier);
+	if(defaultValue != value)
+	{
+		std::string identifier = encoder(value);
+		serializeString(fieldName, identifier);
+	}
 }
 
 void JsonSerializer::serializeLIC(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const std::vector<bool> & standard, std::vector<bool> & value)
@@ -66,9 +69,9 @@ void JsonSerializer::serializeLIC(const std::string & fieldName, const TDecoder
 	}
 }
 
-
 void JsonSerializer::serializeString(const std::string & fieldName, std::string & value)
 {
-	current->operator[](fieldName).String() = value;
+	if(value != "")
+		current->operator[](fieldName).String() = value;
 }
 

From 51bee1000b03b22212c8ac8e65ab89240533a3eb Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 22 Feb 2016 03:16:33 +0300
Subject: [PATCH 088/105] Implemented CGWitchHut::serializeJsonOptions

---
 lib/mapObjects/MiscObjects.cpp | 26 ++++++++++++++++++++++++--
 lib/mapping/MapFormatJson.cpp  |  1 -
 2 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/lib/mapObjects/MiscObjects.cpp b/lib/mapObjects/MiscObjects.cpp
index dce89f71f..ea7e345cc 100644
--- a/lib/mapObjects/MiscObjects.cpp
+++ b/lib/mapObjects/MiscObjects.cpp
@@ -16,7 +16,7 @@
 #include "../CGeneralTextHandler.h"
 #include "../CSoundBase.h"
 #include "../CModHandler.h"
-
+#include "../CHeroHandler.h"
 #include "CObjectClassesHandler.h"
 #include "../spells/CSpellHandler.h"
 #include "../IGameCallback.h"
@@ -1500,7 +1500,29 @@ std::string CGWitchHut::getHoverText(const CGHeroInstance * hero) const
 
 void CGWitchHut::serializeJsonOptions(JsonSerializeFormat & handler)
 {
-	//todo:CGWitchHut::serializeJsonOptions
+	//TODO: unify allowed abilities with others - make them std::vector<bool>
+
+	std::vector<bool> temp;
+	temp.resize(GameConstants::SKILL_QUANTITY, false);
+
+	auto standard = VLC->heroh->getDefaultAllowedAbilities(); //todo: for WitchHut default is all except Leadership and Necromancy
+
+    if(handler.saving)
+	{
+		for(si32 i = 0; i < GameConstants::SKILL_QUANTITY; ++i)
+			if(vstd::contains(allowedAbilities, i))
+				temp[i] = true;
+	}
+
+	handler.serializeLIC("allowedSkills", &CHeroHandler::decodeSkill, &CHeroHandler::encodeSkill, standard, temp);
+
+	if(!handler.saving)
+	{
+		allowedAbilities.clear();
+		for (si32 i=0; i<temp.size(); i++)
+			if(temp[i])
+				allowedAbilities.push_back(i);
+	}
 }
 
 void CGMagicWell::onHeroVisit( const CGHeroInstance * h ) const
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 17f8680f5..c610a6b75 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -539,7 +539,6 @@ JsonNode CMapLoaderJson::getFromArchive(const std::string & archiveFilename)
 	return std::move(res);
 }
 
-
 void CMapLoaderJson::readMap()
 {
 	LOG_TRACE(logGlobal);

From 64cb0267a31ec34d56ceb1f170e1dfb824f787bd Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 22 Feb 2016 03:22:10 +0300
Subject: [PATCH 089/105] Do not save "visitableFrom" if object do not have
 active tiles.

---
 lib/mapObjects/ObjectTemplate.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/mapObjects/ObjectTemplate.cpp b/lib/mapObjects/ObjectTemplate.cpp
index 0f3a9349c..57e55eb7c 100644
--- a/lib/mapObjects/ObjectTemplate.cpp
+++ b/lib/mapObjects/ObjectTemplate.cpp
@@ -263,7 +263,7 @@ void ObjectTemplate::writeJson(JsonNode & node, const bool withTerrain) const
 {
 	node["animation"].String() = animationFile;
 
-	if(visitDir != 0x0)
+	if(visitDir != 0x0 && isVisitable())
 	{
 		JsonVector & visitDirs = node["visitableFrom"].Vector();
 		visitDirs.resize(3);

From ac281f3fec691b5a38844ea8d5702318b70a2fe9 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 22 Feb 2016 04:53:14 +0300
Subject: [PATCH 090/105] Tweaks

---
 lib/mapObjects/CObjectHandler.cpp | 1 -
 lib/mapObjects/CObjectHandler.h   | 2 +-
 lib/mapping/MapFormatJson.cpp     | 9 +++++++--
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 7742eccb2..8ec171506 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -141,7 +141,6 @@ CGObjectInstance::~CGObjectInstance()
 
 const std::string & CGObjectInstance::getStringId() const
 {
-	//todo: getStringId use real object type
 	if(stringId == "")
 	{
 		boost::format fmt("%s_%d");
diff --git a/lib/mapObjects/CObjectHandler.h b/lib/mapObjects/CObjectHandler.h
index d417f4763..2bb665ee5 100644
--- a/lib/mapObjects/CObjectHandler.h
+++ b/lib/mapObjects/CObjectHandler.h
@@ -186,7 +186,7 @@ public:
 		}
 	}
 
-	///Entry point of Json serialization
+	///Entry point of Json (de-)serialization
 	void serializeJson(JsonSerializeFormat & handler);
 
 protected:
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index c610a6b75..98bc84c27 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -762,7 +762,7 @@ void CMapLoaderJson::MapObjectLoader::construct()
 	if(typeName.empty())
 	{
 		logGlobal->errorStream() << "Object type missing";
-		logGlobal->traceStream() << configuration;
+		logGlobal->debugStream() << configuration;
 		return;
 	}
 
@@ -780,7 +780,7 @@ void CMapLoaderJson::MapObjectLoader::construct()
 	else if(subTypeName.empty())
 	{
 		logGlobal->errorStream() << "Object subType missing";
-		logGlobal->traceStream() << configuration;
+		logGlobal->debugStream() << configuration;
 		return;
 	}
 
@@ -861,6 +861,11 @@ void CMapLoaderJson::readObjects()
 	//configure objects after all objects are constructed so we may resolve internal IDs even to actual pointers OTF
 	for(auto & ptr : loaders)
 		ptr->configure();
+
+	std::sort(map->heroesOnMap.begin(), map->heroesOnMap.end(), [](const ConstTransitivePtr<CGHeroInstance> & a, const ConstTransitivePtr<CGHeroInstance> & b)
+	{
+		return a->subID < b->subID;
+	});
 }
 
 ///CMapSaverJson

From dc5ad7d7b31ba9bb9dab298a5cc5192e6a26e072 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 22 Feb 2016 19:26:42 +0300
Subject: [PATCH 091/105] Make string instance names persistent

---
 lib/NetPacksLib.cpp               |  3 ++-
 lib/mapObjects/CObjectHandler.cpp | 12 ---------
 lib/mapObjects/CObjectHandler.h   | 14 ++++------
 lib/mapping/CMap.cpp              | 26 ++++++++++++++++++
 lib/mapping/CMap.h                |  8 ++++++
 lib/mapping/CMapEditManager.cpp   | 16 +++++------
 lib/mapping/MapFormatH3M.cpp      | 16 +++++------
 lib/mapping/MapFormatJson.cpp     | 45 ++++---------------------------
 lib/mapping/MapFormatJson.h       |  2 +-
 test/MapComparer.cpp              | 28 ++++++++++++++-----
 10 files changed, 83 insertions(+), 87 deletions(-)

diff --git a/lib/NetPacksLib.cpp b/lib/NetPacksLib.cpp
index 1283d7350..54254be11 100644
--- a/lib/NetPacksLib.cpp
+++ b/lib/NetPacksLib.cpp
@@ -386,6 +386,7 @@ DLL_LINKAGE void RemoveObject::applyGs( CGameState *gs )
 		//If hero on Boat is removed, the Boat disappears
 		if(h->boat)
 		{
+			gs->map->instanceNames.erase(h->boat->instanceName);
 			gs->map->objects[h->boat->id.getNum()].dellNull();
 			h->boat = nullptr;
 		}
@@ -430,7 +431,7 @@ DLL_LINKAGE void RemoveObject::applyGs( CGameState *gs )
 		};
 		event.trigger = event.trigger.morph(patcher);
 	}
-
+	gs->map->instanceNames.erase(obj->instanceName);
 	gs->map->objects[id.getNum()].dellNull();
 	gs->map->calculateGuardingGreaturePositions();
 }
diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 8ec171506..02ad308bc 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -139,18 +139,6 @@ CGObjectInstance::~CGObjectInstance()
 {
 }
 
-const std::string & CGObjectInstance::getStringId() const
-{
-	if(stringId == "")
-	{
-		boost::format fmt("%s_%d");
-		fmt % typeName % id.getNum();
-		stringId = fmt.str();
-	}
-
-	return stringId;
-}
-
 void CGObjectInstance::setOwner(PlayerColor ow)
 {
 	tempOwner = ow;
diff --git a/lib/mapObjects/CObjectHandler.h b/lib/mapObjects/CObjectHandler.h
index 2bb665ee5..0c18f97d1 100644
--- a/lib/mapObjects/CObjectHandler.h
+++ b/lib/mapObjects/CObjectHandler.h
@@ -118,14 +118,13 @@ public:
 	/// If true hero can visit this object only from neighbouring tiles and can't stand on this object
 	bool blockVisit;
 
+	std::string instanceName;
 	std::string typeName;
 	std::string subTypeName;
 
 	CGObjectInstance();
 	~CGObjectInstance();
 
-	const std::string & getStringId() const;
-
 	/// "center" tile from which the sight distance is calculated
 	int3 getSightCenter() const;
 
@@ -177,13 +176,13 @@ public:
 	///Entry point of binary (de-)serialization
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
-		h & pos & ID & subID & id & tempOwner & blockVisit & appearance;
-		//definfo is handled by map serializer
-
 		if(version >= 759)
 		{
-			h & typeName & subTypeName;
+			h & instanceName & typeName & subTypeName;
 		}
+
+		h & pos & ID & subID & id & tempOwner & blockVisit & appearance;
+		//definfo is handled by map serializer
 	}
 
 	///Entry point of Json (de-)serialization
@@ -200,9 +199,6 @@ protected:
 	virtual void serializeJsonOptions(JsonSerializeFormat & handler);
 
 	void serializeJsonOwner(JsonSerializeFormat & handler);
-
-private:
-	mutable std::string stringId;///<alternate id, dynamically generated, do not serialize
 };
 
 /// function object which can be used to find an object with an specific sub ID
diff --git a/lib/mapping/CMap.cpp b/lib/mapping/CMap.cpp
index a127b1eea..459767c45 100644
--- a/lib/mapping/CMap.cpp
+++ b/lib/mapping/CMap.cpp
@@ -558,6 +558,32 @@ void CMap::addQuest(CGObjectInstance * quest)
 	quests.push_back(q->quest);
 }
 
+void CMap::addNewObject(CGObjectInstance * obj)
+{
+    if(obj->id != ObjectInstanceID(objects.size()))
+		throw std::runtime_error("Invalid object instance id");
+
+	if(obj->instanceName == "")
+		throw std::runtime_error("Object instance name missing");
+
+	auto it = instanceNames.find(obj->instanceName);
+	if(it != instanceNames.end())
+		throw std::runtime_error("Object instance name duplicated:"+obj->instanceName);
+
+    objects.push_back(obj);
+    instanceNames[obj->instanceName] = obj;
+    addBlockVisTiles(obj);
+
+	if(obj->ID == Obj::TOWN)
+	{
+		towns.push_back(static_cast<CGTownInstance *>(obj));
+	}
+	if(obj->ID == Obj::HERO)
+	{
+		heroesOnMap.push_back(static_cast<CGHeroInstance*>(obj));
+	}
+}
+
 void CMap::initTerrain()
 {
 	int level = twoLevel ? 2 : 1;
diff --git a/lib/mapping/CMap.h b/lib/mapping/CMap.h
index 979856854..91fbd5cfc 100644
--- a/lib/mapping/CMap.h
+++ b/lib/mapping/CMap.h
@@ -299,6 +299,7 @@ public:
 	void addNewArtifactInstance(CArtifactInstance * art);
 	void eraseArtifactInstance(CArtifactInstance * art);
 	void addQuest(CGObjectInstance * quest);
+	void addNewObject(CGObjectInstance * obj);
 
 	/// Gets object of specified type on requested position
 	const CGObjectInstance * getObjectiveObjectFrom(int3 pos, Obj::EObj type);
@@ -336,6 +337,8 @@ public:
 
 	int3 ***guardingCreaturePositions;
 
+	std::map<std::string, ConstTransitivePtr<CGObjectInstance> > instanceNames;
+
 private:
 	/// a 3-dimensional array of terrain tiles, access is as follows: x, y, level. where level=1 is underground
 	TerrainTile*** terrain;
@@ -403,5 +406,10 @@ public:
 		h & CGObelisk::obeliskCount & CGObelisk::visited;
 		h & CGTownInstance::merchantArtifacts;
 		h & CGTownInstance::universitySkills;
+
+		if(version >= 759)
+		{
+			h & instanceNames;
+		}
 	}
 };
diff --git a/lib/mapping/CMapEditManager.cpp b/lib/mapping/CMapEditManager.cpp
index e82108533..87d15b922 100644
--- a/lib/mapping/CMapEditManager.cpp
+++ b/lib/mapping/CMapEditManager.cpp
@@ -1043,16 +1043,12 @@ void CInsertObjectOperation::execute()
 {
 	obj->pos = pos;
 	obj->id = ObjectInstanceID(map->objects.size());
-	map->objects.push_back(obj);
-	if(obj->ID == Obj::TOWN)
-	{
-		map->towns.push_back(static_cast<CGTownInstance *>(obj));
-	}
-	if(obj->ID == Obj::HERO)
-	{
-		map->heroesOnMap.push_back(static_cast<CGHeroInstance*>(obj));
-	}
-	map->addBlockVisTiles(obj);
+
+	boost::format fmt("%s_%d");
+	fmt % obj->typeName % obj->id.getNum();
+	obj->instanceName = fmt.str();
+
+	map->addNewObject(obj);
 }
 
 void CInsertObjectOperation::undo()
diff --git a/lib/mapping/MapFormatH3M.cpp b/lib/mapping/MapFormatH3M.cpp
index e4f4b8fd7..cbc8cdcd4 100644
--- a/lib/mapping/MapFormatH3M.cpp
+++ b/lib/mapping/MapFormatH3M.cpp
@@ -1459,16 +1459,16 @@ void CMapLoaderH3M::readObjects()
 		}
 		nobj->appearance = objTempl;
 		assert(idToBeGiven == ObjectInstanceID(map->objects.size()));
-		map->objects.push_back(nobj);
-		if(nobj->ID == Obj::TOWN)
+
 		{
-			map->towns.push_back(static_cast<CGTownInstance *>(nobj));
-		}
-		if(nobj->ID == Obj::HERO)
-		{
-			logGlobal->debugStream() << "Hero: " << VLC->heroh->heroes[nobj->subID]->name << " at " << objPos;
-			map->heroesOnMap.push_back(static_cast<CGHeroInstance*>(nobj));
+			//TODO: define valid typeName and subtypeName fro H3M maps
+			//boost::format fmt("%s_%d");
+			//fmt % nobj->typeName % nobj->id.getNum();
+			boost::format fmt("obj_%d");
+			fmt % nobj->id.getNum();
+			nobj->instanceName = fmt.str();
 		}
+		map->addNewObject(nobj);
 	}
 
 	std::sort(map->heroesOnMap.begin(), map->heroesOnMap.end(), [](const ConstTransitivePtr<CGHeroInstance> & a, const ConstTransitivePtr<CGHeroInstance> & b)
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 98bc84c27..55f4ae2e3 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -150,21 +150,6 @@ namespace TerrainDetail
 	};
 }
 
-static std::string tailString(const std::string & input, char separator)
-{
-	std::string ret;
-	size_t splitPos = input.find(separator);
-	if (splitPos != std::string::npos)
-		ret = input.substr(splitPos + 1);
-	return ret;
-}
-
-static si32 extractNumber(const std::string & input, char separator)
-{
-	std::string tmp = tailString(input, separator);
-	return atoi(tmp.c_str());
-}
-
 ///CMapFormatJson
 const int CMapFormatJson::VERSION_MAJOR = 1;
 const int CMapFormatJson::VERSION_MINOR = 0;
@@ -547,11 +532,6 @@ void CMapLoaderJson::readMap()
 	readTerrain();
 	readObjects();
 
-	// Calculate blocked / visitable positions
-	for(auto & elem : map->objects)
-	{
-		map->addBlockVisTiles(elem);
-	}
 	map->calculateGuardingGreaturePositions();
 }
 
@@ -747,7 +727,7 @@ void CMapLoaderJson::readTerrain()
 }
 
 CMapLoaderJson::MapObjectLoader::MapObjectLoader(CMapLoaderJson * _owner, JsonMap::value_type& json):
-	owner(_owner), instance(nullptr),id(-1), jsonKey(json.first), configuration(json.second), internalId(extractNumber(jsonKey, '_'))
+	owner(_owner), instance(nullptr),id(-1), jsonKey(json.first), configuration(json.second)
 {
 
 }
@@ -788,7 +768,8 @@ void CMapLoaderJson::MapObjectLoader::construct()
 
 	instance = handler->create(ObjectTemplate());
 	instance->id = ObjectInstanceID(owner->map->objects.size());
-	owner->map->objects.push_back(instance);
+	instance->instanceName = jsonKey;
+	owner->map->addNewObject(instance);
 }
 
 void CMapLoaderJson::MapObjectLoader::configure()
@@ -800,16 +781,7 @@ void CMapLoaderJson::MapObjectLoader::configure()
 
 	instance->serializeJson(handler);
 
-	if(instance->ID == Obj::TOWN)
-	{
-		owner->map->towns.push_back(static_cast<CGTownInstance *>(instance));
-	}
-	else if(instance->ID == Obj::HERO)
-	{
-		logGlobal->debugStream() << "Hero: " << VLC->heroh->heroes[instance->subID]->name << " at " << instance->pos;
-		owner->map->heroesOnMap.push_back(static_cast<CGHeroInstance *>(instance));
-	}
-	else if(auto art = dynamic_cast<CGArtifact *>(instance))
+	if(auto art = dynamic_cast<CGArtifact *>(instance))
 	{
 		//todo: find better place for this code
 
@@ -848,13 +820,6 @@ void CMapLoaderJson::readObjects()
 	for(auto & p : data.Struct())
 		loaders.push_back(vstd::make_unique<MapObjectLoader>(this, p));
 
-	auto sortInfos = [](const std::unique_ptr<MapObjectLoader> & lhs, const std::unique_ptr<MapObjectLoader> & rhs) -> bool
-	{
-		return lhs->internalId < rhs->internalId;
-	};
-	boost::sort(loaders, sortInfos);//this makes instance ids consistent after save-load, needed for testing
-	//todo: use internalId in CMap
-
 	for(auto & ptr : loaders)
 		ptr->construct();
 
@@ -1003,7 +968,7 @@ void CMapSaverJson::writeObjects()
 
 	for(CGObjectInstance * obj : map->objects)
 	{
-		auto temp = handler.enterStruct(obj->getStringId());
+		auto temp = handler.enterStruct(obj->instanceName);
 
 		obj->serializeJson(handler);
 	}
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 17d8b2a31..0b7f493f3 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -165,7 +165,7 @@ private:
 		ObjectInstanceID id;
 		std::string jsonKey;//full id defined by map creator
 		JsonNode & configuration;
-		si32 internalId;//unique part of id defined by map creator (also = quest identifier)
+
 		///constructs object (without configuration)
 		void construct();
 
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 6aad7881e..175683ebd 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -182,7 +182,7 @@ void MapComparer::compareOptions()
 
 void MapComparer::compareObject(const CGObjectInstance * actual, const CGObjectInstance * expected)
 {
-	BOOST_CHECK_EQUAL(actual->getStringId(), expected->getStringId());
+	BOOST_CHECK_EQUAL(actual->instanceName, expected->instanceName);
 	BOOST_CHECK_EQUAL(typeid(actual).name(), typeid(expected).name());//todo: remove and use just comparison
 
 	std::string actualFullID = boost::to_string(boost::format("%s(%d)|%s(%d) %d") % actual->typeName % actual->ID % actual->subTypeName % actual->subID % actual->tempOwner);
@@ -190,18 +190,34 @@ void MapComparer::compareObject(const CGObjectInstance * actual, const CGObjectI
 
 	BOOST_CHECK_EQUAL(actualFullID, expectedFullID);
 	BOOST_CHECK_EQUAL(actual->pos, expected->pos);
-	//BOOST_CHECK_EQUAL(actual->tempOwner,expected->tempOwner);
+
 }
 
 void MapComparer::compareObjects()
 {
 	BOOST_CHECK_EQUAL(actual->objects.size(), expected->objects.size());
 
-	for(size_t idx = 0; idx < std::min(actual->objects.size(), expected->objects.size()); idx++)
+	for(size_t idx = 0; idx < expected->objects.size(); idx++)
 	{
-		BOOST_REQUIRE_EQUAL(idx, expected->objects[idx]->id.getNum());
-		BOOST_CHECK_EQUAL(idx, actual->objects[idx]->id.getNum());
-		compareObject(actual->objects[idx], expected->objects[idx]);
+		auto expectedObject = expected->objects[idx];
+
+		BOOST_REQUIRE_EQUAL(idx, expectedObject->id.getNum());
+
+		{
+			auto it = expected->instanceNames.find(expectedObject->instanceName);
+
+			BOOST_REQUIRE(it != expected->instanceNames.end());
+		}
+
+		{
+			auto it = actual->instanceNames.find(expectedObject->instanceName);
+
+			BOOST_REQUIRE(it != expected->instanceNames.end());
+
+			auto actualObject = it->second;
+
+			compareObject(actualObject, expectedObject);
+		}
 	}
 }
 

From 4bcfb8c27d0c424b25aec7e15f6ab0067d1ce382 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Mon, 22 Feb 2016 23:43:57 +0300
Subject: [PATCH 092/105] Draft of new Event conditions

---
 lib/mapObjects/CObjectHandler.cpp |  2 +-
 lib/mapping/CMap.cpp              |  2 ++
 lib/mapping/CMap.h                | 19 +++++++++++++++--
 lib/mapping/MapFormatJson.cpp     | 34 +++++++++++++++++++++----------
 lib/mapping/MapFormatJson.h       |  3 +++
 5 files changed, 46 insertions(+), 14 deletions(-)

diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 02ad308bc..21e939030 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -325,7 +325,7 @@ void CGObjectInstance::serializeJson(JsonSerializeFormat & handler)
 	if(handler.saving)
 	{
 		handler.serializeString("type", typeName);
-		handler.serializeString("subType", subTypeName);
+		handler.serializeString("subtype", subTypeName);
 	}
 
 	handler.serializeNumeric("x", pos.x);
diff --git a/lib/mapping/CMap.cpp b/lib/mapping/CMap.cpp
index 459767c45..2857822bb 100644
--- a/lib/mapping/CMap.cpp
+++ b/lib/mapping/CMap.cpp
@@ -63,6 +63,7 @@ EventCondition::EventCondition(EWinLoseType condition):
 	object(nullptr),
 	value(-1),
 	objectType(-1),
+	objectSubtype(-1),
 	position(-1, -1, -1),
 	condition(condition)
 {
@@ -72,6 +73,7 @@ EventCondition::EventCondition(EWinLoseType condition, si32 value, si32 objectTy
 	object(nullptr),
 	value(value),
 	objectType(objectType),
+	objectSubtype(-1),
 	position(position),
 	condition(condition)
 {}
diff --git a/lib/mapping/CMap.h b/lib/mapping/CMap.h
index 91fbd5cfc..19e06a2a8 100644
--- a/lib/mapping/CMap.h
+++ b/lib/mapping/CMap.h
@@ -98,6 +98,7 @@ struct DLL_LINKAGE PlayerInfo
 struct DLL_LINKAGE EventCondition
 {
 	enum EWinLoseType {
+		//internal use, deprecated
 		HAVE_ARTIFACT,     // type - required artifact
 		HAVE_CREATURES,    // type - creatures to collect, value - amount to collect
 		HAVE_RESOURCES,    // type - resource ID, value - amount to collect
@@ -105,19 +106,28 @@ struct DLL_LINKAGE EventCondition
 		CONTROL,           // position - position of object, optional, type - type of object
 		DESTROY,           // position - position of object, optional, type - type of object
 		TRANSPORT,         // position - where artifact should be transported, type - type of artifact
+
+		//map format version pre 1.0
 		DAYS_PASSED,       // value - number of days from start of the game
 		IS_HUMAN,          // value - 0 = player is AI, 1 = player is human
 		DAYS_WITHOUT_TOWN, // value - how long player can live without town, 0=instakill
 		STANDARD_WIN,      // normal defeat all enemies condition
-		CONST_VALUE        // condition that always evaluates to "value" (0 = false, 1 = true)
+		CONST_VALUE,        // condition that always evaluates to "value" (0 = false, 1 = true)
+
+		//map format version 1.0+
+		HAVE_0,
+		HAVE_BUILDING_0,
+		DESTROY_0
 	};
 
 	EventCondition(EWinLoseType condition = STANDARD_WIN);
 	EventCondition(EWinLoseType condition, si32 value, si32 objectType, int3 position = int3(-1, -1, -1));
 
-	const CGObjectInstance * object; // object that was at specified position on start
+	const CGObjectInstance * object; // object that was at specified position or with instance name on start
 	si32 value;
 	si32 objectType;
+	si32 objectSubtype;
+	std::string objectInstanceName;
 	int3 position;
 	EWinLoseType condition;
 
@@ -129,6 +139,11 @@ struct DLL_LINKAGE EventCondition
 		h & objectType;
 		h & position;
 		h & condition;
+		if(version > 759)
+		{
+			h & objectSubtype;
+			h & objectInstanceName;
+		}
 	}
 };
 
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 55f4ae2e3..03e73e49e 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -44,13 +44,16 @@ namespace HeaderDetail
 
 namespace TriggeredEventsDetail
 {
-	static const std::array<std::string, 12> conditionNames =
+	static const std::array<std::string, 15> conditionNames =
 	{
 		"haveArtifact", "haveCreatures",   "haveResources",   "haveBuilding",
 		"control",      "destroy",         "transport",       "daysPassed",
-		"isHuman",      "daysWithoutTown", "standardWin",     "constValue"
+		"isHuman",      "daysWithoutTown", "standardWin",     "constValue",
+
+		"have_0", "haveBuilding_0", "destroy_0"
 	};
 
+
 	static const std::array<std::string, 2> typeNames = { "victory", "defeat" };
 
 	static EventCondition JsonToCondition(const JsonNode & node)
@@ -88,6 +91,12 @@ namespace TriggeredEventsDetail
 				event.position.y = position.at(1).Float();
 				event.position.z = position.at(2).Float();
 			}
+
+//			if(!data["subtype"].isNull())
+//			{
+//				//todo
+//			}
+//			event.objectInstanceName = data["object"].String();
 		}
 		return event;
 	}
@@ -452,7 +461,9 @@ void CMapFormatJson::writeOptions(JsonSerializer & handler)
 CMapPatcher::CMapPatcher(JsonNode stream):
 	input(stream)
 {
-
+	//todo: update map patches and change this
+	fileVersionMajor = 0;
+	fileVersionMinor = 0;
 }
 
 void CMapPatcher::patchMapHeader(std::unique_ptr<CMapHeader> & header)
@@ -540,19 +551,19 @@ void CMapLoaderJson::readHeader(const bool complete)
 	//do not use map field here, use only mapHeader
 	JsonNode header = getFromArchive(HEADER_FILE_NAME);
 
-	int versionMajor = header["versionMajor"].Float();
+	fileVersionMajor = header["versionMajor"].Float();
 
-	if(versionMajor != VERSION_MAJOR)
+	if(fileVersionMajor != VERSION_MAJOR)
 	{
-		logGlobal->errorStream() << "Unsupported map format version: " << versionMajor;
+		logGlobal->errorStream() << "Unsupported map format version: " << fileVersionMajor;
 		throw std::runtime_error("Unsupported map format version");
 	}
 
-	int versionMinor = header["versionMinor"].Float();
+	fileVersionMinor = header["versionMinor"].Float();
 
-	if(versionMinor > VERSION_MINOR)
+	if(fileVersionMinor > VERSION_MINOR)
 	{
-		logGlobal->traceStream() << "Too new map format revision: " << versionMinor << ". This map should work but some of map features may be ignored.";
+		logGlobal->traceStream() << "Too new map format revision: " << fileVersionMinor << ". This map should work but some of map features may be ignored.";
 	}
 
 	JsonDeserializer handler(header);
@@ -759,7 +770,7 @@ void CMapLoaderJson::MapObjectLoader::construct()
 	}
 	else if(subTypeName.empty())
 	{
-		logGlobal->errorStream() << "Object subType missing";
+		logGlobal->errorStream() << "Object subtype missing";
 		logGlobal->debugStream() << configuration;
 		return;
 	}
@@ -839,7 +850,8 @@ CMapSaverJson::CMapSaverJson(CInputOutputStream * stream):
 	ioApi(new CProxyIOApi(buffer)),
 	saver(ioApi, "_")
 {
-
+	fileVersionMajor = VERSION_MAJOR;
+	fileVersionMinor = VERSION_MINOR;
 }
 
 CMapSaverJson::~CMapSaverJson()
diff --git a/lib/mapping/MapFormatJson.h b/lib/mapping/MapFormatJson.h
index 0b7f493f3..4930c5654 100644
--- a/lib/mapping/MapFormatJson.h
+++ b/lib/mapping/MapFormatJson.h
@@ -35,6 +35,9 @@ public:
 
 	static const std::string HEADER_FILE_NAME;
 	static const std::string OBJECTS_FILE_NAME;
+
+	int fileVersionMajor;
+	int fileVersionMinor;
 protected:
 
 	/** ptr to the map object which gets filled by data from the buffer or written to buffer */

From 8ed6aa762b1a31a666f9c54ad23f3b62eefe42d5 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Tue, 23 Feb 2016 01:14:06 +0300
Subject: [PATCH 093/105] fix

---
 lib/mapping/MapFormatJson.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 03e73e49e..e35222493 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -749,7 +749,7 @@ void CMapLoaderJson::MapObjectLoader::construct()
 
 	//TODO:consider move to ObjectTypeHandler
 	//find type handler
-	std::string typeName = configuration["type"].String(), subTypeName = configuration["subType"].String();
+	std::string typeName = configuration["type"].String(), subTypeName = configuration["subtype"].String();
 	if(typeName.empty())
 	{
 		logGlobal->errorStream() << "Object type missing";

From 17e557be177ed4f0730d20322a9df14c08fd4e69 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Tue, 23 Feb 2016 16:36:21 +0300
Subject: [PATCH 094/105] Advance Logical identifier condition

---
 lib/mapObjects/CGTownInstance.cpp      | 12 +++-
 lib/mapping/MapFormatJson.cpp          |  2 +-
 lib/serializer/JsonDeserializer.cpp    | 80 ++++++++++++++++----------
 lib/serializer/JsonDeserializer.h      |  5 +-
 lib/serializer/JsonSerializeFormat.cpp | 10 +++-
 lib/serializer/JsonSerializeFormat.h   | 29 +++++++++-
 lib/serializer/JsonSerializer.cpp      | 35 ++++++++---
 lib/serializer/JsonSerializer.h        |  6 +-
 8 files changed, 133 insertions(+), 46 deletions(-)

diff --git a/lib/mapObjects/CGTownInstance.cpp b/lib/mapObjects/CGTownInstance.cpp
index 808416670..b16306be1 100644
--- a/lib/mapObjects/CGTownInstance.cpp
+++ b/lib/mapObjects/CGTownInstance.cpp
@@ -1123,10 +1123,20 @@ void CGTownInstance::battleFinished(const CGHeroInstance *hero, const BattleResu
 	}
 }
 
-void CGTownInstance::serializeJsonOptions(JsonSerializeFormat& handler)
+void CGTownInstance::serializeJsonOptions(JsonSerializeFormat & handler)
 {
 	CGObjectInstance::serializeJsonOwner(handler);
 	CCreatureSet::serializeJson(handler, "army");
+	handler.serializeBool<ui8>("tightFormation", 1, 0, formation);
+	handler.serializeString("name", name);
+
+
+
+	if(!handler.saving)
+	{
+		builtBuildings.insert(BuildingID::DEFAULT);//just in case
+	}
+
 
 	//todo: CGTownInstance::serializeJsonOptions
 }
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index e35222493..9b33d2b52 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -235,7 +235,7 @@ void CMapFormatJson::serializePlayerInfo(JsonSerializeFormat & handler)
 
 		serializeAllowedFactions(handler, info.allowedFactions);
 
-		handler.serializeBoolEnum("canPlay", "PlayerOrAI", "AIOnly", info.canHumanPlay);
+		handler.serializeEnum("canPlay", "PlayerOrAI", "AIOnly", info.canHumanPlay);
 
 		//mainTown
 		if(handler.saving)
diff --git a/lib/serializer/JsonDeserializer.cpp b/lib/serializer/JsonDeserializer.cpp
index 72af19bb0..53cd0afaa 100644
--- a/lib/serializer/JsonDeserializer.cpp
+++ b/lib/serializer/JsonDeserializer.cpp
@@ -25,7 +25,7 @@ void JsonDeserializer::serializeBool(const std::string & fieldName, bool & value
 	value = current->operator[](fieldName).Bool();
 }
 
-void JsonDeserializer::serializeBoolEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value)
+void JsonDeserializer::serializeEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value)
 {
 	const JsonNode & tmp = current->operator[](fieldName);
 
@@ -72,32 +72,11 @@ void JsonDeserializer::serializeLIC(const std::string & fieldName, const TDecode
 	if(field.isNull())
 		return;
 
-	auto loadPart = [&](const JsonVector & part, const bool val)
-	{
-		for(size_t index = 0; index < part.size(); index++)
-		{
-			const std::string & identifier = part[index].String();
+	const JsonNode & anyOf = field["anyOf"];
+	const JsonNode & allOf = field["allOf"];
+	const JsonNode & noneOf = field["noneOf"];
 
-			si32 rawId = decoder(identifier);
-			if(rawId >= 0)
-			{
-				if(rawId < value.size())
-					value[rawId] = val;
-				else
-					logGlobal->errorStream() << "JsonDeserializer::serializeLIC: " << fieldName <<" id out of bounds " << rawId;
-			}
-			else
-			{
-				logGlobal->errorStream() << "JsonDeserializer::serializeLIC: " << fieldName <<" identifier not resolved " << identifier;
-			}
-		}
-	};
-
-	const JsonVector & anyOf = field["anyOf"].Vector();
-	const JsonVector & allOf = field["allOf"].Vector();
-	const JsonVector & noneOf = field["noneOf"].Vector();
-
-	if(anyOf.empty() && allOf.empty())
+	if(anyOf.Vector().empty() && allOf.Vector().empty())
 	{
 		//permissive mode
 		value = standard;
@@ -108,11 +87,37 @@ void JsonDeserializer::serializeLIC(const std::string & fieldName, const TDecode
 		value.clear();
 		value.resize(standard.size(), false);
 
-		loadPart(anyOf, true);
-		loadPart(allOf, true);
+		readLICPart(anyOf, decoder, true, value);
+		readLICPart(allOf, decoder, true, value);
 	}
 
-	loadPart(noneOf, false);
+	readLICPart(noneOf, decoder, false, value);
+}
+
+void JsonDeserializer::serializeLIC(const std::string & fieldName, LIC & value)
+{
+	const JsonNode & field = current->operator[](fieldName);
+
+	const JsonNode & anyOf = field["anyOf"];
+	const JsonNode & allOf = field["allOf"];
+	const JsonNode & noneOf = field["noneOf"];
+
+	if(anyOf.Vector().empty())
+	{
+		//permissive mode
+		value.any = value.standard;
+	}
+	else
+	{
+		//restrictive mode
+		value.any.clear();
+		value.any.resize(value.standard.size(), false);
+
+		readLICPart(anyOf, value.decoder, true, value.any);
+	}
+
+	readLICPart(allOf, value.decoder, true, value.all);
+	readLICPart(noneOf, value.decoder, true, value.none);
 }
 
 void JsonDeserializer::serializeString(const std::string & fieldName, std::string & value)
@@ -120,3 +125,20 @@ void JsonDeserializer::serializeString(const std::string & fieldName, std::strin
 	value = current->operator[](fieldName).String();
 }
 
+void JsonDeserializer::readLICPart(const JsonNode & part, const TDecoder & decoder, const bool val, std::vector<bool> & value)
+{
+	for(size_t index = 0; index < part.Vector().size(); index++)
+	{
+		const std::string & identifier = part.Vector()[index].String();
+
+		const si32 rawId = decoder(identifier);
+		if(rawId >= 0)
+		{
+			if(rawId < value.size())
+				value[rawId] = val;
+			else
+				logGlobal->errorStream() << "JsonDeserializer::serializeLIC: id out of bounds " << rawId;
+		}
+	}
+}
+
diff --git a/lib/serializer/JsonDeserializer.h b/lib/serializer/JsonDeserializer.h
index 2130b3812..cfd7031a5 100644
--- a/lib/serializer/JsonDeserializer.h
+++ b/lib/serializer/JsonDeserializer.h
@@ -20,12 +20,15 @@ public:
 	JsonDeserializer(JsonNode & root_);
 
 	void serializeBool(const std::string & fieldName, bool & value) override;
-	void serializeBoolEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value) override;
+	void serializeEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value) override;
 	void serializeLIC(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const std::vector<bool> & standard, std::vector<bool> & value) override;
+	void serializeLIC(const std::string & fieldName, LIC & value) override;
 	void serializeString(const std::string & fieldName, std::string & value) override;
 
 protected:
 	void serializeFloat(const std::string & fieldName, double & value) override;
 	void serializeIntEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const si32 defaultValue, si32 & value) override;
 	void serializeIntId(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const si32 defaultValue, si32 & value) override;
+private:
+	void readLICPart(const JsonNode & part, const TDecoder & decoder, const bool val, std::vector<bool> & value);
 };
diff --git a/lib/serializer/JsonSerializeFormat.cpp b/lib/serializer/JsonSerializeFormat.cpp
index 11b4f947d..f960a8126 100644
--- a/lib/serializer/JsonSerializeFormat.cpp
+++ b/lib/serializer/JsonSerializeFormat.cpp
@@ -14,6 +14,7 @@
 
 #include "../JsonNode.h"
 
+
 //JsonStructSerializer
 JsonStructSerializer::JsonStructSerializer(JsonStructSerializer&& other):
 	restoreState(false),
@@ -48,7 +49,6 @@ JsonStructSerializer::JsonStructSerializer(JsonStructSerializer & parent, const
 	owner.current = thisNode;
 }
 
-
 JsonStructSerializer JsonStructSerializer::enterStruct(const std::string & fieldName)
 {
 	return JsonStructSerializer(*this, fieldName);
@@ -64,6 +64,14 @@ JsonSerializeFormat * JsonStructSerializer::operator->()
 	return &owner;
 }
 
+JsonSerializeFormat::LIC::LIC(const std::vector<bool> & Standard, const TDecoder & Decoder, const TEncoder & Encoder):
+	standard(Standard), decoder(Decoder), encoder(Encoder)
+{
+	any = standard;
+	all.resize(standard.size(), false);
+	none.resize(standard.size(), false);
+}
+
 
 //JsonSerializeFormat
 JsonSerializeFormat::JsonSerializeFormat(JsonNode & root_, const bool saving_):
diff --git a/lib/serializer/JsonSerializeFormat.h b/lib/serializer/JsonSerializeFormat.h
index 424f2d9aa..70ab8abcb 100644
--- a/lib/serializer/JsonSerializeFormat.h
+++ b/lib/serializer/JsonSerializeFormat.h
@@ -47,6 +47,16 @@ public:
 	///may assume that object index is valid
 	typedef std::function<std::string(si32)> TEncoder;
 
+	struct LIC
+	{
+		LIC(const std::vector<bool> & Standard, const TDecoder & Decoder, const TEncoder & Encoder);
+
+		const std::vector<bool> & standard;
+		const TDecoder & decoder;
+		const TEncoder & encoder;
+		std::vector<bool> all, any, none;
+	};
+
 	const bool saving;
 
 	JsonSerializeFormat() = delete;
@@ -64,10 +74,20 @@ public:
 
 	JsonStructSerializer enterStruct(const std::string & fieldName);
 
-	virtual void serializeBool(const std::string & fieldName, bool & value) = 0;
-	virtual void serializeBoolEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value) = 0;
+	template <typename T>
+	void serializeBool(const std::string & fieldName, const T trueValue, const T falseValue, T & value)
+	{
+		bool temp = (value == trueValue);
+		serializeBool(fieldName, temp);
+		if(!saving)
+			value = temp ? trueValue : falseValue;
+	}
 
-	/** @brief Restrictive serialization of Logical identifier condition (only "anyOf" used), full deserialization
+	virtual void serializeBool(const std::string & fieldName, bool & value) = 0;
+
+	virtual void serializeEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value) = 0;
+
+	/** @brief Restrictive ("anyOf") simple serialization of Logical identifier condition, simple deserialization (allOf=anyOf)
 	 *
 	 * @param fieldName
 	 * @param decoder resolve callback, should report errors itself and do not throw
@@ -77,6 +97,9 @@ public:
 	 */
 	virtual void serializeLIC(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const std::vector<bool> & standard, std::vector<bool> & value) = 0;
 
+	/** @brief Complete serialization of Logical identifier condition
+	 */
+	virtual void serializeLIC(const std::string & fieldName, LIC & value) = 0;
 
 	template <typename T>
 	void serializeNumericEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const T defaultValue, T & value)
diff --git a/lib/serializer/JsonSerializer.cpp b/lib/serializer/JsonSerializer.cpp
index 8f4d37640..22f4215e2 100644
--- a/lib/serializer/JsonSerializer.cpp
+++ b/lib/serializer/JsonSerializer.cpp
@@ -26,7 +26,7 @@ void JsonSerializer::serializeBool(const std::string & fieldName, bool & value)
 		current->operator[](fieldName).Bool() = true;
 }
 
-void JsonSerializer::serializeBoolEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value)
+void JsonSerializer::serializeEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value)
 {
 	current->operator[](fieldName).String() = value ? trueValue : falseValue;
 }
@@ -57,16 +57,19 @@ void JsonSerializer::serializeLIC(const std::string & fieldName, const TDecoder
 	assert(standard.size() == value.size());
 	if(standard == value)
 		return;
-	auto & target = current->operator[](fieldName)["anyOf"].Vector();
-	for(si32 idx = 0; idx < value.size(); idx ++)
+
+	writeLICPart(fieldName, "anyOf", encoder, value);
+}
+
+void JsonSerializer::serializeLIC(const std::string & fieldName, LIC & value)
+{
+	if(value.any != value.standard)
 	{
-		if(value[idx])
-		{
-			JsonNode val(JsonNode::DATA_STRING);
-			val.String() = encoder(idx);
-			target.push_back(std::move(val));
-		}
+		writeLICPart(fieldName, "anyOf", value.encoder, value.any);
 	}
+
+	writeLICPart(fieldName, "allOf", value.encoder, value.all);
+	writeLICPart(fieldName, "noneOf", value.encoder, value.none);
 }
 
 void JsonSerializer::serializeString(const std::string & fieldName, std::string & value)
@@ -75,3 +78,17 @@ void JsonSerializer::serializeString(const std::string & fieldName, std::string
 		current->operator[](fieldName).String() = value;
 }
 
+void JsonSerializer::writeLICPart(const std::string& fieldName, const std::string& partName, const TEncoder& encoder, const std::vector<bool> & data)
+{
+	auto & target = current->operator[](fieldName)[partName].Vector();
+	for(si32 idx = 0; idx < data.size(); idx ++)
+	{
+		if(data[idx])
+		{
+			JsonNode val(JsonNode::DATA_STRING);
+			val.String() = encoder(idx);
+			target.push_back(std::move(val));
+		}
+	}
+}
+
diff --git a/lib/serializer/JsonSerializer.h b/lib/serializer/JsonSerializer.h
index ad19fe782..1fae5fb67 100644
--- a/lib/serializer/JsonSerializer.h
+++ b/lib/serializer/JsonSerializer.h
@@ -20,12 +20,16 @@ public:
 	JsonSerializer(JsonNode & root_);
 
 	void serializeBool(const std::string & fieldName, bool & value) override;
-	void serializeBoolEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value) override;
+	void serializeEnum(const std::string & fieldName, const std::string & trueValue, const std::string & falseValue, bool & value) override;
 	void serializeLIC(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const std::vector<bool> & standard, std::vector<bool> & value) override;
+	void serializeLIC(const std::string & fieldName, LIC & value) override;
 	void serializeString(const std::string & fieldName, std::string & value) override;
 
 protected:
 	void serializeFloat(const std::string & fieldName, double & value) override;
 	void serializeIntEnum(const std::string & fieldName, const std::vector<std::string> & enumMap, const si32 defaultValue, si32 & value) override;
 	void serializeIntId(const std::string & fieldName, const TDecoder & decoder, const TEncoder & encoder, const si32 defaultValue, si32 & value) override;
+
+private:
+	void writeLICPart(const std::string & fieldName, const std::string & partName, const TEncoder & encoder, const std::vector<bool> & data);
 };

From c3775486db329407add070ec4c8e1870132bbc71 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Tue, 23 Feb 2016 23:23:39 +0300
Subject: [PATCH 095/105] Serizlize main town info

---
 lib/mapping/MapFormatJson.cpp | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 9b33d2b52..5cc7edd55 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -237,27 +237,26 @@ void CMapFormatJson::serializePlayerInfo(JsonSerializeFormat & handler)
 
 		handler.serializeEnum("canPlay", "PlayerOrAI", "AIOnly", info.canHumanPlay);
 
-		//mainTown
-		if(handler.saving)
+		//saving whole structure only if position is valid
+		if(!handler.saving || info.posOfMainTown.valid())
 		{
-
+			auto mainTown = handler.enterStruct("mainTown");
+			handler.serializeBool("generateHero", info.generateHeroAtMainTown);
+			handler.serializeNumeric("x", info.posOfMainTown.x);
+			handler.serializeNumeric("y", info.posOfMainTown.y);
+			handler.serializeNumeric("l", info.posOfMainTown.z);
 		}
-		else
+		if(!handler.saving)
 		{
-
+			info.hasMainTown = info.posOfMainTown.valid();
 		}
 
-		handler.serializeBool("generateHeroAtMainTown", info.generateHeroAtMainTown);
-
-
 		//mainHero
 
 		//mainHeroPortrait
 
 		//mainCustomHeroName
 
-		//towns
-
 		//heroes
 		{
 			//auto heroes = playerData.enterStruct("heroes");
@@ -270,10 +269,8 @@ void CMapFormatJson::serializePlayerInfo(JsonSerializeFormat & handler)
 			// true if main town is random and generateHeroAtMainTown==true
 			// or main hero is random
 			//TODO: recheck mechanics
-			//	info.isFactionRandom =
+			info.isFactionRandom = info.allowedFactions.size() > 1;
 		}
-
-
 	}
 }
 

From d2f04332d0f8387ac7572c7f31de21deb7a99dab Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Tue, 23 Feb 2016 23:46:33 +0300
Subject: [PATCH 096/105] Load object appearance and pos before addNewObject
 call, it is required for block-visit calculation. Added a test for tile
 block-visit.

---
 lib/mapObjects/CObjectHandler.cpp | 17 +++++------------
 lib/mapping/MapFormatJson.cpp     | 23 +++++++++++++++--------
 test/MapComparer.cpp              |  7 +++++++
 3 files changed, 27 insertions(+), 20 deletions(-)

diff --git a/lib/mapObjects/CObjectHandler.cpp b/lib/mapObjects/CObjectHandler.cpp
index 21e939030..f43c10751 100644
--- a/lib/mapObjects/CObjectHandler.cpp
+++ b/lib/mapObjects/CObjectHandler.cpp
@@ -322,31 +322,24 @@ bool CGObjectInstance::passableFor(PlayerColor color) const
 
 void CGObjectInstance::serializeJson(JsonSerializeFormat & handler)
 {
+	//only save here, loading is handled by map loader
 	if(handler.saving)
 	{
 		handler.serializeString("type", typeName);
 		handler.serializeString("subtype", subTypeName);
-	}
 
-	handler.serializeNumeric("x", pos.x);
-	handler.serializeNumeric("y", pos.y);
-	handler.serializeNumeric("l", pos.z);
-
-	if(handler.saving)
-	{
+		handler.serializeNumeric("x", pos.x);
+		handler.serializeNumeric("y", pos.y);
+		handler.serializeNumeric("l", pos.z);
 		appearance.writeJson(handler.getCurrent()["template"], false);
 	}
-	else
-	{
-		appearance.readJson(handler.getCurrent()["template"], false);
-	}
 
 	{
 		auto options = handler.enterStruct("options");
 		serializeJsonOptions(handler);
 	}
 
-	if(handler.saving && handler.getCurrent()["options"].isNull())
+	if(handler.saving && handler.getCurrent()["options"].Struct().empty())
 	{
 		handler.getCurrent().Struct().erase("options");
 	}
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 5cc7edd55..88eb394d4 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -746,7 +746,7 @@ void CMapLoaderJson::MapObjectLoader::construct()
 
 	//TODO:consider move to ObjectTypeHandler
 	//find type handler
-	std::string typeName = configuration["type"].String(), subTypeName = configuration["subtype"].String();
+	std::string typeName = configuration["type"].String(), subtypeName = configuration["subtype"].String();
 	if(typeName.empty())
 	{
 		logGlobal->errorStream() << "Object type missing";
@@ -754,29 +754,36 @@ void CMapLoaderJson::MapObjectLoader::construct()
 		return;
 	}
 
+	int3 pos;
+	pos.x = configuration["x"].Float();
+	pos.y = configuration["y"].Float();
+	pos.z = configuration["l"].Float();
 
 	//special case for grail
     if(typeName == "grail")
 	{
-		auto & pos = owner->map->grailPos;
-		pos.x = configuration["x"].Float();
-		pos.y = configuration["y"].Float();
-		pos.z = configuration["l"].Float();
+		owner->map->grailPos = pos;
+
 		owner->map->grailRadius = configuration["options"]["grailRadius"].Float();
 		return;
 	}
-	else if(subTypeName.empty())
+	else if(subtypeName.empty())
 	{
 		logGlobal->errorStream() << "Object subtype missing";
 		logGlobal->debugStream() << configuration;
 		return;
 	}
 
-	auto handler = VLC->objtypeh->getHandlerFor(typeName, subTypeName);
+	auto handler = VLC->objtypeh->getHandlerFor(typeName, subtypeName);
 
-	instance = handler->create(ObjectTemplate());
+	ObjectTemplate appearance;
+
+	appearance.readJson(configuration["template"], false);
+
+	instance = handler->create(appearance);
 	instance->id = ObjectInstanceID(owner->map->objects.size());
 	instance->instanceName = jsonKey;
+	instance->pos = pos;
 	owner->map->addNewObject(instance);
 }
 
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 175683ebd..116d844b0 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -128,6 +128,13 @@ void checkEqual(const TerrainTile & actual, const TerrainTile & expected)
 	VCMI_REQUIRE_FIELD_EQUAL(roadType);
 	VCMI_REQUIRE_FIELD_EQUAL(roadDir);
 	VCMI_REQUIRE_FIELD_EQUAL(extTileFlags);
+
+	BOOST_REQUIRE_EQUAL(actual.blockingObjects.size(), expected.blockingObjects.size());
+	BOOST_REQUIRE_EQUAL(actual.visitableObjects.size(), expected.visitableObjects.size());
+
+	VCMI_REQUIRE_FIELD_EQUAL(visitable);
+	VCMI_REQUIRE_FIELD_EQUAL(blocked);
+
 }
 
 void MapComparer::compareHeader()

From 8b6cf82a0167700108c0ad3ac03cf34d1961dac2 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Wed, 24 Feb 2016 02:59:34 +0300
Subject: [PATCH 097/105] Fix

---
 lib/mapping/CMap.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/mapping/CMap.h b/lib/mapping/CMap.h
index 19e06a2a8..87ba1b994 100644
--- a/lib/mapping/CMap.h
+++ b/lib/mapping/CMap.h
@@ -422,7 +422,7 @@ public:
 		h & CGTownInstance::merchantArtifacts;
 		h & CGTownInstance::universitySkills;
 
-		if(version >= 759)
+		if(formatVersion >= 759)
 		{
 			h & instanceNames;
 		}

From 2021decb915d3a034f3088fda4792e01df2b5822 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Thu, 25 Feb 2016 22:59:17 +0300
Subject: [PATCH 098/105] Serialize town spells

---
 lib/CTownHandler.cpp                   | 16 ----------
 lib/CTownHandler.h                     |  6 ----
 lib/mapObjects/CGTownInstance.cpp      | 42 +++++++++++++++++++++++++-
 lib/serializer/JsonDeserializer.cpp    | 19 ++++++++++++
 lib/serializer/JsonSerializeFormat.cpp |  2 +-
 5 files changed, 61 insertions(+), 24 deletions(-)

diff --git a/lib/CTownHandler.cpp b/lib/CTownHandler.cpp
index 64033743f..9462bf9b6 100644
--- a/lib/CTownHandler.cpp
+++ b/lib/CTownHandler.cpp
@@ -809,19 +809,3 @@ std::string CTownHandler::encodeFaction(const si32 index)
 {
 	return VLC->townh->factions[index]->identifier;
 }
-
-si32 CTownHandler::decodeBuilding(const std::string & identifier)
-{
-	//FIXME: CTownHandler::decodeBuilding
-	auto rawId = VLC->modh->identifiers.getIdentifier("core", "building", identifier); //???
-	if(rawId)
-		return rawId.get();
-	else
-		return -1;
-}
-
-std::string CTownHandler::encodeBuilding(const si32 index)
-{
-	 //FIXME: CTownHandler::encodeBuilding
-	 return "";
-}
diff --git a/lib/CTownHandler.h b/lib/CTownHandler.h
index c04ad2bf9..7df2d78a6 100644
--- a/lib/CTownHandler.h
+++ b/lib/CTownHandler.h
@@ -288,12 +288,6 @@ public:
 	//json serialization helper
 	static std::string encodeFaction(const si32 index);
 
-	//json serialization helper
-	static si32 decodeBuilding(const std::string & identifier);
-
-	//json serialization helper
-	static std::string encodeBuilding(const si32 index);
-
 	template <typename Handler> void serialize(Handler &h, const int version)
 	{
 		h & factions;
diff --git a/lib/mapObjects/CGTownInstance.cpp b/lib/mapObjects/CGTownInstance.cpp
index b16306be1..0e253bbe1 100644
--- a/lib/mapObjects/CGTownInstance.cpp
+++ b/lib/mapObjects/CGTownInstance.cpp
@@ -11,6 +11,7 @@
 #include "StdInc.h"
 #include "CGTownInstance.h"
 #include "CObjectClassesHandler.h"
+#include "../spells/CSpellHandler.h"
 
 #include "../NetPacks.h"
 #include "../CGeneralTextHandler.h"
@@ -1137,8 +1138,47 @@ void CGTownInstance::serializeJsonOptions(JsonSerializeFormat & handler)
 		builtBuildings.insert(BuildingID::DEFAULT);//just in case
 	}
 
+	//todo: serialize buildings
+//	{
+//		std::vector<bool> standard;
+//		standard.resize(44, true);
+//
+//
+//		JsonSerializeFormat::LIC buildingsLIC(, CTownHandler::decodeBuilding, CTownHandler::encodeBuilding);
+//	}
 
-	//todo: CGTownInstance::serializeJsonOptions
+	{
+		JsonSerializeFormat::LIC spellsLIC(VLC->spellh->getDefaultAllowed(), CSpellHandler::decodeSpell, CSpellHandler::encodeSpell);
+
+		for(SpellID id : possibleSpells)
+			spellsLIC.any[id.num] = true;
+
+		for(SpellID id : obligatorySpells)
+			spellsLIC.all[id.num] = true;
+
+		handler.serializeLIC("spells", spellsLIC);
+
+		if(!handler.saving)
+		{
+			possibleSpells.clear();
+			for(si32 idx = 0; idx < spellsLIC.any.size(); idx++)
+			{
+				if(spellsLIC.any[idx])
+				{
+					possibleSpells.push_back(SpellID(idx));
+				}
+			}
+
+			obligatorySpells.clear();
+			for(si32 idx = 0; idx < spellsLIC.all.size(); idx++)
+			{
+				if(spellsLIC.all[idx])
+				{
+					obligatorySpells.push_back(SpellID(idx));
+				}
+			}
+		}
+	}
 }
 
 COPWBonus::COPWBonus (BuildingID index, CGTownInstance *TOWN)
diff --git a/lib/serializer/JsonDeserializer.cpp b/lib/serializer/JsonDeserializer.cpp
index 53cd0afaa..f6229ded0 100644
--- a/lib/serializer/JsonDeserializer.cpp
+++ b/lib/serializer/JsonDeserializer.cpp
@@ -118,6 +118,25 @@ void JsonDeserializer::serializeLIC(const std::string & fieldName, LIC & value)
 
 	readLICPart(allOf, value.decoder, true, value.all);
 	readLICPart(noneOf, value.decoder, true, value.none);
+
+	//remove any banned from allowed and required
+	for(si32 idx = 0; idx < value.none.size(); idx++)
+	{
+		if(value.none[idx])
+		{
+			value.all[idx] = false;
+			value.any[idx] = false;
+		}
+	}
+
+	//add all required to allowed
+	for(si32 idx = 0; idx < value.all.size(); idx++)
+	{
+		if(value.all[idx])
+		{
+			value.any[idx] = true;
+		}
+	}
 }
 
 void JsonDeserializer::serializeString(const std::string & fieldName, std::string & value)
diff --git a/lib/serializer/JsonSerializeFormat.cpp b/lib/serializer/JsonSerializeFormat.cpp
index f960a8126..d11cff326 100644
--- a/lib/serializer/JsonSerializeFormat.cpp
+++ b/lib/serializer/JsonSerializeFormat.cpp
@@ -67,7 +67,7 @@ JsonSerializeFormat * JsonStructSerializer::operator->()
 JsonSerializeFormat::LIC::LIC(const std::vector<bool> & Standard, const TDecoder & Decoder, const TEncoder & Encoder):
 	standard(Standard), decoder(Decoder), encoder(Encoder)
 {
-	any = standard;
+	any.resize(standard.size(), false);
 	all.resize(standard.size(), false);
 	none.resize(standard.size(), false);
 }

From 4a37ed99ea1c25c5910b9b6644d55c15acd13aec Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Fri, 26 Feb 2016 00:42:49 +0300
Subject: [PATCH 099/105] Fix duplicated block-visit regression

---
 lib/mapping/MapFormatH3M.cpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/lib/mapping/MapFormatH3M.cpp b/lib/mapping/MapFormatH3M.cpp
index cbc8cdcd4..03446f083 100644
--- a/lib/mapping/MapFormatH3M.cpp
+++ b/lib/mapping/MapFormatH3M.cpp
@@ -119,11 +119,6 @@ void CMapLoaderH3M::init()
 	readEvents();
 	times.push_back(MapLoadingTime("events", sw.getDiff()));
 
-	// Calculate blocked / visitable positions
-	for(auto & elem : map->objects)
-	{
-		map->addBlockVisTiles(elem);
-	}
 	times.push_back(MapLoadingTime("blocked/visitable tiles", sw.getDiff()));
 
 	// Print profiling times

From 0de1a37d65bc7575600e787e5d8ffb1ed9d3048c Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Fri, 26 Feb 2016 01:01:07 +0300
Subject: [PATCH 100/105] Fix missing template zIndex saving

---
 lib/mapObjects/ObjectTemplate.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/lib/mapObjects/ObjectTemplate.cpp b/lib/mapObjects/ObjectTemplate.cpp
index 57e55eb7c..af45b16ad 100644
--- a/lib/mapObjects/ObjectTemplate.cpp
+++ b/lib/mapObjects/ObjectTemplate.cpp
@@ -252,11 +252,7 @@ void ObjectTemplate::readJson(const JsonNode &node, const bool withTerrain)
 			usedTiles[mask.size() - 1 - i][line.size() - 1 - j] = charToTile(line[j]);
 	}
 
-	const JsonNode zindex = node["zIndex"];
-	if (!zindex.isNull())
-		printPriority = node["zIndex"].Float();
-	else
-		printPriority = 0; //default value
+	printPriority = node["zIndex"].Float();
 }
 
 void ObjectTemplate::writeJson(JsonNode & node, const bool withTerrain) const
@@ -344,6 +340,9 @@ void ObjectTemplate::writeJson(JsonNode & node, const bool withTerrain) const
 			line[j] = tileToChar(usedTiles[height - 1 - i][width - 1 - j]);
 		mask.push_back(lineNode);
 	}
+
+	if(printPriority != 0)
+		node["zIndex"].Float() = printPriority;
 }
 
 ui32 ObjectTemplate::getWidth() const

From 8e3e574900564b447c0f9868844bd3462ed1d187 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Fri, 26 Feb 2016 02:03:14 +0300
Subject: [PATCH 101/105] Fix map object appearance serialization

---
 lib/mapObjects/CObjectClassesHandler.h | 12 ++++++------
 lib/mapping/MapFormatJson.cpp          |  3 +++
 test/MapComparer.cpp                   | 13 ++++++++++++-
 3 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/lib/mapObjects/CObjectClassesHandler.h b/lib/mapObjects/CObjectClassesHandler.h
index 9c7279b2f..2aed19be8 100644
--- a/lib/mapObjects/CObjectClassesHandler.h
+++ b/lib/mapObjects/CObjectClassesHandler.h
@@ -101,12 +101,6 @@ class DLL_LINKAGE AObjectTypeHandler : public boost::noncopyable
 	/// Human-readable name of this object, used for objects like banks and dwellings, if set
 	boost::optional<std::string> objectName;
 
-	si32 type;
-	si32 subtype;
-
-	std::string typeName;
-	std::string subTypeName;
-
 	JsonNode base; /// describes base template
 
 	std::vector<ObjectTemplate> templates;
@@ -117,6 +111,12 @@ protected:
 	/// initialization for classes that inherit this one
 	virtual void initTypeData(const JsonNode & input);
 public:
+	std::string typeName;
+	std::string subTypeName;
+
+	si32 type;
+	si32 subtype;
+
 	virtual ~AObjectTypeHandler(){}
 
 	void setType(si32 type, si32 subtype);
diff --git a/lib/mapping/MapFormatJson.cpp b/lib/mapping/MapFormatJson.cpp
index 88eb394d4..4df1ddd54 100644
--- a/lib/mapping/MapFormatJson.cpp
+++ b/lib/mapping/MapFormatJson.cpp
@@ -779,8 +779,11 @@ void CMapLoaderJson::MapObjectLoader::construct()
 	ObjectTemplate appearance;
 
 	appearance.readJson(configuration["template"], false);
+	appearance.id = Obj(handler->type);
+	appearance.subid = handler->subtype;
 
 	instance = handler->create(appearance);
+
 	instance->id = ObjectInstanceID(owner->map->objects.size());
 	instance->instanceName = jsonKey;
 	instance->pos = pos;
diff --git a/test/MapComparer.cpp b/test/MapComparer.cpp
index 116d844b0..e187d06b8 100644
--- a/test/MapComparer.cpp
+++ b/test/MapComparer.cpp
@@ -116,6 +116,16 @@ void checkEqual(const DisposedHero & actual, const DisposedHero & expected)
 	VCMI_CHECK_FIELD_EQUAL(portrait);
 	VCMI_CHECK_FIELD_EQUAL(name);
 	VCMI_CHECK_FIELD_EQUAL(players);
+
+}
+
+void checkEqual(const ObjectTemplate & actual, const ObjectTemplate & expected)
+{
+	VCMI_CHECK_FIELD_EQUAL(id);
+	VCMI_CHECK_FIELD_EQUAL(subid);
+	VCMI_CHECK_FIELD_EQUAL(printPriority);
+	VCMI_CHECK_FIELD_EQUAL(animationFile);
+	//VCMI_CHECK_FIELD_EQUAL(stringID);
 }
 
 void checkEqual(const TerrainTile & actual, const TerrainTile & expected)
@@ -196,8 +206,9 @@ void MapComparer::compareObject(const CGObjectInstance * actual, const CGObjectI
 	std::string expectedFullID = boost::to_string(boost::format("%s(%d)|%s(%d) %d") % expected->typeName % expected->ID % expected->subTypeName % expected->subID % expected->tempOwner);
 
 	BOOST_CHECK_EQUAL(actualFullID, expectedFullID);
-	BOOST_CHECK_EQUAL(actual->pos, expected->pos);
 
+	VCMI_CHECK_FIELD_EQUAL_P(pos);
+	checkEqual(actual->appearance, expected->appearance);
 }
 
 void MapComparer::compareObjects()

From 66d8408130125922e002c9745aa0b698282c7959 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Fri, 26 Feb 2016 02:35:30 +0300
Subject: [PATCH 102/105] Fix creature set loading

---
 lib/CCreatureSet.cpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/lib/CCreatureSet.cpp b/lib/CCreatureSet.cpp
index 0247747c0..23c6c58b8 100644
--- a/lib/CCreatureSet.cpp
+++ b/lib/CCreatureSet.cpp
@@ -502,11 +502,14 @@ void CCreatureSet::serializeJson(JsonSerializeFormat & handler, const std::strin
 	{
 		for(size_t idx = 0; idx < json.Vector().size(); idx++)
 		{
-			CStackInstance * new_stack = new CStackInstance();
+			if(json.Vector()[idx]["amount"].Float() > 0)
+			{
+				CStackInstance * new_stack = new CStackInstance();
 
-			new_stack->readJson(json.Vector()[idx]);
+				new_stack->readJson(json.Vector()[idx]);
 
-			putStack(SlotID(idx), new_stack);
+				putStack(SlotID(idx), new_stack);
+			}
 		}
 	}
 }

From 5408b6c1ff739b5b82c4ee3404fa5fe7106b1888 Mon Sep 17 00:00:00 2001
From: AlexVinS <alexvins@mail.ru>
Date: Fri, 26 Feb 2016 18:19:41 +0300
Subject: [PATCH 103/105] Formatting

---
 lib/mapObjects/ObjectTemplate.cpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/lib/mapObjects/ObjectTemplate.cpp b/lib/mapObjects/ObjectTemplate.cpp
index af45b16ad..389d4ccf0 100644
--- a/lib/mapObjects/ObjectTemplate.cpp
+++ b/lib/mapObjects/ObjectTemplate.cpp
@@ -268,16 +268,16 @@ void ObjectTemplate::writeJson(JsonNode & node, const bool withTerrain) const
 		visitDirs[1].String().resize(3);
 		visitDirs[2].String().resize(3);
 
-		visitDirs[0].String()[0] = (visitDir & 1)	? '+' : '-';
-		visitDirs[0].String()[1] = (visitDir & 2)	? '+' : '-';
-		visitDirs[0].String()[2] = (visitDir & 4)	? '+' : '-';
-		visitDirs[1].String()[2] = (visitDir & 8)	? '+' : '-';
-		visitDirs[2].String()[2] = (visitDir & 16)	? '+' : '-';
-		visitDirs[2].String()[1] = (visitDir & 32)	? '+' : '-';
-		visitDirs[2].String()[0] = (visitDir & 64)	? '+' : '-';
+		visitDirs[0].String()[0] = (visitDir & 1)   ? '+' : '-';
+		visitDirs[0].String()[1] = (visitDir & 2)   ? '+' : '-';
+		visitDirs[0].String()[2] = (visitDir & 4)   ? '+' : '-';
+		visitDirs[1].String()[2] = (visitDir & 8)   ? '+' : '-';
+		visitDirs[2].String()[2] = (visitDir & 16)  ? '+' : '-';
+		visitDirs[2].String()[1] = (visitDir & 32)  ? '+' : '-';
+		visitDirs[2].String()[0] = (visitDir & 64)  ? '+' : '-';
 		visitDirs[1].String()[0] = (visitDir & 128) ? '+' : '-';
 
-		visitDirs[1].String()[1] = '-';//??? center
+		visitDirs[1].String()[1] = '-';
 	}
 
 	if(withTerrain)
@@ -295,7 +295,7 @@ void ObjectTemplate::writeJson(JsonNode & node, const bool withTerrain) const
 			}
 		}
 	}
-//todo: use lookup?
+
 	auto tileToChar = [&](const ui8 & tile) -> char
 	{
 		if(tile & VISIBLE)

From 30189a386fb7228118c86e351a5bd20e45024c6e Mon Sep 17 00:00:00 2001
From: Arseniy Shestakov <me@arseniyshestakov.com>
Date: Fri, 26 Feb 2016 21:43:43 +0300
Subject: [PATCH 104/105] CPathfinder: fix and improve sail-land transition
 checks

---
 lib/CPathfinder.cpp | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/lib/CPathfinder.cpp b/lib/CPathfinder.cpp
index 162acb81f..d35ba3043 100644
--- a/lib/CPathfinder.cpp
+++ b/lib/CPathfinder.cpp
@@ -133,6 +133,7 @@ void CPathfinder::calculatePaths()
 				if(!hlp->isLayerAvailable(i))
 					continue;
 
+				/// Check transition without tile accessability rules
 				if(cp->layer != i && !isLayerTransitionPossible(i))
 					continue;
 
@@ -143,6 +144,7 @@ void CPathfinder::calculatePaths()
 				if(dp->accessible == CGPathNode::NOT_SET)
 					continue;
 
+				/// Check transition using tile accessability rules
 				if(cp->layer != i && !isLayerTransitionPossible())
 					continue;
 
@@ -302,16 +304,23 @@ bool CPathfinder::isLayerTransitionPossible(const ELayer destLayer) const
 	switch(cp->layer)
 	{
 	case ELayer::LAND:
-		if(destLayer != ELayer::AIR)
-			return true;
-
-		if(!options.lightweightFlyingMode || isSourceInitialPosition())
+		if(destLayer == ELayer::AIR)
+		{
+			if(!options.lightweightFlyingMode || isSourceInitialPosition())
+				return true;
+		}
+		else if(destLayer == ELayer::SAIL)
+		{
+			if(dt->isWater())
+				return true;
+		}
+		else
 			return true;
 
 		break;
 
 	case ELayer::SAIL:
-		if(destLayer == ELayer::LAND && gs->map->isCoastalTile(dp->coord))
+		if(destLayer == ELayer::LAND && !dt->isWater())
 			return true;
 
 		break;

From 772bc9e6c16e59d2d4a3372e552511200e7fb7ce Mon Sep 17 00:00:00 2001
From: DjWarmonger <Warmonger@vp.pl>
Date: Mon, 29 Feb 2016 10:04:25 +0100
Subject: [PATCH 105/105] Updated MSVS project files.

---
 lib/VCMI_lib.vcxproj         | 15 +++++++++++
 lib/VCMI_lib.vcxproj.filters | 48 ++++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+)

diff --git a/lib/VCMI_lib.vcxproj b/lib/VCMI_lib.vcxproj
index 2a1796676..310a6fa3a 100644
--- a/lib/VCMI_lib.vcxproj
+++ b/lib/VCMI_lib.vcxproj
@@ -188,8 +188,14 @@
     <ClCompile Include="CThreadHelper.cpp" />
     <ClCompile Include="CTownHandler.cpp" />
     <ClCompile Include="CRandomGenerator.cpp" />
+    <ClCompile Include="filesystem\CMemoryBuffer.cpp" />
+    <ClCompile Include="filesystem\CZipSaver.cpp" />
     <ClCompile Include="filesystem\FileInfo.cpp" />
     <ClCompile Include="filesystem\FileStream.cpp" />
+    <ClCompile Include="filesystem\MinizipExtensions.cpp" />
+    <ClCompile Include="serializer\JsonDeserializer.cpp" />
+    <ClCompile Include="serializer\JsonSerializeFormat.cpp" />
+    <ClCompile Include="serializer\JsonSerializer.cpp" />
     <ClCompile Include="spells\CSpellHandler.cpp" />
     <ClCompile Include="spells\ISpellMechanics.cpp" />
     <ClCompile Include="spells\AdventureSpellMechanics.cpp" />
@@ -308,13 +314,19 @@
     <ClInclude Include="filesystem\CFileInfo.h" />
     <ClInclude Include="filesystem\CFileInputStream.h" />
     <ClInclude Include="filesystem\CFilesystemLoader.h" />
+    <ClInclude Include="filesystem\CInputOutputStream.h" />
     <ClInclude Include="filesystem\CInputStream.h" />
+    <ClInclude Include="filesystem\CMemoryBuffer.h" />
     <ClInclude Include="filesystem\CMemoryStream.h" />
+    <ClInclude Include="filesystem\COutputStream.h" />
+    <ClInclude Include="filesystem\CStream.h" />
     <ClInclude Include="filesystem\CZipLoader.h" />
+    <ClInclude Include="filesystem\CZipSaver.h" />
     <ClInclude Include="filesystem\FileInfo.h" />
     <ClInclude Include="filesystem\FileStream.h" />
     <ClInclude Include="filesystem\Filesystem.h" />
     <ClInclude Include="filesystem\ISimpleResourceLoader.h" />
+    <ClInclude Include="filesystem\MinizipExtensions.h" />
     <ClInclude Include="filesystem\ResourceID.h" />
     <ClInclude Include="FunctionList.h" />
     <ClInclude Include="IBonusTypeHandler.h" />
@@ -370,6 +382,9 @@
     <ClInclude Include="rmg\CZonePlacer.h" />
     <ClInclude Include="rmg\float3.h" />
     <ClInclude Include="ScopeGuard.h" />
+    <ClInclude Include="serializer\JsonDeserializer.h" />
+    <ClInclude Include="serializer\JsonSerializeFormat.h" />
+    <ClInclude Include="serializer\JsonSerializer.h" />
     <ClInclude Include="spells\AdventureSpellMechanics.h" />
     <ClInclude Include="spells\BattleSpellMechanics.h" />
     <ClInclude Include="spells\CDefaultSpellMechanics.h" />
diff --git a/lib/VCMI_lib.vcxproj.filters b/lib/VCMI_lib.vcxproj.filters
index bf53bd06e..f84db0b5d 100644
--- a/lib/VCMI_lib.vcxproj.filters
+++ b/lib/VCMI_lib.vcxproj.filters
@@ -26,6 +26,9 @@
     <Filter Include="spells">
       <UniqueIdentifier>{bda963b1-00e1-412a-9b44-f5cd3f8e9e33}</UniqueIdentifier>
     </Filter>
+    <Filter Include="serializer">
+      <UniqueIdentifier>{2f582170-d8a6-42f3-8da3-8255bac28f5a}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="BattleAction.cpp" />
@@ -234,6 +237,24 @@
       <Filter>filesystem</Filter>
     </ClCompile>
     <ClCompile Include="filesystem\FileInfo.cpp" />
+    <ClCompile Include="serializer\JsonDeserializer.cpp">
+      <Filter>serializer</Filter>
+    </ClCompile>
+    <ClCompile Include="serializer\JsonSerializeFormat.cpp">
+      <Filter>serializer</Filter>
+    </ClCompile>
+    <ClCompile Include="serializer\JsonSerializer.cpp">
+      <Filter>serializer</Filter>
+    </ClCompile>
+    <ClCompile Include="filesystem\CMemoryBuffer.cpp">
+      <Filter>filesystem</Filter>
+    </ClCompile>
+    <ClCompile Include="filesystem\CZipSaver.cpp">
+      <Filter>filesystem</Filter>
+    </ClCompile>
+    <ClCompile Include="filesystem\MinizipExtensions.cpp">
+      <Filter>filesystem</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="CCreatureSet.h">
@@ -581,5 +602,32 @@
     <ClInclude Include="filesystem\FileInfo.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="serializer\JsonDeserializer.h">
+      <Filter>serializer</Filter>
+    </ClInclude>
+    <ClInclude Include="serializer\JsonSerializeFormat.h">
+      <Filter>serializer</Filter>
+    </ClInclude>
+    <ClInclude Include="serializer\JsonSerializer.h">
+      <Filter>serializer</Filter>
+    </ClInclude>
+    <ClInclude Include="filesystem\CInputOutputStream.h">
+      <Filter>filesystem</Filter>
+    </ClInclude>
+    <ClInclude Include="filesystem\CMemoryBuffer.h">
+      <Filter>filesystem</Filter>
+    </ClInclude>
+    <ClInclude Include="filesystem\COutputStream.h">
+      <Filter>filesystem</Filter>
+    </ClInclude>
+    <ClInclude Include="filesystem\CStream.h">
+      <Filter>filesystem</Filter>
+    </ClInclude>
+    <ClInclude Include="filesystem\CZipSaver.h">
+      <Filter>filesystem</Filter>
+    </ClInclude>
+    <ClInclude Include="filesystem\MinizipExtensions.h">
+      <Filter>filesystem</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>
\ No newline at end of file