src/meta/cvmaze.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#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;

#define  CPMEOF  0x1a


main(argc, argv)

int  argc;
char  **argv;

{
    FILE  *fp;

#ifdef  CPM
    fixargs("cvmaze", &argc, &argv);
#endif
    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.1
Committed:	Sat Feb 22 02:07:26 2003 UTC (21 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R5
Log Message:	Changes and check-in for 3.5 release Includes new source files and modifications not recorded for many years See ray/doc/notes/ReleaseNotes for notes between 3.1 and 3.5 release
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2			static const char RCSid[] = "$Id$";
3			#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			#define CPMEOF 0x1a
99
100
101			main(argc, argv)
102
103			int argc;
104			char **argv;
105
106			{
107			FILE *fp;
108
109			#ifdef CPM
110			fixargs("cvmaze", &argc, &argv);
111			#endif
112			progname = *argv++;
113			argc--;
114
115			if (argc)
116
117			for ( ; argc; argc--, argv++) {
118			if ((fp = fopen(*argv, "r")) == NULL) {
119			fprintf(stderr, "%s: no such file\n", *argv);
120			exit(1);
121			}
122			execute(fp);
123			fclose(fp);
124			}
125
126			else
127
128			execute(stdin);
129
130			writeof(stdout);
131
132			return(0);
133			}
134
135
136
137
138			execute(fp) /* process file fp */
139
140			FILE *fp;
141
142			{
143
144			while (readmaze(fp, &amaze, MARKS) != ERROR) {
145
146			cellsize = (XYSIZE-1)/max(amaze.nrows, amaze.ncols);
147			printmaze(stdout, &amaze, MARKS);
148			pglob(PEOP, 0200, NULL);
149			}
150
151			}
152
153
154
155
156
157			printmaze(fp, mzp, mrks) /* print maze to fp */
158
159			FILE *fp;
160			struct MAZE *mzp;
161			char *mrks;
162
163			{
164			int i;
165
166			for (i = mzp->rt; i < mzp->rb; i++) {
167
168			putrline(fp, mzp, i);
169
170			putcline(fp, mzp, i, mrks);
171
172			}
173
174			putrline(fp, mzp, mzp->rb);
175
176			}
177
178
179
180
181			putrline(fp, mzp, row) /* print horizontal row to fp */
182
183			FILE *fp;
184			struct MAZE *mzp;
185			int row;
186
187			{
188			register int j;
189
190			for (j = mzp->cl; j < mzp->cr; j++)
191			if (mzp->r0[row][j] == YES)
192			plseg(0, jcellsize, (XYSIZE-1)-rowcellsize, (j+1)cellsize, (XYSIZE-1)-rowcellsize);
193
194			}
195
196
197
198
199
200			putcline(fp, mzp, row, mrks) /* print column line to fp */
201
202			FILE *fp;
203			struct MAZE *mzp;
204			int row;
205			char mrks[];
206
207			{
208			register int j;
209			char s[2];
210
211			s[1] = '\0';
212
213			for (j = mzp->cl; j <= mzp->cr; j++)
214			if (mzp->c0[j][row] == YES)
215			plseg(0, jcellsize, (XYSIZE-1)-rowcellsize, jcellsize, (XYSIZE-1)-(row+1)cellsize);
216
217			}
218
219
220
221
222
223			readmaze(fp, mzp, mrks) /* read maze from fp into mzp */
224
225			FILE *fp;
226			struct MAZE *mzp;
227			char *mrks;
228
229			{
230			int i;
231
232			mzp->rt = mzp->rb = mzp->cl = mzp->cr = mzp->nrows = mzp ->ncols = 0;
233
234			if ((mzp->cr = mzp->ncols = getrline(fp, mzp, 0)) == 0)
235			return(ERROR);
236
237			for (i = 0; i <= MAXSIDE; i++) {
238
239			if (getcline(fp, mzp, i, mrks) != mzp->ncols)
240			break;
241
242			if (getrline(fp, mzp, i+1) != mzp->ncols)
243			return(ERROR);
244
245			}
246
247			if (i > MAXSIDE)
248			return(ERROR);
249
250			mzp->rb = mzp->nrows = i;
251			return(OK);
252			}
253
254
255
256			getrline(fp, mzp, row) /* get row from fp */
257
258			FILE *fp;
259			struct MAZE *mzp;
260			int row;
261
262			{
263			int j, nc;
264			char fgets(), linbuf[4 + 4MAXSIDE];
265
266			if (fgets(linbuf, sizeof(linbuf), fp) == NULL)
267			return(0);
268
269			nc = (strlen(linbuf) - 2) / 4;
270
271			for (j = 0; j < nc; j++)
272
273			switch (linbuf[2 + 4*j]) {
274
275			case HSEP:
276			mzp->r0[row][j] = YES;
277			break;
278
279			case ' ':
280			mzp->r0[row][j] = NO;
281			break;
282
283			default:
284			return(0);
285			break;
286
287			}
288
289			return(nc);
290			}
291
292
293
294
295
296			getcline(fp, mzp, row, mrks) /* get column line from fp */
297
298			FILE *fp;
299			struct MAZE *mzp;
300			int row;
301			char mrks[];
302
303			{
304			int j, nc, k;
305			char fgets(), linbuf[4 + 4MAXSIDE];
306
307			if (fgets(linbuf, sizeof(linbuf), fp) == NULL)
308			return(0);
309
310			nc = (strlen(linbuf) - 2) / 4;
311
312			for (j = 0; j < nc; j++) {
313
314			switch (linbuf[4*j]) {
315
316			case VSEP:
317			mzp->c0[j][row] = YES;
318			break;
319
320			case ' ':
321			mzp->c0[j][row] = NO;
322			break;
323
324			default:
325			return(0);
326			break;
327
328			}
329
330			for (k = 0; mrks[k]; k++)
331
332			if (linbuf[2 + 4*j] == mrks[k]) {
333			mzp->mark[row][j] = k;
334			break;
335			}
336
337			if (!mrks[k])
338			return(0);
339
340			}
341
342			switch (linbuf[4*nc]) {
343
344			case VSEP:
345			mzp->c0[nc][row] = YES;
346			break;
347
348			case ' ':
349			mzp->c0[nc][row] = NO;
350			break;
351
352			default:
353			return(0);
354			break;
355
356			}
357
358			return(nc);
359			}