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

parameter validation cleanup

Browse source
This commit is contained in:
Max-Wilhelm Bruker 2009-04-09 14:18:11 +02:00
parent 792a400a3d
commit 503d42519a
2 changed files with 237 additions and 218 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

401
servatrice/src/serversocket.cpp
View file

@ -187,43 +187,65 @@ void ServerSocket::readClient()
} }
const ServerSocket::CommandProperties ServerSocket::commandList[ServerSocket::numberCommands] = { const ServerSocket::CommandProperties ServerSocket::commandList[ServerSocket::numberCommands] = {
{"login", 2, false, false, false, &ServerSocket::cmdLogin}, {"login", false, false, false, QList<QVariant::Type>() << QVariant::String
{"list_games", 0, true, false, false, &ServerSocket::cmdListGames}, << QVariant::String, &ServerSocket::cmdLogin},
{"create_game", 4, true, false, false, &ServerSocket::cmdCreateGame}, {"list_games", true, false, false, QList<QVariant::Type>(), &ServerSocket::cmdListGames},
{"join_game", 2, true, false, false, &ServerSocket::cmdJoinGame}, {"create_game", true, false, false, QList<QVariant::Type>() << QVariant::String
{"leave_game", 0, true, true, false, &ServerSocket::cmdLeaveGame}, << QVariant::String
{"list_players", 0, true, true, false, &ServerSocket::cmdListPlayers}, << QVariant::String
{"say", 1, true, true, false, &ServerSocket::cmdSay}, << QVariant::Int, &ServerSocket::cmdCreateGame},
{"submit_deck", 0, true, true, false, &ServerSocket::cmdSubmitDeck}, {"join_game", true, false, false, QList<QVariant::Type>() << QVariant::String
{"ready_start", 0, true, true, false, &ServerSocket::cmdReadyStart}, << QVariant::String, &ServerSocket::cmdJoinGame},
{"shuffle", 0, true, true, true, &ServerSocket::cmdShuffle}, {"leave_game", true, true, false, QList<QVariant::Type>(), &ServerSocket::cmdLeaveGame},
{"draw_cards", 1, true, true, true, &ServerSocket::cmdDrawCards}, {"list_players", true, true, false, QList<QVariant::Type>(), &ServerSocket::cmdListPlayers},
{"move_card", 6, true, true, true, &ServerSocket::cmdMoveCard}, {"say", true, true, false, QList<QVariant::Type>() << QVariant::String, &ServerSocket::cmdSay},
{"create_token", 5, true, true, true, &ServerSocket::cmdCreateToken}, {"submit_deck", true, true, false, QList<QVariant::Type>(), &ServerSocket::cmdSubmitDeck},
{"set_card_attr", 4, true, true, true, &ServerSocket::cmdSetCardAttr}, {"ready_start", true, true, false, QList<QVariant::Type>(), &ServerSocket::cmdReadyStart},
{"inc_counter", 2, true, true, true, &ServerSocket::cmdIncCounter}, {"shuffle", true, true, true, QList<QVariant::Type>(), &ServerSocket::cmdShuffle},
{"set_counter", 2, true, true, true, &ServerSocket::cmdSetCounter}, {"draw_cards", true, true, true, QList<QVariant::Type>() << QVariant::Int, &ServerSocket::cmdDrawCards},
{"del_counter", 1, true, true, true, &ServerSocket::cmdDelCounter}, {"move_card", true, true, true, QList<QVariant::Type>() << QVariant::Int
{"list_counters", 2, true, true, true, &ServerSocket::cmdListCounters}, << QVariant::String
{"list_zones", 1, true, true, true, &ServerSocket::cmdListZones}, << QVariant::String
{"dump_zone", 3, true, true, true, &ServerSocket::cmdDumpZone}, << QVariant::Int
{"roll_dice", 1, true, true, true, &ServerSocket::cmdRollDice}, << QVariant::Int
{"set_active_player", 1, true, true, true, &ServerSocket::cmdSetActivePlayer}, << QVariant::Bool, &ServerSocket::cmdMoveCard},
{"set_active_phase", 1, true, true, true, &ServerSocket::cmdSetActivePhase} {"create_token", true, true, true, QList<QVariant::Type>() << QVariant::String
<< QVariant::String
<< QVariant::String
<< QVariant::Int
<< QVariant::Int, &ServerSocket::cmdCreateToken},
{"set_card_attr", true, true, true, QList<QVariant::Type>() << QVariant::String
<< QVariant::Int
<< QVariant::String
<< QVariant::String, &ServerSocket::cmdSetCardAttr},
{"inc_counter", true, true, true, QList<QVariant::Type>() << QVariant::String
<< QVariant::Int, &ServerSocket::cmdIncCounter},
{"set_counter", true, true, true, QList<QVariant::Type>() << QVariant::String
<< QVariant::Int, &ServerSocket::cmdSetCounter},
{"del_counter", true, true, true, QList<QVariant::Type>() << QVariant::String, &ServerSocket::cmdDelCounter},
{"list_counters", true, true, true, QList<QVariant::Type>() << QVariant::Int, &ServerSocket::cmdListCounters},
{"list_zones", true, true, true, QList<QVariant::Type>() << QVariant::Int, &ServerSocket::cmdListZones},
{"dump_zone", true, true, true, QList<QVariant::Type>() << QVariant::Int
<< QVariant::String
<< QVariant::Int, &ServerSocket::cmdDumpZone},
{"roll_dice", true, true, true, QList<QVariant::Type>() << QVariant::Int, &ServerSocket::cmdRollDice},
{"set_active_player", true, true, true, QList<QVariant::Type>() << QVariant::Int, &ServerSocket::cmdSetActivePlayer},
{"set_active_phase", true, true, true, QList<QVariant::Type>() << QVariant::Int, &ServerSocket::cmdSetActivePhase}
}; };
ReturnMessage::ReturnCode ServerSocket::cmdLogin(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdLogin(const QList<QVariant> &params)
{ {
authState = server->checkUserPassword(params[0], params[1]); authState = server->checkUserPassword(params[0].toString(), params[1].toString());
if (authState == PasswordWrong) if (authState == PasswordWrong)
return ReturnMessage::ReturnPasswordWrong; return ReturnMessage::ReturnPasswordWrong;
PlayerName = params[0]; PlayerName = params[0].toString();
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdListGames(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdListGames(const QList<QVariant> &params)
{ {
Q_UNUSED(params);
QList<ServerGame *> gameList = server->listOpenGames(); QList<ServerGame *> gameList = server->listOpenGames();
QListIterator<ServerGame *> gameListIterator(gameList); QListIterator<ServerGame *> gameListIterator(gameList);
QStringList result; QStringList result;
@ -241,11 +263,11 @@ ReturnMessage::ReturnCode ServerSocket::cmdListGames(const QStringList &params)
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdCreateGame(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdCreateGame(const QList<QVariant> &params)
{ {
QString name = params[0]; QString name = params[0].toString();
QString description = params[1]; QString description = params[1].toString();
QString password = params[2]; QString password = params[2].toString();
int maxPlayers = params[3].toInt(); int maxPlayers = params[3].toInt();
if (server->getGame(name)) if (server->getGame(name))
return ReturnMessage::ReturnNameNotFound; return ReturnMessage::ReturnNameNotFound;
@ -254,10 +276,10 @@ ReturnMessage::ReturnCode ServerSocket::cmdCreateGame(const QStringList &params)
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdJoinGame(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdJoinGame(const QList<QVariant> &params)
{ {
QString name = params[0]; QString name = params[0].toString();
QString password = params[1]; QString password = params[1].toString();
if (!server->checkGamePassword(name, password)) if (!server->checkGamePassword(name, password))
return ReturnMessage::ReturnPasswordWrong; return ReturnMessage::ReturnPasswordWrong;
leaveGame(); leaveGame();
@ -265,53 +287,55 @@ ReturnMessage::ReturnCode ServerSocket::cmdJoinGame(const QStringList &params)
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdLeaveGame(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdLeaveGame(const QList<QVariant> &params)
{ {
Q_UNUSED(params);
leaveGame(); leaveGame();
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdListPlayers(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdListPlayers(const QList<QVariant> &params)
{ {
Q_UNUSED(params);
remsg->sendList(game->getPlayerNames()); remsg->sendList(game->getPlayerNames());
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdSay(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdSay(const QList<QVariant> &params)
{ {
emit broadcastEvent(QString("say|%1").arg(params[0]), this); emit broadcastEvent(QString("say|%1").arg(params[0].toString()), this);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdSubmitDeck(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdSubmitDeck(const QList<QVariant> &params)
{ {
Q_UNUSED(params);
PlayerStatus = StatusSubmitDeck; PlayerStatus = StatusSubmitDeck;
DeckList.clear(); DeckList.clear();
SideboardList.clear(); SideboardList.clear();
return ReturnMessage::ReturnNothing; return ReturnMessage::ReturnNothing;
} }
ReturnMessage::ReturnCode ServerSocket::cmdReadyStart(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdReadyStart(const QList<QVariant> &params)
{ {
Q_UNUSED(params);
PlayerStatus = StatusReadyStart; PlayerStatus = StatusReadyStart;
emit broadcastEvent(QString("ready_start"), this); emit broadcastEvent(QString("ready_start"), this);
game->startGameIfReady(); game->startGameIfReady();
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdShuffle(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdShuffle(const QList<QVariant> &params)
{ {
Q_UNUSED(params);
getZone("deck")->shuffle(game->rnd); getZone("deck")->shuffle(game->rnd);
emit broadcastEvent("shuffle", this); emit broadcastEvent("shuffle", this);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdDrawCards(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdDrawCards(const QList<QVariant> &params)
{ {
bool ok; int number = params[0].toInt();
int number = params[0].toInt(&ok);
if (!ok)
return ReturnMessage::ReturnSyntaxError;
PlayerZone *deck = getZone("deck"); PlayerZone *deck = getZone("deck");
PlayerZone *hand = getZone("hand"); PlayerZone *hand = getZone("hand");
if (deck->cards.size() < number) if (deck->cards.size() < number)
@ -328,174 +352,156 @@ ReturnMessage::ReturnCode ServerSocket::cmdDrawCards(const QStringList &params)
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdMoveCard(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdMoveCard(const QList<QVariant> &params)
{ {
// ID Karte, Startzone, Zielzone, Koordinaten X, Y, Facedown // ID Karte, Startzone, Zielzone, Koordinaten X, Y, Facedown
bool ok; int cardid = params[0].toInt();
int cardid = params[0].toInt(&ok); PlayerZone *startzone = getZone(params[1].toString());
if (!ok) PlayerZone *targetzone = getZone(params[2].toString());
return ReturnMessage::ReturnSyntaxError; if ((!startzone) || (!targetzone))
PlayerZone *startzone = getZone(params[1]); return ReturnMessage::ReturnContextError;
PlayerZone *targetzone = getZone(params[2]);
if ((!startzone) || (!targetzone))
return ReturnMessage::ReturnContextError;
int position = -1; int position = -1;
Card *card = startzone->getCard(cardid, true, &position); Card *card = startzone->getCard(cardid, true, &position);
if (!card) if (!card)
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
int x = params[3].toInt(&ok); int x = params[3].toInt();
if (!ok) int y = 0;
return ReturnMessage::ReturnSyntaxError; if (targetzone->hasCoords())
int y = 0; y = params[4].toInt();
if (targetzone->hasCoords()) { bool facedown = params[5].toBool();
y = params[4].toInt(&ok);
if (!ok)
return ReturnMessage::ReturnSyntaxError;
}
bool facedown = params[5].toInt(&ok);
if (!ok)
return ReturnMessage::ReturnSyntaxError;
targetzone->insertCard(card, x, y); targetzone->insertCard(card, x, y);
QString privateCardName, publicCardName; QString privateCardName, publicCardName;
if (facedown) if (facedown)
card->setId(newCardId()); card->setId(newCardId());
if ((!facedown && !card->getFaceDown()) if ((!facedown && !card->getFaceDown())
|| (card->getFaceDown() && !facedown && startzone->isPublic() && targetzone->isPublic())) || (card->getFaceDown() && !facedown && startzone->isPublic() && targetzone->isPublic()))
publicCardName = card->getName(); publicCardName = card->getName();
if ((!facedown && !card->getFaceDown()) if ((!facedown && !card->getFaceDown())
|| (card->getFaceDown() && !facedown && startzone->isPublic() && targetzone->isPublic()) || (card->getFaceDown() && !facedown && startzone->isPublic() && targetzone->isPublic())
|| (!facedown && targetzone->isPrivate())) || (!facedown && targetzone->isPrivate()))
privateCardName = card->getName(); privateCardName = card->getName();
card->setFaceDown(facedown); card->setFaceDown(facedown);
msg(QString("private|||move_card|%1|%2|%3|%4|%5|%6|%7|%8").arg(card->getId()) msg(QString("private|||move_card|%1|%2|%3|%4|%5|%6|%7|%8").arg(card->getId())
.arg(privateCardName) .arg(privateCardName)
.arg(startzone->getName()) .arg(startzone->getName())
.arg(position) .arg(position)
.arg(targetzone->getName()) .arg(targetzone->getName())
.arg(x) .arg(x)
.arg(y) .arg(y)
.arg(facedown ? 1 : 0)); .arg(facedown ? 1 : 0));
if ((startzone->isPublic()) || (targetzone->isPublic())) if ((startzone->isPublic()) || (targetzone->isPublic()))
emit broadcastEvent(QString("move_card|%1|%2|%3|%4|%5|%6|%7|%8").arg(card->getId()) emit broadcastEvent(QString("move_card|%1|%2|%3|%4|%5|%6|%7|%8").arg(card->getId())
.arg(publicCardName) .arg(publicCardName)
.arg(startzone->getName()) .arg(startzone->getName())
.arg(position) .arg(position)
.arg(targetzone->getName()) .arg(targetzone->getName())
.arg(x) .arg(x)
.arg(y) .arg(y)
.arg(facedown ? 1 : 0), this); .arg(facedown ? 1 : 0), this);
else else
emit broadcastEvent(QString("move_card|||%1|%2|%3|%4|%5|0").arg(startzone->getName()) emit broadcastEvent(QString("move_card|||%1|%2|%3|%4|%5|0").arg(startzone->getName())
.arg(position) .arg(position)
.arg(targetzone->getName()) .arg(targetzone->getName())
.arg(x) .arg(x)
.arg(y), this); .arg(y), this);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdCreateToken(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdCreateToken(const QList<QVariant> &params)
{ {
// zone, cardname, powtough, x, y // zone, cardname, powtough, x, y
// powtough wird erst mal ignoriert // powtough wird erst mal ignoriert
PlayerZone *zone = getZone(params[0]); PlayerZone *zone = getZone(params[0].toString());
if (!zone) if (!zone)
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
QString cardname = params[1]; QString cardname = params[1].toString();
int x = params[3].toInt(); QString powtough = params[2].toString();
int y = params[4].toInt(); int x = params[3].toInt();
int cardid = newCardId(); int y = params[4].toInt();
QString powtough = params[2]; int cardid = newCardId();
Card *card = new Card(cardname, cardid, x, y); Card *card = new Card(cardname, cardid, x, y);
zone->insertCard(card, x, y); zone->insertCard(card, x, y);
emit broadcastEvent(QString("create_token|%1|%2|%3|%4|%5|%6").arg(zone->getName()) emit broadcastEvent(QString("create_token|%1|%2|%3|%4|%5|%6").arg(zone->getName())
.arg(cardid) .arg(cardid)
.arg(cardname) .arg(cardname)
.arg(powtough) .arg(powtough)
.arg(x) .arg(x)
.arg(y), this); .arg(y), this);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdSetCardAttr(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdSetCardAttr(const QList<QVariant> &params)
{ {
// zone, card id, attr name, attr value // zone, card id, attr name, attr value
// card id = -1 => affects all cards in the specified zone // card id = -1 => affects all cards in the specified zone
PlayerZone *zone = getZone(params[0]); PlayerZone *zone = getZone(params[0].toString());
if (!zone) if (!zone)
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
bool ok; int cardid = params[1].toInt();
int cardid = params[1].toInt(&ok); QString aname = params[2].toString();
if (!ok) QString avalue = params[3].toString();
return ReturnMessage::ReturnSyntaxError;
if (cardid == -1) { if (cardid == -1) {
QListIterator<Card *> CardIterator(zone->cards); QListIterator<Card *> CardIterator(zone->cards);
while (CardIterator.hasNext()) while (CardIterator.hasNext())
if (!CardIterator.next()->setAttribute(params[2], params[3], true)) if (!CardIterator.next()->setAttribute(aname, avalue, true))
return ReturnMessage::ReturnSyntaxError; return ReturnMessage::ReturnSyntaxError;
} else { } else {
Card *card = zone->getCard(cardid, false); Card *card = zone->getCard(cardid, false);
if (!card) if (!card)
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
if (!card->setAttribute(params[2], params[3], false)) if (!card->setAttribute(aname, avalue, false))
return ReturnMessage::ReturnSyntaxError; return ReturnMessage::ReturnSyntaxError;
} }
emit broadcastEvent(QString("set_card_attr|%1|%2|%3|%4").arg(zone->getName()).arg(cardid).arg(params[2]).arg(params[3]), this); emit broadcastEvent(QString("set_card_attr|%1|%2|%3|%4").arg(zone->getName()).arg(cardid).arg(aname).arg(avalue), this);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdIncCounter(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdIncCounter(const QList<QVariant> &params)
{ {
Counter *c = getCounter(params[0]); Counter *c = getCounter(params[0].toString());
if (!c) if (!c)
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
bool ok; int delta = params[1].toInt();
int delta = params[1].toInt(&ok);
if (!ok)
return ReturnMessage::ReturnSyntaxError;
c->setCount(c->getCount() + delta); c->setCount(c->getCount() + delta);
emit broadcastEvent(QString("set_counter|%1|%2").arg(params[0]).arg(c->getCount()), this); emit broadcastEvent(QString("set_counter|%1|%2").arg(c->getName()).arg(c->getCount()), this);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdSetCounter(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdSetCounter(const QList<QVariant> &params)
{ {
Counter *c = getCounter(params[0]); Counter *c = getCounter(params[0].toString());
bool ok; int count = params[1].toInt();
int count = params[1].toInt(&ok);
if (!ok)
return ReturnMessage::ReturnSyntaxError;
if (!c) { if (!c) {
c = new Counter(params[0], count); c = new Counter(params[0].toString(), count);
counters << c; counters << c;
} else } else
c->setCount(count); c->setCount(count);
emit broadcastEvent(QString("set_counter|%1|%2").arg(params[0]).arg(count), this); emit broadcastEvent(QString("set_counter|%1|%2").arg(c->getName()).arg(count), this);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdDelCounter(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdDelCounter(const QList<QVariant> &params)
{ {
Counter *c = getCounter(params[0]); Counter *c = getCounter(params[0].toString());
if (!c) if (!c)
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
delete c; delete c;
counters.removeAt(counters.indexOf(c)); counters.removeAt(counters.indexOf(c));
emit broadcastEvent(QString("del_counter|%1").arg(params[0]), this); emit broadcastEvent(QString("del_counter|%1").arg(params[0].toString()), this);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdListCounters(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdListCounters(const QList<QVariant> &params)
{ {
bool ok; int player_id = params[0].toInt();
int player_id = params[0].toInt(&ok);
if (!ok)
return ReturnMessage::ReturnSyntaxError;
ServerSocket *player = game->getPlayer(player_id); ServerSocket *player = game->getPlayer(player_id);
if (!player) if (!player)
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
@ -503,12 +509,9 @@ ReturnMessage::ReturnCode ServerSocket::cmdListCounters(const QStringList &param
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdListZones(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdListZones(const QList<QVariant> &params)
{ {
bool ok; int player_id = params[0].toInt();
int player_id = params[0].toInt(&ok);
if (!ok)
return ReturnMessage::ReturnSyntaxError;
ServerSocket *player = game->getPlayer(player_id); ServerSocket *player = game->getPlayer(player_id);
if (!player) if (!player)
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
@ -516,23 +519,19 @@ ReturnMessage::ReturnCode ServerSocket::cmdListZones(const QStringList &params)
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdDumpZone(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdDumpZone(const QList<QVariant> &params)
{ {
bool ok; int player_id = params[0].toInt();
int player_id = params[0].toInt(&ok); int number_cards = params[2].toInt();
if (!ok)
return ReturnMessage::ReturnSyntaxError;
int number_cards = params[2].toInt(&ok);
if (!ok)
return ReturnMessage::ReturnSyntaxError;
ServerSocket *player = game->getPlayer(player_id); ServerSocket *player = game->getPlayer(player_id);
if (!player) if (!player)
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
PlayerZone *zone = player->getZone(params[1]); PlayerZone *zone = player->getZone(params[1].toString());
if (!zone) if (!zone)
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
if (!(zone->isPublic() || (player_id == PlayerId))) if (!(zone->isPublic() || (player_id == PlayerId)))
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
QListIterator<Card *> card_iterator(zone->cards); QListIterator<Card *> card_iterator(zone->cards);
QStringList result; QStringList result;
for (int i = 0; card_iterator.hasNext() && (i < number_cards || number_cards == 0); i++) { for (int i = 0; card_iterator.hasNext() && (i < number_cards || number_cards == 0); i++) {
@ -555,34 +554,25 @@ ReturnMessage::ReturnCode ServerSocket::cmdDumpZone(const QStringList &params)
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdRollDice(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdRollDice(const QList<QVariant> &params)
{ {
bool ok; int sides = params[0].toInt();
int sides = params[0].toInt(&ok);
if (!ok)
return ReturnMessage::ReturnSyntaxError;
emit broadcastEvent(QString("roll_dice|%1|%2").arg(sides).arg(game->rnd->getNumber(1, sides)), this); emit broadcastEvent(QString("roll_dice|%1|%2").arg(sides).arg(game->rnd->getNumber(1, sides)), this);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdSetActivePlayer(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdSetActivePlayer(const QList<QVariant> &params)
{ {
bool ok; int active_player = params[0].toInt();
int active_player = params[0].toInt(&ok);
if (!ok)
return ReturnMessage::ReturnSyntaxError;
if (!game->getPlayer(active_player)) if (!game->getPlayer(active_player))
return ReturnMessage::ReturnContextError; return ReturnMessage::ReturnContextError;
game->setActivePlayer(active_player); game->setActivePlayer(active_player);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
} }
ReturnMessage::ReturnCode ServerSocket::cmdSetActivePhase(const QStringList &params) ReturnMessage::ReturnCode ServerSocket::cmdSetActivePhase(const QList<QVariant> &params)
{ {
bool ok; int active_phase = params[0].toInt();
int active_phase = params[0].toInt(&ok);
if (!ok)
return ReturnMessage::ReturnSyntaxError;
// XXX Überprüfung, ob die Phase existiert... // XXX Überprüfung, ob die Phase existiert...
game->setActivePhase(active_phase); game->setActivePhase(active_phase);
return ReturnMessage::ReturnOk; return ReturnMessage::ReturnOk;
@ -620,12 +610,39 @@ bool ServerSocket::parseCommand(QString line)
return remsg->send(ReturnMessage::ReturnContextError); return remsg->send(ReturnMessage::ReturnContextError);
if (commandList[i].needsStartedGame && !game->getGameStarted()) if (commandList[i].needsStartedGame && !game->getGameStarted())
return remsg->send(ReturnMessage::ReturnContextError); return remsg->send(ReturnMessage::ReturnContextError);
// Check parameter count // Validate parameters
if (commandList[i].numberParams != params.size()) if (commandList[i].paramTypes.size() != params.size())
return remsg->send(ReturnMessage::ReturnSyntaxError); return remsg->send(ReturnMessage::ReturnSyntaxError);
QList<QVariant> paramList;
for (int j = 0; j < commandList[i].paramTypes.size(); j++)
switch (commandList[i].paramTypes[j]) {
case QVariant::String: {
paramList << QVariant(params[j]);
break;
}
case QVariant::Int: {
bool ok;
int temp = params[j].toInt(&ok);
if (!ok)
return remsg->send(ReturnMessage::ReturnSyntaxError);
paramList << QVariant(temp);
break;
}
case QVariant::Bool: {
if (params[j] == "1")
paramList << QVariant(true);
else if (params[j] == "0")
paramList << QVariant(false);
else
return remsg->send(ReturnMessage::ReturnSyntaxError);
break;
}
default:
paramList << QVariant(params[j]);
}
// Call handler function // Call handler function
CommandHandler handler = commandList[i].handler; CommandHandler handler = commandList[i].handler;
return remsg->send((this->*handler)(params)); return remsg->send((this->*handler)(paramList));
} }
return remsg->send(ReturnMessage::ReturnSyntaxError); return remsg->send(ReturnMessage::ReturnSyntaxError);
} }

52
servatrice/src/serversocket.h
View file

@ -21,6 +21,8 @@
#define SERVERSOCKET_H #define SERVERSOCKET_H
#include <QTcpSocket> #include <QTcpSocket>
#include <QList>
#include <QVariant>
#include "server.h" #include "server.h"
#include "returnmessage.h" #include "returnmessage.h"
@ -44,41 +46,41 @@ signals:
void broadcastEvent(const QString &event, ServerSocket *player); void broadcastEvent(const QString &event, ServerSocket *player);
void startGameIfReady(); void startGameIfReady();
private: private:
typedef ReturnMessage::ReturnCode (ServerSocket::*CommandHandler)(const QStringList &); typedef ReturnMessage::ReturnCode (ServerSocket::*CommandHandler)(const QList<QVariant> &);
struct CommandProperties { struct CommandProperties {
QString name; QString name;
int numberParams;
bool needsLogin; bool needsLogin;
bool needsGame; bool needsGame;
bool needsStartedGame; bool needsStartedGame;
QList<QVariant::Type> paramTypes;
CommandHandler handler; CommandHandler handler;
}; };
static const int numberCommands = 23; static const int numberCommands = 23;
static const CommandProperties commandList[numberCommands]; static const CommandProperties commandList[numberCommands];
ReturnMessage::ReturnCode cmdLogin(const QStringList &params); ReturnMessage::ReturnCode cmdLogin(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdListGames(const QStringList &params); ReturnMessage::ReturnCode cmdListGames(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdCreateGame(const QStringList &params); ReturnMessage::ReturnCode cmdCreateGame(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdJoinGame(const QStringList &params); ReturnMessage::ReturnCode cmdJoinGame(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdLeaveGame(const QStringList &params); ReturnMessage::ReturnCode cmdLeaveGame(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdListPlayers(const QStringList &params); ReturnMessage::ReturnCode cmdListPlayers(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdSay(const QStringList &params); ReturnMessage::ReturnCode cmdSay(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdSubmitDeck(const QStringList &params); ReturnMessage::ReturnCode cmdSubmitDeck(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdReadyStart(const QStringList &params); ReturnMessage::ReturnCode cmdReadyStart(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdShuffle(const QStringList &params); ReturnMessage::ReturnCode cmdShuffle(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdDrawCards(const QStringList &params); ReturnMessage::ReturnCode cmdDrawCards(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdMoveCard(const QStringList &params); ReturnMessage::ReturnCode cmdMoveCard(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdCreateToken(const QStringList &params); ReturnMessage::ReturnCode cmdCreateToken(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdSetCardAttr(const QStringList &params); ReturnMessage::ReturnCode cmdSetCardAttr(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdIncCounter(const QStringList &params); ReturnMessage::ReturnCode cmdIncCounter(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdSetCounter(const QStringList &params); ReturnMessage::ReturnCode cmdSetCounter(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdDelCounter(const QStringList &params); ReturnMessage::ReturnCode cmdDelCounter(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdListCounters(const QStringList &params); ReturnMessage::ReturnCode cmdListCounters(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdListZones(const QStringList &params); ReturnMessage::ReturnCode cmdListZones(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdDumpZone(const QStringList &params); ReturnMessage::ReturnCode cmdDumpZone(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdRollDice(const QStringList &params); ReturnMessage::ReturnCode cmdRollDice(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdSetActivePlayer(const QStringList &params); ReturnMessage::ReturnCode cmdSetActivePlayer(const QList<QVariant> &params);
ReturnMessage::ReturnCode cmdSetActivePhase(const QStringList &params); ReturnMessage::ReturnCode cmdSetActivePhase(const QList<QVariant> &params);
Server *server; Server *server;
ServerGame *game; ServerGame *game;