game_event_handler.h

Go to the documentation of this file.

 
#ifndef COCKATRICE_GAME_EVENT_HANDLER_H
#define COCKATRICE_GAME_EVENT_HANDLER_H
 
#include "player/event_processing_options.h"
 
#include <QLoggingCategory>
#include <QObject>
#include <QPair>
#include <QString>
#include <QVector>
#include <libcockatrice/protocol/pb/event_leave.pb.h>
#include <qtmetamacros.h>
 
// IWYU pragma: keep
// GameEventContext, ServerInfo_Player and ServerInfo_User are passed by value
// to signals and slots, so the moc-generated code needs the complete types.
#include <libcockatrice/protocol/pb/game_event_context.pb.h>
#include <libcockatrice/protocol/pb/serverinfo_player.pb.h>
#include <libcockatrice/protocol/pb/serverinfo_user.pb.h>
 
class AbstractClient;
class AbstractGame;
class GameEventContainer;
class GameEventContext;
class PendingCommand;
class PlayerLogic;
class Response;
class Event_GameStateChanged;
class Event_PlayerPropertiesChanged;
class Event_Join;
class Event_GameHostChanged;
class Event_GameClosed;
class Event_SetActivePlayer;
class Event_SetActivePhase;
class Event_GameSay;
class Event_Kicked;
class Event_ReverseTurn;
class Event_Ping;
class ServerInfo_PlayerProperties;
namespace google
{
namespace protobuf
{
class Message;
} // namespace protobuf
} // namespace google
template <typename T> class QList;
 
inline Q_LOGGING_CATEGORY(GameEventHandlerLog, "game_event_handler");

class GameEventHandler : public QObject
{
    Q_OBJECT
 
private:
    AbstractGame *game;
 
public:

    explicit GameEventHandler(AbstractGame *_game);



    void handleNextTurn();

    void handleReverseTurn();

    void handleActiveLocalPlayerConceded();

    void handleActiveLocalPlayerUnconceded();

    void handleActivePhaseChanged(int phase);

    void handleGameLeft();

    void handleChatMessageSent(const QString &chatMessage);

    void handleArrowDeletion(int creatorId, int arrowId);
    void handleArrowDeletionFinished(const Response &response, int creatorId, int arrowId);



    void
    processGameEventContainer(const GameEventContainer &cont, AbstractClient *client, EventProcessingOptions options);



    PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd);

    PendingCommand *prepareGameCommand(const QList<const ::google::protobuf::Message *> &cmdList);



    void eventSpectatorSay(const Event_GameSay &event, int eventPlayerId, const GameEventContext &context);

    void eventSpectatorLeave(const Event_Leave &event, int eventPlayerId, const GameEventContext &context);



    void eventGameStateChanged(const Event_GameStateChanged &event, int eventPlayerId, const GameEventContext &context);

    void processCardAttachmentsForPlayers(const Event_GameStateChanged &event);

    void eventGameHostChanged(const Event_GameHostChanged &event, int eventPlayerId, const GameEventContext &context);

    void eventGameClosed(const Event_GameClosed &event, int eventPlayerId, const GameEventContext &context);

    void eventSetActivePlayer(const Event_SetActivePlayer &event, int eventPlayerId, const GameEventContext &context);

    void eventSetActivePhase(const Event_SetActivePhase &event, int eventPlayerId, const GameEventContext &context);

    void eventReverseTurn(const Event_ReverseTurn &event, int eventPlayerId, const GameEventContext &context);

    void eventPing(const Event_Ping &event, int eventPlayerId, const GameEventContext &context);



    void eventPlayerPropertiesChanged(const Event_PlayerPropertiesChanged &event,
                                      int eventPlayerId,
                                      const GameEventContext &context);

    void eventJoin(const Event_Join &event, int eventPlayerId, const GameEventContext &context);

    void eventLeave(const Event_Leave &event, int eventPlayerId, const GameEventContext &context);

    void eventKicked(const Event_Kicked &event, int eventPlayerId, const GameEventContext &context);

    QString getLeaveReason(Event_Leave::LeaveReason reason);

 
public slots:

    void sendGameCommand(PendingCommand *pend, int playerId = -1);

    void sendGameCommand(const ::google::protobuf::Message &command, int playerId = -1);

    void commandFinished(const Response &response);

 
signals:
 
    void emitUserEvent();
    void containerProcessingStarted(GameEventContext context);
    void containerProcessingDone();
    void gameFlooded();
    void setContextJudgeName(QString judgeName);


 
    void addPlayerToAutoCompleteList(QString playerName);
    void localPlayerDeckSelected(PlayerLogic *localPlayer, int playerId, ServerInfo_Player playerInfo);
    void remotePlayerDeckSelected(QString deckList, int playerId, QString playerName);
    void remotePlayersDecksSelected(QVector<QPair<int, QPair<QString, QString>>> opponentDecks);
    void localPlayerSideboardLocked(int playerId, bool sideboardLocked);
    void localPlayerReadyStateChanged(int playerId, bool ready);


 
    void gameStopped();
    void gameClosed();
    void playerPropertiesChanged(const ServerInfo_PlayerProperties &prop, int playerId);
    void playerJoined(const ServerInfo_PlayerProperties &playerInfo);
    void playerLeft(int leavingPlayerId);
    void playerKicked();
    void spectatorJoined(const ServerInfo_PlayerProperties &spectatorInfo);
    void spectatorLeft(int leavingSpectatorId);
    void arrowDeleted(int creatorId, int arrowId);


 
    void logSpectatorSay(ServerInfo_User userInfo, QString message);
    void logSpectatorLeave(QString name, QString reason);
    void logGameStart();
    void logReadyStart(PlayerLogic *player);
    void logNotReadyStart(PlayerLogic *player);
    void logDeckSelect(PlayerLogic *player, QString deckHash, int sideboardSize);
    void logSideboardLockSet(PlayerLogic *player, bool sideboardLocked);
    void logConnectionStateChanged(PlayerLogic *player, bool connected);
    void logJoinSpectator(QString spectatorName);
    void logJoinPlayer(PlayerLogic *player);
    void logLeave(PlayerLogic *player, QString reason);
    void logKicked();
    void logTurnReversed(PlayerLogic *player, bool reversed);
    void logGameClosed();
    void logActivePlayer(PlayerLogic *activePlayer);
    void logActivePhaseChanged(int activePhase);
    void logConcede(int playerId);
    void logUnconcede(int playerId);

};
 
#endif // COCKATRICE_GAME_EVENT_HANDLER_H