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