![[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 / xrogue|
Return to rooms.c CVS log | Up to [contributed] / early-roguelike / xrogue |
1.1 ! rubenllo 1: /*
! 2: rooms.c - Draw the nine rooms on the screen
! 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: 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 <curses.h>
! 21: #include "rogue.h"
! 22:
! 23: void horiz(int cnt);
! 24: void vert(int cnt);
! 25:
! 26: void
! 27: do_rooms(void)
! 28: {
! 29: register int i;
! 30: register struct room *rp;
! 31: register struct linked_list *item;
! 32: register struct thing *tp;
! 33: int left_out;
! 34: int num_monsters;
! 35: int which_monster;
! 36: int j;
! 37: coord top;
! 38: coord bsze;
! 39: coord mp;
! 40: coord *np;
! 41:
! 42: /*
! 43: * bsze is the maximum room size
! 44: */
! 45: bsze.x = cols/3;
! 46: bsze.y = (lines-2)/3;
! 47: /*
! 48: * Clear things for a new level
! 49: */
! 50: for (rp = rooms; rp < &rooms[MAXROOMS]; rp++) {
! 51: rp->r_flags = 0;
! 52: _r_free_fire_list(&rp->r_fires);
! 53: }
! 54: /*
! 55: * Put the gone rooms, if any, on the level
! 56: */
! 57: left_out = rnd(4);
! 58: for (i = 0; i < left_out; i++)
! 59: rooms[rnd_room()].r_flags |= ISGONE;
! 60: /*
! 61: * dig and populate all the rooms on the level
! 62: */
! 63: for (i = 0, rp = rooms; i < MAXROOMS; rp++, i++)
! 64: {
! 65: bool has_gold=FALSE;
! 66:
! 67: /*
! 68: * Find upper left corner of box that this room goes in
! 69: */
! 70: top.x = (i%3)*bsze.x;
! 71: top.y = i/3*bsze.y + 1;
! 72: if (rp->r_flags & ISGONE)
! 73: {
! 74: /*
! 75: * Place a gone room. Make certain that there is a blank line
! 76: * for passage drawing.
! 77: */
! 78: do
! 79: {
! 80: rp->r_pos.x = top.x + rnd(bsze.x-2) + 1;
! 81: rp->r_pos.y = top.y + rnd(bsze.y-2) + 1;
! 82: rp->r_max.x = -cols;
! 83: rp->r_max.y = -lines;
! 84: } until(rp->r_pos.y > 0 && rp->r_pos.y < lines-2);
! 85: continue;
! 86: }
! 87: if (rnd(10) < level-1)
! 88: rp->r_flags |= ISDARK;
! 89: /*
! 90: * Find a place and size for a random room
! 91: */
! 92: do
! 93: {
! 94: rp->r_max.x = rnd(bsze.x - 4) + 4;
! 95: rp->r_max.y = rnd(bsze.y - 4) + 4;
! 96: rp->r_pos.x = top.x + rnd(bsze.x - rp->r_max.x);
! 97: rp->r_pos.y = top.y + rnd(bsze.y - rp->r_max.y);
! 98: } until (rp->r_pos.y != 0);
! 99:
! 100: /* Draw the room */
! 101: draw_room(rp);
! 102:
! 103: /*
! 104: * Put the gold in
! 105: */
! 106: if (rnd(100) < 55 && level >= cur_max)
! 107: {
! 108: register struct linked_list *item;
! 109: register struct object *cur;
! 110: coord tp;
! 111:
! 112: has_gold = TRUE; /* This room has gold in it */
! 113:
! 114: item = spec_item(GOLD, 0, 0, 0);
! 115: cur = OBJPTR(item);
! 116:
! 117: /* Put the gold into the level list of items */
! 118: attach(lvl_obj, item);
! 119:
! 120: /* Put it somewhere */
! 121: rnd_pos(rp, &tp);
! 122: mvaddch(tp.y, tp.x, GOLD);
! 123: cur->o_pos = tp;
! 124: if (roomin(&tp) != rp) {
! 125: endwin();
! 126: abort();
! 127: }
! 128: }
! 129:
! 130: /*
! 131: * Put the monster in
! 132: */
! 133: if (rnd(100) < (has_gold ? 80 : 25) + vlevel/2)
! 134: {
! 135: do
! 136: {
! 137: rnd_pos(rp, &mp);
! 138: } until(mvwinch(stdscr, mp.y, mp.x) == FLOOR);
! 139: which_monster = randmonster(FALSE, FALSE);
! 140: num_monsters = 1;
! 141: /*
! 142: * see if we should make a whole bunch
! 143: */
! 144: for (j=0; j<MAXFLAGS; j++) {
! 145: if (monsters[which_monster].m_flags[j] == AREMANY)
! 146: num_monsters = roll(7,2);
! 147: }
! 148: for (j=0; j<num_monsters; j++) {
! 149: if ((np = fallpos(&mp, FALSE, 2)) != NULL &&
! 150: mvwinch(stdscr, np->y, np->x) == FLOOR) {
! 151: item = new_item(sizeof *tp);
! 152: tp = THINGPTR(item);
! 153: new_monster(item, which_monster, np, FALSE);
! 154: /*
! 155: * See if we want to give it a treasure to
! 156: * carry around.
! 157: */
! 158: carry_obj(tp, monsters[tp->t_index].m_carry);
! 159: tp->t_no_move = movement(tp);
! 160:
! 161: /*
! 162: * If it has a fire, mark it
! 163: */
! 164: if (on(*tp, HASFIRE)) {
! 165: register struct linked_list *fire_item;
! 166:
! 167: fire_item = creat_item();
! 168: ldata(fire_item) = (char *) tp;
! 169: attach(rp->r_fires, fire_item);
! 170: rp->r_flags |= HASFIRE;
! 171: }
! 172: }
! 173: }
! 174: }
! 175: }
! 176: }
! 177:
! 178: /*
! 179: * Given a room pointer and a pointer to a door, supposedly in that room,
! 180: * return the coordinates of the entrance to the doorway.
! 181: */
! 182:
! 183: coord *
! 184: doorway(struct room *rp, coord *door)
! 185: {
! 186: register int misses = 0;
! 187: static coord answer;
! 188:
! 189: /* Do we have decent parameters? */
! 190: if (rp == NULL || door == NULL) return(NULL);
! 191:
! 192: /* Initialize the answer to be the door, then calculate the offset */
! 193: answer = *door;
! 194:
! 195: /* Calculate the x-offset */
! 196: if (door->x == rp->r_pos.x) answer.x++;
! 197: else if (door->x == rp->r_pos.x + rp->r_max.x - 1) answer.x--;
! 198: else misses++;
! 199:
! 200: /* Calculate the y-offset */
! 201: if (door->y == rp->r_pos.y) answer.y++;
! 202: else if (door->y == rp->r_pos.y + rp->r_max.y - 1) answer.y--;
! 203: else misses++;
! 204:
! 205: if (misses <= 1) return(&answer);
! 206: else return(NULL);
! 207: }
! 208:
! 209: /*
! 210: * Draw a box around a room
! 211: */
! 212:
! 213: void
! 214: draw_room(struct room *rp)
! 215: {
! 216: register int j, k;
! 217:
! 218: move(rp->r_pos.y, rp->r_pos.x+1);
! 219: vert(rp->r_max.y-2); /* Draw left side */
! 220: move(rp->r_pos.y+rp->r_max.y-1, rp->r_pos.x);
! 221: horiz(rp->r_max.x); /* Draw bottom */
! 222: move(rp->r_pos.y, rp->r_pos.x);
! 223: horiz(rp->r_max.x); /* Draw top */
! 224: vert(rp->r_max.y-2); /* Draw right side */
! 225: /*
! 226: * Put the floor down
! 227: */
! 228: for (j = 1; j < rp->r_max.y-1; j++)
! 229: {
! 230: move(rp->r_pos.y + j, rp->r_pos.x+1);
! 231: for (k = 1; k < rp->r_max.x-1; k++)
! 232: addch(FLOOR);
! 233: }
! 234: }
! 235:
! 236: /*
! 237: * horiz:
! 238: * draw a horizontal line
! 239: */
! 240:
! 241: void
! 242: horiz(int cnt)
! 243: {
! 244: while (cnt--)
! 245: addch(HORZWALL);
! 246: }
! 247:
! 248: /*
! 249: * rnd_pos:
! 250: * pick a random spot in a room
! 251: */
! 252:
! 253: void
! 254: rnd_pos(struct room *rp, coord *cp)
! 255: {
! 256: cp->x = rp->r_pos.x + rnd(rp->r_max.x-2) + 1;
! 257: cp->y = rp->r_pos.y + rnd(rp->r_max.y-2) + 1;
! 258: }
! 259:
! 260:
! 261:
! 262: /*
! 263: * roomin:
! 264: * Find what room some coordinates are in. NULL means they aren't
! 265: * in any room.
! 266: */
! 267:
! 268: struct room *
! 269: roomin(coord *cp)
! 270: {
! 271: register struct room *rp;
! 272:
! 273: for (rp = rooms; rp < &rooms[MAXROOMS]; rp++)
! 274: if (inroom(rp, cp))
! 275: return rp;
! 276: return NULL;
! 277: }
! 278:
! 279: /*
! 280: * vert:
! 281: * draw a vertical line
! 282: */
! 283:
! 284: void
! 285: vert(int cnt)
! 286: {
! 287: register int x, y;
! 288:
! 289: getyx(stdscr, y, x);
! 290: x--;
! 291: while (cnt--) {
! 292: move(++y, x);
! 293: addch(VERTWALL);
! 294: }
! 295: }
! 296: