games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-10-31 00:07:39 +02:00
Code Issues Releases Activity

Implemented terrain serialisation

Browse Source 
* with test
This commit is contained in:
AlexVinS
2015-08-18 01:56:16 +03:00
committed by AlexVinS
parent 3d63a97cf9
commit 3af255d1b9
5 changed files with 321 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
lib/mapping/MapFormatJson.cpp
View File

@@ -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");
}
}