add abstract player in expectance of draft players (#6210)

* add abstract player in expectance of draft players

common/CMakeLists.txt

@@ -18,6 +18,7 @@ set(common_SOURCES
     rng_abstract.cpp
     rng_sfmt.cpp
     server/game/server_abstract_participant.cpp
+    server/game/server_abstract_player.cpp
     server/game/server_arrow.cpp
     server/game/server_arrowtarget.cpp
     server/game/server_card.cpp

common/server/game/server_abstract_participant.cpp

@@ -202,7 +202,7 @@ Server_AbstractParticipant::cmdJudge(const Command_Judge &cmd, ResponseContainer
         return Response::RespFunctionNotAllowed;
     }
 
-    Server_Player *player = this->game->getPlayer(cmd.target_id());
+    auto *player = this->game->getPlayer(cmd.target_id());
 
     ges.setForcedByJudge(playerId);
     if (player == nullptr) {

common/server/game/server_abstract_player.h

@@ -0,0 +1,152 @@
+#ifndef ABSTRACT_PLAYER_H
+#define ABSTRACT_PLAYER_H
+
+#include "../../serverinfo_user_container.h"
+#include "server_abstract_participant.h"
+
+#include <QList>
+#include <QMap>
+#include <QString>
+
+class CardToMove;
+class DeckList;
+class Server_Arrow;
+class Server_Card;
+class Server_CardZone;
+class Server_Counter;
+struct MoveCardStruct;
+
+class Server_AbstractPlayer : public Server_AbstractParticipant
+{
+    Q_OBJECT
+private:
+    class MoveCardCompareFunctor;
+    QMap<int, Server_Arrow *> arrows;
+
+    void sendCreateTokenEvents(Server_CardZone *zone, Server_Card *card, int xCoord, int yCoord, GameEventStorage &ges);
+    void getPlayerProperties(ServerInfo_PlayerProperties &result) override;
+
+protected:
+    bool conceded;
+    DeckList *deck;
+    bool sideboardLocked;
+    QMap<QString, Server_CardZone *> zones;
+    bool readyStart;
+    int nextCardId;
+
+    void revealTopCardIfNeeded(Server_CardZone *zone, GameEventStorage &ges);
+
+public:
+    Server_AbstractPlayer(Server_Game *_game,
+                          int _playerId,
+                          const ServerInfo_User &_userInfo,
+                          bool _judge,
+                          Server_AbstractUserInterface *_handler);
+    ~Server_AbstractPlayer() override;
+    void prepareDestroy() override;
+    const DeckList *getDeckList() const
+    {
+        return deck;
+    }
+    bool getReadyStart() const
+    {
+        return readyStart;
+    }
+    void setReadyStart(bool _readyStart)
+    {
+        readyStart = _readyStart;
+    }
+    bool getConceded() const
+    {
+        return conceded;
+    }
+    void setConceded(bool _conceded)
+    {
+        conceded = _conceded;
+    }
+
+    const QMap<QString, Server_CardZone *> &getZones() const
+    {
+        return zones;
+    }
+    const QMap<int, Server_Arrow *> &getArrows() const
+    {
+        return arrows;
+    }
+
+    int newCardId();
+    int newArrowId() const;
+
+    void addZone(Server_CardZone *zone);
+    void addArrow(Server_Arrow *arrow);
+    void updateArrowId(int id);
+    bool deleteArrow(int arrowId);
+
+    virtual void setupZones();
+    virtual void clearZones();
+
+    Response::ResponseCode moveCard(GameEventStorage &ges,
+                                    Server_CardZone *startzone,
+                                    const QList<const CardToMove *> &_cards,
+                                    Server_CardZone *targetzone,
+                                    int xCoord,
+                                    int yCoord,
+                                    bool fixFreeSpaces = true,
+                                    bool undoingDraw = false,
+                                    bool isReversed = false);
+    virtual void onCardBeingMoved(GameEventStorage &ges,
+                                  const MoveCardStruct &cardStruct,
+                                  Server_CardZone *startzone,
+                                  Server_CardZone *targetzone,
+                                  bool undoingDraw);
+
+    void unattachCard(GameEventStorage &ges, Server_Card *card);
+    Response::ResponseCode setCardAttrHelper(GameEventStorage &ges,
+                                             int targetPlayerId,
+                                             const QString &zone,
+                                             int cardId,
+                                             CardAttribute attribute,
+                                             const QString &attrValue,
+                                             Server_Card *unzonedCard = nullptr);
+
+    virtual Response::ResponseCode
+    cmdConcede(const Command_Concede &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdUnconcede(const Command_Unconcede &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdReadyStart(const Command_ReadyStart &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdRollDie(const Command_RollDie &cmd, ResponseContainer &rc, GameEventStorage &ges) const override;
+    virtual Response::ResponseCode
+    cmdMoveCard(const Command_MoveCard &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdFlipCard(const Command_FlipCard &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdAttachCard(const Command_AttachCard &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdCreateToken(const Command_CreateToken &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdCreateArrow(const Command_CreateArrow &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdDeleteArrow(const Command_DeleteArrow &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdSetCardAttr(const Command_SetCardAttr &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdSetCardCounter(const Command_SetCardCounter &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdIncCardCounter(const Command_IncCardCounter &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdDumpZone(const Command_DumpZone &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode
+    cmdRevealCards(const Command_RevealCards &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
+    virtual Response::ResponseCode cmdChangeZoneProperties(const Command_ChangeZoneProperties &cmd,
+                                                           ResponseContainer &rc,
+                                                           GameEventStorage &ges) override;
+
+    virtual void getInfo(ServerInfo_Player *info,
+                         Server_AbstractParticipant *playerWhosAsking,
+                         bool omniscient,
+                         bool withUserInfo) override;
+};
+
+#endif

common/server/game/server_cardzone.cpp

@@ -21,13 +21,13 @@
 
 #include "../rng_abstract.h"
 #include "pb/command_move_card.pb.h"
+#include "server_abstract_player.h"
 #include "server_card.h"
-#include "server_player.h"
 
 #include <QDebug>
 #include <QSet>
 
-Server_CardZone::Server_CardZone(Server_Player *_player,
+Server_CardZone::Server_CardZone(Server_AbstractPlayer *_player,
                                  const QString &_name,
                                  bool _has_coords,
                                  ServerInfo_Zone::ZoneType _type)

common/server/game/server_cardzone.h

@@ -28,7 +28,7 @@
 #include <QString>
 
 class Server_Card;
-class Server_Player;
+class Server_AbstractPlayer;
 class Server_AbstractParticipant;
 class Server_Game;
 class GameEventStorage;
@@ -36,7 +36,7 @@ class GameEventStorage;
 class Server_CardZone
 {
 private:
-    Server_Player *player;
+    Server_AbstractPlayer *player;
     QString name;
     bool has_coords; // having coords means this zone has x and y coordinates
     ServerInfo_Zone::ZoneType type;
@@ -52,7 +52,10 @@ private:
     void insertCardIntoCoordMap(Server_Card *card, int x, int y);
 
 public:
-    Server_CardZone(Server_Player *_player, const QString &_name, bool _has_coords, ServerInfo_Zone::ZoneType _type);
+    Server_CardZone(Server_AbstractPlayer *_player,
+                    const QString &_name,
+                    bool _has_coords,
+                    ServerInfo_Zone::ZoneType _type);
     ~Server_CardZone();
 
     const QList<Server_Card *> &getCards() const
@@ -84,7 +87,7 @@ public:
     {
         return name;
     }
-    Server_Player *getPlayer() const
+    Server_AbstractPlayer *getPlayer() const
     {
         return player;
     }

common/server/game/server_game.cpp

@@ -41,6 +41,7 @@
 #include "pb/event_set_active_player.pb.h"
 #include "pb/game_replay.pb.h"
 #include "pb/serverinfo_playerping.pb.h"
+#include "server_abstract_player.h"
 #include "server_arrow.h"
 #include "server_card.h"
 #include "server_cardzone.h"
@@ -221,24 +222,24 @@ void Server_Game::pingClockTimeout()
     }
 }
 
-QMap<int, Server_Player *> Server_Game::getPlayers() const // copies pointers to new map
+QMap<int, Server_AbstractPlayer *> Server_Game::getPlayers() const // copies pointers to new map
 {
-    QMap<int, Server_Player *> players;
+    QMap<int, Server_AbstractPlayer *> players;
     QMutexLocker locker(&gameMutex);
     for (int id : participants.keys()) {
         auto *participant = participants[id];
         if (!participant->getSpectator()) {
-            players[id] = static_cast<Server_Player *>(participant);
+            players[id] = static_cast<Server_AbstractPlayer *>(participant);
         }
     }
     return players;
 }
 
-Server_Player *Server_Game::getPlayer(int id) const
+Server_AbstractPlayer *Server_Game::getPlayer(int id) const
 {
     auto *participant = participants.value(id);
     if (!participant->getSpectator()) {
-        return static_cast<Server_Player *>(participant);
+        return static_cast<Server_AbstractPlayer *>(participant);
     } else {
         return nullptr;
     }
@@ -339,7 +340,7 @@ void Server_Game::doStartGameIfReady(bool forceStartGame)
         }
     }
 
-    for (Server_Player *player : players.values()) {
+    for (Server_AbstractPlayer *player : players.values()) {
         player->setupZones();
     }
 
@@ -534,7 +535,7 @@ void Server_Game::removeParticipant(Server_AbstractParticipant *participant, Eve
     bool spectator = participant->getSpectator();
     GameEventStorage ges;
     if (!spectator) {
-        auto *player = static_cast<Server_Player *>(participant);
+        auto *player = static_cast<Server_AbstractPlayer *>(participant);
         removeArrowsRelatedToPlayer(ges, player);
         unattachCards(ges, player);
     }
@@ -577,14 +578,14 @@ void Server_Game::removeParticipant(Server_AbstractParticipant *participant, Eve
     emit gameInfoChanged(gameInfo);
 }
 
-void Server_Game::removeArrowsRelatedToPlayer(GameEventStorage &ges, Server_Player *player)
+void Server_Game::removeArrowsRelatedToPlayer(GameEventStorage &ges, Server_AbstractPlayer *player)
 {
     QMutexLocker locker(&gameMutex);
 
     // Remove all arrows of other players pointing to the player being removed or to one of his cards.
     // Also remove all arrows starting at one of his cards. This is necessary since players can create
     // arrows that start at another person's cards.
-    for (Server_Player *anyPlayer : getPlayers().values()) {
+    for (Server_AbstractPlayer *anyPlayer : getPlayers().values()) {
         QList<Server_Arrow *> arrows = anyPlayer->getArrows().values();
         QList<Server_Arrow *> toDelete;
         for (int i = 0; i < arrows.size(); ++i) {
@@ -593,7 +594,7 @@ void Server_Game::removeArrowsRelatedToPlayer(GameEventStorage &ges, Server_Play
             if (targetCard) {
                 if (targetCard->getZone() != nullptr && targetCard->getZone()->getPlayer() == player)
                     toDelete.append(arrow);
-            } else if (static_cast<Server_Player *>(arrow->getTargetItem()) == player)
+            } else if (static_cast<Server_AbstractPlayer *>(arrow->getTargetItem()) == player)
                 toDelete.append(arrow);
 
             // Don't use else here! It has to happen regardless of whether targetCard == 0.
@@ -610,7 +611,7 @@ void Server_Game::removeArrowsRelatedToPlayer(GameEventStorage &ges, Server_Play
     }
 }
 
-void Server_Game::unattachCards(GameEventStorage &ges, Server_Player *player)
+void Server_Game::unattachCards(GameEventStorage &ges, Server_AbstractPlayer *player)
 {
     QMutexLocker locker(&gameMutex);
 

common/server/game/server_game.h

@@ -36,7 +36,7 @@ class QTimer;
 class GameEventContainer;
 class GameReplay;
 class Server_Room;
-class Server_Player;
+class Server_AbstractPlayer;
 class Server_AbstractParticipant;
 class ServerInfo_User;
 class ServerInfo_Game;
@@ -130,8 +130,8 @@ public:
     }
     int getPlayerCount() const;
     int getSpectatorCount() const;
-    QMap<int, Server_Player *> getPlayers() const;
+    QMap<int, Server_AbstractPlayer *> getPlayers() const;
-    Server_Player *getPlayer(int id) const;
+    Server_AbstractPlayer *getPlayer(int id) const;
     const QMap<int, Server_AbstractParticipant *> &getParticipants() const
     {
         return participants;
@@ -185,8 +185,8 @@ public:
                    bool judge,
                    bool broadcastUpdate = true);
     void removeParticipant(Server_AbstractParticipant *participant, Event_Leave::LeaveReason reason);
-    void removeArrowsRelatedToPlayer(GameEventStorage &ges, Server_Player *player);
+    void removeArrowsRelatedToPlayer(GameEventStorage &ges, Server_AbstractPlayer *player);
-    void unattachCards(GameEventStorage &ges, Server_Player *player);
+    void unattachCards(GameEventStorage &ges, Server_AbstractPlayer *player);
     bool kickParticipant(int playerId);
     void startGameIfReady(bool forceStartGame);
     void stopGameIfFinished();

common/server/game/server_move_card_struct.h

@@ -0,0 +1,26 @@
+#ifndef MOVE_CARD_STRUCT
+#define MOVE_CARD_STRUCT
+
+#include "server_card.h"
+class CardToMove;
+
+struct MoveCardStruct
+{
+    Server_Card *card;
+    int position;
+    const CardToMove *cardToMove;
+    int xCoord, yCoord;
+    MoveCardStruct(Server_Card *_card, int _position, const CardToMove *_cardToMove)
+        : card(_card), position(_position), cardToMove(_cardToMove), xCoord(_card->getX()), yCoord(_card->getY())
+
+    {
+    }
+    bool operator<(const MoveCardStruct &other) const
+    {
+        return (yCoord == other.yCoord &&
+                ((xCoord == other.xCoord && position < other.position) || xCoord < other.xCoord)) ||
+               yCoord < other.yCoord;
+    }
+};
+
+#endif

common/server/game/server_player.h

@@ -1,37 +1,14 @@
 #ifndef PLAYER_H
 #define PLAYER_H
 
-#include "../../serverinfo_user_container.h"
+#include "server_abstract_player.h"
-#include "server_abstract_participant.h"
 
-#include <QList>
+class Server_Player : public Server_AbstractPlayer
-#include <QMap>
-#include <QString>
-
-class DeckList;
-class Server_CardZone;
-class Server_Counter;
-class Server_Arrow;
-class Server_Card;
-class CardToMove;
-
-class Server_Player : public Server_AbstractParticipant
 {
     Q_OBJECT
 private:
-    class MoveCardCompareFunctor;
-    DeckList *deck;
-    QMap<QString, Server_CardZone *> zones;
     QMap<int, Server_Counter *> counters;
-    QMap<int, Server_Arrow *> arrows;
     QList<int> lastDrawList;
-    int nextCardId;
-    bool readyStart;
-    bool conceded;
-    bool sideboardLocked;
-    void revealTopCardIfNeeded(Server_CardZone *zone, GameEventStorage &ges);
-    void sendCreateTokenEvents(Server_CardZone *zone, Server_Card *card, int xCoord, int yCoord, GameEventStorage &ges);
-    void getPlayerProperties(ServerInfo_PlayerProperties &result) override;
 
 public:
     Server_Player(Server_Game *_game,
@@ -40,79 +17,23 @@ public:
                   bool _judge,
                   Server_AbstractUserInterface *_handler);
     ~Server_Player() override;
-    void prepareDestroy() override;
-    const DeckList *getDeckList() const
-    {
-        return deck;
-    }
-    bool getReadyStart() const
-    {
-        return readyStart;
-    }
-    void setReadyStart(bool _readyStart)
-    {
-        readyStart = _readyStart;
-    }
-    bool getConceded() const
-    {
-        return conceded;
-    }
-    void setConceded(bool _conceded)
-    {
-        conceded = _conceded;
-    }
-
-    const QMap<QString, Server_CardZone *> &getZones() const
-    {
-        return zones;
-    }
     const QMap<int, Server_Counter *> &getCounters() const
     {
         return counters;
     }
-    const QMap<int, Server_Arrow *> &getArrows() const
-    {
-        return arrows;
-    }
-
-    int newCardId();
     int newCounterId() const;
-    int newArrowId() const;
-
-    void addZone(Server_CardZone *zone);
-    void addArrow(Server_Arrow *arrow);
-    void updateArrowId(int id);
-    bool deleteArrow(int arrowId);
     void addCounter(Server_Counter *counter);
 
-    void clearZones();
+    void setupZones() override;
-    void setupZones();
+    void clearZones() override;
 
     Response::ResponseCode drawCards(GameEventStorage &ges, int number);
-    Response::ResponseCode moveCard(GameEventStorage &ges,
+    void onCardBeingMoved(GameEventStorage &ges,
-                                    Server_CardZone *startzone,
+                          const MoveCardStruct &cardStruct,
-                                    const QList<const CardToMove *> &_cards,
+                          Server_CardZone *startzone,
-                                    Server_CardZone *targetzone,
+                          Server_CardZone *targetzone,
-                                    int xCoord,
+                          bool undoingDraw) override;
-                                    int yCoord,
-                                    bool fixFreeSpaces = true,
-                                    bool undoingDraw = false,
-                                    bool isReversed = false);
-    void unattachCard(GameEventStorage &ges, Server_Card *card);
-    Response::ResponseCode setCardAttrHelper(GameEventStorage &ges,
-                                             int targetPlayerId,
-                                             const QString &zone,
-                                             int cardId,
-                                             CardAttribute attribute,
-                                             const QString &attrValue,
-                                             Server_Card *unzonedCard = nullptr);
 
-    Response::ResponseCode
-    cmdConcede(const Command_Concede &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
-    cmdUnconcede(const Command_Unconcede &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
-    cmdReadyStart(const Command_ReadyStart &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
     Response::ResponseCode
     cmdDeckSelect(const Command_DeckSelect &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
     Response::ResponseCode
@@ -124,30 +45,10 @@ public:
     Response::ResponseCode
     cmdMulligan(const Command_Mulligan &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
     Response::ResponseCode
-    cmdRollDie(const Command_RollDie &cmd, ResponseContainer &rc, GameEventStorage &ges) const override;
-    Response::ResponseCode
     cmdDrawCards(const Command_DrawCards &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
     Response::ResponseCode
     cmdUndoDraw(const Command_UndoDraw &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
     Response::ResponseCode
-    cmdMoveCard(const Command_MoveCard &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
-    cmdFlipCard(const Command_FlipCard &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
-    cmdAttachCard(const Command_AttachCard &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
-    cmdCreateToken(const Command_CreateToken &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
-    cmdCreateArrow(const Command_CreateArrow &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
-    cmdDeleteArrow(const Command_DeleteArrow &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
-    cmdSetCardAttr(const Command_SetCardAttr &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
-    cmdSetCardCounter(const Command_SetCardCounter &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
-    cmdIncCardCounter(const Command_IncCardCounter &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
     cmdIncCounter(const Command_IncCounter &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
     Response::ResponseCode
     cmdCreateCounter(const Command_CreateCounter &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
@@ -160,10 +61,6 @@ public:
     Response::ResponseCode
     cmdSetActivePhase(const Command_SetActivePhase &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
     Response::ResponseCode
-    cmdDumpZone(const Command_DumpZone &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
-    cmdRevealCards(const Command_RevealCards &cmd, ResponseContainer &rc, GameEventStorage &ges) override;
-    Response::ResponseCode
     cmdReverseTurn(const Command_ReverseTurn & /*cmd*/, ResponseContainer & /*rc*/, GameEventStorage &ges) override;
     Response::ResponseCode cmdChangeZoneProperties(const Command_ChangeZoneProperties &cmd,
                                                    ResponseContainer &rc,