1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-14 10:12:59 +02:00
vcmi/lib/networkPacks/PacksForServer.h

749 lines
16 KiB
C++
Raw Normal View History

/*
* PacksForServer.h, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#pragma once
#include "ArtifactLocation.h"
#include "NetPacksBase.h"
#include "TradeItem.h"
#include "../int3.h"
#include "../battle/BattleAction.h"
VCMI_LIB_NAMESPACE_BEGIN
struct DLL_LINKAGE GamePause : public CPackForServer
{
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
}
};
struct DLL_LINKAGE EndTurn : public CPackForServer
{
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
}
};
struct DLL_LINKAGE DismissHero : public CPackForServer
{
DismissHero() = default;
DismissHero(const ObjectInstanceID & HID)
: hid(HID)
{
}
ObjectInstanceID hid;
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & hid;
}
};
struct DLL_LINKAGE MoveHero : public CPackForServer
{
MoveHero() = default;
MoveHero(const std::vector<int3> & path, const ObjectInstanceID & HID, bool Transit)
: path(path)
, hid(HID)
, transit(Transit)
{
}
std::vector<int3> path;
ObjectInstanceID hid;
bool transit = false;
void visitTyped(ICPackVisitor & visitor) override;
template<typename Handler>
void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & path;
h & hid;
h & transit;
}
};
struct DLL_LINKAGE CastleTeleportHero : public CPackForServer
{
CastleTeleportHero() = default;
CastleTeleportHero(const ObjectInstanceID & HID, const ObjectInstanceID & Dest, ui8 Source)
: dest(Dest)
, hid(HID)
, source(Source)
{
}
ObjectInstanceID dest;
ObjectInstanceID hid;
si8 source = 0; //who give teleporting, 1=castle gate
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & dest;
h & hid;
}
};
struct DLL_LINKAGE ArrangeStacks : public CPackForServer
{
ArrangeStacks() = default;
ArrangeStacks(ui8 W, const SlotID & P1, const SlotID & P2, const ObjectInstanceID & ID1, const ObjectInstanceID & ID2, si32 VAL)
: what(W)
, p1(P1)
, p2(P2)
, id1(ID1)
, id2(ID2)
, val(VAL)
{
}
ui8 what = 0; //1 - swap; 2 - merge; 3 - split
SlotID p1, p2; //positions of first and second stack
ObjectInstanceID id1, id2; //ids of objects with garrison
si32 val = 0;
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & what;
h & p1;
h & p2;
h & id1;
h & id2;
h & val;
}
};
struct DLL_LINKAGE BulkMoveArmy : public CPackForServer
{
SlotID srcSlot;
ObjectInstanceID srcArmy;
ObjectInstanceID destArmy;
BulkMoveArmy() = default;
BulkMoveArmy(const ObjectInstanceID & srcArmy, const ObjectInstanceID & destArmy, const SlotID & srcSlot)
: srcArmy(srcArmy)
, destArmy(destArmy)
, srcSlot(srcSlot)
{
}
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler>
void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & srcSlot;
h & srcArmy;
h & destArmy;
}
};
struct DLL_LINKAGE BulkSplitStack : public CPackForServer
{
SlotID src;
ObjectInstanceID srcOwner;
si32 amount = 0;
BulkSplitStack() = default;
BulkSplitStack(const ObjectInstanceID & srcOwner, const SlotID & src, si32 howMany)
: src(src)
, srcOwner(srcOwner)
, amount(howMany)
{
}
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler>
void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & src;
h & srcOwner;
h & amount;
}
};
struct DLL_LINKAGE BulkMergeStacks : public CPackForServer
{
SlotID src;
ObjectInstanceID srcOwner;
BulkMergeStacks() = default;
BulkMergeStacks(const ObjectInstanceID & srcOwner, const SlotID & src)
: src(src)
, srcOwner(srcOwner)
{
}
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler>
void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & src;
h & srcOwner;
}
};
struct DLL_LINKAGE BulkSmartSplitStack : public CPackForServer
{
SlotID src;
ObjectInstanceID srcOwner;
BulkSmartSplitStack() = default;
BulkSmartSplitStack(const ObjectInstanceID & srcOwner, const SlotID & src)
: src(src)
, srcOwner(srcOwner)
{
}
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler>
void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & src;
h & srcOwner;
}
};
struct DLL_LINKAGE DisbandCreature : public CPackForServer
{
DisbandCreature() = default;
DisbandCreature(const SlotID & Pos, const ObjectInstanceID & ID)
: pos(Pos)
, id(ID)
{
}
SlotID pos; //stack pos
ObjectInstanceID id; //object id
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & pos;
h & id;
}
};
struct DLL_LINKAGE BuildStructure : public CPackForServer
{
BuildStructure() = default;
BuildStructure(const ObjectInstanceID & TID, const BuildingID & BID)
: tid(TID)
, bid(BID)
{
}
ObjectInstanceID tid; //town id
BuildingID bid; //structure id
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & tid;
h & bid;
}
};
struct DLL_LINKAGE VisitTownBuilding : public CPackForServer
2024-08-04 15:44:57 +02:00
{
VisitTownBuilding() = default;
VisitTownBuilding(const ObjectInstanceID & TID, const BuildingID BID)
2024-08-04 15:44:57 +02:00
: tid(TID)
, bid(BID)
2024-08-04 15:44:57 +02:00
{
}
ObjectInstanceID tid;
BuildingID bid;
2024-08-04 15:44:57 +02:00
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & tid;
h & bid;
2024-08-04 15:44:57 +02:00
}
};
struct DLL_LINKAGE RazeStructure : public BuildStructure
{
void visitTyped(ICPackVisitor & visitor) override;
};
struct DLL_LINKAGE RecruitCreatures : public CPackForServer
{
RecruitCreatures() = default;
RecruitCreatures(const ObjectInstanceID & TID, const ObjectInstanceID & DST, const CreatureID & CRID, si32 Amount, si32 Level)
: tid(TID)
, dst(DST)
, crid(CRID)
, amount(Amount)
, level(Level)
{
}
ObjectInstanceID tid; //dwelling id, or town
ObjectInstanceID dst; //destination ID, e.g. hero
CreatureID crid;
ui32 amount = 0; //creature amount
si32 level = 0; //dwelling level to buy from, -1 if any
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & tid;
h & dst;
h & crid;
h & amount;
h & level;
}
};
struct DLL_LINKAGE UpgradeCreature : public CPackForServer
{
UpgradeCreature() = default;
UpgradeCreature(const SlotID & Pos, const ObjectInstanceID & ID, const CreatureID & CRID)
: pos(Pos)
, id(ID)
, cid(CRID)
{
}
SlotID pos; //stack pos
ObjectInstanceID id; //object id
CreatureID cid; //id of type to which we want make upgrade
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & pos;
h & id;
h & cid;
}
};
struct DLL_LINKAGE GarrisonHeroSwap : public CPackForServer
{
GarrisonHeroSwap() = default;
GarrisonHeroSwap(const ObjectInstanceID & TID)
: tid(TID)
{
}
ObjectInstanceID tid;
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & tid;
}
};
struct DLL_LINKAGE ExchangeArtifacts : public CPackForServer
{
ArtifactLocation src, dst;
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & src;
h & dst;
}
};
struct DLL_LINKAGE BulkExchangeArtifacts : public CPackForServer
{
ObjectInstanceID srcHero;
ObjectInstanceID dstHero;
bool swap = false;
bool equipped = true;
bool backpack = true;
BulkExchangeArtifacts() = default;
BulkExchangeArtifacts(const ObjectInstanceID & srcHero, const ObjectInstanceID & dstHero, bool swap, bool equipped, bool backpack)
: srcHero(srcHero)
, dstHero(dstHero)
, swap(swap)
, equipped(equipped)
, backpack(backpack)
{
}
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & srcHero;
h & dstHero;
h & swap;
h & equipped;
h & backpack;
}
};
2024-03-06 15:16:35 +02:00
struct DLL_LINKAGE ManageBackpackArtifacts : public CPackForServer
{
enum class ManageCmd
{
SCROLL_LEFT, SCROLL_RIGHT, SORT_BY_SLOT, SORT_BY_CLASS, SORT_BY_COST
};
ManageBackpackArtifacts() = default;
ManageBackpackArtifacts(const ObjectInstanceID & artHolder, const ManageCmd & cmd)
: artHolder(artHolder)
, cmd(cmd)
{
}
ObjectInstanceID artHolder;
ManageCmd cmd;
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer&>(*this);
h & artHolder;
h & cmd;
}
};
2024-03-30 17:18:50 +02:00
struct DLL_LINKAGE ManageEquippedArtifacts : public CPackForServer
{
ManageEquippedArtifacts() = default;
ManageEquippedArtifacts(const ObjectInstanceID & artHolder, const uint32_t costumeIdx, bool saveCostume = false)
2024-03-30 17:18:50 +02:00
: artHolder(artHolder)
, costumeIdx(costumeIdx)
, saveCostume(saveCostume)
{
}
ObjectInstanceID artHolder;
uint32_t costumeIdx;
2024-03-30 17:18:50 +02:00
bool saveCostume;
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer&>(*this);
h & artHolder;
h & costumeIdx;
h & saveCostume;
}
};
struct DLL_LINKAGE AssembleArtifacts : public CPackForServer
{
AssembleArtifacts() = default;
AssembleArtifacts(const ObjectInstanceID & _heroID, const ArtifactPosition & _artifactSlot, bool _assemble, const ArtifactID & _assembleTo)
: heroID(_heroID)
, artifactSlot(_artifactSlot)
, assemble(_assemble)
, assembleTo(_assembleTo)
{
}
ObjectInstanceID heroID;
ArtifactPosition artifactSlot;
bool assemble = false; // True to assemble artifact, false to disassemble.
ArtifactID assembleTo; // Artifact to assemble into.
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & heroID;
h & artifactSlot;
h & assemble;
h & assembleTo;
}
};
struct DLL_LINKAGE EraseArtifactByClient : public CPackForServer
{
EraseArtifactByClient() = default;
EraseArtifactByClient(const ArtifactLocation & al)
: al(al)
{
}
ArtifactLocation al;
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer&>(*this);
h & al;
}
};
struct DLL_LINKAGE BuyArtifact : public CPackForServer
{
BuyArtifact() = default;
BuyArtifact(const ObjectInstanceID & HID, const ArtifactID & AID)
: hid(HID)
, aid(AID)
{
}
ObjectInstanceID hid;
ArtifactID aid;
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & hid;
h & aid;
}
};
struct DLL_LINKAGE TradeOnMarketplace : public CPackForServer
{
ObjectInstanceID marketId;
ObjectInstanceID heroId;
EMarketMode mode = EMarketMode::RESOURCE_RESOURCE;
std::vector<TradeItemSell> r1;
std::vector<TradeItemBuy> 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
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & marketId;
h & heroId;
h & mode;
h & r1;
h & r2;
h & val;
}
};
struct DLL_LINKAGE SetFormation : public CPackForServer
{
SetFormation() = default;
;
SetFormation(const ObjectInstanceID & HID, EArmyFormation Formation)
: hid(HID)
, formation(Formation)
{
}
ObjectInstanceID hid;
EArmyFormation formation{};
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & hid;
h & formation;
}
};
struct DLL_LINKAGE HireHero : public CPackForServer
{
HireHero() = default;
2024-01-20 02:09:55 +02:00
HireHero(HeroTypeID HID, const ObjectInstanceID & TID, const HeroTypeID & NHID)
: hid(HID)
, tid(TID)
2024-01-20 02:09:55 +02:00
, nhid(NHID)
{
}
HeroTypeID hid; //available hero serial
2024-01-20 02:09:55 +02:00
HeroTypeID nhid; //next hero
ObjectInstanceID tid; //town (tavern) id
PlayerColor player;
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & hid;
2024-01-20 02:09:55 +02:00
h & nhid;
h & tid;
h & player;
}
};
struct DLL_LINKAGE BuildBoat : public CPackForServer
{
ObjectInstanceID objid; //where player wants to buy a boat
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & objid;
}
};
struct DLL_LINKAGE QueryReply : public CPackForServer
{
QueryReply() = default;
QueryReply(const QueryID & QID, std::optional<int32_t> Reply)
: qid(QID)
, reply(Reply)
{
}
QueryID qid;
PlayerColor player;
std::optional<int32_t> reply;
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & qid;
h & player;
h & reply;
}
};
struct DLL_LINKAGE MakeAction : public CPackForServer
{
MakeAction() = default;
MakeAction(BattleAction BA)
: ba(std::move(BA))
{
}
BattleAction ba;
BattleID battleID;
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & ba;
h & battleID;
}
};
struct DLL_LINKAGE DigWithHero : public CPackForServer
{
ObjectInstanceID id; //digging hero id
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & id;
}
};
struct DLL_LINKAGE CastAdvSpell : public CPackForServer
{
ObjectInstanceID hid; //hero id
SpellID sid; //spell id
int3 pos; //selected tile (not always used)
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & hid;
h & sid;
h & pos;
}
};
/***********************************************************************************************************/
struct DLL_LINKAGE SaveGame : public CPackForServer
{
SaveGame() = default;
SaveGame(std::string Fname)
: fname(std::move(Fname))
{
}
std::string fname;
void applyGs(CGameState * gs) {};
void visitTyped(ICPackVisitor & visitor) override;
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & fname;
}
};
struct DLL_LINKAGE PlayerMessage : public CPackForServer
{
PlayerMessage() = default;
PlayerMessage(std::string Text, const ObjectInstanceID & obj)
: text(std::move(Text))
, currObj(obj)
{
}
void applyGs(CGameState * gs) {};
void visitTyped(ICPackVisitor & visitor) override;
std::string text;
ObjectInstanceID currObj; // optional parameter that specifies current object. For cheats :)
template <typename Handler> void serialize(Handler & h)
{
h & static_cast<CPackForServer &>(*this);
h & text;
h & currObj;
}
};
VCMI_LIB_NAMESPACE_END