games::memory_game Namespace Reference

Functions for the Memory Game implementation. More...

Functions
template<typename T >
bool	is_number (const T &input)
	Utility function to verify if the given input is a number or not. This is very useful to prevent the program being stuck in a loop.
template<typename T >
void	init (std::vector< T > *table)
	Initializes the table with the letters.
template<typename T >
void	print_table (const std::vector< T > &table)
	Utility function to print the table.
template<typename T >
void	reset_data (const std::vector< T > &table, int *answer, int *old_answer, int *memory_count)
	Utility function that resets the data if the user enters an invalid value.
template<typename T >
void	ask_data (const std::vector< T > &table, int *answer, int *old_answer, int *memory_count)
	Function that asks the user for their input in the table they previously chose.
template<typename T >
bool	match (const std::vector< T > &table, std::vector< T > *table_empty, const int &answer, bool *first_time, int *old_answer, int *memory_count)
	Checks if the two values given by the user match.
template<typename T >
void	assign_results (std::vector< T > *table_empty, std::vector< T > *table, int *answer, bool *first_time, int *old_answer, int *memory_count)
	Function to assign the results to the table.

Detailed Description

Functions for the Memory Game implementation.

Function Documentation

ask_data()

template<typename T >

void games::memory_game::ask_data	(	const std::vector< T > &	table,
		int *	answer,
		int *	old_answer,
		int *	memory_count )

Function that asks the user for their input in the table they previously chose.

Template Parameters

T	The type of the table.

Parameters

table	The table that's used to get the user's input and data.
answer	The user's answer.
old_answer	The user's previous answer.
memory_count	A counter to check if the user has already answered two values.

Returns

void

                                 {
    (*old_answer) = (*answer);
    print_table(table);
 
    std::cout << "\n\nType your response here (number index):\n";
    std::cin >> (*answer);
 
    if (!is_number((*answer))) {
        std::cout << "\nYou must enter a valid number.\n\n";
        reset_data(table, answer, old_answer, memory_count);
    }
 
    // Increase the memory count, which will be later on used for checking if
    // the user has already answered two values.
    (*memory_count)++;
 
    if (((*answer) > table.size()) || ((*answer) < 1)) {
        std::cout << "\nYou can't check a value that doesn't exist (or an "
                     "invalid number).\n\n";
        reset_data(table, answer, old_answer, memory_count);
    }
 
    if ((*old_answer) == (*answer)) {
        std::cout << "\nYou can't check the same value twice.\n\n";
        reset_data(table, answer, old_answer, memory_count);
    }
 
    // If two matches are answered already, but the user checkes a non-answered
    // and an answered value, the program will mark it as no match, however, we
    // must not allow the user to check the same value twice.
    if ((table[(*answer) - 1] != 0) &&
        ((table[(*old_answer)] == 0) || (table[(*old_answer)] != 0))) {
        std::cout << "\nYou can't check the same value twice.\n\n";
        reset_data(table, answer, old_answer, memory_count);
    }
}

Here is the call graph for this function:

assign_results()

template<typename T >

void games::memory_game::assign_results	(	std::vector< T > *	table_empty,
		std::vector< T > *	table,
		int *	answer,
		bool *	first_time,
		int *	old_answer,
		int *	memory_count )

Function to assign the results to the table.

Also checkes if the user has answered all the values already, as well as verify if the user made a match or not.

Template Parameters

T	The type of the tables.

Parameters

table_empty	The table with no values, slowly assigned from table depending on the user's input.
table	The table with the original values.
answer	The user's answer.
first_time	A boolean to check if the user has already answered a value.
old_answer	The user's previous answer.
memory_count	A counter to check if the user has already answered two values.

Returns

void

                                       {
    // Search through the entire table and if the answer matches the index, show
    // the value. If it doesn't match, hide both the values. Don't forget to
    // keep older values already answered.
    for (int i = 0; i < (*table).size() + 1; i++) {
        if (i == (*answer)) {
            if (match((*table), table_empty, (*answer), first_time, old_answer,
                      memory_count) == true) {
                (*table_empty)[i - 1] = (*table)[i - 1];
                (*first_time) = true;
            }
        }
    }
 
    if ((*memory_count) == 1) {
        (*first_time) = false;
        (*memory_count) = 0;
    }
 
    char try_again = 'n';
 
    // Has the user finished the game? Use a `for` loop, and if the table is
    // full, ask the user if he wants to play again.
    for (int i = 0; i < (*table).size() + 1; i++) {
        if ((*table_empty)[i] == 0) {
            break;
        } else if (i == (*table).size() - 1) {
            print_table((*table));
 
            std::cout << "\n\nYou won. Congratulations! Do you want to play "
                         "again? (y/n)\n";
            std::cout
                << "Size " << (*table).size()
                << " will be used. This can be changed by re-running the game.";
            std::cin >> try_again;
            if (try_again == 'y') {
                // This is needed when checking if the user has two matches
                // already.
                for (int i = 0; i < (*table_empty).size(); i++) {
                    (*table_empty)[i] = 0;
                }
 
                init(table);
            } else if (try_again == 'n') {
                std::cout << "\nThanks for playing the game!\n";
                SLEEP(3);
 
                exit(0);
            } else {
                std::cout << "\nInvalid input (exitting...).\n";
                SLEEP(3);
 
                exit(0);
            }
        }
    }
 
    // Ask data again.
    ask_data((*table_empty), answer, old_answer, memory_count);
    assign_results(table_empty, table, answer, first_time, old_answer,
                   memory_count);
}

Here is the call graph for this function:

init()

template<typename T >

void games::memory_game::init

(

std::vector< T > *

table

)

Initializes the table with the letters.

Template Parameters

T	The type of the table.

Parameters

table

The table to initialize.

Returns

void

                               {
    std::vector<char> letters(7);
 
    // Decrease / increase the number of letters depending on the size.
    if ((*table).size() == 10) {  // 5x2
        letters = {'A', 'E', 'Z', 'P', 'D'};
    } else if ((*table).size() == 8) {  // 4x2
        letters = {'A', 'E', 'Z', 'D'};
    } else if ((*table).size() == 14) {  // 7x2
        letters = {'A', 'E', 'Z', 'P', 'D', 'B', 'M'};
    }
 
    std::vector<char> pairs;
    for (char letter : letters) {
        pairs.push_back(letter);
        pairs.push_back(letter);
    }
 
    std::shuffle(pairs.begin(), pairs.end(),
                 std::mt19937(std::random_device()()));
 
    for (int i = 0; i < (*table).size(); i++) {
        (*table)[i] = pairs[i];
    }
 
    std::cout << "All available types are: ";
 
    for (int i = 0; i < letters.size(); i++) {
        if (i == letters.size() - 1) {
            std::cout << "and " << letters[i] << ".\n\n";
        } else {
            std::cout << letters[i] << ", ";
        }
    }
}

Here is the call graph for this function:

is_number()

template<typename T >

bool games::memory_game::is_number

(

const T &

input

)

Utility function to verify if the given input is a number or not. This is very useful to prevent the program being stuck in a loop.

Template Parameters

T	The type of the input

Parameters

input

The input to check.

Returns

false if the input IS empty or if it contains a non-digit character

true if the input is NOT empty and if it contains only digit characters

                               {
    if (std::cin.fail()) {
        std::cin.clear();
        std::cin.ignore(256, '\n');
 
        return false;
    }
 
    return true;
}

match()

template<typename T >

bool games::memory_game::match	(	const std::vector< T > &	table,
		std::vector< T > *	table_empty,
		const int &	answer,
		bool *	first_time,
		int *	old_answer,
		int *	memory_count )

Checks if the two values given by the user match.

Template Parameters

T	The type of the table.

Parameters

table_empty	The table with no values, slowly assigned from table depending on the user's input.
table	The table with the original values.
answer	The user's answer.
first_time	A boolean to check if the user has already answered a value.
old_answer	The user's previous answer.
memory_count	A counter to check if the user has already answered two values.

Returns

true IF the values given by the user match

false if the values given by the user do NOT match

                              {
    if ((*first_time) == true) {
        return true;
    }
 
    // Search across the whole table and if the two values match, keep results,
    // otherwise, hide 'em up.
    for (int i = 0; i < table.size() + 1; i++) {
        if (i == answer) {
            if (table[i - 1] == table[(*old_answer) - 1]) {
                (*first_time) = true;
                (*memory_count) = 0;
 
                (*old_answer) = 0;
                return true;
            } else {
                std::cout << "\nNo match (value was " << table[i - 1]
                          << ", index is " << i << ").\n\n";
 
                (*table_empty)[(*old_answer) - 1] = 0;
                (*table_empty)[answer - 1] = 0;
 
                (*first_time) = true;
                (*memory_count) = 0;
 
                (*old_answer) = 0;
                return false;
            }
        }
    }
 
    return false;
}

print_table()

template<typename T >

void games::memory_game::print_table

(

const std::vector< T > &

table

)

Utility function to print the table.

Template Parameters

T	The type of the table.

Parameters

table

The table to print.

Returns

void

                                            {
    std::cout << "| ";
    std::vector<T> table_print(table.size());
 
    for (int i = 0; i < table.size(); i++) {
        table_print[i] = ' ';
 
        if (table[i] != 0) {
            table_print[i] = table[i];
        }
    }
 
    for (int i = 0; i < table.size(); i++) {
        if (i % 5 == 0 && i != 0) {
            std::cout << "\n| ";
        }
 
        std::cout << table_print[i] << " | ";
    }
}

reset_data()

template<typename T >

void games::memory_game::reset_data	(	const std::vector< T > &	table,
		int *	answer,
		int *	old_answer,
		int *	memory_count )

Utility function that resets the data if the user enters an invalid value.

Template Parameters

T	The type of the table.

Parameters

table	The table that will be used to call ask_data().
answer	The user's answer.
old_answer	The user's previous answer.
memory_count	A counter to check if the user has already answered two values.

Returns

void

                                   {
    (*answer) = (*old_answer);
    (*memory_count)--;
 
    ask_data(table, answer, old_answer, memory_count);
}

Here is the call graph for this function: