[BACK]Return to new_level.c CVS log [TXT][DIR] Up to [contributed] / early-roguelike / rogue5

Annotation of early-roguelike/rogue5/new_level.c, Revision 1.1

1.1     ! rubenllo    1: /*
        !             2:  * new_level:
        !             3:  *     Dig and draw a new level
        !             4:  *
        !             5:  * @(#)new_level.c     4.38 (Berkeley) 02/05/99
        !             6:  *
        !             7:  * Rogue: Exploring the Dungeons of Doom
        !             8:  * Copyright (C) 1980-1983, 1985, 1999 Michael Toy, Ken Arnold and Glenn Wichman
        !             9:  * All rights reserved.
        !            10:  *
        !            11:  * See the file LICENSE.TXT for full copyright and licensing information.
        !            12:  */
        !            13:
        !            14: #include <curses.h>
        !            15: #include <string.h>
        !            16: #include "rogue.h"
        !            17:
        !            18: #define TREAS_ROOM 20  /* one chance in TREAS_ROOM for a treasure room */
        !            19: #define MAXTREAS 10    /* maximum number of treasures in a treasure room */
        !            20: #define MINTREAS 2     /* minimum number of treasures in a treasure room */
        !            21:
        !            22: void
        !            23: new_level(void)
        !            24: {
        !            25:     THING *tp;
        !            26:     PLACE *pp;
        !            27:     int *sp;
        !            28:     int i;
        !            29:
        !            30:     player.t_flags &= ~ISHELD; /* unhold when you go down just in case */
        !            31:     if (level > max_level)
        !            32:        max_level = level;
        !            33:     /*
        !            34:      * Clean things off from last level
        !            35:      */
        !            36:     for (pp = places; pp < &places[MAXCOLS*MAXLINES]; pp++)
        !            37:     {
        !            38:        pp->p_ch = ' ';
        !            39:        pp->p_flags = F_REAL;
        !            40:        pp->p_monst = NULL;
        !            41:     }
        !            42:     clear();
        !            43:     /*
        !            44:      * Free up the monsters on the last level
        !            45:      */
        !            46:     for (tp = mlist; tp != NULL; tp = next(tp))
        !            47:        free_list(tp->t_pack);
        !            48:     free_list(mlist);
        !            49:     /*
        !            50:      * Throw away stuff left on the previous level (if anything)
        !            51:      */
        !            52:     free_list(lvl_obj);
        !            53:     do_rooms();                                /* Draw rooms */
        !            54:     do_passages();                     /* Draw passages */
        !            55:     no_food++;
        !            56:     put_things();                      /* Place objects (if any) */
        !            57:     /*
        !            58:      * Place the traps
        !            59:      */
        !            60:     if (rnd(10) < level)
        !            61:     {
        !            62:        ntraps = rnd(level / 4) + 1;
        !            63:        if (ntraps > MAXTRAPS)
        !            64:            ntraps = MAXTRAPS;
        !            65:        i = ntraps;
        !            66:        while (i--)
        !            67:        {
        !            68:            /*
        !            69:             * not only wouldn't it be NICE to have traps in mazes
        !            70:             * (not that we care about being nice), since the trap
        !            71:             * number is stored where the passage number is, we
        !            72:             * can't actually do it.
        !            73:             */
        !            74:            do
        !            75:            {
        !            76:                find_floor(NULL, &stairs, FALSE, FALSE);
        !            77:            } while ( (chat(stairs.y, stairs.x) != FLOOR) &&
        !            78:                      (flat(stairs.y, stairs.x) & F_REAL) );
        !            79:            sp = &flat(stairs.y, stairs.x);
        !            80:            *sp &= ~(F_REAL | F_TMASK);
        !            81:            *sp |= rnd(NTRAPS);
        !            82:        }
        !            83:     }
        !            84:     /*
        !            85:      * Place the staircase down.
        !            86:      */
        !            87:     find_floor(NULL, &stairs, FALSE, FALSE);
        !            88:     chat(stairs.y, stairs.x) = STAIRS;
        !            89:     seenstairs = FALSE;
        !            90:
        !            91:     for (tp = mlist; tp != NULL; tp = next(tp))
        !            92:        tp->t_room = roomin(&tp->t_pos);
        !            93:
        !            94:     find_floor(NULL, &hero, FALSE, TRUE);
        !            95:     enter_room(&hero);
        !            96:     mvaddch(hero.y, hero.x, PLAYER);
        !            97:     if (on(player, SEEMONST))
        !            98:        turn_see(FALSE);
        !            99:     if (on(player, ISHALU))
        !           100:        visuals();
        !           101: }
        !           102:
        !           103: /*
        !           104:  * rnd_room:
        !           105:  *     Pick a room that is really there
        !           106:  */
        !           107: int
        !           108: rnd_room(void)
        !           109: {
        !           110:     int rm;
        !           111:
        !           112:     do
        !           113:     {
        !           114:        rm = rnd(MAXROOMS);
        !           115:     } while (rooms[rm].r_flags & ISGONE);
        !           116:     return rm;
        !           117: }
        !           118:
        !           119: /*
        !           120:  * put_things:
        !           121:  *     Put potions and scrolls on this level
        !           122:  */
        !           123:
        !           124: void
        !           125: put_things(void)
        !           126: {
        !           127:     int i;
        !           128:     THING *obj;
        !           129:
        !           130:     /*
        !           131:      * Once you have found the amulet, the only way to get new stuff is
        !           132:      * go down into the dungeon.
        !           133:      */
        !           134:     if (amulet && level < max_level)
        !           135:        return;
        !           136:     /*
        !           137:      * check for treasure rooms, and if so, put it in.
        !           138:      */
        !           139:     if (rnd(TREAS_ROOM) == 0)
        !           140:        treas_room();
        !           141:     /*
        !           142:      * Do MAXOBJ attempts to put things on a level
        !           143:      */
        !           144:     for (i = 0; i < MAXOBJ; i++)
        !           145:        if (rnd(100) < 36)
        !           146:        {
        !           147:            /*
        !           148:             * Pick a new object and link it in the list
        !           149:             */
        !           150:            obj = new_thing();
        !           151:            attach(lvl_obj, obj);
        !           152:            /*
        !           153:             * Put it somewhere
        !           154:             */
        !           155:            find_floor(NULL, &obj->o_pos, FALSE, FALSE);
        !           156:            chat(obj->o_pos.y, obj->o_pos.x) = obj->o_type;
        !           157:        }
        !           158:     /*
        !           159:      * If he is really deep in the dungeon and he hasn't found the
        !           160:      * amulet yet, put it somewhere on the ground
        !           161:      */
        !           162:     if (level >= AMULETLEVEL && !amulet)
        !           163:     {
        !           164:        obj = new_item();
        !           165:        attach(lvl_obj, obj);
        !           166:        obj->o_hplus = 0;
        !           167:        obj->o_dplus = 0;
        !           168:        strncpy(obj->o_damage,"0x0",sizeof(obj->o_damage));
        !           169:         strncpy(obj->o_hurldmg,"0x0",sizeof(obj->o_hurldmg));
        !           170:        obj->o_arm = 11;
        !           171:        obj->o_type = AMULET;
        !           172:        /*
        !           173:         * Put it somewhere
        !           174:         */
        !           175:        find_floor(NULL, &obj->o_pos, FALSE, FALSE);
        !           176:        chat(obj->o_pos.y, obj->o_pos.x) = AMULET;
        !           177:     }
        !           178: }
        !           179:
        !           180: /*
        !           181:  * treas_room:
        !           182:  *     Add a treasure room
        !           183:  */
        !           184: #define MAXTRIES 10    /* max number of tries to put down a monster */
        !           185:
        !           186:
        !           187: void
        !           188: treas_room(void)
        !           189: {
        !           190:     int nm;
        !           191:     THING *tp;
        !           192:     struct room *rp;
        !           193:     int spots, num_monst;
        !           194:     coord mp;
        !           195:
        !           196:     rp = &rooms[rnd_room()];
        !           197:     spots = (rp->r_max.y - 2) * (rp->r_max.x - 2) - MINTREAS;
        !           198:     if (spots > (MAXTREAS - MINTREAS))
        !           199:        spots = (MAXTREAS - MINTREAS);
        !           200:     num_monst = nm = rnd(spots) + MINTREAS;
        !           201:     while (nm--)
        !           202:     {
        !           203:        find_floor(rp, &mp, 2 * MAXTRIES, FALSE);
        !           204:        tp = new_thing();
        !           205:        tp->o_pos = mp;
        !           206:        attach(lvl_obj, tp);
        !           207:        chat(mp.y, mp.x) = tp->o_type;
        !           208:     }
        !           209:
        !           210:     /*
        !           211:      * fill up room with monsters from the next level down
        !           212:      */
        !           213:
        !           214:     if ((nm = rnd(spots) + MINTREAS) < num_monst + 2)
        !           215:        nm = num_monst + 2;
        !           216:     spots = (rp->r_max.y - 2) * (rp->r_max.x - 2);
        !           217:     if (nm > spots)
        !           218:        nm = spots;
        !           219:     level++;
        !           220:     while (nm--)
        !           221:     {
        !           222:        spots = 0;
        !           223:        if (find_floor(rp, &mp, MAXTRIES, TRUE))
        !           224:        {
        !           225:            tp = new_item();
        !           226:            new_monster(tp, randmonster(FALSE), &mp);
        !           227:            tp->t_flags |= ISMEAN;      /* no sloughers in THIS room */
        !           228:            give_pack(tp);
        !           229:        }
        !           230:     }
        !           231:     level--;
        !           232: }

CVSweb