aly/servatrice
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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
Show stats Download patch file Download diff file Expand all files Collapse all files

4
cockatrice/cockatrice.pro
View file

@ -20,7 +20,6 @@ HEADERS += src/counter.h \
src/carditem.h \
src/tablezone.h \
src/handzone.h \
src/game.h \
src/carddatabase.h \
src/gameview.h \
src/deck_picturecacher.h \
@ -49,6 +48,7 @@ HEADERS += src/counter.h \
src/tab_supervisor.h \
src/remotedecklist_treewidget.h \
src/deckview.h \
src/playerlistwidget.h \
../common/decklist.h \
../common/protocol.h \
../common/protocol_items.h \
@ -68,7 +68,6 @@ SOURCES += src/counter.cpp \
src/carditem.cpp \
src/tablezone.cpp \
src/handzone.cpp \
src/game.cpp \
src/carddatabase.cpp \
src/gameview.cpp \
src/deck_picturecacher.cpp \
@ -97,6 +96,7 @@ SOURCES += src/counter.cpp \
src/tab_supervisor.cpp \
src/remotedecklist_treewidget.cpp \
src/deckview.cpp \
src/playerlistwidget.cpp \
../common/decklist.cpp \
../common/protocol.cpp \
../common/protocol_items.cpp \

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);
}

413
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,88 +423,127 @@ 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
// 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();
emit logDeckSelect(this, event->getDeckId());
}
clearCounters();
clearArrows();
CardZone *deck = zones.value("deck");
for (; deck_cards; deck_cards--)
deck->addCard(new CardItem(db), false, -1);
CardZone *sb = zones.value("sb");
for (; sb_cards; sb_cards--)
sb->addCard(new CardItem(db), false, -1);
zoneIterator.toFront();
while (zoneIterator.hasNext())
zoneIterator.next().value()->reorganizeCards();
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::eventSay(Event_Say *event)
{
emit logSay(this, event->getMessage());
}
break;
void Player::eventReadyStart(Event_ReadyStart * /*event*/)
{
emit logReadyStart(this);
}
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);
void Player::eventShuffle(Event_Shuffle * /*event*/)
{
emit logShuffle(this);
}
void Player::eventRollDie(Event_RollDie *event)
{
emit logRollDie(this, event->getSides(), event->getValue());
}
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());
}
void Player::eventDeleteArrow(Event_DeleteArrow *event)
{
delArrow(event->getArrowId());
}
void Player::eventCreateToken(Event_CreateToken *event)
{
CardZone *zone = zones.value(event->getZone(), 0);
if (!zone)
return;
CardItem *card = new CardItem(this, event->getCardName(), event->getCardId());
emit logCreateToken(this, card->getName());
zone->addCard(card, true, event->getX(), event->getY());
}
void Player::eventSetCardAttr(Event_SetCardAttr *event)
{
CardZone *zone = zones.value(event->getZone(), 0);
if (!zone)
return;
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 {
int number = data[0].toInt();
for (; number; number--)
hand->addCard(deck->takeCard(0, -1, QString()), false, -1);
hand->reorganizeCards();
CardItem *card = zone->getCard(event->getCardId(), QString());
setCardAttrHelper(card, event->getAttrName(), event->getAttrValue(), false);
}
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;
}
int x = data[5].toInt();
int y = data[6].toInt();
bool facedown = data[7].toInt();
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;
@ -496,15 +551,13 @@ void Player::setCardAttrHelper(CardItem *card, const QString &aname, const QStri
position = 0;
if (x == -1)
x = 0;
CardItem *card = startZone->takeCard(position, cardId, cardName, startZone != targetZone);
if (!card) {
qDebug("moveCard: card not found");
break;
}
CardItem *card = startZone->takeCard(position, event->getCardId(), event->getCardName(), startZone != targetZone);
if (!card)
return;
card->deleteDragItem();
card->setFaceDown(facedown);
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.
@ -514,7 +567,7 @@ void Player::setCardAttrHelper(CardItem *card, const QString &aname, const QStri
// 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());
QMapIterator<int, Player *> playerIterator(static_cast<TabGame *>(parent())->getPlayers());
while (playerIterator.hasNext()) {
Player *p = playerIterator.next().value();
@ -532,115 +585,50 @@ void Player::setCardAttrHelper(CardItem *card, const QString &aname, const QStri
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);
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 logCreateToken(this, card->getName());
zone->addCard(card, true, x, y);
break;
emit logDrawCards(this, event->getNumberCards());
}
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");
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)

64
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

177
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()));
/* 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);
gameMenu = new QMenu(this);
gameMenu->addAction(aNextPhase);
gameMenu->addAction(aNextTurn);
gameMenu->addSeparator();
gameMenu->addAction(aRemoveLocalArrows);
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;

9
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);
}

117
common/protocol.cpp
View file

@ -77,6 +77,9 @@ void ProtocolItem::initializeHash()
itemNameHash.insert("generic_eventlist_games", Event_ListGames::newItem);
itemNameHash.insert("generic_eventlist_chat_channels", Event_ListChatChannels::newItem);
itemNameHash.insert("game_eventgame_state_changed", Event_GameStateChanged::newItem);
itemNameHash.insert("game_eventcreate_arrow", Event_CreateArrow::newItem);
itemNameHash.insert("game_eventcreate_counter", Event_CreateCounter::newItem);
itemNameHash.insert("game_eventdraw_cards", Event_DrawCards::newItem);
itemNameHash.insert("chat_eventchat_list_players", Event_ChatListPlayers::newItem);
}
@ -422,7 +425,7 @@ void Event_ListGames::writeElement(QXmlStreamWriter *xml)
}
Event_GameStateChanged::Event_GameStateChanged(int _gameId, const QList<ServerInfo_Player *> &_playerList)
: GameEvent("game_state_changed", _gameId, -1), currentItem(0), readFinished(false), playerList(_playerList)
: GameEvent("game_state_changed", _gameId, -1), currentItem(0), playerList(_playerList)
{
}
@ -456,3 +459,115 @@ void Event_GameStateChanged::writeElement(QXmlStreamWriter *xml)
for (int i = 0; i < playerList.size(); ++i)
playerList[i]->writeElement(xml);
}
Event_CreateArrow::Event_CreateArrow(int _gameId, int _playerId, ServerInfo_Arrow *_arrow)
: GameEvent("create_arrow", _gameId, _playerId), arrow(_arrow), readFinished(false)
{
}
Event_CreateArrow::~Event_CreateArrow()
{
delete arrow;
}
bool Event_CreateArrow::readElement(QXmlStreamReader *xml)
{
if (readFinished)
return false;
if (!arrow) {
if (xml->isStartElement() && (xml->name() == "arrow"))
arrow = new ServerInfo_Arrow;
else
return false;
}
if (arrow->readElement(xml))
readFinished = true;
return true;
}
void Event_CreateArrow::writeElement(QXmlStreamWriter *xml)
{
if (arrow)
arrow->writeElement(xml);
}
Event_CreateCounter::Event_CreateCounter(int _gameId, int _playerId, ServerInfo_Counter *_counter)
: GameEvent("create_counter", _gameId, _playerId), counter(_counter), readFinished(false)
{
}
Event_CreateCounter::~Event_CreateCounter()
{
delete counter;
}
bool Event_CreateCounter::readElement(QXmlStreamReader *xml)
{
if (readFinished)
return false;
if (!counter) {
if (xml->isStartElement() && (xml->name() == "counter"))
counter = new ServerInfo_Counter;
else
return false;
}
if (counter->readElement(xml))
readFinished = true;
return true;
}
void Event_CreateCounter::writeElement(QXmlStreamWriter *xml)
{
if (counter)
counter->writeElement(xml);
}
Event_DrawCards::Event_DrawCards(int _gameId, int _playerId, int _numberCards, const QList<ServerInfo_Card *> &_cardList)
: GameEvent("draw_cards", _gameId, _playerId), currentItem(0), numberCards(_numberCards), cardList(_cardList)
{
setParameter("number_cards", numberCards);
}
Event_DrawCards::~Event_DrawCards()
{
for (int i = 0; i < cardList.size(); ++i)
delete cardList[i];
}
void Event_DrawCards::extractParameters()
{
GameEvent::extractParameters();
bool ok;
numberCards = parameters["number_cards"].toInt(&ok);
if (!ok)
numberCards = -1;
}
bool Event_DrawCards::readElement(QXmlStreamReader *xml)
{
if (currentItem) {
if (currentItem->readElement(xml))
currentItem = 0;
return true;
}
if (xml->isStartElement() && (xml->name() == "card")) {
ServerInfo_Card *card = new ServerInfo_Card;
cardList.append(card);
currentItem = card;
} else
return false;
if (currentItem)
if (currentItem->readElement(xml))
currentItem = 0;
return true;
}
void Event_DrawCards::writeElement(QXmlStreamWriter *xml)
{
for (int i = 0; i < cardList.size(); ++i)
cardList[i]->writeElement(xml);
}

55
common/protocol.h
View file

@ -23,6 +23,9 @@ enum ItemId {
ItemId_Event_ChatListPlayers = ItemId_Other + 201,
ItemId_Event_ListGames = ItemId_Other + 202,
ItemId_Event_GameStateChanged = ItemId_Other + 203,
ItemId_Event_CreateArrow = ItemId_Other + 204,
ItemId_Event_CreateCounter = ItemId_Other + 205,
ItemId_Event_DrawCards = ItemId_Other + 206,
ItemId_Response_DeckList = ItemId_Other + 300,
ItemId_Response_DeckDownload = ItemId_Other + 301,
ItemId_Response_DeckUpload = ItemId_Other + 302
@ -341,7 +344,6 @@ class Event_GameStateChanged : public GameEvent {
Q_OBJECT
private:
SerializableItem *currentItem;
bool readFinished;
QList<ServerInfo_Player *> playerList;
public:
Event_GameStateChanged(int _gameId = -1, const QList<ServerInfo_Player *> &_playerList = QList<ServerInfo_Player *>());
@ -354,4 +356,55 @@ public:
void writeElement(QXmlStreamWriter *xml);
};
class Event_CreateArrow : public GameEvent {
Q_OBJECT
private:
ServerInfo_Arrow *arrow;
bool readFinished;
protected:
bool readElement(QXmlStreamReader *xml);
void writeElement(QXmlStreamWriter *xml);
public:
Event_CreateArrow(int _gameId = -1, int _playerId = -1, ServerInfo_Arrow *_arrow = 0);
~Event_CreateArrow();
int getItemId() const { return ItemId_Event_CreateArrow; }
static ProtocolItem *newItem() { return new Event_CreateArrow; }
ServerInfo_Arrow *getArrow() const { return arrow; }
};
class Event_CreateCounter : public GameEvent {
Q_OBJECT
private:
ServerInfo_Counter *counter;
bool readFinished;
protected:
bool readElement(QXmlStreamReader *xml);
void writeElement(QXmlStreamWriter *xml);
public:
Event_CreateCounter(int _gameId = -1, int _playerId = -1, ServerInfo_Counter *_counter = 0);
~Event_CreateCounter();
int getItemId() const { return ItemId_Event_CreateCounter; }
static ProtocolItem *newItem() { return new Event_CreateCounter; }
ServerInfo_Counter *getCounter() const { return counter; }
};
class Event_DrawCards : public GameEvent {
Q_OBJECT
private:
SerializableItem *currentItem;
int numberCards;
QList<ServerInfo_Card *> cardList;
protected:
void extractParameters();
bool readElement(QXmlStreamReader *xml);
void writeElement(QXmlStreamWriter *xml);
public:
Event_DrawCards(int _gameId = -1, int _playerId = -1, int numberCards = -1, const QList<ServerInfo_Card *> &_cardList = QList<ServerInfo_Card *>());
~Event_DrawCards();
int getItemId() const { return ItemId_Event_DrawCards; }
static ProtocolItem *newItem() { return new Event_DrawCards; }
int getNumberCards() const { return numberCards; }
const QList<ServerInfo_Card *> &getCardList() const { return cardList; }
};
#endif

55
common/protocol_item_ids.h
View file

@ -25,39 +25,36 @@ ItemId_Command_DeleteArrow = 1023,
ItemId_Command_SetCardAttr = 1024,
ItemId_Command_ReadyStart = 1025,
ItemId_Command_IncCounter = 1026,
ItemId_Command_AddCounter = 1027,
ItemId_Command_CreateCounter = 1027,
ItemId_Command_SetCounter = 1028,
ItemId_Command_DelCounter = 1029,
ItemId_Command_NextTurn = 1030,
ItemId_Command_SetActivePhase = 1031,
ItemId_Command_DumpZone = 1032,
ItemId_Command_StopDumpZone = 1033,
ItemId_Command_DumpAll = 1034,
ItemId_Event_Say = 1035,
ItemId_Event_Join = 1036,
ItemId_Event_Leave = 1037,
ItemId_Event_DeckSelect = 1038,
ItemId_Event_GameClosed = 1039,
ItemId_Event_ReadyStart = 1040,
ItemId_Event_GameStart = 1041,
ItemId_Event_Shuffle = 1042,
ItemId_Event_RollDie = 1043,
ItemId_Event_MoveCard = 1044,
ItemId_Event_CreateToken = 1045,
ItemId_Event_CreateArrow = 1046,
ItemId_Event_DeleteArrow = 1047,
ItemId_Event_SetCardAttr = 1048,
ItemId_Event_AddCounter = 1049,
ItemId_Event_SetCounter = 1050,
ItemId_Event_DelCounter = 1051,
ItemId_Event_SetActivePlayer = 1052,
ItemId_Event_SetActivePhase = 1053,
ItemId_Event_DumpZone = 1054,
ItemId_Event_StopDumpZone = 1055,
ItemId_Event_ServerMessage = 1056,
ItemId_Event_GameJoined = 1057,
ItemId_Event_ChatJoinChannel = 1058,
ItemId_Event_ChatLeaveChannel = 1059,
ItemId_Event_ChatSay = 1060,
ItemId_Other = 1061
ItemId_Event_Say = 1034,
ItemId_Event_Join = 1035,
ItemId_Event_Leave = 1036,
ItemId_Event_DeckSelect = 1037,
ItemId_Event_GameClosed = 1038,
ItemId_Event_ReadyStart = 1039,
ItemId_Event_GameStart = 1040,
ItemId_Event_Shuffle = 1041,
ItemId_Event_RollDie = 1042,
ItemId_Event_MoveCard = 1043,
ItemId_Event_CreateToken = 1044,
ItemId_Event_DeleteArrow = 1045,
ItemId_Event_SetCardAttr = 1046,
ItemId_Event_SetCounter = 1047,
ItemId_Event_DelCounter = 1048,
ItemId_Event_SetActivePlayer = 1049,
ItemId_Event_SetActivePhase = 1050,
ItemId_Event_DumpZone = 1051,
ItemId_Event_StopDumpZone = 1052,
ItemId_Event_ServerMessage = 1053,
ItemId_Event_GameJoined = 1054,
ItemId_Event_ChatJoinChannel = 1055,
ItemId_Event_ChatLeaveChannel = 1056,
ItemId_Event_ChatSay = 1057,
ItemId_Other = 1058
};

57
common/protocol_items.cpp
View file

@ -265,15 +265,15 @@ void Command_IncCounter::extractParameters()
counterId = parameters["counter_id"].toInt();
delta = parameters["delta"].toInt();
}
Command_AddCounter::Command_AddCounter(int _gameId, const QString &_counterName, const QColor &_color, int _radius, int _value)
: GameCommand("add_counter", _gameId), counterName(_counterName), color(_color), radius(_radius), value(_value)
Command_CreateCounter::Command_CreateCounter(int _gameId, const QString &_counterName, const QColor &_color, int _radius, int _value)
: GameCommand("create_counter", _gameId), counterName(_counterName), color(_color), radius(_radius), value(_value)
{
setParameter("counter_name", counterName);
setParameter("color", color);
setParameter("radius", radius);
setParameter("value", value);
}
void Command_AddCounter::extractParameters()
void Command_CreateCounter::extractParameters()
{
GameCommand::extractParameters();
counterName = parameters["counter_name"];
@ -343,10 +343,6 @@ void Command_StopDumpZone::extractParameters()
playerId = parameters["player_id"].toInt();
zoneName = parameters["zone_name"];
}
Command_DumpAll::Command_DumpAll(int _gameId)
: GameCommand("dump_all", _gameId)
{
}
Event_Say::Event_Say(int _gameId, int _playerId, const QString &_message)
: GameEvent("say", _gameId, _playerId), message(_message)
{
@ -455,30 +451,6 @@ void Event_CreateToken::extractParameters()
x = parameters["x"].toInt();
y = parameters["y"].toInt();
}
Event_CreateArrow::Event_CreateArrow(int _gameId, int _playerId, int _arrowId, int _startPlayerId, const QString &_startZone, int _startCardId, int _targetPlayerId, const QString &_targetZone, int _targetCardId, const QColor &_color)
: GameEvent("create_arrow", _gameId, _playerId), arrowId(_arrowId), startPlayerId(_startPlayerId), startZone(_startZone), startCardId(_startCardId), targetPlayerId(_targetPlayerId), targetZone(_targetZone), targetCardId(_targetCardId), color(_color)
{
setParameter("arrow_id", arrowId);
setParameter("start_player_id", startPlayerId);
setParameter("start_zone", startZone);
setParameter("start_card_id", startCardId);
setParameter("target_player_id", targetPlayerId);
setParameter("target_zone", targetZone);
setParameter("target_card_id", targetCardId);
setParameter("color", color);
}
void Event_CreateArrow::extractParameters()
{
GameEvent::extractParameters();
arrowId = parameters["arrow_id"].toInt();
startPlayerId = parameters["start_player_id"].toInt();
startZone = parameters["start_zone"];
startCardId = parameters["start_card_id"].toInt();
targetPlayerId = parameters["target_player_id"].toInt();
targetZone = parameters["target_zone"];
targetCardId = parameters["target_card_id"].toInt();
color = ColorConverter::colorFromInt(parameters["color"].toInt());
}
Event_DeleteArrow::Event_DeleteArrow(int _gameId, int _playerId, int _arrowId)
: GameEvent("delete_arrow", _gameId, _playerId), arrowId(_arrowId)
{
@ -505,24 +477,6 @@ void Event_SetCardAttr::extractParameters()
attrName = parameters["attr_name"];
attrValue = parameters["attr_value"];
}
Event_AddCounter::Event_AddCounter(int _gameId, int _playerId, int _counterId, const QString &_counterName, const QColor &_color, int _radius, int _value)
: GameEvent("add_counter", _gameId, _playerId), counterId(_counterId), counterName(_counterName), color(_color), radius(_radius), value(_value)
{
setParameter("counter_id", counterId);
setParameter("counter_name", counterName);
setParameter("color", color);
setParameter("radius", radius);
setParameter("value", value);
}
void Event_AddCounter::extractParameters()
{
GameEvent::extractParameters();
counterId = parameters["counter_id"].toInt();
counterName = parameters["counter_name"];
color = ColorConverter::colorFromInt(parameters["color"].toInt());
radius = parameters["radius"].toInt();
value = parameters["value"].toInt();
}
Event_SetCounter::Event_SetCounter(int _gameId, int _playerId, int _counterId, int _value)
: GameEvent("set_counter", _gameId, _playerId), counterId(_counterId), value(_value)
{
@ -675,14 +629,13 @@ void ProtocolItem::initializeHashAuto()
itemNameHash.insert("cmdset_card_attr", Command_SetCardAttr::newItem);
itemNameHash.insert("cmdready_start", Command_ReadyStart::newItem);
itemNameHash.insert("cmdinc_counter", Command_IncCounter::newItem);
itemNameHash.insert("cmdadd_counter", Command_AddCounter::newItem);
itemNameHash.insert("cmdcreate_counter", Command_CreateCounter::newItem);
itemNameHash.insert("cmdset_counter", Command_SetCounter::newItem);
itemNameHash.insert("cmddel_counter", Command_DelCounter::newItem);
itemNameHash.insert("cmdnext_turn", Command_NextTurn::newItem);
itemNameHash.insert("cmdset_active_phase", Command_SetActivePhase::newItem);
itemNameHash.insert("cmddump_zone", Command_DumpZone::newItem);
itemNameHash.insert("cmdstop_dump_zone", Command_StopDumpZone::newItem);
itemNameHash.insert("cmddump_all", Command_DumpAll::newItem);
itemNameHash.insert("game_eventsay", Event_Say::newItem);
itemNameHash.insert("game_eventjoin", Event_Join::newItem);
itemNameHash.insert("game_eventleave", Event_Leave::newItem);
@ -694,10 +647,8 @@ void ProtocolItem::initializeHashAuto()
itemNameHash.insert("game_eventroll_die", Event_RollDie::newItem);
itemNameHash.insert("game_eventmove_card", Event_MoveCard::newItem);
itemNameHash.insert("game_eventcreate_token", Event_CreateToken::newItem);
itemNameHash.insert("game_eventcreate_arrow", Event_CreateArrow::newItem);
itemNameHash.insert("game_eventdelete_arrow", Event_DeleteArrow::newItem);
itemNameHash.insert("game_eventset_card_attr", Event_SetCardAttr::newItem);
itemNameHash.insert("game_eventadd_counter", Event_AddCounter::newItem);
itemNameHash.insert("game_eventset_counter", Event_SetCounter::newItem);
itemNameHash.insert("game_eventdel_counter", Event_DelCounter::newItem);
itemNameHash.insert("game_eventset_active_player", Event_SetActivePlayer::newItem);

5
common/protocol_items.dat
View file

@ -24,14 +24,13 @@
2:set_card_attr:s,zone:i,card_id:s,attr_name:s,attr_value
2:ready_start
2:inc_counter:i,counter_id:i,delta
2:add_counter:s,counter_name:c,color:i,radius:i,value
2:create_counter:s,counter_name:c,color:i,radius:i,value
2:set_counter:i,counter_id:i,value
2:del_counter:i,counter_id
2:next_turn
2:set_active_phase:i,phase
2:dump_zone:i,player_id:s,zone_name:i,number_cards
2:stop_dump_zone:i,player_id:s,zone_name
2:dump_all
3:say:s,message
3:join:s,player_name:b,spectator
3:leave
@ -43,10 +42,8 @@
3:roll_die:i,sides:i,value
3:move_card:i,card_id:s,card_name:s,start_zone:i,position:s,target_zone:i,x:i,y:b,face_down
3:create_token:s,zone:i,card_id:s,card_name:s,pt:i,x:i,y
3:create_arrow:i,arrow_id:i,start_player_id:s,start_zone:i,start_card_id:i,target_player_id:s,target_zone:i,target_card_id:c,color
3:delete_arrow:i,arrow_id
3:set_card_attr:s,zone:i,card_id:s,attr_name:s,attr_value
3:add_counter:i,counter_id:s,counter_name:c,color:i,radius:i,value
3:set_counter:i,counter_id:i,value
3:del_counter:i,counter_id
3:set_active_player:i,active_player_id

62
common/protocol_items.h
View file

@ -335,7 +335,7 @@ public:
protected:
void extractParameters();
};
class Command_AddCounter : public GameCommand {
class Command_CreateCounter : public GameCommand {
Q_OBJECT
private:
QString counterName;
@ -343,13 +343,13 @@ private:
int radius;
int value;
public:
Command_AddCounter(int _gameId = -1, const QString &_counterName = QString(), const QColor &_color = QColor(), int _radius = -1, int _value = -1);
Command_CreateCounter(int _gameId = -1, const QString &_counterName = QString(), const QColor &_color = QColor(), int _radius = -1, int _value = -1);
QString getCounterName() const { return counterName; }
QColor getColor() const { return color; }
int getRadius() const { return radius; }
int getValue() const { return value; }
static ProtocolItem *newItem() { return new Command_AddCounter; }
int getItemId() const { return ItemId_Command_AddCounter; }
static ProtocolItem *newItem() { return new Command_CreateCounter; }
int getItemId() const { return ItemId_Command_CreateCounter; }
protected:
void extractParameters();
};
@ -429,14 +429,6 @@ public:
protected:
void extractParameters();
};
class Command_DumpAll : public GameCommand {
Q_OBJECT
private:
public:
Command_DumpAll(int _gameId = -1);
static ProtocolItem *newItem() { return new Command_DumpAll; }
int getItemId() const { return ItemId_Command_DumpAll; }
};
class Event_Say : public GameEvent {
Q_OBJECT
private:
@ -577,32 +569,6 @@ public:
protected:
void extractParameters();
};
class Event_CreateArrow : public GameEvent {
Q_OBJECT
private:
int arrowId;
int startPlayerId;
QString startZone;
int startCardId;
int targetPlayerId;
QString targetZone;
int targetCardId;
QColor color;
public:
Event_CreateArrow(int _gameId = -1, int _playerId = -1, int _arrowId = -1, int _startPlayerId = -1, const QString &_startZone = QString(), int _startCardId = -1, int _targetPlayerId = -1, const QString &_targetZone = QString(), int _targetCardId = -1, const QColor &_color = QColor());
int getArrowId() const { return arrowId; }
int getStartPlayerId() const { return startPlayerId; }
QString getStartZone() const { return startZone; }
int getStartCardId() const { return startCardId; }
int getTargetPlayerId() const { return targetPlayerId; }
QString getTargetZone() const { return targetZone; }
int getTargetCardId() const { return targetCardId; }
QColor getColor() const { return color; }
static ProtocolItem *newItem() { return new Event_CreateArrow; }
int getItemId() const { return ItemId_Event_CreateArrow; }
protected:
void extractParameters();
};
class Event_DeleteArrow : public GameEvent {
Q_OBJECT
private:
@ -633,26 +599,6 @@ public:
protected:
void extractParameters();
};
class Event_AddCounter : public GameEvent {
Q_OBJECT
private:
int counterId;
QString counterName;
QColor color;
int radius;
int value;
public:
Event_AddCounter(int _gameId = -1, int _playerId = -1, int _counterId = -1, const QString &_counterName = QString(), const QColor &_color = QColor(), int _radius = -1, int _value = -1);
int getCounterId() const { return counterId; }
QString getCounterName() const { return counterName; }
QColor getColor() const { return color; }
int getRadius() const { return radius; }
int getValue() const { return value; }
static ProtocolItem *newItem() { return new Event_AddCounter; }
int getItemId() const { return ItemId_Event_AddCounter; }
protected:
void extractParameters();
};
class Event_SetCounter : public GameEvent {
Q_OBJECT
private:

3
common/server_game.cpp
View file

@ -219,12 +219,13 @@ QList<ServerInfo_Player *> Server_Game::getGameState(Server_Player *playerWhosAs
return result;
}
void Server_Game::sendGameEvent(GameEvent *event)
void Server_Game::sendGameEvent(GameEvent *event, Server_Player *exclude)
{
event->setGameId(gameId);
QList<Server_Player *> receivers = QList<Server_Player *>() << players.values() << spectators;
for (int i = 0; i < receivers.size(); ++i)
if (receivers[i] != exclude)
receivers[i]->sendProtocolItem(event, false);
delete event;

2
common/server_game.h
View file

@ -66,7 +66,7 @@ public:
void setActivePhase(int _activePhase);
QList<ServerInfo_Player *> getGameState(Server_Player *playerWhosAsking) const;
void sendGameEvent(GameEvent *event);
void sendGameEvent(GameEvent *event, Server_Player *exclude = 0);
};
#endif

29
common/server_protocolhandler.cpp
View file

@ -80,14 +80,13 @@ void Server_ProtocolHandler::processCommand(Command *command)
case ItemId_Command_SetCardAttr: response = cmdSetCardAttr(qobject_cast<Command_SetCardAttr *>(command), game, player); break;
case ItemId_Command_ReadyStart: response = cmdReadyStart(qobject_cast<Command_ReadyStart *>(command), game, player); break;
case ItemId_Command_IncCounter: response = cmdIncCounter(qobject_cast<Command_IncCounter *>(command), game, player); break;
case ItemId_Command_AddCounter: response = cmdAddCounter(qobject_cast<Command_AddCounter *>(command), game, player); break;
case ItemId_Command_CreateCounter: response = cmdCreateCounter(qobject_cast<Command_CreateCounter *>(command), game, player); break;
case ItemId_Command_SetCounter: response = cmdSetCounter(qobject_cast<Command_SetCounter *>(command), game, player); break;
case ItemId_Command_DelCounter: response = cmdDelCounter(qobject_cast<Command_DelCounter *>(command), game, player); break;
case ItemId_Command_NextTurn: response = cmdNextTurn(qobject_cast<Command_NextTurn *>(command), game, player); break;
case ItemId_Command_SetActivePhase: response = cmdSetActivePhase(qobject_cast<Command_SetActivePhase *>(command), game, player); break;
case ItemId_Command_DumpZone: response = cmdDumpZone(qobject_cast<Command_DumpZone *>(command), game, player); break;
case ItemId_Command_StopDumpZone: response = cmdStopDumpZone(qobject_cast<Command_StopDumpZone *>(command), game, player); break;
case ItemId_Command_DumpAll: response = cmdDumpAll(qobject_cast<Command_DumpAll *>(command), game, player); break;
}
} else {
qDebug() << "received generic Command";
@ -297,13 +296,16 @@ ResponseCode Server_ProtocolHandler::cmdDrawCards(Command_DrawCards *cmd, Server
if (deck->cards.size() < number)
number = deck->cards.size();
QList<ServerInfo_Card *> cardList;
for (int i = 0; i < number; ++i) {
Server_Card *card = deck->cards.takeFirst();
hand->cards.append(card);
// player->privateEvent(QString("draw|%1|%2").arg(card->getId()).arg(card->getName()));
cardList.append(new ServerInfo_Card(card->getId(), card->getName()));
}
// game->broadcastEvent(QString("draw|%1").arg(number), player);
player->sendProtocolItem(new Event_DrawCards(game->getGameId(), player->getPlayerId(), cardList.size(), cardList));
game->sendGameEvent(new Event_DrawCards(-1, player->getPlayerId(), cardList.size()), player);
return RespOk;
}
@ -365,9 +367,9 @@ ResponseCode Server_ProtocolHandler::cmdMoveCard(Command_MoveCard *cmd, Server_G
x = -1;
if ((startzone->getType() == PublicZone) || (targetzone->getType() == PublicZone))
game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), card->getId(), publicCardName, startzone->getName(), position, targetzone->getName(), x, y, facedown));
game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), card->getId(), publicCardName, startzone->getName(), position, targetzone->getName(), x, y, facedown), player);
else
game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), -1, QString(), startzone->getName(), position, targetzone->getName(), x, y, false));
game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), -1, QString(), startzone->getName(), position, targetzone->getName(), x, y, false), player);
// If the card was moved to another zone, delete all arrows from and to the card
if (startzone != targetzone) {
@ -425,9 +427,7 @@ ResponseCode Server_ProtocolHandler::cmdCreateArrow(Command_CreateArrow *cmd, Se
Server_Arrow *arrow = new Server_Arrow(player->newArrowId(), startCard, targetCard, cmd->getColor());
player->addArrow(arrow);
game->sendGameEvent(new Event_CreateArrow(
-1,
player->getPlayerId(),
game->sendGameEvent(new Event_CreateArrow(-1, player->getPlayerId(), new ServerInfo_Arrow(
arrow->getId(),
startPlayer->getPlayerId(),
startZone->getName(),
@ -436,7 +436,7 @@ ResponseCode Server_ProtocolHandler::cmdCreateArrow(Command_CreateArrow *cmd, Se
targetZone->getName(),
targetCard->getId(),
cmd->getColor()
));
)));
return RespOk;
}
@ -496,11 +496,11 @@ ResponseCode Server_ProtocolHandler::cmdIncCounter(Command_IncCounter *cmd, Serv
return RespOk;
}
ResponseCode Server_ProtocolHandler::cmdAddCounter(Command_AddCounter *cmd, Server_Game *game, Server_Player *player)
ResponseCode Server_ProtocolHandler::cmdCreateCounter(Command_CreateCounter *cmd, Server_Game *game, Server_Player *player)
{
Server_Counter *c = new Server_Counter(player->newCounterId(), cmd->getCounterName(), cmd->getColor(), cmd->getRadius(), cmd->getValue());
player->addCounter(c);
game->sendGameEvent(new Event_AddCounter(-1, player->getPlayerId(), c->getId(), c->getName(), c->getColor(), c->getRadius(), c->getCount()));
game->sendGameEvent(new Event_CreateCounter(-1, player->getPlayerId(), new ServerInfo_Counter(c->getId(), c->getName(), c->getColor(), c->getRadius(), c->getCount())));
return RespOk;
}
@ -575,8 +575,3 @@ ResponseCode Server_ProtocolHandler::cmdStopDumpZone(Command_StopDumpZone *cmd,
}
return RespOk;
}
ResponseCode Server_ProtocolHandler::cmdDumpAll(Command_DumpAll *cmd, Server_Game *game, Server_Player *player)
{
return RespOk;
}

3
common/server_protocolhandler.h
View file

@ -57,14 +57,13 @@ private:
ResponseCode cmdSetCardAttr(Command_SetCardAttr *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdReadyStart(Command_ReadyStart *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdIncCounter(Command_IncCounter *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdAddCounter(Command_AddCounter *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdCreateCounter(Command_CreateCounter *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdSetCounter(Command_SetCounter *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdDelCounter(Command_DelCounter *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdNextTurn(Command_NextTurn *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdSetActivePhase(Command_SetActivePhase *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdDumpZone(Command_DumpZone *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdStopDumpZone(Command_StopDumpZone *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdDumpAll(Command_DumpAll *cmd, Server_Game *game, Server_Player *player);
public:
Server_ProtocolHandler(Server *_server, QObject *parent = 0);
~Server_ProtocolHandler();

3
servatrice/src/serversocketinterface.cpp
View file

@ -152,8 +152,9 @@ bool ServerSocketInterface::deckListHelper(DeckList_Directory *folder)
return false;
}
query.prepare("select id, name, upload_time from decklist_files where id_folder = :id_folder");
query.prepare("select id, name, upload_time from decklist_files where id_folder = :id_folder and user = :user");
query.bindValue(":id_folder", folder->getId());
query.bindValue(":user", playerName);
if (!servatrice->execSqlQuery(query))
return false;