jeirmeister/Cockatrice
1
0
Fork 0
mirror of https://github.com/Cockatrice/Cockatrice.git synced 2026-06-30 10:33:54 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

everything compiles again; enough for today

Browse source
This commit is contained in:
Max-Wilhelm Bruker 2009-11-12 00:09:24 +01:00
parent dd5ae4d74d
commit cb0e4d07e4
29 changed files with 340 additions and 766 deletions
Download patch file Download diff file Expand all files Collapse all files

18
cockatrice/src/chatwidget.cpp
View file

@ -128,7 +128,7 @@ void ChatWidget::disableChat()
channelList->clear();
hide();
}
/*
void ChatWidget::chatEvent(const ChatEventData &data)
{
const QStringList &msg = data.getEventData();
@ -209,11 +209,11 @@ void ChatWidget::chatEvent(const ChatEventData &data)
}
}
}
*/
void ChatWidget::joinChannel(const QString &channelName)
{
PendingCommand_ChatJoinChannel *pc = client->chatJoinChannel(channelName);
connect(pc, SIGNAL(finished(ServerResponse)), this, SLOT(joinFinished(ServerResponse)));
// PendingCommand_ChatJoinChannel *pc = client->chatJoinChannel(channelName);
// connect(pc, SIGNAL(finished(ServerResponse)), this, SLOT(joinFinished(ServerResponse)));
}
void ChatWidget::joinClicked()
@ -228,15 +228,15 @@ void ChatWidget::joinClicked()
joinChannel(channelName);
}
void ChatWidget::joinFinished(ServerResponse resp)
void ChatWidget::joinFinished(ResponseCode resp)
{
if (resp != RespOk)
return;
PendingCommand_ChatJoinChannel *pc = qobject_cast<PendingCommand_ChatJoinChannel *>(sender());
QString channelName = pc->getChannelName();
ChannelWidget *cw = new ChannelWidget(client, channelName);
tab->addTab(cw, channelName);
// PendingCommand_ChatJoinChannel *pc = qobject_cast<PendingCommand_ChatJoinChannel *>(sender());
// QString channelName = pc->getChannelName();
// ChannelWidget *cw = new ChannelWidget(client, channelName);
// tab->addTab(cw, channelName);
}
ChannelWidget *ChatWidget::getChannel(const QString &name)

7
cockatrice/src/chatwidget.h
View file

@ -2,7 +2,7 @@
#define CHATWIDGET_H
#include <QWidget>
#include "client.h"
#include "protocol_datastructures.h"
class QListWidget;
class QTextEdit;
@ -10,6 +10,7 @@ class QLineEdit;
class QTreeWidget;
class QTabWidget;
class QPushButton;
class Client;
class ChannelWidget : public QWidget {
Q_OBJECT
@ -45,9 +46,9 @@ private:
ChannelWidget *getChannel(const QString &name);
void joinChannel(const QString &channelName);
private slots:
void chatEvent(const ChatEventData &data);
// void chatEvent(const ChatEventData &data);
void joinClicked();
void joinFinished(ServerResponse resp);
void joinFinished(ResponseCode resp);
public:
ChatWidget(Client *_client, QWidget *parent = 0);
void retranslateUi();

197
cockatrice/src/client.cpp
View file

@ -1,132 +1,26 @@
#include <QTimer>
#include <QXmlStreamReader>
#include <QXmlStreamWriter>
#include "client.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("say", eventSay);
eventHash.insert("join", eventJoin);
eventHash.insert("leave", eventLeave);
eventHash.insert("game_closed", eventGameClosed);
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("create_arrow", eventCreateArrow);
eventHash.insert("delete_arrow", eventDeleteArrow);
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");
bool ok = false;
PlayerId = values.takeFirst().toInt(&ok);
if (!ok)
PlayerId = -1;
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(ServerResponse resp)
{
emit finished(resp);
deleteLater();
}
void PendingCommand_ListPlayers::responseReceived(ServerResponse resp)
{
if (resp == RespOk)
emit playerListReceived(playerList);
PendingCommand::responseReceived(resp);
}
void PendingCommand_ListZones::responseReceived(ServerResponse resp)
{
if (resp == RespOk)
emit zoneListReceived(zoneList);
PendingCommand::responseReceived(resp);
}
void PendingCommand_DumpZone::responseReceived(ServerResponse resp)
{
if (resp == RespOk)
emit cardListReceived(cardList);
PendingCommand::responseReceived(resp);
}
void PendingCommand_ListCounters::responseReceived(ServerResponse resp)
{
if (resp == RespOk)
emit counterListReceived(counterList);
PendingCommand::responseReceived(resp);
}
void PendingCommand_DumpAll::responseReceived(ServerResponse resp)
{
if (resp == RespOk) {
emit playerListReceived(playerList);
emit zoneListReceived(zoneList);
emit cardListReceived(cardList);
emit counterListReceived(counterList);
emit arrowListReceived(arrowList);
}
PendingCommand::responseReceived(resp);
}
#include "protocol.h"
#include "protocol_items.h"
Client::Client(QObject *parent)
: QObject(parent), status(StatusDisconnected), MsgId(0)
: QObject(parent), currentItem(0), status(StatusDisconnected)
{
timer = new QTimer(this);
timer->setInterval(1000);
connect(timer, SIGNAL(timeout()), this, SLOT(ping()));
socket = new QTcpSocket(this);
socket->setTextModeEnabled(true);
connect(socket, SIGNAL(connected()), this, SLOT(slotConnected()));
connect(socket, SIGNAL(readyRead()), this, SLOT(readLine()));
connect(socket, SIGNAL(readyRead()), this, SLOT(readData()));
connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(slotSocketError(QAbstractSocket::SocketError)));
xmlReader = new QXmlStreamReader;
xmlWriter = new QXmlStreamWriter;
xmlWriter->setAutoFormatting(true);
xmlWriter->setDevice(socket);
}
Client::~Client()
@ -148,9 +42,9 @@ void Client::slotConnected()
void Client::removePendingCommand()
{
pendingCommands.remove(static_cast<PendingCommand *>(sender())->getMsgId());
pendingCommands.remove(static_cast<Command *>(sender())->getCmdId());
}
/*
void Client::loginResponse(ServerResponse response)
{
if (response == RespOk)
@ -172,9 +66,40 @@ void Client::leaveGameResponse(ServerResponse response)
if (response == RespOk)
setStatus(StatusIdle);
}
void Client::readLine()
*/
void Client::readData()
{
xmlReader->addData(socket->readAll());
if (currentItem) {
if (!currentItem->read(xmlReader))
return;
currentItem = 0;
}
while (!xmlReader->atEnd()) {
xmlReader->readNext();
if (xmlReader->isStartElement()) {
QString itemType = xmlReader->name().toString();
if (itemType == "cockatrice_server_stream")
continue;
QString itemName = xmlReader->attributes().value("name").toString();
qDebug() << "parseXml: startElement: " << "type =" << itemType << ", name =" << itemName;
currentItem = ProtocolItem::getNewItem(itemType + itemName);
if (!currentItem)
continue;
if (!currentItem->read(xmlReader))
return;
else {
/* Command *command = qobject_cast<Command *>(currentItem);
if (qobject_cast<InvalidCommand *>(command))
sendProtocolItem(new ProtocolResponse(command->getCmdId(), ProtocolResponse::RespInvalidCommand));
else
processCommand(command);
currentItem = 0;
*/ }
}
}
/*
while (socket->canReadLine()) {
QString line = QString(socket->readLine()).trimmed();
@ -337,25 +262,17 @@ void Client::readLine()
} else
emit protocolError();
}
*/
}
void Client::setStatus(const ProtocolStatus _status)
void Client::setStatus(const ClientStatus _status)
{
if (_status != status) {
status = _status;
emit statusChanged(_status);
}
}
void Client::msg(const QString &s)
{
qDebug(QString(">> %1").arg(s).toLatin1());
QTextStream stream(socket);
stream.setCodec("UTF-8");
stream << s << endl;
stream.flush();
}
/*
PendingCommand *Client::cmd(const QString &s, PendingCommand *_pc)
{
msg(QString("%1|%2").arg(++MsgId).arg(s));
@ -369,7 +286,7 @@ PendingCommand *Client::cmd(const QString &s, PendingCommand *_pc)
connect(pc, SIGNAL(finished(ServerResponse)), this, SLOT(removePendingCommand()));
return pc;
}
*/
void Client::connectToServer(const QString &hostname, unsigned int port, const QString &_playerName, const QString &_password)
{
disconnectFromServer();
@ -382,9 +299,12 @@ void Client::connectToServer(const QString &hostname, unsigned int port, const Q
void Client::disconnectFromServer()
{
currentItem = 0;
xmlReader->clear();
timer->stop();
QList<PendingCommand *> pc = pendingCommands.values();
QList<Command *> pc = pendingCommands.values();
for (int i = 0; i < pc.size(); i++)
delete pc[i];
pendingCommands.clear();
@ -396,7 +316,7 @@ void Client::disconnectFromServer()
void Client::ping()
{
int maxTime = 0;
QMapIterator<int, PendingCommand *> i(pendingCommands);
QMapIterator<int, Command *> i(pendingCommands);
while (i.hasNext()) {
int time = i.next().value()->tick();
if (time > maxTime)
@ -406,10 +326,12 @@ void Client::ping()
if (maxTime >= maxTimeout) {
emit serverTimeout();
disconnectFromServer();
} else
}
/* else
cmd("ping");
*/
}
/*
PendingCommand *Client::chatListChannels()
{
return cmd("chat_list_channels");
@ -601,3 +523,4 @@ int Client::colorToNumber(const QColor &color) const
{
return color.red() * 65536 + color.green() * 256 + color.blue();
}
*/

431
cockatrice/src/client.h
View file

@ -7,410 +7,97 @@
#include <QHash>
class QTimer;
class Command;
class QXmlStreamReader;
class QXmlStreamWriter;
class ProtocolItem;
// Connection state.
// The protocol handler itself is stateless once the connection
// has been established.
enum ProtocolStatus { StatusDisconnected,
StatusConnecting,
StatusAwaitingWelcome,
StatusLoggingIn,
StatusIdle,
StatusPlaying };
enum ServerResponse {
RespOk,
RespNameNotFound,
RespLoginNeeded,
RespSyntaxError,
RespContextError,
RespPasswordWrong,
RespSpectatorsNotAllowed,
RespInvalid
};
enum ServerEventType {
eventInvalid,
eventSay,
eventJoin,
eventLeave,
eventGameClosed,
eventReadyStart,
eventSetupZones,
eventGameStart,
eventShuffle,
eventRollDie,
eventDraw,
eventMoveCard,
eventCreateToken,
eventCreateArrow,
eventDeleteArrow,
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 = -1, const QString &_creator = QString(), const QString &_description = QString(), bool _hasPassword = false, unsigned char _playerCount = 0, unsigned char _maxPlayers = 0, bool _spectatorsAllowed = false, unsigned int _spectatorsCount = 0)
: 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 playerId;
QString zoneName;
int id;
QString name;
int x, y;
int counters;
bool tapped;
bool attacking;
QString annotation;
public:
ServerZoneCard(int _playerId, const QString &_zoneName, int _id, const QString &_name, int _x, int _y, int _counters, bool _tapped, bool _attacking, const QString &_annotation)
: playerId(_playerId), zoneName(_zoneName), id(_id), name(_name), x(_x), y(_y), counters(_counters), tapped(_tapped), attacking(_attacking), annotation(_annotation) { }
int getPlayerId() const { return playerId; }
QString getZoneName() const { return zoneName; }
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 {
public:
enum ZoneType { PrivateZone, PublicZone, HiddenZone };
private:
int playerId;
QString name;
ZoneType type;
bool hasCoords;
int cardCount;
public:
ServerZone(int _playerId, const QString &_name, ZoneType _type, bool _hasCoords, int _cardCount)
: playerId(_playerId), name(_name), type(_type), hasCoords(_hasCoords), cardCount(_cardCount) { }
int getPlayerId() const { return playerId; }
QString getName() const { return name; }
ZoneType getType() const { return type; }
bool getHasCoords() const { return hasCoords; }
int getCardCount() const { return cardCount; }
};
class ServerCounter {
private:
int playerId;
int id;
QString name;
QColor color;
int radius;
int count;
public:
ServerCounter(int _playerId, int _id, const QString &_name, QColor _color, int _radius, int _count)
: playerId(_playerId), id(_id), name(_name), color(_color), radius(_radius), count(_count) { }
int getPlayerId() const { return playerId; }
int getId() const { return id; }
QString getName() const { return name; }
QColor getColor() const { return color; }
int getRadius() const { return radius; }
int getCount() const { return count; }
};
class ServerArrow {
private:
int id;
int playerId;
int startPlayerId;
QString startZone;
int startCardId;
int targetPlayerId;
QString targetZone;
int targetCardId;
QColor color;
public:
ServerArrow(int _playerId, int _id, int _startPlayerId, const QString &_startZone, int _startCardId, int _targetPlayerId, const QString &_targetZone, int _targetCardId, const QColor &_color)
: id(_id), playerId(_playerId), startPlayerId(_startPlayerId), startZone(_startZone), startCardId(_startCardId), targetPlayerId(_targetPlayerId), targetZone(_targetZone), targetCardId(_targetCardId), color(_color) { }
int getId() const { return id; }
int getPlayerId() const { return playerId; }
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; }
};
class PendingCommand : public QObject {
Q_OBJECT
private:
int msgid;
int time;
signals:
void finished(ServerResponse resp);
public slots:
virtual void responseReceived(ServerResponse resp);
public:
PendingCommand(int _msgid = -1);
int tick() { return ++time; }
int getMsgId() const { return msgid; }
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) { playerList.append(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) { zoneList.append(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) { cardList.append(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) { counterList.append(counter); }
int getPlayerId() const { return playerId; }
};
class PendingCommand_DumpAll : public PendingCommand {
Q_OBJECT
private:
QList<ServerPlayer> playerList;
QList<ServerZone> zoneList;
QList<ServerZoneCard> cardList;
QList<ServerCounter> counterList;
QList<ServerArrow> arrowList;
signals:
void playerListReceived(QList<ServerPlayer> _playerList);
void zoneListReceived(QList<ServerZone> _zoneList);
void cardListReceived(QList<ServerZoneCard> _cardList);
void counterListReceived(QList<ServerCounter> _counterList);
void arrowListReceived(QList<ServerArrow> _arrowList);
public:
void responseReceived(ServerResponse resp);
void addPlayer(const ServerPlayer &player) { playerList.append(player); }
void addZone(const ServerZone &zone) { zoneList.append(zone); }
void addCard(const ServerZoneCard &card) { cardList.append(card); }
void addCounter(const ServerCounter &counter) { counterList.append(counter); }
void addArrow(const ServerArrow &arrow) { arrowList.append(arrow); }
enum ClientStatus {
StatusDisconnected,
StatusConnecting,
StatusAwaitingWelcome,
StatusLoggingIn,
StatusLoggedIn,
};
class Client : public QObject {
Q_OBJECT
signals:
void statusChanged(ProtocolStatus _status);
void statusChanged(ClientStatus _status);
void welcomeMsgReceived(QString welcomeMsg);
void gameListEvent(const ServerGame &game);
// void gameListEvent(const ServerGame &game);
void playerIdReceived(int id, QString name);
void gameEvent(const ServerEventData &msg);
void chatEvent(const ChatEventData &msg);
// void gameEvent(const ServerEventData &msg);
// void chatEvent(const ChatEventData &msg);
void maxPingTime(int seconds, int maxSeconds);
void serverTimeout();
void logSocketError(const QString &errorString);
void serverError(ServerResponse resp);
// void serverError(ServerResponse resp);
void protocolVersionMismatch();
void protocolError();
private slots:
void slotConnected();
void readLine();
void readData();
void slotSocketError(QAbstractSocket::SocketError error);
void ping();
void removePendingCommand();
void loginResponse(ServerResponse response);
void enterGameResponse(ServerResponse response);
void leaveGameResponse(ServerResponse response);
// void loginResponse(ServerResponse response);
// void enterGameResponse(ServerResponse response);
// void leaveGameResponse(ServerResponse response);
private:
static const int protocolVersion = 2;
static const int maxTimeout = 10;
QTimer *timer;
QMap<int, PendingCommand *> pendingCommands;
QMap<int, Command *> pendingCommands;
QTcpSocket *socket;
ProtocolStatus status;
QXmlStreamReader *xmlReader;
QXmlStreamWriter *xmlWriter;
ProtocolItem *currentItem;
ClientStatus status;
QString playerName, password;
unsigned int MsgId;
void msg(const QString &s);
PendingCommand *cmd(const QString &s, PendingCommand *_pc = 0);
void setStatus(const ProtocolStatus _status);
void setStatus(ClientStatus _status);
public:
Client(QObject *parent = 0);
~Client();
ProtocolStatus getStatus() const { return status; }
ClientStatus getStatus() const { return status; }
QString peerName() const { return socket->peerName(); }
void connectToServer(const QString &hostname, unsigned int port, const QString &_playerName, const QString &_password);
void disconnectFromServer();
QColor numberToColor(int colorValue) const;
int colorToNumber(const QColor &color) const;
public slots:
PendingCommand *chatListChannels();
PendingCommand_ChatJoinChannel *chatJoinChannel(const QString &name);
PendingCommand *chatLeaveChannel(const QString &name);
PendingCommand *chatSay(const QString &name, const QString &s);
PendingCommand *listGames();
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();
PendingCommand *login(const QString &name, const QString &pass);
PendingCommand *say(const QString &s);
PendingCommand *shuffle();
PendingCommand *rollDie(unsigned int sides);
PendingCommand *drawCard() { return drawCards(1); }
PendingCommand *drawCards(unsigned int number);
PendingCommand *moveCard(int cardid, const QString &startzone, const QString &targetzone, int x, int y = 0, bool faceDown = false);
PendingCommand *createToken(const QString &zone, const QString &name, const QString &powtough, int x, int y);
PendingCommand *createArrow(int startPlayerId, const QString &startZone, int startCardId, int targetPlayerId, const QString &targetPlayerZone, int targetCardId, const QColor &color);
PendingCommand *deleteArrow(int arrowId);
PendingCommand *setCardAttr(const QString &zone, int cardid, const QString &aname, const QString &avalue);
PendingCommand *readyStart();
PendingCommand *incCounter(int counterId, int delta);
PendingCommand *addCounter(const QString &counterName, QColor color, int radius, int value);
PendingCommand *setCounter(int counterId, int value);
PendingCommand *delCounter(int counterId);
PendingCommand_ListCounters *listCounters(int playerId);
PendingCommand *nextTurn();
PendingCommand *setActivePhase(int phase);
PendingCommand_ListZones *listZones(int playerId);
PendingCommand_DumpZone *dumpZone(int player, const QString &zone, int numberCards);
PendingCommand *stopDumpZone(int player, const QString &zone);
PendingCommand_DumpAll *dumpAll();
void submitDeck(const QStringList &deck);
void chatListChannels() { }
void chatJoinChannel(const QString &name) { }
void chatLeaveChannel(const QString &name) { }
void chatSay(const QString &name, const QString &s) { }
void listGames() { }
void listPlayers() { }
void createGame(const QString &description, const QString &password, unsigned int maxPlayers, bool spectatorsAllowed) { }
void joinGame(int gameId, const QString &password, bool spectator) { }
void leaveGame() { }
void login(const QString &name, const QString &pass) { }
void say(const QString &s) { }
void shuffle() { }
void rollDie(unsigned int sides) { }
void drawCard() { return drawCards(1); }
void drawCards(unsigned int number) { }
void moveCard(int cardid, const QString &startzone, const QString &targetzone, int x, int y = 0, bool faceDown = false) { }
void createToken(const QString &zone, const QString &name, const QString &powtough, int x, int y) { }
void createArrow(int startPlayerId, const QString &startZone, int startCardId, int targetPlayerId, const QString &targetPlayerZone, int targetCardId, const QColor &color) { }
void deleteArrow(int arrowId) { }
void setCardAttr(const QString &zone, int cardid, const QString &aname, const QString &avalue) { }
void readyStart() { }
void incCounter(int counterId, int delta) { }
void addCounter(const QString &counterName, QColor color, int radius, int value) { }
void setCounter(int counterId, int value) { }
void delCounter(int counterId) { }
void nextTurn() { }
void setActivePhase(int phase) { }
void dumpZone(int player, const QString &zone, int numberCards) { }
void stopDumpZone(int player, const QString &zone) { }
void dumpAll() { }
void submitDeck(const QStringList &deck) { }
};
#endif

7
cockatrice/src/dlg_creategame.cpp
View file

@ -58,13 +58,13 @@ void DlgCreateGame::actOK()
QMessageBox::critical(this, tr("Error"), tr("Invalid number of players."));
return;
}
PendingCommand *createCommand = client->createGame(descriptionEdit->text(), passwordEdit->text(), maxPlayers, spectatorsAllowedCheckBox->isChecked());
connect(createCommand, SIGNAL(finished(ServerResponse)), this, SLOT(checkResponse(ServerResponse)));
// PendingCommand *createCommand = client->createGame(descriptionEdit->text(), passwordEdit->text(), maxPlayers, spectatorsAllowedCheckBox->isChecked());
// connect(createCommand, SIGNAL(finished(ServerResponse)), this, SLOT(checkResponse(ServerResponse)));
okButton->setEnabled(false);
cancelButton->setEnabled(false);
}
void DlgCreateGame::checkResponse(ServerResponse response)
/*void DlgCreateGame::checkResponse(ServerResponse response)
{
okButton->setEnabled(true);
cancelButton->setEnabled(true);
@ -76,3 +76,4 @@ void DlgCreateGame::checkResponse(ServerResponse response)
return;
}
}
*/

2
cockatrice/src/dlg_creategame.h
View file

@ -15,7 +15,7 @@ public:
DlgCreateGame(Client *_client, QWidget *parent = 0);
private slots:
void actOK();
void checkResponse(ServerResponse response);
// void checkResponse(ServerResponse response);
private:
Client *client;

13
cockatrice/src/game.cpp
View file

@ -13,6 +13,7 @@
#include "gamescene.h"
#include "player.h"
#include "arrowitem.h"
#include "protocol_datastructures.h"
Game::Game(CardDatabase *_db, Client *_client, GameScene *_scene, QMenuBar *menuBar, QObject *parent)
: QObject(parent), db(_db), client(_client), scene(_scene), started(false), currentPhase(-1)
@ -151,7 +152,7 @@ Player *Game::addPlayer(int playerId, const QString &playerName, bool local)
return newPlayer;
}
/*
void Game::cardListReceived(QList<ServerZoneCard> list)
{
for (int i = 0; i < list.size(); ++i) {
@ -250,7 +251,7 @@ void Game::playerListReceived(QList<ServerPlayer> playerList)
emit logPlayerListReceived(nameList);
restartGameDialog();
}
*/
void Game::readyStart()
{
client->readyStart();
@ -260,7 +261,7 @@ 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());
@ -410,7 +411,7 @@ void Game::gameEvent(const ServerEventData &msg)
}
}
}
*/
void Game::actNextPhase()
{
int phase = currentPhase;
@ -537,13 +538,13 @@ void Game::hoverCardEvent(CardItem *card)
void Game::queryGameState()
{
PendingCommand_DumpAll *pc = client->dumpAll();
/* 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()
{

5
cockatrice/src/game.h
View file

@ -10,7 +10,6 @@
class GameScene;
class Player;
class ServerEventData;
class CardDatabase;
class DlgStartGame;
class CardItem;
@ -63,14 +62,14 @@ private slots:
void actMoveToGraveyard(CardItem *card);
void actMoveToExile(CardItem *card);
void gameEvent(const ServerEventData &msg);
/* void gameEvent(const ServerEventData &msg);
void playerListReceived(QList<ServerPlayer> playerList);
void cardListReceived(QList<ServerZoneCard> list);
void zoneListReceived(QList<ServerZone> list);
void counterListReceived(QList<ServerCounter> list);
void arrowListReceived(QList<ServerArrow> list);
*/
void readyStart();
signals:
void submitDecklist();

12
cockatrice/src/gameselector.cpp
View file

@ -51,7 +51,7 @@ void GameSelector::actCreate()
disableGameList();
}
void GameSelector::checkResponse(ServerResponse response)
/*void GameSelector::checkResponse(ServerResponse response)
{
createButton->setEnabled(true);
joinButton->setEnabled(true);
@ -66,7 +66,7 @@ void GameSelector::checkResponse(ServerResponse response)
default: ;
}
}
*/
void GameSelector::actJoin()
{
bool spectator = sender() == spectateButton;
@ -74,7 +74,7 @@ void GameSelector::actJoin()
QModelIndex ind = gameListView->currentIndex();
if (!ind.isValid())
return;
const ServerGame &game = gameListModel->getGame(ind.data(Qt::UserRole).toInt());
const ServerGameInfo &game = gameListModel->getGame(ind.data(Qt::UserRole).toInt());
QString password;
if (game.getHasPassword()) {
bool ok;
@ -83,8 +83,8 @@ void GameSelector::actJoin()
return;
}
PendingCommand *joinCommand = client->joinGame(game.getGameId(), password, spectator);
connect(joinCommand, SIGNAL(finished(ServerResponse)), this, SLOT(checkResponse(ServerResponse)));
// PendingCommand *joinCommand = client->joinGame(game.getGameId(), password, spectator);
// connect(joinCommand, SIGNAL(finished(ServerResponse)), this, SLOT(checkResponse(ServerResponse)));
createButton->setEnabled(false);
joinButton->setEnabled(false);
spectateButton->setEnabled(false);
@ -95,7 +95,7 @@ void GameSelector::enableGameList()
if (isVisible())
return;
connect(client, SIGNAL(gameListEvent(const ServerGame &)), gameListModel, SLOT(updateGameList(const ServerGame &)));
connect(client, SIGNAL(gameListEvent(const ServerGameInfo &)), gameListModel, SLOT(updateGameList(const ServerGameInfo &)));
client->listGames();
show();
}

2
cockatrice/src/gameselector.h
View file

@ -21,7 +21,7 @@ private slots:
void showFullGamesChanged(int state);
void actCreate();
void actJoin();
void checkResponse(ServerResponse response);
// void checkResponse(ServerResponse response);
private:
Client *client;

14
cockatrice/src/gamesmodel.cpp
View file

@ -1,5 +1,5 @@
#include "gamesmodel.h"
#include "client.h"
#include "protocol_datastructures.h"
GamesModel::~GamesModel()
{
@ -17,13 +17,13 @@ QVariant GamesModel::data(const QModelIndex &index, int role) const
if ((index.row() >= gameList.size()) || (index.column() >= columnCount()))
return QVariant();
const ServerGame &g = gameList[index.row()];
const ServerGameInfo &g = gameList[index.row()];
switch (index.column()) {
case 0: return g.getDescription();
case 1: return g.getCreator();
case 1: return g.getCreatorName();
case 2: return g.getHasPassword() ? tr("yes") : tr("no");
case 3: return QString("%1/%2").arg(g.getPlayerCount()).arg(g.getMaxPlayers());
case 4: return g.getSpectatorsAllowed() ? QVariant(g.getSpectatorsCount()) : QVariant(tr("not allowed"));
case 4: return g.getSpectatorsAllowed() ? QVariant(g.getSpectatorCount()) : QVariant(tr("not allowed"));
default: return QVariant();
}
}
@ -42,13 +42,13 @@ QVariant GamesModel::headerData(int section, Qt::Orientation orientation, int ro
}
}
const ServerGame &GamesModel::getGame(int row)
const ServerGameInfo &GamesModel::getGame(int row)
{
Q_ASSERT(row < gameList.size());
return gameList[row];
}
void GamesModel::updateGameList(const ServerGame &game)
void GamesModel::updateGameList(const ServerGameInfo &game)
{
for (int i = 0; i < gameList.size(); i++)
if (gameList[i].getGameId() == game.getGameId()) {
@ -100,7 +100,7 @@ bool GamesProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &/*sourc
if (!model)
return false;
const ServerGame &game = model->getGame(sourceRow);
const ServerGameInfo &game = model->getGame(sourceRow);
if (game.getPlayerCount() == game.getMaxPlayers())
return false;

8
cockatrice/src/gamesmodel.h
View file

@ -4,7 +4,7 @@
#include <QAbstractTableModel>
#include <QSortFilterProxyModel>
#include <QList>
#include "client.h"
#include "protocol_datastructures.h"
class GamesModel : public QAbstractTableModel {
Q_OBJECT
@ -16,12 +16,12 @@ public:
QVariant data(const QModelIndex &index, int role) const;
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
const ServerGame &getGame(int row);
const ServerGameInfo &getGame(int row);
void cleanList();
public slots:
void updateGameList(const ServerGame &game);
void updateGameList(const ServerGameInfo &game);
private:
QList<ServerGame> gameList;
QList<ServerGameInfo> gameList;
};
class GamesProxyModel : public QSortFilterProxyModel {

4
cockatrice/src/messagelogwidget.cpp
View file

@ -32,10 +32,10 @@ void MessageLogWidget::logSocketError(const QString &errorString)
append(sanitizeHtml(errorString));
}
void MessageLogWidget::logServerError(ServerResponse response)
void MessageLogWidget::logServerError(ResponseCode response)
{
switch (response) {
case RespPasswordWrong: append(tr("Invalid password.")); break;
case RespWrongPassword: append(tr("Invalid password.")); break;
default: ;
}
}

4
cockatrice/src/messagelogwidget.h
View file

@ -3,8 +3,8 @@
#include <QPlainTextEdit>
#include <QAbstractSocket>
#include "client.h"
#include "translation.h"
#include "protocol_datastructures.h"
class Game;
class Player;
@ -20,7 +20,7 @@ public slots:
void logConnected(QString welcomeMsg);
void logDisconnected();
void logSocketError(const QString &errorString);
void logServerError(ServerResponse response);
void logServerError(ResponseCode response);
void logProtocolVersionMismatch();
void logProtocolError();
private slots:

4
cockatrice/src/player.cpp
View file

@ -410,7 +410,7 @@ void Player::setCardAttrHelper(CardItem *card, const QString &aname, const QStri
}
}
void Player::gameEvent(const ServerEventData &event)
/*void Player::gameEvent(const ServerEventData &event)
{
QStringList data = event.getEventData();
switch (event.getEventType()) {
@ -643,7 +643,7 @@ void Player::gameEvent(const ServerEventData &event)
qDebug("unhandled player event");
}
}
*/
void Player::showCardMenu(const QPoint &p)
{
emit sigShowCardMenu(p);

2
cockatrice/src/player.h
View file

@ -114,7 +114,7 @@ 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 gameEvent(const ServerEventData &event);
CardDatabase *getDb() const { return db; }
void showCardMenu(const QPoint &p);
bool getActive() const { return active; }

16
cockatrice/src/window_main.cpp
View file

@ -74,7 +74,7 @@ void MainWindow::playerAdded(Player *player)
connect(player, SIGNAL(closeZoneView(ZoneViewZone *)), zoneLayout, SLOT(removeItem(ZoneViewZone *)));
}
void MainWindow::statusChanged(ProtocolStatus _status)
void MainWindow::statusChanged(ClientStatus _status)
{
switch (_status) {
case StatusConnecting:
@ -101,8 +101,8 @@ void MainWindow::statusChanged(ProtocolStatus _status)
aConnect->setEnabled(false);
aDisconnect->setEnabled(true);
break;
case StatusIdle: {
if (game) {
case StatusLoggedIn: {
/* if (game) {
zoneLayout->clear();
delete game;
game = 0;
@ -115,10 +115,10 @@ void MainWindow::statusChanged(ProtocolStatus _status)
view->hide();
gameSelector->enableGameList();
chatWidget->enableChat();
break;
*/ break;
}
case StatusPlaying: {
chatWidget->disableChat();
// case StatusPlaying: {
/* chatWidget->disableChat();
game = new Game(db, client, scene, menuBar(), this);
connect(game, SIGNAL(hoverCard(QString)), cardInfo, SLOT(setCard(const QString &)));
@ -137,7 +137,7 @@ void MainWindow::statusChanged(ProtocolStatus _status)
view->show();
break;
}
default:
*/ default:
break;
}
}
@ -338,7 +338,7 @@ MainWindow::MainWindow(QTranslator *_translator, QWidget *parent)
connect(client, SIGNAL(maxPingTime(int, int)), pingWidget, SLOT(setPercentage(int, int)));
connect(client, SIGNAL(serverTimeout()), this, SLOT(serverTimeout()));
connect(client, SIGNAL(statusChanged(ProtocolStatus)), this, SLOT(statusChanged(ProtocolStatus)));
connect(client, SIGNAL(statusChanged(ClientStatus)), this, SLOT(statusChanged(ClientStatus)));
connect(this, SIGNAL(logConnecting(QString)), messageLog, SLOT(logConnecting(QString)));
connect(client, SIGNAL(welcomeMsgReceived(QString)), messageLog, SLOT(logConnected(QString)));

2
cockatrice/src/window_main.h
View file

@ -60,7 +60,7 @@ class MainWindow : public QMainWindow {
Q_OBJECT
private slots:
void playerAdded(Player *player);
void statusChanged(ProtocolStatus _status);
void statusChanged(ClientStatus _status);
void serverTimeout();
void actSay();

4
cockatrice/src/zoneviewzone.cpp
View file

@ -27,8 +27,8 @@ void ZoneViewZone::paint(QPainter */*painter*/, const QStyleOptionGraphicsItem *
void ZoneViewZone::initializeCards()
{
if (!origZone->contentsKnown()) {
PendingCommand_DumpZone *dumpZoneCommand = player->client->dumpZone(player->getId(), name, numberCards);
connect(dumpZoneCommand, SIGNAL(cardListReceived(QList<ServerZoneCard>)), this, SLOT(zoneDumpReceived(QList<ServerZoneCard>)));
// 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());

2
cockatrice/src/zoneviewzone.h
View file

@ -2,7 +2,7 @@
#define ZONEVIEWERZONE_H
#include "cardzone.h"
#include "client.h"
#include "protocol_datastructures.h"
#include <QGraphicsWidget>
#include <QGraphicsLayoutItem>