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

PB: everything compiles except for deck storage

Browse source
This commit is contained in:
Max-Wilhelm Bruker 2012-01-01 02:48:24 +01:00
parent 695fde7541
commit d5c628966f
51 changed files with 659 additions and 628 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
cockatrice/cockatrice.pro
View file

@ -5,6 +5,8 @@ INCLUDEPATH += . src ../common
MOC_DIR = build MOC_DIR = build
OBJECTS_DIR = build OBJECTS_DIR = build
RESOURCES = cockatrice.qrc RESOURCES = cockatrice.qrc
QMAKE_CXXFLAGS_RELEASE += -O2
CPPFLAGS += -O2
QT += network script svg QT += network script svg
LIBS += -lprotobuf LIBS += -lprotobuf
unix:!macx { unix:!macx {
@ -84,6 +86,7 @@ HEADERS += src/abstractcounter.h \
src/priceupdater.h \ src/priceupdater.h \
src/soundengine.h \ src/soundengine.h \
src/pending_command.h \ src/pending_command.h \
../common/get_pb_extension.h \
../common/color.h \ ../common/color.h \
../common/serializable_item.h \ ../common/serializable_item.h \
../common/decklist.h \ ../common/decklist.h \
@ -168,6 +171,7 @@ SOURCES += src/abstractcounter.cpp \
src/localclient.cpp \ src/localclient.cpp \
src/priceupdater.cpp \ src/priceupdater.cpp \
src/soundengine.cpp \ src/soundengine.cpp \
../common/get_pb_extension.cpp \
../common/serializable_item.cpp \ ../common/serializable_item.cpp \
../common/decklist.cpp \ ../common/decklist.cpp \
../common/protocol.cpp \ ../common/protocol.cpp \

11
cockatrice/src/abstractclient.cpp
View file

@ -14,6 +14,7 @@
#include "pb/event_user_joined.pb.h" #include "pb/event_user_joined.pb.h"
#include "pb/event_user_left.pb.h" #include "pb/event_user_left.pb.h"
#include "pb/event_game_joined.pb.h" #include "pb/event_game_joined.pb.h"
#include "get_pb_extension.h"
#include <google/protobuf/descriptor.h> #include <google/protobuf/descriptor.h>
AbstractClient::AbstractClient(QObject *parent) AbstractClient::AbstractClient(QObject *parent)
@ -42,15 +43,7 @@ void AbstractClient::processProtocolItem(const ServerMessage &item)
} }
case ServerMessage::SESSION_EVENT: { case ServerMessage::SESSION_EVENT: {
const SessionEvent &event = item.session_event(); const SessionEvent &event = item.session_event();
std::vector< const ::google::protobuf::FieldDescriptor * > fieldList; switch ((SessionEvent::SessionEventType) getPbExtension(event)) {
event.GetReflection()->ListFields(event, &fieldList);
int num = 0;
for (unsigned int j = 0; j < fieldList.size(); ++j)
if (fieldList[j]->is_extension()) {
num = fieldList[j]->number();
break;
}
switch ((SessionEvent::SessionEventType) num) {
case SessionEvent::SERVER_IDENTIFICATION: emit serverIdentificationEventReceived(event.GetExtension(Event_ServerIdentification::ext)); break; case SessionEvent::SERVER_IDENTIFICATION: emit serverIdentificationEventReceived(event.GetExtension(Event_ServerIdentification::ext)); break;
case SessionEvent::SERVER_MESSAGE: emit serverMessageEventReceived(event.GetExtension(Event_ServerMessage::ext)); break; case SessionEvent::SERVER_MESSAGE: emit serverMessageEventReceived(event.GetExtension(Event_ServerMessage::ext)); break;
case SessionEvent::SERVER_SHUTDOWN: emit serverShutdownEventReceived(event.GetExtension(Event_ServerShutdown::ext)); break; case SessionEvent::SERVER_SHUTDOWN: emit serverShutdownEventReceived(event.GetExtension(Event_ServerShutdown::ext)); break;

3
cockatrice/src/arrowitem.cpp
View file

@ -10,7 +10,6 @@
#include <QDebug> #include <QDebug>
#include "color.h" #include "color.h"
// XXX
#include "pb/command_attach_card.pb.h" #include "pb/command_attach_card.pb.h"
#include "pb/command_create_arrow.pb.h" #include "pb/command_create_arrow.pb.h"
#include "pb/command_delete_arrow.pb.h" #include "pb/command_delete_arrow.pb.h"
@ -207,7 +206,7 @@ void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
CardItem *targetCard = qgraphicsitem_cast<CardItem *>(targetItem); CardItem *targetCard = qgraphicsitem_cast<CardItem *>(targetItem);
Command_CreateArrow cmd; Command_CreateArrow cmd;
cmd.mutable_arrow_color()->CopyFrom(Color(color).get_color()); // XXX cmd.mutable_arrow_color()->CopyFrom(convertQColorToColor(color));
cmd.set_start_player_id(startZone->getPlayer()->getId()); cmd.set_start_player_id(startZone->getPlayer()->getId());
cmd.set_start_zone(startZone->getName().toStdString()); cmd.set_start_zone(startZone->getName().toStdString());
cmd.set_start_card_id(startCard->getId()); cmd.set_start_card_id(startCard->getId());

31
cockatrice/src/carditem.cpp
View file

@ -14,6 +14,7 @@
#include "main.h" #include "main.h"
#include "settingscache.h" #include "settingscache.h"
#include "tab_game.h" #include "tab_game.h"
#include "pb/serverinfo_card.pb.h"
CardItem::CardItem(Player *_owner, const QString &_name, int _cardid, bool _revealedCard, QGraphicsItem *parent) CardItem::CardItem(Player *_owner, const QString &_name, int _cardid, bool _revealedCard, QGraphicsItem *parent)
: AbstractCardItem(_name, _owner, parent), zone(0), id(_cardid), revealedCard(_revealedCard), attacking(false), facedown(false), destroyOnZoneChange(false), doesntUntap(false), dragItem(0), attachedTo(0) : AbstractCardItem(_name, _owner, parent), zone(0), id(_cardid), revealedCard(_revealedCard), attacking(false), facedown(false), destroyOnZoneChange(false), doesntUntap(false), dragItem(0), attachedTo(0)
@ -373,23 +374,25 @@ void CardItem::resetState()
update(); update();
} }
void CardItem::processCardInfo(ServerInfo_Card *info) void CardItem::processCardInfo(const ServerInfo_Card &info)
{ {
counters.clear(); counters.clear();
const QList<ServerInfo_CardCounter *> &_counterList = info->getCounters(); const int counterListSize = info.counter_list_size();
for (int i = 0; i < _counterList.size(); ++i) for (int i = 0; i < counterListSize; ++i) {
counters.insert(_counterList[i]->getId(), _counterList[i]->getValue()); const ServerInfo_CardCounter &counterInfo = info.counter_list(i);
counters.insert(counterInfo.id(), counterInfo.value());
}
setId(info->getId()); setId(info.id());
setName(info->getName()); setName(QString::fromStdString(info.name()));
setAttacking(info->getAttacking()); setAttacking(info.attacking());
setFaceDown(info->getFaceDown()); setFaceDown(info.face_down());
setPT(info->getPT()); setPT(QString::fromStdString(info.pt()));
setAnnotation(info->getAnnotation()); setAnnotation(QString::fromStdString(info.annotation()));
setColor(info->getColor()); setColor(QString::fromStdString(info.color()));
setTapped(info->getTapped()); setTapped(info.tapped());
setDestroyOnZoneChange(info->getDestroyOnZoneChange()); setDestroyOnZoneChange(info.destroy_on_zone_change());
setDoesntUntap(info->getDoesntUntap()); setDoesntUntap(info.doesnt_untap());
} }
CardDragItem *CardItem::createDragItem(int _id, const QPointF &_pos, const QPointF &_scenePos, bool faceDown) CardDragItem *CardItem::createDragItem(int _id, const QPointF &_pos, const QPointF &_scenePos, bool faceDown)

2
cockatrice/src/carditem.h
View file

@ -96,7 +96,7 @@ public:
void removeAttachedCard(CardItem *card) { attachedCards.removeAt(attachedCards.indexOf(card)); } void removeAttachedCard(CardItem *card) { attachedCards.removeAt(attachedCards.indexOf(card)); }
const QList<CardItem *> &getAttachedCards() const { return attachedCards; } const QList<CardItem *> &getAttachedCards() const { return attachedCards; }
void resetState(); void resetState();
void processCardInfo(ServerInfo_Card *info); void processCardInfo(const ServerInfo_Card &info);
void updateCardMenu(); void updateCardMenu();
bool animationEvent(); bool animationEvent();

3
cockatrice/src/gamescene.cpp
View file

@ -4,6 +4,7 @@
#include "zoneviewzone.h" #include "zoneviewzone.h"
#include "phasestoolbar.h" #include "phasestoolbar.h"
#include "settingscache.h" #include "settingscache.h"
#include "carditem.h"
#include <math.h> #include <math.h>
#include <QAction> #include <QAction>
#include <QGraphicsSceneMouseEvent> #include <QGraphicsSceneMouseEvent>
@ -127,7 +128,7 @@ void GameScene::toggleZoneView(Player *player, const QString &zoneName, int numb
item->setPos(50, 50); item->setPos(50, 50);
} }
void GameScene::addRevealedZoneView(Player *player, CardZone *zone, const QList<ServerInfo_Card *> &cardList) void GameScene::addRevealedZoneView(Player *player, CardZone *zone, const QList<const ServerInfo_Card *> &cardList)
{ {
ZoneViewWidget *item = new ZoneViewWidget(player, zone, -2, true, cardList); ZoneViewWidget *item = new ZoneViewWidget(player, zone, -2, true, cardList);
zoneViews.append(item); zoneViews.append(item);

2
cockatrice/src/gamescene.h
View file

@ -45,7 +45,7 @@ public:
void unregisterAnimationItem(AbstractCardItem *card); void unregisterAnimationItem(AbstractCardItem *card);
public slots: public slots:
void toggleZoneView(Player *player, const QString &zoneName, int numberCards); void toggleZoneView(Player *player, const QString &zoneName, int numberCards);
void addRevealedZoneView(Player *player, CardZone *zone, const QList<ServerInfo_Card *> &cardList); void addRevealedZoneView(Player *player, CardZone *zone, const QList<const ServerInfo_Card *> &cardList);
void removeZoneView(ZoneViewWidget *item); void removeZoneView(ZoneViewWidget *item);
void addPlayer(Player *player); void addPlayer(Player *player);
void removePlayer(Player *player); void removePlayer(Player *player);

1
cockatrice/src/handzone.cpp
View file

@ -3,6 +3,7 @@
#include "settingscache.h" #include "settingscache.h"
#include "player.h" #include "player.h"
#include "carddragitem.h" #include "carddragitem.h"
#include "carditem.h"
#include "pb/command_move_card.pb.h" #include "pb/command_move_card.pb.h"

1
cockatrice/src/messagelogwidget.cpp
View file

@ -1,6 +1,7 @@
#include "messagelogwidget.h" #include "messagelogwidget.h"
#include "player.h" #include "player.h"
#include "cardzone.h" #include "cardzone.h"
#include "carditem.h"
#include "soundengine.h" #include "soundengine.h"
#include "pb/serverinfo_user.pb.h" #include "pb/serverinfo_user.pb.h"
#include "pb/context_move_card.pb.h" #include "pb/context_move_card.pb.h"

2
cockatrice/src/phasestoolbar.h
View file

@ -4,8 +4,8 @@
#include <QFrame> #include <QFrame>
#include <QList> #include <QList>
#include <QGraphicsObject> #include <QGraphicsObject>
#include <google/protobuf/message.h>
namespace google { namespace protobuf { class Message; } }
class Player; class Player;
class GameCommand; class GameCommand;

1
cockatrice/src/pilezone.cpp
View file

@ -5,6 +5,7 @@
#include "player.h" #include "player.h"
#include "carddragitem.h" #include "carddragitem.h"
#include "zoneviewzone.h" #include "zoneviewzone.h"
#include "carditem.h"
#include "pb/command_move_card.pb.h" #include "pb/command_move_card.pb.h"

207
cockatrice/src/player.cpp
View file

@ -17,6 +17,7 @@
#include "settingscache.h" #include "settingscache.h"
#include "dlg_create_token.h" #include "dlg_create_token.h"
#include "carddatabase.h" #include "carddatabase.h"
#include "color.h"
#include <QSettings> #include <QSettings>
#include <QPainter> #include <QPainter>
#include <QMenu> #include <QMenu>
@ -36,7 +37,10 @@
#include "pb/command_flip_card.pb.h" #include "pb/command_flip_card.pb.h"
#include "pb/command_game_say.pb.h" #include "pb/command_game_say.pb.h"
#include "pb/serverinfo_user.pb.h" #include "pb/serverinfo_user.pb.h"
#include "pb/serverinfo_player.pb.h"
#include "pb/serverinfo_zone.pb.h"
#include "pb/context_move_card.pb.h" #include "pb/context_move_card.pb.h"
#include "pb/context_undo_draw.pb.h"
#include "pb/event_connection_state_changed.pb.h" #include "pb/event_connection_state_changed.pb.h"
#include "pb/event_game_say.pb.h" #include "pb/event_game_say.pb.h"
#include "pb/event_shuffle.pb.h" #include "pb/event_shuffle.pb.h"
@ -941,30 +945,34 @@ void Player::eventStopDumpZone(const Event_StopDumpZone &event)
emit logStopDumpZone(this, zone); emit logStopDumpZone(this, zone);
} }
void Player::eventMoveCard(const Event_MoveCard &event, GameEventContext *context) void Player::eventMoveCard(const Event_MoveCard &event, const GameEventContext &context)
{ {
CardZone *startZone = zones.value(event->getStartZone(), 0); CardZone *startZone = zones.value(QString::fromStdString(event.start_zone()), 0);
Player *targetPlayer = static_cast<TabGame *>(parent())->getPlayers().value(event->getTargetPlayerId()); Player *targetPlayer = static_cast<TabGame *>(parent())->getPlayers().value(event.target_player_id());
if (!targetPlayer) if (!targetPlayer)
return; return;
CardZone *targetZone = targetPlayer->getZones().value(event->getTargetZone(), 0); CardZone *targetZone;
if (event.has_target_zone())
targetZone = targetPlayer->getZones().value(QString::fromStdString(event.target_zone()), 0);
else
targetZone = startZone;
if (!startZone || !targetZone) if (!startZone || !targetZone)
return; return;
int position = event->getPosition(); int position = event.position();
int x = event->getX(); int x = event.x();
int y = event->getY(); int y = event.y();
int logPosition = position; int logPosition = position;
int logX = x; int logX = x;
if (x == -1) if (x == -1)
x = 0; x = 0;
CardItem *card = startZone->takeCard(position, event->getCardId(), startZone != targetZone); CardItem *card = startZone->takeCard(position, event.card_id(), startZone != targetZone);
if (!card) if (!card)
return; return;
if (startZone != targetZone) if (startZone != targetZone)
card->deleteCardInfoPopup(); card->deleteCardInfoPopup();
card->setName(event->getCardName()); card->setName(QString::fromStdString(event.card_name()));
if (card->getAttachedTo() && (startZone != targetZone)) { if (card->getAttachedTo() && (startZone != targetZone)) {
CardItem *parentCard = card->getAttachedTo(); CardItem *parentCard = card->getAttachedTo();
@ -974,8 +982,8 @@ void Player::eventMoveCard(const Event_MoveCard &event, GameEventContext *contex
card->deleteDragItem(); card->deleteDragItem();
card->setId(event->getNewCardId()); card->setId(event.new_card_id());
card->setFaceDown(event->getFaceDown()); card->setFaceDown(event.face_down());
if (startZone != targetZone) { if (startZone != targetZone) {
card->setBeingPointedAt(false); card->setBeingPointedAt(false);
card->setHovered(false); card->setHovered(false);
@ -990,11 +998,8 @@ void Player::eventMoveCard(const Event_MoveCard &event, GameEventContext *contex
// The log event has to be sent before the card is added to the target zone // The log event has to be sent before the card is added to the target zone
// because the addCard function can modify the card object. // because the addCard function can modify the card object.
if (context) if (context.HasExtension(Context_UndoDraw::ext))
switch (context->getItemId()) { emit logUndoDraw(this, card->getName());
case ItemId_Context_UndoDraw: emit logUndoDraw(this, card->getName()); break;
default: emit logMoveCard(this, card, startZone, logPosition, targetZone, logX);
}
else else
emit logMoveCard(this, card, startZone, logPosition, targetZone, logX); emit logMoveCard(this, card, startZone, logPosition, targetZone, logX);
@ -1097,68 +1102,76 @@ void Player::eventDrawCards(const Event_DrawCards &event)
{ {
CardZone *deck = zones.value("deck"); CardZone *deck = zones.value("deck");
CardZone *hand = zones.value("hand"); CardZone *hand = zones.value("hand");
const QList<ServerInfo_Card *> &cardList = event->getCardList();
if (!cardList.isEmpty()) const int listSize = event.cards_size();
for (int i = 0; i < cardList.size(); ++i) { if (listSize) {
CardItem *card = deck->takeCard(0, cardList[i]->getId()); for (int i = 0; i < listSize; ++i) {
card->setName(cardList[i]->getName()); const ServerInfo_Card &cardInfo = event.cards(i);
CardItem *card = deck->takeCard(0, cardInfo.id());
card->setName(QString::fromStdString(cardInfo.name()));
hand->addCard(card, false, -1); hand->addCard(card, false, -1);
} }
else } else {
for (int i = 0; i < event->getNumberCards(); ++i) const int number = event.number();
for (int i = 0; i < number; ++i)
hand->addCard(deck->takeCard(0, -1), false, -1); hand->addCard(deck->takeCard(0, -1), false, -1);
}
hand->reorganizeCards(); hand->reorganizeCards();
deck->reorganizeCards(); deck->reorganizeCards();
emit logDrawCards(this, event->getNumberCards()); emit logDrawCards(this, event.number());
} }
void Player::eventRevealCards(Event_RevealCards *event) void Player::eventRevealCards(const Event_RevealCards &event)
{ {
CardZone *zone = zones.value(event->getZoneName()); CardZone *zone = zones.value(QString::fromStdString(event.zone_name()));
if (!zone) if (!zone)
return; return;
Player *otherPlayer = 0; Player *otherPlayer = 0;
if (event->getOtherPlayerId() != -1) { if (event.has_other_player_id()) {
otherPlayer = static_cast<TabGame *>(parent())->getPlayers().value(event->getOtherPlayerId()); otherPlayer = static_cast<TabGame *>(parent())->getPlayers().value(event.other_player_id());
if (!otherPlayer) if (!otherPlayer)
return; return;
} }
QList<ServerInfo_Card *> cardList = event->getCardList(); QList<const ServerInfo_Card *> cardList;
const int cardListSize = event.cards_size();
for (int i = 0; i < cardListSize; ++i) {
const ServerInfo_Card *temp = &event.cards(i);
cardList.append(temp);
}
if (!cardList.isEmpty()) if (!cardList.isEmpty())
static_cast<GameScene *>(scene())->addRevealedZoneView(this, zone, cardList); static_cast<GameScene *>(scene())->addRevealedZoneView(this, zone, cardList);
QString cardName; QString cardName;
if (cardList.size() == 1) if (cardList.size() == 1)
cardName = cardList.first()->getName(); cardName = QString::fromStdString(cardList.first()->name());
emit logRevealCards(this, zone, event->getCardId(), cardName, otherPlayer); emit logRevealCards(this, zone, event.card_id(), cardName, otherPlayer);
} }
void Player::processGameEvent(GameEvent *event, GameEventContext *context) void Player::processGameEvent(GameEvent::GameEventType type, const GameEvent &event, const GameEventContext &context)
{ {
qDebug() << "player event: id=" << event->getItemId(); switch (type) {
switch (event->getItemId()) { case GameEvent::CONNECTION_STATE_CHANGED: eventConnectionStateChanged(event.GetExtension(Event_ConnectionStateChanged::ext)); break;
case ItemId_Event_ConnectionStateChanged: eventConnectionStateChanged(static_cast<Event_ConnectionStateChanged *>(event)); break; case GameEvent::GAME_SAY: eventGameSay(event.GetExtension(Event_GameSay::ext)); break;
case ItemId_Event_Say: eventSay(static_cast<Event_Say *>(event)); break; case GameEvent::SHUFFLE: eventShuffle(event.GetExtension(Event_Shuffle::ext)); break;
case ItemId_Event_Shuffle: eventShuffle(static_cast<Event_Shuffle *>(event)); break; case GameEvent::ROLL_DIE: eventRollDie(event.GetExtension(Event_RollDie::ext)); break;
case ItemId_Event_RollDie: eventRollDie(static_cast<Event_RollDie *>(event)); break; case GameEvent::CREATE_ARROW: eventCreateArrow(event.GetExtension(Event_CreateArrow::ext)); break;
case ItemId_Event_CreateArrows: eventCreateArrows(static_cast<Event_CreateArrows *>(event)); break; case GameEvent::DELETE_ARROW: eventDeleteArrow(event.GetExtension(Event_DeleteArrow::ext)); break;
case ItemId_Event_DeleteArrow: eventDeleteArrow(static_cast<Event_DeleteArrow *>(event)); break; case GameEvent::CREATE_TOKEN: eventCreateToken(event.GetExtension(Event_CreateToken::ext)); break;
case ItemId_Event_CreateToken: eventCreateToken(static_cast<Event_CreateToken *>(event)); break; case GameEvent::SET_CARD_ATTR: eventSetCardAttr(event.GetExtension(Event_SetCardAttr::ext), context); break;
case ItemId_Event_SetCardAttr: eventSetCardAttr(static_cast<Event_SetCardAttr *>(event), context); break; case GameEvent::SET_CARD_COUNTER: eventSetCardCounter(event.GetExtension(Event_SetCardCounter::ext)); break;
case ItemId_Event_SetCardCounter: eventSetCardCounter(static_cast<Event_SetCardCounter *>(event)); break; case GameEvent::CREATE_COUNTER: eventCreateCounter(event.GetExtension(Event_CreateCounter::ext)); break;
case ItemId_Event_CreateCounters: eventCreateCounters(static_cast<Event_CreateCounters *>(event)); break; case GameEvent::SET_COUNTER: eventSetCounter(event.GetExtension(Event_SetCounter::ext)); break;
case ItemId_Event_SetCounter: eventSetCounter(static_cast<Event_SetCounter *>(event)); break; case GameEvent::DEL_COUNTER: eventDelCounter(event.GetExtension(Event_DelCounter::ext)); break;
case ItemId_Event_DelCounter: eventDelCounter(static_cast<Event_DelCounter *>(event)); break; case GameEvent::DUMP_ZONE: eventDumpZone(event.GetExtension(Event_DumpZone::ext)); break;
case ItemId_Event_DumpZone: eventDumpZone(static_cast<Event_DumpZone *>(event)); break; case GameEvent::STOP_DUMP_ZONE: eventStopDumpZone(event.GetExtension(Event_StopDumpZone::ext)); break;
case ItemId_Event_StopDumpZone: eventStopDumpZone(static_cast<Event_StopDumpZone *>(event)); break; case GameEvent::MOVE_CARD: eventMoveCard(event.GetExtension(Event_MoveCard::ext), context); break;
case ItemId_Event_MoveCard: eventMoveCard(static_cast<Event_MoveCard *>(event), context); break; case GameEvent::FLIP_CARD: eventFlipCard(event.GetExtension(Event_FlipCard::ext)); break;
case ItemId_Event_FlipCard: eventFlipCard(static_cast<Event_FlipCard *>(event)); break; case GameEvent::DESTROY_CARD: eventDestroyCard(event.GetExtension(Event_DestroyCard::ext)); break;
case ItemId_Event_DestroyCard: eventDestroyCard(static_cast<Event_DestroyCard *>(event)); break; case GameEvent::ATTACH_CARD: eventAttachCard(event.GetExtension(Event_AttachCard::ext)); break;
case ItemId_Event_AttachCard: eventAttachCard(static_cast<Event_AttachCard *>(event)); break; case GameEvent::DRAW_CARDS: eventDrawCards(event.GetExtension(Event_DrawCards::ext)); break;
case ItemId_Event_DrawCards: eventDrawCards(static_cast<Event_DrawCards *>(event)); break; case GameEvent::REVEAL_CARDS: eventRevealCards(event.GetExtension(Event_RevealCards::ext)); break;
case ItemId_Event_RevealCards: eventRevealCards(static_cast<Event_RevealCards *>(event)); break;
default: { default: {
qDebug() << "unhandled game event"; qDebug() << "unhandled game event";
} }
@ -1181,7 +1194,7 @@ void Player::paint(QPainter * /*painter*/, const QStyleOptionGraphicsItem */*opt
{ {
} }
void Player::processPlayerInfo(ServerInfo_Player *info) void Player::processPlayerInfo(const ServerInfo_Player &info)
{ {
clearCounters(); clearCounters();
clearArrows(); clearArrows();
@ -1190,54 +1203,54 @@ void Player::processPlayerInfo(ServerInfo_Player *info)
while (zoneIt.hasNext()) while (zoneIt.hasNext())
zoneIt.next().value()->clearContents(); zoneIt.next().value()->clearContents();
QList<ServerInfo_Zone *> zl = info->getZoneList(); const int zoneListSize = info.zone_list_size();
for (int i = 0; i < zl.size(); ++i) { for (int i = 0; i < zoneListSize; ++i) {
ServerInfo_Zone *zoneInfo = zl[i]; const ServerInfo_Zone &zoneInfo = info.zone_list(i);
CardZone *zone = zones.value(zoneInfo->getName(), 0); CardZone *zone = zones.value(QString::fromStdString(zoneInfo.name()), 0);
if (!zone) if (!zone)
continue; continue;
const QList<ServerInfo_Card *> &cardList = zoneInfo->getCardList(); const int cardListSize = zoneInfo.card_list_size();
if (cardList.isEmpty()) { if (!cardListSize) {
for (int j = 0; j < zoneInfo->getCardCount(); ++j) for (int j = 0; j < zoneInfo.card_count(); ++j)
zone->addCard(new CardItem(this), false, -1); zone->addCard(new CardItem(this), false, -1);
} else { } else {
for (int j = 0; j < cardList.size(); ++j) { for (int j = 0; j < cardListSize; ++j) {
const ServerInfo_Card &cardInfo = zoneInfo.card_list(j);
CardItem *card = new CardItem(this); CardItem *card = new CardItem(this);
card->processCardInfo(cardList[j]); card->processCardInfo(cardInfo);
zone->addCard(card, false, cardList[j]->getX(), cardList[j]->getY()); zone->addCard(card, false, cardInfo.x(), cardInfo.y());
} }
} }
zone->reorganizeCards(); zone->reorganizeCards();
} }
QList<ServerInfo_Counter *> cl = info->getCounterList(); const int counterListSize = info.counter_list_size();
for (int i = 0; i < cl.size(); ++i) { for (int i = 0; i < counterListSize; ++i)
addCounter(cl.at(i)); addCounter(info.counter_list(i));
}
QList<ServerInfo_Arrow *> al = info->getArrowList(); const int arrowListSize = info.arrow_list_size();
for (int i = 0; i < al.size(); ++i) for (int i = 0; i < arrowListSize; ++i)
addArrow(al.at(i)); addArrow(info.arrow_list(i));
setConceded(info->getProperties()->getConceded()); setConceded(info.properties().conceded());
} }
void Player::processCardAttachment(ServerInfo_Player *info) void Player::processCardAttachment(const ServerInfo_Player &info)
{ {
QList<ServerInfo_Zone *> zl = info->getZoneList(); const int zoneListSize = info.zone_list_size();
for (int i = 0; i < zl.size(); ++i) { for (int i = 0; i < zoneListSize; ++i) {
ServerInfo_Zone *zoneInfo = zl[i]; const ServerInfo_Zone &zoneInfo = info.zone_list(i);
CardZone *zone = zones.value(zoneInfo->getName(), 0); CardZone *zone = zones.value(QString::fromStdString(zoneInfo.name()), 0);
if (!zone) if (!zone)
continue; continue;
const QList<ServerInfo_Card *> &cardList = zoneInfo->getCardList(); const int cardListSize = zoneInfo.card_list_size();
for (int j = 0; j < cardList.size(); ++j) { for (int j = 0; j < cardListSize; ++j) {
ServerInfo_Card *cardInfo = cardList[j]; const ServerInfo_Card &cardInfo = zoneInfo.card_list(j);
if (cardInfo->getAttachPlayerId() != -1) { if (cardInfo.has_attach_player_id()) {
CardItem *startCard = zone->getCard(cardInfo->getId(), QString()); CardItem *startCard = zone->getCard(cardInfo.id(), QString());
CardItem *targetCard = static_cast<TabGame *>(parent())->getCard(cardInfo->getAttachPlayerId(), cardInfo->getAttachZone(), cardInfo->getAttachCardId()); CardItem *targetCard = static_cast<TabGame *>(parent())->getCard(cardInfo.attach_player_id(), QString::fromStdString(cardInfo.attach_zone()), cardInfo.attach_card_id());
if (!targetCard) if (!targetCard)
continue; continue;
@ -1292,7 +1305,7 @@ void Player::addZone(CardZone *z)
AbstractCounter *Player::addCounter(const ServerInfo_Counter &counter) AbstractCounter *Player::addCounter(const ServerInfo_Counter &counter)
{ {
return addCounter(counter.id(), QString::fromStdString(counter.name()), counter.color(), counter.radius(), counter.count()); return addCounter(counter.id(), QString::fromStdString(counter.name()), convertColorToQColor(counter.counter_color()), counter.radius(), counter.count());
} }
AbstractCounter *Player::addCounter(int counterId, const QString &name, QColor color, int radius, int value) AbstractCounter *Player::addCounter(int counterId, const QString &name, QColor color, int radius, int value)
@ -1339,27 +1352,29 @@ void Player::clearCounters()
ArrowItem *Player::addArrow(const ServerInfo_Arrow &arrow) ArrowItem *Player::addArrow(const ServerInfo_Arrow &arrow)
{ {
const QMap<int, Player *> &playerList = static_cast<TabGame *>(parent())->getPlayers(); const QMap<int, Player *> &playerList = static_cast<TabGame *>(parent())->getPlayers();
Player *startPlayer = playerList.value(arrow->getStartPlayerId(), 0); Player *startPlayer = playerList.value(arrow.start_player_id(), 0);
Player *targetPlayer = playerList.value(arrow->getTargetPlayerId(), 0); Player *targetPlayer = playerList.value(arrow.target_player_id(), 0);
if (!startPlayer || !targetPlayer) if (!startPlayer || !targetPlayer)
return 0; return 0;
CardZone *startZone = startPlayer->getZones().value(arrow->getStartZone(), 0); CardZone *startZone = startPlayer->getZones().value(QString::fromStdString(arrow.start_zone()), 0);
CardZone *targetZone = targetPlayer->getZones().value(arrow->getTargetZone(), 0); CardZone *targetZone = 0;
if (!startZone || (!targetZone && !arrow->getTargetZone().isEmpty())) if (arrow.has_target_zone())
targetZone = targetPlayer->getZones().value(QString::fromStdString(arrow.target_zone()), 0);
if (!startZone || (!targetZone && arrow.has_target_zone()))
return 0; return 0;
CardItem *startCard = startZone->getCard(arrow->getStartCardId(), QString()); CardItem *startCard = startZone->getCard(arrow.start_card_id(), QString());
CardItem *targetCard = 0; CardItem *targetCard = 0;
if (targetZone) if (targetZone)
targetCard = targetZone->getCard(arrow->getTargetCardId(), QString()); targetCard = targetZone->getCard(arrow.target_card_id(), QString());
if (!startCard || (!targetCard && !arrow->getTargetZone().isEmpty())) if (!startCard || (!targetCard && arrow.has_target_card_id()))
return 0; return 0;
if (targetCard) if (targetCard)
return addArrow(arrow->getId(), startCard, targetCard, arrow->getColor().getQColor()); return addArrow(arrow.id(), startCard, targetCard, convertColorToQColor(arrow.arrow_color()));
else else
return addArrow(arrow->getId(), startCard, targetPlayer->getPlayerTarget(), arrow->getColor().getQColor()); return addArrow(arrow.id(), startCard, targetPlayer->getPlayerTarget(), convertColorToQColor(arrow.arrow_color()));
} }
ArrowItem *Player::addArrow(int arrowId, CardItem *startCard, ArrowTarget *targetItem, const QColor &color) ArrowItem *Player::addArrow(int arrowId, CardItem *startCard, ArrowTarget *targetItem, const QColor &color)
@ -1740,7 +1755,7 @@ QMenu *Player::getCardMenu() const
QString Player::getName() const QString Player::getName() const
{ {
return userInfo->getName(); return QString::fromStdString(userInfo->name());
} }
qreal Player::getMinimumWidth() const qreal Player::getMinimumWidth() const

11
cockatrice/src/player.h
View file

@ -5,8 +5,9 @@
#include <QPoint> #include <QPoint>
#include <QMap> #include <QMap>
#include "abstractgraphicsitem.h" #include "abstractgraphicsitem.h"
#include <google/protobuf/message.h> #include "pb/game_event.pb.h"
namespace google { namespace protobuf { class Message; } }
class CardDatabase; class CardDatabase;
class QMenu; class QMenu;
class QAction; class QAction;
@ -197,7 +198,7 @@ private:
void eventDelCounter(const Event_DelCounter &event); void eventDelCounter(const Event_DelCounter &event);
void eventDumpZone(const Event_DumpZone &event); void eventDumpZone(const Event_DumpZone &event);
void eventStopDumpZone(const Event_StopDumpZone &event); void eventStopDumpZone(const Event_StopDumpZone &event);
void eventMoveCard(const Event_MoveCard &event, GameEventContext &context); void eventMoveCard(const Event_MoveCard &event, const GameEventContext &context);
void eventFlipCard(const Event_FlipCard &event); void eventFlipCard(const Event_FlipCard &event);
void eventDestroyCard(const Event_DestroyCard &event); void eventDestroyCard(const Event_DestroyCard &event);
void eventAttachCard(const Event_AttachCard &event); void eventAttachCard(const Event_AttachCard &event);
@ -255,10 +256,10 @@ public:
void setMirrored(bool _mirrored); void setMirrored(bool _mirrored);
void processSceneSizeChange(int newPlayerWidth); void processSceneSizeChange(int newPlayerWidth);
void processPlayerInfo(ServerInfo_Player *info); void processPlayerInfo(const ServerInfo_Player &info);
void processCardAttachment(ServerInfo_Player *info); void processCardAttachment(const ServerInfo_Player &info);
void processGameEvent(GameEvent *event, GameEventContext *context); void processGameEvent(GameEvent::GameEventType type, const GameEvent &event, const GameEventContext &context);
PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd); PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd);
PendingCommand *prepareGameCommand(const QList< const ::google::protobuf::Message * > &cmdList); PendingCommand *prepareGameCommand(const QList< const ::google::protobuf::Message * > &cmdList);

13
cockatrice/src/playertarget.cpp
View file

@ -1,7 +1,7 @@
#include "playertarget.h" #include "playertarget.h"
#include "player.h" #include "player.h"
#include "protocol_datastructures.h"
#include "pixmapgenerator.h" #include "pixmapgenerator.h"
#include "pb/serverinfo_user.pb.h"
#include <QPainter> #include <QPainter>
#include <QPixmapCache> #include <QPixmapCache>
#include <QDebug> #include <QDebug>
@ -51,7 +51,8 @@ PlayerTarget::PlayerTarget(Player *_owner, QGraphicsItem *parentItem)
{ {
setCacheMode(DeviceCoordinateCache); setCacheMode(DeviceCoordinateCache);
if (!fullPixmap.loadFromData(_owner->getUserInfo()->getAvatarBmp())) const std::string bmp = _owner->getUserInfo()->avatar_bmp();
if (!fullPixmap.loadFromData((const uchar *) bmp.data(), bmp.size()))
fullPixmap = QPixmap(); fullPixmap = QPixmap();
} }
@ -62,7 +63,7 @@ QRectF PlayerTarget::boundingRect() const
void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/) void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
{ {
ServerInfo_User *info = owner->getUserInfo(); const ServerInfo_User *const info = owner->getUserInfo();
const qreal border = 2; const qreal border = 2;
@ -70,7 +71,7 @@ void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*o
QRectF translatedRect = painter->combinedTransform().mapRect(avatarBoundingRect); QRectF translatedRect = painter->combinedTransform().mapRect(avatarBoundingRect);
QSize translatedSize = translatedRect.size().toSize(); QSize translatedSize = translatedRect.size().toSize();
QPixmap cachedPixmap; QPixmap cachedPixmap;
const QString cacheKey = "avatar" + QString::number(translatedSize.width()) + "_" + QString::number(info->getUserLevel()) + "_" + QString::number(fullPixmap.cacheKey()); const QString cacheKey = "avatar" + QString::number(translatedSize.width()) + "_" + QString::number(info->user_level()) + "_" + QString::number(fullPixmap.cacheKey());
#if QT_VERSION >= 0x040600 #if QT_VERSION >= 0x040600
if (!QPixmapCache::find(cacheKey, &cachedPixmap)) { if (!QPixmapCache::find(cacheKey, &cachedPixmap)) {
#else #else
@ -86,7 +87,7 @@ void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*o
QPixmap tempPixmap; QPixmap tempPixmap;
if (fullPixmap.isNull()) if (fullPixmap.isNull())
tempPixmap = UserLevelPixmapGenerator::generatePixmap(translatedSize.height(), info->getUserLevel()); tempPixmap = UserLevelPixmapGenerator::generatePixmap(translatedSize.height(), info->user_level());
else else
tempPixmap = fullPixmap.scaled(translatedSize, Qt::KeepAspectRatio, Qt::SmoothTransformation); tempPixmap = fullPixmap.scaled(translatedSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
@ -107,7 +108,7 @@ void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*o
painter->save(); painter->save();
painter->resetTransform(); painter->resetTransform();
QString name = info->getName(); QString name = QString::fromStdString(info->name());
if (name.size() > 13) if (name.size() > 13)
name = name.mid(0, 10) + "..."; name = name.mid(0, 10) + "...";

20
cockatrice/src/remotedecklist_treewidget.cpp
View file

@ -2,11 +2,11 @@
#include <QHeaderView> #include <QHeaderView>
#include <QSortFilterProxyModel> #include <QSortFilterProxyModel>
#include "remotedecklist_treewidget.h" #include "remotedecklist_treewidget.h"
#include "protocol_items.h"
#include "abstractclient.h" #include "abstractclient.h"
#include "pending_command.h" #include "pending_command.h"
#include "pb/session_commands.pb.h" #include "pb/session_commands.pb.h"
//#include "pb/response_deck_list.pb.h"
RemoteDeckList_TreeModel::DirectoryNode::DirectoryNode(const QString &_name, RemoteDeckList_TreeModel::DirectoryNode *_parent) RemoteDeckList_TreeModel::DirectoryNode::DirectoryNode(const QString &_name, RemoteDeckList_TreeModel::DirectoryNode *_parent)
: RemoteDeckList_TreeModel::Node(_name, _parent) : RemoteDeckList_TreeModel::Node(_name, _parent)
@ -204,19 +204,21 @@ QModelIndex RemoteDeckList_TreeModel::nodeToIndex(Node *node) const
void RemoteDeckList_TreeModel::addFileToTree(DeckList_File *file, DirectoryNode *parent) void RemoteDeckList_TreeModel::addFileToTree(DeckList_File *file, DirectoryNode *parent)
{ {
beginInsertRows(nodeToIndex(parent), parent->size(), parent->size()); /* beginInsertRows(nodeToIndex(parent), parent->size(), parent->size());
parent->append(new FileNode(file->getName(), file->getId(), file->getUploadTime(), parent)); parent->append(new FileNode(file->getName(), file->getId(), file->getUploadTime(), parent));
endInsertRows(); endInsertRows();
*/
} }
void RemoteDeckList_TreeModel::addFolderToTree(DeckList_Directory *folder, DirectoryNode *parent) void RemoteDeckList_TreeModel::addFolderToTree(DeckList_Directory *folder, DirectoryNode *parent)
{ {
addFolderToTree(folder->getName(), folder->getTreeItems(), parent); // addFolderToTree(folder->getName(), folder->getTreeItems(), parent);
} }
void RemoteDeckList_TreeModel::addFolderToTree(const QString &name, const QList<DeckList_TreeItem *> &folderItems, DirectoryNode *parent) void RemoteDeckList_TreeModel::addFolderToTree(const QString &name, const QList<DeckList_TreeItem *> &folderItems, DirectoryNode *parent)
{ {
DirectoryNode *newItem = new DirectoryNode(name, parent); /* DirectoryNode *newItem = new DirectoryNode(name, parent);
beginInsertRows(nodeToIndex(parent), parent->size(), parent->size()); beginInsertRows(nodeToIndex(parent), parent->size(), parent->size());
parent->append(newItem); parent->append(newItem);
endInsertRows(); endInsertRows();
@ -228,6 +230,7 @@ void RemoteDeckList_TreeModel::addFolderToTree(const QString &name, const QList<
else else
addFileToTree(dynamic_cast<DeckList_File *>(folderItems[i]), newItem); addFileToTree(dynamic_cast<DeckList_File *>(folderItems[i]), newItem);
} }
*/
} }
void RemoteDeckList_TreeModel::removeNode(RemoteDeckList_TreeModel::Node *node) void RemoteDeckList_TreeModel::removeNode(RemoteDeckList_TreeModel::Node *node)
@ -242,22 +245,21 @@ void RemoteDeckList_TreeModel::removeNode(RemoteDeckList_TreeModel::Node *node)
void RemoteDeckList_TreeModel::refreshTree() void RemoteDeckList_TreeModel::refreshTree()
{ {
PendingCommand *pend = client->prepareSessionCommand(Command_DeckList()); PendingCommand *pend = client->prepareSessionCommand(Command_DeckList());
connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(deckListFinished(ProtocolResponse *))); connect(pend, SIGNAL(finished(const Response &)), this, SLOT(deckListFinished(const Response &)));
client->sendCommand(pend); client->sendCommand(pend);
} }
void RemoteDeckList_TreeModel::deckListFinished(ProtocolResponse *r) void RemoteDeckList_TreeModel::deckListFinished(const Response &r)
{ {
Response_DeckList *resp = qobject_cast<Response_DeckList *>(r); /* const Response_DeckList &resp = r.GetExtension(Response_DeckList::ext);
if (!resp)
return;
root->clearTree(); root->clearTree();
reset(); reset();
addFolderToTree(resp->getRoot(), root); addFolderToTree(resp->getRoot(), root);
emit treeRefreshed(); emit treeRefreshed();
*/
} }
RemoteDeckList_TreeWidget::RemoteDeckList_TreeWidget(AbstractClient *_client, QWidget *parent) RemoteDeckList_TreeWidget::RemoteDeckList_TreeWidget(AbstractClient *_client, QWidget *parent)

4
cockatrice/src/remotedecklist_treewidget.h
View file

@ -5,7 +5,7 @@
#include <QDateTime> #include <QDateTime>
#include <QTreeView> #include <QTreeView>
class ProtocolResponse; class Response;
class AbstractClient; class AbstractClient;
class QSortFilterProxyModel; class QSortFilterProxyModel;
class DeckList_File; class DeckList_File;
@ -64,7 +64,7 @@ private:
signals: signals:
void treeRefreshed(); void treeRefreshed();
private slots: private slots:
void deckListFinished(ProtocolResponse *r); void deckListFinished(const Response &r);
public: public:
RemoteDeckList_TreeModel(AbstractClient *_client, QObject *parent = 0); RemoteDeckList_TreeModel(AbstractClient *_client, QObject *parent = 0);
~RemoteDeckList_TreeModel(); ~RemoteDeckList_TreeModel();

1
cockatrice/src/stackzone.cpp
View file

@ -5,6 +5,7 @@
#include "settingscache.h" #include "settingscache.h"
#include "player.h" #include "player.h"
#include "carddragitem.h" #include "carddragitem.h"
#include "carditem.h"
#include "pb/command_move_card.pb.h" #include "pb/command_move_card.pb.h"

242
cockatrice/src/tab_game.cpp
View file

@ -18,7 +18,6 @@
#include "zoneviewwidget.h" #include "zoneviewwidget.h"
#include "deckview.h" #include "deckview.h"
#include "decklist.h" #include "decklist.h"
#include "protocol_items.h"
#include "dlg_load_remote_deck.h" #include "dlg_load_remote_deck.h"
#include "abstractclient.h" #include "abstractclient.h"
#include "carditem.h" #include "carditem.h"
@ -38,6 +37,22 @@
#include "pb/command_set_active_phase.pb.h" #include "pb/command_set_active_phase.pb.h"
#include "pb/command_next_turn.pb.h" #include "pb/command_next_turn.pb.h"
#include "pb/command_delete_arrow.pb.h" #include "pb/command_delete_arrow.pb.h"
#include "pb/response_deck_download.pb.h"
#include "pb/game_event_container.pb.h"
#include "pb/event_game_joined.pb.h"
#include "pb/event_game_say.pb.h"
#include "pb/event_game_state_changed.pb.h"
#include "pb/event_player_properties_changed.pb.h"
#include "pb/event_join.pb.h"
#include "pb/event_leave.pb.h"
#include "pb/event_kicked.pb.h"
#include "pb/event_game_host_changed.pb.h"
#include "pb/event_game_closed.pb.h"
#include "pb/event_set_active_player.pb.h"
#include "pb/event_set_active_phase.pb.h"
#include "pb/event_ping.pb.h"
#include "pb/context_deck_select.pb.h"
#include "get_pb_extension.h"
ReadyStartButton::ReadyStartButton(QWidget *parent) ReadyStartButton::ReadyStartButton(QWidget *parent)
: QPushButton(parent), readyStart(false) : QPushButton(parent), readyStart(false)
@ -125,7 +140,7 @@ void DeckViewContainer::loadLocalDeck()
Command_DeckSelect cmd; Command_DeckSelect cmd;
cmd.set_deck(deck->writeToString_Native().toStdString()); cmd.set_deck(deck->writeToString_Native().toStdString());
PendingCommand *pend = static_cast<TabGame *>(parent())->prepareGameCommand(cmd); PendingCommand *pend = static_cast<TabGame *>(parent())->prepareGameCommand(cmd);
connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(deckSelectFinished(ProtocolResponse *))); connect(pend, SIGNAL(finished(const Response &)), this, SLOT(deckSelectFinished(const Response &)));
static_cast<TabGame *>(parent())->sendGameCommand(pend, playerId); static_cast<TabGame *>(parent())->sendGameCommand(pend, playerId);
} }
@ -136,19 +151,17 @@ void DeckViewContainer::loadRemoteDeck()
Command_DeckSelect cmd; Command_DeckSelect cmd;
cmd.set_deck_id(dlg.getDeckId()); cmd.set_deck_id(dlg.getDeckId());
PendingCommand *pend = static_cast<TabGame *>(parent())->prepareGameCommand(cmd); PendingCommand *pend = static_cast<TabGame *>(parent())->prepareGameCommand(cmd);
connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(deckSelectFinished(ProtocolResponse *))); connect(pend, SIGNAL(finished(const Response &)), this, SLOT(deckSelectFinished(const Response &)));
static_cast<TabGame *>(parent())->sendGameCommand(pend, playerId); static_cast<TabGame *>(parent())->sendGameCommand(pend, playerId);
} }
} }
void DeckViewContainer::deckSelectFinished(ProtocolResponse *r) void DeckViewContainer::deckSelectFinished(const Response &r)
{ {
Response_DeckDownload *resp = qobject_cast<Response_DeckDownload *>(r); const Response_DeckDownload &resp = r.GetExtension(Response_DeckDownload::ext);
if (!resp) DeckList *newDeck = new DeckList(QString::fromStdString(resp.deck()));
return; db->cacheCardPixmaps(newDeck->getCardList());
deckView->setDeck(newDeck);
db->cacheCardPixmaps(resp->getDeck()->getCardList());
deckView->setDeck(new DeckList(resp->getDeck()));
readyStartButton->setEnabled(true); readyStartButton->setEnabled(true);
} }
@ -180,8 +193,20 @@ void DeckViewContainer::setDeck(DeckList *deck)
readyStartButton->setEnabled(true); readyStartButton->setEnabled(true);
} }
TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, int _gameId, const QString &_gameDescription, int _hostId, int _localPlayerId, bool _spectator, bool _spectatorsCanTalk, bool _spectatorsSeeEverything, bool _resuming) TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, const Event_GameJoined &event)
: Tab(_tabSupervisor), clients(_clients), gameId(_gameId), gameDescription(_gameDescription), hostId(_hostId), localPlayerId(_localPlayerId), spectator(_spectator), spectatorsCanTalk(_spectatorsCanTalk), spectatorsSeeEverything(_spectatorsSeeEverything), gameStateKnown(false), started(false), resuming(_resuming), currentPhase(-1) : Tab(_tabSupervisor),
clients(_clients),
gameId(event.game_id()),
gameDescription(QString::fromStdString(event.game_description())),
hostId(event.host_id()),
localPlayerId(event.player_id()),
spectator(event.spectator()),
spectatorsCanTalk(event.spectators_can_talk()),
spectatorsSeeEverything(event.spectators_see_everything()),
gameStateKnown(false),
started(false),
resuming(event.resuming()),
currentPhase(-1)
{ {
phasesToolbar = new PhasesToolbar; phasesToolbar = new PhasesToolbar;
phasesToolbar->hide(); phasesToolbar->hide();
@ -198,7 +223,7 @@ TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_client
timeElapsedLabel = new QLabel; timeElapsedLabel = new QLabel;
timeElapsedLabel->setAlignment(Qt::AlignCenter); timeElapsedLabel->setAlignment(Qt::AlignCenter);
messageLog = new MessageLogWidget(tabSupervisor->getUserInfo()->getName(), tabSupervisor->getUserInfo()->getGender() == ServerInfo_User::Female); messageLog = new MessageLogWidget(QString::fromStdString(tabSupervisor->getUserInfo()->name()), tabSupervisor->getUserInfo()->gender() == ServerInfo_User::Female);
connect(messageLog, SIGNAL(cardNameHovered(QString)), cardInfo, SLOT(setCard(QString))); connect(messageLog, SIGNAL(cardNameHovered(QString)), cardInfo, SLOT(setCard(QString)));
connect(messageLog, SIGNAL(showCardInfoPopup(QPoint, QString)), this, SLOT(showCardInfoPopup(QPoint, QString))); connect(messageLog, SIGNAL(showCardInfoPopup(QPoint, QString)), this, SLOT(showCardInfoPopup(QPoint, QString)));
connect(messageLog, SIGNAL(deleteCardInfoPopup(QString)), this, SLOT(deleteCardInfoPopup(QString))); connect(messageLog, SIGNAL(deleteCardInfoPopup(QString)), this, SLOT(deleteCardInfoPopup(QString)));
@ -411,7 +436,7 @@ void TabGame::actRemoveLocalArrows()
} }
} }
Player *TabGame::addPlayer(int playerId, ServerInfo_User *info) Player *TabGame::addPlayer(int playerId, const ServerInfo_User &info)
{ {
bool local = ((clients.size() > 1) || (playerId == localPlayerId)); bool local = ((clients.size() > 1) || (playerId == localPlayerId));
Player *newPlayer = new Player(info, playerId, local, this); Player *newPlayer = new Player(info, playerId, local, this);
@ -438,47 +463,48 @@ Player *TabGame::addPlayer(int playerId, ServerInfo_User *info)
return newPlayer; return newPlayer;
} }
void TabGame::processGameEventContainer(GameEventContainer *cont, AbstractClient *client) void TabGame::processGameEventContainer(const GameEventContainer &cont, AbstractClient *client)
{ {
const QList<GameEvent *> &eventList = cont->getEventList(); const GameEventContext &context = cont.context();
GameEventContext *context = cont->getContext();
messageLog->containerProcessingStarted(context); messageLog->containerProcessingStarted(context);
for (int i = 0; i < eventList.size(); ++i) { const int eventListSize = cont.event_list_size();
GameEvent *event = eventList[i]; for (int i = 0; i < eventListSize; ++i) {
const GameEvent &event = cont.event_list(i);
if (spectators.contains(event->getPlayerId())) { const int playerId = event.player_id();
switch (event->getItemId()) { const GameEvent::GameEventType eventType = static_cast<GameEvent::GameEventType>(getPbExtension(event));
case ItemId_Event_Say: eventSpectatorSay(static_cast<Event_Say *>(event), context); break; if (spectators.contains(playerId)) {
case ItemId_Event_Leave: eventSpectatorLeave(static_cast<Event_Leave *>(event), context); break; switch (eventType) {
case GameEvent::GAME_SAY: eventSpectatorSay(event.GetExtension(Event_GameSay::ext), playerId, context); break;
case GameEvent::LEAVE: eventSpectatorLeave(event.GetExtension(Event_Leave::ext), playerId, context); break;
default: { default: {
qDebug() << "unhandled spectator game event"; qDebug() << "unhandled spectator game event";
break; break;
} }
} }
} else { } else {
if ((clients.size() > 1) && (event->getPlayerId() != -1)) if ((clients.size() > 1) && (playerId != -1))
if (clients.at(event->getPlayerId()) != client) if (clients.at(playerId) != client)
continue; continue;
switch (event->getItemId()) { switch (eventType) {
case ItemId_Event_GameStateChanged: eventGameStateChanged(static_cast<Event_GameStateChanged *>(event), context); break; case GameEvent::GAME_STATE_CHANGED: eventGameStateChanged(event.GetExtension(Event_GameStateChanged::ext), playerId, context); break;
case ItemId_Event_PlayerPropertiesChanged: eventPlayerPropertiesChanged(static_cast<Event_PlayerPropertiesChanged *>(event), context); break; case GameEvent::PLAYER_PROPERTIES_CHANGED: eventPlayerPropertiesChanged(event.GetExtension(Event_PlayerPropertiesChanged::ext), playerId, context); break;
case ItemId_Event_Join: eventJoin(static_cast<Event_Join *>(event), context); break; case GameEvent::JOIN: eventJoin(event.GetExtension(Event_Join::ext), playerId, context); break;
case ItemId_Event_Leave: eventLeave(static_cast<Event_Leave *>(event), context); break; case GameEvent::LEAVE: eventLeave(event.GetExtension(Event_Leave::ext), playerId, context); break;
case ItemId_Event_Kicked: eventKicked(static_cast<Event_Kicked *>(event), context); break; case GameEvent::KICKED: eventKicked(event.GetExtension(Event_Kicked::ext), playerId, context); break;
case ItemId_Event_GameHostChanged: eventGameHostChanged(static_cast<Event_GameHostChanged *>(event), context); break; case GameEvent::GAME_HOST_CHANGED: eventGameHostChanged(event.GetExtension(Event_GameHostChanged::ext), playerId, context); break;
case ItemId_Event_GameClosed: eventGameClosed(static_cast<Event_GameClosed *>(event), context); break; case GameEvent::GAME_CLOSED: eventGameClosed(event.GetExtension(Event_GameClosed::ext), playerId, context); break;
case ItemId_Event_SetActivePlayer: eventSetActivePlayer(static_cast<Event_SetActivePlayer *>(event), context); break; case GameEvent::SET_ACTIVE_PLAYER: eventSetActivePlayer(event.GetExtension(Event_SetActivePlayer::ext), playerId, context); break;
case ItemId_Event_SetActivePhase: eventSetActivePhase(static_cast<Event_SetActivePhase *>(event), context); break; case GameEvent::SET_ACTIVE_PHASE: eventSetActivePhase(event.GetExtension(Event_SetActivePhase::ext), playerId, context); break;
case ItemId_Event_Ping: eventPing(static_cast<Event_Ping *>(event), context); break; case GameEvent::PING: eventPing(event.GetExtension(Event_Ping::ext), playerId, context); break;
default: { default: {
Player *player = players.value(event->getPlayerId(), 0); Player *player = players.value(playerId, 0);
if (!player) { if (!player) {
qDebug() << "unhandled game event: invalid player id"; qDebug() << "unhandled game event: invalid player id";
break; break;
} }
player->processGameEvent(event, context); player->processGameEvent(eventType, event, context);
emit userEvent(); emit userEvent();
} }
} }
@ -574,62 +600,63 @@ void TabGame::stopGame()
phasesToolbar->hide(); phasesToolbar->hide();
} }
void TabGame::eventSpectatorSay(Event_Say *event, GameEventContext * /*context*/) void TabGame::eventSpectatorSay(const Event_GameSay &event, int eventPlayerId, const GameEventContext & /*context*/)
{ {
messageLog->logSpectatorSay(spectators.value(event->getPlayerId()), event->getMessage()); messageLog->logSpectatorSay(spectators.value(eventPlayerId), QString::fromStdString(event.message()));
} }
void TabGame::eventSpectatorLeave(Event_Leave *event, GameEventContext * /*context*/) void TabGame::eventSpectatorLeave(const Event_Leave & /*event*/, int eventPlayerId, const GameEventContext & /*context*/)
{ {
int playerId = event->getPlayerId(); messageLog->logLeaveSpectator(spectators.value(eventPlayerId));
messageLog->logLeaveSpectator(spectators.value(playerId)); playerListWidget->removePlayer(eventPlayerId);
playerListWidget->removePlayer(playerId); spectators.remove(eventPlayerId);
spectators.remove(playerId);
emit userEvent(); emit userEvent();
} }
void TabGame::eventGameStateChanged(Event_GameStateChanged *event, GameEventContext * /*context*/) void TabGame::eventGameStateChanged(const Event_GameStateChanged &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
{ {
const QList<ServerInfo_Player *> &plList = event->getPlayerList(); const int playerListSize = event.player_list_size();
for (int i = 0; i < plList.size(); ++i) { for (int i = 0; i < playerListSize; ++i) {
ServerInfo_Player *pl = plList[i]; const ServerInfo_Player &playerInfo = event.player_list(i);
ServerInfo_PlayerProperties *prop = pl->getProperties(); const ServerInfo_PlayerProperties &prop = playerInfo.properties();
if (prop->getSpectator()) { const int playerId = prop.player_id();
if (!spectators.contains(prop->getPlayerId())) { if (prop.spectator()) {
spectators.insert(prop->getPlayerId(), prop->getUserInfo()->getName()); if (!spectators.contains(playerId)) {
spectators.insert(playerId, QString::fromStdString(prop.user_info().name()));
playerListWidget->addPlayer(prop); playerListWidget->addPlayer(prop);
} }
} else { } else {
Player *player = players.value(prop->getPlayerId(), 0); Player *player = players.value(playerId, 0);
if (!player) { if (!player) {
player = addPlayer(prop->getPlayerId(), prop->getUserInfo()); player = addPlayer(playerId, prop.user_info());
playerListWidget->addPlayer(prop); playerListWidget->addPlayer(prop);
} }
player->processPlayerInfo(pl); player->processPlayerInfo(playerInfo);
if (player->getLocal() && !pl->getDeck()->isEmpty()) { if (player->getLocal() && playerInfo.has_deck_list()) {
db->cacheCardPixmaps(pl->getDeck()->getCardList()); DeckList *newDeck = new DeckList(QString::fromStdString(playerInfo.deck_list()));
deckViewContainers.value(player->getId())->setDeck(new DeckList(pl->getDeck())); db->cacheCardPixmaps(newDeck->getCardList());
deckViewContainers.value(playerId)->setDeck(newDeck);
} }
} }
} }
for (int i = 0; i < plList.size(); ++i) { for (int i = 0; i < playerListSize; ++i) {
ServerInfo_Player *pl = plList[i]; const ServerInfo_Player &playerInfo = event.player_list(i);
ServerInfo_PlayerProperties *prop = pl->getProperties(); const ServerInfo_PlayerProperties &prop = playerInfo.properties();
if (!prop->getSpectator()) { if (!prop.spectator()) {
Player *player = players.value(prop->getPlayerId(), 0); Player *player = players.value(prop.player_id(), 0);
if (!player) if (!player)
continue; continue;
player->processCardAttachment(pl); player->processCardAttachment(playerInfo);
} }
} }
if (event->getGameStarted() && !started) { if (event.game_started() && !started) {
startGame(!gameStateKnown); startGame(!gameStateKnown);
if (gameStateKnown) if (gameStateKnown)
messageLog->logGameStart(); messageLog->logGameStart();
setActivePlayer(event->getActivePlayer()); setActivePlayer(event.active_player_id());
setActivePhase(event->getActivePhase()); setActivePhase(event.active_phase());
} else if (!event->getGameStarted() && started) { } else if (!event.game_started() && started) {
stopGame(); stopGame();
scene->clearViews(); scene->clearViews();
} }
@ -637,15 +664,17 @@ void TabGame::eventGameStateChanged(Event_GameStateChanged *event, GameEventCont
emit userEvent(); emit userEvent();
} }
void TabGame::eventPlayerPropertiesChanged(Event_PlayerPropertiesChanged *event, GameEventContext *context) void TabGame::eventPlayerPropertiesChanged(const Event_PlayerPropertiesChanged &event, int eventPlayerId, const GameEventContext &context)
{ {
Player *player = players.value(event->getProperties()->getPlayerId(), 0); Player *player = players.value(eventPlayerId, 0);
if (!player) if (!player)
return; return;
playerListWidget->updatePlayerProperties(event->getProperties()); playerListWidget->updatePlayerProperties(event.player_properties());
if (context) switch (context->getItemId()) {
case ItemId_Context_ReadyStart: { const GameEventContext::ContextType contextType = static_cast<const GameEventContext::ContextType>(getPbExtension(context));
bool ready = event->getProperties()->getReadyStart(); switch (contextType) {
case GameEventContext::READY_START: {
bool ready = event.player_properties().ready_start();
if (player->getLocal()) if (player->getLocal())
deckViewContainers.value(player->getId())->setReadyStart(ready); deckViewContainers.value(player->getId())->setReadyStart(ready);
if (ready) if (ready)
@ -654,7 +683,7 @@ void TabGame::eventPlayerPropertiesChanged(Event_PlayerPropertiesChanged *event,
messageLog->logNotReadyStart(player); messageLog->logNotReadyStart(player);
break; break;
} }
case ItemId_Context_Concede: { case GameEventContext::CONCEDE: {
messageLog->logConcede(player); messageLog->logConcede(player);
player->setConceded(true); player->setConceded(true);
@ -664,39 +693,40 @@ void TabGame::eventPlayerPropertiesChanged(Event_PlayerPropertiesChanged *event,
break; break;
} }
case ItemId_Context_DeckSelect: messageLog->logDeckSelect(player, static_cast<Context_DeckSelect *>(context)->getDeckHash()); break; case GameEventContext::DECK_SELECT: {
messageLog->logDeckSelect(player, QString::fromStdString(context.GetExtension(Context_DeckSelect::ext).deck_hash()));
break;
}
default: ; default: ;
} }
} }
void TabGame::eventJoin(Event_Join *event, GameEventContext * /*context*/) void TabGame::eventJoin(const Event_Join &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
{ {
ServerInfo_PlayerProperties *playerInfo = event->getPlayer(); const ServerInfo_PlayerProperties &playerInfo = event.player_properties();
if (players.contains(playerInfo->getPlayerId())) const int playerId = playerInfo.player_id();
if (players.contains(playerId))
return; return;
if (playerInfo->getSpectator()) { if (playerInfo.spectator()) {
spectators.insert(playerInfo->getPlayerId(), playerInfo->getUserInfo()->getName()); spectators.insert(playerId, QString::fromStdString(playerInfo.user_info().name()));
messageLog->logJoinSpectator(playerInfo->getUserInfo()->getName()); messageLog->logJoinSpectator(QString::fromStdString(playerInfo.user_info().name()));
playerListWidget->addPlayer(playerInfo);
} else { } else {
Player *newPlayer = addPlayer(playerInfo->getPlayerId(), playerInfo->getUserInfo()); Player *newPlayer = addPlayer(playerId, playerInfo.user_info());
messageLog->logJoin(newPlayer); messageLog->logJoin(newPlayer);
playerListWidget->addPlayer(playerInfo);
} }
playerListWidget->addPlayer(playerInfo);
emit userEvent(); emit userEvent();
} }
void TabGame::eventLeave(Event_Leave *event, GameEventContext * /*context*/) void TabGame::eventLeave(const Event_Leave & /*event*/, int eventPlayerId, const GameEventContext & /*context*/)
{ {
int playerId = event->getPlayerId(); Player *player = players.value(eventPlayerId, 0);
Player *player = players.value(playerId, 0);
if (!player) if (!player)
return; return;
messageLog->logLeave(player); messageLog->logLeave(player);
playerListWidget->removePlayer(playerId); playerListWidget->removePlayer(eventPlayerId);
players.remove(playerId); players.remove(eventPlayerId);
emit playerRemoved(player); emit playerRemoved(player);
player->clear(); player->clear();
player->deleteLater(); player->deleteLater();
@ -709,19 +739,19 @@ void TabGame::eventLeave(Event_Leave *event, GameEventContext * /*context*/)
emit userEvent(); emit userEvent();
} }
void TabGame::eventKicked(Event_Kicked * /*event*/, GameEventContext * /*context*/) void TabGame::eventKicked(const Event_Kicked & /*event*/, int /*eventPlayerId*/, const GameEventContext & /*context*/)
{ {
emit userEvent(); emit userEvent();
QMessageBox::critical(this, tr("Kicked"), tr("You have been kicked out of the game.")); QMessageBox::critical(this, tr("Kicked"), tr("You have been kicked out of the game."));
deleteLater(); deleteLater();
} }
void TabGame::eventGameHostChanged(Event_GameHostChanged *event, GameEventContext * /*context*/) void TabGame::eventGameHostChanged(const Event_GameHostChanged & /*event*/, int eventPlayerId, const GameEventContext & /*context*/)
{ {
hostId = event->getPlayerId(); hostId = eventPlayerId;
} }
void TabGame::eventGameClosed(Event_GameClosed * /*event*/, GameEventContext * /*context*/) void TabGame::eventGameClosed(const Event_GameClosed & /*event*/, int /*eventPlayerId*/, const GameEventContext & /*context*/)
{ {
started = false; started = false;
messageLog->logGameClosed(); messageLog->logGameClosed();
@ -753,9 +783,9 @@ Player *TabGame::setActivePlayer(int id)
return player; return player;
} }
void TabGame::eventSetActivePlayer(Event_SetActivePlayer *event, GameEventContext * /*context*/) void TabGame::eventSetActivePlayer(const Event_SetActivePlayer &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
{ {
Player *player = setActivePlayer(event->getActivePlayerId()); Player *player = setActivePlayer(event.active_player_id());
if (!player) if (!player)
return; return;
messageLog->logSetActivePlayer(player); messageLog->logSetActivePlayer(player);
@ -770,22 +800,22 @@ void TabGame::setActivePhase(int phase)
} }
} }
void TabGame::eventSetActivePhase(Event_SetActivePhase *event, GameEventContext * /*context*/) void TabGame::eventSetActivePhase(const Event_SetActivePhase &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
{ {
int phase = event->getPhase(); const int phase = event.phase();
if (currentPhase != phase) if (currentPhase != phase)
messageLog->logSetActivePhase(phase); messageLog->logSetActivePhase(phase);
setActivePhase(phase); setActivePhase(phase);
emit userEvent(); emit userEvent();
} }
void TabGame::eventPing(Event_Ping *event, GameEventContext * /*context*/) void TabGame::eventPing(const Event_Ping &event, int /*eventPlayerId*/, const GameEventContext & /*context*/)
{ {
const QList<ServerInfo_PlayerPing *> &pingList = event->getPingList(); const int pingListSize = event.ping_list_size();
for (int i = 0; i < pingList.size(); ++i) for (int i = 0; i < pingListSize; ++i)
playerListWidget->updatePing(pingList[i]->getPlayerId(), pingList[i]->getPingTime()); playerListWidget->updatePing(event.ping_list(i).player_id(), event.ping_list(i).ping_time());
int seconds = event->getSecondsElapsed(); int seconds = event.seconds_elapsed();
int minutes = seconds / 60; int minutes = seconds / 60;
seconds -= minutes * 60; seconds -= minutes * 60;
int hours = minutes / 60; int hours = minutes / 60;

41
cockatrice/src/tab_game.h
View file

@ -4,8 +4,8 @@
#include <QMap> #include <QMap>
#include <QPushButton> #include <QPushButton>
#include "tab.h" #include "tab.h"
#include <google/protobuf/message.h>
namespace google { namespace protobuf { class Message; } }
class AbstractClient; class AbstractClient;
class CardDatabase; class CardDatabase;
class GameView; class GameView;
@ -22,11 +22,12 @@ class ZoneViewLayout;
class ZoneViewWidget; class ZoneViewWidget;
class PhasesToolbar; class PhasesToolbar;
class PlayerListWidget; class PlayerListWidget;
class ProtocolResponse; class Response;
class GameEventContainer; class GameEventContainer;
class GameEventContext; class GameEventContext;
class GameCommand; class GameCommand;
class CommandContainer; class CommandContainer;
class Event_GameJoined;
class Event_GameStateChanged; class Event_GameStateChanged;
class Event_PlayerPropertiesChanged; class Event_PlayerPropertiesChanged;
class Event_Join; class Event_Join;
@ -37,7 +38,7 @@ class Event_GameStart;
class Event_SetActivePlayer; class Event_SetActivePlayer;
class Event_SetActivePhase; class Event_SetActivePhase;
class Event_Ping; class Event_Ping;
class Event_Say; class Event_GameSay;
class Event_Kicked; class Event_Kicked;
class Player; class Player;
class CardZone; class CardZone;
@ -73,7 +74,7 @@ private slots:
void loadLocalDeck(); void loadLocalDeck();
void loadRemoteDeck(); void loadRemoteDeck();
void readyStart(); void readyStart();
void deckSelectFinished(ProtocolResponse *r); void deckSelectFinished(const Response &r);
void sideboardPlanChanged(); void sideboardPlanChanged();
signals: signals:
void newCardAdded(AbstractCardItem *card); void newCardAdded(AbstractCardItem *card);
@ -123,31 +124,31 @@ private:
QAction *aConcede, *aLeaveGame, *aNextPhase, *aNextTurn, *aRemoveLocalArrows; QAction *aConcede, *aLeaveGame, *aNextPhase, *aNextTurn, *aRemoveLocalArrows;
QList<QAction *> phaseActions; QList<QAction *> phaseActions;
Player *addPlayer(int playerId, ServerInfo_User *info); Player *addPlayer(int playerId, const ServerInfo_User &info);
void startGame(bool resuming); void startGame(bool resuming);
void stopGame(); void stopGame();
void eventSpectatorSay(Event_Say *event, GameEventContext *context); void eventSpectatorSay(const Event_GameSay &event, int eventPlayerId, const GameEventContext &context);
void eventSpectatorLeave(Event_Leave *event, GameEventContext *context); void eventSpectatorLeave(const Event_Leave &event, int eventPlayerId, const GameEventContext &context);
void eventGameStateChanged(Event_GameStateChanged *event, GameEventContext *context); void eventGameStateChanged(const Event_GameStateChanged &event, int eventPlayerId, const GameEventContext &context);
void eventPlayerPropertiesChanged(Event_PlayerPropertiesChanged *event, GameEventContext *context); void eventPlayerPropertiesChanged(const Event_PlayerPropertiesChanged &event, int eventPlayerId, const GameEventContext &context);
void eventJoin(Event_Join *event, GameEventContext *context); void eventJoin(const Event_Join &event, int eventPlayerId, const GameEventContext &context);
void eventLeave(Event_Leave *event, GameEventContext *context); void eventLeave(const Event_Leave &event, int eventPlayerId, const GameEventContext &context);
void eventKicked(Event_Kicked *event, GameEventContext *context); void eventKicked(const Event_Kicked &event, int eventPlayerId, const GameEventContext &context);
void eventGameHostChanged(Event_GameHostChanged *event, GameEventContext *context); void eventGameHostChanged(const Event_GameHostChanged &event, int eventPlayerId, const GameEventContext &context);
void eventGameClosed(Event_GameClosed *event, GameEventContext *context); void eventGameClosed(const Event_GameClosed &event, int eventPlayerId, const GameEventContext &context);
Player *setActivePlayer(int id); Player *setActivePlayer(int id);
void eventSetActivePlayer(Event_SetActivePlayer *event, GameEventContext *context); void eventSetActivePlayer(const Event_SetActivePlayer &event, int eventPlayerId, const GameEventContext &context);
void setActivePhase(int phase); void setActivePhase(int phase);
void eventSetActivePhase(Event_SetActivePhase *event, GameEventContext *context); void eventSetActivePhase(const Event_SetActivePhase &event, int eventPlayerId, const GameEventContext &context);
void eventPing(Event_Ping *event, GameEventContext *context); void eventPing(const Event_Ping &event, int eventPlayerId, const GameEventContext &context);
signals: signals:
void gameClosing(TabGame *tab); void gameClosing(TabGame *tab);
void playerAdded(Player *player); void playerAdded(Player *player);
void playerRemoved(Player *player); void playerRemoved(Player *player);
void containerProcessingStarted(GameEventContext *context); void containerProcessingStarted(const GameEventContext &context);
void containerProcessingDone(); void containerProcessingDone();
void openMessageDialog(const QString &userName, bool focus); void openMessageDialog(const QString &userName, bool focus);
private slots: private slots:
@ -162,7 +163,7 @@ private slots:
void actNextPhase(); void actNextPhase();
void actNextTurn(); void actNextTurn();
public: public:
TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, int _gameId, const QString &_gameDescription, int _hostId, int _localPlayerId, bool _spectator, bool _spectatorsCanTalk, bool _spectatorsSeeEverything, bool _resuming); TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, const Event_GameJoined &event);
~TabGame(); ~TabGame();
void retranslateUi(); void retranslateUi();
void closeRequest(); void closeRequest();
@ -177,7 +178,7 @@ public:
Player *getActiveLocalPlayer() const; Player *getActiveLocalPlayer() const;
AbstractClient *getClientForPlayer(int playerId) const; AbstractClient *getClientForPlayer(int playerId) const;
void processGameEventContainer(GameEventContainer *cont, AbstractClient *client); void processGameEventContainer(const GameEventContainer &cont, AbstractClient *client);
PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd); PendingCommand *prepareGameCommand(const ::google::protobuf::Message &cmd);
PendingCommand *prepareGameCommand(const QList< const ::google::protobuf::Message * > &cmdList); PendingCommand *prepareGameCommand(const QList< const ::google::protobuf::Message * > &cmdList);
public slots: public slots:

12
cockatrice/src/tab_message.cpp
View file

@ -5,11 +5,11 @@
#include <QAction> #include <QAction>
#include "tab_message.h" #include "tab_message.h"
#include "abstractclient.h" #include "abstractclient.h"
#include "protocol_items.h"
#include "chatview.h" #include "chatview.h"
#include "pending_command.h" #include "pending_command.h"
#include "pb/session_commands.pb.h" #include "pb/session_commands.pb.h"
#include "pb/event_user_message.pb.h"
TabMessage::TabMessage(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &_ownName, const QString &_userName) TabMessage::TabMessage(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &_ownName, const QString &_userName)
: Tab(_tabSupervisor), client(_client), userName(_userName), userOnline(true) : Tab(_tabSupervisor), client(_client), userName(_userName), userOnline(true)
@ -60,15 +60,15 @@ void TabMessage::sendMessage()
cmd.set_message(sayEdit->text().toStdString()); cmd.set_message(sayEdit->text().toStdString());
PendingCommand *pend = client->prepareSessionCommand(cmd); PendingCommand *pend = client->prepareSessionCommand(cmd);
connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(messageSent(ProtocolResponse *))); connect(pend, SIGNAL(finished(const Response &)), this, SLOT(messageSent(const Response &)));
client->sendCommand(pend); client->sendCommand(pend);
sayEdit->clear(); sayEdit->clear();
} }
void TabMessage::messageSent(ProtocolResponse *response) void TabMessage::messageSent(const Response &response)
{ {
if (response->getResponseCode() == RespInIgnoreList) if (response.response_code() == Response::RespInIgnoreList)
chatView->appendMessage(QString(), tr("This user is ignoring you.")); chatView->appendMessage(QString(), tr("This user is ignoring you."));
} }
@ -77,9 +77,9 @@ void TabMessage::actLeave()
deleteLater(); deleteLater();
} }
void TabMessage::processMessageEvent(Event_Message *event) void TabMessage::processUserMessageEvent(const Event_UserMessage &event)
{ {
chatView->appendMessage(event->getSenderName(), event->getText()); chatView->appendMessage(QString::fromStdString(event.sender_name()), QString::fromStdString(event.message()));
emit userEvent(); emit userEvent();
} }

8
cockatrice/src/tab_message.h
View file

@ -6,8 +6,8 @@
class AbstractClient; class AbstractClient;
class ChatView; class ChatView;
class QLineEdit; class QLineEdit;
class Event_Message; class Event_UserMessage;
class ProtocolResponse; class Response;
class TabMessage : public Tab { class TabMessage : public Tab {
Q_OBJECT Q_OBJECT
@ -25,7 +25,7 @@ signals:
private slots: private slots:
void sendMessage(); void sendMessage();
void actLeave(); void actLeave();
void messageSent(ProtocolResponse *response); void messageSent(const Response &response);
public: public:
TabMessage(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &_ownName, const QString &_userName); TabMessage(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &_ownName, const QString &_userName);
~TabMessage(); ~TabMessage();
@ -34,7 +34,7 @@ public:
QString getUserName() const { return userName; } QString getUserName() const { return userName; }
QString getTabText() const { return tr("Talking to %1").arg(userName); } QString getTabText() const { return tr("Talking to %1").arg(userName); }
void processMessageEvent(Event_Message *event); void processUserMessageEvent(const Event_UserMessage &event);
void processUserLeft(); void processUserLeft();
void processUserJoined(); void processUserJoined();
}; };

74
cockatrice/src/tab_room.cpp
View file

@ -15,21 +15,25 @@
#include "abstractclient.h" #include "abstractclient.h"
#include "chatview.h" #include "chatview.h"
#include "gameselector.h" #include "gameselector.h"
#include "protocol_items.h"
#include "pending_command.h" #include "get_pb_extension.h"
#include <google/protobuf/descriptor.h>
#include "pb/room_commands.pb.h" #include "pb/room_commands.pb.h"
#include "pb/serverinfo_room.pb.h"
#include "pb/event_list_games.pb.h"
#include "pb/event_join_room.pb.h"
#include "pb/event_leave_room.pb.h"
#include "pb/event_room_say.pb.h"
#include "pending_command.h"
TabRoom::TabRoom(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &_ownName, ServerInfo_Room *info) TabRoom::TabRoom(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &_ownName, const ServerInfo_Room &info)
: Tab(_tabSupervisor), client(_client), roomId(info->getRoomId()), roomName(info->getName()), ownName(_ownName) : Tab(_tabSupervisor), client(_client), roomId(info.room_id()), roomName(QString::fromStdString(info.name())), ownName(_ownName)
{ {
const QList<ServerInfo_GameType *> gameTypeList = info->getGameTypeList(); const int gameTypeListSize = info.gametype_list_size();
for (int i = 0; i < gameTypeList.size(); ++i) for (int i = 0; i < gameTypeListSize; ++i)
gameTypes.insert(gameTypeList[i]->getGameTypeId(), gameTypeList[i]->getDescription()); gameTypes.insert(info.gametype_list(i).game_type_id(), QString::fromStdString(info.gametype_list(i).description()));
QMap<int, GameTypeMap> tempMap; QMap<int, GameTypeMap> tempMap;
tempMap.insert(info->getRoomId(), gameTypes); tempMap.insert(info.room_id(), gameTypes);
gameSelector = new GameSelector(client, tabSupervisor, this, QMap<int, QString>(), tempMap); gameSelector = new GameSelector(client, tabSupervisor, this, QMap<int, QString>(), tempMap);
userList = new UserList(tabSupervisor, client, UserList::RoomList); userList = new UserList(tabSupervisor, client, UserList::RoomList);
connect(userList, SIGNAL(openMessageDialog(const QString &, bool)), this, SIGNAL(openMessageDialog(const QString &, bool))); connect(userList, SIGNAL(openMessageDialog(const QString &, bool)), this, SIGNAL(openMessageDialog(const QString &, bool)));
@ -70,14 +74,14 @@ TabRoom::TabRoom(TabSupervisor *_tabSupervisor, AbstractClient *_client, const Q
retranslateUi(); retranslateUi();
setLayout(hbox); setLayout(hbox);
const QList<ServerInfo_User *> users = info->getUserList(); const int userListSize = info.user_list_size();
for (int i = 0; i < users.size(); ++i) for (int i = 0; i < userListSize; ++i)
userList->processUserInfo(users[i], true); userList->processUserInfo(info.user_list(i), true);
userList->sortItems(); userList->sortItems();
const QList<ServerInfo_Game *> games = info->getGameList(); const int gameListSize = info.game_list_size();
for (int i = 0; i < games.size(); ++i) for (int i = 0; i < gameListSize; ++i)
gameSelector->processGameInfo(games[i]); gameSelector->processGameInfo(info.game_list(i));
} }
TabRoom::~TabRoom() TabRoom::~TabRoom()
@ -116,14 +120,14 @@ void TabRoom::sendMessage()
cmd.set_message(sayEdit->text().toStdString()); cmd.set_message(sayEdit->text().toStdString());
PendingCommand *pend = prepareRoomCommand(cmd); PendingCommand *pend = prepareRoomCommand(cmd);
connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(sayFinished(ProtocolResponse *))); connect(pend, SIGNAL(finished(const Response &)), this, SLOT(sayFinished(const Response &)));
sendRoomCommand(pend); sendRoomCommand(pend);
sayEdit->clear(); sayEdit->clear();
} }
void TabRoom::sayFinished(ProtocolResponse *response) void TabRoom::sayFinished(const Response &response)
{ {
if (response->getResponseCode() == RespChatFlood) if (response.response_code() == Response::RespChatFlood)
chatView->appendMessage(QString(), tr("You are flooding the chat. Please wait a couple of seconds.")); chatView->appendMessage(QString(), tr("You are flooding the chat. Please wait a couple of seconds."));
} }
@ -133,39 +137,39 @@ void TabRoom::actLeaveRoom()
deleteLater(); deleteLater();
} }
void TabRoom::processRoomEvent(RoomEvent *event) void TabRoom::processRoomEvent(const RoomEvent &event)
{ {
switch (event->getItemId()) { switch (static_cast<RoomEvent::RoomEventType>(getPbExtension(event))) {
case ItemId_Event_ListGames: processListGamesEvent(qobject_cast<Event_ListGames *>(event)); break; case RoomEvent::LIST_GAMES: processListGamesEvent(event.GetExtension(Event_ListGames::ext)); break;
case ItemId_Event_JoinRoom: processJoinRoomEvent(qobject_cast<Event_JoinRoom *>(event)); break; case RoomEvent::JOIN_ROOM: processJoinRoomEvent(event.GetExtension(Event_JoinRoom::ext)); break;
case ItemId_Event_LeaveRoom: processLeaveRoomEvent(qobject_cast<Event_LeaveRoom *>(event)); break; case RoomEvent::LEAVE_ROOM: processLeaveRoomEvent(event.GetExtension(Event_LeaveRoom::ext)); break;
case ItemId_Event_RoomSay: processSayEvent(qobject_cast<Event_RoomSay *>(event)); break; case RoomEvent::ROOM_SAY: processRoomSayEvent(event.GetExtension(Event_RoomSay::ext)); break;
default: ; default: ;
} }
} }
void TabRoom::processListGamesEvent(Event_ListGames *event) void TabRoom::processListGamesEvent(const Event_ListGames &event)
{ {
const QList<ServerInfo_Game *> &gameList = event->getGameList(); const int gameListSize = event.game_list_size();
for (int i = 0; i < gameList.size(); ++i) for (int i = 0; i < gameListSize; ++i)
gameSelector->processGameInfo(gameList[i]); gameSelector->processGameInfo(event.game_list(i));
} }
void TabRoom::processJoinRoomEvent(Event_JoinRoom *event) void TabRoom::processJoinRoomEvent(const Event_JoinRoom &event)
{ {
userList->processUserInfo(event->getUserInfo(), true); userList->processUserInfo(event.user_info(), true);
userList->sortItems(); userList->sortItems();
} }
void TabRoom::processLeaveRoomEvent(Event_LeaveRoom *event) void TabRoom::processLeaveRoomEvent(const Event_LeaveRoom &event)
{ {
userList->deleteUser(event->getPlayerName()); userList->deleteUser(QString::fromStdString(event.name()));
} }
void TabRoom::processSayEvent(Event_RoomSay *event) void TabRoom::processRoomSayEvent(const Event_RoomSay &event)
{ {
if (!tabSupervisor->getUserListsTab()->getIgnoreList()->userInList(event->getPlayerName())) if (!tabSupervisor->getUserListsTab()->getIgnoreList()->userInList(QString::fromStdString(event.name())))
chatView->appendMessage(event->getPlayerName(), event->getMessage()); chatView->appendMessage(QString::fromStdString(event.name()), QString::fromStdString(event.message()));
emit userEvent(false); emit userEvent(false);
} }

18
cockatrice/src/tab_room.h
View file

@ -4,8 +4,8 @@
#include "tab.h" #include "tab.h"
#include <QGroupBox> #include <QGroupBox>
#include <QMap> #include <QMap>
#include <google/protobuf/message.h>
namespace google { namespace protobuf { class Message; } }
class AbstractClient; class AbstractClient;
class UserList; class UserList;
class QLabel; class QLabel;
@ -20,8 +20,8 @@ class Event_ListGames;
class Event_JoinRoom; class Event_JoinRoom;
class Event_LeaveRoom; class Event_LeaveRoom;
class Event_RoomSay; class Event_RoomSay;
class ProtocolResponse;
class GameSelector; class GameSelector;
class Response;
class PendingCommand; class PendingCommand;
class TabRoom : public Tab { class TabRoom : public Tab {
@ -48,18 +48,18 @@ signals:
private slots: private slots:
void sendMessage(); void sendMessage();
void actLeaveRoom(); void actLeaveRoom();
void sayFinished(ProtocolResponse *response); void sayFinished(const Response &response);
void processListGamesEvent(Event_ListGames *event); void processListGamesEvent(const Event_ListGames &event);
void processJoinRoomEvent(Event_JoinRoom *event); void processJoinRoomEvent(const Event_JoinRoom &event);
void processLeaveRoomEvent(Event_LeaveRoom *event); void processLeaveRoomEvent(const Event_LeaveRoom &event);
void processSayEvent(Event_RoomSay *event); void processRoomSayEvent(const Event_RoomSay &event);
public: public:
TabRoom(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &_ownName, ServerInfo_Room *info); TabRoom(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &_ownName, const ServerInfo_Room &info);
~TabRoom(); ~TabRoom();
void retranslateUi(); void retranslateUi();
void closeRequest(); void closeRequest();
void processRoomEvent(RoomEvent *event); void processRoomEvent(const RoomEvent &event);
int getRoomId() const { return roomId; } int getRoomId() const { return roomId; }
const QMap<int, QString> &getGameTypes() const { return gameTypes; } const QMap<int, QString> &getGameTypes() const { return gameTypes; }
QString getChannelName() const { return roomName; } QString getChannelName() const { return roomName; }

58
cockatrice/src/tab_server.cpp
View file

@ -12,13 +12,15 @@
#include "tab_server.h" #include "tab_server.h"
#include "abstractclient.h" #include "abstractclient.h"
#include "protocol.h" #include "protocol.h"
#include "protocol_items.h"
#include "userlist.h" #include "userlist.h"
#include "userinfobox.h" #include "userinfobox.h"
#include <QDebug> #include <QDebug>
#include "pending_command.h" #include "pending_command.h"
#include "pb/session_commands.pb.h" #include "pb/session_commands.pb.h"
#include "pb/event_list_rooms.pb.h"
#include "pb/event_server_message.pb.h"
#include "pb/response_join_room.pb.h"
RoomSelector::RoomSelector(AbstractClient *_client, QWidget *parent) RoomSelector::RoomSelector(AbstractClient *_client, QWidget *parent)
: QGroupBox(parent), client(_client) : QGroupBox(parent), client(_client)
@ -44,7 +46,7 @@ RoomSelector::RoomSelector(AbstractClient *_client, QWidget *parent)
retranslateUi(); retranslateUi();
setLayout(vbox); setLayout(vbox);
connect(client, SIGNAL(listRoomsEventReceived(Event_ListRooms *)), this, SLOT(processListRoomsEvent(Event_ListRooms *))); connect(client, SIGNAL(listRoomsEventReceived(const Event_ListRooms &)), this, SLOT(processListRoomsEvent(const Event_ListRooms &)));
client->sendCommand(client->prepareSessionCommand(Command_ListRooms())); client->sendCommand(client->prepareSessionCommand(Command_ListRooms()));
} }
@ -62,33 +64,33 @@ void RoomSelector::retranslateUi()
header->setTextAlignment(3, Qt::AlignRight); header->setTextAlignment(3, Qt::AlignRight);
} }
void RoomSelector::processListRoomsEvent(Event_ListRooms *event) void RoomSelector::processListRoomsEvent(const Event_ListRooms &event)
{ {
const QList<ServerInfo_Room *> &roomsToUpdate = event->getRoomList(); const int roomListSize = event.room_list_size();
for (int i = 0; i < roomsToUpdate.size(); ++i) { for (int i = 0; i < roomListSize; ++i) {
ServerInfo_Room *room = roomsToUpdate[i]; const ServerInfo_Room &room = event.room_list(i);
for (int j = 0; j < roomList->topLevelItemCount(); ++j) { for (int j = 0; j < roomList->topLevelItemCount(); ++j) {
QTreeWidgetItem *twi = roomList->topLevelItem(j); QTreeWidgetItem *twi = roomList->topLevelItem(j);
if (twi->data(0, Qt::UserRole).toInt() == room->getRoomId()) { if (twi->data(0, Qt::UserRole).toInt() == room.room_id()) {
twi->setData(0, Qt::DisplayRole, room->getName()); twi->setData(0, Qt::DisplayRole, QString::fromStdString(room.name()));
twi->setData(1, Qt::DisplayRole, room->getDescription()); twi->setData(1, Qt::DisplayRole, QString::fromStdString(room.description()));
twi->setData(2, Qt::DisplayRole, room->getPlayerCount()); twi->setData(2, Qt::DisplayRole, room.player_count());
twi->setData(3, Qt::DisplayRole, room->getGameCount()); twi->setData(3, Qt::DisplayRole, room.game_count());
return; return;
} }
} }
QTreeWidgetItem *twi = new QTreeWidgetItem; QTreeWidgetItem *twi = new QTreeWidgetItem;
twi->setData(0, Qt::UserRole, room->getRoomId()); twi->setData(0, Qt::UserRole, room.room_id());
twi->setData(0, Qt::DisplayRole, room->getName()); twi->setData(0, Qt::DisplayRole, QString::fromStdString(room.name()));
twi->setData(1, Qt::DisplayRole, room->getDescription()); twi->setData(1, Qt::DisplayRole, QString::fromStdString(room.description()));
twi->setData(2, Qt::DisplayRole, room->getPlayerCount()); twi->setData(2, Qt::DisplayRole, room.player_count());
twi->setData(3, Qt::DisplayRole, room->getGameCount()); twi->setData(3, Qt::DisplayRole, room.game_count());
twi->setTextAlignment(2, Qt::AlignRight); twi->setTextAlignment(2, Qt::AlignRight);
twi->setTextAlignment(3, Qt::AlignRight); twi->setTextAlignment(3, Qt::AlignRight);
roomList->addTopLevelItem(twi); roomList->addTopLevelItem(twi);
if (room->getAutoJoin()) if (room.auto_join())
joinRoom(room->getRoomId(), false); joinRoom(room.room_id(), false);
} }
} }
@ -99,7 +101,7 @@ void RoomSelector::joinRoom(int id, bool setCurrent)
PendingCommand *pend = client->prepareSessionCommand(cmd); PendingCommand *pend = client->prepareSessionCommand(cmd);
pend->setExtraData(setCurrent); pend->setExtraData(setCurrent);
connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(joinFinished(ProtocolResponse *))); connect(pend, SIGNAL(finished(const Response &)), this, SLOT(joinFinished(const Response &)));
client->sendCommand(pend); client->sendCommand(pend);
} }
@ -113,15 +115,13 @@ void RoomSelector::joinClicked()
joinRoom(twi->data(0, Qt::UserRole).toInt(), true); joinRoom(twi->data(0, Qt::UserRole).toInt(), true);
} }
void RoomSelector::joinFinished(ProtocolResponse *r) void RoomSelector::joinFinished(const Response &r)
{ {
if (r->getResponseCode() != RespOk) if (r.response_code() != Response::RespOk)
return;
Response_JoinRoom *resp = qobject_cast<Response_JoinRoom *>(r);
if (!resp)
return; return;
const Response_JoinRoom &resp = r.GetExtension(Response_JoinRoom::ext);
emit roomJoined(resp->getRoomInfo(), static_cast<PendingCommand *>(sender())->getExtraData().toBool()); emit roomJoined(resp.room_info(), static_cast<PendingCommand *>(sender())->getExtraData().toBool());
} }
TabServer::TabServer(TabSupervisor *_tabSupervisor, AbstractClient *_client, QWidget *parent) TabServer::TabServer(TabSupervisor *_tabSupervisor, AbstractClient *_client, QWidget *parent)
@ -131,9 +131,9 @@ TabServer::TabServer(TabSupervisor *_tabSupervisor, AbstractClient *_client, QWi
serverInfoBox = new QTextBrowser; serverInfoBox = new QTextBrowser;
serverInfoBox->setOpenExternalLinks(true); serverInfoBox->setOpenExternalLinks(true);
connect(roomSelector, SIGNAL(roomJoined(ServerInfo_Room *, bool)), this, SIGNAL(roomJoined(ServerInfo_Room *, bool))); connect(roomSelector, SIGNAL(roomJoined(const ServerInfo_Room &, bool)), this, SIGNAL(roomJoined(const ServerInfo_Room &, bool)));
connect(client, SIGNAL(serverMessageEventReceived(Event_ServerMessage *)), this, SLOT(processServerMessageEvent(Event_ServerMessage *))); connect(client, SIGNAL(serverMessageEventReceived(const Event_ServerMessage &)), this, SLOT(processServerMessageEvent(const Event_ServerMessage &)));
QVBoxLayout *vbox = new QVBoxLayout; QVBoxLayout *vbox = new QVBoxLayout;
vbox->addWidget(roomSelector); vbox->addWidget(roomSelector);
@ -147,8 +147,8 @@ void TabServer::retranslateUi()
roomSelector->retranslateUi(); roomSelector->retranslateUi();
} }
void TabServer::processServerMessageEvent(Event_ServerMessage *event) void TabServer::processServerMessageEvent(const Event_ServerMessage &event)
{ {
serverInfoBox->setHtml(event->getMessage()); serverInfoBox->setHtml(QString::fromStdString(event.message()));
emit userEvent(); emit userEvent();
} }

12
cockatrice/src/tab_server.h
View file

@ -14,7 +14,7 @@ class QPushButton;
class Event_ListRooms; class Event_ListRooms;
class Event_ServerMessage; class Event_ServerMessage;
class ProtocolResponse; class Response;
class ServerInfo_Room; class ServerInfo_Room;
class RoomSelector : public QGroupBox { class RoomSelector : public QGroupBox {
@ -26,11 +26,11 @@ private:
void joinRoom(int id, bool setCurrent); void joinRoom(int id, bool setCurrent);
private slots: private slots:
void processListRoomsEvent(Event_ListRooms *event); void processListRoomsEvent(const Event_ListRooms &event);
void joinClicked(); void joinClicked();
void joinFinished(ProtocolResponse *resp); void joinFinished(const Response &resp);
signals: signals:
void roomJoined(ServerInfo_Room *info, bool setCurrent); void roomJoined(const ServerInfo_Room &info, bool setCurrent);
public: public:
RoomSelector(AbstractClient *_client, QWidget *parent = 0); RoomSelector(AbstractClient *_client, QWidget *parent = 0);
void retranslateUi(); void retranslateUi();
@ -39,9 +39,9 @@ public:
class TabServer : public Tab { class TabServer : public Tab {
Q_OBJECT Q_OBJECT
signals: signals:
void roomJoined(ServerInfo_Room *info, bool setCurrent); void roomJoined(const ServerInfo_Room &info, bool setCurrent);
private slots: private slots:
void processServerMessageEvent(Event_ServerMessage *event); void processServerMessageEvent(const Event_ServerMessage &event);
private: private:
AbstractClient *client; AbstractClient *client;
RoomSelector *roomSelector; RoomSelector *roomSelector;

77
cockatrice/src/tab_supervisor.cpp
View file

@ -8,12 +8,17 @@
#include "tab_admin.h" #include "tab_admin.h"
#include "tab_message.h" #include "tab_message.h"
#include "tab_userlists.h" #include "tab_userlists.h"
#include "protocol_items.h"
#include "pixmapgenerator.h" #include "pixmapgenerator.h"
#include <QDebug> #include <QDebug>
#include <QPainter> #include <QPainter>
#include "pb/room_commands.pb.h" #include "pb/room_commands.pb.h"
#include "pb/room_event.pb.h"
#include "pb/game_event_container.pb.h"
#include "pb/event_user_message.pb.h"
#include "pb/event_game_joined.pb.h"
#include "pb/serverinfo_user.pb.h"
#include "pb/serverinfo_room.pb.h"
CloseButton::CloseButton(QWidget *parent) CloseButton::CloseButton(QWidget *parent)
: QAbstractButton(parent) : QAbstractButton(parent)
@ -107,22 +112,22 @@ int TabSupervisor::myAddTab(Tab *tab)
return addTab(tab, tab->getTabText()); return addTab(tab, tab->getTabText());
} }
void TabSupervisor::start(AbstractClient *_client, ServerInfo_User *_userInfo) void TabSupervisor::start(AbstractClient *_client, const ServerInfo_User &_userInfo)
{ {
client = _client; client = _client;
userInfo = new ServerInfo_User(_userInfo); userInfo = new ServerInfo_User(_userInfo);
connect(client, SIGNAL(roomEventReceived(RoomEvent *)), this, SLOT(processRoomEvent(RoomEvent *))); connect(client, SIGNAL(roomEventReceived(const RoomEvent &)), this, SLOT(processRoomEvent(const RoomEvent &)));
connect(client, SIGNAL(gameEventContainerReceived(GameEventContainer *)), this, SLOT(processGameEventContainer(GameEventContainer *))); connect(client, SIGNAL(gameEventContainerReceived(const GameEventContainer &)), this, SLOT(processGameEventContainer(const GameEventContainer &)));
connect(client, SIGNAL(gameJoinedEventReceived(Event_GameJoined *)), this, SLOT(gameJoined(Event_GameJoined *))); connect(client, SIGNAL(gameJoinedEventReceived(const Event_GameJoined &)), this, SLOT(gameJoined(const Event_GameJoined &)));
connect(client, SIGNAL(messageEventReceived(Event_Message *)), this, SLOT(processMessageEvent(Event_Message *))); connect(client, SIGNAL(userMessageEventReceived(const Event_UserMessage &)), this, SLOT(processUserMessageEvent(const Event_UserMessage &)));
connect(client, SIGNAL(maxPingTime(int, int)), this, SLOT(updatePingTime(int, int))); connect(client, SIGNAL(maxPingTime(int, int)), this, SLOT(updatePingTime(int, int)));
tabServer = new TabServer(this, client); tabServer = new TabServer(this, client);
connect(tabServer, SIGNAL(roomJoined(ServerInfo_Room *, bool)), this, SLOT(addRoomTab(ServerInfo_Room *, bool))); connect(tabServer, SIGNAL(roomJoined(const ServerInfo_Room &, bool)), this, SLOT(addRoomTab(const ServerInfo_Room &, bool)));
myAddTab(tabServer); myAddTab(tabServer);
tabUserLists = new TabUserLists(this, client, userInfo); tabUserLists = new TabUserLists(this, client, *userInfo);
connect(tabUserLists, SIGNAL(openMessageDialog(const QString &, bool)), this, SLOT(addMessageTab(const QString &, bool))); connect(tabUserLists, SIGNAL(openMessageDialog(const QString &, bool)), this, SLOT(addMessageTab(const QString &, bool)));
connect(tabUserLists, SIGNAL(userJoined(const QString &)), this, SLOT(processUserJoined(const QString &))); connect(tabUserLists, SIGNAL(userJoined(const QString &)), this, SLOT(processUserJoined(const QString &)));
connect(tabUserLists, SIGNAL(userLeft(const QString &)), this, SLOT(processUserLeft(const QString &))); connect(tabUserLists, SIGNAL(userLeft(const QString &)), this, SLOT(processUserLeft(const QString &)));
@ -130,14 +135,14 @@ void TabSupervisor::start(AbstractClient *_client, ServerInfo_User *_userInfo)
updatePingTime(0, -1); updatePingTime(0, -1);
if (userInfo->getUserLevel() & ServerInfo_User::IsRegistered) { if (userInfo->user_level() & ServerInfo_User::IsRegistered) {
tabDeckStorage = new TabDeckStorage(this, client); tabDeckStorage = new TabDeckStorage(this, client);
myAddTab(tabDeckStorage); myAddTab(tabDeckStorage);
} else } else
tabDeckStorage = 0; tabDeckStorage = 0;
if (userInfo->getUserLevel() & ServerInfo_User::IsModerator) { if (userInfo->user_level() & ServerInfo_User::IsModerator) {
tabAdmin = new TabAdmin(this, client, (userInfo->getUserLevel() & ServerInfo_User::IsAdmin)); tabAdmin = new TabAdmin(this, client, (userInfo->user_level() & ServerInfo_User::IsAdmin));
connect(tabAdmin, SIGNAL(adminLockChanged(bool)), this, SIGNAL(adminLockChanged(bool))); connect(tabAdmin, SIGNAL(adminLockChanged(bool)), this, SIGNAL(adminLockChanged(bool)));
myAddTab(tabAdmin); myAddTab(tabAdmin);
} else } else
@ -154,8 +159,8 @@ void TabSupervisor::startLocal(const QList<AbstractClient *> &_clients)
userInfo = new ServerInfo_User; userInfo = new ServerInfo_User;
localClients = _clients; localClients = _clients;
for (int i = 0; i < localClients.size(); ++i) for (int i = 0; i < localClients.size(); ++i)
connect(localClients[i], SIGNAL(gameEventContainerReceived(GameEventContainer *)), this, SLOT(processGameEventContainer(GameEventContainer *))); connect(localClients[i], SIGNAL(gameEventContainerReceived(const GameEventContainer &)), this, SLOT(processGameEventContainer(const GameEventContainer &)));
connect(localClients.first(), SIGNAL(gameJoinedEventReceived(Event_GameJoined *)), this, SLOT(localGameJoined(Event_GameJoined *))); connect(localClients.first(), SIGNAL(gameJoinedEventReceived(const Event_GameJoined &)), this, SLOT(localGameJoined(const Event_GameJoined &)));
} }
void TabSupervisor::stop() void TabSupervisor::stop()
@ -228,29 +233,29 @@ void TabSupervisor::addCloseButtonToTab(Tab *tab, int tabIndex)
tabBar()->setTabButton(tabIndex, closeSide, closeButton); tabBar()->setTabButton(tabIndex, closeSide, closeButton);
} }
void TabSupervisor::gameJoined(Event_GameJoined *event) void TabSupervisor::gameJoined(const Event_GameJoined &event)
{ {
TabGame *tab = new TabGame(this, QList<AbstractClient *>() << client, event->getGameId(), event->getGameDescription(), event->getHostId(), event->getPlayerId(), event->getSpectator(), event->getSpectatorsCanTalk(), event->getSpectatorsSeeEverything(), event->getResuming()); TabGame *tab = new TabGame(this, QList<AbstractClient *>() << client, event);
connect(tab, SIGNAL(gameClosing(TabGame *)), this, SLOT(gameLeft(TabGame *))); connect(tab, SIGNAL(gameClosing(TabGame *)), this, SLOT(gameLeft(TabGame *)));
connect(tab, SIGNAL(openMessageDialog(const QString &, bool)), this, SLOT(addMessageTab(const QString &, bool))); connect(tab, SIGNAL(openMessageDialog(const QString &, bool)), this, SLOT(addMessageTab(const QString &, bool)));
int tabIndex = myAddTab(tab); int tabIndex = myAddTab(tab);
addCloseButtonToTab(tab, tabIndex); addCloseButtonToTab(tab, tabIndex);
gameTabs.insert(event->getGameId(), tab); gameTabs.insert(event.game_id(), tab);
setCurrentWidget(tab); setCurrentWidget(tab);
} }
void TabSupervisor::localGameJoined(Event_GameJoined *event) void TabSupervisor::localGameJoined(const Event_GameJoined &event)
{ {
TabGame *tab = new TabGame(this, localClients, event->getGameId(), event->getGameDescription(), event->getHostId(), event->getPlayerId(), event->getSpectator(), event->getSpectatorsCanTalk(), event->getSpectatorsSeeEverything(), event->getResuming()); TabGame *tab = new TabGame(this, localClients, event);
connect(tab, SIGNAL(gameClosing(TabGame *)), this, SLOT(gameLeft(TabGame *))); connect(tab, SIGNAL(gameClosing(TabGame *)), this, SLOT(gameLeft(TabGame *)));
int tabIndex = myAddTab(tab); int tabIndex = myAddTab(tab);
addCloseButtonToTab(tab, tabIndex); addCloseButtonToTab(tab, tabIndex);
gameTabs.insert(event->getGameId(), tab); gameTabs.insert(event.game_id(), tab);
setCurrentWidget(tab); setCurrentWidget(tab);
for (int i = 1; i < localClients.size(); ++i) { for (int i = 1; i < localClients.size(); ++i) {
Command_JoinGame cmd; Command_JoinGame cmd;
cmd.set_game_id(event->getGameId()); cmd.set_game_id(event.game_id());
localClients[i]->sendCommand(localClients[i]->prepareRoomCommand(cmd, 0)); localClients[i]->sendCommand(localClients[i]->prepareRoomCommand(cmd, 0));
} }
} }
@ -266,14 +271,14 @@ void TabSupervisor::gameLeft(TabGame *tab)
stop(); stop();
} }
void TabSupervisor::addRoomTab(ServerInfo_Room *info, bool setCurrent) void TabSupervisor::addRoomTab(const ServerInfo_Room &info, bool setCurrent)
{ {
TabRoom *tab = new TabRoom(this, client, userInfo->getName(), info); TabRoom *tab = new TabRoom(this, client, QString::fromStdString(userInfo->name()), info);
connect(tab, SIGNAL(roomClosing(TabRoom *)), this, SLOT(roomLeft(TabRoom *))); connect(tab, SIGNAL(roomClosing(TabRoom *)), this, SLOT(roomLeft(TabRoom *)));
connect(tab, SIGNAL(openMessageDialog(const QString &, bool)), this, SLOT(addMessageTab(const QString &, bool))); connect(tab, SIGNAL(openMessageDialog(const QString &, bool)), this, SLOT(addMessageTab(const QString &, bool)));
int tabIndex = myAddTab(tab); int tabIndex = myAddTab(tab);
addCloseButtonToTab(tab, tabIndex); addCloseButtonToTab(tab, tabIndex);
roomTabs.insert(info->getRoomId(), tab); roomTabs.insert(info.room_id(), tab);
if (setCurrent) if (setCurrent)
setCurrentWidget(tab); setCurrentWidget(tab);
} }
@ -288,10 +293,10 @@ void TabSupervisor::roomLeft(TabRoom *tab)
TabMessage *TabSupervisor::addMessageTab(const QString &receiverName, bool focus) TabMessage *TabSupervisor::addMessageTab(const QString &receiverName, bool focus)
{ {
if (receiverName == userInfo->getName()) if (receiverName == QString::fromStdString(userInfo->name()))
return 0; return 0;
TabMessage *tab = new TabMessage(this, client, userInfo->getName(), receiverName); TabMessage *tab = new TabMessage(this, client, QString::fromStdString(userInfo->name()), receiverName);
connect(tab, SIGNAL(talkClosing(TabMessage *)), this, SLOT(talkLeft(TabMessage *))); connect(tab, SIGNAL(talkClosing(TabMessage *)), this, SLOT(talkLeft(TabMessage *)));
int tabIndex = myAddTab(tab); int tabIndex = myAddTab(tab);
addCloseButtonToTab(tab, tabIndex); addCloseButtonToTab(tab, tabIndex);
@ -320,33 +325,33 @@ void TabSupervisor::tabUserEvent(bool globalEvent)
QApplication::alert(this); QApplication::alert(this);
} }
void TabSupervisor::processRoomEvent(RoomEvent *event) void TabSupervisor::processRoomEvent(const RoomEvent &event)
{ {
TabRoom *tab = roomTabs.value(event->getRoomId(), 0); TabRoom *tab = roomTabs.value(event.room_id(), 0);
if (tab) if (tab)
tab->processRoomEvent(event); tab->processRoomEvent(event);
} }
void TabSupervisor::processGameEventContainer(GameEventContainer *cont) void TabSupervisor::processGameEventContainer(const GameEventContainer &cont)
{ {
TabGame *tab = gameTabs.value(cont->getGameId()); TabGame *tab = gameTabs.value(cont.game_id());
if (tab) { if (tab) {
qDebug() << "gameEvent gameId =" << cont->getGameId(); qDebug() << "gameEvent gameId =" << cont.game_id();
tab->processGameEventContainer(cont, qobject_cast<AbstractClient *>(sender())); tab->processGameEventContainer(cont, qobject_cast<AbstractClient *>(sender()));
} else } else
qDebug() << "gameEvent: invalid gameId"; qDebug() << "gameEvent: invalid gameId";
} }
void TabSupervisor::processMessageEvent(Event_Message *event) void TabSupervisor::processUserMessageEvent(const Event_UserMessage &event)
{ {
TabMessage *tab = messageTabs.value(event->getSenderName()); TabMessage *tab = messageTabs.value(QString::fromStdString(event.sender_name()));
if (!tab) if (!tab)
tab = messageTabs.value(event->getReceiverName()); tab = messageTabs.value(QString::fromStdString(event.receiver_name()));
if (!tab) if (!tab)
tab = addMessageTab(event->getSenderName(), false); tab = addMessageTab(QString::fromStdString(event.sender_name()), false);
if (!tab) if (!tab)
return; return;
tab->processMessageEvent(event); tab->processUserMessageEvent(event);
} }
void TabSupervisor::processUserLeft(const QString &userName) void TabSupervisor::processUserLeft(const QString &userName)
@ -385,5 +390,5 @@ bool TabSupervisor::getAdminLocked() const
int TabSupervisor::getUserLevel() const int TabSupervisor::getUserLevel() const
{ {
return userInfo->getUserLevel(); return userInfo->user_level();
} }

16
cockatrice/src/tab_supervisor.h
View file

@ -18,7 +18,7 @@ class TabUserLists;
class RoomEvent; class RoomEvent;
class GameEventContainer; class GameEventContainer;
class Event_GameJoined; class Event_GameJoined;
class Event_Message; class Event_UserMessage;
class ServerInfo_Room; class ServerInfo_Room;
class ServerInfo_User; class ServerInfo_User;
@ -54,7 +54,7 @@ public:
TabSupervisor(QWidget *parent = 0); TabSupervisor(QWidget *parent = 0);
~TabSupervisor(); ~TabSupervisor();
void retranslateUi(); void retranslateUi();
void start(AbstractClient *_client, ServerInfo_User *userInfo); void start(AbstractClient *_client, const ServerInfo_User &userInfo);
void startLocal(const QList<AbstractClient *> &_clients); void startLocal(const QList<AbstractClient *> &_clients);
void stop(); void stop();
int getGameCount() const { return gameTabs.size(); } int getGameCount() const { return gameTabs.size(); }
@ -71,19 +71,19 @@ private slots:
void closeButtonPressed(); void closeButtonPressed();
void updateCurrent(int index); void updateCurrent(int index);
void updatePingTime(int value, int max); void updatePingTime(int value, int max);
void gameJoined(Event_GameJoined *event); void gameJoined(const Event_GameJoined &event);
void localGameJoined(Event_GameJoined *event); void localGameJoined(const Event_GameJoined &event);
void gameLeft(TabGame *tab); void gameLeft(TabGame *tab);
void addRoomTab(ServerInfo_Room *info, bool setCurrent); void addRoomTab(const ServerInfo_Room &info, bool setCurrent);
void roomLeft(TabRoom *tab); void roomLeft(TabRoom *tab);
TabMessage *addMessageTab(const QString &userName, bool focus); TabMessage *addMessageTab(const QString &userName, bool focus);
void processUserLeft(const QString &userName); void processUserLeft(const QString &userName);
void processUserJoined(const QString &userName); void processUserJoined(const QString &userName);
void talkLeft(TabMessage *tab); void talkLeft(TabMessage *tab);
void tabUserEvent(bool globalEvent); void tabUserEvent(bool globalEvent);
void processRoomEvent(RoomEvent *event); void processRoomEvent(const RoomEvent &event);
void processGameEventContainer(GameEventContainer *cont); void processGameEventContainer(const GameEventContainer &cont);
void processMessageEvent(Event_Message *event); void processUserMessageEvent(const Event_UserMessage &event);
}; };
#endif #endif

74
cockatrice/src/tab_userlists.cpp
View file

@ -5,12 +5,16 @@
#include <QDebug> #include <QDebug>
#include <QHBoxLayout> #include <QHBoxLayout>
#include <QVBoxLayout> #include <QVBoxLayout>
#include "protocol_items.h"
#include "pending_command.h" #include "pending_command.h"
#include "pb/session_commands.pb.h" #include "pb/session_commands.pb.h"
#include "pb/response_list_users.pb.h"
#include "pb/event_user_joined.pb.h"
#include "pb/event_user_left.pb.h"
#include "pb/event_add_to_list.pb.h"
#include "pb/event_remove_from_list.pb.h"
TabUserLists::TabUserLists(TabSupervisor *_tabSupervisor, AbstractClient *_client, ServerInfo_User *userInfo, QWidget *parent) TabUserLists::TabUserLists(TabSupervisor *_tabSupervisor, AbstractClient *_client, const ServerInfo_User &userInfo, QWidget *parent)
: Tab(_tabSupervisor, parent), client(_client) : Tab(_tabSupervisor, parent), client(_client)
{ {
allUsersList = new UserList(_tabSupervisor, client, UserList::AllUsersList); allUsersList = new UserList(_tabSupervisor, client, UserList::AllUsersList);
@ -23,15 +27,15 @@ TabUserLists::TabUserLists(TabSupervisor *_tabSupervisor, AbstractClient *_clien
connect(buddyList, SIGNAL(openMessageDialog(const QString &, bool)), this, SIGNAL(openMessageDialog(const QString &, bool))); connect(buddyList, SIGNAL(openMessageDialog(const QString &, bool)), this, SIGNAL(openMessageDialog(const QString &, bool)));
connect(ignoreList, SIGNAL(openMessageDialog(const QString &, bool)), this, SIGNAL(openMessageDialog(const QString &, bool))); connect(ignoreList, SIGNAL(openMessageDialog(const QString &, bool)), this, SIGNAL(openMessageDialog(const QString &, bool)));
connect(client, SIGNAL(userJoinedEventReceived(Event_UserJoined *)), this, SLOT(processUserJoinedEvent(Event_UserJoined *))); connect(client, SIGNAL(userJoinedEventReceived(const Event_UserJoined &)), this, SLOT(processUserJoinedEvent(const Event_UserJoined &)));
connect(client, SIGNAL(userLeftEventReceived(Event_UserLeft *)), this, SLOT(processUserLeftEvent(Event_UserLeft *))); connect(client, SIGNAL(userLeftEventReceived(const Event_UserLeft &)), this, SLOT(processUserLeftEvent(const Event_UserLeft &)));
connect(client, SIGNAL(buddyListReceived(const QList<ServerInfo_User *> &)), this, SLOT(buddyListReceived(const QList<ServerInfo_User *> &))); connect(client, SIGNAL(buddyListReceived(const QList<ServerInfo_User> &)), this, SLOT(buddyListReceived(const QList<ServerInfo_User> &)));
connect(client, SIGNAL(ignoreListReceived(const QList<ServerInfo_User *> &)), this, SLOT(ignoreListReceived(const QList<ServerInfo_User *> &))); connect(client, SIGNAL(ignoreListReceived(const QList<ServerInfo_User> &)), this, SLOT(ignoreListReceived(const QList<ServerInfo_User> &)));
connect(client, SIGNAL(addToListEventReceived(Event_AddToList *)), this, SLOT(processAddToListEvent(Event_AddToList *))); connect(client, SIGNAL(addToListEventReceived(const Event_AddToList *)), this, SLOT(processAddToListEvent(const Event_AddToList &)));
connect(client, SIGNAL(removeFromListEventReceived(Event_RemoveFromList *)), this, SLOT(processRemoveFromListEvent(Event_RemoveFromList *))); connect(client, SIGNAL(removeFromListEventReceived(const Event_RemoveFromList *)), this, SLOT(processRemoveFromListEvent(const Event_RemoveFromList &)));
PendingCommand *pend = client->prepareSessionCommand(Command_ListUsers()); PendingCommand *pend = client->prepareSessionCommand(Command_ListUsers());
connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(processListUsersResponse(ProtocolResponse *))); connect(pend, SIGNAL(finished(const Response &)), this, SLOT(processListUsersResponse(const Response &)));
client->sendCommand(pend); client->sendCommand(pend);
QVBoxLayout *vbox = new QVBoxLayout; QVBoxLayout *vbox = new QVBoxLayout;
@ -54,17 +58,17 @@ void TabUserLists::retranslateUi()
userInfoBox->retranslateUi(); userInfoBox->retranslateUi();
} }
void TabUserLists::processListUsersResponse(ProtocolResponse *response) void TabUserLists::processListUsersResponse(const Response &response)
{ {
Response_ListUsers *resp = qobject_cast<Response_ListUsers *>(response); const Response_ListUsers &resp = response.GetExtension(Response_ListUsers::ext);
if (!resp)
return;
const QList<ServerInfo_User *> &respList = resp->getUserList(); const int userListSize = resp.user_list_size();
for (int i = 0; i < respList.size(); ++i) { for (int i = 0; i < userListSize; ++i) {
allUsersList->processUserInfo(respList[i], true); const ServerInfo_User &info = resp.user_list(i);
ignoreList->setUserOnline(respList[i]->getName(), true); const QString userName = QString::fromStdString(info.name());
buddyList->setUserOnline(respList[i]->getName(), true); allUsersList->processUserInfo(info, true);
ignoreList->setUserOnline(userName, true);
buddyList->setUserOnline(userName, true);
} }
allUsersList->sortItems(); allUsersList->sortItems();
@ -72,23 +76,25 @@ void TabUserLists::processListUsersResponse(ProtocolResponse *response)
buddyList->sortItems(); buddyList->sortItems();
} }
void TabUserLists::processUserJoinedEvent(Event_UserJoined *event) void TabUserLists::processUserJoinedEvent(const Event_UserJoined &event)
{ {
ServerInfo_User *info = event->getUserInfo(); const ServerInfo_User &info = event.user_info();
const QString userName = QString::fromStdString(info.name());
allUsersList->processUserInfo(info, true); allUsersList->processUserInfo(info, true);
ignoreList->setUserOnline(info->getName(), true); ignoreList->setUserOnline(userName, true);
buddyList->setUserOnline(info->getName(), true); buddyList->setUserOnline(userName, true);
allUsersList->sortItems(); allUsersList->sortItems();
ignoreList->sortItems(); ignoreList->sortItems();
buddyList->sortItems(); buddyList->sortItems();
emit userJoined(event->getUserInfo()->getName()); emit userJoined(userName);
} }
void TabUserLists::processUserLeftEvent(Event_UserLeft *event) void TabUserLists::processUserLeftEvent(const Event_UserLeft &event)
{ {
QString userName = event->getUserName(); QString userName = QString::fromStdString(event.name());
if (allUsersList->deleteUser(userName)) { if (allUsersList->deleteUser(userName)) {
ignoreList->setUserOnline(userName, false); ignoreList->setUserOnline(userName, false);
buddyList->setUserOnline(userName, false); buddyList->setUserOnline(userName, false);
@ -99,25 +105,25 @@ void TabUserLists::processUserLeftEvent(Event_UserLeft *event)
} }
} }
void TabUserLists::buddyListReceived(const QList<ServerInfo_User *> &_buddyList) void TabUserLists::buddyListReceived(const QList<ServerInfo_User> &_buddyList)
{ {
for (int i = 0; i < _buddyList.size(); ++i) for (int i = 0; i < _buddyList.size(); ++i)
buddyList->processUserInfo(_buddyList[i], false); buddyList->processUserInfo(_buddyList[i], false);
buddyList->sortItems(); buddyList->sortItems();
} }
void TabUserLists::ignoreListReceived(const QList<ServerInfo_User *> &_ignoreList) void TabUserLists::ignoreListReceived(const QList<ServerInfo_User> &_ignoreList)
{ {
for (int i = 0; i < _ignoreList.size(); ++i) for (int i = 0; i < _ignoreList.size(); ++i)
ignoreList->processUserInfo(_ignoreList[i], false); ignoreList->processUserInfo(_ignoreList[i], false);
ignoreList->sortItems(); ignoreList->sortItems();
} }
void TabUserLists::processAddToListEvent(Event_AddToList *event) void TabUserLists::processAddToListEvent(const Event_AddToList &event)
{ {
ServerInfo_User *info = event->getUserInfo(); const ServerInfo_User &info = event.user_info();
bool online = allUsersList->userInList(info->getName()); bool online = allUsersList->userInList(QString::fromStdString(info.name()));
QString list = event->getList(); QString list = QString::fromStdString(event.list_name());
UserList *userList = 0; UserList *userList = 0;
if (list == "buddy") if (list == "buddy")
userList = buddyList; userList = buddyList;
@ -130,10 +136,10 @@ void TabUserLists::processAddToListEvent(Event_AddToList *event)
userList->sortItems(); userList->sortItems();
} }
void TabUserLists::processRemoveFromListEvent(Event_RemoveFromList *event) void TabUserLists::processRemoveFromListEvent(const Event_RemoveFromList &event)
{ {
QString list = event->getList(); QString list = QString::fromStdString(event.list_name());
QString user = event->getUserName(); QString user = QString::fromStdString(event.user_name());
UserList *userList = 0; UserList *userList = 0;
if (list == "buddy") if (list == "buddy")
userList = buddyList; userList = buddyList;

19
cockatrice/src/tab_userlists.h
View file

@ -2,6 +2,7 @@
#define TAB_USERLISTS_H #define TAB_USERLISTS_H
#include "tab.h" #include "tab.h"
#include "pb/serverinfo_user.pb.h"
class AbstractClient; class AbstractClient;
class UserList; class UserList;
@ -10,7 +11,7 @@ class UserInfoBox;
class Event_ListRooms; class Event_ListRooms;
class Event_UserJoined; class Event_UserJoined;
class Event_UserLeft; class Event_UserLeft;
class ProtocolResponse; class Response;
class ServerInfo_User; class ServerInfo_User;
class Event_AddToList; class Event_AddToList;
class Event_RemoveFromList; class Event_RemoveFromList;
@ -22,13 +23,13 @@ signals:
void userLeft(const QString &userName); void userLeft(const QString &userName);
void userJoined(const QString &userName); void userJoined(const QString &userName);
private slots: private slots:
void processListUsersResponse(ProtocolResponse *response); void processListUsersResponse(const Response &response);
void processUserJoinedEvent(Event_UserJoined *event); void processUserJoinedEvent(const Event_UserJoined &event);
void processUserLeftEvent(Event_UserLeft *event); void processUserLeftEvent(const Event_UserLeft &event);
void buddyListReceived(const QList<ServerInfo_User *> &_buddyList); void buddyListReceived(const QList<ServerInfo_User> &_buddyList);
void ignoreListReceived(const QList<ServerInfo_User *> &_ignoreList); void ignoreListReceived(const QList<ServerInfo_User> &_ignoreList);
void processAddToListEvent(Event_AddToList *event); void processAddToListEvent(const Event_AddToList &event);
void processRemoveFromListEvent(Event_RemoveFromList *event); void processRemoveFromListEvent(const Event_RemoveFromList &event);
private: private:
AbstractClient *client; AbstractClient *client;
UserList *allUsersList; UserList *allUsersList;
@ -36,7 +37,7 @@ private:
UserList *ignoreList; UserList *ignoreList;
UserInfoBox *userInfoBox; UserInfoBox *userInfoBox;
public: public:
TabUserLists(TabSupervisor *_tabSupervisor, AbstractClient *_client, ServerInfo_User *userInfo, QWidget *parent = 0); TabUserLists(TabSupervisor *_tabSupervisor, AbstractClient *_client, const ServerInfo_User &userInfo, QWidget *parent = 0);
void retranslateUi(); void retranslateUi();
QString getTabText() const { return tr("User lists"); } QString getTabText() const { return tr("User lists"); }
UserList *getBuddyList() const { return buddyList; } UserList *getBuddyList() const { return buddyList; }

1
cockatrice/src/tablezone.cpp
View file

@ -8,6 +8,7 @@
#include "arrowitem.h" #include "arrowitem.h"
#include "carddragitem.h" #include "carddragitem.h"
#include "carddatabase.h" #include "carddatabase.h"
#include "carditem.h"
#include "pb/command_move_card.pb.h" #include "pb/command_move_card.pb.h"
#include "pb/command_set_card_attr.pb.h" #include "pb/command_set_card_attr.pb.h"

29
cockatrice/src/userinfobox.cpp
View file

@ -1,13 +1,12 @@
#include "userinfobox.h" #include "userinfobox.h"
#include "protocol_datastructures.h"
#include "pixmapgenerator.h" #include "pixmapgenerator.h"
#include "protocol_items.h"
#include "abstractclient.h" #include "abstractclient.h"
#include <QLabel> #include <QLabel>
#include <QGridLayout> #include <QGridLayout>
#include "pending_command.h" #include "pending_command.h"
#include "pb/session_commands.pb.h" #include "pb/session_commands.pb.h"
#include "pb/response_get_user_info.pb.h"
UserInfoBox::UserInfoBox(AbstractClient *_client, bool _fullInfo, QWidget *parent, Qt::WindowFlags flags) UserInfoBox::UserInfoBox(AbstractClient *_client, bool _fullInfo, QWidget *parent, Qt::WindowFlags flags)
: QWidget(parent, flags), client(_client), fullInfo(_fullInfo) : QWidget(parent, flags), client(_client), fullInfo(_fullInfo)
@ -55,19 +54,20 @@ void UserInfoBox::retranslateUi()
userLevelLabel1->setText(tr("User level:")); userLevelLabel1->setText(tr("User level:"));
} }
void UserInfoBox::updateInfo(ServerInfo_User *user) void UserInfoBox::updateInfo(const ServerInfo_User &user)
{ {
int userLevel = user->getUserLevel(); const int userLevel = user.user_level();
QPixmap avatarPixmap; QPixmap avatarPixmap;
if (!avatarPixmap.loadFromData(user->getAvatarBmp())) const std::string bmp = user.avatar_bmp();
if (!avatarPixmap.loadFromData((const uchar *) bmp.data(), bmp.size()))
avatarPixmap = UserLevelPixmapGenerator::generatePixmap(64, userLevel); avatarPixmap = UserLevelPixmapGenerator::generatePixmap(64, userLevel);
avatarLabel->setPixmap(avatarPixmap); avatarLabel->setPixmap(avatarPixmap);
nameLabel->setText(user->getName()); nameLabel->setText(QString::fromStdString(user.name()));
realNameLabel2->setText(user->getRealName()); realNameLabel2->setText(QString::fromStdString(user.real_name()));
genderLabel2->setPixmap(GenderPixmapGenerator::generatePixmap(15, user->getGender())); genderLabel2->setPixmap(GenderPixmapGenerator::generatePixmap(15, user.gender()));
countryLabel2->setPixmap(CountryPixmapGenerator::generatePixmap(15, user->getCountry())); countryLabel2->setPixmap(CountryPixmapGenerator::generatePixmap(15, QString::fromStdString(user.country())));
userLevelLabel2->setPixmap(UserLevelPixmapGenerator::generatePixmap(15, userLevel)); userLevelLabel2->setPixmap(UserLevelPixmapGenerator::generatePixmap(15, userLevel));
QString userLevelText; QString userLevelText;
if (userLevel & ServerInfo_User::IsAdmin) if (userLevel & ServerInfo_User::IsAdmin)
@ -87,18 +87,15 @@ void UserInfoBox::updateInfo(const QString &userName)
cmd.set_user_name(userName.toStdString()); cmd.set_user_name(userName.toStdString());
PendingCommand *pend = client->prepareSessionCommand(cmd); PendingCommand *pend = client->prepareSessionCommand(cmd);
connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(processResponse(ProtocolResponse *))); connect(pend, SIGNAL(finished(const Response &)), this, SLOT(processResponse(const Response &)));
client->sendCommand(pend); client->sendCommand(pend);
} }
void UserInfoBox::processResponse(ProtocolResponse *r) void UserInfoBox::processResponse(const Response &r)
{ {
Response_GetUserInfo *response = qobject_cast<Response_GetUserInfo *>(r); const Response_GetUserInfo &response = r.GetExtension(Response_GetUserInfo::ext);
if (!response) updateInfo(response.user_info());
return;
updateInfo(response->getUserInfo());
setFixedSize(sizeHint()); setFixedSize(sizeHint());
show(); show();
} }

6
cockatrice/src/userinfobox.h
View file

@ -6,7 +6,7 @@
class QLabel; class QLabel;
class ServerInfo_User; class ServerInfo_User;
class AbstractClient; class AbstractClient;
class ProtocolResponse; class Response;
class UserInfoBox : public QWidget { class UserInfoBox : public QWidget {
Q_OBJECT Q_OBJECT
@ -18,9 +18,9 @@ public:
UserInfoBox(AbstractClient *_client, bool fullInfo, QWidget *parent = 0, Qt::WindowFlags flags = 0); UserInfoBox(AbstractClient *_client, bool fullInfo, QWidget *parent = 0, Qt::WindowFlags flags = 0);
void retranslateUi(); void retranslateUi();
private slots: private slots:
void processResponse(ProtocolResponse *r); void processResponse(const Response &r);
public slots: public slots:
void updateInfo(ServerInfo_User *user); void updateInfo(const ServerInfo_User &user);
void updateInfo(const QString &userName); void updateInfo(const QString &userName);
}; };

62
cockatrice/src/userlist.cpp
View file

@ -4,7 +4,6 @@
#include "abstractclient.h" #include "abstractclient.h"
#include "pixmapgenerator.h" #include "pixmapgenerator.h"
#include "userinfobox.h" #include "userinfobox.h"
#include "protocol_items.h"
#include "gameselector.h" #include "gameselector.h"
#include <QHeaderView> #include <QHeaderView>
#include <QVBoxLayout> #include <QVBoxLayout>
@ -23,18 +22,20 @@
#include "pending_command.h" #include "pending_command.h"
#include "pb/session_commands.pb.h" #include "pb/session_commands.pb.h"
#include "pb/moderator_commands.pb.h" #include "pb/moderator_commands.pb.h"
#include "pb/response_get_games_of_user.pb.h"
#include "pb/response_get_user_info.pb.h"
BanDialog::BanDialog(ServerInfo_User *info, QWidget *parent) BanDialog::BanDialog(const ServerInfo_User &info, QWidget *parent)
: QDialog(parent) : QDialog(parent)
{ {
setAttribute(Qt::WA_DeleteOnClose); setAttribute(Qt::WA_DeleteOnClose);
nameBanCheckBox = new QCheckBox(tr("ban &user name")); nameBanCheckBox = new QCheckBox(tr("ban &user name"));
nameBanCheckBox->setChecked(true); nameBanCheckBox->setChecked(true);
nameBanEdit = new QLineEdit(info->getName()); nameBanEdit = new QLineEdit(QString::fromStdString(info.name()));
ipBanCheckBox = new QCheckBox(tr("ban &IP address")); ipBanCheckBox = new QCheckBox(tr("ban &IP address"));
ipBanCheckBox->setChecked(true); ipBanCheckBox->setChecked(true);
ipBanEdit = new QLineEdit(info->getAddress()); ipBanEdit = new QLineEdit(QString::fromStdString(info.address()));
QGridLayout *banTypeGrid = new QGridLayout; QGridLayout *banTypeGrid = new QGridLayout;
banTypeGrid->addWidget(nameBanCheckBox, 0, 0); banTypeGrid->addWidget(nameBanCheckBox, 0, 0);
banTypeGrid->addWidget(nameBanEdit, 0, 1); banTypeGrid->addWidget(nameBanEdit, 0, 1);
@ -211,12 +212,12 @@ void UserList::retranslateUi()
updateCount(); updateCount();
} }
void UserList::processUserInfo(ServerInfo_User *user, bool online) void UserList::processUserInfo(const ServerInfo_User &user, bool online)
{ {
QTreeWidgetItem *item = 0; QTreeWidgetItem *item = 0;
for (int i = 0; i < userTree->topLevelItemCount(); ++i) { for (int i = 0; i < userTree->topLevelItemCount(); ++i) {
QTreeWidgetItem *temp = userTree->topLevelItem(i); QTreeWidgetItem *temp = userTree->topLevelItem(i);
if (temp->data(2, Qt::UserRole) == user->getName()) { if (temp->data(2, Qt::UserRole) == QString::fromStdString(user.name())) {
item = temp; item = temp;
break; break;
} }
@ -228,11 +229,11 @@ void UserList::processUserInfo(ServerInfo_User *user, bool online)
++onlineCount; ++onlineCount;
updateCount(); updateCount();
} }
item->setData(0, Qt::UserRole, user->getUserLevel()); item->setData(0, Qt::UserRole, user.user_level());
item->setIcon(0, QIcon(UserLevelPixmapGenerator::generatePixmap(12, user->getUserLevel()))); item->setIcon(0, QIcon(UserLevelPixmapGenerator::generatePixmap(12, user.user_level())));
item->setIcon(1, QIcon(CountryPixmapGenerator::generatePixmap(12, user->getCountry()))); item->setIcon(1, QIcon(CountryPixmapGenerator::generatePixmap(12, QString::fromStdString(user.country()))));
item->setData(2, Qt::UserRole, user->getName()); item->setData(2, Qt::UserRole, QString::fromStdString(user.name()));
item->setData(2, Qt::DisplayRole, user->getName()); item->setData(2, Qt::DisplayRole, QString::fromStdString(user.name()));
item->setData(0, Qt::UserRole + 1, online); item->setData(0, Qt::UserRole + 1, online);
if (online) if (online)
@ -294,43 +295,42 @@ void UserList::userClicked(QTreeWidgetItem *item, int /*column*/)
emit openMessageDialog(item->data(2, Qt::UserRole).toString(), true); emit openMessageDialog(item->data(2, Qt::UserRole).toString(), true);
} }
void UserList::gamesOfUserReceived(ProtocolResponse *resp) void UserList::gamesOfUserReceived(const Response &resp)
{ {
Response_GetGamesOfUser *response = qobject_cast<Response_GetGamesOfUser *>(resp); const Response_GetGamesOfUser &response = resp.GetExtension(Response_GetGamesOfUser::ext);
if (!response)
return;
const Command_GetGamesOfUser &cmd = static_cast<const Command_GetGamesOfUser &>(static_cast<PendingCommand *>(sender())->getCommandContainer().session_command(0).GetExtension(Command_GetGamesOfUser::ext)); const Command_GetGamesOfUser &cmd = static_cast<const Command_GetGamesOfUser &>(static_cast<PendingCommand *>(sender())->getCommandContainer().session_command(0).GetExtension(Command_GetGamesOfUser::ext));
QMap<int, GameTypeMap> gameTypeMap; QMap<int, GameTypeMap> gameTypeMap;
QMap<int, QString> roomMap; QMap<int, QString> roomMap;
const QList<ServerInfo_Room *> roomList = response->getRoomList(); const int roomListSize = response.room_list_size();
for (int i = 0; i < roomList.size(); ++i) { for (int i = 0; i < roomListSize; ++i) {
roomMap.insert(roomList[i]->getRoomId(), roomList[i]->getName()); const ServerInfo_Room &roomInfo = response.room_list(i);
const QList<ServerInfo_GameType *> gameTypeList = roomList[i]->getGameTypeList(); roomMap.insert(roomInfo.room_id(), QString::fromStdString(roomInfo.name()));
GameTypeMap tempMap; GameTypeMap tempMap;
for (int j = 0; j < gameTypeList.size(); ++j) const int gameTypeListSize = roomInfo.gametype_list_size();
tempMap.insert(gameTypeList[j]->getGameTypeId(), gameTypeList[j]->getDescription()); for (int j = 0; j < gameTypeListSize; ++j) {
gameTypeMap.insert(roomList[i]->getRoomId(), tempMap); const ServerInfo_GameType &gameTypeInfo = roomInfo.gametype_list(j);
tempMap.insert(gameTypeInfo.game_type_id(), QString::fromStdString(gameTypeInfo.description()));
}
gameTypeMap.insert(roomInfo.room_id(), tempMap);
} }
GameSelector *selector = new GameSelector(client, tabSupervisor, 0, roomMap, gameTypeMap); GameSelector *selector = new GameSelector(client, tabSupervisor, 0, roomMap, gameTypeMap);
const QList<ServerInfo_Game *> gameList = response->getGameList(); const int gameListSize = response.game_list_size();
for (int i = 0; i < gameList.size(); ++i) for (int i = 0; i < gameListSize; ++i)
selector->processGameInfo(gameList[i]); selector->processGameInfo(response.game_list(i));
selector->setWindowTitle(tr("%1's games").arg(QString::fromStdString(cmd.user_name()))); selector->setWindowTitle(tr("%1's games").arg(QString::fromStdString(cmd.user_name())));
selector->setAttribute(Qt::WA_DeleteOnClose); selector->setAttribute(Qt::WA_DeleteOnClose);
selector->show(); selector->show();
} }
void UserList::banUser_processUserInfoResponse(ProtocolResponse *r) void UserList::banUser_processUserInfoResponse(const Response &r)
{ {
Response_GetUserInfo *response = qobject_cast<Response_GetUserInfo *>(r); const Response_GetUserInfo &response = r.GetExtension(Response_GetUserInfo::ext);
if (!response)
return;
// The dialog needs to be non-modal in order to not block the event queue of the client. // The dialog needs to be non-modal in order to not block the event queue of the client.
BanDialog *dlg = new BanDialog(response->getUserInfo(), this); BanDialog *dlg = new BanDialog(response.user_info(), this);
connect(dlg, SIGNAL(accepted()), this, SLOT(banUser_dialogFinished())); connect(dlg, SIGNAL(accepted()), this, SLOT(banUser_dialogFinished()));
dlg->show(); dlg->show();
} }
@ -385,7 +385,7 @@ void UserList::showContextMenu(const QPoint &pos, const QModelIndex &index)
menu->addSeparator(); menu->addSeparator();
menu->addAction(aBan); menu->addAction(aBan);
} }
if (userName == tabSupervisor->getUserInfo()->getName()) { if (userName == QString::fromStdString(tabSupervisor->getUserInfo()->name())) {
aChat->setEnabled(false); aChat->setEnabled(false);
aAddToBuddyList->setEnabled(false); aAddToBuddyList->setEnabled(false);
aRemoveFromBuddyList->setEnabled(false); aRemoveFromBuddyList->setEnabled(false);

10
cockatrice/src/userlist.h
View file

@ -15,7 +15,7 @@ class QCheckBox;
class QSpinBox; class QSpinBox;
class QRadioButton; class QRadioButton;
class QPlainTextEdit; class QPlainTextEdit;
class ProtocolResponse; class Response;
class BanDialog : public QDialog { class BanDialog : public QDialog {
Q_OBJECT Q_OBJECT
@ -30,7 +30,7 @@ private slots:
void okClicked(); void okClicked();
void enableTemporaryEdits(bool enabled); void enableTemporaryEdits(bool enabled);
public: public:
BanDialog(ServerInfo_User *info, QWidget *parent = 0); BanDialog(const ServerInfo_User &info, QWidget *parent = 0);
QString getBanName() const; QString getBanName() const;
QString getBanIP() const; QString getBanIP() const;
int getMinutes() const; int getMinutes() const;
@ -65,9 +65,9 @@ private:
void setUserOnline(QTreeWidgetItem *user, bool online); void setUserOnline(QTreeWidgetItem *user, bool online);
private slots: private slots:
void userClicked(QTreeWidgetItem *item, int column); void userClicked(QTreeWidgetItem *item, int column);
void banUser_processUserInfoResponse(ProtocolResponse *resp); void banUser_processUserInfoResponse(const Response &resp);
void banUser_dialogFinished(); void banUser_dialogFinished();
void gamesOfUserReceived(ProtocolResponse *resp); void gamesOfUserReceived(const Response &resp);
signals: signals:
void openMessageDialog(const QString &userName, bool focus); void openMessageDialog(const QString &userName, bool focus);
void addBuddy(const QString &userName); void addBuddy(const QString &userName);
@ -77,7 +77,7 @@ signals:
public: public:
UserList(TabSupervisor *_tabSupervisor, AbstractClient *_client, UserListType _type, QWidget *parent = 0); UserList(TabSupervisor *_tabSupervisor, AbstractClient *_client, UserListType _type, QWidget *parent = 0);
void retranslateUi(); void retranslateUi();
void processUserInfo(ServerInfo_User *user, bool online); void processUserInfo(const ServerInfo_User &user, bool online);
bool deleteUser(const QString &userName); bool deleteUser(const QString &userName);
void setUserOnline(const QString &userName, bool online); void setUserOnline(const QString &userName, bool online);
bool userInList(const QString &userName) const; bool userInList(const QString &userName) const;

8
cockatrice/src/window_main.cpp
View file

@ -96,7 +96,7 @@ void MainWindow::statusChanged(ClientStatus _status)
} }
} }
void MainWindow::userInfoReceived(ServerInfo_User *info) void MainWindow::userInfoReceived(const ServerInfo_User &info)
{ {
tabSupervisor->start(client, info); tabSupervisor->start(client, info);
} }
@ -302,14 +302,14 @@ MainWindow::MainWindow(QWidget *parent)
QPixmapCache::setCacheLimit(200000); QPixmapCache::setCacheLimit(200000);
client = new RemoteClient(this); client = new RemoteClient(this);
connect(client, SIGNAL(connectionClosedEventReceived(Event_ConnectionClosed *)), this, SLOT(processConnectionClosedEvent(Event_ConnectionClosed *))); connect(client, SIGNAL(connectionClosedEventReceived(const Event_ConnectionClosed &)), this, SLOT(processConnectionClosedEvent(const Event_ConnectionClosed &)));
connect(client, SIGNAL(serverShutdownEventReceived(Event_ServerShutdown *)), this, SLOT(processServerShutdownEvent(Event_ServerShutdown *))); connect(client, SIGNAL(serverShutdownEventReceived(const Event_ServerShutdown &)), this, SLOT(processServerShutdownEvent(const Event_ServerShutdown &)));
connect(client, SIGNAL(serverError(Response::ResponseCode)), this, SLOT(serverError(Response::ResponseCode))); connect(client, SIGNAL(serverError(Response::ResponseCode)), this, SLOT(serverError(Response::ResponseCode)));
connect(client, SIGNAL(socketError(const QString &)), this, SLOT(socketError(const QString &))); connect(client, SIGNAL(socketError(const QString &)), this, SLOT(socketError(const QString &)));
connect(client, SIGNAL(serverTimeout()), this, SLOT(serverTimeout())); connect(client, SIGNAL(serverTimeout()), this, SLOT(serverTimeout()));
connect(client, SIGNAL(statusChanged(ClientStatus)), this, SLOT(statusChanged(ClientStatus))); connect(client, SIGNAL(statusChanged(ClientStatus)), this, SLOT(statusChanged(ClientStatus)));
connect(client, SIGNAL(protocolVersionMismatch(int, int)), this, SLOT(protocolVersionMismatch(int, int))); connect(client, SIGNAL(protocolVersionMismatch(int, int)), this, SLOT(protocolVersionMismatch(int, int)));
connect(client, SIGNAL(userInfoChanged(ServerInfo_User *)), this, SLOT(userInfoReceived(ServerInfo_User *))); connect(client, SIGNAL(userInfoChanged(const ServerInfo_User &)), this, SLOT(userInfoReceived(const ServerInfo_User &)));
tabSupervisor = new TabSupervisor; tabSupervisor = new TabSupervisor;
connect(tabSupervisor, SIGNAL(setMenu(QMenu *)), this, SLOT(updateTabMenu(QMenu *))); connect(tabSupervisor, SIGNAL(setMenu(QMenu *)), this, SLOT(updateTabMenu(QMenu *)));

2
cockatrice/src/window_main.h
View file

@ -41,7 +41,7 @@ private slots:
void serverError(Response::ResponseCode r); void serverError(Response::ResponseCode r);
void socketError(const QString &errorStr); void socketError(const QString &errorStr);
void protocolVersionMismatch(int localVersion, int remoteVersion); void protocolVersionMismatch(int localVersion, int remoteVersion);
void userInfoReceived(ServerInfo_User *userInfo); void userInfoReceived(const ServerInfo_User &userInfo);
void localGameEnded(); void localGameEnded();
void actConnect(); void actConnect();

3
cockatrice/src/zoneviewwidget.cpp
View file

@ -11,7 +11,6 @@
#include "zoneviewzone.h" #include "zoneviewzone.h"
#include "player.h" #include "player.h"
#include "gamescene.h" #include "gamescene.h"
#include "protocol_items.h"
#include "settingscache.h" #include "settingscache.h"
#include "gamescene.h" #include "gamescene.h"
@ -56,7 +55,7 @@ void TitleLabel::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
emit mouseMoved(event->scenePos() - buttonDownPos); emit mouseMoved(event->scenePos() - buttonDownPos);
} }
ZoneViewWidget::ZoneViewWidget(Player *_player, CardZone *_origZone, int numberCards, bool _revealZone, const QList<ServerInfo_Card *> &cardList) ZoneViewWidget::ZoneViewWidget(Player *_player, CardZone *_origZone, int numberCards, bool _revealZone, const QList<const ServerInfo_Card *> &cardList)
: QGraphicsWidget(0, Qt::Tool | Qt::FramelessWindowHint), player(_player) : QGraphicsWidget(0, Qt::Tool | Qt::FramelessWindowHint), player(_player)
{ {
setAcceptHoverEvents(true); setAcceptHoverEvents(true);

2
cockatrice/src/zoneviewwidget.h
View file

@ -51,7 +51,7 @@ private slots:
void zoneDeleted(); void zoneDeleted();
void moveWidget(QPointF scenePos); void moveWidget(QPointF scenePos);
public: public:
ZoneViewWidget(Player *_player, CardZone *_origZone, int numberCards = 0, bool _revealZone = false, const QList<ServerInfo_Card *> &cardList = QList<ServerInfo_Card *>()); ZoneViewWidget(Player *_player, CardZone *_origZone, int numberCards = 0, bool _revealZone = false, const QList<const ServerInfo_Card *> &cardList = QList<const ServerInfo_Card *>());
ZoneViewZone *getZone() const { return zone; } ZoneViewZone *getZone() const { return zone; }
void retranslateUi(); void retranslateUi();
protected: protected:

26
cockatrice/src/zoneviewzone.cpp
View file

@ -3,11 +3,11 @@
#include "zoneviewzone.h" #include "zoneviewzone.h"
#include "player.h" #include "player.h"
#include "carddragitem.h" #include "carddragitem.h"
#include "protocol_items.h" #include "carditem.h"
#include "protocol_datastructures.h"
#include "pb/command_dump_zone.pb.h" #include "pb/command_dump_zone.pb.h"
#include "pb/command_move_card.pb.h" #include "pb/command_move_card.pb.h"
#include "pb/serverinfo_card.pb.h"
#include "pb/response_dump_zone.pb.h"
#include "pending_command.h" #include "pending_command.h"
ZoneViewZone::ZoneViewZone(Player *_p, CardZone *_origZone, int _numberCards, bool _revealZone, QGraphicsItem *parent) ZoneViewZone::ZoneViewZone(Player *_p, CardZone *_origZone, int _numberCards, bool _revealZone, QGraphicsItem *parent)
@ -34,11 +34,11 @@ void ZoneViewZone::paint(QPainter */*painter*/, const QStyleOptionGraphicsItem *
{ {
} }
void ZoneViewZone::initializeCards(const QList<ServerInfo_Card *> &cardList) void ZoneViewZone::initializeCards(const QList<const ServerInfo_Card *> &cardList)
{ {
if (!cardList.isEmpty()) { if (!cardList.isEmpty()) {
for (int i = 0; i < cardList.size(); ++i) for (int i = 0; i < cardList.size(); ++i)
addCard(new CardItem(player, cardList[i]->getName(), cardList[i]->getId(), revealZone, this), false, i); addCard(new CardItem(player, QString::fromStdString(cardList[i]->name()), cardList[i]->id(), revealZone, this), false, i);
reorganizeCards(); reorganizeCards();
} else if (!origZone->contentsKnown()) { } else if (!origZone->contentsKnown()) {
Command_DumpZone cmd; Command_DumpZone cmd;
@ -47,7 +47,7 @@ void ZoneViewZone::initializeCards(const QList<ServerInfo_Card *> &cardList)
cmd.set_number_cards(numberCards); cmd.set_number_cards(numberCards);
PendingCommand *pend = player->prepareGameCommand(cmd); PendingCommand *pend = player->prepareGameCommand(cmd);
connect(pend, SIGNAL(finished(ProtocolResponse *)), this, SLOT(zoneDumpReceived(ProtocolResponse *))); connect(pend, SIGNAL(finished(const Response &)), this, SLOT(zoneDumpReceived(const Response &)));
player->sendGameCommand(pend); player->sendGameCommand(pend);
} else { } else {
const CardList &c = origZone->getCards(); const CardList &c = origZone->getCards();
@ -60,15 +60,13 @@ void ZoneViewZone::initializeCards(const QList<ServerInfo_Card *> &cardList)
} }
} }
void ZoneViewZone::zoneDumpReceived(ProtocolResponse *r) void ZoneViewZone::zoneDumpReceived(const Response &r)
{ {
Response_DumpZone *resp = qobject_cast<Response_DumpZone *>(r); const Response_DumpZone &resp = r.GetExtension(Response_DumpZone::ext);
if (!resp) const int respCardListSize = resp.zone_info().card_list_size();
return; for (int i = 0; i < respCardListSize; ++i) {
const ServerInfo_Card &cardInfo = resp.zone_info().card_list(i);
const QList<ServerInfo_Card *> &respCardList = resp->getZone()->getCardList(); CardItem *card = new CardItem(player, QString::fromStdString(cardInfo.name()), cardInfo.id(), revealZone, this);
for (int i = 0; i < respCardList.size(); i++) {
CardItem *card = new CardItem(player, respCardList[i]->getName(), respCardList[i]->getId(), revealZone, this);
addCard(card, false, i); addCard(card, false, i);
} }

6
cockatrice/src/zoneviewzone.h
View file

@ -5,7 +5,7 @@
#include <QGraphicsLayoutItem> #include <QGraphicsLayoutItem>
class ZoneViewWidget; class ZoneViewWidget;
class ProtocolResponse; class Response;
class ServerInfo_Card; class ServerInfo_Card;
class ZoneViewZone : public SelectZone, public QGraphicsLayoutItem { class ZoneViewZone : public SelectZone, public QGraphicsLayoutItem {
@ -23,7 +23,7 @@ public:
QRectF boundingRect() const; QRectF boundingRect() const;
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
void reorganizeCards(); void reorganizeCards();
void initializeCards(const QList<ServerInfo_Card *> &cardList = QList<ServerInfo_Card *>()); void initializeCards(const QList<const ServerInfo_Card *> &cardList = QList<const ServerInfo_Card *>());
void removeCard(int position); void removeCard(int position);
int getNumberCards() const { return numberCards; } int getNumberCards() const { return numberCards; }
void setGeometry(const QRectF &rect); void setGeometry(const QRectF &rect);
@ -32,7 +32,7 @@ public slots:
void setSortByName(int _sortByName); void setSortByName(int _sortByName);
void setSortByType(int _sortByType); void setSortByType(int _sortByType);
private slots: private slots:
void zoneDumpReceived(ProtocolResponse *r); void zoneDumpReceived(const Response &r);
signals: signals:
void beingDeleted(); void beingDeleted();
void optimumRectChanged(); void optimumRectChanged();

7
common/.directory
View file

@ -1,3 +1,6 @@
[Dolphin] [Dolphin]
Timestamp=2009,10,26,13,45,44 Timestamp=2011,12,31,17,13,2
ViewMode=1 Version=2
[Settings]
ShowDotFiles=true

47
common/color.h
View file

@ -7,32 +7,29 @@
#include "pb/color.pb.h" #include "pb/color.pb.h"
class Color {
private:
int value;
public:
Color(const color &other) : value(other.r() * 65536 + other.g() * 256 + other.b()) { } // TEMPORARY HACK
Color(int _value = 0) : value(_value) { }
Color(int r, int g, int b) : value(r * 65536 + g * 256 + b) { }
int getValue() const { return value; }
#ifdef QT_GUI_LIB #ifdef QT_GUI_LIB
Color(const QColor &_color) inline QColor convertColorToQColor(const color &c)
{ {
value = _color.red() * 65536 + _color.green() * 256 + _color.blue(); return QColor(c.r(), c.g(), c.b());
} }
QColor getQColor() const
{ inline color convertQColorToColor(const QColor &c)
return QColor(value / 65536, (value % 65536) / 256, value % 256); {
} color result;
result.set_r(c.red());
result.set_g(c.green());
result.set_b(c.blue());
return result;
}
#endif #endif
color get_color() const // HACK
{ inline color makeColor(int r, int g, int b)
color c; {
c.set_r(value / 65536); color result;
c.set_g((value % 65536) / 256); result.set_r(r);
c.set_b(value % 256); result.set_g(g);
return c; result.set_b(b);
} return result;
}; }
#endif #endif

12
common/pb/proto/event_move_card.proto
View file

@ -4,14 +4,14 @@ message Event_MoveCard {
extend GameEvent { extend GameEvent {
optional Event_MoveCard ext = 2009; optional Event_MoveCard ext = 2009;
} }
optional sint32 card_id = 1; optional sint32 card_id = 1 [default = -1];
optional string card_name = 2; optional string card_name = 2;
optional string start_zone = 3; optional string start_zone = 3;
optional sint32 position = 4; optional sint32 position = 4 [default = -1];
optional sint32 target_player_id = 5; optional sint32 target_player_id = 5 [default = -1];
optional string target_zone = 6; optional string target_zone = 6;
optional sint32 x = 7; optional sint32 x = 7 [default = -1];
optional sint32 y = 8; optional sint32 y = 8 [default = -1];
optional sint32 new_card_id = 9; optional sint32 new_card_id = 9 [default = -1];
optional bool face_down = 10; optional bool face_down = 10;
} }

2
common/pb/proto/game_event.proto
View file

@ -31,6 +31,6 @@ message GameEvent {
DUMP_ZONE = 2018; DUMP_ZONE = 2018;
STOP_DUMP_ZONE = 2019; STOP_DUMP_ZONE = 2019;
} }
optional sint32 player_id = 1; optional sint32 player_id = 1 [default = -1];
extensions 100 to max; extensions 100 to max;
} }

15
common/serializable_item.cpp
View file

@ -163,21 +163,6 @@ void SerializableItem_Bool::writeElement(QXmlStreamWriter *xml)
xml->writeCharacters(data ? "1" : "0"); xml->writeCharacters(data ? "1" : "0");
} }
bool SerializableItem_Color::readElement(QXmlStreamReader *xml)
{
if (xml->isCharacters() && !xml->isWhitespace()) {
bool ok;
int colorValue = xml->text().toString().toInt(&ok);
data = ok ? Color(colorValue) : Color();
}
return SerializableItem::readElement(xml);
}
void SerializableItem_Color::writeElement(QXmlStreamWriter *xml)
{
xml->writeCharacters(QString::number(data.getValue()));
}
bool SerializableItem_DateTime::readElement(QXmlStreamReader *xml) bool SerializableItem_DateTime::readElement(QXmlStreamReader *xml)
{ {
if (xml->isCharacters() && !xml->isWhitespace()) { if (xml->isCharacters() && !xml->isWhitespace()) {

14
common/serializable_item.h
View file

@ -122,20 +122,6 @@ public:
bool isEmpty() const { return data == false; } bool isEmpty() const { return data == false; }
}; };
class SerializableItem_Color : public SerializableItem {
private:
Color data;
protected:
bool readElement(QXmlStreamReader *xml);
void writeElement(QXmlStreamWriter *xml);
public:
SerializableItem_Color(const QString &_itemType, const Color &_data = Color())
: SerializableItem(_itemType), data(_data) { }
const Color &getData() { return data; }
void setData(const Color &_data) { data = _data; }
bool isEmpty() const { return data.getValue() == 0; }
};
class SerializableItem_DateTime : public SerializableItem { class SerializableItem_DateTime : public SerializableItem {
private: private:
QDateTime data; QDateTime data;

10
common/server_arrow.h
View file

@ -1,7 +1,7 @@
#ifndef SERVER_ARROW_H #ifndef SERVER_ARROW_H
#define SERVER_ARROW_H #define SERVER_ARROW_H
#include "color.h" #include "pb/color.pb.h"
class Server_Card; class Server_Card;
class Server_ArrowTarget; class Server_ArrowTarget;
@ -11,14 +11,14 @@ private:
int id; int id;
Server_Card *startCard; Server_Card *startCard;
Server_ArrowTarget *targetItem; Server_ArrowTarget *targetItem;
Color color; color arrowColor;
public: public:
Server_Arrow(int _id, Server_Card *_startCard, Server_ArrowTarget *_targetItem, const Color &_color) Server_Arrow(int _id, Server_Card *_startCard, Server_ArrowTarget *_targetItem, const color &_arrowColor)
: id(_id), startCard(_startCard), targetItem(_targetItem), color(_color) { } : id(_id), startCard(_startCard), targetItem(_targetItem), arrowColor(_arrowColor) { }
int getId() const { return id; } int getId() const { return id; }
Server_Card *getStartCard() const { return startCard; } Server_Card *getStartCard() const { return startCard; }
Server_ArrowTarget *getTargetItem() const { return targetItem; } Server_ArrowTarget *getTargetItem() const { return targetItem; }
const Color &getColor() const { return color; } const color &getColor() const { return arrowColor; }
}; };
#endif #endif

8
common/server_counter.h
View file

@ -21,21 +21,21 @@
#define SERVER_COUNTER_H #define SERVER_COUNTER_H
#include <QString> #include <QString>
#include "color.h" #include "pb/color.pb.h"
class Server_Counter { class Server_Counter {
protected: protected:
int id; int id;
QString name; QString name;
Color color; color counterColor;
int radius; int radius;
int count; int count;
public: public:
Server_Counter(int _id, const QString &_name, const Color &_color, int _radius, int _count = 0) : id(_id), name(_name), color(_color), radius(_radius), count(_count) { } Server_Counter(int _id, const QString &_name, const color &_counterColor, int _radius, int _count = 0) : id(_id), name(_name), counterColor(_counterColor), radius(_radius), count(_count) { }
~Server_Counter() { } ~Server_Counter() { }
int getId() const { return id; } int getId() const { return id; }
QString getName() const { return name; } QString getName() const { return name; }
Color getColor() const { return color; } const color &getColor() const { return counterColor; }
int getRadius() const { return radius; } int getRadius() const { return radius; }
int getCount() const { return count; } int getCount() const { return count; }
void setCount(int _count) { count = _count; } void setCount(int _count) { count = _count; }

7
common/server_game.cpp
View file

@ -460,7 +460,8 @@ QList<ServerInfo_Player> Server_Game::getGameState(Server_Player *playerWhosAski
ServerInfo_Player playerInfo; ServerInfo_Player playerInfo;
playerInfo.mutable_properties()->CopyFrom(player->getProperties()); playerInfo.mutable_properties()->CopyFrom(player->getProperties());
if (player == playerWhosAsking) if (player == playerWhosAsking)
playerInfo.set_deck_list(player->getDeck()->writeToString_Native().toStdString()); if (player->getDeck())
playerInfo.set_deck_list(player->getDeck()->writeToString_Native().toStdString());
QList<ServerInfo_Arrow *> arrowList; QList<ServerInfo_Arrow *> arrowList;
QMapIterator<int, Server_Arrow *> arrowIterator(player->getArrows()); QMapIterator<int, Server_Arrow *> arrowIterator(player->getArrows());
@ -472,7 +473,7 @@ QList<ServerInfo_Player> Server_Game::getGameState(Server_Player *playerWhosAski
arrowInfo->set_start_player_id(arrow->getStartCard()->getZone()->getPlayer()->getPlayerId()); arrowInfo->set_start_player_id(arrow->getStartCard()->getZone()->getPlayer()->getPlayerId());
arrowInfo->set_start_zone(arrow->getStartCard()->getZone()->getName().toStdString()); arrowInfo->set_start_zone(arrow->getStartCard()->getZone()->getName().toStdString());
arrowInfo->set_start_card_id(arrow->getStartCard()->getId()); arrowInfo->set_start_card_id(arrow->getStartCard()->getId());
arrowInfo->mutable_arrow_color()->CopyFrom(arrow->getColor().get_color()); arrowInfo->mutable_arrow_color()->CopyFrom(arrow->getColor());
if (targetCard) { if (targetCard) {
arrowInfo->set_target_player_id(targetCard->getZone()->getPlayer()->getPlayerId()); arrowInfo->set_target_player_id(targetCard->getZone()->getPlayer()->getPlayerId());
arrowInfo->set_target_zone(targetCard->getZone()->getName().toStdString()); arrowInfo->set_target_zone(targetCard->getZone()->getName().toStdString());
@ -487,7 +488,7 @@ QList<ServerInfo_Player> Server_Game::getGameState(Server_Player *playerWhosAski
ServerInfo_Counter *counterInfo = playerInfo.add_counter_list(); ServerInfo_Counter *counterInfo = playerInfo.add_counter_list();
counterInfo->set_id(counter->getId()); counterInfo->set_id(counter->getId());
counterInfo->set_name(counter->getName().toStdString()); counterInfo->set_name(counter->getName().toStdString());
counterInfo->mutable_counter_color()->CopyFrom(counter->getColor().get_color()); counterInfo->mutable_counter_color()->CopyFrom(counter->getColor());
counterInfo->set_radius(counter->getRadius()); counterInfo->set_radius(counter->getRadius());
counterInfo->set_count(counter->getCount()); counterInfo->set_count(counter->getCount());
} }

19
common/server_player.cpp
View file

@ -99,14 +99,14 @@ void Server_Player::setupZones()
addZone(new Server_CardZone(this, "grave", false, ServerInfo_Zone::PublicZone)); addZone(new Server_CardZone(this, "grave", false, ServerInfo_Zone::PublicZone));
addZone(new Server_CardZone(this, "rfg", false, ServerInfo_Zone::PublicZone)); addZone(new Server_CardZone(this, "rfg", false, ServerInfo_Zone::PublicZone));
addCounter(new Server_Counter(0, "life", Color(255, 255, 255), 25, 20)); addCounter(new Server_Counter(0, "life", makeColor(255, 255, 255), 25, 20));
addCounter(new Server_Counter(1, "w", Color(255, 255, 150), 20, 0)); addCounter(new Server_Counter(1, "w", makeColor(255, 255, 150), 20, 0));
addCounter(new Server_Counter(2, "u", Color(150, 150, 255), 20, 0)); addCounter(new Server_Counter(2, "u", makeColor(150, 150, 255), 20, 0));
addCounter(new Server_Counter(3, "b", Color(150, 150, 150), 20, 0)); addCounter(new Server_Counter(3, "b", makeColor(150, 150, 150), 20, 0));
addCounter(new Server_Counter(4, "r", Color(250, 150, 150), 20, 0)); addCounter(new Server_Counter(4, "r", makeColor(250, 150, 150), 20, 0));
addCounter(new Server_Counter(5, "g", Color(150, 255, 150), 20, 0)); addCounter(new Server_Counter(5, "g", makeColor(150, 255, 150), 20, 0));
addCounter(new Server_Counter(6, "x", Color(255, 255, 255), 20, 0)); addCounter(new Server_Counter(6, "x", makeColor(255, 255, 255), 20, 0));
addCounter(new Server_Counter(7, "storm", Color(255, 255, 255), 20, 0)); addCounter(new Server_Counter(7, "storm", makeColor(255, 255, 255), 20, 0));
initialCards = 7; initialCards = 7;
@ -467,7 +467,8 @@ Response::ResponseCode Server_Player::moveCard(GameEventStorage &ges, Server_Car
Event_MoveCard eventOthers; Event_MoveCard eventOthers;
eventOthers.set_start_zone(startzone->getName().toStdString()); eventOthers.set_start_zone(startzone->getName().toStdString());
eventOthers.set_target_player_id(targetzone->getPlayer()->getPlayerId()); eventOthers.set_target_player_id(targetzone->getPlayer()->getPlayerId());
eventOthers.set_target_zone(targetzone->getName().toStdString()); if (startzone != targetzone)
eventOthers.set_target_zone(targetzone->getName().toStdString());
eventOthers.set_x(newX); eventOthers.set_x(newX);
eventOthers.set_y(y); eventOthers.set_y(y);
eventOthers.set_face_down(thisCardProperties->face_down()); eventOthers.set_face_down(thisCardProperties->face_down());

7
common/server_protocolhandler.cpp
View file

@ -532,7 +532,6 @@ Response::ResponseCode Server_ProtocolHandler::cmdLogin(const Command_Login &cmd
server->serverMutex.lock(); server->serverMutex.lock();
QList<ServerInfo_Game *> gameList;
QMapIterator<int, Server_Room *> roomIterator(server->getRooms()); QMapIterator<int, Server_Room *> roomIterator(server->getRooms());
QMutexLocker gameListLocker(&gameListMutex); QMutexLocker gameListLocker(&gameListMutex);
while (roomIterator.hasNext()) { while (roomIterator.hasNext()) {
@ -613,8 +612,6 @@ Response::ResponseCode Server_ProtocolHandler::cmdGetGamesOfUser(const Command_G
return Response::RespNameNotFound; return Response::RespNameNotFound;
Response_GetGamesOfUser *re = new Response_GetGamesOfUser; Response_GetGamesOfUser *re = new Response_GetGamesOfUser;
QList<ServerInfo_Room *> roomList;
QList<ServerInfo_Game *> gameList;
QMapIterator<int, Server_Room *> roomIterator(server->getRooms()); QMapIterator<int, Server_Room *> roomIterator(server->getRooms());
while (roomIterator.hasNext()) { while (roomIterator.hasNext()) {
Server_Room *room = roomIterator.next().value(); Server_Room *room = roomIterator.next().value();
@ -1574,7 +1571,6 @@ Response::ResponseCode Server_ProtocolHandler::cmdDumpZone(const Command_DumpZon
zoneInfo->set_with_coords(zone->hasCoords()); zoneInfo->set_with_coords(zone->hasCoords());
zoneInfo->set_card_count(numberCards < zone->cards.size() ? zone->cards.size() : numberCards); zoneInfo->set_card_count(numberCards < zone->cards.size() ? zone->cards.size() : numberCards);
QList<ServerInfo_Card *> respCardList;
for (int i = 0; (i < zone->cards.size()) && (i < numberCards || numberCards == -1); ++i) { for (int i = 0; (i < zone->cards.size()) && (i < numberCards || numberCards == -1); ++i) {
Server_Card *card = zone->cards[i]; Server_Card *card = zone->cards[i];
QString displayedName = card->getFaceDown() ? QString() : card->getName(); QString displayedName = card->getFaceDown() ? QString() : card->getName();
@ -1595,7 +1591,6 @@ Response::ResponseCode Server_ProtocolHandler::cmdDumpZone(const Command_DumpZon
cardInfo->set_destroy_on_zone_change(card->getDestroyOnZoneChange()); cardInfo->set_destroy_on_zone_change(card->getDestroyOnZoneChange());
cardInfo->set_doesnt_untap(card->getDoesntUntap()); cardInfo->set_doesnt_untap(card->getDoesntUntap());
QList<ServerInfo_CardCounter *> cardCounterList;
QMapIterator<int, int> cardCounterIterator(card->getCounters()); QMapIterator<int, int> cardCounterIterator(card->getCounters());
while (cardCounterIterator.hasNext()) { while (cardCounterIterator.hasNext()) {
cardCounterIterator.next(); cardCounterIterator.next();
@ -1692,7 +1687,6 @@ Response::ResponseCode Server_ProtocolHandler::cmdRevealCards(const Command_Reve
Event_RevealCards eventPrivate(eventOthers); Event_RevealCards eventPrivate(eventOthers);
QList<ServerInfo_Card *> respCardListPrivate, respCardListOmniscient;
for (int i = 0; i < cardsToReveal.size(); ++i) { for (int i = 0; i < cardsToReveal.size(); ++i) {
Server_Card *card = cardsToReveal[i]; Server_Card *card = cardsToReveal[i];
ServerInfo_Card *cardInfo = eventPrivate.add_cards(); ServerInfo_Card *cardInfo = eventPrivate.add_cards();
@ -1710,7 +1704,6 @@ Response::ResponseCode Server_ProtocolHandler::cmdRevealCards(const Command_Reve
cardInfo->set_destroy_on_zone_change(card->getDestroyOnZoneChange()); cardInfo->set_destroy_on_zone_change(card->getDestroyOnZoneChange());
cardInfo->set_doesnt_untap(card->getDoesntUntap()); cardInfo->set_doesnt_untap(card->getDoesntUntap());
QList<ServerInfo_CardCounter *> cardCounterList;
QMapIterator<int, int> cardCounterIterator(card->getCounters()); QMapIterator<int, int> cardCounterIterator(card->getCounters());
while (cardCounterIterator.hasNext()) { while (cardCounterIterator.hasNext()) {
cardCounterIterator.next(); cardCounterIterator.next();