update.cpp

Go to the documentation of this file.

 
#include <cassert>
#include <vector>
 
#include "graph.h"
#include "match.h"
#include "round.h"
#include "settings.h"
#include "state.h"
#include "update.h"
 
void update_onturn(const Settings &settings, State &state, const Question &question)
{
    // player onturn does not have any cards
    if (info_num_cards(settings, state, state.onturn) == 0) {
 
        // player asked does not have any cards
        if (info_num_cards(settings, state, question.player) > 0)
            state.onturn = question.player;
        else {
            // choose the first player with cards from the player list
            for (int player = 0; player < settings.NUM_PLAYERS; player++)
                if (info_num_cards(settings, state, player) > 0) {
                    state.onturn = player;
                    return;
                }
            state.onturn = -1;  // no players with cards left
        }
    }
}
 
bool update_quartet(const Settings &settings, State &state, const Graph &graph, int hand_offset, int player, int set)
{
    // check if we already know the quartet belongs to the player
    if (state.quartets[set] == player)
        return false;
 
    // make sure that in every possible matching this player has the given set
    for (int card = set * settings.SET_SIZE; card < (set + 1) * settings.SET_SIZE; card++) {
        Graph graph_restricted = graph_copy(graph);
        for (int hand_entry = 0; hand_entry < state.players[player].num_cards; hand_entry++)
            graph_restricted[hand_offset + hand_entry][card] = false;
        if (match_exists(graph_restricted))
            return false;
    }
 
    // update the state so only this player can have the cards from the set
    for (int card = set * settings.SET_SIZE; card < (set + 1) * settings.SET_SIZE; card++) {
        state.cards[card].players = std::vector<bool>(settings.NUM_PLAYERS, false);
        state.cards[card].players[player] = true;
    }
    state.quartets[set] = player;
    return true;
}
 
void update_quartets(const Settings &settings, State &state, const Question &question)
{
    assert(graph_possible(settings, state) && match_exists(graph_create(settings, state)));
 
    // find any matching of the current state graph for checking of quartets
    Graph graph = graph_create(settings, state);
    std::vector<int> match = match_find(graph);
 
    bool newquartet = false;  // indicates whether any new quartet was found
    int hand_offset = 0;
    for (int player = 0; player < settings.NUM_PLAYERS; player++) {
 
        // count the number of cards this player has of every set
        std::vector<int> sets(settings.NUM_SETS, 0);
        for (int card = 0; card < state.players[player].num_cards; card++)
            sets[match[hand_offset + card] / settings.SET_SIZE]++;
 
        // check if there are any new possible quartets, if so update the state
        for (int set = 0; set < settings.NUM_SETS; set++)
            if (sets[set] == settings.SET_SIZE)
                if (update_quartet(settings, state, graph, hand_offset, player, set))
                    newquartet = true;
 
        hand_offset += state.players[player].num_cards;
    }
 
    // make sure that the player who is onturn has cards left
    if (newquartet)
        update_onturn(settings, state, question);
}
 
void update_state(const Settings &settings, State &state, const Question &question, const Answer &answer)
{
    const int card = question.set * settings.SET_SIZE + question.card;
 
    // update the set restriction of the player onturn
    int *set = &state.players[state.onturn].sets[question.set];
    if (*set == 0) *set = 1;
 
    if (answer) {
        // update the set restrictions
        state.players[state.onturn].sets[question.set] += 1;
        int *set = &state.players[question.player].sets[question.set];
        if (*set > 0) *set -= 1;
 
        // update who has the card which is asked
        state.cards[card].players = std::vector<bool>(settings.NUM_PLAYERS, false);
        state.cards[card].players[state.onturn] = true;
 
        // update the number of cards the players have
        state.players[state.onturn].num_cards += 1;
        state.players[question.player].num_cards -= 1;
 
        // update the quartets
        update_quartets(settings, state, question);
    } else {
        // update who could have the card which is asked
        state.cards[card].players[state.onturn] = false;
        state.cards[card].players[question.player] = false;
 
        // update the turn
        state.onturn = question.player;
    }
}