jeirmeister/Cockatrice
1
0
Fork 0
mirror of https://github.com/Cockatrice/Cockatrice.git synced 2026-06-29 18:13:55 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

event handling

Browse source
This commit is contained in:
Max-Wilhelm Bruker 2009-11-28 00:02:11 +01:00
parent e796af2b89
commit 77015c9ebf
34 changed files with 891 additions and 855 deletions
Download patch file Download diff file Expand all files Collapse all files

21
cockatrice/src/cardinfowidget.cpp
View file

@ -1,12 +1,13 @@
#include "cardinfowidget.h"
#include "carditem.h"
#include <QGridLayout>
#include <QLabel>
#include <QTextEdit>
#include <QMessageBox>
#include "cardinfowidget.h"
#include "carditem.h"
#include "carddatabase.h"
#include "main.h"
CardInfoWidget::CardInfoWidget(CardDatabase *_db, QWidget *parent)
: QFrame(parent), db(_db), pixmapHeight(pixmapWidth), info(0)
CardInfoWidget::CardInfoWidget(QWidget *parent)
: QFrame(parent), pixmapHeight(pixmapWidth), info(0)
{
cardPicture = new QLabel;
cardPicture->setAlignment(Qt::AlignCenter);
@ -62,15 +63,12 @@ CardInfoWidget::CardInfoWidget(CardDatabase *_db, QWidget *parent)
retranslateUi();
setFrameStyle(QFrame::Panel | QFrame::Raised);
textLabel->setFixedHeight(130);
textLabel->setFixedHeight(100);
setFixedSize(sizeHint());
}
void CardInfoWidget::setCard(CardInfo *card)
{
if (!card)
return;
if (info)
disconnect(info, 0, this, 0);
info = card;
@ -89,6 +87,11 @@ void CardInfoWidget::setCard(const QString &cardName)
setCard(db->getCard(cardName));
}
void CardInfoWidget::setCard(CardItem *card)
{
setCard(card->getInfo());
}
void CardInfoWidget::updatePixmap()
{
QPixmap *resizedPixmap = info->getPixmap(QSize(pixmapWidth, pixmapHeight));

9
cockatrice/src/cardinfowidget.h
View file

@ -1,17 +1,17 @@
#ifndef CARDINFOWIDGET_H
#define CARDINFOWIDGET_H
#include "carddatabase.h"
#include <QFrame>
class QLabel;
class QTextEdit;
class CardItem;
class CardInfo;
class CardInfoWidget : public QFrame {
Q_OBJECT
private:
CardDatabase *db;
static const int pixmapWidth = 180;
static const int pixmapWidth = 160;
int pixmapHeight;
QLabel *cardPicture;
@ -23,11 +23,12 @@ private:
CardInfo *info;
public:
CardInfoWidget(CardDatabase *_db, QWidget *parent = 0);
CardInfoWidget(QWidget *parent = 0);
void retranslateUi();
public slots:
void setCard(CardInfo *card);
void setCard(const QString &cardName);
void setCard(CardItem *card);
private slots:
void updatePixmap();
};

14
cockatrice/src/carditem.cpp
View file

@ -6,13 +6,14 @@
#include "cardzone.h"
#include "tablezone.h"
#include "player.h"
#include "game.h"
#include "arrowitem.h"
#include "main.h"
#include "protocol_datastructures.h"
CardItem::CardItem(const QString &_name, int _cardid, QGraphicsItem *parent)
: AbstractCardItem(_name, parent), id(_cardid), attacking(false), facedown(false), counters(0), doesntUntap(false), dragItem(NULL)
CardItem::CardItem(Player *_owner, const QString &_name, int _cardid, QGraphicsItem *parent)
: AbstractCardItem(_name, parent), owner(_owner), id(_cardid), attacking(false), facedown(false), counters(0), doesntUntap(false), dragItem(NULL)
{
owner->addCard(this);
}
CardItem::~CardItem()
@ -172,8 +173,13 @@ void CardItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
}
}
void CardItem::processHoverEvent()
{
emit hovered(this);
}
void CardItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
{
((Game *) ((CardZone *) parentItem())->getPlayer()->parent())->hoverCardEvent(this);
processHoverEvent();
QGraphicsItem::hoverEnterEvent(event);
}

8
cockatrice/src/carditem.h
View file

@ -7,12 +7,14 @@ class CardDatabase;
class CardDragItem;
class CardZone;
class ServerInfo_Card;
class Player;
const int MAX_COUNTERS_ON_CARD = 999;
class CardItem : public AbstractCardItem {
Q_OBJECT
private:
Player *owner;
int id;
bool attacking;
bool facedown;
@ -24,11 +26,12 @@ private:
public:
enum { Type = typeCard };
int type() const { return Type; }
CardItem(const QString &_name = QString(), int _cardid = -1, QGraphicsItem *parent = 0);
CardItem(Player *_owner, const QString &_name = QString(), int _cardid = -1, QGraphicsItem *parent = 0);
~CardItem();
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
QPoint getGridPoint() const { return gridPoint; }
void setGridPoint(const QPoint &_gridPoint) { gridPoint = _gridPoint; }
Player *getOwner() const { return owner; }
int getId() const { return id; }
void setId(int _id) { id = _id; }
bool getAttacking() const { return attacking; }
@ -46,6 +49,9 @@ public:
CardDragItem *createDragItem(int _id, const QPointF &_pos, const QPointF &_scenePos, bool faceDown);
void deleteDragItem();
void processHoverEvent();
signals:
void hovered(CardItem *card);
protected:
void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);

2
cockatrice/src/cardzone.cpp
View file

@ -84,7 +84,7 @@ void CardZone::addCard(CardItem *card, bool reorganize, int x, int y)
{
if (view)
if ((x <= view->getCards().size()) || (view->getNumberCards() == -1))
view->addCard(new CardItem(card->getName(), card->getId()), reorganize, x, y);
view->addCard(new CardItem(player, card->getName(), card->getId()), reorganize, x, y);
addCardImpl(card, x, y);

7
cockatrice/src/deckview.cpp
View file

@ -89,6 +89,13 @@ DeckViewScene::~DeckViewScene()
void DeckViewScene::setDeck(DeckList *_deck)
{
if (deck)
delete deck;
QMapIterator<QString, DeckViewCardContainer *> i(cardContainers);
while (i.hasNext())
delete i.next().value();
cardContainers.clear();
deck = _deck;
rebuildTree();
rearrangeItems();

302
cockatrice/src/game.cpp
View file

@ -19,12 +19,6 @@ Game::Game(Client *_client, GameScene *_scene, QMenuBar *menuBar, QObject *paren
{
connect(client, SIGNAL(gameEvent(const ServerEventData &)), this, SLOT(gameEvent(const ServerEventData &)));
aNextPhase = new QAction(this);
connect(aNextPhase, SIGNAL(triggered()), this, SLOT(actNextPhase()));
aNextTurn = new QAction(this);
connect(aNextTurn, SIGNAL(triggered()), this, SLOT(actNextTurn()));
aRemoveLocalArrows = new QAction(this);
connect(aRemoveLocalArrows, SIGNAL(triggered()), this, SLOT(actRemoveLocalArrows()));
aTap = new QAction(this);
aUntap = new QAction(this);
aDoesntUntap = new QAction(this);
@ -38,12 +32,6 @@ Game::Game(Client *_client, GameScene *_scene, QMenuBar *menuBar, QObject *paren
aMoveToGraveyard = new QAction(this);
aMoveToExile = new QAction(this);
gameMenu = menuBar->addMenu(QString());
gameMenu->addAction(aNextPhase);
gameMenu->addAction(aNextTurn);
gameMenu->addSeparator();
gameMenu->addAction(aRemoveLocalArrows);
cardMenu = menuBar->addMenu(QString());
cardMenu->addAction(aTap);
cardMenu->addAction(aUntap);
@ -99,14 +87,6 @@ Game::~Game()
void Game::retranslateUi()
{
gameMenu->setTitle(tr("&Game"));
aNextPhase->setText(tr("Next &phase"));
aNextPhase->setShortcut(tr("Ctrl+Space"));
aNextTurn->setText(tr("Next &turn"));
aNextTurn->setShortcuts(QList<QKeySequence>() << QKeySequence(tr("Ctrl+Return")) << QKeySequence(tr("Ctrl+Enter")));
aRemoveLocalArrows->setText(tr("&Remove all local arrows"));
aRemoveLocalArrows->setShortcut(tr("Ctrl+R"));
cardMenu->setTitle(tr("C&ard"));
aTap->setText(tr("&Tap"));
aUntap->setText(tr("&Untap"));
@ -123,248 +103,12 @@ void Game::retranslateUi()
moveMenu->setTitle(tr("&Move to"));
QMapIterator<int, Player *> i(players);
while (i.hasNext())
i.next().value()->retranslateUi();
}
/*
void Game::counterListReceived(QList<ServerCounter> list)
{
QMapIterator<int, Player *> i(players);
while (i.hasNext())
i.next().value()->clearCounters();
for (int i = 0; i < list.size(); ++i) {
Player *p = players.value(list[i].getPlayerId(), 0);
if (!p)
continue;
p->addCounter(list[i].getId(), list[i].getName(), list[i].getColor(), list[i].getRadius(), list[i].getCount());
}
}
void Game::arrowListReceived(QList<ServerArrow> list)
{
QMapIterator<int, Player *> i(players);
while (i.hasNext())
i.next().value()->clearArrows();
for (int i = 0; i < list.size(); ++i) {
Player *p = players.value(list[i].getPlayerId(), 0);
if (!p)
continue;
Player *startPlayer = players.value(list[i].getStartPlayerId(), 0);
Player *targetPlayer = players.value(list[i].getTargetPlayerId(), 0);
if (!startPlayer || !targetPlayer)
continue;
CardZone *startZone = startPlayer->getZones().value(list[i].getStartZone(), 0);
CardZone *targetZone = targetPlayer->getZones().value(list[i].getTargetZone(), 0);
if (!startZone || !targetZone)
continue;
CardItem *startCard = startZone->getCard(list[i].getStartCardId(), QString());
CardItem *targetCard = targetZone->getCard(list[i].getTargetCardId(), QString());
if (!startCard || !targetCard)
continue;
p->addArrow(list[i].getId(), startCard, targetCard, list[i].getColor());
}
}
void Game::playerListReceived(QList<ServerPlayer> playerList)
{
QStringList nameList;
for (int i = 0; i < playerList.size(); ++i) {
nameList << playerList[i].getName();
addPlayer(playerList[i].getPlayerId(), playerList[i].getName(), playerList[i].getLocal());
}
emit logPlayerListReceived(nameList);
restartGameDialog();
}
*/
void Game::restartGameDialog()
{
// dlgStartGame->show();
}
/*
void Game::gameEvent(const ServerEventData &msg)
{
qDebug(QString("game::gameEvent: public=%1, player=%2, name=%3, type=%4, data=%5").arg(msg.getPublic()).arg(msg.getPlayerId()).arg(msg.getPlayerName()).arg(msg.getEventType()).arg(msg.getEventData().join("/")).toLatin1());
Player *p = players.value(msg.getPlayerId(), 0);
if (!msg.getPublic()) {
if (!p)
return;
p->gameEvent(msg);
} else {
if ((msg.getPlayerId() != -1) && (!p) && (msg.getEventType() != eventJoin) && (msg.getEventType() != eventLeave)) {
qDebug("Game::gameEvent: invalid player");
return;
}
switch(msg.getEventType()) {
case eventSay:
emit logSay(p, msg.getEventData()[0]);
break;
case eventJoin: {
const QStringList &data = msg.getEventData();
if (data.size() != 1)
return;
bool spectator = data[0].toInt();
if (spectator) {
spectatorList << msg.getPlayerName();
emit logJoinSpectator(msg.getPlayerName());
} else {
Player *newPlayer = addPlayer(msg.getPlayerId(), msg.getPlayerName(), false);
emit logJoin(newPlayer);
}
break;
}
case eventLeave: {
if (p)
emit logLeave(p);
// XXX Spieler natürlich noch rauswerfen
else {
int spectatorIndex = spectatorList.indexOf(msg.getPlayerName());
if (spectatorIndex != -1) {
spectatorList.removeAt(spectatorIndex);
emit logLeaveSpectator(msg.getPlayerName());
}
}
break;
}
case eventGameClosed: {
started = false;
emit logGameClosed();
break;
}
case eventReadyStart:
if (started) {
started = false;
emit logReadyStart(p);
if (!p->getLocal())
restartGameDialog();
}
break;
case eventGameStart:
started = true;
emit logGameStart();
break;
case eventShuffle:
emit logShuffle(p);
break;
case eventRollDie: {
QStringList data = msg.getEventData();
int sides = data[0].toInt();
int roll = data[1].toInt();
emit logRollDie(p, sides, roll);
break;
}
case eventSetActivePlayer: {
QStringList data = msg.getEventData();
int playerId = data[0].toInt();
Player *player = players.value(playerId, 0);
if (!player) {
qDebug(QString("setActivePlayer: invalid player: %1").arg(playerId).toLatin1());
break;
}
QMapIterator<int, Player *> i(players);
while (i.hasNext()) {
i.next();
i.value()->setActive(i.value() == player);
}
emit logSetActivePlayer(player);
break;
}
case eventSetActivePhase: {
QStringList data = msg.getEventData();
int phase = data[0].toInt();
if (currentPhase != phase) {
currentPhase = phase;
emit setActivePhase(phase);
}
break;
}
case eventCreateArrow:
case eventDeleteArrow:
case eventCreateToken:
case eventSetupZones:
case eventSetCardAttr:
case eventAddCounter:
case eventSetCounter:
case eventDelCounter: {
p->gameEvent(msg);
break;
}
case eventDumpZone: {
QStringList data = msg.getEventData();
Player *zoneOwner = players.value(data[0].toInt(), 0);
if (!zoneOwner)
break;
CardZone *zone = zoneOwner->getZones().value(data[1], 0);
if (!zone)
break;
emit logDumpZone(p, zone, data[2].toInt());
break;
}
case eventStopDumpZone: {
QStringList data = msg.getEventData();
Player *zoneOwner = players.value(data[0].toInt(), 0);
if (!zoneOwner)
break;
CardZone *zone = zoneOwner->getZones().value(data[1], 0);
if (!zone)
break;
emit logStopDumpZone(p, zone);
break;
}
case eventMoveCard: {
if (!p->getLocal())
p->gameEvent(msg);
break;
}
case eventDraw: {
emit logDraw(p, msg.getEventData()[0].toInt());
if (!p->getLocal())
p->gameEvent(msg);
break;
}
case eventInvalid: {
qDebug("Unhandled global event");
}
default: {
}
}
}
}
*/
void Game::actNextPhase()
{
int phase = currentPhase;
if (++phase >= phaseCount)
phase = 0;
// client->setActivePhase(phase);
}
void Game::actNextTurn()
{
// client->nextTurn();
}
void Game::actRemoveLocalArrows()
{
for (int i = 0; i < players.size(); ++i) {
if (!players[i]->getLocal())
continue;
QMapIterator<int, ArrowItem *> arrowIterator(players[i]->getArrows());
while (arrowIterator.hasNext()) {
ArrowItem *a = arrowIterator.next().value();
// players[i]->client->deleteArrow(a->getId());
}
}
}
void Game::showCardMenu(QPoint p)
{
@ -458,49 +202,3 @@ void Game::actMoveToExile(CardItem *card)
// CardZone *startZone = qgraphicsitem_cast<CardZone *>(card->parentItem());
// client->moveCard(card->getId(), startZone->getName(), "rfg", 0, 0, false);
}
void Game::hoverCardEvent(CardItem *card)
{
emit hoverCard(card->getName());
}
void Game::queryGameState()
{
/* PendingCommand_DumpAll *pc = client->dumpAll();
connect(pc, SIGNAL(playerListReceived(QList<ServerPlayer>)), this, SLOT(playerListReceived(QList<ServerPlayer>)));
connect(pc, SIGNAL(zoneListReceived(QList<ServerZone>)), this, SLOT(zoneListReceived(QList<ServerZone>)));
connect(pc, SIGNAL(cardListReceived(QList<ServerZoneCard>)), this, SLOT(cardListReceived(QList<ServerZoneCard>)));
connect(pc, SIGNAL(counterListReceived(QList<ServerCounter>)), this, SLOT(counterListReceived(QList<ServerCounter>)));
connect(pc, SIGNAL(arrowListReceived(QList<ServerArrow>)), this, SLOT(arrowListReceived(QList<ServerArrow>)));
*/}
void Game::activePlayerDrawCard()
{
Player *p = getActiveLocalPlayer();
if (p)
p->actDrawCard();
}
void Game::activePlayerUntapAll()
{
Player *p = getActiveLocalPlayer();
if (p)
p->actUntapAll();
}
Player *Game::getActiveLocalPlayer() const
{
int localPlayerCount = 0;
QMapIterator<int, Player *> i(players);
while (i.hasNext())
if (i.next().value()->getLocal())
++localPlayerCount;
i.toFront();
while (i.hasNext()) {
Player *p = i.next().value();
if (p->getLocal() && (p->getActive() || (localPlayerCount == 1)))
return p;
}
return 0;
}

59
cockatrice/src/messagelogwidget.cpp
View file

@ -1,5 +1,4 @@
#include "messagelogwidget.h"
#include "game.h"
#include "player.h"
#include "cardzone.h"
#include <QApplication>
@ -50,23 +49,19 @@ void MessageLogWidget::logProtocolError()
append(tr("Protocol error."));
}
void MessageLogWidget::logPlayerListReceived(QStringList players)
void MessageLogWidget::logGameJoined(int gameId)
{
append("---");
append(tr("You have joined the game. Player list:"));
for (int i = 0; i < players.size(); i++)
append(sanitizeHtml(players.at(i)));
append("---");
append(tr("You have joined game #%1.").arg(gameId));
}
void MessageLogWidget::logJoin(Player *player)
{
append(tr("%1 has joined the game").arg(sanitizeHtml(player->getName())));
append(tr("%1 has joined the game.").arg(sanitizeHtml(player->getName())));
}
void MessageLogWidget::logLeave(Player *player)
{
append(tr("%1 has left the game").arg(sanitizeHtml(player->getName())));
append(tr("%1 has left the game.").arg(sanitizeHtml(player->getName())));
}
void MessageLogWidget::logGameClosed()
@ -84,9 +79,17 @@ void MessageLogWidget::logLeaveSpectator(QString name)
append(tr("%1 is not watching the game any more.").arg(sanitizeHtml(name)));
}
void MessageLogWidget::logDeckSelect(Player *player, int deckId)
{
if (deckId == -1)
append(tr("%1 has loaded a local deck.").arg(sanitizeHtml(player->getName())));
else
append(tr("%1 has loaded deck #%2.").arg(sanitizeHtml(player->getName())).arg(deckId));
}
void MessageLogWidget::logReadyStart(Player *player)
{
append(tr("%1 is ready to start a new game.").arg(sanitizeHtml(player->getName())));
append(tr("%1 is ready to start the game.").arg(sanitizeHtml(player->getName())));
}
void MessageLogWidget::logGameStart()
@ -109,7 +112,7 @@ void MessageLogWidget::logRollDie(Player *player, int sides, int roll)
append(tr("%1 rolls a %2 with a %3-sided die.").arg(sanitizeHtml(player->getName())).arg(roll).arg(sides));
}
void MessageLogWidget::logDraw(Player *player, int number)
void MessageLogWidget::logDrawCards(Player *player, int number)
{
if (number == 1)
append(tr("%1 draws a card.").arg(sanitizeHtml(player->getName())));
@ -277,29 +280,27 @@ void MessageLogWidget::logSetActivePhase(int phase)
void MessageLogWidget::connectToPlayer(Player *player)
{
/* connect(game, SIGNAL(logPlayerListReceived(QStringList)), this, SLOT(logPlayerListReceived(QStringList)));
connect(player, SIGNAL(logSay(Player *, QString)), this, SLOT(logSay(Player *, QString)));
connect(player, SIGNAL(logDeckSelect(Player *, int)), this, SLOT(logDeckSelect(Player *, int)));
connect(player, SIGNAL(logReadyStart(Player *)), this, SLOT(logReadyStart(Player *)));
connect(player, SIGNAL(logShuffle(Player *)), this, SLOT(logShuffle(Player *)));
connect(player, SIGNAL(logRollDie(Player *, int, int)), this, SLOT(logRollDie(Player *, int, int)));
connect(player, SIGNAL(logCreateArrow(Player *, Player *, QString, Player *, QString)), this, SLOT(logCreateArrow(Player *, Player *, QString, Player *, QString)));
connect(player, SIGNAL(logCreateToken(Player *, QString)), this, SLOT(logCreateToken(Player *, QString)));
connect(player, SIGNAL(logSetCounter(Player *, QString, int, int)), this, SLOT(logSetCounter(Player *, QString, int, int)));
connect(player, SIGNAL(logSetCardCounters(Player *, QString, int, int)), this, SLOT(logSetCardCounters(Player *, QString, int, int)));
connect(player, SIGNAL(logSetTapped(Player *, QString, bool)), this, SLOT(logSetTapped(Player *, QString, bool)));
connect(player, SIGNAL(logSetDoesntUntap(Player *, QString, bool)), this, SLOT(logSetDoesntUntap(Player *, QString, bool)));
connect(player, SIGNAL(logMoveCard(Player *, QString, CardZone *, int, CardZone *, int)), this, SLOT(logMoveCard(Player *, QString, CardZone *, int, CardZone *, int)));
connect(player, SIGNAL(logDumpZone(Player *, CardZone *, int)), this, SLOT(logDumpZone(Player *, CardZone *, int)));
connect(player, SIGNAL(logStopDumpZone(Player *, CardZone *)), this, SLOT(logStopDumpZone(Player *, CardZone *)));
connect(player, SIGNAL(logDrawCards(Player *, int)), this, SLOT(logDrawCards(Player *, int)));
/*
connect(game, SIGNAL(logJoin(Player *)), this, SLOT(logJoin(Player *)));
connect(game, SIGNAL(logLeave(Player *)), this, SLOT(logLeave(Player *)));
connect(game, SIGNAL(logGameClosed()), this, SLOT(logGameClosed()));
connect(game, SIGNAL(logJoinSpectator(QString)), this, SLOT(logJoinSpectator(QString)));
connect(game, SIGNAL(logLeaveSpectator(QString)), this, SLOT(logLeaveSpectator(QString)));
connect(game, SIGNAL(logReadyStart(Player *)), this, SLOT(logReadyStart(Player *)));
connect(game, SIGNAL(logGameStart()), this, SLOT(logGameStart()));
connect(game, SIGNAL(logSay(Player *, QString)), this, SLOT(logSay(Player *, QString)));
connect(game, SIGNAL(logShuffle(Player *)), this, SLOT(logShuffle(Player *)));
connect(game, SIGNAL(logRollDie(Player *, int, int)), this, SLOT(logRollDie(Player *, int, int)));
connect(game, SIGNAL(logDraw(Player *, int)), this, SLOT(logDraw(Player *, int)));
connect(game, SIGNAL(logMoveCard(Player *, QString, CardZone *, int, CardZone *, int)), this, SLOT(logMoveCard(Player *, QString, CardZone *, int, CardZone *, int)));
connect(game, SIGNAL(logCreateToken(Player *, QString)), this, SLOT(logCreateToken(Player *, QString)));
connect(game, SIGNAL(logCreateArrow(Player *, Player *, QString, Player *, QString)), this, SLOT(logCreateArrow(Player *, Player *, QString, Player *, QString)));
connect(game, SIGNAL(logSetCardCounters(Player *, QString, int, int)), this, SLOT(logSetCardCounters(Player *, QString, int, int)));
connect(game, SIGNAL(logSetTapped(Player *, QString, bool)), this, SLOT(logSetTapped(Player *, QString, bool)));
connect(game, SIGNAL(logSetCounter(Player *, QString, int, int)), this, SLOT(logSetCounter(Player *, QString, int, int)));
connect(game, SIGNAL(logSetDoesntUntap(Player *, QString, bool)), this, SLOT(logSetDoesntUntap(Player *, QString, bool)));
connect(game, SIGNAL(logDumpZone(Player *, CardZone *, int)), this, SLOT(logDumpZone(Player *, CardZone *, int)));
connect(game, SIGNAL(logStopDumpZone(Player *, CardZone *)), this, SLOT(logStopDumpZone(Player *, CardZone *)));
connect(game, SIGNAL(logSetActivePlayer(Player *)), this, SLOT(logSetActivePlayer(Player *)));
connect(game, SIGNAL(setActivePhase(int)), this, SLOT(logSetActivePhase(int)));
//Alert Test
connect(game, SIGNAL(logSay(Player *, QString)), this, SLOT(msgAlert()));

6
cockatrice/src/messagelogwidget.h
View file

@ -22,19 +22,19 @@ public slots:
void logServerError(ResponseCode response);
void logProtocolVersionMismatch(int clientVersion, int serverVersion);
void logProtocolError();
private slots:
void logPlayerListReceived(QStringList players);
void logGameJoined(int gameId);
void logJoin(Player *player);
void logLeave(Player *player);
void logGameClosed();
void logJoinSpectator(QString name);
void logLeaveSpectator(QString name);
void logDeckSelect(Player *player, int deckId);
void logReadyStart(Player *player);
void logGameStart();
void logSay(Player *player, QString message);
void logShuffle(Player *player);
void logRollDie(Player *player, int sides, int roll);
void logDraw(Player *player, int number);
void logDrawCards(Player *player, int number);
void logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
void logCreateToken(Player *player, QString cardName);
void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard);

26
cockatrice/src/phasestoolbar.cpp
View file

@ -1,8 +1,9 @@
#include "phasestoolbar.h"
#include <QAction>
#include <QVBoxLayout>
#include <QPainter>
#include <QPen>
#include "phasestoolbar.h"
#include "protocol_items.h"
PhaseButton::PhaseButton(const QIcon &icon, QAction *_doubleClickAction)
: QPushButton(icon, QString()), active(false), doubleClickAction(_doubleClickAction), activePixmap(50, 50), inactivePixmap(50, 50)
@ -54,9 +55,9 @@ PhasesToolbar::PhasesToolbar(QWidget *parent)
: QFrame(parent)
{
QAction *aUntapAll = new QAction(this);
connect(aUntapAll, SIGNAL(triggered()), this, SIGNAL(signalUntapAll()));
connect(aUntapAll, SIGNAL(triggered()), this, SLOT(actUntapAll()));
QAction *aDrawCard = new QAction(this);
connect(aDrawCard, SIGNAL(triggered()), this, SIGNAL(signalDrawCard()));
connect(aDrawCard, SIGNAL(triggered()), this, SLOT(actDrawCard()));
PhaseButton *untapButton = new PhaseButton(QIcon(":/resources/icon_phase_untap.svg"), aUntapAll);
PhaseButton *upkeepButton = new PhaseButton(QIcon(":/resources/icon_phase_upkeep.svg"));
@ -80,7 +81,7 @@ PhasesToolbar::PhasesToolbar(QWidget *parent)
QPushButton *nextTurnButton = new QPushButton(QIcon(":/resources/icon_nextturn.svg"), QString());
nextTurnButton->setIconSize(QSize(40, 40));
nextTurnButton->setFixedSize(50, 50);
connect(nextTurnButton, SIGNAL(clicked()), this, SIGNAL(signalNextTurn()));
connect(nextTurnButton, SIGNAL(clicked()), this, SLOT(actNextTurn()));
QVBoxLayout *layout = new QVBoxLayout;
layout->setSpacing(0);
@ -138,5 +139,20 @@ void PhasesToolbar::phaseButtonClicked()
PhaseButton *button = qobject_cast<PhaseButton *>(sender());
if (button->getActive())
return;
emit signalSetPhase(buttonList.indexOf(button));
emit sendGameCommand(new Command_SetActivePhase(-1, buttonList.indexOf(button)));
}
void PhasesToolbar::actNextTurn()
{
emit sendGameCommand(new Command_NextTurn);
}
void PhasesToolbar::actUntapAll()
{
emit sendGameCommand(new Command_SetCardAttr(-1, "table", -1, "tapped", "0"));
}
void PhasesToolbar::actDrawCard()
{
emit sendGameCommand(new Command_DrawCards(-1, 1));
}

10
cockatrice/src/phasestoolbar.h
View file

@ -6,6 +6,7 @@
#include <QPushButton>
class Player;
class GameCommand;
class PhaseButton : public QPushButton {
Q_OBJECT
@ -34,15 +35,16 @@ private:
public:
PhasesToolbar(QWidget *parent = 0);
void retranslateUi();
int phaseCount() const { return buttonList.size(); }
public slots:
void setActivePhase(int phase);
private slots:
void phaseButtonClicked();
void actNextTurn();
void actUntapAll();
void actDrawCard();
signals:
void signalSetPhase(int phase);
void signalNextTurn();
void signalUntapAll();
void signalDrawCard();
void sendGameCommand(GameCommand *command);
};
#endif

3
cockatrice/src/pilezone.cpp
View file

@ -1,7 +1,6 @@
#include <QtGui>
#include "pilezone.h"
#include "player.h"
#include "game.h"
#include "client.h"
#include "carddragitem.h"
#include "zoneviewzone.h"
@ -94,6 +93,6 @@ void PileZone::mouseReleaseEvent(QGraphicsSceneMouseEvent */*event*/)
void PileZone::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
{
if (!cards.isEmpty())
((Game *) player->parent())->hoverCardEvent(cards.at(0));
cards[0]->processHoverEvent();
QGraphicsItem::hoverEnterEvent(event);
}

491
cockatrice/src/player.cpp
View file

@ -213,7 +213,7 @@ Player::~Player()
void Player::updateBoundingRect()
{
// XXX! PREPARE GEOMETRY CHANGE
prepareGeometryChange();
bRect = QRectF(0, 0, CARD_WIDTH + 5 + counterAreaWidth + hand->boundingRect().width() + table->boundingRect().width(), table->boundingRect().height());
emit sizeChanged();
}
@ -296,6 +296,22 @@ void Player::initSayMenu()
}
}
void Player::prepareForGame()
{
if (local) {
sendGameCommand(new Command_CreateCounter(-1, "life", Qt::white, 25, 20));
sendGameCommand(new Command_CreateCounter(-1, "w", QColor(255, 255, 150), 20, 0));
sendGameCommand(new Command_CreateCounter(-1, "u", QColor(150, 150, 255), 20, 0));
sendGameCommand(new Command_CreateCounter(-1, "b", QColor(150, 150, 150), 20, 0));
sendGameCommand(new Command_CreateCounter(-1, "r", QColor(250, 150, 150), 20, 0));
sendGameCommand(new Command_CreateCounter(-1, "g", QColor(150, 255, 150), 20, 0));
sendGameCommand(new Command_CreateCounter(-1, "x", QColor(255, 255, 255), 20, 0));
sendGameCommand(new Command_CreateCounter(-1, "storm", QColor(255, 255, 255), 20, 0));
mulliganCards = 7;
}
}
void Player::actViewLibrary()
{
emit toggleZoneView(this, "deck", -1);
@ -407,240 +423,212 @@ void Player::setCardAttrHelper(CardItem *card, const QString &aname, const QStri
}
}
/*void Player::gameEvent(const ServerEventData &event)
void Player::eventDeckSelect(Event_DeckSelect *event)
{
QStringList data = event.getEventData();
switch (event.getEventType()) {
case eventSetupZones: {
// XXX Life counter
int deck_cards = data[0].toInt();
int sb_cards = data[1].toInt();
// XXX Fehlerbehandlung
emit logDeckSelect(this, event->getDeckId());
}
// Clean up existing zones first
QMapIterator<QString, CardZone *> zoneIterator(zones);
while (zoneIterator.hasNext()) {
zoneIterator.next();
if (ZoneViewZone *view = zoneIterator.value()->getView())
((ZoneViewWidget *) view->parentItem())->close();
zoneIterator.value()->clearContents();
}
void Player::eventSay(Event_Say *event)
{
emit logSay(this, event->getMessage());
}
clearCounters();
clearArrows();
void Player::eventReadyStart(Event_ReadyStart * /*event*/)
{
emit logReadyStart(this);
}
CardZone *deck = zones.value("deck");
for (; deck_cards; deck_cards--)
deck->addCard(new CardItem(db), false, -1);
void Player::eventShuffle(Event_Shuffle * /*event*/)
{
emit logShuffle(this);
}
CardZone *sb = zones.value("sb");
for (; sb_cards; sb_cards--)
sb->addCard(new CardItem(db), false, -1);
void Player::eventRollDie(Event_RollDie *event)
{
emit logRollDie(this, event->getSides(), event->getValue());
}
zoneIterator.toFront();
while (zoneIterator.hasNext())
zoneIterator.next().value()->reorganizeCards();
void Player::eventCreateArrow(Event_CreateArrow *event)
{
ArrowItem *arrow = addArrow(event->getArrow());
if (!arrow)
return;
emit logCreateArrow(this, arrow->getStartItem()->getOwner(), arrow->getStartItem()->getName(), arrow->getTargetItem()->getOwner(), arrow->getTargetItem()->getName());
}
if (local) {
client->addCounter("life", Qt::white, 25, 20);
client->addCounter("w", QColor(255, 255, 150), 20, 0);
client->addCounter("u", QColor(150, 150, 255), 20, 0);
client->addCounter("b", QColor(150, 150, 150), 20, 0);
client->addCounter("r", QColor(250, 150, 150), 20, 0);
client->addCounter("g", QColor(150, 255, 150), 20, 0);
client->addCounter("x", QColor(255, 255, 255), 20, 0);
client->addCounter("storm", QColor(255, 255, 255), 20, 0);
mulliganCards = 7;
}
void Player::eventDeleteArrow(Event_DeleteArrow *event)
{
delArrow(event->getArrowId());
}
break;
}
case eventDraw: {
CardZone *deck = zones.value("deck");
CardZone *hand = zones.value("hand");
if (!event.getPublic()) {
hand->addCard(deck->takeCard(0, data[0].toInt(), data[1]), true, -1);
} else {
int number = data[0].toInt();
for (; number; number--)
hand->addCard(deck->takeCard(0, -1, QString()), false, -1);
hand->reorganizeCards();
}
break;
}
case eventMoveCard: {
if (data.size() != 8)
break;
int cardId = data[0].toInt();
QString cardName = data[1];
CardZone *startZone = zones.value(data[2], 0);
if (!startZone) {
qDebug(QString("start zone invalid: %1").arg(data[2]).toLatin1());
break;
}
int position = data[3].toInt();
CardZone *targetZone = zones.value(data[4], 0);
if (!targetZone) {
qDebug(QString("target zone invalid: %1").arg(data[4]).toLatin1());
break;
}
void Player::eventCreateToken(Event_CreateToken *event)
{
CardZone *zone = zones.value(event->getZone(), 0);
if (!zone)
return;
int x = data[5].toInt();
int y = data[6].toInt();
bool facedown = data[7].toInt();
CardItem *card = new CardItem(this, event->getCardName(), event->getCardId());
int logPosition = position;
int logX = x;
if (position == -1)
position = 0;
if (x == -1)
x = 0;
CardItem *card = startZone->takeCard(position, cardId, cardName, startZone != targetZone);
if (!card) {
qDebug("moveCard: card not found");
break;
}
card->deleteDragItem();
emit logCreateToken(this, card->getName());
zone->addCard(card, true, event->getX(), event->getY());
card->setFaceDown(facedown);
}
// 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.
emit logMoveCard(this, card->getName(), startZone, logPosition, targetZone, logX);
void Player::eventSetCardAttr(Event_SetCardAttr *event)
{
CardZone *zone = zones.value(event->getZone(), 0);
if (!zone)
return;
targetZone->addCard(card, true, x, y);
// Look at all arrows from and to the card.
// If the card was moved to another zone, delete the arrows, otherwise update them.
QMapIterator<int, Player *> playerIterator(static_cast<Game *>(parent())->getPlayers());
while (playerIterator.hasNext()) {
Player *p = playerIterator.next().value();
QList<int> arrowsToDelete;
QMapIterator<int, ArrowItem *> arrowIterator(p->getArrows());
while (arrowIterator.hasNext()) {
ArrowItem *arrow = arrowIterator.next().value();
if ((arrow->getStartItem() == card) || (arrow->getTargetItem() == card)) {
if (startZone == targetZone)
arrow->updatePath();
else
arrowsToDelete.append(arrow->getId());
}
}
for (int i = 0; i < arrowsToDelete.size(); ++i)
p->delArrow(arrowsToDelete[i]);
}
break;
}
case eventCreateToken: {
// zone, cardid, cardname, powtough, x, y
if (data.size() != 6)
break;
CardZone *zone = zones.value(data[0], 0);
if (!zone)
break;
int cardid = data[1].toInt();
QString cardname = data[2];
QString powtough = data[3];
int x = data[4].toInt();
int y = data[5].toInt();
CardItem *card = new CardItem(db, cardname, cardid);
emit logCreateToken(this, card->getName());
zone->addCard(card, true, x, y);
break;
}
case eventSetCardAttr: {
if (data.size() != 4)
break;
CardZone *zone = zones.value(data[0], 0);
if (!zone)
break;
int cardId = data[1].toInt();
QString aname = data[2];
QString avalue = data[3];
// XXX Fehlerbehandlung
if (cardId == -1) {
const CardList &cards = zone->getCards();
for (int i = 0; i < cards.size(); i++)
setCardAttrHelper(cards.at(i), aname, avalue, true);
if (aname == "tapped")
emit logSetTapped(this, QString("-1"), avalue == "1");
} else {
CardItem *card = zone->getCard(cardId, "");
setCardAttrHelper(card, aname, avalue, false);
}
break;
}
case eventAddCounter: {
if (data.size() != 5)
break;
int counterId = data[0].toInt();
QString counterName = data[1];
int colorValue = data[2].toInt();
int radius = data[3].toInt();
int value = data[4].toInt();
QColor color(colorValue / 65536, (colorValue % 65536) / 256, colorValue % 256);
addCounter(counterId, counterName, color, radius, value);
break;
}
case eventSetCounter: {
if (data.size() != 2)
break;
int counterId = data[0].toInt();
int value = data[1].toInt();
Counter *c = counters.value(counterId, 0);
if (!c)
break;
int oldValue = c->getValue();
c->setValue(value);
emit logSetCounter(this, c->getName(), value, oldValue);
break;
}
case eventCreateArrow: {
if (data.size() != 8)
break;
const QMap<int, Player *> &playerList = static_cast<Game *>(parent())->getPlayers();
Player *startPlayer = playerList.value(data[1].toInt(), 0);
Player *targetPlayer = playerList.value(data[4].toInt(), 0);
if (!startPlayer || !targetPlayer)
return;
CardZone *startZone = startPlayer->getZones().value(data[2], 0);
CardZone *targetZone = targetPlayer->getZones().value(data[5], 0);
if (!startZone || !targetZone)
return;
CardItem *startCard = startZone->getCard(data[3].toInt(), QString());
CardItem *targetCard = targetZone->getCard(data[6].toInt(), QString());
if (!startCard || !targetCard)
return;
addArrow(data[0].toInt(), startCard, targetCard, client->numberToColor(data[7].toInt()));
emit logCreateArrow(this, startPlayer, startCard->getName(), targetPlayer, targetCard->getName());
break;
}
case eventDeleteArrow: {
if (data.size() != 1)
break;
delArrow(data[0].toInt());
break;
}
default:
qDebug("unhandled player event");
if (event->getCardId() == -1) {
const CardList &cards = zone->getCards();
for (int i = 0; i < cards.size(); i++)
setCardAttrHelper(cards.at(i), event->getAttrName(), event->getAttrValue(), true);
if (event->getAttrName() == "tapped")
emit logSetTapped(this, QString("-1"), event->getAttrValue() == "1");
} else {
CardItem *card = zone->getCard(event->getCardId(), QString());
setCardAttrHelper(card, event->getAttrName(), event->getAttrValue(), false);
}
}
*/
void Player::eventCreateCounter(Event_CreateCounter *event)
{
addCounter(event->getCounter());
}
void Player::eventSetCounter(Event_SetCounter *event)
{
Counter *c = counters.value(event->getCounterId(), 0);
if (!c)
return;
int oldValue = c->getValue();
c->setValue(event->getValue());
emit logSetCounter(this, c->getName(), event->getValue(), oldValue);
}
void Player::eventDelCounter(Event_DelCounter *event)
{
delCounter(event->getCounterId());
}
void Player::eventDumpZone(Event_DumpZone *event)
{
Player *zoneOwner = static_cast<TabGame *>(parent())->getPlayers().value(event->getZoneOwnerId(), 0);
if (!zoneOwner)
return;
CardZone *zone = zoneOwner->getZones().value(event->getZone(), 0);
if (!zone)
return;
emit logDumpZone(this, zone, event->getNumberCards());
}
void Player::eventStopDumpZone(Event_StopDumpZone *event)
{
Player *zoneOwner = static_cast<TabGame *>(parent())->getPlayers().value(event->getZoneOwnerId(), 0);
if (!zoneOwner)
return;
CardZone *zone = zoneOwner->getZones().value(event->getZone(), 0);
if (!zone)
return;
emit logStopDumpZone(this, zone);
}
void Player::eventMoveCard(Event_MoveCard *event)
{
CardZone *startZone = zones.value(event->getStartZone(), 0);
CardZone *targetZone = zones.value(event->getTargetZone(), 0);
if (!startZone || !targetZone)
return;
int position = event->getPosition();
int x = event->getX();
int y = event->getY();
int logPosition = position;
int logX = x;
if (position == -1)
position = 0;
if (x == -1)
x = 0;
CardItem *card = startZone->takeCard(position, event->getCardId(), event->getCardName(), startZone != targetZone);
if (!card)
return;
card->deleteDragItem();
card->setFaceDown(event->getFaceDown());
// 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.
emit logMoveCard(this, card->getName(), startZone, logPosition, targetZone, logX);
targetZone->addCard(card, true, x, y);
// Look at all arrows from and to the card.
// If the card was moved to another zone, delete the arrows, otherwise update them.
QMapIterator<int, Player *> playerIterator(static_cast<TabGame *>(parent())->getPlayers());
while (playerIterator.hasNext()) {
Player *p = playerIterator.next().value();
QList<int> arrowsToDelete;
QMapIterator<int, ArrowItem *> arrowIterator(p->getArrows());
while (arrowIterator.hasNext()) {
ArrowItem *arrow = arrowIterator.next().value();
if ((arrow->getStartItem() == card) || (arrow->getTargetItem() == card)) {
if (startZone == targetZone)
arrow->updatePath();
else
arrowsToDelete.append(arrow->getId());
}
}
for (int i = 0; i < arrowsToDelete.size(); ++i)
p->delArrow(arrowsToDelete[i]);
}
}
void Player::eventDrawCards(Event_DrawCards *event)
{
CardZone *deck = zones.value("deck");
CardZone *hand = zones.value("hand");
const QList<ServerInfo_Card *> &cardList = event->getCardList();
if (!cardList.isEmpty())
for (int i = 0; i < cardList.size(); ++i)
hand->addCard(deck->takeCard(0, cardList[i]->getId(), cardList[i]->getName()), false, -1);
else
for (int i = 0; i < event->getNumberCards(); ++i)
hand->addCard(deck->takeCard(0, -1, QString()), false, -1);
hand->reorganizeCards();
deck->reorganizeCards();
emit logDrawCards(this, event->getNumberCards());
}
void Player::processGameEvent(GameEvent *event)
{
switch (event->getItemId()) {
case ItemId_Event_DeckSelect: eventDeckSelect(qobject_cast<Event_DeckSelect *>(event)); break;
case ItemId_Event_Say: eventSay(qobject_cast<Event_Say *>(event)); break;
case ItemId_Event_ReadyStart: eventReadyStart(qobject_cast<Event_ReadyStart *>(event)); break;
case ItemId_Event_Shuffle: eventShuffle(qobject_cast<Event_Shuffle *>(event)); break;
case ItemId_Event_RollDie: eventRollDie(qobject_cast<Event_RollDie *>(event)); break;
case ItemId_Event_CreateArrow: eventCreateArrow(qobject_cast<Event_CreateArrow *>(event)); break;
case ItemId_Event_DeleteArrow: eventDeleteArrow(qobject_cast<Event_DeleteArrow *>(event)); break;
case ItemId_Event_CreateToken: eventCreateToken(qobject_cast<Event_CreateToken *>(event)); break;
case ItemId_Event_SetCardAttr: eventSetCardAttr(qobject_cast<Event_SetCardAttr *>(event)); break;
case ItemId_Event_CreateCounter: eventCreateCounter(qobject_cast<Event_CreateCounter *>(event)); break;
case ItemId_Event_SetCounter: eventSetCounter(qobject_cast<Event_SetCounter *>(event)); break;
case ItemId_Event_DelCounter: eventDelCounter(qobject_cast<Event_DelCounter *>(event)); break;
case ItemId_Event_DumpZone: eventDumpZone(qobject_cast<Event_DumpZone *>(event)); break;
case ItemId_Event_StopDumpZone: eventStopDumpZone(qobject_cast<Event_StopDumpZone *>(event)); break;
case ItemId_Event_MoveCard: eventMoveCard(qobject_cast<Event_MoveCard *>(event)); break;
case ItemId_Event_DrawCards: eventDrawCards(qobject_cast<Event_DrawCards *>(event)); break;
default: {
qDebug() << "unhandled game event";
}
}
}
void Player::showCardMenu(const QPoint &p)
{
emit sigShowCardMenu(p);
@ -705,10 +693,10 @@ void Player::processPlayerInfo(ServerInfo_Player *info)
const QList<ServerInfo_Card *> &cardList = zoneInfo->getCardList();
if (cardList.isEmpty()) {
for (int j = 0; j < zoneInfo->getCardCount(); ++j)
zone->addCard(new CardItem, false, -1);
zone->addCard(new CardItem(this), false, -1);
} else {
for (int j = 0; j < cardList.size(); ++j) {
CardItem *card = new CardItem;
CardItem *card = new CardItem(this);
card->processCardInfo(cardList[i]);
zone->addCard(card, false, cardList[i]->getX(), cardList[i]->getY());
}
@ -718,28 +706,17 @@ void Player::processPlayerInfo(ServerInfo_Player *info)
clearCounters();
for (int i = 0; i < info->getCounterList().size(); ++i) {
ServerInfo_Counter *counterInfo = info->getCounterList().at(i);
addCounter(counterInfo->getId(), counterInfo->getName(), counterInfo->getColor(), counterInfo->getRadius(), counterInfo->getCount());
addCounter(info->getCounterList().at(i));
}
clearArrows();
for (int i = 0; i < info->getArrowList().size(); ++i) {
ServerInfo_Arrow *arrowInfo = info->getArrowList().at(i);
const QMap<int, Player *> &playerList = static_cast<TabGame *>(parent())->getPlayers();
Player *startPlayer = playerList.value(arrowInfo->getStartPlayerId(), 0);
Player *targetPlayer = playerList.value(arrowInfo->getTargetPlayerId(), 0);
if (!startPlayer || !targetPlayer)
continue;
CardZone *startZone = startPlayer->getZones().value(arrowInfo->getStartZone(), 0);
CardZone *targetZone = targetPlayer->getZones().value(arrowInfo->getTargetZone(), 0);
if (!startZone || !targetZone)
continue;
CardItem *startCard = startZone->getCard(arrowInfo->getStartCardId(), QString());
CardItem *targetCard = targetZone->getCard(arrowInfo->getTargetCardId(), QString());
if (!startCard || !targetCard)
continue;
addArrow(arrowInfo->getId(), startCard, targetCard, arrowInfo->getColor());
}
for (int i = 0; i < info->getArrowList().size(); ++i)
addArrow(info->getArrowList().at(i));
}
void Player::addCard(CardItem *c)
{
emit newCardAdded(c);
}
void Player::addZone(CardZone *z)
@ -747,13 +724,19 @@ void Player::addZone(CardZone *z)
zones.insert(z->getName(), z);
}
void Player::addCounter(int counterId, const QString &name, QColor color, int radius, int value)
Counter *Player::addCounter(ServerInfo_Counter *counter)
{
return addCounter(counter->getId(), counter->getName(), counter->getColor(), counter->getRadius(), counter->getCount());
}
Counter *Player::addCounter(int counterId, const QString &name, QColor color, int radius, int value)
{
Counter *c = new Counter(this, counterId, name, color, radius, value, this);
counters.insert(counterId, c);
if (countersMenu)
countersMenu->addMenu(c->getMenu());
rearrangeCounters();
return c;
}
void Player::delCounter(int counterId)
@ -774,11 +757,33 @@ void Player::clearCounters()
counters.clear();
}
void Player::addArrow(int arrowId, CardItem *startCard, CardItem *targetCard, const QColor &color)
ArrowItem *Player::addArrow(ServerInfo_Arrow *arrow)
{
const QMap<int, Player *> &playerList = static_cast<TabGame *>(parent())->getPlayers();
Player *startPlayer = playerList.value(arrow->getStartPlayerId(), 0);
Player *targetPlayer = playerList.value(arrow->getTargetPlayerId(), 0);
if (!startPlayer || !targetPlayer)
return 0;
CardZone *startZone = startPlayer->getZones().value(arrow->getStartZone(), 0);
CardZone *targetZone = targetPlayer->getZones().value(arrow->getTargetZone(), 0);
if (!startZone || !targetZone)
return 0;
CardItem *startCard = startZone->getCard(arrow->getStartCardId(), QString());
CardItem *targetCard = targetZone->getCard(arrow->getTargetCardId(), QString());
if (!startCard || !targetCard)
return 0;
return addArrow(arrow->getId(), startCard, targetCard, arrow->getColor());
}
ArrowItem *Player::addArrow(int arrowId, CardItem *startCard, CardItem *targetCard, const QColor &color)
{
ArrowItem *arrow = new ArrowItem(this, arrowId, startCard, targetCard, color);
arrows.insert(arrowId, arrow);
scene()->addItem(arrow);
return arrow;
}
void Player::delArrow(int arrowId)

66
cockatrice/src/player.h
View file

@ -4,7 +4,6 @@
#include <QInputDialog>
#include <QPoint>
#include <QMap>
#include "client.h"
#include "carditem.h"
class Client;
@ -19,24 +18,50 @@ class CardZone;
class TableZone;
class HandZone;
class ServerInfo_Player;
class ServerInfo_Arrow;
class ServerInfo_Counter;
class GameCommand;
class GameEvent;
class Event_DeckSelect;
class Event_Say;
class Event_ReadyStart;
class Event_Shuffle;
class Event_RollDie;
class Event_CreateArrow;
class Event_DeleteArrow;
class Event_CreateToken;
class Event_SetCardAttr;
class Event_CreateCounter;
class Event_SetCounter;
class Event_DelCounter;
class Event_DumpZone;
class Event_StopDumpZone;
class Event_MoveCard;
class Event_DrawCards;
class Player : public QObject, public QGraphicsItem {
Q_OBJECT
signals:
void moveCard(int cardId, QString startZone, QString targetZone, int x, int y);
void hoverCard(QString name);
void closeZoneView(ZoneViewZone *zone);
void toggleZoneView(Player *player, QString zoneName, int number);
void sigShowCardMenu(QPoint p);
void sigShowCardMenu(QPoint p); // XXX
void newCardAdded(CardItem *card);
// Log events
void logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
void logDeckSelect(Player *player, int deckId);
void logSay(Player *player, QString message);
void logReadyStart(Player *player);
void logShuffle(Player *player);
void logRollDie(Player *player, int sides, int roll);
void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard);
void logCreateToken(Player *player, QString cardName);
void logDrawCards(Player *player, int number);
void logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
void logSetCardCounters(Player *player, QString cardName, int value, int oldValue);
void logSetTapped(Player *player, QString cardName, bool tapped);
void logSetCounter(Player *player, QString counterName, int value, int oldValue);
void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard);
void logSetDoesntUntap(Player *player, QString cardName, bool doesntUntap);
void logDumpZone(Player *player, CardZone *zone, int numberCards);
void logStopDumpZone(Player *player, CardZone *zone);
void sizeChanged();
public slots:
@ -87,6 +112,23 @@ private:
void rearrangeCounters();
void initSayMenu();
void eventDeckSelect(Event_DeckSelect *event);
void eventSay(Event_Say *event);
void eventReadyStart(Event_ReadyStart *event);
void eventShuffle(Event_Shuffle *event);
void eventRollDie(Event_RollDie *event);
void eventCreateArrow(Event_CreateArrow *event);
void eventDeleteArrow(Event_DeleteArrow *event);
void eventCreateToken(Event_CreateToken *event);
void eventSetCardAttr(Event_SetCardAttr *event);
void eventCreateCounter(Event_CreateCounter *event);
void eventSetCounter(Event_SetCounter *event);
void eventDelCounter(Event_DelCounter *event);
void eventDumpZone(Event_DumpZone *event);
void eventStopDumpZone(Event_StopDumpZone *event);
void eventMoveCard(Event_MoveCard *event);
void eventDrawCards(Event_DrawCards *event);
public:
static const int counterAreaWidth = 65;
@ -95,13 +137,16 @@ public:
QRectF boundingRect() const;
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
void addCard(CardItem *c);
void addZone(CardZone *z);
void addCounter(int counterId, const QString &name, QColor color, int radius, int value);
Counter *addCounter(ServerInfo_Counter *counter);
Counter *addCounter(int counterId, const QString &name, QColor color, int radius, int value);
void delCounter(int counterId);
void clearCounters();
void addArrow(int arrowId, CardItem *startCard, CardItem *targetCard, const QColor &color);
ArrowItem *addArrow(ServerInfo_Arrow *arrow);
ArrowItem *addArrow(int arrowId, CardItem *startCard, CardItem *targetCard, const QColor &color);
void delArrow(int arrowId);
void clearArrows();
@ -116,12 +161,13 @@ public:
const QMap<QString, CardZone *> &getZones() const { return zones; }
const QMap<int, ArrowItem *> &getArrows() const { return arrows; }
TableZone *getTable() const { return table; }
// void gameEvent(const ServerEventData &event);
void showCardMenu(const QPoint &p);
bool getActive() const { return active; }
void setActive(bool _active);
void prepareForGame();
void processPlayerInfo(ServerInfo_Player *info);
void processGameEvent(GameEvent *event);
void sendGameCommand(GameCommand *command);
};

42
cockatrice/src/playerlistwidget.cpp Normal file
View file

@ -0,0 +1,42 @@
#include "playerlistwidget.h"
#include "protocol_datastructures.h"
PlayerListWidget::PlayerListWidget(QWidget *parent)
: QTreeWidget(parent)
{
setColumnCount(1);
setRootIsDecorated(false);
retranslateUi();
}
void PlayerListWidget::retranslateUi()
{
headerItem()->setText(0, tr("Player name"));
}
void PlayerListWidget::addPlayer(ServerInfo_Player *player)
{
QTreeWidgetItem *newPlayer = new QTreeWidgetItem;
newPlayer->setText(0, player->getName());
addTopLevelItem(newPlayer);
players.insert(player->getPlayerId(), newPlayer);
}
void PlayerListWidget::removePlayer(int playerId)
{
QTreeWidgetItem *player = players.value(playerId, 0);
if (!player)
return;
players.remove(playerId);
delete takeTopLevelItem(indexOfTopLevelItem(player));
}
void PlayerListWidget::setActivePlayer(int playerId)
{
QMapIterator<int, QTreeWidgetItem *> i(players);
while (i.hasNext()) {
i.next();
QTreeWidgetItem *twi = i.value();
twi->setBackground(0, i.key() == playerId ? QColor(150, 255, 150) : Qt::white);
}
}

21
cockatrice/src/playerlistwidget.h Normal file
View file

@ -0,0 +1,21 @@
#ifndef PLAYERLISTWIDGET_H
#define PLAYERLISTWIDGET_H
#include <QTreeWidget>
#include <QMap>
class ServerInfo_Player;
class PlayerListWidget : public QTreeWidget {
Q_OBJECT
private:
QMap<int, QTreeWidgetItem *> players;
public:
PlayerListWidget(QWidget *parent = 0);
void retranslateUi();
void addPlayer(ServerInfo_Player *player);
void removePlayer(int playerId);
void setActivePlayer(int playerId);
};
#endif

179
cockatrice/src/tab_game.cpp
View file

@ -1,12 +1,12 @@
#include <QtGui>
#include "tab_game.h"
#include "cardinfowidget.h"
#include "playerlistwidget.h"
#include "messagelogwidget.h"
#include "phasestoolbar.h"
#include "gameview.h"
#include "gamescene.h"
#include "player.h"
#include "game.h"
#include "zoneviewzone.h"
#include "zoneviewwidget.h"
#include "zoneviewlayout.h"
@ -15,10 +15,13 @@
#include "deck_picturecacher.h"
#include "protocol_items.h"
#include "dlg_load_remote_deck.h"
#include "client.h"
#include "carditem.h"
#include "arrowitem.h"
#include "main.h"
TabGame::TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectator)
: client(_client), gameId(_gameId), localPlayerId(_localPlayerId), spectator(_spectator)
: client(_client), gameId(_gameId), localPlayerId(_localPlayerId), spectator(_spectator), started(false), currentPhase(-1)
{
zoneLayout = new ZoneViewLayout;
scene = new GameScene(zoneLayout, this);
@ -41,7 +44,8 @@ TabGame::TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectat
deckViewContainer = new QWidget;
deckViewContainer->setLayout(deckViewLayout);
cardInfo = new CardInfoWidget(db);
cardInfo = new CardInfoWidget;
playerListWidget = new PlayerListWidget;
messageLog = new MessageLogWidget;
sayLabel = new QLabel;
sayEdit = new QLineEdit;
@ -53,9 +57,11 @@ TabGame::TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectat
phasesToolbar = new PhasesToolbar;
phasesToolbar->hide();
connect(phasesToolbar, SIGNAL(sendGameCommand(GameCommand *)), this, SLOT(sendGameCommand(GameCommand *)));
QVBoxLayout *verticalLayout = new QVBoxLayout;
verticalLayout->addWidget(cardInfo);
verticalLayout->addWidget(playerListWidget);
verticalLayout->addWidget(messageLog);
verticalLayout->addLayout(hLayout);
@ -75,36 +81,84 @@ TabGame::TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectat
connect(sayEdit, SIGNAL(returnPressed()), this, SLOT(actSay()));
connect(phasesToolbar, SIGNAL(signalSetPhase(int)), client, SLOT(setActivePhase(int)));
connect(phasesToolbar, SIGNAL(signalNextTurn()), client, SLOT(nextTurn()));
// Menu actions
aNextPhase = new QAction(this);
connect(aNextPhase, SIGNAL(triggered()), this, SLOT(actNextPhase()));
aNextTurn = new QAction(this);
connect(aNextTurn, SIGNAL(triggered()), this, SLOT(actNextTurn()));
aRemoveLocalArrows = new QAction(this);
connect(aRemoveLocalArrows, SIGNAL(triggered()), this, SLOT(actRemoveLocalArrows()));
gameMenu = new QMenu(this);
gameMenu->addAction(aNextPhase);
gameMenu->addAction(aNextTurn);
gameMenu->addSeparator();
gameMenu->addAction(aRemoveLocalArrows);
/* game = new Game(client, scene, menuBar(), this);
connect(game, SIGNAL(hoverCard(QString)), cardInfo, SLOT(setCard(const QString &)));
connect(game, SIGNAL(playerAdded(Player *)), this, SLOT(playerAdded(Player *)));
connect(game, SIGNAL(playerRemoved(Player *)), scene, SLOT(removePlayer(Player *)));
connect(game, SIGNAL(setActivePhase(int)), phasesToolbar, SLOT(setActivePhase(int)));
connect(phasesToolbar, SIGNAL(signalDrawCard()), game, SLOT(activePlayerDrawCard()));
connect(phasesToolbar, SIGNAL(signalUntapAll()), game, SLOT(activePlayerUntapAll()));
messageLog->connectToGame(game);
game->queryGameState();
*/
retranslateUi();
setLayout(mainLayout);
messageLog->logGameJoined(gameId);
}
void TabGame::retranslateUi()
{
gameMenu->setTitle(tr("&Game"));
aNextPhase->setText(tr("Next &phase"));
aNextPhase->setShortcut(tr("Ctrl+Space"));
aNextTurn->setText(tr("Next &turn"));
aNextTurn->setShortcuts(QList<QKeySequence>() << QKeySequence(tr("Ctrl+Return")) << QKeySequence(tr("Ctrl+Enter")));
aRemoveLocalArrows->setText(tr("&Remove all local arrows"));
aRemoveLocalArrows->setShortcut(tr("Ctrl+R"));
loadLocalButton->setText(tr("Load &local deck"));
loadRemoteButton->setText(tr("Load deck from &server"));
readyStartButton->setText(tr("&Start game"));
sayLabel->setText(tr("&Say:"));
cardInfo->retranslateUi();
// if (game)
// game->retranslateUi();
zoneLayout->retranslateUi();
aCloseMostRecentZoneView->setText(tr("Close most recent zone view"));
aCloseMostRecentZoneView->setShortcut(tr("Esc"));
QMapIterator<int, Player *> i(players);
while (i.hasNext())
i.next().value()->retranslateUi();
}
void TabGame::actSay()
{
if (!sayEdit->text().isEmpty()) {
sendGameCommand(new Command_Say(-1, sayEdit->text()));
sayEdit->clear();
}
}
void TabGame::actNextPhase()
{
int phase = currentPhase;
if (++phase >= phasesToolbar->phaseCount())
phase = 0;
sendGameCommand(new Command_SetActivePhase(-1, phase));
}
void TabGame::actNextTurn()
{
sendGameCommand(new Command_NextTurn);
}
void TabGame::actRemoveLocalArrows()
{
QMapIterator<int, Player *> playerIterator(players);
while (playerIterator.hasNext()) {
Player *player = playerIterator.next().value();
if (!player->getLocal())
continue;
QMapIterator<int, ArrowItem *> arrowIterator(player->getArrows());
while (arrowIterator.hasNext()) {
ArrowItem *a = arrowIterator.next().value();
sendGameCommand(new Command_DeleteArrow(-1, a->getId()));
}
}
}
Player *TabGame::addPlayer(int playerId, const QString &playerName)
@ -112,6 +166,7 @@ Player *TabGame::addPlayer(int playerId, const QString &playerName)
Player *newPlayer = new Player(playerName, playerId, playerId == localPlayerId, client, this);
scene->addPlayer(newPlayer);
connect(newPlayer, SIGNAL(newCardAdded(CardItem *)), this, SLOT(newCardAdded(CardItem *)));
messageLog->connectToPlayer(newPlayer);
players.insert(playerId, newPlayer);
@ -125,7 +180,19 @@ void TabGame::processGameEvent(GameEvent *event)
switch (event->getItemId()) {
case ItemId_Event_GameStart: eventGameStart(qobject_cast<Event_GameStart *>(event)); break;
case ItemId_Event_GameStateChanged: eventGameStateChanged(qobject_cast<Event_GameStateChanged *>(event)); break;
default: qDebug() << "unhandled game event";
case ItemId_Event_Join: eventJoin(qobject_cast<Event_Join *>(event)); break;
case ItemId_Event_Leave: eventLeave(qobject_cast<Event_Leave *>(event)); break;
case ItemId_Event_GameClosed: eventGameClosed(qobject_cast<Event_GameClosed *>(event)); break;
case ItemId_Event_SetActivePlayer: eventSetActivePlayer(qobject_cast<Event_SetActivePlayer *>(event)); break;
case ItemId_Event_SetActivePhase: eventSetActivePhase(qobject_cast<Event_SetActivePhase *>(event)); break;
default: {
Player *player = players.value(event->getPlayerId(), 0);
if (!player) {
qDebug() << "unhandled game event: invalid player id";
break;
}
player->processGameEvent(event);
}
}
}
@ -135,22 +202,83 @@ void TabGame::sendGameCommand(GameCommand *command)
client->sendCommand(command);
}
void TabGame::eventGameStart(Event_GameStart * /*event*/)
{
currentPhase = -1;
deckViewContainer->hide();
gameView->show();
phasesToolbar->show();
messageLog->logGameStart();
QMapIterator<int, Player *> i(players);
while (i.hasNext())
i.next().value()->prepareForGame();
}
void TabGame::eventGameStateChanged(Event_GameStateChanged *event)
{
const QList<ServerInfo_Player *> &plList = event->getPlayerList();
for (int i = 0; i < plList.size(); ++i) {
ServerInfo_Player *pl = plList[i];
Player *player = players.value(pl->getPlayerId(), 0);
if (!player)
if (!player) {
player = addPlayer(pl->getPlayerId(), pl->getName());
playerListWidget->addPlayer(pl);
}
player->processPlayerInfo(pl);
}
}
void TabGame::eventGameStart(Event_GameStart *event)
void TabGame::eventJoin(Event_Join *event)
{
deckViewContainer->hide();
gameView->show();
if (event->getSpectator()) {
spectatorList.append(event->getPlayerName());
messageLog->logJoinSpectator(event->getPlayerName());
} else {
Player *newPlayer = addPlayer(event->getPlayerId(), event->getPlayerName());
messageLog->logJoin(newPlayer);
}
}
void TabGame::eventLeave(Event_Leave *event)
{
Player *player = players.value(event->getPlayerId(), 0);
if (!player)
return;
messageLog->logLeave(player);
}
void TabGame::eventGameClosed(Event_GameClosed * /*event*/)
{
started = false;
messageLog->logGameClosed();
}
void TabGame::eventSetActivePlayer(Event_SetActivePlayer *event)
{
Player *player = players.value(event->getActivePlayerId(), 0);
if (!player)
return;
playerListWidget->setActivePlayer(event->getActivePlayerId());
QMapIterator<int, Player *> i(players);
while (i.hasNext()) {
i.next();
i.value()->setActive(i.value() == player);
}
messageLog->logSetActivePlayer(player);
currentPhase = -1;
}
void TabGame::eventSetActivePhase(Event_SetActivePhase *event)
{
const int phase = event->getPhase();
if (currentPhase != phase) {
currentPhase = phase;
phasesToolbar->setActivePhase(phase);
messageLog->logSetActivePhase(phase);
}
}
void TabGame::loadLocalDeck()
@ -202,3 +330,8 @@ void TabGame::readyStart()
{
client->sendCommand(new Command_ReadyStart(gameId));
}
void TabGame::newCardAdded(CardItem *card)
{
connect(card, SIGNAL(hovered(CardItem *)), cardInfo, SLOT(setCard(CardItem *)));
}

57
cockatrice/src/tab_game.h
View file

@ -14,16 +14,25 @@ class MessageLogWidget;
class QLabel;
class QLineEdit;
class QPushButton;
class QMenu;
class ZoneViewLayout;
class ZoneViewWidget;
class PhasesToolbar;
class PlayerListWidget;
class ProtocolResponse;
class GameEvent;
class GameCommand;
class Event_GameStateChanged;
class Event_GameStart;
class Event_GameStateChanged;
class Event_Join;
class Event_Leave;
class Event_GameClosed;
class Event_GameStart;
class Event_SetActivePlayer;
class Event_SetActivePhase;
class Player;
class CardZone;
class CardItem;
class TabGame : public QWidget {
Q_OBJECT
@ -39,6 +48,7 @@ private:
QPushButton *loadLocalButton, *loadRemoteButton, *readyStartButton;
CardInfoWidget *cardInfo;
PlayerListWidget *playerListWidget;
MessageLogWidget *messageLog;
QLabel *sayLabel;
QLineEdit *sayEdit;
@ -48,51 +58,42 @@ private:
DeckView *deckView;
QWidget *deckViewContainer;
ZoneViewLayout *zoneLayout;
QAction *aCloseMostRecentZoneView;
QAction *aCloseMostRecentZoneView,
*aNextPhase, *aNextTurn, *aRemoveLocalArrows;
QMenu *gameMenu;
Player *addPlayer(int playerId, const QString &playerName);
void eventGameStateChanged(Event_GameStateChanged *event);
void eventGameStart(Event_GameStart *event);
void eventGameStateChanged(Event_GameStateChanged *event);
void eventJoin(Event_Join *event);
void eventLeave(Event_Leave *event);
void eventGameClosed(Event_GameClosed *event);
void eventSetActivePlayer(Event_SetActivePlayer *event);
void eventSetActivePhase(Event_SetActivePhase *event);
signals:
// -- XXX --
void playerAdded(Player *player);
void playerRemoved(Player *player);
// Log events
void logPlayerListReceived(QStringList players);
void logJoin(Player *player);
void logLeave(Player *player);
void logGameClosed();
void logJoinSpectator(QString playerName);
void logLeaveSpectator(QString playerName);
void logReadyStart(Player *player);
void logGameStart();
void logSay(Player *player, QString text);
void logShuffle(Player *player);
void logRollDie(Player *player, int sides, int roll);
void logDraw(Player *player, int number);
void logMoveCard(Player *player, QString cardName, CardZone *startZone, int oldX, CardZone *targetZone, int newX);
void logCreateToken(Player *player, QString cardName);
void logCreateArrow(Player *player, Player *startPlayer, QString startCard, Player *targetPlayer, QString targetCard);
void logSetCardCounters(Player *player, QString cardName, int value, int oldValue);
void logSetTapped(Player *player, QString cardName, bool tapped);
void logSetCounter(Player *player, QString counterName, int value, int oldValue);
void logSetDoesntUntap(Player *player, QString cardName, bool doesntUntap);
void logDumpZone(Player *player, CardZone *zone, int numberCards);
void logStopDumpZone(Player *player, CardZone *zone);
void logSetActivePlayer(Player *player);
void setActivePhase(int phase);
// -- XXX --
private slots:
void loadLocalDeck();
void loadRemoteDeck();
void readyStart();
void deckSelectFinished(ProtocolResponse *r);
void newCardAdded(CardItem *card);
void actRemoveLocalArrows();
void actSay();
void actNextPhase();
void actNextTurn();
public:
TabGame(Client *_client, int _gameId, int _localPlayerId, bool _spectator);
void retranslateUi();
const QMap<int, Player *> &getPlayers() const { return players; }
void processGameEvent(GameEvent *event);
public slots:
void sendGameCommand(GameCommand *command);
};

5
cockatrice/src/tab_supervisor.cpp
View file

@ -125,6 +125,9 @@ void TabSupervisor::processChatEvent(ChatEvent *event)
void TabSupervisor::processGameEvent(GameEvent *event)
{
TabGame *tab = gameTabs.value(event->getGameId());
if (tab)
if (tab) {
qDebug() << "gameEvent gameId =" << event->getGameId();
tab->processGameEvent(event);
} else
qDebug() << "gameEvent: invalid gameId";
}

2
cockatrice/src/window_deckeditor.cpp
View file

@ -47,7 +47,7 @@ WndDeckEditor::WndDeckEditor(QWidget *parent)
leftFrame->addLayout(searchLayout);
leftFrame->addWidget(databaseView);
cardInfo = new CardInfoWidget(db);
cardInfo = new CardInfoWidget;
cardInfo->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
QToolBar *verticalToolBar = new QToolBar;

11
cockatrice/src/window_main.cpp
View file

@ -143,16 +143,7 @@ void MainWindow::actExit()
{
close();
}
/*
void MainWindow::actSay()
{
if (sayEdit->text().isEmpty())
return;
client->say(sayEdit->text());
sayEdit->clear();
}
*/
void MainWindow::serverTimeout()
{
QMessageBox::critical(this, tr("Error"), tr("Server timeout"));

4
cockatrice/src/zoneviewzone.cpp
View file

@ -35,7 +35,7 @@ void ZoneViewZone::initializeCards()
int number = numberCards == -1 ? c.size() : (numberCards < c.size() ? numberCards : c.size());
for (int i = 0; i < number; i++) {
CardItem *card = c.at(i);
addCard(new CardItem(card->getName(), card->getId(), this), false, i);
addCard(new CardItem(player, card->getName(), card->getId(), this), false, i);
}
emit contentsChanged();
reorganizeCards();
@ -45,7 +45,7 @@ void ZoneViewZone::initializeCards()
void ZoneViewZone::zoneDumpReceived(QList<ServerInfo_Card> cards)
{
for (int i = 0; i < cards.size(); i++) {
CardItem *card = new CardItem(cards[i].getName(), i, this);
CardItem *card = new CardItem(player, cards[i].getName(), i, this);
addCard(card, false, i);
}