memory_game.cpp File Reference

A simple Memory Game with 3 different sizes and multiple letters. More...

#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <random>
#include <vector>
#include <unistd.h>

Include dependency graph for memory_game.cpp:

Go to the source code of this file.

Namespaces
namespace	games
	(Mini)game implementations.
namespace	games::memory_game
	Functions for the Memory Game implementation.

Functions
template<typename T >
constexpr T	SLEEP (T seconds)
	for sleep()
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<typename T >
void	games::memory_game::init (std::vector< T > *table)
	Initializes the table with the letters.
template<typename T >
void	games::memory_game::print_table (const std::vector< T > &table)
	Utility function to print the table.
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<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<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<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.
int	main ()
	Main function.

Detailed Description

A simple Memory Game with 3 different sizes and multiple letters.

The game consists on finding the pair of all the given letters depending on the table size. Once all of the instances are all found, the game will end and will ask you if you'd like to play again or not.

It provides 3 different sizes available that the user can choose (4x2, 5x2, 7x2). 7x2 being the biggest table size and hardest mode. The bigger the size, the more letters are available.

Author

David Leal

Definition in file memory_game.cpp.

Function Documentation

main()

int main

(

void

)

Main function.

Returns

0 on exit

< Size of the table.

< Selection of the size (4x2, 5x2, 7x2).

< The answer (number index) that the user chose.

< Previous answer (number index).

< Counter to check if the user has already answered two values.

< Whether the user has answered 1 value or not (previous answered values do not count).

Definition at line 360 of file memory_game.cpp.

           {
    // Start randomizer. This changes the values every time.
    std::srand(std::time(nullptr));
 
    int size = 0;       
    int selection = 0;  
 
    int response = 0;    
    int old_answer = 0;  
 
    int memory_count =
        0;  
    bool first_time = true;  
 
    std::cout << "\tMEMORY GAME\n";
 
    do {
        std::cout << "\n1. 4x2 (1)";
        std::cout << "\n2. 5x2 (2)";
        std::cout << "\n3. 7x2 (3)\n";
 
        std::cout << "\nChoose table size: ";
        std::cin >> selection;
    } while ((selection < 1 || selection > 3) &&
             (!games::memory_game::is_number(selection)));
 
    switch (selection) {
        case 1:
            size = 8;
            break;
        case 2:
            size = 10;
            break;
        case 3:
            size = 14;
            break;
        default:
            size = 10;
            break;
    }
 
    std::vector<char> table(size);
    std::vector<char> table_empty(size);
 
    std::cout << "\n";
 
    games::memory_game::init(&table);
    games::memory_game::ask_data(table_empty, &response, &old_answer,
                                 &memory_count);
    games::memory_game::assign_results(&table_empty, &table, &response,
                                       &first_time, &old_answer, &memory_count);
 
    return 0;
}

SLEEP()

template<typename T >

T SLEEP ( T seconds )

constexpr

for sleep()

for std::shuffle() for std::srand() for std::time() for IO operations for std::mt19937 for std::vector

Definition at line 36 of file memory_game.cpp.

                             {
    return sleep(seconds);
}