![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rooms.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / rogue5|
Return to rooms.c CVS log | Up to [contributed] / early-roguelike / rogue5 |
1.1 ! rubenllo 1: /*
! 2: * Create the layout for the new level
! 3: *
! 4: * @(#)rooms.c 4.45 (Berkeley) 02/05/99
! 5: *
! 6: * Rogue: Exploring the Dungeons of Doom
! 7: * Copyright (C) 1980-1983, 1985, 1999 Michael Toy, Ken Arnold and Glenn Wichman
! 8: * All rights reserved.
! 9: *
! 10: * See the file LICENSE.TXT for full copyright and licensing information.
! 11: */
! 12:
! 13: #include <ctype.h>
! 14: #include <curses.h>
! 15: #include "rogue.h"
! 16:
! 17: typedef struct spot { /* position matrix for maze positions */
! 18: int nexits;
! 19: coord exits[4];
! 20: int used;
! 21: } SPOT;
! 22:
! 23: #define GOLDGRP 1
! 24:
! 25: /*
! 26: * do_rooms:
! 27: * Create rooms and corridors with a connectivity graph
! 28: */
! 29:
! 30: void
! 31: do_rooms(void)
! 32: {
! 33: int i;
! 34: struct room *rp;
! 35: THING *tp;
! 36: int left_out;
! 37: coord top;
! 38: coord bsze; /* maximum room size */
! 39: coord mp;
! 40:
! 41: bsze.x = NUMCOLS / 3;
! 42: bsze.y = NUMLINES / 3;
! 43: /*
! 44: * Clear things for a new level
! 45: */
! 46: for (rp = rooms; rp < &rooms[MAXROOMS]; rp++)
! 47: {
! 48: rp->r_goldval = 0;
! 49: rp->r_nexits = 0;
! 50: rp->r_flags = 0;
! 51: }
! 52: /*
! 53: * Put the gone rooms, if any, on the level
! 54: */
! 55: left_out = rnd(4);
! 56: for (i = 0; i < left_out; i++)
! 57: rooms[rnd_room()].r_flags |= ISGONE;
! 58: /*
! 59: * dig and populate all the rooms on the level
! 60: */
! 61: for (i = 0, rp = rooms; i < MAXROOMS; rp++, i++)
! 62: {
! 63: /*
! 64: * Find upper left corner of box that this room goes in
! 65: */
! 66: top.x = (i % 3) * bsze.x + 1;
! 67: top.y = (i / 3) * bsze.y;
! 68: if (rp->r_flags & ISGONE)
! 69: {
! 70: /*
! 71: * Place a gone room. Make certain that there is a blank line
! 72: * for passage drawing.
! 73: */
! 74: do
! 75: {
! 76: rp->r_pos.x = top.x + rnd(bsze.x - 2) + 1;
! 77: rp->r_pos.y = top.y + rnd(bsze.y - 2) + 1;
! 78: rp->r_max.x = -NUMCOLS;
! 79: rp->r_max.y = -NUMLINES;
! 80: } until (rp->r_pos.y > 0 && rp->r_pos.y < NUMLINES-1);
! 81: continue;
! 82: }
! 83: /*
! 84: * set room type
! 85: */
! 86: if (rnd(10) < level - 1)
! 87: {
! 88: rp->r_flags |= ISDARK; /* dark room */
! 89: if (rnd(15) == 0)
! 90: rp->r_flags = ISMAZE; /* maze room */
! 91: }
! 92: /*
! 93: * Find a place and size for a random room
! 94: */
! 95: if (rp->r_flags & ISMAZE)
! 96: {
! 97: rp->r_max.x = bsze.x - 1;
! 98: rp->r_max.y = bsze.y - 1;
! 99: if ((rp->r_pos.x = top.x) == 1)
! 100: rp->r_pos.x = 0;
! 101: if ((rp->r_pos.y = top.y) == 0)
! 102: {
! 103: rp->r_pos.y++;
! 104: rp->r_max.y--;
! 105: }
! 106: }
! 107: else
! 108: do
! 109: {
! 110: rp->r_max.x = rnd(bsze.x - 4) + 4;
! 111: rp->r_max.y = rnd(bsze.y - 4) + 4;
! 112: rp->r_pos.x = top.x + rnd(bsze.x - rp->r_max.x);
! 113: rp->r_pos.y = top.y + rnd(bsze.y - rp->r_max.y);
! 114: } until (rp->r_pos.y != 0);
! 115: draw_room(rp);
! 116: /*
! 117: * Put the gold in
! 118: */
! 119: if (rnd(2) == 0 && (!amulet || level >= max_level))
! 120: {
! 121: THING *gold;
! 122:
! 123: gold = new_item();
! 124: gold->o_goldval = rp->r_goldval = GOLDCALC;
! 125: find_floor(rp, &rp->r_gold, FALSE, FALSE);
! 126: gold->o_pos = rp->r_gold;
! 127: chat(rp->r_gold.y, rp->r_gold.x) = GOLD;
! 128: gold->o_flags = ISMANY;
! 129: gold->o_group = GOLDGRP;
! 130: gold->o_type = GOLD;
! 131: attach(lvl_obj, gold);
! 132: }
! 133: /*
! 134: * Put the monster in
! 135: */
! 136: if (rnd(100) < (rp->r_goldval > 0 ? 80 : 25))
! 137: {
! 138: tp = new_item();
! 139: find_floor(rp, &mp, FALSE, TRUE);
! 140: new_monster(tp, randmonster(FALSE), &mp);
! 141: give_pack(tp);
! 142: }
! 143: }
! 144: }
! 145:
! 146: /*
! 147: * draw_room:
! 148: * Draw a box around a room and lay down the floor for normal
! 149: * rooms; for maze rooms, draw maze.
! 150: */
! 151:
! 152: void
! 153: draw_room(const struct room *rp)
! 154: {
! 155: int y, x;
! 156:
! 157: if (rp->r_flags & ISMAZE)
! 158: do_maze(rp);
! 159: else
! 160: {
! 161: vert(rp, rp->r_pos.x); /* Draw left side */
! 162: vert(rp, rp->r_pos.x + rp->r_max.x - 1); /* Draw right side */
! 163: horiz(rp, rp->r_pos.y); /* Draw top */
! 164: horiz(rp, rp->r_pos.y + rp->r_max.y - 1); /* Draw bottom */
! 165:
! 166: /*
! 167: * Put the floor down
! 168: */
! 169: for (y = rp->r_pos.y + 1; y < rp->r_pos.y + rp->r_max.y - 1; y++)
! 170: for (x = rp->r_pos.x + 1; x < rp->r_pos.x + rp->r_max.x - 1; x++)
! 171: chat(y, x) = FLOOR;
! 172: }
! 173: }
! 174:
! 175: /*
! 176: * vert:
! 177: * Draw a vertical line
! 178: */
! 179:
! 180: void
! 181: vert(const struct room *rp, int startx)
! 182: {
! 183: int y;
! 184:
! 185: for (y = rp->r_pos.y + 1; y <= rp->r_max.y + rp->r_pos.y - 1; y++)
! 186: chat(y, startx) = '|';
! 187: }
! 188:
! 189: /*
! 190: * horiz:
! 191: * Draw a horizontal line
! 192: */
! 193:
! 194: void
! 195: horiz(const struct room *rp, int starty)
! 196: {
! 197: int x;
! 198:
! 199: for (x = rp->r_pos.x; x <= rp->r_pos.x + rp->r_max.x - 1; x++)
! 200: chat(starty, x) = '-';
! 201: }
! 202:
! 203: /*
! 204: * do_maze:
! 205: * Dig a maze
! 206: */
! 207:
! 208: static int Maxy, Maxx, Starty, Startx;
! 209:
! 210: static SPOT maze[NUMLINES/3+1][NUMCOLS/3+1];
! 211:
! 212:
! 213: void
! 214: do_maze(const struct room *rp)
! 215: {
! 216: SPOT *sp;
! 217: int starty, startx;
! 218: coord pos;
! 219:
! 220: for (sp = &maze[0][0]; sp <= &maze[NUMLINES / 3][NUMCOLS / 3]; sp++)
! 221: {
! 222: sp->used = FALSE;
! 223: sp->nexits = 0;
! 224: }
! 225:
! 226: Maxy = rp->r_max.y;
! 227: Maxx = rp->r_max.x;
! 228: Starty = rp->r_pos.y;
! 229: Startx = rp->r_pos.x;
! 230: starty = (rnd(rp->r_max.y) / 2) * 2;
! 231: startx = (rnd(rp->r_max.x) / 2) * 2;
! 232: pos.y = starty + Starty;
! 233: pos.x = startx + Startx;
! 234: putpass(&pos);
! 235: dig(starty, startx);
! 236: }
! 237:
! 238: /*
! 239: * dig:
! 240: * Dig out from around where we are now, if possible
! 241: */
! 242:
! 243: void
! 244: dig(int y, int x)
! 245: {
! 246: coord *cp;
! 247: int cnt, newy, newx, nexty = 0, nextx = 0;
! 248: coord pos;
! 249: coord del[4] = {
! 250: {2, 0}, {-2, 0}, {0, 2}, {0, -2}
! 251: };
! 252:
! 253: for (;;)
! 254: {
! 255: cnt = 0;
! 256: for (cp = del; cp <= &del[3]; cp++)
! 257: {
! 258: newy = y + cp->y;
! 259: newx = x + cp->x;
! 260: if (newy < 0 || newy > Maxy || newx < 0 || newx > Maxx)
! 261: continue;
! 262: if (flat(newy + Starty, newx + Startx) & F_PASS)
! 263: continue;
! 264: if (rnd(++cnt) == 0)
! 265: {
! 266: nexty = newy;
! 267: nextx = newx;
! 268: }
! 269: }
! 270: if (cnt == 0)
! 271: return;
! 272: accnt_maze(y, x, nexty, nextx);
! 273: accnt_maze(nexty, nextx, y, x);
! 274: if (nexty == y)
! 275: {
! 276: pos.y = y + Starty;
! 277: if (nextx - x < 0)
! 278: pos.x = nextx + Startx + 1;
! 279: else
! 280: pos.x = nextx + Startx - 1;
! 281: }
! 282: else
! 283: {
! 284: pos.x = x + Startx;
! 285: if (nexty - y < 0)
! 286: pos.y = nexty + Starty + 1;
! 287: else
! 288: pos.y = nexty + Starty - 1;
! 289: }
! 290: putpass(&pos);
! 291: pos.y = nexty + Starty;
! 292: pos.x = nextx + Startx;
! 293: putpass(&pos);
! 294: dig(nexty, nextx);
! 295: }
! 296: }
! 297:
! 298: /*
! 299: * accnt_maze:
! 300: * Account for maze exits
! 301: */
! 302:
! 303: void
! 304: accnt_maze(int y, int x, int ny, int nx)
! 305: {
! 306: SPOT *sp;
! 307: coord *cp;
! 308:
! 309: sp = &maze[y][x];
! 310: for (cp = sp->exits; cp < &sp->exits[sp->nexits]; cp++)
! 311: if (cp->y == ny && cp->x == nx)
! 312: return;
! 313: cp->y = ny;
! 314: cp->x = nx;
! 315: }
! 316:
! 317: /*
! 318: * rnd_pos:
! 319: * Pick a random spot in a room
! 320: */
! 321:
! 322: void
! 323: rnd_pos(const struct room *rp, coord *cp)
! 324: {
! 325: cp->x = rp->r_pos.x + rnd(rp->r_max.x - 2) + 1;
! 326: cp->y = rp->r_pos.y + rnd(rp->r_max.y - 2) + 1;
! 327: }
! 328:
! 329: /*
! 330: * find_floor:
! 331: * Find a valid floor spot in this room. If rp is NULL, then
! 332: * pick a new room each time around the loop.
! 333: */
! 334: int
! 335: find_floor(const struct room *rp, coord *cp, int limit, int monst)
! 336: {
! 337: PLACE *pp;
! 338: int cnt;
! 339: int compchar = 0;
! 340: int pickroom;
! 341:
! 342: pickroom = (rp == NULL);
! 343:
! 344: if (!pickroom)
! 345: compchar = ((rp->r_flags & ISMAZE) ? PASSAGE : FLOOR);
! 346: cnt = limit;
! 347: for (;;)
! 348: {
! 349: if (limit && cnt-- == 0)
! 350: return FALSE;
! 351: if (pickroom)
! 352: {
! 353: rp = &rooms[rnd_room()];
! 354: compchar = ((rp->r_flags & ISMAZE) ? PASSAGE : FLOOR);
! 355: }
! 356: rnd_pos(rp, cp);
! 357: pp = INDEX(cp->y, cp->x);
! 358: if (monst)
! 359: {
! 360: if (pp->p_monst == NULL && step_ok(pp->p_ch))
! 361: return TRUE;
! 362: }
! 363: else if (pp->p_ch == compchar)
! 364: return TRUE;
! 365: }
! 366: }
! 367:
! 368: /*
! 369: * enter_room:
! 370: * Code that is executed whenver you appear in a room
! 371: */
! 372:
! 373: void
! 374: enter_room(const coord *cp)
! 375: {
! 376: struct room *rp;
! 377: THING *tp;
! 378: int y, x;
! 379: chtype ch;
! 380:
! 381: rp = proom = roomin(cp);
! 382: door_open(rp);
! 383: if (!(rp->r_flags & ISDARK) && !on(player, ISBLIND))
! 384: for (y = rp->r_pos.y; y < rp->r_max.y + rp->r_pos.y; y++)
! 385: {
! 386: move(y, rp->r_pos.x);
! 387: for (x = rp->r_pos.x; x < rp->r_max.x + rp->r_pos.x; x++)
! 388: {
! 389: tp = moat(y, x);
! 390: ch = chat(y, x);
! 391: if (tp == NULL)
! 392: if (CCHAR(inch()) != ch)
! 393: addch(ch);
! 394: else
! 395: move(y, x + 1);
! 396: else
! 397: {
! 398: tp->t_oldch = ch;
! 399: if (!see_monst(tp))
! 400: if (on(player, SEEMONST))
! 401: {
! 402: standout();
! 403: addch(tp->t_disguise);
! 404: standend();
! 405: }
! 406: else
! 407: addch(ch);
! 408: else
! 409: addch(tp->t_disguise);
! 410: }
! 411: }
! 412: }
! 413: }
! 414:
! 415: /*
! 416: * leave_room:
! 417: * Code for when we exit a room
! 418: */
! 419:
! 420: void
! 421: leave_room(const coord *cp)
! 422: {
! 423: PLACE *pp;
! 424: struct room *rp;
! 425: int y, x;
! 426: int floor;
! 427: int ch;
! 428:
! 429: rp = proom;
! 430:
! 431: if (rp->r_flags & ISMAZE)
! 432: return;
! 433:
! 434: if (rp->r_flags & ISGONE)
! 435: floor = PASSAGE;
! 436: else if (!(rp->r_flags & ISDARK) || on(player, ISBLIND))
! 437: floor = FLOOR;
! 438: else
! 439: floor = ' ';
! 440:
! 441: proom = &passages[flat(cp->y, cp->x) & F_PNUM];
! 442: for (y = rp->r_pos.y; y < rp->r_max.y + rp->r_pos.y; y++)
! 443: for (x = rp->r_pos.x; x < rp->r_max.x + rp->r_pos.x; x++)
! 444: {
! 445: move(y, x);
! 446: switch ( ch = CCHAR(inch()) )
! 447: {
! 448: case FLOOR:
! 449: if (floor == ' ' && ch != ' ')
! 450: addch(' ');
! 451: break;
! 452: default:
! 453: /*
! 454: * to check for monster, we have to strip out
! 455: * standout bit
! 456: */
! 457: if (isupper(toascii(ch)))
! 458: {
! 459: if (on(player, SEEMONST))
! 460: {
! 461: standout();
! 462: addch(ch);
! 463: standend();
! 464: break;
! 465: }
! 466: pp = INDEX(y,x);
! 467: addch(pp->p_ch == DOOR ? DOOR : floor);
! 468: }
! 469: }
! 470: }
! 471: door_open(rp);
! 472: }