130 lines
3.9 KiB
C++
130 lines
3.9 KiB
C++
#include "parse_game.h"
|
|
|
|
#include "myassert.h"
|
|
|
|
namespace Parsing
|
|
{
|
|
// This helper function deduces the type and assigns the value with the matching key
|
|
template<class T>
|
|
void extract(boost::json::object const & obj, T & t, std::string_view key)
|
|
{
|
|
t = boost::json::value_to<T>(obj.at(key));
|
|
}
|
|
}
|
|
|
|
namespace Hanabi
|
|
{
|
|
Card tag_invoke(
|
|
boost::json::value_to_tag<Card>, boost::json::value const & jv
|
|
)
|
|
{
|
|
Hanabi::Card card{};
|
|
boost::json::object const & obj = jv.as_object();
|
|
Parsing::extract(obj, card.rank, "rank");
|
|
Parsing::extract(obj, card.suit, "suitIndex");
|
|
card.rank = 5 - card.rank;
|
|
return card;
|
|
}
|
|
|
|
void tag_invoke(boost::json::value_from_tag, boost::json::value & jv, Hanabi::Card const & card)
|
|
{
|
|
jv = {{ "suitIndex", card.suit}
|
|
, {"rank" , card.rank}};
|
|
}
|
|
}
|
|
|
|
namespace Parsing
|
|
{
|
|
|
|
HanabLiveAction tag_invoke(boost::json::value_to_tag<HanabLiveAction>, boost::json::value const & jv)
|
|
{
|
|
HanabLiveAction action{};
|
|
uint8_t type;
|
|
boost::json::object const & obj = jv.as_object();
|
|
|
|
extract(obj, action.target, "target");
|
|
extract(obj, type, "type");
|
|
|
|
action.type = static_cast<Hanabi::ActionType>(type);
|
|
switch (action.type)
|
|
{
|
|
case Hanabi::ActionType::color_clue:
|
|
case Hanabi::ActionType::rank_clue:
|
|
action.type = Hanabi::ActionType::clue;
|
|
break;
|
|
case Hanabi::ActionType::end_game:
|
|
case Hanabi::ActionType::vote_terminate_players:
|
|
case Hanabi::ActionType::vote_terminate:
|
|
action.type = Hanabi::ActionType::end_game;
|
|
break;
|
|
case Hanabi::ActionType::play:
|
|
case Hanabi::ActionType::discard:
|
|
break;
|
|
default:
|
|
throw std::runtime_error(
|
|
"Invalid game format, could not parse action type " + std::to_string(type));
|
|
}
|
|
return action;
|
|
}
|
|
|
|
std::pair<std::vector<Hanabi::Card>, Hanabi::suit_t> parse_deck(const boost::json::value & deck_json)
|
|
{
|
|
auto deck = boost::json::value_to<std::vector<Hanabi::Card>>(deck_json);
|
|
for (auto & card: deck)
|
|
{
|
|
ASSERT(card.rank < 5);
|
|
ASSERT(card.rank >= 0);
|
|
ASSERT(card.suit < 6);
|
|
ASSERT(card.suit >= 0);
|
|
}
|
|
Hanabi::suit_t num_suits = 0;
|
|
for (const auto & card: deck)
|
|
{
|
|
num_suits = std::max(num_suits, card.suit);
|
|
}
|
|
return {deck, num_suits + 1};
|
|
}
|
|
|
|
std::vector<HanabLiveAction> parse_actions(const boost::json::value & action_json)
|
|
{
|
|
return boost::json::value_to<std::vector<HanabLiveAction>>(action_json);
|
|
}
|
|
|
|
std::vector<Hanabi::Action>
|
|
convert_actions(std::vector<HanabLiveAction> const & hanab_live_actions, std::vector<Hanabi::Card> const & deck)
|
|
{
|
|
std::vector<Hanabi::Action> actions;
|
|
std::transform(
|
|
hanab_live_actions.begin()
|
|
, hanab_live_actions.end()
|
|
, std::back_inserter(actions)
|
|
, [&deck](HanabLiveAction const & action) {
|
|
return Hanabi::Action{action.type, deck[action.target]};
|
|
}
|
|
);
|
|
return actions;
|
|
}
|
|
|
|
Hanabi::GameInfo parse_game(boost::json::object const & game_json)
|
|
{
|
|
auto const [deck, num_suits] = parse_deck(game_json.at("deck"));
|
|
const std::vector<Parsing::HanabLiveAction> hanab_live_actions = parse_actions(game_json.at("actions"));
|
|
Hanabi::player_t num_players = game_json.at("players").as_array().size();
|
|
std::vector<Hanabi::Action> actions = convert_actions(hanab_live_actions, deck);
|
|
|
|
boost::json::value const * options = game_json.if_contains("options");
|
|
Hanabi::clue_t num_clues_gained_on_discard = Hanabi::clue_t(1);
|
|
if (options != nullptr) {
|
|
boost::json::value const * variant = options->as_object().if_contains("variant");
|
|
if (variant != nullptr) {
|
|
if (variant->as_string().find("Clue Starved") != std::string::npos) {
|
|
num_clues_gained_on_discard = Hanabi::clue_t (1) / Hanabi::clue_t (2);
|
|
}
|
|
}
|
|
}
|
|
return {deck, actions, num_suits, num_players, num_clues_gained_on_discard };
|
|
}
|
|
|
|
|
|
}
|
|
|