jeirmeister/Cockatrice
1
0
Fork 0
mirror of https://github.com/Cockatrice/Cockatrice.git synced 2026-06-12 17:14:52 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

event handling

Browse source
This commit is contained in:
Max-Wilhelm Bruker 2009-11-28 00:02:11 +01:00
parent e796af2b89
commit 77015c9ebf
34 changed files with 891 additions and 855 deletions
Download patch file Download diff file Expand all files Collapse all files

117
common/protocol.cpp
View file

@ -77,6 +77,9 @@ void ProtocolItem::initializeHash()
itemNameHash.insert("generic_eventlist_games", Event_ListGames::newItem);
itemNameHash.insert("generic_eventlist_chat_channels", Event_ListChatChannels::newItem);
itemNameHash.insert("game_eventgame_state_changed", Event_GameStateChanged::newItem);
itemNameHash.insert("game_eventcreate_arrow", Event_CreateArrow::newItem);
itemNameHash.insert("game_eventcreate_counter", Event_CreateCounter::newItem);
itemNameHash.insert("game_eventdraw_cards", Event_DrawCards::newItem);
itemNameHash.insert("chat_eventchat_list_players", Event_ChatListPlayers::newItem);
}
@ -422,7 +425,7 @@ void Event_ListGames::writeElement(QXmlStreamWriter *xml)
}
Event_GameStateChanged::Event_GameStateChanged(int _gameId, const QList<ServerInfo_Player *> &_playerList)
: GameEvent("game_state_changed", _gameId, -1), currentItem(0), readFinished(false), playerList(_playerList)
: GameEvent("game_state_changed", _gameId, -1), currentItem(0), playerList(_playerList)
{
}
@ -456,3 +459,115 @@ void Event_GameStateChanged::writeElement(QXmlStreamWriter *xml)
for (int i = 0; i < playerList.size(); ++i)
playerList[i]->writeElement(xml);
}
Event_CreateArrow::Event_CreateArrow(int _gameId, int _playerId, ServerInfo_Arrow *_arrow)
: GameEvent("create_arrow", _gameId, _playerId), arrow(_arrow), readFinished(false)
{
}
Event_CreateArrow::~Event_CreateArrow()
{
delete arrow;
}
bool Event_CreateArrow::readElement(QXmlStreamReader *xml)
{
if (readFinished)
return false;
if (!arrow) {
if (xml->isStartElement() && (xml->name() == "arrow"))
arrow = new ServerInfo_Arrow;
else
return false;
}
if (arrow->readElement(xml))
readFinished = true;
return true;
}
void Event_CreateArrow::writeElement(QXmlStreamWriter *xml)
{
if (arrow)
arrow->writeElement(xml);
}
Event_CreateCounter::Event_CreateCounter(int _gameId, int _playerId, ServerInfo_Counter *_counter)
: GameEvent("create_counter", _gameId, _playerId), counter(_counter), readFinished(false)
{
}
Event_CreateCounter::~Event_CreateCounter()
{
delete counter;
}
bool Event_CreateCounter::readElement(QXmlStreamReader *xml)
{
if (readFinished)
return false;
if (!counter) {
if (xml->isStartElement() && (xml->name() == "counter"))
counter = new ServerInfo_Counter;
else
return false;
}
if (counter->readElement(xml))
readFinished = true;
return true;
}
void Event_CreateCounter::writeElement(QXmlStreamWriter *xml)
{
if (counter)
counter->writeElement(xml);
}
Event_DrawCards::Event_DrawCards(int _gameId, int _playerId, int _numberCards, const QList<ServerInfo_Card *> &_cardList)
: GameEvent("draw_cards", _gameId, _playerId), currentItem(0), numberCards(_numberCards), cardList(_cardList)
{
setParameter("number_cards", numberCards);
}
Event_DrawCards::~Event_DrawCards()
{
for (int i = 0; i < cardList.size(); ++i)
delete cardList[i];
}
void Event_DrawCards::extractParameters()
{
GameEvent::extractParameters();
bool ok;
numberCards = parameters["number_cards"].toInt(&ok);
if (!ok)
numberCards = -1;
}
bool Event_DrawCards::readElement(QXmlStreamReader *xml)
{
if (currentItem) {
if (currentItem->readElement(xml))
currentItem = 0;
return true;
}
if (xml->isStartElement() && (xml->name() == "card")) {
ServerInfo_Card *card = new ServerInfo_Card;
cardList.append(card);
currentItem = card;
} else
return false;
if (currentItem)
if (currentItem->readElement(xml))
currentItem = 0;
return true;
}
void Event_DrawCards::writeElement(QXmlStreamWriter *xml)
{
for (int i = 0; i < cardList.size(); ++i)
cardList[i]->writeElement(xml);
}

55
common/protocol.h
View file

@ -23,6 +23,9 @@ enum ItemId {
ItemId_Event_ChatListPlayers = ItemId_Other + 201,
ItemId_Event_ListGames = ItemId_Other + 202,
ItemId_Event_GameStateChanged = ItemId_Other + 203,
ItemId_Event_CreateArrow = ItemId_Other + 204,
ItemId_Event_CreateCounter = ItemId_Other + 205,
ItemId_Event_DrawCards = ItemId_Other + 206,
ItemId_Response_DeckList = ItemId_Other + 300,
ItemId_Response_DeckDownload = ItemId_Other + 301,
ItemId_Response_DeckUpload = ItemId_Other + 302
@ -341,7 +344,6 @@ class Event_GameStateChanged : public GameEvent {
Q_OBJECT
private:
SerializableItem *currentItem;
bool readFinished;
QList<ServerInfo_Player *> playerList;
public:
Event_GameStateChanged(int _gameId = -1, const QList<ServerInfo_Player *> &_playerList = QList<ServerInfo_Player *>());
@ -354,4 +356,55 @@ public:
void writeElement(QXmlStreamWriter *xml);
};
class Event_CreateArrow : public GameEvent {
Q_OBJECT
private:
ServerInfo_Arrow *arrow;
bool readFinished;
protected:
bool readElement(QXmlStreamReader *xml);
void writeElement(QXmlStreamWriter *xml);
public:
Event_CreateArrow(int _gameId = -1, int _playerId = -1, ServerInfo_Arrow *_arrow = 0);
~Event_CreateArrow();
int getItemId() const { return ItemId_Event_CreateArrow; }
static ProtocolItem *newItem() { return new Event_CreateArrow; }
ServerInfo_Arrow *getArrow() const { return arrow; }
};
class Event_CreateCounter : public GameEvent {
Q_OBJECT
private:
ServerInfo_Counter *counter;
bool readFinished;
protected:
bool readElement(QXmlStreamReader *xml);
void writeElement(QXmlStreamWriter *xml);
public:
Event_CreateCounter(int _gameId = -1, int _playerId = -1, ServerInfo_Counter *_counter = 0);
~Event_CreateCounter();
int getItemId() const { return ItemId_Event_CreateCounter; }
static ProtocolItem *newItem() { return new Event_CreateCounter; }
ServerInfo_Counter *getCounter() const { return counter; }
};
class Event_DrawCards : public GameEvent {
Q_OBJECT
private:
SerializableItem *currentItem;
int numberCards;
QList<ServerInfo_Card *> cardList;
protected:
void extractParameters();
bool readElement(QXmlStreamReader *xml);
void writeElement(QXmlStreamWriter *xml);
public:
Event_DrawCards(int _gameId = -1, int _playerId = -1, int numberCards = -1, const QList<ServerInfo_Card *> &_cardList = QList<ServerInfo_Card *>());
~Event_DrawCards();
int getItemId() const { return ItemId_Event_DrawCards; }
static ProtocolItem *newItem() { return new Event_DrawCards; }
int getNumberCards() const { return numberCards; }
const QList<ServerInfo_Card *> &getCardList() const { return cardList; }
};
#endif

55
common/protocol_item_ids.h
View file

@ -25,39 +25,36 @@ ItemId_Command_DeleteArrow = 1023,
ItemId_Command_SetCardAttr = 1024,
ItemId_Command_ReadyStart = 1025,
ItemId_Command_IncCounter = 1026,
ItemId_Command_AddCounter = 1027,
ItemId_Command_CreateCounter = 1027,
ItemId_Command_SetCounter = 1028,
ItemId_Command_DelCounter = 1029,
ItemId_Command_NextTurn = 1030,
ItemId_Command_SetActivePhase = 1031,
ItemId_Command_DumpZone = 1032,
ItemId_Command_StopDumpZone = 1033,
ItemId_Command_DumpAll = 1034,
ItemId_Event_Say = 1035,
ItemId_Event_Join = 1036,
ItemId_Event_Leave = 1037,
ItemId_Event_DeckSelect = 1038,
ItemId_Event_GameClosed = 1039,
ItemId_Event_ReadyStart = 1040,
ItemId_Event_GameStart = 1041,
ItemId_Event_Shuffle = 1042,
ItemId_Event_RollDie = 1043,
ItemId_Event_MoveCard = 1044,
ItemId_Event_CreateToken = 1045,
ItemId_Event_CreateArrow = 1046,
ItemId_Event_DeleteArrow = 1047,
ItemId_Event_SetCardAttr = 1048,
ItemId_Event_AddCounter = 1049,
ItemId_Event_SetCounter = 1050,
ItemId_Event_DelCounter = 1051,
ItemId_Event_SetActivePlayer = 1052,
ItemId_Event_SetActivePhase = 1053,
ItemId_Event_DumpZone = 1054,
ItemId_Event_StopDumpZone = 1055,
ItemId_Event_ServerMessage = 1056,
ItemId_Event_GameJoined = 1057,
ItemId_Event_ChatJoinChannel = 1058,
ItemId_Event_ChatLeaveChannel = 1059,
ItemId_Event_ChatSay = 1060,
ItemId_Other = 1061
ItemId_Event_Say = 1034,
ItemId_Event_Join = 1035,
ItemId_Event_Leave = 1036,
ItemId_Event_DeckSelect = 1037,
ItemId_Event_GameClosed = 1038,
ItemId_Event_ReadyStart = 1039,
ItemId_Event_GameStart = 1040,
ItemId_Event_Shuffle = 1041,
ItemId_Event_RollDie = 1042,
ItemId_Event_MoveCard = 1043,
ItemId_Event_CreateToken = 1044,
ItemId_Event_DeleteArrow = 1045,
ItemId_Event_SetCardAttr = 1046,
ItemId_Event_SetCounter = 1047,
ItemId_Event_DelCounter = 1048,
ItemId_Event_SetActivePlayer = 1049,
ItemId_Event_SetActivePhase = 1050,
ItemId_Event_DumpZone = 1051,
ItemId_Event_StopDumpZone = 1052,
ItemId_Event_ServerMessage = 1053,
ItemId_Event_GameJoined = 1054,
ItemId_Event_ChatJoinChannel = 1055,
ItemId_Event_ChatLeaveChannel = 1056,
ItemId_Event_ChatSay = 1057,
ItemId_Other = 1058
};

57
common/protocol_items.cpp
View file

@ -265,15 +265,15 @@ void Command_IncCounter::extractParameters()
counterId = parameters["counter_id"].toInt();
delta = parameters["delta"].toInt();
}
Command_AddCounter::Command_AddCounter(int _gameId, const QString &_counterName, const QColor &_color, int _radius, int _value)
: GameCommand("add_counter", _gameId), counterName(_counterName), color(_color), radius(_radius), value(_value)
Command_CreateCounter::Command_CreateCounter(int _gameId, const QString &_counterName, const QColor &_color, int _radius, int _value)
: GameCommand("create_counter", _gameId), counterName(_counterName), color(_color), radius(_radius), value(_value)
{
setParameter("counter_name", counterName);
setParameter("color", color);
setParameter("radius", radius);
setParameter("value", value);
}
void Command_AddCounter::extractParameters()
void Command_CreateCounter::extractParameters()
{
GameCommand::extractParameters();
counterName = parameters["counter_name"];
@ -343,10 +343,6 @@ void Command_StopDumpZone::extractParameters()
playerId = parameters["player_id"].toInt();
zoneName = parameters["zone_name"];
}
Command_DumpAll::Command_DumpAll(int _gameId)
: GameCommand("dump_all", _gameId)
{
}
Event_Say::Event_Say(int _gameId, int _playerId, const QString &_message)
: GameEvent("say", _gameId, _playerId), message(_message)
{
@ -455,30 +451,6 @@ void Event_CreateToken::extractParameters()
x = parameters["x"].toInt();
y = parameters["y"].toInt();
}
Event_CreateArrow::Event_CreateArrow(int _gameId, int _playerId, int _arrowId, int _startPlayerId, const QString &_startZone, int _startCardId, int _targetPlayerId, const QString &_targetZone, int _targetCardId, const QColor &_color)
: GameEvent("create_arrow", _gameId, _playerId), arrowId(_arrowId), startPlayerId(_startPlayerId), startZone(_startZone), startCardId(_startCardId), targetPlayerId(_targetPlayerId), targetZone(_targetZone), targetCardId(_targetCardId), color(_color)
{
setParameter("arrow_id", arrowId);
setParameter("start_player_id", startPlayerId);
setParameter("start_zone", startZone);
setParameter("start_card_id", startCardId);
setParameter("target_player_id", targetPlayerId);
setParameter("target_zone", targetZone);
setParameter("target_card_id", targetCardId);
setParameter("color", color);
}
void Event_CreateArrow::extractParameters()
{
GameEvent::extractParameters();
arrowId = parameters["arrow_id"].toInt();
startPlayerId = parameters["start_player_id"].toInt();
startZone = parameters["start_zone"];
startCardId = parameters["start_card_id"].toInt();
targetPlayerId = parameters["target_player_id"].toInt();
targetZone = parameters["target_zone"];
targetCardId = parameters["target_card_id"].toInt();
color = ColorConverter::colorFromInt(parameters["color"].toInt());
}
Event_DeleteArrow::Event_DeleteArrow(int _gameId, int _playerId, int _arrowId)
: GameEvent("delete_arrow", _gameId, _playerId), arrowId(_arrowId)
{
@ -505,24 +477,6 @@ void Event_SetCardAttr::extractParameters()
attrName = parameters["attr_name"];
attrValue = parameters["attr_value"];
}
Event_AddCounter::Event_AddCounter(int _gameId, int _playerId, int _counterId, const QString &_counterName, const QColor &_color, int _radius, int _value)
: GameEvent("add_counter", _gameId, _playerId), counterId(_counterId), counterName(_counterName), color(_color), radius(_radius), value(_value)
{
setParameter("counter_id", counterId);
setParameter("counter_name", counterName);
setParameter("color", color);
setParameter("radius", radius);
setParameter("value", value);
}
void Event_AddCounter::extractParameters()
{
GameEvent::extractParameters();
counterId = parameters["counter_id"].toInt();
counterName = parameters["counter_name"];
color = ColorConverter::colorFromInt(parameters["color"].toInt());
radius = parameters["radius"].toInt();
value = parameters["value"].toInt();
}
Event_SetCounter::Event_SetCounter(int _gameId, int _playerId, int _counterId, int _value)
: GameEvent("set_counter", _gameId, _playerId), counterId(_counterId), value(_value)
{
@ -675,14 +629,13 @@ void ProtocolItem::initializeHashAuto()
itemNameHash.insert("cmdset_card_attr", Command_SetCardAttr::newItem);
itemNameHash.insert("cmdready_start", Command_ReadyStart::newItem);
itemNameHash.insert("cmdinc_counter", Command_IncCounter::newItem);
itemNameHash.insert("cmdadd_counter", Command_AddCounter::newItem);
itemNameHash.insert("cmdcreate_counter", Command_CreateCounter::newItem);
itemNameHash.insert("cmdset_counter", Command_SetCounter::newItem);
itemNameHash.insert("cmddel_counter", Command_DelCounter::newItem);
itemNameHash.insert("cmdnext_turn", Command_NextTurn::newItem);
itemNameHash.insert("cmdset_active_phase", Command_SetActivePhase::newItem);
itemNameHash.insert("cmddump_zone", Command_DumpZone::newItem);
itemNameHash.insert("cmdstop_dump_zone", Command_StopDumpZone::newItem);
itemNameHash.insert("cmddump_all", Command_DumpAll::newItem);
itemNameHash.insert("game_eventsay", Event_Say::newItem);
itemNameHash.insert("game_eventjoin", Event_Join::newItem);
itemNameHash.insert("game_eventleave", Event_Leave::newItem);
@ -694,10 +647,8 @@ void ProtocolItem::initializeHashAuto()
itemNameHash.insert("game_eventroll_die", Event_RollDie::newItem);
itemNameHash.insert("game_eventmove_card", Event_MoveCard::newItem);
itemNameHash.insert("game_eventcreate_token", Event_CreateToken::newItem);
itemNameHash.insert("game_eventcreate_arrow", Event_CreateArrow::newItem);
itemNameHash.insert("game_eventdelete_arrow", Event_DeleteArrow::newItem);
itemNameHash.insert("game_eventset_card_attr", Event_SetCardAttr::newItem);
itemNameHash.insert("game_eventadd_counter", Event_AddCounter::newItem);
itemNameHash.insert("game_eventset_counter", Event_SetCounter::newItem);
itemNameHash.insert("game_eventdel_counter", Event_DelCounter::newItem);
itemNameHash.insert("game_eventset_active_player", Event_SetActivePlayer::newItem);

5
common/protocol_items.dat
View file

@ -24,14 +24,13 @@
2:set_card_attr:s,zone:i,card_id:s,attr_name:s,attr_value
2:ready_start
2:inc_counter:i,counter_id:i,delta
2:add_counter:s,counter_name:c,color:i,radius:i,value
2:create_counter:s,counter_name:c,color:i,radius:i,value
2:set_counter:i,counter_id:i,value
2:del_counter:i,counter_id
2:next_turn
2:set_active_phase:i,phase
2:dump_zone:i,player_id:s,zone_name:i,number_cards
2:stop_dump_zone:i,player_id:s,zone_name
2:dump_all
3:say:s,message
3:join:s,player_name:b,spectator
3:leave
@ -43,10 +42,8 @@
3:roll_die:i,sides:i,value
3:move_card:i,card_id:s,card_name:s,start_zone:i,position:s,target_zone:i,x:i,y:b,face_down
3:create_token:s,zone:i,card_id:s,card_name:s,pt:i,x:i,y
3:create_arrow:i,arrow_id:i,start_player_id:s,start_zone:i,start_card_id:i,target_player_id:s,target_zone:i,target_card_id:c,color
3:delete_arrow:i,arrow_id
3:set_card_attr:s,zone:i,card_id:s,attr_name:s,attr_value
3:add_counter:i,counter_id:s,counter_name:c,color:i,radius:i,value
3:set_counter:i,counter_id:i,value
3:del_counter:i,counter_id
3:set_active_player:i,active_player_id

62
common/protocol_items.h
View file

@ -335,7 +335,7 @@ public:
protected:
void extractParameters();
};
class Command_AddCounter : public GameCommand {
class Command_CreateCounter : public GameCommand {
Q_OBJECT
private:
QString counterName;
@ -343,13 +343,13 @@ private:
int radius;
int value;
public:
Command_AddCounter(int _gameId = -1, const QString &_counterName = QString(), const QColor &_color = QColor(), int _radius = -1, int _value = -1);
Command_CreateCounter(int _gameId = -1, const QString &_counterName = QString(), const QColor &_color = QColor(), int _radius = -1, int _value = -1);
QString getCounterName() const { return counterName; }
QColor getColor() const { return color; }
int getRadius() const { return radius; }
int getValue() const { return value; }
static ProtocolItem *newItem() { return new Command_AddCounter; }
int getItemId() const { return ItemId_Command_AddCounter; }
static ProtocolItem *newItem() { return new Command_CreateCounter; }
int getItemId() const { return ItemId_Command_CreateCounter; }
protected:
void extractParameters();
};
@ -429,14 +429,6 @@ public:
protected:
void extractParameters();
};
class Command_DumpAll : public GameCommand {
Q_OBJECT
private:
public:
Command_DumpAll(int _gameId = -1);
static ProtocolItem *newItem() { return new Command_DumpAll; }
int getItemId() const { return ItemId_Command_DumpAll; }
};
class Event_Say : public GameEvent {
Q_OBJECT
private:
@ -577,32 +569,6 @@ public:
protected:
void extractParameters();
};
class Event_CreateArrow : public GameEvent {
Q_OBJECT
private:
int arrowId;
int startPlayerId;
QString startZone;
int startCardId;
int targetPlayerId;
QString targetZone;
int targetCardId;
QColor color;
public:
Event_CreateArrow(int _gameId = -1, int _playerId = -1, int _arrowId = -1, int _startPlayerId = -1, const QString &_startZone = QString(), int _startCardId = -1, int _targetPlayerId = -1, const QString &_targetZone = QString(), int _targetCardId = -1, const QColor &_color = QColor());
int getArrowId() const { return arrowId; }
int getStartPlayerId() const { return startPlayerId; }
QString getStartZone() const { return startZone; }
int getStartCardId() const { return startCardId; }
int getTargetPlayerId() const { return targetPlayerId; }
QString getTargetZone() const { return targetZone; }
int getTargetCardId() const { return targetCardId; }
QColor getColor() const { return color; }
static ProtocolItem *newItem() { return new Event_CreateArrow; }
int getItemId() const { return ItemId_Event_CreateArrow; }
protected:
void extractParameters();
};
class Event_DeleteArrow : public GameEvent {
Q_OBJECT
private:
@ -633,26 +599,6 @@ public:
protected:
void extractParameters();
};
class Event_AddCounter : public GameEvent {
Q_OBJECT
private:
int counterId;
QString counterName;
QColor color;
int radius;
int value;
public:
Event_AddCounter(int _gameId = -1, int _playerId = -1, int _counterId = -1, const QString &_counterName = QString(), const QColor &_color = QColor(), int _radius = -1, int _value = -1);
int getCounterId() const { return counterId; }
QString getCounterName() const { return counterName; }
QColor getColor() const { return color; }
int getRadius() const { return radius; }
int getValue() const { return value; }
static ProtocolItem *newItem() { return new Event_AddCounter; }
int getItemId() const { return ItemId_Event_AddCounter; }
protected:
void extractParameters();
};
class Event_SetCounter : public GameEvent {
Q_OBJECT
private:

5
common/server_game.cpp
View file

@ -219,13 +219,14 @@ QList<ServerInfo_Player *> Server_Game::getGameState(Server_Player *playerWhosAs
return result;
}
void Server_Game::sendGameEvent(GameEvent *event)
void Server_Game::sendGameEvent(GameEvent *event, Server_Player *exclude)
{
event->setGameId(gameId);
QList<Server_Player *> receivers = QList<Server_Player *>() << players.values() << spectators;
for (int i = 0; i < receivers.size(); ++i)
receivers[i]->sendProtocolItem(event, false);
if (receivers[i] != exclude)
receivers[i]->sendProtocolItem(event, false);
delete event;
}

2
common/server_game.h
View file

@ -66,7 +66,7 @@ public:
void setActivePhase(int _activePhase);
QList<ServerInfo_Player *> getGameState(Server_Player *playerWhosAsking) const;
void sendGameEvent(GameEvent *event);
void sendGameEvent(GameEvent *event, Server_Player *exclude = 0);
};
#endif

29
common/server_protocolhandler.cpp
View file

@ -80,14 +80,13 @@ void Server_ProtocolHandler::processCommand(Command *command)
case ItemId_Command_SetCardAttr: response = cmdSetCardAttr(qobject_cast<Command_SetCardAttr *>(command), game, player); break;
case ItemId_Command_ReadyStart: response = cmdReadyStart(qobject_cast<Command_ReadyStart *>(command), game, player); break;
case ItemId_Command_IncCounter: response = cmdIncCounter(qobject_cast<Command_IncCounter *>(command), game, player); break;
case ItemId_Command_AddCounter: response = cmdAddCounter(qobject_cast<Command_AddCounter *>(command), game, player); break;
case ItemId_Command_CreateCounter: response = cmdCreateCounter(qobject_cast<Command_CreateCounter *>(command), game, player); break;
case ItemId_Command_SetCounter: response = cmdSetCounter(qobject_cast<Command_SetCounter *>(command), game, player); break;
case ItemId_Command_DelCounter: response = cmdDelCounter(qobject_cast<Command_DelCounter *>(command), game, player); break;
case ItemId_Command_NextTurn: response = cmdNextTurn(qobject_cast<Command_NextTurn *>(command), game, player); break;
case ItemId_Command_SetActivePhase: response = cmdSetActivePhase(qobject_cast<Command_SetActivePhase *>(command), game, player); break;
case ItemId_Command_DumpZone: response = cmdDumpZone(qobject_cast<Command_DumpZone *>(command), game, player); break;
case ItemId_Command_StopDumpZone: response = cmdStopDumpZone(qobject_cast<Command_StopDumpZone *>(command), game, player); break;
case ItemId_Command_DumpAll: response = cmdDumpAll(qobject_cast<Command_DumpAll *>(command), game, player); break;
}
} else {
qDebug() << "received generic Command";
@ -297,13 +296,16 @@ ResponseCode Server_ProtocolHandler::cmdDrawCards(Command_DrawCards *cmd, Server
if (deck->cards.size() < number)
number = deck->cards.size();
QList<ServerInfo_Card *> cardList;
for (int i = 0; i < number; ++i) {
Server_Card *card = deck->cards.takeFirst();
hand->cards.append(card);
// player->privateEvent(QString("draw|%1|%2").arg(card->getId()).arg(card->getName()));
cardList.append(new ServerInfo_Card(card->getId(), card->getName()));
}
player->sendProtocolItem(new Event_DrawCards(game->getGameId(), player->getPlayerId(), cardList.size(), cardList));
game->sendGameEvent(new Event_DrawCards(-1, player->getPlayerId(), cardList.size()), player);
// game->broadcastEvent(QString("draw|%1").arg(number), player);
return RespOk;
}
@ -365,9 +367,9 @@ ResponseCode Server_ProtocolHandler::cmdMoveCard(Command_MoveCard *cmd, Server_G
x = -1;
if ((startzone->getType() == PublicZone) || (targetzone->getType() == PublicZone))
game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), card->getId(), publicCardName, startzone->getName(), position, targetzone->getName(), x, y, facedown));
game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), card->getId(), publicCardName, startzone->getName(), position, targetzone->getName(), x, y, facedown), player);
else
game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), -1, QString(), startzone->getName(), position, targetzone->getName(), x, y, false));
game->sendGameEvent(new Event_MoveCard(-1, player->getPlayerId(), -1, QString(), startzone->getName(), position, targetzone->getName(), x, y, false), player);
// If the card was moved to another zone, delete all arrows from and to the card
if (startzone != targetzone) {
@ -425,9 +427,7 @@ ResponseCode Server_ProtocolHandler::cmdCreateArrow(Command_CreateArrow *cmd, Se
Server_Arrow *arrow = new Server_Arrow(player->newArrowId(), startCard, targetCard, cmd->getColor());
player->addArrow(arrow);
game->sendGameEvent(new Event_CreateArrow(
-1,
player->getPlayerId(),
game->sendGameEvent(new Event_CreateArrow(-1, player->getPlayerId(), new ServerInfo_Arrow(
arrow->getId(),
startPlayer->getPlayerId(),
startZone->getName(),
@ -436,7 +436,7 @@ ResponseCode Server_ProtocolHandler::cmdCreateArrow(Command_CreateArrow *cmd, Se
targetZone->getName(),
targetCard->getId(),
cmd->getColor()
));
)));
return RespOk;
}
@ -496,11 +496,11 @@ ResponseCode Server_ProtocolHandler::cmdIncCounter(Command_IncCounter *cmd, Serv
return RespOk;
}
ResponseCode Server_ProtocolHandler::cmdAddCounter(Command_AddCounter *cmd, Server_Game *game, Server_Player *player)
ResponseCode Server_ProtocolHandler::cmdCreateCounter(Command_CreateCounter *cmd, Server_Game *game, Server_Player *player)
{
Server_Counter *c = new Server_Counter(player->newCounterId(), cmd->getCounterName(), cmd->getColor(), cmd->getRadius(), cmd->getValue());
player->addCounter(c);
game->sendGameEvent(new Event_AddCounter(-1, player->getPlayerId(), c->getId(), c->getName(), c->getColor(), c->getRadius(), c->getCount()));
game->sendGameEvent(new Event_CreateCounter(-1, player->getPlayerId(), new ServerInfo_Counter(c->getId(), c->getName(), c->getColor(), c->getRadius(), c->getCount())));
return RespOk;
}
@ -575,8 +575,3 @@ ResponseCode Server_ProtocolHandler::cmdStopDumpZone(Command_StopDumpZone *cmd,
}
return RespOk;
}
ResponseCode Server_ProtocolHandler::cmdDumpAll(Command_DumpAll *cmd, Server_Game *game, Server_Player *player)
{
return RespOk;
}

3
common/server_protocolhandler.h
View file

@ -57,14 +57,13 @@ private:
ResponseCode cmdSetCardAttr(Command_SetCardAttr *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdReadyStart(Command_ReadyStart *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdIncCounter(Command_IncCounter *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdAddCounter(Command_AddCounter *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdCreateCounter(Command_CreateCounter *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdSetCounter(Command_SetCounter *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdDelCounter(Command_DelCounter *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdNextTurn(Command_NextTurn *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdSetActivePhase(Command_SetActivePhase *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdDumpZone(Command_DumpZone *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdStopDumpZone(Command_StopDumpZone *cmd, Server_Game *game, Server_Player *player);
ResponseCode cmdDumpAll(Command_DumpAll *cmd, Server_Game *game, Server_Player *player);
public:
Server_ProtocolHandler(Server *_server, QObject *parent = 0);
~Server_ProtocolHandler();