1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-04 09:42:40 +02:00
vcmi/lib/mapping/CMap.h
2022-12-12 04:46:42 +04:00

507 lines
14 KiB
C++

/*
* CMap.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 "../ConstTransitivePtr.h"
#include "../mapObjects/MiscObjects.h" // To serialize static props
#include "../mapObjects/CQuest.h" // To serialize static props
#include "../mapObjects/CGTownInstance.h" // To serialize static props
#include "../ResourceSet.h"
#include "../int3.h"
#include "../GameConstants.h"
#include "../LogicalExpression.h"
#include "CMapDefines.h"
VCMI_LIB_NAMESPACE_BEGIN
class CArtifactInstance;
class CGObjectInstance;
class CGHeroInstance;
class CCommanderInstance;
class CGCreature;
class CQuest;
class CGTownInstance;
class IModableArt;
class IQuestObject;
class CInputStream;
class CMapEditManager;
/// The hero name struct consists of the hero id and the hero name.
struct DLL_LINKAGE SHeroName
{
SHeroName();
int heroId;
std::string heroName;
template <typename Handler>
void serialize(Handler & h, const int version)
{
h & heroId;
h & heroName;
}
};
/// The player info constains data about which factions are allowed, AI tactical settings,
/// the main hero name, where to generate the hero, whether the faction should be selected randomly,...
struct DLL_LINKAGE PlayerInfo
{
PlayerInfo();
/// Gets the default faction id or -1 for a random faction.
si8 defaultCastle() const;
/// Gets the default hero id or -1 for a random hero.
si8 defaultHero() const;
bool canAnyonePlay() const;
bool hasCustomMainHero() const;
bool canHumanPlay;
bool canComputerPlay;
EAiTactic::EAiTactic aiTactic; /// The default value is EAiTactic::RANDOM.
std::set<TFaction> allowedFactions;
bool isFactionRandom;
///main hero instance (VCMI maps only)
std::string mainHeroInstance;
/// Player has a random main hero
bool hasRandomHero;
/// The default value is -1.
si32 mainCustomHeroPortrait;
std::string mainCustomHeroName;
/// ID of custom hero (only if portrait and hero name are set, otherwise unpredicted value), -1 if none (not always -1)
si32 mainCustomHeroId;
std::vector<SHeroName> heroesNames; /// list of placed heroes on the map
bool hasMainTown; /// The default value is false.
bool generateHeroAtMainTown; /// The default value is false.
int3 posOfMainTown;
TeamID team; /// The default value NO_TEAM
bool generateHero; /// Unused.
si32 p7; /// Unknown and unused.
/// Unused. Count of hero placeholders containing hero type.
/// WARNING: powerPlaceholders sometimes gives false 0 (eg. even if there is one placeholder), maybe different meaning ???
ui8 powerPlaceholders;
template <typename Handler>
void serialize(Handler & h, const int version)
{
h & p7;
h & hasRandomHero;
h & mainCustomHeroId;
h & canHumanPlay;
h & canComputerPlay;
h & aiTactic;
h & allowedFactions;
h & isFactionRandom;
h & mainCustomHeroPortrait;
h & mainCustomHeroName;
h & heroesNames;
h & hasMainTown;
h & generateHeroAtMainTown;
h & posOfMainTown;
h & team;
h & generateHero;
h & mainHeroInstance;
}
};
/// The loss condition describes the condition to lose the game. (e.g. lose all own heroes/castles)
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
HAVE_BUILDING, // position - town, optional, type - building to build
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)
//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 or with instance name on start
EMetaclass metaType;
si32 value;
si32 objectType;
si32 objectSubtype;
std::string objectInstanceName;
int3 position;
EWinLoseType condition;
template <typename Handler>
void serialize(Handler & h, const int version)
{
h & object;
h & value;
h & objectType;
h & position;
h & condition;
h & objectSubtype;
h & objectInstanceName;
h & metaType;
}
};
typedef LogicalExpression<EventCondition> EventExpression;
struct DLL_LINKAGE EventEffect
{
enum EType
{
VICTORY,
DEFEAT
};
/// effect type, using EType enum
si8 type;
/// message that will be sent to other players
std::string toOtherMessage;
template <typename Handler>
void serialize(Handler & h, const int version)
{
h & type;
h & toOtherMessage;
}
};
struct DLL_LINKAGE TriggeredEvent
{
/// base condition that must be evaluated
EventExpression trigger;
/// string identifier read from config file (e.g. captureKreelah)
std::string identifier;
/// string-description, for use in UI (capture town to win)
std::string description;
/// Message that will be displayed when this event is triggered (You captured town. You won!)
std::string onFulfill;
/// Effect of this event. TODO: refactor into something more flexible
EventEffect effect;
template <typename Handler>
void serialize(Handler & h, const int version)
{
h & identifier;
h & trigger;
h & description;
h & onFulfill;
h & effect;
}
};
/// The rumor struct consists of a rumor name and text.
struct DLL_LINKAGE Rumor
{
std::string name;
std::string text;
Rumor() = default;
~Rumor() = default;
template <typename Handler>
void serialize(Handler & h, const int version)
{
h & name;
h & text;
}
void serializeJson(JsonSerializeFormat & handler);
};
/// The disposed hero struct describes which hero can be hired from which player.
struct DLL_LINKAGE DisposedHero
{
DisposedHero();
ui32 heroId;
ui16 portrait; /// The portrait id of the hero, 0xFF is default.
std::string name;
ui8 players; /// Who can hire this hero (bitfield).
template <typename Handler>
void serialize(Handler & h, const int version)
{
h & heroId;
h & portrait;
h & name;
h & players;
}
};
namespace EMapFormat
{
enum EMapFormat: ui8
{
INVALID = 0,
// HEX DEC
ROE = 0x0e, // 14
AB = 0x15, // 21
SOD = 0x1c, // 28
// HOTA = 0x1e ... 0x20 // 28 ... 30
WOG = 0x33, // 51
VCMI = 0xF0
};
}
/// The map header holds information about loss/victory condition,map format, version, players, height, width,...
class DLL_LINKAGE CMapHeader
{
void setupEvents();
public:
static const int MAP_SIZE_SMALL = 36;
static const int MAP_SIZE_MIDDLE = 72;
static const int MAP_SIZE_LARGE = 108;
static const int MAP_SIZE_XLARGE = 144;
static const int MAP_SIZE_HUGE = 180;
static const int MAP_SIZE_XHUGE = 216;
static const int MAP_SIZE_GIANT = 252;
CMapHeader();
virtual ~CMapHeader();
ui8 levels() const;
EMapFormat::EMapFormat version; /// The default value is EMapFormat::SOD.
si32 height; /// The default value is 72.
si32 width; /// The default value is 72.
bool twoLevel; /// The default value is true.
std::string name;
std::string description;
ui8 difficulty; /// The default value is 1 representing a normal map difficulty.
/// Specifies the maximum level to reach for a hero. A value of 0 states that there is no
/// maximum level for heroes. This is the default value.
ui8 levelLimit;
std::string victoryMessage;
std::string defeatMessage;
ui16 victoryIconIndex;
ui16 defeatIconIndex;
std::vector<PlayerInfo> players; /// The default size of the vector is PlayerColor::PLAYER_LIMIT.
ui8 howManyTeams;
std::vector<bool> allowedHeroes;
bool areAnyPlayers; /// Unused. True if there are any playable players on the map.
/// "main quests" of the map that describe victory and loss conditions
std::vector<TriggeredEvent> triggeredEvents;
template <typename Handler>
void serialize(Handler & h, const int Version)
{
h & version;
h & name;
h & description;
h & width;
h & height;
h & twoLevel;
h & difficulty;
h & levelLimit;
h & areAnyPlayers;
h & players;
h & howManyTeams;
h & allowedHeroes;
//Do not serialize triggeredEvents in header as they can contain information about heroes and armies
h & victoryMessage;
h & victoryIconIndex;
h & defeatMessage;
h & defeatIconIndex;
}
};
/// The map contains the map header, the tiles of the terrain, objects, heroes, towns, rumors...
class DLL_LINKAGE CMap : public CMapHeader
{
public:
CMap();
~CMap();
void initTerrain();
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 canMoveBetween(const int3 &src, const int3 &dst) const;
bool checkForVisitableDir( const int3 & src, const TerrainTile *pom, const int3 & dst ) const;
int3 guardingCreaturePosition (int3 pos) const;
void addBlockVisTiles(CGObjectInstance * obj);
void removeBlockVisTiles(CGObjectInstance * obj, bool total = false);
void calculateGuardingGreaturePositions();
void addNewArtifactInstance(CArtifactInstance * art);
void eraseArtifactInstance(CArtifactInstance * art);
void addNewQuestInstance(CQuest * quest);
void removeQuestInstance(CQuest * quest);
void setUniqueInstanceName(CGObjectInstance * obj);
///Use only this method when creating new map object instances
void addNewObject(CGObjectInstance * obj);
void moveObject(CGObjectInstance * obj, const int3 & dst);
void removeObject(CGObjectInstance * obj);
/// Gets object of specified type on requested position
const CGObjectInstance * getObjectiveObjectFrom(int3 pos, Obj::EObj type);
CGHeroInstance * getHero(int heroId);
/// Sets the victory/loss condition objectives ??
void checkForObjectives();
void resetStaticData();
ui32 checksum;
std::vector<Rumor> rumors;
std::vector<DisposedHero> disposedHeroes;
std::vector<ConstTransitivePtr<CGHeroInstance> > predefinedHeroes;
std::vector<bool> allowedSpell;
std::vector<bool> allowedArtifact;
std::vector<bool> allowedAbilities;
std::list<CMapEvent> events;
int3 grailPos;
int grailRadius;
//Central lists of items in game. Position of item in the vectors below is their (instance) id.
std::vector< ConstTransitivePtr<CGObjectInstance> > objects;
std::vector< ConstTransitivePtr<CGTownInstance> > towns;
std::vector< ConstTransitivePtr<CArtifactInstance> > artInstances;
std::vector< ConstTransitivePtr<CQuest> > quests;
std::vector< ConstTransitivePtr<CGHeroInstance> > allHeroes; //indexed by [hero_type_id]; on map, disposed, prisons, etc.
//Helper lists
std::vector< ConstTransitivePtr<CGHeroInstance> > heroesOnMap;
std::map<TeleportChannelID, std::shared_ptr<TeleportChannel> > teleportChannels;
/// associative list to identify which hero/creature id belongs to which object id(index for objects)
std::map<si32, ObjectInstanceID> questIdentifierToId;
std::unique_ptr<CMapEditManager> editManager;
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;
si32 uidCounter; //TODO: initialize when loading an old map
public:
template <typename Handler>
void serialize(Handler &h, const int formatVersion)
{
h & static_cast<CMapHeader&>(*this);
h & triggeredEvents; //from CMapHeader
h & rumors;
h & allowedSpell;
h & allowedAbilities;
h & allowedArtifact;
h & events;
h & grailPos;
h & artInstances;
h & quests;
h & allHeroes;
h & questIdentifierToId;
//TODO: viccondetails
const int level = levels();
if(h.saving)
{
// Save terrain
for(int z = 0; z < level; ++z)
{
for(int x = 0; x < width; ++x)
{
for(int y = 0; y < height; ++y)
{
h & terrain[z][x][y];
h & guardingCreaturePositions[z][x][y];
}
}
}
}
else
{
// Load terrain
terrain = new TerrainTile**[level];
guardingCreaturePositions = new int3**[level];
for(int z = 0; z < level; ++z)
{
terrain[z] = new TerrainTile*[width];
guardingCreaturePositions[z] = new int3*[width];
for(int x = 0; x < width; ++x)
{
terrain[z][x] = new TerrainTile[height];
guardingCreaturePositions[z][x] = new int3[height];
}
}
for(int z = 0; z < level; ++z)
{
for(int x = 0; x < width; ++x)
{
for(int y = 0; y < height; ++y)
{
h & terrain[z][x][y];
h & guardingCreaturePositions[z][x][y];
}
}
}
}
h & objects;
h & heroesOnMap;
h & teleportChannels;
h & towns;
h & artInstances;
// static members
h & CGKeys::playerKeyMap;
h & CGMagi::eyelist;
h & CGObelisk::obeliskCount;
h & CGObelisk::visited;
h & CGTownInstance::merchantArtifacts;
h & CGTownInstance::universitySkills;
h & instanceNames;
}
};
VCMI_LIB_NAMESPACE_END