![[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 / xrogue|
Return to maze.c CVS log | Up to [contributed] / early-roguelike / xrogue |
1.1 ! rubenllo 1: /*
! 2: maze.c - functions for dealing with mazes
! 3:
! 4: XRogue: Expeditions into the Dungeons of Doom
! 5: Copyright (C) 1991 Robert Pietkivitch
! 6: All rights reserved.
! 7:
! 8: Based on "Advanced Rogue"
! 9: Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
! 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 <curses.h>
! 17: #include "rogue.h"
! 18:
! 19: struct cell {
! 20: char y_pos;
! 21: char x_pos;
! 22: };
! 23: struct b_cellscells {
! 24: unsigned char num_pos; /* number of frontier cells next to you */
! 25: struct cell conn[4]; /* the y,x position of above cell */
! 26: } b_cells;
! 27:
! 28: static char *maze_frontier, *maze_bits;
! 29: static int maze_lines, maze_cols;
! 30: static char *moffset(int y, int x);
! 31: static char *foffset(int y, int x);
! 32: static void rmwall(int newy, int newx, int oldy, int oldx);
! 33: static void draw_maze(void);
! 34: static int findcells(int y, int x);
! 35:
! 36: /*
! 37: * crankout:
! 38: * Does actual drawing of maze to window
! 39: */
! 40:
! 41: static
! 42: void
! 43: crankout(void)
! 44: {
! 45: reg int x, y;
! 46:
! 47: for (y = 0; y < lines - 3; y++) {
! 48: move(y + 1, 0);
! 49: for (x = 0; x < cols - 1; x++) {
! 50: if (*moffset(y, x)) { /* here is a wall */
! 51: if(y==0 || y==lines-4) /* top or bottom line */
! 52: addch(HORZWALL);
! 53: else if(x==0 || x==cols-2) /* left | right side */
! 54: addch(VERTWALL);
! 55: else if (y % 2 == 0 && x % 2 == 0) {
! 56: if(*moffset(y, x-1) || *moffset(y, x+1))
! 57: addch(HORZWALL);
! 58: else
! 59: addch(VERTWALL);
! 60: }
! 61: else if (y % 2 == 0)
! 62: addch(HORZWALL);
! 63: else
! 64: addch(VERTWALL);
! 65: }
! 66: else
! 67: addch(FLOOR);
! 68: }
! 69: }
! 70: }
! 71:
! 72: /*
! 73: * domaze:
! 74: * Draw the maze on this level.
! 75: */
! 76:
! 77: void
! 78: do_maze(void)
! 79: {
! 80: reg int least;
! 81: reg struct room *rp;
! 82: reg struct linked_list *item;
! 83: reg struct object *obj;
! 84: int cnt;
! 85: bool treas;
! 86: coord tp;
! 87:
! 88: for (rp = rooms; rp < &rooms[MAXROOMS]; rp++) {
! 89: rp->r_flags = ISGONE; /* kill all rooms */
! 90: rp->r_fires = NULL; /* no fires */
! 91: }
! 92: rp = &rooms[0]; /* point to only room */
! 93: rp->r_flags = ISDARK; /* mazes always dark */
! 94: rp->r_pos.x = 0; /* room fills whole screen */
! 95: rp->r_pos.y = 1;
! 96: rp->r_max.x = cols - 1;
! 97: rp->r_max.y = lines - 3;
! 98: draw_maze(); /* put maze into window */
! 99: /*
! 100: * add some gold to make it worth looking for
! 101: */
! 102: item = spec_item(GOLD, 0, 0, 0);
! 103: obj = OBJPTR(item);
! 104: obj->o_count *= (rnd(50) + 50); /* add in one large hunk */
! 105: attach(lvl_obj, item);
! 106: cnt = 0;
! 107: do {
! 108: rnd_pos(rp, &tp);
! 109: } until (mvinch(tp.y, tp.x) == FLOOR || cnt++ > 2500);
! 110: mvaddch(tp.y, tp.x, GOLD);
! 111: obj->o_pos = tp;
! 112: /*
! 113: * add in some food to make sure he has enough
! 114: */
! 115: item = spec_item(FOOD, 0, 0, 0);
! 116: obj = OBJPTR(item);
! 117: attach(lvl_obj, item);
! 118: do {
! 119: rnd_pos(rp, &tp);
! 120: } until (mvinch(tp.y, tp.x) == FLOOR || cnt++ > 2500);
! 121: mvaddch(tp.y, tp.x, FOOD);
! 122: obj->o_pos = tp;
! 123:
! 124: /* it doesn't mater if it's a treasure maze or a normal maze,
! 125: * more than enough monsters will be genned.
! 126: */
! 127: least = rnd(11)+5;
! 128: if (least < 6) {
! 129: least = 7;
! 130: treas = FALSE;
! 131: }
! 132: else treas = TRUE;
! 133: genmonsters(least, treas);
! 134:
! 135: /* sometimes they're real angry */
! 136: if (rnd(100) < 65) {
! 137: /* protect the good charactors */
! 138: if (player.t_ctype == C_PALADIN ||
! 139: player.t_ctype == C_RANGER || player.t_ctype == C_MONK) {
! 140: aggravate(TRUE, FALSE);
! 141: }
! 142: else {
! 143: aggravate(TRUE, TRUE);
! 144: }
! 145: }
! 146: }
! 147:
! 148: /*
! 149: * draw_maze:
! 150: * Generate and draw the maze on the screen
! 151: */
! 152:
! 153: static
! 154: void
! 155: draw_maze(void)
! 156: {
! 157: reg int i, j, more;
! 158: reg char *ptr;
! 159:
! 160: maze_lines = (lines - 3) / 2;
! 161: maze_cols = (cols - 1) / 2;
! 162: maze_bits = ALLOC((lines - 3) * (cols - 1));
! 163: maze_frontier = ALLOC(maze_lines * maze_cols);
! 164: ptr = maze_frontier;
! 165: while (ptr < (maze_frontier + (maze_lines * maze_cols)))
! 166: *ptr++ = TRUE;
! 167: for (i = 0; i < lines - 3; i++) {
! 168: for (j = 0; j < cols - 1; j++) {
! 169: if (i % 2 == 1 && j % 2 == 1)
! 170: *moffset(i, j) = FALSE; /* floor */
! 171: else
! 172: *moffset(i, j) = TRUE; /* wall */
! 173: }
! 174: }
! 175: for (i = 0; i < maze_lines; i++) {
! 176: for (j = 0; j < maze_cols; j++) {
! 177: do
! 178: more = findcells(i,j);
! 179: while(more != 0);
! 180: }
! 181: }
! 182: crankout();
! 183: FREE(maze_frontier);
! 184: FREE(maze_bits);
! 185: }
! 186:
! 187: /*
! 188: * findcells:
! 189: * Figure out cells to open up
! 190: */
! 191:
! 192: static int
! 193: findcells(int y, int x)
! 194: {
! 195: reg int rtpos, i;
! 196:
! 197: *foffset(y, x) = FALSE;
! 198: b_cells.num_pos = 0;
! 199: if (y < maze_lines - 1) { /* look below */
! 200: if (*foffset(y + 1, x)) {
! 201: b_cells.conn[b_cells.num_pos].y_pos = y + 1;
! 202: b_cells.conn[b_cells.num_pos].x_pos = x;
! 203: b_cells.num_pos += 1;
! 204: }
! 205: }
! 206: if (y > 0) { /* look above */
! 207: if (*foffset(y - 1, x)) {
! 208: b_cells.conn[b_cells.num_pos].y_pos = y - 1;
! 209: b_cells.conn[b_cells.num_pos].x_pos = x;
! 210: b_cells.num_pos += 1;
! 211:
! 212: }
! 213: }
! 214: if (x < maze_cols - 1) { /* look right */
! 215: if (*foffset(y, x + 1)) {
! 216: b_cells.conn[b_cells.num_pos].y_pos = y;
! 217: b_cells.conn[b_cells.num_pos].x_pos = x + 1;
! 218: b_cells.num_pos += 1;
! 219: }
! 220: }
! 221: if (x > 0) { /* look left */
! 222: if (*foffset(y, x - 1)) {
! 223: b_cells.conn[b_cells.num_pos].y_pos = y;
! 224: b_cells.conn[b_cells.num_pos].x_pos = x - 1;
! 225: b_cells.num_pos += 1;
! 226:
! 227: }
! 228: }
! 229: if (b_cells.num_pos == 0) /* no neighbors available */
! 230: return 0;
! 231: else {
! 232: i = rnd(b_cells.num_pos);
! 233: rtpos = b_cells.num_pos - 1;
! 234: rmwall(b_cells.conn[i].y_pos, b_cells.conn[i].x_pos, y, x);
! 235: return rtpos;
! 236: }
! 237: }
! 238:
! 239: /*
! 240: * foffset:
! 241: * Calculate memory address for frontier
! 242: */
! 243:
! 244: static char *
! 245: foffset(int y, int x)
! 246: {
! 247:
! 248: return (maze_frontier + (y * maze_cols) + x);
! 249: }
! 250:
! 251:
! 252: /*
! 253: * Maze_view:
! 254: * Returns true if the player can see the specified location within
! 255: * the confines of a maze (within one column or row)
! 256: */
! 257:
! 258: bool
! 259: maze_view(int y, int x)
! 260: {
! 261: register int start, goal, delta, ycheck = 0, xcheck = 0, absy, absx, see_radius;
! 262: register bool row;
! 263:
! 264: /* Get the absolute value of y and x differences */
! 265: absy = hero.y - y;
! 266: absx = hero.x - x;
! 267: if (absy < 0) absy = -absy;
! 268: if (absx < 0) absx = -absx;
! 269:
! 270: /* If we are standing in a wall, we can see a bit more */
! 271: switch (winat(hero.y, hero.x)) {
! 272: case VERTWALL:
! 273: case HORZWALL:
! 274: case WALL:
! 275: case SECRETDOOR:
! 276: case DOOR:
! 277: see_radius = 2;
! 278: otherwise:
! 279: see_radius = 1;
! 280: }
! 281:
! 282: /* Must be within one or two rows or columns */
! 283: if (absy > see_radius && absx > see_radius) return(FALSE);
! 284:
! 285: if (absx > see_radius) { /* Go along row */
! 286: start = hero.x;
! 287: goal = x;
! 288: ycheck = hero.y;
! 289: row = TRUE;
! 290: }
! 291: else { /* Go along column */
! 292: start = hero.y;
! 293: goal = y;
! 294: xcheck = hero.x;
! 295: row = FALSE;
! 296: }
! 297:
! 298: if (start <= goal) delta = 1;
! 299: else delta = -1;
! 300:
! 301: /* Start one past where we are standing */
! 302: if (start != goal) start += delta;
! 303:
! 304: /* If we are in a wall, we want to look in the area outside the wall */
! 305: if (see_radius > 1) {
! 306: if (row) {
! 307: /* See if above us it okay first */
! 308: switch (winat(ycheck, start)) {
! 309: case VERTWALL:
! 310: case HORZWALL:
! 311: case WALL:
! 312: case DOOR:
! 313: case SECRETDOOR:
! 314: /* No good, try one up */
! 315: if (y > hero.y) ycheck++;
! 316: else ycheck--;
! 317: otherwise:
! 318: see_radius = 1; /* Just look straight over the row */
! 319: }
! 320: }
! 321: else {
! 322: /* See if above us it okay first */
! 323: switch (winat(start, xcheck)) {
! 324: case VERTWALL:
! 325: case HORZWALL:
! 326: case WALL:
! 327: case DOOR:
! 328: case SECRETDOOR:
! 329: /* No good, try one over */
! 330: if (x > hero.x) xcheck++;
! 331: else xcheck--;
! 332: otherwise:
! 333: see_radius = 1; /* Just look straight up the column */
! 334: }
! 335: }
! 336: }
! 337:
! 338: /* Check boundary again */
! 339: if (absy > see_radius && absx > see_radius) return(FALSE);
! 340:
! 341: while (start != goal) {
! 342: if (row) xcheck = start;
! 343: else ycheck = start;
! 344:
! 345: if (xcheck < 0 || ycheck < 0)
! 346: return FALSE;
! 347: switch (winat(ycheck, xcheck)) {
! 348: case VERTWALL:
! 349: case HORZWALL:
! 350: case WALL:
! 351: case DOOR:
! 352: case SECRETDOOR:
! 353: return(FALSE);
! 354: }
! 355: start += delta;
! 356: }
! 357: return(TRUE);
! 358: }
! 359:
! 360:
! 361: /*
! 362: * moffset:
! 363: * Calculate memory address for bits
! 364: */
! 365:
! 366: static char *
! 367: moffset(int y, int x)
! 368: {
! 369: return (maze_bits + (y * (cols - 1)) + x);
! 370: }
! 371:
! 372: /*
! 373: * rmwall:
! 374: * Removes appropriate walls from the maze
! 375: */
! 376: static
! 377: void
! 378: rmwall(int newy, int newx, int oldy, int oldx)
! 379: {
! 380: reg int xdif,ydif;
! 381:
! 382: xdif = newx - oldx;
! 383: ydif = newy - oldy;
! 384:
! 385: *moffset((oldy * 2) + ydif + 1, (oldx * 2) + xdif + 1) = FALSE;
! 386: findcells(newy, newx);
! 387: }
! 388: