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

removed the need to refresh the game list

Browse source
This commit is contained in:
Max-Wilhelm Bruker 2009-06-11 17:51:52 +02:00
parent 197bf0dc64
commit c00027f988
21 changed files with 211 additions and 215 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
cockatrice/src/cardinfowidget.cpp
View file

@ -9,20 +9,32 @@ CardInfoWidget::CardInfoWidget(CardDatabase *_db, QWidget *parent)
cardPicture = new QLabel(); cardPicture = new QLabel();
cardPicture->setAlignment(Qt::AlignCenter); cardPicture->setAlignment(Qt::AlignCenter);
QFont f;
f.setPointSize(9);
nameLabel1 = new QLabel(tr("Name:")); nameLabel1 = new QLabel(tr("Name:"));
nameLabel1->setFont(f);
nameLabel2 = new QLabel(); nameLabel2 = new QLabel();
nameLabel2->setWordWrap(true); nameLabel2->setWordWrap(true);
nameLabel2->setFont(f);
manacostLabel1 = new QLabel(tr("Mana cost:")); manacostLabel1 = new QLabel(tr("Mana cost:"));
manacostLabel1->setFont(f);
manacostLabel2 = new QLabel(); manacostLabel2 = new QLabel();
manacostLabel2->setFont(f);
manacostLabel2->setWordWrap(true); manacostLabel2->setWordWrap(true);
cardtypeLabel1 = new QLabel(tr("Card type:")); cardtypeLabel1 = new QLabel(tr("Card type:"));
cardtypeLabel1->setFont(f);
cardtypeLabel2 = new QLabel(); cardtypeLabel2 = new QLabel();
cardtypeLabel2->setFont(f);
cardtypeLabel2->setWordWrap(true); cardtypeLabel2->setWordWrap(true);
powtoughLabel1 = new QLabel(tr("P / T:")); powtoughLabel1 = new QLabel(tr("P / T:"));
powtoughLabel1->setFont(f);
powtoughLabel2 = new QLabel(); powtoughLabel2 = new QLabel();
powtoughLabel2->setFont(f);
textLabel = new QTextEdit(); textLabel = new QTextEdit();
textLabel->setReadOnly(true); textLabel->setReadOnly(true);
textLabel->setFont(f);
QGridLayout *grid = new QGridLayout(this); QGridLayout *grid = new QGridLayout(this);
grid->addWidget(cardPicture, 0, 0, 1, 2); grid->addWidget(cardPicture, 0, 0, 1, 2);
@ -36,8 +48,11 @@ CardInfoWidget::CardInfoWidget(CardDatabase *_db, QWidget *parent)
grid->addWidget(powtoughLabel2, 4, 1); grid->addWidget(powtoughLabel2, 4, 1);
grid->addWidget(textLabel, 5, 0, -1, 2); grid->addWidget(textLabel, 5, 0, -1, 2);
grid->setRowStretch(5, 1); grid->setRowStretch(5, 1);
grid->setColumnStretch(1, 1);
setFrameStyle(QFrame::Panel | QFrame::Raised); setFrameStyle(QFrame::Panel | QFrame::Raised);
setCard(db->getCard());
setFixedSize(sizeHint());
} }
void CardInfoWidget::setCard(CardInfo *card) void CardInfoWidget::setCard(CardInfo *card)

24
cockatrice/src/client.cpp
View file

@ -61,7 +61,7 @@ void Client::readLine()
QStringList values = line.split("|"); QStringList values = line.split("|");
QString prefix = values.takeFirst(); QString prefix = values.takeFirst();
// prefix is one of {welcome, private, public, resp, list_games, list_players, list_counters, list_zones, dump_zone} // prefix is one of {welcome, private, public, resp, list_games, list_players, list_counters, list_zones, dump_zone}
if (!(prefix.compare("private") && prefix.compare("public"))) { if ((prefix == "private") || (prefix == "public")) {
ServerEventData event(line); ServerEventData event(line);
if (event.getEventType() == eventPlayerId) { if (event.getEventType() == eventPlayerId) {
QStringList data = event.getEventData(); QStringList data = event.getEventData();
@ -76,7 +76,7 @@ void Client::readLine()
emit playerIdReceived(id, data[1]); emit playerIdReceived(id, data[1]);
} else } else
emit gameEvent(event); emit gameEvent(event);
} else if (!prefix.compare("resp")) { } else if (prefix == "resp") {
bool ok; bool ok;
int msgid = values.takeFirst().toInt(&ok); int msgid = values.takeFirst().toInt(&ok);
if (!ok) { if (!ok) {
@ -110,16 +110,12 @@ void Client::readLine()
qDebug(QString("msgid unknown: %1").arg(msgid).toLatin1()); qDebug(QString("msgid unknown: %1").arg(msgid).toLatin1());
emit responseReceived(new ServerResponse(msgid, ok, message)); emit responseReceived(new ServerResponse(msgid, ok, message));
} else if (!(prefix.compare("list_games") } else if (prefix == "list_games") {
&& prefix.compare("list_players") emit gameListEvent(new ServerGame(values[0].toInt(), values[5], values[1], values[2].toInt(), values[3].toInt(), values[4].toInt()));
&& prefix.compare("list_counters") } else if ((prefix == "list_players") || (prefix == "list_counters") || (prefix == "list_zones") || (prefix == "dump_zone") || (prefix == "welcome")) {
&& prefix.compare("list_zones")
&& prefix.compare("dump_zone")
&& prefix.compare("welcome"))) {
int cmdid = values.takeFirst().toInt(); int cmdid = values.takeFirst().toInt();
if (!values[0].compare(".")) { if (values[0] == ".") {
QListIterator<QStringList> i(msgbuf); QListIterator<QStringList> i(msgbuf);
QList<ServerGame *> gamelist;
QList<ServerPlayer *> playerlist; QList<ServerPlayer *> playerlist;
QList<ServerZone *> zonelist; QList<ServerZone *> zonelist;
QList<ServerZoneCard *> zonedump; QList<ServerZoneCard *> zonedump;
@ -128,9 +124,7 @@ void Client::readLine()
QStringList val = i.next(); QStringList val = i.next();
// XXX Parametergültigkeit überprüfen // XXX Parametergültigkeit überprüfen
if (!prefix.compare("list_games")) if (!prefix.compare("list_players"))
gamelist << new ServerGame(val[0].toInt(), val[5], val[1], val[2].toInt(), val[3].toInt(), val[4].toInt());
else if (!prefix.compare("list_players"))
playerlist << new ServerPlayer(val[0].toInt(), val[1]); playerlist << new ServerPlayer(val[0].toInt(), val[1]);
else if (!prefix.compare("list_counters")) else if (!prefix.compare("list_counters"))
{ } { }
@ -141,9 +135,7 @@ void Client::readLine()
else if (!prefix.compare("welcome")) else if (!prefix.compare("welcome"))
welcomemsg << val[0]; welcomemsg << val[0];
} }
if (!prefix.compare("list_games")) if (!prefix.compare("list_players"))
emit gameListReceived(gamelist);
else if (!prefix.compare("list_players"))
emit playerListReceived(playerlist); emit playerListReceived(playerlist);
else if (!prefix.compare("list_counters")) else if (!prefix.compare("list_counters"))
{ } { }

2
cockatrice/src/client.h
View file

@ -26,7 +26,7 @@ class Client : public QObject {
signals: signals:
void statusChanged(ProtocolStatus _status); void statusChanged(ProtocolStatus _status);
void welcomeMsgReceived(QStringList welcomeMsg); void welcomeMsgReceived(QStringList welcomeMsg);
void gameListReceived(QList<ServerGame *> games); void gameListEvent(ServerGame *game);
void playerListReceived(QList<ServerPlayer *> players); void playerListReceived(QList<ServerPlayer *> players);
void zoneListReceived(int commandId, QList<ServerZone *> zones); void zoneListReceived(int commandId, QList<ServerZone *> zones);
void zoneDumpReceived(int commandId, QList<ServerZoneCard *> cards); void zoneDumpReceived(int commandId, QList<ServerZoneCard *> cards);

26
cockatrice/src/dlg_games.cpp
View file

@ -5,34 +5,29 @@
DlgGames::DlgGames(Client *_client, QWidget *parent) DlgGames::DlgGames(Client *_client, QWidget *parent)
: QDialog(parent), client(_client), msgid(0) : QDialog(parent), client(_client), msgid(0)
{ {
tableView = new QTreeView; gameListView = new QTreeView;
tableModel = new GamesModel(this); gameListModel = new GamesModel(this);
tableView->setModel(tableModel); gameListView->setModel(gameListModel);
createButton = new QPushButton(tr("&Create")); createButton = new QPushButton(tr("&Create"));
refreshButton = new QPushButton(tr("&Refresh"));
joinButton = new QPushButton(tr("&Join")); joinButton = new QPushButton(tr("&Join"));
QHBoxLayout *buttonLayout = new QHBoxLayout; QHBoxLayout *buttonLayout = new QHBoxLayout;
buttonLayout->addStretch();
buttonLayout->addWidget(createButton); buttonLayout->addWidget(createButton);
buttonLayout->addStretch();
buttonLayout->addWidget(refreshButton);
buttonLayout->addStretch();
buttonLayout->addWidget(joinButton); buttonLayout->addWidget(joinButton);
QVBoxLayout *mainLayout = new QVBoxLayout; QVBoxLayout *mainLayout = new QVBoxLayout;
mainLayout->addWidget(tableView); mainLayout->addWidget(gameListView);
mainLayout->addLayout(buttonLayout); mainLayout->addLayout(buttonLayout);
setLayout(mainLayout); setLayout(mainLayout);
setWindowTitle(tr("Games")); setWindowTitle(tr("Games"));
setMinimumWidth(tableView->columnWidth(0) * tableModel->columnCount()); setMinimumWidth(gameListView->columnWidth(0) * gameListModel->columnCount());
connect(createButton, SIGNAL(clicked()), this, SLOT(actCreate())); connect(createButton, SIGNAL(clicked()), this, SLOT(actCreate()));
connect(refreshButton, SIGNAL(clicked()), this, SLOT(actRefresh()));
connect(joinButton, SIGNAL(clicked()), this, SLOT(actJoin())); connect(joinButton, SIGNAL(clicked()), this, SLOT(actJoin()));
connect(client, SIGNAL(gameListReceived(QList<ServerGame *>)), this, SLOT(gameListReceived(QList<ServerGame *>))); connect(client, SIGNAL(gameListEvent(ServerGame *)), gameListModel, SLOT(updateGameList(ServerGame *)));
client->listGames(); client->listGames();
} }
@ -66,7 +61,7 @@ void DlgGames::actJoin()
if (msgid) if (msgid)
return; return;
ServerGame *game = tableModel->getGame(tableView->currentIndex().row()); ServerGame *game = gameListModel->getGame(gameListView->currentIndex().row());
QString password; QString password;
if (game->getHasPassword()) { if (game->getHasPassword()) {
bool ok; bool ok;
@ -78,8 +73,3 @@ void DlgGames::actJoin()
connect(client, SIGNAL(responseReceived(ServerResponse *)), this, SLOT(checkResponse(ServerResponse *))); connect(client, SIGNAL(responseReceived(ServerResponse *)), this, SLOT(checkResponse(ServerResponse *)));
msgid = client->joinGame(game->getGameId(), password); msgid = client->joinGame(game->getGameId(), password);
} }
void DlgGames::gameListReceived(QList<ServerGame *> _gameList)
{
tableModel->setGameList(_gameList);
}

5
cockatrice/src/dlg_games.h
View file

@ -17,14 +17,13 @@ private slots:
void actCreate(); void actCreate();
void actRefresh(); void actRefresh();
void actJoin(); void actJoin();
void gameListReceived(QList<ServerGame *> _gameList);
void checkResponse(ServerResponse *response); void checkResponse(ServerResponse *response);
private: private:
Client *client; Client *client;
int msgid; int msgid;
QTreeView *tableView; QTreeView *gameListView;
GamesModel *tableModel; GamesModel *gameListModel;
QPushButton *refreshButton, *createButton, *joinButton; QPushButton *refreshButton, *createButton, *joinButton;
}; };

2
cockatrice/src/game.cpp
View file

@ -43,7 +43,7 @@ Game::Game(CardDatabase *_db, Client *_client, QGraphicsScene *_scene, QMenu *_a
connect(aDraw, SIGNAL(triggered()), this, SLOT(actDrawCard())); connect(aDraw, SIGNAL(triggered()), this, SLOT(actDrawCard()));
aDrawCards = new QAction(tr("D&raw cards..."), this); aDrawCards = new QAction(tr("D&raw cards..."), this);
connect(aDrawCards, SIGNAL(triggered()), this, SLOT(actDrawCards())); connect(aDrawCards, SIGNAL(triggered()), this, SLOT(actDrawCards()));
aDrawCards->setShortcut(tr("Ctrl+C")); aDrawCards->setShortcut(tr("Ctrl+E"));
aRollDice = new QAction(tr("R&oll dice..."), this); aRollDice = new QAction(tr("R&oll dice..."), this);
aRollDice->setShortcut(tr("Ctrl+I")); aRollDice->setShortcut(tr("Ctrl+I"));
connect(aRollDice, SIGNAL(triggered()), this, SLOT(actRollDice())); connect(aRollDice, SIGNAL(triggered()), this, SLOT(actRollDice()));

54
cockatrice/src/gamesmodel.cpp
View file

@ -6,32 +6,19 @@ GamesModel::~GamesModel()
cleanList(); cleanList();
} }
int GamesModel::rowCount(const QModelIndex &/*parent*/) const
{
return gameList.size();
}
int GamesModel::columnCount(const QModelIndex &/*parent*/) const
{
return 5;
}
QVariant GamesModel::data(const QModelIndex &index, int role) const QVariant GamesModel::data(const QModelIndex &index, int role) const
{ {
if (!index.isValid()) if ((role != Qt::DisplayRole) || !index.isValid())
return QVariant(); return QVariant();
if ((index.row() >= gameList.size()) || (index.column() >= columnCount())) if ((index.row() >= gameList.size()) || (index.column() >= columnCount()))
return QVariant(); return QVariant();
if (role != Qt::DisplayRole)
return QVariant();
ServerGame *g = gameList.at(index.row()); ServerGame *g = gameList.at(index.row());
switch (index.column()) { switch (index.column()) {
case 0: return g->getGameId(); case 0: return g->getGameId();
case 1: return g->getCreator(); case 1: return g->getCreator();
case 2: return g->getDescription(); case 2: return g->getDescription();
case 3: return QString(g->getHasPassword() ? "yes" : "no"); case 3: return QString(g->getHasPassword() ? tr("yes") : tr("no"));
case 4: return QString("%1/%2").arg(g->getPlayerCount()).arg(g->getMaxPlayers()); case 4: return QString("%1/%2").arg(g->getPlayerCount()).arg(g->getMaxPlayers());
default: return QVariant(); default: return QVariant();
} }
@ -39,16 +26,14 @@ QVariant GamesModel::data(const QModelIndex &index, int role) const
QVariant GamesModel::headerData(int section, Qt::Orientation orientation, int role) const QVariant GamesModel::headerData(int section, Qt::Orientation orientation, int role) const
{ {
if (role != Qt::DisplayRole) if ((role != Qt::DisplayRole) || (orientation != Qt::Horizontal))
return QVariant();
if (orientation != Qt::Horizontal)
return QVariant(); return QVariant();
switch (section) { switch (section) {
case 0: return QString("Game ID"); case 0: return tr("Game ID");
case 1: return QString("Creator"); case 1: return tr("Creator");
case 2: return QString("Description"); case 2: return tr("Description");
case 3: return QString("Password"); case 3: return tr("Password");
case 4: return QString("Players"); case 4: return tr("Players");
default: return QVariant(); default: return QVariant();
} }
} }
@ -60,11 +45,26 @@ ServerGame *GamesModel::getGame(int row)
return gameList[row]; return gameList[row];
} }
void GamesModel::setGameList(const QList<ServerGame *> &_gameList) void GamesModel::updateGameList(ServerGame *game)
{ {
cleanList(); for (int i = 0; i < gameList.size(); i++)
gameList = _gameList; if (gameList[i]->getGameId() == game->getGameId()) {
reset(); if ((game->getPlayerCount() == 0) || (game->getPlayerCount() == game->getMaxPlayers())) {
beginRemoveRows(QModelIndex(), i, i);
delete gameList.takeAt(i);
endRemoveRows();
} else {
delete gameList[i];
gameList[i] = game;
emit dataChanged(index(i, 0), index(i, 4));
}
return;
}
if ((game->getPlayerCount() == 0) || (game->getPlayerCount() == game->getMaxPlayers()))
return;
beginInsertRows(QModelIndex(), gameList.size(), gameList.size());
gameList << game;
endInsertRows();
} }
void GamesModel::cleanList() void GamesModel::cleanList()

12
cockatrice/src/gamesmodel.h
View file

@ -5,19 +5,19 @@
#include <QList> #include <QList>
#include "servergame.h" #include "servergame.h"
class GamesModel : public QAbstractListModel { class GamesModel : public QAbstractTableModel {
Q_OBJECT Q_OBJECT
public: public:
GamesModel(QObject *parent = 0) GamesModel(QObject *parent = 0) : QAbstractTableModel(parent) { }
: QAbstractListModel(parent) { }
~GamesModel(); ~GamesModel();
int rowCount(const QModelIndex &parent = QModelIndex()) const; int rowCount(const QModelIndex &parent = QModelIndex()) const { return parent.isValid() ? 0 : gameList.size(); }
int columnCount(const QModelIndex &parent = QModelIndex()) const; int columnCount(const QModelIndex &/*parent*/ = QModelIndex()) const { return 5; }
QVariant data(const QModelIndex &index, int role) const; QVariant data(const QModelIndex &index, int role) const;
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const; QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
void setGameList(const QList<ServerGame *> &_gameList);
ServerGame *getGame(int row); ServerGame *getGame(int row);
public slots:
void updateGameList(ServerGame *game);
private: private:
QList<ServerGame *> gameList; QList<ServerGame *> gameList;
void cleanList(); void cleanList();

59
cockatrice/src/messagelogwidget.cpp
View file

@ -2,34 +2,28 @@
#include "game.h" #include "game.h"
#include <QScrollBar> #include <QScrollBar>
void MessageLogWidget::appendAndScroll(const QString &s)
{
append(s);
verticalScrollBar()->setValue(verticalScrollBar()->maximum());
}
void MessageLogWidget::logConnecting(QString hostname) void MessageLogWidget::logConnecting(QString hostname)
{ {
appendAndScroll(tr("Connecting to %1...").arg(hostname)); append(tr("Connecting to %1...").arg(hostname));
} }
void MessageLogWidget::logConnected(const QStringList WelcomeMsg) void MessageLogWidget::logConnected(const QStringList WelcomeMsg)
{ {
appendAndScroll(tr("Connected.")); append(tr("Connected."));
QStringListIterator i(WelcomeMsg); QStringListIterator i(WelcomeMsg);
while (i.hasNext()) while (i.hasNext())
appendAndScroll(i.next()); append(i.next());
} }
void MessageLogWidget::logDisconnected() void MessageLogWidget::logDisconnected()
{ {
appendAndScroll(tr("Disconnected from server.")); append(tr("Disconnected from server."));
} }
void MessageLogWidget::logSocketError(const QString &errorString) void MessageLogWidget::logSocketError(const QString &errorString)
{ {
appendAndScroll(errorString); append(errorString);
} }
void MessageLogWidget::logPlayerListReceived(QStringList players) void MessageLogWidget::logPlayerListReceived(QStringList players)
@ -38,96 +32,96 @@ void MessageLogWidget::logPlayerListReceived(QStringList players)
append(tr("You have joined the game. Player list:")); append(tr("You have joined the game. Player list:"));
for (int i = 0; i < players.size(); i++) for (int i = 0; i < players.size(); i++)
append(players.at(i)); append(players.at(i));
appendAndScroll("---"); append("---");
} }
void MessageLogWidget::logJoin(QString playerName) void MessageLogWidget::logJoin(QString playerName)
{ {
appendAndScroll(tr("%1 has joined the game").arg(playerName)); append(tr("%1 has joined the game").arg(playerName));
} }
void MessageLogWidget::logLeave(QString playerName) void MessageLogWidget::logLeave(QString playerName)
{ {
appendAndScroll(tr("%1 has left the game").arg(playerName)); append(tr("%1 has left the game").arg(playerName));
} }
void MessageLogWidget::logReadyStart(QString playerName) void MessageLogWidget::logReadyStart(QString playerName)
{ {
appendAndScroll(tr("%1 is ready to start a new game.").arg(playerName)); append(tr("%1 is ready to start a new game.").arg(playerName));
} }
void MessageLogWidget::logGameStart() void MessageLogWidget::logGameStart()
{ {
appendAndScroll(tr("Game has started.")); append(tr("Game has started."));
} }
void MessageLogWidget::logSay(QString playerName, QString message) void MessageLogWidget::logSay(QString playerName, QString message)
{ {
appendAndScroll(QString("<font color=\"red\">%1:</font> %2").arg(playerName).arg(message)); append(QString("<font color=\"red\">%1:</font> %2").arg(playerName).arg(message));
} }
void MessageLogWidget::logShuffle(QString playerName) void MessageLogWidget::logShuffle(QString playerName)
{ {
appendAndScroll(tr("%1 shuffles his/her library").arg(playerName)); append(tr("%1 shuffles his/her library").arg(playerName));
} }
void MessageLogWidget::logRollDice(QString playerName, int sides, int roll) void MessageLogWidget::logRollDice(QString playerName, int sides, int roll)
{ {
appendAndScroll(tr("%1 rolled a %2 with a %3-sided dice").arg(playerName).arg(roll).arg(sides)); append(tr("%1 rolled a %2 with a %3-sided dice").arg(playerName).arg(roll).arg(sides));
} }
void MessageLogWidget::logDraw(QString playerName, int number) void MessageLogWidget::logDraw(QString playerName, int number)
{ {
if (number == 1) if (number == 1)
appendAndScroll(tr("%1 draws a card").arg(playerName)); append(tr("%1 draws a card").arg(playerName));
else else
appendAndScroll(tr("%1 draws %2 cards").arg(playerName).arg(number)); append(tr("%1 draws %2 cards").arg(playerName).arg(number));
} }
void MessageLogWidget::logMoveCard(QString playerName, QString cardName, QString startZone, QString targetZone) void MessageLogWidget::logMoveCard(QString playerName, QString cardName, QString startZone, QString targetZone)
{ {
appendAndScroll(tr("%1 moves %2 from %3 to %4").arg(playerName).arg(cardName).arg(startZone).arg(targetZone)); append(tr("%1 moves %2 from %3 to %4").arg(playerName).arg(cardName).arg(startZone).arg(targetZone));
} }
void MessageLogWidget::logCreateToken(QString playerName, QString cardName) void MessageLogWidget::logCreateToken(QString playerName, QString cardName)
{ {
appendAndScroll(tr("%1 creates token: %2").arg(playerName).arg(cardName)); append(tr("%1 creates token: %2").arg(playerName).arg(cardName));
} }
void MessageLogWidget::logSetCardCounters(QString playerName, QString cardName, int value, int oldValue) void MessageLogWidget::logSetCardCounters(QString playerName, QString cardName, int value, int oldValue)
{ {
if (value > oldValue) if (value > oldValue)
appendAndScroll(tr("%1 places %2 counters on %3 (now %4)").arg(playerName).arg(value - oldValue).arg(cardName).arg(value)); append(tr("%1 places %2 counters on %3 (now %4)").arg(playerName).arg(value - oldValue).arg(cardName).arg(value));
else else
appendAndScroll(tr("%1 removes %2 counters from %3 (now %4)").arg(playerName).arg(oldValue - value).arg(cardName).arg(value)); append(tr("%1 removes %2 counters from %3 (now %4)").arg(playerName).arg(oldValue - value).arg(cardName).arg(value));
} }
void MessageLogWidget::logSetTapped(QString playerName, QString cardName, bool tapped) void MessageLogWidget::logSetTapped(QString playerName, QString cardName, bool tapped)
{ {
if (cardName == "-1") if (cardName == "-1")
cardName = tr("his permanents"); cardName = tr("his permanents");
appendAndScroll(tr("%1 %2 %3").arg(playerName).arg(tapped ? "taps" : "untaps").arg(cardName)); append(tr("%1 %2 %3").arg(playerName).arg(tapped ? "taps" : "untaps").arg(cardName));
} }
void MessageLogWidget::logSetCounter(QString playerName, QString counterName, int value, int oldValue) void MessageLogWidget::logSetCounter(QString playerName, QString counterName, int value, int oldValue)
{ {
appendAndScroll(tr("%1 sets counter \"%2\" to %3 (%4%5)").arg(playerName).arg(counterName).arg(value).arg(value > oldValue ? "+" : "").arg(value - oldValue)); append(tr("%1 sets counter \"%2\" to %3 (%4%5)").arg(playerName).arg(counterName).arg(value).arg(value > oldValue ? "+" : "").arg(value - oldValue));
} }
void MessageLogWidget::logSetDoesntUntap(QString playerName, QString cardName, bool doesntUntap) void MessageLogWidget::logSetDoesntUntap(QString playerName, QString cardName, bool doesntUntap)
{ {
if (doesntUntap) if (doesntUntap)
appendAndScroll(tr("%1 sets %2 to not untap normally.").arg(playerName).arg(cardName)); append(tr("%1 sets %2 to not untap normally.").arg(playerName).arg(cardName));
else else
appendAndScroll(tr("%1 sets %2 to untap normally.").arg(playerName).arg(cardName)); append(tr("%1 sets %2 to untap normally.").arg(playerName).arg(cardName));
} }
void MessageLogWidget::logDumpZone(QString playerName, QString zoneName, QString zoneOwner, int numberCards) void MessageLogWidget::logDumpZone(QString playerName, QString zoneName, QString zoneOwner, int numberCards)
{ {
if (numberCards) if (numberCards)
appendAndScroll(tr("%1 is looking at the top %2 cards of %3's %4").arg(playerName).arg(numberCards).arg(zoneOwner).arg(zoneName)); append(tr("%1 is looking at the top %2 cards of %3's %4").arg(playerName).arg(numberCards).arg(zoneOwner).arg(zoneName));
else else
appendAndScroll(tr("%1 is looking at %2's %3").arg(playerName).arg(zoneOwner).arg(zoneName)); append(tr("%1 is looking at %2's %3").arg(playerName).arg(zoneOwner).arg(zoneName));
} }
@ -155,4 +149,7 @@ MessageLogWidget::MessageLogWidget(QWidget *parent)
: QTextEdit(parent) : QTextEdit(parent)
{ {
setReadOnly(true); setReadOnly(true);
QFont f;
f.setPointSize(9);
setFont(f);
} }

2
cockatrice/src/messagelogwidget.h
View file

@ -30,8 +30,6 @@ private slots:
void logSetCounter(QString playerName, QString counterName, int value, int oldValue); void logSetCounter(QString playerName, QString counterName, int value, int oldValue);
void logSetDoesntUntap(QString playerName, QString cardName, bool doesntUntap); void logSetDoesntUntap(QString playerName, QString cardName, bool doesntUntap);
void logDumpZone(QString playerName, QString zoneName, QString zoneOwner, int numberCards); void logDumpZone(QString playerName, QString zoneName, QString zoneOwner, int numberCards);
private:
void appendAndScroll(const QString &s);
public: public:
void connectToGame(Game *game); void connectToGame(Game *game);
MessageLogWidget(QWidget *parent = 0); MessageLogWidget(QWidget *parent = 0);

20
servatrice/src/card.cpp
View file

@ -42,24 +42,24 @@ void Card::resetState()
bool Card::setAttribute(const QString &aname, const QString &avalue, bool allCards) bool Card::setAttribute(const QString &aname, const QString &avalue, bool allCards)
{ {
if (!aname.compare("counters")) { if (aname == "counters") {
bool ok; bool ok;
int tmp_int = avalue.toInt(&ok); int tmp_int = avalue.toInt(&ok);
if (!ok) if (!ok)
return false; return false;
setCounters(tmp_int); setCounters(tmp_int);
} else if (!aname.compare("tapped")) { } else if (aname == "tapped") {
bool value = !avalue.compare("1"); bool value = avalue == "1";
if (!(!value && allCards && doesntUntap)) if (!(!value && allCards && doesntUntap))
setTapped(value); setTapped(value);
} else if (!aname.compare("attacking")) { } else if (aname == "attacking") {
setAttacking(!avalue.compare("1")); setAttacking(avalue == "1");
} else if (!aname.compare("facedown")) { } else if (aname == "facedown") {
setFaceDown(!avalue.compare("1")); setFaceDown(avalue == "1");
} else if (!aname.compare("annotation")) { } else if (aname == "annotation") {
setAnnotation(avalue); setAnnotation(avalue);
} else if (!aname.compare("doesnt_untap")) { } else if (aname == "doesnt_untap") {
setDoesntUntap(!avalue.compare("1")); setDoesntUntap(avalue == "1");
} else } else
return false; return false;

20
servatrice/src/card.h
View file

@ -37,16 +37,16 @@ public:
Card(QString _name, int _id, int _coord_x, int _coord_y); Card(QString _name, int _id, int _coord_x, int _coord_y);
~Card(); ~Card();
int getId() { return id; } int getId() const { return id; }
int getX() { return coord_x; } int getX() const { return coord_x; }
int getY() { return coord_y; } int getY() const { return coord_y; }
QString getName() { return name; } QString getName() const { return name; }
int getCounters() { return counters; } int getCounters() const { return counters; }
bool getTapped() { return tapped; } bool getTapped() const { return tapped; }
bool getAttacking() { return attacking; } bool getAttacking() const { return attacking; }
bool getFaceDown() { return facedown; } bool getFaceDown() const { return facedown; }
QString getAnnotation() { return annotation; } QString getAnnotation() const { return annotation; }
bool getDoesntUntap() { return doesntUntap; } bool getDoesntUntap() const { return doesntUntap; }
void setId(int _id) { id = _id; } void setId(int _id) { id = _id; }
void setCoords(int x, int y) { coord_x = x; coord_y = y; } void setCoords(int x, int y) { coord_x = x; coord_y = y; }

2
servatrice/src/counter.h
View file

@ -30,7 +30,7 @@ protected:
public: public:
Counter(QString _name, int _color, int _count = 0) : name(_name), color(_color), count(_count) { } Counter(QString _name, int _color, int _count = 0) : name(_name), color(_color), count(_count) { }
~Counter() { } ~Counter() { }
int getCount() { return count; } int getCount() const { return count; }
void setCount(int _count) { count = _count; } void setCount(int _count) { count = _count; }
QString getName() const { return name; } QString getName() const { return name; }
}; };

5
servatrice/src/returnmessage.cpp
View file

@ -1,11 +1,6 @@
#include "returnmessage.h" #include "returnmessage.h"
#include "serversocket.h" #include "serversocket.h"
void ReturnMessage::setMsgId(unsigned int _msg_id)
{
msg_id = _msg_id;
}
bool ReturnMessage::send(ReturnCode code) bool ReturnMessage::send(ReturnCode code)
{ {
ServerSocket *s = qobject_cast<ServerSocket *>(parent()); ServerSocket *s = qobject_cast<ServerSocket *>(parent());

2
servatrice/src/returnmessage.h
View file

@ -12,7 +12,7 @@ public:
enum ReturnCode { ReturnNothing, ReturnOk, ReturnLoginNeeded, ReturnSyntaxError, ReturnContextError, ReturnPasswordWrong, ReturnNameNotFound }; enum ReturnCode { ReturnNothing, ReturnOk, ReturnLoginNeeded, ReturnSyntaxError, ReturnContextError, ReturnPasswordWrong, ReturnNameNotFound };
ReturnMessage(QObject *parent = 0) : QObject(parent), msg_id(0) { } ReturnMessage(QObject *parent = 0) : QObject(parent), msg_id(0) { }
unsigned int getMsgId() const { return msg_id; } unsigned int getMsgId() const { return msg_id; }
void setMsgId(unsigned int _msg_id); void setMsgId(unsigned int _msg_id) { msg_id = _msg_id; }
void setCmd(const QString &_cmd) { cmd = _cmd; } void setCmd(const QString &_cmd) { cmd = _cmd; }
bool send(ReturnCode code); bool send(ReturnCode code);
bool sendList(const QStringList &args); bool sendList(const QStringList &args);

36
servatrice/src/server.cpp
View file

@ -71,10 +71,12 @@ bool Server::openDatabase()
void Server::addGame(const QString description, const QString password, const int maxPlayers, ServerSocket *creator) void Server::addGame(const QString description, const QString password, const int maxPlayers, ServerSocket *creator)
{ {
ServerGame *newGame = new ServerGame(creator, nextGameId++, description, password, maxPlayers); ServerGame *newGame = new ServerGame(creator, nextGameId++, description, password, maxPlayers, this);
games << newGame; games << newGame;
connect(newGame, SIGNAL(gameClosing()), this, SLOT(gameClosing())); connect(newGame, SIGNAL(gameClosing()), this, SLOT(gameClosing()));
newGame->addPlayer(creator); newGame->addPlayer(creator);
broadcastGameListUpdate(newGame);
} }
void Server::incomingConnection(int socketId) void Server::incomingConnection(int socketId)
@ -83,7 +85,9 @@ void Server::incomingConnection(int socketId)
socket->setSocketDescriptor(socketId); socket->setSocketDescriptor(socketId);
connect(socket, SIGNAL(createGame(const QString, const QString, const int, ServerSocket *)), this, SLOT(addGame(const QString, const QString, const int, ServerSocket *))); connect(socket, SIGNAL(createGame(const QString, const QString, const int, ServerSocket *)), this, SLOT(addGame(const QString, const QString, const int, ServerSocket *)));
connect(socket, SIGNAL(joinGame(int, ServerSocket *)), this, SLOT(addClientToGame(int, ServerSocket *))); connect(socket, SIGNAL(joinGame(int, ServerSocket *)), this, SLOT(addClientToGame(int, ServerSocket *)));
connect(socket, SIGNAL(destroyed(QObject *)), this, SLOT(socketDestroyed(QObject *)));
socket->initConnection(); socket->initConnection();
players << socket;
} }
AuthenticationResult Server::checkUserPassword(const QString &user, const QString &password) AuthenticationResult Server::checkUserPassword(const QString &user, const QString &password)
@ -118,7 +122,7 @@ ServerGame *Server::getGame(int gameId)
QListIterator<ServerGame *> i(games); QListIterator<ServerGame *> i(games);
while (i.hasNext()) { while (i.hasNext()) {
ServerGame *tmp = i.next(); ServerGame *tmp = i.next();
if ((tmp->gameId == gameId) && !tmp->getGameStarted()) if ((tmp->getGameId() == gameId) && !tmp->getGameStarted())
return tmp; return tmp;
} }
return NULL; return NULL;
@ -131,7 +135,7 @@ QList<ServerGame *> Server::listOpenGames()
while (i.hasNext()) { while (i.hasNext()) {
ServerGame *tmp = i.next(); ServerGame *tmp = i.next();
if ((!tmp->getGameStarted()) if ((!tmp->getGameStarted())
&& (tmp->getPlayerCount() < tmp->maxPlayers)) && (tmp->getPlayerCount() < tmp->getMaxPlayers()))
result.append(tmp); result.append(tmp);
} }
return result; return result;
@ -141,23 +145,35 @@ bool Server::checkGamePassword(int gameId, const QString &password)
{ {
ServerGame *tmp; ServerGame *tmp;
if ((tmp = getGame(gameId))) { if ((tmp = getGame(gameId))) {
if ((!tmp->getGameStarted()) if ((!tmp->getGameStarted()) && (tmp->getPassword() == password) && (tmp->getPlayerCount() < tmp->getMaxPlayers()))
&& (!tmp->password.compare(password, Qt::CaseSensitive))
&& (tmp->getPlayerCount() < tmp->maxPlayers))
return true; return true;
} }
return false; return false;
} }
void Server::broadcastGameListUpdate(ServerGame *game)
{
QString line = game->getGameListLine();
for (int i = 0; i < players.size(); i++)
if (players[i]->getAcceptsGameListChanges())
players[i]->msg(line);
}
void Server::addClientToGame(int gameId, ServerSocket *client) void Server::addClientToGame(int gameId, ServerSocket *client)
{ {
ServerGame *tmp = getGame(gameId); ServerGame *game = getGame(gameId);
tmp->addPlayer(client); game->addPlayer(client);
broadcastGameListUpdate(game);
} }
void Server::gameClosing() void Server::gameClosing()
{ {
qDebug("Server::gameClosing"); qDebug("Server::gameClosing");
ServerGame *g = qobject_cast<ServerGame *>(sender()); games.removeAt(games.indexOf(static_cast<ServerGame *>(sender())));
games.removeAt(games.indexOf(g)); }
void Server::socketDestroyed(QObject *obj)
{
players.removeAt(players.indexOf(static_cast<ServerSocket *>(obj)));
qDebug(QString("Server::socketDestroyed: %1 players left").arg(players.size()).toLatin1());
} }

3
servatrice/src/server.h
View file

@ -37,6 +37,7 @@ private slots:
void addGame(const QString description, const QString password, const int maxPlayers, ServerSocket *creator); void addGame(const QString description, const QString password, const int maxPlayers, ServerSocket *creator);
void addClientToGame(int gameId, ServerSocket *client); void addClientToGame(int gameId, ServerSocket *client);
void gameClosing(); void gameClosing();
void socketDestroyed(QObject *obj);
public: public:
Server(QObject *parent = 0); Server(QObject *parent = 0);
~Server(); ~Server();
@ -47,9 +48,11 @@ public:
QList<ServerGame *> listOpenGames(); QList<ServerGame *> listOpenGames();
ServerGame *getGame(int gameId); ServerGame *getGame(int gameId);
AbstractRNG *getRNG() const { return rng; } AbstractRNG *getRNG() const { return rng; }
void broadcastGameListUpdate(ServerGame *game);
private: private:
void incomingConnection(int SocketId); void incomingConnection(int SocketId);
QList<ServerGame *> games; QList<ServerGame *> games;
QList<ServerSocket *> players;
int nextGameId; int nextGameId;
AbstractRNG *rng; AbstractRNG *rng;
}; };

31
servatrice/src/servergame.cpp
View file

@ -17,12 +17,13 @@
* Free Software Foundation, Inc., * * Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#include "server.h"
#include "servergame.h" #include "servergame.h"
#include "serversocket.h" #include "serversocket.h"
#include <QSqlQuery> #include <QSqlQuery>
ServerGame::ServerGame(ServerSocket *_creator, int _gameId, QString _description, QString _password, int _maxPlayers, QObject *parent) ServerGame::ServerGame(ServerSocket *_creator, int _gameId, const QString &_description, const QString &_password, int _maxPlayers, QObject *parent)
: QObject(parent), gameStarted(false), creator(_creator), gameId(_gameId), description(_description), password(_password), maxPlayers(_maxPlayers) : QObject(parent), creator(_creator), gameStarted(false), gameId(_gameId), description(_description), password(_password), maxPlayers(_maxPlayers)
{ {
} }
@ -32,23 +33,23 @@ ServerGame::~ServerGame()
qDebug("ServerGame destructor"); qDebug("ServerGame destructor");
} }
bool ServerGame::getGameStarted() QString ServerGame::getGameListLine() const
{ {
return gameStarted; return QString("list_games|%1|%2|%3|%4|%5|%6").arg(gameId)
.arg(description)
.arg(password.isEmpty() ? 0 : 1)
.arg(players.size())
.arg(maxPlayers)
.arg(creator->getPlayerName());
} }
int ServerGame::getPlayerCount() QStringList ServerGame::getPlayerNames() const
{
return players.size();
}
QStringList ServerGame::getPlayerNames()
{ {
QStringList result; QStringList result;
QListIterator<ServerSocket *> i(players); QListIterator<ServerSocket *> i(players);
while (i.hasNext()) { while (i.hasNext()) {
ServerSocket *tmp = i.next(); ServerSocket *tmp = i.next();
result << QString("%1|%2").arg(tmp->getPlayerId()).arg(tmp->PlayerName); result << QString("%1|%2").arg(tmp->getPlayerId()).arg(tmp->getPlayerName());
} }
return result; return result;
} }
@ -74,7 +75,7 @@ void ServerGame::msg(const QString &s)
void ServerGame::broadcastEvent(const QString &cmd, ServerSocket *player) void ServerGame::broadcastEvent(const QString &cmd, ServerSocket *player)
{ {
if (player) if (player)
msg(QString("public|%1|%2|%3").arg(player->getPlayerId()).arg(player->PlayerName).arg(cmd)); msg(QString("public|%1|%2|%3").arg(player->getPlayerId()).arg(player->getPlayerName()).arg(cmd));
else else
msg(QString("public|||%1").arg(cmd)); msg(QString("public|||%1").arg(cmd));
} }
@ -97,7 +98,7 @@ void ServerGame::startGameIfReady()
for (int i = 0; i < players.size(); i++) { for (int i = 0; i < players.size(); i++) {
query.prepare("insert into games_players (id_game, player) values(:id, :player)"); query.prepare("insert into games_players (id_game, player) values(:id, :player)");
query.bindValue(":id", gameId); query.bindValue(":id", gameId);
query.bindValue(":player", players.at(i)->PlayerName); query.bindValue(":player", players.at(i)->getPlayerName());
query.exec(); query.exec();
} }
@ -122,7 +123,7 @@ void ServerGame::addPlayer(ServerSocket *player)
player->setPlayerId(max + 1); player->setPlayerId(max + 1);
player->setGame(this); player->setGame(this);
player->msg(QString("private|||player_id|%1|%2").arg(max + 1).arg(player->PlayerName)); player->msg(QString("private|||player_id|%1|%2").arg(max + 1).arg(player->getPlayerName()));
broadcastEvent("join", player); broadcastEvent("join", player);
players << player; players << player;
@ -136,6 +137,8 @@ void ServerGame::removePlayer(ServerSocket *player)
broadcastEvent("leave", player); broadcastEvent("leave", player);
if (!players.size()) if (!players.size())
deleteLater(); deleteLater();
if (!gameStarted)
qobject_cast<Server *>(parent())->broadcastGameListUpdate(this);
} }
void ServerGame::setActivePlayer(int _activePlayer) void ServerGame::setActivePlayer(int _activePlayer)

31
servatrice/src/servergame.h
View file

@ -27,32 +27,37 @@ class ServerSocket;
class ServerGame : public QObject { class ServerGame : public QObject {
Q_OBJECT Q_OBJECT
private: private:
ServerSocket *creator;
QList<ServerSocket *> players; QList<ServerSocket *> players;
bool gameStarted; bool gameStarted;
int activePlayer; int gameId;
int activePhase; QString description;
QString password;
int maxPlayers;
int activePlayer, activePhase;
signals: signals:
void gameClosing(); void gameClosing();
public slots: public slots:
void broadcastEvent(const QString &event, ServerSocket *player); void broadcastEvent(const QString &event, ServerSocket *player);
public: public:
ServerSocket *creator; ServerGame(ServerSocket *_creator, int _gameId, const QString &_description, const QString &_password, int _maxPlayers, QObject *parent = 0);
int gameId;
QString description;
QString password;
int maxPlayers;
ServerGame(ServerSocket *_creator, int _gameId, QString _description, QString _password, int _maxPlayers, QObject *parent = 0);
~ServerGame(); ~ServerGame();
bool getGameStarted(); ServerSocket *getCreator() const { return creator; }
int getPlayerCount(); bool getGameStarted() const { return gameStarted; }
QStringList getPlayerNames(); int getPlayerCount() const { return players.size(); }
int getGameId() const { return gameId; }
QString getDescription() const { return description; }
QString getPassword() const { return password; }
int getMaxPlayers() const { return maxPlayers; }
QString getGameListLine() const;
QStringList getPlayerNames() const;
ServerSocket *getPlayer(int player_id); ServerSocket *getPlayer(int player_id);
void addPlayer(ServerSocket *player); void addPlayer(ServerSocket *player);
void removePlayer(ServerSocket *player); void removePlayer(ServerSocket *player);
void startGameIfReady(); void startGameIfReady();
void msg(const QString &s); void msg(const QString &s);
int getActivePlayer() { return activePlayer; } int getActivePlayer() const { return activePlayer; }
int getActivePhase() { return activePhase; } int getActivePhase() const { return activePhase; }
void setActivePlayer(int _activePlayer); void setActivePlayer(int _activePlayer);
void setActivePhase(int _activePhase); void setActivePhase(int _activePhase);
}; };

59
servatrice/src/serversocket.cpp
View file

@ -30,14 +30,13 @@
#include "abstractrng.h" #include "abstractrng.h"
ServerSocket::ServerSocket(Server *_server, QObject *parent) ServerSocket::ServerSocket(Server *_server, QObject *parent)
: QTcpSocket(parent), server(_server), game(0), authState(PasswordWrong) : QTcpSocket(parent), server(_server), game(0), PlayerStatus(StatusNormal), authState(PasswordWrong), acceptsGameListChanges(false)
{ {
remsg = new ReturnMessage(this); remsg = new ReturnMessage(this);
connect(this, SIGNAL(readyRead()), this, SLOT(readClient())); connect(this, SIGNAL(readyRead()), this, SLOT(readClient()));
connect(this, SIGNAL(disconnected()), this, SLOT(deleteLater())); connect(this, SIGNAL(disconnected()), this, SLOT(deleteLater()));
connect(this, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(catchSocketError(QAbstractSocket::SocketError))); connect(this, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(catchSocketError(QAbstractSocket::SocketError)));
setTextModeEnabled(true); setTextModeEnabled(true);
PlayerStatus = StatusNormal;
} }
ServerSocket::~ServerSocket() ServerSocket::~ServerSocket()
@ -52,29 +51,23 @@ int ServerSocket::newCardId()
return nextCardId++; return nextCardId++;
} }
void ServerSocket::setName(const QString &name) PlayerZone *ServerSocket::getZone(const QString &name) const
{
emit broadcastEvent(QString("name|%1|%2").arg(PlayerName).arg(name), this);
PlayerName = name;
}
PlayerZone *ServerSocket::getZone(const QString &name)
{ {
QListIterator<PlayerZone *> ZoneIterator(zones); QListIterator<PlayerZone *> ZoneIterator(zones);
while (ZoneIterator.hasNext()) { while (ZoneIterator.hasNext()) {
PlayerZone *temp = ZoneIterator.next(); PlayerZone *temp = ZoneIterator.next();
if (!temp->getName().compare(name)) if (temp->getName() == name)
return temp; return temp;
} }
return NULL; return NULL;
} }
Counter *ServerSocket::getCounter(const QString &name) Counter *ServerSocket::getCounter(const QString &name) const
{ {
QListIterator<Counter *> CounterIterator(counters); QListIterator<Counter *> CounterIterator(counters);
while (CounterIterator.hasNext()) { while (CounterIterator.hasNext()) {
Counter *temp = CounterIterator.next(); Counter *temp = CounterIterator.next();
if (!temp->getName().compare(name)) if (temp->getName() == name)
return temp; return temp;
} }
return NULL; return NULL;
@ -137,7 +130,6 @@ void ServerSocket::leaveGame()
game = 0; game = 0;
PlayerStatus = StatusNormal; PlayerStatus = StatusNormal;
clearZones(); clearZones();
moveToThread(server->thread());
} }
void ServerSocket::readClient() void ServerSocket::readClient()
@ -156,7 +148,7 @@ void ServerSocket::readClient()
break; break;
case StatusSubmitDeck: case StatusSubmitDeck:
QString card = line; QString card = line;
if (!card.compare(".")) { if (card == ".") {
PlayerStatus = StatusNormal; PlayerStatus = StatusNormal;
remsg->send(ReturnMessage::ReturnOk); remsg->send(ReturnMessage::ReturnOk);
} else if (card.startsWith("SB:")) } else if (card.startsWith("SB:"))
@ -229,27 +221,19 @@ ReturnMessage::ReturnCode ServerSocket::cmdLogin(const QList<QVariant> &params)
authState = server->checkUserPassword(params[0].toString(), params[1].toString()); authState = server->checkUserPassword(params[0].toString(), params[1].toString());
if (authState == PasswordWrong) if (authState == PasswordWrong)
return ReturnMessage::ReturnPasswordWrong; return ReturnMessage::ReturnPasswordWrong;
PlayerName = params[0].toString(); playerName = params[0].toString();
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdListGames(const QList<QVariant> &params) ReturnMessage::ReturnCode ServerSocket::cmdListGames(const QList<QVariant> &/*params*/)
{ {
Q_UNUSED(params);
QList<ServerGame *> gameList = server->listOpenGames(); QList<ServerGame *> gameList = server->listOpenGames();
QListIterator<ServerGame *> gameListIterator(gameList); QListIterator<ServerGame *> gameListIterator(gameList);
QStringList result; while (gameListIterator.hasNext())
while (gameListIterator.hasNext()) { msg(gameListIterator.next()->getGameListLine());
ServerGame *tmp = gameListIterator.next();
result << QString("%1|%2|%3|%4|%5|%6").arg(tmp->gameId) acceptsGameListChanges = true;
.arg(tmp->description)
.arg(tmp->password == "" ? 0 : 1)
.arg(tmp->getPlayerCount())
.arg(tmp->maxPlayers)
.arg(tmp->creator->PlayerName);
}
remsg->sendList(result);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
@ -260,6 +244,7 @@ ReturnMessage::ReturnCode ServerSocket::cmdCreateGame(const QList<QVariant> &par
int maxPlayers = params[2].toInt(); int maxPlayers = params[2].toInt();
leaveGame(); leaveGame();
emit createGame(description, password, maxPlayers, this); emit createGame(description, password, maxPlayers, this);
acceptsGameListChanges = false;
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
@ -271,19 +256,18 @@ ReturnMessage::ReturnCode ServerSocket::cmdJoinGame(const QList<QVariant> &param
return ReturnMessage::ReturnPasswordWrong; return ReturnMessage::ReturnPasswordWrong;
leaveGame(); leaveGame();
emit joinGame(gameId, this); emit joinGame(gameId, this);
acceptsGameListChanges = false;
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdLeaveGame(const QList<QVariant> &params) ReturnMessage::ReturnCode ServerSocket::cmdLeaveGame(const QList<QVariant> &/*params*/)
{ {
Q_UNUSED(params);
leaveGame(); leaveGame();
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdListPlayers(const QList<QVariant> &params) ReturnMessage::ReturnCode ServerSocket::cmdListPlayers(const QList<QVariant> &/*params*/)
{ {
Q_UNUSED(params);
remsg->sendList(game->getPlayerNames()); remsg->sendList(game->getPlayerNames());
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
@ -294,27 +278,24 @@ ReturnMessage::ReturnCode ServerSocket::cmdSay(const QList<QVariant> &params)
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdSubmitDeck(const QList<QVariant> &params) ReturnMessage::ReturnCode ServerSocket::cmdSubmitDeck(const QList<QVariant> &/*params*/)
{ {
Q_UNUSED(params);
PlayerStatus = StatusSubmitDeck; PlayerStatus = StatusSubmitDeck;
DeckList.clear(); DeckList.clear();
SideboardList.clear(); SideboardList.clear();
return ReturnMessage::ReturnNothing; return ReturnMessage::ReturnNothing;
} }
ReturnMessage::ReturnCode ServerSocket::cmdReadyStart(const QList<QVariant> &params) ReturnMessage::ReturnCode ServerSocket::cmdReadyStart(const QList<QVariant> &/*params*/)
{ {
Q_UNUSED(params);
PlayerStatus = StatusReadyStart; PlayerStatus = StatusReadyStart;
emit broadcastEvent(QString("ready_start"), this); emit broadcastEvent(QString("ready_start"), this);
game->startGameIfReady(); game->startGameIfReady();
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdShuffle(const QList<QVariant> &params) ReturnMessage::ReturnCode ServerSocket::cmdShuffle(const QList<QVariant> &/*params*/)
{ {
Q_UNUSED(params);
getZone("deck")->shuffle(server->getRNG()); getZone("deck")->shuffle(server->getRNG());
emit broadcastEvent("shuffle", this); emit broadcastEvent("shuffle", this);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
@ -545,7 +526,7 @@ ReturnMessage::ReturnCode ServerSocket::cmdDumpZone(const QList<QVariant> &param
PlayerZone *zone = player->getZone(params[1].toString()); PlayerZone *zone = player->getZone(params[1].toString());
if (!zone) if (!zone)
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
if (!(zone->isPublic() || (player_id == PlayerId))) if (!(zone->isPublic() || (player_id == playerId)))
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
QListIterator<Card *> card_iterator(zone->cards); QListIterator<Card *> card_iterator(zone->cards);

16
servatrice/src/serversocket.h
View file

@ -91,20 +91,20 @@ private:
QList<QString> SideboardList; QList<QString> SideboardList;
QList<PlayerZone *> zones; QList<PlayerZone *> zones;
QList<Counter *> counters; QList<Counter *> counters;
int PlayerId; int playerId;
QString playerName;
int nextCardId; int nextCardId;
int newCardId(); int newCardId();
PlayerZone *getZone(const QString &name); PlayerZone *getZone(const QString &name) const;
Counter *getCounter(const QString &name); Counter *getCounter(const QString &name) const;
void setName(const QString &name);
void clearZones(); void clearZones();
void leaveGame(); void leaveGame();
bool parseCommand(QString line); bool parseCommand(QString line);
PlayerStatusEnum PlayerStatus; PlayerStatusEnum PlayerStatus;
ReturnMessage *remsg; ReturnMessage *remsg;
AuthenticationResult authState; AuthenticationResult authState;
bool acceptsGameListChanges;
public: public:
QString PlayerName;
ServerSocket(Server *_server, QObject *parent = 0); ServerSocket(Server *_server, QObject *parent = 0);
~ServerSocket(); ~ServerSocket();
void msg(const QString &s); void msg(const QString &s);
@ -112,8 +112,10 @@ public:
PlayerStatusEnum getStatus(); PlayerStatusEnum getStatus();
void setStatus(PlayerStatusEnum status); void setStatus(PlayerStatusEnum status);
void initConnection(); void initConnection();
int getPlayerId() { return PlayerId; } int getPlayerId() const { return playerId; }
void setPlayerId(int _id) { PlayerId = _id; } void setPlayerId(int _id) { playerId = _id; }
QString getPlayerName() const { return playerName; }
bool getAcceptsGameListChanges() const { return acceptsGameListChanges; }
QStringList listCounters(); QStringList listCounters();
QStringList listZones(); QStringList listZones();
void setupZones(); void setupZones();