![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to passages.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 passages.c CVS log | Up to [contributed] / early-roguelike / urogue |
1.1 rubenllo 1: /*
2: passages.c - Draw the connecting passages
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: Based on "Rogue: Exploring the Dungeons of Doom"
13: Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
14: All rights reserved.
15:
16: See the file LICENSE.TXT for full copyright and licensing information.
17: */
18:
19: #include <stdlib.h>
20: #include "rogue.h"
21:
22: #define cmov(xy) move((xy).y, (xy).x)
23:
24: /*
25: do_passages()
26: Draw all the passages on a level.
27: */
28:
29: void
30: do_passages(void)
31: {
32: struct rdes *r1, *r2 = NULL;
33: int i, j;
34: int roomcount;
35:
36: static struct rdes rdes[MAXROOMS] =
37: {
38: {{ 0, 1, 0, 1, 0, 0, 0, 0, 0},
39: { 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0},
40: {{ 1, 0, 1, 0, 1, 0, 0, 0, 0},
41: { 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0},
42: {{ 0, 1, 0, 0, 0, 1, 0, 0, 0},
43: { 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0},
44: {{ 1, 0, 0, 0, 1, 0, 1, 0, 0},
45: { 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0},
46: {{ 0, 1, 0, 1, 0, 1, 0, 1, 0},
47: { 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0},
48: {{ 0, 0, 1, 0, 1, 0, 0, 0, 1},
49: { 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0},
50: {{ 0, 0, 0, 1, 0, 0, 0, 1, 0},
51: { 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0},
52: {{ 0, 0, 0, 0, 1, 0, 1, 0, 1},
53: { 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0},
54: {{ 0, 0, 0, 0, 0, 1, 0, 1, 0},
55: { 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0}
56: };
57:
58: /* reinitialize room graph description */
59:
60: for (r1 = rdes; r1 < &rdes[MAXROOMS]; r1++)
61: {
62: for (j = 0; j < MAXROOMS; j++)
63: r1->isconn[j] = FALSE;
64:
65: r1->ingraph = FALSE;
66: }
67:
68: /*
69: * starting with one room, connect it to a random adjacent room and
70: * then pick a new room to start with.
71: */
72:
73: roomcount = 1;
74: r1 = &rdes[rnd(MAXROOMS)];
75: r1->ingraph = TRUE;
76:
77: do
78: {
79: j = 0;
80:
81: for (i = 0; i < MAXROOMS; i++)
82: if (r1->conn[i] && !rdes[i].ingraph && rnd(++j) == 0)
83: r2 = &rdes[i];
84:
85: /*
86: * if no adjacent rooms are outside the graph, pick a new
87: * room to look from
88: */
89:
90: if (j == 0)
91: do
92: {
93: r1 = &rdes[rnd(MAXROOMS)];
94: }
95: while (!r1->ingraph);
96:
97: /*
98: * otherwise, connect new room to the graph, and draw a
99: * tunnel to it
100: */
101: else
102: {
103: r2->ingraph = TRUE;
104: i = (int)(r1 - rdes);
105: j = (int)(r2 - rdes);
106: conn(i, j);
107: r1->isconn[j] = TRUE;
108: r2->isconn[i] = TRUE;
109: roomcount++;
110: }
111: }
112: while (roomcount < MAXROOMS);
113:
114: /*
115: * attempt to add passages to the graph a random number of times so
116: * that there isn't just one unique passage through it.
117: */
118:
119: for (roomcount = rnd(5); roomcount > 0; roomcount--)
120: {
121: r1 = &rdes[rnd(MAXROOMS)]; /* a random room to look from */
122:
123: /*
124: * find an adjacent room not already connected
125: */
126:
127: j = 0;
128: for (i = 0; i < MAXROOMS; i++)
129: if (r1->conn[i] && !r1->isconn[i] && rnd(++j) == 0)
130: r2 = &rdes[i];
131:
132: /*
133: * if there is one, connect it and look for the next added
134: * passage
135: */
136:
137: if (j != 0)
138: {
139: i = (int)(r1 - rdes);
140: j = (int)(r2 - rdes);
141: conn(i, j);
142: r1->isconn[j] = TRUE;
143: r2->isconn[i] = TRUE;
144: }
145: }
146: }
147:
148: /*
149: conn()
150: Draw a corridor from a room in a certain direction.
151: */
152:
153: void
154: conn(int r1, int r2)
155: {
156: struct room *rpf, *rpt = NULL;
157: int rmt;
158: int distance = 0, turn_spot = 0, turn_distance = 0;
159: int rm;
160: char direc;
161: coord delt = {0,0}, curr, turn_delta = {0,0}, spos = {0,0}, epos = {0,0};
162:
163: if (r1 < r2)
164: {
165: rm = r1;
166:
167: if (r1 + 1 == r2)
168: direc = 'r';
169: else
170: direc = 'd';
171: }
172: else
173: {
174: rm = r2;
175:
176: if (r2 + 1 == r1)
177: direc = 'r';
178: else
179: direc = 'd';
180: }
181:
182: rpf = &rooms[rm];
183:
184: /*
185: * Set up the movement variables, in two cases: first drawing one
186: * down.
187: */
188:
189: if (direc == 'd')
190: {
191: rmt = rm + 3; /* room # of dest */
192: rpt = &rooms[rmt]; /* room pointer of dest */
193: delt.x = 0; /* direction of move */
194: delt.y = 1;
195: spos.x = rpf->r_pos.x; /* start of move */
196: spos.y = rpf->r_pos.y;
197: epos.x = rpt->r_pos.x; /* end of move */
198: epos.y = rpt->r_pos.y;
199:
200: if (!(rpf->r_flags & ISGONE)) /* if not gone pick door pos */
201: {
202: spos.x += rnd(rpf->r_max.x - 2) + 1;
203: spos.y += rpf->r_max.y - 1;
204: }
205:
206: if (!(rpt->r_flags & ISGONE))
207: epos.x += rnd(rpt->r_max.x - 2) + 1;
208:
209: distance = abs(spos.y - epos.y) - 1; /* distance to move */
210: turn_delta.y = 0; /* direction to turn */
211: turn_delta.x = (spos.x < epos.x ? 1 : -1);
212: turn_distance = abs(spos.x - epos.x); /* how far to turn */
213: turn_spot = rnd(distance - 1) + 1; /* where turn starts */
214: }
215: else if (direc == 'r') /* setup for moving right */
216: {
217: rmt = rm + 1;
218: rpt = &rooms[rmt];
219: delt.x = 1;
220: delt.y = 0;
221: spos.x = rpf->r_pos.x;
222: spos.y = rpf->r_pos.y;
223: epos.x = rpt->r_pos.x;
224: epos.y = rpt->r_pos.y;
225:
226: if (!(rpf->r_flags & ISGONE))
227: {
228: spos.x += rpf->r_max.x - 1;
229: spos.y += rnd(rpf->r_max.y - 2) + 1;
230: }
231:
232: if (!(rpt->r_flags & ISGONE))
233: epos.y += rnd(rpt->r_max.y - 2) + 1;
234:
235: distance = abs(spos.x - epos.x) - 1;
236: turn_delta.y = (spos.y < epos.y ? 1 : -1);
237: turn_delta.x = 0;
238: turn_distance = abs(spos.y - epos.y);
239: turn_spot = rnd(distance - 1) + 1;
240: }
241: else
242: debug("Error in connection tables.");
243:
244: /*
245: * Draw in the doors on either side of the passage or just put #'s if
246: * the rooms are gone.
247: */
248:
249: if (!(rpf->r_flags & ISGONE))
250: door(rpf, &spos);
251: else
252: {
253: cmov(spos);
254: addch('#');
255: }
256:
257: if (!(rpt->r_flags & ISGONE))
258: door(rpt, &epos);
259: else
260: {
261: cmov(epos);
262: addch('#');
263: }
264:
265: /* Get ready to move... */
266:
267: curr.x = spos.x;
268: curr.y = spos.y;
269:
270: while (distance)
271: {
272: /* Move to new position */
273:
274: curr.x += delt.x;
275: curr.y += delt.y;
276:
277: /* Check if we are at the turn place, if so do the turn */
278:
279: if (distance == turn_spot && turn_distance > 0)
280: while (turn_distance--)
281: {
282: cmov(curr);
283: addch(PASSAGE);
284: curr.x += turn_delta.x;
285: curr.y += turn_delta.y;
286: }
287:
288: /* Continue digging along */
289:
290: cmov(curr);
291: addch(PASSAGE);
292: distance--;
293: }
294:
295: curr.x += delt.x;
296: curr.y += delt.y;
297:
298: if (!ce(curr, epos))
299: msg("Warning, connectivity problem on this level.");
300: }
301:
302: /*
303: door()
304: Add a door or possibly a secret door also enters the door in the exits
305: array of the room.
306: */
307:
308: void
309: door(struct room *rm, coord *cp)
310: {
311: char a_door;
312:
313: cmov(*cp);
314:
315: a_door = (rnd(10)<level - 1 && rnd(100) < 20) ? SECRETDOOR : DOOR;
316:
317: addch(a_door);
318:
319: rm->r_exit[rm->r_nexits++] = *cp;
320: }