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

small cleanups

Browse source
This commit is contained in:
Max-Wilhelm Bruker 2009-09-23 16:00:44 +02:00
parent 890740bcc9
commit fa16d86283
27 changed files with 616 additions and 497 deletions
Download patch file Download diff file Expand all files Collapse all files

7
cockatrice/src/chatwidget.cpp
View file

@ -212,8 +212,7 @@ void ChatWidget::chatEvent(const ChatEventData &data)
void ChatWidget::joinChannel(const QString &channelName)
{
PendingCommand *pc = client->chatJoinChannel(channelName);
pc->setExtraData(channelName);
PendingCommand_ChatJoinChannel *pc = client->chatJoinChannel(channelName);
connect(pc, SIGNAL(finished(ServerResponse)), this, SLOT(joinFinished(ServerResponse)));
}
@ -234,8 +233,8 @@ void ChatWidget::joinFinished(ServerResponse resp)
if (resp != RespOk)
return;
PendingCommand *pc = qobject_cast<PendingCommand *>(sender());
QString channelName = pc->getExtraData();
PendingCommand_ChatJoinChannel *pc = qobject_cast<PendingCommand_ChatJoinChannel *>(sender());
QString channelName = pc->getChannelName();
ChannelWidget *cw = new ChannelWidget(client, channelName);
tab->addTab(cw, channelName);
}

1
cockatrice/src/chatwidget.h
View file

@ -2,7 +2,6 @@
#define CHATWIDGET_H
#include <QWidget>
#include "servereventdata.h"
#include "client.h"
class QListWidget;

255
cockatrice/src/client.cpp
View file

@ -1,17 +1,74 @@
#include <QTimer>
#include "client.h"
PendingCommand::PendingCommand(const QString &_cmd, int _msgid, QObject *parent)
: QObject(parent), cmd(_cmd), msgid(_msgid), time(0)
// Message structure for server events:
// {"private","public"}|PlayerId|PlayerName|EventType|EventData
QHash<QString, ServerEventType> ServerEventData::eventHash;
ServerEventData::ServerEventData(const QString &line)
{
if (eventHash.isEmpty()) {
eventHash.insert("player_id", eventPlayerId);
eventHash.insert("say", eventSay);
eventHash.insert("name", eventName);
eventHash.insert("join", eventJoin);
eventHash.insert("leave", eventLeave);
eventHash.insert("ready_start", eventReadyStart);
eventHash.insert("setup_zones", eventSetupZones);
eventHash.insert("game_start", eventGameStart);
eventHash.insert("shuffle", eventShuffle);
eventHash.insert("roll_die", eventRollDie);
eventHash.insert("draw", eventDraw);
eventHash.insert("move_card", eventMoveCard);
eventHash.insert("create_token", eventCreateToken);
eventHash.insert("set_card_attr", eventSetCardAttr);
eventHash.insert("add_counter", eventAddCounter);
eventHash.insert("set_counter", eventSetCounter);
eventHash.insert("del_counter", eventDelCounter);
eventHash.insert("set_active_player", eventSetActivePlayer);
eventHash.insert("set_active_phase", eventSetActivePhase);
eventHash.insert("dump_zone", eventDumpZone);
eventHash.insert("stop_dump_zone", eventStopDumpZone);
}
QStringList values = line.split('|');
IsPublic = !values.takeFirst().compare("public");
PlayerId = values.takeFirst().toInt();
PlayerName = values.takeFirst();
EventType = eventHash.value(values.takeFirst(), eventInvalid);
EventData = values;
}
QHash<QString, ChatEventType> ChatEventData::eventHash;
ChatEventData::ChatEventData(const QString &line)
{
if (eventHash.isEmpty()) {
eventHash.insert("list_channels", eventChatListChannels);
eventHash.insert("join_channel", eventChatJoinChannel);
eventHash.insert("list_players", eventChatListPlayers);
eventHash.insert("leave_channel", eventChatLeaveChannel);
eventHash.insert("say", eventChatSay);
eventHash.insert("server_message", eventChatServerMessage);
}
QStringList values = line.split('|');
values.removeFirst();
eventType = eventHash.value(values.takeFirst(), eventChatInvalid);
eventData = values;
}
PendingCommand::PendingCommand(int _msgid)
: QObject(), msgid(_msgid), time(0)
{
}
void PendingCommand::responseReceived(int _msgid, ServerResponse _resp)
void PendingCommand::responseReceived(ServerResponse resp)
{
if (_msgid == msgid) {
emit finished(_resp);
deleteLater();
}
emit finished(resp);
deleteLater();
}
void PendingCommand::checkTimeout()
@ -20,6 +77,54 @@ void PendingCommand::checkTimeout()
emit timeout();
}
void PendingCommand_ListPlayers::responseReceived(ServerResponse resp)
{
if (resp == RespOk)
emit playerListReceived(playerList);
PendingCommand::responseReceived(resp);
}
void PendingCommand_ListPlayers::addPlayer(const ServerPlayer &player)
{
playerList.append(player);
}
void PendingCommand_ListZones::responseReceived(ServerResponse resp)
{
if (resp == RespOk)
emit zoneListReceived(zoneList);
PendingCommand::responseReceived(resp);
}
void PendingCommand_ListZones::addZone(const ServerZone &zone)
{
zoneList.append(zone);
}
void PendingCommand_DumpZone::responseReceived(ServerResponse resp)
{
if (resp == RespOk)
emit cardListReceived(cardList);
PendingCommand::responseReceived(resp);
}
void PendingCommand_DumpZone::addCard(const ServerZoneCard &card)
{
cardList.append(card);
}
void PendingCommand_ListCounters::responseReceived(ServerResponse resp)
{
if (resp == RespOk)
emit counterListReceived(counterList);
PendingCommand::responseReceived(resp);
}
void PendingCommand_ListCounters::addCounter(const ServerCounter &counter)
{
counterList.append(counter);
}
Client::Client(QObject *parent)
: QObject(parent), status(StatusDisconnected), MsgId(0)
{
@ -59,7 +164,7 @@ void Client::slotConnected()
void Client::removePendingCommand()
{
PendingCommands.removeAt(PendingCommands.indexOf(static_cast<PendingCommand *>(sender())));
pendingCommands.remove(static_cast<PendingCommand *>(sender())->getMsgId());
}
void Client::loginResponse(ServerResponse response)
@ -114,14 +219,16 @@ void Client::readLine()
emit chatEvent(ChatEventData(line));
} else if (prefix == "resp") {
if (values.size() != 2) {
// XXX
qDebug("Client::parseCommand: Invalid response");
continue;
}
bool ok;
int msgid = values.takeFirst().toInt(&ok);
if (!ok) {
// XXX
PendingCommand *pc = pendingCommands.value(msgid, 0);
if (!ok || !pc) {
qDebug("Client::parseCommand: Invalid msgid");
continue;
}
ServerResponse resp;
if (values[0] == "ok")
resp = RespOk;
@ -129,14 +236,14 @@ void Client::readLine()
resp = RespPassword;
else
resp = RespErr;
emit responseReceived(msgid, resp);
pc->responseReceived(resp);
} else if (prefix == "list_games") {
if (values.size() != 8)
return;
continue;
emit gameListEvent(new ServerGame(values[0].toInt(), values[5], values[1], values[2].toInt(), values[3].toInt(), values[4].toInt(), values[6].toInt(), values[7].toInt()));
} else if (prefix == "welcome") {
if (values.size() != 2) {
emit protocolVersionMismatch();
emit protocolError();
disconnectFromServer();
} else if (values[0].toInt() != protocolVersion) {
emit protocolVersionMismatch();
@ -146,40 +253,45 @@ void Client::readLine()
setStatus(StatusLoggingIn);
login(playerName, password);
}
} else if ((prefix == "list_players") || (prefix == "list_counters") || (prefix == "list_zones") || (prefix == "dump_zone")) {
} else if (prefix == "list_players") {
if (values.size() != 4) {
emit protocolError();
continue;
}
int cmdid = values.takeFirst().toInt();
if (values[0] == ".") {
QListIterator<QStringList> i(msgbuf);
QList<ServerPlayer *> playerlist;
QList<ServerZone *> zonelist;
QList<ServerZoneCard *> zonedump;
while (i.hasNext()) {
QStringList val = i.next();
// XXX Parametergültigkeit überprüfen
if (prefix == "list_players")
playerlist << new ServerPlayer(val[0].toInt(), val[1], val[2].toInt());
else if (prefix == "list_counters")
{ }
else if (prefix == "list_zones")
zonelist << new ServerZone(val[0], val[1] == "1", val[2] == "1", val[3].toInt());
else if (prefix == "dump_zone")
zonedump << new ServerZoneCard(val[0].toInt(), val[1], val[2].toInt(), val[3].toInt(), val[4].toInt(), val[5] == "1", val[6]);
}
if (prefix == "list_players")
emit playerListReceived(playerlist);
else if (prefix == "list_counters")
{ }
else if (prefix == "list_zones")
emit zoneListReceived(cmdid, zonelist);
else if (prefix == "dump_zone")
emit zoneDumpReceived(cmdid, zonedump);
msgbuf.clear();
} else
msgbuf << values;
} else {
// XXX
}
PendingCommand_ListPlayers *pc = qobject_cast<PendingCommand_ListPlayers *>(pendingCommands.value(cmdid, 0));
if (!pc) {
emit protocolError();
continue;
}
pc->addPlayer(ServerPlayer(values[0].toInt(), values[1], values[2].toInt()));
} else if (prefix == "dump_zone") {
if (values.size() != 9) {
emit protocolError();
continue;
}
int cmdid = values.takeFirst().toInt();
PendingCommand_DumpZone *pc = qobject_cast<PendingCommand_DumpZone *>(pendingCommands.value(cmdid, 0));
if (!pc) {
emit protocolError();
continue;
}
pc->addCard(ServerZoneCard(values[0].toInt(), values[1], values[2].toInt(), values[3].toInt(), values[4].toInt(), values[5] == "1", values[6] == "1", values[7]));
} else if (prefix == "list_zones") {
if (values.size() != 5) {
emit protocolError();
continue;
}
int cmdid = values.takeFirst().toInt();
PendingCommand_ListZones *pc = qobject_cast<PendingCommand_ListZones *>(pendingCommands.value(cmdid, 0));
if (!pc) {
emit protocolError();
continue;
}
pc->addZone(ServerZone(values[0], values[1] == "1", values[2] == "1", values[3].toInt()));
} else if (prefix == "list_counters") {
} else
emit protocolError();
}
}
@ -200,12 +312,16 @@ void Client::msg(const QString &s)
stream.flush();
}
PendingCommand *Client::cmd(const QString &s)
PendingCommand *Client::cmd(const QString &s, PendingCommand *_pc)
{
msg(QString("%1|%2").arg(++MsgId).arg(s));
PendingCommand *pc = new PendingCommand(s, MsgId, this);
PendingCommands << pc;
connect(this, SIGNAL(responseReceived(int, ServerResponse)), pc, SLOT(responseReceived(int, ServerResponse)));
PendingCommand *pc;
if (_pc) {
pc = _pc;
pc->setMsgId(MsgId);
} else
pc = new PendingCommand(MsgId);
pendingCommands.insert(MsgId, pc);
connect(pc, SIGNAL(finished(ServerResponse)), this, SLOT(removePendingCommand()));
connect(pc, SIGNAL(timeout()), this, SLOT(timeout()));
connect(timer, SIGNAL(timeout()), pc, SLOT(checkTimeout()));
@ -226,9 +342,10 @@ void Client::disconnectFromServer()
{
timer->stop();
for (int i = 0; i < PendingCommands.size(); i++)
delete PendingCommands[i];
PendingCommands.clear();
QList<PendingCommand *> pc = pendingCommands.values();
for (int i = 0; i < pc.size(); i++)
delete pc[i];
pendingCommands.clear();
setStatus(StatusDisconnected);
socket->close();
@ -244,9 +361,9 @@ PendingCommand *Client::chatListChannels()
return cmd("chat_list_channels");
}
PendingCommand *Client::chatJoinChannel(const QString &name)
PendingCommand_ChatJoinChannel *Client::chatJoinChannel(const QString &name)
{
return cmd(QString("chat_join_channel|%1").arg(name));
return static_cast<PendingCommand_ChatJoinChannel *>(cmd(QString("chat_join_channel|%1").arg(name), new PendingCommand_ChatJoinChannel(name)));
}
PendingCommand *Client::chatLeaveChannel(const QString &name)
@ -264,9 +381,9 @@ PendingCommand *Client::listGames()
return cmd("list_games");
}
PendingCommand *Client::listPlayers()
PendingCommand_ListPlayers *Client::listPlayers()
{
return cmd("list_players");
return static_cast<PendingCommand_ListPlayers *>(cmd("list_players", new PendingCommand_ListPlayers));
}
PendingCommand *Client::createGame(const QString &description, const QString &password, unsigned int maxPlayers, bool spectatorsAllowed)
@ -368,6 +485,13 @@ PendingCommand *Client::delCounter(const QString &counter)
return cmd(QString("del_counter|%1").arg(counter));
}
PendingCommand_ListCounters *Client::listCounters(int playerId)
{
PendingCommand_ListCounters *pc = new PendingCommand_ListCounters(playerId);
cmd(QString("list_counters|%1").arg(playerId), pc);
return pc;
}
PendingCommand *Client::nextTurn()
{
return cmd(QString("next_turn"));
@ -378,9 +502,18 @@ PendingCommand *Client::setActivePhase(int phase)
return cmd(QString("set_active_phase|%1").arg(phase));
}
PendingCommand *Client::dumpZone(int player, const QString &zone, int numberCards)
PendingCommand_ListZones *Client::listZones(int playerId)
{
return cmd(QString("dump_zone|%1|%2|%3").arg(player).arg(zone).arg(numberCards));
PendingCommand_ListZones *pc = new PendingCommand_ListZones(playerId);
cmd(QString("list_zones|%1").arg(playerId), pc);
return pc;
}
PendingCommand_DumpZone *Client::dumpZone(int player, const QString &zone, int numberCards)
{
PendingCommand_DumpZone *pc = new PendingCommand_DumpZone(player, zone, numberCards);
cmd(QString("dump_zone|%1|%2|%3").arg(player).arg(zone).arg(numberCards), pc);
return pc;
}
PendingCommand *Client::stopDumpZone(int player, const QString &zone)

256
cockatrice/src/client.h
View file

@ -1,13 +1,10 @@
#ifndef CLIENT_H
#define CLIENT_H
#include "servereventdata.h"
#include "servergame.h"
#include "serverplayer.h"
#include "serverzone.h"
#include "serverzonecard.h"
#include <QTcpSocket>
#include <QColor>
#include <QStringList>
#include <QHash>
class QTimer;
@ -27,25 +24,242 @@ enum ServerResponse {
RespErr
};
enum ServerEventType {
eventInvalid,
eventPlayerId,
eventSay,
eventName,
eventJoin,
eventLeave,
eventReadyStart,
eventSetupZones,
eventGameStart,
eventShuffle,
eventRollDie,
eventDraw,
eventMoveCard,
eventCreateToken,
eventSetCardAttr,
eventAddCounter,
eventSetCounter,
eventDelCounter,
eventSetActivePlayer,
eventSetActivePhase,
eventDumpZone,
eventStopDumpZone
};
class ServerEventData {
private:
static QHash<QString, ServerEventType> eventHash;
bool IsPublic;
int PlayerId;
QString PlayerName;
ServerEventType EventType;
QStringList EventData;
public:
ServerEventData(const QString &line);
bool getPublic() const { return IsPublic; }
int getPlayerId() const { return PlayerId; }
const QString &getPlayerName() const { return PlayerName; }
ServerEventType getEventType() const { return EventType; }
const QStringList &getEventData() const { return EventData; }
};
enum ChatEventType {
eventChatInvalid,
eventChatListChannels,
eventChatJoinChannel,
eventChatListPlayers,
eventChatLeaveChannel,
eventChatSay,
eventChatServerMessage
};
class ChatEventData {
private:
static QHash<QString, ChatEventType> eventHash;
ChatEventType eventType;
QStringList eventData;
public:
ChatEventData(const QString &line);
ChatEventType getEventType() const { return eventType; }
const QStringList &getEventData() const { return eventData; }
};
class ServerGame {
private:
int gameId;
QString creator;
QString description;
bool hasPassword;
unsigned char playerCount;
unsigned char maxPlayers;
bool spectatorsAllowed;
unsigned int spectatorsCount;
public:
ServerGame(int _gameId, const QString &_creator, const QString &_description, bool _hasPassword, unsigned char _playerCount, unsigned char _maxPlayers, bool _spectatorsAllowed, unsigned int _spectatorsCount)
: gameId(_gameId), creator(_creator), description(_description), hasPassword(_hasPassword), playerCount(_playerCount), maxPlayers(_maxPlayers), spectatorsAllowed(_spectatorsAllowed), spectatorsCount(_spectatorsCount) { }
int getGameId() const { return gameId; }
QString getCreator() const { return creator; }
QString getDescription() const { return description; }
bool getHasPassword() const { return hasPassword; }
unsigned char getPlayerCount() const { return playerCount; }
unsigned char getMaxPlayers() const { return maxPlayers; }
bool getSpectatorsAllowed() const { return spectatorsAllowed; }
unsigned int getSpectatorsCount() const { return spectatorsCount; }
};
class ServerPlayer {
private:
int PlayerId;
QString name;
bool local;
public:
ServerPlayer(int _PlayerId, const QString &_name, bool _local)
: PlayerId(_PlayerId), name(_name), local(_local) { }
int getPlayerId() const { return PlayerId; }
QString getName() const { return name; }
bool getLocal() const { return local; }
};
class ServerZoneCard {
private:
int id;
QString name;
int x, y;
int counters;
bool tapped;
bool attacking;
QString annotation;
public:
ServerZoneCard(int _id, const QString &_name, int _x, int _y, int _counters, bool _tapped, bool _attacking, const QString &_annotation)
: id(_id), name(_name), x(_x), y(_y), counters(_counters), tapped(_tapped), attacking(_attacking), annotation(_annotation) { }
int getId() const { return id; }
QString getName() const { return name; }
int getX() const { return x; }
int getY() const { return y; }
int getCounters() const { return counters; }
bool getTapped() const { return tapped; }
bool getAttacking() const { return attacking; }
QString getAnnotation() const { return annotation; }
};
class ServerZone {
private:
QString name;
bool isPublic;
bool hasCoords;
int cardCount;
public:
ServerZone(const QString &_name, bool _isPublic, bool _hasCoords, int _cardCount)
: name(_name), isPublic(_isPublic), hasCoords(_hasCoords), cardCount(_cardCount) { }
QString getName() const { return name; }
bool getPublic() const { return isPublic; }
bool getHasCoords() const { return hasCoords; }
int getCardCount() const { return cardCount; }
};
class ServerCounter {
private:
QString name;
int color;
int count;
public:
ServerCounter(const QString &_name, int _color, int _count)
: name(_name), color(_color), count(_count) { }
QString getName() const { return name; }
int getColor() const { return color; }
int getCount() const { return count; }
};
class PendingCommand : public QObject {
Q_OBJECT
private:
QString cmd;
int msgid;
int time;
QString extraData;
signals:
void finished(ServerResponse resp);
void timeout();
public slots:
void responseReceived(int _msgid, ServerResponse _resp);
virtual void responseReceived(ServerResponse resp);
void checkTimeout();
public:
PendingCommand(int _msgid = -1);
int getMsgId() const { return msgid; }
QString getCmd() const { return cmd; }
const QString &getExtraData() const { return extraData; }
void setExtraData(const QString &_extraData) { extraData = _extraData; }
PendingCommand(const QString &_cmd, int _msgid, QObject *parent = 0);
void setMsgId(int _msgId) { msgid = _msgId; }
};
class PendingCommand_ChatJoinChannel : public PendingCommand {
Q_OBJECT
private:
QString channelName;
public:
PendingCommand_ChatJoinChannel(const QString &_channelName)
: channelName(_channelName) { }
const QString &getChannelName() const { return channelName; }
};
class PendingCommand_ListPlayers : public PendingCommand {
Q_OBJECT
private:
QList<ServerPlayer> playerList;
signals:
void playerListReceived(QList<ServerPlayer> _playerList);
public:
void responseReceived(ServerResponse resp);
void addPlayer(const ServerPlayer &player);
};
class PendingCommand_ListZones : public PendingCommand {
Q_OBJECT
private:
QList<ServerZone> zoneList;
int playerId;
signals:
void zoneListReceived(QList<ServerZone> _zoneList);
public:
PendingCommand_ListZones(int _playerId)
: playerId(_playerId) { }
void responseReceived(ServerResponse resp);
void addZone(const ServerZone &zone);
int getPlayerId() const { return playerId; }
};
class PendingCommand_DumpZone : public PendingCommand {
Q_OBJECT
private:
QList<ServerZoneCard> cardList;
int playerId;
QString zoneName;
int numberCards;
signals:
void cardListReceived(QList<ServerZoneCard> _cardList);
public:
PendingCommand_DumpZone(int _playerId, const QString &_zoneName, int _numberCards)
: playerId(_playerId), zoneName(_zoneName), numberCards(_numberCards) { }
void responseReceived(ServerResponse resp);
void addCard(const ServerZoneCard &card);
int getPlayerId() const { return playerId; }
QString getZoneName() const { return zoneName; }
int getNumberCards() const { return numberCards; }
};
class PendingCommand_ListCounters : public PendingCommand {
Q_OBJECT
private:
QList<ServerCounter> counterList;
int playerId;
signals:
void counterListReceived(QList<ServerCounter> _counterList);
public:
PendingCommand_ListCounters(int _playerId)
: playerId(_playerId) { }
void responseReceived(ServerResponse resp);
void addCounter(const ServerCounter &counter);
int getPlayerId() const { return playerId; }
};
class Client : public QObject {
@ -54,10 +268,6 @@ signals:
void statusChanged(ProtocolStatus _status);
void welcomeMsgReceived(QString welcomeMsg);
void gameListEvent(ServerGame *game);
void playerListReceived(QList<ServerPlayer *> players);
void zoneListReceived(int commandId, QList<ServerZone *> zones);
void zoneDumpReceived(int commandId, QList<ServerZoneCard *> cards);
void responseReceived(int msgid, ServerResponse resp);
void playerIdReceived(int id, QString name);
void gameEvent(const ServerEventData &msg);
void chatEvent(const ChatEventData &msg);
@ -65,6 +275,7 @@ signals:
void logSocketError(const QString &errorString);
void serverError(ServerResponse resp);
void protocolVersionMismatch();
void protocolError();
private slots:
void slotConnected();
void readLine();
@ -78,14 +289,13 @@ private slots:
private:
static const int protocolVersion = 1;
QTimer *timer;
QList<PendingCommand *> PendingCommands;
QMap<int, PendingCommand *> pendingCommands;
QTcpSocket *socket;
ProtocolStatus status;
QList<QStringList> msgbuf;
QString playerName, password;
unsigned int MsgId;
void msg(const QString &s);
PendingCommand *cmd(const QString &s);
PendingCommand *cmd(const QString &s, PendingCommand *_pc = 0);
void setStatus(const ProtocolStatus _status);
public:
Client(QObject *parent = 0);
@ -97,11 +307,11 @@ public:
void disconnectFromServer();
public slots:
PendingCommand *chatListChannels();
PendingCommand *chatJoinChannel(const QString &name);
PendingCommand_ChatJoinChannel *chatJoinChannel(const QString &name);
PendingCommand *chatLeaveChannel(const QString &name);
PendingCommand *chatSay(const QString &name, const QString &s);
PendingCommand *listGames();
PendingCommand *listPlayers();
PendingCommand_ListPlayers *listPlayers();
PendingCommand *createGame(const QString &description, const QString &password, unsigned int maxPlayers, bool spectatorsAllowed);
PendingCommand *joinGame(int gameId, const QString &password, bool spectator);
PendingCommand *leaveGame();
@ -119,9 +329,11 @@ public slots:
PendingCommand *addCounter(const QString &counter, QColor color, int value);
PendingCommand *setCounter(const QString &counter, int value);
PendingCommand *delCounter(const QString &counter);
PendingCommand_ListCounters *listCounters(int playerId);
PendingCommand *nextTurn();
PendingCommand *setActivePhase(int phase);
PendingCommand *dumpZone(int player, const QString &zone, int numberCards);
PendingCommand_ListZones *listZones(int playerId);
PendingCommand_DumpZone *dumpZone(int player, const QString &zone, int numberCards);
PendingCommand *stopDumpZone(int player, const QString &zone);
void submitDeck(const QStringList &deck);
};

20
cockatrice/src/game.cpp
View file

@ -3,9 +3,7 @@
#include <QMessageBox>
#include <QSettings>
#include <stdlib.h>
#include "serverplayer.h"
#include "game.h"
#include "servereventdata.h"
#include "client.h"
#include "tablezone.h"
#include "handzone.h"
@ -18,7 +16,6 @@ Game::Game(CardDatabase *_db, Client *_client, GameScene *_scene, QMenuBar *menu
: QObject(parent), db(_db), client(_client), scene(_scene), started(false), currentPhase(-1)
{
connect(client, SIGNAL(gameEvent(const ServerEventData &)), this, SLOT(gameEvent(const ServerEventData &)));
connect(client, SIGNAL(playerListReceived(QList<ServerPlayer *>)), this, SLOT(playerListReceived(QList<ServerPlayer *>)));
aNextPhase = new QAction(this);
connect(aNextPhase, SIGNAL(triggered()), this, SLOT(actNextPhase()));
@ -82,7 +79,8 @@ Game::Game(CardDatabase *_db, Client *_client, GameScene *_scene, QMenuBar *menu
retranslateUi();
client->listPlayers();
PendingCommand_ListPlayers *pc = client->listPlayers();
connect(pc, SIGNAL(playerListReceived(QList<ServerPlayer>)), this, SLOT(playerListReceived(QList<ServerPlayer>)));
}
Game::~Game()
@ -143,18 +141,12 @@ Player *Game::addPlayer(int playerId, const QString &playerName, bool local)
return newPlayer;
}
void Game::playerListReceived(QList<ServerPlayer *> playerList)
void Game::playerListReceived(QList<ServerPlayer> playerList)
{
QListIterator<ServerPlayer *> i(playerList);
QStringList nameList;
while (i.hasNext()) {
ServerPlayer *temp = i.next();
nameList << temp->getName();
int id = temp->getPlayerId();
addPlayer(id, temp->getName(), temp->getLocal());
delete temp;
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();

5
cockatrice/src/game.h
View file

@ -4,11 +4,10 @@
#include <QHash>
#include <QStringList>
#include "playerlist.h"
#include "client.h"
class ServerPlayer;
class GameScene;
class Player;
class Client;
class ServerEventData;
class CardDatabase;
class DlgStartGame;
@ -56,7 +55,7 @@ private slots:
void actMoveToExile(CardItem *card);
void gameEvent(const ServerEventData &msg);
void playerListReceived(QList<ServerPlayer *> playerList);
void playerListReceived(QList<ServerPlayer> playerList);
void readyStart();
signals:
void submitDecklist();

1
cockatrice/src/gameselector.h
View file

@ -3,7 +3,6 @@
#include <QWidget>
#include "gamesmodel.h"
#include "servergame.h"
#include "client.h"
class QPushButton;

2
cockatrice/src/gamesmodel.cpp
View file

@ -1,5 +1,5 @@
#include "gamesmodel.h"
#include "servergame.h"
#include "client.h"
GamesModel::~GamesModel()
{

3
cockatrice/src/gamesmodel.h
View file

@ -3,7 +3,8 @@
#include <QAbstractListModel>
#include <QList>
#include "servergame.h"
class ServerGame;
class GamesModel : public QAbstractTableModel {
Q_OBJECT

5
cockatrice/src/messagelogwidget.cpp
View file

@ -45,6 +45,11 @@ void MessageLogWidget::logProtocolVersionMismatch()
append(tr("Protocol version mismatch."));
}
void MessageLogWidget::logProtocolError()
{
append(tr("Protocol error."));
}
void MessageLogWidget::logPlayerListReceived(QStringList players)
{
append("---");

1
cockatrice/src/messagelogwidget.h
View file

@ -22,6 +22,7 @@ public slots:
void logSocketError(const QString &errorString);
void logServerError(ServerResponse response);
void logProtocolVersionMismatch();
void logProtocolError();
private slots:
void logPlayerListReceived(QStringList players);
void logJoin(Player *player);

2
cockatrice/src/player.h
View file

@ -4,7 +4,6 @@
#include <QInputDialog>
#include <QPoint>
#include "zonelist.h"
#include "servereventdata.h"
class Client;
class CardDatabase;
@ -15,6 +14,7 @@ class Game;
class Counter;
class TableZone;
class HandZone;
class ServerEventData;
class Player : public QObject, public QGraphicsItem {
Q_OBJECT

60
cockatrice/src/servereventdata.cpp
View file

@ -1,60 +0,0 @@
#include "servereventdata.h"
// Message structure for server events:
// {"private","public"}|PlayerId|PlayerName|EventType|EventData
QHash<QString, ServerEventType> ServerEventData::eventHash;
ServerEventData::ServerEventData(const QString &line)
{
if (eventHash.isEmpty()) {
eventHash.insert("player_id", eventPlayerId);
eventHash.insert("say", eventSay);
eventHash.insert("name", eventName);
eventHash.insert("join", eventJoin);
eventHash.insert("leave", eventLeave);
eventHash.insert("ready_start", eventReadyStart);
eventHash.insert("setup_zones", eventSetupZones);
eventHash.insert("game_start", eventGameStart);
eventHash.insert("shuffle", eventShuffle);
eventHash.insert("roll_die", eventRollDie);
eventHash.insert("draw", eventDraw);
eventHash.insert("move_card", eventMoveCard);
eventHash.insert("create_token", eventCreateToken);
eventHash.insert("set_card_attr", eventSetCardAttr);
eventHash.insert("add_counter", eventAddCounter);
eventHash.insert("set_counter", eventSetCounter);
eventHash.insert("del_counter", eventDelCounter);
eventHash.insert("set_active_player", eventSetActivePlayer);
eventHash.insert("set_active_phase", eventSetActivePhase);
eventHash.insert("dump_zone", eventDumpZone);
eventHash.insert("stop_dump_zone", eventStopDumpZone);
}
QStringList values = line.split('|');
IsPublic = !values.takeFirst().compare("public");
PlayerId = values.takeFirst().toInt();
PlayerName = values.takeFirst();
EventType = eventHash.value(values.takeFirst(), eventInvalid);
EventData = values;
}
QHash<QString, ChatEventType> ChatEventData::eventHash;
ChatEventData::ChatEventData(const QString &line)
{
if (eventHash.isEmpty()) {
eventHash.insert("list_channels", eventChatListChannels);
eventHash.insert("join_channel", eventChatJoinChannel);
eventHash.insert("list_players", eventChatListPlayers);
eventHash.insert("leave_channel", eventChatLeaveChannel);
eventHash.insert("say", eventChatSay);
eventHash.insert("server_message", eventChatServerMessage);
}
QStringList values = line.split('|');
values.removeFirst();
eventType = eventHash.value(values.takeFirst(), eventChatInvalid);
eventData = values;
}

72
cockatrice/src/servereventdata.h
View file

@ -1,72 +0,0 @@
#ifndef SERVEREVENTDATA_H
#define SERVEREVENTDATA_H
#include <QStringList>
#include <QHash>
enum ServerEventType {
eventInvalid,
eventPlayerId,
eventSay,
eventName,
eventJoin,
eventLeave,
eventReadyStart,
eventSetupZones,
eventGameStart,
eventShuffle,
eventRollDie,
eventDraw,
eventMoveCard,
eventCreateToken,
eventSetCardAttr,
eventAddCounter,
eventSetCounter,
eventDelCounter,
eventSetActivePlayer,
eventSetActivePhase,
eventDumpZone,
eventStopDumpZone
};
class ServerEventData {
private:
static QHash<QString, ServerEventType> eventHash;
bool IsPublic;
int PlayerId;
QString PlayerName;
ServerEventType EventType;
QStringList EventData;
public:
ServerEventData(const QString &line);
bool getPublic() const { return IsPublic; }
int getPlayerId() const { return PlayerId; }
const QString &getPlayerName() const { return PlayerName; }
ServerEventType getEventType() const { return EventType; }
const QStringList &getEventData() const { return EventData; }
};
enum ChatEventType {
eventChatInvalid,
eventChatListChannels,
eventChatJoinChannel,
eventChatListPlayers,
eventChatLeaveChannel,
eventChatSay,
eventChatServerMessage
};
class ChatEventData {
private:
static QHash<QString, ChatEventType> eventHash;
ChatEventType eventType;
QStringList eventData;
public:
ChatEventData(const QString &line);
ChatEventType getEventType() const { return eventType; }
const QStringList &getEventData() const { return eventData; }
};
#endif

27
cockatrice/src/servergame.h
View file

@ -1,27 +0,0 @@
#ifndef SERVERGAME_H
#define SERVERGAME_H
class ServerGame {
private:
int gameId;
QString creator;
QString description;
bool hasPassword;
unsigned char playerCount;
unsigned char maxPlayers;
bool spectatorsAllowed;
unsigned int spectatorsCount;
public:
ServerGame(int _gameId, const QString &_creator, const QString &_description, bool _hasPassword, unsigned char _playerCount, unsigned char _maxPlayers, bool _spectatorsAllowed, unsigned int _spectatorsCount)
: gameId(_gameId), creator(_creator), description(_description), hasPassword(_hasPassword), playerCount(_playerCount), maxPlayers(_maxPlayers), spectatorsAllowed(_spectatorsAllowed), spectatorsCount(_spectatorsCount) { }
int getGameId() const { return gameId; }
QString getCreator() const { return creator; }
QString getDescription() const { return description; }
bool getHasPassword() const { return hasPassword; }
unsigned char getPlayerCount() const { return playerCount; }
unsigned char getMaxPlayers() const { return maxPlayers; }
bool getSpectatorsAllowed() const { return spectatorsAllowed; }
unsigned int getSpectatorsCount() const { return spectatorsCount; }
};
#endif

19
cockatrice/src/serverplayer.h
View file

@ -1,19 +0,0 @@
#ifndef SERVERPLAYER_H
#define SERVERPLAYER_H
#include <QString>
class ServerPlayer {
private:
int PlayerId;
QString name;
bool local;
public:
ServerPlayer(int _PlayerId, const QString &_name, bool _local)
: PlayerId(_PlayerId), name(_name), local(_local) { }
int getPlayerId() const { return PlayerId; }
QString getName() const { return name; }
bool getLocal() const { return local; }
};
#endif

21
cockatrice/src/serverzone.h
View file

@ -1,21 +0,0 @@
#ifndef SERVERZONE_H
#define SERVERZONE_H
#include <QString>
class ServerZone {
private:
QString name;
bool isPublic;
bool hasCoords;
int cardCount;
public:
ServerZone(const QString &_name, bool _isPublic, bool _hasCoords, int _cardCount)
: name(_name), isPublic(_isPublic), hasCoords(_hasCoords), cardCount(_cardCount) { }
QString getName() const { return name; }
bool getPublic() const { return isPublic; }
bool getHasCoords() const { return hasCoords; }
int getCardCount() const { return cardCount; }
};
#endif

28
cockatrice/src/serverzonecard.h
View file

@ -1,28 +0,0 @@
#ifndef SERVERZONECARD_H
#define SERVERZONECARD_H
#include <QString>
class ServerZoneCard {
private:
int id;
QString name;
int x, y;
int counters;
bool tapped;
bool attacking;
QString annotation;
public:
ServerZoneCard(int _id, const QString &_name, int _x, int _y, int _counters, bool _attacking, const QString &_annotation)
: id(_id), name(_name), x(_x), y(_y), counters(_counters), attacking(_attacking), annotation(_annotation) { }
int getId() const { return id; }
QString getName() const { return name; }
int getX() const { return x; }
int getY() const { return y; }
int getCounters() const { return counters; }
bool getTapped() const { return tapped; }
bool getAttacking() const { return attacking; }
QString getAnnotation() const { return annotation; }
};
#endif

1
cockatrice/src/window_main.cpp
View file

@ -307,6 +307,7 @@ MainWindow::MainWindow(QTranslator *_translator, QWidget *parent)
connect(client, SIGNAL(logSocketError(const QString &)), messageLog, SLOT(logSocketError(const QString &)));
connect(client, SIGNAL(serverError(ServerResponse)), messageLog, SLOT(logServerError(ServerResponse)));
connect(client, SIGNAL(protocolVersionMismatch()), messageLog, SLOT(logProtocolVersionMismatch()));
connect(client, SIGNAL(protocolError()), messageLog, SLOT(logProtocolError()));
connect(phasesToolbar, SIGNAL(signalSetPhase(int)), client, SLOT(setActivePhase(int)));
connect(phasesToolbar, SIGNAL(signalNextTurn()), client, SLOT(nextTurn()));
connect(phasesToolbar, SIGNAL(signalDrawCard()), client, SLOT(drawCard()));

1
cockatrice/src/zoneviewwidget.h
View file

@ -4,7 +4,6 @@
#include <QDialog>
#include <QGraphicsScene>
#include <QGraphicsWidget>
#include "serverzonecard.h"
class CardZone;
class ZoneViewZone;

16
cockatrice/src/zoneviewzone.cpp
View file

@ -27,9 +27,8 @@ void ZoneViewZone::paint(QPainter */*painter*/, const QStyleOptionGraphicsItem *
void ZoneViewZone::initializeCards()
{
if (!origZone->contentsKnown()) {
connect(player->client, SIGNAL(zoneDumpReceived(int, QList<ServerZoneCard *>)), this, SLOT(zoneDumpReceived(int, QList<ServerZoneCard *>)));
PendingCommand *dumpZoneCommand = player->client->dumpZone(player->getId(), name, numberCards);
cmdId = dumpZoneCommand->getMsgId();
PendingCommand_DumpZone *dumpZoneCommand = player->client->dumpZone(player->getId(), name, numberCards);
connect(dumpZoneCommand, SIGNAL(cardListReceived(QList<ServerZoneCard>)), this, SLOT(zoneDumpReceived(QList<ServerZoneCard>)));
} else {
const CardList &c = origZone->getCards();
int number = numberCards == -1 ? c.size() : (numberCards < c.size() ? numberCards : c.size());
@ -42,18 +41,11 @@ void ZoneViewZone::initializeCards()
}
}
void ZoneViewZone::zoneDumpReceived(int commandId, QList<ServerZoneCard *> cards)
void ZoneViewZone::zoneDumpReceived(QList<ServerZoneCard> cards)
{
if (commandId != cmdId)
return;
for (int i = 0; i < cards.size(); i++) {
ServerZoneCard *temp = cards[i];
CardItem *card = new CardItem(player->getDb(), temp->getName(), i, this);
CardItem *card = new CardItem(player->getDb(), cards[i].getName(), i, this);
addCard(card, false, i);
delete temp;
}
emit contentsChanged();

5
cockatrice/src/zoneviewzone.h
View file

@ -2,7 +2,7 @@
#define ZONEVIEWERZONE_H
#include "cardzone.h"
#include "serverzonecard.h"
#include "client.h"
#include <QGraphicsWidget>
#include <QGraphicsLayoutItem>
@ -16,7 +16,6 @@ private:
void handleDropEvent(int cardId, CardZone *startZone, const QPoint &dropPoint, bool faceDown);
CardZone *origZone;
bool sortingEnabled;
int cmdId;
public:
ZoneViewZone(Player *_p, CardZone *_origZone, int _numberCards = -1, QGraphicsItem *parent = 0);
~ZoneViewZone();
@ -30,7 +29,7 @@ public:
public slots:
void setSortingEnabled(int _sortingEnabled);
private slots:
void zoneDumpReceived(int commandId, QList<ServerZoneCard *> cards);
void zoneDumpReceived(QList<ServerZoneCard> cards);
protected:
void addCardImpl(CardItem *card, int x, int y);
QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;