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