vcmi/lib/mapping/MapFormatJson.h

/*
 * MapFormatJSON.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 "CMapService.h"
#include "../JsonNode.h"

#include "../filesystem/CZipSaver.h"
#include "../filesystem/CZipLoader.h"

class TriggeredEvent;
struct TerrainTile;
struct PlayerInfo;

class DLL_LINKAGE CMapFormatJson
{
public:	
	static const int VERSION_MAJOR;
	static const int VERSION_MINOR;	
	
	static const std::string HEADER_FILE_NAME;

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.
	 * (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);

	/**
	 * Writes triggered events, including victory/loss conditions
	 */
	void writeTriggeredEvents(JsonNode & output);

	/**
	 * Reads one of triggered events
	 */
	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
{
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 CMapFormatZip : public CMapFormatJson
{
public:
	CMapFormatZip(CInputOutputStream * stream);
protected:
	CInputOutputStream * buffer;
	std::shared_ptr<CIOApi> ioApi;
};

class DLL_LINKAGE CMapLoaderJson : public CMapFormatZip, public IMapLoader
{
public:
	/**
	 * Default constructor.
	 *
	 * @param stream a stream containing the map data
	 */
	CMapLoaderJson(CInputOutputStream * stream);

	/**
	 * Loads the VCMI/Json map file.
	 *
	 * @return a unique ptr of the loaded map class
	 */
	std::unique_ptr<CMap> loadMap() override;

	/**
	 * Loads the VCMI/Json map header.
	 *
	 * @return a unique ptr of the loaded map header class
	 */
	std::unique_ptr<CMapHeader> loadMapHeader() override;

private:
	/**
	 * Reads complete map.
	 */
	void readMap();

	/**
	 * Reads the map header.
	 */
	void readHeader();

	/**
	 * Reads player information.
	 */
	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;
};

class DLL_LINKAGE CMapSaverJson : public CMapFormatZip, public IMapSaver
{
public:
	/**
	 * Default constructor.
	 *
	 * @param stream a stream to save the map to
	 */
	CMapSaverJson(CInputOutputStream * stream);	
	
	~CMapSaverJson();
	
	/**
	 * Actually saves the VCMI/Json map into stream.
	 *
	 */	
	void saveMap(const std::unique_ptr<CMap> & map) override;	
private:
	/**
	 * Save @data as json file with specified @filename
	 *
	 */		
	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);
		
	void writeTerrain();
		
	CZipSaver saver;	
};