server-side part of client -> server commands almost converted to ProtocolBuffers. not usable yet

common/color.h

@@ -5,10 +5,13 @@
 #include <QColor>
 #endif
 
+#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; }

common/pb/admin_commands.proto

+message Command_UpdateServerMessage {
+}
+
+message Command_ShutdownServer {
+	optional string reason = 1;
+	optional uint32 minutes = 2;
+}
+
+message AdminCommand {
+	enum AdminCommandType {
+		UPDATE_SERVER_MESSAGE = 1000;
+		SHUTDOWN_SERVER = 1001;
+	}
+	extensions 100 to max;
+}
+
+extend AdminCommand {
+	optional Command_UpdateServerMessage command_update_server_message = 1000;
+	optional Command_ShutdownServer command_shutdown_server = 1001;
+}
+ 

common/pb/color.proto

+message color {
+	optional uint32 r = 1;
+	optional uint32 g = 2;
+	optional uint32 b = 3;
+	optional uint32 a = 4;
+}
\ No newline at end of file

common/pb/commands.proto

+import "session_commands.proto";
+import "game_commands.proto";
+import "room_commands.proto";
+import "moderator_commands.proto";
+import "admin_commands.proto";
+
+message CommandContainer {
+	enum CommandType {
+		SESSION = 0;
+		GAME = 1;
+		ROOM = 2;
+		MODERATOR = 3;
+		ADMIN = 4;
+	}
+	required uint64 cmd_id = 1;
+	
+	optional uint32 game_id = 10;
+	optional uint32 room_id = 20;
+	
+	repeated SessionCommand session_command = 100;
+	repeated GameCommand game_command = 101;
+	repeated RoomCommand room_command = 102;
+	repeated ModeratorCommand moderator_command = 103;
+	repeated AdminCommand admin_command = 104;
+}

common/pb/game_commands.proto

+import "color.proto";
+import "move_card_to_zone.proto";
+
+message Command_KickFromGame {
+	optional sint32 player_id = 1;
+}
+
+message Command_LeaveGame {
+}
+
+message Command_GameSay {
+	optional string message = 1;
+}
+
+message Command_Shuffle {
+}
+
+message Command_Mulligan {
+}
+
+message Command_RollDie {
+	optional uint32 sides = 1;
+}
+
+message Command_DrawCards {
+	optional uint32 number = 1;
+}
+
+message Command_UndoDraw {
+}
+
+message Command_FlipCard {
+	optional string zone = 1;
+	optional sint32 card_id = 2;
+	optional bool face_down = 3;
+}
+
+message Command_AttachCard {
+	optional string start_zone = 1;
+	optional sint32 card_id = 2;
+	optional sint32 target_player_id = 3;
+	optional string target_zone = 4;
+	optional sint32 target_card_id = 5;
+}
+
+message Command_CreateToken {
+	optional string zone = 1;
+	optional string card_name = 2;
+	optional string color = 3;
+	optional string pt = 4;
+	optional string annotation = 5;
+	optional bool destroy_on_zone_change = 6;
+	optional sint32 x = 7;
+	optional sint32 y = 8;
+}
+
+message Command_CreateArrow {
+	optional sint32 start_player_id = 1;
+	optional string start_zone = 2;
+	optional sint32 start_card_id = 3;
+	optional sint32 target_player_id = 4;
+	optional string target_zone = 5;
+	optional sint32 target_card_id = 6;
+	optional color arrow_color = 7;
+}
+
+message Command_DeleteArrow {
+	optional sint32 arrow_id = 1;
+}
+
+message Command_SetCardAttr {
+	optional string zone = 1;
+	optional sint32 card_id = 2;
+	optional string attr_name = 3;
+	optional string attr_value = 4;
+}
+
+message Command_SetCardCounter {
+	optional string zone = 1;
+	optional sint32 card_id = 2;
+	optional sint32 counter_id = 3;
+	optional sint32 counter_value = 4;
+}
+
+message Command_IncCardCounter {
+	optional string zone = 1;
+	optional sint32 card_id = 2;
+	optional sint32 counter_id = 3;
+	optional sint32 counter_delta = 4;
+}
+
+message Command_ReadyStart {
+	optional bool ready = 1;
+}
+
+message Command_Concede {
+}
+
+message Command_IncCounter {
+	optional sint32 counter_id = 1;
+	optional sint32 delta = 2;
+}
+
+message Command_CreateCounter {
+	optional string counter_name = 1;
+	optional color counter_color = 2;
+	optional uint32 radius = 3;
+	optional sint32 value = 4;
+}
+
+message Command_SetCounter {
+	optional sint32 counter_id = 1;
+	optional sint32 value = 2;
+}
+
+message Command_DelCounter {
+	optional sint32 counter_id = 1;
+}
+
+message Command_NextTurn {
+}
+
+message Command_SetActivePhase {
+	optional uint32 phase = 1;
+}
+
+message Command_DumpZone {
+	optional sint32 player_id = 1;
+	optional string zone_name = 2;
+	optional sint32 number_cards = 3;
+}
+
+message Command_StopDumpZone {
+	optional sint32 player_id = 1;
+	optional string zone_name = 2;
+}
+
+message Command_RevealCards {
+	optional string zone_name = 1;
+	optional sint32 card_id = 2;
+	optional sint32 player_id = 3;
+}
+
+message CardToMove {
+	optional sint32 card_id = 1;
+	optional bool face_down = 2;
+	optional string pt = 3;
+	optional bool tapped = 4;
+}
+
+message Command_MoveCard {
+	optional string start_zone = 1;
+	repeated CardToMove cards_to_move = 2;
+	optional sint32 target_player_id = 3;
+	optional string target_zone = 4;
+	optional sint32 x = 5;
+	optional sint32 y = 6;
+}
+
+message Command_SetSideboardPlan {
+	repeated MoveCard_ToZone move_list = 1;
+}
+
+message Command_DeckSelect {
+	optional string deck = 1;
+	optional sint32 deck_id = 2;
+}
+
+message GameCommand {
+	enum GameCommandType {
+		KICK_FROM_GAME = 1000;
+		LEAVE_GAME = 1001;
+		GAME_SAY = 1002;
+		SHUFFLE = 1003;
+		MULLIGAN = 1004;
+		ROLL_DIE = 1005;
+		DRAW_CARDS = 1006;
+		UNDO_DRAW = 1007;
+		FLIP_CARD = 1008;
+		ATTACH_CARD = 1009;
+		CREATE_TOKEN = 1010;
+		CREATE_ARROW = 1011;
+		DELETE_ARROW = 1012;
+		SET_CARD_ATTR = 1013;
+		SET_CARD_COUNTER = 1014;
+		INC_CARD_COUNTER = 1015;
+		READY_START = 1016;
+		CONCEDE = 1017;
+		INC_COUNTER = 1018;
+		CREATE_COUNTER = 1019;
+		SET_COUNTER = 1020;
+		DEL_COUNTER = 1021;
+		NEXT_TURN = 1022;
+		SET_ACTIVE_PHASE = 1023;
+		DUMP_ZONE = 1024;
+		STOP_DUMP_ZONE = 1025;
+		REVEAL_CARDS = 1026;
+		MOVE_CARD = 1027;
+		SET_SIDEBOARD_PLAN = 1028;
+		DECK_SELECT = 1029;
+	}
+	extensions 100 to max;
+}
+
+extend GameCommand {
+	optional Command_KickFromGame command_kick_from_game = 1000;
+	optional Command_LeaveGame command_leave_game = 1001;
+	optional Command_GameSay command_game_say = 1002;
+	optional Command_Shuffle command_shuffle = 1003;
+	optional Command_Mulligan command_mulligan = 1004;
+	optional Command_RollDie command_roll_die = 1005;
+	optional Command_DrawCards command_draw_cards = 1006;
+	optional Command_UndoDraw command_undo_draw = 1007;
+	optional Command_FlipCard command_flip_card = 1008;
+	optional Command_AttachCard command_attach_card = 1009;
+	optional Command_CreateToken command_create_token = 1010;
+	optional Command_CreateArrow command_create_arrow = 1011;
+	optional Command_DeleteArrow command_delete_arrow = 1012;
+	optional Command_SetCardAttr command_set_card_attr = 1013;
+	optional Command_SetCardCounter command_set_card_counter = 1014;
+	optional Command_IncCardCounter command_inc_card_counter = 1015;
+	optional Command_ReadyStart command_ready_start = 1016;
+	optional Command_Concede command_concede = 1017;
+	optional Command_IncCounter command_inc_counter = 1018;
+	optional Command_CreateCounter command_create_counter = 1019;
+	optional Command_SetCounter command_set_counter = 1020;
+	optional Command_DelCounter command_del_counter = 1021;
+	optional Command_NextTurn command_next_turn = 1022;
+	optional Command_SetActivePhase command_set_active_phase = 1023;
+	optional Command_DumpZone command_dump_zone = 1024;
+	optional Command_StopDumpZone command_stop_dump_zone = 1025;
+	optional Command_RevealCards command_reveal_cards = 1026;
+	optional Command_MoveCard command_move_card = 1027;
+	optional Command_SetSideboardPlan command_set_sideboard_plan = 1028;
+	optional Command_DeckSelect command_deck_select = 1029;
+}
+ 

common/pb/moderator_commands.proto

+ 
+
+message Command_BanFromServer {
+	optional string user_name = 1;
+	optional string address = 2;
+	optional uint32 minutes = 3;
+	optional string reason = 4;
+}
+
+message ModeratorCommand {
+	enum ModeratorCommandType {
+		BAN_FROM_SERVER = 1000;
+	}
+	extensions 100 to max;
+}
+
+extend ModeratorCommand {
+	optional Command_BanFromServer command_ban_from_server = 1000;
+}
+

common/pb/move_card_to_zone.proto

+message MoveCard_ToZone {
+	optional string card_name = 1;
+	optional string start_zone = 2;
+	optional string target_zone = 3;
+}

common/pb/room_commands.proto

+
+message Command_LeaveRoom {
+}
+
+message Command_RoomSay {
+	optional string message = 1;
+}
+
+message Command_CreateGame {
+	optional string description = 1;
+	optional string password = 2;
+	optional uint32 max_players = 3;
+	optional bool only_buddies = 4;
+	optional bool only_registered = 5;
+	optional bool spectators_allowed = 6;
+	optional bool spectators_need_password = 7;
+	optional bool spectators_can_talk = 8;
+	optional bool spectators_see_everything = 9;
+	repeated uint32 game_type_ids = 10;
+}
+
+message Command_JoinGame {
+	optional uint32 game_id = 1;
+	optional string password = 2;
+	optional bool spectator = 3;
+	optional bool override_restrictions = 4;
+}
+
+message RoomCommand {
+	enum RoomCommandType {
+		LEAVE_ROOM = 1000;
+		ROOM_SAY = 1001;
+		CREATE_GAME = 1002;
+		JOIN_GAME = 1003;
+	}
+	extensions 100 to max;
+}
+
+extend RoomCommand {
+	optional Command_LeaveRoom command_leave_room = 1000;
+	optional Command_RoomSay command_room_say = 1001;
+	optional Command_CreateGame command_create_game = 1002;
+	optional Command_JoinGame command_join_game = 1003;
+}
+
+ 

common/pb/session_commands.proto

+message Command_Ping {
+}
+
+message Command_Login {
+	optional string user_name = 1;
+	optional string password = 2;
+}
+
+message Command_Message {
+	optional string user_name = 1;
+	optional string message = 2;
+}
+
+message Command_ListUsers {
+}
+
+message Command_GetGamesOfUser {
+	optional string user_name = 1;
+}
+
+message Command_GetUserInfo {
+	optional string user_name = 1;
+}
+
+message Command_AddToList {
+	optional string list = 1;
+	optional string user_name = 2;
+}
+
+message Command_RemoveFromList {
+	optional string list = 1;
+	optional string user_name = 2;
+}
+
+message Command_DeckList {
+}
+
+message Command_DeckNewDir {
+	optional string path = 1;
+	optional string dir_name = 2;
+}
+
+message Command_DeckDelDir {
+	optional string path = 1;
+}
+
+message Command_DeckDel {
+	optional uint32 deck_id = 1;
+}
+
+message Command_DeckDownload {
+	optional uint32 deck_id = 1;
+}
+
+message Command_DeckUpload {
+	optional string path = 1;
+	optional string deck_list = 2;
+}
+
+message Command_ListRooms {
+}
+
+message Command_JoinRoom {
+	optional uint32 room_id = 1;
+}
+
+message SessionCommand {
+	enum SessionCommandType {
+		PING = 1000;
+		LOGIN = 1001;
+		MESSAGE = 1002;
+		LIST_USERS = 1003;
+		GET_GAMES_OF_USER = 1004;
+		GET_USER_INFO = 1005;
+		ADD_TO_LIST = 1006;
+		REMOVE_FROM_LIST = 1007;
+		DECK_LIST = 1008;
+		DECK_NEW_DIR = 1009;
+		DECK_DEL_DIR = 1010;
+		DECK_DEL = 1011;
+		DECK_DOWNLOAD = 1012;
+		DECK_UPLOAD = 1013;
+		LIST_ROOMS = 1014;
+		JOIN_ROOM = 1015;
+	}
+	extensions 100 to max;
+}
+
+extend SessionCommand {
+	optional Command_Ping command_ping = 1000;
+	optional Command_Login command_login = 1001;
+	optional Command_Message command_message = 1002;
+	optional Command_ListUsers command_list_users = 1003;
+	optional Command_GetGamesOfUser command_get_games_of_user = 1004;
+	optional Command_GetUserInfo command_get_user_info = 1005;
+	optional Command_AddToList command_add_to_list = 1006;
+	optional Command_RemoveFromList command_remove_from_list = 1007;
+	optional Command_DeckList command_deck_list = 1008;
+	optional Command_DeckNewDir command_deck_new_dir = 1009;
+	optional Command_DeckDelDir command_deck_del_dir = 1010;
+	optional Command_DeckDel command_deck_del = 1011;
+	optional Command_DeckDownload command_deck_download = 1012;
+	optional Command_DeckUpload command_deck_upload = 1013;
+	optional Command_ListRooms command_list_rooms = 1014;
+	optional Command_JoinRoom command_join_room = 1015;
+}
+ 

common/protocol.cpp

@@ -28,9 +28,9 @@ void ProtocolItem::initializeHash()
 	registerSerializableItem("player_ping", ServerInfo_PlayerPing::newItem);
 	registerSerializableItem("file", DeckList_File::newItem);
 	registerSerializableItem("directory", DeckList_Directory::newItem);
-	registerSerializableItem("card_to_move", CardToMove::newItem);
+//	registerSerializableItem("card_to_move", CardToMove::newItem);
 	registerSerializableItem("game_type_id", GameTypeId::newItem);
-	
+/*	
 	registerSerializableItem("containercmd", CommandContainer::newItem);
 	registerSerializableItem("containergame_event", GameEventContainer::newItem);
 	
@@ -39,7 +39,7 @@ void ProtocolItem::initializeHash()
 	registerSerializableItem("cmddeck_select", Command_DeckSelect::newItem);
 	registerSerializableItem("cmdset_sideboard_plan", Command_SetSideboardPlan::newItem);
 	registerSerializableItem("cmdmove_card", Command_MoveCard::newItem);
-	
+*/	
 	registerSerializableItem("resp", ProtocolResponse::newItem);
 	ProtocolResponse::initializeHash();
 	registerSerializableItem("respjoin_room", Response_JoinRoom::newItem);
@@ -105,6 +105,7 @@ void TopLevelProtocolItem::writeElement(QXmlStreamWriter * /*xml*/)
 {
 }
 
+/*
 int CommandContainer::lastCmdId = 0;
 
 Command::Command(const QString &_itemName)
@@ -138,14 +139,19 @@ void CommandContainer::processResponse(ProtocolResponse *response)
 	for (int i = 0; i < cmdList.size(); ++i)
 		cmdList[i]->processResponse(response);
 }
+*/
+BlaContainer::BlaContainer()
+	: ProtocolItem("container", "cmd"), resp(0), gameEventQueuePublic(0), gameEventQueueOmniscient(0), gameEventQueuePrivate(0), privatePlayerId(-1)
+{
+}
 
-void CommandContainer::setResponse(ProtocolResponse *_resp)
+void BlaContainer::setResponse(ProtocolResponse *_resp)
 {
 	delete resp;
 	resp = _resp;
 }
 
-void CommandContainer::enqueueGameEventPublic(GameEvent *event, int gameId, GameEventContext *context)
+void BlaContainer::enqueueGameEventPublic(GameEvent *event, int gameId, GameEventContext *context)
 {
 	if (!gameEventQueuePublic)
 		gameEventQueuePublic = new GameEventContainer(QList<GameEvent *>(), gameId);
@@ -154,7 +160,7 @@ void CommandContainer::enqueueGameEventPublic(GameEvent *event, int gameId, Game
 		gameEventQueuePublic->setContext(context);
 }
 
-void CommandContainer::enqueueGameEventOmniscient(GameEvent *event, int gameId, GameEventContext *context)
+void BlaContainer::enqueueGameEventOmniscient(GameEvent *event, int gameId, GameEventContext *context)
 {
 	if (!gameEventQueueOmniscient)
 		gameEventQueueOmniscient = new GameEventContainer(QList<GameEvent *>(), gameId);
@@ -163,7 +169,7 @@ void CommandContainer::enqueueGameEventOmniscient(GameEvent *event, int gameId,
 		gameEventQueueOmniscient->setContext(context);
 }
 
-void CommandContainer::enqueueGameEventPrivate(GameEvent *event, int gameId, int playerId, GameEventContext *context)
+void BlaContainer::enqueueGameEventPrivate(GameEvent *event, int gameId, int playerId, GameEventContext *context)
 {
 	if (!gameEventQueuePrivate)
 		gameEventQueuePrivate = new GameEventContainer(QList<GameEvent *>(), gameId);
@@ -172,7 +178,7 @@ void CommandContainer::enqueueGameEventPrivate(GameEvent *event, int gameId, int
 	if (context)
 		gameEventQueuePrivate->setContext(context);
 }
-
+/*
 Command_CreateGame::Command_CreateGame(int _roomId, const QString &_description, const QString &_password, int _maxPlayers, const QList<GameTypeId *> &_gameTypes, bool _onlyBuddies, bool _onlyRegistered, bool _spectatorsAllowed, bool _spectatorsNeedPassword, bool _spectatorsCanTalk, bool _spectatorsSeeEverything)
 	: RoomCommand("create_game", _roomId)
 {
@@ -242,7 +248,7 @@ Command_MoveCard::Command_MoveCard(int _gameId, const QString &_startZone, const
 	for (int i = 0; i < _cards.size(); ++i)
 		itemList.append(_cards[i]);
 }
-
+*/
 QHash<QString, ResponseCode> ProtocolResponse::responseHash;
 
 ProtocolResponse::ProtocolResponse(int _cmdId, ResponseCode _responseCode, const QString &_itemName)

common/protocol.h

@@ -91,7 +91,7 @@ public:
 // ----------------
 // --- COMMANDS ---
 // ----------------
-
+/*
 class Command : public ProtocolItem {
 	Q_OBJECT
 signals:
@@ -105,17 +105,10 @@ public:
 	QVariant getExtraData() const { return extraData; }
 	void processResponse(ProtocolResponse *response);
 };
-
-class CommandContainer : public ProtocolItem {
+*/
+class BlaContainer : public ProtocolItem {
 	Q_OBJECT
-signals:
-	void finished(ProtocolResponse *response);
-	void finished(ResponseCode response);
 private:
-	int ticks;
-	static int lastCmdId;
-	
-	// XXX Move these out. They are only for processing inside the server.
 	ProtocolResponse *resp;
 	QList<ProtocolItem *> itemQueue;
 	GameEventContext *gameEventContext;
@@ -124,13 +117,8 @@ private:
 	GameEventContainer *gameEventQueuePrivate;
 	int privatePlayerId;
 public:
-	CommandContainer(const QList<Command *> &_commandList = QList<Command *>(), int _cmdId = -1);
-	static SerializableItem *newItem() { return new CommandContainer; }
-	int getItemId() const { return ItemId_CommandContainer; }
-	int getCmdId() const { return static_cast<SerializableItem_Int *>(itemMap.value("cmd_id"))->getData(); }
-	int tick() { return ++ticks; }
-	void processResponse(ProtocolResponse *response);
-	QList<Command *> getCommandList() const { return typecastItemList<Command *>(); }
+	BlaContainer();
+	int getItemId() const { return 102332456; }
 	
 	ProtocolResponse *getResponse() const { return resp; }
 	void setResponse(ProtocolResponse *_resp);
@@ -144,7 +132,7 @@ public:
 	void enqueueGameEventPrivate(GameEvent *event, int gameId, int playerId = -1, GameEventContext *context = 0);
 	int getPrivatePlayerId() const { return privatePlayerId; }
 };
-
+/*
 class RoomCommand : public Command {
 	Q_OBJECT
 public:
@@ -186,24 +174,6 @@ public:
 	}
 };
 
-class Command_CreateGame : public RoomCommand {
-	Q_OBJECT
-public:
-	Command_CreateGame(int _roomId = -1, const QString &_description = QString(), const QString &_password = QString(), int _maxPlayers = -1, const QList<GameTypeId *> &_gameTypes = QList<GameTypeId *>(), bool _onlyBuddies = false, bool _onlyRegistered = false, bool _spectatorsAllowed = false, bool _spectatorsNeedPassword = false, bool _spectatorsCanTalk = false, bool _spectatorsSeeEverything = false);
-	QString getDescription() const { return static_cast<SerializableItem_String *>(itemMap.value("description"))->getData(); };
-	QString getPassword() const { return static_cast<SerializableItem_String *>(itemMap.value("password"))->getData(); };
-	int getMaxPlayers() const { return static_cast<SerializableItem_Int *>(itemMap.value("max_players"))->getData(); };
-	bool getOnlyBuddies() const { return static_cast<SerializableItem_Bool *>(itemMap.value("only_buddies"))->getData(); };
-	bool getOnlyRegistered() const { return static_cast<SerializableItem_Bool *>(itemMap.value("only_registered"))->getData(); };
-	bool getSpectatorsAllowed() const { return static_cast<SerializableItem_Bool *>(itemMap.value("spectators_allowed"))->getData(); };
-	bool getSpectatorsNeedPassword() const { return static_cast<SerializableItem_Bool *>(itemMap.value("spectators_need_password"))->getData(); };
-	bool getSpectatorsCanTalk() const { return static_cast<SerializableItem_Bool *>(itemMap.value("spectators_can_talk"))->getData(); };
-	bool getSpectatorsSeeEverything() const { return static_cast<SerializableItem_Bool *>(itemMap.value("spectators_see_everything"))->getData(); };
-	QList<GameTypeId *> getGameTypes() const { return typecastItemList<GameTypeId *>(); }
-	static SerializableItem *newItem() { return new Command_CreateGame; }
-	int getItemId() const { return ItemId_Command_CreateGame; }
-};
-
 class Command_DeckUpload : public Command {
 	Q_OBJECT
 public:
@@ -246,7 +216,7 @@ public:
 	static SerializableItem *newItem() { return new Command_MoveCard; }
 	int getItemId() const { return ItemId_Command_MoveCard; }
 };
-
+*/
 // -----------------
 // --- RESPONSES ---
 // -----------------

common/protocol_datastructures.cpp

@@ -3,15 +3,6 @@
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 
-CardToMove::CardToMove(int _cardId, bool _faceDown, const QString &_pt, bool _tapped)
-	: SerializableItem_Map("card_to_move")
-{
-	insertItem(new SerializableItem_Int("card_id", _cardId));
-	insertItem(new SerializableItem_Bool("facedown", _faceDown));
-	insertItem(new SerializableItem_String("pt", _pt));
-	insertItem(new SerializableItem_Bool("tapped", _tapped));
-}
-
 ServerInfo_User::ServerInfo_User(const QString &_name, int _userLevel, const QString &_address, const QString &_realName, Gender _gender, const QString &_country, const QByteArray &_avatarBmp)
 	: SerializableItem_Map("user")
 {

common/protocol_datastructures.h

@@ -20,22 +20,14 @@ enum ResponseCode { RespNothing, RespOk, RespNotInRoom, RespInternalError, RespI
 // list index, whereas cards in any other zone are referenced by their ids.
 enum ZoneType { PrivateZone, PublicZone, HiddenZone };
 
-class CardToMove : public SerializableItem_Map {
-public:
-	CardToMove(int _cardId = -1, bool _faceDown = false, const QString &_pt = QString(), bool _tapped = false);
-	static SerializableItem *newItem() { return new CardToMove; }
-	int getCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("card_id"))->getData(); }
-	bool getFaceDown() const { return static_cast<SerializableItem_Bool *>(itemMap.value("facedown"))->getData(); }
-	QString getPT() const { return static_cast<SerializableItem_String *>(itemMap.value("pt"))->getData(); }
-	bool getTapped() const { return static_cast<SerializableItem_Bool *>(itemMap.value("tapped"))->getData(); }
-};
-
 class GameTypeId : public SerializableItem_Int {
 public:
-	GameTypeId(int _gameTypeId = -1) : SerializableItem_Int("game_type_id", _gameTypeId) { }
-	static SerializableItem *newItem() { return new GameTypeId; }
+GameTypeId(int _gameTypeId = -1) : SerializableItem_Int("game_type_id", _gameTypeId) { }
+static SerializableItem *newItem() { return new GameTypeId; }
 };
 
+
+
 class ServerInfo_User : public SerializableItem_Map {
 public:
 	enum UserLevelFlags {

common/protocol_item_ids.h

 enum AutoItemId {
-ItemId_Command_Ping = 1001,
-ItemId_Command_Login = 1002,
-ItemId_Command_Message = 1003,
-ItemId_Command_ListUsers = 1004,
-ItemId_Command_GetGamesOfUser = 1005,
-ItemId_Command_GetUserInfo = 1006,
-ItemId_Command_AddToList = 1007,
-ItemId_Command_RemoveFromList = 1008,
-ItemId_Command_DeckList = 1009,
-ItemId_Command_DeckNewDir = 1010,
-ItemId_Command_DeckDelDir = 1011,
-ItemId_Command_DeckDel = 1012,
-ItemId_Command_DeckDownload = 1013,
-ItemId_Command_ListRooms = 1014,
-ItemId_Command_JoinRoom = 1015,
-ItemId_Command_LeaveRoom = 1016,
-ItemId_Command_RoomSay = 1017,
-ItemId_Command_JoinGame = 1018,
-ItemId_Command_KickFromGame = 1019,
-ItemId_Command_LeaveGame = 1020,
-ItemId_Command_Say = 1021,
-ItemId_Command_Shuffle = 1022,
-ItemId_Command_Mulligan = 1023,
-ItemId_Command_RollDie = 1024,
-ItemId_Command_DrawCards = 1025,
-ItemId_Command_UndoDraw = 1026,
-ItemId_Command_FlipCard = 1027,
-ItemId_Command_AttachCard = 1028,
-ItemId_Command_CreateToken = 1029,
-ItemId_Command_CreateArrow = 1030,
-ItemId_Command_DeleteArrow = 1031,
-ItemId_Command_SetCardAttr = 1032,
-ItemId_Command_SetCardCounter = 1033,
-ItemId_Command_IncCardCounter = 1034,
-ItemId_Command_ReadyStart = 1035,
-ItemId_Command_Concede = 1036,
-ItemId_Command_IncCounter = 1037,
-ItemId_Command_CreateCounter = 1038,
-ItemId_Command_SetCounter = 1039,
-ItemId_Command_DelCounter = 1040,
-ItemId_Command_NextTurn = 1041,
-ItemId_Command_SetActivePhase = 1042,
-ItemId_Command_DumpZone = 1043,
-ItemId_Command_StopDumpZone = 1044,
-ItemId_Command_RevealCards = 1045,
-ItemId_Event_ConnectionStateChanged = 1046,
-ItemId_Event_Say = 1047,
-ItemId_Event_Leave = 1048,
-ItemId_Event_GameClosed = 1049,
-ItemId_Event_GameHostChanged = 1050,
-ItemId_Event_Kicked = 1051,
-ItemId_Event_Shuffle = 1052,
-ItemId_Event_RollDie = 1053,
-ItemId_Event_MoveCard = 1054,
-ItemId_Event_FlipCard = 1055,
-ItemId_Event_DestroyCard = 1056,
-ItemId_Event_AttachCard = 1057,
-ItemId_Event_CreateToken = 1058,
-ItemId_Event_DeleteArrow = 1059,
-ItemId_Event_SetCardAttr = 1060,
-ItemId_Event_SetCardCounter = 1061,
-ItemId_Event_SetCounter = 1062,
-ItemId_Event_DelCounter = 1063,
-ItemId_Event_SetActivePlayer = 1064,
-ItemId_Event_SetActivePhase = 1065,
-ItemId_Event_DumpZone = 1066,
-ItemId_Event_StopDumpZone = 1067,
-ItemId_Event_RemoveFromList = 1068,
-ItemId_Event_ServerMessage = 1069,
-ItemId_Event_ServerShutdown = 1070,
-ItemId_Event_ConnectionClosed = 1071,
-ItemId_Event_Message = 1072,
-ItemId_Event_GameJoined = 1073,
-ItemId_Event_UserLeft = 1074,
-ItemId_Event_LeaveRoom = 1075,
-ItemId_Event_RoomSay = 1076,
-ItemId_Context_ReadyStart = 1077,
-ItemId_Context_Concede = 1078,
-ItemId_Context_DeckSelect = 1079,
-ItemId_Context_UndoDraw = 1080,
-ItemId_Context_MoveCard = 1081,
-ItemId_Context_Mulligan = 1082,
-ItemId_Command_UpdateServerMessage = 1083,
-ItemId_Command_ShutdownServer = 1084,
-ItemId_Command_BanFromServer = 1085,
-ItemId_Other = 1086
+ItemId_Event_ConnectionStateChanged = 1001,
+ItemId_Event_Say = 1002,
+ItemId_Event_Leave = 1003,
+ItemId_Event_GameClosed = 1004,
+ItemId_Event_GameHostChanged = 1005,
+ItemId_Event_Kicked = 1006,
+ItemId_Event_Shuffle = 1007,
+ItemId_Event_RollDie = 1008,
+ItemId_Event_MoveCard = 1009,
+ItemId_Event_FlipCard = 1010,
+ItemId_Event_DestroyCard = 1011,
+ItemId_Event_AttachCard = 1012,
+ItemId_Event_CreateToken = 1013,
+ItemId_Event_DeleteArrow = 1014,
+ItemId_Event_SetCardAttr = 1015,
+ItemId_Event_SetCardCounter = 1016,
+ItemId_Event_SetCounter = 1017,
+ItemId_Event_DelCounter = 1018,
+ItemId_Event_SetActivePlayer = 1019,
+ItemId_Event_SetActivePhase = 1020,
+ItemId_Event_DumpZone = 1021,
+ItemId_Event_StopDumpZone = 1022,
+ItemId_Event_RemoveFromList = 1023,
+ItemId_Event_ServerMessage = 1024,
+ItemId_Event_ServerShutdown = 1025,
+ItemId_Event_ConnectionClosed = 1026,
+ItemId_Event_Message = 1027,
+ItemId_Event_GameJoined = 1028,
+ItemId_Event_UserLeft = 1029,
+ItemId_Event_LeaveRoom = 1030,
+ItemId_Event_RoomSay = 1031,
+ItemId_Context_ReadyStart = 1032,
+ItemId_Context_Concede = 1033,
+ItemId_Context_DeckSelect = 1034,
+ItemId_Context_UndoDraw = 1035,
+ItemId_Context_MoveCard = 1036,
+ItemId_Context_Mulligan = 1037,
+ItemId_Other = 1038
 };

common/protocol_items.cpp

 #include "protocol.h"
 #include "protocol_items.h"
 
-Command_Ping::Command_Ping()
-	: Command("ping")
-{
-}
-Command_Login::Command_Login(const QString &_username, const QString &_password)
-	: Command("login")
-{
-	insertItem(new SerializableItem_String("username", _username));
-	insertItem(new SerializableItem_String("password", _password));
-}
-Command_Message::Command_Message(const QString &_userName, const QString &_text)
-	: Command("message")
-{
-	insertItem(new SerializableItem_String("user_name", _userName));
-	insertItem(new SerializableItem_String("text", _text));
-}
-Command_ListUsers::Command_ListUsers()
-	: Command("list_users")
-{
-}
-Command_GetGamesOfUser::Command_GetGamesOfUser(const QString &_userName)
-	: Command("get_games_of_user")
-{
-	insertItem(new SerializableItem_String("user_name", _userName));
-}
-Command_GetUserInfo::Command_GetUserInfo(const QString &_userName)
-	: Command("get_user_info")
-{
-	insertItem(new SerializableItem_String("user_name", _userName));
-}
-Command_AddToList::Command_AddToList(const QString &_list, const QString &_userName)
-	: Command("add_to_list")
-{
-	insertItem(new SerializableItem_String("list", _list));
-	insertItem(new SerializableItem_String("user_name", _userName));
-}
-Command_RemoveFromList::Command_RemoveFromList(const QString &_list, const QString &_userName)
-	: Command("remove_from_list")
-{
-	insertItem(new SerializableItem_String("list", _list));
-	insertItem(new SerializableItem_String("user_name", _userName));
-}
-Command_DeckList::Command_DeckList()
-	: Command("deck_list")
-{
-}
-Command_DeckNewDir::Command_DeckNewDir(const QString &_path, const QString &_dirName)
-	: Command("deck_new_dir")
-{
-	insertItem(new SerializableItem_String("path", _path));
-	insertItem(new SerializableItem_String("dir_name", _dirName));
-}
-Command_DeckDelDir::Command_DeckDelDir(const QString &_path)
-	: Command("deck_del_dir")
-{
-	insertItem(new SerializableItem_String("path", _path));
-}
-Command_DeckDel::Command_DeckDel(int _deckId)
-	: Command("deck_del")
-{
-	insertItem(new SerializableItem_Int("deck_id", _deckId));
-}
-Command_DeckDownload::Command_DeckDownload(int _deckId)
-	: Command("deck_download")
-{
-	insertItem(new SerializableItem_Int("deck_id", _deckId));
-}
-Command_ListRooms::Command_ListRooms()
-	: Command("list_rooms")
-{
-}
-Command_JoinRoom::Command_JoinRoom(int _roomId)
-	: Command("join_room")
-{
-	insertItem(new SerializableItem_Int("room_id", _roomId));
-}
-Command_LeaveRoom::Command_LeaveRoom(int _roomId)
-	: RoomCommand("leave_room", _roomId)
-{
-}
-Command_RoomSay::Command_RoomSay(int _roomId, const QString &_message)
-	: RoomCommand("room_say", _roomId)
-{
-	insertItem(new SerializableItem_String("message", _message));
-}
-Command_JoinGame::Command_JoinGame(int _roomId, int _gameId, const QString &_password, bool _spectator, bool _overrideRestrictions)
-	: RoomCommand("join_game", _roomId)
-{
-	insertItem(new SerializableItem_Int("game_id", _gameId));
-	insertItem(new SerializableItem_String("password", _password));
-	insertItem(new SerializableItem_Bool("spectator", _spectator));
-	insertItem(new SerializableItem_Bool("override_restrictions", _overrideRestrictions));
-}
-Command_KickFromGame::Command_KickFromGame(int _gameId, int _playerId)
-	: GameCommand("kick_from_game", _gameId)
-{
-	insertItem(new SerializableItem_Int("player_id", _playerId));
-}
-Command_LeaveGame::Command_LeaveGame(int _gameId)
-	: GameCommand("leave_game", _gameId)
-{
-}
-Command_Say::Command_Say(int _gameId, const QString &_message)
-	: GameCommand("say", _gameId)
-{
-	insertItem(new SerializableItem_String("message", _message));
-}
-Command_Shuffle::Command_Shuffle(int _gameId)
-	: GameCommand("shuffle", _gameId)
-{
-}
-Command_Mulligan::Command_Mulligan(int _gameId)
-	: GameCommand("mulligan", _gameId)
-{
-}
-Command_RollDie::Command_RollDie(int _gameId, int _sides)
-	: GameCommand("roll_die", _gameId)
-{
-	insertItem(new SerializableItem_Int("sides", _sides));
-}
-Command_DrawCards::Command_DrawCards(int _gameId, int _number)
-	: GameCommand("draw_cards", _gameId)
-{
-	insertItem(new SerializableItem_Int("number", _number));
-}
-Command_UndoDraw::Command_UndoDraw(int _gameId)
-	: GameCommand("undo_draw", _gameId)
-{
-}
-Command_FlipCard::Command_FlipCard(int _gameId, const QString &_zone, int _cardId, bool _faceDown)
-	: GameCommand("flip_card", _gameId)
-{
-	insertItem(new SerializableItem_String("zone", _zone));
-	insertItem(new SerializableItem_Int("card_id", _cardId));
-	insertItem(new SerializableItem_Bool("face_down", _faceDown));
-}
-Command_AttachCard::Command_AttachCard(int _gameId, const QString &_startZone, int _cardId, int _targetPlayerId, const QString &_targetZone, int _targetCardId)
-	: GameCommand("attach_card", _gameId)
-{
-	insertItem(new SerializableItem_String("start_zone", _startZone));
-	insertItem(new SerializableItem_Int("card_id", _cardId));
-	insertItem(new SerializableItem_Int("target_player_id", _targetPlayerId));
-	insertItem(new SerializableItem_String("target_zone", _targetZone));
-	insertItem(new SerializableItem_Int("target_card_id", _targetCardId));
-}
-Command_CreateToken::Command_CreateToken(int _gameId, const QString &_zone, const QString &_cardName, const QString &_color, const QString &_pt, const QString &_annotation, bool _destroy, int _x, int _y)
-	: GameCommand("create_token", _gameId)
-{
-	insertItem(new SerializableItem_String("zone", _zone));
-	insertItem(new SerializableItem_String("card_name", _cardName));
-	insertItem(new SerializableItem_String("color", _color));
-	insertItem(new SerializableItem_String("pt", _pt));
-	insertItem(new SerializableItem_String("annotation", _annotation));
-	insertItem(new SerializableItem_Bool("destroy", _destroy));
-	insertItem(new SerializableItem_Int("x", _x));
-	insertItem(new SerializableItem_Int("y", _y));
-}
-Command_CreateArrow::Command_CreateArrow(int _gameId, int _startPlayerId, const QString &_startZone, int _startCardId, int _targetPlayerId, const QString &_targetZone, int _targetCardId, const Color &_color)
-	: GameCommand("create_arrow", _gameId)
-{
-	insertItem(new SerializableItem_Int("start_player_id", _startPlayerId));
-	insertItem(new SerializableItem_String("start_zone", _startZone));
-	insertItem(new SerializableItem_Int("start_card_id", _startCardId));
-	insertItem(new SerializableItem_Int("target_player_id", _targetPlayerId));
-	insertItem(new SerializableItem_String("target_zone", _targetZone));
-	insertItem(new SerializableItem_Int("target_card_id", _targetCardId));
-	insertItem(new SerializableItem_Color("color", _color));
-}
-Command_DeleteArrow::Command_DeleteArrow(int _gameId, int _arrowId)
-	: GameCommand("delete_arrow", _gameId)
-{
-	insertItem(new SerializableItem_Int("arrow_id", _arrowId));
-}
-Command_SetCardAttr::Command_SetCardAttr(int _gameId, const QString &_zone, int _cardId, const QString &_attrName, const QString &_attrValue)
-	: GameCommand("set_card_attr", _gameId)
-{
-	insertItem(new SerializableItem_String("zone", _zone));
-	insertItem(new SerializableItem_Int("card_id", _cardId));
-	insertItem(new SerializableItem_String("attr_name", _attrName));
-	insertItem(new SerializableItem_String("attr_value", _attrValue));
-}
-Command_SetCardCounter::Command_SetCardCounter(int _gameId, const QString &_zone, int _cardId, int _counterId, int _counterValue)
-	: GameCommand("set_card_counter", _gameId)
-{
-	insertItem(new SerializableItem_String("zone", _zone));
-	insertItem(new SerializableItem_Int("card_id", _cardId));
-	insertItem(new SerializableItem_Int("counter_id", _counterId));
-	insertItem(new SerializableItem_Int("counter_value", _counterValue));
-}
-Command_IncCardCounter::Command_IncCardCounter(int _gameId, const QString &_zone, int _cardId, int _counterId, int _counterDelta)
-	: GameCommand("inc_card_counter", _gameId)
-{
-	insertItem(new SerializableItem_String("zone", _zone));
-	insertItem(new SerializableItem_Int("card_id", _cardId));
-	insertItem(new SerializableItem_Int("counter_id", _counterId));
-	insertItem(new SerializableItem_Int("counter_delta", _counterDelta));
-}
-Command_ReadyStart::Command_ReadyStart(int _gameId, bool _ready)
-	: GameCommand("ready_start", _gameId)
-{
-	insertItem(new SerializableItem_Bool("ready", _ready));
-}
-Command_Concede::Command_Concede(int _gameId)
-	: GameCommand("concede", _gameId)
-{
-}
-Command_IncCounter::Command_IncCounter(int _gameId, int _counterId, int _delta)
-	: GameCommand("inc_counter", _gameId)
-{
-	insertItem(new SerializableItem_Int("counter_id", _counterId));
-	insertItem(new SerializableItem_Int("delta", _delta));
-}
-Command_CreateCounter::Command_CreateCounter(int _gameId, const QString &_counterName, const Color &_color, int _radius, int _value)
-	: GameCommand("create_counter", _gameId)
-{
-	insertItem(new SerializableItem_String("counter_name", _counterName));
-	insertItem(new SerializableItem_Color("color", _color));
-	insertItem(new SerializableItem_Int("radius", _radius));
-	insertItem(new SerializableItem_Int("value", _value));
-}
-Command_SetCounter::Command_SetCounter(int _gameId, int _counterId, int _value)
-	: GameCommand("set_counter", _gameId)
-{
-	insertItem(new SerializableItem_Int("counter_id", _counterId));
-	insertItem(new SerializableItem_Int("value", _value));
-}
-Command_DelCounter::Command_DelCounter(int _gameId, int _counterId)
-	: GameCommand("del_counter", _gameId)
-{
-	insertItem(new SerializableItem_Int("counter_id", _counterId));
-}
-Command_NextTurn::Command_NextTurn(int _gameId)
-	: GameCommand("next_turn", _gameId)
-{
-}
-Command_SetActivePhase::Command_SetActivePhase(int _gameId, int _phase)
-	: GameCommand("set_active_phase", _gameId)
-{
-	insertItem(new SerializableItem_Int("phase", _phase));
-}
-Command_DumpZone::Command_DumpZone(int _gameId, int _playerId, const QString &_zoneName, int _numberCards)
-	: GameCommand("dump_zone", _gameId)
-{
-	insertItem(new SerializableItem_Int("player_id", _playerId));
-	insertItem(new SerializableItem_String("zone_name", _zoneName));
-	insertItem(new SerializableItem_Int("number_cards", _numberCards));
-}
-Command_StopDumpZone::Command_StopDumpZone(int _gameId, int _playerId, const QString &_zoneName)
-	: GameCommand("stop_dump_zone", _gameId)
-{
-	insertItem(new SerializableItem_Int("player_id", _playerId));
-	insertItem(new SerializableItem_String("zone_name", _zoneName));
-}
-Command_RevealCards::Command_RevealCards(int _gameId, const QString &_zoneName, int _cardId, int _playerId)
-	: GameCommand("reveal_cards", _gameId)
-{
-	insertItem(new SerializableItem_String("zone_name", _zoneName));
-	insertItem(new SerializableItem_Int("card_id", _cardId));
-	insertItem(new SerializableItem_Int("player_id", _playerId));
-}
 Event_ConnectionStateChanged::Event_ConnectionStateChanged(int _playerId, bool _connected)
 	: GameEvent("connection_state_changed", _playerId)
 {
@@ -485,71 +225,8 @@ Context_Mulligan::Context_Mulligan(int _number)
 {
 	insertItem(new SerializableItem_Int("number", _number));
 }
-Command_UpdateServerMessage::Command_UpdateServerMessage()
-	: AdminCommand("update_server_message")
-{
-}
-Command_ShutdownServer::Command_ShutdownServer(const QString &_reason, int _minutes)
-	: AdminCommand("shutdown_server")
-{
-	insertItem(new SerializableItem_String("reason", _reason));
-	insertItem(new SerializableItem_Int("minutes", _minutes));
-}
-Command_BanFromServer::Command_BanFromServer(const QString &_userName, const QString &_address, int _minutes, const QString &_reason)
-	: ModeratorCommand("ban_from_server")
-{
-	insertItem(new SerializableItem_String("user_name", _userName));
-	insertItem(new SerializableItem_String("address", _address));
-	insertItem(new SerializableItem_Int("minutes", _minutes));
-	insertItem(new SerializableItem_String("reason", _reason));
-}
 void ProtocolItem::initializeHashAuto()
 {
-	itemNameHash.insert("cmdping", Command_Ping::newItem);
-	itemNameHash.insert("cmdlogin", Command_Login::newItem);
-	itemNameHash.insert("cmdmessage", Command_Message::newItem);
-	itemNameHash.insert("cmdlist_users", Command_ListUsers::newItem);
-	itemNameHash.insert("cmdget_games_of_user", Command_GetGamesOfUser::newItem);
-	itemNameHash.insert("cmdget_user_info", Command_GetUserInfo::newItem);
-	itemNameHash.insert("cmdadd_to_list", Command_AddToList::newItem);
-	itemNameHash.insert("cmdremove_from_list", Command_RemoveFromList::newItem);
-	itemNameHash.insert("cmddeck_list", Command_DeckList::newItem);
-	itemNameHash.insert("cmddeck_new_dir", Command_DeckNewDir::newItem);
-	itemNameHash.insert("cmddeck_del_dir", Command_DeckDelDir::newItem);
-	itemNameHash.insert("cmddeck_del", Command_DeckDel::newItem);
-	itemNameHash.insert("cmddeck_download", Command_DeckDownload::newItem);
-	itemNameHash.insert("cmdlist_rooms", Command_ListRooms::newItem);
-	itemNameHash.insert("cmdjoin_room", Command_JoinRoom::newItem);
-	itemNameHash.insert("cmdleave_room", Command_LeaveRoom::newItem);
-	itemNameHash.insert("cmdroom_say", Command_RoomSay::newItem);
-	itemNameHash.insert("cmdjoin_game", Command_JoinGame::newItem);
-	itemNameHash.insert("cmdkick_from_game", Command_KickFromGame::newItem);
-	itemNameHash.insert("cmdleave_game", Command_LeaveGame::newItem);
-	itemNameHash.insert("cmdsay", Command_Say::newItem);
-	itemNameHash.insert("cmdshuffle", Command_Shuffle::newItem);
-	itemNameHash.insert("cmdmulligan", Command_Mulligan::newItem);
-	itemNameHash.insert("cmdroll_die", Command_RollDie::newItem);
-	itemNameHash.insert("cmddraw_cards", Command_DrawCards::newItem);
-	itemNameHash.insert("cmdundo_draw", Command_UndoDraw::newItem);
-	itemNameHash.insert("cmdflip_card", Command_FlipCard::newItem);
-	itemNameHash.insert("cmdattach_card", Command_AttachCard::newItem);
-	itemNameHash.insert("cmdcreate_token", Command_CreateToken::newItem);
-	itemNameHash.insert("cmdcreate_arrow", Command_CreateArrow::newItem);
-	itemNameHash.insert("cmddelete_arrow", Command_DeleteArrow::newItem);
-	itemNameHash.insert("cmdset_card_attr", Command_SetCardAttr::newItem);
-	itemNameHash.insert("cmdset_card_counter", Command_SetCardCounter::newItem);
-	itemNameHash.insert("cmdinc_card_counter", Command_IncCardCounter::newItem);
-	itemNameHash.insert("cmdready_start", Command_ReadyStart::newItem);
-	itemNameHash.insert("cmdconcede", Command_Concede::newItem);
-	itemNameHash.insert("cmdinc_counter", Command_IncCounter::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("cmdreveal_cards", Command_RevealCards::newItem);
 	itemNameHash.insert("game_eventconnection_state_changed", Event_ConnectionStateChanged::newItem);
 	itemNameHash.insert("game_eventsay", Event_Say::newItem);
 	itemNameHash.insert("game_eventleave", Event_Leave::newItem);
@@ -587,7 +264,4 @@ void ProtocolItem::initializeHashAuto()
 	itemNameHash.insert("game_event_contextundo_draw", Context_UndoDraw::newItem);
 	itemNameHash.insert("game_event_contextmove_card", Context_MoveCard::newItem);
 	itemNameHash.insert("game_event_contextmulligan", Context_Mulligan::newItem);
-	itemNameHash.insert("cmdupdate_server_message", Command_UpdateServerMessage::newItem);
-	itemNameHash.insert("cmdshutdown_server", Command_ShutdownServer::newItem);
-	itemNameHash.insert("cmdban_from_server", Command_BanFromServer::newItem);
 }

common/protocol_items.dat

-0:ping
-0:login:s,username:s,password
-0:message:s,user_name:s,text
-0:list_users
-0:get_games_of_user:s,user_name
-0:get_user_info:s,user_name
-0:add_to_list:s,list:s,user_name
-0:remove_from_list:s,list:s,user_name
-0:deck_list
-0:deck_new_dir:s,path:s,dir_name
-0:deck_del_dir:s,path
-0:deck_del:i,deck_id
-0:deck_download:i,deck_id
-0:list_rooms
-0:join_room:i,room_id
-1:leave_room
-1:room_say:s,message
-1:join_game:i,game_id:s,password:b,spectator:b,override_restrictions
-2:kick_from_game:i,player_id
-2:leave_game
-2:say:s,message
-2:shuffle
-2:mulligan
-2:roll_die:i,sides
-2:draw_cards:i,number
-2:undo_draw
-2:flip_card:s,zone:i,card_id:b,face_down
-2:attach_card:s,start_zone:i,card_id:i,target_player_id:s,target_zone:i,target_card_id
-2:create_token:s,zone:s,card_name:s,color:s,pt:s,annotation:b,destroy:i,x:i,y
-2:create_arrow:i,start_player_id:s,start_zone:i,start_card_id:i,target_player_id:s,target_zone:i,target_card_id:c,color
-2:delete_arrow:i,arrow_id
-2:set_card_attr:s,zone:i,card_id:s,attr_name:s,attr_value
-2:set_card_counter:s,zone:i,card_id:i,counter_id:i,counter_value
-2:inc_card_counter:s,zone:i,card_id:i,counter_id:i,counter_delta
-2:ready_start:b,ready
-2:concede
-2:inc_counter:i,counter_id:i,delta
-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:reveal_cards:s,zone_name:i,card_id:i,player_id
 3:connection_state_changed:b,connected
 3:say:s,message
 3:leave
@@ -80,6 +35,3 @@
 6:undo_draw
 6:move_card
 6:mulligan:i,number
-7:update_server_message
-7:shutdown_server:s,reason:i,minutes
-8:ban_from_server:s,user_name:s,address:i,minutes:s,reason

common/server_cardzone.cpp

@@ -24,6 +24,7 @@
 #include <QSet>
 #include <QDebug>
 #include "server_game.h"
+#include "pb/game_commands.pb.h"
 
 Server_CardZone::Server_CardZone(Server_Player *_player, const QString &_name, bool _has_coords, ZoneType _type)
 	: player(_player), name(_name), has_coords(_has_coords), type(_type), cardsBeingLookedAt(0)
@@ -159,20 +160,21 @@ bool Server_CardZone::isColumnEmpty(int x, int y) const
 	return !coordMap.contains((x / 3) * 3);
 }
 
-void Server_CardZone::moveCard(CommandContainer *cont, QMap<int, Server_Card *> &coordMap, Server_Card *card, int x, int y)
+void Server_CardZone::moveCard(BlaContainer *bla, QMap<int, Server_Card *> &coordMap, Server_Card *card, int x, int y)
 {
 	QMutexLocker locker(&player->getGame()->gameMutex);
 	
 	coordMap.remove(card->getY() * 10000 + card->getX());
 	
-	CardToMove *cardToMove = new CardToMove(card->getId());
-	player->moveCard(cont, this, QList<CardToMove *>() << cardToMove, this, x, y, card->getFaceDown(), false);
+	CardToMove *cardToMove = new CardToMove;
+	cardToMove->set_card_id(card->getId());
+	player->moveCard(bla, this, QList<const CardToMove *>() << cardToMove, this, x, y, card->getFaceDown(), false);
 	delete cardToMove;
 	
 	coordMap.insert(y * 10000 + x, card);
 }
 
-void Server_CardZone::fixFreeSpaces(CommandContainer *cont)
+void Server_CardZone::fixFreeSpaces(BlaContainer *bla)
 {
 	QMutexLocker locker(&player->getGame()->gameMutex);
 	
@@ -191,15 +193,15 @@ void Server_CardZone::fixFreeSpaces(CommandContainer *cont)
 		
 		if (!coordMap.contains(y * 10000 + baseX)) {
 			if (coordMap.contains(y * 10000 + baseX + 1))
-				moveCard(cont, coordMap, coordMap.value(y * 10000 + baseX + 1), baseX, y);
+				moveCard(bla, coordMap, coordMap.value(y * 10000 + baseX + 1), baseX, y);
 			else if (coordMap.contains(y * 10000 + baseX + 2)) {
-				moveCard(cont, coordMap, coordMap.value(y * 10000 + baseX + 2), baseX, y);
+				moveCard(bla, coordMap, coordMap.value(y * 10000 + baseX + 2), baseX, y);
 				continue;
 			} else
 				continue;
 		}
 		if (!coordMap.contains(y * 10000 + baseX + 1) && coordMap.contains(y * 10000 + baseX + 2))
-			moveCard(cont, coordMap, coordMap.value(y * 10000 + baseX + 2), baseX + 1, y);
+			moveCard(bla, coordMap, coordMap.value(y * 10000 + baseX + 2), baseX + 1, y);
 	}
 }
 

common/server_cardzone.h

@@ -27,7 +27,7 @@
 class Server_Card;
 class Server_Player;
 class Server_Game;
-class CommandContainer;
+class BlaContainer;
 
 class Server_CardZone {
 private:
@@ -53,8 +53,8 @@ public:
 	int getFreeGridColumn(int x, int y, const QString &cardName) const;
 	bool isColumnEmpty(int x, int y) const;
 	bool isColumnStacked(int x, int y) const;
-	void fixFreeSpaces(CommandContainer *cont);
-	void moveCard(CommandContainer *cont, QMap<int, Server_Card *> &coordMap, Server_Card *card, int x, int y);
+	void fixFreeSpaces(BlaContainer *bla);
+	void moveCard(BlaContainer *bla, QMap<int, Server_Card *> &coordMap, Server_Card *card, int x, int y);
 	QList<Server_Card *> cards;
 	void insertCard(Server_Card *card, int x, int y);
 	void shuffle();

common/server_player.cpp

@@ -8,6 +8,7 @@
 #include "protocol.h"
 #include "protocol_items.h"
 #include "decklist.h"
+#include "pb/game_commands.pb.h"
 #include <QDebug>
 
 Server_Player::Server_Player(Server_Game *_game, int _playerId, ServerInfo_User *_userInfo, bool _spectator, Server_ProtocolHandler *_handler)
@@ -243,7 +244,7 @@ bool Server_Player::deleteCounter(int counterId)
 	return true;
 }
 
-ResponseCode Server_Player::drawCards(CommandContainer *cont, int number)
+ResponseCode Server_Player::drawCards(BlaContainer *bla, int number)
 {
 	QMutexLocker locker(&game->gameMutex);
 	
@@ -261,14 +262,14 @@ ResponseCode Server_Player::drawCards(CommandContainer *cont, int number)
 		cardListPrivate.append(new ServerInfo_Card(card->getId(), card->getName()));
 		cardListOmniscient.append(new ServerInfo_Card(card->getId(), card->getName()));
 	}
-	cont->enqueueGameEventPrivate(new Event_DrawCards(playerId, cardListPrivate.size(), cardListPrivate), game->getGameId());
-	cont->enqueueGameEventOmniscient(new Event_DrawCards(playerId, cardListOmniscient.size(), cardListOmniscient), game->getGameId());
-	cont->enqueueGameEventPublic(new Event_DrawCards(playerId, cardListPrivate.size()), game->getGameId());
+	bla->enqueueGameEventPrivate(new Event_DrawCards(playerId, cardListPrivate.size(), cardListPrivate), game->getGameId());
+	bla->enqueueGameEventOmniscient(new Event_DrawCards(playerId, cardListOmniscient.size(), cardListOmniscient), game->getGameId());
+	bla->enqueueGameEventPublic(new Event_DrawCards(playerId, cardListPrivate.size()), game->getGameId());
 
 	return RespOk;
 }
 
-ResponseCode Server_Player::undoDraw(CommandContainer *cont)
+ResponseCode Server_Player::undoDraw(BlaContainer *bla)
 {
 	QMutexLocker locker(&game->gameMutex);
 	
@@ -276,13 +277,14 @@ ResponseCode Server_Player::undoDraw(CommandContainer *cont)
 		return RespContextError;
 	
 	ResponseCode retVal;
-	CardToMove *cardToMove = new CardToMove(lastDrawList.takeLast());
-	retVal = moveCard(cont, zones.value("hand"), QList<CardToMove *>() << cardToMove, zones.value("deck"), 0, 0, false, true);
+	CardToMove *cardToMove = new CardToMove;
+	cardToMove->set_card_id(lastDrawList.takeLast());
+	retVal = moveCard(bla, zones.value("hand"), QList<const CardToMove *>() << cardToMove, zones.value("deck"), 0, 0, false, true);
 	delete cardToMove;
 	return retVal;
 }
 
-ResponseCode Server_Player::moveCard(CommandContainer *cont, const QString &_startZone, const QList<CardToMove *> &_cards, int targetPlayerId, const QString &_targetZone, int x, int y)
+ResponseCode Server_Player::moveCard(BlaContainer *bla, const QString &_startZone, const QList<const CardToMove *> &_cards, int targetPlayerId, const QString &_targetZone, int x, int y)
 {
 	QMutexLocker locker(&game->gameMutex);
 	
@@ -294,7 +296,7 @@ ResponseCode Server_Player::moveCard(CommandContainer *cont, const QString &_sta
 	if ((!startzone) || (!targetzone))
 		return RespNameNotFound;
 	
-	return moveCard(cont, startzone, _cards, targetzone, x, y);
+	return moveCard(bla, startzone, _cards, targetzone, x, y);
 }
 
 class Server_Player::MoveCardCompareFunctor {
@@ -318,7 +320,7 @@ public:
 	}
 };
 
-ResponseCode Server_Player::moveCard(CommandContainer *cont, Server_CardZone *startzone, const QList<CardToMove *> &_cards, Server_CardZone *targetzone, int x, int y, bool fixFreeSpaces, bool undoingDraw)
+ResponseCode Server_Player::moveCard(BlaContainer *bla, Server_CardZone *startzone, const QList<const CardToMove *> &_cards, Server_CardZone *targetzone, int x, int y, bool fixFreeSpaces, bool undoingDraw)
 {
 	QMutexLocker locker(&game->gameMutex);
 	
@@ -330,10 +332,10 @@ ResponseCode Server_Player::moveCard(CommandContainer *cont, Server_CardZone *st
 		x = targetzone->cards.size();
 	
 	QList<QPair<Server_Card *, int> > cardsToMove;
-	QMap<Server_Card *, CardToMove *> cardProperties;
+	QMap<Server_Card *, const CardToMove *> cardProperties;
 	for (int i = 0; i < _cards.size(); ++i) {
 		int position;
-		Server_Card *card = startzone->getCard(_cards[i]->getCardId(), &position);
+		Server_Card *card = startzone->getCard(_cards[i]->card_id(), &position);
 		if (!card)
 			return RespNameNotFound;
 		if (!card->getAttachedCards().isEmpty() && !targetzone->isColumnEmpty(x, y))
@@ -349,7 +351,7 @@ ResponseCode Server_Player::moveCard(CommandContainer *cont, Server_CardZone *st
 	int xIndex = -1;
 	for (int cardIndex = 0; cardIndex < cardsToMove.size(); ++cardIndex) {
 		Server_Card *card = cardsToMove[cardIndex].first;
-		CardToMove *thisCardProperties = cardProperties.value(card);
+		const CardToMove *thisCardProperties = cardProperties.value(card);
 		int originalPosition = cardsToMove[cardIndex].second;
 		int position = startzone->removeCard(card);
 		if (startzone->getName() == "hand") {
@@ -380,7 +382,7 @@ ResponseCode Server_Player::moveCard(CommandContainer *cont, Server_CardZone *st
 			// Make a copy of the list because the original one gets modified during the loop
 			QList<Server_Card *> attachedCards = card->getAttachedCards();
 			for (int i = 0; i < attachedCards.size(); ++i)
-				attachedCards[i]->getZone()->getPlayer()->unattachCard(cont, attachedCards[i]);
+				attachedCards[i]->getZone()->getPlayer()->unattachCard(bla, attachedCards[i]);
 		}
 		
 		if (startzone != targetzone) {
@@ -400,9 +402,9 @@ ResponseCode Server_Player::moveCard(CommandContainer *cont, Server_CardZone *st
 		}
 		
 		if (card->getDestroyOnZoneChange() && (startzone->getName() != targetzone->getName())) {
-			cont->enqueueGameEventPrivate(new Event_DestroyCard(getPlayerId(), startzone->getName(), card->getId()), game->getGameId(), -1, new Context_MoveCard);
-			cont->enqueueGameEventOmniscient(new Event_DestroyCard(getPlayerId(), startzone->getName(), card->getId()), game->getGameId(), new Context_MoveCard);
-			cont->enqueueGameEventPublic(new Event_DestroyCard(getPlayerId(), startzone->getName(), card->getId()), game->getGameId(), new Context_MoveCard);
+			bla->enqueueGameEventPrivate(new Event_DestroyCard(getPlayerId(), startzone->getName(), card->getId()), game->getGameId(), -1, new Context_MoveCard);
+			bla->enqueueGameEventOmniscient(new Event_DestroyCard(getPlayerId(), startzone->getName(), card->getId()), game->getGameId(), new Context_MoveCard);
+			bla->enqueueGameEventPublic(new Event_DestroyCard(getPlayerId(), startzone->getName(), card->getId()), game->getGameId(), new Context_MoveCard);
 			card->deleteLater();
 		} else {
 			if (!targetzone->hasCoords()) {
@@ -416,8 +418,8 @@ ResponseCode Server_Player::moveCard(CommandContainer *cont, Server_CardZone *st
 			bool targetBeingLookedAt = (targetzone->getType() != HiddenZone) || (targetzone->getCardsBeingLookedAt() > newX) || (targetzone->getCardsBeingLookedAt() == -1);
 			bool sourceBeingLookedAt = (startzone->getType() != HiddenZone) || (startzone->getCardsBeingLookedAt() > position) || (startzone->getCardsBeingLookedAt() == -1);
 		
-			bool targetHiddenToPlayer = thisCardProperties->getFaceDown() || !targetBeingLookedAt;
-			bool targetHiddenToOthers = thisCardProperties->getFaceDown() || (targetzone->getType() != PublicZone);
+			bool targetHiddenToPlayer = thisCardProperties->face_down() || !targetBeingLookedAt;
+			bool targetHiddenToOthers = thisCardProperties->face_down() || (targetzone->getType() != PublicZone);
 			bool sourceHiddenToPlayer = card->getFaceDown() || !sourceBeingLookedAt;
 			bool sourceHiddenToOthers = card->getFaceDown() || (startzone->getType() != PublicZone);
 		
@@ -428,9 +430,9 @@ ResponseCode Server_Player::moveCard(CommandContainer *cont, Server_CardZone *st
 				publicCardName = card->getName();
 		
 			int oldCardId = card->getId();
-			if (thisCardProperties->getFaceDown() || (targetzone->getPlayer() != startzone->getPlayer()))
+			if (thisCardProperties->face_down() || (targetzone->getPlayer() != startzone->getPlayer()))
 				card->setId(targetzone->getPlayer()->newCardId());
-			card->setFaceDown(thisCardProperties->getFaceDown());
+			card->setFaceDown(thisCardProperties->face_down());
 		
 			// The player does not get to see which card he moved if it moves between two parts of hidden zones which
 			// are not being looked at.
@@ -444,8 +446,8 @@ ResponseCode Server_Player::moveCard(CommandContainer *cont, Server_CardZone *st
 			int privatePosition = -1;
 			if (startzone->getType() == HiddenZone)
 				privatePosition = position;
-			cont->enqueueGameEventPrivate(new Event_MoveCard(getPlayerId(), privateOldCardId, privateCardName, startzone->getName(), privatePosition, targetzone->getPlayer()->getPlayerId(), targetzone->getName(), newX, y, privateNewCardId, thisCardProperties->getFaceDown()), game->getGameId(), -1, undoingDraw ? static_cast<GameEventContext *>(new Context_UndoDraw) : static_cast<GameEventContext *>(new Context_MoveCard));
-			cont->enqueueGameEventOmniscient(new Event_MoveCard(getPlayerId(), privateOldCardId, privateCardName, startzone->getName(), privatePosition, targetzone->getPlayer()->getPlayerId(), targetzone->getName(), newX, y, privateNewCardId, thisCardProperties->getFaceDown()), game->getGameId(), undoingDraw ? static_cast<GameEventContext *>(new Context_UndoDraw) : static_cast<GameEventContext *>(new Context_MoveCard));
+			bla->enqueueGameEventPrivate(new Event_MoveCard(getPlayerId(), privateOldCardId, privateCardName, startzone->getName(), privatePosition, targetzone->getPlayer()->getPlayerId(), targetzone->getName(), newX, y, privateNewCardId, thisCardProperties->face_down()), game->getGameId(), -1, undoingDraw ? static_cast<GameEventContext *>(new Context_UndoDraw) : static_cast<GameEventContext *>(new Context_MoveCard));
+			bla->enqueueGameEventOmniscient(new Event_MoveCard(getPlayerId(), privateOldCardId, privateCardName, startzone->getName(), privatePosition, targetzone->getPlayer()->getPlayerId(), targetzone->getName(), newX, y, privateNewCardId, thisCardProperties->face_down()), game->getGameId(), undoingDraw ? static_cast<GameEventContext *>(new Context_UndoDraw) : static_cast<GameEventContext *>(new Context_MoveCard));
 			
 			// Other players do not get to see the start and/or target position of the card if the respective
 			// part of the zone is being looked at. The information is not needed anyway because in hidden zones,
@@ -459,38 +461,40 @@ ResponseCode Server_Player::moveCard(CommandContainer *cont, Server_CardZone *st
 				newX = -1;
 		
 			if ((startzone->getType() == PublicZone) || (targetzone->getType() == PublicZone))
-				cont->enqueueGameEventPublic(new Event_MoveCard(getPlayerId(), oldCardId, publicCardName, startzone->getName(), position, targetzone->getPlayer()->getPlayerId(), targetzone->getName(), newX, y, card->getId(), thisCardProperties->getFaceDown()), game->getGameId(), undoingDraw ? static_cast<GameEventContext *>(new Context_UndoDraw) : static_cast<GameEventContext *>(new Context_MoveCard));
+				bla->enqueueGameEventPublic(new Event_MoveCard(getPlayerId(), oldCardId, publicCardName, startzone->getName(), position, targetzone->getPlayer()->getPlayerId(), targetzone->getName(), newX, y, card->getId(), thisCardProperties->face_down()), game->getGameId(), undoingDraw ? static_cast<GameEventContext *>(new Context_UndoDraw) : static_cast<GameEventContext *>(new Context_MoveCard));
 			else
-				cont->enqueueGameEventPublic(new Event_MoveCard(getPlayerId(), -1, QString(), startzone->getName(), position, targetzone->getPlayer()->getPlayerId(), targetzone->getName(), newX, y, -1, false), game->getGameId(), undoingDraw ? static_cast<GameEventContext *>(new Context_UndoDraw) : static_cast<GameEventContext *>(new Context_MoveCard));
+				bla->enqueueGameEventPublic(new Event_MoveCard(getPlayerId(), -1, QString(), startzone->getName(), position, targetzone->getPlayer()->getPlayerId(), targetzone->getName(), newX, y, -1, false), game->getGameId(), undoingDraw ? static_cast<GameEventContext *>(new Context_UndoDraw) : static_cast<GameEventContext *>(new Context_MoveCard));
 			
-			if (thisCardProperties->getTapped())
-				setCardAttrHelper(cont, targetzone->getName(), card->getId(), "tapped", "1");
-			if (!thisCardProperties->getPT().isEmpty() && !thisCardProperties->getFaceDown())
-				setCardAttrHelper(cont, targetzone->getName(), card->getId(), "pt", thisCardProperties->getPT());
+			if (thisCardProperties->tapped())
+				setCardAttrHelper(bla, targetzone->getName(), card->getId(), "tapped", "1");
+			QString ptString = QString::fromStdString(thisCardProperties->pt());
+			if (!ptString.isEmpty() && !thisCardProperties->face_down())
+				setCardAttrHelper(bla, targetzone->getName(), card->getId(), "pt", ptString);
 		}
 	}
 	if (startzone->hasCoords() && fixFreeSpaces)
-		startzone->fixFreeSpaces(cont);
+		startzone->fixFreeSpaces(bla);
 	
 	return RespOk;
 }
 
-void Server_Player::unattachCard(CommandContainer *cont, Server_Card *card)
+void Server_Player::unattachCard(BlaContainer *bla, Server_Card *card)
 {
 	QMutexLocker locker(&game->gameMutex);
 	
 	Server_CardZone *zone = card->getZone();
 	
 	card->setParentCard(0);
-	cont->enqueueGameEventPrivate(new Event_AttachCard(getPlayerId(), zone->getName(), card->getId(), -1, QString(), -1), game->getGameId());
-	cont->enqueueGameEventPublic(new Event_AttachCard(getPlayerId(), zone->getName(), card->getId(), -1, QString(), -1), game->getGameId());
+	bla->enqueueGameEventPrivate(new Event_AttachCard(getPlayerId(), zone->getName(), card->getId(), -1, QString(), -1), game->getGameId());
+	bla->enqueueGameEventPublic(new Event_AttachCard(getPlayerId(), zone->getName(), card->getId(), -1, QString(), -1), game->getGameId());
 	
-	CardToMove *cardToMove = new CardToMove(card->getId());
-	moveCard(cont, zone, QList<CardToMove *>() << cardToMove, zone, -1, card->getY(), card->getFaceDown());
+	CardToMove *cardToMove = new CardToMove;
+	cardToMove->set_card_id(card->getId());
+	moveCard(bla, zone, QList<const CardToMove *>() << cardToMove, zone, -1, card->getY(), card->getFaceDown());
 	delete cardToMove;
 }
 
-ResponseCode Server_Player::setCardAttrHelper(CommandContainer *cont, const QString &zoneName, int cardId, const QString &attrName, const QString &attrValue)
+ResponseCode Server_Player::setCardAttrHelper(BlaContainer *bla, const QString &zoneName, int cardId, const QString &attrName, const QString &attrValue)
 {
 	QMutexLocker locker(&game->gameMutex);
 	
@@ -516,9 +520,9 @@ ResponseCode Server_Player::setCardAttrHelper(CommandContainer *cont, const QStr
 		if (result.isNull())
 			return RespInvalidCommand;
 	}
-	cont->enqueueGameEventPrivate(new Event_SetCardAttr(getPlayerId(), zone->getName(), cardId, attrName, result), game->getGameId());
-	cont->enqueueGameEventPublic(new Event_SetCardAttr(getPlayerId(), zone->getName(), cardId, attrName, result), game->getGameId());
-	cont->enqueueGameEventOmniscient(new Event_SetCardAttr(getPlayerId(), zone->getName(), cardId, attrName, result), game->getGameId());
+	bla->enqueueGameEventPrivate(new Event_SetCardAttr(getPlayerId(), zone->getName(), cardId, attrName, result), game->getGameId());
+	bla->enqueueGameEventPublic(new Event_SetCardAttr(getPlayerId(), zone->getName(), cardId, attrName, result), game->getGameId());
+	bla->enqueueGameEventOmniscient(new Event_SetCardAttr(getPlayerId(), zone->getName(), cardId, attrName, result), game->getGameId());
 	return RespOk;
 }