![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to n_level.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 n_level.c CVS log | Up to [contributed] / early-roguelike / xrogue |
1.1 ! rubenllo 1: /*
! 2: n_level.c - Dig and draw a new level
! 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 <curses.h>
! 20: #include "rogue.h"
! 21: #define TERRASAVE 3
! 22:
! 23: void put_things(LEVTYPE ltype);
! 24:
! 25: /*
! 26: * new_level:
! 27: * Dig and draw a new level
! 28: * ltype: designates type of level to create
! 29: */
! 30:
! 31: void
! 32: new_level(LEVTYPE ltype)
! 33: {
! 34: register int rm = 0, i, cnt;
! 35: register unsigned char ch;
! 36: register struct linked_list *item;
! 37: register struct thing *tp;
! 38: register struct object *obj;
! 39: int waslit = 0; /* Was the previous outside level lit? */
! 40: int starty = 0, startx = 0, deltay = 0, deltax = 0;
! 41: bool fresh=TRUE, vert = 0, top;
! 42: struct room *rp;
! 43: struct linked_list *nitem, *savmonst=NULL, *savitems=NULL;
! 44: coord stairs = {0,0};
! 45:
! 46: if (wizard) {
! 47: msg("Turns: %ld", turns); /* Number of turns for last level */
! 48: mpos = 0;
! 49: }
! 50:
! 51: /* Start player off right */
! 52: turn_off(player, ISHELD);
! 53: turn_off(player, ISFLEE);
! 54: extinguish(suffocate);
! 55: hold_count = 0;
! 56: trap_tries = 0;
! 57:
! 58: /* Are we just entering a dungeon? If so, how big is it? */
! 59: if (ltype != OUTSIDE && nfloors < 0) nfloors = HARDER+20 + rnd(51);
! 60:
! 61: if (level > max_level)
! 62: max_level = level;
! 63:
! 64: /* Are we starting a new outside level? */
! 65: if (ltype == OUTSIDE) {
! 66: register int i, j;
! 67:
! 68: /* Save some information prior to clearing the screen */
! 69: if (level == -1 || mvinch(hero.y, hero.x) == HORZWALL) vert = TRUE;
! 70: else vert = FALSE;
! 71:
! 72: if (level < 1) {
! 73: fresh = TRUE;
! 74: starty = 2;
! 75: startx = 1;
! 76: deltay = deltax = 1;
! 77: level = max_level; /* Restore level to deepest attempt */
! 78: prev_max = level; /* reset for boundary crossings below */
! 79: }
! 80: else if (level >= 1 && prev_max == 1000) {
! 81: fresh = TRUE;
! 82: starty = 2;
! 83: startx = 1;
! 84: deltay = deltax = 1;
! 85: prev_max = level; /* reset for boundary crossings below */
! 86: }
! 87: else { /* Copy several lines of the terrain to the other end */
! 88:
! 89: unsigned char cch; /* Copy character */
! 90:
! 91: if (wizard) msg("Crossing sector boundary ");
! 92:
! 93: /* Was the area dark (not magically lit)? */
! 94: if (!(rooms[0].r_flags & ISDARK)) waslit = 1;
! 95:
! 96: fresh = FALSE;
! 97: if ((vert && hero.y == 1) || (!vert && hero.x == 0)) top = TRUE;
! 98: else top = FALSE;
! 99: for (i=0; i<TERRASAVE; i++) {
! 100: if (vert)
! 101: for (j=1; j<cols-1; j++) {
! 102: if (top) {
! 103: cch = mvinch(i+2, j);
! 104: mvaddch(lines-6+i, j, cch);
! 105: }
! 106: else {
! 107: cch = mvinch(lines-4-i, j);
! 108: mvaddch(4-i, j, cch);
! 109: }
! 110: }
! 111: else
! 112: for (j=2; j<lines-3; j++) {
! 113: if (top) {
! 114: cch = mvinch(j, i+1);
! 115: mvaddch(j, cols-4+i, cch);
! 116: }
! 117: else {
! 118: cch = mvinch(j, cols-2-i);
! 119: mvaddch(j, 3-i, cch);
! 120: }
! 121: }
! 122: }
! 123:
! 124: if (vert) {
! 125: startx = deltax = 1;
! 126: if (top) {
! 127: starty = lines-4-TERRASAVE;
! 128: deltay = -1;
! 129: }
! 130: else {
! 131: starty = TERRASAVE + 2;
! 132: deltay = 1;
! 133: }
! 134: }
! 135: else {
! 136: starty = 2;
! 137: deltay = 1;
! 138: if (top) {
! 139: startx = cols-2-TERRASAVE;
! 140: deltax = -1;
! 141: }
! 142: else {
! 143: deltax = 1;
! 144: startx = TERRASAVE + 1;
! 145: }
! 146: }
! 147:
! 148: /* Check if any monsters should be saved */
! 149: for (item = mlist; item != NULL; item = nitem) {
! 150: nitem = next(item);
! 151: tp = THINGPTR(item);
! 152: if (vert) {
! 153: if (top) {
! 154: if (tp->t_pos.y < TERRASAVE + 2)
! 155: tp->t_pos.y += lines - 5 - TERRASAVE;
! 156: else continue;
! 157: }
! 158: else {
! 159: if (tp->t_pos.y > lines - 4 - TERRASAVE)
! 160: tp->t_pos.y += 5 + TERRASAVE - lines;
! 161: else continue;
! 162: }
! 163: }
! 164: else {
! 165: if (top) {
! 166: if (tp->t_pos.x < TERRASAVE + 1)
! 167: tp->t_pos.x += cols - 2 - TERRASAVE;
! 168: else continue;
! 169: }
! 170: else {
! 171: if (tp->t_pos.x > cols - 2 - TERRASAVE)
! 172: tp->t_pos.x += 2 + TERRASAVE - cols;
! 173: else continue;
! 174: }
! 175: }
! 176:
! 177: /*
! 178: * If the monster is busy chasing another monster, don't save
! 179: * it
! 180: */
! 181: if (tp->t_dest && tp->t_dest != &hero) continue;
! 182:
! 183: /* Outside has plenty of monsters, don't need these.
! 184: * detach(mlist, item);
! 185: * attach(savmonst, item);
! 186: */
! 187: }
! 188:
! 189: /* Check if any treasure should be saved */
! 190: for (item = lvl_obj; item != NULL; item = nitem) {
! 191: nitem = next(item);
! 192: obj = OBJPTR(item);
! 193: if (vert) {
! 194: if (top) {
! 195: if (obj->o_pos.y < TERRASAVE + 2)
! 196: obj->o_pos.y += lines - 5 - TERRASAVE;
! 197: else continue;
! 198: }
! 199: else {
! 200: if (obj->o_pos.y > lines - 4 - TERRASAVE)
! 201: obj->o_pos.y += 5 + TERRASAVE - lines;
! 202: else continue;
! 203: }
! 204: }
! 205: else {
! 206: if (top) {
! 207: if (obj->o_pos.x < TERRASAVE + 1)
! 208: obj->o_pos.x += cols - 2 - TERRASAVE;
! 209: else continue;
! 210: }
! 211: else {
! 212: if (obj->o_pos.x > cols - 2 - TERRASAVE)
! 213: obj->o_pos.x += 2 + TERRASAVE - cols;
! 214: else continue;
! 215: }
! 216: }
! 217: detach(lvl_obj, item);
! 218: attach(savitems, item);
! 219: }
! 220: }
! 221: }
! 222:
! 223: wclear(cw);
! 224: wclear(mw);
! 225: if (fresh || levtype != OUTSIDE) clear();
! 226: /*
! 227: * check to see if he missed a UNIQUE, If he did then put it back
! 228: * in the monster table for next time
! 229: */
! 230: for (item = mlist; item != NULL; item = next(item)) {
! 231: tp = THINGPTR(item);
! 232: if (on(*tp, ISUNIQUE))
! 233: monsters[tp->t_index].m_normal = TRUE;
! 234: }
! 235: /*
! 236: * Free up the monsters on the last level
! 237: */
! 238: t_free_list(mlist);
! 239: o_free_list(lvl_obj); /* Free up previous objects (if any) */
! 240: for (rp = rooms; rp < &rooms[MAXROOMS]; rp++)
! 241: r_free_list(rp->r_exit); /* Free up the exit lists */
! 242:
! 243: levtype = ltype;
! 244: foods_this_level = 0; /* food for hero this level */
! 245:
! 246: /* What kind of level are we on? */
! 247: if (ltype == POSTLEV || ltype == STARTLEV) {
! 248: if (ltype == POSTLEV)
! 249: do_post(FALSE); /* Trading post */
! 250: else
! 251: do_post(TRUE); /* Equipage */
! 252:
! 253: levtype = ltype = POSTLEV;
! 254: }
! 255: else if (ltype == MAZELEV) {
! 256: do_maze();
! 257: no_food++;
! 258: put_things(ltype); /* Place objects (if any) */
! 259: }
! 260: else if (ltype == OUTSIDE) {
! 261: /* Move the cursor back onto the hero */
! 262: wmove(cw, hero.y, hero.x);
! 263: init_terrain();
! 264: do_terrain(starty, startx, deltay, deltax, (bool) (fresh || !vert));
! 265: no_food++;
! 266: put_things(ltype);
! 267:
! 268: /* Should we magically light this area? */
! 269: if (waslit) rooms[0].r_flags &= ~ISDARK;
! 270: }
! 271: else {
! 272: do_rooms(); /* Draw rooms */
! 273: do_passages(); /* Draw passages */
! 274: no_food++;
! 275: put_things(ltype); /* Place objects (if any) */
! 276: }
! 277: /*
! 278: * Place the staircase down. Only a small chance for an outside stairway.
! 279: */
! 280: if (ltype != OUTSIDE || roll(1, 5) == 5) {
! 281: cnt = 0;
! 282: do {
! 283: rm = rnd_room();
! 284: rnd_pos(&rooms[rm], &stairs);
! 285: } until (mvinch(stairs.y, stairs.x) == FLOOR || cnt++ > 2500);
! 286: addch(STAIRS);
! 287: }
! 288: /*
! 289: * maybe add a trading post
! 290: */
! 291: if (level > 5 && rnd(10) == 7 && ltype == NORMLEV) {
! 292: cnt = 0;
! 293: do {
! 294: rm = rnd_room();
! 295: if (rooms[rm].r_flags & ISTREAS)
! 296: continue;
! 297: rnd_pos(&rooms[rm], &stairs);
! 298: } until (winat(stairs.y, stairs.x) == FLOOR || cnt++ > 2500);
! 299: addch(POST);
! 300: }
! 301: if (ltype != POSTLEV) { /* Add monsters that fell through */
! 302: nitem = tlist;
! 303: while (nitem != NULL) {
! 304: item = nitem;
! 305: nitem = next(item); /* because detach and attach mess up ptrs */
! 306: tp = THINGPTR(item);
! 307: cnt = 0;
! 308: do {
! 309: rm = rnd_room();
! 310: rnd_pos(&rooms[rm], &tp->t_pos);
! 311: } until (cnt++ > 2500 || winat(tp->t_pos.y, tp->t_pos.x) == FLOOR);
! 312: mvwaddch(mw, tp->t_pos.y, tp->t_pos.x, tp->t_type);
! 313: tp->t_oldch = mvwinch(cw, tp->t_pos.y, tp->t_pos.x);
! 314:
! 315: /*
! 316: * If it has a fire, mark it
! 317: */
! 318: if (on(*tp, HASFIRE)) {
! 319: register struct linked_list *fire_item;
! 320:
! 321: fire_item = creat_item();
! 322: ldata(fire_item) = (char *) tp;
! 323: attach(rooms[rm].r_fires, fire_item);
! 324: rooms[rm].r_flags |= HASFIRE;
! 325: }
! 326:
! 327: detach(tlist, item);
! 328: turn_off(*tp,ISELSEWHERE);
! 329: attach(mlist, item);
! 330: }
! 331: }
! 332:
! 333: /* Restore any saved monsters */
! 334: for (item = savmonst; item != NULL; item = nitem) {
! 335: nitem = next(item);
! 336: tp = THINGPTR(item);
! 337: mvwaddch(mw, tp->t_pos.y, tp->t_pos.x, tp->t_type);
! 338: tp->t_oldch = mvwinch(cw, tp->t_pos.y, tp->t_pos.x);
! 339:
! 340: /*
! 341: * If it has a fire, mark it
! 342: */
! 343: if (on(*tp, HASFIRE)) {
! 344: register struct linked_list *fire_item;
! 345:
! 346: fire_item = creat_item();
! 347: ldata(fire_item) = (char *) tp;
! 348: attach(rooms[rm].r_fires, fire_item);
! 349: rooms[rm].r_flags |= HASFIRE;
! 350: }
! 351:
! 352: detach(savmonst, item);
! 353: attach(mlist, item);
! 354: }
! 355:
! 356: /* Restore any saved objects */
! 357: for(item = savitems; item != NULL; item = nitem) {
! 358: nitem = next(item);
! 359: obj = OBJPTR(item);
! 360: mvaddch(obj->o_pos.y, obj->o_pos.x, obj->o_type);
! 361: detach(savitems, item);
! 362: attach(lvl_obj, item);
! 363: }
! 364:
! 365: /*
! 366: * Place the traps (except for trading post)
! 367: */
! 368: ntraps = 0; /* No traps yet */
! 369: if (levtype == NORMLEV) {
! 370: if (rnd(10) < vlevel) {
! 371: ntraps = rnd(vlevel/4)+2;
! 372: if (ntraps > MAXTRAPS)
! 373: ntraps = MAXTRAPS;
! 374: i = ntraps;
! 375: while (i--)
! 376: {
! 377: cnt = 0;
! 378: do {
! 379: rm = rnd_room();
! 380: if (rooms[rm].r_flags & ISTREAS)
! 381: continue;
! 382: rnd_pos(&rooms[rm], &stairs);
! 383: } until (winat(stairs.y, stairs.x) == FLOOR || cnt++ > 2500);
! 384:
! 385: traps[i].tr_flags = 0;
! 386:
! 387: /* If we are at the bottom, we can't set a trap door */
! 388: if (level >= nfloors) ch = (unsigned char) rnd(8) + 1;
! 389: else ch = (unsigned char) rnd(9);
! 390:
! 391: switch((int) ch) {
! 392: case 0: ch = TRAPDOOR;
! 393: when 1: ch = BEARTRAP;
! 394: when 2: ch = SLEEPTRAP;
! 395: when 3: ch = ARROWTRAP;
! 396: when 4: ch = TELTRAP;
! 397: when 5: ch = DARTTRAP;
! 398: when 6: ch = POOL;
! 399: traps[i].tr_flags = ISFOUND;
! 400: when 7: ch = MAZETRAP;
! 401: when 8: ch = WORMHOLE;
! 402: }
! 403: addch(ch);
! 404: traps[i].tr_type = ch;
! 405: traps[i].tr_show = FLOOR;
! 406: traps[i].tr_pos = stairs;
! 407: }
! 408: }
! 409: }
! 410: if (fresh) { /* A whole new picture */
! 411: /*
! 412: * try to find a room for the hero. The objective here is to:
! 413: * --> don't put him in a treasure room
! 414: * --> don't put him on an object
! 415: * --> try not to put him next to the stairs
! 416: */
! 417: cnt = 2500;
! 418: do {
! 419: if (ltype != OUTSIDE) rm = rnd_room();
! 420: else continue;
! 421:
! 422: if (rooms[rm].r_flags & ISTREAS)
! 423: continue;
! 424:
! 425: rnd_pos(&rooms[rm], &hero);
! 426: } until( cnt-- == 0 ||
! 427: (winat(hero.y, hero.x) == FLOOR &&
! 428: DISTANCE(hero.y, hero.x, stairs.y, stairs.x) > cnt/10));
! 429: }
! 430: else { /* We're extending into an adjacent outside plane */
! 431: rm = 0;
! 432: if (vert) {
! 433: if (hero.y == 1) hero.y = lines - 3 - TERRASAVE; /* Top to bottom */
! 434: else hero.y = TERRASAVE + 1; /* Bottom to top */
! 435: }
! 436: else {
! 437: if (hero.x == 0) hero.x = cols - 1 - TERRASAVE; /* Right to left */
! 438: else hero.x = TERRASAVE; /* Left to right */
! 439: }
! 440: }
! 441: oldrp = &rooms[rm]; /* Set the current room */
! 442: player.t_oldpos = player.t_pos; /* Set the current position */
! 443:
! 444: if (ISWEARING(R_AGGR) ||
! 445: (cur_misc[WEAR_JEWEL] != NULL &&
! 446: cur_misc[WEAR_JEWEL]->o_which == MM_JEWEL))
! 447: aggravate(TRUE, TRUE); /* affect all charactors */
! 448:
! 449: /*
! 450: * If player is moving up or above his deepest point, wake up any
! 451: * non-uniques
! 452: */
! 453: else if (level < cur_max) {
! 454: aggravate(FALSE, FALSE);
! 455: }
! 456:
! 457: light(&hero);
! 458: wmove(cw, hero.y, hero.x);
! 459: waddch(cw, PLAYER);
! 460:
! 461: if (level > cur_max)
! 462: cur_max = level;
! 463:
! 464: draw(cw);
! 465:
! 466: status(TRUE);
! 467:
! 468: /* Do we sense any food on this level? */
! 469: if (cur_relic[SURTUR_RING])
! 470: quaff(P_FFIND, 0, 0, FALSE);
! 471: }
! 472:
! 473: /*
! 474: * Pick a room that is really there
! 475: */
! 476:
! 477: int
! 478: rnd_room(void)
! 479: {
! 480: register int rm;
! 481:
! 482: if (levtype != NORMLEV)
! 483: rm = 0;
! 484: else do
! 485: {
! 486: rm = rnd(MAXROOMS);
! 487: } while (rooms[rm].r_flags & ISGONE);
! 488: return rm;
! 489: }
! 490:
! 491: /*
! 492: * put_things:
! 493: * put potions and scrolls on this level
! 494: * ltype: designates type of level to create
! 495: */
! 496:
! 497: void
! 498: put_things(LEVTYPE ltype)
! 499: {
! 500: register int i, rm, cnt;
! 501: register struct object *cur;
! 502: register struct linked_list *item, *nextitem, *exitptr;
! 503: int length, width;
! 504: int ITEMS = 0; /* number of items to place */
! 505: coord tp, *exit;
! 506:
! 507: /*
! 508: * The only way to get new stuff is to go down into the dungeon.
! 509: */
! 510: if (level < cur_max) {
! 511: if (ltype == NORMLEV)
! 512: return;
! 513: }
! 514:
! 515: if (ltype == OUTSIDE) goto jmp_here; /* a jump for outside */
! 516:
! 517: /*
! 518: * There is a chance that there is a Treasure Room on this level
! 519: */
! 520: if (ltype == NORMLEV && rnd(150) < level) {
! 521: register int j;
! 522: register struct room *rp;
! 523:
! 524: /* Count the number of free spaces */
! 525: i = 0; /* 0 tries */
! 526: do {
! 527: rp = &rooms[rnd_room()];
! 528: width = rp->r_max.y - 2;
! 529: length = rp->r_max.x - 2;
! 530: } until ((width*length >= MAXTREAS) || (i++ > MAXROOMS*4));
! 531:
! 532: /* Mark the room as a treasure room */
! 533: rp->r_flags |= ISTREAS;
! 534:
! 535: /* Make all the doors secret doors */
! 536: for (exitptr = rp->r_exit; exitptr; exitptr = next(exitptr)) {
! 537: exit = DOORPTR(exitptr);
! 538: move(exit->y, exit->x);
! 539: addch(SECRETDOOR);
! 540: }
! 541:
! 542: /*
! 543: * check to see if there are any monsters in room already
! 544: */
! 545: for (item = mlist; item != NULL; item = nextitem) {
! 546: register struct thing *tp;
! 547:
! 548: tp = THINGPTR(item);
! 549: nextitem = next(item);
! 550: if (rp == roomin(&tp->t_pos)) {
! 551: /*
! 552: * Don't let nice creatures be generated in a treasure
! 553: * room.
! 554: */
! 555: if ((player.t_ctype==C_PALADIN || player.t_ctype==C_RANGER ||
! 556: player.t_ctype==C_MONK) && off(*tp, ISMEAN)) {
! 557: int index;
! 558:
! 559: if (on(*tp, ISUNIQUE)) index = tp->t_index;
! 560: else index = -1;
! 561:
! 562: /* Get rid of the monster */
! 563: killed(item, FALSE, FALSE, FALSE);
! 564:
! 565: /* Restore uniques back in the table */
! 566: if (index != -1) monsters[index].m_normal = TRUE;
! 567:
! 568: continue;
! 569: }
! 570: turn_on(*tp, ISMEAN);
! 571: turn_on(*tp, ISGUARDIAN);
! 572: }
! 573: }
! 574:
! 575: /* Put in the monsters and treasures */
! 576: for (j=1; j<rp->r_max.y-1; j++)
! 577: for (i=1; i<rp->r_max.x-1; i++) {
! 578: coord trp;
! 579:
! 580: trp.y = rp->r_pos.y+j;
! 581: trp.x = rp->r_pos.x+i;
! 582:
! 583: /* Monsters */
! 584: if ((rnd(100) < (MAXTREAS*100)/(width*length)) &&
! 585: (mvwinch(mw, rp->r_pos.y+j, rp->r_pos.x+i) == ' ')) {
! 586: register struct thing *tp;
! 587:
! 588: /*
! 589: * Put it there and leave it asleep. Wake the monsters
! 590: * when the player enters the room. Hopefully, all bases
! 591: * are covered as far as the ways to get in. This way
! 592: * cpu time is not wasted on the awake monsters that
! 593: * can't get to the player anyway.
! 594: * try not to put any UNIQUEs in a treasure room.
! 595: * note that they may have put put in already by the
! 596: * non-treasure room code.
! 597: * also, try not to put ISMEAN monsters in a treasure
! 598: * room as these are supposed to be non-hostile until
! 599: * attacked. It also makes life simpler for the ranger,
! 600: * paladin, and monk.
! 601: */
! 602: for(;;) {
! 603: item = new_item(sizeof *tp); /* Make a monster */
! 604: tp = THINGPTR(item);
! 605: new_monster(item,randmonster(FALSE, TRUE),&trp,TRUE);
! 606: if (on(*tp, HASFIRE)) {
! 607: register struct linked_list *fire_item;
! 608:
! 609: fire_item = creat_item();
! 610: ldata(fire_item) = (char *) tp;
! 611: attach(rp->r_fires, fire_item);
! 612: rp->r_flags |= HASFIRE;
! 613: }
! 614: /*
! 615: * only picky for these classes
! 616: */
! 617: if (player.t_ctype != C_RANGER &&
! 618: player.t_ctype != C_PALADIN &&
! 619: player.t_ctype != C_MONK)
! 620: break;
! 621: if (on(*tp, ISMEAN))
! 622: break;
! 623: killed (item, FALSE, FALSE, FALSE);
! 624: }
! 625: if (on(*tp, ISUNIQUE)) { /* just in case */
! 626: carry_obj(tp, monsters[tp->t_index].m_carry);
! 627: tp->t_no_move = movement(tp);
! 628: }
! 629: turn_on(*tp, ISGUARDIAN);
! 630:
! 631: }
! 632:
! 633: /* Treasures */
! 634: if ((rnd(100) < (MAXTREAS*100)/(width*length)) &&
! 635: (mvinch(rp->r_pos.y+j, rp->r_pos.x+i) == FLOOR)) {
! 636: item = new_thing(ALL, TRUE);
! 637: attach(lvl_obj, item);
! 638: cur = OBJPTR(item);
! 639:
! 640: mvaddch(trp.y, trp.x, cur->o_type);
! 641: cur->o_pos = trp;
! 642: }
! 643: }
! 644: }
! 645:
! 646: jmp_here: /* outside jumper for equippage */
! 647:
! 648: /*
! 649: * Do ITEMS attempts to put things in dungeon, maze, or outside
! 650: */
! 651:
! 652: if (ltype == OUTSIDE) ITEMS = rnd(15)+1;
! 653: else if (ltype == MAZELEV) ITEMS = rnd(20)+1;
! 654: else ITEMS = MAXOBJ + rnd(4);
! 655:
! 656: for (i = 0; i < ITEMS; i++)
! 657: if (rnd(100) < 65) {
! 658: /*
! 659: * Pick a new object and link it in the list
! 660: */
! 661: item = new_thing(ALL, TRUE);
! 662: attach(lvl_obj, item);
! 663: cur = OBJPTR(item);
! 664: /*
! 665: * Put it somewhere
! 666: */
! 667: cnt = 0;
! 668: do {
! 669: if (ltype == OUTSIDE) rm = 0;
! 670: else rm = rnd_room();
! 671: rnd_pos(&rooms[rm], &tp);
! 672: } until (winat(tp.y, tp.x) == FLOOR || cnt++ > 2500);
! 673: mvaddch(tp.y, tp.x, cur->o_type);
! 674: cur->o_pos = tp;
! 675: }
! 676: }
! 677: