src/meta/cvmaze.c

#ifndef lint
static const char       RCSid[] = "$Id: cvmaze.c,v 1.1 2003/02/22 02:07:26 greg Exp $";
#endif
/*
 *      THE MAZE GAME  definitions and global structures
 *
 *           Written by Greg Ward 8/4/84
 */


#include  "meta.h"


#define  ERROR  (-1)            /* something wrong */

#define  OK  0                  /* everything swell */

#define  TRUE  1

#define  FALSE  0

#define  UP  1

#define  DOWN  2

#define  LEFT  3

#define  RIGHT  4

#define  min(a, b)  ((a) < (b) ? (a) : (b))

#define  max(a, b)  ((a) > (b) ? (a) : (b))

#define  VSEP  '|'              /* vertical separator */

#define  HSEP  '-'              /* horizontal separator */

#define  ISECT  '+'             /* intersection character */

#define  MARKS  " ^v<>*"        /* maze markings */

#define  TUP  1                 /* mark for trace up */

#define  TDOWN  2               /* mark for trace down */

#define  TLEFT  3               /* mark for trace left */

#define  TRIGHT  4              /* mark for trace right */

#define  MAN  5                 /* mark for player */

#define  MAXSIDE  50            /* maximum maze side */

#define  YES  1                 /* edge is there */

#define  NO  0                  /* edge isn't there */

#define  MAYBE  2               /* undecided */


#define  DIRECTION  char

#define  EDGE  char

#define  MRKINDX  char

struct  MAZE  {
               EDGE  r0[MAXSIDE+1][MAXSIDE],
                     c0[MAXSIDE+1][MAXSIDE];

               int  nrows, ncols;

               MRKINDX  mark[MAXSIDE][MAXSIDE];

               int  rt, rb, cl, cr;

               };


/*
 *  Convert maze to metafile
 */


struct MAZE  amaze;     /* our working maze */

int  cellsize;          /* the size of a maze cell (in metacoordinates) */

char  *progname;


main(argc, argv)

int  argc;
char  **argv;

{
    FILE  *fp;

    progname = *argv++;
    argc--;
        
    if (argc)
    
        for ( ; argc; argc--, argv++) {
            if ((fp = fopen(*argv, "r")) == NULL) {
                fprintf(stderr, "%s:  no such file\n", *argv);
                exit(1);
            }
            execute(fp);
            fclose(fp);
        }
        
    else
    
        execute(stdin);

    writeof(stdout);
    
    return(0);
}


execute(fp)             /* process file fp */

FILE  *fp;

{
    
    while (readmaze(fp, &amaze, MARKS) != ERROR) {
   
       cellsize = (XYSIZE-1)/max(amaze.nrows, amaze.ncols);
       printmaze(stdout, &amaze, MARKS);
       pglob(PEOP, 0200, NULL);
    }
    
}


printmaze(fp, mzp, mrks)                /* print maze to fp */

FILE  *fp;
struct MAZE  *mzp;
char  *mrks;

{
 int  i;
 
 for (i = mzp->rt; i < mzp->rb; i++)  {
 
    putrline(fp, mzp, i);
    
    putcline(fp, mzp, i, mrks);
    
    }

 putrline(fp, mzp, mzp->rb);
 
 }
 
 
putrline(fp, mzp, row)                  /* print horizontal row to fp */

FILE  *fp;
struct MAZE  *mzp;
int  row;

{
 register int  j;

 for (j = mzp->cl; j < mzp->cr; j++) 
   if (mzp->r0[row][j] == YES)
       plseg(0, j*cellsize, (XYSIZE-1)-row*cellsize, (j+1)*cellsize, (XYSIZE-1)-row*cellsize);
   
 }
 
 
putcline(fp, mzp, row, mrks)            /* print column line to fp */

FILE  *fp;
struct MAZE  *mzp;
int  row;
char  mrks[];

{
 register int  j;
 char  s[2];
 
 s[1] = '\0';
 
 for (j = mzp->cl; j <= mzp->cr; j++)
    if (mzp->c0[j][row] == YES)
       plseg(0, j*cellsize, (XYSIZE-1)-row*cellsize, j*cellsize, (XYSIZE-1)-(row+1)*cellsize);

 }
 
 
readmaze(fp, mzp, mrks)                 /* read maze from fp into mzp */

FILE  *fp;
struct MAZE  *mzp;
char  *mrks;

{
 int  i;

 mzp->rt = mzp->rb = mzp->cl = mzp->cr = mzp->nrows = mzp ->ncols = 0;

 if ((mzp->cr = mzp->ncols = getrline(fp, mzp, 0)) == 0)
    return(ERROR);

 for (i = 0; i <= MAXSIDE; i++)  {

    if (getcline(fp, mzp, i, mrks) != mzp->ncols)
       break;

    if (getrline(fp, mzp, i+1) != mzp->ncols)
       return(ERROR);

    }

 if (i > MAXSIDE)
    return(ERROR);

 mzp->rb = mzp->nrows = i;
 return(OK);
 }
 

getrline(fp, mzp, row)                  /* get row from fp */

FILE  *fp;
struct MAZE  *mzp;
int  row;

{
 int  j, nc;
 char  *fgets(), linbuf[4 + 4*MAXSIDE];

 if (fgets(linbuf, sizeof(linbuf), fp) == NULL)
    return(0);

 nc = (strlen(linbuf) - 2) / 4;

 for (j = 0; j < nc; j++)

    switch (linbuf[2 + 4*j])  {

       case HSEP:
          mzp->r0[row][j] = YES;
          break;

       case ' ':
          mzp->r0[row][j] = NO;
          break;

       default:
          return(0);
          break;

       }

 return(nc);
 }


getcline(fp, mzp, row, mrks)            /* get column line from fp */

FILE  *fp;
struct MAZE  *mzp;
int  row;
char  mrks[];

{
 int  j, nc, k;
 char  *fgets(), linbuf[4 + 4*MAXSIDE];

 if (fgets(linbuf, sizeof(linbuf), fp) == NULL)
    return(0);

 nc = (strlen(linbuf) - 2) / 4;

 for (j = 0; j < nc; j++)  {

    switch (linbuf[4*j])  {

       case VSEP:
          mzp->c0[j][row] = YES;
          break;

       case ' ':
          mzp->c0[j][row] = NO;
          break;

       default:
          return(0);
          break;

       }

    for (k = 0; mrks[k]; k++)

       if (linbuf[2 + 4*j] == mrks[k])  {
          mzp->mark[row][j] = k;
          break;
          }

    if (!mrks[k])
       return(0);

    }

 switch (linbuf[4*nc])  {

    case VSEP:
       mzp->c0[nc][row] = YES;
       break;

    case ' ':
       mzp->c0[nc][row] = NO;
       break;

    default:
       return(0);
       break;

    }

 return(nc);
 }
Revision:	1.2
Committed:	Fri Aug 1 14:14:24 2003 UTC (20 years, 9 months ago) by schorsch
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R6P1, rad3R6
Changes since 1.1:	+1 -6 lines
Log Message:	Eliminated CPM, MAC, and UNIX conditional compiles.
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	schorsch	1.2	static const char RCSid[] = "$Id: cvmaze.c,v 1.1 2003/02/22 02:07:26 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* THE MAZE GAME definitions and global structures
6			*
7			* Written by Greg Ward 8/4/84
8			*/
9
10
11			#include "meta.h"
12
13
14			#define ERROR (-1) /* something wrong */
15
16			#define OK 0 /* everything swell */
17
18			#define TRUE 1
19
20			#define FALSE 0
21
22			#define UP 1
23
24			#define DOWN 2
25
26			#define LEFT 3
27
28			#define RIGHT 4
29
30			#define min(a, b) ((a) < (b) ? (a) : (b))
31
32			#define max(a, b) ((a) > (b) ? (a) : (b))
33
34			#define VSEP '\|' /* vertical separator */
35
36			#define HSEP '-' /* horizontal separator */
37
38			#define ISECT '+' /* intersection character */
39
40			#define MARKS " ^v<>" / maze markings */
41
42			#define TUP 1 /* mark for trace up */
43
44			#define TDOWN 2 /* mark for trace down */
45
46			#define TLEFT 3 /* mark for trace left */
47
48			#define TRIGHT 4 /* mark for trace right */
49
50			#define MAN 5 /* mark for player */
51
52			#define MAXSIDE 50 /* maximum maze side */
53
54			#define YES 1 /* edge is there */
55
56			#define NO 0 /* edge isn't there */
57
58			#define MAYBE 2 /* undecided */
59
60
61
62
63
64			#define DIRECTION char
65
66			#define EDGE char
67
68			#define MRKINDX char
69
70			struct MAZE {
71			EDGE r0[MAXSIDE+1][MAXSIDE],
72			c0[MAXSIDE+1][MAXSIDE];
73
74			int nrows, ncols;
75
76			MRKINDX mark[MAXSIDE][MAXSIDE];
77
78			int rt, rb, cl, cr;
79
80			};
81
82
83
84			/*
85			* Convert maze to metafile
86			*/
87
88
89
90
91
92			struct MAZE amaze; /* our working maze */
93
94			int cellsize; /* the size of a maze cell (in metacoordinates) */
95
96			char *progname;
97
98
99			main(argc, argv)
100
101			int argc;
102			char **argv;
103
104			{
105			FILE *fp;
106
107			progname = *argv++;
108			argc--;
109
110			if (argc)
111
112			for ( ; argc; argc--, argv++) {
113			if ((fp = fopen(*argv, "r")) == NULL) {
114			fprintf(stderr, "%s: no such file\n", *argv);
115			exit(1);
116			}
117			execute(fp);
118			fclose(fp);
119			}
120
121			else
122
123			execute(stdin);
124
125			writeof(stdout);
126
127			return(0);
128			}
129
130
131
132
133			execute(fp) /* process file fp */
134
135			FILE *fp;
136
137			{
138
139			while (readmaze(fp, &amaze, MARKS) != ERROR) {
140
141			cellsize = (XYSIZE-1)/max(amaze.nrows, amaze.ncols);
142			printmaze(stdout, &amaze, MARKS);
143			pglob(PEOP, 0200, NULL);
144			}
145
146			}
147
148
149
150
151
152			printmaze(fp, mzp, mrks) /* print maze to fp */
153
154			FILE *fp;
155			struct MAZE *mzp;
156			char *mrks;
157
158			{
159			int i;
160
161			for (i = mzp->rt; i < mzp->rb; i++) {
162
163			putrline(fp, mzp, i);
164
165			putcline(fp, mzp, i, mrks);
166
167			}
168
169			putrline(fp, mzp, mzp->rb);
170
171			}
172
173
174
175
176			putrline(fp, mzp, row) /* print horizontal row to fp */
177
178			FILE *fp;
179			struct MAZE *mzp;
180			int row;
181
182			{
183			register int j;
184
185			for (j = mzp->cl; j < mzp->cr; j++)
186			if (mzp->r0[row][j] == YES)
187			plseg(0, jcellsize, (XYSIZE-1)-rowcellsize, (j+1)cellsize, (XYSIZE-1)-rowcellsize);
188
189			}
190
191
192
193
194
195			putcline(fp, mzp, row, mrks) /* print column line to fp */
196
197			FILE *fp;
198			struct MAZE *mzp;
199			int row;
200			char mrks[];
201
202			{
203			register int j;
204			char s[2];
205
206			s[1] = '\0';
207
208			for (j = mzp->cl; j <= mzp->cr; j++)
209			if (mzp->c0[j][row] == YES)
210			plseg(0, jcellsize, (XYSIZE-1)-rowcellsize, jcellsize, (XYSIZE-1)-(row+1)cellsize);
211
212			}
213
214
215
216
217
218			readmaze(fp, mzp, mrks) /* read maze from fp into mzp */
219
220			FILE *fp;
221			struct MAZE *mzp;
222			char *mrks;
223
224			{
225			int i;
226
227			mzp->rt = mzp->rb = mzp->cl = mzp->cr = mzp->nrows = mzp ->ncols = 0;
228
229			if ((mzp->cr = mzp->ncols = getrline(fp, mzp, 0)) == 0)
230			return(ERROR);
231
232			for (i = 0; i <= MAXSIDE; i++) {
233
234			if (getcline(fp, mzp, i, mrks) != mzp->ncols)
235			break;
236
237			if (getrline(fp, mzp, i+1) != mzp->ncols)
238			return(ERROR);
239
240			}
241
242			if (i > MAXSIDE)
243			return(ERROR);
244
245			mzp->rb = mzp->nrows = i;
246			return(OK);
247			}
248
249
250
251			getrline(fp, mzp, row) /* get row from fp */
252
253			FILE *fp;
254			struct MAZE *mzp;
255			int row;
256
257			{
258			int j, nc;
259			char fgets(), linbuf[4 + 4MAXSIDE];
260
261			if (fgets(linbuf, sizeof(linbuf), fp) == NULL)
262			return(0);
263
264			nc = (strlen(linbuf) - 2) / 4;
265
266			for (j = 0; j < nc; j++)
267
268			switch (linbuf[2 + 4*j]) {
269
270			case HSEP:
271			mzp->r0[row][j] = YES;
272			break;
273
274			case ' ':
275			mzp->r0[row][j] = NO;
276			break;
277
278			default:
279			return(0);
280			break;
281
282			}
283
284			return(nc);
285			}
286
287
288
289
290
291			getcline(fp, mzp, row, mrks) /* get column line from fp */
292
293			FILE *fp;
294			struct MAZE *mzp;
295			int row;
296			char mrks[];
297
298			{
299			int j, nc, k;
300			char fgets(), linbuf[4 + 4MAXSIDE];
301
302			if (fgets(linbuf, sizeof(linbuf), fp) == NULL)
303			return(0);
304
305			nc = (strlen(linbuf) - 2) / 4;
306
307			for (j = 0; j < nc; j++) {
308
309			switch (linbuf[4*j]) {
310
311			case VSEP:
312			mzp->c0[j][row] = YES;
313			break;
314
315			case ' ':
316			mzp->c0[j][row] = NO;
317			break;
318
319			default:
320			return(0);
321			break;
322
323			}
324
325			for (k = 0; mrks[k]; k++)
326
327			if (linbuf[2 + 4*j] == mrks[k]) {
328			mzp->mark[row][j] = k;
329			break;
330			}
331
332			if (!mrks[k])
333			return(0);
334
335			}
336
337			switch (linbuf[4*nc]) {
338
339			case VSEP:
340			mzp->c0[nc][row] = YES;
341			break;
342
343			case ' ':
344			mzp->c0[nc][row] = NO;
345			break;
346
347			default:
348			return(0);
349			break;
350
351			}
352
353			return(nc);
354			}