271 lines
7.6 KiB
C
271 lines
7.6 KiB
C
#ifndef S4638520_WORDLE
|
|
#define S4638520_WORDLE
|
|
#include <csse2310a1.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
|
|
#define MIN_RANGE 3
|
|
#define MAX_RANGE 9
|
|
#define MAX_FLAGS 2
|
|
// According to spec max guess is 50, so giving some extra space for
|
|
// newline, EOF, etc
|
|
#define MAX_GUESS_LENGTH 55
|
|
|
|
#define ENVIRONMENT_WORD "WORD2310"
|
|
|
|
#define WELCOME_MESSAGE "Welcome to Wordle!\n"
|
|
#define USAGE_MESSAGE "Usage: wordle [-len word-length] [-max max-guesses] "\
|
|
"[dictionary]\n"
|
|
#define FILE_ERROR "wordle: dictionary file \"%s\" cannot be opened\n"
|
|
|
|
#define DEFAULT_WORD_LENGTH 5
|
|
#define DEFAULT_MAX_GUESSES 6
|
|
#define DEFAULT_DICTIONARY_PATH "/usr/share/dict/words"
|
|
|
|
enum ErrorCodes {
|
|
E_OK = 0,
|
|
E_ARGS = 1,
|
|
E_FILE = 2,
|
|
E_LOST = 3
|
|
};
|
|
|
|
typedef struct Dictionary {
|
|
char** contents;
|
|
int size;
|
|
} Dictionary;
|
|
|
|
/* get_flag_from_argument()
|
|
* ------------------------
|
|
* Gets the flag from the given argument
|
|
*
|
|
* argument: the argument
|
|
*
|
|
* Returns: the flag
|
|
*/
|
|
char* get_flag_from_argument(char* argument);
|
|
|
|
/* add_to_used_flags()
|
|
* ---------------------
|
|
* Adds the given flag to an array of already used flags, also checks if
|
|
* the flag has been used before within the array.
|
|
*
|
|
* flag: the given flag to add to the array
|
|
* usedFlags: the array containing the already contained flags, assumes
|
|
* each word is of length 5 including the null terminator.
|
|
* usedFlagIndex: the current index of "usedFlags".
|
|
*
|
|
* Returns: 1 if the function completes successfully, 0 otherwise.
|
|
*/
|
|
int add_to_used_flags(char* flag, char usedFlags[MAX_FLAGS][5],
|
|
int* usedFlagIndex);
|
|
|
|
/* check_valid_value()
|
|
* --------------------------
|
|
* Check if the entire value given is of an integer
|
|
*
|
|
* value: the value to check
|
|
*
|
|
* Returns: 0 if invalid, 1 if valid
|
|
*/
|
|
int check_valid_value(char* value);
|
|
|
|
/* update_file_path_from_value()
|
|
* -----------------------------
|
|
* Updates the filePath pointer to point at the new parsed filepath from the
|
|
* argument.
|
|
*
|
|
* filePath: pointer to the string for the filePath
|
|
* argument: what to update the filepath to
|
|
*/
|
|
void update_file_path_from_argument(char** filePath, char* argument);
|
|
|
|
/* get_valid_command_arguments()
|
|
* ---------------------------
|
|
* Parses the given set of flags parsed on the command line and updates
|
|
* variables "wordLength", "maxGuesses" and "filepath".
|
|
*
|
|
* argc: the amount of parsed arguments
|
|
* argv: the array containing strings of all parsed arguments
|
|
* wordLength: pointer to update for the wordLength flag '-len'
|
|
* maxGuesses: pointer to update for the maxGuesses flag '-max'
|
|
* filePath: pointer to update the filepath to the dictionary
|
|
*
|
|
* Returns:
|
|
* 0:
|
|
* - the flag parsed has been seen before in the command
|
|
* - the flag does not have an associated value
|
|
* - the flag value is NaN or not within 3 and 9
|
|
* - the flag is not a recognised flag
|
|
* - an argument is parsed without a dash and is not at the end of the command
|
|
* 1:
|
|
* - the above is not true, and hence the function completed successfully
|
|
*
|
|
* Exits: if strcpy fails at any point during this function
|
|
*/
|
|
int get_valid_command_arguments(int argc, char** argv, int* wordLength,
|
|
int* maxGuesses, char** filePath);
|
|
|
|
/* check_invalid_word()
|
|
* --------------------
|
|
* Checks if a word is invalid
|
|
*
|
|
* word: the word to check
|
|
* wordLength: the length the word needs to be
|
|
*
|
|
* Returns:
|
|
* 0: if the word is valid
|
|
* 1: if the word is not the required length
|
|
* 2: if the word has characters that are not alphas
|
|
*/
|
|
int check_invalid_word(char* word, int wordLength);
|
|
|
|
/* free_dictionary()
|
|
* -----------------
|
|
* Frees all allocated memory for the dictionary, including its contents
|
|
*
|
|
* dictionary: the dictionary to free from memory
|
|
*/
|
|
void free_dictionary(Dictionary* dictionary);
|
|
|
|
/* insert_word_into_dictionary()
|
|
* -----------------------------
|
|
* Reallocate space for the dictionary, allocate space for word and then
|
|
* instert it into the dictionary
|
|
*
|
|
* dictionary: the dictionary to insert the word into
|
|
* word: the word to insert into the dictionary
|
|
*/
|
|
void insert_word_into_dictionary(Dictionary* dictionary, char* word);
|
|
|
|
/* get_new_dictionary()
|
|
* --------------------
|
|
* Creates a new dictionary and allocates the needed space for it
|
|
*
|
|
* Returns: the new dictionary
|
|
*/
|
|
Dictionary get_new_dictionary(void);
|
|
|
|
/* get_dictionary_from_buffer()
|
|
* ----------------------------
|
|
* Creates a dictionary based on the parsed file buffer
|
|
*
|
|
* dictionaryFile: the buffer containing newline seperated words for the
|
|
* dictionary
|
|
*
|
|
* Returns: the dictionary made from the buffer
|
|
*/
|
|
Dictionary get_dictionary_from_buffer(FILE* dictionaryFile);
|
|
|
|
/* get_dictionary_words_of_length()
|
|
* --------------------------------
|
|
* Makes a new dictionary from an old containing only words of the given
|
|
* length
|
|
*
|
|
* dictionary: the dictionary containing all of the words
|
|
* wordLength: the length of the words to be extracted
|
|
*
|
|
* Returns: the dictionary containing only words of given length
|
|
*/
|
|
Dictionary get_dictionary_words_of_length(Dictionary dictionary,
|
|
int wordLength);
|
|
|
|
/* check_word_in_dictionary()
|
|
* --------------------------
|
|
* Checks if the supplied word is in the supplied dictionary
|
|
*
|
|
* dictionary: the dictionary to check
|
|
* word: the word to check if in dictionary
|
|
*
|
|
* Returns: 0 if it is not, 1 if it is
|
|
*/
|
|
int check_word_in_dictionary(Dictionary dictionary, char* word);
|
|
|
|
/* get_blank_wordle()
|
|
* ------------------
|
|
* Gets a string that only contains '-' of given length
|
|
* For example, with a length of 5, the string will be "-----"
|
|
*
|
|
* wordLength: the length of the blank word
|
|
*
|
|
* Returns: the blank word
|
|
*
|
|
* Reference: Inspired by https://stackoverflow.com/questions/12352682
|
|
*/
|
|
char* get_blank_wordle(int wordLength);
|
|
|
|
/* get_wordle_format()
|
|
* -------------------
|
|
* Get the guess in the format of wordle
|
|
*
|
|
* guessedWord: the word the user guessed
|
|
* answer: the correct word
|
|
*
|
|
* Returns: the word in the format of wordle
|
|
*/
|
|
char* get_wordle_format(char* guessedWord, char* answer);
|
|
|
|
/* string_lowercase()
|
|
* ------------------
|
|
* Converts a string to its lowercase varient
|
|
*
|
|
* string: the string to convert
|
|
*/
|
|
void string_lowercase(char* string);
|
|
|
|
/* get_guessed_word_from_input()
|
|
* -----------------------------
|
|
* Prompt for a guess word and return the guessed word if it is valid
|
|
*
|
|
* Returns:
|
|
* NULL: if EOF
|
|
* "a": if the word is blank
|
|
* the input if not the above
|
|
*/
|
|
char* get_guessed_word_from_input(void);
|
|
|
|
/* prompt_invalid_guess()
|
|
* ----------------------
|
|
* Prompt if the guess was invalid and the correct message for the type of
|
|
* invalidity
|
|
*
|
|
* invalidType: the type of invalid guess
|
|
* wordLength: the length of the answer
|
|
*/
|
|
void prompt_invalid_guess(int invalidType, int wordLength);
|
|
|
|
/* print_attempt_prompt()
|
|
* ----------------------
|
|
* Print the attempt with the amount of guesses remaing and length of word
|
|
*
|
|
* guessesRemaining: the amount of guesses remaining
|
|
* wordLength: the length of the answer
|
|
*/
|
|
void print_attempt_prompt(int guessesRemaining, int wordLength);
|
|
|
|
/* game_loop()
|
|
* -----------
|
|
* The gameplay loop for the game
|
|
*
|
|
* wordLength: the maximum length of a word to be given
|
|
* maxGuesses: the maximum number of guesses the user has
|
|
*
|
|
* Returns:
|
|
* 0: if the correct word was guessed
|
|
* 3: if the user failed
|
|
*/
|
|
int game_loop(int wordLength, int maxGuesses, char* answer,
|
|
Dictionary dictionary);
|
|
|
|
/* get_answer()
|
|
* ------------
|
|
* Gets and allocates a random word as the answer using get_random_word()
|
|
*
|
|
* answer: pointer to the answer
|
|
* wordLength, the word length if getting a random word
|
|
*/
|
|
void get_answer(char** answer, int wordLength);
|
|
|
|
#endif
|