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