2017-07-13 10:26:03 +02:00
|
|
|
/*
|
|
|
|
* NetPacksLib.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
|
|
|
|
*
|
|
|
|
*/
|
2011-12-14 00:23:17 +03:00
|
|
|
#include "StdInc.h"
|
2009-05-20 13:08:56 +03:00
|
|
|
#include "NetPacks.h"
|
2011-12-14 00:23:17 +03:00
|
|
|
|
2010-12-20 23:22:53 +02:00
|
|
|
#include "CGeneralTextHandler.h"
|
2014-06-05 14:19:47 +03:00
|
|
|
#include "mapObjects/CObjectClassesHandler.h"
|
2010-12-20 23:22:53 +02:00
|
|
|
#include "CArtHandler.h"
|
|
|
|
#include "CHeroHandler.h"
|
2014-06-05 14:19:47 +03:00
|
|
|
#include "mapObjects/CObjectHandler.h"
|
2012-08-24 12:37:52 +03:00
|
|
|
#include "CModHandler.h"
|
2009-05-20 13:08:56 +03:00
|
|
|
#include "VCMI_Lib.h"
|
2013-04-07 13:48:07 +03:00
|
|
|
#include "mapping/CMap.h"
|
2015-03-10 22:14:58 +02:00
|
|
|
#include "spells/CSpellHandler.h"
|
2010-12-20 23:22:53 +02:00
|
|
|
#include "CCreatureHandler.h"
|
2010-12-25 21:23:30 +02:00
|
|
|
#include "CGameState.h"
|
2017-03-17 17:48:44 +02:00
|
|
|
#include "CStack.h"
|
2017-06-24 16:42:05 +02:00
|
|
|
#include "battle/BattleInfo.h"
|
2013-09-27 18:20:42 +03:00
|
|
|
#include "CTownHandler.h"
|
2014-06-25 17:11:07 +03:00
|
|
|
#include "mapping/CMapInfo.h"
|
|
|
|
#include "StartInfo.h"
|
2015-12-02 21:39:53 +02:00
|
|
|
#include "CPlayerState.h"
|
2023-01-09 01:17:37 +02:00
|
|
|
#include "TerrainHandler.h"
|
2009-03-07 17:55:56 +02:00
|
|
|
|
2022-07-26 15:07:42 +02:00
|
|
|
VCMI_LIB_NAMESPACE_BEGIN
|
|
|
|
|
2009-05-18 01:52:22 +03:00
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void SetResources::applyGs(CGameState *gs)
|
2011-07-05 09:14:07 +03:00
|
|
|
{
|
2013-03-03 20:06:03 +03:00
|
|
|
assert(player < PlayerColor::PLAYER_LIMIT);
|
2016-11-26 14:14:43 +02:00
|
|
|
if(abs)
|
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
|
|
|
gs->getPlayerState(player)->resources = res;
|
2016-11-26 14:14:43 +02:00
|
|
|
else
|
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
|
|
|
gs->getPlayerState(player)->resources += res;
|
2016-11-26 14:14:43 +02:00
|
|
|
|
|
|
|
//just ensure that player resources are not negative
|
|
|
|
//server is responsible to check if player can afford deal
|
|
|
|
//but events on server side are allowed to take more than player have
|
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
|
|
|
gs->getPlayerState(player)->resources.positive();
|
2011-07-05 09:14:07 +03:00
|
|
|
}
|
2009-03-07 17:55:56 +02:00
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void SetPrimSkill::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2014-04-10 20:11:09 +03:00
|
|
|
CGHeroInstance * hero = gs->getHero(id);
|
2010-05-02 21:20:26 +03:00
|
|
|
assert(hero);
|
2014-04-10 20:11:09 +03:00
|
|
|
hero->setPrimarySkill(which, val, abs);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void SetSecSkill::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
CGHeroInstance *hero = gs->getHero(id);
|
2013-02-04 22:43:16 +03:00
|
|
|
hero->setSecSkillLevel(which, val, abs);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2012-05-18 17:02:27 +03:00
|
|
|
DLL_LINKAGE void SetCommanderProperty::applyGs(CGameState *gs)
|
|
|
|
{
|
|
|
|
CCommanderInstance * commander = gs->getHero(heroid)->commander;
|
|
|
|
assert (commander);
|
|
|
|
|
|
|
|
switch (which)
|
|
|
|
{
|
|
|
|
case BONUS:
|
2016-09-19 23:36:35 +02:00
|
|
|
commander->accumulateBonus (std::make_shared<Bonus>(accumulatedBonus));
|
2012-05-18 17:02:27 +03:00
|
|
|
break;
|
2012-05-18 22:44:15 +03:00
|
|
|
case SPECIAL_SKILL:
|
2016-09-19 23:36:35 +02:00
|
|
|
commander->accumulateBonus (std::make_shared<Bonus>(accumulatedBonus));
|
2012-05-18 22:44:15 +03:00
|
|
|
commander->specialSKills.insert (additionalInfo);
|
|
|
|
break;
|
2012-05-18 17:02:27 +03:00
|
|
|
case SECONDARY_SKILL:
|
2020-10-01 10:38:06 +02:00
|
|
|
commander->secondarySkills[additionalInfo] = static_cast<ui8>(amount);
|
2012-05-18 17:02:27 +03:00
|
|
|
break;
|
|
|
|
case ALIVE:
|
|
|
|
if (amount)
|
|
|
|
commander->setAlive(true);
|
|
|
|
else
|
|
|
|
commander->setAlive(false);
|
|
|
|
break;
|
2012-05-18 22:44:15 +03:00
|
|
|
case EXPERIENCE:
|
2016-10-29 17:00:12 +02:00
|
|
|
commander->giveStackExp(amount); //TODO: allow setting exp for stacks via netpacks
|
2012-05-18 22:44:15 +03:00
|
|
|
break;
|
2012-05-18 17:02:27 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-06 22:12:04 +03:00
|
|
|
DLL_LINKAGE void AddQuest::applyGs(CGameState *gs)
|
|
|
|
{
|
|
|
|
assert (vstd::contains(gs->players, player));
|
2012-07-08 19:36:20 +03:00
|
|
|
auto vec = &gs->players[player].quests;
|
|
|
|
if (!vstd::contains(*vec, quest))
|
|
|
|
vec->push_back (quest);
|
|
|
|
else
|
2017-08-10 18:39:27 +02:00
|
|
|
logNetwork->warn("Warning! Attempt to add duplicated quest");
|
2012-07-06 22:12:04 +03:00
|
|
|
}
|
|
|
|
|
2013-02-19 01:37:22 +03:00
|
|
|
DLL_LINKAGE void UpdateArtHandlerLists::applyGs(CGameState *gs)
|
|
|
|
{
|
|
|
|
VLC->arth->minors = minors;
|
|
|
|
VLC->arth->majors = majors;
|
|
|
|
VLC->arth->treasures = treasures;
|
|
|
|
VLC->arth->relics = relics;
|
|
|
|
}
|
|
|
|
|
|
|
|
DLL_LINKAGE void UpdateMapEvents::applyGs(CGameState *gs)
|
|
|
|
{
|
|
|
|
gs->map->events = events;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
DLL_LINKAGE void UpdateCastleEvents::applyGs(CGameState *gs)
|
|
|
|
{
|
|
|
|
auto t = gs->getTown(town);
|
|
|
|
t->events = events;
|
|
|
|
}
|
|
|
|
|
2016-09-08 18:29:15 +02:00
|
|
|
DLL_LINKAGE void ChangeFormation::applyGs(CGameState *gs)
|
|
|
|
{
|
|
|
|
gs->getHero(hid)->setFormation(formation);
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void HeroVisitCastle::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
CGHeroInstance *h = gs->getHero(hid);
|
|
|
|
CGTownInstance *t = gs->getTown(tid);
|
2011-02-04 16:58:14 +02:00
|
|
|
|
2014-06-05 18:19:11 +03:00
|
|
|
assert(h);
|
|
|
|
assert(t);
|
2014-07-01 08:07:40 +03:00
|
|
|
|
2009-03-07 17:55:56 +02:00
|
|
|
if(start())
|
2011-02-04 16:58:14 +02:00
|
|
|
t->setVisitingHero(h);
|
2009-03-07 17:55:56 +02:00
|
|
|
else
|
2013-06-26 14:18:27 +03:00
|
|
|
t->setVisitingHero(nullptr);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void ChangeSpells::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
CGHeroInstance *hero = gs->getHero(hid);
|
|
|
|
|
|
|
|
if(learn)
|
2013-06-29 16:05:48 +03:00
|
|
|
for(auto sid : spells)
|
2018-12-20 23:42:31 +02:00
|
|
|
hero->addSpellToSpellbook(sid);
|
2009-03-07 17:55:56 +02:00
|
|
|
else
|
2013-06-29 16:05:48 +03:00
|
|
|
for(auto sid : spells)
|
2018-12-20 23:42:31 +02:00
|
|
|
hero->removeSpellFromSpellbook(sid);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void SetMana::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2014-11-26 12:30:55 +02:00
|
|
|
CGHeroInstance * hero = gs->getHero(hid);
|
2015-03-10 22:14:58 +02:00
|
|
|
|
2014-11-26 12:30:55 +02:00
|
|
|
assert(hero);
|
2015-03-10 22:14:58 +02:00
|
|
|
|
2014-11-26 12:30:55 +02:00
|
|
|
if(absolute)
|
2015-03-10 22:14:58 +02:00
|
|
|
hero->mana = val;
|
2014-11-26 12:30:55 +02:00
|
|
|
else
|
|
|
|
hero->mana += val;
|
|
|
|
|
|
|
|
vstd::amax(hero->mana, 0); //not less than 0
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void SetMovePoints::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
CGHeroInstance *hero = gs->getHero(hid);
|
2017-05-11 20:52:10 +02:00
|
|
|
|
|
|
|
assert(hero);
|
|
|
|
|
|
|
|
if(absolute)
|
|
|
|
hero->movement = val;
|
|
|
|
else
|
|
|
|
hero->movement += val;
|
|
|
|
|
|
|
|
vstd::amax(hero->movement, 0); //not less than 0
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void FoWChange::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2010-08-03 15:34:06 +03:00
|
|
|
TeamState * team = gs->getPlayerTeam(player);
|
2022-09-18 16:39:10 +02:00
|
|
|
auto fogOfWarMap = team->fogOfWarMap;
|
2013-06-29 16:05:48 +03:00
|
|
|
for(int3 t : tiles)
|
2022-09-18 16:39:10 +02:00
|
|
|
(*fogOfWarMap)[t.z][t.x][t.y] = mode;
|
2010-06-06 09:05:39 +03:00
|
|
|
if (mode == 0) //do not hide too much
|
|
|
|
{
|
2013-06-29 16:05:48 +03:00
|
|
|
std::unordered_set<int3, ShashInt3> tilesRevealed;
|
|
|
|
for (auto & elem : gs->map->objects)
|
2010-06-06 09:05:39 +03:00
|
|
|
{
|
2013-06-29 16:05:48 +03:00
|
|
|
const CGObjectInstance *o = elem;
|
2013-01-12 21:08:33 +03:00
|
|
|
if (o)
|
2010-06-06 09:05:39 +03:00
|
|
|
{
|
2013-01-12 21:08:33 +03:00
|
|
|
switch(o->ID)
|
2010-06-06 09:05:39 +03:00
|
|
|
{
|
2013-01-12 21:08:33 +03:00
|
|
|
case Obj::HERO:
|
|
|
|
case Obj::MINE:
|
|
|
|
case Obj::TOWN:
|
|
|
|
case Obj::ABANDONED_MINE:
|
|
|
|
if(vstd::contains(team->players, o->tempOwner)) //check owned observators
|
2016-01-31 17:01:58 +02:00
|
|
|
gs->getTilesInRange(tilesRevealed, o->getSightCenter(), o->getSightRadius(), o->tempOwner, 1);
|
2010-06-06 09:05:39 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-06-29 16:05:48 +03:00
|
|
|
for(int3 t : tilesRevealed) //probably not the most optimal solution ever
|
2022-09-18 16:39:10 +02:00
|
|
|
(*fogOfWarMap)[t.z][t.x][t.y] = 1;
|
2010-06-06 09:05:39 +03:00
|
|
|
}
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
2016-11-18 16:45:59 +02:00
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void SetAvailableHeroes::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02: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 = gs->getPlayerState(player);
|
2010-07-08 08:52:11 +03:00
|
|
|
p->availableHeroes.clear();
|
2009-03-07 17:55:56 +02:00
|
|
|
|
2011-12-14 00:23:17 +03:00
|
|
|
for (int i = 0; i < GameConstants::AVAILABLE_HEROES_PER_PLAYER; i++)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2012-09-26 16:13:39 +03:00
|
|
|
CGHeroInstance *h = (hid[i]>=0 ? gs->hpool.heroesPool[hid[i]].get() : nullptr);
|
2010-07-08 08:52:11 +03:00
|
|
|
if(h && army[i])
|
2011-01-28 04:11:58 +02:00
|
|
|
h->setToArmy(army[i]);
|
2010-07-08 08:52:11 +03:00
|
|
|
p->availableHeroes.push_back(h);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void GiveBonus::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2013-06-26 14:18:27 +03:00
|
|
|
CBonusSystemNode *cbsn = nullptr;
|
2010-02-10 04:56:00 +02:00
|
|
|
switch(who)
|
|
|
|
{
|
|
|
|
case HERO:
|
2013-02-14 02:55:42 +03:00
|
|
|
cbsn = gs->getHero(ObjectInstanceID(id));
|
2010-02-10 04:56:00 +02:00
|
|
|
break;
|
|
|
|
case PLAYER:
|
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
|
|
|
cbsn = gs->getPlayerState(PlayerColor(id));
|
2010-02-10 04:56:00 +02:00
|
|
|
break;
|
2010-06-07 08:28:12 +03:00
|
|
|
case TOWN:
|
2013-02-14 02:55:42 +03:00
|
|
|
cbsn = gs->getTown(ObjectInstanceID(id));
|
2010-11-19 00:06:56 +02:00
|
|
|
break;
|
2010-02-10 04:56:00 +02:00
|
|
|
}
|
2009-04-21 01:57:07 +03:00
|
|
|
|
2010-11-19 00:06:56 +02:00
|
|
|
assert(cbsn);
|
|
|
|
|
2015-11-20 11:11:35 +02:00
|
|
|
if(Bonus::OneWeek(&bonus))
|
|
|
|
bonus.turnsRemain = 8 - gs->getDate(Date::DAY_OF_WEEK); // set correct number of days before adding bonus
|
|
|
|
|
2016-09-19 23:36:35 +02:00
|
|
|
auto b = std::make_shared<Bonus>(bonus);
|
2010-11-19 00:06:56 +02:00
|
|
|
cbsn->addNewBonus(b);
|
|
|
|
|
|
|
|
std::string &descr = b->description;
|
2009-04-21 01:57:07 +03:00
|
|
|
|
2013-01-12 21:08:33 +03:00
|
|
|
if(!bdescr.message.size()
|
2014-07-07 08:29:07 +03:00
|
|
|
&& (bonus.type == Bonus::LUCK || bonus.type == Bonus::MORALE))
|
2009-04-21 01:57:07 +03:00
|
|
|
{
|
2021-01-14 00:02:13 +02:00
|
|
|
if (bonus.source == Bonus::OBJECT)
|
|
|
|
{
|
|
|
|
descr = VLC->generaltexth->arraytxt[bonus.val > 0 ? 110 : 109]; //+/-%d Temporary until next battle"
|
|
|
|
}
|
|
|
|
else if(bonus.source == Bonus::TOWN_STRUCTURE)
|
|
|
|
{
|
|
|
|
descr = bonus.description;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
bdescr.toString(descr);
|
|
|
|
}
|
2009-04-21 01:57:07 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-07-09 22:15:22 +03:00
|
|
|
bdescr.toString(descr);
|
2009-04-21 01:57:07 +03:00
|
|
|
}
|
2014-04-07 20:32:15 +03:00
|
|
|
// Some of(?) versions of H3 use %s here instead of %d. Try to replace both of them
|
|
|
|
boost::replace_first(descr,"%d",boost::lexical_cast<std::string>(std::abs(bonus.val)));
|
|
|
|
boost::replace_first(descr,"%s",boost::lexical_cast<std::string>(std::abs(bonus.val)));
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void ChangeObjPos::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2013-02-14 02:55:42 +03:00
|
|
|
CGObjectInstance *obj = gs->getObjInstance(objid);
|
2009-03-07 17:55:56 +02:00
|
|
|
if(!obj)
|
|
|
|
{
|
2017-08-12 13:36:04 +02:00
|
|
|
logNetwork->error("Wrong ChangeObjPos: object %d doesn't exist!", objid.getNum());
|
2009-03-07 17:55:56 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
gs->map->removeBlockVisTiles(obj);
|
|
|
|
obj->pos = nPos;
|
|
|
|
gs->map->addBlockVisTiles(obj);
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void ChangeObjectVisitors::applyGs(CGameState *gs)
|
2014-04-07 20:32:15 +03:00
|
|
|
{
|
|
|
|
switch (mode) {
|
|
|
|
case VISITOR_ADD:
|
|
|
|
gs->getHero(hero)->visitedObjects.insert(object);
|
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
|
|
|
gs->getPlayerState(gs->getHero(hero)->tempOwner)->visitedObjects.insert(object);
|
2014-04-07 20:32:15 +03:00
|
|
|
break;
|
2016-09-20 22:05:44 +02:00
|
|
|
case VISITOR_ADD_TEAM:
|
|
|
|
{
|
|
|
|
TeamState *ts = gs->getPlayerTeam(gs->getHero(hero)->tempOwner);
|
|
|
|
for (auto & color : ts->players)
|
|
|
|
{
|
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
|
|
|
gs->getPlayerState(color)->visitedObjects.insert(object);
|
2016-09-20 22:05:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2014-04-07 20:32:15 +03:00
|
|
|
case VISITOR_CLEAR:
|
|
|
|
for (CGHeroInstance * hero : gs->map->allHeroes)
|
2016-09-28 19:07:48 +02:00
|
|
|
{
|
|
|
|
if (hero)
|
|
|
|
{
|
|
|
|
hero->visitedObjects.erase(object); // remove visit info from all heroes, including those that are not present on map
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for(auto &elem : gs->players)
|
|
|
|
{
|
|
|
|
elem.second.visitedObjects.erase(object);
|
|
|
|
}
|
|
|
|
|
2014-04-07 20:32:15 +03:00
|
|
|
break;
|
|
|
|
case VISITOR_REMOVE:
|
|
|
|
gs->getHero(hero)->visitedObjects.erase(object);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void PlayerEndsGame::applyGs(CGameState *gs)
|
2010-01-29 22:52:45 +02: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 = gs->getPlayerState(player);
|
2018-01-05 19:21:07 +02:00
|
|
|
if(victoryLossCheckResult.victory())
|
|
|
|
{
|
|
|
|
p->status = EPlayerStatus::WINNER;
|
|
|
|
|
|
|
|
// TODO: Campaign-specific code might as well go somewhere else
|
|
|
|
if(p->human && gs->scenarioOps->campState)
|
|
|
|
{
|
|
|
|
std::vector<CGHeroInstance *> crossoverHeroes;
|
|
|
|
for (CGHeroInstance * hero : gs->map->heroesOnMap)
|
|
|
|
{
|
|
|
|
if (hero->tempOwner == player)
|
|
|
|
{
|
|
|
|
// keep all heroes from the winning player
|
|
|
|
crossoverHeroes.push_back(hero);
|
|
|
|
}
|
|
|
|
else if (vstd::contains(gs->scenarioOps->campState->getCurrentScenario().keepHeroes, HeroTypeID(hero->subID)))
|
|
|
|
{
|
|
|
|
// keep hero whether lost or won (like Xeron in AB campaign)
|
|
|
|
crossoverHeroes.push_back(hero);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// keep lost heroes which are in heroes pool
|
|
|
|
for (auto & heroPair : gs->hpool.heroesPool)
|
|
|
|
{
|
|
|
|
if (vstd::contains(gs->scenarioOps->campState->getCurrentScenario().keepHeroes, HeroTypeID(heroPair.first)))
|
|
|
|
{
|
|
|
|
crossoverHeroes.push_back(heroPair.second.get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gs->scenarioOps->campState->setCurrentMapAsConquered(crossoverHeroes);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
p->status = EPlayerStatus::LOSER;
|
|
|
|
}
|
2010-01-29 22:52:45 +02:00
|
|
|
}
|
|
|
|
|
2022-09-30 21:08:37 +02:00
|
|
|
DLL_LINKAGE void PlayerReinitInterface::applyGs(CGameState *gs)
|
|
|
|
{
|
|
|
|
if(!gs || !gs->scenarioOps)
|
|
|
|
return;
|
2022-10-04 00:25:22 +02:00
|
|
|
|
2022-09-30 21:08:37 +02:00
|
|
|
//TODO: what does mean if more that one player connected?
|
2022-10-04 16:11:12 +02:00
|
|
|
if(playerConnectionId == PlayerSettings::PLAYER_AI)
|
2022-10-04 23:54:31 +02:00
|
|
|
{
|
|
|
|
for(auto player : players)
|
|
|
|
gs->scenarioOps->getIthPlayersSettings(player).connectedPlayerIDs.clear();
|
|
|
|
}
|
2022-09-30 21:08:37 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void RemoveBonus::applyGs(CGameState *gs)
|
2010-02-10 04:56:00 +02:00
|
|
|
{
|
2011-07-13 21:39:02 +03:00
|
|
|
CBonusSystemNode *node;
|
|
|
|
if (who == HERO)
|
2013-02-14 02:55:42 +03:00
|
|
|
node = gs->getHero(ObjectInstanceID(whoID));
|
2011-07-13 21:39:02 +03:00
|
|
|
else
|
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
|
|
|
node = gs->getPlayerState(PlayerColor(whoID));
|
2010-02-10 04:56:00 +02:00
|
|
|
|
2015-04-13 08:04:43 +02:00
|
|
|
BonusList &bonuses = node->getExportedBonusList();
|
2013-01-12 21:08:33 +03:00
|
|
|
|
2011-07-13 21:39:02 +03:00
|
|
|
for (int i = 0; i < bonuses.size(); i++)
|
2010-02-10 04:56:00 +02:00
|
|
|
{
|
2016-09-19 23:36:35 +02:00
|
|
|
auto b = bonuses[i];
|
2011-07-13 21:39:02 +03:00
|
|
|
if(b->source == source && b->sid == id)
|
2010-02-10 04:56:00 +02:00
|
|
|
{
|
2011-07-13 21:39:02 +03:00
|
|
|
bonus = *b; //backup bonus (to show to interfaces later)
|
2016-01-22 11:53:01 +02:00
|
|
|
node->removeBonus(b);
|
2010-02-10 04:56:00 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void RemoveObject::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2013-04-21 15:11:13 +03:00
|
|
|
|
2013-02-14 02:55:42 +03:00
|
|
|
CGObjectInstance *obj = gs->getObjInstance(id);
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->debug("removing object id=%d; address=%x; name=%s", id, (intptr_t)obj, obj->getObjectName());
|
2010-02-11 17:51:26 +02:00
|
|
|
//unblock tiles
|
2014-01-03 02:48:38 +03:00
|
|
|
gs->map->removeBlockVisTiles(obj);
|
2010-02-11 17:51:26 +02:00
|
|
|
|
2021-03-23 16:47:07 +02:00
|
|
|
if(obj->ID == Obj::HERO) //remove beaten hero
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2021-03-23 16:47:07 +02:00
|
|
|
CGHeroInstance * beatenHero = static_cast<CGHeroInstance*>(obj);
|
|
|
|
PlayerState * p = gs->getPlayerState(beatenHero->tempOwner);
|
|
|
|
gs->map->heroesOnMap -= beatenHero;
|
|
|
|
p->heroes -= beatenHero;
|
2022-11-06 01:26:13 +02:00
|
|
|
beatenHero->detachFrom(*beatenHero->whereShouldBeAttachedOnSiege(gs));
|
2021-03-23 16:47:07 +02:00
|
|
|
beatenHero->tempOwner = PlayerColor::NEUTRAL; //no one owns beaten hero
|
|
|
|
vstd::erase_if(beatenHero->artifactsInBackpack, [](const ArtSlotInfo& asi)
|
2016-01-20 13:22:12 +02:00
|
|
|
{
|
|
|
|
return asi.artifact->artType->id == ArtifactID::GRAIL;
|
|
|
|
});
|
2010-01-29 22:52:45 +02:00
|
|
|
|
2021-03-23 16:47:07 +02:00
|
|
|
if(beatenHero->visitedTown)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2021-03-23 16:47:07 +02:00
|
|
|
if(beatenHero->visitedTown->garrisonHero == beatenHero)
|
|
|
|
beatenHero->visitedTown->garrisonHero = nullptr;
|
2009-03-07 17:55:56 +02:00
|
|
|
else
|
2021-03-23 16:47:07 +02:00
|
|
|
beatenHero->visitedTown->visitingHero = nullptr;
|
2009-03-07 17:55:56 +02:00
|
|
|
|
2021-03-23 16:47:07 +02:00
|
|
|
beatenHero->visitedTown = nullptr;
|
|
|
|
beatenHero->inTownGarrison = false;
|
|
|
|
}
|
2010-07-08 08:52:11 +03:00
|
|
|
//return hero to the pool, so he may reappear in tavern
|
2021-03-23 16:47:07 +02:00
|
|
|
gs->hpool.heroesPool[beatenHero->subID] = beatenHero;
|
|
|
|
|
|
|
|
if(!vstd::contains(gs->hpool.pavailable, beatenHero->subID))
|
|
|
|
gs->hpool.pavailable[beatenHero->subID] = 0xff;
|
2011-01-18 20:56:14 +02:00
|
|
|
|
2013-06-26 14:18:27 +03:00
|
|
|
gs->map->objects[id.getNum()] = nullptr;
|
2013-01-12 21:08:33 +03:00
|
|
|
|
2013-09-09 00:50:49 +03:00
|
|
|
//If hero on Boat is removed, the Boat disappears
|
2021-03-23 16:47:07 +02:00
|
|
|
if(beatenHero->boat)
|
2013-09-09 00:50:49 +03:00
|
|
|
{
|
2021-03-23 16:47:07 +02:00
|
|
|
gs->map->instanceNames.erase(beatenHero->boat->instanceName);
|
|
|
|
gs->map->objects[beatenHero->boat->id.getNum()].dellNull();
|
|
|
|
beatenHero->boat = nullptr;
|
2013-09-09 00:50:49 +03:00
|
|
|
}
|
2011-01-18 20:56:14 +02:00
|
|
|
return;
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
2012-07-19 12:10:55 +03:00
|
|
|
|
2013-07-23 18:03:01 +03:00
|
|
|
auto quest = dynamic_cast<const IQuestObject *>(obj);
|
2012-07-19 12:10:55 +03:00
|
|
|
if (quest)
|
|
|
|
{
|
2013-07-23 18:03:01 +03:00
|
|
|
gs->map->quests[quest->quest->qid] = nullptr;
|
2013-06-29 16:05:48 +03:00
|
|
|
for (auto &player : gs->players)
|
2012-07-19 12:10:55 +03:00
|
|
|
{
|
2013-06-29 16:05:48 +03:00
|
|
|
for (auto &q : player.second.quests)
|
2012-07-19 12:10:55 +03:00
|
|
|
{
|
|
|
|
if (q.obj == obj)
|
|
|
|
{
|
2013-06-26 14:18:27 +03:00
|
|
|
q.obj = nullptr;
|
2012-07-19 12:10:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-09 15:10:02 +03:00
|
|
|
for (TriggeredEvent & event : gs->map->triggeredEvents)
|
|
|
|
{
|
2014-08-07 19:40:22 +03:00
|
|
|
auto patcher = [&](EventCondition cond) -> EventExpression::Variant
|
2014-02-09 15:10:02 +03:00
|
|
|
{
|
|
|
|
if (cond.object == obj)
|
|
|
|
{
|
2016-11-13 12:38:42 +02:00
|
|
|
if (cond.condition == EventCondition::DESTROY || cond.condition == EventCondition::DESTROY_0)
|
2014-02-09 15:10:02 +03:00
|
|
|
{
|
|
|
|
cond.condition = EventCondition::CONST_VALUE;
|
|
|
|
cond.value = 1; // destroyed object, from now on always fulfilled
|
|
|
|
}
|
2016-11-13 12:38:42 +02:00
|
|
|
else if (cond.condition == EventCondition::CONTROL || cond.condition == EventCondition::HAVE_0)
|
2014-02-09 15:10:02 +03:00
|
|
|
{
|
|
|
|
cond.condition = EventCondition::CONST_VALUE;
|
|
|
|
cond.value = 0; // destroyed object, from now on can not be fulfilled
|
|
|
|
}
|
|
|
|
}
|
2014-08-07 19:40:22 +03:00
|
|
|
return cond;
|
2014-02-09 15:10:02 +03:00
|
|
|
};
|
2014-08-07 19:40:22 +03:00
|
|
|
event.trigger = event.trigger.morph(patcher);
|
2014-02-09 15:10:02 +03:00
|
|
|
}
|
2016-02-22 18:26:42 +02:00
|
|
|
gs->map->instanceNames.erase(obj->instanceName);
|
2013-02-14 02:55:42 +03:00
|
|
|
gs->map->objects[id.getNum()].dellNull();
|
2014-04-01 14:53:28 +03:00
|
|
|
gs->map->calculateGuardingGreaturePositions();
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2009-07-18 06:13:13 +03:00
|
|
|
static int getDir(int3 src, int3 dst)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
if(dst.x+1 == src.x && dst.y+1 == src.y) //tl
|
|
|
|
{
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
else if(dst.x == src.x && dst.y+1 == src.y) //t
|
|
|
|
{
|
|
|
|
ret = 2;
|
|
|
|
}
|
|
|
|
else if(dst.x-1 == src.x && dst.y+1 == src.y) //tr
|
|
|
|
{
|
|
|
|
ret = 3;
|
|
|
|
}
|
|
|
|
else if(dst.x-1 == src.x && dst.y == src.y) //r
|
|
|
|
{
|
|
|
|
ret = 4;
|
|
|
|
}
|
|
|
|
else if(dst.x-1 == src.x && dst.y-1 == src.y) //br
|
|
|
|
{
|
|
|
|
ret = 5;
|
|
|
|
}
|
|
|
|
else if(dst.x == src.x && dst.y-1 == src.y) //b
|
|
|
|
{
|
|
|
|
ret = 6;
|
|
|
|
}
|
|
|
|
else if(dst.x+1 == src.x && dst.y-1 == src.y) //bl
|
|
|
|
{
|
|
|
|
ret = 7;
|
|
|
|
}
|
|
|
|
else if(dst.x+1 == src.x && dst.y == src.y) //l
|
|
|
|
{
|
|
|
|
ret = 8;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
void TryMoveHero::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
CGHeroInstance *h = gs->getHero(id);
|
2015-10-24 15:09:46 +02:00
|
|
|
if (!h)
|
|
|
|
{
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->error("Attempt ot move unavailable hero %d", id.getNum());
|
2015-10-24 15:09:46 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-03-07 17:55:56 +02:00
|
|
|
h->movement = movePoints;
|
2009-07-19 04:00:19 +03:00
|
|
|
|
2014-02-15 12:40:33 +03:00
|
|
|
if((result == SUCCESS || result == BLOCKING_VISIT || result == EMBARK || result == DISEMBARK) && start != end)
|
2013-10-13 23:05:34 +03:00
|
|
|
{
|
|
|
|
auto dir = getDir(start,end);
|
|
|
|
if(dir > 0 && dir <= 8)
|
|
|
|
h->moveDir = dir;
|
2014-05-21 12:02:20 +03:00
|
|
|
//else don`t change move direction - hero might have traversed the subterranean gate, direction should be kept
|
2010-05-06 15:13:31 +03:00
|
|
|
}
|
2009-07-19 06:10:24 +03:00
|
|
|
|
2014-05-21 12:02:20 +03:00
|
|
|
if(result == EMBARK) //hero enters boat at destination tile
|
2009-07-19 04:00:19 +03:00
|
|
|
{
|
2022-12-09 14:42:47 +02:00
|
|
|
const TerrainTile &tt = gs->map->getTile(h->convertToVisitablePos(end));
|
2014-05-21 12:02:20 +03:00
|
|
|
assert(tt.visitableObjects.size() >= 1 && tt.visitableObjects.back()->ID == Obj::BOAT); //the only visitable object at destination is Boat
|
2011-04-23 01:28:13 +03:00
|
|
|
CGBoat *boat = static_cast<CGBoat*>(tt.visitableObjects.back());
|
2009-07-19 04:00:19 +03:00
|
|
|
|
|
|
|
gs->map->removeBlockVisTiles(boat); //hero blockvis mask will be used, we don't need to duplicate it with boat
|
|
|
|
h->boat = boat;
|
|
|
|
boat->hero = h;
|
|
|
|
}
|
2014-05-21 12:02:20 +03:00
|
|
|
else if(result == DISEMBARK) //hero leaves boat to destination tile
|
2009-07-19 06:10:24 +03:00
|
|
|
{
|
2010-07-20 21:34:32 +03:00
|
|
|
CGBoat *b = const_cast<CGBoat *>(h->boat);
|
|
|
|
b->direction = h->moveDir;
|
|
|
|
b->pos = start;
|
2013-06-26 14:18:27 +03:00
|
|
|
b->hero = nullptr;
|
2010-07-20 21:34:32 +03:00
|
|
|
gs->map->addBlockVisTiles(b);
|
2013-06-26 14:18:27 +03:00
|
|
|
h->boat = nullptr;
|
2009-07-19 06:10:24 +03:00
|
|
|
}
|
2009-07-19 04:00:19 +03:00
|
|
|
|
2009-07-19 06:10:24 +03:00
|
|
|
if(start!=end && (result == SUCCESS || result == TELEPORTATION || result == EMBARK || result == DISEMBARK))
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
gs->map->removeBlockVisTiles(h);
|
|
|
|
h->pos = end;
|
2010-07-20 21:34:32 +03:00
|
|
|
if(CGBoat *b = const_cast<CGBoat *>(h->boat))
|
|
|
|
b->pos = end;
|
2009-03-07 17:55:56 +02:00
|
|
|
gs->map->addBlockVisTiles(h);
|
|
|
|
}
|
2009-07-18 06:13:13 +03:00
|
|
|
|
2022-09-18 16:39:10 +02:00
|
|
|
auto fogOfWarMap = gs->getPlayerTeam(h->getOwner())->fogOfWarMap;
|
2013-06-29 16:05:48 +03:00
|
|
|
for(int3 t : fowRevealed)
|
2022-09-18 16:39:10 +02:00
|
|
|
(*fogOfWarMap)[t.z][t.x][t.y] = 1;
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void NewStructures::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2009-08-23 18:02:21 +03:00
|
|
|
CGTownInstance *t = gs->getTown(tid);
|
2021-01-14 00:02:13 +02:00
|
|
|
|
2013-06-29 16:05:48 +03:00
|
|
|
for(const auto & id : bid)
|
2009-08-23 18:02:21 +03:00
|
|
|
{
|
2013-11-12 13:45:42 +03:00
|
|
|
assert(t->town->buildings.at(id) != nullptr);
|
2009-03-07 17:55:56 +02:00
|
|
|
t->builtBuildings.insert(id);
|
2016-08-24 04:15:04 +02:00
|
|
|
t->updateAppearance();
|
2021-01-14 00:02:13 +02:00
|
|
|
auto currentBuilding = t->town->buildings.at(id);
|
|
|
|
|
|
|
|
if(currentBuilding->overrideBids.empty())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for(auto overrideBid : currentBuilding->overrideBids)
|
|
|
|
{
|
|
|
|
t->overriddenBuildings.insert(overrideBid);
|
|
|
|
t->deleteTownBonus(overrideBid);
|
|
|
|
}
|
2009-08-23 18:02:21 +03:00
|
|
|
}
|
2009-03-07 17:55:56 +02:00
|
|
|
t->builded = builded;
|
2011-02-04 16:58:14 +02:00
|
|
|
t->recreateBuildingsBonuses();
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
2021-01-14 00:02:13 +02:00
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void RazeStructures::applyGs(CGameState *gs)
|
2009-09-22 17:27:46 +03:00
|
|
|
{
|
|
|
|
CGTownInstance *t = gs->getTown(tid);
|
2013-06-29 16:05:48 +03:00
|
|
|
for(const auto & id : bid)
|
2009-09-22 17:27:46 +03:00
|
|
|
{
|
|
|
|
t->builtBuildings.erase(id);
|
2016-08-24 04:15:04 +02:00
|
|
|
|
|
|
|
t->updateAppearance();
|
2009-09-22 17:27:46 +03:00
|
|
|
}
|
2009-09-24 20:54:02 +03:00
|
|
|
t->destroyed = destroyed; //yeaha
|
2011-02-04 16:58:14 +02:00
|
|
|
t->recreateBuildingsBonuses();
|
2009-09-22 17:27:46 +03:00
|
|
|
}
|
2011-02-04 16:58:14 +02:00
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void SetAvailableCreatures::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2013-02-14 02:55:42 +03:00
|
|
|
CGDwelling *dw = dynamic_cast<CGDwelling*>(gs->getObjInstance(tid));
|
2009-07-26 13:43:22 +03:00
|
|
|
assert(dw);
|
|
|
|
dw->creatures = creatures;
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void SetHeroesInTown::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
CGTownInstance *t = gs->getTown(tid);
|
|
|
|
|
2013-01-12 21:08:33 +03:00
|
|
|
CGHeroInstance *v = gs->getHero(visiting),
|
2009-03-07 17:55:56 +02:00
|
|
|
*g = gs->getHero(garrison);
|
|
|
|
|
2011-02-04 16:58:14 +02:00
|
|
|
bool newVisitorComesFromGarrison = v && v == t->garrisonHero;
|
|
|
|
bool newGarrisonComesFromVisiting = g && g == t->visitingHero;
|
|
|
|
|
|
|
|
if(newVisitorComesFromGarrison)
|
2013-06-26 14:18:27 +03:00
|
|
|
t->setGarrisonedHero(nullptr);
|
2011-02-04 16:58:14 +02:00
|
|
|
if(newGarrisonComesFromVisiting)
|
2013-06-26 14:18:27 +03:00
|
|
|
t->setVisitingHero(nullptr);
|
2011-02-04 16:58:14 +02:00
|
|
|
if(!newGarrisonComesFromVisiting || v)
|
|
|
|
t->setVisitingHero(v);
|
|
|
|
if(!newVisitorComesFromGarrison || g)
|
|
|
|
t->setGarrisonedHero(g);
|
|
|
|
|
2009-03-07 17:55:56 +02:00
|
|
|
if(v)
|
|
|
|
{
|
|
|
|
gs->map->addBlockVisTiles(v);
|
|
|
|
}
|
|
|
|
if(g)
|
|
|
|
{
|
|
|
|
gs->map->removeBlockVisTiles(g);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void HeroRecruited::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2009-08-05 03:05:37 +03:00
|
|
|
assert(vstd::contains(gs->hpool.heroesPool, hid));
|
2009-03-07 17:55:56 +02:00
|
|
|
CGHeroInstance *h = gs->hpool.heroesPool[hid];
|
|
|
|
CGTownInstance *t = gs->getTown(tid);
|
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 = gs->getPlayerState(player);
|
2013-09-09 00:50:49 +03:00
|
|
|
|
|
|
|
assert(!h->boat);
|
|
|
|
|
2009-03-07 17:55:56 +02:00
|
|
|
h->setOwner(player);
|
|
|
|
h->pos = tile;
|
2016-01-26 21:24:38 +02:00
|
|
|
bool fresh = !h->isInitialized();
|
|
|
|
if(fresh)
|
|
|
|
{ // this is a fresh hero who hasn't appeared yet
|
|
|
|
h->movement = h->maxMovePoints(true);
|
|
|
|
}
|
2009-03-07 17:55:56 +02:00
|
|
|
|
|
|
|
gs->hpool.heroesPool.erase(hid);
|
2013-02-14 02:55:42 +03:00
|
|
|
if(h->id == ObjectInstanceID())
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2020-10-01 10:38:06 +02:00
|
|
|
h->id = ObjectInstanceID((si32)gs->map->objects.size());
|
2009-03-07 17:55:56 +02:00
|
|
|
gs->map->objects.push_back(h);
|
|
|
|
}
|
|
|
|
else
|
2013-02-14 02:55:42 +03:00
|
|
|
gs->map->objects[h->id.getNum()] = h;
|
2009-03-07 17:55:56 +02:00
|
|
|
|
2013-05-19 01:30:48 +03:00
|
|
|
gs->map->heroesOnMap.push_back(h);
|
2011-02-04 16:58:14 +02:00
|
|
|
p->heroes.push_back(h);
|
2022-11-06 01:26:13 +02:00
|
|
|
h->attachTo(*p);
|
2016-01-26 21:24:38 +02:00
|
|
|
if(fresh)
|
|
|
|
{
|
2016-09-09 19:30:36 +02:00
|
|
|
h->initObj(gs->getRandomGenerator());
|
2016-01-26 21:24:38 +02:00
|
|
|
}
|
2009-03-07 17:55:56 +02:00
|
|
|
gs->map->addBlockVisTiles(h);
|
2010-07-09 02:03:27 +03:00
|
|
|
|
|
|
|
if(t)
|
|
|
|
{
|
2011-02-04 16:58:14 +02:00
|
|
|
t->setVisitingHero(h);
|
2010-07-09 02:03:27 +03:00
|
|
|
}
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void GiveHero::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
CGHeroInstance *h = gs->getHero(id);
|
2012-01-03 04:55:26 +03:00
|
|
|
|
|
|
|
//bonus system
|
2022-11-06 01:26:13 +02:00
|
|
|
h->detachFrom(gs->globalEffects);
|
|
|
|
h->attachTo(*gs->getPlayerState(player));
|
2012-01-03 04:55:26 +03:00
|
|
|
|
2022-12-09 14:42:47 +02:00
|
|
|
auto oldVisitablePos = h->visitablePos();
|
2009-03-07 17:55:56 +02:00
|
|
|
gs->map->removeBlockVisTiles(h,true);
|
2022-12-04 22:00:33 +02:00
|
|
|
h->appearance = VLC->objtypeh->getHandlerFor(Obj::HERO, h->type->heroClass->getIndex())->getTemplates().front();
|
|
|
|
|
2009-03-07 17:55:56 +02:00
|
|
|
h->setOwner(player);
|
|
|
|
h->movement = h->maxMovePoints(true);
|
2022-12-09 14:42:47 +02:00
|
|
|
h->pos = h->convertFromVisitablePos(oldVisitablePos);
|
2013-05-19 01:30:48 +03:00
|
|
|
gs->map->heroesOnMap.push_back(h);
|
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
|
|
|
gs->getPlayerState(h->getOwner())->heroes.push_back(h);
|
2022-12-04 22:00:33 +02:00
|
|
|
|
2009-03-07 17:55:56 +02:00
|
|
|
gs->map->addBlockVisTiles(h);
|
|
|
|
h->inTownGarrison = false;
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void NewObject::applyGs(CGameState *gs)
|
2009-07-26 06:33:13 +03:00
|
|
|
{
|
2023-01-10 20:09:09 +02:00
|
|
|
TerrainId terrainType = ETerrainId::NONE;
|
2019-05-18 19:39:36 +02:00
|
|
|
|
|
|
|
if(ID == Obj::BOAT && !gs->isInTheMap(pos)) //special handling for bug #3060 - pos outside map but visitablePos is not
|
|
|
|
{
|
|
|
|
CGObjectInstance testObject = CGObjectInstance();
|
|
|
|
testObject.pos = pos;
|
2022-12-20 18:35:40 +02:00
|
|
|
testObject.appearance = VLC->objtypeh->getHandlerFor(ID, subID)->getTemplates(ETerrainId::WATER).front();
|
2019-05-18 19:39:36 +02:00
|
|
|
|
|
|
|
const int3 previousXAxisTile = int3(pos.x - 1, pos.y, pos.z);
|
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
|
|
|
assert(gs->isInTheMap(previousXAxisTile) && (testObject.visitablePos() == previousXAxisTile));
|
2022-12-07 18:06:47 +02:00
|
|
|
MAYBE_UNUSED(previousXAxisTile);
|
2019-05-18 19:39:36 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const TerrainTile & t = gs->map->getTile(pos);
|
2023-01-01 17:10:47 +02:00
|
|
|
terrainType = t.terType->getId();
|
2019-05-18 19:39:36 +02:00
|
|
|
}
|
2013-01-12 21:08:33 +03:00
|
|
|
|
2013-06-26 14:18:27 +03:00
|
|
|
CGObjectInstance *o = nullptr;
|
2009-07-26 06:33:13 +03:00
|
|
|
switch(ID)
|
|
|
|
{
|
2013-01-12 21:08:33 +03:00
|
|
|
case Obj::BOAT:
|
2009-07-26 06:33:13 +03:00
|
|
|
o = new CGBoat();
|
2022-12-20 18:35:40 +02:00
|
|
|
terrainType = ETerrainId::WATER; //TODO: either boat should only spawn on water, or all water objects should be handled this way
|
2009-07-26 06:33:13 +03:00
|
|
|
break;
|
2013-01-12 21:08:33 +03:00
|
|
|
case Obj::MONSTER: //probably more options will be needed
|
2010-08-22 10:11:46 +03:00
|
|
|
o = new CGCreature();
|
|
|
|
{
|
2010-11-22 02:34:46 +02:00
|
|
|
//CStackInstance hlp;
|
2010-08-22 10:11:46 +03:00
|
|
|
CGCreature *cre = static_cast<CGCreature*>(o);
|
2010-11-22 02:34:46 +02:00
|
|
|
//cre->slots[0] = hlp;
|
2010-08-22 10:11:46 +03:00
|
|
|
cre->notGrowingTeam = cre->neverFlees = 0;
|
|
|
|
cre->character = 2;
|
2013-02-07 20:34:50 +03:00
|
|
|
cre->gainedArtifact = ArtifactID::NONE;
|
2011-05-28 04:02:28 +03:00
|
|
|
cre->identifier = -1;
|
2013-02-16 17:03:47 +03:00
|
|
|
cre->addToSlot(SlotID(0), new CStackInstance(CreatureID(subID), -1)); //add placeholder stack
|
2010-08-22 10:11:46 +03:00
|
|
|
}
|
|
|
|
break;
|
2009-07-26 06:33:13 +03:00
|
|
|
default:
|
|
|
|
o = new CGObjectInstance();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
o->ID = ID;
|
|
|
|
o->subID = subID;
|
|
|
|
o->pos = pos;
|
2014-10-01 12:38:03 +03:00
|
|
|
o->appearance = VLC->objtypeh->getHandlerFor(o->ID, o->subID)->getTemplates(terrainType).front();
|
2020-10-01 10:38:06 +02:00
|
|
|
id = o->id = ObjectInstanceID((si32)gs->map->objects.size());
|
2009-07-26 06:33:13 +03:00
|
|
|
|
|
|
|
gs->map->objects.push_back(o);
|
|
|
|
gs->map->addBlockVisTiles(o);
|
2016-09-09 19:30:36 +02:00
|
|
|
o->initObj(gs->getRandomGenerator());
|
2014-04-01 14:53:28 +03:00
|
|
|
gs->map->calculateGuardingGreaturePositions();
|
2013-08-18 18:46:28 +03:00
|
|
|
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->debug("Added object id=%d; address=%x; name=%s", id, (intptr_t)o, o->getObjectName());
|
2009-07-26 06:33:13 +03:00
|
|
|
}
|
2013-08-18 18:46:28 +03:00
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void NewArtifact::applyGs(CGameState *gs)
|
2010-11-10 02:06:25 +02:00
|
|
|
{
|
2010-12-26 16:34:11 +02:00
|
|
|
assert(!vstd::contains(gs->map->artInstances, art));
|
2011-01-22 05:43:20 +02:00
|
|
|
gs->map->addNewArtifactInstance(art);
|
2010-12-26 16:34:11 +02:00
|
|
|
|
2011-07-13 21:39:02 +03:00
|
|
|
assert(!art->getParentNodes().size());
|
2011-01-18 20:56:14 +02:00
|
|
|
art->setType(art->artType);
|
2011-06-21 12:31:08 +03:00
|
|
|
if (CCombinedArtifactInstance* cart = dynamic_cast<CCombinedArtifactInstance*>(art.get()))
|
|
|
|
cart->createConstituents();
|
2010-11-10 02:06:25 +02:00
|
|
|
}
|
2009-07-26 06:33:13 +03:00
|
|
|
|
2011-12-14 00:23:17 +03:00
|
|
|
DLL_LINKAGE const CStackInstance * StackLocation::getStack()
|
2010-12-14 23:55:23 +02:00
|
|
|
{
|
|
|
|
if(!army->hasStackAtSlot(slot))
|
|
|
|
{
|
2017-08-11 19:03:05 +02:00
|
|
|
logNetwork->warn("%s don't have a stack at slot %d", army->nodeName(), slot.getNum());
|
2013-06-26 14:18:27 +03:00
|
|
|
return nullptr;
|
2010-12-14 23:55:23 +02:00
|
|
|
}
|
|
|
|
return &army->getStack(slot);
|
|
|
|
}
|
|
|
|
|
2012-04-14 05:20:22 +03:00
|
|
|
struct ObjectRetriever : boost::static_visitor<const CArmedInstance *>
|
|
|
|
{
|
|
|
|
const CArmedInstance * operator()(const ConstTransitivePtr<CGHeroInstance> &h) const
|
|
|
|
{
|
|
|
|
return h;
|
|
|
|
}
|
|
|
|
const CArmedInstance * operator()(const ConstTransitivePtr<CStackInstance> &s) const
|
|
|
|
{
|
|
|
|
return s->armyObj;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
template <typename T>
|
|
|
|
struct GetBase : boost::static_visitor<T*>
|
|
|
|
{
|
|
|
|
template <typename TArg>
|
|
|
|
T * operator()(TArg &arg) const
|
|
|
|
{
|
|
|
|
return arg;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-02-09 02:07:33 +03:00
|
|
|
|
|
|
|
DLL_LINKAGE void ArtifactLocation::removeArtifact()
|
|
|
|
{
|
|
|
|
CArtifactInstance *a = getArt();
|
|
|
|
assert(a);
|
|
|
|
a->removeFrom(*this);
|
|
|
|
}
|
|
|
|
|
2012-04-14 05:20:22 +03:00
|
|
|
DLL_LINKAGE const CArmedInstance * ArtifactLocation::relatedObj() const
|
|
|
|
{
|
|
|
|
return boost::apply_visitor(ObjectRetriever(), artHolder);
|
|
|
|
}
|
|
|
|
|
2013-03-03 20:06:03 +03:00
|
|
|
DLL_LINKAGE PlayerColor ArtifactLocation::owningPlayer() const
|
2012-04-14 05:20:22 +03:00
|
|
|
{
|
|
|
|
auto obj = relatedObj();
|
2013-03-03 20:06:03 +03:00
|
|
|
return obj ? obj->tempOwner : PlayerColor::NEUTRAL;
|
2012-04-14 05:20:22 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
DLL_LINKAGE CArtifactSet *ArtifactLocation::getHolderArtSet()
|
|
|
|
{
|
|
|
|
return boost::apply_visitor(GetBase<CArtifactSet>(), artHolder);
|
|
|
|
}
|
|
|
|
|
|
|
|
DLL_LINKAGE CBonusSystemNode *ArtifactLocation::getHolderNode()
|
|
|
|
{
|
|
|
|
return boost::apply_visitor(GetBase<CBonusSystemNode>(), artHolder);
|
|
|
|
}
|
|
|
|
|
2011-12-14 00:23:17 +03:00
|
|
|
DLL_LINKAGE const CArtifactInstance *ArtifactLocation::getArt() const
|
2010-12-26 16:34:11 +02:00
|
|
|
{
|
2022-11-06 23:54:50 +02:00
|
|
|
auto s = getSlot();
|
2022-11-10 18:29:39 +02:00
|
|
|
if(s)
|
2022-11-06 23:54:50 +02:00
|
|
|
return s->getArt();
|
|
|
|
else
|
|
|
|
return nullptr;
|
2010-12-26 16:34:11 +02:00
|
|
|
}
|
|
|
|
|
2012-04-14 05:20:22 +03:00
|
|
|
DLL_LINKAGE const CArtifactSet * ArtifactLocation::getHolderArtSet() const
|
|
|
|
{
|
|
|
|
ArtifactLocation *t = const_cast<ArtifactLocation*>(this);
|
|
|
|
return t->getHolderArtSet();
|
|
|
|
}
|
|
|
|
|
|
|
|
DLL_LINKAGE const CBonusSystemNode * ArtifactLocation::getHolderNode() const
|
|
|
|
{
|
|
|
|
ArtifactLocation *t = const_cast<ArtifactLocation*>(this);
|
|
|
|
return t->getHolderNode();
|
|
|
|
}
|
|
|
|
|
2011-12-14 00:23:17 +03:00
|
|
|
DLL_LINKAGE CArtifactInstance *ArtifactLocation::getArt()
|
2010-12-26 16:34:11 +02:00
|
|
|
{
|
|
|
|
const ArtifactLocation *t = this;
|
|
|
|
return const_cast<CArtifactInstance*>(t->getArt());
|
|
|
|
}
|
|
|
|
|
2011-12-14 00:23:17 +03:00
|
|
|
DLL_LINKAGE const ArtSlotInfo *ArtifactLocation::getSlot() const
|
2010-12-26 16:34:11 +02:00
|
|
|
{
|
2012-04-14 05:20:22 +03:00
|
|
|
return getHolderArtSet()->getSlot(slot);
|
2010-12-26 16:34:11 +02:00
|
|
|
}
|
|
|
|
|
2018-03-10 23:19:36 +02:00
|
|
|
DLL_LINKAGE void ChangeStackCount::applyGs(CGameState * gs)
|
2010-11-27 03:46:19 +02:00
|
|
|
{
|
2018-03-10 23:19:36 +02:00
|
|
|
auto srcObj = gs->getArmyInstance(army);
|
|
|
|
if(!srcObj)
|
|
|
|
logNetwork->error("[CRITICAL] ChangeStackCount: invalid army object %d, possible game state corruption.", army.getNum());
|
|
|
|
|
2010-11-27 03:46:19 +02:00
|
|
|
if(absoluteValue)
|
2018-03-10 23:19:36 +02:00
|
|
|
srcObj->setStackCount(slot, count);
|
2010-11-27 03:46:19 +02:00
|
|
|
else
|
2018-03-10 23:19:36 +02:00
|
|
|
srcObj->changeStackCount(slot, count);
|
2010-11-27 03:46:19 +02:00
|
|
|
}
|
|
|
|
|
2018-03-10 23:19:36 +02:00
|
|
|
DLL_LINKAGE void SetStackType::applyGs(CGameState * gs)
|
2010-11-27 03:46:19 +02:00
|
|
|
{
|
2018-03-10 23:19:36 +02:00
|
|
|
auto srcObj = gs->getArmyInstance(army);
|
|
|
|
if(!srcObj)
|
|
|
|
logNetwork->error("[CRITICAL] SetStackType: invalid army object %d, possible game state corruption.", army.getNum());
|
|
|
|
|
|
|
|
srcObj->setStackType(slot, type);
|
2010-11-27 03:46:19 +02:00
|
|
|
}
|
|
|
|
|
2018-03-10 23:19:36 +02:00
|
|
|
DLL_LINKAGE void EraseStack::applyGs(CGameState * gs)
|
2010-11-27 03:46:19 +02:00
|
|
|
{
|
2018-03-10 23:19:36 +02:00
|
|
|
auto srcObj = gs->getArmyInstance(army);
|
|
|
|
if(!srcObj)
|
|
|
|
logNetwork->error("[CRITICAL] EraseStack: invalid army object %d, possible game state corruption.", army.getNum());
|
|
|
|
|
|
|
|
srcObj->eraseStack(slot);
|
2010-11-27 03:46:19 +02:00
|
|
|
}
|
|
|
|
|
2018-03-10 23:19:36 +02:00
|
|
|
DLL_LINKAGE void SwapStacks::applyGs(CGameState * gs)
|
2010-11-27 03:46:19 +02:00
|
|
|
{
|
2018-03-10 23:19:36 +02:00
|
|
|
auto srcObj = gs->getArmyInstance(srcArmy);
|
|
|
|
if(!srcObj)
|
|
|
|
logNetwork->error("[CRITICAL] SwapStacks: invalid army object %d, possible game state corruption.", srcArmy.getNum());
|
|
|
|
|
|
|
|
auto dstObj = gs->getArmyInstance(dstArmy);
|
|
|
|
if(!dstObj)
|
|
|
|
logNetwork->error("[CRITICAL] SwapStacks: invalid army object %d, possible game state corruption.", dstArmy.getNum());
|
|
|
|
|
|
|
|
CStackInstance * s1 = srcObj->detachStack(srcSlot);
|
|
|
|
CStackInstance * s2 = dstObj->detachStack(dstSlot);
|
2010-11-27 03:46:19 +02:00
|
|
|
|
2018-03-10 23:19:36 +02:00
|
|
|
srcObj->putStack(srcSlot, s2);
|
|
|
|
dstObj->putStack(dstSlot, s1);
|
2010-11-27 03:46:19 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void InsertNewStack::applyGs(CGameState *gs)
|
2010-11-27 03:46:19 +02:00
|
|
|
{
|
2022-09-24 16:29:39 +02:00
|
|
|
if(auto obj = gs->getArmyInstance(army))
|
|
|
|
obj->putStack(slot, new CStackInstance(type, count));
|
2018-03-10 23:19:36 +02:00
|
|
|
else
|
|
|
|
logNetwork->error("[CRITICAL] InsertNewStack: invalid army object %d, possible game state corruption.", army.getNum());
|
2010-11-27 03:46:19 +02:00
|
|
|
}
|
|
|
|
|
2018-03-10 23:19:36 +02:00
|
|
|
DLL_LINKAGE void RebalanceStacks::applyGs(CGameState * gs)
|
2010-11-27 03:46:19 +02:00
|
|
|
{
|
2018-03-10 23:19:36 +02:00
|
|
|
auto srcObj = gs->getArmyInstance(srcArmy);
|
|
|
|
if(!srcObj)
|
|
|
|
logNetwork->error("[CRITICAL] RebalanceStacks: invalid army object %d, possible game state corruption.", srcArmy.getNum());
|
|
|
|
|
|
|
|
auto dstObj = gs->getArmyInstance(dstArmy);
|
|
|
|
if(!dstObj)
|
|
|
|
logNetwork->error("[CRITICAL] RebalanceStacks: invalid army object %d, possible game state corruption.", dstArmy.getNum());
|
|
|
|
|
|
|
|
StackLocation src(srcObj, srcSlot);
|
|
|
|
StackLocation dst(dstObj, dstSlot);
|
|
|
|
|
|
|
|
const CCreature * srcType = src.army->getCreature(src.slot);
|
2010-12-06 01:10:02 +02:00
|
|
|
TQuantity srcCount = src.army->getStackCount(src.slot);
|
2012-08-24 12:37:52 +03:00
|
|
|
bool stackExp = VLC->modh->modules.STACK_EXP;
|
2010-12-06 01:10:02 +02:00
|
|
|
|
|
|
|
if(srcCount == count) //moving whole stack
|
|
|
|
{
|
|
|
|
if(const CCreature *c = dst.army->getCreature(dst.slot)) //stack at dest -> merge
|
|
|
|
{
|
|
|
|
assert(c == srcType);
|
2022-12-07 18:06:47 +02:00
|
|
|
MAYBE_UNUSED(c);
|
2013-03-05 10:34:52 +03:00
|
|
|
auto alHere = ArtifactLocation (src.getStack(), ArtifactPosition::CREATURE_SLOT);
|
|
|
|
auto alDest = ArtifactLocation (dst.getStack(), ArtifactPosition::CREATURE_SLOT);
|
|
|
|
auto artHere = alHere.getArt();
|
|
|
|
auto artDest = alDest.getArt();
|
|
|
|
if (artHere)
|
|
|
|
{
|
|
|
|
if (alDest.getArt())
|
|
|
|
{
|
|
|
|
auto hero = dynamic_cast <CGHeroInstance *>(src.army.get());
|
|
|
|
if (hero)
|
|
|
|
{
|
|
|
|
artDest->move (alDest, ArtifactLocation (hero, alDest.getArt()->firstBackpackSlot (hero)));
|
|
|
|
}
|
|
|
|
//else - artifact cna be lost :/
|
|
|
|
else
|
|
|
|
{
|
2017-08-10 18:39:27 +02:00
|
|
|
logNetwork->warn("Artifact is present at destination slot!");
|
2013-03-05 10:34:52 +03:00
|
|
|
}
|
|
|
|
artHere->move (alHere, alDest);
|
|
|
|
//TODO: choose from dialog
|
|
|
|
}
|
|
|
|
else //just move to the other slot before stack gets erased
|
|
|
|
{
|
|
|
|
artHere->move (alHere, alDest);
|
|
|
|
}
|
|
|
|
}
|
2012-08-24 12:37:52 +03:00
|
|
|
if (stackExp)
|
2011-03-27 12:31:14 +03:00
|
|
|
{
|
|
|
|
ui64 totalExp = srcCount * src.army->getStackExperience(src.slot) + dst.army->getStackCount(dst.slot) * dst.army->getStackExperience(dst.slot);
|
|
|
|
src.army->eraseStack(src.slot);
|
|
|
|
dst.army->changeStackCount(dst.slot, count);
|
|
|
|
dst.army->setStackExp(dst.slot, totalExp /(dst.army->getStackCount(dst.slot))); //mean
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
src.army->eraseStack(src.slot);
|
|
|
|
dst.army->changeStackCount(dst.slot, count);
|
|
|
|
}
|
2010-12-06 01:10:02 +02:00
|
|
|
}
|
2011-03-27 12:31:14 +03:00
|
|
|
else //move stack to an empty slot, no exp change needed
|
2010-12-06 01:10:02 +02:00
|
|
|
{
|
|
|
|
CStackInstance *stackDetached = src.army->detachStack(src.slot);
|
|
|
|
dst.army->putStack(dst.slot, stackDetached);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(const CCreature *c = dst.army->getCreature(dst.slot)) //stack at dest -> rebalance
|
|
|
|
{
|
|
|
|
assert(c == srcType);
|
2022-12-07 18:06:47 +02:00
|
|
|
MAYBE_UNUSED(c);
|
2012-08-24 12:37:52 +03:00
|
|
|
if (stackExp)
|
2011-03-27 12:31:14 +03:00
|
|
|
{
|
|
|
|
ui64 totalExp = srcCount * src.army->getStackExperience(src.slot) + dst.army->getStackCount(dst.slot) * dst.army->getStackExperience(dst.slot);
|
|
|
|
src.army->changeStackCount(src.slot, -count);
|
|
|
|
dst.army->changeStackCount(dst.slot, count);
|
|
|
|
dst.army->setStackExp(dst.slot, totalExp /(src.army->getStackCount(src.slot) + dst.army->getStackCount(dst.slot))); //mean
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
src.army->changeStackCount(src.slot, -count);
|
|
|
|
dst.army->changeStackCount(dst.slot, count);
|
|
|
|
}
|
2010-12-06 01:10:02 +02:00
|
|
|
}
|
|
|
|
else //split stack to an empty slot
|
|
|
|
{
|
|
|
|
src.army->changeStackCount(src.slot, -count);
|
|
|
|
dst.army->addToSlot(dst.slot, srcType->idNumber, count, false);
|
2012-08-24 12:37:52 +03:00
|
|
|
if (stackExp)
|
2011-03-27 12:31:14 +03:00
|
|
|
dst.army->setStackExp(dst.slot, src.army->getStackExperience(src.slot));
|
2010-12-06 01:10:02 +02:00
|
|
|
}
|
|
|
|
}
|
2012-03-06 19:59:55 +03:00
|
|
|
|
|
|
|
CBonusSystemNode::treeHasChanged();
|
2010-11-27 03:46:19 +02:00
|
|
|
}
|
|
|
|
|
2021-11-28 14:57:38 +02:00
|
|
|
DLL_LINKAGE void BulkRebalanceStacks::applyGs(CGameState * gs)
|
|
|
|
{
|
|
|
|
for(auto & move : moves)
|
|
|
|
move.applyGs(gs);
|
|
|
|
}
|
|
|
|
|
|
|
|
DLL_LINKAGE void BulkSmartRebalanceStacks::applyGs(CGameState * gs)
|
|
|
|
{
|
|
|
|
for(auto & move : moves)
|
|
|
|
move.applyGs(gs);
|
|
|
|
|
|
|
|
for(auto & change : changes)
|
|
|
|
change.applyGs(gs);
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void PutArtifact::applyGs(CGameState *gs)
|
2010-12-26 16:34:11 +02:00
|
|
|
{
|
|
|
|
assert(art->canBePutAt(al));
|
2012-04-14 05:20:22 +03:00
|
|
|
art->putAt(al);
|
|
|
|
//al.hero->putArtifact(al.slot, art);
|
2010-12-26 16:34:11 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void EraseArtifact::applyGs(CGameState *gs)
|
2010-12-26 16:34:11 +02:00
|
|
|
{
|
2016-01-22 11:53:01 +02:00
|
|
|
auto slot = al.getSlot();
|
|
|
|
if(slot->locked)
|
|
|
|
{
|
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
|
|
|
logGlobal->debug("Erasing locked artifact: %s", slot->artifact->artType->getName());
|
2016-01-22 11:53:01 +02:00
|
|
|
DisassembledArtifact dis;
|
|
|
|
dis.al.artHolder = al.artHolder;
|
|
|
|
auto aset = al.getHolderArtSet();
|
2016-10-27 19:22:29 +02:00
|
|
|
#ifndef NDEBUG
|
2016-01-22 11:53:01 +02:00
|
|
|
bool found = false;
|
2016-10-27 19:22:29 +02:00
|
|
|
#endif
|
2016-01-22 11:53:01 +02:00
|
|
|
for(auto& p : aset->artifactsWorn)
|
|
|
|
{
|
|
|
|
auto art = p.second.artifact;
|
|
|
|
if(art->canBeDisassembled() && art->isPart(slot->artifact))
|
|
|
|
{
|
|
|
|
dis.al.slot = aset->getArtPos(art);
|
2016-10-27 19:22:29 +02:00
|
|
|
#ifndef NDEBUG
|
2016-01-22 11:53:01 +02:00
|
|
|
found = true;
|
2016-10-27 19:22:29 +02:00
|
|
|
#endif
|
2016-01-22 11:53:01 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(found && "Failed to determine the assembly this locked artifact belongs to");
|
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
|
|
|
logGlobal->debug("Found the corresponding assembly: %s", dis.al.getSlot()->artifact->artType->getName());
|
2016-01-22 11:53:01 +02:00
|
|
|
dis.applyGs(gs);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
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
|
|
|
logGlobal->debug("Erasing artifact %s", slot->artifact->artType->getName());
|
2016-01-22 11:53:01 +02:00
|
|
|
}
|
2014-02-09 02:07:33 +03:00
|
|
|
al.removeArtifact();
|
2010-12-26 16:34:11 +02:00
|
|
|
}
|
|
|
|
|
2022-11-06 23:54:50 +02:00
|
|
|
DLL_LINKAGE void MoveArtifact::applyGs(CGameState * gs)
|
2010-12-26 16:34:11 +02:00
|
|
|
{
|
2022-11-06 23:54:50 +02:00
|
|
|
CArtifactInstance * art = src.getArt();
|
2022-11-18 22:49:57 +02:00
|
|
|
if(!ArtifactUtils::isSlotBackpack(dst.slot))
|
2011-01-15 04:17:56 +02:00
|
|
|
assert(!dst.getArt());
|
2011-01-22 05:43:20 +02:00
|
|
|
|
2022-11-06 23:54:50 +02:00
|
|
|
art->move(src, dst);
|
2010-12-26 16:34:11 +02:00
|
|
|
}
|
|
|
|
|
2022-11-06 23:54:50 +02:00
|
|
|
DLL_LINKAGE void BulkMoveArtifacts::applyGs(CGameState * gs)
|
|
|
|
{
|
2022-11-12 19:30:24 +02:00
|
|
|
enum class EBulkArtsOp
|
2022-11-06 23:54:50 +02:00
|
|
|
{
|
2022-11-12 19:30:24 +02:00
|
|
|
BULK_MOVE,
|
|
|
|
BULK_REMOVE,
|
|
|
|
BULK_PUT
|
|
|
|
};
|
2012-02-17 22:30:40 +03:00
|
|
|
|
2022-11-12 19:30:24 +02:00
|
|
|
auto bulkArtsOperation = [this](std::vector<LinkedSlots> & artsPack,
|
|
|
|
CArtifactSet * artSet, EBulkArtsOp operation) -> void
|
2012-04-14 05:20:22 +03:00
|
|
|
{
|
2022-11-12 19:30:24 +02:00
|
|
|
int numBackpackArtifactsMoved = 0;
|
|
|
|
for(auto & slot : artsPack)
|
2012-04-14 05:20:22 +03:00
|
|
|
{
|
2022-11-12 19:30:24 +02:00
|
|
|
// When an object gets removed from the backpack, the backpack shrinks
|
|
|
|
// so all the following indices will be affected. Thus, we need to update
|
|
|
|
// the subsequent artifact slots to account for that
|
|
|
|
auto srcPos = slot.srcPos;
|
2022-11-18 22:49:57 +02:00
|
|
|
if(ArtifactUtils::isSlotBackpack(srcPos) && (operation != EBulkArtsOp::BULK_PUT))
|
2022-11-06 23:54:50 +02:00
|
|
|
{
|
2022-11-12 19:30:24 +02:00
|
|
|
srcPos = ArtifactPosition(srcPos.num - numBackpackArtifactsMoved);
|
|
|
|
}
|
|
|
|
auto slotInfo = artSet->getSlot(srcPos);
|
|
|
|
assert(slotInfo);
|
|
|
|
auto art = const_cast<CArtifactInstance*>(slotInfo->getArt());
|
|
|
|
assert(art);
|
|
|
|
switch(operation)
|
|
|
|
{
|
|
|
|
case EBulkArtsOp::BULK_MOVE:
|
|
|
|
const_cast<CArtifactInstance*>(art)->move(
|
|
|
|
ArtifactLocation(srcArtHolder, srcPos), ArtifactLocation(dstArtHolder, slot.dstPos));
|
|
|
|
break;
|
|
|
|
case EBulkArtsOp::BULK_REMOVE:
|
|
|
|
art->removeFrom(ArtifactLocation(dstArtHolder, srcPos));
|
|
|
|
break;
|
|
|
|
case EBulkArtsOp::BULK_PUT:
|
|
|
|
art->putAt(ArtifactLocation(srcArtHolder, slot.dstPos));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2022-11-06 23:54:50 +02:00
|
|
|
}
|
|
|
|
|
2022-11-12 19:30:24 +02:00
|
|
|
if(srcPos >= GameConstants::BACKPACK_START)
|
2022-11-06 23:54:50 +02:00
|
|
|
{
|
2022-11-12 19:30:24 +02:00
|
|
|
numBackpackArtifactsMoved++;
|
2022-11-06 23:54:50 +02:00
|
|
|
}
|
2012-04-14 05:20:22 +03:00
|
|
|
}
|
2022-11-12 19:30:24 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
if(swap)
|
|
|
|
{
|
|
|
|
// Swap
|
|
|
|
auto leftSet = getSrcHolderArtSet();
|
|
|
|
auto rightSet = getDstHolderArtSet();
|
2022-11-13 12:04:51 +02:00
|
|
|
CArtifactFittingSet artFittingSet(leftSet->bearerType());
|
2022-11-06 23:54:50 +02:00
|
|
|
|
2022-11-13 12:04:51 +02:00
|
|
|
artFittingSet.artifactsWorn = rightSet->artifactsWorn;
|
|
|
|
artFittingSet.artifactsInBackpack = rightSet->artifactsInBackpack;
|
2022-11-06 23:54:50 +02:00
|
|
|
|
2022-11-12 19:30:24 +02:00
|
|
|
bulkArtsOperation(artsPack1, rightSet, EBulkArtsOp::BULK_REMOVE);
|
|
|
|
bulkArtsOperation(artsPack0, leftSet, EBulkArtsOp::BULK_MOVE);
|
2022-11-13 12:04:51 +02:00
|
|
|
bulkArtsOperation(artsPack1, &artFittingSet, EBulkArtsOp::BULK_PUT);
|
2022-11-06 23:54:50 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-11-12 19:30:24 +02:00
|
|
|
bulkArtsOperation(artsPack0, getSrcHolderArtSet(), EBulkArtsOp::BULK_MOVE);
|
2012-04-14 05:20:22 +03:00
|
|
|
}
|
2010-12-26 16:34:11 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void AssembledArtifact::applyGs(CGameState *gs)
|
2011-01-22 05:43:20 +02:00
|
|
|
{
|
2022-11-18 01:32:25 +02:00
|
|
|
CArtifactSet * artSet = al.getHolderArtSet();
|
2011-01-22 05:43:20 +02:00
|
|
|
const CArtifactInstance *transformedArt = al.getArt();
|
|
|
|
assert(transformedArt);
|
2022-11-18 22:49:57 +02:00
|
|
|
bool combineEquipped = !ArtifactUtils::isSlotBackpack(al.slot);
|
2022-12-18 12:28:30 +02:00
|
|
|
assert(vstd::contains_if(transformedArt->assemblyPossibilities(artSet, combineEquipped), [=](const CArtifact * art)->bool
|
|
|
|
{
|
|
|
|
return art->id == builtArt->id;
|
|
|
|
}));
|
2022-12-07 18:06:47 +02:00
|
|
|
MAYBE_UNUSED(transformedArt);
|
2011-01-22 05:43:20 +02:00
|
|
|
|
2013-06-29 16:05:48 +03:00
|
|
|
auto combinedArt = new CCombinedArtifactInstance(builtArt);
|
2011-01-28 04:11:58 +02:00
|
|
|
gs->map->addNewArtifactInstance(combinedArt);
|
2022-11-18 01:32:25 +02:00
|
|
|
// Retrieve all constituents
|
2013-06-29 16:05:48 +03:00
|
|
|
for(const CArtifact * constituent : *builtArt->constituents)
|
2011-01-22 05:43:20 +02:00
|
|
|
{
|
2022-11-19 16:09:32 +02:00
|
|
|
ArtifactPosition pos = combineEquipped ? artSet->getArtPos(constituent->id, true, false) :
|
|
|
|
artSet->getArtBackpackPos(constituent->id);
|
2011-01-22 05:43:20 +02:00
|
|
|
assert(pos >= 0);
|
2022-11-18 01:32:25 +02:00
|
|
|
CArtifactInstance * constituentInstance = artSet->getArt(pos);
|
2011-01-22 05:43:20 +02:00
|
|
|
|
|
|
|
//move constituent from hero to be part of new, combined artifact
|
2012-09-28 23:49:23 +03:00
|
|
|
constituentInstance->removeFrom(ArtifactLocation(al.artHolder, pos));
|
2011-01-22 05:43:20 +02:00
|
|
|
combinedArt->addAsConstituent(constituentInstance, pos);
|
2022-11-18 01:32:25 +02:00
|
|
|
if(combineEquipped)
|
|
|
|
{
|
|
|
|
if(!vstd::contains(combinedArt->artType->possibleSlots[artSet->bearerType()], al.slot)
|
|
|
|
&& vstd::contains(combinedArt->artType->possibleSlots[artSet->bearerType()], pos))
|
|
|
|
al.slot = pos;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-11-18 22:49:57 +02:00
|
|
|
al.slot = std::min(al.slot, pos);
|
2022-11-18 01:32:25 +02:00
|
|
|
}
|
2011-01-22 05:43:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
//put new combined artifacts
|
2012-04-14 05:20:22 +03:00
|
|
|
combinedArt->putAt(al);
|
2011-01-22 05:43:20 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void DisassembledArtifact::applyGs(CGameState *gs)
|
2011-01-22 05:43:20 +02:00
|
|
|
{
|
2011-01-24 01:49:17 +02:00
|
|
|
CCombinedArtifactInstance *disassembled = dynamic_cast<CCombinedArtifactInstance*>(al.getArt());
|
|
|
|
assert(disassembled);
|
|
|
|
|
|
|
|
std::vector<CCombinedArtifactInstance::ConstituentInfo> constituents = disassembled->constituentsInfo;
|
2012-04-14 05:20:22 +03:00
|
|
|
disassembled->removeFrom(al);
|
2013-06-29 16:05:48 +03:00
|
|
|
for(CCombinedArtifactInstance::ConstituentInfo &ci : constituents)
|
2011-01-24 01:49:17 +02:00
|
|
|
{
|
2012-04-14 05:20:22 +03:00
|
|
|
ArtifactLocation constituentLoc = al;
|
|
|
|
constituentLoc.slot = (ci.slot >= 0 ? ci.slot : al.slot); //-1 is slot of main constituent -> it'll replace combined artifact in its pos
|
2022-11-06 01:26:13 +02:00
|
|
|
disassembled->detachFrom(*ci.art);
|
2012-04-14 05:20:22 +03:00
|
|
|
ci.art->putAt(constituentLoc);
|
2011-01-24 01:49:17 +02:00
|
|
|
}
|
|
|
|
|
2011-01-28 04:11:58 +02:00
|
|
|
gs->map->eraseArtifactInstance(disassembled);
|
2011-01-22 05:43:20 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void HeroVisit::applyGs(CGameState *gs)
|
2011-05-10 01:20:47 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void SetAvailableArtifacts::applyGs(CGameState *gs)
|
2010-06-26 19:02:10 +03:00
|
|
|
{
|
|
|
|
if(id >= 0)
|
|
|
|
{
|
2010-12-19 00:11:28 +02:00
|
|
|
if(CGBlackMarket *bm = dynamic_cast<CGBlackMarket*>(gs->map->objects[id].get()))
|
2010-06-26 19:02:10 +03:00
|
|
|
{
|
|
|
|
bm->artifacts = arts;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-08-10 18:39:27 +02:00
|
|
|
logNetwork->error("Wrong black market id!");
|
2010-06-26 19:02:10 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CGTownInstance::merchantArtifacts = arts;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void NewTurn::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
gs->day = day;
|
2015-12-25 00:46:44 +02:00
|
|
|
|
|
|
|
// Update bonuses before doing anything else so hero don't get more MP than needed
|
2018-03-05 08:51:35 +02:00
|
|
|
gs->globalEffects.removeBonusesRecursive(Bonus::OneDay); //works for children -> all game objs
|
2017-09-09 14:25:55 +02:00
|
|
|
gs->globalEffects.reduceBonusDurations(Bonus::NDays);
|
|
|
|
gs->globalEffects.reduceBonusDurations(Bonus::OneWeek);
|
2015-12-25 00:46:44 +02:00
|
|
|
//TODO not really a single root hierarchy, what about bonuses placed elsewhere? [not an issue with H3 mechanics but in the future...]
|
|
|
|
|
2013-06-29 16:05:48 +03:00
|
|
|
for(NewTurn::Hero h : heroes) //give mana/movement point
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2009-04-04 01:34:31 +03:00
|
|
|
CGHeroInstance *hero = gs->getHero(h.id);
|
2016-01-28 21:48:51 +02:00
|
|
|
if(!hero)
|
|
|
|
{
|
|
|
|
// retreated or surrendered hero who has not been reset yet
|
|
|
|
for(auto& hp : gs->hpool.heroesPool)
|
|
|
|
{
|
|
|
|
if(hp.second->id == h.id)
|
|
|
|
{
|
|
|
|
hero = hp.second;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(!hero)
|
|
|
|
{
|
2017-08-11 19:03:05 +02:00
|
|
|
logGlobal->error("Hero %d not found in NewTurn::applyGs", h.id.getNum());
|
2016-01-28 21:48:51 +02:00
|
|
|
continue;
|
|
|
|
}
|
2009-04-04 01:34:31 +03:00
|
|
|
hero->movement = h.move;
|
|
|
|
hero->mana = h.mana;
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2013-03-03 20:06:03 +03:00
|
|
|
for(auto i = res.cbegin(); i != res.cend(); i++)
|
2009-11-28 03:42:08 +02:00
|
|
|
{
|
2013-03-03 20:06:03 +03:00
|
|
|
assert(i->first < PlayerColor::PLAYER_LIMIT);
|
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
|
|
|
gs->getPlayerState(i->first)->resources = i->second;
|
2009-11-28 03:42:08 +02:00
|
|
|
}
|
2009-03-07 17:55:56 +02:00
|
|
|
|
2013-06-29 16:05:48 +03:00
|
|
|
for(auto creatureSet : cres) //set available creatures in towns
|
2013-03-14 23:44:00 +03:00
|
|
|
creatureSet.second.applyGs(gs);
|
2009-03-07 17:55:56 +02:00
|
|
|
|
2013-06-29 16:05:48 +03:00
|
|
|
for(CGTownInstance* t : gs->map->towns)
|
2011-08-26 23:32:05 +03:00
|
|
|
t->builded = 0;
|
2015-11-30 23:44:58 +02:00
|
|
|
|
|
|
|
if(gs->getDate(Date::DAY_OF_WEEK) == 1)
|
|
|
|
gs->updateRumor();
|
2016-08-23 06:57:57 +02:00
|
|
|
|
|
|
|
//count days without town for all players, regardless of their turn order
|
|
|
|
for (auto &p : gs->players)
|
|
|
|
{
|
|
|
|
PlayerState & playerState = p.second;
|
|
|
|
if (playerState.status == EPlayerStatus::INGAME)
|
|
|
|
{
|
|
|
|
if (playerState.towns.empty())
|
|
|
|
{
|
|
|
|
if (playerState.daysWithoutCastle)
|
|
|
|
++(*playerState.daysWithoutCastle);
|
2017-08-05 15:09:29 +02:00
|
|
|
else
|
|
|
|
playerState.daysWithoutCastle = boost::make_optional(0);
|
2016-08-23 06:57:57 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
playerState.daysWithoutCastle = boost::none;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void SetObjectProperty::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2013-02-14 02:55:42 +03:00
|
|
|
CGObjectInstance *obj = gs->getObjInstance(id);
|
2009-03-07 17:55:56 +02:00
|
|
|
if(!obj)
|
2009-08-22 16:59:15 +03:00
|
|
|
{
|
2017-08-10 18:39:27 +02:00
|
|
|
logNetwork->error("Wrong object ID - property cannot be set!");
|
2009-08-22 16:59:15 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-03-08 09:40:14 +02:00
|
|
|
CArmedInstance *cai = dynamic_cast<CArmedInstance *>(obj);
|
|
|
|
if(what == ObjProperty::OWNER && cai)
|
2009-08-22 16:59:15 +03:00
|
|
|
{
|
2012-09-23 21:01:04 +03:00
|
|
|
if(obj->ID == Obj::TOWN)
|
2011-02-21 06:13:00 +02:00
|
|
|
{
|
2011-03-08 09:40:14 +02:00
|
|
|
CGTownInstance *t = static_cast<CGTownInstance*>(obj);
|
2013-03-03 20:06:03 +03:00
|
|
|
if(t->tempOwner < PlayerColor::PLAYER_LIMIT)
|
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
|
|
|
gs->getPlayerState(t->tempOwner)->towns -= t;
|
2013-03-03 20:06:03 +03:00
|
|
|
if(val < PlayerColor::PLAYER_LIMIT_I)
|
2016-08-23 06:57:57 +02: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 = gs->getPlayerState(PlayerColor(val));
|
2016-08-23 06:57:57 +02:00
|
|
|
p->towns.push_back(t);
|
|
|
|
|
|
|
|
//reset counter before NewTurn to avoid no town message if game loaded at turn when one already captured
|
|
|
|
if(p->daysWithoutCastle)
|
|
|
|
p->daysWithoutCastle = boost::none;
|
|
|
|
}
|
2011-02-21 06:13:00 +02:00
|
|
|
}
|
2011-03-08 09:40:14 +02:00
|
|
|
|
2022-11-06 01:26:13 +02:00
|
|
|
CBonusSystemNode & nodeToMove = cai->whatShouldBeAttached();
|
|
|
|
nodeToMove.detachFrom(cai->whereShouldBeAttached(gs));
|
2011-03-08 09:40:14 +02:00
|
|
|
obj->setProperty(what,val);
|
2022-11-06 01:26:13 +02:00
|
|
|
nodeToMove.attachTo(cai->whereShouldBeAttached(gs));
|
2009-08-22 16:59:15 +03:00
|
|
|
}
|
2011-03-08 09:40:14 +02:00
|
|
|
else //not an armed instance
|
2011-02-22 11:47:25 +02:00
|
|
|
{
|
|
|
|
obj->setProperty(what,val);
|
|
|
|
}
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2018-03-10 21:19:55 +02:00
|
|
|
DLL_LINKAGE void PrepareHeroLevelUp::applyGs(CGameState * gs)
|
2016-09-07 23:24:05 +02:00
|
|
|
{
|
2018-03-10 21:19:55 +02:00
|
|
|
auto hero = gs->getHero(heroId);
|
|
|
|
assert(hero);
|
|
|
|
|
|
|
|
auto proposedSkills = hero->getLevelUpProposedSecondarySkills();
|
2016-09-07 23:24:05 +02:00
|
|
|
|
|
|
|
if(skills.size() == 1 || hero->tempOwner == PlayerColor::NEUTRAL) //choose skill automatically
|
|
|
|
{
|
2018-03-10 21:19:55 +02:00
|
|
|
skills.push_back(*RandomGeneratorUtil::nextItem(proposedSkills, hero->skillsInfo.rand));
|
2016-09-07 23:24:05 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
skills = proposedSkills;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-10 21:19:55 +02:00
|
|
|
DLL_LINKAGE void HeroLevelUp::applyGs(CGameState * gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2018-03-10 21:19:55 +02:00
|
|
|
auto hero = gs->getHero(heroId);
|
|
|
|
assert(hero);
|
|
|
|
hero->levelUp(skills);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2018-03-10 21:19:55 +02:00
|
|
|
DLL_LINKAGE void CommanderLevelUp::applyGs(CGameState * gs)
|
2012-05-16 20:29:05 +03:00
|
|
|
{
|
2018-03-10 21:19:55 +02:00
|
|
|
auto hero = gs->getHero(heroId);
|
|
|
|
assert(hero);
|
|
|
|
auto commander = hero->commander;
|
|
|
|
assert(commander);
|
2012-05-16 20:29:05 +03:00
|
|
|
commander->levelUp();
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void BattleStart::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
gs->curB = info;
|
2010-12-23 02:33:48 +02:00
|
|
|
gs->curB->localInit();
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void BattleNextRound::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
gs->curB->nextRound(round);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void BattleSetActiveStack::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
gs->curB->nextTurn(stack);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void BattleTriggerEffect::applyGs(CGameState *gs)
|
2011-10-08 16:02:58 +03:00
|
|
|
{
|
2017-07-04 13:24:46 +02:00
|
|
|
CStack * st = gs->curB->getStack(stackID);
|
|
|
|
assert(st);
|
|
|
|
switch(effect)
|
2011-10-08 16:02:58 +03:00
|
|
|
{
|
2017-07-04 13:24:46 +02:00
|
|
|
case Bonus::HP_REGENERATION:
|
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
int64_t toHeal = val;
|
|
|
|
st->heal(toHeal, EHealLevel::HEAL, EHealPower::PERMANENT);
|
2017-07-04 13:24:46 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Bonus::MANA_DRAIN:
|
|
|
|
{
|
|
|
|
CGHeroInstance * h = gs->getHero(ObjectInstanceID(additionalInfo));
|
2017-07-20 06:08:49 +02:00
|
|
|
st->drainedMana = true;
|
2017-07-04 13:24:46 +02:00
|
|
|
h->mana -= val;
|
|
|
|
vstd::amax(h->mana, 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Bonus::POISON:
|
|
|
|
{
|
|
|
|
auto b = st->getBonusLocalFirst(Selector::source(Bonus::SPELL_EFFECT, SpellID::POISON)
|
2020-11-11 21:43:40 +02:00
|
|
|
.And(Selector::type()(Bonus::STACK_HEALTH)));
|
2017-07-04 13:24:46 +02:00
|
|
|
if (b)
|
|
|
|
b->val = val;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Bonus::ENCHANTER:
|
|
|
|
break;
|
|
|
|
case Bonus::FEAR:
|
2017-07-20 06:08:49 +02:00
|
|
|
st->fear = true;
|
2017-07-04 13:24:46 +02:00
|
|
|
break;
|
|
|
|
default:
|
2017-08-11 19:03:05 +02:00
|
|
|
logNetwork->error("Unrecognized trigger effect type %d", effect);
|
2011-10-08 16:02:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-13 16:40:31 +02:00
|
|
|
DLL_LINKAGE void BattleUpdateGateState::applyGs(CGameState *gs)
|
2016-01-29 21:35:11 +02:00
|
|
|
{
|
2016-02-09 16:38:59 +02:00
|
|
|
if(gs->curB)
|
2016-02-13 16:40:31 +02:00
|
|
|
gs->curB->si.gateState = state;
|
2016-01-29 21:35:11 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
void BattleResult::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2013-06-29 16:05:48 +03:00
|
|
|
for (auto & elem : gs->curB->stacks)
|
|
|
|
delete elem;
|
2009-03-07 17:55:56 +02:00
|
|
|
|
2013-07-22 01:01:29 +03:00
|
|
|
|
|
|
|
for(int i = 0; i < 2; ++i)
|
2012-05-07 15:54:22 +03:00
|
|
|
{
|
2013-07-22 01:01:29 +03:00
|
|
|
if(auto h = gs->curB->battleGetFightingHero(i))
|
2012-05-07 15:54:22 +03:00
|
|
|
{
|
2018-03-05 08:51:35 +02:00
|
|
|
h->removeBonusesRecursive(Bonus::OneBattle); //remove any "until next battle" bonuses
|
2012-07-16 19:18:02 +03:00
|
|
|
if (h->commander && h->commander->alive)
|
|
|
|
{
|
2013-06-29 16:05:48 +03:00
|
|
|
for (auto art : h->commander->artifactsWorn) //increment bonuses for commander artifacts
|
2012-07-16 19:18:02 +03:00
|
|
|
{
|
|
|
|
art.second.artifact->artType->levelUpArtifact (art.second.artifact);
|
|
|
|
}
|
|
|
|
}
|
2012-05-07 15:54:22 +03:00
|
|
|
}
|
|
|
|
}
|
2009-03-07 17:55:56 +02:00
|
|
|
|
2013-07-22 01:01:29 +03:00
|
|
|
if(VLC->modh->modules.STACK_EXP)
|
2011-02-13 15:11:09 +02:00
|
|
|
{
|
2013-07-22 01:01:29 +03:00
|
|
|
for(int i = 0; i < 2; i++)
|
|
|
|
if(exp[i])
|
|
|
|
gs->curB->battleGetArmyObject(i)->giveStackExp(exp[i]);
|
2014-02-15 12:40:33 +03:00
|
|
|
|
2012-03-06 19:59:55 +03:00
|
|
|
CBonusSystemNode::treeHasChanged();
|
2011-02-13 15:11:09 +02:00
|
|
|
}
|
|
|
|
|
2013-07-22 01:01:29 +03:00
|
|
|
for(int i = 0; i < 2; i++)
|
|
|
|
gs->curB->battleGetArmyObject(i)->battle = nullptr;
|
|
|
|
|
2010-12-26 16:34:11 +02:00
|
|
|
gs->curB.dellNull();
|
2009-03-07 17:55:56 +02: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
|
|
|
DLL_LINKAGE void BattleLogMessage::applyGs(CGameState *gs)
|
|
|
|
{
|
|
|
|
//nothing
|
|
|
|
}
|
|
|
|
|
|
|
|
DLL_LINKAGE void BattleLogMessage::applyBattle(IBattleState * battleState)
|
|
|
|
{
|
|
|
|
//nothing
|
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void BattleStackMoved::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
applyBattle(gs->curB);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void BattleStackMoved::applyBattle(IBattleState * battleState)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
battleState->moveUnit(stack, tilesToMove.back());
|
|
|
|
}
|
2016-01-22 11:53:01 +02:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void BattleStackAttacked::applyGs(CGameState * gs)
|
|
|
|
{
|
|
|
|
applyBattle(gs->curB);
|
|
|
|
}
|
2016-02-27 17:39:37 +02:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void BattleStackAttacked::applyBattle(IBattleState * battleState)
|
|
|
|
{
|
|
|
|
battleState->setUnitState(newState.id, newState.data, newState.healthDelta);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2017-07-04 13:24:46 +02:00
|
|
|
DLL_LINKAGE void BattleAttack::applyGs(CGameState * gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2017-07-04 13:24:46 +02:00
|
|
|
CStack * attacker = gs->curB->getStack(stackAttacking);
|
|
|
|
assert(attacker);
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
attackerChanges.applyGs(gs);
|
2010-05-20 13:54:24 +03:00
|
|
|
|
2016-09-30 01:09:02 +02:00
|
|
|
for(BattleStackAttacked & stackAttacked : bsa)
|
2009-03-21 14:49:58 +02:00
|
|
|
stackAttacked.applyGs(gs);
|
2009-08-07 14:22:17 +03:00
|
|
|
|
2018-03-05 08:51:35 +02:00
|
|
|
attacker->removeBonusesRecursive(Bonus::UntilAttack);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void StartAction::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
CStack *st = gs->curB->getStack(ba.stackNumber);
|
2009-09-10 14:28:34 +03:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
if(ba.actionType == EActionType::END_TACTIC_PHASE)
|
2011-02-12 18:12:48 +02:00
|
|
|
{
|
|
|
|
gs->curB->tacticDistance = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-03-27 23:08:54 +03:00
|
|
|
if(gs->curB->tacticDistance)
|
|
|
|
{
|
|
|
|
// moves in tactics phase do not affect creature status
|
|
|
|
// (tactics stack queue is managed by client)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
if(ba.actionType != EActionType::HERO_SPELL) //don't check for stack if it's custom action by hero
|
2011-02-11 21:12:08 +02:00
|
|
|
{
|
2009-09-10 14:28:34 +03:00
|
|
|
assert(st);
|
2011-02-11 21:12:08 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
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
|
|
|
gs->curB->sides[ba.side].usedSpellsHistory.push_back(SpellID(ba.actionSubtype));
|
2011-02-11 21:12:08 +02:00
|
|
|
}
|
2009-09-10 14:28:34 +03:00
|
|
|
|
2009-03-07 17:55:56 +02:00
|
|
|
switch(ba.actionType)
|
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
case EActionType::DEFEND:
|
|
|
|
st->waiting = false;
|
|
|
|
st->defending = true;
|
|
|
|
st->defendingAnim = true;
|
|
|
|
break;
|
|
|
|
case EActionType::WAIT:
|
|
|
|
st->defendingAnim = false;
|
|
|
|
st->waiting = true;
|
2019-03-24 00:51:50 +02:00
|
|
|
st->waitedThisTurn = true;
|
2017-07-20 06:08:49 +02:00
|
|
|
break;
|
|
|
|
case EActionType::HERO_SPELL: //no change in current stack state
|
2009-03-07 17:55:56 +02:00
|
|
|
break;
|
2011-10-01 22:56:54 +03:00
|
|
|
default: //any active stack action - attack, catapult, heal, spell...
|
2017-07-20 06:08:49 +02:00
|
|
|
st->waiting = false;
|
|
|
|
st->defendingAnim = false;
|
|
|
|
st->movedThisRound = true;
|
2009-03-07 17:55:56 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void BattleSpellCast::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2010-05-02 21:20:26 +03:00
|
|
|
assert(gs->curB);
|
2012-09-14 02:41:03 +03:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
if(castByHero)
|
2011-04-23 12:57:51 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
if(side < 2)
|
2011-04-23 12:57:51 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
gs->curB->sides[side].castSpellsCount++;
|
2011-04-23 12:57:51 +03:00
|
|
|
}
|
|
|
|
}
|
2015-04-13 07:51:23 +02:00
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void SetStackEffect::applyGs(CGameState *gs)
|
2015-04-13 07:51:23 +02:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
applyBattle(gs->curB);
|
2009-05-17 18:24:50 +03:00
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void SetStackEffect::applyBattle(IBattleState * battleState)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
for(const auto & stackData : toRemove)
|
|
|
|
battleState->removeUnitBonus(stackData.first, stackData.second);
|
2014-03-07 16:21:09 +03:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
for(const auto & stackData : toUpdate)
|
|
|
|
battleState->updateUnitBonus(stackData.first, stackData.second);
|
2011-04-23 12:57:51 +03:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
for(const auto & stackData : toAdd)
|
|
|
|
battleState->addUnitBonus(stackData.first, stackData.second);
|
|
|
|
}
|
2016-09-29 14:23:28 +02:00
|
|
|
|
2016-11-02 19:11:01 +02:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void StacksInjured::applyGs(CGameState *gs)
|
|
|
|
{
|
|
|
|
applyBattle(gs->curB);
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void StacksInjured::applyBattle(IBattleState * battleState)
|
2009-04-16 03:28:54 +03:00
|
|
|
{
|
2013-06-29 16:05:48 +03:00
|
|
|
for(BattleStackAttacked stackAttacked : stacks)
|
2017-07-20 06:08:49 +02:00
|
|
|
stackAttacked.applyBattle(battleState);
|
2009-04-16 03:28:54 +03:00
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void BattleUnitsChanged::applyGs(CGameState *gs)
|
2009-08-04 20:05:49 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
applyBattle(gs->curB);
|
2009-08-04 20:05:49 +03:00
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void BattleUnitsChanged::applyBattle(IBattleState * battleState)
|
2009-08-19 13:59:42 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
for(auto & elem : changedStacks)
|
2009-08-19 13:59:42 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
switch(elem.operation)
|
2009-08-19 13:59:42 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
case BattleChanges::EOperation::RESET_STATE:
|
|
|
|
battleState->setUnitState(elem.id, elem.data, elem.healthDelta);
|
|
|
|
break;
|
|
|
|
case BattleChanges::EOperation::REMOVE:
|
|
|
|
battleState->removeUnit(elem.id);
|
|
|
|
break;
|
|
|
|
case BattleChanges::EOperation::ADD:
|
|
|
|
battleState->addUnit(elem.id, elem.data);
|
|
|
|
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
|
|
|
case BattleChanges::EOperation::UPDATE:
|
|
|
|
battleState->updateUnit(elem.id, elem.data);
|
|
|
|
break;
|
2017-07-20 06:08:49 +02:00
|
|
|
default:
|
|
|
|
logNetwork->error("Unknown unit operation %d", (int)elem.operation);
|
|
|
|
break;
|
2009-08-19 13:59:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void BattleObstaclesChanged::applyGs(CGameState * gs)
|
2014-06-24 17:17:25 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
if(gs->curB)
|
|
|
|
applyBattle(gs->curB);
|
2014-06-24 17:17:25 +03:00
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void BattleObstaclesChanged::applyBattle(IBattleState * battleState)
|
2009-09-01 16:54:13 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
for(const auto & change : changes)
|
2009-09-01 16:54:13 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
switch(change.operation)
|
2009-09-07 15:30:10 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
case BattleChanges::EOperation::REMOVE:
|
|
|
|
battleState->removeObstacle(change.id);
|
|
|
|
break;
|
|
|
|
case BattleChanges::EOperation::ADD:
|
|
|
|
battleState->addObstacle(change);
|
|
|
|
break;
|
2022-12-17 19:37:00 +02:00
|
|
|
case BattleChanges::EOperation::ACTIVATE_AND_UPDATE:
|
2020-02-12 19:12:12 +02:00
|
|
|
case BattleChanges::EOperation::UPDATE:
|
|
|
|
battleState->updateObstacle(change);
|
|
|
|
break;
|
2017-07-20 06:08:49 +02:00
|
|
|
default:
|
|
|
|
logNetwork->error("Unknown obstacle operation %d", (int)change.operation);
|
|
|
|
break;
|
2009-09-07 15:30:10 +03:00
|
|
|
}
|
2009-09-01 16:54:13 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE CatapultAttack::CatapultAttack()
|
2013-12-08 20:54:13 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
attacker = -1;
|
2013-12-08 20:54:13 +03:00
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE CatapultAttack::~CatapultAttack()
|
2013-12-08 20:54:13 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void CatapultAttack::applyGs(CGameState * gs)
|
2009-09-05 17:10:26 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
if(gs->curB)
|
|
|
|
applyBattle(gs->curB);
|
2009-09-05 17:10:26 +03:00
|
|
|
}
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
DLL_LINKAGE void CatapultAttack::applyBattle(IBattleState * battleState)
|
2011-10-01 22:56:54 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
auto town = battleState->getDefendedTown();
|
|
|
|
if(!town)
|
2011-10-01 22:56:54 +03:00
|
|
|
return;
|
2012-02-29 04:31:48 +03:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
if(town->fortLevel() == CGTownInstance::NONE)
|
|
|
|
return;
|
2015-03-10 22:14:58 +02:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
for(const auto & part : attackedParts)
|
|
|
|
{
|
2023-01-13 01:09:24 +02:00
|
|
|
auto newWallState = SiegeInfo::applyDamage(battleState->getWallState(part.attackedPart), part.damageDealt);
|
2017-07-20 06:08:49 +02:00
|
|
|
battleState->setWallState(part.attackedPart, newWallState);
|
|
|
|
}
|
2011-10-01 22:56:54 +03:00
|
|
|
}
|
|
|
|
|
2017-07-04 13:24:46 +02:00
|
|
|
DLL_LINKAGE void BattleSetStackProperty::applyGs(CGameState * gs)
|
2011-10-02 16:59:12 +03:00
|
|
|
{
|
2011-10-08 12:11:36 +03:00
|
|
|
CStack * stack = gs->curB->getStack(stackID);
|
2017-07-04 13:24:46 +02:00
|
|
|
switch(which)
|
2011-10-02 16:59:12 +03:00
|
|
|
{
|
|
|
|
case CASTS:
|
|
|
|
{
|
2017-07-04 13:24:46 +02:00
|
|
|
if(absolute)
|
|
|
|
logNetwork->error("Can not change casts in absolute mode");
|
2011-10-02 16:59:12 +03:00
|
|
|
else
|
2017-07-14 18:14:34 +02:00
|
|
|
stack->casts.use(-val);
|
2011-10-02 16:59:12 +03:00
|
|
|
break;
|
|
|
|
}
|
2011-10-09 10:20:23 +03:00
|
|
|
case ENCHANTER_COUNTER:
|
|
|
|
{
|
2013-07-22 01:01:29 +03:00
|
|
|
auto & counter = gs->curB->sides[gs->curB->whatSide(stack->owner)].enchanterCounter;
|
2017-07-04 13:24:46 +02:00
|
|
|
if(absolute)
|
2013-07-22 01:01:29 +03:00
|
|
|
counter = val;
|
2011-10-09 10:20:23 +03:00
|
|
|
else
|
2013-07-22 01:01:29 +03:00
|
|
|
counter += val;
|
|
|
|
vstd::amax(counter, 0);
|
2011-10-09 10:20:23 +03:00
|
|
|
break;
|
|
|
|
}
|
2011-10-17 11:24:51 +03:00
|
|
|
case UNBIND:
|
|
|
|
{
|
2020-11-11 21:43:40 +02:00
|
|
|
stack->removeBonusesRecursive(Selector::type()(Bonus::BIND_EFFECT));
|
2011-10-17 11:24:51 +03:00
|
|
|
break;
|
|
|
|
}
|
2012-02-10 16:13:24 +03:00
|
|
|
case CLONED:
|
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
stack->cloned = true;
|
2012-02-10 16:13:24 +03:00
|
|
|
break;
|
|
|
|
}
|
2015-09-14 19:13:26 +02:00
|
|
|
case HAS_CLONE:
|
|
|
|
{
|
|
|
|
stack->cloneID = val;
|
|
|
|
break;
|
|
|
|
}
|
2011-10-02 16:59:12 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-02 02:34:50 +02:00
|
|
|
DLL_LINKAGE void PlayerCheated::applyGs(CGameState *gs)
|
|
|
|
{
|
2017-06-03 07:25:10 +02:00
|
|
|
if(!player.isValidPlayer())
|
|
|
|
return;
|
|
|
|
|
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
|
|
|
gs->getPlayerState(player)->enteredLosingCheatCode = losingCheatCode;
|
|
|
|
gs->getPlayerState(player)->enteredWinningCheatCode = winningCheatCode;
|
2017-06-02 02:34:50 +02:00
|
|
|
}
|
|
|
|
|
2016-10-12 17:16:26 +02:00
|
|
|
DLL_LINKAGE void YourTurn::applyGs(CGameState *gs)
|
2009-03-07 17:55:56 +02:00
|
|
|
{
|
|
|
|
gs->currentPlayer = player;
|
2013-12-06 22:44:11 +03:00
|
|
|
|
|
|
|
auto & playerState = gs->players[player];
|
2015-10-24 16:21:30 +02:00
|
|
|
playerState.daysWithoutCastle = daysWithoutCastle;
|
2009-03-07 17:55:56 +02:00
|
|
|
}
|
|
|
|
|
2011-12-14 00:23:17 +03:00
|
|
|
DLL_LINKAGE Component::Component(const CStackBasicDescriptor &stack)
|
2012-07-19 12:10:55 +03:00
|
|
|
: id(CREATURE), subtype(stack.type->idNumber), val(stack.count), when(0)
|
2010-04-02 05:07:40 +03:00
|
|
|
{
|
2011-09-24 04:15:36 +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
|
|
|
|
|
|
|
DLL_LINKAGE void EntitiesChanged::applyGs(CGameState * gs)
|
|
|
|
{
|
|
|
|
for(const auto & change : changes)
|
|
|
|
gs->updateEntity(change.metatype, change.entityIndex, change.data);
|
|
|
|
}
|
2022-07-26 15:07:42 +02:00
|
|
|
|
2022-11-06 23:54:50 +02:00
|
|
|
const CArtifactInstance * ArtSlotInfo::getArt() const
|
|
|
|
{
|
2022-11-10 17:45:54 +02:00
|
|
|
if(locked)
|
2022-11-06 23:54:50 +02:00
|
|
|
{
|
2022-11-10 17:45:54 +02:00
|
|
|
logNetwork->warn("ArtifactLocation::getArt: This location is locked!");
|
|
|
|
return nullptr;
|
2022-11-06 23:54:50 +02:00
|
|
|
}
|
2022-11-10 17:45:54 +02:00
|
|
|
return artifact;
|
2022-11-06 23:54:50 +02:00
|
|
|
}
|
|
|
|
|
2022-11-07 14:13:36 +02:00
|
|
|
CArtifactSet * BulkMoveArtifacts::getSrcHolderArtSet()
|
2022-11-06 23:54:50 +02:00
|
|
|
{
|
|
|
|
return boost::apply_visitor(GetBase<CArtifactSet>(), srcArtHolder);
|
|
|
|
}
|
|
|
|
|
2022-11-07 14:13:36 +02:00
|
|
|
CArtifactSet * BulkMoveArtifacts::getDstHolderArtSet()
|
2022-11-06 23:54:50 +02:00
|
|
|
{
|
|
|
|
return boost::apply_visitor(GetBase<CArtifactSet>(), dstArtHolder);
|
|
|
|
}
|
|
|
|
|
2022-07-26 15:07:42 +02:00
|
|
|
VCMI_LIB_NAMESPACE_END
|