home *** CD-ROM | disk | FTP | other *** search
/ Boldly Go Collection / version40.iso / TS / 17A / ANGRY.ZIP / ANGRY.C next >
C/C++ Source or Header  |  1992-07-30  |  19KB  |  788 lines
  1. /* Angry! The cross word builder */
  2. /* written by Andrew Tridgell (23rd July 1992) */  
  3. /* Copyright (C) Andrew Tridgell 1992 */
  4.  
  5. /* 
  6. Permission is given for the use or copying of this program for
  7. non-commercial purposes. If you wish to use it for commercial purposes
  8. then please contact the author:
  9.  
  10. Andrew Tridgell
  11. Computer Sciences Laboratory
  12. Australian National University
  13. GPO BOX 4
  14. Canberra, 2601, Australia
  15.  
  16. E-Mail: Andrew.Tridgell@anu.edu.au
  17. */
  18.  
  19.  
  20. #define VERSION "1.0"
  21.   
  22. #include <stdio.h>  
  23. #include <alloc.h>
  24. #include <stdlib.h>  
  25. #include <time.h>  
  26.  
  27. enum _Direction{ACROSS,DOWN}; 
  28. typedef enum _Direction Direction; 
  29. typedef int BOOL; 
  30.  
  31.  
  32. /* this structure holds the word list */
  33. typedef struct
  34. {
  35.   char *word;
  36.   int i,j;
  37.   Direction d;
  38.   BOOL used;
  39. } list_struct;
  40.  
  41.  
  42.  
  43. #define True 1 
  44. #define False 0 
  45. #define CONST const 
  46. #define LONG_STRING_LENGTH 1000
  47. #define MAX_TRY depth 
  48. #define MAX_FAILURES 20 
  49.  
  50. /* define how words will be scored */
  51. #define SC_END 30 
  52. #define SC_MID 35 
  53. #define SC_NOEDGE 9 
  54. #define SC_DIR 1 
  55.  
  56. /* min score for a word with some crossings */
  57. #define SC_MIN_CROSSING (SC_NOEDGE + SC_DIR + 1)
  58.  
  59. /* these bits implement the "rotating line" */
  60. char circle[4] = "\\|/-"; 
  61. char lastc = 0; 
  62. #define CIRCLE {printf("%c\r",circle[(lastc=((lastc+1)%4))]);fflush(stdout);}
  63.  
  64.  
  65. char *strtidy(); 
  66. void read_a_line(); 
  67. char *my_fgets(); 
  68.  
  69.  
  70. #ifndef __MSDOS__ 
  71. #define randomize() srand(time(NULL)) 
  72. #define BLACKSQUARE 32 
  73. #define kbhit() False 
  74. #else 
  75. #define BLACKSQUARE 219 
  76. #endif 
  77.  
  78.  
  79.  
  80. /* GLOBAL VARIABLES */
  81. int xsize=0;  
  82. int ysize=0;  
  83. int depth=1; 
  84. BOOL final_try=False; 
  85. char **grid; 
  86.  
  87.  
  88.  
  89. /******************************************************************* 
  90. create a 2D matrix of any type. The return must be cast correctly. 
  91. ********************************************************************/ 
  92. void **any_matrix2D(int el_size,int dim1,int dim2) 
  93. { 
  94. int dimension=2; 
  95. int *dims=NULL; 
  96. void **mat; 
  97. int i,j,size,ptr_size,ppos,prod; 
  98. int padding; 
  99. void *next_ptr; 
  100.   
  101. /* first gather the arguments */  
  102.   
  103. if (dimension <= 0) return(NULL);  
  104. if (el_size <= 0) return(NULL);  
  105.   
  106. dims = (int *)malloc(dimension * sizeof(int));  
  107. if (dims == NULL) return(NULL);  
  108. dims[0] = dim1;
  109. dims[1] = dim2;
  110.   
  111. /* now we've disected the arguments we can go about the real business of  
  112. creating the matrix */  
  113.   
  114. /* calculate how much space all the pointers will take up */  
  115. ptr_size = 0;  
  116. for (i=0;i<(dimension-1);i++)  
  117.     {  
  118.     prod=sizeof(void *);  
  119.     for (j=0;j<=i;j++) prod *= dims[j];  
  120.     ptr_size += prod;  
  121.     }  
  122.   
  123. /* padding overcomes potential alignment errors */  
  124. padding = (el_size - (ptr_size % el_size)) % el_size;  
  125.   
  126. /* now calculate the total memory taken by the array */  
  127. {  
  128. prod=el_size;  
  129. for (i=0;i<dimension;i++) prod *= dims[i];  
  130. size = prod + ptr_size + padding;  
  131. }  
  132.   
  133. /* allocate the matrix memory */  
  134. mat = (void **)malloc(size);  
  135.   
  136. if (mat == NULL)  
  137.     {  
  138.     fprintf(stdout,"Error allocating %d dim matrix of size %d\n",dimension,size);  
  139.     free(dims);  
  140.     return(NULL);  
  141.     }  
  142.   
  143. /* now fill in the pointer values */  
  144. next_ptr = (void *)&mat[dims[0]];  
  145. ppos = 0;  
  146. prod = 1;  
  147. for (i=0;i<(dimension-1);i++)  
  148. {  
  149. int skip;  
  150. if (i == dimension-2)   
  151.   {  
  152.     skip = el_size*dims[i+1];  
  153.     next_ptr = (void *)(((char *)next_ptr) + padding); /* add in the padding */  
  154.   }  
  155. else  
  156.   skip = sizeof(void *)*dims[i+1];  
  157.   
  158. for (j=0;j<(dims[i]*prod);j++)  
  159.   {  
  160.     mat[ppos++] = next_ptr;  
  161.     next_ptr = (void *)(((char *)next_ptr) + skip);  
  162.   }  
  163. prod *= dims[i];  
  164. }  
  165.   
  166. free(dims);  
  167. return((void *)mat);  
  168. }  
  169.   
  170.   
  171. /*******************************************************************  
  172. return a random number  
  173. ********************************************************************/  
  174. int random_num(void)  
  175. {  
  176. return(rand());  
  177. }  
  178.   
  179.   
  180. /*******************************************************************  
  181. this returns the number of lines in a text file  
  182. ********************************************************************/  
  183. int num_text_lines(CONST char *fname)  
  184. {  
  185. FILE *file;  
  186. int count = 0;  
  187. char buf[2000];  
  188.   
  189. file = fopen(fname,"r");  
  190. if (!file)  
  191.   return(0);  
  192.   
  193. while (!feof(file))  
  194.   {  
  195.     read_a_line(buf,2000,file);  
  196.     if (*buf) count++;  
  197.   }  
  198.   
  199. fclose(file);  
  200. return(count);  
  201. }  
  202.   
  203. /*******************************************************************  
  204. read a line from a file. If the line is of 0 length then read another  
  205. ********************************************************************/  
  206. void read_a_line(char *buf,int maxlen,FILE *file)  
  207. {  
  208. my_fgets(buf,maxlen,file);  
  209. if (strlen(buf) == 0)  
  210.     my_fgets(buf,maxlen,file);  
  211. }  
  212.   
  213. /*******************************************************************  
  214. like fgets but remove trailing CR or LF  
  215. ********************************************************************/  
  216. char *my_fgets(char *s,int n,FILE *stream)  
  217. {  
  218. char *ret;  
  219.   
  220. ret = fgets(s,n,stream);  
  221. if (ret == NULL)   
  222.   {  
  223.     *s = 0;  
  224.     return(NULL);  
  225.   }  
  226.   
  227. return(strtidy(s,"\n\r "));  
  228. }  
  229.   
  230. /*******************************************************************  
  231. remove specified chars from front and back of a string   
  232. ********************************************************************/  
  233. char *strtidy(char *str,CONST char *chars)  
  234. {  
  235. int len=strlen(str);  
  236. while ((len > 0) && (strchr(chars,*str) != NULL))  
  237.     {  
  238.     memcpy(str,&str[1],len);  
  239.     len--;  
  240.     }  
  241. while ((len > 0) && (strchr(chars,str[len-1]) != NULL))  
  242.     {  
  243.     str[len-1]=0;  
  244.     len--;  
  245.     }  
  246. return(str);  
  247. }  
  248.   
  249.   
  250.   
  251.   
  252. /*******************************************************************  
  253. load a list of words  
  254. ********************************************************************/  
  255. list_struct *LoadWordList(char *fname,int *num)  
  256. {  
  257. FILE *file;  
  258. int i;  
  259. char line[LONG_STRING_LENGTH];  
  260. list_struct *list;  
  261. *num = num_text_lines(fname);  
  262. if (*num < 1)  
  263.   return(NULL);  
  264.   
  265. list = (list_struct *)malloc(sizeof(list_struct)*(*num));  
  266. if (!list) return(NULL);
  267.  
  268. file = fopen(fname,"r");  
  269. for (i=0;i<(*num);i++)  
  270.   {  
  271.     read_a_line(line,LONG_STRING_LENGTH,file);  
  272.     list[i].word = (char *)malloc(sizeof(char)*(strlen(line)+1));
  273.     if (!list[i].word) return(NULL);
  274.     strcpy(list[i].word,line);  
  275.     list[i].used = False;
  276.   }  
  277. fclose(file);  
  278.   
  279. return(list);  
  280. }  
  281.   
  282. /*******************************************************************  
  283. place a word on the grid
  284. ********************************************************************/  
  285. void PlaceWord(char *word,int i,int j,Direction dir)  
  286. {  
  287. int k;  
  288. int len=strlen(word);  
  289. CIRCLE
  290. if (dir == ACROSS)  
  291.   {  
  292.     for (k=0;k<len;k++)  
  293.       grid[i+k][j] = word[k];  
  294.   }  
  295. else  
  296.   {  
  297.     for (k=0;k<len;k++)  
  298.       grid[i][j+k] = word[k];  
  299.   }  
  300. }  
  301.  
  302.  
  303. /*******************************************************************  
  304. un_place a word  
  305. ********************************************************************/  
  306. void UnPlaceWord(char *word,int i,int j,Direction dir)  
  307. {  
  308. int k;  
  309. int len=strlen(word);
  310. BOOL minus,plus;  
  311. if (dir == ACROSS)  
  312.   {  
  313.     minus = (j!=0);
  314.     plus = (j!=(ysize-1));
  315.     for (k=0;k<len;k++)  
  316.       if (!(minus && grid[i+k][j-1]) && !(plus && grid[i+k][j+1]))
  317.     grid[i+k][j] = 0;  
  318.   }  
  319. else  
  320.   {  
  321.     minus = (i!=0);
  322.     plus = (i!=(xsize-1));
  323.     for (k=0;k<len;k++)  
  324.       if (!(minus && grid[i-1][j+k]) && !(plus && grid[i+1][j+k]))
  325.     grid[i][j+k] = 0;  
  326.   }  
  327. }  
  328.  
  329.  
  330. /*******************************************************************  
  331. work out how many cross overs there are for a word
  332. ********************************************************************/  
  333. int Crossings(char *word,int i,int j,Direction dir)  
  334. {  
  335. int k;  
  336. int len=strlen(word);
  337. int res=0;
  338. BOOL minus,plus;  
  339. if (dir == ACROSS)  
  340.   {  
  341.     minus = (j!=0);
  342.     plus = (j!=(ysize-1));
  343.     for (k=0;k<len;k++)  
  344.       if ((minus && grid[i+k][j-1]) || (plus && grid[i+k][j+1]))
  345.     res++;
  346.   }  
  347. else  
  348.   {  
  349.     minus = (i!=0);
  350.     plus = (i!=(xsize-1));
  351.     for (k=0;k<len;k++)  
  352.       if ((minus && grid[i-1][j+k]) || (plus && grid[i+1][j+k]))
  353.     res++;
  354.   }  
  355. return(res);
  356. }  
  357.  
  358.  
  359. /*******************************************************************  
  360. determine if a position is taken - just checks for overlaps
  361. ********************************************************************/  
  362. BOOL Taken(list_struct *list,int num,char *word,int i,int j,Direction dir)  
  363. {
  364.   int len=strlen(word);
  365.   int n;
  366.   if (dir == ACROSS)
  367.     for (n=0;n<num;n++)
  368.       if (list[n].used && (list[n].d == dir) && (list[n].j == j))
  369.     {
  370.       int l2=strlen(list[n].word);
  371.       int e1 = i+len-1;
  372.       int e2 = list[n].i+l2-1;
  373.       if (!((i>e2) || (list[n].i>e1))) return(True);
  374.     }
  375.  
  376.   if (dir == DOWN)
  377.     for (n=0;n<num;n++)
  378.       if (list[n].used && (list[n].d == dir) && (list[n].i == i))
  379.     {
  380.       int l2=strlen(list[n].word);
  381.       int e1 = j+len-1;
  382.       int e2 = list[n].j+l2-1;
  383.       if (!((j>e2) || (list[n].j>e1))) return(True);
  384.     }
  385.  
  386. return(False);
  387. }
  388.  
  389.   
  390. /*******************************************************************  
  391. determine if a word is legal in a position  
  392. ********************************************************************/  
  393. BOOL Legal(char *word,int i,int j,Direction dir)  
  394. {  
  395. int len=strlen(word);  
  396. BOOL plus,minus;
  397. if (dir == ACROSS)  
  398.   {  
  399.     int k;  
  400.     if (i+len > xsize) return(False);  
  401.     if ((i != 0) && grid[i-1][j]) return(False);  
  402.     if (((i+len) != xsize) && grid[i+len][j]) return(False);  
  403.     minus = (j!=0);
  404.     plus = (j!=(ysize-1));
  405.     for (k=0;k<len;k++)  
  406.       {  
  407.     if (grid[i+k][j] && (grid[i+k][j] != word[k])) return(False);  
  408.     if ((j != 0) && grid[i+k][j-1] && !grid[i+k][j]) return(False);  
  409.     if ((j != (ysize-1)) && grid[i+k][j+1] && !grid[i+k][j]) return(False);  
  410.     if (grid[i+k][j] && !((plus && grid[i+k][j+1]) || (minus && grid[i+k][j-1])))
  411.       return(False);
  412.       }  
  413.   }  
  414. else  
  415.   {  
  416.     int k;  
  417.     if (j+len > ysize) return(False);  
  418.     if ((j != 0) && grid[i][j-1]) return(False);  
  419.     if (((j+len) != ysize) && grid[i][j+len]) return(False);  
  420.     minus = (i!=0);
  421.     plus = (i!=(xsize-1));
  422.     for (k=0;k<len;k++)  
  423.       {  
  424.     if (grid[i][j+k] && (grid[i][j+k] != word[k])) return(False);  
  425.     if ((i != 0) && grid[i-1][j+k] && !grid[i][j+k]) return(False);  
  426.     if ((i != (xsize-1)) && grid[i+1][j+k] && !grid[i][j+k]) return(False);  
  427.     if (grid[i][j+k] && !((plus && grid[i][j+k]) || (minus && grid[i-1][j+k])))
  428.       return(False);
  429.       }  
  430.   }  
  431. return(True);  
  432. }  
  433.   
  434. /*******************************************************************  
  435. score a word in a position  
  436. ********************************************************************/  
  437. int Score(char *word,int i,int j,Direction dir)  
  438. {  
  439. int len=strlen(word);  
  440. int score=0;  
  441. if (dir == ACROSS)  
  442.   {  
  443.     int k;  
  444.     for (k=0;k<len;k++)  
  445.       if (grid[i+k][j])
  446.     {  
  447.       if ((k == 0) || (k == (len-1)))   
  448.         score += SC_END;  
  449.       else  
  450.         score += SC_MID;  
  451.     }  
  452.     if ((j != 0) && (j != (ysize-1))) score += SC_NOEDGE;  
  453.   }  
  454. else  
  455.   {  
  456.     int k;  
  457.     for (k=0;k<len;k++)  
  458.       if (grid[i][j+k])
  459.     {  
  460.       if ((k == 0) || (k == (len-1)))   
  461.         score += SC_END;  
  462.       else  
  463.         score += SC_MID;  
  464.     }  
  465.     if ((i != 0) && (i != (xsize-1))) score += SC_NOEDGE;  
  466.   }  
  467. return(score);  
  468. }  
  469.   
  470. Direction last_dir=ACROSS;  
  471.   
  472.   
  473. /*******************************************************************  
  474. find the best position for a word  
  475. ********************************************************************/  
  476. BOOL BestPosition(char *word,int *besti,int *bestj,Direction *dir)  
  477. {  
  478. int best;  
  479. register int i,j;  
  480. Direction d;  
  481. int s;  
  482. int len = strlen(word);  
  483. best = -1;  
  484.  
  485.   
  486. d = ACROSS;  
  487. for (i=0;i<=(xsize-len);i++)  
  488.   for (j=0;j<ysize;j++)  
  489.       if (Legal(word,i,j,d))  
  490.     {  
  491.       s = Score(word,i,j,d);  
  492.       if (last_dir != d) s += SC_DIR;  
  493.       if (s > best || ((s == best) && ((random_num()%(xsize*ysize/4))!=0)))  
  494.         {  
  495.           best = s;  
  496.           *besti = i;  
  497.           *bestj = j;  
  498.           *dir = d;  
  499.         }  
  500.     }  
  501.   
  502. d = DOWN;  
  503. for (i=0;i<xsize;i++)  
  504.   for (j=0;j<=(ysize-len);j++)  
  505.       if (Legal(word,i,j,d))  
  506.     {  
  507.       s = Score(word,i,j,d);  
  508.       if (last_dir != d) s += SC_DIR;  
  509.       if (s > best || ((s == best) && ((random_num()%(xsize*ysize/4))!=0)))  
  510.         {  
  511.           best = s;  
  512.           *besti = i;  
  513.           *bestj = j;  
  514.           *dir = d;  
  515.         }  
  516.     }  
  517.   
  518. return(best >= 0);  
  519. }  
  520.   
  521. /*******************************************************************  
  522. zero a crossword  
  523. ********************************************************************/  
  524. void ZeroCrossword(list_struct *list,int num)  
  525. {  
  526. int i,j;  
  527. for (i=0;i<xsize;i++)  
  528.   for (j=0;j<ysize;j++)  
  529.     grid[i][j] = 0;  
  530. for (i=0;i<num;i++)
  531.   list[i].used = False;
  532. }  
  533.   
  534.   
  535.   
  536. /*******************************************************************  
  537. build a crossword  
  538. ********************************************************************/  
  539. int BuildCrossword(list_struct *list,int num,int min_score)  
  540. {  
  541. int i,j,n;  
  542. Direction d;  
  543. int remaining=0;  
  544. int failures=0; 
  545. int *scores = (int *)malloc(sizeof(int)*num);  
  546.  
  547. for (n=0;n<num;n++)
  548.   if (!list[n].used) remaining++;
  549.   
  550. while (remaining > 0)  
  551.   {  
  552.     int n1,tried;  
  553.     int choose;  
  554.     int numbest=0,bestscore=-1;  
  555.     int k;  
  556.  
  557.  
  558.     for (i=0;i<num;i++)  
  559.       scores[i] = -1;  
  560.  
  561.     tried=0;  
  562.  
  563.     n1 = random_num() % num;  
  564.  
  565.     for (n=n1;(n<num) && (tried++ < MAX_TRY) && !kbhit();n++)  
  566.       if (!list[n].used && BestPosition(list[n].word,&i,&j,&d))  
  567.     {
  568.       scores[n] = Score(list[n].word,i,j,d);  
  569.       if (scores[n] == bestscore) numbest++;  
  570.       if (scores[n] > bestscore)  
  571.         {  
  572.           bestscore = scores[n];  
  573.           numbest = 1;  
  574.         } 
  575.     } 
  576.  
  577.     for (n=0;(n<n1) && (tried++ < MAX_TRY) && !kbhit();n++)  
  578.       if (!list[n].used && BestPosition(list[n].word,&i,&j,&d))  
  579.     {
  580.       scores[n] = Score(list[n].word,i,j,d);  
  581.       if (scores[n] == bestscore) numbest++;  
  582.       if (scores[n] > bestscore)  
  583.         {  
  584.           bestscore = scores[n];  
  585.           numbest = 1;  
  586.         } 
  587.     } 
  588.  
  589.     if (kbhit()) return(0);  
  590.  
  591.     if (bestscore < min_score) 
  592.       { 
  593.     failures++; 
  594.     if (failures > MAX_FAILURES) 
  595.       {  
  596.         free(scores);  
  597.         return(num-remaining);  
  598.       }  
  599.     continue; 
  600.       } 
  601.     else 
  602.       failures=0; 
  603.     k = random_num() % numbest;  
  604.     numbest=0;  
  605.     for (n=0;n<num;n++)  
  606.       if (scores[n] == bestscore)  
  607.     {  
  608.       if (numbest == k) choose=n;  
  609.       numbest++;  
  610.     }  
  611.     BestPosition(list[choose].word,&i,&j,&d);  
  612.     PlaceWord(list[choose].word,i,j,d);
  613.     
  614.     list[choose].used = True;  
  615.     list[choose].i = i;
  616.     list[choose].j = j;
  617.     list[choose].d = d;
  618.  
  619.     remaining--;  
  620.   }  
  621. free(scores);  
  622. return(num-remaining);  
  623. }
  624.  
  625.  
  626. /*******************************************************************  
  627. try every word - place any with score greater than min_score
  628. ********************************************************************/  
  629. int TryAllWords(list_struct *list,int num,int min_score)  
  630. {  
  631.   int i,j,n;  
  632.   Direction d;  
  633.   int res=0;
  634.  
  635.   for (n=0;n<num && !kbhit();n++)  
  636.     if (!list[n].used && BestPosition(list[n].word,&i,&j,&d) &&
  637.     (Score(list[n].word,i,j,d) >= min_score))
  638.       {
  639.     PlaceWord(list[n].word,i,j,d);
  640.     
  641.     list[n].used = True;  
  642.     list[n].i = i;
  643.     list[n].j = j;
  644.     list[n].d = d;
  645.     res++;
  646.       }
  647.  
  648. return(res);  
  649. }
  650.  
  651.  
  652. /*******************************************************************  
  653. remove all words below a specified score
  654. ********************************************************************/  
  655. int RemoveLowCrossings(list_struct *list,int num,int min_cross)  
  656. {  
  657. int n;  
  658. int removed=0;
  659.  
  660. for (n=0;(n<num);n++)  
  661.   if (list[n].used && (Crossings(list[n].word,list[n].i,list[n].j,list[n].d) < min_cross))
  662.     {
  663.       UnPlaceWord(list[n].word,list[n].i,list[n].j,list[n].d);
  664.       list[n].used = False;
  665.       removed++;
  666.     }
  667. return(removed);
  668. }  
  669.  
  670.   
  671. /*******************************************************************  
  672. display the crossword  
  673. ********************************************************************/  
  674. void DisplayCrossword(FILE *f)  
  675. {  
  676. int i,j;  
  677. for (j=0;j<ysize;j++)  
  678.   {  
  679.     for (i=0;i<xsize;i++)  
  680.       {  
  681.     if (grid[i][j])  
  682.       fputc(grid[i][j],f);  
  683.     else  
  684.       fputc(BLACKSQUARE,f);  
  685.       }  
  686.     fputc('\n',f);  
  687.   }  
  688. putchar('\n');  
  689. }  
  690.   
  691.   
  692. /*******************************************************************  
  693. save the crossword in a pzl file  
  694. ********************************************************************/  
  695. void SavePuzzle(char *fname)  
  696. {  
  697. FILE *f = fopen(fname,"w");  
  698. int i,j;  
  699. if (!f) return;  
  700.   
  701. fprintf(f,"%cXWORD0%s%c%c%2d%2d",42,"Angry",3,3,xsize,ysize);  
  702.   
  703. for (j=0;j<ysize;j++)  
  704.     for (i=0;i<xsize;i++)  
  705.       fprintf(f,"%c %c",(grid[i][j]?grid[i][j]:'1'),3);  
  706.   
  707. fclose(f);  
  708. }  
  709.   
  710.   
  711. /*******************************************************************  
  712. the main program
  713. ********************************************************************/  
  714. int main(int argc,char *argv[])  
  715. {  
  716. char *wordfile;
  717. list_struct *wordlist;
  718. int num_words;
  719.  
  720. int best=-1;  
  721.   
  722. randomize();
  723. if (argc < 4)  
  724.   {  
  725.     printf("angry: Xsize Ysize WordFile [depth]\n");  
  726.     return(0);  
  727.   }  
  728.  
  729. xsize = atoi(argv[1]);  
  730. ysize = atoi(argv[2]);  
  731. wordfile = argv[3];  
  732.  
  733. if (argc > 4) 
  734.   depth = atoi(argv[4]); 
  735. if (depth > 10) final_try = True;
  736.   
  737. grid = (char **)any_matrix2D(sizeof(char),xsize,ysize);  
  738.  
  739. if (!grid)  
  740.   {  
  741.     printf("failed to allocate memory for the crossword\n");
  742.     return(0);  
  743.   }  
  744.   
  745. wordlist = LoadWordList(wordfile,&num_words);  
  746. if (!wordlist)
  747.   {
  748.     printf("Failed to read list of words from %s\n",wordfile);
  749.     return(0);
  750.   }
  751.  
  752.  
  753. printf("Welcome to Angry - the Cross Word builder! (version %s)\n",VERSION);  
  754. printf("please be patient.....\n\n");  
  755.   
  756. while (True && !kbhit())
  757.   {  
  758.   int n;  
  759.   ZeroCrossword(wordlist,num_words);  
  760.   printf("*\r");
  761.   n = BuildCrossword(wordlist,num_words,0);  
  762.   n -= RemoveLowCrossings(wordlist,num_words,1);
  763.   n = BuildCrossword(wordlist,num_words,SC_MIN_CROSSING);
  764.   n -= RemoveLowCrossings(wordlist,num_words,1);
  765.   if (final_try)
  766.   n += TryAllWords(wordlist,num_words,SC_MIN_CROSSING);
  767.   if (n > best)  
  768.     {  
  769.       best = n;  
  770.       printf("placed %d words\n",best);  
  771.       {  
  772.     FILE *f = fopen("best.doc","w");  
  773.     if (f)
  774.       {
  775.         fprintf(f,"placed %d words\n\n",best);  
  776.         DisplayCrossword(f);  
  777.         fclose(f);
  778.       }
  779.     DisplayCrossword(stdout);  
  780.     SavePuzzle("best.pzl");  
  781.       }  
  782.     }  
  783.   fflush(stdout);  
  784. }  
  785. return(0);  
  786. }  
  787.  
  788.