2017-07-13 10:26:03 +02:00
|
|
|
/*
|
|
|
|
* CGameState.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
|
|
|
|
*
|
|
|
|
*/
|
2013-11-12 13:09:55 +03:00
|
|
|
#include "StdInc.h"
|
|
|
|
#include "CGameState.h"
|
|
|
|
|
|
|
|
#include "mapping/CCampaignHandler.h"
|
2014-06-05 14:19:47 +03:00
|
|
|
#include "mapObjects/CObjectClassesHandler.h"
|
2013-11-12 13:09:55 +03:00
|
|
|
#include "CArtHandler.h"
|
|
|
|
#include "CBuildingHandler.h"
|
|
|
|
#include "CGeneralTextHandler.h"
|
|
|
|
#include "CTownHandler.h"
|
2015-02-02 10:25:26 +02:00
|
|
|
#include "spells/CSpellHandler.h"
|
2013-11-12 13:09:55 +03:00
|
|
|
#include "CHeroHandler.h"
|
2014-06-05 14:19:47 +03:00
|
|
|
#include "mapObjects/CObjectHandler.h"
|
2013-11-12 13:09:55 +03:00
|
|
|
#include "CModHandler.h"
|
2023-03-15 21:34:29 +02:00
|
|
|
#include "GameSettings.h"
|
2023-01-09 01:17:37 +02:00
|
|
|
#include "TerrainHandler.h"
|
2017-08-30 12:35:23 +02:00
|
|
|
#include "CSkillHandler.h"
|
2013-11-12 13:09:55 +03:00
|
|
|
#include "mapping/CMap.h"
|
|
|
|
#include "mapping/CMapService.h"
|
|
|
|
#include "StartInfo.h"
|
|
|
|
#include "NetPacks.h"
|
2014-02-24 22:57:33 +03:00
|
|
|
#include "registerTypes/RegisterTypes.h"
|
2017-06-24 16:42:05 +02:00
|
|
|
#include "battle/BattleInfo.h"
|
2013-11-12 13:09:55 +03:00
|
|
|
#include "JsonNode.h"
|
|
|
|
#include "filesystem/Filesystem.h"
|
|
|
|
#include "GameConstants.h"
|
|
|
|
#include "rmg/CMapGenerator.h"
|
|
|
|
#include "CStopWatch.h"
|
2013-12-28 15:47:55 +03:00
|
|
|
#include "mapping/CMapEditManager.h"
|
2016-09-10 02:32:40 +02:00
|
|
|
#include "serializer/CTypeList.h"
|
|
|
|
#include "serializer/CMemorySerializer.h"
|
2017-06-04 19:33:28 +02:00
|
|
|
#include "VCMIDirs.h"
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2022-07-26 15:07:42 +02:00
|
|
|
VCMI_LIB_NAMESPACE_BEGIN
|
|
|
|
|
2017-06-14 06:59:41 +02:00
|
|
|
boost::shared_mutex CGameState::mutex;
|
|
|
|
|
2013-11-12 13:09:55 +03:00
|
|
|
template <typename T> class CApplyOnGS;
|
|
|
|
|
|
|
|
class CBaseForGSApply
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
virtual void applyOnGS(CGameState *gs, void *pack) const =0;
|
2023-03-13 23:26:44 +02:00
|
|
|
virtual ~CBaseForGSApply() = default;
|
2013-11-12 13:09:55 +03:00
|
|
|
template<typename U> static CBaseForGSApply *getApplier(const U * t=nullptr)
|
|
|
|
{
|
2017-07-16 11:58:05 +02:00
|
|
|
return new CApplyOnGS<U>();
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T> class CApplyOnGS : public CBaseForGSApply
|
|
|
|
{
|
|
|
|
public:
|
2015-10-12 15:47:10 +02:00
|
|
|
void applyOnGS(CGameState *gs, void *pack) const override
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
T *ptr = static_cast<T*>(pack);
|
|
|
|
|
2017-06-14 06:59:41 +02:00
|
|
|
boost::unique_lock<boost::shared_mutex> lock(CGameState::mutex);
|
2013-11-12 13:09:55 +03:00
|
|
|
ptr->applyGs(gs);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
void MetaString::getLocalString(const std::pair<ui8, ui32> & txt, std::string & dst) const
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
int type = txt.first;
|
|
|
|
int ser = txt.second;
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
if(type == ART_NAMES)
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * art = ArtifactID(ser).toArtifact(VLC->artifacts());
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
if(art)
|
2023-01-02 15:58:56 +02:00
|
|
|
dst = art->getNameTranslated();
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else
|
|
|
|
dst = "#!#";
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else if(type == ART_DESCR)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * art = ArtifactID(ser).toArtifact(VLC->artifacts());
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
if(art)
|
2023-01-02 15:58:56 +02:00
|
|
|
dst = art->getDescriptionTranslated();
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else
|
|
|
|
dst = "#!#";
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else if (type == ART_EVNTS)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * art = ArtifactID(ser).toArtifact(VLC->artifacts());
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
if(art)
|
2023-01-02 15:58:56 +02:00
|
|
|
dst = art->getEventTranslated();
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else
|
|
|
|
dst = "#!#";
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else if(type == CRE_PL_NAMES)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * cre = CreatureID(ser).toCreature(VLC->creatures());
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
if(cre)
|
2023-01-02 18:00:51 +02:00
|
|
|
dst = cre->getNamePluralTranslated();
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else
|
|
|
|
dst = "#!#";
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else if(type == CRE_SING_NAMES)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * cre = CreatureID(ser).toCreature(VLC->creatures());
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
if(cre)
|
2023-01-02 18:00:51 +02:00
|
|
|
dst = cre->getNameSingularTranslated();
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else
|
|
|
|
dst = "#!#";
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else if(type == MINE_NAMES)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2022-12-27 22:19:05 +02:00
|
|
|
dst = VLC->generaltexth->translate("core.minename", ser);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else if(type == MINE_EVNTS)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2022-12-27 22:19:05 +02:00
|
|
|
dst = VLC->generaltexth->translate("core.mineevnt", ser);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else if(type == SPELL_NAME)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * spell = SpellID(ser).toSpell(VLC->spells());
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
if(spell)
|
2023-01-02 00:06:42 +02:00
|
|
|
dst = spell->getNameTranslated();
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else
|
|
|
|
dst = "#!#";
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
else if(type == OBJ_NAMES)
|
2014-05-24 01:56:51 +03:00
|
|
|
{
|
2022-12-31 15:01:19 +02:00
|
|
|
dst = VLC->objtypeh->getObjectName(ser, 0);
|
2014-05-24 01:56:51 +03:00
|
|
|
}
|
2017-08-30 12:35:23 +02:00
|
|
|
else if(type == SEC_SKILL_NAME)
|
|
|
|
{
|
2023-01-01 22:20:41 +02:00
|
|
|
dst = VLC->skillh->getByIndex(ser)->getNameTranslated();
|
2017-08-30 12:35:23 +02:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
else
|
|
|
|
{
|
|
|
|
switch(type)
|
|
|
|
{
|
|
|
|
case GENERAL_TXT:
|
2023-01-01 20:54:05 +02:00
|
|
|
dst = VLC->generaltexth->translate("core.genrltxt", ser);
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
case RES_NAMES:
|
2022-12-27 22:19:05 +02:00
|
|
|
dst = VLC->generaltexth->translate("core.restypes", ser);
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
case ARRAY_TXT:
|
2022-12-27 22:19:05 +02:00
|
|
|
dst = VLC->generaltexth->translate("core.arraytxt", ser);
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
case CREGENS:
|
2023-01-10 16:25:25 +02:00
|
|
|
dst = VLC->objtypeh->getObjectName(Obj::CREATURE_GENERATOR1, ser);
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
case CREGENS4:
|
2023-01-10 16:25:25 +02:00
|
|
|
dst = VLC->objtypeh->getObjectName(Obj::CREATURE_GENERATOR4, ser);
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
case ADVOB_TXT:
|
2022-12-27 22:19:05 +02:00
|
|
|
dst = VLC->generaltexth->translate("core.advevent", ser);
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
case COLOR:
|
2022-12-27 22:19:05 +02:00
|
|
|
dst = VLC->generaltexth->translate("vcmi.capitalColors", ser);
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
2017-06-06 06:53:51 +02:00
|
|
|
case JK_TXT:
|
2022-12-27 22:19:05 +02:00
|
|
|
dst = VLC->generaltexth->translate("core.jktext", ser);
|
2017-06-06 06:53:51 +02:00
|
|
|
break;
|
2013-11-12 13:09:55 +03:00
|
|
|
default:
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->error("Failed string substitution because type is %d", type);
|
2013-11-12 13:09:55 +03:00
|
|
|
dst = "#@#";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
DLL_LINKAGE void MetaString::toString(std::string &dst) const
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
size_t exSt = 0;
|
|
|
|
size_t loSt = 0;
|
|
|
|
size_t nums = 0;
|
2013-11-12 13:09:55 +03:00
|
|
|
dst.clear();
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & elem : message)
|
2013-11-12 13:09:55 +03:00
|
|
|
{//TEXACT_STRING, TLOCAL_STRING, TNUMBER, TREPLACE_ESTRING, TREPLACE_LSTRING, TREPLACE_NUMBER
|
|
|
|
switch(elem)
|
|
|
|
{
|
|
|
|
case TEXACT_STRING:
|
|
|
|
dst += exactStrings[exSt++];
|
|
|
|
break;
|
|
|
|
case TLOCAL_STRING:
|
|
|
|
{
|
|
|
|
std::string hlp;
|
|
|
|
getLocalString(localStrings[loSt++], hlp);
|
|
|
|
dst += hlp;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TNUMBER:
|
2023-03-09 15:36:46 +02:00
|
|
|
dst += std::to_string(numbers[nums++]);
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
case TREPLACE_ESTRING:
|
|
|
|
boost::replace_first(dst, "%s", exactStrings[exSt++]);
|
|
|
|
break;
|
|
|
|
case TREPLACE_LSTRING:
|
|
|
|
{
|
|
|
|
std::string hlp;
|
|
|
|
getLocalString(localStrings[loSt++], hlp);
|
|
|
|
boost::replace_first(dst, "%s", hlp);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TREPLACE_NUMBER:
|
2023-03-09 15:36:46 +02:00
|
|
|
boost::replace_first(dst, "%d", std::to_string(numbers[nums++]));
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
case TREPLACE_PLUSNUMBER:
|
2023-03-09 15:36:46 +02:00
|
|
|
boost::replace_first(dst, "%+d", '+' + std::to_string(numbers[nums++]));
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
default:
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->error("MetaString processing error! Received message of type %d", int(elem));
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
DLL_LINKAGE std::string MetaString::toString() const
|
|
|
|
{
|
|
|
|
std::string ret;
|
|
|
|
toString(ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
DLL_LINKAGE std::string MetaString::buildList () const
|
|
|
|
///used to handle loot from creature bank
|
|
|
|
{
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
size_t exSt = 0;
|
|
|
|
size_t loSt = 0;
|
|
|
|
size_t nums = 0;
|
2013-11-12 13:09:55 +03:00
|
|
|
std::string lista;
|
|
|
|
for (int i = 0; i < message.size(); ++i)
|
|
|
|
{
|
|
|
|
if (i > 0 && (message[i] == TEXACT_STRING || message[i] == TLOCAL_STRING))
|
|
|
|
{
|
|
|
|
if (exSt == exactStrings.size() - 1)
|
|
|
|
lista += VLC->generaltexth->allTexts[141]; //" and "
|
|
|
|
else
|
|
|
|
lista += ", ";
|
|
|
|
}
|
|
|
|
switch (message[i])
|
|
|
|
{
|
|
|
|
case TEXACT_STRING:
|
|
|
|
lista += exactStrings[exSt++];
|
|
|
|
break;
|
|
|
|
case TLOCAL_STRING:
|
|
|
|
{
|
|
|
|
std::string hlp;
|
|
|
|
getLocalString (localStrings[loSt++], hlp);
|
|
|
|
lista += hlp;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TNUMBER:
|
2023-03-09 15:36:46 +02:00
|
|
|
lista += std::to_string(numbers[nums++]);
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
case TREPLACE_ESTRING:
|
|
|
|
lista.replace (lista.find("%s"), 2, exactStrings[exSt++]);
|
|
|
|
break;
|
|
|
|
case TREPLACE_LSTRING:
|
|
|
|
{
|
|
|
|
std::string hlp;
|
|
|
|
getLocalString (localStrings[loSt++], hlp);
|
|
|
|
lista.replace (lista.find("%s"), 2, hlp);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TREPLACE_NUMBER:
|
2023-03-09 15:36:46 +02:00
|
|
|
lista.replace (lista.find("%d"), 2, std::to_string(numbers[nums++]));
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
default:
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->error("MetaString processing error! Received message of type %d",int(message[i]));
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return lista;
|
|
|
|
}
|
|
|
|
|
2023-02-09 18:06:02 +02:00
|
|
|
void MetaString::addCreReplacement(const CreatureID & id, TQuantity count) //adds sing or plural name;
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
if (!count)
|
|
|
|
addReplacement (CRE_PL_NAMES, id); //no creatures - just empty name (eg. defeat Angels)
|
|
|
|
else if (count == 1)
|
|
|
|
addReplacement (CRE_SING_NAMES, id);
|
|
|
|
else
|
|
|
|
addReplacement (CRE_PL_NAMES, id);
|
|
|
|
}
|
|
|
|
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
void MetaString::addReplacement(const CStackBasicDescriptor & stack)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
assert(stack.type); //valid type
|
|
|
|
addCreReplacement(stack.type->idNumber, stack.count);
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
static CGObjectInstance * createObject(const Obj & id, int subid, const int3 & pos, const PlayerColor & owner)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
CGObjectInstance * nobj;
|
|
|
|
switch(id)
|
|
|
|
{
|
|
|
|
case Obj::HERO:
|
2014-05-16 23:50:02 +03:00
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
auto handler = VLC->objtypeh->getHandlerFor(id, VLC->heroh->objects[subid]->heroClass->getIndex());
|
2014-05-16 23:50:02 +03:00
|
|
|
nobj = handler->create(handler->getTemplates().front());
|
|
|
|
break;
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::TOWN:
|
2017-07-16 11:58:05 +02:00
|
|
|
nobj = new CGTownInstance();
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
default: //rest of objects
|
2017-07-16 11:58:05 +02:00
|
|
|
nobj = new CGObjectInstance();
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
nobj->ID = id;
|
|
|
|
nobj->subID = subid;
|
|
|
|
nobj->pos = pos;
|
|
|
|
nobj->tempOwner = owner;
|
2014-01-03 02:48:38 +03:00
|
|
|
if (id != Obj::HERO)
|
2014-05-16 23:50:02 +03:00
|
|
|
nobj->appearance = VLC->objtypeh->getHandlerFor(id, subid)->getTemplates().front();
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
return nobj;
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
CGHeroInstance * CGameState::HeroesPool::pickHeroFor(bool native,
|
|
|
|
const PlayerColor & player,
|
|
|
|
const CTown * town,
|
|
|
|
std::map<ui32, ConstTransitivePtr<CGHeroInstance>> & available,
|
|
|
|
CRandomGenerator & rand,
|
|
|
|
const CHeroClass * bannedClass) const
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
CGHeroInstance *ret = nullptr;
|
|
|
|
|
|
|
|
if(player>=PlayerColor::PLAYER_LIMIT)
|
|
|
|
{
|
2023-01-04 15:17:50 +02:00
|
|
|
logGlobal->error("Cannot pick hero for faction %s. Wrong owner!", town->faction->getJsonKey());
|
2013-11-12 13:09:55 +03:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<CGHeroInstance *> pool;
|
|
|
|
|
|
|
|
if(native)
|
|
|
|
{
|
|
|
|
for(auto & elem : available)
|
|
|
|
{
|
|
|
|
if(pavailable.find(elem.first)->second & 1<<player.getNum()
|
2023-01-04 15:17:50 +02:00
|
|
|
&& elem.second->type->heroClass->faction == town->faction->getIndex())
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
pool.push_back(elem.second); //get all available heroes
|
|
|
|
}
|
|
|
|
}
|
2023-03-13 23:26:44 +02:00
|
|
|
if(pool.empty())
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2017-08-12 13:36:04 +02:00
|
|
|
logGlobal->error("Cannot pick native hero for %s. Picking any...", player.getStr());
|
2014-03-17 22:51:07 +03:00
|
|
|
return pickHeroFor(false, player, town, available, rand);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-03-17 22:51:07 +03:00
|
|
|
ret = *RandomGeneratorUtil::nextItem(pool, rand);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
int sum = 0;
|
|
|
|
int r;
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
for(auto & elem : available)
|
|
|
|
{
|
|
|
|
if (pavailable.find(elem.first)->second & (1<<player.getNum()) && // hero is available
|
|
|
|
( !bannedClass || elem.second->type->heroClass != bannedClass) ) // and his class is not same as other hero
|
|
|
|
{
|
|
|
|
pool.push_back(elem.second);
|
2023-01-04 15:17:50 +02:00
|
|
|
sum += elem.second->type->heroClass->selectionProbability[town->faction->getIndex()]; //total weight
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
2023-03-13 23:26:44 +02:00
|
|
|
if(pool.empty() || sum == 0)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2017-08-12 13:36:04 +02:00
|
|
|
logGlobal->error("There are no heroes available for player %s!", player.getStr());
|
2013-11-12 13:09:55 +03:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2014-03-17 22:51:07 +03:00
|
|
|
r = rand.nextInt(sum - 1);
|
2013-11-12 13:09:55 +03:00
|
|
|
for (auto & elem : pool)
|
|
|
|
{
|
2023-01-04 15:17:50 +02:00
|
|
|
r -= elem->type->heroClass->selectionProbability[town->faction->getIndex()];
|
2013-11-12 13:09:55 +03:00
|
|
|
if(r < 0)
|
|
|
|
{
|
|
|
|
ret = elem;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(!ret)
|
|
|
|
ret = pool.back();
|
|
|
|
}
|
|
|
|
|
|
|
|
available.erase(ret->subID);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-01-30 21:56:31 +03:00
|
|
|
void CGameState::CrossoverHeroesList::addHeroToBothLists(CGHeroInstance * hero)
|
|
|
|
{
|
|
|
|
heroesFromPreviousScenario.push_back(hero);
|
|
|
|
heroesFromAnyPreviousScenarios.push_back(hero);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CGameState::CrossoverHeroesList::removeHeroFromBothLists(CGHeroInstance * hero)
|
|
|
|
{
|
|
|
|
heroesFromPreviousScenario -= hero;
|
|
|
|
heroesFromAnyPreviousScenarios -= hero;
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
CGameState::CampaignHeroReplacement::CampaignHeroReplacement(CGHeroInstance * hero, const ObjectInstanceID & heroPlaceholderId):
|
|
|
|
hero(hero),
|
|
|
|
heroPlaceholderId(heroPlaceholderId)
|
2014-01-30 21:56:31 +03:00
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
int CGameState::pickNextHeroType(const PlayerColor & owner)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
const PlayerSettings &ps = scenarioOps->getIthPlayersSettings(owner);
|
2013-12-28 15:47:55 +03:00
|
|
|
if(ps.hero >= 0 && !isUsedHero(HeroTypeID(ps.hero))) //we haven't used selected hero
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-12-28 15:47:55 +03:00
|
|
|
return ps.hero;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2013-12-28 15:47:55 +03:00
|
|
|
return pickUnusedHeroTypeRandomly(owner);
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
int CGameState::pickUnusedHeroTypeRandomly(const PlayerColor & owner)
|
2013-12-28 15:47:55 +03:00
|
|
|
{
|
2013-11-12 13:09:55 +03:00
|
|
|
//list of available heroes for this faction and others
|
2023-03-13 23:26:44 +02:00
|
|
|
std::vector<HeroTypeID> factionHeroes;
|
|
|
|
std::vector<HeroTypeID> otherHeroes;
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-28 15:47:55 +03:00
|
|
|
const PlayerSettings &ps = scenarioOps->getIthPlayersSettings(owner);
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const HeroTypeID & hid : getUnusedAllowedHeroes())
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
if(VLC->heroh->objects[hid.getNum()]->heroClass->faction == ps.castle)
|
2013-11-12 13:09:55 +03:00
|
|
|
factionHeroes.push_back(hid);
|
|
|
|
else
|
|
|
|
otherHeroes.push_back(hid);
|
|
|
|
}
|
|
|
|
|
|
|
|
// select random hero native to "our" faction
|
2014-03-17 22:51:07 +03:00
|
|
|
if(!factionHeroes.empty())
|
|
|
|
{
|
2016-08-22 00:58:52 +02:00
|
|
|
return RandomGeneratorUtil::nextItem(factionHeroes, getRandomGenerator())->getNum();
|
2014-03-17 22:51:07 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2017-08-12 13:36:04 +02:00
|
|
|
logGlobal->warn("Cannot find free hero of appropriate faction for player %s - trying to get first available...", owner.getStr());
|
2013-11-12 13:09:55 +03:00
|
|
|
if(!otherHeroes.empty())
|
2014-03-17 22:51:07 +03:00
|
|
|
{
|
2016-08-22 00:58:52 +02:00
|
|
|
return RandomGeneratorUtil::nextItem(otherHeroes, getRandomGenerator())->getNum();
|
2014-03-17 22:51:07 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->error("No free allowed heroes!");
|
2013-11-12 13:09:55 +03:00
|
|
|
auto notAllowedHeroesButStillBetterThanCrash = getUnusedAllowedHeroes(true);
|
2023-03-13 23:26:44 +02:00
|
|
|
if(!notAllowedHeroesButStillBetterThanCrash.empty())
|
2013-11-12 13:09:55 +03:00
|
|
|
return notAllowedHeroesButStillBetterThanCrash.begin()->getNum();
|
|
|
|
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->error("No free heroes at all!");
|
2013-11-12 13:09:55 +03:00
|
|
|
assert(0); //current code can't handle this situation
|
|
|
|
return -1; // no available heroes at all
|
|
|
|
}
|
|
|
|
|
|
|
|
std::pair<Obj,int> CGameState::pickObject (CGObjectInstance *obj)
|
|
|
|
{
|
|
|
|
switch(obj->ID)
|
|
|
|
{
|
|
|
|
case Obj::RANDOM_ART:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::ARTIFACT, VLC->arth->pickRandomArtifact(getRandomGenerator(), CArtifact::ART_TREASURE | CArtifact::ART_MINOR | CArtifact::ART_MAJOR | CArtifact::ART_RELIC));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_TREASURE_ART:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::ARTIFACT, VLC->arth->pickRandomArtifact(getRandomGenerator(), CArtifact::ART_TREASURE));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_MINOR_ART:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::ARTIFACT, VLC->arth->pickRandomArtifact(getRandomGenerator(), CArtifact::ART_MINOR));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_MAJOR_ART:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::ARTIFACT, VLC->arth->pickRandomArtifact(getRandomGenerator(), CArtifact::ART_MAJOR));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_RELIC_ART:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::ARTIFACT, VLC->arth->pickRandomArtifact(getRandomGenerator(), CArtifact::ART_RELIC));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_HERO:
|
2013-12-28 15:47:55 +03:00
|
|
|
return std::make_pair(Obj::HERO, pickNextHeroType(obj->tempOwner));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_MONSTER:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(getRandomGenerator()));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_MONSTER_L1:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(getRandomGenerator(), 1));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_MONSTER_L2:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(getRandomGenerator(), 2));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_MONSTER_L3:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(getRandomGenerator(), 3));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_MONSTER_L4:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(getRandomGenerator(), 4));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_RESOURCE:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::RESOURCE,getRandomGenerator().nextInt(6)); //now it's OH3 style, use %8 for mithril
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_TOWN:
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
PlayerColor align = PlayerColor((dynamic_cast<CGTownInstance *>(obj))->alignment);
|
2013-11-12 13:09:55 +03:00
|
|
|
si32 f; // can be negative (for random)
|
2023-03-13 23:26:44 +02:00
|
|
|
if(align >= PlayerColor::PLAYER_LIMIT) //same as owner / random
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
if(obj->tempOwner >= PlayerColor::PLAYER_LIMIT)
|
|
|
|
f = -1; //random
|
|
|
|
else
|
|
|
|
f = scenarioOps->getIthPlayersSettings(obj->tempOwner).castle;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
f = scenarioOps->getIthPlayersSettings(align).castle;
|
|
|
|
}
|
|
|
|
if(f<0)
|
|
|
|
{
|
|
|
|
do
|
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
f = getRandomGenerator().nextInt((int)VLC->townh->size() - 1);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
while ((*VLC->townh)[f]->town == nullptr); // find playable faction
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
return std::make_pair(Obj::TOWN,f);
|
|
|
|
}
|
|
|
|
case Obj::RANDOM_MONSTER_L5:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(getRandomGenerator(), 5));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_MONSTER_L6:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(getRandomGenerator(), 6));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_MONSTER_L7:
|
2016-08-22 00:58:52 +02:00
|
|
|
return std::make_pair(Obj::MONSTER, VLC->creh->pickRandomMonster(getRandomGenerator(), 7));
|
2013-11-12 13:09:55 +03:00
|
|
|
case Obj::RANDOM_DWELLING:
|
|
|
|
case Obj::RANDOM_DWELLING_LVL:
|
|
|
|
case Obj::RANDOM_DWELLING_FACTION:
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * dwl = dynamic_cast<CGDwelling *>(obj);
|
2013-11-12 13:09:55 +03:00
|
|
|
int faction;
|
|
|
|
|
|
|
|
//if castle alignment available
|
2023-03-13 23:26:44 +02:00
|
|
|
if(auto * info = dynamic_cast<CCreGenAsCastleInfo *>(dwl->info))
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
faction = getRandomGenerator().nextInt((int)VLC->townh->size() - 1);
|
2022-11-15 02:20:55 +02:00
|
|
|
if(info->asCastle && !info->instanceId.empty())
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2016-11-13 12:38:42 +02:00
|
|
|
auto iter = map->instanceNames.find(info->instanceId);
|
|
|
|
|
|
|
|
if(iter == map->instanceNames.end())
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->error("Map object not found: %s", info->instanceId);
|
2016-11-13 12:38:42 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
auto elem = iter->second;
|
|
|
|
if(elem->ID==Obj::RANDOM_TOWN)
|
|
|
|
{
|
|
|
|
randomizeObject(elem.get()); //we have to randomize the castle first
|
|
|
|
faction = elem->subID;
|
|
|
|
}
|
|
|
|
else if(elem->ID==Obj::TOWN)
|
|
|
|
faction = elem->subID;
|
|
|
|
else
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->error("Map object must be town: %s", info->instanceId);
|
2016-11-13 12:38:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(info->asCastle)
|
|
|
|
{
|
|
|
|
|
2013-11-12 13:09:55 +03:00
|
|
|
for(auto & elem : map->objects)
|
|
|
|
{
|
|
|
|
if(!elem)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if(elem->ID==Obj::RANDOM_TOWN
|
|
|
|
&& dynamic_cast<CGTownInstance*>(elem.get())->identifier == info->identifier)
|
|
|
|
{
|
|
|
|
randomizeObject(elem); //we have to randomize the castle first
|
|
|
|
faction = elem->subID;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if(elem->ID==Obj::TOWN
|
|
|
|
&& dynamic_cast<CGTownInstance*>(elem.get())->identifier == info->identifier)
|
|
|
|
{
|
|
|
|
faction = elem->subID;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-11-13 12:38:42 +02:00
|
|
|
std::set<int> temp;
|
|
|
|
|
|
|
|
for(int i = 0; i < info->allowedFactions.size(); i++)
|
|
|
|
if(info->allowedFactions[i])
|
|
|
|
temp.insert(i);
|
|
|
|
|
|
|
|
if(temp.empty())
|
|
|
|
logGlobal->error("Random faction selection failed. Nothing is allowed. Fall back to random.");
|
|
|
|
else
|
|
|
|
faction = *RandomGeneratorUtil::nextItem(temp, getRandomGenerator());
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else // castle alignment fixed
|
|
|
|
faction = obj->subID;
|
|
|
|
|
|
|
|
int level;
|
|
|
|
|
|
|
|
//if level set to range
|
2023-03-13 23:26:44 +02:00
|
|
|
if(auto * info = dynamic_cast<CCreGenLeveledInfo *>(dwl->info))
|
2014-03-17 22:51:07 +03:00
|
|
|
{
|
2016-08-22 00:58:52 +02:00
|
|
|
level = getRandomGenerator().nextInt(info->minLevel, info->maxLevel);
|
2014-03-17 22:51:07 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
else // fixed level
|
2014-03-17 22:51:07 +03:00
|
|
|
{
|
2013-11-12 13:09:55 +03:00
|
|
|
level = obj->subID;
|
2014-03-17 22:51:07 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
delete dwl->info;
|
|
|
|
dwl->info = nullptr;
|
|
|
|
|
|
|
|
std::pair<Obj, int> result(Obj::NO_OBJ, -1);
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
CreatureID cid = (*VLC->townh)[faction]->town->creatures[level][0];
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
//NOTE: this will pick last dwelling with this creature (Mantis #900)
|
|
|
|
//check for block map equality is better but more complex solution
|
2023-03-13 23:26:44 +02:00
|
|
|
auto testID = [&](const Obj & primaryID) -> void
|
2014-06-15 19:43:01 +03:00
|
|
|
{
|
|
|
|
auto dwellingIDs = VLC->objtypeh->knownSubObjects(primaryID);
|
|
|
|
for (si32 entry : dwellingIDs)
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * handler = dynamic_cast<const CDwellingInstanceConstructor *>(VLC->objtypeh->getHandlerFor(primaryID, entry).get());
|
2014-06-15 19:43:01 +03:00
|
|
|
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
if (handler->producesCreature(VLC->creh->objects[cid]))
|
2014-06-15 19:43:01 +03:00
|
|
|
result = std::make_pair(primaryID, entry);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
testID(Obj::CREATURE_GENERATOR1);
|
|
|
|
if (result.first == Obj::NO_OBJ)
|
|
|
|
testID(Obj::CREATURE_GENERATOR4);
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
if (result.first == Obj::NO_OBJ)
|
|
|
|
{
|
2023-01-04 15:17:50 +02:00
|
|
|
logGlobal->error("Error: failed to find dwelling for %s of level %d", (*VLC->townh)[faction]->getNameTranslated(), int(level));
|
2016-08-22 00:58:52 +02:00
|
|
|
result = std::make_pair(Obj::CREATURE_GENERATOR1, *RandomGeneratorUtil::nextItem(VLC->objtypeh->knownSubObjects(Obj::CREATURE_GENERATOR1), getRandomGenerator()));
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return std::make_pair(Obj::NO_OBJ,-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CGameState::randomizeObject(CGObjectInstance *cur)
|
|
|
|
{
|
|
|
|
std::pair<Obj,int> ran = pickObject(cur);
|
|
|
|
if(ran.first == Obj::NO_OBJ || ran.second<0) //this is not a random object, or we couldn't find anything
|
|
|
|
{
|
2014-05-24 01:56:51 +03:00
|
|
|
if(cur->ID==Obj::TOWN)
|
|
|
|
cur->setType(cur->ID, cur->subID); // update def, if necessary
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
else if(ran.first==Obj::HERO)//special code for hero
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * h = dynamic_cast<CGHeroInstance *>(cur);
|
2014-05-24 01:56:51 +03:00
|
|
|
cur->setType(ran.first, ran.second);
|
2023-03-13 23:26:44 +02:00
|
|
|
map->heroesOnMap.emplace_back(h);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
else if(ran.first==Obj::TOWN)//special code for town
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * t = dynamic_cast<CGTownInstance *>(cur);
|
2014-05-24 01:56:51 +03:00
|
|
|
cur->setType(ran.first, ran.second);
|
2023-03-13 23:26:44 +02:00
|
|
|
map->towns.emplace_back(t);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2014-11-06 13:28:34 +02:00
|
|
|
else
|
|
|
|
{
|
2015-10-31 19:23:13 +02:00
|
|
|
cur->setType(ran.first, ran.second);
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
int CGameState::getDate(Date::EDateType mode) const
|
|
|
|
{
|
|
|
|
int temp;
|
|
|
|
switch (mode)
|
|
|
|
{
|
|
|
|
case Date::DAY:
|
|
|
|
return day;
|
|
|
|
case Date::DAY_OF_WEEK: //day of week
|
|
|
|
temp = (day)%7; // 1 - Monday, 7 - Sunday
|
|
|
|
return temp ? temp : 7;
|
|
|
|
case Date::WEEK: //current week
|
|
|
|
temp = ((day-1)/7)+1;
|
|
|
|
if (!(temp%4))
|
|
|
|
return 4;
|
|
|
|
else
|
|
|
|
return (temp%4);
|
|
|
|
case Date::MONTH: //current month
|
|
|
|
return ((day-1)/28)+1;
|
|
|
|
case Date::DAY_OF_MONTH: //day of month
|
|
|
|
temp = (day)%28;
|
|
|
|
if (temp)
|
|
|
|
return temp;
|
|
|
|
else return 28;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
|
2013-11-12 13:09:55 +03:00
|
|
|
CGameState::CGameState()
|
|
|
|
{
|
|
|
|
gs = this;
|
2018-01-05 19:21:07 +02:00
|
|
|
applier = std::make_shared<CApplier<CBaseForGSApply>>();
|
|
|
|
registerTypesClientPacks1(*applier);
|
|
|
|
registerTypesClientPacks2(*applier);
|
2017-07-16 11:58:05 +02:00
|
|
|
//objCaller = new CObjectCallersHandler();
|
2013-11-12 13:09:55 +03:00
|
|
|
globalEffects.setDescription("Global effects");
|
2014-03-30 00:39:19 +03:00
|
|
|
globalEffects.setNodeType(CBonusSystemNode::GLOBAL_EFFECTS);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
|
2013-11-12 13:09:55 +03:00
|
|
|
CGameState::~CGameState()
|
|
|
|
{
|
|
|
|
map.dellNull();
|
|
|
|
curB.dellNull();
|
|
|
|
|
|
|
|
for(auto ptr : hpool.heroesPool) // clean hero pool
|
|
|
|
ptr.second.dellNull();
|
|
|
|
}
|
|
|
|
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
void CGameState::preInit(Services * services)
|
|
|
|
{
|
|
|
|
this->services = services;
|
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
void CGameState::init(const IMapService * mapService, StartInfo * si, bool allowSavingRandomMap)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
preInitAuto();
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->info("\tUsing random seed: %d", si->seedToBeUsed);
|
2016-08-22 00:58:52 +02:00
|
|
|
getRandomGenerator().setSeed(si->seedToBeUsed);
|
2014-02-09 00:54:35 +03:00
|
|
|
scenarioOps = CMemorySerializer::deepCopy(*si).release();
|
|
|
|
initialOpts = CMemorySerializer::deepCopy(*si).release();
|
2013-12-18 21:18:12 +03:00
|
|
|
si = nullptr;
|
|
|
|
|
|
|
|
switch(scenarioOps->mode)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-12-18 21:18:12 +03:00
|
|
|
case StartInfo::NEW_GAME:
|
2017-07-20 06:08:49 +02:00
|
|
|
initNewGame(mapService, allowSavingRandomMap);
|
2013-12-18 21:18:12 +03:00
|
|
|
break;
|
|
|
|
case StartInfo::CAMPAIGN:
|
2018-01-05 19:21:07 +02:00
|
|
|
initCampaign();
|
2013-12-18 21:18:12 +03:00
|
|
|
break;
|
|
|
|
default:
|
2017-08-12 14:43:41 +02:00
|
|
|
logGlobal->error("Wrong mode: %d", static_cast<int>(scenarioOps->mode));
|
2013-12-18 21:18:12 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
VLC->arth->initAllowedArtifactsList(map->allowedArtifact);
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->info("Map loaded!");
|
2013-12-18 21:18:12 +03:00
|
|
|
|
|
|
|
checkMapChecksum();
|
|
|
|
|
|
|
|
day = 0;
|
|
|
|
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("Initialization:");
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2023-02-19 20:42:51 +02:00
|
|
|
initGlobalBonuses();
|
2013-12-28 15:47:55 +03:00
|
|
|
initPlayerStates();
|
|
|
|
placeCampaignHeroes();
|
2013-12-18 21:18:12 +03:00
|
|
|
initGrailPosition();
|
|
|
|
initRandomFactionsForPlayers();
|
|
|
|
randomizeMapObjects();
|
|
|
|
placeStartingHeroes();
|
|
|
|
initStartingResources();
|
|
|
|
initHeroes();
|
|
|
|
initStartingBonus();
|
|
|
|
initTowns();
|
2022-12-05 13:02:55 +02:00
|
|
|
placeHeroesInTowns();
|
2013-12-18 21:18:12 +03:00
|
|
|
initMapObjects();
|
|
|
|
buildBonusSystemTree();
|
|
|
|
initVisitingAndGarrisonedHeroes();
|
2014-02-09 22:47:23 +03:00
|
|
|
initFogOfWar();
|
2013-12-18 21:18:12 +03:00
|
|
|
|
2016-08-29 22:07:52 +02:00
|
|
|
// Explicitly initialize static variables
|
|
|
|
for(auto & elem : players)
|
|
|
|
{
|
2016-08-30 07:50:38 +02:00
|
|
|
CGKeys::playerKeyMap[elem.first] = std::set<ui8>();
|
2016-08-29 22:07:52 +02:00
|
|
|
}
|
|
|
|
for(auto & elem : teams)
|
|
|
|
{
|
|
|
|
CGObelisk::visited[elem.first] = 0;
|
|
|
|
}
|
|
|
|
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tChecking objectives");
|
2013-12-18 21:18:12 +03:00
|
|
|
map->checkForObjectives(); //needs to be run when all objects are properly placed
|
|
|
|
|
2016-08-22 00:58:52 +02:00
|
|
|
auto seedAfterInit = getRandomGenerator().nextInt();
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->info("Seed after init is %d (before was %d)", seedAfterInit, scenarioOps->seedToBeUsed);
|
2013-12-18 21:18:12 +03:00
|
|
|
if(scenarioOps->seedPostInit > 0)
|
|
|
|
{
|
|
|
|
//RNG must be in the same state on all machines when initialization is done (otherwise we have desync)
|
|
|
|
assert(scenarioOps->seedPostInit == seedAfterInit);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
scenarioOps->seedPostInit = seedAfterInit; //store the post init "seed"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
void CGameState::updateEntity(Metatype metatype, int32_t index, const JsonNode & data)
|
|
|
|
{
|
|
|
|
switch(metatype)
|
|
|
|
{
|
|
|
|
case Metatype::ARTIFACT_INSTANCE:
|
|
|
|
logGlobal->error("Artifact instance update is not implemented");
|
|
|
|
break;
|
|
|
|
case Metatype::CREATURE_INSTANCE:
|
|
|
|
logGlobal->error("Creature instance update is not implemented");
|
|
|
|
break;
|
|
|
|
case Metatype::HERO_INSTANCE:
|
|
|
|
//index is hero type
|
|
|
|
if(index >= 0 && index < map->allHeroes.size())
|
|
|
|
{
|
|
|
|
CGHeroInstance * hero = map->allHeroes.at(index);
|
|
|
|
hero->updateFrom(data);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
logGlobal->error("Update entity: hero index %s is out of range [%d,%d]", index, 0, map->allHeroes.size());
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Metatype::MAP_OBJECT_INSTANCE:
|
|
|
|
if(index >= 0 && index < map->objects.size())
|
|
|
|
{
|
|
|
|
CGObjectInstance * obj = getObjInstance(ObjectInstanceID(index));
|
|
|
|
obj->updateFrom(data);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
logGlobal->error("Update entity: object index %s is out of range [%d,%d]", index, 0, map->objects.size());
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
services->updateEntity(metatype, index, data);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-05 19:21:07 +02:00
|
|
|
void CGameState::updateOnLoad(StartInfo * si)
|
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
preInitAuto();
|
2018-01-05 19:21:07 +02:00
|
|
|
scenarioOps->playerInfos = si->playerInfos;
|
|
|
|
for(auto & i : si->playerInfos)
|
|
|
|
gs->players[i.first].human = i.second.isControlledByHuman();
|
|
|
|
}
|
|
|
|
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
void CGameState::preInitAuto()
|
|
|
|
{
|
|
|
|
if(services == nullptr)
|
|
|
|
{
|
|
|
|
logGlobal->error("Game state preinit missing");
|
|
|
|
preInit(VLC);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
void CGameState::initNewGame(const IMapService * mapService, bool allowSavingRandomMap)
|
2013-12-18 21:18:12 +03:00
|
|
|
{
|
|
|
|
if(scenarioOps->createRandomMap())
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->info("Create random map.");
|
2013-12-18 21:18:12 +03:00
|
|
|
CStopWatch sw;
|
|
|
|
|
|
|
|
// Gen map
|
2022-05-28 15:03:50 +02:00
|
|
|
CMapGenerator mapGenerator(*scenarioOps->mapGenOptions, scenarioOps->seedToBeUsed);
|
2013-12-18 21:18:12 +03:00
|
|
|
|
2022-05-28 15:03:50 +02:00
|
|
|
std::unique_ptr<CMap> randomMap = mapGenerator.generate();
|
2017-06-04 19:33:28 +02:00
|
|
|
|
|
|
|
if(allowSavingRandomMap)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
auto path = VCMIDirs::get().userCachePath() / "RandomMaps";
|
|
|
|
boost::filesystem::create_directories(path);
|
|
|
|
|
|
|
|
std::shared_ptr<CMapGenOptions> options = scenarioOps->mapGenOptions;
|
|
|
|
|
|
|
|
const std::string templateName = options->getMapTemplate()->getName();
|
|
|
|
const ui32 seed = scenarioOps->seedToBeUsed;
|
|
|
|
|
|
|
|
const std::string fileName = boost::str(boost::format("%s_%d.vmap") % templateName % seed );
|
|
|
|
const auto fullPath = path / fileName;
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
mapService->saveMap(randomMap, fullPath);
|
2017-06-04 19:33:28 +02:00
|
|
|
|
|
|
|
logGlobal->info("Random map has been saved to:");
|
|
|
|
logGlobal->info(fullPath.string());
|
|
|
|
}
|
|
|
|
catch(...)
|
|
|
|
{
|
|
|
|
logGlobal->error("Saving random map failed with exception");
|
|
|
|
handleException();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
map = randomMap.release();
|
2013-12-18 21:18:12 +03:00
|
|
|
// Update starting options
|
|
|
|
for(int i = 0; i < map->players.size(); ++i)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-12-18 21:18:12 +03:00
|
|
|
const auto & playerInfo = map->players[i];
|
|
|
|
if(playerInfo.canAnyonePlay())
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-12-18 21:18:12 +03:00
|
|
|
PlayerSettings & playerSettings = scenarioOps->playerInfos[PlayerColor(i)];
|
|
|
|
playerSettings.compOnly = !playerInfo.canHumanPlay;
|
|
|
|
playerSettings.team = playerInfo.team;
|
|
|
|
playerSettings.castle = playerInfo.defaultCastle();
|
2018-01-05 19:21:07 +02:00
|
|
|
if(playerSettings.isControlledByAI() && playerSettings.name.empty())
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-12-18 21:18:12 +03:00
|
|
|
playerSettings.name = VLC->generaltexth->allTexts[468];
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
playerSettings.color = PlayerColor(i);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
scenarioOps->playerInfos.erase(PlayerColor(i));
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-10 18:39:27 +02:00
|
|
|
logGlobal->info("Generated random map in %i ms.", sw.getDiff());
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
|
|
|
else
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->info("Open map file: %s", scenarioOps->mapname);
|
2017-06-04 21:42:48 +02:00
|
|
|
const ResourceID mapURI(scenarioOps->mapname, EResType::MAP);
|
2017-07-20 06:08:49 +02:00
|
|
|
map = mapService->loadMap(mapURI).release();
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2018-01-05 19:21:07 +02:00
|
|
|
void CGameState::initCampaign()
|
2013-12-18 21:18:12 +03:00
|
|
|
{
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->info("Open campaign map file: %d", scenarioOps->campState->currentMap.get());
|
2018-01-05 19:21:07 +02:00
|
|
|
map = scenarioOps->campState->getMap();
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
void CGameState::checkMapChecksum()
|
|
|
|
{
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->info("\tOur checksum for the map: %d", map->checksum);
|
2013-11-12 13:09:55 +03:00
|
|
|
if(scenarioOps->mapfileChecksum)
|
|
|
|
{
|
2017-08-12 13:36:04 +02:00
|
|
|
logGlobal->info("\tServer checksum for %s: %d", scenarioOps->mapname, scenarioOps->mapfileChecksum);
|
2013-11-12 13:09:55 +03:00
|
|
|
if(map->checksum != scenarioOps->mapfileChecksum)
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->error("Wrong map checksum!!!");
|
2013-11-12 13:09:55 +03:00
|
|
|
throw std::runtime_error("Wrong checksum");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2013-12-18 21:18:12 +03:00
|
|
|
{
|
2013-11-12 13:09:55 +03:00
|
|
|
scenarioOps->mapfileChecksum = map->checksum;
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2023-02-19 20:42:51 +02:00
|
|
|
void CGameState::initGlobalBonuses()
|
|
|
|
{
|
2023-03-15 23:47:26 +02:00
|
|
|
const JsonNode & baseBonuses = VLC->settings()->getValue(EGameSettings::BONUSES_GLOBAL);
|
2023-02-19 20:42:51 +02:00
|
|
|
logGlobal->debug("\tLoading global bonuses");
|
2023-03-15 21:34:29 +02:00
|
|
|
for(const auto & b : baseBonuses.Struct())
|
2023-02-19 20:42:51 +02:00
|
|
|
{
|
2023-03-15 21:34:29 +02:00
|
|
|
auto bonus = JsonUtils::parseBonus(b.second);
|
2023-02-19 20:42:51 +02:00
|
|
|
bonus->source = Bonus::GLOBAL;//for all
|
|
|
|
bonus->sid = -1; //there is one global object
|
|
|
|
globalEffects.addNewBonus(bonus);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
void CGameState::initGrailPosition()
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tPicking grail position");
|
2013-12-18 21:18:12 +03:00
|
|
|
//pick grail location
|
2016-01-31 17:01:58 +02:00
|
|
|
if(map->grailPos.x < 0 || map->grailRadius) //grail not set or set within a radius around some place
|
2013-12-18 21:18:12 +03:00
|
|
|
{
|
2016-01-31 17:01:58 +02:00
|
|
|
if(!map->grailRadius) //radius not given -> anywhere on map
|
|
|
|
map->grailRadius = map->width * 2;
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
std::vector<int3> allowedPos;
|
2013-11-12 13:09:55 +03:00
|
|
|
static const int BORDER_WIDTH = 9; // grail must be at least 9 tiles away from border
|
|
|
|
|
|
|
|
// add all not blocked tiles in range
|
2022-09-18 16:39:10 +02:00
|
|
|
|
|
|
|
for (int z = 0; z < map->levels(); z++)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2022-09-18 16:39:10 +02:00
|
|
|
for(int x = BORDER_WIDTH; x < map->width - BORDER_WIDTH ; x++)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2022-09-18 16:39:10 +02:00
|
|
|
for(int y = BORDER_WIDTH; y < map->height - BORDER_WIDTH; y++)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2022-09-18 16:39:10 +02:00
|
|
|
const TerrainTile &t = map->getTile(int3(x, y, z));
|
2013-11-12 13:09:55 +03:00
|
|
|
if(!t.blocked
|
|
|
|
&& !t.visitable
|
2022-09-21 11:34:23 +02:00
|
|
|
&& t.terType->isLand()
|
|
|
|
&& t.terType->isPassable()
|
2022-09-18 16:39:10 +02:00
|
|
|
&& (int)map->grailPos.dist2dSQ(int3(x, y, z)) <= (map->grailRadius * map->grailRadius))
|
2023-03-13 23:26:44 +02:00
|
|
|
allowedPos.emplace_back(x, y, z);
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
//remove tiles with holes
|
|
|
|
for(auto & elem : map->objects)
|
|
|
|
if(elem && elem->ID == Obj::HOLE)
|
|
|
|
allowedPos -= elem->pos;
|
|
|
|
|
2014-03-17 22:51:07 +03:00
|
|
|
if(!allowedPos.empty())
|
|
|
|
{
|
2016-08-22 00:58:52 +02:00
|
|
|
map->grailPos = *RandomGeneratorUtil::nextItem(allowedPos, getRandomGenerator());
|
2014-03-17 22:51:07 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
else
|
2014-03-17 22:51:07 +03:00
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->warn("Grail cannot be placed, no appropriate tile found!");
|
2014-03-17 22:51:07 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
void CGameState::initRandomFactionsForPlayers()
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tPicking random factions for players");
|
2013-11-12 13:09:55 +03:00
|
|
|
for(auto & elem : scenarioOps->playerInfos)
|
|
|
|
{
|
|
|
|
if(elem.second.castle==-1)
|
|
|
|
{
|
2020-10-01 10:38:06 +02:00
|
|
|
auto randomID = getRandomGenerator().nextInt((int)map->players[elem.first.getNum()].allowedFactions.size() - 1);
|
2013-11-12 13:09:55 +03:00
|
|
|
auto iter = map->players[elem.first.getNum()].allowedFactions.begin();
|
|
|
|
std::advance(iter, randomID);
|
|
|
|
|
|
|
|
elem.second.castle = *iter;
|
|
|
|
}
|
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
void CGameState::randomizeMapObjects()
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tRandomizing objects");
|
2013-11-12 13:09:55 +03:00
|
|
|
for(CGObjectInstance *obj : map->objects)
|
|
|
|
{
|
2013-12-18 21:18:12 +03:00
|
|
|
if(!obj) continue;
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
randomizeObject(obj);
|
|
|
|
|
|
|
|
//handle Favouring Winds - mark tiles under it
|
|
|
|
if(obj->ID == Obj::FAVORABLE_WINDS)
|
2013-12-18 21:18:12 +03:00
|
|
|
{
|
2013-11-12 13:09:55 +03:00
|
|
|
for (int i = 0; i < obj->getWidth() ; i++)
|
2013-12-18 21:18:12 +03:00
|
|
|
{
|
2013-11-12 13:09:55 +03:00
|
|
|
for (int j = 0; j < obj->getHeight() ; j++)
|
|
|
|
{
|
|
|
|
int3 pos = obj->pos - int3(i,j,0);
|
2013-12-18 21:18:12 +03:00
|
|
|
if(map->isInTheMap(pos)) map->getTile(pos).extTileFlags |= 128;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
void CGameState::initPlayerStates()
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tCreating player entries in gs");
|
2013-11-12 13:09:55 +03:00
|
|
|
for(auto & elem : scenarioOps->playerInfos)
|
|
|
|
{
|
2015-10-25 22:44:25 +02:00
|
|
|
PlayerState & p = players[elem.first];
|
|
|
|
p.color=elem.first;
|
2018-01-05 19:21:07 +02:00
|
|
|
p.human = elem.second.isControlledByHuman();
|
2015-10-25 22:44:25 +02:00
|
|
|
p.team = map->players[elem.first.getNum()].team;
|
|
|
|
teams[p.team].id = p.team;//init team
|
|
|
|
teams[p.team].players.insert(elem.first);//add player to team
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-28 15:47:55 +03:00
|
|
|
void CGameState::placeCampaignHeroes()
|
2013-12-18 21:18:12 +03:00
|
|
|
{
|
2013-11-12 13:09:55 +03:00
|
|
|
if (scenarioOps->campState)
|
|
|
|
{
|
2013-12-28 15:47:55 +03:00
|
|
|
// place bonus hero
|
|
|
|
auto campaignBonus = scenarioOps->campState->getBonusForCurrentMap();
|
|
|
|
bool campaignGiveHero = campaignBonus && campaignBonus.get().type == CScenarioTravel::STravelBonus::HERO;
|
|
|
|
|
|
|
|
if(campaignGiveHero)
|
|
|
|
{
|
|
|
|
auto playerColor = PlayerColor(campaignBonus->info1);
|
|
|
|
auto it = scenarioOps->playerInfos.find(playerColor);
|
|
|
|
if(it != scenarioOps->playerInfos.end())
|
|
|
|
{
|
|
|
|
auto heroTypeId = campaignBonus->info2;
|
|
|
|
if(heroTypeId == 0xffff) // random bonus hero
|
|
|
|
{
|
|
|
|
heroTypeId = pickUnusedHeroTypeRandomly(playerColor);
|
|
|
|
}
|
|
|
|
|
|
|
|
placeStartingHero(playerColor, HeroTypeID(heroTypeId), map->players[playerColor.getNum()].posOfMainTown);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// replace heroes placeholders
|
2014-01-30 21:56:31 +03:00
|
|
|
auto crossoverHeroes = getCrossoverHeroesFromPreviousScenarios();
|
2013-12-20 16:07:58 +03:00
|
|
|
|
2014-01-30 21:56:31 +03:00
|
|
|
if(!crossoverHeroes.heroesFromAnyPreviousScenarios.empty())
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tGenerate list of hero placeholders");
|
2014-01-30 21:56:31 +03:00
|
|
|
auto campaignHeroReplacements = generateCampaignHeroesToReplace(crossoverHeroes);
|
|
|
|
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tPrepare crossover heroes");
|
2014-01-30 21:56:31 +03:00
|
|
|
prepareCrossoverHeroes(campaignHeroReplacements, scenarioOps->campState->getCurrentScenario().travelOptions);
|
2013-12-28 15:47:55 +03:00
|
|
|
|
|
|
|
// remove same heroes on the map which will be added through crossover heroes
|
2013-12-30 18:34:28 +03:00
|
|
|
// INFO: we will remove heroes because later it may be possible that the API doesn't allow having heroes
|
|
|
|
// with the same hero type id
|
|
|
|
std::vector<CGHeroInstance *> removedHeroes;
|
|
|
|
|
|
|
|
for(auto & campaignHeroReplacement : campaignHeroReplacements)
|
2013-12-28 15:47:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * hero = getUsedHero(HeroTypeID(campaignHeroReplacement.hero->subID));
|
2013-12-30 18:34:28 +03:00
|
|
|
if(hero)
|
|
|
|
{
|
|
|
|
removedHeroes.push_back(hero);
|
|
|
|
map->heroesOnMap -= hero;
|
|
|
|
map->objects[hero->id.getNum()] = nullptr;
|
|
|
|
map->removeBlockVisTiles(hero, true);
|
|
|
|
}
|
|
|
|
}
|
2013-12-20 16:07:58 +03:00
|
|
|
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tReplace placeholders with heroes");
|
2013-12-28 15:47:55 +03:00
|
|
|
replaceHeroesPlaceholders(campaignHeroReplacements);
|
2013-12-30 18:34:28 +03:00
|
|
|
|
|
|
|
// now add removed heroes again with unused type ID
|
2023-03-13 23:26:44 +02:00
|
|
|
for(auto * hero : removedHeroes)
|
2013-12-30 18:34:28 +03:00
|
|
|
{
|
|
|
|
si32 heroTypeId = 0;
|
|
|
|
if(hero->ID == Obj::HERO)
|
|
|
|
{
|
|
|
|
heroTypeId = pickUnusedHeroTypeRandomly(hero->tempOwner);
|
|
|
|
}
|
|
|
|
else if(hero->ID == Obj::PRISON)
|
|
|
|
{
|
|
|
|
auto unusedHeroTypeIds = getUnusedAllowedHeroes();
|
|
|
|
if(!unusedHeroTypeIds.empty())
|
|
|
|
{
|
2016-08-22 00:58:52 +02:00
|
|
|
heroTypeId = (*RandomGeneratorUtil::nextItem(unusedHeroTypeIds, getRandomGenerator())).getNum();
|
2013-12-30 18:34:28 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->error("No free hero type ID found to replace prison.");
|
2013-12-30 18:34:28 +03:00
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
assert(0); // should not happen
|
|
|
|
}
|
|
|
|
|
|
|
|
hero->subID = heroTypeId;
|
|
|
|
hero->portrait = hero->subID;
|
2016-11-13 12:38:42 +02:00
|
|
|
map->getEditManager()->insertObject(hero);
|
2013-12-30 18:34:28 +03:00
|
|
|
}
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
|
|
|
}
|
2023-02-21 18:42:31 +02:00
|
|
|
|
|
|
|
// remove hero placeholders on map
|
|
|
|
for(auto obj : map->objects)
|
|
|
|
{
|
|
|
|
if(obj && obj->ID == Obj::HERO_PLACEHOLDER)
|
|
|
|
{
|
|
|
|
auto heroPlaceholder = dynamic_cast<CGHeroPlaceholder *>(obj.get());
|
|
|
|
map->removeBlockVisTiles(heroPlaceholder, true);
|
|
|
|
map->instanceNames.erase(obj->instanceName);
|
|
|
|
map->objects[heroPlaceholder->id.getNum()] = nullptr;
|
|
|
|
delete heroPlaceholder;
|
|
|
|
}
|
|
|
|
}
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
void CGameState::placeStartingHero(const PlayerColor & playerColor, const HeroTypeID & heroTypeId, int3 townPos)
|
2013-12-28 15:47:55 +03:00
|
|
|
{
|
2022-10-19 00:54:06 +02:00
|
|
|
for(auto town : map->towns)
|
|
|
|
{
|
|
|
|
if(town->getPosition() == townPos)
|
|
|
|
{
|
|
|
|
townPos = town->visitablePos();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-12-28 15:47:55 +03:00
|
|
|
|
2016-11-13 12:38:42 +02:00
|
|
|
CGObjectInstance * hero = createObject(Obj::HERO, heroTypeId.getNum(), townPos, playerColor);
|
|
|
|
hero->pos += hero->getVisitableOffset();
|
|
|
|
map->getEditManager()->insertObject(hero);
|
2013-12-28 15:47:55 +03:00
|
|
|
}
|
|
|
|
|
2014-01-30 21:56:31 +03:00
|
|
|
CGameState::CrossoverHeroesList CGameState::getCrossoverHeroesFromPreviousScenarios() const
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
2014-01-30 21:56:31 +03:00
|
|
|
CrossoverHeroesList crossoverHeroes;
|
2013-12-20 16:07:58 +03:00
|
|
|
|
|
|
|
auto campaignState = scenarioOps->campState;
|
|
|
|
auto bonus = campaignState->getBonusForCurrentMap();
|
2021-06-18 19:57:07 +02:00
|
|
|
if(bonus && bonus->type == CScenarioTravel::STravelBonus::HEROES_FROM_PREVIOUS_SCENARIO)
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
2018-01-05 19:21:07 +02:00
|
|
|
std::vector<CGHeroInstance *> heroes;
|
|
|
|
for(auto & node : campaignState->camp->scenarios[bonus->info2].crossoverHeroes)
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * h = CCampaignState::crossoverDeserialize(node);
|
2018-01-05 19:21:07 +02:00
|
|
|
heroes.push_back(h);
|
|
|
|
}
|
|
|
|
crossoverHeroes.heroesFromAnyPreviousScenarios = crossoverHeroes.heroesFromPreviousScenario = heroes;
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(!campaignState->mapsConquered.empty())
|
|
|
|
{
|
2021-06-18 19:57:07 +02:00
|
|
|
std::vector<CGHeroInstance *> heroes = {};
|
|
|
|
|
2018-01-05 19:21:07 +02:00
|
|
|
crossoverHeroes.heroesFromAnyPreviousScenarios = crossoverHeroes.heroesFromPreviousScenario = heroes;
|
|
|
|
crossoverHeroes.heroesFromPreviousScenario = heroes;
|
2014-01-30 21:56:31 +03:00
|
|
|
|
|
|
|
for(auto mapNr : campaignState->mapsConquered)
|
|
|
|
{
|
|
|
|
// create a list of deleted heroes
|
|
|
|
auto & scenario = campaignState->camp->scenarios[mapNr];
|
|
|
|
auto lostCrossoverHeroes = scenario.getLostCrossoverHeroes();
|
|
|
|
|
|
|
|
// remove heroes which didn't reached the end of the scenario, but were available at the start
|
2023-03-13 23:26:44 +02:00
|
|
|
for(auto * hero : lostCrossoverHeroes)
|
2014-01-30 21:56:31 +03:00
|
|
|
{
|
2021-06-18 19:57:07 +02:00
|
|
|
// auto hero = CCampaignState::crossoverDeserialize(node);
|
2018-01-05 19:21:07 +02:00
|
|
|
vstd::erase_if(crossoverHeroes.heroesFromAnyPreviousScenarios, [hero](CGHeroInstance * h)
|
|
|
|
{
|
|
|
|
return hero->subID == h->subID;
|
|
|
|
});
|
2014-01-30 21:56:31 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// now add heroes which completed the scenario
|
2018-01-05 19:21:07 +02:00
|
|
|
for(auto node : scenario.crossoverHeroes)
|
2014-01-30 21:56:31 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * hero = CCampaignState::crossoverDeserialize(node);
|
2014-01-30 21:56:31 +03:00
|
|
|
// add new heroes and replace old heroes with newer ones
|
2021-06-18 19:57:07 +02:00
|
|
|
auto it = range::find_if(crossoverHeroes.heroesFromAnyPreviousScenarios, [hero](CGHeroInstance * h)
|
2018-01-05 19:21:07 +02:00
|
|
|
{
|
|
|
|
return hero->subID == h->subID;
|
|
|
|
});
|
2021-06-18 19:57:07 +02:00
|
|
|
|
|
|
|
if(it != crossoverHeroes.heroesFromAnyPreviousScenarios.end())
|
2014-02-26 22:51:44 +03:00
|
|
|
{
|
|
|
|
// replace old hero with newer one
|
|
|
|
crossoverHeroes.heroesFromAnyPreviousScenarios[it - crossoverHeroes.heroesFromAnyPreviousScenarios.begin()] = hero;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// add new hero
|
|
|
|
crossoverHeroes.heroesFromAnyPreviousScenarios.push_back(hero);
|
|
|
|
}
|
2021-06-18 19:57:07 +02:00
|
|
|
|
|
|
|
if(mapNr == campaignState->mapsConquered.back())
|
|
|
|
{
|
|
|
|
crossoverHeroes.heroesFromPreviousScenario.push_back(hero);
|
|
|
|
}
|
2014-01-30 21:56:31 +03:00
|
|
|
}
|
|
|
|
}
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-09 01:14:54 +03:00
|
|
|
return crossoverHeroes;
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
|
|
|
|
2016-09-09 19:30:36 +02:00
|
|
|
void CGameState::prepareCrossoverHeroes(std::vector<CGameState::CampaignHeroReplacement> & campaignHeroReplacements, const CScenarioTravel & travelOptions)
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
2014-01-30 21:56:31 +03:00
|
|
|
// create heroes list for convenience iterating
|
|
|
|
std::vector<CGHeroInstance *> crossoverHeroes;
|
2023-03-13 23:26:44 +02:00
|
|
|
crossoverHeroes.reserve(campaignHeroReplacements.size());
|
2014-01-30 21:56:31 +03:00
|
|
|
for(auto & campaignHeroReplacement : campaignHeroReplacements)
|
|
|
|
{
|
|
|
|
crossoverHeroes.push_back(campaignHeroReplacement.hero);
|
|
|
|
}
|
2013-12-20 16:07:58 +03:00
|
|
|
|
2014-02-09 01:14:54 +03:00
|
|
|
// TODO replace magic numbers with named constants
|
|
|
|
// TODO this logic (what should be kept) should be part of CScenarioTravel and be exposed via some clean set of methods
|
2014-01-03 19:36:22 +03:00
|
|
|
if(!(travelOptions.whatHeroKeeps & 1))
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
|
|
|
//trimming experience
|
|
|
|
for(CGHeroInstance * cgh : crossoverHeroes)
|
|
|
|
{
|
2016-09-09 19:30:36 +02:00
|
|
|
cgh->initExp(getRandomGenerator());
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
|
|
|
}
|
2014-01-03 19:36:22 +03:00
|
|
|
|
|
|
|
if(!(travelOptions.whatHeroKeeps & 2))
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
|
|
|
//trimming prim skills
|
|
|
|
for(CGHeroInstance * cgh : crossoverHeroes)
|
|
|
|
{
|
|
|
|
for(int g=0; g<GameConstants::PRIMARY_SKILLS; ++g)
|
|
|
|
{
|
2020-11-11 21:43:40 +02:00
|
|
|
auto sel = Selector::type()(Bonus::PRIMARY_SKILL)
|
|
|
|
.And(Selector::subtype()(g))
|
|
|
|
.And(Selector::sourceType()(Bonus::HERO_BASE_SKILL));
|
2013-12-20 16:07:58 +03:00
|
|
|
|
|
|
|
cgh->getBonusLocalFirst(sel)->val = cgh->type->heroClass->primarySkillInitial[g];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-01-03 19:36:22 +03:00
|
|
|
|
|
|
|
if(!(travelOptions.whatHeroKeeps & 4))
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
|
|
|
//trimming sec skills
|
|
|
|
for(CGHeroInstance * cgh : crossoverHeroes)
|
|
|
|
{
|
|
|
|
cgh->secSkills = cgh->type->secSkillsInit;
|
2014-02-09 02:07:33 +03:00
|
|
|
cgh->recreateSecondarySkillsBonuses();
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
|
|
|
}
|
2014-01-03 19:36:22 +03:00
|
|
|
|
2014-03-07 16:21:09 +03:00
|
|
|
if(!(travelOptions.whatHeroKeeps & 8))
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
|
|
|
for(CGHeroInstance * cgh : crossoverHeroes)
|
|
|
|
{
|
2018-12-20 23:42:31 +02:00
|
|
|
cgh->removeSpellbook();
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
|
|
|
}
|
2014-01-03 19:36:22 +03:00
|
|
|
|
|
|
|
if(!(travelOptions.whatHeroKeeps & 16))
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
|
|
|
//trimming artifacts
|
|
|
|
for(CGHeroInstance * hero : crossoverHeroes)
|
|
|
|
{
|
|
|
|
size_t totalArts = GameConstants::BACKPACK_START + hero->artifactsInBackpack.size();
|
2014-02-09 02:07:33 +03:00
|
|
|
for (size_t i = 0; i < totalArts; i++ )
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
2020-10-01 10:38:06 +02:00
|
|
|
auto artifactPosition = ArtifactPosition((si32)i);
|
2013-12-20 16:07:58 +03:00
|
|
|
if(artifactPosition == ArtifactPosition::SPELLBOOK) continue; // do not handle spellbook this way
|
|
|
|
|
|
|
|
const ArtSlotInfo *info = hero->getSlot(artifactPosition);
|
2014-03-07 16:21:09 +03:00
|
|
|
if(!info)
|
2014-02-09 02:07:33 +03:00
|
|
|
continue;
|
2013-12-20 16:07:58 +03:00
|
|
|
|
2014-02-09 12:57:00 +03:00
|
|
|
// TODO: why would there be nullptr artifacts?
|
2013-12-20 16:07:58 +03:00
|
|
|
const CArtifactInstance *art = info->artifact;
|
2014-03-07 16:21:09 +03:00
|
|
|
if(!art)
|
2014-02-09 02:07:33 +03:00
|
|
|
continue;
|
2013-12-20 16:07:58 +03:00
|
|
|
|
2023-01-02 15:58:56 +02:00
|
|
|
int id = art->artType->getId();
|
2013-12-20 16:07:58 +03:00
|
|
|
assert( 8*18 > id );//number of arts that fits into h3m format
|
|
|
|
bool takeable = travelOptions.artifsKeptByHero[id / 8] & ( 1 << (id%8) );
|
2014-03-07 16:21:09 +03:00
|
|
|
|
2014-03-01 20:41:29 +03:00
|
|
|
ArtifactLocation al(hero, artifactPosition);
|
|
|
|
if(!takeable && !al.getSlot()->locked) //don't try removing locked artifacts -> it crashes #1719
|
|
|
|
al.removeArtifact();
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//trimming creatures
|
|
|
|
for(CGHeroInstance * cgh : crossoverHeroes)
|
|
|
|
{
|
2014-02-09 02:07:33 +03:00
|
|
|
auto shouldSlotBeErased = [&](const std::pair<SlotID, CStackInstance *> & j) -> bool
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
|
|
|
CreatureID::ECreatureID crid = j.second->getCreatureID().toEnum();
|
2014-02-09 02:07:33 +03:00
|
|
|
return !(travelOptions.monstersKeptByHero[crid / 8] & (1 << (crid % 8)));
|
|
|
|
};
|
|
|
|
|
|
|
|
auto stacksCopy = cgh->stacks; //copy of the map, so we can iterate iover it and remove stacks
|
|
|
|
for(auto &slotPair : stacksCopy)
|
|
|
|
if(shouldSlotBeErased(slotPair))
|
|
|
|
cgh->eraseStack(slotPair.first);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2014-02-09 12:57:00 +03:00
|
|
|
|
|
|
|
// Removing short-term bonuses
|
|
|
|
for(CGHeroInstance * cgh : crossoverHeroes)
|
|
|
|
{
|
2018-03-05 08:51:35 +02:00
|
|
|
cgh->removeBonusesRecursive(CSelector(Bonus::OneDay)
|
2015-04-13 09:24:32 +02:00
|
|
|
.Or(CSelector(Bonus::OneWeek))
|
|
|
|
.Or(CSelector(Bonus::NTurns))
|
|
|
|
.Or(CSelector(Bonus::NDays))
|
|
|
|
.Or(CSelector(Bonus::OneBattle)));
|
2014-02-09 12:57:00 +03:00
|
|
|
}
|
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
void CGameState::placeStartingHeroes()
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tGiving starting hero");
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-28 15:47:55 +03:00
|
|
|
for(auto & playerSettingPair : scenarioOps->playerInfos)
|
2013-12-18 21:18:12 +03:00
|
|
|
{
|
2013-12-28 15:47:55 +03:00
|
|
|
auto playerColor = playerSettingPair.first;
|
|
|
|
auto & playerInfo = map->players[playerColor.getNum()];
|
|
|
|
if(playerInfo.generateHeroAtMainTown && playerInfo.hasMainTown)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-12-28 15:47:55 +03:00
|
|
|
// Do not place a starting hero if the hero was already placed due to a campaign bonus
|
|
|
|
if(scenarioOps->campState)
|
|
|
|
{
|
|
|
|
if(auto campaignBonus = scenarioOps->campState->getBonusForCurrentMap())
|
|
|
|
{
|
2022-12-05 13:02:55 +02:00
|
|
|
if(campaignBonus->type == CScenarioTravel::STravelBonus::HERO && playerColor == PlayerColor(campaignBonus->info1))
|
|
|
|
continue;
|
2013-12-28 15:47:55 +03:00
|
|
|
}
|
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
|
2013-12-28 15:47:55 +03:00
|
|
|
int heroTypeId = pickNextHeroType(playerColor);
|
2015-12-05 01:40:23 +02:00
|
|
|
if(playerSettingPair.second.hero == -1)
|
|
|
|
playerSettingPair.second.hero = heroTypeId;
|
2013-12-18 21:18:12 +03:00
|
|
|
|
2013-12-28 15:47:55 +03:00
|
|
|
placeStartingHero(playerColor, HeroTypeID(heroTypeId), playerInfo.posOfMainTown);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
void CGameState::initStartingResources()
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tSetting up resources");
|
2013-11-12 13:09:55 +03:00
|
|
|
const JsonNode config(ResourceID("config/startres.json"));
|
|
|
|
const JsonVector &vector = config["difficulty"].Vector();
|
|
|
|
const JsonNode &level = vector[scenarioOps->difficulty];
|
|
|
|
|
|
|
|
TResources startresAI(level["ai"]);
|
|
|
|
TResources startresHuman(level["human"]);
|
|
|
|
|
|
|
|
for (auto & elem : players)
|
|
|
|
{
|
|
|
|
PlayerState &p = elem.second;
|
|
|
|
|
|
|
|
if (p.human)
|
|
|
|
p.resources = startresHuman;
|
|
|
|
else
|
|
|
|
p.resources = startresAI;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
auto getHumanPlayerInfo = [&]() -> std::vector<const PlayerSettings *>
|
|
|
|
{
|
|
|
|
std::vector<const PlayerSettings *> ret;
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & playerInfo : scenarioOps->playerInfos)
|
2013-12-18 21:18:12 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
if(playerInfo.second.isControlledByHuman())
|
|
|
|
ret.push_back(&playerInfo.second);
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
2013-11-12 13:09:55 +03:00
|
|
|
//give start resource bonus in case of campaign
|
|
|
|
if (scenarioOps->mode == StartInfo::CAMPAIGN)
|
|
|
|
{
|
|
|
|
auto chosenBonus = scenarioOps->campState->getBonusForCurrentMap();
|
|
|
|
if(chosenBonus && chosenBonus->type == CScenarioTravel::STravelBonus::RESOURCE)
|
|
|
|
{
|
|
|
|
std::vector<const PlayerSettings *> people = getHumanPlayerInfo(); //players we will give resource bonus
|
|
|
|
for(const PlayerSettings *ps : people)
|
|
|
|
{
|
|
|
|
std::vector<int> res; //resources we will give
|
|
|
|
switch (chosenBonus->info1)
|
|
|
|
{
|
|
|
|
case 0: case 1: case 2: case 3: case 4: case 5: case 6:
|
|
|
|
res.push_back(chosenBonus->info1);
|
|
|
|
break;
|
|
|
|
case 0xFD: //wood+ore
|
|
|
|
res.push_back(Res::WOOD); res.push_back(Res::ORE);
|
|
|
|
break;
|
|
|
|
case 0xFE: //rare
|
|
|
|
res.push_back(Res::MERCURY); res.push_back(Res::SULFUR); res.push_back(Res::CRYSTAL); res.push_back(Res::GEMS);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
//increasing resource quantity
|
|
|
|
for (auto & re : res)
|
|
|
|
{
|
|
|
|
players[ps->color].resources[re] += chosenBonus->info2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
void CGameState::initHeroes()
|
|
|
|
{
|
2013-11-12 13:09:55 +03:00
|
|
|
for(auto hero : map->heroesOnMap) //heroes instances initialization
|
|
|
|
{
|
|
|
|
if (hero->getOwner() == PlayerColor::UNFLAGGABLE)
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->warn("Hero with uninitialized owner!");
|
2013-11-12 13:09:55 +03:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2016-09-09 19:30:36 +02:00
|
|
|
hero->initHero(getRandomGenerator());
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
getPlayerState(hero->getOwner())->heroes.push_back(hero);
|
2023-01-02 13:27:03 +02:00
|
|
|
map->allHeroes[hero->type->getIndex()] = hero;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
for(auto obj : map->objects) //prisons
|
|
|
|
{
|
|
|
|
if(obj && obj->ID == Obj::PRISON)
|
|
|
|
map->allHeroes[obj->subID] = dynamic_cast<CGHeroInstance*>(obj.get());
|
|
|
|
}
|
|
|
|
|
|
|
|
std::set<HeroTypeID> heroesToCreate = getUnusedAllowedHeroes(); //ids of heroes to be created and put into the pool
|
|
|
|
for(auto ph : map->predefinedHeroes)
|
|
|
|
{
|
|
|
|
if(!vstd::contains(heroesToCreate, HeroTypeID(ph->subID)))
|
|
|
|
continue;
|
2016-09-09 19:30:36 +02:00
|
|
|
ph->initHero(getRandomGenerator());
|
2013-11-12 13:09:55 +03:00
|
|
|
hpool.heroesPool[ph->subID] = ph;
|
|
|
|
hpool.pavailable[ph->subID] = 0xff;
|
2023-01-02 13:27:03 +02:00
|
|
|
heroesToCreate.erase(ph->type->getId());
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
map->allHeroes[ph->subID] = ph;
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const HeroTypeID & htype : heroesToCreate) //all not used allowed heroes go with default state into the pool
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * vhi = new CGHeroInstance();
|
2016-09-09 19:30:36 +02:00
|
|
|
vhi->initHero(getRandomGenerator(), htype);
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
int typeID = htype.getNum();
|
|
|
|
map->allHeroes[typeID] = vhi;
|
|
|
|
hpool.heroesPool[typeID] = vhi;
|
|
|
|
hpool.pavailable[typeID] = 0xff;
|
|
|
|
}
|
|
|
|
|
|
|
|
for(auto & elem : map->disposedHeroes)
|
|
|
|
{
|
2013-12-18 21:18:12 +03:00
|
|
|
hpool.pavailable[elem.heroId] = elem.players;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (scenarioOps->mode == StartInfo::CAMPAIGN) //give campaign bonuses for specific / best hero
|
|
|
|
{
|
|
|
|
auto chosenBonus = scenarioOps->campState->getBonusForCurrentMap();
|
|
|
|
if (chosenBonus && chosenBonus->isBonusForHero() && chosenBonus->info1 != 0xFFFE) //exclude generated heroes
|
|
|
|
{
|
|
|
|
//find human player
|
|
|
|
PlayerColor humanPlayer=PlayerColor::NEUTRAL;
|
|
|
|
for (auto & elem : players)
|
|
|
|
{
|
|
|
|
if(elem.second.human)
|
|
|
|
{
|
|
|
|
humanPlayer = elem.first;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(humanPlayer != PlayerColor::NEUTRAL);
|
|
|
|
|
|
|
|
std::vector<ConstTransitivePtr<CGHeroInstance> > & heroes = players[humanPlayer].heroes;
|
|
|
|
|
|
|
|
if (chosenBonus->info1 == 0xFFFD) //most powerful
|
|
|
|
{
|
|
|
|
int maxB = -1;
|
|
|
|
for (int b=0; b<heroes.size(); ++b)
|
|
|
|
{
|
|
|
|
if (maxB == -1 || heroes[b]->getTotalStrength() > heroes[maxB]->getTotalStrength())
|
|
|
|
{
|
|
|
|
maxB = b;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(maxB < 0)
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->warn("Cannot give bonus to hero cause there are no heroes!");
|
2013-11-12 13:09:55 +03:00
|
|
|
else
|
|
|
|
giveCampaignBonusToHero(heroes[maxB]);
|
|
|
|
}
|
|
|
|
else //specific hero
|
|
|
|
{
|
|
|
|
for (auto & heroe : heroes)
|
|
|
|
{
|
|
|
|
if (heroe->subID == chosenBonus->info1)
|
|
|
|
{
|
|
|
|
giveCampaignBonusToHero(heroe);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void CGameState::giveCampaignBonusToHero(CGHeroInstance * hero)
|
|
|
|
{
|
|
|
|
const boost::optional<CScenarioTravel::STravelBonus> & curBonus = scenarioOps->campState->getBonusForCurrentMap();
|
|
|
|
if(!curBonus)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if(curBonus->isBonusForHero())
|
|
|
|
{
|
|
|
|
//apply bonus
|
|
|
|
switch (curBonus->type)
|
|
|
|
{
|
|
|
|
case CScenarioTravel::STravelBonus::SPELL:
|
2018-12-20 23:42:31 +02:00
|
|
|
hero->addSpellToSpellbook(SpellID(curBonus->info2));
|
2013-12-18 21:18:12 +03:00
|
|
|
break;
|
|
|
|
case CScenarioTravel::STravelBonus::MONSTER:
|
|
|
|
{
|
|
|
|
for(int i=0; i<GameConstants::ARMY_SIZE; i++)
|
|
|
|
{
|
|
|
|
if(hero->slotEmpty(SlotID(i)))
|
|
|
|
{
|
|
|
|
hero->addToSlot(SlotID(i), CreatureID(curBonus->info2), curBonus->info3);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CScenarioTravel::STravelBonus::ARTIFACT:
|
|
|
|
gs->giveHeroArtifact(hero, static_cast<ArtifactID>(curBonus->info2));
|
|
|
|
break;
|
|
|
|
case CScenarioTravel::STravelBonus::SPELL_SCROLL:
|
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
CArtifactInstance * scroll = CArtifactInstance::createScroll(SpellID(curBonus->info2));
|
2013-12-18 21:18:12 +03:00
|
|
|
scroll->putAt(ArtifactLocation(hero, scroll->firstAvailableSlot(hero)));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CScenarioTravel::STravelBonus::PRIMARY_SKILL:
|
|
|
|
{
|
|
|
|
const ui8* ptr = reinterpret_cast<const ui8*>(&curBonus->info2);
|
|
|
|
for (int g=0; g<GameConstants::PRIMARY_SKILLS; ++g)
|
|
|
|
{
|
|
|
|
int val = ptr[g];
|
|
|
|
if (val == 0)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
2016-09-19 23:36:35 +02:00
|
|
|
auto bb = std::make_shared<Bonus>(Bonus::PERMANENT, Bonus::PRIMARY_SKILL, Bonus::CAMPAIGN_BONUS, val, *scenarioOps->campState->currentMap, g);
|
2013-12-18 21:18:12 +03:00
|
|
|
hero->addNewBonus(bb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CScenarioTravel::STravelBonus::SECONDARY_SKILL:
|
|
|
|
hero->setSecSkillLevel(SecondarySkill(curBonus->info2), curBonus->info3, true);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
void CGameState::initFogOfWar()
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tFog of war"); //FIXME: should be initialized after all bonuses are set
|
2022-09-18 16:39:10 +02:00
|
|
|
|
|
|
|
int layers = map->levels();
|
2013-11-12 13:09:55 +03:00
|
|
|
for(auto & elem : teams)
|
|
|
|
{
|
2022-09-18 16:39:10 +02:00
|
|
|
auto fow = elem.second.fogOfWarMap;
|
|
|
|
fow->resize(boost::extents[layers][map->width][map->height]);
|
|
|
|
std::fill(fow->data(), fow->data() + fow->num_elements(), 0);
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
for(CGObjectInstance *obj : map->objects)
|
|
|
|
{
|
|
|
|
if(!obj || !vstd::contains(elem.second.players, obj->tempOwner)) continue; //not a flagged object
|
|
|
|
|
|
|
|
std::unordered_set<int3, ShashInt3> tiles;
|
2016-01-31 17:01:58 +02:00
|
|
|
getTilesInRange(tiles, obj->getSightCenter(), obj->getSightRadius(), obj->tempOwner, 1);
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const int3 & tile : tiles)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2022-09-18 16:39:10 +02:00
|
|
|
(*elem.second.fogOfWarMap)[tile.z][tile.x][tile.y] = 1;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
void CGameState::initStartingBonus()
|
|
|
|
{
|
2018-08-04 20:18:32 +02:00
|
|
|
if (scenarioOps->mode == StartInfo::CAMPAIGN)
|
|
|
|
return;
|
|
|
|
// These are the single scenario bonuses; predefined
|
|
|
|
// campaign bonuses are spread out over other init* functions.
|
|
|
|
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tStarting bonuses");
|
2013-11-12 13:09:55 +03:00
|
|
|
for(auto & elem : players)
|
|
|
|
{
|
|
|
|
//starting bonus
|
|
|
|
if(scenarioOps->playerInfos[elem.first].bonus==PlayerSettings::RANDOM)
|
2016-08-22 00:58:52 +02:00
|
|
|
scenarioOps->playerInfos[elem.first].bonus = static_cast<PlayerSettings::Ebonus>(getRandomGenerator().nextInt(2));
|
2013-11-12 13:09:55 +03:00
|
|
|
switch(scenarioOps->playerInfos[elem.first].bonus)
|
|
|
|
{
|
|
|
|
case PlayerSettings::GOLD:
|
2016-08-22 00:58:52 +02:00
|
|
|
elem.second.resources[Res::GOLD] += getRandomGenerator().nextInt(5, 10) * 100;
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
case PlayerSettings::RESOURCE:
|
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
int res = (*VLC->townh)[scenarioOps->playerInfos[elem.first].castle]->town->primaryRes;
|
2013-11-12 13:09:55 +03:00
|
|
|
if(res == Res::WOOD_AND_ORE)
|
|
|
|
{
|
2016-08-22 00:58:52 +02:00
|
|
|
int amount = getRandomGenerator().nextInt(5, 10);
|
2016-01-15 19:36:16 +02:00
|
|
|
elem.second.resources[Res::WOOD] += amount;
|
|
|
|
elem.second.resources[Res::ORE] += amount;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-08-22 00:58:52 +02:00
|
|
|
elem.second.resources[res] += getRandomGenerator().nextInt(3, 6);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PlayerSettings::ARTIFACT:
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
if(elem.second.heroes.empty())
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->error("Cannot give starting artifact - no heroes!");
|
2013-11-12 13:09:55 +03:00
|
|
|
break;
|
|
|
|
}
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
const Artifact * toGive = VLC->arth->pickRandomArtifact(getRandomGenerator(), CArtifact::ART_TREASURE).toArtifact(VLC->artifacts());
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
CGHeroInstance *hero = elem.second.heroes[0];
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
giveHeroArtifact(hero, toGive->getId());
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void CGameState::initTowns()
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tTowns");
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
//campaign bonuses for towns
|
|
|
|
if (scenarioOps->mode == StartInfo::CAMPAIGN)
|
|
|
|
{
|
|
|
|
auto chosenBonus = scenarioOps->campState->getBonusForCurrentMap();
|
|
|
|
|
|
|
|
if (chosenBonus && chosenBonus->type == CScenarioTravel::STravelBonus::BUILDING)
|
|
|
|
{
|
|
|
|
for (int g=0; g<map->towns.size(); ++g)
|
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
PlayerState * owner = getPlayerState(map->towns[g]->getOwner());
|
2013-11-12 13:09:55 +03:00
|
|
|
if (owner)
|
|
|
|
{
|
|
|
|
PlayerInfo & pi = map->players[owner->color.getNum()];
|
|
|
|
|
|
|
|
if (owner->human && //human-owned
|
2016-11-13 12:38:42 +02:00
|
|
|
map->towns[g]->pos == pi.posOfMainTown)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
map->towns[g]->builtBuildings.insert(
|
|
|
|
CBuildingHandler::campToERMU(chosenBonus->info1, map->towns[g]->subID, map->towns[g]->builtBuildings));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CGTownInstance::universitySkills.clear();
|
|
|
|
for ( int i=0; i<4; i++)
|
|
|
|
CGTownInstance::universitySkills.push_back(14+i);//skills for university
|
|
|
|
|
|
|
|
for (auto & elem : map->towns)
|
|
|
|
{
|
|
|
|
CGTownInstance * vti =(elem);
|
|
|
|
if(!vti->town)
|
2014-03-17 22:51:07 +03:00
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
vti->town = (*VLC->townh)[vti->subID]->town;
|
2014-03-17 22:51:07 +03:00
|
|
|
}
|
2023-01-04 15:17:50 +02:00
|
|
|
if(vti->getNameTranslated().empty())
|
2014-03-17 22:51:07 +03:00
|
|
|
{
|
2023-01-18 23:56:01 +02:00
|
|
|
size_t nameID = getRandomGenerator().nextInt(vti->town->getRandomNamesCount() - 1);
|
2023-01-04 15:17:50 +02:00
|
|
|
vti->setNameTranslated(vti->town->getRandomNameTranslated(nameID));
|
2014-03-17 22:51:07 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
//init buildings
|
|
|
|
if(vstd::contains(vti->builtBuildings, BuildingID::DEFAULT)) //give standard set of buildings
|
|
|
|
{
|
|
|
|
vti->builtBuildings.erase(BuildingID::DEFAULT);
|
|
|
|
vti->builtBuildings.insert(BuildingID::VILLAGE_HALL);
|
2015-03-12 17:47:32 +02:00
|
|
|
if(vti->tempOwner != PlayerColor::NEUTRAL)
|
|
|
|
vti->builtBuildings.insert(BuildingID::TAVERN);
|
|
|
|
|
2023-03-15 23:47:26 +02:00
|
|
|
auto definesBuildingsChances = VLC->settings()->getVector(EGameSettings::TOWNS_STARTING_DWELLING_CHANCES);
|
2023-02-05 00:40:02 +02:00
|
|
|
|
|
|
|
BuildingID basicDwellings[] = { BuildingID::DWELL_FIRST, BuildingID::DWELL_LVL_2, BuildingID::DWELL_LVL_3, BuildingID::DWELL_LVL_4, BuildingID::DWELL_LVL_5, BuildingID::DWELL_LVL_6, BuildingID::DWELL_LVL_7 };
|
|
|
|
|
|
|
|
for(int i = 0; i < definesBuildingsChances.size(); i++)
|
2014-03-17 22:51:07 +03:00
|
|
|
{
|
2023-02-05 00:40:02 +02:00
|
|
|
if((getRandomGenerator().nextInt(1,100) <= definesBuildingsChances[i]))
|
|
|
|
{
|
|
|
|
vti->builtBuildings.insert(basicDwellings[i]);
|
|
|
|
}
|
2014-03-17 22:51:07 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//#1444 - remove entries that don't have buildings defined (like some unused extra town hall buildings)
|
2023-03-13 23:26:44 +02:00
|
|
|
vstd::erase_if(vti->builtBuildings, [vti](const BuildingID & bid)
|
|
|
|
{
|
|
|
|
return !vti->town->buildings.count(bid) || !vti->town->buildings.at(bid);
|
|
|
|
});
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
if (vstd::contains(vti->builtBuildings, BuildingID::SHIPYARD) && vti->shipyardStatus()==IBoatGenerator::TILE_BLOCKED)
|
|
|
|
vti->builtBuildings.erase(BuildingID::SHIPYARD);//if we have harbor without water - erase it (this is H3 behaviour)
|
|
|
|
|
|
|
|
//init hordes
|
|
|
|
for (int i = 0; i<GameConstants::CREATURES_PER_TOWN; i++)
|
|
|
|
if (vstd::contains(vti->builtBuildings,(-31-i))) //if we have horde for this level
|
|
|
|
{
|
|
|
|
vti->builtBuildings.erase(BuildingID(-31-i));//remove old ID
|
2013-11-12 13:45:42 +03:00
|
|
|
if (vti->town->hordeLvl.at(0) == i)//if town first horde is this one
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
vti->builtBuildings.insert(BuildingID::HORDE_1);//add it
|
|
|
|
if (vstd::contains(vti->builtBuildings,(BuildingID::DWELL_UP_FIRST+i)))//if we have upgraded dwelling as well
|
|
|
|
vti->builtBuildings.insert(BuildingID::HORDE_1_UPGR);//add it as well
|
|
|
|
}
|
2013-11-12 13:45:42 +03:00
|
|
|
if (vti->town->hordeLvl.at(1) == i)//if town second horde is this one
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
vti->builtBuildings.insert(BuildingID::HORDE_2);
|
|
|
|
if (vstd::contains(vti->builtBuildings,(BuildingID::DWELL_UP_FIRST+i)))
|
|
|
|
vti->builtBuildings.insert(BuildingID::HORDE_2_UPGR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Early check for #1444-like problems
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & building : vti->builtBuildings)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-11-12 13:45:42 +03:00
|
|
|
assert(vti->town->buildings.at(building) != nullptr);
|
2022-12-07 18:06:47 +02:00
|
|
|
MAYBE_UNUSED(building);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//town events
|
|
|
|
for(CCastleEvent &ev : vti->events)
|
|
|
|
{
|
|
|
|
for (int i = 0; i<GameConstants::CREATURES_PER_TOWN; i++)
|
|
|
|
if (vstd::contains(ev.buildings,(-31-i))) //if we have horde for this level
|
|
|
|
{
|
|
|
|
ev.buildings.erase(BuildingID(-31-i));
|
2013-11-12 13:45:42 +03:00
|
|
|
if (vti->town->hordeLvl.at(0) == i)
|
2013-11-12 13:09:55 +03:00
|
|
|
ev.buildings.insert(BuildingID::HORDE_1);
|
2013-11-12 13:45:42 +03:00
|
|
|
if (vti->town->hordeLvl.at(1) == i)
|
2013-11-12 13:09:55 +03:00
|
|
|
ev.buildings.insert(BuildingID::HORDE_2);
|
|
|
|
}
|
|
|
|
}
|
2014-03-17 22:51:07 +03:00
|
|
|
//init spells
|
2013-11-12 13:09:55 +03:00
|
|
|
vti->spells.resize(GameConstants::SPELL_LEVELS);
|
|
|
|
|
|
|
|
for(ui32 z=0; z<vti->obligatorySpells.size();z++)
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * s = vti->obligatorySpells[z].toSpell();
|
2013-11-12 13:09:55 +03:00
|
|
|
vti->spells[s->level-1].push_back(s->id);
|
|
|
|
vti->possibleSpells -= s->id;
|
2014-03-17 22:51:07 +03:00
|
|
|
}
|
2023-03-13 23:26:44 +02:00
|
|
|
while(!vti->possibleSpells.empty())
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
ui32 total=0;
|
|
|
|
int sel = -1;
|
|
|
|
|
|
|
|
for(ui32 ps=0;ps<vti->possibleSpells.size();ps++)
|
2014-03-07 16:21:09 +03:00
|
|
|
total += vti->possibleSpells[ps].toSpell()->getProbability(vti->subID);
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
if (total == 0) // remaining spells have 0 probability
|
|
|
|
break;
|
|
|
|
|
2016-08-22 00:58:52 +02:00
|
|
|
auto r = getRandomGenerator().nextInt(total - 1);
|
2013-11-12 13:09:55 +03:00
|
|
|
for(ui32 ps=0; ps<vti->possibleSpells.size();ps++)
|
|
|
|
{
|
2014-03-07 16:21:09 +03:00
|
|
|
r -= vti->possibleSpells[ps].toSpell()->getProbability(vti->subID);
|
2013-11-12 13:09:55 +03:00
|
|
|
if(r<0)
|
|
|
|
{
|
|
|
|
sel = ps;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(sel<0)
|
|
|
|
sel=0;
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * s = vti->possibleSpells[sel].toSpell();
|
2013-11-12 13:09:55 +03:00
|
|
|
vti->spells[s->level-1].push_back(s->id);
|
|
|
|
vti->possibleSpells -= s->id;
|
|
|
|
}
|
|
|
|
vti->possibleSpells.clear();
|
|
|
|
if(vti->getOwner() != PlayerColor::NEUTRAL)
|
2023-03-13 23:26:44 +02:00
|
|
|
getPlayerState(vti->getOwner())->towns.emplace_back(vti);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-18 21:18:12 +03:00
|
|
|
void CGameState::initMapObjects()
|
|
|
|
{
|
2016-08-12 11:10:27 +02:00
|
|
|
logGlobal->debug("\tObject initialization");
|
2020-12-10 03:05:37 +02:00
|
|
|
VLC->creh->removeBonusesFromAllCreatures();
|
|
|
|
|
2014-02-19 04:04:27 +03:00
|
|
|
// objCaller->preInit();
|
2013-11-12 13:09:55 +03:00
|
|
|
for(CGObjectInstance *obj : map->objects)
|
|
|
|
{
|
|
|
|
if(obj)
|
2014-07-27 20:30:17 +03:00
|
|
|
{
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->trace("Calling Init for object %d, %s, %s", obj->id.getNum(), obj->typeName, obj->subTypeName);
|
2016-09-09 19:30:36 +02:00
|
|
|
obj->initObj(getRandomGenerator());
|
2014-07-27 20:30:17 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
for(CGObjectInstance *obj : map->objects)
|
|
|
|
{
|
|
|
|
if(!obj)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
switch (obj->ID)
|
|
|
|
{
|
|
|
|
case Obj::QUEST_GUARD:
|
|
|
|
case Obj::SEER_HUT:
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * q = dynamic_cast<CGSeerHut *>(obj);
|
2013-11-12 13:09:55 +03:00
|
|
|
assert (q);
|
|
|
|
q->setObjToKill();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-03-11 16:17:21 +02:00
|
|
|
CGSubterraneanGate::postInit(); //pairing subterranean gates
|
2014-06-03 22:45:18 +03:00
|
|
|
|
|
|
|
map->calculateGuardingGreaturePositions(); //calculate once again when all the guards are placed and initialized
|
2013-12-18 21:18:12 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2022-12-05 13:02:55 +02:00
|
|
|
void CGameState::placeHeroesInTowns()
|
2013-12-18 21:18:12 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(auto & player : players)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
if(player.first == PlayerColor::NEUTRAL)
|
2013-11-12 13:09:55 +03:00
|
|
|
continue;
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
for(CGHeroInstance * h : player.second.heroes)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(CGTownInstance * t : player.second.towns)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-02-17 18:34:49 +02:00
|
|
|
if(h->visitablePos().z != t->visitablePos().z)
|
|
|
|
continue;
|
|
|
|
|
2022-12-04 21:23:47 +02:00
|
|
|
bool heroOnTownBlockableTile = t->blockingAt(h->visitablePos().x, h->visitablePos().y);
|
|
|
|
|
|
|
|
// current hero position is at one of blocking tiles of current town
|
|
|
|
// assume that this hero should be visiting the town (H3M format quirk) and move hero to correct position
|
|
|
|
if (heroOnTownBlockableTile)
|
|
|
|
{
|
2022-12-09 14:42:47 +02:00
|
|
|
int3 correctedPos = h->convertFromVisitablePos(t->visitablePos());
|
2022-12-04 22:03:25 +02:00
|
|
|
|
|
|
|
map->removeBlockVisTiles(h);
|
2022-12-04 21:23:47 +02:00
|
|
|
h->pos = correctedPos;
|
2022-12-04 22:03:25 +02:00
|
|
|
map->addBlockVisTiles(h);
|
2022-12-04 21:23:47 +02:00
|
|
|
|
|
|
|
assert(t->visitableAt(h->visitablePos().x, h->visitablePos().y));
|
|
|
|
}
|
2022-12-05 13:02:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-12-04 21:23:47 +02:00
|
|
|
|
2022-12-05 13:02:55 +02:00
|
|
|
void CGameState::initVisitingAndGarrisonedHeroes()
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(auto & player : players)
|
2022-12-05 13:02:55 +02:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
if(player.first == PlayerColor::NEUTRAL)
|
2022-12-05 13:02:55 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
//init visiting and garrisoned heroes
|
2023-03-13 23:26:44 +02:00
|
|
|
for(CGHeroInstance * h : player.second.heroes)
|
2022-12-05 13:02:55 +02:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(CGTownInstance * t : player.second.towns)
|
2022-12-05 13:02:55 +02:00
|
|
|
{
|
2023-02-17 18:34:49 +02:00
|
|
|
if(h->visitablePos().z != t->visitablePos().z)
|
|
|
|
continue;
|
|
|
|
|
2022-12-05 13:02:55 +02:00
|
|
|
if (t->visitableAt(h->visitablePos().x, h->visitablePos().y))
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2022-12-04 21:23:47 +02:00
|
|
|
assert(t->visitingHero == nullptr);
|
2013-11-12 13:09:55 +03:00
|
|
|
t->setVisitingHero(h);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-07-01 13:07:53 +03:00
|
|
|
for (auto hero : map->heroesOnMap)
|
|
|
|
{
|
|
|
|
if (hero->visitedTown)
|
|
|
|
{
|
|
|
|
assert (hero->visitedTown->visitingHero == hero);
|
|
|
|
}
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2022-06-22 10:41:02 +02:00
|
|
|
BattleField CGameState::battleGetBattlefieldType(int3 tile, CRandomGenerator & rand)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2016-10-02 07:39:01 +02:00
|
|
|
if(!tile.valid() && curB)
|
2013-11-12 13:09:55 +03:00
|
|
|
tile = curB->tile;
|
2016-10-02 07:39:01 +02:00
|
|
|
else if(!tile.valid() && !curB)
|
2022-06-22 10:41:02 +02:00
|
|
|
return BattleField::NONE;
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
const TerrainTile &t = map->getTile(tile);
|
2022-06-26 09:21:05 +02:00
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * topObject = t.visitableObjects.front();
|
2022-06-26 09:21:05 +02:00
|
|
|
if(topObject && topObject->getBattlefield() != BattleField::NONE)
|
|
|
|
{
|
|
|
|
return topObject->getBattlefield();
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
for(auto &obj : map->objects)
|
|
|
|
{
|
|
|
|
//look only for objects covering given tile
|
2014-06-03 22:45:18 +03:00
|
|
|
if( !obj || obj->pos.z != tile.z || !obj->coveringAt(tile.x, tile.y))
|
2013-11-12 13:09:55 +03:00
|
|
|
continue;
|
|
|
|
|
2022-06-26 09:21:05 +02:00
|
|
|
auto customBattlefield = obj->getBattlefield();
|
|
|
|
|
|
|
|
if(customBattlefield != BattleField::NONE)
|
|
|
|
return customBattlefield;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2015-08-15 20:46:28 +02:00
|
|
|
if(map->isCoastalTile(tile)) //coastal tile is always ground
|
2022-06-28 10:05:30 +02:00
|
|
|
return BattleField::fromString("sand_shore");
|
2022-06-20 16:39:50 +02:00
|
|
|
|
2022-12-21 00:45:35 +02:00
|
|
|
return BattleField(*RandomGeneratorUtil::nextItem(t.terType->battleFields, rand));
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2022-12-07 21:50:45 +02:00
|
|
|
|
2022-12-25 14:03:43 +02:00
|
|
|
void CGameState::fillUpgradeInfo(const CArmedInstance *obj, SlotID stackPos, UpgradeInfo &out) const
|
2022-12-07 21:50:45 +02:00
|
|
|
{
|
|
|
|
assert(obj);
|
|
|
|
assert(obj->hasStackAtSlot(stackPos));
|
|
|
|
|
2022-12-25 14:03:43 +02:00
|
|
|
out = fillUpgradeInfo(obj->getStack(stackPos));
|
2022-12-07 21:50:45 +02:00
|
|
|
}
|
|
|
|
|
2022-12-25 14:03:43 +02:00
|
|
|
UpgradeInfo CGameState::fillUpgradeInfo(const CStackInstance &stack) const
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
UpgradeInfo ret;
|
|
|
|
const CCreature *base = stack.type;
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
const CGHeroInstance * h = stack.armyObj->ID == Obj::HERO ? dynamic_cast<const CGHeroInstance *>(stack.armyObj) : nullptr;
|
2013-11-12 13:09:55 +03:00
|
|
|
const CGTownInstance *t = nullptr;
|
|
|
|
|
|
|
|
if(stack.armyObj->ID == Obj::TOWN)
|
2023-03-13 23:26:44 +02:00
|
|
|
t = dynamic_cast<const CGTownInstance *>(stack.armyObj);
|
2013-11-12 13:09:55 +03:00
|
|
|
else if(h)
|
|
|
|
{ //hero specialty
|
2020-10-01 07:55:41 +02:00
|
|
|
TConstBonusListPtr lista = h->getBonuses(Selector::typeSubtype(Bonus::SPECIAL_UPGRADE, base->idNumber));
|
|
|
|
for(const auto & it : *lista)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2018-03-12 07:20:18 +02:00
|
|
|
auto nid = CreatureID(it->additionalInfo[0]);
|
2013-11-12 13:09:55 +03:00
|
|
|
if (nid != base->idNumber) //in very specific case the upgrade is available by default (?)
|
|
|
|
{
|
|
|
|
ret.newID.push_back(nid);
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
ret.cost.push_back(VLC->creh->objects[nid]->cost - base->cost);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
t = h->visitedTown;
|
|
|
|
}
|
|
|
|
if(t)
|
|
|
|
{
|
|
|
|
for(const CGTownInstance::TCreaturesSet::value_type & dwelling : t->creatures)
|
|
|
|
{
|
|
|
|
if (vstd::contains(dwelling.second, base->idNumber)) //Dwelling with our creature
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & upgrID : dwelling.second)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
if(vstd::contains(base->upgrades, upgrID)) //possible upgrade
|
|
|
|
{
|
|
|
|
ret.newID.push_back(upgrID);
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
ret.cost.push_back(VLC->creh->objects[upgrID]->cost - base->cost);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//hero is visiting Hill Fort
|
|
|
|
if(h && map->getTile(h->visitablePos()).visitableObjects.front()->ID == Obj::HILL_FORT)
|
|
|
|
{
|
|
|
|
static const int costModifiers[] = {0, 25, 50, 75, 100}; //we get cheaper upgrades depending on level
|
|
|
|
const int costModifier = costModifiers[std::min<int>(std::max((int)base->level - 1, 0), ARRAY_COUNT(costModifiers) - 1)];
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & nid : base->upgrades)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
ret.newID.push_back(nid);
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
ret.cost.push_back((VLC->creh->objects[nid]->cost - base->cost) * costModifier / 100);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
if(!ret.newID.empty())
|
2013-11-12 13:09:55 +03:00
|
|
|
ret.oldID = base->idNumber;
|
|
|
|
|
|
|
|
for (Res::ResourceSet &cost : ret.cost)
|
|
|
|
cost.positive(); //upgrade cost can't be negative, ignore missing resources
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-12-07 21:50:45 +02:00
|
|
|
PlayerRelations::PlayerRelations CGameState::getPlayerRelations( PlayerColor color1, PlayerColor color2 ) const
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
if ( color1 == color2 )
|
|
|
|
return PlayerRelations::SAME_PLAYER;
|
|
|
|
if(color1 == PlayerColor::NEUTRAL || color2 == PlayerColor::NEUTRAL) //neutral player has no friends
|
|
|
|
return PlayerRelations::ENEMIES;
|
|
|
|
|
|
|
|
const TeamState * ts = getPlayerTeam(color1);
|
|
|
|
if (ts && vstd::contains(ts->players, color2))
|
|
|
|
return PlayerRelations::ALLIES;
|
|
|
|
return PlayerRelations::ENEMIES;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CGameState::apply(CPack *pack)
|
|
|
|
{
|
|
|
|
ui16 typ = typeList.getTypeID(pack);
|
2018-01-05 19:21:07 +02:00
|
|
|
applier->getApplier(typ)->applyOnGS(this, pack);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2014-09-21 16:42:08 +03:00
|
|
|
void CGameState::calculatePaths(const CGHeroInstance *hero, CPathsInfo &out)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2022-12-07 21:50:45 +02:00
|
|
|
calculatePaths(std::make_shared<SingleHeroPathfinderConfig>(out, this, hero));
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
void CGameState::calculatePaths(const std::shared_ptr<PathfinderConfig> & config)
|
2018-07-28 14:30:57 +02:00
|
|
|
{
|
2022-09-18 16:39:10 +02:00
|
|
|
//FIXME: creating pathfinder is costly, maybe reset / clear is enough?
|
2021-05-16 19:53:11 +02:00
|
|
|
CPathfinder pathfinder(this, config);
|
2018-07-28 14:30:57 +02:00
|
|
|
pathfinder.calculatePaths();
|
|
|
|
}
|
|
|
|
|
2013-11-12 13:09:55 +03:00
|
|
|
/**
|
|
|
|
* Tells if the tile is guarded by a monster as well as the position
|
|
|
|
* of the monster that will attack on it.
|
|
|
|
*
|
|
|
|
* @return int3(-1, -1, -1) if the tile is unguarded, or the position of
|
|
|
|
* the monster guarding the tile.
|
|
|
|
*/
|
|
|
|
std::vector<CGObjectInstance*> CGameState::guardingCreatures (int3 pos) const
|
|
|
|
{
|
|
|
|
std::vector<CGObjectInstance*> guards;
|
|
|
|
const int3 originalPos = pos;
|
|
|
|
if (!map->isInTheMap(pos))
|
|
|
|
return guards;
|
|
|
|
|
|
|
|
const TerrainTile &posTile = map->getTile(pos);
|
|
|
|
if (posTile.visitable)
|
|
|
|
{
|
|
|
|
for (CGObjectInstance* obj : posTile.visitableObjects)
|
|
|
|
{
|
|
|
|
if(obj->blockVisit)
|
|
|
|
{
|
|
|
|
if (obj->ID == Obj::MONSTER) // Monster
|
|
|
|
guards.push_back(obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pos -= int3(1, 1, 0); // Start with top left.
|
|
|
|
for (int dx = 0; dx < 3; dx++)
|
|
|
|
{
|
|
|
|
for (int dy = 0; dy < 3; dy++)
|
|
|
|
{
|
|
|
|
if (map->isInTheMap(pos))
|
|
|
|
{
|
|
|
|
const auto & tile = map->getTile(pos);
|
2016-03-12 03:41:27 +02:00
|
|
|
if (tile.visitable && (tile.isWater() == posTile.isWater()))
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
for (CGObjectInstance* obj : tile.visitableObjects)
|
|
|
|
{
|
2014-04-01 14:53:28 +03:00
|
|
|
if (obj->ID == Obj::MONSTER && map->checkForVisitableDir(pos, &map->getTile(originalPos), originalPos)) // Monster being able to attack investigated tile
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
guards.push_back(obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pos.y++;
|
|
|
|
}
|
|
|
|
pos.y -= 3;
|
|
|
|
pos.x++;
|
|
|
|
}
|
|
|
|
return guards;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int3 CGameState::guardingCreaturePosition (int3 pos) const
|
|
|
|
{
|
2022-09-18 16:39:10 +02:00
|
|
|
return gs->map->guardingCreaturePositions[pos.z][pos.x][pos.y];
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2015-11-30 23:44:58 +02:00
|
|
|
void CGameState::updateRumor()
|
|
|
|
{
|
2015-12-04 21:58:14 +02:00
|
|
|
static std::vector<RumorState::ERumorType> rumorTypes = {RumorState::TYPE_MAP, RumorState::TYPE_SPECIAL, RumorState::TYPE_RAND, RumorState::TYPE_RAND};
|
|
|
|
std::vector<RumorState::ERumorTypeSpecial> sRumorTypes = {
|
|
|
|
RumorState::RUMOR_OBELISKS, RumorState::RUMOR_ARTIFACTS, RumorState::RUMOR_ARMY, RumorState::RUMOR_INCOME};
|
|
|
|
if(map->grailPos.valid()) // Grail should always be on map, but I had related crash I didn't manage to reproduce
|
|
|
|
sRumorTypes.push_back(RumorState::RUMOR_GRAIL);
|
2015-11-30 23:44:58 +02:00
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
int rumorId = -1;
|
|
|
|
int rumorExtra = -1;
|
2015-12-04 21:58:14 +02:00
|
|
|
auto & rand = getRandomGenerator();
|
2015-11-30 23:44:58 +02:00
|
|
|
rumor.type = *RandomGeneratorUtil::nextItem(rumorTypes, rand);
|
|
|
|
|
2015-12-01 01:14:11 +02:00
|
|
|
do
|
2015-11-30 23:44:58 +02:00
|
|
|
{
|
2015-12-01 01:14:11 +02:00
|
|
|
switch(rumor.type)
|
2015-11-30 23:44:58 +02:00
|
|
|
{
|
2015-12-04 21:58:14 +02:00
|
|
|
case RumorState::TYPE_SPECIAL:
|
2015-12-01 01:14:11 +02:00
|
|
|
{
|
|
|
|
SThievesGuildInfo tgi;
|
2015-12-04 21:58:14 +02:00
|
|
|
obtainPlayersStats(tgi, 20);
|
|
|
|
rumorId = *RandomGeneratorUtil::nextItem(sRumorTypes, rand);
|
|
|
|
if(rumorId == RumorState::RUMOR_GRAIL)
|
2015-12-01 03:57:52 +02:00
|
|
|
{
|
2023-01-01 17:10:47 +02:00
|
|
|
rumorExtra = getTile(map->grailPos)->terType->getIndex();
|
2015-12-01 03:57:52 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<PlayerColor> players = {};
|
2015-12-01 01:14:11 +02:00
|
|
|
switch(rumorId)
|
|
|
|
{
|
2015-12-04 21:58:14 +02:00
|
|
|
case RumorState::RUMOR_OBELISKS:
|
2015-12-01 01:14:11 +02:00
|
|
|
players = tgi.obelisks[0];
|
|
|
|
break;
|
2015-11-30 23:44:58 +02:00
|
|
|
|
2015-12-04 21:58:14 +02:00
|
|
|
case RumorState::RUMOR_ARTIFACTS:
|
2015-12-01 01:14:11 +02:00
|
|
|
players = tgi.artifacts[0];
|
|
|
|
break;
|
2015-11-30 23:44:58 +02:00
|
|
|
|
2015-12-04 21:58:14 +02:00
|
|
|
case RumorState::RUMOR_ARMY:
|
2015-12-01 01:14:11 +02:00
|
|
|
players = tgi.army[0];
|
|
|
|
break;
|
2015-11-30 23:44:58 +02:00
|
|
|
|
2015-12-04 21:58:14 +02:00
|
|
|
case RumorState::RUMOR_INCOME:
|
2015-12-01 01:14:11 +02:00
|
|
|
players = tgi.income[0];
|
|
|
|
break;
|
|
|
|
}
|
2015-12-01 03:57:52 +02:00
|
|
|
rumorExtra = RandomGeneratorUtil::nextItem(players, rand)->getNum();
|
2015-11-30 23:44:58 +02:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
2015-12-04 21:58:14 +02:00
|
|
|
case RumorState::TYPE_MAP:
|
2016-09-15 22:22:25 +02:00
|
|
|
// Makes sure that map rumors only used if there enough rumors too choose from
|
2023-03-13 23:26:44 +02:00
|
|
|
if(!map->rumors.empty() && (map->rumors.size() > 1 || !rumor.last.count(RumorState::TYPE_MAP)))
|
2016-09-15 22:22:25 +02:00
|
|
|
{
|
2020-10-01 10:38:06 +02:00
|
|
|
rumorId = rand.nextInt((int)map->rumors.size() - 1);
|
2016-09-15 22:22:25 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
rumor.type = RumorState::TYPE_RAND;
|
2018-02-09 12:02:44 +02:00
|
|
|
FALLTHROUGH
|
2015-11-30 23:44:58 +02:00
|
|
|
|
2015-12-04 21:58:14 +02:00
|
|
|
case RumorState::TYPE_RAND:
|
2022-12-27 22:19:05 +02:00
|
|
|
auto vector = VLC->generaltexth->findStringsWithPrefix("core.randtvrn");
|
2022-12-28 01:14:19 +02:00
|
|
|
rumorId = rand.nextInt((int)vector.size() - 1);
|
2015-11-30 23:44:58 +02:00
|
|
|
|
2015-12-01 01:14:11 +02:00
|
|
|
break;
|
2015-11-30 23:44:58 +02:00
|
|
|
}
|
|
|
|
}
|
2015-12-01 03:57:52 +02:00
|
|
|
while(!rumor.update(rumorId, rumorExtra));
|
2015-11-30 23:44:58 +02:00
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
bool CGameState::isVisible(int3 pos, const boost::optional<PlayerColor> & player) const
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2022-12-07 21:50:45 +02:00
|
|
|
if (!map->isInTheMap(pos))
|
|
|
|
return false;
|
|
|
|
if (!player)
|
|
|
|
return true;
|
2013-11-12 13:09:55 +03:00
|
|
|
if(player == PlayerColor::NEUTRAL)
|
|
|
|
return false;
|
2022-12-07 21:50:45 +02:00
|
|
|
if(player->isSpectator())
|
2017-06-03 07:25:10 +02:00
|
|
|
return true;
|
|
|
|
|
2022-12-07 21:50:45 +02:00
|
|
|
return (*getPlayerTeam(*player)->fogOfWarMap)[pos.z][pos.x][pos.y];
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
bool CGameState::isVisible( const CGObjectInstance *obj, const boost::optional<PlayerColor> & player) const
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
if(!player)
|
|
|
|
return true;
|
|
|
|
|
2014-12-21 14:56:32 +02:00
|
|
|
//we should always see our own heroes - but sometimes not visible heroes cause crash :?
|
|
|
|
if (player == obj->tempOwner)
|
|
|
|
return true;
|
|
|
|
|
2013-11-12 13:09:55 +03:00
|
|
|
if(*player == PlayerColor::NEUTRAL) //-> TODO ??? needed?
|
|
|
|
return false;
|
|
|
|
//object is visible when at least one blocked tile is visible
|
2014-01-03 02:48:38 +03:00
|
|
|
for(int fy=0; fy < obj->getHeight(); ++fy)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2014-01-03 02:48:38 +03:00
|
|
|
for(int fx=0; fx < obj->getWidth(); ++fx)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2014-01-03 02:48:38 +03:00
|
|
|
int3 pos = obj->pos + int3(-fx, -fy, 0);
|
|
|
|
|
|
|
|
if ( map->isInTheMap(pos) &&
|
|
|
|
obj->coveringAt(pos.x, pos.y) &&
|
|
|
|
isVisible(pos, *player))
|
2013-11-12 13:09:55 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CGameState::checkForVisitableDir(const int3 & src, const int3 & dst) const
|
|
|
|
{
|
|
|
|
const TerrainTile * pom = &map->getTile(dst);
|
2014-04-01 14:53:28 +03:00
|
|
|
return map->checkForVisitableDir(src, pom, dst);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
EVictoryLossCheckResult CGameState::checkForVictoryAndLoss(const PlayerColor & player) const
|
2013-11-17 20:57:04 +03:00
|
|
|
{
|
2013-12-29 14:27:38 +03:00
|
|
|
const std::string & messageWonSelf = VLC->generaltexth->allTexts[659];
|
|
|
|
const std::string & messageWonOther = VLC->generaltexth->allTexts[5];
|
|
|
|
const std::string & messageLostSelf = VLC->generaltexth->allTexts[7];
|
|
|
|
const std::string & messageLostOther = VLC->generaltexth->allTexts[8];
|
|
|
|
|
|
|
|
auto evaluateEvent = [=](const EventCondition & condition)
|
|
|
|
{
|
|
|
|
return this->checkForVictory(player, condition);
|
|
|
|
};
|
2013-11-12 13:09:55 +03:00
|
|
|
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
const PlayerState *p = CGameInfoCallback::getPlayerState(player);
|
2013-12-29 14:27:38 +03:00
|
|
|
|
|
|
|
//cheater or tester, but has entered the code...
|
|
|
|
if (p->enteredWinningCheatCode)
|
|
|
|
return EVictoryLossCheckResult::victory(messageWonSelf, messageWonOther);
|
|
|
|
|
|
|
|
if (p->enteredLosingCheatCode)
|
|
|
|
return EVictoryLossCheckResult::defeat(messageLostSelf, messageLostOther);
|
|
|
|
|
|
|
|
for (const TriggeredEvent & event : map->triggeredEvents)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2016-01-27 12:47:42 +02:00
|
|
|
if (event.trigger.test(evaluateEvent))
|
2013-12-29 14:27:38 +03:00
|
|
|
{
|
|
|
|
if (event.effect.type == EventEffect::VICTORY)
|
|
|
|
return EVictoryLossCheckResult::victory(event.onFulfill, event.effect.toOtherMessage);
|
|
|
|
|
|
|
|
if (event.effect.type == EventEffect::DEFEAT)
|
|
|
|
return EVictoryLossCheckResult::defeat(event.onFulfill, event.effect.toOtherMessage);
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2013-12-29 14:27:38 +03:00
|
|
|
if (checkForStandardLoss(player))
|
|
|
|
{
|
|
|
|
return EVictoryLossCheckResult::defeat(messageLostSelf, messageLostOther);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-29 14:27:38 +03:00
|
|
|
return EVictoryLossCheckResult();
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
bool CGameState::checkForVictory(const PlayerColor & player, const EventCondition & condition) const
|
2013-12-29 14:27:38 +03:00
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
const PlayerState *p = CGameInfoCallback::getPlayerState(player);
|
2013-12-29 14:27:38 +03:00
|
|
|
switch (condition.condition)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-12-29 14:27:38 +03:00
|
|
|
case EventCondition::STANDARD_WIN:
|
|
|
|
{
|
|
|
|
return player == checkForStandardWin();
|
|
|
|
}
|
|
|
|
case EventCondition::HAVE_ARTIFACT: //check if any hero has winning artifact
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & elem : p->heroes)
|
2022-11-29 00:11:46 +02:00
|
|
|
if(elem->hasArt(ArtifactID(condition.objectType)))
|
2013-12-29 14:27:38 +03:00
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
case EventCondition::HAVE_CREATURES:
|
|
|
|
{
|
|
|
|
//check if in players armies there is enough creatures
|
|
|
|
int total = 0; //creature counter
|
2023-03-13 23:26:44 +02:00
|
|
|
for(auto object : map->objects)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-12-29 14:27:38 +03:00
|
|
|
const CArmedInstance *ai = nullptr;
|
2023-03-13 23:26:44 +02:00
|
|
|
if(object
|
|
|
|
&& object->tempOwner == player //object controlled by player
|
|
|
|
&& (ai = dynamic_cast<const CArmedInstance *>(object.get()))) //contains army
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & elem : ai->Slots()) //iterate through army
|
2013-12-29 14:27:38 +03:00
|
|
|
if(elem.second->type->idNumber == condition.objectType) //it's searched creature
|
|
|
|
total += elem.second->count;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
2013-12-29 14:27:38 +03:00
|
|
|
return total >= condition.value;
|
|
|
|
}
|
|
|
|
case EventCondition::HAVE_RESOURCES:
|
|
|
|
{
|
|
|
|
return p->resources[condition.objectType] >= condition.value;
|
|
|
|
}
|
|
|
|
case EventCondition::HAVE_BUILDING:
|
|
|
|
{
|
2014-02-09 00:05:24 +03:00
|
|
|
if (condition.object) // specific town
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * t = dynamic_cast<const CGTownInstance *>(condition.object);
|
2014-02-09 00:05:24 +03:00
|
|
|
return (t->tempOwner == player && t->hasBuilt(BuildingID(condition.objectType)));
|
|
|
|
}
|
|
|
|
else // any town
|
|
|
|
{
|
|
|
|
for (const CGTownInstance * t : p->towns)
|
|
|
|
{
|
|
|
|
if (t->hasBuilt(BuildingID(condition.objectType)))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2013-12-29 14:27:38 +03:00
|
|
|
}
|
|
|
|
case EventCondition::DESTROY:
|
|
|
|
{
|
|
|
|
if (condition.object) // mode A - destroy specific object of this type
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
if(const auto * hero = dynamic_cast<const CGHeroInstance *>(condition.object))
|
2013-12-29 14:27:38 +03:00
|
|
|
return boost::range::find(gs->map->heroesOnMap, hero) == gs->map->heroesOnMap.end();
|
|
|
|
else
|
|
|
|
return getObj(condition.object->id) == nullptr;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-29 14:27:38 +03:00
|
|
|
else
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & elem : map->objects) // mode B - destroy all objects of this type
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-12-29 14:27:38 +03:00
|
|
|
if(elem && elem->ID == condition.objectType)
|
|
|
|
return false;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-29 14:27:38 +03:00
|
|
|
return true;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-29 14:27:38 +03:00
|
|
|
}
|
|
|
|
case EventCondition::CONTROL:
|
|
|
|
{
|
2014-02-26 20:32:42 +03:00
|
|
|
// list of players that need to control object to fulfull condition
|
|
|
|
// NOTE: cgameinfocallback specified explicitly in order to get const version
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto & team = CGameInfoCallback::getPlayerTeam(player)->players;
|
2014-02-26 20:32:42 +03:00
|
|
|
|
2013-12-29 14:27:38 +03:00
|
|
|
if (condition.object) // mode A - flag one specific object, like town
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2014-02-26 20:32:42 +03:00
|
|
|
return team.count(condition.object->tempOwner) != 0;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-29 14:27:38 +03:00
|
|
|
else
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & elem : map->objects) // mode B - flag all objects of this type
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-12-29 14:27:38 +03:00
|
|
|
//check not flagged objs
|
2014-02-26 20:32:42 +03:00
|
|
|
if ( elem && elem->ID == condition.objectType && team.count(elem->tempOwner) == 0 )
|
2013-12-29 14:27:38 +03:00
|
|
|
return false;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-29 14:27:38 +03:00
|
|
|
return true;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2013-12-29 14:27:38 +03:00
|
|
|
}
|
|
|
|
case EventCondition::TRANSPORT:
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * t = dynamic_cast<const CGTownInstance *>(condition.object);
|
|
|
|
return (t->visitingHero && t->visitingHero->hasArt(ArtifactID(condition.objectType))) ||
|
|
|
|
(t->garrisonHero && t->garrisonHero->hasArt(ArtifactID(condition.objectType)));
|
2013-12-29 14:27:38 +03:00
|
|
|
}
|
|
|
|
case EventCondition::DAYS_PASSED:
|
|
|
|
{
|
2020-10-01 10:38:06 +02:00
|
|
|
return (si32)gs->day > condition.value;
|
2013-12-29 14:27:38 +03:00
|
|
|
}
|
|
|
|
case EventCondition::IS_HUMAN:
|
|
|
|
{
|
|
|
|
return p->human ? condition.value == 1 : condition.value == 0;
|
|
|
|
}
|
|
|
|
case EventCondition::DAYS_WITHOUT_TOWN:
|
|
|
|
{
|
|
|
|
if (p->daysWithoutCastle)
|
|
|
|
return p->daysWithoutCastle.get() >= condition.value;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
2014-02-09 15:10:02 +03:00
|
|
|
case EventCondition::CONST_VALUE:
|
|
|
|
{
|
|
|
|
return condition.value; // just convert to bool
|
|
|
|
}
|
2016-11-13 12:38:42 +02:00
|
|
|
case EventCondition::HAVE_0:
|
|
|
|
{
|
|
|
|
logGlobal->debug("Not implemented event condition type: %d", (int)condition.condition);
|
|
|
|
//TODO: support new condition format
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
case EventCondition::HAVE_BUILDING_0:
|
|
|
|
{
|
|
|
|
logGlobal->debug("Not implemented event condition type: %d", (int)condition.condition);
|
|
|
|
//TODO: support new condition format
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
case EventCondition::DESTROY_0:
|
|
|
|
{
|
|
|
|
logGlobal->debug("Not implemented event condition type: %d", (int)condition.condition);
|
|
|
|
//TODO: support new condition format
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
logGlobal->error("Invalid event condition type: %d", (int)condition.condition);
|
|
|
|
return false;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PlayerColor CGameState::checkForStandardWin() const
|
|
|
|
{
|
|
|
|
//std victory condition is:
|
|
|
|
//all enemies lost
|
|
|
|
PlayerColor supposedWinner = PlayerColor::NEUTRAL;
|
|
|
|
TeamID winnerTeam = TeamID::NO_TEAM;
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & elem : players)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
if(elem.second.status == EPlayerStatus::INGAME && elem.first < PlayerColor::PLAYER_LIMIT)
|
|
|
|
{
|
|
|
|
if(supposedWinner == PlayerColor::NEUTRAL)
|
|
|
|
{
|
|
|
|
//first player remaining ingame - candidate for victory
|
|
|
|
supposedWinner = elem.second.color;
|
|
|
|
winnerTeam = elem.second.team;
|
|
|
|
}
|
|
|
|
else if(winnerTeam != elem.second.team)
|
|
|
|
{
|
|
|
|
//current candidate has enemy remaining in game -> no vicotry
|
|
|
|
return PlayerColor::NEUTRAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return supposedWinner;
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
bool CGameState::checkForStandardLoss(const PlayerColor & player) const
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
//std loss condition is: player lost all towns and heroes
|
2022-01-25 13:19:48 +02:00
|
|
|
const PlayerState & pState = *CGameInfoCallback::getPlayerState(player);
|
|
|
|
return pState.checkVanquished();
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
struct statsHLP
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
using TStat = std::pair<PlayerColor, si64>;
|
2013-11-12 13:09:55 +03:00
|
|
|
//converts [<player's color, value>] to vec[place] -> platers
|
|
|
|
static std::vector< std::vector< PlayerColor > > getRank( std::vector<TStat> stats )
|
|
|
|
{
|
|
|
|
std::sort(stats.begin(), stats.end(), statsHLP());
|
|
|
|
|
|
|
|
//put first element
|
|
|
|
std::vector< std::vector<PlayerColor> > ret;
|
|
|
|
std::vector<PlayerColor> tmp;
|
|
|
|
tmp.push_back( stats[0].first );
|
|
|
|
ret.push_back( tmp );
|
|
|
|
|
|
|
|
//the rest of elements
|
|
|
|
for(int g=1; g<stats.size(); ++g)
|
|
|
|
{
|
|
|
|
if(stats[g].second == stats[g-1].second)
|
|
|
|
{
|
|
|
|
(ret.end()-1)->push_back( stats[g].first );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//create next occupied rank
|
|
|
|
std::vector<PlayerColor> tmp;
|
|
|
|
tmp.push_back(stats[g].first);
|
|
|
|
ret.push_back(tmp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool operator()(const TStat & a, const TStat & b) const
|
|
|
|
{
|
|
|
|
return a.second > b.second;
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
static const CGHeroInstance * findBestHero(CGameState * gs, const PlayerColor & color)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
std::vector<ConstTransitivePtr<CGHeroInstance> > &h = gs->players[color].heroes;
|
2023-03-13 23:26:44 +02:00
|
|
|
if(h.empty())
|
2013-11-12 13:09:55 +03:00
|
|
|
return nullptr;
|
|
|
|
//best hero will be that with highest exp
|
|
|
|
int best = 0;
|
|
|
|
for(int b=1; b<h.size(); ++b)
|
|
|
|
{
|
|
|
|
if(h[b]->exp > h[best]->exp)
|
|
|
|
{
|
|
|
|
best = b;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return h[best];
|
|
|
|
}
|
|
|
|
|
|
|
|
//calculates total number of artifacts that belong to given player
|
|
|
|
static int getNumberOfArts(const PlayerState * ps)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
for(auto h : ps->heroes)
|
|
|
|
{
|
2020-10-01 10:38:06 +02:00
|
|
|
ret += (int)h->artifactsInBackpack.size() + (int)h->artifactsWorn.size();
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
// get total strength of player army
|
|
|
|
static si64 getArmyStrength(const PlayerState * ps)
|
|
|
|
{
|
|
|
|
si64 str = 0;
|
|
|
|
|
|
|
|
for(auto h : ps->heroes)
|
|
|
|
{
|
|
|
|
if(!h->inTownGarrison) //original h3 behavior
|
|
|
|
str += h->getArmyStrength();
|
|
|
|
}
|
|
|
|
return str;
|
|
|
|
}
|
2015-12-01 05:28:08 +02:00
|
|
|
|
|
|
|
// get total gold income
|
|
|
|
static int getIncome(const PlayerState * ps)
|
|
|
|
{
|
|
|
|
int totalIncome = 0;
|
|
|
|
const CGObjectInstance * heroOrTown = nullptr;
|
|
|
|
|
|
|
|
//Heroes can produce gold as well - skill, specialty or arts
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & h : ps->heroes)
|
2015-12-01 05:28:08 +02:00
|
|
|
{
|
|
|
|
totalIncome += h->valOfBonuses(Selector::typeSubtype(Bonus::GENERATE_RESOURCE, Res::GOLD));
|
|
|
|
|
|
|
|
if(!heroOrTown)
|
|
|
|
heroOrTown = h;
|
|
|
|
}
|
|
|
|
|
|
|
|
//Add town income of all towns
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & t : ps->towns)
|
2015-12-01 05:28:08 +02:00
|
|
|
{
|
|
|
|
totalIncome += t->dailyIncome()[Res::GOLD];
|
|
|
|
|
|
|
|
if(!heroOrTown)
|
|
|
|
heroOrTown = t;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// FIXME: Dirty dirty hack
|
|
|
|
/// Stats helper need some access to gamestate.
|
|
|
|
std::vector<const CGObjectInstance *> ownedObjects;
|
|
|
|
for(const CGObjectInstance * obj : heroOrTown->cb->gameState()->map->objects)
|
|
|
|
{
|
|
|
|
if(obj && obj->tempOwner == ps->color)
|
|
|
|
ownedObjects.push_back(obj);
|
|
|
|
}
|
|
|
|
/// This is code from CPlayerSpecificInfoCallback::getMyObjects
|
|
|
|
/// I'm really need to find out about callback interface design...
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto * object : ownedObjects)
|
2015-12-01 05:28:08 +02:00
|
|
|
{
|
|
|
|
//Mines
|
|
|
|
if ( object->ID == Obj::MINE )
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
const auto * mine = dynamic_cast<const CGMine *>(object);
|
2015-12-01 05:28:08 +02:00
|
|
|
assert(mine);
|
|
|
|
|
|
|
|
if (mine->producedResource == Res::GOLD)
|
|
|
|
totalIncome += mine->producedQuantity;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return totalIncome;
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
void CGameState::obtainPlayersStats(SThievesGuildInfo & tgi, int level)
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto playerInactive = [&](const PlayerColor & color)
|
2013-12-04 06:54:02 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
return color == PlayerColor::NEUTRAL || players.at(color).status != EPlayerStatus::INGAME;
|
2013-12-04 06:54:02 +03:00
|
|
|
};
|
|
|
|
|
2013-11-12 13:09:55 +03:00
|
|
|
#define FILL_FIELD(FIELD, VAL_GETTER) \
|
|
|
|
{ \
|
|
|
|
std::vector< std::pair< PlayerColor, si64 > > stats; \
|
|
|
|
for(auto g = players.begin(); g != players.end(); ++g) \
|
|
|
|
{ \
|
2013-12-04 06:54:02 +03:00
|
|
|
if(playerInactive(g->second.color)) \
|
2013-11-12 13:09:55 +03:00
|
|
|
continue; \
|
|
|
|
std::pair< PlayerColor, si64 > stat; \
|
|
|
|
stat.first = g->second.color; \
|
|
|
|
stat.second = VAL_GETTER; \
|
|
|
|
stats.push_back(stat); \
|
|
|
|
} \
|
|
|
|
tgi.FIELD = statsHLP::getRank(stats); \
|
|
|
|
}
|
|
|
|
|
|
|
|
for(auto & elem : players)
|
|
|
|
{
|
2013-12-04 06:54:02 +03:00
|
|
|
if(!playerInactive(elem.second.color))
|
2013-11-12 13:09:55 +03:00
|
|
|
tgi.playerColors.push_back(elem.second.color);
|
|
|
|
}
|
|
|
|
|
2015-12-04 17:38:57 +02:00
|
|
|
if(level >= 0) //num of towns & num of heroes
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
//num of towns
|
|
|
|
FILL_FIELD(numOfTowns, g->second.towns.size())
|
|
|
|
//num of heroes
|
|
|
|
FILL_FIELD(numOfHeroes, g->second.heroes.size())
|
2015-12-04 17:38:57 +02:00
|
|
|
}
|
|
|
|
if(level >= 1) //best hero's portrait
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & player : players)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
if(playerInactive(player.second.color))
|
2013-11-12 13:09:55 +03:00
|
|
|
continue;
|
2023-03-13 23:26:44 +02:00
|
|
|
const CGHeroInstance * best = statsHLP::findBestHero(this, player.second.color);
|
2013-11-12 13:09:55 +03:00
|
|
|
InfoAboutHero iah;
|
2016-09-28 13:22:33 +02:00
|
|
|
iah.initFromHero(best, (level >= 2) ? InfoAboutHero::EInfoLevel::DETAILED : InfoAboutHero::EInfoLevel::BASIC);
|
2013-11-12 13:09:55 +03:00
|
|
|
iah.army.clear();
|
2023-03-13 23:26:44 +02:00
|
|
|
tgi.colorToBestHero[player.second.color] = iah;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if(level >= 2) //gold
|
|
|
|
{
|
|
|
|
FILL_FIELD(gold, g->second.resources[Res::GOLD])
|
|
|
|
}
|
|
|
|
if(level >= 2) //wood & ore
|
|
|
|
{
|
|
|
|
FILL_FIELD(woodOre, g->second.resources[Res::WOOD] + g->second.resources[Res::ORE])
|
|
|
|
}
|
|
|
|
if(level >= 3) //mercury, sulfur, crystal, gems
|
|
|
|
{
|
|
|
|
FILL_FIELD(mercSulfCrystGems, g->second.resources[Res::MERCURY] + g->second.resources[Res::SULFUR] + g->second.resources[Res::CRYSTAL] + g->second.resources[Res::GEMS])
|
|
|
|
}
|
2015-12-04 16:37:19 +02:00
|
|
|
if(level >= 3) //obelisks found
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto getObeliskVisited = [](const TeamID & t)
|
2016-08-29 22:07:52 +02:00
|
|
|
{
|
|
|
|
if(CGObelisk::visited.count(t))
|
|
|
|
return CGObelisk::visited[t];
|
|
|
|
else
|
|
|
|
return ui8(0);
|
|
|
|
};
|
|
|
|
|
|
|
|
FILL_FIELD(obelisks, getObeliskVisited(gs->getPlayerTeam(g->second.color)->id))
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2015-12-04 16:37:19 +02:00
|
|
|
if(level >= 4) //artifacts
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
FILL_FIELD(artifacts, statsHLP::getNumberOfArts(&g->second))
|
|
|
|
}
|
2015-12-04 16:37:19 +02:00
|
|
|
if(level >= 4) //army strength
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
FILL_FIELD(army, statsHLP::getArmyStrength(&g->second))
|
|
|
|
}
|
2015-12-04 16:37:19 +02:00
|
|
|
if(level >= 5) //income
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2015-12-01 05:28:08 +02:00
|
|
|
FILL_FIELD(income, statsHLP::getIncome(&g->second))
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
2015-12-04 16:37:19 +02:00
|
|
|
if(level >= 2) //best hero's stats
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
//already set in lvl 1 handling
|
|
|
|
}
|
2015-12-04 16:37:19 +02:00
|
|
|
if(level >= 3) //personality
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & player : players)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
if(playerInactive(player.second.color)) //do nothing for neutral player
|
2013-11-12 13:09:55 +03:00
|
|
|
continue;
|
2023-03-13 23:26:44 +02:00
|
|
|
if(player.second.human)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
tgi.personality[player.second.color] = EAiTactic::NONE;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
else //AI
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
tgi.personality[player.second.color] = map->players[player.second.color.getNum()].aiTactic;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
2015-12-04 16:37:19 +02:00
|
|
|
if(level >= 4) //best creature
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
//best creatures belonging to player (highest AI value)
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & player : players)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
if(playerInactive(player.second.color)) //do nothing for neutral player
|
2013-11-12 13:09:55 +03:00
|
|
|
continue;
|
|
|
|
int bestCre = -1; //best creature's ID
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & elem : player.second.heroes)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & it : elem->Slots())
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
int toCmp = it.second->type->idNumber; //ID of creature we should compare with the best one
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
if(bestCre == -1 || VLC->creh->objects[bestCre]->AIValue < VLC->creh->objects[toCmp]->AIValue)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
bestCre = toCmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-03-13 23:26:44 +02:00
|
|
|
tgi.bestCreature[player.second.color] = bestCre;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef FILL_FIELD
|
|
|
|
}
|
|
|
|
|
2013-11-12 13:45:42 +03:00
|
|
|
std::map<ui32, ConstTransitivePtr<CGHeroInstance> > CGameState::unusedHeroesFromPool()
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2013-11-12 13:45:42 +03:00
|
|
|
std::map<ui32, ConstTransitivePtr<CGHeroInstance> > pool = hpool.heroesPool;
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & player : players)
|
|
|
|
for(auto availableHero : player.second.availableHeroes)
|
|
|
|
if(availableHero)
|
|
|
|
pool.erase((*availableHero).subID);
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
return pool;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CGameState::buildBonusSystemTree()
|
|
|
|
{
|
|
|
|
buildGlobalTeamPlayerTree();
|
|
|
|
attachArmedObjects();
|
|
|
|
|
|
|
|
for(CGTownInstance *t : map->towns)
|
|
|
|
{
|
|
|
|
t->deserializationFix();
|
|
|
|
}
|
|
|
|
// CStackInstance <-> CCreature, CStackInstance <-> CArmedInstance, CArtifactInstance <-> CArtifact
|
|
|
|
// are provided on initializing / deserializing
|
|
|
|
}
|
|
|
|
|
|
|
|
void CGameState::deserializationFix()
|
|
|
|
{
|
|
|
|
buildGlobalTeamPlayerTree();
|
|
|
|
attachArmedObjects();
|
|
|
|
}
|
|
|
|
|
|
|
|
void CGameState::buildGlobalTeamPlayerTree()
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(auto & team : teams)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
TeamState * t = &team.second;
|
2022-11-06 01:26:13 +02:00
|
|
|
t->attachTo(globalEffects);
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const PlayerColor & teamMember : team.second.players)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
PlayerState *p = getPlayerState(teamMember);
|
2013-11-12 13:09:55 +03:00
|
|
|
assert(p);
|
2022-11-06 01:26:13 +02:00
|
|
|
p->attachTo(*t);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CGameState::attachArmedObjects()
|
|
|
|
{
|
|
|
|
for(CGObjectInstance *obj : map->objects)
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
if(auto * armed = dynamic_cast<CArmedInstance *>(obj))
|
2022-11-06 01:26:13 +02:00
|
|
|
{
|
|
|
|
armed->whatShouldBeAttached().attachTo(armed->whereShouldBeAttached(this));
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
void CGameState::giveHeroArtifact(CGHeroInstance * h, const ArtifactID & aid)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
CArtifact * const artifact = VLC->arth->objects[aid]; //pointer to constant object
|
2013-11-12 13:09:55 +03:00
|
|
|
CArtifactInstance *ai = CArtifactInstance::createNewArtifactInstance(artifact);
|
|
|
|
map->addNewArtifactInstance(ai);
|
|
|
|
ai->putAt(ArtifactLocation(h, ai->firstAvailableSlot(h)));
|
|
|
|
}
|
|
|
|
|
2017-07-15 13:08:20 +02:00
|
|
|
std::set<HeroTypeID> CGameState::getUnusedAllowedHeroes(bool alsoIncludeNotAllowed) const
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
std::set<HeroTypeID> ret;
|
|
|
|
for(int i = 0; i < map->allowedHeroes.size(); i++)
|
|
|
|
if(map->allowedHeroes[i] || alsoIncludeNotAllowed)
|
|
|
|
ret.insert(HeroTypeID(i));
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & playerSettingPair : scenarioOps->playerInfos) //remove uninitialized yet heroes picked for start by other players
|
2019-04-29 07:45:30 +02:00
|
|
|
{
|
|
|
|
if(playerSettingPair.second.hero != PlayerSettings::RANDOM)
|
|
|
|
ret -= HeroTypeID(playerSettingPair.second.hero);
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
for(auto hero : map->heroesOnMap) //heroes instances initialization
|
|
|
|
{
|
|
|
|
if(hero->type)
|
2023-01-02 13:27:03 +02:00
|
|
|
ret -= hero->type->getId();
|
2013-11-12 13:09:55 +03:00
|
|
|
else
|
|
|
|
ret -= HeroTypeID(hero->subID);
|
|
|
|
}
|
|
|
|
|
|
|
|
for(auto obj : map->objects) //prisons
|
|
|
|
if(obj && obj->ID == Obj::PRISON)
|
|
|
|
ret -= HeroTypeID(obj->subID);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-01-30 21:56:31 +03:00
|
|
|
std::vector<CGameState::CampaignHeroReplacement> CGameState::generateCampaignHeroesToReplace(CrossoverHeroesList & crossoverHeroes)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2014-01-30 21:56:31 +03:00
|
|
|
std::vector<CampaignHeroReplacement> campaignHeroReplacements;
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-20 16:07:58 +03:00
|
|
|
//selecting heroes by type
|
2014-01-30 21:56:31 +03:00
|
|
|
for(auto obj : map->objects)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2014-01-30 21:56:31 +03:00
|
|
|
if(obj && obj->ID == Obj::HERO_PLACEHOLDER)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * heroPlaceholder = dynamic_cast<CGHeroPlaceholder *>(obj.get());
|
2014-01-30 21:56:31 +03:00
|
|
|
if(heroPlaceholder->subID != 0xFF) //select by type
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2014-01-30 21:56:31 +03:00
|
|
|
auto it = range::find_if(crossoverHeroes.heroesFromAnyPreviousScenarios, [heroPlaceholder](CGHeroInstance * hero)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2014-01-30 21:56:31 +03:00
|
|
|
return hero->subID == heroPlaceholder->subID;
|
|
|
|
});
|
2014-02-19 22:14:32 +03:00
|
|
|
|
2014-02-23 16:52:06 +03:00
|
|
|
if(it != crossoverHeroes.heroesFromAnyPreviousScenarios.end())
|
2014-01-30 21:56:31 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * hero = *it;
|
2014-02-19 22:14:32 +03:00
|
|
|
crossoverHeroes.removeHeroFromBothLists(hero);
|
2023-03-13 23:26:44 +02:00
|
|
|
campaignHeroReplacements.emplace_back(CMemorySerializer::deepCopy(*hero).release(), heroPlaceholder->id);
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-20 16:07:58 +03:00
|
|
|
//selecting heroes by power
|
2014-01-30 21:56:31 +03:00
|
|
|
range::sort(crossoverHeroes.heroesFromPreviousScenario, [](const CGHeroInstance * a, const CGHeroInstance * b)
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
|
|
|
return a->getHeroStrength() > b->getHeroStrength();
|
|
|
|
}); //sort, descending strength
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-20 16:07:58 +03:00
|
|
|
// sort hero placeholders descending power
|
|
|
|
std::vector<CGHeroPlaceholder *> heroPlaceholders;
|
2014-01-30 21:56:31 +03:00
|
|
|
for(auto obj : map->objects)
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
2013-12-31 19:58:11 +03:00
|
|
|
if(obj && obj->ID == Obj::HERO_PLACEHOLDER)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * heroPlaceholder = dynamic_cast<CGHeroPlaceholder *>(obj.get());
|
2014-01-30 21:56:31 +03:00
|
|
|
if(heroPlaceholder->subID == 0xFF) //select by power
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2014-01-30 21:56:31 +03:00
|
|
|
heroPlaceholders.push_back(heroPlaceholder);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-01-30 21:56:31 +03:00
|
|
|
range::sort(heroPlaceholders, [](const CGHeroPlaceholder * a, const CGHeroPlaceholder * b)
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
|
|
|
return a->power > b->power;
|
|
|
|
});
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-20 16:07:58 +03:00
|
|
|
for(int i = 0; i < heroPlaceholders.size(); ++i)
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * heroPlaceholder = heroPlaceholders[i];
|
2014-01-30 21:56:31 +03:00
|
|
|
if(crossoverHeroes.heroesFromPreviousScenario.size() > i)
|
2013-12-20 16:07:58 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * hero = crossoverHeroes.heroesFromPreviousScenario[i];
|
|
|
|
campaignHeroReplacements.emplace_back(CMemorySerializer::deepCopy(*hero).release(), heroPlaceholder->id);
|
2013-12-20 16:07:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return campaignHeroReplacements;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2014-01-30 21:56:31 +03:00
|
|
|
void CGameState::replaceHeroesPlaceholders(const std::vector<CGameState::CampaignHeroReplacement> & campaignHeroReplacements)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & campaignHeroReplacement : campaignHeroReplacements)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * heroPlaceholder = dynamic_cast<CGHeroPlaceholder *>(getObjInstance(campaignHeroReplacement.heroPlaceholderId));
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2014-01-30 21:56:31 +03:00
|
|
|
CGHeroInstance *heroToPlace = campaignHeroReplacement.hero;
|
|
|
|
heroToPlace->id = campaignHeroReplacement.heroPlaceholderId;
|
|
|
|
heroToPlace->tempOwner = heroPlaceholder->tempOwner;
|
|
|
|
heroToPlace->pos = heroPlaceholder->pos;
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
heroToPlace->type = VLC->heroh->objects[heroToPlace->subID];
|
2022-11-23 12:32:03 +02:00
|
|
|
heroToPlace->appearance = VLC->objtypeh->getHandlerFor(Obj::HERO,
|
|
|
|
heroToPlace->type->heroClass->getIndex())->getTemplates().front();
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
for(auto &&i : heroToPlace->stacks)
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
i.second->type = VLC->creh->objects[i.second->getCreatureID()];
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
auto fixArtifact = [&](CArtifactInstance * art)
|
|
|
|
{
|
2023-01-02 15:58:56 +02:00
|
|
|
art->artType = VLC->arth->objects[art->artType->getId()];
|
2023-03-13 23:26:44 +02:00
|
|
|
gs->map->artInstances.emplace_back(art);
|
2020-10-01 10:38:06 +02:00
|
|
|
art->id = ArtifactInstanceID((si32)gs->map->artInstances.size() - 1);
|
2013-11-12 13:09:55 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
for(auto &&i : heroToPlace->artifactsWorn)
|
|
|
|
fixArtifact(i.second.artifact);
|
|
|
|
for(auto &&i : heroToPlace->artifactsInBackpack)
|
|
|
|
fixArtifact(i.artifact);
|
|
|
|
|
2023-02-21 18:42:31 +02:00
|
|
|
map->removeBlockVisTiles(heroPlaceholder, true);
|
|
|
|
map->objects[heroPlaceholder->id.getNum()] = nullptr;
|
|
|
|
map->instanceNames.erase(heroPlaceholder->instanceName);
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
map->heroesOnMap.emplace_back(heroToPlace);
|
2013-11-12 13:09:55 +03:00
|
|
|
map->objects[heroToPlace->id.getNum()] = heroToPlace;
|
|
|
|
map->addBlockVisTiles(heroToPlace);
|
2023-02-21 18:42:31 +02:00
|
|
|
map->instanceNames[heroToPlace->instanceName] = heroToPlace;
|
|
|
|
|
|
|
|
delete heroPlaceholder;
|
2014-01-30 21:56:31 +03:00
|
|
|
|
2018-01-05 19:21:07 +02:00
|
|
|
scenarioOps->campState->getCurrentScenario().placedCrossoverHeroes.push_back(CCampaignState::crossoverSerialize(heroToPlace));
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
bool CGameState::isUsedHero(const HeroTypeID & hid) const
|
2013-12-30 18:34:28 +03:00
|
|
|
{
|
|
|
|
return getUsedHero(hid);
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
CGHeroInstance * CGameState::getUsedHero(const HeroTypeID & hid) const
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
for(auto hero : map->heroesOnMap) //heroes instances initialization
|
2013-12-30 18:34:28 +03:00
|
|
|
{
|
2023-01-02 13:27:03 +02:00
|
|
|
if(hero->type && hero->type->getId() == hid)
|
2013-12-30 18:34:28 +03:00
|
|
|
{
|
|
|
|
return hero;
|
|
|
|
}
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
|
|
|
for(auto obj : map->objects) //prisons
|
2013-12-30 18:34:28 +03:00
|
|
|
{
|
2015-12-05 01:40:23 +02:00
|
|
|
if(obj && obj->ID == Obj::PRISON )
|
2013-12-30 18:34:28 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
auto * hero = dynamic_cast<CGHeroInstance *>(obj.get());
|
2015-12-05 01:40:23 +02:00
|
|
|
assert(hero);
|
2023-01-02 13:27:03 +02:00
|
|
|
if ( hero->type && hero->type->getId() == hid )
|
2015-12-05 01:40:23 +02:00
|
|
|
return hero;
|
2013-12-30 18:34:28 +03:00
|
|
|
}
|
|
|
|
}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2013-12-30 18:34:28 +03:00
|
|
|
return nullptr;
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2015-12-01 03:57:52 +02:00
|
|
|
bool RumorState::update(int id, int extra)
|
2015-12-01 01:14:11 +02:00
|
|
|
{
|
|
|
|
if(vstd::contains(last, type))
|
|
|
|
{
|
|
|
|
if(last[type].first != id)
|
|
|
|
{
|
|
|
|
last[type].first = id;
|
2015-12-01 03:57:52 +02:00
|
|
|
last[type].second = extra;
|
2015-12-01 01:14:11 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
2015-12-01 03:57:52 +02:00
|
|
|
last[type] = std::make_pair(id, extra);
|
2015-12-01 01:14:11 +02:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-11-12 13:09:55 +03:00
|
|
|
InfoAboutArmy::InfoAboutArmy():
|
2016-03-12 03:41:27 +02:00
|
|
|
owner(PlayerColor::NEUTRAL)
|
2013-11-12 13:09:55 +03:00
|
|
|
{}
|
|
|
|
|
|
|
|
InfoAboutArmy::InfoAboutArmy(const CArmedInstance *Army, bool detailed)
|
|
|
|
{
|
|
|
|
initFromArmy(Army, detailed);
|
|
|
|
}
|
|
|
|
|
|
|
|
void InfoAboutArmy::initFromArmy(const CArmedInstance *Army, bool detailed)
|
|
|
|
{
|
|
|
|
army = ArmyDescriptor(Army, detailed);
|
|
|
|
owner = Army->tempOwner;
|
2014-06-24 20:39:36 +03:00
|
|
|
name = Army->getObjectName();
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void InfoAboutHero::assign(const InfoAboutHero & iah)
|
|
|
|
{
|
2016-11-26 21:24:16 +02:00
|
|
|
vstd::clear_pointer(details);
|
2013-11-12 13:09:55 +03:00
|
|
|
InfoAboutArmy::operator = (iah);
|
|
|
|
|
|
|
|
details = (iah.details ? new Details(*iah.details) : nullptr);
|
|
|
|
hclass = iah.hclass;
|
|
|
|
portrait = iah.portrait;
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
InfoAboutHero::InfoAboutHero(): portrait(-1) {}
|
2013-11-12 13:09:55 +03:00
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
InfoAboutHero::InfoAboutHero(const InfoAboutHero & iah): InfoAboutArmy(iah)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
assign(iah);
|
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
InfoAboutHero::InfoAboutHero(const CGHeroInstance * h, InfoAboutHero::EInfoLevel infoLevel):
|
2013-11-12 13:09:55 +03:00
|
|
|
portrait(-1)
|
|
|
|
{
|
2016-09-28 13:22:33 +02:00
|
|
|
initFromHero(h, infoLevel);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
InfoAboutHero::~InfoAboutHero()
|
|
|
|
{
|
2016-11-26 21:24:16 +02:00
|
|
|
vstd::clear_pointer(details);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
InfoAboutHero & InfoAboutHero::operator=(const InfoAboutHero & iah)
|
|
|
|
{
|
|
|
|
assign(iah);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2016-09-28 13:22:33 +02:00
|
|
|
void InfoAboutHero::initFromHero(const CGHeroInstance *h, InfoAboutHero::EInfoLevel infoLevel)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2016-11-26 21:24:16 +02:00
|
|
|
vstd::clear_pointer(details);
|
2013-11-12 13:09:55 +03:00
|
|
|
if(!h)
|
|
|
|
return;
|
|
|
|
|
2016-09-28 13:22:33 +02:00
|
|
|
bool detailed = ( (infoLevel == EInfoLevel::DETAILED) || (infoLevel == EInfoLevel::INBATTLE) );
|
|
|
|
|
2013-11-12 13:09:55 +03:00
|
|
|
initFromArmy(h, detailed);
|
|
|
|
|
|
|
|
hclass = h->type->heroClass;
|
2023-01-02 13:27:03 +02:00
|
|
|
name = h->getNameTranslated();
|
2013-11-12 13:09:55 +03:00
|
|
|
portrait = h->portrait;
|
|
|
|
|
|
|
|
if(detailed)
|
|
|
|
{
|
|
|
|
//include details about hero
|
2017-07-16 11:58:05 +02:00
|
|
|
details = new Details();
|
2013-11-12 13:09:55 +03:00
|
|
|
details->luck = h->LuckVal();
|
|
|
|
details->morale = h->MoraleVal();
|
|
|
|
details->mana = h->mana;
|
|
|
|
details->primskills.resize(GameConstants::PRIMARY_SKILLS);
|
|
|
|
|
|
|
|
for (int i = 0; i < GameConstants::PRIMARY_SKILLS ; i++)
|
|
|
|
{
|
|
|
|
details->primskills[i] = h->getPrimSkillLevel(static_cast<PrimarySkill::PrimarySkill>(i));
|
|
|
|
}
|
2016-09-28 13:22:33 +02:00
|
|
|
if (infoLevel == EInfoLevel::INBATTLE)
|
|
|
|
details->manaLimit = h->manaLimit();
|
|
|
|
else
|
|
|
|
details->manaLimit = -1; //we do not want to leak max mana info outside battle so set to meaningless value
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
InfoAboutTown::InfoAboutTown():
|
2016-03-12 03:41:27 +02:00
|
|
|
details(nullptr),
|
|
|
|
tType(nullptr),
|
|
|
|
built(0),
|
|
|
|
fortLevel(0)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-11-26 21:24:16 +02:00
|
|
|
InfoAboutTown::InfoAboutTown(const CGTownInstance *t, bool detailed):
|
|
|
|
details(nullptr),
|
|
|
|
tType(nullptr),
|
|
|
|
built(0),
|
|
|
|
fortLevel(0)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
initFromTown(t, detailed);
|
|
|
|
}
|
|
|
|
|
|
|
|
InfoAboutTown::~InfoAboutTown()
|
|
|
|
{
|
2016-11-26 21:24:16 +02:00
|
|
|
vstd::clear_pointer(details);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void InfoAboutTown::initFromTown(const CGTownInstance *t, bool detailed)
|
|
|
|
{
|
|
|
|
initFromArmy(t, detailed);
|
|
|
|
army = ArmyDescriptor(t->getUpperArmy(), detailed);
|
|
|
|
built = t->builded;
|
|
|
|
fortLevel = t->fortLevel();
|
2023-01-04 15:17:50 +02:00
|
|
|
name = t->getNameTranslated();
|
2013-11-12 13:09:55 +03:00
|
|
|
tType = t->town;
|
|
|
|
|
2016-11-26 21:24:16 +02:00
|
|
|
vstd::clear_pointer(details);
|
|
|
|
|
2013-11-12 13:09:55 +03:00
|
|
|
if(detailed)
|
|
|
|
{
|
|
|
|
//include details about hero
|
2017-07-16 11:58:05 +02:00
|
|
|
details = new Details();
|
2014-06-03 22:45:18 +03:00
|
|
|
TResources income = t->dailyIncome();
|
|
|
|
details->goldIncome = income[Res::GOLD];
|
2013-11-12 13:09:55 +03:00
|
|
|
details->customRes = t->hasBuilt(BuildingID::RESOURCE_SILO);
|
|
|
|
details->hallLevel = t->hallLevel();
|
|
|
|
details->garrisonedHero = t->garrisonHero;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ArmyDescriptor::ArmyDescriptor(const CArmedInstance *army, bool detailed)
|
2016-03-12 03:41:27 +02:00
|
|
|
: isDetailed(detailed)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & elem : army->Slots())
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
if(detailed)
|
|
|
|
(*this)[elem.first] = *elem.second;
|
|
|
|
else
|
2023-01-14 16:55:08 +02:00
|
|
|
(*this)[elem.first] = CStackBasicDescriptor(elem.second->type, (int)elem.second->getQuantityID());
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ArmyDescriptor::ArmyDescriptor()
|
2016-03-12 03:41:27 +02:00
|
|
|
: isDetailed(false)
|
2013-11-12 13:09:55 +03:00
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int ArmyDescriptor::getStrength() const
|
|
|
|
{
|
|
|
|
ui64 ret = 0;
|
|
|
|
if(isDetailed)
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & elem : *this)
|
2013-11-12 13:09:55 +03:00
|
|
|
ret += elem.second.type->AIValue * elem.second.count;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2023-03-13 23:26:44 +02:00
|
|
|
for(const auto & elem : *this)
|
2013-11-12 13:09:55 +03:00
|
|
|
ret += elem.second.type->AIValue * CCreature::estimateCreatureCount(elem.second.count);
|
|
|
|
}
|
2020-10-01 10:38:06 +02:00
|
|
|
return static_cast<int>(ret);
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
TeamState::TeamState()
|
|
|
|
{
|
|
|
|
setNodeType(TEAM);
|
2022-09-18 16:39:10 +02:00
|
|
|
fogOfWarMap = std::make_shared<boost::multi_array<ui8, 3>>();
|
2013-11-12 13:09:55 +03:00
|
|
|
}
|
|
|
|
|
2023-03-13 23:26:44 +02:00
|
|
|
TeamState::TeamState(TeamState && other) noexcept:
|
2016-07-29 11:27:55 +02:00
|
|
|
CBonusSystemNode(std::move(other)),
|
|
|
|
id(other.id)
|
|
|
|
{
|
|
|
|
std::swap(players, other.players);
|
|
|
|
std::swap(fogOfWarMap, other.fogOfWarMap);
|
|
|
|
}
|
|
|
|
|
2014-03-17 22:51:07 +03:00
|
|
|
CRandomGenerator & CGameState::getRandomGenerator()
|
|
|
|
{
|
|
|
|
return rand;
|
|
|
|
}
|
2022-07-26 15:07:42 +02:00
|
|
|
|
|
|
|
VCMI_LIB_NAMESPACE_END
|