![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to maze.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / urogue|
Return to maze.c CVS log | Up to [contributed] / early-roguelike / urogue |
1.1 rubenllo 1: /*
2: maze.c - functions for dealing with armor
3:
4: UltraRogue: The Ultimate Adventure in the Dungeons of Doom
5: Copyright (C) 1985, 1986, 1992, 1993, 1995 Herb Chong
6: All rights reserved.
7:
8: Based on "Advanced Rogue"
9: Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka
10: All rights reserved.
11:
12: See the file LICENSE.TXT for full copyright and licensing information.
13: */
14:
15: #include <stdlib.h>
16: #include "rogue.h"
17:
18: static char *frontier;
19: static char *bits;
20: static int urlines;
21: static int urcols;
22:
23: /*
24: domaze()
25: Draw the maze on this level.
26: */
27:
28: void
29: do_maze(void)
30: {
31: int i, least;
32: struct room *rp;
33: struct linked_list *item;
34: struct object *obj;
35: struct thing *mp;
36: int treas;
37: coord tp;
38:
39: for (rp = rooms; rp < &rooms[MAXROOMS]; rp++)
40: {
41: rp->r_nexits = 0; /* no exits */
42: rp->r_flags = ISGONE; /* kill all rooms */
43: rp->r_fires = 0; /* no fires */
44: }
45:
46: rp = &rooms[0]; /* point to only room */
47: rp->r_flags = ISDARK; /* mazes always dark */
48: rp->r_pos.x = 0; /* room fills whole screen */
49: rp->r_pos.y = 1;
50: rp->r_max.x = COLS - 1;
51: rp->r_max.y = LINES - 3;
52: draw_maze(); /* put maze into window */
53:
54: /* add some gold to make it worth looking for */
55:
56: item = spec_item(GOLD, 0, 0, 0);
57: obj = OBJPTR(item);
58: obj->o_count *= (rnd(10) + 5); /* add in one large hunk */
59:
60: do
61: {
62: rnd_pos(rp, &tp);
63: }
64: while( mvwinch(stdscr, tp.y, tp.x) != FLOOR);
65:
66: obj->o_pos = tp;
67: add_obj(item, tp.y, tp.x);
68:
69: /* add in some food to make sure he has enough */
70:
71: item = spec_item(FOOD, 0, 0, 0);
72: obj = OBJPTR(item);
73:
74: do
75: {
76: rnd_pos(rp, &tp);
77: }
78: while( mvwinch(stdscr, tp.y, tp.x) != FLOOR);
79:
80: obj->o_pos = tp;
81: add_obj(item, tp.y, tp.x);
82:
83: if (rnd(100) < 5) /* 5% for treasure maze level */
84: {
85: treas = TRUE;
86: least = 20;
87: debug("Treasure maze.");
88: }
89: else /* normal maze level */
90: {
91: least = 1;
92: treas = FALSE;
93: }
94:
95: for (i = 0; i < level + least; i++)
96: {
97: if (!treas && rnd(100) < 50) /* put in some little buggers */
98: continue;
99:
100: /* Put the monster in */
101:
102: item = new_item(sizeof *mp);
103:
104: mp = THINGPTR(item);
105:
106: do
107: {
108: rnd_pos(rp, &tp);
109: }
110: while(mvwinch(stdscr, tp.y, tp.x) != FLOOR);
111:
112: new_monster(item, randmonster(NOWANDER, NOGRAB), &tp, NOMAXSTATS);
113:
114: /* See if we want to give it a treasure to carry around. */
115:
116: if (rnd(100) < monsters[mp->t_index].m_carry)
117: attach(mp->t_pack, new_thing());
118:
119: /* If it carries gold, give it some */
120:
121: if (on(*mp, CARRYGOLD))
122: {
123: item = spec_item(GOLD, 0, 0, 0);
124: obj = OBJPTR(item);
125: obj->o_count = GOLDCALC + GOLDCALC + GOLDCALC;
126: obj->o_pos = mp->t_pos;
127: attach(mp->t_pack, item);
128: }
129:
130: }
131: }
132:
133: /*
134: draw_maze()
135: Generate and draw the maze on the screen
136: */
137:
138: void
139: draw_maze(void)
140: {
141: int i, j, more;
142: char *ptr;
143:
144: urlines = (LINES - 3) / 2;
145: urcols = (COLS - 1) / 2;
146:
147: bits = ur_alloc((unsigned int) ((LINES - 3) * (COLS - 1)));
148: frontier = ur_alloc((unsigned int) (urlines * urcols));
149: ptr = frontier;
150:
151: while (ptr < (frontier + (urlines * urcols)))
152: *ptr++ = TRUE;
153:
154: for (i = 0; i < LINES - 3; i++)
155: {
156: for (j = 0; j < COLS - 1; j++)
157: {
158: if (i % 2 == 1 && j % 2 == 1)
159: *moffset(i, j) = FALSE; /* floor */
160: else
161: *moffset(i, j) = TRUE; /* wall */
162: }
163: }
164:
165: for (i = 0; i < urlines; i++)
166: {
167: for (j = 0; j < urcols; j++)
168: {
169: do
170: more = findcells(i, j);
171: while (more != 0);
172: }
173: }
174:
175: crankout();
176: ur_free(frontier);
177: ur_free(bits);
178: }
179:
180: /*
181: moffset()
182: Calculate memory address for bits
183: */
184:
185: char *
186: moffset(int y, int x)
187: {
188: return (bits + (y * (COLS - 1)) + x);
189: }
190:
191: /*
192: foffset()
193: Calculate memory address for frontier
194: */
195:
196: char *
197: foffset(int y, int x)
198: {
199: return (frontier + (y * urcols) + x);
200: }
201:
202: /*
203: findcells()
204: Figure out cells to open up
205: */
206:
207: int
208: findcells(int y, int x)
209: {
210: int rtpos, i;
211:
212: struct
213: {
214: int num_pos; /* number of frontier cells next to you */
215:
216: struct
217: {
218: int y_pos;
219: int x_pos;
220: } conn[4]; /* the y,x position of above cell */
221: } mborder;
222:
223: *foffset(y, x) = FALSE;
224: mborder.num_pos = 0;
225:
226: if (y < urlines - 1) { /* look below */
227: if (*foffset(y + 1, x))
228: {
229: mborder.conn[mborder.num_pos].y_pos = y + 1;
230: mborder.conn[mborder.num_pos].x_pos = x;
231: mborder.num_pos += 1;
232: }
233: }
234:
235: if (y > 0) /* look above */
236: {
237: if (*foffset(y - 1, x))
238: {
239: mborder.conn[mborder.num_pos].y_pos = y - 1;
240: mborder.conn[mborder.num_pos].x_pos = x;
241: mborder.num_pos += 1;
242: }
243: }
244:
245: if (x < urcols - 1) /* look right */
246: {
247: if (*foffset(y, x + 1))
248: {
249: mborder.conn[mborder.num_pos].y_pos = y;
250: mborder.conn[mborder.num_pos].x_pos = x + 1;
251: mborder.num_pos += 1;
252: }
253: }
254:
255: if (x > 0) /* look left */
256: {
257: if (*foffset(y, x - 1))
258: {
259: mborder.conn[mborder.num_pos].y_pos = y;
260: mborder.conn[mborder.num_pos].x_pos = x - 1;
261: mborder.num_pos += 1;
262: }
263: }
264:
265: if (mborder.num_pos == 0)/* no neighbors available */
266: return(0);
267: else
268: {
269: i = rnd(mborder.num_pos);
270: rtpos = mborder.num_pos - 1;
271: rmwall(mborder.conn[i].y_pos, mborder.conn[i].x_pos, y, x);
272: return(rtpos);
273: }
274: }
275:
276: /*
277: rmwall()
278: Removes appropriate walls from the maze
279: */
280:
281: void
282: rmwall(int newy, int newx, int oldy, int oldx)
283: {
284: int xdif, ydif;
285:
286: xdif = newx - oldx;
287: ydif = newy - oldy;
288:
289: *moffset((oldy * 2) + ydif + 1, (oldx * 2) + xdif + 1) = FALSE;
290:
291: findcells(newy, newx);
292: }
293:
294:
295: /*
296: crankout()
297: Does actual drawing of maze to window
298: */
299:
300: void
301: crankout(void)
302: {
303: int x, y;
304:
305: for (y = 0; y < LINES - 3; y++)
306: {
307: move(y + 1, 0);
308:
309: for (x = 0; x < COLS - 1; x++)
310: {
311: if (*moffset(y, x)) /* here is a wall */
312: {
313: if (y == 0 || y == LINES - 4) /* top or bottom line */
314: addch('-');
315: else if (x == 0 || x == COLS - 2) /* left | right side */
316: addch('|');
317: else if (y % 2 == 0 && x % 2 == 0)
318: {
319: if (*moffset(y, x - 1) || *moffset(y, x + 1))
320: addch('-');
321: else
322: addch('|');
323: }
324: else if (y % 2 == 0)
325: addch('-');
326: else
327: addch('|');
328: }
329: else
330: addch(FLOOR);
331: }
332: }
333: }