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