Initial commit of mtgonline project
This commit is contained in:
@@ -0,0 +1,25 @@
|
||||
/**
|
||||
* @file event_processing_options.h
|
||||
* @ingroup GameLogicPlayers
|
||||
*/
|
||||
//! \todo Document this file.
|
||||
|
||||
#ifndef COCKATRICE_EVENT_PROCESSING_OPTIONS_H
|
||||
#define COCKATRICE_EVENT_PROCESSING_OPTIONS_H
|
||||
|
||||
#include <QFlags>
|
||||
|
||||
// Define the base enum
|
||||
enum EventProcessingOption
|
||||
{
|
||||
SKIP_REVEAL_WINDOW = 0x0001,
|
||||
SKIP_TAP_ANIMATION = 0x0002
|
||||
};
|
||||
|
||||
// Wrap it in a QFlags typedef
|
||||
Q_DECLARE_FLAGS(EventProcessingOptions, EventProcessingOption)
|
||||
|
||||
// Add operator overloads (|, &, etc.)
|
||||
Q_DECLARE_OPERATORS_FOR_FLAGS(EventProcessingOptions)
|
||||
|
||||
#endif // COCKATRICE_EVENT_PROCESSING_OPTIONS_H
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,254 @@
|
||||
/**
|
||||
* @file player_actions.h
|
||||
* @ingroup GameLogicActions
|
||||
* @ingroup GameLogicPlayers
|
||||
*/
|
||||
//! \todo Document this file.
|
||||
|
||||
#ifndef COCKATRICE_PLAYER_ACTIONS_H
|
||||
#define COCKATRICE_PLAYER_ACTIONS_H
|
||||
|
||||
#include "../../game_graphics/board/card_item.h"
|
||||
#include "../../game_graphics/dialogs/dlg_create_token.h"
|
||||
#include "../../game_graphics/dialogs/dlg_move_top_cards_until.h"
|
||||
#include "../../game_graphics/player/card_menu_action_type.h"
|
||||
#include "event_processing_options.h"
|
||||
#include "player_logic.h"
|
||||
|
||||
#include <QMenu>
|
||||
#include <QObject>
|
||||
#include <libcockatrice/card/relation/card_relation_type.h>
|
||||
#include <libcockatrice/filters/filter_string.h>
|
||||
|
||||
namespace google
|
||||
{
|
||||
namespace protobuf
|
||||
{
|
||||
class Message;
|
||||
}
|
||||
} // namespace google
|
||||
|
||||
class Command_MoveCard;
|
||||
class GameEventContext;
|
||||
class PendingCommand;
|
||||
class PlayerLogic;
|
||||
class PlayerActions : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
enum CardsToReveal
|
||||
{
|
||||
RANDOM_CARD_FROM_ZONE = -2
|
||||
};
|
||||
|
||||
explicit PlayerActions(PlayerLogic *player);
|
||||
|
||||
void sendGameCommand(PendingCommand *pend);
|
||||
void sendGameCommand(const google::protobuf::Message &command);
|
||||
|
||||
PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd);
|
||||
PendingCommand *prepareGameCommand(const QList<const ::google::protobuf::Message *> &cmdList);
|
||||
|
||||
void moveOneCardUntil(CardItem *card);
|
||||
void stopMoveTopCardsUntil();
|
||||
|
||||
[[nodiscard]] bool isMovingCardsUntil() const
|
||||
{
|
||||
return movingCardsUntil;
|
||||
}
|
||||
|
||||
signals:
|
||||
void requestViewTopCardsDialog(int defaultNumberTopCards, int deckSize);
|
||||
void requestViewBottomCardsDialog(int defaultNumberBottomCards, int deckSize);
|
||||
void requestShuffleTopDialog(int defaultNumberTopCards, int maxCards);
|
||||
void requestShuffleBottomDialog(int defaultNumberBottomCards, int maxCards);
|
||||
void requestMulliganDialog(int startSize, int handSize, int deckSize);
|
||||
void requestDrawCardsDialog(int defaultNumberTopCards, int deckSize);
|
||||
void requestMoveTopCardsToDialog(int defaultNumberTopCards,
|
||||
int maxCards,
|
||||
const QString &targetZone,
|
||||
const QString &zoneDisplayName,
|
||||
bool faceDown);
|
||||
void requestMoveTopCardsUntilDialog(MoveTopCardsUntilOptions options);
|
||||
void requestMoveBottomCardsToDialog(int defaultNumberBottomCards,
|
||||
int maxCards,
|
||||
const QString &targetZone,
|
||||
const QString &zoneDisplayName,
|
||||
bool faceDown);
|
||||
void requestDrawBottomCardsDialog(int defaultNumberBottomCards, int maxCards);
|
||||
void requestRollDieDialog();
|
||||
void requestCreateTokenDialog(const QStringList &predefinedTokens);
|
||||
void requestCreateRelatedFromRelationDialog(const CardItem *sourceCard, const CardRelation *cardRelation);
|
||||
void requestMoveCardXCardsFromTopDialog(int defaultNumberTopCardsToPlaceBelow, int deckSize);
|
||||
void requestSetPTDialog(const QString &oldPT);
|
||||
void requestSetAnnotationDialog(const QString &oldAnnotation);
|
||||
void requestSetCardCounterDialog(int counterId, const QString &oldValueForDlg);
|
||||
void requestZoneViewToggle(const QString &zoneName, int numberCards, bool isReversed = false);
|
||||
void requestSortHand(const QList<CardList::SortOption> &options);
|
||||
void requestEnableAndSetCreateAnotherTokenAction(const QString &lastTokenName);
|
||||
void requestSetLastToken(CardInfoPtr lastToken);
|
||||
|
||||
public slots:
|
||||
void setLastToken(CardInfoPtr cardInfo);
|
||||
void setLastTokenInfo(CardInfoPtr cardInfo);
|
||||
void playCard(CardItem *c, bool faceDown);
|
||||
void playCardToTable(const CardItem *c, bool faceDown);
|
||||
|
||||
void actUntapAll();
|
||||
void actRequestRollDieDialog();
|
||||
void actRollDie(int sides, int count);
|
||||
void actFlipCoin();
|
||||
void actRequestCreateTokenDialog(const QStringList &predefinedTokens);
|
||||
void actCreateToken(TokenInfo tokenToCreate);
|
||||
void actCreateAnotherToken();
|
||||
void actRequestCreateRelatedFromRelationDialog(const CardItem *sourceCard, const CardRelation *cardRelation);
|
||||
bool createRelatedFromRelation(const CardItem *sourceCard, const CardRelation *cardRelation, int variableCount);
|
||||
void onRelatedCardCreated(const CardItem *sourceCard, const CardRelation *cardRelation);
|
||||
void setLastRelatedCreationSucceeded(bool succeeded)
|
||||
{
|
||||
lastRelatedCreationSucceeded = succeeded;
|
||||
}
|
||||
void actShuffle();
|
||||
void actRequestShuffleTopDialog();
|
||||
void actShuffleTop(int number);
|
||||
void actRequestShuffleBottomDialog();
|
||||
void actShuffleBottom(int number);
|
||||
void actDrawCard();
|
||||
void actRequestDrawCardsDialog();
|
||||
void actDrawCards(int number);
|
||||
void actUndoDraw();
|
||||
void actRequestMulliganDialog();
|
||||
void actMulligan(int number);
|
||||
void actMulliganSameSize();
|
||||
void actMulliganMinusOne();
|
||||
void doMulligan(int number);
|
||||
|
||||
void actPlay(QList<CardItem *> selectedCards);
|
||||
void actPlayFacedown(QList<CardItem *> selectedCards);
|
||||
void actHide(QList<CardItem *> selectedCards);
|
||||
|
||||
void actMoveTopCardToPlay();
|
||||
void actMoveTopCardToPlayFaceDown();
|
||||
void actMoveTopCardToGrave();
|
||||
void actMoveTopCardToExile();
|
||||
void actMoveTopCardsToGrave();
|
||||
void actMoveTopCardsToGraveFaceDown();
|
||||
void actMoveTopCardsToExile();
|
||||
void actMoveTopCardsToExileFaceDown();
|
||||
void actRequestMoveTopCardsUntilDialog();
|
||||
void moveTopCardsUntil(const QString &expr, MoveTopCardsUntilOptions options);
|
||||
void actMoveTopCardToBottom();
|
||||
void actRequestMoveTopCardsToDialog(const QString &targetZone, const QString &zoneDisplayName, bool faceDown);
|
||||
void moveTopCardsTo(int number, const QString &targetZone, bool faceDown);
|
||||
void actDrawBottomCard();
|
||||
void actRequestDrawBottomCardsDialog();
|
||||
void actDrawBottomCards(int number);
|
||||
void actMoveBottomCardToPlay();
|
||||
void actMoveBottomCardToPlayFaceDown();
|
||||
void actMoveBottomCardToGrave();
|
||||
void actMoveBottomCardToExile();
|
||||
void actMoveBottomCardsToGrave();
|
||||
void actMoveBottomCardsToGraveFaceDown();
|
||||
void actMoveBottomCardsToExile();
|
||||
void actMoveBottomCardsToExileFaceDown();
|
||||
void actMoveBottomCardToTop();
|
||||
void actRequestMoveBottomCardsToDialog(const QString &targetZone, const QString &zoneDisplayName, bool faceDown);
|
||||
void moveBottomCardsTo(int number, const QString &targetZone, bool faceDown);
|
||||
|
||||
void actSelectAll();
|
||||
void actSelectRow();
|
||||
void actSelectColumn();
|
||||
|
||||
void actViewLibrary();
|
||||
void actViewHand();
|
||||
void actRequestViewTopCardsDialog();
|
||||
void actViewTopCards(int number);
|
||||
void actRequestViewBottomCardsDialog();
|
||||
void actViewBottomCards(int number);
|
||||
void actAlwaysRevealTopCard(bool alwaysRevealTopCard);
|
||||
void actAlwaysLookAtTopCard(bool alwaysRevealTopCard);
|
||||
void actViewGraveyard();
|
||||
void actLendLibrary(int lendToPlayerId);
|
||||
void actRevealTopCards(int revealToPlayerId, int amount);
|
||||
void actRevealRandomGraveyardCard(int revealToPlayerId);
|
||||
void actViewRfg();
|
||||
void actViewSideboard();
|
||||
|
||||
void actSayMessage();
|
||||
|
||||
void actOpenDeckInDeckEditor();
|
||||
void actCreatePredefinedToken();
|
||||
void actCreateRelatedCard();
|
||||
void actCreateAllRelatedCards();
|
||||
|
||||
void actRequestMoveCardXCardsFromTopDialog();
|
||||
void actMoveCardXCardsFromTop(QList<CardItem *> selectedCards, int number);
|
||||
void actRemoveCardCounter(QList<CardItem *> selectedCards, int counterId);
|
||||
void actAddCardCounter(QList<CardItem *> selectedCards, int counterId);
|
||||
void actRequestSetCardCounterDialog(QList<CardItem *> selectedCards, int counterId);
|
||||
void actSetCardCounter(QList<CardItem *> selectedCards, int counterId, const QString &counterValue);
|
||||
void actIncrementAllCardCounters(QList<CardItem *> cardsToUpdate);
|
||||
void actAttach();
|
||||
void actUnattach(QList<CardItem *> selectedCards);
|
||||
void actDrawArrow();
|
||||
void actIncPT(QList<CardItem *> selectedCards, int deltaP, int deltaT);
|
||||
void actResetPT(QList<CardItem *> selectedCards);
|
||||
void actRequestSetPTDialog(QList<CardItem *> selectedCards);
|
||||
void actSetPT(QList<CardItem *> selectedCards, const QString &pt);
|
||||
void actIncP(QList<CardItem *> selectedCards);
|
||||
void actDecP(QList<CardItem *> selectedCards);
|
||||
void actIncT(QList<CardItem *> selectedCards);
|
||||
void actDecT(QList<CardItem *> selectedCards);
|
||||
void actIncPT(QList<CardItem *> selectedCards);
|
||||
void actDecPT(QList<CardItem *> selectedCards);
|
||||
void actFlowP(QList<CardItem *> selectedCards);
|
||||
void actFlowT(QList<CardItem *> selectedCards);
|
||||
|
||||
void actReduceLifeByPower(QList<CardItem *> selectedCards);
|
||||
|
||||
void actRequestSetAnnotationDialog(QList<CardItem *> selectedCards);
|
||||
void actSetAnnotation(QList<CardItem *> selectedCards, const QString &annotation);
|
||||
void actReveal(QList<CardItem *> selectedCards, QAction *action);
|
||||
void actRevealHand(int revealToPlayerId);
|
||||
void actRevealRandomHandCard(int revealToPlayerId);
|
||||
void actRevealLibrary(int revealToPlayerId);
|
||||
|
||||
void actSortHand();
|
||||
|
||||
void cardMenuAction(QList<CardItem *> selectedCards, CardMenuActionType type);
|
||||
|
||||
private:
|
||||
PlayerLogic *player;
|
||||
|
||||
int defaultNumberTopCards = 1;
|
||||
int defaultNumberTopCardsToPlaceBelow = 1;
|
||||
int defaultNumberBottomCards = 1;
|
||||
int defaultNumberDieRoll = 20;
|
||||
|
||||
TokenInfo lastTokenInfo;
|
||||
int lastTokenTableRow;
|
||||
|
||||
bool movingCardsUntil;
|
||||
QTimer *moveTopCardTimer;
|
||||
FilterString movingCardsUntilFilter;
|
||||
int movingCardsUntilCounter = 0;
|
||||
MoveTopCardsUntilOptions movingCardsUntilOptions;
|
||||
|
||||
bool lastRelatedCreationSucceeded = false;
|
||||
|
||||
void createCard(const CardItem *sourceCard,
|
||||
const QString &dbCardName,
|
||||
CardRelationType attach = CardRelationType::DoesNotAttach,
|
||||
bool persistent = false,
|
||||
bool faceDown = false);
|
||||
|
||||
void playSelectedCards(QList<CardItem *> selectedCards, bool faceDown = false);
|
||||
|
||||
void cmdSetTopCard(Command_MoveCard &cmd);
|
||||
void cmdSetBottomCard(Command_MoveCard &cmd);
|
||||
|
||||
void offsetCardCounter(QList<CardItem *> selectedCards, int counterId, int offset);
|
||||
};
|
||||
|
||||
#endif // COCKATRICE_PLAYER_ACTIONS_H
|
||||
@@ -0,0 +1,664 @@
|
||||
#include "player_event_handler.h"
|
||||
|
||||
#include "../../game_graphics/board/arrow_item.h"
|
||||
#include "../../game_graphics/board/card_item.h"
|
||||
#include "../../game_graphics/zones/view_zone.h"
|
||||
#include "../../interface/widgets/tabs/tab_game.h"
|
||||
#include "../board/arrow_data.h"
|
||||
#include "../board/card_list.h"
|
||||
#include "player_actions.h"
|
||||
#include "player_logic.h"
|
||||
|
||||
#include <libcockatrice/protocol/pb/command_set_card_attr.pb.h>
|
||||
#include <libcockatrice/protocol/pb/context_move_card.pb.h>
|
||||
#include <libcockatrice/protocol/pb/context_undo_draw.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_attach_card.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_change_zone_properties.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_create_arrow.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_create_counter.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_create_token.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_del_counter.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_delete_arrow.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_destroy_card.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_draw_cards.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_dump_zone.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_flip_card.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_game_log_notice.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_game_say.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_move_card.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_reveal_cards.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_roll_die.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_set_card_attr.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_set_card_counter.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_set_counter.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_shuffle.pb.h>
|
||||
#include <libcockatrice/utility/color.h>
|
||||
#include <libcockatrice/utility/zone_names.h>
|
||||
|
||||
PlayerEventHandler::PlayerEventHandler(PlayerLogic *_player) : QObject(_player), player(_player)
|
||||
{
|
||||
connect(this, &PlayerEventHandler::requestCardMenuUpdate, player, &PlayerLogic::requestCardMenuUpdate);
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventGameSay(const Event_GameSay &event)
|
||||
{
|
||||
emit logSay(player, QString::fromStdString(event.message()));
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventShuffle(const Event_Shuffle &event)
|
||||
{
|
||||
CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
|
||||
if (!zone) {
|
||||
return;
|
||||
}
|
||||
auto &cardList = zone->getCards();
|
||||
int absStart = event.start();
|
||||
if (absStart < 0) { // negative indexes start from the end
|
||||
absStart += cardList.length();
|
||||
}
|
||||
|
||||
// close all views that contain shuffled cards
|
||||
for (ZoneViewZone *view : zone->getViews()) {
|
||||
if (view != nullptr) {
|
||||
int length = view->getLogic()->getCards().length();
|
||||
// we want to close empty views as well
|
||||
if (length == 0 || length > absStart) { // note this assumes views always start at the top of the library
|
||||
view->close();
|
||||
}
|
||||
} else {
|
||||
qWarning() << zone->getName() << "of" << player->getPlayerInfo()->getName() << "holds empty zoneview!";
|
||||
}
|
||||
}
|
||||
|
||||
// remove revealed card name on top of decks
|
||||
if (absStart == 0 && !cardList.isEmpty()) {
|
||||
cardList.first()->setCardRef({});
|
||||
emit zone->updateGraphics();
|
||||
}
|
||||
|
||||
emit logShuffle(player, zone, event.start(), event.end());
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventRollDie(const Event_RollDie &event)
|
||||
{
|
||||
if (!event.values().empty()) {
|
||||
QList<uint> rolls(event.values().begin(), event.values().end());
|
||||
std::sort(rolls.begin(), rolls.end());
|
||||
emit logRollDie(player, static_cast<int>(event.sides()), rolls);
|
||||
} else if (event.value()) {
|
||||
// Backwards compatibility for old clients
|
||||
emit logRollDie(player, static_cast<int>(event.sides()), {event.value()});
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventCreateArrow(const Event_CreateArrow &event)
|
||||
{
|
||||
auto data = QSharedPointer<ArrowData>::create(ArrowData::fromProto(
|
||||
event.arrow_info(), player->getPlayerInfo()->getId(), player->getPlayerInfo()->getLocal()));
|
||||
|
||||
const auto &playerList = player->getGame()->getPlayerManager()->getPlayers();
|
||||
PlayerLogic *startPlayer = playerList.value(data->startPlayerId);
|
||||
PlayerLogic *targetPlayer = playerList.value(data->targetPlayerId);
|
||||
|
||||
QString startCardName, targetCardName;
|
||||
if (startPlayer) {
|
||||
if (auto *zone = startPlayer->getZones().value(data->startZone)) {
|
||||
if (auto *card = zone->getCard(data->startCardId)) {
|
||||
startCardName = card->getName();
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!data->isPlayerTargeted() && targetPlayer) {
|
||||
if (auto *zone = targetPlayer->getZones().value(data->targetZone)) {
|
||||
if (auto *card = zone->getCard(data->targetCardId)) {
|
||||
targetCardName = card->getName();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
emit player->arrowCreateRequested(data);
|
||||
|
||||
if (startPlayer && targetPlayer && !startCardName.isEmpty() &&
|
||||
(data->isPlayerTargeted() || !targetCardName.isEmpty())) {
|
||||
emit logCreateArrow(player, startPlayer, startCardName, targetPlayer, targetCardName, data->isPlayerTargeted());
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventDeleteArrow(const Event_DeleteArrow &event)
|
||||
{
|
||||
emit player->arrowDeleted(player->getPlayerInfo()->getId(), event.arrow_id());
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventCreateToken(const Event_CreateToken &event)
|
||||
{
|
||||
CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
|
||||
if (!zone) {
|
||||
return;
|
||||
}
|
||||
|
||||
CardRef cardRef = {QString::fromStdString(event.card_name()), QString::fromStdString(event.card_provider_id())};
|
||||
CardItem *card = new CardItem(player, nullptr, cardRef, event.card_id());
|
||||
// use db PT if not provided in event and not face-down
|
||||
if (!QString::fromStdString(event.pt()).isEmpty()) {
|
||||
card->setPT(QString::fromStdString(event.pt()));
|
||||
} else if (!event.face_down()) {
|
||||
ExactCard dbCard = card->getCard();
|
||||
if (dbCard) {
|
||||
card->setPT(dbCard.getInfo().getPowTough());
|
||||
}
|
||||
}
|
||||
card->setColor(QString::fromStdString(event.color()));
|
||||
card->setAnnotation(QString::fromStdString(event.annotation()));
|
||||
card->setDestroyOnZoneChange(event.destroy_on_zone_change());
|
||||
card->setFaceDown(event.face_down());
|
||||
|
||||
emit logCreateToken(player, card->getName(), card->getPT(), card->getFaceDown());
|
||||
zone->addCard(card, true, event.x(), event.y());
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventSetCardAttr(const Event_SetCardAttr &event,
|
||||
const GameEventContext &context,
|
||||
EventProcessingOptions options)
|
||||
{
|
||||
CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
|
||||
if (!zone) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!event.has_card_id()) {
|
||||
const CardList &cards = zone->getCards();
|
||||
for (int i = 0; i < cards.size(); ++i) {
|
||||
setCardAttrHelper(context, cards.at(i), event.attribute(), QString::fromStdString(event.attr_value()), true,
|
||||
options);
|
||||
}
|
||||
if (event.attribute() == AttrTapped) {
|
||||
emit logSetTapped(player, nullptr, event.attr_value() == "1");
|
||||
}
|
||||
} else {
|
||||
CardItem *card = zone->getCard(event.card_id());
|
||||
if (!card) {
|
||||
qWarning() << "PlayerEventHandler::eventSetCardAttr: card id=" << event.card_id() << "not found";
|
||||
return;
|
||||
}
|
||||
setCardAttrHelper(context, card, event.attribute(), QString::fromStdString(event.attr_value()), false, options);
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerEventHandler::setCardAttrHelper(const GameEventContext &context,
|
||||
CardItem *card,
|
||||
CardAttribute attribute,
|
||||
const QString &avalue,
|
||||
bool allCards,
|
||||
EventProcessingOptions options)
|
||||
{
|
||||
if (card == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
bool moveCardContext = context.HasExtension(Context_MoveCard::ext);
|
||||
switch (attribute) {
|
||||
case AttrTapped: {
|
||||
bool tapped = avalue == "1";
|
||||
if (!(!tapped && card->getDoesntUntap() && allCards)) {
|
||||
if (!allCards) {
|
||||
emit logSetTapped(player, card, tapped);
|
||||
}
|
||||
bool canAnimate = !options.testFlag(SKIP_TAP_ANIMATION) && !moveCardContext;
|
||||
card->setTapped(tapped, canAnimate);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case AttrAttacking: {
|
||||
card->setAttacking(avalue == "1");
|
||||
break;
|
||||
}
|
||||
case AttrFaceDown: {
|
||||
card->setFaceDown(avalue == "1");
|
||||
break;
|
||||
}
|
||||
case AttrColor: {
|
||||
card->setColor(avalue);
|
||||
break;
|
||||
}
|
||||
case AttrAnnotation: {
|
||||
emit logSetAnnotation(player, card, avalue);
|
||||
card->setAnnotation(avalue);
|
||||
break;
|
||||
}
|
||||
case AttrDoesntUntap: {
|
||||
bool value = (avalue == "1");
|
||||
emit logSetDoesntUntap(player, card, value);
|
||||
card->setDoesntUntap(value);
|
||||
break;
|
||||
}
|
||||
case AttrPT: {
|
||||
emit logSetPT(player, card, avalue);
|
||||
card->setPT(avalue);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventSetCardCounter(const Event_SetCardCounter &event)
|
||||
{
|
||||
CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
|
||||
if (!zone) {
|
||||
return;
|
||||
}
|
||||
|
||||
CardItem *card = zone->getCard(event.card_id());
|
||||
if (!card) {
|
||||
return;
|
||||
}
|
||||
|
||||
int oldValue = card->getCounters().value(event.counter_id(), 0);
|
||||
card->setCounter(event.counter_id(), event.counter_value());
|
||||
emit requestCardMenuUpdate(card);
|
||||
emit logSetCardCounter(player, card->getName(), event.counter_id(), event.counter_value(), oldValue);
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventCreateCounter(const Event_CreateCounter &event)
|
||||
{
|
||||
player->addCounter(event.counter_info());
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventSetCounter(const Event_SetCounter &event)
|
||||
{
|
||||
CounterState *ctr = player->getCounters().value(event.counter_id(), nullptr);
|
||||
if (!ctr) {
|
||||
return;
|
||||
}
|
||||
int oldValue = ctr->getValue();
|
||||
ctr->setValue(event.value());
|
||||
emit logSetCounter(player, ctr->getName(), event.value(), oldValue);
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventDelCounter(const Event_DelCounter &event)
|
||||
{
|
||||
player->delCounter(event.counter_id());
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventDumpZone(const Event_DumpZone &event)
|
||||
{
|
||||
PlayerLogic *zoneOwner = player->getGame()->getPlayerManager()->getPlayers().value(event.zone_owner_id(), 0);
|
||||
if (!zoneOwner) {
|
||||
return;
|
||||
}
|
||||
CardZoneLogic *zone = zoneOwner->getZones().value(QString::fromStdString(event.zone_name()), 0);
|
||||
if (!zone) {
|
||||
return;
|
||||
}
|
||||
emit logDumpZone(player, zone, event.number_cards(), event.is_reversed());
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventMoveCard(const Event_MoveCard &event, const GameEventContext &context)
|
||||
{
|
||||
PlayerLogic *startPlayer = player->getGame()->getPlayerManager()->getPlayers().value(event.start_player_id());
|
||||
if (!startPlayer) {
|
||||
return;
|
||||
}
|
||||
QString startZoneString = QString::fromStdString(event.start_zone());
|
||||
CardZoneLogic *startZone = startPlayer->getZones().value(startZoneString, 0);
|
||||
PlayerLogic *targetPlayer = player->getGame()->getPlayerManager()->getPlayers().value(event.target_player_id());
|
||||
if (!targetPlayer) {
|
||||
return;
|
||||
}
|
||||
CardZoneLogic *targetZone;
|
||||
if (event.has_target_zone()) {
|
||||
targetZone = targetPlayer->getZones().value(QString::fromStdString(event.target_zone()), 0);
|
||||
} else {
|
||||
targetZone = startZone;
|
||||
}
|
||||
if (!startZone || !targetZone) {
|
||||
return;
|
||||
}
|
||||
|
||||
int position = event.position();
|
||||
int x = event.x();
|
||||
int y = event.y();
|
||||
|
||||
int logPosition = position;
|
||||
int logX = x;
|
||||
if (x == -1) {
|
||||
x = 0;
|
||||
}
|
||||
CardItem *card = startZone->takeCard(position, event.card_id(), startZone != targetZone);
|
||||
if (card == nullptr) {
|
||||
return;
|
||||
}
|
||||
if (startZone != targetZone) {
|
||||
card->deleteCardInfoPopup();
|
||||
}
|
||||
if (event.has_card_name()) {
|
||||
QString name = QString::fromStdString(event.card_name());
|
||||
QString providerId =
|
||||
event.has_new_card_provider_id() ? QString::fromStdString(event.new_card_provider_id()) : "";
|
||||
card->setCardRef({name, providerId});
|
||||
}
|
||||
|
||||
if (card->getAttachedTo() && (startZone != targetZone)) {
|
||||
CardItem *parentCard = card->getAttachedTo();
|
||||
card->setAttachedTo(nullptr);
|
||||
parentCard->getZone()->reorganizeCards();
|
||||
}
|
||||
|
||||
card->deleteDragItem();
|
||||
|
||||
card->setId(event.new_card_id());
|
||||
card->setFaceDown(event.face_down());
|
||||
if (startZone != targetZone) {
|
||||
card->setBeingPointedAt(false);
|
||||
card->setHovered(false);
|
||||
|
||||
const QList<CardItem *> &attachedCards = card->getAttachedCards();
|
||||
for (auto attachedCard : attachedCards) {
|
||||
emit targetZone->cardAdded(attachedCard);
|
||||
}
|
||||
|
||||
if (startZone->getPlayer() != targetZone->getPlayer()) {
|
||||
card->setOwner(targetZone->getPlayer());
|
||||
}
|
||||
}
|
||||
|
||||
// The log event has to be sent before the card is added to the target zone
|
||||
// because the addCard function can modify the card object.
|
||||
if (context.HasExtension(Context_UndoDraw::ext)) {
|
||||
emit logUndoDraw(player, card->getName());
|
||||
} else {
|
||||
emit logMoveCard(player, card, startZone, logPosition, targetZone, logX);
|
||||
}
|
||||
|
||||
targetZone->addCard(card, true, x, y);
|
||||
|
||||
emit cardZoneChanged(card, startZone == targetZone);
|
||||
emit requestCardMenuUpdate(card);
|
||||
|
||||
if (player->getPlayerActions()->isMovingCardsUntil() && startZoneString == ZoneNames::DECK &&
|
||||
targetZone->getName() == ZoneNames::STACK) {
|
||||
player->getPlayerActions()->moveOneCardUntil(card);
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventFlipCard(const Event_FlipCard &event)
|
||||
{
|
||||
CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
|
||||
if (!zone) {
|
||||
return;
|
||||
}
|
||||
CardItem *card = zone->getCard(event.card_id());
|
||||
if (!card) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!event.face_down()) {
|
||||
QString cardName = QString::fromStdString(event.card_name());
|
||||
QString providerId = QString::fromStdString(event.card_provider_id());
|
||||
card->setCardRef({cardName, providerId});
|
||||
}
|
||||
|
||||
emit logFlipCard(player, card->getName(), event.face_down());
|
||||
card->setFaceDown(event.face_down());
|
||||
emit requestCardMenuUpdate(card);
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventDestroyCard(const Event_DestroyCard &event)
|
||||
{
|
||||
CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
|
||||
if (!zone) {
|
||||
return;
|
||||
}
|
||||
|
||||
CardItem *card = zone->getCard(event.card_id());
|
||||
if (!card) {
|
||||
return;
|
||||
}
|
||||
|
||||
QList<CardItem *> attachedCards = card->getAttachedCards();
|
||||
// This list is always empty except for buggy server implementations.
|
||||
for (auto &attachedCard : attachedCards) {
|
||||
attachedCard->setAttachedTo(nullptr);
|
||||
}
|
||||
|
||||
emit logDestroyCard(player, card->getName());
|
||||
zone->takeCard(-1, event.card_id(), true);
|
||||
card->deleteLater();
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventAttachCard(const Event_AttachCard &event)
|
||||
{
|
||||
const QMap<int, PlayerLogic *> &playerList = player->getGame()->getPlayerManager()->getPlayers();
|
||||
PlayerLogic *targetPlayer = nullptr;
|
||||
CardZoneLogic *targetZone = nullptr;
|
||||
CardItem *targetCard = nullptr;
|
||||
if (event.has_target_player_id()) {
|
||||
targetPlayer = playerList.value(event.target_player_id(), 0);
|
||||
if (targetPlayer) {
|
||||
targetZone = targetPlayer->getZones().value(QString::fromStdString(event.target_zone()), 0);
|
||||
if (targetZone) {
|
||||
targetCard = targetZone->getCard(event.target_card_id());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CardZoneLogic *startZone = player->getZone(QString::fromStdString(event.start_zone()));
|
||||
if (!startZone) {
|
||||
return;
|
||||
}
|
||||
|
||||
CardItem *startCard = startZone->getCard(event.card_id());
|
||||
if (!startCard) {
|
||||
return;
|
||||
}
|
||||
|
||||
CardItem *oldParent = startCard->getAttachedTo();
|
||||
|
||||
startCard->setAttachedTo(targetCard);
|
||||
|
||||
startZone->reorganizeCards();
|
||||
if ((startZone != targetZone) && targetZone) {
|
||||
targetZone->reorganizeCards();
|
||||
}
|
||||
if (oldParent) {
|
||||
oldParent->getZone()->reorganizeCards();
|
||||
}
|
||||
|
||||
if (targetCard) {
|
||||
emit logAttachCard(player, startCard->getName(), targetPlayer, targetCard->getName());
|
||||
} else {
|
||||
emit logUnattachCard(player, startCard->getName());
|
||||
}
|
||||
emit requestCardMenuUpdate(startCard);
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventDrawCards(const Event_DrawCards &event)
|
||||
{
|
||||
CardZoneLogic *_deck = player->getDeckZone();
|
||||
CardZoneLogic *_hand = player->getHandZone();
|
||||
|
||||
const int listSize = event.cards_size();
|
||||
if (listSize) {
|
||||
for (int i = 0; i < listSize; ++i) {
|
||||
const ServerInfo_Card &cardInfo = event.cards(i);
|
||||
CardItem *card = _deck->takeCard(0, cardInfo.id());
|
||||
QString cardName = QString::fromStdString(cardInfo.name());
|
||||
QString providerId = QString::fromStdString(cardInfo.provider_id());
|
||||
card->setCardRef({cardName, providerId});
|
||||
_hand->addCard(card, false, -1);
|
||||
}
|
||||
} else {
|
||||
const int number = event.number();
|
||||
for (int i = 0; i < number; ++i) {
|
||||
_hand->addCard(_deck->takeCard(0, -1), false, -1);
|
||||
}
|
||||
}
|
||||
|
||||
_hand->reorganizeCards();
|
||||
_deck->reorganizeCards();
|
||||
emit logDrawCards(player, event.number(), _deck->getCards().size() == 0);
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventRevealCards(const Event_RevealCards &event, EventProcessingOptions options)
|
||||
{
|
||||
Q_UNUSED(options);
|
||||
CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
|
||||
if (!zone) {
|
||||
return;
|
||||
}
|
||||
PlayerLogic *otherPlayer = nullptr;
|
||||
if (event.has_other_player_id()) {
|
||||
otherPlayer = player->getGame()->getPlayerManager()->getPlayers().value(event.other_player_id());
|
||||
if (!otherPlayer) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
bool peeking = false;
|
||||
QList<const ServerInfo_Card *> cardList;
|
||||
const int cardListSize = event.cards_size();
|
||||
for (int i = 0; i < cardListSize; ++i) {
|
||||
const ServerInfo_Card *temp = &event.cards(i);
|
||||
if (temp->face_down()) {
|
||||
peeking = true;
|
||||
}
|
||||
cardList.append(temp);
|
||||
}
|
||||
|
||||
if (peeking) {
|
||||
for (const auto &card : cardList) {
|
||||
QString cardName = QString::fromStdString(card->name());
|
||||
QString providerId = QString::fromStdString(card->provider_id());
|
||||
CardItem *cardItem = zone->getCard(card->id());
|
||||
if (!cardItem) {
|
||||
continue;
|
||||
}
|
||||
cardItem->setCardRef({cardName, providerId});
|
||||
emit logRevealCards(player, zone, card->id(), cardName, player, true, 1);
|
||||
}
|
||||
} else {
|
||||
bool showZoneView = true;
|
||||
QString cardName;
|
||||
auto cardId = event.card_id_size() == 0 ? -1 : event.card_id(0);
|
||||
if (cardList.size() == 1) {
|
||||
cardName = QString::fromStdString(cardList.first()->name());
|
||||
|
||||
// Handle case of revealing top card of library in-place
|
||||
if (cardId == 0 && dynamic_cast<PileZoneLogic *>(zone)) {
|
||||
auto card = zone->getCards().first();
|
||||
QString providerId = QString::fromStdString(cardList.first()->provider_id());
|
||||
card->setCardRef({cardName, providerId});
|
||||
|
||||
emit zone->updateGraphics();
|
||||
showZoneView = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (!options.testFlag(SKIP_REVEAL_WINDOW) && showZoneView && !cardList.isEmpty()) {
|
||||
emit player->requestRevealedZoneView(player, zone, cardList, event.grant_write_access());
|
||||
}
|
||||
|
||||
emit logRevealCards(player, zone, cardId, cardName, otherPlayer, false,
|
||||
event.has_number_of_cards() ? event.number_of_cards() : cardList.size(),
|
||||
event.grant_write_access());
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventChangeZoneProperties(const Event_ChangeZoneProperties &event)
|
||||
{
|
||||
CardZoneLogic *zone = player->getZone(QString::fromStdString(event.zone_name()));
|
||||
if (!zone) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (event.has_always_reveal_top_card()) {
|
||||
zone->setAlwaysRevealTopCard(event.always_reveal_top_card());
|
||||
emit logAlwaysRevealTopCard(player, zone, event.always_reveal_top_card());
|
||||
}
|
||||
if (event.has_always_look_at_top_card()) {
|
||||
zone->setAlwaysRevealTopCard(event.always_look_at_top_card());
|
||||
emit logAlwaysLookAtTopCard(player, zone, event.always_look_at_top_card());
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerEventHandler::eventGameLogNotice(const Event_GameLogNotice &event)
|
||||
{
|
||||
Event_GameLogNotice::NoticeType type = event.notice_type();
|
||||
switch (type) {
|
||||
case Event_GameLogNotice::UNDO_DRAW_FAILED:
|
||||
emit logUndoDrawFailed(player);
|
||||
break;
|
||||
default:
|
||||
qWarning() << "Received Event_GameLogNotice with unknown noticeType: " << type;
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerEventHandler::processGameEvent(GameEvent::GameEventType type,
|
||||
const GameEvent &event,
|
||||
const GameEventContext &context,
|
||||
EventProcessingOptions options)
|
||||
{
|
||||
switch (type) {
|
||||
case GameEvent::GAME_SAY:
|
||||
eventGameSay(event.GetExtension(Event_GameSay::ext));
|
||||
break;
|
||||
case GameEvent::SHUFFLE:
|
||||
eventShuffle(event.GetExtension(Event_Shuffle::ext));
|
||||
break;
|
||||
case GameEvent::ROLL_DIE:
|
||||
eventRollDie(event.GetExtension(Event_RollDie::ext));
|
||||
break;
|
||||
case GameEvent::CREATE_ARROW:
|
||||
eventCreateArrow(event.GetExtension(Event_CreateArrow::ext));
|
||||
break;
|
||||
case GameEvent::DELETE_ARROW:
|
||||
eventDeleteArrow(event.GetExtension(Event_DeleteArrow::ext));
|
||||
break;
|
||||
case GameEvent::CREATE_TOKEN:
|
||||
eventCreateToken(event.GetExtension(Event_CreateToken::ext));
|
||||
break;
|
||||
case GameEvent::SET_CARD_ATTR:
|
||||
eventSetCardAttr(event.GetExtension(Event_SetCardAttr::ext), context, options);
|
||||
break;
|
||||
case GameEvent::SET_CARD_COUNTER:
|
||||
eventSetCardCounter(event.GetExtension(Event_SetCardCounter::ext));
|
||||
break;
|
||||
case GameEvent::CREATE_COUNTER:
|
||||
eventCreateCounter(event.GetExtension(Event_CreateCounter::ext));
|
||||
break;
|
||||
case GameEvent::SET_COUNTER:
|
||||
eventSetCounter(event.GetExtension(Event_SetCounter::ext));
|
||||
break;
|
||||
case GameEvent::DEL_COUNTER:
|
||||
eventDelCounter(event.GetExtension(Event_DelCounter::ext));
|
||||
break;
|
||||
case GameEvent::DUMP_ZONE:
|
||||
eventDumpZone(event.GetExtension(Event_DumpZone::ext));
|
||||
break;
|
||||
case GameEvent::MOVE_CARD:
|
||||
eventMoveCard(event.GetExtension(Event_MoveCard::ext), context);
|
||||
break;
|
||||
case GameEvent::FLIP_CARD:
|
||||
eventFlipCard(event.GetExtension(Event_FlipCard::ext));
|
||||
break;
|
||||
case GameEvent::DESTROY_CARD:
|
||||
eventDestroyCard(event.GetExtension(Event_DestroyCard::ext));
|
||||
break;
|
||||
case GameEvent::ATTACH_CARD:
|
||||
eventAttachCard(event.GetExtension(Event_AttachCard::ext));
|
||||
break;
|
||||
case GameEvent::DRAW_CARDS:
|
||||
eventDrawCards(event.GetExtension(Event_DrawCards::ext));
|
||||
break;
|
||||
case GameEvent::REVEAL_CARDS:
|
||||
eventRevealCards(event.GetExtension(Event_RevealCards::ext), options);
|
||||
break;
|
||||
case GameEvent::CHANGE_ZONE_PROPERTIES:
|
||||
eventChangeZoneProperties(event.GetExtension(Event_ChangeZoneProperties::ext));
|
||||
break;
|
||||
case GameEvent::GAME_LOG_NOTICE:
|
||||
eventGameLogNotice(event.GetExtension(Event_GameLogNotice::ext));
|
||||
break;
|
||||
default: {
|
||||
qWarning() << "unhandled game event" << type;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
/**
|
||||
* @file player_event_handler.h
|
||||
* @ingroup GameLogicPlayers
|
||||
*/
|
||||
//! \todo Document this file.
|
||||
|
||||
#ifndef COCKATRICE_PLAYER_EVENT_HANDLER_H
|
||||
#define COCKATRICE_PLAYER_EVENT_HANDLER_H
|
||||
#include "event_processing_options.h"
|
||||
|
||||
#include <QObject>
|
||||
#include <libcockatrice/protocol/pb/card_attributes.pb.h>
|
||||
#include <libcockatrice/protocol/pb/game_event.pb.h>
|
||||
#include <libcockatrice/protocol/pb/game_event_context.pb.h>
|
||||
|
||||
class CardItem;
|
||||
class CardZoneLogic;
|
||||
class PlayerLogic;
|
||||
class Event_AttachCard;
|
||||
class Event_ChangeZoneProperties;
|
||||
class Event_CreateArrow;
|
||||
class Event_CreateCounter;
|
||||
class Event_CreateToken;
|
||||
class Event_DelCounter;
|
||||
class Event_DeleteArrow;
|
||||
class Event_DestroyCard;
|
||||
class Event_DrawCards;
|
||||
class Event_DumpZone;
|
||||
class Event_FlipCard;
|
||||
class Event_GameSay;
|
||||
class Event_MoveCard;
|
||||
class Event_RevealCards;
|
||||
class Event_RollDie;
|
||||
class Event_SetCardAttr;
|
||||
class Event_SetCardCounter;
|
||||
class Event_SetCounter;
|
||||
class Event_Shuffle;
|
||||
class Event_GameLogNotice;
|
||||
|
||||
class PlayerEventHandler : public QObject
|
||||
{
|
||||
|
||||
Q_OBJECT
|
||||
signals:
|
||||
void logSay(PlayerLogic *player, QString message);
|
||||
void logShuffle(PlayerLogic *player, CardZoneLogic *zone, int start, int end);
|
||||
void logRollDie(PlayerLogic *player, int sides, const QList<uint> &rolls);
|
||||
void logCreateArrow(PlayerLogic *player,
|
||||
PlayerLogic *startPlayer,
|
||||
QString startCard,
|
||||
PlayerLogic *targetPlayer,
|
||||
QString targetCard,
|
||||
bool _playerTarget);
|
||||
void logCreateToken(PlayerLogic *player, QString cardName, QString pt, bool faceDown);
|
||||
void logDrawCards(PlayerLogic *player, int number, bool deckIsEmpty);
|
||||
void logUndoDraw(PlayerLogic *player, QString cardName);
|
||||
void logUndoDrawFailed(PlayerLogic *player);
|
||||
void logMoveCard(PlayerLogic *player,
|
||||
CardItem *card,
|
||||
CardZoneLogic *startZone,
|
||||
int oldX,
|
||||
CardZoneLogic *targetZone,
|
||||
int newX);
|
||||
void logFlipCard(PlayerLogic *player, QString cardName, bool faceDown);
|
||||
void logDestroyCard(PlayerLogic *player, QString cardName);
|
||||
void logAttachCard(PlayerLogic *player, QString cardName, PlayerLogic *targetPlayer, QString targetCardName);
|
||||
void logUnattachCard(PlayerLogic *player, QString cardName);
|
||||
void logSetCardCounter(PlayerLogic *player, QString cardName, int counterId, int value, int oldValue);
|
||||
void logSetTapped(PlayerLogic *player, CardItem *card, bool tapped);
|
||||
void logSetCounter(PlayerLogic *player, QString counterName, int value, int oldValue);
|
||||
void logSetDoesntUntap(PlayerLogic *player, CardItem *card, bool doesntUntap);
|
||||
void logSetPT(PlayerLogic *player, CardItem *card, QString newPT);
|
||||
void logSetAnnotation(PlayerLogic *player, CardItem *card, QString newAnnotation);
|
||||
void logDumpZone(PlayerLogic *player, CardZoneLogic *zone, int numberCards, bool isReversed = false);
|
||||
void logRevealCards(PlayerLogic *player,
|
||||
CardZoneLogic *zone,
|
||||
int cardId,
|
||||
QString cardName,
|
||||
PlayerLogic *otherPlayer,
|
||||
bool faceDown,
|
||||
int amount,
|
||||
bool isLentToAnotherPlayer = false);
|
||||
void logAlwaysRevealTopCard(PlayerLogic *player, CardZoneLogic *zone, bool reveal);
|
||||
void logAlwaysLookAtTopCard(PlayerLogic *player, CardZoneLogic *zone, bool reveal);
|
||||
void cardZoneChanged(CardItem *card, bool sameZone);
|
||||
void requestCardMenuUpdate(const CardItem *card);
|
||||
|
||||
public:
|
||||
PlayerEventHandler(PlayerLogic *player);
|
||||
|
||||
void processGameEvent(GameEvent::GameEventType type,
|
||||
const GameEvent &event,
|
||||
const GameEventContext &context,
|
||||
EventProcessingOptions options);
|
||||
|
||||
void eventGameSay(const Event_GameSay &event);
|
||||
void eventShuffle(const Event_Shuffle &event);
|
||||
void eventRollDie(const Event_RollDie &event);
|
||||
void eventCreateArrow(const Event_CreateArrow &event);
|
||||
void eventDeleteArrow(const Event_DeleteArrow &event);
|
||||
void eventCreateToken(const Event_CreateToken &event);
|
||||
void
|
||||
eventSetCardAttr(const Event_SetCardAttr &event, const GameEventContext &context, EventProcessingOptions options);
|
||||
void eventSetCardCounter(const Event_SetCardCounter &event);
|
||||
void eventCreateCounter(const Event_CreateCounter &event);
|
||||
void eventSetCounter(const Event_SetCounter &event);
|
||||
void eventDelCounter(const Event_DelCounter &event);
|
||||
void eventDumpZone(const Event_DumpZone &event);
|
||||
void eventMoveCard(const Event_MoveCard &event, const GameEventContext &context);
|
||||
void eventFlipCard(const Event_FlipCard &event);
|
||||
void eventDestroyCard(const Event_DestroyCard &event);
|
||||
void eventAttachCard(const Event_AttachCard &event);
|
||||
void eventDrawCards(const Event_DrawCards &event);
|
||||
void eventRevealCards(const Event_RevealCards &event, EventProcessingOptions options);
|
||||
void eventChangeZoneProperties(const Event_ChangeZoneProperties &event);
|
||||
void eventGameLogNotice(const Event_GameLogNotice &event);
|
||||
|
||||
private:
|
||||
PlayerLogic *player;
|
||||
|
||||
void setCardAttrHelper(const GameEventContext &context,
|
||||
CardItem *card,
|
||||
CardAttribute attribute,
|
||||
const QString &avalue,
|
||||
bool allCards,
|
||||
EventProcessingOptions options);
|
||||
};
|
||||
|
||||
#endif // COCKATRICE_PLAYER_EVENT_HANDLER_H
|
||||
@@ -0,0 +1,8 @@
|
||||
#include "player_info.h"
|
||||
|
||||
PlayerInfo::PlayerInfo(const ServerInfo_User &info, int _id, bool _local, bool _judge)
|
||||
: id(_id), local(_local), judge(_judge)
|
||||
{
|
||||
userInfo = new ServerInfo_User;
|
||||
userInfo->CopyFrom(info);
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* @file player_info.h
|
||||
* @ingroup GameLogicPlayers
|
||||
*/
|
||||
//! \todo Document this file.
|
||||
|
||||
#ifndef COCKATRICE_PLAYER_INFO_H
|
||||
#define COCKATRICE_PLAYER_INFO_H
|
||||
|
||||
#include "../../game_graphics/player/player_target.h"
|
||||
|
||||
#include <QObject>
|
||||
#include <libcockatrice/protocol/pb/serverinfo_user.pb.h>
|
||||
|
||||
class PlayerInfo : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
public:
|
||||
PlayerInfo(const ServerInfo_User &info, int id, bool local, bool judge);
|
||||
|
||||
ServerInfo_User *userInfo;
|
||||
int id;
|
||||
bool local;
|
||||
bool judge;
|
||||
|
||||
int getId() const
|
||||
{
|
||||
return id;
|
||||
}
|
||||
ServerInfo_User *getUserInfo() const
|
||||
{
|
||||
return userInfo;
|
||||
}
|
||||
|
||||
void setLocal(bool _local)
|
||||
{
|
||||
local = _local;
|
||||
}
|
||||
|
||||
bool getLocal() const
|
||||
{
|
||||
return local;
|
||||
}
|
||||
bool getLocalOrJudge() const
|
||||
{
|
||||
return local || judge;
|
||||
}
|
||||
bool getJudge() const
|
||||
{
|
||||
return judge;
|
||||
}
|
||||
|
||||
QString getName() const
|
||||
{
|
||||
return QString::fromStdString(userInfo->name());
|
||||
}
|
||||
};
|
||||
|
||||
#endif // COCKATRICE_PLAYER_INFO_H
|
||||
@@ -0,0 +1,336 @@
|
||||
#include "player_logic.h"
|
||||
|
||||
#include "../../game_graphics/board/arrow_item.h"
|
||||
#include "../../game_graphics/board/card_item.h"
|
||||
#include "../../game_graphics/board/counter_general.h"
|
||||
#include "../../game_graphics/game_scene.h"
|
||||
#include "../../game_graphics/player/player_target.h"
|
||||
#include "../../game_graphics/zones/hand_zone.h"
|
||||
#include "../../game_graphics/zones/pile_zone.h"
|
||||
#include "../../game_graphics/zones/stack_zone.h"
|
||||
#include "../../game_graphics/zones/table_zone.h"
|
||||
#include "../../interface/theme_manager.h"
|
||||
#include "../../interface/widgets/tabs/tab_game.h"
|
||||
#include "../board/card_list.h"
|
||||
#include "player_actions.h"
|
||||
|
||||
#include <QDebug>
|
||||
#include <QMenu>
|
||||
#include <QMetaType>
|
||||
#include <QPainter>
|
||||
#include <QtConcurrent>
|
||||
#include <libcockatrice/protocol/pb/command_attach_card.pb.h>
|
||||
#include <libcockatrice/protocol/pb/command_set_card_counter.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_create_arrow.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_create_counter.pb.h>
|
||||
#include <libcockatrice/protocol/pb/event_draw_cards.pb.h>
|
||||
#include <libcockatrice/protocol/pb/serverinfo_player.pb.h>
|
||||
#include <libcockatrice/protocol/pb/serverinfo_user.pb.h>
|
||||
#include <libcockatrice/protocol/pb/serverinfo_zone.pb.h>
|
||||
#include <libcockatrice/utility/color.h>
|
||||
|
||||
PlayerLogic::PlayerLogic(const ServerInfo_User &info, int _id, bool _local, bool _judge, AbstractGame *_parent)
|
||||
: QObject(_parent), game(_parent), playerInfo(new PlayerInfo(info, _id, _local, _judge)),
|
||||
playerEventHandler(new PlayerEventHandler(this)), playerActions(new PlayerActions(this)), active(false),
|
||||
conceded(false), zoneId(0), dialogSemaphore(false)
|
||||
{
|
||||
initializeZones();
|
||||
}
|
||||
|
||||
void PlayerLogic::initializeZones()
|
||||
{
|
||||
addZone(new PileZoneLogic(this, ZoneNames::DECK, false, true, false, this));
|
||||
addZone(new PileZoneLogic(this, ZoneNames::GRAVE, false, false, true, this));
|
||||
addZone(new PileZoneLogic(this, ZoneNames::EXILE, false, false, true, this));
|
||||
addZone(new PileZoneLogic(this, ZoneNames::SIDEBOARD, false, false, false, this));
|
||||
addZone(new TableZoneLogic(this, ZoneNames::TABLE, true, false, true, this));
|
||||
addZone(new StackZoneLogic(this, ZoneNames::STACK, true, false, true, this));
|
||||
bool visibleHand = playerInfo->getLocalOrJudge() ||
|
||||
(game->getPlayerManager()->isSpectator() && game->getGameMetaInfo()->spectatorsOmniscient());
|
||||
addZone(new HandZoneLogic(this, ZoneNames::HAND, false, false, visibleHand, this));
|
||||
}
|
||||
|
||||
PlayerLogic::~PlayerLogic()
|
||||
{
|
||||
qCInfo(PlayerLog) << "Player destructor:" << getPlayerInfo()->getName();
|
||||
|
||||
QMapIterator<QString, CardZoneLogic *> i(zones);
|
||||
while (i.hasNext()) {
|
||||
delete i.next().value();
|
||||
}
|
||||
zones.clear();
|
||||
|
||||
delete getPlayerInfo()->userInfo;
|
||||
}
|
||||
|
||||
void PlayerLogic::clear()
|
||||
{
|
||||
emit arrowsClearedLocally();
|
||||
|
||||
QMapIterator<QString, CardZoneLogic *> i(zones);
|
||||
while (i.hasNext()) {
|
||||
i.next().value()->clearContents();
|
||||
}
|
||||
|
||||
clearCounters();
|
||||
}
|
||||
|
||||
void PlayerLogic::setConceded(bool _conceded)
|
||||
{
|
||||
if (conceded != _conceded) {
|
||||
conceded = _conceded;
|
||||
|
||||
if (conceded) {
|
||||
clear();
|
||||
}
|
||||
emit concededChanged(getPlayerInfo()->getId(), conceded);
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerLogic::setZoneId(int _zoneId)
|
||||
{
|
||||
if (zoneId != _zoneId) {
|
||||
zoneId = _zoneId;
|
||||
emit zoneIdChanged(zoneId);
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerLogic::processPlayerInfo(const ServerInfo_Player &info)
|
||||
{
|
||||
static QSet<QString> builtinZones{/* PileZones */
|
||||
ZoneNames::DECK, ZoneNames::GRAVE, ZoneNames::EXILE, ZoneNames::SIDEBOARD,
|
||||
/* TableZone */
|
||||
ZoneNames::TABLE,
|
||||
/* StackZone */
|
||||
ZoneNames::STACK,
|
||||
/* HandZone */
|
||||
ZoneNames::HAND};
|
||||
clearCounters();
|
||||
emit arrowsClearedLocally();
|
||||
|
||||
QMutableMapIterator<QString, CardZoneLogic *> zoneIt(zones);
|
||||
while (zoneIt.hasNext()) {
|
||||
zoneIt.next().value()->clearContents();
|
||||
|
||||
if (!builtinZones.contains(zoneIt.key())) {
|
||||
zoneIt.remove();
|
||||
}
|
||||
}
|
||||
|
||||
emit clearCustomZonesMenu();
|
||||
|
||||
const int zoneListSize = info.zone_list_size();
|
||||
for (int i = 0; i < zoneListSize; ++i) {
|
||||
const ServerInfo_Zone &zoneInfo = info.zone_list(i);
|
||||
|
||||
QString zoneName = QString::fromStdString(zoneInfo.name());
|
||||
CardZoneLogic *zone = zones.value(zoneName, 0);
|
||||
if (!zone) {
|
||||
// Create a new CardZone if it doesn't exist
|
||||
|
||||
if (zoneInfo.with_coords()) {
|
||||
// Visibility not currently supported for TableZone
|
||||
zone = addZone(new TableZoneLogic(this, zoneName, true, false, true, this));
|
||||
} else {
|
||||
// Zones without coordinats are always treated as non-shufflable
|
||||
// PileZones, although supporting alternate hand or stack zones
|
||||
// might make sense in some scenarios.
|
||||
bool contentsKnown;
|
||||
|
||||
switch (zoneInfo.type()) {
|
||||
case ServerInfo_Zone::PrivateZone:
|
||||
contentsKnown =
|
||||
playerInfo->getLocalOrJudge() || (game->getPlayerManager()->isSpectator() &&
|
||||
game->getGameMetaInfo()->spectatorsOmniscient());
|
||||
break;
|
||||
|
||||
case ServerInfo_Zone::PublicZone:
|
||||
contentsKnown = true;
|
||||
break;
|
||||
|
||||
case ServerInfo_Zone::HiddenZone:
|
||||
contentsKnown = false;
|
||||
break;
|
||||
}
|
||||
|
||||
zone = addZone(new PileZoneLogic(this, zoneName, false, /* isShufflable */ false, contentsKnown, this));
|
||||
}
|
||||
|
||||
// Non-builtin zones are hidden by default and can't be interacted
|
||||
// with, except through menus.
|
||||
emit zone->setGraphicsVisibility(false);
|
||||
|
||||
emit addViewCustomZoneActionToCustomZoneMenu(zoneName);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
const int cardListSize = zoneInfo.card_list_size();
|
||||
if (!cardListSize) {
|
||||
for (int j = 0; j < zoneInfo.card_count(); ++j) {
|
||||
zone->addCard(new CardItem(this), false, -1);
|
||||
}
|
||||
} else {
|
||||
for (int j = 0; j < cardListSize; ++j) {
|
||||
const ServerInfo_Card &cardInfo = zoneInfo.card_list(j);
|
||||
auto *card = new CardItem(this);
|
||||
card->processCardInfo(cardInfo);
|
||||
zone->addCard(card, false, cardInfo.x(), cardInfo.y());
|
||||
}
|
||||
}
|
||||
if (zoneInfo.has_always_reveal_top_card()) {
|
||||
zone->setAlwaysRevealTopCard(zoneInfo.always_reveal_top_card());
|
||||
}
|
||||
|
||||
zone->reorganizeCards();
|
||||
}
|
||||
|
||||
const int counterListSize = info.counter_list_size();
|
||||
for (int i = 0; i < counterListSize; ++i) {
|
||||
addCounter(info.counter_list(i));
|
||||
}
|
||||
|
||||
setConceded(info.properties().conceded());
|
||||
}
|
||||
|
||||
void PlayerLogic::processCardAttachment(const ServerInfo_Player &info)
|
||||
{
|
||||
const int zoneListSize = info.zone_list_size();
|
||||
for (int i = 0; i < zoneListSize; ++i) {
|
||||
const ServerInfo_Zone &zoneInfo = info.zone_list(i);
|
||||
CardZoneLogic *zone = zones.value(QString::fromStdString(zoneInfo.name()), 0);
|
||||
if (!zone) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const int cardListSize = zoneInfo.card_list_size();
|
||||
for (int j = 0; j < cardListSize; ++j) {
|
||||
const ServerInfo_Card &cardInfo = zoneInfo.card_list(j);
|
||||
if (cardInfo.has_attach_player_id()) {
|
||||
CardItem *startCard = zone->getCard(cardInfo.id());
|
||||
CardItem *targetCard =
|
||||
game->getCard(cardInfo.attach_player_id(), QString::fromStdString(cardInfo.attach_zone()),
|
||||
cardInfo.attach_card_id());
|
||||
if (!targetCard) {
|
||||
continue;
|
||||
}
|
||||
|
||||
startCard->setAttachedTo(targetCard);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const int arrowListSize = info.arrow_list_size();
|
||||
for (int i = 0; i < arrowListSize; ++i) {
|
||||
emit arrowCreateRequested(QSharedPointer<ArrowData>::create(
|
||||
ArrowData::fromProto(info.arrow_list(i), getPlayerInfo()->getId(), getPlayerInfo()->getLocal())));
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerLogic::addCard(CardItem *card)
|
||||
{
|
||||
emit newCardAdded(card);
|
||||
}
|
||||
|
||||
void PlayerLogic::deleteCard(CardItem *card)
|
||||
{
|
||||
if (card == nullptr) {
|
||||
return;
|
||||
} else if (dialogSemaphore) {
|
||||
cardsToDelete.append(card);
|
||||
} else {
|
||||
card->deleteLater();
|
||||
}
|
||||
}
|
||||
|
||||
void PlayerLogic::setDeck(const DeckList &_deck)
|
||||
{
|
||||
deck = _deck;
|
||||
|
||||
emit deckChanged();
|
||||
}
|
||||
|
||||
CounterState *PlayerLogic::addCounter(const ServerInfo_Counter &counter)
|
||||
{
|
||||
return addCounter(counter.id(), QString::fromStdString(counter.name()),
|
||||
convertColorToQColor(counter.counter_color()), counter.radius(), counter.count());
|
||||
}
|
||||
|
||||
CounterState *PlayerLogic::addCounter(int id, const QString &name, const QColor &color, int radius, int value)
|
||||
{
|
||||
if (counters.contains(id)) {
|
||||
return nullptr;
|
||||
}
|
||||
auto *state = new CounterState(id, name, color, radius, value, this);
|
||||
counters.insert(id, state);
|
||||
emit counterAdded(state);
|
||||
return state;
|
||||
}
|
||||
|
||||
void PlayerLogic::delCounter(int id)
|
||||
{
|
||||
auto *state = counters.take(id);
|
||||
if (!state) {
|
||||
return;
|
||||
}
|
||||
emit counterRemoved(id);
|
||||
state->deleteLater();
|
||||
}
|
||||
|
||||
void PlayerLogic::clearCounters()
|
||||
{
|
||||
for (int id : counters.keys()) {
|
||||
emit counterRemoved(id);
|
||||
}
|
||||
qDeleteAll(counters);
|
||||
counters.clear();
|
||||
}
|
||||
|
||||
CounterState *PlayerLogic::getLifeCounter() const
|
||||
{
|
||||
for (auto *s : counters.values()) {
|
||||
if (s->getName() == "life") {
|
||||
return s;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool PlayerLogic::clearCardsToDelete()
|
||||
{
|
||||
if (cardsToDelete.isEmpty()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (auto &i : cardsToDelete) {
|
||||
if (i != nullptr) {
|
||||
i->deleteLater();
|
||||
}
|
||||
}
|
||||
cardsToDelete.clear();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void PlayerLogic::setActive(bool _active)
|
||||
{
|
||||
active = _active;
|
||||
emit activeChanged(active);
|
||||
}
|
||||
void PlayerLogic::onRequestZoneViewToggle(const QString &zoneName, int numberCards, bool isReversed)
|
||||
{
|
||||
emit requestZoneViewToggle(this, zoneName, numberCards, isReversed);
|
||||
}
|
||||
|
||||
void PlayerLogic::updateZones()
|
||||
{
|
||||
getTableZone()->reorganizeCards();
|
||||
}
|
||||
|
||||
void PlayerLogic::setGameStarted()
|
||||
{
|
||||
if (playerInfo->local) {
|
||||
emit resetTopCardMenuActions();
|
||||
}
|
||||
setConceded(false);
|
||||
}
|
||||
@@ -0,0 +1,259 @@
|
||||
/**
|
||||
* @file player.h
|
||||
* @ingroup GameLogicPlayers
|
||||
*/
|
||||
//! \todo Document this file.
|
||||
|
||||
#ifndef PLAYER_H
|
||||
#define PLAYER_H
|
||||
|
||||
#include "../../game_graphics/player/player_area.h"
|
||||
#include "../../interface/widgets/menus/tearoff_menu.h"
|
||||
#include "../board/arrow_data.h"
|
||||
#include "../interface/deck_loader/loaded_deck.h"
|
||||
#include "../zones/hand_zone_logic.h"
|
||||
#include "../zones/pile_zone_logic.h"
|
||||
#include "../zones/stack_zone_logic.h"
|
||||
#include "../zones/table_zone_logic.h"
|
||||
#include "player_event_handler.h"
|
||||
#include "player_info.h"
|
||||
|
||||
#include <QInputDialog>
|
||||
#include <QLoggingCategory>
|
||||
#include <QMap>
|
||||
#include <QTimer>
|
||||
#include <libcockatrice/filters/filter_string.h>
|
||||
#include <libcockatrice/protocol/pb/card_attributes.pb.h>
|
||||
#include <libcockatrice/protocol/pb/game_event.pb.h>
|
||||
#include <libcockatrice/utility/zone_names.h>
|
||||
|
||||
inline Q_LOGGING_CATEGORY(PlayerLog, "player");
|
||||
|
||||
namespace google
|
||||
{
|
||||
namespace protobuf
|
||||
{
|
||||
class Message;
|
||||
}
|
||||
} // namespace google
|
||||
class AbstractCardItem;
|
||||
class AbstractGame;
|
||||
class ArrowItem;
|
||||
class ArrowTarget;
|
||||
class CardDatabase;
|
||||
class CardZone;
|
||||
class CommandContainer;
|
||||
class GameCommand;
|
||||
class GameEvent;
|
||||
class PlayerInfo;
|
||||
class PlayerEventHandler;
|
||||
class PlayerActions;
|
||||
class PlayerMenu;
|
||||
class QAction;
|
||||
class QMenu;
|
||||
class ServerInfo_Arrow;
|
||||
class ServerInfo_Card;
|
||||
class ServerInfo_Counter;
|
||||
class ServerInfo_Player;
|
||||
class ServerInfo_User;
|
||||
class TabGame;
|
||||
|
||||
const int MAX_TOKENS_PER_DIALOG = 99;
|
||||
|
||||
class PlayerLogic : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
signals:
|
||||
void openDeckEditor(const LoadedDeck &deck);
|
||||
void requestZoneViewToggle(PlayerLogic *player, const QString &zoneName, int numberCards, bool isReversed);
|
||||
void requestRevealedZoneView(PlayerLogic *player,
|
||||
CardZoneLogic *zone,
|
||||
const QList<const ServerInfo_Card *> &cardList,
|
||||
bool withWritePermission);
|
||||
void deckChanged();
|
||||
void newCardAdded(AbstractCardItem *card);
|
||||
void requestCardMenuUpdate(const CardItem *card);
|
||||
void counterAdded(CounterState *state);
|
||||
void counterRemoved(int counterId);
|
||||
void rearrangeCounters();
|
||||
void activeChanged(bool active);
|
||||
void zoneIdChanged(int zoneId);
|
||||
void concededChanged(int playerId, bool conceded);
|
||||
void clearCustomZonesMenu();
|
||||
void addViewCustomZoneActionToCustomZoneMenu(QString zoneName);
|
||||
void resetTopCardMenuActions();
|
||||
void arrowCreateRequested(QSharedPointer<ArrowData> data);
|
||||
void arrowDeleteRequested(int creatorId, int arrowId);
|
||||
void arrowDeleted(int creatorId, int arrowId);
|
||||
void arrowsClearedLocally(); // fires on clear() and processPlayerInfo
|
||||
|
||||
public slots:
|
||||
void setActive(bool _active);
|
||||
void onRequestZoneViewToggle(const QString &zoneName, int numberCards, bool isReversed);
|
||||
|
||||
public:
|
||||
PlayerLogic(const ServerInfo_User &info, int _id, bool _local, bool _judge, AbstractGame *_parent);
|
||||
~PlayerLogic() override;
|
||||
|
||||
void initializeZones();
|
||||
void updateZones();
|
||||
void clear();
|
||||
|
||||
void processPlayerInfo(const ServerInfo_Player &info);
|
||||
void processCardAttachment(const ServerInfo_Player &info);
|
||||
|
||||
void addCard(CardItem *c);
|
||||
void deleteCard(CardItem *c);
|
||||
|
||||
bool clearCardsToDelete();
|
||||
|
||||
bool getActive() const
|
||||
{
|
||||
return active;
|
||||
}
|
||||
|
||||
AbstractGame *getGame() const
|
||||
{
|
||||
return game;
|
||||
}
|
||||
|
||||
[[nodiscard]] PlayerActions *getPlayerActions() const
|
||||
{
|
||||
return playerActions;
|
||||
}
|
||||
|
||||
[[nodiscard]] PlayerEventHandler *getPlayerEventHandler() const
|
||||
{
|
||||
return playerEventHandler;
|
||||
}
|
||||
|
||||
[[nodiscard]] PlayerInfo *getPlayerInfo() const
|
||||
{
|
||||
return playerInfo;
|
||||
}
|
||||
|
||||
void setDeck(const DeckList &_deck);
|
||||
|
||||
[[nodiscard]] const DeckList &getDeck() const
|
||||
{
|
||||
return deck;
|
||||
}
|
||||
|
||||
template <typename T> T *addZone(T *zone)
|
||||
{
|
||||
zones.insert(zone->getName(), zone);
|
||||
return zone;
|
||||
}
|
||||
|
||||
CardZoneLogic *getZone(const QString zoneName)
|
||||
{
|
||||
return zones.value(zoneName);
|
||||
}
|
||||
|
||||
const QMap<QString, CardZoneLogic *> &getZones() const
|
||||
{
|
||||
return zones;
|
||||
}
|
||||
|
||||
PileZoneLogic *getDeckZone()
|
||||
{
|
||||
return qobject_cast<PileZoneLogic *>(zones.value(ZoneNames::DECK));
|
||||
}
|
||||
|
||||
PileZoneLogic *getGraveZone()
|
||||
{
|
||||
return qobject_cast<PileZoneLogic *>(zones.value(ZoneNames::GRAVE));
|
||||
}
|
||||
|
||||
PileZoneLogic *getRfgZone()
|
||||
{
|
||||
return qobject_cast<PileZoneLogic *>(zones.value(ZoneNames::EXILE));
|
||||
}
|
||||
|
||||
PileZoneLogic *getSideboardZone()
|
||||
{
|
||||
return qobject_cast<PileZoneLogic *>(zones.value(ZoneNames::SIDEBOARD));
|
||||
}
|
||||
|
||||
TableZoneLogic *getTableZone()
|
||||
{
|
||||
return qobject_cast<TableZoneLogic *>(zones.value(ZoneNames::TABLE));
|
||||
}
|
||||
|
||||
StackZoneLogic *getStackZone()
|
||||
{
|
||||
return qobject_cast<StackZoneLogic *>(zones.value(ZoneNames::STACK));
|
||||
}
|
||||
|
||||
HandZoneLogic *getHandZone()
|
||||
{
|
||||
return qobject_cast<HandZoneLogic *>(zones.value(ZoneNames::HAND));
|
||||
}
|
||||
|
||||
CounterState *addCounter(const ServerInfo_Counter &counter);
|
||||
CounterState *addCounter(int id, const QString &name, const QColor &color, int radius, int value);
|
||||
void delCounter(int counterId);
|
||||
void clearCounters();
|
||||
|
||||
QMap<int, CounterState *> getCounters() const
|
||||
{
|
||||
return counters;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the counter that represents the life total.
|
||||
*/
|
||||
CounterState *getLifeCounter() const;
|
||||
|
||||
void setConceded(bool _conceded);
|
||||
bool getConceded() const
|
||||
{
|
||||
return conceded;
|
||||
}
|
||||
|
||||
void setGameStarted();
|
||||
|
||||
void setDialogSemaphore(const bool _active)
|
||||
{
|
||||
dialogSemaphore = _active;
|
||||
}
|
||||
|
||||
int getZoneId() const
|
||||
{
|
||||
return zoneId;
|
||||
}
|
||||
|
||||
void setZoneId(int _zoneId);
|
||||
|
||||
private:
|
||||
AbstractGame *game;
|
||||
PlayerInfo *playerInfo;
|
||||
PlayerEventHandler *playerEventHandler;
|
||||
PlayerActions *playerActions;
|
||||
|
||||
bool active;
|
||||
bool conceded;
|
||||
|
||||
DeckList deck;
|
||||
|
||||
int zoneId;
|
||||
QMap<QString, CardZoneLogic *> zones;
|
||||
QMap<int, CounterState *> counters;
|
||||
|
||||
bool dialogSemaphore;
|
||||
QList<CardItem *> cardsToDelete;
|
||||
};
|
||||
|
||||
class AnnotationDialog : public QInputDialog
|
||||
{
|
||||
Q_OBJECT
|
||||
void keyPressEvent(QKeyEvent *e) override;
|
||||
|
||||
public:
|
||||
explicit AnnotationDialog(QWidget *parent = nullptr) : QInputDialog(parent)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,86 @@
|
||||
#include "player_manager.h"
|
||||
|
||||
#include "../abstract_game.h"
|
||||
#include "player_logic.h"
|
||||
|
||||
PlayerManager::PlayerManager(AbstractGame *_game,
|
||||
int _localPlayerId,
|
||||
bool _localPlayerIsJudge,
|
||||
bool localPlayerIsSpectator)
|
||||
: QObject(_game), game(_game), players(QMap<int, PlayerLogic *>()), localPlayerId(_localPlayerId),
|
||||
localPlayerIsJudge(_localPlayerIsJudge), localPlayerIsSpectator(localPlayerIsSpectator)
|
||||
{
|
||||
}
|
||||
|
||||
bool PlayerManager::isMainPlayerConceded() const
|
||||
{
|
||||
PlayerLogic *player = players.value(localPlayerId, nullptr);
|
||||
return player && player->getConceded();
|
||||
}
|
||||
|
||||
PlayerLogic *PlayerManager::getActiveLocalPlayer(int activePlayer) const
|
||||
{
|
||||
PlayerLogic *active = players.value(activePlayer, 0);
|
||||
if (active) {
|
||||
if (active->getPlayerInfo()->getLocal()) {
|
||||
return active;
|
||||
}
|
||||
}
|
||||
|
||||
QMapIterator<int, PlayerLogic *> playerIterator(players);
|
||||
while (playerIterator.hasNext()) {
|
||||
PlayerLogic *temp = playerIterator.next().value();
|
||||
if (temp->getPlayerInfo()->getLocal()) {
|
||||
return temp;
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool PlayerManager::isLocalPlayer(int playerId)
|
||||
{
|
||||
return game->getGameState()->getIsLocalGame() || playerId == localPlayerId;
|
||||
}
|
||||
|
||||
PlayerLogic *PlayerManager::addPlayer(int playerId, const ServerInfo_User &info)
|
||||
{
|
||||
auto *newPlayer = new PlayerLogic(info, playerId, isLocalPlayer(playerId) || game->getGameState()->getIsLocalGame(),
|
||||
isJudge(), getGame());
|
||||
connect(newPlayer, &PlayerLogic::concededChanged, this, &PlayerManager::onPlayerConceded);
|
||||
players.insert(playerId, newPlayer);
|
||||
emit playerAdded(newPlayer);
|
||||
emit playerCountChanged();
|
||||
return newPlayer;
|
||||
}
|
||||
|
||||
void PlayerManager::removePlayer(int playerId)
|
||||
{
|
||||
PlayerLogic *player = getPlayer(playerId);
|
||||
if (!player) {
|
||||
return;
|
||||
}
|
||||
emit playerRemoved(player);
|
||||
emit playerCountChanged();
|
||||
players.remove(playerId);
|
||||
player->deleteLater();
|
||||
}
|
||||
|
||||
PlayerLogic *PlayerManager::getPlayer(int playerId) const
|
||||
{
|
||||
PlayerLogic *player = players.value(playerId, 0);
|
||||
if (!player) {
|
||||
return nullptr;
|
||||
}
|
||||
return player;
|
||||
}
|
||||
|
||||
void PlayerManager::onPlayerConceded(int playerId, bool conceded)
|
||||
{
|
||||
// Everything else cares about this
|
||||
if (conceded) {
|
||||
emit playerConceded(playerId);
|
||||
} else {
|
||||
emit playerUnconceded(playerId);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
/**
|
||||
* @file player_manager.h
|
||||
* @ingroup GameLogicPlayers
|
||||
*/
|
||||
//! \todo Document this file.
|
||||
|
||||
#ifndef COCKATRICE_PLAYER_MANAGER_H
|
||||
#define COCKATRICE_PLAYER_MANAGER_H
|
||||
|
||||
#include <QMap>
|
||||
#include <QObject>
|
||||
#include <libcockatrice/protocol/pb/serverinfo_playerproperties.pb.h>
|
||||
|
||||
class AbstractGame;
|
||||
class PlayerLogic;
|
||||
class PlayerManager : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
PlayerManager(AbstractGame *_game, int _localPlayerId, bool _localPlayerIsJudge, bool localPlayerIsSpectator);
|
||||
|
||||
AbstractGame *game;
|
||||
QMap<int, PlayerLogic *> players;
|
||||
int localPlayerId;
|
||||
bool localPlayerIsJudge;
|
||||
bool localPlayerIsSpectator;
|
||||
QMap<int, ServerInfo_User> spectators;
|
||||
|
||||
[[nodiscard]] bool isSpectator() const
|
||||
{
|
||||
return localPlayerIsSpectator;
|
||||
}
|
||||
|
||||
[[nodiscard]] bool isJudge() const
|
||||
{
|
||||
return localPlayerIsJudge;
|
||||
}
|
||||
|
||||
[[nodiscard]] int getLocalPlayerId() const
|
||||
{
|
||||
return localPlayerId;
|
||||
}
|
||||
|
||||
[[nodiscard]] const QMap<int, PlayerLogic *> &getPlayers() const
|
||||
{
|
||||
return players;
|
||||
}
|
||||
|
||||
[[nodiscard]] int getPlayerCount() const
|
||||
{
|
||||
return players.size();
|
||||
}
|
||||
|
||||
[[nodiscard]] PlayerLogic *getActiveLocalPlayer(int activePlayer) const;
|
||||
bool isLocalPlayer(int playerId);
|
||||
|
||||
PlayerLogic *addPlayer(int playerId, const ServerInfo_User &info);
|
||||
|
||||
void removePlayer(int playerId);
|
||||
|
||||
[[nodiscard]] PlayerLogic *getPlayer(int playerId) const;
|
||||
|
||||
void onPlayerConceded(int playerId, bool conceded);
|
||||
|
||||
[[nodiscard]] bool isMainPlayerConceded() const;
|
||||
|
||||
[[nodiscard]] bool isLocalPlayer(int playerId) const
|
||||
{
|
||||
return playerId == getLocalPlayerId();
|
||||
}
|
||||
|
||||
[[nodiscard]] const QMap<int, ServerInfo_User> &getSpectators() const
|
||||
{
|
||||
return spectators;
|
||||
}
|
||||
|
||||
[[nodiscard]] ServerInfo_User getSpectator(int playerId) const
|
||||
{
|
||||
return spectators.value(playerId);
|
||||
}
|
||||
|
||||
[[nodiscard]] QString getSpectatorName(int spectatorId) const
|
||||
{
|
||||
return QString::fromStdString(spectators.value(spectatorId).name());
|
||||
}
|
||||
|
||||
void addSpectator(int spectatorId, const ServerInfo_PlayerProperties &prop)
|
||||
{
|
||||
if (!spectators.contains(spectatorId)) {
|
||||
spectators.insert(spectatorId, prop.user_info());
|
||||
emit spectatorAdded(prop);
|
||||
}
|
||||
}
|
||||
|
||||
void removeSpectator(int spectatorId)
|
||||
{
|
||||
ServerInfo_User spectatorInfo = spectators.value(spectatorId);
|
||||
spectators.remove(spectatorId);
|
||||
emit spectatorRemoved(spectatorId, spectatorInfo);
|
||||
}
|
||||
|
||||
[[nodiscard]] AbstractGame *getGame() const
|
||||
{
|
||||
return game;
|
||||
}
|
||||
|
||||
signals:
|
||||
void playerAdded(PlayerLogic *player);
|
||||
void playerRemoved(PlayerLogic *player);
|
||||
void activeLocalPlayerConceded();
|
||||
void activeLocalPlayerUnconceded();
|
||||
void playerConceded(int playerId);
|
||||
void playerUnconceded(int playerId);
|
||||
void playerCountChanged();
|
||||
void spectatorAdded(ServerInfo_PlayerProperties spectator);
|
||||
void spectatorRemoved(int spectatorId, ServerInfo_User spectator);
|
||||
};
|
||||
|
||||
#endif // COCKATRICE_PLAYER_MANAGER_H
|
||||
Reference in New Issue
Block a user