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
OBJECTS_DIR = build
RESOURCES = cockatrice.qrc
QMAKE_CXXFLAGS_RELEASE += -O2
CPPFLAGS += -O2
QT += network script svg
LIBS += -lprotobuf
unix:!macx {
@ -84,6 +86,7 @@ HEADERS += src/abstractcounter.h \
src/priceupdater.h \
src/soundengine.h \
src/pending_command.h \
../common/get_pb_extension.h \
../common/color.h \
../common/serializable_item.h \
../common/decklist.h \
@ -168,6 +171,7 @@ SOURCES += src/abstractcounter.cpp \
src/localclient.cpp \
src/priceupdater.cpp \
src/soundengine.cpp \
../common/get_pb_extension.cpp \
../common/serializable_item.cpp \
../common/decklist.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_left.pb.h"
#include "pb/event_game_joined.pb.h"
#include "get_pb_extension.h"
#include <google/protobuf/descriptor.h>
AbstractClient::AbstractClient(QObject *parent)
@ -42,15 +43,7 @@ void AbstractClient::processProtocolItem(const ServerMessage &item)
}
case ServerMessage::SESSION_EVENT: {
const SessionEvent &event = item.session_event();
std::vector< const ::google::protobuf::FieldDescriptor * > fieldList;
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) {
switch ((SessionEvent::SessionEventType) getPbExtension(event)) {
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_SHUTDOWN: emit serverShutdownEventReceived(event.GetExtension(Event_ServerShutdown::ext)); break;

3
cockatrice/src/arrowitem.cpp
View file

@ -10,7 +10,6 @@
#include <QDebug>
#include "color.h"
// XXX
#include "pb/command_attach_card.pb.h"
#include "pb/command_create_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);
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_zone(startZone->getName().toStdString());
cmd.set_start_card_id(startCard->getId());

31
cockatrice/src/carditem.cpp
View file

@ -14,6 +14,7 @@
#include "main.h"
#include "settingscache.h"
#include "tab_game.h"
#include "pb/serverinfo_card.pb.h"
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)
@ -373,23 +374,25 @@ void CardItem::resetState()
update();
}
void CardItem::processCardInfo(ServerInfo_Card *info)
void CardItem::processCardInfo(const ServerInfo_Card &info)
{
counters.clear();
const QList<ServerInfo_CardCounter *> &_counterList = info->getCounters();
for (int i = 0; i < _counterList.size(); ++i)
counters.insert(_counterList[i]->getId(), _counterList[i]->getValue());
const int counterListSize = info.counter_list_size();
for (int i = 0; i < counterListSize; ++i) {
const ServerInfo_CardCounter &counterInfo = info.counter_list(i);
counters.insert(counterInfo.id(), counterInfo.value());
}
setId(info->getId());
setName(info->getName());
setAttacking(info->getAttacking());
setFaceDown(info->getFaceDown());
setPT(info->getPT());
setAnnotation(info->getAnnotation());
setColor(info->getColor());
setTapped(info->getTapped());
setDestroyOnZoneChange(info->getDestroyOnZoneChange());
setDoesntUntap(info->getDoesntUntap());
setId(info.id());
setName(QString::fromStdString(info.name()));
setAttacking(info.attacking());
setFaceDown(info.face_down());
setPT(QString::fromStdString(info.pt()));
setAnnotation(QString::fromStdString(info.annotation()));
setColor(QString::fromStdString(info.color()));
setTapped(info.tapped());
setDestroyOnZoneChange(info.destroy_on_zone_change());
setDoesntUntap(info.doesnt_untap());
}
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)); }
const QList<CardItem *> &getAttachedCards() const { return attachedCards; }
void resetState();
void processCardInfo(ServerInfo_Card *info);
void processCardInfo(const ServerInfo_Card &info);
void updateCardMenu();
bool animationEvent();

3
cockatrice/src/gamescene.cpp
View file

@ -4,6 +4,7 @@
#include "zoneviewzone.h"
#include "phasestoolbar.h"
#include "settingscache.h"
#include "carditem.h"
#include <math.h>
#include <QAction>
#include <QGraphicsSceneMouseEvent>
@ -127,7 +128,7 @@ void GameScene::toggleZoneView(Player *player, const QString &zoneName, int numb
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);
zoneViews.append(item);

2
cockatrice/src/gamescene.h
View file

@ -45,7 +45,7 @@ public:
void unregisterAnimationItem(AbstractCardItem *card);
public slots:
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 addPlayer(Player *player);
void removePlayer(Player *player);

1
cockatrice/src/handzone.cpp
View file

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

1
cockatrice/src/messagelogwidget.cpp
View file

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

2
cockatrice/src/phasestoolbar.h
View file

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

1
cockatrice/src/pilezone.cpp
View file

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

207
cockatrice/src/player.cpp
View file

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

11
cockatrice/src/player.h
View file

@ -5,8 +5,9 @@
#include <QPoint>
#include <QMap>
#include "abstractgraphicsitem.h"
#include <google/protobuf/message.h>
#include "pb/game_event.pb.h"
namespace google { namespace protobuf { class Message; } }
class CardDatabase;
class QMenu;
class QAction;
@ -197,7 +198,7 @@ private:
void eventDelCounter(const Event_DelCounter &event);
void eventDumpZone(const Event_DumpZone &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 eventDestroyCard(const Event_DestroyCard &event);
void eventAttachCard(const Event_AttachCard &event);
@ -255,10 +256,10 @@ public:
void setMirrored(bool _mirrored);
void processSceneSizeChange(int newPlayerWidth);
void processPlayerInfo(ServerInfo_Player *info);
void processCardAttachment(ServerInfo_Player *info);
void processPlayerInfo(const 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 QList< const ::google::protobuf::Message * > &cmdList);

13
cockatrice/src/playertarget.cpp
View file

@ -1,7 +1,7 @@
#include "playertarget.h"
#include "player.h"
#include "protocol_datastructures.h"
#include "pixmapgenerator.h"
#include "pb/serverinfo_user.pb.h"
#include <QPainter>
#include <QPixmapCache>
#include <QDebug>
@ -51,7 +51,8 @@ PlayerTarget::PlayerTarget(Player *_owner, QGraphicsItem *parentItem)
{
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();
}
@ -62,7 +63,7 @@ QRectF PlayerTarget::boundingRect() const
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;
@ -70,7 +71,7 @@ void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*o
QRectF translatedRect = painter->combinedTransform().mapRect(avatarBoundingRect);
QSize translatedSize = translatedRect.size().toSize();
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 (!QPixmapCache::find(cacheKey, &cachedPixmap)) {
#else
@ -86,7 +87,7 @@ void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*o
QPixmap tempPixmap;
if (fullPixmap.isNull())
tempPixmap = UserLevelPixmapGenerator::generatePixmap(translatedSize.height(), info->getUserLevel());
tempPixmap = UserLevelPixmapGenerator::generatePixmap(translatedSize.height(), info->user_level());
else
tempPixmap = fullPixmap.scaled(translatedSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
@ -107,7 +108,7 @@ void PlayerTarget::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*o
painter->save();
painter->resetTransform();
QString name = info->getName();
QString name = QString::fromStdString(info->name());
if (name.size() > 13)
name = name.mid(0, 10) + "...";

20
cockatrice/src/remotedecklist_treewidget.cpp
View file

@ -2,11 +2,11 @@
#include <QHeaderView>
#include <QSortFilterProxyModel>
#include "remotedecklist_treewidget.h"
#include "protocol_items.h"
#include "abstractclient.h"
#include "pending_command.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::Node(_name, _parent)
@ -204,19 +204,21 @@ QModelIndex RemoteDeckList_TreeModel::nodeToIndex(Node *node) const
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));
endInsertRows();
*/
}
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)
{
DirectoryNode *newItem = new DirectoryNode(name, parent);
/* DirectoryNode *newItem = new DirectoryNode(name, parent);
beginInsertRows(nodeToIndex(parent), parent->size(), parent->size());
parent->append(newItem);
endInsertRows();
@ -228,6 +230,7 @@ void RemoteDeckList_TreeModel::addFolderToTree(const QString &name, const QList<
else
addFileToTree(dynamic_cast<DeckList_File *>(folderItems[i]), newItem);
}
*/
}
void RemoteDeckList_TreeModel::removeNode(RemoteDeckList_TreeModel::Node *node)
@ -242,22 +245,21 @@ void RemoteDeckList_TreeModel::removeNode(RemoteDeckList_TreeModel::Node *node)
void RemoteDeckList_TreeModel::refreshTree()
{
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);
}
void RemoteDeckList_TreeModel::deckListFinished(ProtocolResponse *r)
void RemoteDeckList_TreeModel::deckListFinished(const Response &r)
{
Response_DeckList *resp = qobject_cast<Response_DeckList *>(r);
if (!resp)
return;
/* const Response_DeckList &resp = r.GetExtension(Response_DeckList::ext);
root->clearTree();
reset();
addFolderToTree(resp->getRoot(), root);
emit treeRefreshed();
*/
}
RemoteDeckList_TreeWidget::RemoteDeckList_TreeWidget(AbstractClient *_client, QWidget *parent)

4
cockatrice/src/remotedecklist_treewidget.h
View file

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

1
cockatrice/src/stackzone.cpp
View file

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

242
cockatrice/src/tab_game.cpp
View file

@ -18,7 +18,6 @@
#include "zoneviewwidget.h"
#include "deckview.h"
#include "decklist.h"
#include "protocol_items.h"
#include "dlg_load_remote_deck.h"
#include "abstractclient.h"
#include "carditem.h"
@ -38,6 +37,22 @@
#include "pb/command_set_active_phase.pb.h"
#include "pb/command_next_turn.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)
: QPushButton(parent), readyStart(false)
@ -125,7 +140,7 @@ void DeckViewContainer::loadLocalDeck()
Command_DeckSelect cmd;
cmd.set_deck(deck->writeToString_Native().toStdString());
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);
}
@ -136,19 +151,17 @@ void DeckViewContainer::loadRemoteDeck()
Command_DeckSelect cmd;
cmd.set_deck_id(dlg.getDeckId());
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);
}
}
void DeckViewContainer::deckSelectFinished(ProtocolResponse *r)
void DeckViewContainer::deckSelectFinished(const Response &r)
{
Response_DeckDownload *resp = qobject_cast<Response_DeckDownload *>(r);
if (!resp)
return;
db->cacheCardPixmaps(resp->getDeck()->getCardList());
deckView->setDeck(new DeckList(resp->getDeck()));
const Response_DeckDownload &resp = r.GetExtension(Response_DeckDownload::ext);
DeckList *newDeck = new DeckList(QString::fromStdString(resp.deck()));
db->cacheCardPixmaps(newDeck->getCardList());
deckView->setDeck(newDeck);
readyStartButton->setEnabled(true);
}
@ -180,8 +193,20 @@ void DeckViewContainer::setDeck(DeckList *deck)
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)
: 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)
TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, const Event_GameJoined &event)
: 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->hide();
@ -198,7 +223,7 @@ TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_client
timeElapsedLabel = new QLabel;
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(showCardInfoPopup(QPoint, QString)), this, SLOT(showCardInfoPopup(QPoint, 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));
Player *newPlayer = new Player(info, playerId, local, this);
@ -438,47 +463,48 @@ Player *TabGame::addPlayer(int playerId, ServerInfo_User *info)
return newPlayer;
}
void TabGame::processGameEventContainer(GameEventContainer *cont, AbstractClient *client)
void TabGame::processGameEventContainer(const GameEventContainer &cont, AbstractClient *client)
{
const QList<GameEvent *> &eventList = cont->getEventList();
GameEventContext *context = cont->getContext();
const GameEventContext &context = cont.context();
messageLog->containerProcessingStarted(context);
for (int i = 0; i < eventList.size(); ++i) {
GameEvent *event = eventList[i];
if (spectators.contains(event->getPlayerId())) {
switch (event->getItemId()) {
case ItemId_Event_Say: eventSpectatorSay(static_cast<Event_Say *>(event), context); break;
case ItemId_Event_Leave: eventSpectatorLeave(static_cast<Event_Leave *>(event), context); break;
const int eventListSize = cont.event_list_size();
for (int i = 0; i < eventListSize; ++i) {
const GameEvent &event = cont.event_list(i);
const int playerId = event.player_id();
const GameEvent::GameEventType eventType = static_cast<GameEvent::GameEventType>(getPbExtension(event));
if (spectators.contains(playerId)) {
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: {
qDebug() << "unhandled spectator game event";
break;
}
}
} else {
if ((clients.size() > 1) && (event->getPlayerId() != -1))
if (clients.at(event->getPlayerId()) != client)
if ((clients.size() > 1) && (playerId != -1))
if (clients.at(playerId) != client)
continue;
switch (event->getItemId()) {
case ItemId_Event_GameStateChanged: eventGameStateChanged(static_cast<Event_GameStateChanged *>(event), context); break;
case ItemId_Event_PlayerPropertiesChanged: eventPlayerPropertiesChanged(static_cast<Event_PlayerPropertiesChanged *>(event), context); break;
case ItemId_Event_Join: eventJoin(static_cast<Event_Join *>(event), context); break;
case ItemId_Event_Leave: eventLeave(static_cast<Event_Leave *>(event), context); break;
case ItemId_Event_Kicked: eventKicked(static_cast<Event_Kicked *>(event), context); break;
case ItemId_Event_GameHostChanged: eventGameHostChanged(static_cast<Event_GameHostChanged *>(event), context); break;
case ItemId_Event_GameClosed: eventGameClosed(static_cast<Event_GameClosed *>(event), context); break;
case ItemId_Event_SetActivePlayer: eventSetActivePlayer(static_cast<Event_SetActivePlayer *>(event), context); break;
case ItemId_Event_SetActivePhase: eventSetActivePhase(static_cast<Event_SetActivePhase *>(event), context); break;
case ItemId_Event_Ping: eventPing(static_cast<Event_Ping *>(event), context); break;
switch (eventType) {
case GameEvent::GAME_STATE_CHANGED: eventGameStateChanged(event.GetExtension(Event_GameStateChanged::ext), playerId, context); break;
case GameEvent::PLAYER_PROPERTIES_CHANGED: eventPlayerPropertiesChanged(event.GetExtension(Event_PlayerPropertiesChanged::ext), playerId, context); break;
case GameEvent::JOIN: eventJoin(event.GetExtension(Event_Join::ext), playerId, context); break;
case GameEvent::LEAVE: eventLeave(event.GetExtension(Event_Leave::ext), playerId, context); break;
case GameEvent::KICKED: eventKicked(event.GetExtension(Event_Kicked::ext), playerId, context); break;
case GameEvent::GAME_HOST_CHANGED: eventGameHostChanged(event.GetExtension(Event_GameHostChanged::ext), playerId, context); break;
case GameEvent::GAME_CLOSED: eventGameClosed(event.GetExtension(Event_GameClosed::ext), playerId, context); break;
case GameEvent::SET_ACTIVE_PLAYER: eventSetActivePlayer(event.GetExtension(Event_SetActivePlayer::ext), playerId, context); break;
case GameEvent::SET_ACTIVE_PHASE: eventSetActivePhase(event.GetExtension(Event_SetActivePhase::ext), playerId, context); break;
case GameEvent::PING: eventPing(event.GetExtension(Event_Ping::ext), playerId, context); break;
default: {
Player *player = players.value(event->getPlayerId(), 0);
Player *player = players.value(playerId, 0);
if (!player) {
qDebug() << "unhandled game event: invalid player id";
break;
}
player->processGameEvent(event, context);
player->processGameEvent(eventType, event, context);
emit userEvent();
}
}
@ -574,62 +600,63 @@ void TabGame::stopGame()
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(playerId));
playerListWidget->removePlayer(playerId);
spectators.remove(playerId);
messageLog->logLeaveSpectator(spectators.value(eventPlayerId));
playerListWidget->removePlayer(eventPlayerId);
spectators.remove(eventPlayerId);
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();
for (int i = 0; i < plList.size(); ++i) {
ServerInfo_Player *pl = plList[i];
ServerInfo_PlayerProperties *prop = pl->getProperties();
if (prop->getSpectator()) {
if (!spectators.contains(prop->getPlayerId())) {
spectators.insert(prop->getPlayerId(), prop->getUserInfo()->getName());
const int playerListSize = event.player_list_size();
for (int i = 0; i < playerListSize; ++i) {
const ServerInfo_Player &playerInfo = event.player_list(i);
const ServerInfo_PlayerProperties &prop = playerInfo.properties();
const int playerId = prop.player_id();
if (prop.spectator()) {
if (!spectators.contains(playerId)) {
spectators.insert(playerId, QString::fromStdString(prop.user_info().name()));
playerListWidget->addPlayer(prop);
}
} else {
Player *player = players.value(prop->getPlayerId(), 0);
Player *player = players.value(playerId, 0);
if (!player) {
player = addPlayer(prop->getPlayerId(), prop->getUserInfo());
player = addPlayer(playerId, prop.user_info());
playerListWidget->addPlayer(prop);
}
player->processPlayerInfo(pl);
if (player->getLocal() && !pl->getDeck()->isEmpty()) {
db->cacheCardPixmaps(pl->getDeck()->getCardList());
deckViewContainers.value(player->getId())->setDeck(new DeckList(pl->getDeck()));
player->processPlayerInfo(playerInfo);
if (player->getLocal() && playerInfo.has_deck_list()) {
DeckList *newDeck = new DeckList(QString::fromStdString(playerInfo.deck_list()));
db->cacheCardPixmaps(newDeck->getCardList());
deckViewContainers.value(playerId)->setDeck(newDeck);
}
}
}
for (int i = 0; i < plList.size(); ++i) {
ServerInfo_Player *pl = plList[i];
ServerInfo_PlayerProperties *prop = pl->getProperties();
if (!prop->getSpectator()) {
Player *player = players.value(prop->getPlayerId(), 0);
for (int i = 0; i < playerListSize; ++i) {
const ServerInfo_Player &playerInfo = event.player_list(i);
const ServerInfo_PlayerProperties &prop = playerInfo.properties();
if (!prop.spectator()) {
Player *player = players.value(prop.player_id(), 0);
if (!player)
continue;
player->processCardAttachment(pl);
player->processCardAttachment(playerInfo);
}
}
if (event->getGameStarted() && !started) {
if (event.game_started() && !started) {
startGame(!gameStateKnown);
if (gameStateKnown)
messageLog->logGameStart();
setActivePlayer(event->getActivePlayer());
setActivePhase(event->getActivePhase());
} else if (!event->getGameStarted() && started) {
setActivePlayer(event.active_player_id());
setActivePhase(event.active_phase());
} else if (!event.game_started() && started) {
stopGame();
scene->clearViews();
}
@ -637,15 +664,17 @@ void TabGame::eventGameStateChanged(Event_GameStateChanged *event, GameEventCont
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)
return;
playerListWidget->updatePlayerProperties(event->getProperties());
if (context) switch (context->getItemId()) {
case ItemId_Context_ReadyStart: {
bool ready = event->getProperties()->getReadyStart();
playerListWidget->updatePlayerProperties(event.player_properties());
const GameEventContext::ContextType contextType = static_cast<const GameEventContext::ContextType>(getPbExtension(context));
switch (contextType) {
case GameEventContext::READY_START: {
bool ready = event.player_properties().ready_start();
if (player->getLocal())
deckViewContainers.value(player->getId())->setReadyStart(ready);
if (ready)
@ -654,7 +683,7 @@ void TabGame::eventPlayerPropertiesChanged(Event_PlayerPropertiesChanged *event,
messageLog->logNotReadyStart(player);
break;
}
case ItemId_Context_Concede: {
case GameEventContext::CONCEDE: {
messageLog->logConcede(player);
player->setConceded(true);
@ -664,39 +693,40 @@ void TabGame::eventPlayerPropertiesChanged(Event_PlayerPropertiesChanged *event,
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: ;
}
}
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();
if (players.contains(playerInfo->getPlayerId()))
const ServerInfo_PlayerProperties &playerInfo = event.player_properties();
const int playerId = playerInfo.player_id();
if (players.contains(playerId))
return;
if (playerInfo->getSpectator()) {
spectators.insert(playerInfo->getPlayerId(), playerInfo->getUserInfo()->getName());
messageLog->logJoinSpectator(playerInfo->getUserInfo()->getName());
playerListWidget->addPlayer(playerInfo);
if (playerInfo.spectator()) {
spectators.insert(playerId, QString::fromStdString(playerInfo.user_info().name()));
messageLog->logJoinSpectator(QString::fromStdString(playerInfo.user_info().name()));
} else {
Player *newPlayer = addPlayer(playerInfo->getPlayerId(), playerInfo->getUserInfo());
Player *newPlayer = addPlayer(playerId, playerInfo.user_info());
messageLog->logJoin(newPlayer);
playerListWidget->addPlayer(playerInfo);
}
playerListWidget->addPlayer(playerInfo);
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(playerId, 0);
Player *player = players.value(eventPlayerId, 0);
if (!player)
return;
messageLog->logLeave(player);
playerListWidget->removePlayer(playerId);
players.remove(playerId);
playerListWidget->removePlayer(eventPlayerId);
players.remove(eventPlayerId);
emit playerRemoved(player);
player->clear();
player->deleteLater();
@ -709,19 +739,19 @@ void TabGame::eventLeave(Event_Leave *event, GameEventContext * /*context*/)
emit userEvent();
}
void TabGame::eventKicked(Event_Kicked * /*event*/, GameEventContext * /*context*/)
void TabGame::eventKicked(const Event_Kicked & /*event*/, int /*eventPlayerId*/, const GameEventContext & /*context*/)
{
emit userEvent();
QMessageBox::critical(this, tr("Kicked"), tr("You have been kicked out of the game."));
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;
messageLog->logGameClosed();
@ -753,9 +783,9 @@ Player *TabGame::setActivePlayer(int id)
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)
return;
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)
messageLog->logSetActivePhase(phase);
setActivePhase(phase);
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();
for (int i = 0; i < pingList.size(); ++i)
playerListWidget->updatePing(pingList[i]->getPlayerId(), pingList[i]->getPingTime());
const int pingListSize = event.ping_list_size();
for (int i = 0; i < pingListSize; ++i)
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;
seconds -= minutes * 60;
int hours = minutes / 60;

41
cockatrice/src/tab_game.h
View file

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

12
cockatrice/src/tab_message.cpp
View file

@ -5,11 +5,11 @@
#include <QAction>
#include "tab_message.h"
#include "abstractclient.h"
#include "protocol_items.h"
#include "chatview.h"
#include "pending_command.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)
: Tab(_tabSupervisor), client(_client), userName(_userName), userOnline(true)
@ -60,15 +60,15 @@ void TabMessage::sendMessage()
cmd.set_message(sayEdit->text().toStdString());
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);
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."));
}
@ -77,9 +77,9 @@ void TabMessage::actLeave()
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();
}

8
cockatrice/src/tab_message.h
View file

@ -6,8 +6,8 @@
class AbstractClient;
class ChatView;
class QLineEdit;
class Event_Message;
class ProtocolResponse;
class Event_UserMessage;
class Response;
class TabMessage : public Tab {
Q_OBJECT
@ -25,7 +25,7 @@ signals:
private slots:
void sendMessage();
void actLeave();
void messageSent(ProtocolResponse *response);
void messageSent(const Response &response);
public:
TabMessage(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &_ownName, const QString &_userName);
~TabMessage();
@ -34,7 +34,7 @@ public:
QString getUserName() const { return 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 processUserJoined();
};

74
cockatrice/src/tab_room.cpp
View file

@ -15,21 +15,25 @@
#include "abstractclient.h"
#include "chatview.h"
#include "gameselector.h"
#include "protocol_items.h"
#include "pending_command.h"
#include <google/protobuf/descriptor.h>
#include "get_pb_extension.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)
: Tab(_tabSupervisor), client(_client), roomId(info->getRoomId()), roomName(info->getName()), ownName(_ownName)
TabRoom::TabRoom(TabSupervisor *_tabSupervisor, AbstractClient *_client, const QString &_ownName, const ServerInfo_Room &info)
: Tab(_tabSupervisor), client(_client), roomId(info.room_id()), roomName(QString::fromStdString(info.name())), ownName(_ownName)
{
const QList<ServerInfo_GameType *> gameTypeList = info->getGameTypeList();
for (int i = 0; i < gameTypeList.size(); ++i)
gameTypes.insert(gameTypeList[i]->getGameTypeId(), gameTypeList[i]->getDescription());
const int gameTypeListSize = info.gametype_list_size();
for (int i = 0; i < gameTypeListSize; ++i)
gameTypes.insert(info.gametype_list(i).game_type_id(), QString::fromStdString(info.gametype_list(i).description()));
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);
userList = new UserList(tabSupervisor, client, UserList::RoomList);
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();
setLayout(hbox);
const QList<ServerInfo_User *> users = info->getUserList();
for (int i = 0; i < users.size(); ++i)
userList->processUserInfo(users[i], true);
const int userListSize = info.user_list_size();
for (int i = 0; i < userListSize; ++i)
userList->processUserInfo(info.user_list(i), true);
userList->sortItems();
const QList<ServerInfo_Game *> games = info->getGameList();
for (int i = 0; i < games.size(); ++i)
gameSelector->processGameInfo(games[i]);
const int gameListSize = info.game_list_size();
for (int i = 0; i < gameListSize; ++i)
gameSelector->processGameInfo(info.game_list(i));
}
TabRoom::~TabRoom()
@ -116,14 +120,14 @@ void TabRoom::sendMessage()
cmd.set_message(sayEdit->text().toStdString());
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);
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."));
}
@ -133,39 +137,39 @@ void TabRoom::actLeaveRoom()
deleteLater();
}
void TabRoom::processRoomEvent(RoomEvent *event)
void TabRoom::processRoomEvent(const RoomEvent &event)
{
switch (event->getItemId()) {
case ItemId_Event_ListGames: processListGamesEvent(qobject_cast<Event_ListGames *>(event)); break;
case ItemId_Event_JoinRoom: processJoinRoomEvent(qobject_cast<Event_JoinRoom *>(event)); break;
case ItemId_Event_LeaveRoom: processLeaveRoomEvent(qobject_cast<Event_LeaveRoom *>(event)); break;
case ItemId_Event_RoomSay: processSayEvent(qobject_cast<Event_RoomSay *>(event)); break;
switch (static_cast<RoomEvent::RoomEventType>(getPbExtension(event))) {
case RoomEvent::LIST_GAMES: processListGamesEvent(event.GetExtension(Event_ListGames::ext)); break;
case RoomEvent::JOIN_ROOM: processJoinRoomEvent(event.GetExtension(Event_JoinRoom::ext)); break;
case RoomEvent::LEAVE_ROOM: processLeaveRoomEvent(event.GetExtension(Event_LeaveRoom::ext)); break;
case RoomEvent::ROOM_SAY: processRoomSayEvent(event.GetExtension(Event_RoomSay::ext)); break;
default: ;
}
}
void TabRoom::processListGamesEvent(Event_ListGames *event)
void TabRoom::processListGamesEvent(const Event_ListGames &event)
{
const QList<ServerInfo_Game *> &gameList = event->getGameList();
for (int i = 0; i < gameList.size(); ++i)
gameSelector->processGameInfo(gameList[i]);
const int gameListSize = event.game_list_size();
for (int i = 0; i < gameListSize; ++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();
}
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()))
chatView->appendMessage(event->getPlayerName(), event->getMessage());
if (!tabSupervisor->getUserListsTab()->getIgnoreList()->userInList(QString::fromStdString(event.name())))
chatView->appendMessage(QString::fromStdString(event.name()), QString::fromStdString(event.message()));
emit userEvent(false);
}

18
cockatrice/src/tab_room.h
View file

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

58
cockatrice/src/tab_server.cpp
View file

@ -12,13 +12,15 @@
#include "tab_server.h"
#include "abstractclient.h"
#include "protocol.h"
#include "protocol_items.h"
#include "userlist.h"
#include "userinfobox.h"
#include <QDebug>
#include "pending_command.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)
: QGroupBox(parent), client(_client)
@ -44,7 +46,7 @@ RoomSelector::RoomSelector(AbstractClient *_client, QWidget *parent)
retranslateUi();
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()));
}
@ -62,33 +64,33 @@ void RoomSelector::retranslateUi()
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();
for (int i = 0; i < roomsToUpdate.size(); ++i) {
ServerInfo_Room *room = roomsToUpdate[i];
const int roomListSize = event.room_list_size();
for (int i = 0; i < roomListSize; ++i) {
const ServerInfo_Room &room = event.room_list(i);
for (int j = 0; j < roomList->topLevelItemCount(); ++j) {
QTreeWidgetItem *twi = roomList->topLevelItem(j);
if (twi->data(0, Qt::UserRole).toInt() == room->getRoomId()) {
twi->setData(0, Qt::DisplayRole, room->getName());
twi->setData(1, Qt::DisplayRole, room->getDescription());
twi->setData(2, Qt::DisplayRole, room->getPlayerCount());
twi->setData(3, Qt::DisplayRole, room->getGameCount());
if (twi->data(0, Qt::UserRole).toInt() == room.room_id()) {
twi->setData(0, Qt::DisplayRole, QString::fromStdString(room.name()));
twi->setData(1, Qt::DisplayRole, QString::fromStdString(room.description()));
twi->setData(2, Qt::DisplayRole, room.player_count());
twi->setData(3, Qt::DisplayRole, room.game_count());
return;
}
}
QTreeWidgetItem *twi = new QTreeWidgetItem;
twi->setData(0, Qt::UserRole, room->getRoomId());
twi->setData(0, Qt::DisplayRole, room->getName());
twi->setData(1, Qt::DisplayRole, room->getDescription());
twi->setData(2, Qt::DisplayRole, room->getPlayerCount());
twi->setData(3, Qt::DisplayRole, room->getGameCount());
twi->setData(0, Qt::UserRole, room.room_id());
twi->setData(0, Qt::DisplayRole, QString::fromStdString(room.name()));
twi->setData(1, Qt::DisplayRole, QString::fromStdString(room.description()));
twi->setData(2, Qt::DisplayRole, room.player_count());
twi->setData(3, Qt::DisplayRole, room.game_count());
twi->setTextAlignment(2, Qt::AlignRight);
twi->setTextAlignment(3, Qt::AlignRight);
roomList->addTopLevelItem(twi);
if (room->getAutoJoin())
joinRoom(room->getRoomId(), false);
if (room.auto_join())
joinRoom(room.room_id(), false);
}
}
@ -99,7 +101,7 @@ void RoomSelector::joinRoom(int id, bool setCurrent)
PendingCommand *pend = client->prepareSessionCommand(cmd);
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);
}
@ -113,15 +115,13 @@ void RoomSelector::joinClicked()
joinRoom(twi->data(0, Qt::UserRole).toInt(), true);
}
void RoomSelector::joinFinished(ProtocolResponse *r)
void RoomSelector::joinFinished(const Response &r)
{
if (r->getResponseCode() != RespOk)
return;
Response_JoinRoom *resp = qobject_cast<Response_JoinRoom *>(r);
if (!resp)
if (r.response_code() != Response::RespOk)
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)
@ -131,9 +131,9 @@ TabServer::TabServer(TabSupervisor *_tabSupervisor, AbstractClient *_client, QWi
serverInfoBox = new QTextBrowser;
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;
vbox->addWidget(roomSelector);
@ -147,8 +147,8 @@ void TabServer::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();
}

12
cockatrice/src/tab_server.h
View file

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

77
cockatrice/src/tab_supervisor.cpp
View file

@ -8,12 +8,17 @@
#include "tab_admin.h"
#include "tab_message.h"
#include "tab_userlists.h"
#include "protocol_items.h"
#include "pixmapgenerator.h"
#include <QDebug>
#include <QPainter>
#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)
: QAbstractButton(parent)
@ -107,22 +112,22 @@ int TabSupervisor::myAddTab(Tab *tab)
return addTab(tab, tab->getTabText());
}
void TabSupervisor::start(AbstractClient *_client, ServerInfo_User *_userInfo)
void TabSupervisor::start(AbstractClient *_client, const ServerInfo_User &_userInfo)
{
client = _client;
userInfo = new ServerInfo_User(_userInfo);
connect(client, SIGNAL(roomEventReceived(RoomEvent *)), this, SLOT(processRoomEvent(RoomEvent *)));
connect(client, SIGNAL(gameEventContainerReceived(GameEventContainer *)), this, SLOT(processGameEventContainer(GameEventContainer *)));
connect(client, SIGNAL(gameJoinedEventReceived(Event_GameJoined *)), this, SLOT(gameJoined(Event_GameJoined *)));
connect(client, SIGNAL(messageEventReceived(Event_Message *)), this, SLOT(processMessageEvent(Event_Message *)));
connect(client, SIGNAL(roomEventReceived(const RoomEvent &)), this, SLOT(processRoomEvent(const RoomEvent &)));
connect(client, SIGNAL(gameEventContainerReceived(const GameEventContainer &)), this, SLOT(processGameEventContainer(const GameEventContainer &)));
connect(client, SIGNAL(gameJoinedEventReceived(const Event_GameJoined &)), this, SLOT(gameJoined(const Event_GameJoined &)));
connect(client, SIGNAL(userMessageEventReceived(const Event_UserMessage &)), this, SLOT(processUserMessageEvent(const Event_UserMessage &)));
connect(client, SIGNAL(maxPingTime(int, int)), this, SLOT(updatePingTime(int, int)));
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);
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(userJoined(const QString &)), this, SLOT(processUserJoined(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);
if (userInfo->getUserLevel() & ServerInfo_User::IsRegistered) {
if (userInfo->user_level() & ServerInfo_User::IsRegistered) {
tabDeckStorage = new TabDeckStorage(this, client);
myAddTab(tabDeckStorage);
} else
tabDeckStorage = 0;
if (userInfo->getUserLevel() & ServerInfo_User::IsModerator) {
tabAdmin = new TabAdmin(this, client, (userInfo->getUserLevel() & ServerInfo_User::IsAdmin));
if (userInfo->user_level() & ServerInfo_User::IsModerator) {
tabAdmin = new TabAdmin(this, client, (userInfo->user_level() & ServerInfo_User::IsAdmin));
connect(tabAdmin, SIGNAL(adminLockChanged(bool)), this, SIGNAL(adminLockChanged(bool)));
myAddTab(tabAdmin);
} else
@ -154,8 +159,8 @@ void TabSupervisor::startLocal(const QList<AbstractClient *> &_clients)
userInfo = new ServerInfo_User;
localClients = _clients;
for (int i = 0; i < localClients.size(); ++i)
connect(localClients[i], SIGNAL(gameEventContainerReceived(GameEventContainer *)), this, SLOT(processGameEventContainer(GameEventContainer *)));
connect(localClients.first(), SIGNAL(gameJoinedEventReceived(Event_GameJoined *)), this, SLOT(localGameJoined(Event_GameJoined *)));
connect(localClients[i], SIGNAL(gameEventContainerReceived(const GameEventContainer &)), this, SLOT(processGameEventContainer(const GameEventContainer &)));
connect(localClients.first(), SIGNAL(gameJoinedEventReceived(const Event_GameJoined &)), this, SLOT(localGameJoined(const Event_GameJoined &)));
}
void TabSupervisor::stop()
@ -228,29 +233,29 @@ void TabSupervisor::addCloseButtonToTab(Tab *tab, int tabIndex)
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(openMessageDialog(const QString &, bool)), this, SLOT(addMessageTab(const QString &, bool)));
int tabIndex = myAddTab(tab);
addCloseButtonToTab(tab, tabIndex);
gameTabs.insert(event->getGameId(), tab);
gameTabs.insert(event.game_id(), 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 *)));
int tabIndex = myAddTab(tab);
addCloseButtonToTab(tab, tabIndex);
gameTabs.insert(event->getGameId(), tab);
gameTabs.insert(event.game_id(), tab);
setCurrentWidget(tab);
for (int i = 1; i < localClients.size(); ++i) {
Command_JoinGame cmd;
cmd.set_game_id(event->getGameId());
cmd.set_game_id(event.game_id());
localClients[i]->sendCommand(localClients[i]->prepareRoomCommand(cmd, 0));
}
}
@ -266,14 +271,14 @@ void TabSupervisor::gameLeft(TabGame *tab)
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(openMessageDialog(const QString &, bool)), this, SLOT(addMessageTab(const QString &, bool)));
int tabIndex = myAddTab(tab);
addCloseButtonToTab(tab, tabIndex);
roomTabs.insert(info->getRoomId(), tab);
roomTabs.insert(info.room_id(), tab);
if (setCurrent)
setCurrentWidget(tab);
}
@ -288,10 +293,10 @@ void TabSupervisor::roomLeft(TabRoom *tab)
TabMessage *TabSupervisor::addMessageTab(const QString &receiverName, bool focus)
{
if (receiverName == userInfo->getName())
if (receiverName == QString::fromStdString(userInfo->name()))
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 *)));
int tabIndex = myAddTab(tab);
addCloseButtonToTab(tab, tabIndex);
@ -320,33 +325,33 @@ void TabSupervisor::tabUserEvent(bool globalEvent)
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)
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) {
qDebug() << "gameEvent gameId =" << cont->getGameId();
qDebug() << "gameEvent gameId =" << cont.game_id();
tab->processGameEventContainer(cont, qobject_cast<AbstractClient *>(sender()));
} else
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)
tab = messageTabs.value(event->getReceiverName());
tab = messageTabs.value(QString::fromStdString(event.receiver_name()));
if (!tab)
tab = addMessageTab(event->getSenderName(), false);
tab = addMessageTab(QString::fromStdString(event.sender_name()), false);
if (!tab)
return;
tab->processMessageEvent(event);
tab->processUserMessageEvent(event);
}
void TabSupervisor::processUserLeft(const QString &userName)
@ -385,5 +390,5 @@ bool TabSupervisor::getAdminLocked() 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 GameEventContainer;
class Event_GameJoined;
class Event_Message;
class Event_UserMessage;
class ServerInfo_Room;
class ServerInfo_User;
@ -54,7 +54,7 @@ public:
TabSupervisor(QWidget *parent = 0);
~TabSupervisor();
void retranslateUi();
void start(AbstractClient *_client, ServerInfo_User *userInfo);
void start(AbstractClient *_client, const ServerInfo_User &userInfo);
void startLocal(const QList<AbstractClient *> &_clients);
void stop();
int getGameCount() const { return gameTabs.size(); }
@ -71,19 +71,19 @@ private slots:
void closeButtonPressed();
void updateCurrent(int index);
void updatePingTime(int value, int max);
void gameJoined(Event_GameJoined *event);
void localGameJoined(Event_GameJoined *event);
void gameJoined(const Event_GameJoined &event);
void localGameJoined(const Event_GameJoined &event);
void gameLeft(TabGame *tab);
void addRoomTab(ServerInfo_Room *info, bool setCurrent);
void addRoomTab(const ServerInfo_Room &info, bool setCurrent);
void roomLeft(TabRoom *tab);
TabMessage *addMessageTab(const QString &userName, bool focus);
void processUserLeft(const QString &userName);
void processUserJoined(const QString &userName);
void talkLeft(TabMessage *tab);
void tabUserEvent(bool globalEvent);
void processRoomEvent(RoomEvent *event);
void processGameEventContainer(GameEventContainer *cont);
void processMessageEvent(Event_Message *event);
void processRoomEvent(const RoomEvent &event);
void processGameEventContainer(const GameEventContainer &cont);
void processUserMessageEvent(const Event_UserMessage &event);
};
#endif

74
cockatrice/src/tab_userlists.cpp
View file

@ -5,12 +5,16 @@
#include <QDebug>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include "protocol_items.h"
#include "pending_command.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)
{
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(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(userLeftEventReceived(Event_UserLeft *)), this, SLOT(processUserLeftEvent(Event_UserLeft *)));
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(addToListEventReceived(Event_AddToList *)), this, SLOT(processAddToListEvent(Event_AddToList *)));
connect(client, SIGNAL(removeFromListEventReceived(Event_RemoveFromList *)), this, SLOT(processRemoveFromListEvent(Event_RemoveFromList *)));
connect(client, SIGNAL(userJoinedEventReceived(const Event_UserJoined &)), this, SLOT(processUserJoinedEvent(const Event_UserJoined &)));
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(ignoreListReceived(const QList<ServerInfo_User> &)), this, SLOT(ignoreListReceived(const QList<ServerInfo_User> &)));
connect(client, SIGNAL(addToListEventReceived(const Event_AddToList *)), this, SLOT(processAddToListEvent(const Event_AddToList &)));
connect(client, SIGNAL(removeFromListEventReceived(const Event_RemoveFromList *)), this, SLOT(processRemoveFromListEvent(const Event_RemoveFromList &)));
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);
QVBoxLayout *vbox = new QVBoxLayout;
@ -54,17 +58,17 @@ void TabUserLists::retranslateUi()
userInfoBox->retranslateUi();
}
void TabUserLists::processListUsersResponse(ProtocolResponse *response)
void TabUserLists::processListUsersResponse(const Response &response)
{
Response_ListUsers *resp = qobject_cast<Response_ListUsers *>(response);
if (!resp)
return;
const Response_ListUsers &resp = response.GetExtension(Response_ListUsers::ext);
const QList<ServerInfo_User *> &respList = resp->getUserList();
for (int i = 0; i < respList.size(); ++i) {
allUsersList->processUserInfo(respList[i], true);
ignoreList->setUserOnline(respList[i]->getName(), true);
buddyList->setUserOnline(respList[i]->getName(), true);
const int userListSize = resp.user_list_size();
for (int i = 0; i < userListSize; ++i) {
const ServerInfo_User &info = resp.user_list(i);
const QString userName = QString::fromStdString(info.name());
allUsersList->processUserInfo(info, true);
ignoreList->setUserOnline(userName, true);
buddyList->setUserOnline(userName, true);
}
allUsersList->sortItems();
@ -72,23 +76,25 @@ void TabUserLists::processListUsersResponse(ProtocolResponse *response)
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);
ignoreList->setUserOnline(info->getName(), true);
buddyList->setUserOnline(info->getName(), true);
ignoreList->setUserOnline(userName, true);
buddyList->setUserOnline(userName, true);
allUsersList->sortItems();
ignoreList->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)) {
ignoreList->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)
buddyList->processUserInfo(_buddyList[i], false);
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)
ignoreList->processUserInfo(_ignoreList[i], false);
ignoreList->sortItems();
}
void TabUserLists::processAddToListEvent(Event_AddToList *event)
void TabUserLists::processAddToListEvent(const Event_AddToList &event)
{
ServerInfo_User *info = event->getUserInfo();
bool online = allUsersList->userInList(info->getName());
QString list = event->getList();
const ServerInfo_User &info = event.user_info();
bool online = allUsersList->userInList(QString::fromStdString(info.name()));
QString list = QString::fromStdString(event.list_name());
UserList *userList = 0;
if (list == "buddy")
userList = buddyList;
@ -130,10 +136,10 @@ void TabUserLists::processAddToListEvent(Event_AddToList *event)
userList->sortItems();
}
void TabUserLists::processRemoveFromListEvent(Event_RemoveFromList *event)
void TabUserLists::processRemoveFromListEvent(const Event_RemoveFromList &event)
{
QString list = event->getList();
QString user = event->getUserName();
QString list = QString::fromStdString(event.list_name());
QString user = QString::fromStdString(event.user_name());
UserList *userList = 0;
if (list == "buddy")
userList = buddyList;

19
cockatrice/src/tab_userlists.h
View file

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

1
cockatrice/src/tablezone.cpp
View file

@ -8,6 +8,7 @@
#include "arrowitem.h"
#include "carddragitem.h"
#include "carddatabase.h"
#include "carditem.h"
#include "pb/command_move_card.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 "protocol_datastructures.h"
#include "pixmapgenerator.h"
#include "protocol_items.h"
#include "abstractclient.h"
#include <QLabel>
#include <QGridLayout>
#include "pending_command.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)
: QWidget(parent, flags), client(_client), fullInfo(_fullInfo)
@ -55,19 +54,20 @@ void UserInfoBox::retranslateUi()
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;
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);
avatarLabel->setPixmap(avatarPixmap);
nameLabel->setText(user->getName());
realNameLabel2->setText(user->getRealName());
genderLabel2->setPixmap(GenderPixmapGenerator::generatePixmap(15, user->getGender()));
countryLabel2->setPixmap(CountryPixmapGenerator::generatePixmap(15, user->getCountry()));
nameLabel->setText(QString::fromStdString(user.name()));
realNameLabel2->setText(QString::fromStdString(user.real_name()));
genderLabel2->setPixmap(GenderPixmapGenerator::generatePixmap(15, user.gender()));
countryLabel2->setPixmap(CountryPixmapGenerator::generatePixmap(15, QString::fromStdString(user.country())));
userLevelLabel2->setPixmap(UserLevelPixmapGenerator::generatePixmap(15, userLevel));
QString userLevelText;
if (userLevel & ServerInfo_User::IsAdmin)
@ -87,18 +87,15 @@ void UserInfoBox::updateInfo(const QString &userName)
cmd.set_user_name(userName.toStdString());
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);
}
void UserInfoBox::processResponse(ProtocolResponse *r)
void UserInfoBox::processResponse(const Response &r)
{
Response_GetUserInfo *response = qobject_cast<Response_GetUserInfo *>(r);
if (!response)
return;
updateInfo(response->getUserInfo());
const Response_GetUserInfo &response = r.GetExtension(Response_GetUserInfo::ext);
updateInfo(response.user_info());
setFixedSize(sizeHint());
show();
}

6
cockatrice/src/userinfobox.h
View file

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

62
cockatrice/src/userlist.cpp
View file

@ -4,7 +4,6 @@
#include "abstractclient.h"
#include "pixmapgenerator.h"
#include "userinfobox.h"
#include "protocol_items.h"
#include "gameselector.h"
#include <QHeaderView>
#include <QVBoxLayout>
@ -23,18 +22,20 @@
#include "pending_command.h"
#include "pb/session_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)
{
setAttribute(Qt::WA_DeleteOnClose);
nameBanCheckBox = new QCheckBox(tr("ban &user name"));
nameBanCheckBox->setChecked(true);
nameBanEdit = new QLineEdit(info->getName());
nameBanEdit = new QLineEdit(QString::fromStdString(info.name()));
ipBanCheckBox = new QCheckBox(tr("ban &IP address"));
ipBanCheckBox->setChecked(true);
ipBanEdit = new QLineEdit(info->getAddress());
ipBanEdit = new QLineEdit(QString::fromStdString(info.address()));
QGridLayout *banTypeGrid = new QGridLayout;
banTypeGrid->addWidget(nameBanCheckBox, 0, 0);
banTypeGrid->addWidget(nameBanEdit, 0, 1);
@ -211,12 +212,12 @@ void UserList::retranslateUi()
updateCount();
}
void UserList::processUserInfo(ServerInfo_User *user, bool online)
void UserList::processUserInfo(const ServerInfo_User &user, bool online)
{
QTreeWidgetItem *item = 0;
for (int i = 0; i < userTree->topLevelItemCount(); ++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;
break;
}
@ -228,11 +229,11 @@ void UserList::processUserInfo(ServerInfo_User *user, bool online)
++onlineCount;
updateCount();
}
item->setData(0, Qt::UserRole, user->getUserLevel());
item->setIcon(0, QIcon(UserLevelPixmapGenerator::generatePixmap(12, user->getUserLevel())));
item->setIcon(1, QIcon(CountryPixmapGenerator::generatePixmap(12, user->getCountry())));
item->setData(2, Qt::UserRole, user->getName());
item->setData(2, Qt::DisplayRole, user->getName());
item->setData(0, Qt::UserRole, user.user_level());
item->setIcon(0, QIcon(UserLevelPixmapGenerator::generatePixmap(12, user.user_level())));
item->setIcon(1, QIcon(CountryPixmapGenerator::generatePixmap(12, QString::fromStdString(user.country()))));
item->setData(2, Qt::UserRole, QString::fromStdString(user.name()));
item->setData(2, Qt::DisplayRole, QString::fromStdString(user.name()));
item->setData(0, Qt::UserRole + 1, online);
if (online)
@ -294,43 +295,42 @@ void UserList::userClicked(QTreeWidgetItem *item, int /*column*/)
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);
if (!response)
return;
const Response_GetGamesOfUser &response = resp.GetExtension(Response_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, QString> roomMap;
const QList<ServerInfo_Room *> roomList = response->getRoomList();
for (int i = 0; i < roomList.size(); ++i) {
roomMap.insert(roomList[i]->getRoomId(), roomList[i]->getName());
const QList<ServerInfo_GameType *> gameTypeList = roomList[i]->getGameTypeList();
const int roomListSize = response.room_list_size();
for (int i = 0; i < roomListSize; ++i) {
const ServerInfo_Room &roomInfo = response.room_list(i);
roomMap.insert(roomInfo.room_id(), QString::fromStdString(roomInfo.name()));
GameTypeMap tempMap;
for (int j = 0; j < gameTypeList.size(); ++j)
tempMap.insert(gameTypeList[j]->getGameTypeId(), gameTypeList[j]->getDescription());
gameTypeMap.insert(roomList[i]->getRoomId(), tempMap);
const int gameTypeListSize = roomInfo.gametype_list_size();
for (int j = 0; j < gameTypeListSize; ++j) {
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);
const QList<ServerInfo_Game *> gameList = response->getGameList();
for (int i = 0; i < gameList.size(); ++i)
selector->processGameInfo(gameList[i]);
const int gameListSize = response.game_list_size();
for (int i = 0; i < gameListSize; ++i)
selector->processGameInfo(response.game_list(i));
selector->setWindowTitle(tr("%1's games").arg(QString::fromStdString(cmd.user_name())));
selector->setAttribute(Qt::WA_DeleteOnClose);
selector->show();
}
void UserList::banUser_processUserInfoResponse(ProtocolResponse *r)
void UserList::banUser_processUserInfoResponse(const Response &r)
{
Response_GetUserInfo *response = qobject_cast<Response_GetUserInfo *>(r);
if (!response)
return;
const Response_GetUserInfo &response = r.GetExtension(Response_GetUserInfo::ext);
// 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()));
dlg->show();
}
@ -385,7 +385,7 @@ void UserList::showContextMenu(const QPoint &pos, const QModelIndex &index)
menu->addSeparator();
menu->addAction(aBan);
}
if (userName == tabSupervisor->getUserInfo()->getName()) {
if (userName == QString::fromStdString(tabSupervisor->getUserInfo()->name())) {
aChat->setEnabled(false);
aAddToBuddyList->setEnabled(false);
aRemoveFromBuddyList->setEnabled(false);

10
cockatrice/src/userlist.h
View file

@ -15,7 +15,7 @@ class QCheckBox;
class QSpinBox;
class QRadioButton;
class QPlainTextEdit;
class ProtocolResponse;
class Response;
class BanDialog : public QDialog {
Q_OBJECT
@ -30,7 +30,7 @@ private slots:
void okClicked();
void enableTemporaryEdits(bool enabled);
public:
BanDialog(ServerInfo_User *info, QWidget *parent = 0);
BanDialog(const ServerInfo_User &info, QWidget *parent = 0);
QString getBanName() const;
QString getBanIP() const;
int getMinutes() const;
@ -65,9 +65,9 @@ private:
void setUserOnline(QTreeWidgetItem *user, bool online);
private slots:
void userClicked(QTreeWidgetItem *item, int column);
void banUser_processUserInfoResponse(ProtocolResponse *resp);
void banUser_processUserInfoResponse(const Response &resp);
void banUser_dialogFinished();
void gamesOfUserReceived(ProtocolResponse *resp);
void gamesOfUserReceived(const Response &resp);
signals:
void openMessageDialog(const QString &userName, bool focus);
void addBuddy(const QString &userName);
@ -77,7 +77,7 @@ signals:
public:
UserList(TabSupervisor *_tabSupervisor, AbstractClient *_client, UserListType _type, QWidget *parent = 0);
void retranslateUi();
void processUserInfo(ServerInfo_User *user, bool online);
void processUserInfo(const ServerInfo_User &user, bool online);
bool deleteUser(const QString &userName);
void setUserOnline(const QString &userName, bool online);
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);
}
@ -302,14 +302,14 @@ MainWindow::MainWindow(QWidget *parent)
QPixmapCache::setCacheLimit(200000);
client = new RemoteClient(this);
connect(client, SIGNAL(connectionClosedEventReceived(Event_ConnectionClosed *)), this, SLOT(processConnectionClosedEvent(Event_ConnectionClosed *)));
connect(client, SIGNAL(serverShutdownEventReceived(Event_ServerShutdown *)), this, SLOT(processServerShutdownEvent(Event_ServerShutdown *)));
connect(client, SIGNAL(connectionClosedEventReceived(const Event_ConnectionClosed &)), this, SLOT(processConnectionClosedEvent(const Event_ConnectionClosed &)));
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(socketError(const QString &)), this, SLOT(socketError(const QString &)));
connect(client, SIGNAL(serverTimeout()), this, SLOT(serverTimeout()));
connect(client, SIGNAL(statusChanged(ClientStatus)), this, SLOT(statusChanged(ClientStatus)));
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;
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 socketError(const QString &errorStr);
void protocolVersionMismatch(int localVersion, int remoteVersion);
void userInfoReceived(ServerInfo_User *userInfo);
void userInfoReceived(const ServerInfo_User &userInfo);
void localGameEnded();
void actConnect();

3
cockatrice/src/zoneviewwidget.cpp
View file

@ -11,7 +11,6 @@
#include "zoneviewzone.h"
#include "player.h"
#include "gamescene.h"
#include "protocol_items.h"
#include "settingscache.h"
#include "gamescene.h"
@ -56,7 +55,7 @@ void TitleLabel::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
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)
{
setAcceptHoverEvents(true);

2
cockatrice/src/zoneviewwidget.h
View file

@ -51,7 +51,7 @@ private slots:
void zoneDeleted();
void moveWidget(QPointF scenePos);
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; }
void retranslateUi();
protected:

26
cockatrice/src/zoneviewzone.cpp
View file

@ -3,11 +3,11 @@
#include "zoneviewzone.h"
#include "player.h"
#include "carddragitem.h"
#include "protocol_items.h"
#include "protocol_datastructures.h"
#include "carditem.h"
#include "pb/command_dump_zone.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"
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()) {
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();
} else if (!origZone->contentsKnown()) {
Command_DumpZone cmd;
@ -47,7 +47,7 @@ void ZoneViewZone::initializeCards(const QList<ServerInfo_Card *> &cardList)
cmd.set_number_cards(numberCards);
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);
} else {
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);
if (!resp)
return;
const QList<ServerInfo_Card *> &respCardList = resp->getZone()->getCardList();
for (int i = 0; i < respCardList.size(); i++) {
CardItem *card = new CardItem(player, respCardList[i]->getName(), respCardList[i]->getId(), revealZone, this);
const Response_DumpZone &resp = r.GetExtension(Response_DumpZone::ext);
const int respCardListSize = resp.zone_info().card_list_size();
for (int i = 0; i < respCardListSize; ++i) {
const ServerInfo_Card &cardInfo = resp.zone_info().card_list(i);
CardItem *card = new CardItem(player, QString::fromStdString(cardInfo.name()), cardInfo.id(), revealZone, this);
addCard(card, false, i);
}

6
cockatrice/src/zoneviewzone.h
View file

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

7
common/.directory
View file

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

47
common/color.h
View file

@ -7,32 +7,29 @@
#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
Color(const QColor &_color)
{
value = _color.red() * 65536 + _color.green() * 256 + _color.blue();
}
QColor getQColor() const
{
return QColor(value / 65536, (value % 65536) / 256, value % 256);
}
inline QColor convertColorToQColor(const color &c)
{
return QColor(c.r(), c.g(), c.b());
}
inline color convertQColorToColor(const QColor &c)
{
color result;
result.set_r(c.red());
result.set_g(c.green());
result.set_b(c.blue());
return result;
}
#endif
color get_color() const // HACK
{
color c;
c.set_r(value / 65536);
c.set_g((value % 65536) / 256);
c.set_b(value % 256);
return c;
}
};
inline color makeColor(int r, int g, int b)
{
color result;
result.set_r(r);
result.set_g(g);
result.set_b(b);
return result;
}
#endif

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

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

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

@ -31,6 +31,6 @@ message GameEvent {
DUMP_ZONE = 2018;
STOP_DUMP_ZONE = 2019;
}
optional sint32 player_id = 1;
optional sint32 player_id = 1 [default = -1];
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");
}
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)
{
if (xml->isCharacters() && !xml->isWhitespace()) {

14
common/serializable_item.h
View file

@ -122,20 +122,6 @@ public:
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 {
private:
QDateTime data;

10
common/server_arrow.h
View file

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

8
common/server_counter.h
View file

@ -21,21 +21,21 @@
#define SERVER_COUNTER_H
#include <QString>
#include "color.h"
#include "pb/color.pb.h"
class Server_Counter {
protected:
int id;
QString name;
Color color;
color counterColor;
int radius;
int count;
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() { }
int getId() const { return id; }
QString getName() const { return name; }
Color getColor() const { return color; }
const color &getColor() const { return counterColor; }
int getRadius() const { return radius; }
int getCount() const { return 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;
playerInfo.mutable_properties()->CopyFrom(player->getProperties());
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;
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_zone(arrow->getStartCard()->getZone()->getName().toStdString());
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) {
arrowInfo->set_target_player_id(targetCard->getZone()->getPlayer()->getPlayerId());
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();
counterInfo->set_id(counter->getId());
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_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, "rfg", false, ServerInfo_Zone::PublicZone));
addCounter(new Server_Counter(0, "life", Color(255, 255, 255), 25, 20));
addCounter(new Server_Counter(1, "w", Color(255, 255, 150), 20, 0));
addCounter(new Server_Counter(2, "u", Color(150, 150, 255), 20, 0));
addCounter(new Server_Counter(3, "b", Color(150, 150, 150), 20, 0));
addCounter(new Server_Counter(4, "r", Color(250, 150, 150), 20, 0));
addCounter(new Server_Counter(5, "g", Color(150, 255, 150), 20, 0));
addCounter(new Server_Counter(6, "x", Color(255, 255, 255), 20, 0));
addCounter(new Server_Counter(7, "storm", Color(255, 255, 255), 20, 0));
addCounter(new Server_Counter(0, "life", makeColor(255, 255, 255), 25, 20));
addCounter(new Server_Counter(1, "w", makeColor(255, 255, 150), 20, 0));
addCounter(new Server_Counter(2, "u", makeColor(150, 150, 255), 20, 0));
addCounter(new Server_Counter(3, "b", makeColor(150, 150, 150), 20, 0));
addCounter(new Server_Counter(4, "r", makeColor(250, 150, 150), 20, 0));
addCounter(new Server_Counter(5, "g", makeColor(150, 255, 150), 20, 0));
addCounter(new Server_Counter(6, "x", makeColor(255, 255, 255), 20, 0));
addCounter(new Server_Counter(7, "storm", makeColor(255, 255, 255), 20, 0));
initialCards = 7;
@ -467,7 +467,8 @@ Response::ResponseCode Server_Player::moveCard(GameEventStorage &ges, Server_Car
Event_MoveCard eventOthers;
eventOthers.set_start_zone(startzone->getName().toStdString());
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_y(y);
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();
QList<ServerInfo_Game *> gameList;
QMapIterator<int, Server_Room *> roomIterator(server->getRooms());
QMutexLocker gameListLocker(&gameListMutex);
while (roomIterator.hasNext()) {
@ -613,8 +612,6 @@ Response::ResponseCode Server_ProtocolHandler::cmdGetGamesOfUser(const Command_G
return Response::RespNameNotFound;
Response_GetGamesOfUser *re = new Response_GetGamesOfUser;
QList<ServerInfo_Room *> roomList;
QList<ServerInfo_Game *> gameList;
QMapIterator<int, Server_Room *> roomIterator(server->getRooms());
while (roomIterator.hasNext()) {
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_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) {
Server_Card *card = zone->cards[i];
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_doesnt_untap(card->getDoesntUntap());
QList<ServerInfo_CardCounter *> cardCounterList;
QMapIterator<int, int> cardCounterIterator(card->getCounters());
while (cardCounterIterator.hasNext()) {
cardCounterIterator.next();
@ -1692,7 +1687,6 @@ Response::ResponseCode Server_ProtocolHandler::cmdRevealCards(const Command_Reve
Event_RevealCards eventPrivate(eventOthers);
QList<ServerInfo_Card *> respCardListPrivate, respCardListOmniscient;
for (int i = 0; i < cardsToReveal.size(); ++i) {
Server_Card *card = cardsToReveal[i];
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_doesnt_untap(card->getDoesntUntap());
QList<ServerInfo_CardCounter *> cardCounterList;
QMapIterator<int, int> cardCounterIterator(card->getCounters());
while (cardCounterIterator.hasNext()) {
cardCounterIterator.next();