2017-07-13 10:26:03 +02:00
/*
* NetPacks . h , part of VCMI engine
*
* Authors : listed in file AUTHORS in main folder
*
* License : GNU General Public License v2 .0 or later
* Full text of license available in license . txt file , in main folder
*
*/
2011-12-14 00:23:17 +03:00
# pragma once
2014-01-16 23:24:06 +03:00
# include "NetPacksBase.h"
2010-12-14 23:55:23 +02:00
# include "ConstTransitivePtr.h"
2023-06-17 22:52:42 +02:00
# include "MetaString.h"
2023-06-23 17:02:48 +02:00
# include "ResourceSet.h"
# include "int3.h"
2009-02-04 15:40:54 +02:00
2023-06-23 17:02:48 +02:00
# include "battle/BattleAction.h"
# include "battle/CObstacleInstance.h"
# include "gameState/EVictoryLossCheckResult.h"
2023-07-11 22:08:30 +02:00
# include "gameState/TavernSlot.h"
2023-06-23 17:02:48 +02:00
# include "gameState/QuestInfo.h"
# include "mapObjects/CGHeroInstance.h"
# include "mapping/CMapDefines.h"
2015-02-26 16:15:17 +02:00
# include "spells/ViewSpellInt.h"
2018-01-05 19:21:07 +02:00
class CClient ;
class CGameHandler ;
2022-07-26 15:07:42 +02:00
VCMI_LIB_NAMESPACE_BEGIN
class CGameState ;
2010-06-26 19:02:10 +03:00
class CArtifact ;
2010-12-25 21:23:30 +02:00
class CGObjectInstance ;
2010-12-26 16:34:11 +02:00
class CArtifactInstance ;
2012-05-18 17:02:27 +03:00
struct StackLocation ;
2010-12-26 16:34:11 +02:00
struct ArtSlotInfo ;
2012-05-16 20:29:05 +03:00
struct QuestInfo ;
2017-07-20 06:08:49 +02:00
class IBattleState ;
2009-03-07 00:11:17 +02:00
2023-06-02 20:47:37 +02:00
// This one teleport-specific, but has to be available everywhere in callbacks and netpacks
// For now it's will be there till teleports code refactored and moved into own file
using TTeleportExitsList = std : : vector < std : : pair < ObjectInstanceID , int3 > > ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE Query : public CPackForClient
2008-08-13 03:44:31 +03:00
{
2013-05-27 13:53:28 +03:00
QueryID queryID ; // equals to -1 if it is not an actual query (and should not be answered)
2008-08-13 03:44:31 +03:00
} ;
2009-02-03 07:28:05 +02:00
2012-05-18 17:02:27 +03:00
struct StackLocation
{
ConstTransitivePtr < CArmedInstance > army ;
2013-02-16 17:03:47 +03:00
SlotID slot ;
2012-05-18 17:02:27 +03:00
2023-02-09 18:06:02 +02:00
StackLocation ( ) = default ;
StackLocation ( const CArmedInstance * Army , const SlotID & Slot )
: army ( const_cast < CArmedInstance * > ( Army ) ) //we are allowed here to const cast -> change will go through one of our packages... do not abuse!
, slot ( Slot )
2012-05-18 17:02:27 +03:00
{
}
2012-08-30 19:01:19 +03:00
2023-02-12 09:23:39 +02:00
DLL_LINKAGE const CStackInstance * getStack ( ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
2012-05-18 17:02:27 +03:00
{
2017-07-31 15:35:42 +02:00
h & army ;
h & slot ;
2012-05-18 17:02:27 +03:00
}
} ;
2009-03-09 12:37:49 +02:00
/***********************************************************************************************************/
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE PackageApplied : public CPackForClient
2009-04-16 03:28:54 +03:00
{
2023-02-09 18:06:02 +02:00
PackageApplied ( ) = default ;
2016-11-25 19:04:07 +02:00
PackageApplied ( ui8 Result )
2023-02-09 18:06:02 +02:00
: result ( Result )
{
}
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-04-16 03:28:54 +03:00
2023-02-09 18:06:02 +02:00
ui8 result = 0 ; //0 - something went wrong, request hasn't been realized; 1 - OK
ui32 packType = 0 ; //type id of applied package
ui32 requestID = 0 ; //an ID given by client to the request that was applied
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-04-16 03:28:54 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2009-04-16 03:28:54 +03:00
{
2017-07-31 15:35:42 +02:00
h & result ;
h & packType ;
h & requestID ;
h & player ;
2009-04-16 03:28:54 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SystemMessage : public CPackForClient
2008-07-26 09:39:44 +03:00
{
2023-02-09 18:06:02 +02:00
SystemMessage ( std : : string Text )
: text ( std : : move ( Text ) )
{
}
SystemMessage ( ) = default ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2008-07-26 09:39:44 +03:00
2009-03-07 00:11:17 +02:00
std : : string text ;
2009-03-07 00:25:19 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-07-26 09:39:44 +03:00
{
2009-03-07 00:25:19 +02:00
h & text ;
2008-07-26 09:39:44 +03:00
}
2008-08-10 07:46:16 +03:00
} ;
2009-03-07 00:11:17 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE PlayerBlocked : public CPackForClient
2009-08-04 02:53:18 +03:00
{
2013-09-28 02:46:58 +03:00
enum EReason { UPCOMING_BATTLE , ONGOING_MOVEMENT } ;
enum EMode { BLOCKADE_STARTED , BLOCKADE_ENDED } ;
2016-08-30 04:13:45 +02:00
2023-02-09 18:06:02 +02:00
EReason reason = UPCOMING_BATTLE ;
EMode startOrEnd = BLOCKADE_STARTED ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-08-04 02:53:18 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-08-04 02:53:18 +03:00
{
2017-07-31 15:35:42 +02:00
h & reason ;
h & startOrEnd ;
h & player ;
2009-08-04 02:53:18 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE PlayerCheated : public CPackForClient
2017-06-02 02:34:50 +02:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2017-06-02 02:34:50 +02:00
PlayerColor player ;
2023-02-09 18:06:02 +02:00
bool losingCheatCode = false ;
bool winningCheatCode = false ;
2017-06-02 02:34:50 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2017-06-02 02:34:50 +02:00
{
2017-07-31 15:35:42 +02:00
h & player ;
h & losingCheatCode ;
h & winningCheatCode ;
2017-06-02 02:34:50 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE YourTurn : public CPackForClient
2009-03-07 00:11:17 +02:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2009-03-07 00:11:17 +02:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2023-04-16 19:42:56 +02:00
std : : optional < ui8 > daysWithoutCastle ;
2008-07-26 09:39:44 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-07-26 09:39:44 +03:00
{
2017-07-31 15:35:42 +02:00
h & player ;
h & daysWithoutCastle ;
2008-07-26 09:39:44 +03:00
}
2008-08-10 07:46:16 +03:00
} ;
2009-03-07 00:11:17 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE EntitiesChanged : public CPackForClient
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
{
std : : vector < EntityChanges > changes ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
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
{
h & changes ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetResources : public CPackForClient
2016-11-18 16:45:59 +02:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2012-09-15 22:16:16 +03:00
2023-02-09 18:06:02 +02:00
bool abs = true ; //false - changes by value; 1 - sets to value
2016-11-18 16:45:59 +02:00
PlayerColor player ;
TResources res ; //res[resid] => res amount
2009-03-07 00:11:17 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2016-11-18 16:45:59 +02:00
{
2017-07-31 15:35:42 +02:00
h & abs ;
h & player ;
h & res ;
2016-11-18 16:45:59 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetPrimSkill : public CPackForClient
2008-08-04 18:56:36 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-03-07 00:11:17 +02:00
2023-02-09 18:06:02 +02:00
ui8 abs = 0 ; //0 - changes by value; 1 - sets to value
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
2023-02-09 18:06:02 +02:00
PrimarySkill : : PrimarySkill which = PrimarySkill : : ATTACK ;
si64 val = 0 ;
2008-08-04 18:56:36 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-04 18:56:36 +03:00
{
2017-07-31 15:35:42 +02:00
h & abs ;
h & id ;
h & which ;
h & val ;
2008-08-04 18:56:36 +03:00
}
2012-09-15 22:16:16 +03:00
} ;
2016-11-18 16:45:59 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetSecSkill : public CPackForClient
2008-08-13 03:44:31 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-03-07 00:11:17 +02:00
2023-02-09 18:06:02 +02:00
ui8 abs = 0 ; //0 - changes by value; 1 - sets to value
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
2013-02-12 22:49:40 +03:00
SecondarySkill which ;
2023-02-09 18:06:02 +02:00
ui16 val = 0 ;
2008-08-13 03:44:31 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-13 03:44:31 +03:00
{
2017-07-31 15:35:42 +02:00
h & abs ;
h & id ;
h & which ;
h & val ;
2008-08-13 03:44:31 +03:00
}
2012-05-07 15:54:22 +03:00
} ;
2016-11-18 16:45:59 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE HeroVisitCastle : public CPackForClient
2008-08-13 12:28:06 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-03-07 00:11:17 +02:00
2023-02-09 18:06:02 +02:00
ui8 flags = 0 ; //1 - start
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid , hid ;
2008-08-13 12:28:06 +03:00
2023-02-09 18:06:02 +02:00
bool start ( ) const //if hero is entering castle (if false - leaving)
2008-08-13 12:28:06 +03:00
{
return flags & 1 ;
}
2016-11-18 16:45:59 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-13 12:28:06 +03:00
{
2017-07-31 15:35:42 +02:00
h & flags ;
h & tid ;
h & hid ;
2008-08-13 12:28:06 +03:00
}
2012-09-15 22:16:16 +03:00
} ;
2016-11-25 19:04:07 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE ChangeSpells : public CPackForClient
2008-09-12 11:51:46 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-03-07 00:11:17 +02:00
2023-02-09 18:06:02 +02:00
ui8 learn = 1 ; //1 - gives spell, 0 - takes
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
2013-02-11 02:24:57 +03:00
std : : set < SpellID > spells ;
2008-09-12 11:51:46 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-09-12 11:51:46 +03:00
{
2017-07-31 15:35:42 +02:00
h & learn ;
h & hid ;
h & spells ;
2008-09-12 11:51:46 +03:00
}
2012-09-15 22:16:16 +03:00
} ;
2008-10-19 02:20:48 +03:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetMana : public CPackForClient
2008-10-19 02:20:48 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
2023-02-09 18:06:02 +02:00
si32 val = 0 ;
bool absolute = true ;
2008-10-19 02:20:48 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-10-19 02:20:48 +03:00
{
2017-07-31 15:35:42 +02:00
h & val ;
h & hid ;
h & absolute ;
2008-10-19 02:20:48 +03:00
}
2011-01-20 19:25:15 +02:00
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetMovePoints : public CPackForClient
2008-10-19 02:20:48 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
2023-02-09 18:06:02 +02:00
si32 val = 0 ;
bool absolute = true ;
2008-10-19 02:20:48 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-10-19 02:20:48 +03:00
{
2017-07-31 15:35:42 +02:00
h & val ;
h & hid ;
h & absolute ;
2008-10-19 02:20:48 +03:00
}
2011-01-20 19:25:15 +02:00
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE FoWChange : public CPackForClient
2008-10-19 02:20:48 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2023-04-16 00:48:49 +02:00
std : : unordered_set < int3 > tiles ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2023-02-09 18:06:02 +02:00
ui8 mode = 0 ; //mode==0 - hide, mode==1 - reveal
bool waitForDialogs = false ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-10-19 02:20:48 +03:00
{
2017-07-31 15:35:42 +02:00
h & tiles ;
h & player ;
h & mode ;
h & waitForDialogs ;
2008-10-19 02:20:48 +03:00
}
2012-09-15 22:16:16 +03:00
} ;
2008-10-26 22:58:34 +02:00
2023-07-11 14:16:02 +02:00
struct DLL_LINKAGE SetAvailableHero : public CPackForClient
2008-10-26 22:58:34 +02:00
{
2023-07-11 14:16:02 +02:00
SetAvailableHero ( )
2010-07-08 08:52:11 +03:00
{
2023-08-07 18:13:02 +02:00
army . clearSlots ( ) ;
2010-07-08 08:52:11 +03:00
}
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2023-07-11 22:08:30 +02:00
TavernHeroSlot slotID ;
TavernSlotRole roleID ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2023-07-12 11:29:05 +02:00
HeroTypeID hid ; //HeroTypeID::NONE if no hero
2023-07-11 14:16:02 +02:00
CSimpleArmy army ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-10-26 22:58:34 +02:00
{
2023-07-11 14:16:02 +02:00
h & slotID ;
2023-07-11 22:08:30 +02:00
h & roleID ;
2017-07-31 15:35:42 +02:00
h & player ;
h & hid ;
h & army ;
2008-10-26 22:58:34 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE GiveBonus : public CPackForClient
2009-02-03 07:28:05 +02:00
{
2023-03-28 13:57:44 +02:00
enum class ETarget : ui8 { HERO , PLAYER , TOWN , BATTLE } ;
2023-03-28 13:46:53 +02:00
GiveBonus ( ETarget Who = ETarget : : HERO )
2023-02-18 14:32:30 +02:00
: who ( Who )
2010-02-10 04:56:00 +02:00
{
}
2009-02-03 07:28:05 +02:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2023-03-28 13:46:53 +02:00
ETarget who = ETarget : : HERO ; //who receives bonus
2023-02-09 18:06:02 +02:00
si32 id = 0 ; //hero. town or player id - whoever receives it
2010-05-02 21:20:26 +03:00
Bonus bonus ;
2009-02-03 07:28:05 +02:00
MetaString bdescr ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-02-03 07:28:05 +02:00
{
2017-07-31 15:35:42 +02:00
h & bonus ;
h & id ;
h & bdescr ;
h & who ;
2023-02-12 09:23:39 +02:00
assert ( id ! = - 1 ) ;
2009-02-03 07:28:05 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE ChangeObjPos : public CPackForClient
2009-02-20 12:36:15 +02:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2009-02-20 12:36:15 +02:00
2023-06-20 22:09:11 +02:00
/// Object to move
2013-02-14 02:55:42 +03:00
ObjectInstanceID objid ;
2023-06-20 22:09:11 +02:00
/// New position of visitable tile of an object
2009-02-20 12:36:15 +02:00
int3 nPos ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-02-20 12:36:15 +02:00
{
2017-07-31 15:35:42 +02:00
h & objid ;
h & nPos ;
2009-02-20 12:36:15 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE PlayerEndsGame : public CPackForClient
2010-01-29 22:52:45 +02:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2010-01-29 22:52:45 +02:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2013-11-17 20:57:04 +03:00
EVictoryLossCheckResult victoryLossCheckResult ;
2010-01-29 22:52:45 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2010-01-29 22:52:45 +02:00
{
2017-07-31 15:35:42 +02:00
h & player ;
h & victoryLossCheckResult ;
2010-01-29 22:52:45 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE PlayerReinitInterface : public CPackForClient
2022-09-30 21:08:37 +02:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2022-10-04 23:54:31 +02:00
std : : vector < PlayerColor > players ;
2022-10-08 17:41:38 +02:00
ui8 playerConnectionId ; //PLAYER_AI for AI player
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2022-09-30 21:08:37 +02:00
{
2022-10-04 23:54:31 +02:00
h & players ;
2022-09-30 21:08:37 +02:00
h & playerConnectionId ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE RemoveBonus : public CPackForClient
2010-02-10 04:56:00 +02:00
{
2023-03-28 13:46:53 +02:00
RemoveBonus ( GiveBonus : : ETarget Who = GiveBonus : : ETarget : : HERO )
2023-02-18 14:32:30 +02:00
: who ( Who )
2010-02-10 04:56:00 +02:00
{
}
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2010-02-10 04:56:00 +02:00
2023-03-28 13:46:53 +02:00
GiveBonus : : ETarget who ; //who receives bonus
2023-02-09 18:06:02 +02:00
ui32 whoID = 0 ; //hero, town or player id - whoever loses bonus
2010-02-10 04:56:00 +02:00
//vars to identify bonus: its source
2023-02-09 18:06:02 +02:00
ui8 source = 0 ;
ui32 id = 0 ; //source id
2010-02-10 04:56:00 +02:00
//used locally: copy of removed bonus
2010-05-02 21:20:26 +03:00
Bonus bonus ;
2010-02-10 04:56:00 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2010-02-10 04:56:00 +02:00
{
2017-07-31 15:35:42 +02:00
h & source ;
h & id ;
h & who ;
h & whoID ;
2010-02-10 04:56:00 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetCommanderProperty : public CPackForClient
2012-05-07 15:54:22 +03:00
{
2023-02-12 09:23:39 +02:00
enum ECommanderProperty { ALIVE , BONUS , SECONDARY_SKILL , EXPERIENCE , SPECIAL_SKILL } ;
2012-05-07 15:54:22 +03:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2012-05-18 17:02:27 +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
ObjectInstanceID heroid ;
2012-05-07 15:54:22 +03:00
2023-02-09 18:06:02 +02:00
ECommanderProperty which = ALIVE ;
TExpType amount = 0 ; //0 for dead, >0 for alive
si32 additionalInfo = 0 ; //for secondary skills choice
2012-05-07 15:54:22 +03:00
Bonus accumulatedBonus ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2012-05-07 15:54:22 +03:00
{
2017-07-31 15:35:42 +02:00
h & heroid ;
h & which ;
h & amount ;
h & additionalInfo ;
h & accumulatedBonus ;
2012-05-07 15:54:22 +03:00
}
2012-05-16 20:29:05 +03:00
} ;
2016-11-18 16:45:59 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE AddQuest : public CPackForClient
2012-05-16 20:29:05 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2012-05-16 20:29:05 +03:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2012-05-16 20:29:05 +03:00
QuestInfo quest ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2012-05-16 20:29:05 +03:00
{
2017-07-31 15:35:42 +02:00
h & player ;
h & quest ;
2012-05-16 20:29:05 +03:00
}
} ;
2010-08-20 16:34:39 +03:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE UpdateArtHandlerLists : public CPackForClient
2013-02-19 01:37:22 +03:00
{
2023-02-12 09:23:39 +02:00
std : : vector < CArtifact * > treasures , minors , majors , relics ;
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2013-02-19 01:37:22 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2013-02-19 01:37:22 +03:00
{
2017-07-31 15:35:42 +02:00
h & treasures ;
h & minors ;
h & majors ;
h & relics ;
2013-02-19 01:37:22 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE UpdateMapEvents : public CPackForClient
2013-02-19 01:37:22 +03:00
{
std : : list < CMapEvent > events ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2013-02-19 01:37:22 +03:00
{
h & events ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE UpdateCastleEvents : public CPackForClient
2013-02-19 01:37:22 +03:00
{
ObjectInstanceID town ;
std : : list < CCastleEvent > events ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2013-02-19 01:37:22 +03:00
{
2017-07-31 15:35:42 +02:00
h & town ;
h & events ;
2013-02-19 01:37:22 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE ChangeFormation : public CPackForClient
2016-09-08 18:29:15 +02:00
{
ObjectInstanceID hid ;
2023-02-09 18:06:02 +02:00
ui8 formation = 0 ;
2016-09-08 18:29:15 +02:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2016-09-08 18:29:15 +02:00
{
2017-07-31 15:35:42 +02:00
h & hid ;
h & formation ;
2016-09-08 18:29:15 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE RemoveObject : public CPackForClient
2008-08-02 00:41:38 +03:00
{
2023-02-09 18:06:02 +02:00
RemoveObject ( ) = default ;
RemoveObject ( const ObjectInstanceID & ID )
: id ( ID )
2023-02-12 09:23:39 +02:00
{
}
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
2008-08-02 00:41:38 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-02 00:41:38 +03:00
{
h & id ;
}
2012-09-15 22:16:16 +03:00
} ;
2016-11-18 16:45:59 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE TryMoveHero : public CPackForClient
2008-07-28 15:44:08 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2008-07-28 15:44:08 +03:00
2009-07-03 22:57:14 +03:00
enum EResult
{
2023-02-09 18:06:02 +02:00
FAILED ,
SUCCESS ,
TELEPORTATION ,
BLOCKING_VISIT ,
EMBARK ,
DISEMBARK
2009-07-03 22:57:14 +03:00
} ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
2023-02-09 18:06:02 +02:00
ui32 movePoints = 0 ;
EResult result = FAILED ; //uses EResult
2010-03-21 00:17:19 +02:00
int3 start , end ; //h3m format
2023-04-16 00:48:49 +02:00
std : : unordered_set < int3 > fowRevealed ; //revealed tiles
2023-04-16 19:42:56 +02:00
std : : optional < int3 > attackedFrom ; // Set when stepping into endangered tile.
2008-07-28 15:44:08 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2017-09-16 09:42:27 +02:00
2023-02-12 09:23:39 +02:00
bool stopMovement ( ) const
{
return result ! = SUCCESS & & result ! = EMBARK & & result ! = DISEMBARK & & result ! = TELEPORTATION ;
}
template < typename Handler > void serialize ( Handler & h , const int version )
2008-07-28 15:44:08 +03:00
{
2017-07-31 15:35:42 +02:00
h & id ;
h & result ;
h & start ;
h & end ;
h & movePoints ;
h & fowRevealed ;
h & attackedFrom ;
2008-07-28 15:44:08 +03:00
}
2010-11-27 03:46:19 +02:00
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE NewStructures : public CPackForClient
2008-08-01 14:21:15 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid ;
2013-02-11 22:11:34 +03:00
std : : set < BuildingID > bid ;
2023-02-09 18:06:02 +02:00
si16 builded = 0 ;
2008-08-01 14:21:15 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-01 14:21:15 +03:00
{
2017-07-31 15:35:42 +02:00
h & tid ;
h & bid ;
h & builded ;
2008-08-01 14:21:15 +03:00
}
2009-09-22 17:27:46 +03:00
} ;
2016-11-18 16:45:59 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE RazeStructures : public CPackForClient
2009-09-22 17:27:46 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2009-09-22 17:27:46 +03:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid ;
2013-02-11 22:11:34 +03:00
std : : set < BuildingID > bid ;
2023-02-09 18:06:02 +02:00
si16 destroyed = 0 ;
2009-09-24 20:54:02 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-09-22 17:27:46 +03:00
{
2017-07-31 15:35:42 +02:00
h & tid ;
h & bid ;
h & destroyed ;
2009-09-22 17:27:46 +03:00
}
} ;
2016-11-18 16:45:59 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetAvailableCreatures : public CPackForClient
2008-08-01 14:21:15 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid ;
2013-02-11 02:24:57 +03:00
std : : vector < std : : pair < ui32 , std : : vector < CreatureID > > > creatures ;
2008-08-01 14:21:15 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-01 14:21:15 +03:00
{
2017-07-31 15:35:42 +02:00
h & tid ;
h & creatures ;
2008-08-10 07:46:16 +03:00
}
2012-09-15 22:16:16 +03:00
} ;
2016-11-18 16:45:59 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetHeroesInTown : public CPackForClient
2008-08-16 11:47:41 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid , visiting , garrison ; //id of town, visiting hero, hero in garrison
2008-08-16 11:47:41 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-16 11:47:41 +03:00
{
2017-07-31 15:35:42 +02:00
h & tid ;
h & visiting ;
h & garrison ;
2008-08-16 11:47:41 +03:00
}
2010-12-06 01:10:02 +02:00
} ;
2010-12-17 00:32:53 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE HeroRecruited : public CPackForClient
2008-10-26 22:58:34 +02:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2009-03-07 00:11:17 +02:00
2023-07-11 14:16:02 +02:00
HeroTypeID hid ; //subID of hero
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid ;
2023-06-08 09:17:08 +02:00
ObjectInstanceID boatId ;
2008-10-26 22:58:34 +02:00
int3 tile ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2008-10-26 22:58:34 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-10-26 22:58:34 +02:00
{
2017-07-31 15:35:42 +02:00
h & hid ;
h & tid ;
2023-06-08 09:17:08 +02:00
h & boatId ;
2017-07-31 15:35:42 +02:00
h & tile ;
h & player ;
2008-10-26 22:58:34 +02:00
}
2012-09-15 22:16:16 +03:00
} ;
2009-02-14 21:12:40 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE GiveHero : public CPackForClient
2009-02-14 21:12:40 +02:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //object id
2023-06-08 09:17:08 +02:00
ObjectInstanceID boatId ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-02-14 21:12:40 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-02-14 21:12:40 +02:00
{
2017-07-31 15:35:42 +02:00
h & id ;
2023-06-08 09:17:08 +02:00
h & boatId ;
2017-07-31 15:35:42 +02:00
h & player ;
2009-02-14 21:12:40 +02:00
}
2012-09-15 22:16:16 +03:00
} ;
2009-02-14 21:12:40 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE OpenWindow : public CPackForClient
2009-06-16 14:18:14 +03:00
{
2023-03-08 00:32:21 +02:00
EOpenWindowMode window ;
2023-02-09 18:06:02 +02:00
si32 id1 = - 1 ;
si32 id2 = - 1 ;
2009-06-16 14:18:14 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-06-16 14:18:14 +03:00
{
2017-07-31 15:35:42 +02:00
h & window ;
h & id1 ;
h & id2 ;
2009-06-16 14:18:14 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE NewObject : public CPackForClient
2009-07-26 06:33:13 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2009-07-26 06:33:13 +03:00
2023-06-20 21:06:45 +02:00
/// Object ID to create
2013-02-11 02:24:57 +03:00
Obj ID ;
2023-06-20 21:06:45 +02:00
/// Object secondary ID to create
2023-02-09 18:06:02 +02:00
ui32 subID = 0 ;
2023-06-20 21:06:45 +02:00
/// Position of visitable tile of created object
int3 targetPos ;
2009-07-26 06:33:13 +03:00
2023-06-20 21:06:45 +02:00
ObjectInstanceID createdObjectID ; //used locally, filled during applyGs
2009-07-26 06:33:13 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-07-26 06:33:13 +03:00
{
2017-07-31 15:35:42 +02:00
h & ID ;
h & subID ;
2023-06-20 21:06:45 +02:00
h & targetPos ;
2009-07-26 06:33:13 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetAvailableArtifacts : public CPackForClient
2010-06-26 19:02:10 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2010-06-26 19:02:10 +03:00
2023-02-09 18:06:02 +02:00
si32 id = 0 ; //two variants: id < 0: set artifact pool for Artifact Merchants in towns; id >= 0: set pool for adv. map Black Market (id is the id of Black Market instance then)
2010-06-26 19:02:10 +03:00
std : : vector < const CArtifact * > arts ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2010-06-26 19:02:10 +03:00
{
2017-07-31 15:35:42 +02:00
h & id ;
h & arts ;
2010-06-26 19:02:10 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE CGarrisonOperationPack : CPackForClient
2010-11-27 22:17:28 +02:00
{
} ;
2016-11-18 16:45:59 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE ChangeStackCount : CGarrisonOperationPack
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
ObjectInstanceID army ;
SlotID slot ;
2010-11-27 03:46:19 +02:00
TQuantity count ;
2018-03-10 23:19:36 +02:00
bool absoluteValue ; //if not -> count will be added (or subtracted if negative)
2010-11-27 03:46:19 +02:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2010-11-27 03:46:19 +02:00
2018-03-10 23:19:36 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
h & army ;
h & slot ;
2017-07-31 15:35:42 +02:00
h & count ;
h & absoluteValue ;
2010-11-27 03:46:19 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetStackType : CGarrisonOperationPack
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
ObjectInstanceID army ;
SlotID slot ;
CreatureID type ;
2010-11-27 03:46:19 +02:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2010-11-27 03:46:19 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
h & army ;
h & slot ;
2017-07-31 15:35:42 +02:00
h & type ;
2010-11-27 03:46:19 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE EraseStack : CGarrisonOperationPack
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
ObjectInstanceID army ;
SlotID slot ;
2010-11-27 03:46:19 +02:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2010-11-27 03:46:19 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
h & army ;
h & slot ;
2010-11-27 03:46:19 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SwapStacks : CGarrisonOperationPack
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
ObjectInstanceID srcArmy ;
ObjectInstanceID dstArmy ;
SlotID srcSlot ;
SlotID dstSlot ;
2010-11-27 03:46:19 +02:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2010-11-27 03:46:19 +02:00
2018-03-10 23:19:36 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
h & srcArmy ;
h & dstArmy ;
h & srcSlot ;
h & dstSlot ;
2010-11-27 03:46:19 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE InsertNewStack : CGarrisonOperationPack
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
ObjectInstanceID army ;
SlotID slot ;
CreatureID type ;
2023-02-09 18:06:02 +02:00
TQuantity count = 0 ;
2010-11-27 03:46:19 +02:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2018-03-10 23:19:36 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
h & army ;
h & slot ;
h & type ;
h & count ;
2010-11-27 03:46:19 +02:00
}
} ;
2016-11-18 16:45:59 +02:00
///moves creatures from src stack to dst slot, may be used for merging/splittint/moving stacks
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE RebalanceStacks : CGarrisonOperationPack
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
ObjectInstanceID srcArmy ;
ObjectInstanceID dstArmy ;
SlotID srcSlot ;
SlotID dstSlot ;
2010-11-27 03:46:19 +02:00
TQuantity count ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2010-11-27 03:46:19 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
h & srcArmy ;
h & dstArmy ;
h & srcSlot ;
h & dstSlot ;
2017-07-31 15:35:42 +02:00
h & count ;
2010-11-27 03:46:19 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BulkRebalanceStacks : CGarrisonOperationPack
2021-11-28 14:57:38 +02:00
{
std : : vector < RebalanceStacks > moves ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2021-11-28 14:57:38 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler >
2021-11-28 14:57:38 +02:00
void serialize ( Handler & h , const int version )
{
h & moves ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BulkSmartRebalanceStacks : CGarrisonOperationPack
2021-11-28 14:57:38 +02:00
{
std : : vector < RebalanceStacks > moves ;
std : : vector < ChangeStackCount > changes ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2021-11-28 14:57:38 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler >
2021-11-28 14:57:38 +02:00
void serialize ( Handler & h , const int version )
{
h & moves ;
h & changes ;
}
} ;
2023-04-16 23:24:11 +02:00
struct GetEngagedHeroIds
2013-06-01 01:23:53 +03:00
{
2023-04-16 19:42:56 +02:00
std : : optional < ObjectInstanceID > operator ( ) ( const ConstTransitivePtr < CGHeroInstance > & h ) const
2013-06-01 01:23:53 +03:00
{
return h - > id ;
}
2023-04-16 19:42:56 +02:00
std : : optional < ObjectInstanceID > operator ( ) ( const ConstTransitivePtr < CStackInstance > & s ) const
2013-06-01 01:23:53 +03:00
{
if ( s - > armyObj & & s - > armyObj - > ID = = Obj : : HERO )
return s - > armyObj - > id ;
2023-04-16 19:42:56 +02:00
return std : : optional < ObjectInstanceID > ( ) ;
2013-06-01 01:23:53 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE CArtifactOperationPack : CPackForClient
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
{
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE PutArtifact : CArtifactOperationPack
2010-12-17 00:32:53 +02:00
{
2023-04-08 00:54:19 +02:00
PutArtifact ( ) = default ;
PutArtifact ( ArtifactLocation * dst , bool askAssemble = true )
: al ( * dst ) , askAssemble ( askAssemble )
{
}
2010-12-17 00:32:53 +02:00
ArtifactLocation al ;
2023-04-08 00:54:19 +02:00
bool askAssemble = false ;
2010-12-26 16:34:11 +02:00
ConstTransitivePtr < CArtifactInstance > art ;
2010-12-17 00:32:53 +02:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2010-12-17 00:32:53 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-12-17 00:32:53 +02:00
{
2017-07-31 15:35:42 +02:00
h & al ;
2023-04-08 00:54:19 +02:00
h & askAssemble ;
2017-07-31 15:35:42 +02:00
h & art ;
2010-12-17 00:32:53 +02:00
}
} ;
2023-06-24 17:26:16 +02:00
struct DLL_LINKAGE NewArtifact : public CArtifactOperationPack
{
ConstTransitivePtr < CArtifactInstance > art ;
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & art ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE EraseArtifact : CArtifactOperationPack
2010-12-17 00:32:53 +02:00
{
ArtifactLocation al ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2010-12-17 00:32:53 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-12-17 00:32:53 +02:00
{
h & al ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE MoveArtifact : CArtifactOperationPack
2010-12-17 00:32:53 +02:00
{
2023-02-09 18:06:02 +02:00
MoveArtifact ( ) = default ;
2023-01-02 16:19:45 +02:00
MoveArtifact ( ArtifactLocation * src , ArtifactLocation * dst , bool askAssemble = true )
2023-02-09 18:06:02 +02:00
: src ( * src ) , dst ( * dst ) , askAssemble ( askAssemble )
2023-02-12 09:23:39 +02:00
{
}
2010-12-17 00:32:53 +02:00
ArtifactLocation src , dst ;
2023-02-09 18:06:02 +02:00
bool askAssemble = true ;
2010-12-17 00:32:53 +02:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2010-12-17 00:32:53 +02:00
2022-11-06 23:54:50 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-12-17 00:32:53 +02:00
{
2017-07-31 15:35:42 +02:00
h & src ;
h & dst ;
2023-01-02 16:19:45 +02:00
h & askAssemble ;
2010-12-17 00:32:53 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BulkMoveArtifacts : CArtifactOperationPack
2022-11-06 23:29:22 +02:00
{
2022-11-07 14:13:36 +02:00
struct LinkedSlots
2022-11-06 23:29:22 +02:00
{
2022-11-07 14:13:36 +02:00
ArtifactPosition srcPos ;
ArtifactPosition dstPos ;
2023-02-09 18:06:02 +02:00
LinkedSlots ( ) = default ;
LinkedSlots ( const ArtifactPosition & srcPos , const ArtifactPosition & dstPos )
: srcPos ( srcPos )
, dstPos ( dstPos )
{
}
2022-11-06 23:29:22 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2022-11-07 14:13:36 +02:00
h & srcPos ;
h & dstPos ;
2022-11-06 23:29:22 +02:00
}
} ;
2022-11-07 14:13:36 +02:00
TArtHolder srcArtHolder ;
TArtHolder dstArtHolder ;
2022-11-10 20:48:19 +02:00
BulkMoveArtifacts ( )
2023-02-12 09:23:39 +02:00
: swap ( false )
{
}
2022-11-10 20:48:19 +02:00
BulkMoveArtifacts ( TArtHolder srcArtHolder , TArtHolder dstArtHolder , bool swap )
2023-02-09 18:06:02 +02:00
: srcArtHolder ( std : : move ( std : : move ( srcArtHolder ) ) )
, dstArtHolder ( std : : move ( std : : move ( dstArtHolder ) ) )
, swap ( swap )
{
}
2022-11-06 23:29:22 +02:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2022-11-06 23:29:22 +02:00
2022-11-07 14:13:36 +02:00
std : : vector < LinkedSlots > artsPack0 ;
2022-11-07 14:20:28 +02:00
std : : vector < LinkedSlots > artsPack1 ;
bool swap ;
2022-11-07 14:13:36 +02:00
CArtifactSet * getSrcHolderArtSet ( ) ;
CArtifactSet * getDstHolderArtSet ( ) ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2022-11-06 23:29:22 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & artsPack0 ;
h & artsPack1 ;
2022-11-07 14:13:36 +02:00
h & srcArtHolder ;
h & dstArtHolder ;
2022-11-07 14:20:28 +02:00
h & swap ;
2022-11-06 23:29:22 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE AssembledArtifact : CArtifactOperationPack
2011-01-22 05:43:20 +02:00
{
ArtifactLocation al ; //where assembly will be put
2023-02-12 09:23:39 +02:00
CArtifact * builtArt ;
2011-01-22 05:43:20 +02:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2011-01-22 05:43:20 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2011-01-22 05:43:20 +02:00
{
2017-07-31 15:35:42 +02:00
h & al ;
h & builtArt ;
2011-01-22 05:43:20 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE DisassembledArtifact : CArtifactOperationPack
2011-01-22 05:43:20 +02:00
{
ArtifactLocation al ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2011-01-22 05:43:20 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2011-01-22 05:43:20 +02:00
{
h & al ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE HeroVisit : public CPackForClient
2011-05-10 01:20:47 +03:00
{
2018-03-10 21:19:55 +02:00
PlayerColor player ;
ObjectInstanceID heroId ;
ObjectInstanceID objId ;
2011-05-10 01:20:47 +03:00
bool starting ; //false -> ending
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2011-05-10 01:20:47 +03:00
2018-03-10 21:19:55 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2011-05-10 01:20:47 +03:00
{
2017-07-31 15:35:42 +02:00
h & player ;
2018-03-10 21:19:55 +02:00
h & heroId ;
h & objId ;
2017-07-31 15:35:42 +02:00
h & starting ;
2011-05-10 01:20:47 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE NewTurn : public CPackForClient
2008-08-10 07:46:16 +03:00
{
2023-02-12 09:23:39 +02:00
enum weekType { NORMAL , DOUBLE_GROWTH , BONUS_GROWTH , DEITYOFFIRE , PLAGUE , NO_ACTION } ;
void applyGs ( CGameState * gs ) ;
2010-08-22 21:21:45 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-03-07 00:11:17 +02:00
2008-08-10 07:46:16 +03:00
struct Hero
{
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
ui32 move , mana ; //id is a general serial id
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-10 07:46:16 +03:00
{
2017-07-31 15:35:42 +02:00
h & id ;
h & move ;
h & mana ;
2008-08-10 07:46:16 +03:00
}
2023-02-12 09:23:39 +02:00
bool operator < ( const Hero & h ) const { return id < h . id ; }
2008-08-10 07:46:16 +03:00
} ;
std : : set < Hero > heroes ; //updates movement and mana points
2013-03-03 20:06:03 +03:00
std : : map < PlayerColor , TResources > res ; //player ID => resource value[res_id]
2013-03-14 23:44:00 +03:00
std : : map < ObjectInstanceID , SetAvailableCreatures > cres ; //creatures to be placed in towns
2023-02-09 18:06:02 +02:00
ui32 day = 0 ;
ui8 specialWeek = 0 ; //weekType
2013-02-11 02:24:57 +03:00
CreatureID creatureid ; //for creature weeks
2008-08-10 07:46:16 +03:00
2023-02-09 18:06:02 +02:00
NewTurn ( ) = default ;
2008-08-10 07:46:16 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-10 07:46:16 +03:00
{
2017-07-31 15:35:42 +02:00
h & heroes ;
h & cres ;
h & res ;
h & day ;
h & specialWeek ;
h & creatureid ;
2008-08-01 14:21:15 +03:00
}
2012-09-15 22:16:16 +03:00
} ;
2009-03-07 00:11:17 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE InfoWindow : public CPackForClient //103 - displays simple info window
2008-07-31 00:27:15 +03:00
{
2023-03-06 01:30:21 +02:00
EInfoWindowMode type = EInfoWindowMode : : MODAL ;
2008-07-31 00:27:15 +03:00
MetaString text ;
std : : vector < Component > components ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2023-02-09 18:06:02 +02:00
ui16 soundID = 0 ;
2008-07-31 00:27:15 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-07-31 00:27:15 +03:00
{
2023-03-06 01:30:21 +02:00
h & type ;
2017-07-31 15:35:42 +02:00
h & text ;
h & components ;
h & player ;
h & soundID ;
2008-07-31 00:27:15 +03:00
}
2023-02-09 18:06:02 +02:00
InfoWindow ( ) = default ;
2008-07-30 20:51:19 +03:00
} ;
2010-05-02 21:20:26 +03:00
namespace ObjProperty
{
2023-02-12 09:23:39 +02:00
enum
{
OWNER = 1 , BLOCKVIS = 2 , PRIMARY_STACK_COUNT = 3 , VISITORS = 4 , VISITED = 5 , ID = 6 , AVAILABLE_CREATURE = 7 , SUBID = 8 ,
2013-04-20 14:34:01 +03:00
MONSTER_COUNT = 10 , MONSTER_POWER = 11 , MONSTER_EXP = 12 , MONSTER_RESTORE_TYPE = 13 , MONSTER_REFUSED_JOIN ,
2016-08-30 04:13:45 +02:00
2013-02-14 16:19:03 +03:00
//town-specific
STRUCTURE_ADD_VISITING_HERO , STRUCTURE_CLEAR_VISITORS , STRUCTURE_ADD_GARRISONED_HERO , //changing buildings state
2013-02-19 01:37:22 +03:00
BONUS_VALUE_FIRST , BONUS_VALUE_SECOND , //used in Rampart for special building that generates resources (storing resource type and quantity)
2013-02-14 16:19:03 +03:00
2013-02-19 01:37:22 +03:00
//creature-bank specific
2014-06-22 13:39:40 +03:00
BANK_DAYCOUNTER , BANK_RESET , BANK_CLEAR ,
2013-09-17 15:02:33 +03:00
2014-04-07 20:32:15 +03:00
//object with reward
2023-01-24 23:31:07 +02:00
REWARD_RANDOMIZE , REWARD_SELECT , REWARD_CLEARED
2013-02-14 16:19:03 +03:00
} ;
2010-05-02 21:20:26 +03:00
}
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetObjectProperty : public CPackForClient
2008-07-30 20:51:19 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
2023-02-09 18:06:02 +02:00
ui8 what = 0 ; // see ObjProperty enum
ui32 val = 0 ;
SetObjectProperty ( ) = default ;
SetObjectProperty ( const ObjectInstanceID & ID , ui8 What , ui32 Val )
: id ( ID )
, what ( What )
, val ( Val )
2023-02-12 09:23:39 +02:00
{
}
2012-09-15 22:16:16 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-07-30 20:51:19 +03:00
{
2017-07-31 15:35:42 +02:00
h & id ;
h & what ;
h & val ;
2008-07-30 20:51:19 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE ChangeObjectVisitors : public CPackForClient
2014-04-07 20:32:15 +03:00
{
enum VisitMode
{
2016-09-20 22:05:44 +02:00
VISITOR_ADD , // mark hero as one that have visited this object
VISITOR_ADD_TEAM , // mark team as one that have visited this object
VISITOR_REMOVE , // unmark visitor, reversed to ADD
VISITOR_CLEAR // clear all visitors from this object (object reset)
2014-04-07 20:32:15 +03:00
} ;
2023-02-09 18:06:02 +02:00
ui32 mode = VISITOR_CLEAR ; // uses VisitMode enum
2014-04-07 20:32:15 +03:00
ObjectInstanceID object ;
ObjectInstanceID hero ; // note: hero owner will be also marked as "visited" this object
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2014-04-07 20:32:15 +03:00
2023-02-09 18:06:02 +02:00
ChangeObjectVisitors ( ) = default ;
2014-04-11 22:49:25 +03:00
2023-02-09 18:06:02 +02:00
ChangeObjectVisitors ( ui32 mode , const ObjectInstanceID & object , const ObjectInstanceID & heroID = ObjectInstanceID ( - 1 ) )
: mode ( mode )
, object ( object )
, hero ( heroID )
2023-02-12 09:23:39 +02:00
{
}
2014-04-07 20:32:15 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2014-04-07 20:32:15 +03:00
{
2017-07-31 15:35:42 +02:00
h & object ;
h & hero ;
h & mode ;
2014-04-07 20:32:15 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE PrepareHeroLevelUp : public CPackForClient
2016-09-07 23:24:05 +02:00
{
2018-03-10 21:19:55 +02:00
ObjectInstanceID heroId ;
2016-09-07 23:24:05 +02:00
/// Do not serialize, used by server only
std : : vector < SecondarySkill > skills ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2016-09-07 23:24:05 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2016-09-07 23:24:05 +02:00
{
2018-03-10 21:19:55 +02:00
h & heroId ;
2016-09-07 23:24:05 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE HeroLevelUp : public Query
2008-08-04 18:56:36 +03:00
{
2018-03-10 21:19:55 +02:00
PlayerColor player ;
ObjectInstanceID heroId ;
2009-03-07 00:11:17 +02:00
2023-02-09 18:06:02 +02:00
PrimarySkill : : PrimarySkill primskill = PrimarySkill : : ATTACK ;
2013-02-12 22:49:40 +03:00
std : : vector < SecondarySkill > skills ;
2008-08-04 18:56:36 +03:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2018-03-10 21:19:55 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-04 18:56:36 +03:00
{
2017-07-31 15:35:42 +02:00
h & queryID ;
2018-03-10 21:19:55 +02:00
h & player ;
h & heroId ;
2017-07-31 15:35:42 +02:00
h & primskill ;
h & skills ;
2008-08-04 18:56:36 +03:00
}
} ;
2008-08-13 03:44:31 +03:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE CommanderLevelUp : public Query
2012-05-07 15:54:22 +03:00
{
2018-03-10 21:19:55 +02:00
PlayerColor player ;
ObjectInstanceID heroId ;
2012-05-18 17:02:27 +03:00
2012-07-03 11:07:34 +03:00
std : : vector < ui32 > skills ; //0-5 - secondary skills, val-100 - special skill
2012-05-07 15:54:22 +03:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2018-03-10 21:19:55 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2012-05-07 15:54:22 +03:00
{
2017-07-31 15:35:42 +02:00
h & queryID ;
2018-03-10 21:19:55 +02:00
h & player ;
h & heroId ;
2017-07-31 15:35:42 +02:00
h & skills ;
2012-05-07 15:54:22 +03:00
}
} ;
2009-04-11 04:32:50 +03:00
//A dialog that requires making decision by player - it may contain components to choose between or has yes/no options
//Client responds with QueryReply, where answer: 0 - cancel pressed, choice doesn't matter; 1/2/... - first/second/... component selected and OK pressed
//Until sending reply player won't be allowed to take any actions
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BlockingDialog : public Query
2008-08-13 03:44:31 +03:00
{
2023-02-12 09:23:39 +02:00
enum { ALLOW_CANCEL = 1 , SELECTION = 2 } ;
2008-08-13 03:44:31 +03:00
MetaString text ;
std : : vector < Component > components ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2023-02-09 18:06:02 +02:00
ui8 flags = 0 ;
ui16 soundID = 0 ;
2008-08-13 03:44:31 +03:00
2009-04-11 04:32:50 +03:00
bool cancel ( ) const
2008-08-13 03:44:31 +03:00
{
2009-04-11 04:32:50 +03:00
return flags & ALLOW_CANCEL ;
}
bool selection ( ) const
{
return flags & SELECTION ;
2008-08-13 03:44:31 +03:00
}
2008-08-22 15:21:09 +03:00
2009-04-11 04:32:50 +03:00
BlockingDialog ( bool yesno , bool Selection )
{
if ( yesno ) flags | = ALLOW_CANCEL ;
if ( Selection ) flags | = SELECTION ;
}
2023-02-09 18:06:02 +02:00
BlockingDialog ( ) = default ;
2008-08-22 15:21:09 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-22 15:21:09 +03:00
{
2017-07-31 15:35:42 +02:00
h & queryID ;
h & text ;
h & components ;
h & player ;
h & flags ;
h & soundID ;
2008-08-22 15:21:09 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE GarrisonDialog : public Query
2009-04-12 03:58:41 +03:00
{
2013-02-14 02:55:42 +03:00
ObjectInstanceID objid , hid ;
2023-02-09 18:06:02 +02:00
bool removableUnits = false ;
2009-04-12 03:58:41 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-04-12 03:58:41 +03:00
{
2017-07-31 15:35:42 +02:00
h & queryID ;
h & objid ;
h & hid ;
h & removableUnits ;
2009-04-12 03:58:41 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE ExchangeDialog : public Query
2013-05-27 13:53:28 +03:00
{
2018-03-10 21:19:55 +02:00
PlayerColor player ;
ObjectInstanceID hero1 ;
ObjectInstanceID hero2 ;
2013-05-27 13:53:28 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2013-05-27 13:53:28 +03:00
{
2017-07-31 15:35:42 +02:00
h & queryID ;
2018-03-10 21:19:55 +02:00
h & player ;
h & hero1 ;
h & hero2 ;
2013-05-27 13:53:28 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE TeleportDialog : public Query
2015-03-08 15:37:33 +02:00
{
2023-02-09 18:06:02 +02:00
TeleportDialog ( ) = default ;
2016-11-26 19:49:26 +02:00
2023-02-09 18:06:02 +02:00
TeleportDialog ( const PlayerColor & Player , const TeleportChannelID & Channel )
: player ( Player )
, channel ( Channel )
2023-02-12 09:23:39 +02:00
{
}
2018-03-10 21:19:55 +02:00
PlayerColor player ;
2015-03-08 15:37:33 +02:00
TeleportChannelID channel ;
2015-11-28 01:41:30 +02:00
TTeleportExitsList exits ;
2023-02-09 18:06:02 +02:00
bool impassable = false ;
2015-03-08 15:37:33 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2015-03-08 15:37:33 +02:00
{
2017-07-31 15:35:42 +02:00
h & queryID ;
2018-03-10 21:19:55 +02:00
h & player ;
2017-07-31 15:35:42 +02:00
h & channel ;
h & exits ;
h & impassable ;
2015-03-08 15:37:33 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE MapObjectSelectDialog : public Query
2017-06-06 06:53:51 +02:00
{
PlayerColor player ;
Component icon ;
MetaString title ;
MetaString description ;
std : : vector < ObjectInstanceID > objects ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2017-06-06 06:53:51 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & queryID ;
h & player ;
h & icon ;
h & title ;
h & description ;
h & objects ;
2017-06-06 06:53:51 +02:00
}
} ;
2017-07-20 06:08:49 +02:00
class BattleInfo ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleStart : public CPackForClient
2008-08-04 18:56:36 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2008-08-04 18:56:36 +03:00
2023-02-09 18:06:02 +02:00
BattleInfo * info = nullptr ;
2012-09-15 22:16:16 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-04 18:56:36 +03:00
{
h & info ;
}
} ;
2016-11-26 19:49:26 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleNextRound : public CPackForClient
2012-09-15 22:16:16 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2023-02-09 18:06:02 +02:00
si32 round = 0 ;
2008-08-04 18:56:36 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-04 18:56:36 +03:00
{
h & round ;
}
} ;
2016-11-26 19:49:26 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleSetActiveStack : public CPackForClient
2008-08-04 18:56:36 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2009-03-07 00:11:17 +02:00
2023-02-09 18:06:02 +02:00
ui32 stack = 0 ;
ui8 askPlayerInterface = true ;
2008-08-04 18:56:36 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-04 18:56:36 +03:00
{
2017-07-31 15:35:42 +02:00
h & stack ;
h & askPlayerInterface ;
2008-08-04 18:56:36 +03:00
}
} ;
2016-11-26 19:49:26 +02:00
2023-04-06 17:34:07 +02:00
struct DLL_LINKAGE BattleResultAccepted : public CPackForClient
{
void applyGs ( CGameState * gs ) const ;
2023-06-30 17:59:45 +02:00
struct HeroBattleResults
2023-04-06 17:34:07 +02:00
{
2023-06-30 17:59:45 +02:00
HeroBattleResults ( )
: hero ( nullptr ) , army ( nullptr ) , exp ( 0 ) { }
CGHeroInstance * hero ;
CArmedInstance * army ;
TExpType exp ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & hero ;
h & army ;
h & exp ;
}
} ;
std : : array < HeroBattleResults , 2 > heroResult ;
ui8 winnerSide ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & heroResult ;
h & winnerSide ;
2023-04-06 17:34:07 +02:00
}
} ;
struct DLL_LINKAGE BattleResult : public Query
2008-08-04 18:56:36 +03:00
{
2023-02-12 09:23:39 +02:00
enum EResult { NORMAL = 0 , ESCAPE = 1 , SURRENDER = 2 } ;
2012-05-01 11:52:22 +03:00
2023-02-12 09:23:39 +02:00
void applyFirstCl ( CClient * cl ) ;
2009-03-07 00:11:17 +02:00
2023-02-09 18:06:02 +02:00
EResult result = NORMAL ;
ui8 winner = 2 ; //0 - attacker, 1 - defender, [2 - draw (should be possible?)]
2023-02-12 09:23:39 +02:00
std : : map < ui32 , si32 > casualties [ 2 ] ; //first => casualties of attackers - map crid => number
2023-02-09 18:06:02 +02:00
TExpType exp [ 2 ] = { 0 , 0 } ; //exp for attacker and defender
2013-02-14 02:55:42 +03:00
std : : set < ArtifactInstanceID > artifacts ; //artifacts taken from loser to winner - currently unused
2008-08-04 18:56:36 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-04 18:56:36 +03:00
{
2023-04-06 17:34:07 +02:00
h & queryID ;
2017-07-31 15:35:42 +02:00
h & result ;
h & winner ;
h & casualties [ 0 ] ;
h & casualties [ 1 ] ;
h & exp ;
h & artifacts ;
2008-08-04 18:56:36 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleLogMessage : public CPackForClient
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
{
std : : vector < MetaString > lines ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
void applyBattle ( IBattleState * battleState ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
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
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & lines ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleStackMoved : public CPackForClient
2008-08-05 02:04:15 +03:00
{
2023-02-09 18:06:02 +02:00
ui32 stack = 0 ;
2011-12-22 16:05:19 +03:00
std : : vector < BattleHex > tilesToMove ;
2023-02-09 18:06:02 +02:00
int distance = 0 ;
bool teleporting = false ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
void applyBattle ( IBattleState * battleState ) ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-05 02:04:15 +03:00
{
2017-07-31 15:35:42 +02:00
h & stack ;
h & tilesToMove ;
h & distance ;
2022-12-18 18:26:43 +02:00
h & teleporting ;
2008-08-05 02:04:15 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleUnitsChanged : public CPackForClient
2010-05-07 15:29:41 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
void applyBattle ( IBattleState * battleState ) ;
2010-05-07 15:29:41 +03:00
2017-07-20 06:08:49 +02:00
std : : vector < UnitChanges > changedStacks ;
2010-05-07 15:29:41 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2017-07-20 06:08:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-05-07 15:29:41 +03:00
{
2017-07-20 06:08:49 +02:00
h & changedStacks ;
2010-05-07 15:29:41 +03:00
}
} ;
2017-07-20 06:08:49 +02:00
struct BattleStackAttacked
2008-08-09 02:02:32 +03:00
{
2023-02-12 09:23:39 +02:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2017-07-20 06:08:49 +02:00
DLL_LINKAGE void applyBattle ( IBattleState * battleState ) ;
2009-03-07 00:11:17 +02:00
2023-02-09 18:06:02 +02:00
ui32 stackAttacked = 0 , attackerID = 0 ;
ui32 killedAmount = 0 ;
int64_t damageAmount = 0 ;
2017-07-20 06:08:49 +02:00
UnitChanges newState ;
2023-02-12 09:23:39 +02:00
enum EFlags { KILLED = 1 , SECONDARY = 2 , REBIRTH = 4 , CLONE_KILLED = 8 , SPELL_EFFECT = 16 , FIRE_SHIELD = 32 , } ;
2023-02-09 18:06:02 +02:00
ui32 flags = 0 ; //uses EFlags (above)
SpellID spellID = SpellID : : NONE ; //only if flag SPELL_EFFECT is set
2008-08-09 02:02:32 +03:00
2009-03-24 23:28:17 +02:00
bool killed ( ) const //if target stack was killed
2008-08-09 02:02:32 +03:00
{
2012-02-18 20:39:47 +03:00
return flags & KILLED | | flags & CLONE_KILLED ;
}
bool cloneKilled ( ) const
{
return flags & CLONE_KILLED ;
2008-08-09 02:02:32 +03:00
}
2011-07-02 19:49:22 +03:00
bool isSecondary ( ) const //if stack was not a primary target (receives no spell effects)
{
return flags & SECONDARY ;
}
2014-11-27 23:36:14 +02:00
///Attacked with spell (SPELL_LIKE_ATTACK)
bool isSpell ( ) const
{
return flags & SPELL_EFFECT ;
}
2013-08-09 20:37:41 +03:00
bool willRebirth ( ) const //resurrection, e.g. Phoenix
2011-07-08 17:54:20 +03:00
{
return flags & REBIRTH ;
}
2022-12-17 17:35:15 +02:00
bool fireShield ( ) const
{
return flags & FIRE_SHIELD ;
}
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-09 02:02:32 +03:00
{
2017-07-31 15:35:42 +02:00
h & stackAttacked ;
h & attackerID ;
2017-07-20 06:08:49 +02:00
h & newState ;
2017-07-31 15:35:42 +02:00
h & flags ;
h & killedAmount ;
h & damageAmount ;
2014-11-27 23:36:14 +02:00
h & spellID ;
2008-08-09 02:02:32 +03:00
}
2023-02-12 09:23:39 +02:00
bool operator < ( const BattleStackAttacked & b ) const
2009-03-21 14:49:58 +02:00
{
return stackAttacked < b . stackAttacked ;
}
2008-08-09 02:02:32 +03:00
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleAttack : public CPackForClient
2008-08-09 02:02:32 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
2017-07-20 06:08:49 +02:00
BattleUnitsChanged attackerChanges ;
2010-02-20 15:24:38 +02:00
std : : vector < BattleStackAttacked > bsa ;
2023-02-09 18:06:02 +02:00
ui32 stackAttacking = 0 ;
ui32 flags = 0 ; //uses Eflags (below)
2023-02-12 09:23:39 +02:00
enum EFlags { SHOT = 1 , COUNTER = 2 , LUCKY = 4 , UNLUCKY = 8 , BALLISTA_DOUBLE_DMG = 16 , DEATH_BLOW = 32 , SPELL_LIKE = 64 , LIFE_DRAIN = 128 } ;
2016-08-30 04:13:45 +02:00
2022-12-11 12:29:11 +02:00
BattleHex tile ;
2023-02-09 18:06:02 +02:00
SpellID spellID = SpellID : : NONE ; //for SPELL_LIKE
2008-08-09 02:02:32 +03:00
2010-12-04 21:44:23 +02:00
bool shot ( ) const //distance attack - decrease number of shots
2008-08-09 02:02:32 +03:00
{
2011-02-24 17:33:03 +02:00
return flags & SHOT ;
2008-08-09 02:02:32 +03:00
}
2010-12-04 21:44:23 +02:00
bool counter ( ) const //is it counterattack?
2008-09-12 11:51:46 +03:00
{
2011-02-24 17:33:03 +02:00
return flags & COUNTER ;
2008-09-12 11:51:46 +03:00
}
2010-12-04 21:44:23 +02:00
bool lucky ( ) const
2009-03-21 14:49:58 +02:00
{
2011-02-24 17:33:03 +02:00
return flags & LUCKY ;
2009-03-21 14:49:58 +02:00
}
2010-12-04 21:44:23 +02:00
bool unlucky ( ) const
2008-08-09 02:02:32 +03:00
{
2011-02-24 17:33:03 +02:00
return flags & UNLUCKY ;
}
bool ballistaDoubleDmg ( ) const //if it's ballista attack and does double dmg
{
return flags & BALLISTA_DOUBLE_DMG ;
2008-08-09 02:02:32 +03:00
}
2011-07-06 20:00:45 +03:00
bool deathBlow ( ) const
{
return flags & DEATH_BLOW ;
}
2014-11-27 23:36:14 +02:00
bool spellLike ( ) const
{
return flags & SPELL_LIKE ;
}
2022-12-11 12:29:11 +02:00
bool lifeDrain ( ) const
{
return flags & LIFE_DRAIN ;
}
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-08-09 02:02:32 +03:00
{
2017-07-31 15:35:42 +02:00
h & bsa ;
h & stackAttacking ;
h & flags ;
2022-12-11 12:29:11 +02:00
h & tile ;
2017-07-31 15:35:42 +02:00
h & spellID ;
2017-07-20 06:08:49 +02:00
h & attackerChanges ;
2008-08-09 02:02:32 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE StartAction : public CPackForClient
2008-09-29 00:01:49 +03:00
{
2023-02-09 18:06:02 +02:00
StartAction ( ) = default ;
StartAction ( BattleAction act )
: ba ( std : : move ( act ) )
2023-02-12 09:23:39 +02:00
{
}
void applyFirstCl ( CClient * cl ) ;
void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
BattleAction ba ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-09-29 00:01:49 +03:00
{
h & ba ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE EndAction : public CPackForClient
2008-10-18 14:41:24 +03:00
{
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-03-07 00:25:19 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-07 00:11:17 +02:00
{
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleSpellCast : public CPackForClient
2008-10-18 14:41:24 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2023-02-09 18:06:02 +02:00
bool activeCast = true ;
ui8 side = 0 ; //which hero did cast spell: 0 - attacker, 1 - defender
2017-07-20 06:08:49 +02:00
SpellID spellID ; //id of spell
2023-02-09 18:06:02 +02:00
ui8 manaGained = 0 ; //mana channeling ability
2011-12-22 16:05:19 +03:00
BattleHex tile ; //destination tile (may not be set in some global/mass spells
2009-08-04 20:05:49 +03:00
std : : set < ui32 > affectedCres ; //ids of creatures affected by this spell, generally used if spell does not set any effect (like dispel or cure)
2022-12-17 17:35:15 +02:00
std : : set < ui32 > resistedCres ; // creatures that resisted the spell (e.g. Dwarves)
std : : set < ui32 > reflectedCres ; // creatures that reflected the spell (e.g. Magic Mirror spell)
2023-02-09 18:06:02 +02:00
si32 casterStack = - 1 ; // -1 if not cated by creature, >=0 caster stack ID
bool castByHero = true ; //if true - spell has been cast by hero, otherwise by a creature
2016-09-10 17:23:55 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2008-10-18 14:41:24 +03:00
{
2017-07-31 15:35:42 +02:00
h & side ;
2017-07-20 06:08:49 +02:00
h & spellID ;
2017-07-31 15:35:42 +02:00
h & manaGained ;
h & tile ;
h & affectedCres ;
2022-12-17 17:35:15 +02:00
h & resistedCres ;
h & reflectedCres ;
2017-07-31 15:35:42 +02:00
h & casterStack ;
h & castByHero ;
2017-09-08 13:25:12 +02:00
h & activeCast ;
2008-10-18 14:41:24 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetStackEffect : public CPackForClient
2008-11-09 00:29:19 +02:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
void applyBattle ( IBattleState * battleState ) ;
2017-07-20 06:08:49 +02:00
std : : vector < std : : pair < ui32 , std : : vector < Bonus > > > toAdd ;
std : : vector < std : : pair < ui32 , std : : vector < Bonus > > > toUpdate ;
std : : vector < std : : pair < ui32 , std : : vector < Bonus > > > toRemove ;
2016-11-02 19:11:01 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2017-07-20 06:08:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2008-11-09 00:29:19 +02:00
{
2017-07-20 06:08:49 +02:00
h & toAdd ;
h & toUpdate ;
h & toRemove ;
2008-11-09 00:29:19 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE StacksInjured : public CPackForClient
2009-04-16 03:28:54 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
void applyBattle ( IBattleState * battleState ) ;
2009-04-16 03:28:54 +03:00
2010-02-20 15:24:38 +02:00
std : : vector < BattleStackAttacked > stacks ;
2017-07-20 06:08:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2017-07-20 06:08:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2009-04-16 03:28:54 +03:00
{
h & stacks ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleResultsApplied : public CPackForClient
2009-08-04 02:53:18 +03:00
{
2013-03-03 20:06:03 +03:00
PlayerColor player1 , player2 ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-08-04 02:53:18 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2009-08-04 02:53:18 +03:00
{
2017-07-31 15:35:42 +02:00
h & player1 ;
h & player2 ;
2009-08-04 02:53:18 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleObstaclesChanged : public CPackForClient
2009-08-19 13:59:42 +03:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
void applyBattle ( IBattleState * battleState ) ;
2009-08-19 13:59:42 +03:00
2017-07-20 06:08:49 +02:00
std : : vector < ObstacleChanges > changes ;
2009-08-19 13:59:42 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2017-07-20 06:08:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2009-08-19 13:59:42 +03:00
{
2017-07-20 06:08:49 +02:00
h & changes ;
2009-08-19 13:59:42 +03:00
}
2009-09-01 16:54:13 +03:00
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE CatapultAttack : public CPackForClient
2009-09-01 16:54:13 +03:00
{
2013-08-06 14:20:28 +03:00
struct AttackInfo
{
si16 destinationTile ;
2023-01-13 00:35:58 +02:00
EWallPart attackedPart ;
2013-08-06 14:20:28 +03:00
ui8 damageDealt ;
2017-07-20 06:08:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2013-08-06 14:20:28 +03:00
{
2017-07-31 15:35:42 +02:00
h & destinationTile ;
h & attackedPart ;
h & damageDealt ;
2013-08-06 14:20:28 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
CatapultAttack ( ) ;
~ CatapultAttack ( ) override ;
2009-09-01 16:54:13 +03:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) ;
void applyBattle ( IBattleState * battleState ) ;
2009-09-01 16:54:13 +03:00
2013-08-06 14:20:28 +03:00
std : : vector < AttackInfo > attackedParts ;
2023-02-09 18:06:02 +02:00
int attacker = - 1 ; //if -1, then a spell caused this
2009-09-01 16:54:13 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-09-01 16:54:13 +03:00
{
2017-07-31 15:35:42 +02:00
h & attackedParts ;
h & attacker ;
2009-09-01 16:54:13 +03:00
}
2009-09-05 17:10:26 +03:00
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleSetStackProperty : public CPackForClient
2011-10-02 16:59:12 +03:00
{
2023-02-12 09:23:39 +02:00
enum BattleStackProperty { CASTS , ENCHANTER_COUNTER , UNBIND , CLONED , HAS_CLONE } ;
2011-10-02 16:59:12 +03:00
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2011-10-02 16:59:12 +03:00
2023-02-09 18:06:02 +02:00
int stackID = 0 ;
BattleStackProperty which = CASTS ;
int val = 0 ;
int absolute = 0 ;
2011-10-02 16:59:12 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2011-10-02 16:59:12 +03:00
{
2017-07-31 15:35:42 +02:00
h & stackID ;
h & which ;
h & val ;
h & absolute ;
2011-10-02 16:59:12 +03:00
}
2023-02-12 09:23:39 +02:00
protected :
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2011-10-02 16:59:12 +03:00
} ;
2016-11-26 19:49:26 +02:00
///activated at the beginning of turn
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleTriggerEffect : public CPackForClient
2016-11-26 19:49:26 +02:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ; //effect
2011-10-08 16:02:58 +03:00
2023-02-09 18:06:02 +02:00
int stackID = 0 ;
int effect = 0 ; //use corresponding Bonus type
int val = 0 ;
int additionalInfo = 0 ;
2011-10-08 16:02:58 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2011-10-08 16:02:58 +03:00
{
2017-07-31 15:35:42 +02:00
h & stackID ;
h & effect ;
h & val ;
h & additionalInfo ;
2011-10-08 16:02:58 +03:00
}
2023-02-12 09:23:39 +02:00
protected :
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2011-10-08 16:02:58 +03:00
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BattleUpdateGateState : public CPackForClient
2016-01-29 21:35:11 +02:00
{
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) const ;
2016-01-29 21:35:11 +02:00
2023-02-09 18:06:02 +02:00
EGateState state = EGateState : : NONE ;
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2016-01-29 21:35:11 +02:00
{
h & state ;
}
2023-02-12 09:23:39 +02:00
protected :
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2016-01-29 21:35:11 +02:00
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE AdvmapSpellCast : public CPackForClient
2010-05-16 16:42:19 +03:00
{
2018-03-10 21:19:55 +02:00
ObjectInstanceID casterID ;
2013-03-03 20:06:03 +03:00
SpellID spellID ;
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2010-05-16 16:42:19 +03:00
{
2018-03-10 21:19:55 +02:00
h & casterID ;
2017-07-31 15:35:42 +02:00
h & spellID ;
2010-05-16 16:42:19 +03:00
}
2023-02-12 09:23:39 +02:00
protected :
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2008-12-26 17:00:34 +02:00
} ;
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE ShowWorldViewEx : public CPackForClient
2015-02-26 16:15:17 +02:00
{
PlayerColor player ;
2023-02-21 14:38:08 +02:00
bool showTerrain ; // TODO: send terrain state
2016-08-30 04:13:45 +02:00
2015-02-26 16:15:17 +02:00
std : : vector < ObjectPosInfo > objectPositions ;
2016-08-30 04:13:45 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2015-02-26 16:15:17 +02:00
{
2017-07-31 15:35:42 +02:00
h & player ;
2023-02-21 14:38:08 +02:00
h & showTerrain ;
2017-07-31 15:35:42 +02:00
h & objectPositions ;
2016-08-30 04:13:45 +02:00
}
2023-02-12 09:23:39 +02:00
protected :
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2015-02-26 16:15:17 +02:00
} ;
2009-03-09 12:37:49 +02:00
/***********************************************************************************************************/
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE EndTurn : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2018-01-05 19:21:07 +02:00
{
h & static_cast < CPackForServer & > ( * this ) ;
}
2009-03-09 12:37:49 +02:00
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE DismissHero : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
DismissHero ( ) = default ;
DismissHero ( const ObjectInstanceID & HID )
: hid ( HID )
2023-02-12 09:23:39 +02:00
{
}
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2009-03-09 12:37:49 +02:00
h & hid ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE MoveHero : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
MoveHero ( ) = default ;
MoveHero ( const int3 & Dest , const ObjectInstanceID & HID , bool Transit )
: dest ( Dest )
, hid ( HID )
, transit ( Transit )
2023-02-12 09:23:39 +02:00
{
}
2009-03-09 12:37:49 +02:00
int3 dest ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
2023-02-09 18:06:02 +02:00
bool transit = false ;
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2010-06-30 22:27:35 +03:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & dest ;
h & hid ;
h & transit ;
2010-06-30 22:27:35 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE CastleTeleportHero : public CPackForServer
2010-06-30 22:27:35 +03:00
{
2023-02-09 18:06:02 +02:00
CastleTeleportHero ( ) = default ;
CastleTeleportHero ( const ObjectInstanceID & HID , const ObjectInstanceID & Dest , ui8 Source )
: dest ( Dest )
, hid ( HID )
, source ( Source )
2023-02-12 09:23:39 +02:00
{
}
2013-02-14 02:55:42 +03:00
ObjectInstanceID dest ;
ObjectInstanceID hid ;
2023-02-09 18:06:02 +02:00
si8 source = 0 ; //who give teleporting, 1=castle gate
2010-06-30 22:27:35 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & dest ;
h & hid ;
2009-03-09 12:37:49 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE ArrangeStacks : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
ArrangeStacks ( ) = default ;
ArrangeStacks ( ui8 W , const SlotID & P1 , const SlotID & P2 , const ObjectInstanceID & ID1 , const ObjectInstanceID & ID2 , si32 VAL )
: what ( W )
, p1 ( P1 )
, p2 ( P2 )
, id1 ( ID1 )
, id2 ( ID2 )
, val ( VAL )
2023-02-12 09:23:39 +02:00
{
}
2009-03-09 12:37:49 +02:00
2023-02-09 18:06:02 +02:00
ui8 what = 0 ; //1 - swap; 2 - merge; 3 - split
2013-02-16 17:03:47 +03:00
SlotID p1 , p2 ; //positions of first and second stack
2013-02-14 02:55:42 +03:00
ObjectInstanceID id1 , id2 ; //ids of objects with garrison
2023-02-09 18:06:02 +02:00
si32 val = 0 ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & what ;
h & p1 ;
h & p2 ;
h & id1 ;
h & id2 ;
h & val ;
2009-03-09 12:37:49 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BulkMoveArmy : public CPackForServer
2021-11-28 14:57:38 +02:00
{
SlotID srcSlot ;
ObjectInstanceID srcArmy ;
ObjectInstanceID destArmy ;
2023-02-09 18:06:02 +02:00
BulkMoveArmy ( ) = default ;
2021-11-28 14:57:38 +02:00
2023-02-09 18:06:02 +02:00
BulkMoveArmy ( const ObjectInstanceID & srcArmy , const ObjectInstanceID & destArmy , const SlotID & srcSlot )
: srcArmy ( srcArmy )
, destArmy ( destArmy )
, srcSlot ( srcSlot )
2023-02-12 09:23:39 +02:00
{
}
2021-11-28 14:57:38 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2021-11-28 14:57:38 +02:00
template < typename Handler >
void serialize ( Handler & h , const int version )
{
2023-02-12 09:23:39 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2021-11-28 14:57:38 +02:00
h & srcSlot ;
h & srcArmy ;
h & destArmy ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BulkSplitStack : public CPackForServer
2021-11-28 14:57:38 +02:00
{
SlotID src ;
ObjectInstanceID srcOwner ;
2023-02-09 18:06:02 +02:00
si32 amount = 0 ;
2021-11-28 14:57:38 +02:00
2023-02-09 18:06:02 +02:00
BulkSplitStack ( ) = default ;
2021-11-28 14:57:38 +02:00
2023-02-09 18:06:02 +02:00
BulkSplitStack ( const ObjectInstanceID & srcOwner , const SlotID & src , si32 howMany )
: src ( src )
, srcOwner ( srcOwner )
, amount ( howMany )
2023-02-12 09:23:39 +02:00
{
}
2021-11-28 14:57:38 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2021-11-28 14:57:38 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler >
2021-11-28 14:57:38 +02:00
void serialize ( Handler & h , const int version )
{
2023-02-12 09:23:39 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2021-11-28 14:57:38 +02:00
h & src ;
h & srcOwner ;
h & amount ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BulkMergeStacks : public CPackForServer
2021-11-28 14:57:38 +02:00
{
SlotID src ;
ObjectInstanceID srcOwner ;
2023-02-09 18:06:02 +02:00
BulkMergeStacks ( ) = default ;
2021-11-28 14:57:38 +02:00
2023-02-09 18:06:02 +02:00
BulkMergeStacks ( const ObjectInstanceID & srcOwner , const SlotID & src )
: src ( src )
, srcOwner ( srcOwner )
2023-02-12 09:23:39 +02:00
{
}
2021-11-28 14:57:38 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2021-11-28 14:57:38 +02:00
template < typename Handler >
void serialize ( Handler & h , const int version )
{
2023-02-12 09:23:39 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2021-11-28 14:57:38 +02:00
h & src ;
h & srcOwner ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BulkSmartSplitStack : public CPackForServer
2021-11-28 14:57:38 +02:00
{
SlotID src ;
ObjectInstanceID srcOwner ;
2023-02-09 18:06:02 +02:00
BulkSmartSplitStack ( ) = default ;
2021-11-28 14:57:38 +02:00
2023-02-09 18:06:02 +02:00
BulkSmartSplitStack ( const ObjectInstanceID & srcOwner , const SlotID & src )
: src ( src )
, srcOwner ( srcOwner )
2023-02-12 09:23:39 +02:00
{
}
2021-11-28 14:57:38 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2021-11-28 14:57:38 +02:00
template < typename Handler >
void serialize ( Handler & h , const int version )
{
2023-02-12 09:23:39 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2021-11-28 14:57:38 +02:00
h & src ;
h & srcOwner ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE DisbandCreature : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
DisbandCreature ( ) = default ;
DisbandCreature ( const SlotID & Pos , const ObjectInstanceID & ID )
: pos ( Pos )
, id ( ID )
2023-02-12 09:23:39 +02:00
{
}
2013-02-16 17:03:47 +03:00
SlotID pos ; //stack pos
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //object id
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & pos ;
h & id ;
2009-03-09 12:37:49 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BuildStructure : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
BuildStructure ( ) = default ;
BuildStructure ( const ObjectInstanceID & TID , const BuildingID & BID )
: tid ( TID )
, bid ( BID )
2023-02-12 09:23:39 +02:00
{
}
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid ; //town id
2013-02-11 22:11:34 +03:00
BuildingID bid ; //structure id
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & tid ;
h & bid ;
2009-03-09 12:37:49 +02:00
}
} ;
2016-11-26 19:49:26 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE RazeStructure : public BuildStructure
2009-09-22 17:27:46 +03:00
{
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-09-22 17:27:46 +03:00
} ;
2016-11-26 19:49:26 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE RecruitCreatures : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
RecruitCreatures ( ) = default ;
RecruitCreatures ( const ObjectInstanceID & TID , const ObjectInstanceID & DST , const CreatureID & CRID , si32 Amount , si32 Level )
: tid ( TID )
, dst ( DST )
, crid ( CRID )
, amount ( Amount )
, level ( Level )
2023-02-12 09:23:39 +02:00
{
}
2014-09-19 00:18:49 +03:00
ObjectInstanceID tid ; //dwelling id, or town
ObjectInstanceID dst ; //destination ID, e.g. hero
2013-02-11 02:24:57 +03:00
CreatureID crid ;
2023-02-09 18:06:02 +02:00
ui32 amount = 0 ; //creature amount
si32 level = 0 ; //dwelling level to buy from, -1 if any
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & tid ;
h & dst ;
h & crid ;
h & amount ;
h & level ;
2009-03-09 12:37:49 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE UpgradeCreature : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
UpgradeCreature ( ) = default ;
UpgradeCreature ( const SlotID & Pos , const ObjectInstanceID & ID , const CreatureID & CRID )
: pos ( Pos )
, id ( ID )
, cid ( CRID )
2023-02-12 09:23:39 +02:00
{
}
2013-02-16 17:03:47 +03:00
SlotID pos ; //stack pos
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //object id
2013-02-11 02:24:57 +03:00
CreatureID cid ; //id of type to which we want make upgrade
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & pos ;
h & id ;
h & cid ;
2009-03-09 12:37:49 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE GarrisonHeroSwap : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
GarrisonHeroSwap ( ) = default ;
GarrisonHeroSwap ( const ObjectInstanceID & TID )
: tid ( TID )
2023-02-12 09:23:39 +02:00
{
}
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid ;
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2009-03-09 12:37:49 +02:00
h & tid ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE ExchangeArtifacts : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2012-04-14 05:20:22 +03:00
ArtifactLocation src , dst ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & src ;
h & dst ;
2009-03-09 12:37:49 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BulkExchangeArtifacts : public CPackForServer
2022-11-06 23:29:22 +02:00
{
ObjectInstanceID srcHero ;
ObjectInstanceID dstHero ;
2023-02-09 18:06:02 +02:00
bool swap = false ;
2022-11-06 23:29:22 +02:00
2023-02-09 18:06:02 +02:00
BulkExchangeArtifacts ( ) = default ;
BulkExchangeArtifacts ( const ObjectInstanceID & srcHero , const ObjectInstanceID & dstHero , bool swap )
: srcHero ( srcHero )
, dstHero ( dstHero )
, swap ( swap )
{
}
2022-11-06 23:29:22 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2022-11-06 23:29:22 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2023-02-12 09:23:39 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2022-11-06 23:29:22 +02:00
h & srcHero ;
h & dstHero ;
h & swap ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE AssembleArtifacts : public CPackForServer
2010-02-16 16:39:56 +02:00
{
2023-02-09 18:06:02 +02:00
AssembleArtifacts ( ) = default ;
AssembleArtifacts ( const ObjectInstanceID & _heroID , const ArtifactPosition & _artifactSlot , bool _assemble , const ArtifactID & _assembleTo )
: heroID ( _heroID )
, artifactSlot ( _artifactSlot )
, assemble ( _assemble )
, assembleTo ( _assembleTo )
2023-02-12 09:23:39 +02:00
{
}
2013-02-14 02:55:42 +03:00
ObjectInstanceID heroID ;
2013-02-12 22:49:40 +03:00
ArtifactPosition artifactSlot ;
2023-02-09 18:06:02 +02:00
bool assemble = false ; // True to assemble artifact, false to disassemble.
2013-02-16 17:03:47 +03:00
ArtifactID assembleTo ; // Artifact to assemble into.
2010-02-16 16:39:56 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2010-02-16 16:39:56 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & heroID ;
h & artifactSlot ;
h & assemble ;
h & assembleTo ;
2010-02-16 16:39:56 +02:00
}
} ;
2023-04-07 23:41:55 +02:00
struct DLL_LINKAGE EraseArtifactByClient : public CPackForServer
{
EraseArtifactByClient ( ) = default ;
EraseArtifactByClient ( const ArtifactLocation & al )
: al ( al )
{
}
ArtifactLocation al ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & static_cast < CPackForServer & > ( * this ) ;
h & al ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BuyArtifact : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
BuyArtifact ( ) = default ;
BuyArtifact ( const ObjectInstanceID & HID , const ArtifactID & AID )
: hid ( HID )
, aid ( AID )
2023-02-12 09:23:39 +02:00
{
}
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
2013-02-11 02:24:57 +03:00
ArtifactID aid ;
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & hid ;
h & aid ;
2009-03-09 12:37:49 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE TradeOnMarketplace : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2018-03-10 21:19:55 +02:00
ObjectInstanceID marketId ;
ObjectInstanceID heroId ;
2023-02-09 18:06:02 +02:00
EMarketMode : : EMarketMode mode = EMarketMode : : RESOURCE_RESOURCE ;
2017-10-14 21:30:56 +02:00
std : : vector < ui32 > r1 , r2 ; //mode 0: r1 - sold resource, r2 - bought res (exception: when sacrificing art r1 is art id [todo: make r2 preferred slot?]
std : : vector < ui32 > val ; //units of sold resource
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2018-03-10 21:19:55 +02:00
h & marketId ;
h & heroId ;
2017-07-31 15:35:42 +02:00
h & mode ;
h & r1 ;
h & r2 ;
h & val ;
2009-03-09 12:37:49 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SetFormation : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
SetFormation ( ) = default ;
;
SetFormation ( const ObjectInstanceID & HID , ui8 Formation )
: hid ( HID )
, formation ( Formation )
2023-02-12 09:23:39 +02:00
{
}
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
2023-02-09 18:06:02 +02:00
ui8 formation = 0 ;
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & hid ;
h & formation ;
2009-03-09 12:37:49 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE HireHero : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
HireHero ( ) = default ;
2023-07-11 14:16:02 +02:00
HireHero ( HeroTypeID HID , const ObjectInstanceID & TID )
2023-02-09 18:06:02 +02:00
: hid ( HID )
, tid ( TID )
2023-02-12 09:23:39 +02:00
{
}
2023-07-11 14:16:02 +02:00
HeroTypeID hid ; //available hero serial
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid ; //town (tavern) id
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & hid ;
h & tid ;
h & player ;
2009-03-09 12:37:49 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE BuildBoat : public CPackForServer
2009-07-26 06:33:13 +03:00
{
2013-02-14 02:55:42 +03:00
ObjectInstanceID objid ; //where player wants to buy a boat
2009-07-26 06:33:13 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-07-26 06:33:13 +03:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2009-07-26 06:33:13 +03:00
h & objid ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE QueryReply : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
QueryReply ( ) = default ;
QueryReply ( const QueryID & QID , const JsonNode & Reply )
: qid ( QID )
, reply ( Reply )
2023-02-12 09:23:39 +02:00
{
}
2013-05-27 13:53:28 +03:00
QueryID qid ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2017-06-06 06:53:51 +02:00
JsonNode reply ;
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & qid ;
h & player ;
h & reply ;
2009-03-09 12:37:49 +02:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE MakeAction : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
MakeAction ( ) = default ;
MakeAction ( BattleAction BA )
: ba ( std : : move ( BA ) )
2023-02-12 09:23:39 +02:00
{
}
2009-03-09 12:37:49 +02:00
BattleAction ba ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2009-03-09 12:37:49 +02:00
h & ba ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE MakeCustomAction : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
MakeCustomAction ( ) = default ;
MakeCustomAction ( BattleAction BA )
: ba ( std : : move ( BA ) )
2023-02-12 09:23:39 +02:00
{
}
2009-03-09 12:37:49 +02:00
BattleAction ba ;
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2009-03-09 12:37:49 +02:00
h & ba ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE DigWithHero : public CPackForServer
2010-02-21 17:03:30 +02:00
{
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //digging hero id
2010-02-21 17:03:30 +02:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2010-02-21 17:03:30 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2010-02-21 17:03:30 +02:00
h & id ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE CastAdvSpell : public CPackForServer
2010-03-11 01:16:30 +02:00
{
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ; //hero id
2013-02-11 02:24:57 +03:00
SpellID sid ; //spell id
2010-03-11 01:16:30 +02:00
int3 pos ; //selected tile (not always used)
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2010-03-11 01:16:30 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & hid ;
h & sid ;
h & pos ;
2010-03-11 01:16:30 +02:00
}
} ;
2009-03-09 12:37:49 +02:00
/***********************************************************************************************************/
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE SaveGame : public CPackForServer
2009-03-28 20:46:20 +02:00
{
2023-02-09 18:06:02 +02:00
SaveGame ( ) = default ;
SaveGame ( std : : string Fname )
: fname ( std : : move ( Fname ) )
2023-02-12 09:23:39 +02:00
{
}
2009-03-28 20:46:20 +02:00
std : : string fname ;
2023-02-12 09:23:39 +02:00
void applyGs ( CGameState * gs ) { } ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2018-01-05 19:21:07 +02:00
{
h & static_cast < CPackForServer & > ( * this ) ;
h & fname ;
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE PlayerMessage : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2023-02-09 18:06:02 +02:00
PlayerMessage ( ) = default ;
PlayerMessage ( std : : string Text , const ObjectInstanceID & obj )
: text ( std : : move ( Text ) )
, currObj ( obj )
2023-02-12 09:23:39 +02:00
{
}
void applyGs ( CGameState * gs ) { } ;
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-03-09 12:37:49 +02:00
std : : string text ;
2014-09-21 20:35:53 +03:00
ObjectInstanceID currObj ; // optional parameter that specifies current object. For cheats :)
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2017-07-31 15:35:42 +02:00
h & text ;
h & currObj ;
2009-03-09 12:37:49 +02:00
}
2012-09-15 22:16:16 +03:00
} ;
2009-03-09 12:37:49 +02:00
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE PlayerMessageClient : public CPackForClient
2009-08-11 10:50:29 +03:00
{
2023-02-09 18:06:02 +02:00
PlayerMessageClient ( ) = default ;
PlayerMessageClient ( const PlayerColor & Player , std : : string Text )
: player ( Player )
, text ( std : : move ( Text ) )
2023-02-12 09:23:39 +02:00
{
}
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
2009-08-11 10:50:29 +03:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2018-01-05 19:21:07 +02:00
std : : string text ;
2009-08-11 10:50:29 +03:00
2023-02-12 09:23:39 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-09 12:37:49 +02:00
{
2017-07-31 15:35:42 +02:00
h & player ;
2018-01-05 19:21:07 +02:00
h & text ;
2010-10-24 14:35:14 +03:00
}
} ;
2023-02-12 09:23:39 +02:00
struct DLL_LINKAGE CenterView : public CPackForClient
2010-10-24 14:35:14 +03:00
{
2018-01-05 19:21:07 +02:00
PlayerColor player ;
int3 pos ;
2023-02-09 18:06:02 +02:00
ui32 focusTime = 0 ; //ms
2010-10-24 14:35:14 +03:00
2023-02-12 09:23:39 +02:00
virtual void visitTyped ( ICPackVisitor & visitor ) override ;
template < typename Handler > void serialize ( Handler & h , const int version )
2010-10-24 14:35:14 +03:00
{
2018-01-05 19:21:07 +02:00
h & pos ;
h & player ;
h & focusTime ;
2010-10-24 14:35:14 +03:00
}
} ;
2022-07-26 15:07:42 +02:00
VCMI_LIB_NAMESPACE_END