wordblox.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <time.h>
   4 #include <stdbool.h>
   5 #include <string.h>
   6 #include <ctype.h>
   7
   8 #include "wordblox.h"
   9 #include "constantstrings.h"
  10
  11 void set_clue_across_word (Puzzle *p)
  12 {
  13         print_puzzle (p);
  14         if (p->grid_frozen == false)
  15         {
  16                 printf (UNFROZEN_GRID);
  17                 char ch = getchar ();
  18                 return;
  19         }
  20         int index;
  21         String clue;
  22         printf (INPUT_INDEX);
  23         index = get_num ();
  24         printf (INPUT_CLUE);
  25         fgets (clue, MAX_CLUE_LENGTH, stdin);
  26         char* cl = strtok (clue, "\n");
  27
  28         bool res = set_across_clue (p, cl, index);
  29         if (res == false)
  30                 printf (NO_WORD_INDEX);
  31 }
  32
  33 /* clear a cell in the grid */
  34 void clear_cell (Puzzle *p)
  35 {
  36         print_puzzle (p);
  37         if (p->grid_frozen == true)
  38         {
  39                 printf (FROZEN_GRID);
  40                 char ch = getchar ();
  41                 return;
  42         }
  43         int row, col;
  44         printf (INPUT_ROW);
  45         row = get_num ();
  46         printf (INPUT_COL);
  47         col = get_num ();
  48         if (row >= p->grid_size || col >= p->grid_size)
  49         {
  50                 printf (EXCEED_GRID_SIZE);
  51                 char ch = getchar ();
  52                 return;
  53         }
  54         p->chars[row][col] = ' ';
  55         print_puzzle (p);
  56
  57         char ch = getchar ();
  58 }
  59
  60 /* add a down word to the grid */
  61 void add_down_word (Puzzle *p)
  62 {
  63         print_puzzle (p);
  64         if (p->grid_frozen == true)
  65         {
  66                 printf (FROZEN_GRID);
  67                 char ch = getchar ();
  68                 return;
  69         }
  70         char wd[MAX_PUZZLE_SIZE];
  71         int row, col;
  72         printf (INPUT_WORD);
  73         fgets (wd, MAX_PUZZLE_SIZE, stdin);
  74         char *word = strtok (wd, "\n");
  75         if (! is_valid_word (word))
  76         {
  77                 printf (INVALID_WORD);
  78                 char ch = getchar ();
  79                 return;
  80         }
  81         printf (INPUT_ROW);
  82         row = get_num ();
  83         printf (INPUT_COL);
  84         col = get_num ();
  85         if (row >= p->grid_size || col >= p->grid_size)
  86         {
  87                 printf (EXCEED_GRID_SIZE);
  88                 char ch = getchar ();
  89                 return;
  90         }
  91         if (strlen (word) > (p->grid_size - row))
  92         {
  93                 printf (WORD_TOO_LONG);
  94                 char ch = getchar ();
  95                 return;
  96         }
  97
  98         for (int i = row; i < row + strlen(word); i ++)
  99                 p->chars[i][col] = toupper(word[i - row]);
 100
 101         print_puzzle (p);
 102         char ch = getchar ();
 103 }
 104
 105 /* add an across word to the grid */
 106 void add_across_word (Puzzle *p)
 107 {
 108         print_puzzle (p);
 109         if (p->grid_frozen == true)
 110         {
 111                 printf (FROZEN_GRID);
 112                 char ch = getchar ();
 113                 return;
 114         }
 115         char wd[MAX_PUZZLE_SIZE];
 116         int row, col;
 117         printf (INPUT_WORD);
 118         fgets (wd, p->grid_size, stdin);
 119         char *word = strtok (wd, "\n");
 120         if (! is_valid_word (word))
 121         {
 122                 printf (INVALID_WORD);
 123                 char ch = getchar ();
 124                 return;
 125         }
 126         printf (INPUT_ROW);
 127         row = get_num ();
 128         printf (INPUT_COL);
 129         col = get_num ();
 130         if (row >= p->grid_size || col >= p->grid_size)
 131         {
 132                 printf (EXCEED_GRID_SIZE);
 133                 char ch = getchar ();
 134                 return;
 135         }
 136
 137         if (strlen (word) > (p->grid_size - col))
 138         {
 139                 printf (WORD_TOO_LONG);
 140                 char ch = getchar ();
 141                 return;
 142         }
 143
 144         for (int i = col; i < col+strlen (word); i ++)
 145                 p->chars[row][i] = toupper(word[i - col]);
 146
 147         print_puzzle (p);
 148         char ch = getchar ();
 149 }
 150
 151 void puzzle_editor_loop (Puzzle *p, const char *filename)
 152 {
 153         bool loop = true;
 154         while (loop)
 155         {
 156                 print_menu (WHITE, RED, PUZZLE_MENU_TITLE, PUZZLE_EDIT_MENU, 9, 50);
 157                 printf (INPUT_CHOICE);
 158                 int ch = get_num ();
 159                 switch (ch)
 160                 {
 161                         case 1: print_puzzle (p);
 162                                         char ch = getchar ();
 163                                         break;
 164                         case 2: add_across_word (p);
 165                                         break;
 166                         case 3: add_down_word (p);
 167                                         break;
 168                         case 4: clear_cell (p);
 169                                         break;
 170                         case 5: freeze_puzzle (p);
 171                                         print_puzzle (p);
 172                                         ch = getchar ();
 173                                         break;
 174                         case 6: unfreeze_puzzle (p);
 175                                         print_puzzle (p);
 176                                         ch = getchar ();
 177                                         break;
 178                         case 7: set_clue_across_word (p);
 179                                         print_puzzle (p);
 180                                         ch = getchar ();
 181                                         break;
 182                         case 8: save_puzzle (p, filename);
 183                                         printf ("%s\n",FILE_SAVED);
 184                                         ch = getchar ();
 185                                         break;
 186                         case 9: loop = false;
 187                                         break;
 188                 }
 189         }
 190 }
 191
 192 /* open an existing puzzle */
 193 void open_puzzle ()
 194 {
 195         Puzzle p;
 196         printf (INPUT_FILE);
 197         char fname[256];
 198         fgets(fname, 256, stdin);
 199         char* filename = strtok (fname, "\n");
 200         p = load_puzzle (filename);
 201         puzzle_editor_loop (&p, filename);
 202 }
 203
 204 /* create a new blank puzzle */
 205 void new_puzzle ()
 206 {
 207         Puzzle p;
 208         printf (INPUT_FILE);
 209         char fname[256];
 210         fgets (fname, 256, stdin);
 211         char* filename = strtok (fname, "\n");
 212         printf (INPUT_GRID_SIZE);
 213         int size;
 214         size = get_num ();
 215         if (size > MAX_PUZZLE_SIZE)
 216         {
 217                 printf (EXCEED_MAX_GRID_SIZE);
 218                 char c = getchar ();
 219         }
 220         else
 221         {
 222                 init_puzzle (&p, size);
 223                 puzzle_editor_loop (&p, filename);
 224         }
 225 }
 226
 227 /* The main loop of the program */
 228 int main_loop ()
 229 {
 230         /* Print the main menu */
 231         while (1)
 232         {
 233                 print_menu (WHITE, BLUE, MAIN_MENU_TITLE, MAIN_MENU, 3, 50);
 234                 printf (INPUT_CHOICE);
 235                 int ch = get_num ();
 236                 switch (ch)
 237                 {
 238                         case 1: new_puzzle ();
 239                                         break;
 240                         case 2: open_puzzle ();
 241                                         break;
 242                         case 3: exit (0);
 243                 }
 244         }
 245 }
 246
 247 int main (int argc, char* argv[])
 248 {
 249         return (main_loop ());
 250 }