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