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