Work on puzzle grid in player

[wordblah.git] / wordblox.h

diff --git a/wordblox.h b/wordblox.h
index 22963e4..8886fab 100644 (file)
--- a/wordblox.h
+++ b/wordblox.h
@@ -2,14 +2,18 @@
 #define __WORDBLOX_H
 #define _XOPEN_SOURCE
 #include <unistd.h>
+#include <stdbool.h>
+#include <string.h>
+#include <ctype.h>
 #include <gd.h>
 #include <gdfontmb.h>
 #include <gdfontg.h>
 #include <zlib.h>
 #include "constantstrings.h"
 
-#define MAX_PUZZLE_SIZE 20
+#define MAX_PUZZLE_SIZE 25
 #define MAX_CLUE_LENGTH 150
+#define GRID_PIXELS 37
 
 /* Enum to define terminal colours */
 enum COLOR {
@@ -33,6 +37,12 @@ enum ORIENTATION {
        DOWN=2
 };
 
+/* for use with the player */
+enum DIRECTION {
+       DIR_FORWARD = 1,
+       DIR_BACK = -1
+};
+
 typedef char String[MAX_CLUE_LENGTH];
 
 /* The main puzzle struct type */
@@ -130,7 +140,7 @@ void export_clues (Puzzle *p, const char *filename)
 /* Output the grid to image - if answerkey is true export filled grid */
 void export_grid_image  (Puzzle *p, const char *filename, bool answerkey) 
 {
-       int img_size = p->grid_size * 40;
+       int img_size = p->grid_size * GRID_PIXELS;
        FILE * outfile = fopen (filename, "wb");
        if (outfile == NULL)
        {
@@ -139,7 +149,7 @@ void export_grid_image  (Puzzle *p, const char *filename, bool answerkey)
        }
        
        gdImagePtr img = gdImageCreate (img_size, img_size);
-       int white = gdImageColorAllocate (img, 255,255,255);
+       gdImageColorAllocate (img, 255,255,255);
        int black = gdImageColorAllocate (img, 0, 0, 0);
        int blue = gdImageColorAllocate (img, 0, 0, 216);
        gdFontPtr sm_fnt = gdFontGetMediumBold ();
@@ -151,13 +161,15 @@ void export_grid_image  (Puzzle *p, const char *filename, bool answerkey)
                {
                        /* if it is a block, draw the black square */
                        if (p->chars[i][j] == '#')
-                               gdImageFilledRectangle (img, j*40, i*40, j*40+40, 
-                                                                                       i*40+40,black);
+                               gdImageFilledRectangle (img, j*GRID_PIXELS, i*GRID_PIXELS, 
+                                                                               j*GRID_PIXELS+GRID_PIXELS, 
+                                                                               i*GRID_PIXELS+GRID_PIXELS,black);
                        else
                        {
                                /* draw a regular square */
-                               gdImageRectangle (img, j*40, i*40, j*40+40, 
-                                                                       i*40+40, black);
+                               gdImageRectangle (img, j*GRID_PIXELS, i*GRID_PIXELS, 
+                                                                               j*GRID_PIXELS+GRID_PIXELS, 
+                                                                       i*GRID_PIXELS+GRID_PIXELS, black);
                                
                                /* print the numers, if it is either start across word or 
                                a down word */
@@ -168,22 +180,24 @@ void export_grid_image  (Puzzle *p, const char *filename, bool answerkey)
                                        {
                                                char str[5];
                                                sprintf (str, "%d", p->start_across_word[i][j]);
-                                               gdImageString (img,  sm_fnt, j*40+2, i*40+2,
-                                                                       (unsigned char *)str, blue);   
+                                               gdImageString (img,  sm_fnt, j*GRID_PIXELS+2, 
+                                                                               i*GRID_PIXELS+2, 
+                                                                               (unsigned char *)str, blue);   
                                        }
                                        else 
                                        {
                                                char str[5];
                                                sprintf (str, "%d", p->start_down_word[i][j]);
-                                               gdImageString (img,  sm_fnt, j*40+2, i*40+2,
-                                                                       (unsigned char *)str, blue);                                    
+                                               gdImageString (img,  sm_fnt, j*GRID_PIXELS+2, 
+                                                                               i*GRID_PIXELS+2,
+                                                                               (unsigned char *)str, blue);                                    
                                        }
                                }
                                /* if answerkey is true, draw the character in the cell */
                                if (answerkey)
                                {
-                                       gdImageChar (img, lg_fnt, j*40+15, i*40+15, 
-                                               p->chars[i][j], black);
+                                       gdImageChar (img, lg_fnt, j*GRID_PIXELS+15, 
+                                                                       i*GRID_PIXELS+10, p->chars[i][j], black);
                                }
                        }
                }
@@ -233,7 +247,7 @@ bool next_col_blank (Puzzle *p, int r, int c)
        return false;
 }
 
-/* unfreeze the grid - mak editing possible to change words */
+/* unfreeze the grid - make editing possible to change words */
 void unfreeze_puzzle (Puzzle *p)
 {
        for (int i = 0; i < p->grid_size; i ++)
@@ -317,7 +331,7 @@ void init_puzzle (Puzzle *p, int grid_size)
 /* save the puzzle to a file */
 void save_puzzle (Puzzle *puzzle, const char* file) {
        FILE *outfile;
-       /* First output the uncompressed contents to temp file */
+       /* First output the uncompressed contents to a temp file */
        outfile = tmpfile ();
        if (outfile == NULL)
        {
@@ -386,25 +400,27 @@ void save_puzzle (Puzzle *puzzle, const char* file) {
        gzip compressed file */
        fflush (outfile);
        fseek (outfile, 0, 0);
-               
+                       
        /* now compress the file and save it to destination file */
        gzFile outdestfile = gzopen (file, "wb");
        if (outdestfile == NULL)
        {
-               fprintf (stderr, ERROR_WRITING_FILE);
+               fprintf (stderr, "%s\n", ERROR_WRITING_FILE);
                fclose (outfile);
                exit (1);
        }
-       char buf[4096];
-       while (fread (buf, sizeof(char), 4096, outfile))
+       char buf[128];
+       int num = fread (buf, sizeof(char), sizeof(char)*128, outfile);
+       while (num > 0)
        {
-               int res = gzwrite (outdestfile, buf, strlen (buf) );
+               int res = gzwrite (outdestfile, buf, num*sizeof(char) );
                if (res == 0)
                {
-                       fprintf (stderr, "%s %s", ERROR_WRITING_FILE, COMPRESSED);
+                       fprintf (stderr, "%s %s\n", ERROR_WRITING_FILE, COMPRESSED);
                        fclose (outfile);
                        exit (1);
                }
+               num = fread (buf, sizeof(char), sizeof(char)*128, outfile);
        }
        gzclose (outdestfile);
        fclose (outfile);
@@ -417,28 +433,31 @@ Puzzle load_puzzle (const char* file) {
        gzFile insourcefile = gzopen (file, "rb");
        if (insourcefile == NULL)
        {
-               fprintf (stderr, "%s %s", ERROR_READING_FILE, COMPRESSED);
+               fprintf (stderr, "%s %s\n", ERROR_READING_FILE, COMPRESSED);
                exit (1);
        }
        /* Open a temporary file to uncompress the contents */
        FILE *infile = tmpfile ();
        if (infile == NULL)
        {
-               fprintf (stderr, ERROR_READING_FILE);
+               fprintf (stderr, "%s\n", ERROR_READING_FILE);
                exit (1);       
        }
        /* Put the uncompressed content to the temp file */
-       char buf[4096];
-       while (gzread (insourcefile, buf, 4096))
+       char buf[128];
+       int num = 0;
+       num = gzread (insourcefile, buf, 128);
+       while (num > 0)
        {
-               int res = fwrite (buf, sizeof(char), strlen (buf), infile);
+               int res = fwrite (buf, 1, num, infile);
                if (res == 0)
                {
-                       fprintf (stderr, ERROR_READING_FILE);
+                       fprintf (stderr, "%s\n", ERROR_READING_FILE);
                        fclose (infile);
                        gzclose (insourcefile);
                        exit (1);
                }
+               num = gzread (insourcefile, buf, 128);
        }
        /* Close the gzip file */
        gzclose (insourcefile);