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"
2017-06-24 16:42:05 +02:00
# include "battle/BattleAction.h"
2014-06-05 19:52:14 +03:00
# include "mapObjects/CGHeroInstance.h"
2010-12-14 23:55:23 +02:00
# include "ConstTransitivePtr.h"
2011-12-14 00:23:17 +03:00
# include "int3.h"
2011-07-05 09:14:07 +03:00
# include "ResourceSet.h"
2014-06-25 17:11:07 +03:00
# include "CGameStateFwd.h"
2015-12-02 21:05:10 +02:00
# include "mapping/CMapDefines.h"
2017-06-24 16:42:05 +02:00
# include "battle/CObstacleInstance.h"
2009-02-04 15:40:54 +02:00
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
struct 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)
2012-09-15 22:16:16 +03:00
2012-07-15 18:34:00 +03:00
Query ( )
{
}
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
StackLocation ( )
2013-02-16 17:03:47 +03:00
{ }
2013-11-07 15:48:41 +03:00
StackLocation ( const CArmedInstance * Army , 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
2012-05-18 17:02:27 +03:00
DLL_LINKAGE const CStackInstance * getStack ( ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
/***********************************************************************************************************/
2011-05-22 21:46:52 +03:00
2016-11-18 16:45:59 +02:00
struct PackageApplied : public CPackForClient
2009-04-16 03:28:54 +03:00
{
2016-11-25 19:04:07 +02:00
PackageApplied ( )
: result ( 0 ) , packType ( 0 ) , requestID ( 0 )
{ }
PackageApplied ( ui8 Result )
: result ( Result ) , packType ( 0 ) , requestID ( 0 )
{ }
2009-04-16 03:28:54 +03:00
void applyCl ( CClient * cl ) ;
ui8 result ; //0 - something went wrong, request hasn't been realized; 1 - OK
ui32 packType ; //type id of applied package
2012-03-26 01:46:14 +03:00
ui32 requestID ; //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
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & result ;
h & packType ;
h & requestID ;
h & player ;
2009-04-16 03:28:54 +03:00
}
} ;
2016-11-18 16:45:59 +02:00
struct SystemMessage : public CPackForClient
2008-07-26 09:39:44 +03:00
{
2016-11-25 19:04:07 +02:00
SystemMessage ( const std : : string & Text ) : text ( Text ) { }
SystemMessage ( ) { }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
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
2008-07-26 09:39:44 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
2016-11-18 16:45:59 +02:00
struct PlayerBlocked : public CPackForClient
2009-08-04 02:53:18 +03:00
{
2016-11-25 19:04:07 +02:00
PlayerBlocked ( ) : reason ( UPCOMING_BATTLE ) , startOrEnd ( BLOCKADE_STARTED ) { }
2009-08-04 02:53:18 +03:00
void applyCl ( CClient * cl ) ;
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
2013-02-14 02:55:42 +03:00
EReason reason ;
2013-09-28 02:46:58 +03:00
EMode startOrEnd ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-08-04 02:53:18 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & reason ;
h & startOrEnd ;
h & player ;
2009-08-04 02:53:18 +03:00
}
} ;
2017-06-02 02:34:50 +02:00
struct PlayerCheated : public CPackForClient
{
PlayerCheated ( ) : losingCheatCode ( false ) , winningCheatCode ( false ) { }
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
PlayerColor player ;
bool losingCheatCode ;
bool winningCheatCode ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & player ;
h & losingCheatCode ;
h & winningCheatCode ;
2017-06-02 02:34:50 +02:00
}
} ;
2016-11-18 16:45:59 +02:00
struct YourTurn : public CPackForClient
2009-03-07 00:11:17 +02:00
{
2016-11-25 19:04:07 +02:00
YourTurn ( ) { }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2015-10-24 17:02:00 +02:00
boost : : optional < ui8 > daysWithoutCastle ;
2008-07-26 09:39:44 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
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
struct EntitiesChanged : public CPackForClient
{
std : : vector < EntityChanges > changes ;
EntitiesChanged ( ) { } ;
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & changes ;
}
} ;
2016-11-18 16:45:59 +02:00
struct SetResources : public CPackForClient
{
2016-11-26 14:14:43 +02:00
SetResources ( ) : abs ( true ) { } ;
2016-11-18 16:45:59 +02:00
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2012-09-15 22:16:16 +03:00
2016-11-26 14:14:43 +02:00
bool abs ; //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
2016-11-18 16:45:59 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & abs ;
h & player ;
h & res ;
2016-11-18 16:45:59 +02:00
}
} ;
struct SetPrimSkill : public CPackForClient
2008-08-04 18:56:36 +03:00
{
2016-11-25 19:04:07 +02:00
SetPrimSkill ( )
: abs ( 0 ) , which ( PrimarySkill : : ATTACK ) , val ( 0 )
{ }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2008-08-04 18:56:36 +03:00
ui8 abs ; //0 - changes by value; 1 - sets to value
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
2013-02-04 22:43:16 +03:00
PrimarySkill : : PrimarySkill which ;
2009-08-16 18:39:18 +03:00
si64 val ;
2008-08-04 18:56:36 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
struct SetSecSkill : public CPackForClient
2008-08-13 03:44:31 +03:00
{
2016-11-25 19:04:07 +02:00
SetSecSkill ( )
: abs ( 0 ) , val ( 0 )
{ }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2008-08-13 03:44:31 +03:00
ui8 abs ; //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 ;
2013-02-04 22:43:16 +03:00
ui16 val ;
2008-08-13 03:44:31 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
struct HeroVisitCastle : public CPackForClient
2008-08-13 12:28:06 +03:00
{
2016-11-18 16:45:59 +02:00
HeroVisitCastle ( ) { flags = 0 ; } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2011-02-04 16:58:14 +02:00
ui8 flags ; //1 - start
2013-02-14 02:55:42 +03:00
ObjectInstanceID tid , hid ;
2008-08-13 12:28:06 +03:00
bool start ( ) //if hero is entering castle (if false - leaving)
{
return flags & 1 ;
}
2016-11-18 16:45:59 +02:00
2008-08-13 12:28:06 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
2016-11-18 16:45:59 +02:00
struct ChangeSpells : public CPackForClient
2008-09-12 11:51:46 +03:00
{
2016-11-25 19:04:07 +02:00
ChangeSpells ( ) : learn ( 1 ) { }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2008-09-12 11:51:46 +03:00
ui8 learn ; //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
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
2016-11-18 16:45:59 +02:00
struct SetMana : public CPackForClient
2008-10-19 02:20:48 +03:00
{
2016-11-25 19:04:07 +02:00
SetMana ( ) { val = 0 ; absolute = true ; }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
si32 val ;
2014-11-26 12:30:55 +02:00
bool absolute ;
2008-10-19 02:20:48 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
} ;
2016-11-18 16:45:59 +02:00
struct SetMovePoints : public CPackForClient
2008-10-19 02:20:48 +03:00
{
2017-05-11 20:52:10 +02:00
SetMovePoints ( ) { val = 0 ; absolute = true ; }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
si32 val ;
2017-05-11 20:52:10 +02:00
bool absolute ;
2008-10-19 02:20:48 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
} ;
2016-11-18 16:45:59 +02:00
struct FoWChange : public CPackForClient
2008-10-19 02:20:48 +03:00
{
2016-11-25 19:04:07 +02:00
FoWChange ( ) { mode = 0 ; waitForDialogs = false ; }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-06-29 16:05:48 +03:00
std : : unordered_set < int3 , struct ShashInt3 > tiles ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
ui8 mode ; //mode==0 - hide, mode==1 - reveal
2014-06-21 16:41:05 +03:00
bool waitForDialogs ;
2008-10-19 02:20:48 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
2016-11-18 16:45:59 +02:00
struct SetAvailableHeroes : public CPackForClient
2008-10-26 22:58:34 +02:00
{
2010-07-08 08:52:11 +03:00
SetAvailableHeroes ( )
{
2011-12-14 00:23:17 +03:00
for ( int i = 0 ; i < GameConstants : : AVAILABLE_HEROES_PER_PLAYER ; i + + )
2011-01-28 04:11:58 +02:00
army [ i ] . clear ( ) ;
2010-07-08 08:52:11 +03:00
}
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2011-12-14 00:23:17 +03:00
si32 hid [ GameConstants : : AVAILABLE_HEROES_PER_PLAYER ] ; //-1 if no hero
CSimpleArmy army [ GameConstants : : AVAILABLE_HEROES_PER_PLAYER ] ;
2008-10-26 22:58:34 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & player ;
h & hid ;
h & army ;
2008-10-26 22:58:34 +02:00
}
} ;
2016-11-18 16:45:59 +02:00
struct GiveBonus : public CPackForClient
2009-02-03 07:28:05 +02:00
{
2010-02-10 04:56:00 +02:00
GiveBonus ( ui8 Who = 0 )
{
2012-09-15 22:16:16 +03:00
who = Who ;
2016-11-25 19:04:07 +02:00
id = 0 ;
2010-02-10 04:56:00 +02:00
}
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-02-03 07:28:05 +02:00
2010-06-07 08:28:12 +03:00
enum { HERO , PLAYER , TOWN } ;
2010-02-10 04:56:00 +02:00
ui8 who ; //who receives bonus, uses enum above
2013-02-14 02:55:42 +03:00
si32 id ; //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 ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & bonus ;
h & id ;
h & bdescr ;
h & who ;
2015-12-05 01:39:14 +02:00
assert ( id ! = - 1 ) ;
2009-02-03 07:28:05 +02:00
}
} ;
2016-11-18 16:45:59 +02:00
struct ChangeObjPos : public CPackForClient
2009-02-20 12:36:15 +02:00
{
2010-03-11 01:16:30 +02:00
ChangeObjPos ( )
{
flags = 0 ;
}
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-02-20 12:36:15 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID objid ;
2009-02-20 12:36:15 +02:00
int3 nPos ;
ui8 flags ; //bit flags: 1 - redraw
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & objid ;
h & nPos ;
h & flags ;
2009-02-20 12:36:15 +02:00
}
} ;
2016-11-18 16:45:59 +02:00
struct PlayerEndsGame : public CPackForClient
2010-01-29 22:52:45 +02:00
{
PlayerEndsGame ( )
{
}
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & player ;
h & victoryLossCheckResult ;
2010-01-29 22:52:45 +02:00
}
} ;
2022-09-30 21:08:37 +02:00
struct PlayerReinitInterface : public CPackForClient
{
void applyCl ( CClient * cl ) ;
DLL_LINKAGE 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
2022-09-30 21:08:37 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2022-10-04 23:54:31 +02:00
h & players ;
2022-09-30 21:08:37 +02:00
h & playerConnectionId ;
}
} ;
2016-11-18 16:45:59 +02:00
struct RemoveBonus : public CPackForClient
2010-02-10 04:56:00 +02:00
{
RemoveBonus ( ui8 Who = 0 )
{
2012-09-15 22:16:16 +03:00
who = Who ;
2016-11-25 19:04:07 +02:00
whoID = 0 ;
source = 0 ;
id = 0 ;
2010-02-10 04:56:00 +02:00
}
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-02-10 04:56:00 +02:00
2010-06-13 16:59:59 +03:00
enum { HERO , PLAYER , TOWN } ;
2010-02-10 04:56:00 +02:00
ui8 who ; //who receives bonus, uses enum above
2010-06-13 16:59:59 +03:00
ui32 whoID ; //hero, town or player id - whoever loses bonus
2010-02-10 04:56:00 +02:00
//vars to identify bonus: its source
ui8 source ;
ui32 id ; //source id
//used locally: copy of removed bonus
2010-05-02 21:20:26 +03:00
Bonus bonus ;
2010-02-10 04:56:00 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & source ;
h & id ;
h & who ;
h & whoID ;
2010-02-10 04:56:00 +02:00
}
} ;
2016-11-18 16:45:59 +02:00
struct SetCommanderProperty : public CPackForClient
2012-05-07 15:54:22 +03:00
{
2012-05-18 22:44:15 +03:00
enum ECommanderProperty { ALIVE , BONUS , SECONDARY_SKILL , EXPERIENCE , SPECIAL_SKILL } ;
2012-05-07 15:54:22 +03:00
2016-11-25 19:04:07 +02:00
SetCommanderProperty ( )
: which ( ALIVE ) , amount ( 0 ) , additionalInfo ( 0 )
{ }
2012-05-07 15:54:22 +03:00
void applyCl ( CClient * cl ) { } ;
2012-05-18 17:02:27 +03:00
DLL_LINKAGE 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
ObjectInstanceID heroid ;
2012-05-07 15:54:22 +03:00
2013-02-04 22:43:16 +03:00
ECommanderProperty which ;
2012-09-23 21:01:04 +03:00
TExpType amount ; //0 for dead, >0 for alive
2012-05-18 17:02:27 +03:00
si32 additionalInfo ; //for secondary skills choice
2012-05-07 15:54:22 +03:00
Bonus accumulatedBonus ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
struct AddQuest : public CPackForClient
2012-05-16 20:29:05 +03:00
{
2016-11-18 16:45:59 +02:00
AddQuest ( ) { } ;
2012-05-16 20:29:05 +03:00
void applyCl ( CClient * cl ) { } ;
2012-07-06 22:12:04 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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 ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
2016-11-18 16:45:59 +02:00
struct UpdateArtHandlerLists : public CPackForClient
2013-02-19 01:37:22 +03:00
{
2016-11-25 19:04:07 +02:00
UpdateArtHandlerLists ( ) { }
2013-02-19 01:37:22 +03:00
std : : vector < CArtifact * > treasures , minors , majors , relics ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & treasures ;
h & minors ;
h & majors ;
h & relics ;
2013-02-19 01:37:22 +03:00
}
} ;
2016-11-18 16:45:59 +02:00
struct UpdateMapEvents : public CPackForClient
2013-02-19 01:37:22 +03:00
{
2016-11-18 16:45:59 +02:00
UpdateMapEvents ( ) { }
2013-02-19 01:37:22 +03:00
std : : list < CMapEvent > events ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & events ;
}
} ;
2016-11-18 16:45:59 +02:00
struct UpdateCastleEvents : public CPackForClient
2013-02-19 01:37:22 +03:00
{
2016-11-18 16:45:59 +02:00
UpdateCastleEvents ( ) { }
2013-02-19 01:37:22 +03:00
ObjectInstanceID town ;
std : : list < CCastleEvent > events ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & town ;
h & events ;
2013-02-19 01:37:22 +03:00
}
} ;
2016-11-18 16:45:59 +02:00
struct ChangeFormation : public CPackForClient
2016-09-08 18:29:15 +02:00
{
2016-11-25 19:04:07 +02:00
ChangeFormation ( ) : formation ( 0 ) { }
2016-09-08 18:29:15 +02:00
ObjectInstanceID hid ;
ui8 formation ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & hid ;
h & formation ;
2016-09-08 18:29:15 +02:00
}
} ;
2016-11-18 16:45:59 +02:00
struct RemoveObject : public CPackForClient
2008-08-02 00:41:38 +03:00
{
2016-11-25 19:04:07 +02:00
RemoveObject ( ) { }
2016-11-18 16:45:59 +02:00
RemoveObject ( ObjectInstanceID ID ) { id = ID ; } ;
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & id ;
}
2012-09-15 22:16:16 +03:00
} ;
2016-11-18 16:45:59 +02:00
struct TryMoveHero : public CPackForClient
2008-07-28 15:44:08 +03:00
{
2016-11-25 19:04:07 +02:00
TryMoveHero ( )
: movePoints ( 0 ) , result ( FAILED ) , humanKnows ( false )
{ }
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
void applyCl ( CClient * cl ) ;
2009-03-07 17:54:12 +02:00
void applyGs ( CGameState * gs ) ;
2008-07-28 15:44:08 +03:00
2009-07-03 22:57:14 +03:00
enum EResult
{
2009-07-19 04:00:19 +03:00
FAILED , SUCCESS , TELEPORTATION , RESERVED___ , BLOCKING_VISIT , EMBARK , DISEMBARK
2009-07-03 22:57:14 +03:00
} ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
ui32 movePoints ;
2013-02-04 22:43:16 +03:00
EResult result ; //uses EResult
2010-03-21 00:17:19 +02:00
int3 start , end ; //h3m format
2013-06-29 16:05:48 +03:00
std : : unordered_set < int3 , ShashInt3 > fowRevealed ; //revealed tiles
2013-04-20 14:34:01 +03:00
boost : : optional < int3 > attackedFrom ; // Set when stepping into endangered tile.
2008-07-28 15:44:08 +03:00
2009-12-28 06:08:24 +02:00
bool humanKnows ; //used locally during applying to client
2017-09-16 09:42:27 +02:00
bool stopMovement ( ) const ;
2008-07-28 15:44:08 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
} ;
2016-11-18 16:45:59 +02:00
struct NewStructures : public CPackForClient
2008-08-01 14:21:15 +03:00
{
2016-11-25 19:04:07 +02:00
NewStructures ( ) : builded ( 0 ) { }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2012-09-15 22:16:16 +03:00
DLL_LINKAGE 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 ;
2012-09-15 22:16:16 +03:00
si16 builded ;
2008-08-01 14:21:15 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
struct RazeStructures : public CPackForClient
2009-09-22 17:27:46 +03:00
{
2016-11-25 19:04:07 +02:00
RazeStructures ( ) : destroyed ( 0 ) { }
2009-09-22 17:27:46 +03:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE 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 ;
2012-09-15 22:16:16 +03:00
si16 destroyed ;
2009-09-24 20:54:02 +03:00
2009-09-22 17:27:46 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
struct SetAvailableCreatures : public CPackForClient
2008-08-01 14:21:15 +03:00
{
2016-11-25 19:04:07 +02:00
SetAvailableCreatures ( ) { }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE 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 02:24:57 +03:00
std : : vector < std : : pair < ui32 , std : : vector < CreatureID > > > creatures ;
2008-08-01 14:21:15 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
struct SetHeroesInTown : public CPackForClient
2008-08-16 11:47:41 +03:00
{
2016-11-25 19:04:07 +02:00
SetHeroesInTown ( ) { }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
2016-11-18 16:45:59 +02:00
struct HeroRecruited : public CPackForClient
2008-10-26 22:58:34 +02:00
{
2016-11-25 19:04:07 +02:00
HeroRecruited ( ) : hid ( - 1 ) { }
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
si32 hid ; //subID of hero
ObjectInstanceID tid ;
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
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & hid ;
h & tid ;
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
2016-11-18 16:45:59 +02:00
struct GiveHero : public CPackForClient
2009-02-14 21:12:40 +02:00
{
2016-11-25 19:04:07 +02:00
GiveHero ( ) { }
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //object id
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-02-14 21:12:40 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & id ;
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
2016-11-18 16:45:59 +02:00
struct OpenWindow : public CPackForClient
2009-06-16 14:18:14 +03:00
{
2016-11-25 19:04:07 +02:00
OpenWindow ( ) : id1 ( - 1 ) , id2 ( - 1 ) { }
2009-06-16 14:18:14 +03:00
void applyCl ( CClient * cl ) ;
2010-07-22 03:32:45 +03:00
enum EWindow { EXCHANGE_WINDOW , RECRUITMENT_FIRST , RECRUITMENT_ALL , SHIPYARD_WINDOW , THIEVES_GUILD ,
UNIVERSITY_WINDOW , HILL_FORT_WINDOW , MARKET_WINDOW , PUZZLE_MAP , TAVERN_WINDOW } ;
2009-07-06 22:41:27 +03:00
ui8 window ;
2013-02-14 02:55:42 +03:00
si32 id1 , id2 ;
2009-06-16 14:18:14 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & window ;
h & id1 ;
h & id2 ;
2009-06-16 14:18:14 +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
struct NewObject : public CPackForClient
2009-07-26 06:33:13 +03:00
{
2016-11-25 19:04:07 +02:00
NewObject ( ) : subID ( 0 ) { }
2009-07-26 06:33:13 +03:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-07-26 06:33:13 +03:00
2013-02-11 02:24:57 +03:00
Obj ID ;
2013-02-07 20:34:50 +03:00
ui32 subID ;
2009-07-26 06:33:13 +03:00
int3 pos ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //used locally, filled during applyGs
2009-07-26 06:33:13 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & ID ;
h & subID ;
h & pos ;
2009-07-26 06:33:13 +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
struct SetAvailableArtifacts : public CPackForClient
2010-06-26 19:02:10 +03:00
{
2016-11-25 19:04:07 +02:00
SetAvailableArtifacts ( ) : id ( 0 ) { }
2010-06-27 19:03:01 +03:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-06-26 19:02:10 +03:00
si32 id ; //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)
std : : vector < const CArtifact * > arts ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & id ;
h & arts ;
2010-06-26 19:02:10 +03:00
}
} ;
2016-11-18 16:45:59 +02:00
struct NewArtifact : public CPackForClient
2010-11-10 02:06:25 +02:00
{
2016-11-25 19:04:07 +02:00
NewArtifact ( ) { }
2018-03-10 21:19:55 +02:00
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-11-10 02:06:25 +02:00
2010-12-26 16:34:11 +02:00
ConstTransitivePtr < CArtifactInstance > art ;
2010-11-10 02:06:25 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2010-12-26 16:34:11 +02:00
h & art ;
2010-11-10 02:06:25 +02:00
}
} ;
2010-11-27 22:17:28 +02:00
struct CGarrisonOperationPack : CPackForClient
{
} ;
2016-11-18 16:45:59 +02:00
struct 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
2018-03-10 23:19:36 +02:00
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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
}
} ;
2016-11-18 16:45:59 +02:00
struct 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
2010-11-27 22:17:28 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-11-27 03:46:19 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2016-11-18 16:45:59 +02:00
struct 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
2010-11-27 22:17:28 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-11-27 03:46:19 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2018-03-10 23:19:36 +02:00
h & army ;
h & slot ;
2010-11-27 03:46:19 +02:00
}
} ;
2016-11-18 16:45:59 +02:00
struct 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
2018-03-10 23:19:36 +02:00
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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
}
} ;
2016-11-18 16:45:59 +02:00
struct InsertNewStack : CGarrisonOperationPack
2010-11-27 03:46:19 +02:00
{
2018-03-10 23:19:36 +02:00
ObjectInstanceID army ;
SlotID slot ;
CreatureID type ;
TQuantity count ;
2010-11-27 03:46:19 +02:00
2018-03-10 23:19:36 +02:00
InsertNewStack ( )
: count ( 0 )
{
}
2010-11-27 03:46:19 +02:00
2018-03-10 23:19:36 +02:00
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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
struct 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 ;
2010-11-27 22:17:28 +02:00
void applyCl ( CClient * cl ) ;
2021-11-28 14:57:38 +02:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-11-27 03:46:19 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2021-11-28 14:57:38 +02:00
struct BulkRebalanceStacks : CGarrisonOperationPack
{
std : : vector < RebalanceStacks > moves ;
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
template < typename Handler >
void serialize ( Handler & h , const int version )
{
h & moves ;
}
} ;
struct BulkSmartRebalanceStacks : CGarrisonOperationPack
{
std : : vector < RebalanceStacks > moves ;
std : : vector < ChangeStackCount > changes ;
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
template < typename Handler >
void serialize ( Handler & h , const int version )
{
h & moves ;
h & changes ;
}
} ;
2013-06-01 01:23:53 +03:00
struct GetEngagedHeroIds : boost : : static_visitor < boost : : optional < ObjectInstanceID > >
{
boost : : optional < ObjectInstanceID > operator ( ) ( const ConstTransitivePtr < CGHeroInstance > & h ) const
{
return h - > id ;
}
boost : : optional < ObjectInstanceID > operator ( ) ( const ConstTransitivePtr < CStackInstance > & s ) const
{
if ( s - > armyObj & & s - > armyObj - > ID = = Obj : : HERO )
return s - > armyObj - > id ;
return boost : : optional < ObjectInstanceID > ( ) ;
}
} ;
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
struct CArtifactOperationPack : CPackForClient
{
} ;
2016-11-18 16:45:59 +02:00
struct PutArtifact : CArtifactOperationPack
2010-12-17 00:32:53 +02:00
{
ArtifactLocation al ;
2010-12-26 16:34:11 +02:00
ConstTransitivePtr < CArtifactInstance > art ;
2010-12-17 00:32:53 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-12-17 00:32:53 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & al ;
h & art ;
2010-12-17 00:32:53 +02:00
}
} ;
2016-11-18 16:45:59 +02:00
struct EraseArtifact : CArtifactOperationPack
2010-12-17 00:32:53 +02:00
{
ArtifactLocation al ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2010-12-17 00:32:53 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & al ;
}
} ;
2016-11-18 16:45:59 +02:00
struct MoveArtifact : CArtifactOperationPack
2010-12-17 00:32:53 +02:00
{
2023-01-02 16:19:45 +02:00
MoveArtifact ( )
: askAssemble ( true ) { }
MoveArtifact ( ArtifactLocation * src , ArtifactLocation * dst , bool askAssemble = true )
: src ( * src ) , dst ( * dst ) , askAssemble ( askAssemble ) { }
2010-12-17 00:32:53 +02:00
ArtifactLocation src , dst ;
2023-01-02 16:19:45 +02:00
bool askAssemble ;
2010-12-17 00:32:53 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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
}
} ;
2022-11-06 23:29:22 +02:00
struct BulkMoveArtifacts : CArtifactOperationPack
{
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 ;
LinkedSlots ( ) { }
LinkedSlots ( ArtifactPosition srcPos , 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 ( )
: swap ( false ) { }
BulkMoveArtifacts ( TArtHolder srcArtHolder , TArtHolder dstArtHolder , bool swap )
2022-11-07 14:20:28 +02:00
: srcArtHolder ( srcArtHolder ) , dstArtHolder ( dstArtHolder ) , swap ( swap ) { }
2022-11-06 23:29:22 +02:00
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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 ( ) ;
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
}
} ;
2016-11-18 16:45:59 +02:00
struct AssembledArtifact : CArtifactOperationPack
2011-01-22 05:43:20 +02:00
{
ArtifactLocation al ; //where assembly will be put
CArtifact * builtArt ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2011-01-22 05:43:20 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & al ;
h & builtArt ;
2011-01-22 05:43:20 +02:00
}
} ;
2016-11-18 16:45:59 +02:00
struct DisassembledArtifact : CArtifactOperationPack
2011-01-22 05:43:20 +02:00
{
ArtifactLocation al ;
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2011-01-22 05:43:20 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & al ;
}
} ;
2018-03-10 21:19:55 +02:00
struct 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
2018-03-10 21:19:55 +02:00
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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
}
} ;
2016-11-18 16:45:59 +02:00
struct NewTurn : public CPackForClient
2008-08-10 07:46:16 +03:00
{
2011-08-26 23:32:05 +03:00
enum weekType { NORMAL , DOUBLE_GROWTH , BONUS_GROWTH , DEITYOFFIRE , PLAGUE , NO_ACTION } ;
2010-08-22 21:21:45 +03:00
2011-08-25 18:24:37 +03:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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
2008-08-10 07:46:16 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & id ;
h & move ;
h & mana ;
2008-08-10 07:46:16 +03:00
}
bool operator < ( const Hero & h ) const { return id < h . id ; }
} ;
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
2008-08-10 07:46:16 +03:00
ui32 day ;
2010-08-26 10:23:08 +03:00
ui8 specialWeek ; //weekType
2013-02-11 02:24:57 +03:00
CreatureID creatureid ; //for creature weeks
2008-08-10 07:46:16 +03:00
2016-11-25 19:04:07 +02:00
NewTurn ( ) : day ( 0 ) , specialWeek ( 0 ) { } ;
2008-08-10 07:46:16 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
struct InfoWindow : public CPackForClient //103 - displays simple info window
2008-07-31 00:27:15 +03:00
{
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2008-07-31 00:27:15 +03:00
MetaString text ;
std : : vector < Component > components ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-04-22 21:48:56 +03:00
ui16 soundID ;
2008-07-31 00:27:15 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & text ;
h & components ;
h & player ;
h & soundID ;
2008-07-31 00:27:15 +03:00
}
2012-09-15 22:16:16 +03:00
InfoWindow ( )
{
soundID = 0 ;
2010-03-11 01:16:30 +02:00
}
2008-07-30 20:51:19 +03:00
} ;
2010-05-02 21:20:26 +03:00
namespace ObjProperty
{
2011-05-28 04:02:28 +03: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
REWARD_RESET , REWARD_SELECT
2013-02-14 16:19:03 +03:00
} ;
2010-05-02 21:20:26 +03:00
}
2016-11-18 16:45:59 +02:00
struct SetObjectProperty : public CPackForClient
2008-07-30 20:51:19 +03:00
{
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-07-30 15:49:45 +03:00
void applyCl ( CClient * cl ) ;
2009-03-07 00:11:17 +02:00
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ;
2014-04-07 20:32:15 +03:00
ui8 what ; // see ObjProperty enum
2008-07-30 20:51:19 +03:00
ui32 val ;
2016-11-25 19:04:07 +02:00
SetObjectProperty ( ) : what ( 0 ) , val ( 0 ) { }
2016-11-18 16:45:59 +02:00
SetObjectProperty ( ObjectInstanceID ID , ui8 What , ui32 Val ) : id ( ID ) , what ( What ) , val ( Val ) { } ;
2012-09-15 22:16:16 +03:00
2008-07-30 20:51:19 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & id ;
h & what ;
h & val ;
2008-07-30 20:51:19 +03:00
}
} ;
2016-11-18 16:45:59 +02:00
struct 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
} ;
ui32 mode ; // uses VisitMode enum
ObjectInstanceID object ;
ObjectInstanceID hero ; // note: hero owner will be also marked as "visited" this object
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2014-04-11 22:49:25 +03:00
ChangeObjectVisitors ( )
2016-11-25 19:04:07 +02:00
: mode ( VISITOR_CLEAR )
{ }
2014-04-11 22:49:25 +03:00
2014-04-07 20:32:15 +03:00
ChangeObjectVisitors ( ui32 mode , ObjectInstanceID object , ObjectInstanceID heroID = ObjectInstanceID ( - 1 ) ) :
mode ( mode ) ,
object ( object ) ,
hero ( heroID )
2016-11-25 19:04:07 +02:00
{ }
2014-04-07 20:32:15 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & object ;
h & hero ;
h & mode ;
2014-04-07 20:32:15 +03:00
}
} ;
2016-11-18 16:45:59 +02:00
struct 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 ;
2018-03-10 21:19:55 +02:00
PrepareHeroLevelUp ( ) { }
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2016-09-07 23:24:05 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2018-03-10 21:19:55 +02:00
h & heroId ;
2016-09-07 23:24:05 +02:00
}
} ;
2016-11-18 16:45:59 +02:00
struct 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
2013-02-04 22:43:16 +03:00
PrimarySkill : : PrimarySkill primskill ;
2013-02-12 22:49:40 +03:00
std : : vector < SecondarySkill > skills ;
2008-08-04 18:56:36 +03:00
2018-03-10 21:19:55 +02:00
HeroLevelUp ( ) : primskill ( PrimarySkill : : ATTACK ) { }
2012-09-15 22:16:16 +03:00
2018-03-10 21:19:55 +02:00
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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
2012-05-07 15:54:22 +03:00
struct CommanderLevelUp : public Query
{
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
2018-03-10 21:19:55 +02:00
CommanderLevelUp ( ) { }
2012-05-07 15:54:22 +03:00
2018-03-10 21:19:55 +02:00
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
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
2016-11-18 16:45:59 +02:00
struct BlockingDialog : public Query
2008-08-13 03:44:31 +03:00
{
2009-04-11 04:32:50 +03:00
enum { ALLOW_CANCEL = 1 , SELECTION = 2 } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2008-08-13 03:44:31 +03:00
MetaString text ;
std : : vector < Component > components ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-04-11 04:32:50 +03:00
ui8 flags ;
2009-04-22 21:48:56 +03:00
ui16 soundID ;
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 )
{
2009-04-14 13:46:42 +03:00
flags = 0 ;
2009-04-22 21:48:56 +03:00
soundID = 0 ;
2009-04-11 04:32:50 +03:00
if ( yesno ) flags | = ALLOW_CANCEL ;
if ( Selection ) flags | = SELECTION ;
}
BlockingDialog ( )
{
2009-04-14 13:46:42 +03:00
flags = 0 ;
2009-04-22 21:48:56 +03:00
soundID = 0 ;
2009-04-11 04:32:50 +03:00
} ;
2008-08-22 15:21:09 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2016-11-18 16:45:59 +02:00
struct GarrisonDialog : public Query
2009-04-12 03:58:41 +03:00
{
2016-11-25 19:04:07 +02:00
GarrisonDialog ( ) : removableUnits ( false ) { }
2009-04-12 03:58:41 +03:00
void applyCl ( CClient * cl ) ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID objid , hid ;
2009-09-09 20:49:03 +03:00
bool removableUnits ;
2009-04-12 03:58:41 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & queryID ;
h & objid ;
h & hid ;
h & removableUnits ;
2009-04-12 03:58:41 +03:00
}
} ;
2016-11-18 16:45:59 +02:00
struct ExchangeDialog : public Query
2013-05-27 13:53:28 +03:00
{
2018-03-10 21:19:55 +02:00
ExchangeDialog ( ) { }
2013-05-27 13:53:28 +03:00
void applyCl ( CClient * cl ) ;
2018-03-10 21:19:55 +02:00
PlayerColor player ;
ObjectInstanceID hero1 ;
ObjectInstanceID hero2 ;
2013-05-27 13:53:28 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2016-11-18 16:45:59 +02:00
struct TeleportDialog : public Query
2015-03-08 15:37:33 +02:00
{
2016-11-26 19:49:26 +02:00
TeleportDialog ( )
2018-03-10 21:19:55 +02:00
: impassable ( false )
2016-11-26 19:49:26 +02:00
{ }
2018-03-10 21:19:55 +02:00
TeleportDialog ( PlayerColor Player , TeleportChannelID Channel )
: player ( Player ) , channel ( Channel ) , impassable ( false )
2016-11-26 19:49:26 +02:00
{ }
2015-03-08 15:37:33 +02:00
void applyCl ( CClient * cl ) ;
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 ;
2015-03-08 15:37:33 +02:00
bool impassable ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2017-06-06 06:53:51 +02:00
struct MapObjectSelectDialog : public Query
{
PlayerColor player ;
Component icon ;
MetaString title ;
MetaString description ;
std : : vector < ObjectInstanceID > objects ;
MapObjectSelectDialog ( ) { } ;
void applyCl ( CClient * cl ) ;
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 ;
2016-11-18 16:45:59 +02:00
struct BattleStart : public CPackForClient
2008-08-04 18:56:36 +03:00
{
2016-11-26 19:49:26 +02:00
BattleStart ( )
: info ( nullptr )
{ }
2013-09-14 22:09:35 +03:00
void applyFirstCl ( CClient * cl ) ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2008-08-04 18:56:36 +03:00
BattleInfo * info ;
2012-09-15 22:16:16 +03:00
2008-08-04 18:56:36 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & info ;
}
} ;
2016-11-26 19:49:26 +02:00
2016-11-18 16:45:59 +02:00
struct BattleNextRound : public CPackForClient
2012-09-15 22:16:16 +03:00
{
2016-11-26 19:49:26 +02:00
BattleNextRound ( ) : round ( 0 ) { } ;
2010-05-07 15:29:41 +03:00
void applyFirstCl ( CClient * cl ) ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2008-08-04 18:56:36 +03:00
si32 round ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & round ;
}
} ;
2016-11-26 19:49:26 +02:00
2016-11-18 16:45:59 +02:00
struct BattleSetActiveStack : public CPackForClient
2008-08-04 18:56:36 +03:00
{
2012-08-27 15:34:43 +03:00
BattleSetActiveStack ( )
{
2016-11-26 19:49:26 +02:00
stack = 0 ;
2012-08-27 15:34:43 +03:00
askPlayerInterface = true ;
}
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2008-08-04 18:56:36 +03:00
ui32 stack ;
2012-08-27 15:34:43 +03:00
ui8 askPlayerInterface ;
2008-08-04 18:56:36 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
2016-11-18 16:45:59 +02:00
struct BattleResult : public CPackForClient
2008-08-04 18:56:36 +03:00
{
2012-05-01 11:52:22 +03:00
enum EResult { NORMAL = 0 , ESCAPE = 1 , SURRENDER = 2 } ;
2016-11-26 19:49:26 +02:00
BattleResult ( )
: result ( NORMAL ) , winner ( 2 )
{
exp [ 0 ] = 0 ;
exp [ 1 ] = 0 ;
} ;
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
2009-03-07 19:08:40 +02:00
void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
2013-02-04 22:43:16 +03:00
EResult result ;
2008-08-04 18:56:36 +03:00
ui8 winner ; //0 - attacker, 1 - defender, [2 - draw (should be possible?)]
2009-09-24 16:23:52 +03:00
std : : map < ui32 , si32 > casualties [ 2 ] ; //first => casualties of attackers - map crid => number
2012-09-23 21:01:04 +03:00
TExpType exp [ 2 ] ; //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
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
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
struct BattleLogMessage : public CPackForClient
{
std : : vector < MetaString > lines ;
BattleLogMessage ( ) { }
void applyCl ( CClient * cl ) ;
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
DLL_LINKAGE void applyBattle ( IBattleState * battleState ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & lines ;
}
} ;
2016-11-18 16:45:59 +02:00
struct BattleStackMoved : public CPackForClient
2008-08-05 02:04:15 +03:00
{
2011-01-09 19:41:46 +02:00
ui32 stack ;
2011-12-22 16:05:19 +03:00
std : : vector < BattleHex > tilesToMove ;
2017-07-20 06:08:49 +02:00
int distance ;
bool teleporting ;
2016-11-26 19:49:26 +02:00
BattleStackMoved ( )
2017-07-20 06:08:49 +02:00
: stack ( 0 ) ,
distance ( 0 ) ,
teleporting ( false )
2016-11-26 19:49:26 +02:00
{ } ;
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
2017-07-20 06:08:49 +02:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
DLL_LINKAGE void applyBattle ( IBattleState * battleState ) ;
2008-08-05 02:04:15 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2017-07-20 06:08:49 +02:00
struct BattleUnitsChanged : public CPackForClient
2010-05-07 15:29:41 +03:00
{
2017-07-20 06:08:49 +02:00
BattleUnitsChanged ( ) { }
2010-05-07 15:29:41 +03:00
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2017-07-20 06:08:49 +02:00
DLL_LINKAGE void applyBattle ( IBattleState * battleState ) ;
2010-05-07 15:29:41 +03:00
void applyCl ( CClient * cl ) ;
2017-07-20 06:08:49 +02:00
std : : vector < UnitChanges > changedStacks ;
2010-05-07 15:29:41 +03:00
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
{
2014-11-27 23:36:14 +02:00
BattleStackAttacked ( ) :
2022-12-09 13:10:35 +02:00
stackAttacked ( 0 ) ,
attackerID ( 0 ) ,
killedAmount ( 0 ) ,
damageAmount ( 0 ) ,
2017-07-20 06:08:49 +02:00
newState ( ) ,
2022-12-09 13:10:35 +02:00
flags ( 0 ) ,
spellID ( SpellID : : NONE )
2016-11-26 19:49:26 +02:00
{ } ;
2017-07-20 06:08:49 +02:00
2011-12-14 00:23:17 +03: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
2009-09-15 15:20:11 +03:00
ui32 stackAttacked , attackerID ;
2017-07-04 13:24:46 +02:00
ui32 killedAmount ;
2017-07-20 06:08:49 +02:00
int64_t damageAmount ;
UnitChanges newState ;
2022-12-17 17:35:15 +02:00
enum EFlags { KILLED = 1 , SECONDARY = 2 , REBIRTH = 4 , CLONE_KILLED = 8 , SPELL_EFFECT = 16 , FIRE_SHIELD = 32 , } ;
2014-11-27 23:36:14 +02:00
ui32 flags ; //uses EFlags (above)
SpellID spellID ; //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 ;
}
2008-08-09 02:02:32 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
2009-03-21 14:49:58 +02:00
bool operator < ( const BattleStackAttacked & b ) const
{
return stackAttacked < b . stackAttacked ;
}
2008-08-09 02:02:32 +03:00
} ;
2016-11-18 16:45:59 +02:00
struct BattleAttack : public CPackForClient
2008-08-09 02:02:32 +03:00
{
2016-11-26 19:49:26 +02:00
BattleAttack ( )
: stackAttacking ( 0 ) , flags ( 0 ) , spellID ( SpellID : : NONE )
{ } ;
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2017-07-20 06:08:49 +02:00
BattleUnitsChanged attackerChanges ;
2010-02-20 15:24:38 +02:00
std : : vector < BattleStackAttacked > bsa ;
2008-08-09 02:02:32 +03:00
ui32 stackAttacking ;
2014-11-27 23:36:14 +02:00
ui32 flags ; //uses Eflags (below)
2022-12-11 12:29:11 +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 ;
2016-08-30 04:13:45 +02:00
SpellID spellID ; //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 ;
}
2008-08-09 02:02:32 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2016-11-18 16:45:59 +02:00
struct StartAction : public CPackForClient
2008-09-29 00:01:49 +03:00
{
2016-11-18 16:45:59 +02:00
StartAction ( ) { } ;
StartAction ( const BattleAction & act ) { ba = act ; } ;
2009-03-07 00:11:17 +02:00
void applyFirstCl ( CClient * cl ) ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
BattleAction ba ;
2008-09-29 00:01:49 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & ba ;
}
} ;
2016-11-18 16:45:59 +02:00
struct EndAction : public CPackForClient
2008-10-18 14:41:24 +03:00
{
2016-11-18 16:45:59 +02:00
EndAction ( ) { } ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2009-03-07 00:25:19 +02:00
2009-03-07 00:11:17 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
}
} ;
2016-11-18 16:45:59 +02:00
struct BattleSpellCast : public CPackForClient
2008-10-18 14:41:24 +03:00
{
2016-11-26 19:49:26 +02:00
BattleSpellCast ( )
{
side = 0 ;
manaGained = 0 ;
casterStack = - 1 ;
castByHero = true ;
2017-09-08 13:25:12 +02:00
activeCast = true ;
2016-11-26 19:49:26 +02:00
} ;
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2009-03-07 00:11:17 +02:00
void applyCl ( CClient * cl ) ;
2017-09-08 13:25:12 +02:00
bool activeCast ;
2009-05-12 06:35:51 +03:00
ui8 side ; //which hero did cast spell: 0 - attacker, 1 - defender
2017-07-20 06:08:49 +02:00
SpellID spellID ; //id of spell
2011-10-09 14:23:24 +03:00
ui8 manaGained ; //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)
2014-11-27 19:47:37 +02:00
si32 casterStack ; // -1 if not cated by creature, >=0 caster stack ID
2015-09-21 11:19:35 +02:00
bool castByHero ; //if true - spell has been cast by hero, otherwise by a creature
2016-09-10 17:23:55 +02:00
2008-10-18 14:41:24 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2016-11-18 16:45:59 +02:00
struct SetStackEffect : public CPackForClient
2008-11-09 00:29:19 +02:00
{
2016-11-18 16:45:59 +02:00
SetStackEffect ( ) { } ;
2017-07-20 06:08:49 +02:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
DLL_LINKAGE void applyBattle ( IBattleState * battleState ) ;
void applyCl ( CClient * cl ) ;
2016-11-02 19:11:01 +02:00
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
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
}
} ;
2016-11-18 16:45:59 +02:00
struct StacksInjured : public CPackForClient
2009-04-16 03:28:54 +03:00
{
2016-11-18 16:45:59 +02:00
StacksInjured ( ) { }
2017-07-20 06:08:49 +02:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
DLL_LINKAGE void applyBattle ( IBattleState * battleState ) ;
void applyCl ( CClient * cl ) ;
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
template < typename Handler > void serialize ( Handler & h , const int version )
2009-04-16 03:28:54 +03:00
{
h & stacks ;
}
} ;
2016-11-18 16:45:59 +02:00
struct BattleResultsApplied : public CPackForClient
2009-08-04 02:53:18 +03:00
{
2016-11-18 16:45:59 +02:00
BattleResultsApplied ( ) { }
2009-08-04 02:53:18 +03:00
2013-03-03 20:06:03 +03:00
PlayerColor player1 , player2 ;
2009-08-04 02:53:18 +03:00
void applyCl ( CClient * cl ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & player1 ;
h & player2 ;
2009-08-04 02:53:18 +03:00
}
} ;
2017-07-20 06:08:49 +02:00
struct BattleObstaclesChanged : public CPackForClient
2009-08-19 13:59:42 +03:00
{
2017-07-20 06:08:49 +02:00
BattleObstaclesChanged ( ) { }
2009-08-19 13:59:42 +03:00
2017-07-20 06:08:49 +02:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
DLL_LINKAGE void applyBattle ( IBattleState * battleState ) ;
void applyCl ( CClient * cl ) ;
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
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
} ;
2016-11-18 16:45:59 +02:00
struct ELF_VISIBILITY CatapultAttack : public CPackForClient
2009-09-01 16:54:13 +03:00
{
2013-08-06 14:20:28 +03:00
struct AttackInfo
{
si16 destinationTile ;
ui8 attackedPart ;
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
}
} ;
2014-06-24 17:17:25 +03:00
DLL_LINKAGE CatapultAttack ( ) ;
DLL_LINKAGE ~ CatapultAttack ( ) ;
2009-09-01 16:54:13 +03:00
2017-07-20 06:08:49 +02:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
DLL_LINKAGE void applyBattle ( IBattleState * battleState ) ;
void applyCl ( CClient * cl ) ;
2009-09-01 16:54:13 +03:00
2013-08-06 14:20:28 +03:00
std : : vector < AttackInfo > attackedParts ;
2009-09-24 16:44:55 +03:00
int attacker ; //if -1, then a spell caused this
2009-09-01 16:54:13 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
} ;
2016-11-18 16:45:59 +02:00
struct BattleSetStackProperty : public CPackForClient
2011-10-02 16:59:12 +03:00
{
2016-11-26 19:49:26 +02:00
BattleSetStackProperty ( )
: stackID ( 0 ) , which ( CASTS ) , val ( 0 ) , absolute ( 0 )
{ } ;
2011-10-02 16:59:12 +03:00
2015-09-14 19:13:26 +02:00
enum BattleStackProperty { CASTS , ENCHANTER_COUNTER , UNBIND , CLONED , HAS_CLONE } ;
2011-10-02 16:59:12 +03:00
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2011-10-02 16:59:12 +03:00
int stackID ;
2013-02-04 22:43:16 +03:00
BattleStackProperty which ;
2011-10-02 16:59:12 +03:00
int val ;
int absolute ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & stackID ;
h & which ;
h & val ;
h & absolute ;
2011-10-02 16:59:12 +03:00
}
} ;
2016-11-26 19:49:26 +02:00
///activated at the beginning of turn
2016-11-18 16:45:59 +02:00
struct BattleTriggerEffect : public CPackForClient
2016-11-26 19:49:26 +02:00
{
BattleTriggerEffect ( )
: stackID ( 0 ) , effect ( 0 ) , val ( 0 ) , additionalInfo ( 0 )
{ } ;
2011-10-08 16:02:58 +03:00
2011-12-14 00:23:17 +03:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ; //effect
2011-10-08 16:02:58 +03:00
void applyCl ( CClient * cl ) ; //play animations & stuff
int stackID ;
2016-11-18 16:45:59 +02:00
int effect ; //use corresponding Bonus type
2011-10-08 16:02:58 +03:00
int val ;
int additionalInfo ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & stackID ;
h & effect ;
h & val ;
h & additionalInfo ;
2011-10-08 16:02:58 +03:00
}
} ;
2016-11-18 16:45:59 +02:00
struct BattleUpdateGateState : public CPackForClient
2016-01-29 21:35:11 +02:00
{
2016-11-26 19:49:26 +02:00
BattleUpdateGateState ( ) : state ( EGateState : : NONE ) { } ;
2016-01-29 21:35:11 +02:00
2016-02-10 06:10:32 +02:00
void applyFirstCl ( CClient * cl ) ;
2016-01-29 21:35:11 +02:00
DLL_LINKAGE void applyGs ( CGameState * gs ) ;
2016-02-13 16:40:31 +02:00
EGateState state ;
2016-01-29 21:35:11 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & state ;
}
} ;
2016-11-18 16:45:59 +02:00
struct ShowInInfobox : public CPackForClient
2008-08-04 18:56:36 +03:00
{
2016-11-18 16:45:59 +02:00
ShowInInfobox ( ) { } ;
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2008-08-04 18:56:36 +03:00
Component c ;
MetaString text ;
2009-03-07 00:25:19 +02:00
void applyCl ( CClient * cl ) ;
2008-08-04 18:56:36 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & player ;
h & c ;
h & text ;
2008-08-04 18:56:36 +03:00
}
2010-05-16 16:42:19 +03:00
} ;
2016-11-18 16:45:59 +02:00
struct AdvmapSpellCast : public CPackForClient
2010-05-16 16:42:19 +03:00
{
2018-03-10 21:19:55 +02:00
AdvmapSpellCast ( ) : casterID ( ) { }
ObjectInstanceID casterID ;
2013-03-03 20:06:03 +03:00
SpellID spellID ;
2010-05-16 16:42:19 +03:00
void applyCl ( CClient * cl ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
2008-12-26 17:00:34 +02:00
} ;
2009-03-09 12:37:49 +02:00
2016-11-18 16:45:59 +02:00
struct ShowWorldViewEx : public CPackForClient
2015-02-26 16:15:17 +02:00
{
PlayerColor player ;
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
2016-11-18 16:45:59 +02:00
ShowWorldViewEx ( ) { }
2016-08-30 04:13:45 +02:00
2015-02-26 16:15:17 +02:00
void applyCl ( CClient * cl ) ;
2016-08-30 04:13:45 +02:00
2015-02-26 16:15:17 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
2017-07-31 15:35:42 +02:00
h & player ;
h & objectPositions ;
2016-08-30 04:13:45 +02:00
}
2015-02-26 16:15:17 +02:00
} ;
2009-03-09 12:37:49 +02:00
/***********************************************************************************************************/
struct EndTurn : public CPackForServer
{
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
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
} ;
struct DismissHero : public CPackForServer
{
DismissHero ( ) { } ;
2013-02-14 02:55:42 +03:00
DismissHero ( ObjectInstanceID HID ) : hid ( HID ) { } ;
ObjectInstanceID hid ;
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
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
h & hid ;
}
} ;
struct MoveHero : public CPackForServer
{
2016-11-26 19:49:26 +02:00
MoveHero ( ) : transit ( false ) { } ;
2015-03-08 16:04:09 +02:00
MoveHero ( const int3 & Dest , ObjectInstanceID HID , bool Transit ) : dest ( Dest ) , hid ( HID ) , transit ( Transit ) { } ;
2009-03-09 12:37:49 +02:00
int3 dest ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID hid ;
2015-03-08 16:04:09 +02:00
bool transit ;
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
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
}
} ;
struct CastleTeleportHero : public CPackForServer
{
2016-11-26 19:49:26 +02:00
CastleTeleportHero ( ) : source ( 0 ) { } ;
2013-02-14 02:55:42 +03:00
CastleTeleportHero ( const ObjectInstanceID HID , ObjectInstanceID Dest , ui8 Source ) : dest ( Dest ) , hid ( HID ) , source ( Source ) { } ;
ObjectInstanceID dest ;
ObjectInstanceID hid ;
2010-06-30 22:27:35 +03:00
si8 source ; //who give teleporting, 1=castle gate
bool applyGh ( CGameHandler * gh ) ;
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
}
} ;
struct ArrangeStacks : public CPackForServer
{
2016-11-26 19:49:26 +02:00
ArrangeStacks ( ) : what ( 0 ) , val ( 0 ) { } ;
2013-02-16 17:03:47 +03:00
ArrangeStacks ( ui8 W , SlotID P1 , SlotID P2 , ObjectInstanceID ID1 , ObjectInstanceID ID2 , si32 VAL )
2009-03-09 12:37:49 +02:00
: what ( W ) , p1 ( P1 ) , p2 ( P2 ) , id1 ( ID1 ) , id2 ( ID2 ) , val ( VAL ) { } ;
ui8 what ; //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
2009-03-09 12:37:49 +02:00
si32 val ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2021-11-28 14:57:38 +02:00
struct BulkMoveArmy : public CPackForServer
{
SlotID srcSlot ;
ObjectInstanceID srcArmy ;
ObjectInstanceID destArmy ;
BulkMoveArmy ( )
{ } ;
BulkMoveArmy ( ObjectInstanceID srcArmy , ObjectInstanceID destArmy , SlotID srcSlot )
: srcArmy ( srcArmy ) , destArmy ( destArmy ) , srcSlot ( srcSlot )
{ } ;
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler >
void serialize ( Handler & h , const int version )
{
h & static_cast < CPackForServer & > ( * this ) ;
h & srcSlot ;
h & srcArmy ;
h & destArmy ;
}
} ;
struct BulkSplitStack : public CPackForServer
{
SlotID src ;
ObjectInstanceID srcOwner ;
si32 amount ;
BulkSplitStack ( ) : amount ( 0 )
{ } ;
BulkSplitStack ( ObjectInstanceID srcOwner , SlotID src , si32 howMany )
: src ( src ) , srcOwner ( srcOwner ) , amount ( howMany )
{ } ;
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler >
void serialize ( Handler & h , const int version )
{
h & static_cast < CPackForServer & > ( * this ) ;
h & src ;
h & srcOwner ;
h & amount ;
}
} ;
struct BulkMergeStacks : public CPackForServer
{
SlotID src ;
ObjectInstanceID srcOwner ;
BulkMergeStacks ( )
{ } ;
BulkMergeStacks ( ObjectInstanceID srcOwner , SlotID src )
: src ( src ) , srcOwner ( srcOwner )
{ } ;
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler >
void serialize ( Handler & h , const int version )
{
h & static_cast < CPackForServer & > ( * this ) ;
h & src ;
h & srcOwner ;
}
} ;
struct BulkSmartSplitStack : public CPackForServer
{
SlotID src ;
ObjectInstanceID srcOwner ;
BulkSmartSplitStack ( )
{ } ;
BulkSmartSplitStack ( ObjectInstanceID srcOwner , SlotID src )
: src ( src ) , srcOwner ( srcOwner )
{ } ;
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler >
void serialize ( Handler & h , const int version )
{
h & static_cast < CPackForServer & > ( * this ) ;
h & src ;
h & srcOwner ;
}
} ;
2009-03-09 12:37:49 +02:00
struct DisbandCreature : public CPackForServer
{
DisbandCreature ( ) { } ;
2013-02-16 17:03:47 +03:00
DisbandCreature ( SlotID Pos , ObjectInstanceID ID ) : pos ( Pos ) , id ( ID ) { } ;
SlotID pos ; //stack pos
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //object id
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
struct BuildStructure : public CPackForServer
{
BuildStructure ( ) { } ;
2013-02-14 02:55:42 +03:00
BuildStructure ( ObjectInstanceID TID , BuildingID BID ) : tid ( TID ) , bid ( BID ) { } ;
ObjectInstanceID tid ; //town id
2013-02-11 22:11:34 +03:00
BuildingID bid ; //structure id
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
2009-09-22 17:27:46 +03:00
struct RazeStructure : public BuildStructure
{
RazeStructure ( ) { } ;
2009-03-09 12:37:49 +02:00
2009-09-22 17:27:46 +03:00
bool applyGh ( CGameHandler * gh ) ;
} ;
2016-11-26 19:49:26 +02:00
2009-03-09 12:37:49 +02:00
struct RecruitCreatures : public CPackForServer
{
2016-11-26 19:49:26 +02:00
RecruitCreatures ( ) : amount ( 0 ) , level ( 0 ) { } ;
2014-09-19 00:18:49 +03:00
RecruitCreatures ( ObjectInstanceID TID , ObjectInstanceID DST , CreatureID CRID , si32 Amount , si32 Level ) :
tid ( TID ) , dst ( DST ) , crid ( CRID ) , amount ( Amount ) , level ( Level ) { } ;
ObjectInstanceID tid ; //dwelling id, or town
ObjectInstanceID dst ; //destination ID, e.g. hero
2013-02-11 02:24:57 +03:00
CreatureID crid ;
2013-02-07 20:34:50 +03:00
ui32 amount ; //creature amount
2010-07-10 19:50:23 +03:00
si32 level ; //dwelling level to buy from, -1 if any
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
struct UpgradeCreature : public CPackForServer
{
UpgradeCreature ( ) { } ;
2013-02-16 17:03:47 +03:00
UpgradeCreature ( SlotID Pos , ObjectInstanceID ID , CreatureID CRID ) : pos ( Pos ) , id ( ID ) , cid ( CRID ) { } ;
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
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
struct GarrisonHeroSwap : public CPackForServer
{
GarrisonHeroSwap ( ) { } ;
2013-02-14 02:55:42 +03:00
GarrisonHeroSwap ( ObjectInstanceID TID ) : tid ( TID ) { } ;
ObjectInstanceID tid ;
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
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
h & tid ;
}
} ;
struct ExchangeArtifacts : public CPackForServer
{
2012-04-14 05:20:22 +03:00
ArtifactLocation src , dst ;
2009-03-09 12:37:49 +02:00
ExchangeArtifacts ( ) { } ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2022-11-06 23:29:22 +02:00
struct BulkExchangeArtifacts : public CPackForServer
{
ObjectInstanceID srcHero ;
ObjectInstanceID dstHero ;
bool swap ;
2022-11-10 20:48:19 +02:00
BulkExchangeArtifacts ( )
: swap ( false ) { }
2022-11-06 23:29:22 +02:00
BulkExchangeArtifacts ( ObjectInstanceID srcHero , ObjectInstanceID dstHero , bool swap )
2022-11-10 20:48:19 +02:00
: srcHero ( srcHero ) , dstHero ( dstHero ) , swap ( swap ) { }
2022-11-06 23:29:22 +02:00
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
h & static_cast < CPackForServer & > ( * this ) ;
h & srcHero ;
h & dstHero ;
h & swap ;
}
} ;
2010-02-16 16:39:56 +02:00
struct AssembleArtifacts : public CPackForServer
{
2016-11-26 19:49:26 +02:00
AssembleArtifacts ( ) : assemble ( false ) { } ;
2013-02-16 17:03:47 +03:00
AssembleArtifacts ( ObjectInstanceID _heroID , ArtifactPosition _artifactSlot , bool _assemble , ArtifactID _assembleTo )
2010-02-16 16:39:56 +02:00
: heroID ( _heroID ) , artifactSlot ( _artifactSlot ) , assemble ( _assemble ) , assembleTo ( _assembleTo ) { } ;
2013-02-14 02:55:42 +03:00
ObjectInstanceID heroID ;
2013-02-12 22:49:40 +03:00
ArtifactPosition artifactSlot ;
2010-02-16 16:39:56 +02:00
bool assemble ; // 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
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2009-03-09 12:37:49 +02:00
struct BuyArtifact : public CPackForServer
{
BuyArtifact ( ) { } ;
2013-02-14 02:55:42 +03:00
BuyArtifact ( ObjectInstanceID HID , ArtifactID AID ) : hid ( HID ) , aid ( AID ) { } ;
ObjectInstanceID hid ;
2013-02-11 02:24:57 +03:00
ArtifactID aid ;
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
struct TradeOnMarketplace : public CPackForServer
{
2016-11-26 19:49:26 +02:00
TradeOnMarketplace ( )
2018-03-10 21:19:55 +02:00
: marketId ( ) , heroId ( ) , mode ( EMarketMode : : RESOURCE_RESOURCE )
2016-11-26 19:49:26 +02:00
{ } ;
2010-05-18 10:01:54 +03:00
2018-03-10 21:19:55 +02:00
ObjectInstanceID marketId ;
ObjectInstanceID heroId ;
2013-02-04 22:43:16 +03:00
EMarketMode : : EMarketMode mode ;
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
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
struct SetFormation : public CPackForServer
{
2016-11-26 19:49:26 +02:00
SetFormation ( ) : formation ( 0 ) { } ;
2013-02-14 02:55:42 +03:00
SetFormation ( ObjectInstanceID HID , ui8 Formation ) : hid ( HID ) , formation ( Formation ) { } ;
ObjectInstanceID hid ;
2009-03-09 12:37:49 +02:00
ui8 formation ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
struct HireHero : public CPackForServer
{
2016-11-26 19:49:26 +02:00
HireHero ( ) : hid ( 0 ) { } ;
2013-02-14 02:55:42 +03:00
HireHero ( si32 HID , ObjectInstanceID TID ) : hid ( HID ) , tid ( TID ) { } ;
si32 hid ; //available hero serial
ObjectInstanceID tid ; //town (tavern) id
2013-03-03 20:06:03 +03:00
PlayerColor player ;
2009-03-09 12:37:49 +02:00
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2012-09-15 22:16:16 +03:00
struct BuildBoat : public CPackForServer
2009-07-26 06:33:13 +03:00
{
BuildBoat ( ) { } ;
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
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2009-07-26 06:33:13 +03:00
h & objid ;
}
} ;
2009-03-09 12:37:49 +02:00
struct QueryReply : public CPackForServer
{
2017-06-06 06:53:51 +02:00
QueryReply ( ) { } ;
QueryReply ( QueryID QID , const JsonNode & Reply ) : qid ( QID ) , reply ( Reply ) { } ;
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
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
struct MakeAction : public CPackForServer
{
MakeAction ( ) { } ;
2009-03-09 21:40:43 +02:00
MakeAction ( const BattleAction & BA ) : ba ( BA ) { } ;
2009-03-09 12:37:49 +02:00
BattleAction ba ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
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
h & ba ;
}
} ;
struct MakeCustomAction : public CPackForServer
{
MakeCustomAction ( ) { } ;
2009-03-20 20:51:48 +02:00
MakeCustomAction ( const BattleAction & BA ) : ba ( BA ) { } ;
2009-03-09 12:37:49 +02:00
BattleAction ba ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-09 12:37:49 +02:00
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
h & ba ;
}
} ;
2010-02-21 17:03:30 +02:00
struct DigWithHero : public CPackForServer
{
DigWithHero ( ) { }
2013-02-14 02:55:42 +03:00
ObjectInstanceID id ; //digging hero id
2010-02-21 17:03:30 +02:00
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
2018-01-05 19:21:07 +02:00
h & static_cast < CPackForServer & > ( * this ) ;
2010-02-21 17:03:30 +02:00
h & id ;
}
} ;
2010-03-11 01:16:30 +02:00
struct CastAdvSpell : public CPackForServer
{
CastAdvSpell ( ) { }
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)
bool applyGh ( CGameHandler * gh ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
/***********************************************************************************************************/
2018-01-05 19:21:07 +02:00
struct SaveGame : public CPackForServer
2009-03-28 20:46:20 +02:00
{
SaveGame ( ) { } ;
SaveGame ( const std : : string & Fname ) : fname ( Fname ) { } ;
std : : string fname ;
void applyGs ( CGameState * gs ) { } ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
2009-03-28 20:46:20 +02:00
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 ;
}
} ;
// TODO: Eventually we should re-merge both SaveGame and PlayerMessage
struct SaveGameClient : public CPackForClient
{
SaveGameClient ( ) { } ;
SaveGameClient ( const std : : string & Fname ) : fname ( Fname ) { } ;
std : : string fname ;
void applyCl ( CClient * cl ) ;
template < typename Handler > void serialize ( Handler & h , const int version )
2009-03-28 20:46:20 +02:00
{
h & fname ;
}
} ;
2018-01-05 19:21:07 +02:00
struct PlayerMessage : public CPackForServer
2009-03-09 12:37:49 +02:00
{
2016-11-18 16:45:59 +02:00
PlayerMessage ( ) { } ;
2018-01-05 19:21:07 +02:00
PlayerMessage ( const std : : string & Text , ObjectInstanceID obj )
: text ( Text ) , currObj ( obj )
2016-11-18 16:45:59 +02:00
{ } ;
2009-03-09 12:37:49 +02:00
void applyGs ( CGameState * gs ) { } ;
2009-04-16 03:28:54 +03:00
bool applyGh ( CGameHandler * gh ) ;
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
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
2018-01-05 19:21:07 +02:00
struct PlayerMessageClient : public CPackForClient
2009-08-11 10:50:29 +03:00
{
2018-01-05 19:21:07 +02:00
PlayerMessageClient ( ) { } ;
PlayerMessageClient ( PlayerColor Player , const std : : string & Text )
: player ( Player ) , text ( Text )
{ }
2009-08-11 10:50:29 +03:00
void applyCl ( CClient * cl ) ;
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
2009-03-09 12:37:49 +02:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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
}
} ;
2018-01-05 19:21:07 +02:00
struct CenterView : public CPackForClient
2010-10-24 14:35:14 +03:00
{
2018-01-05 19:21:07 +02:00
CenterView ( ) : focusTime ( 0 ) { } ;
void applyCl ( CClient * cl ) ;
2010-10-24 14:35:14 +03:00
2018-01-05 19:21:07 +02:00
PlayerColor player ;
int3 pos ;
ui32 focusTime ; //ms
2010-10-24 14:35:14 +03:00
template < typename Handler > void serialize ( Handler & h , const int version )
{
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