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