Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/games/volume7/nethack3/part20

Internet Message Format | 1989-07-31 | 56KB

Path: uunet!zephyr.ens.tek.com!tektronix!tekgen!tekred!saab!billr
From: [e-mail] (Bill Randle)
Newsgroups: comp.sources.games
Subject: v07i075:  NetHack3 -  display oriented dungeons & dragons (Ver. 3.0), Part20/38
Message-ID: <[e-mail]>
Date: 24 Jul 89 19:03:03 GMT
Sender: [e-mail]
Lines: 2375
Approved: [e-mail]

Submitted-by: Izchak Miller <[e-mail]>
Posting-number: Volume 7, Issue 75
Archive-name: NetHack3/Part20



#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 20 (of 38)."
# Contents:  include/attrib.h src/lev_comp.y src/mklev.c
# Wrapped by billr@saab on Sun Jul 23 21:33:03 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'include/attrib.h' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'include/attrib.h'\"
else
echo shar: Extracting \"'include/attrib.h'\" \(786 characters\)
sed "s/^X//" >'include/attrib.h' <<'END_OF_FILE'
X/*
X *    attrib.h - Header file for character class processing.
X *
X *    Copyright 1988, M. Stephenson
X */
X/* NetHack may be freely redistributed.  See license for details. */
X
X#ifndef ATTRIB_H
X#define ATTRIB_H
X
X#define    A_STR    0
X#define    A_INT    1
X#define    A_WIS    2
X#define    A_DEX    3
X#define    A_CON    4
X#define    A_CHA    5
X
X#define A_MAX    6    /* used in rn2() selection of attrib */
X
X#define    ABASE(x)    (u.acurr.a[x])
X#define ABON(x)        (u.abon.a[x])
X#define ACURR(x)    (schar) acurr(x)
X/* should be: */
X/* #define    ACURR(x)    (ABON(x) + ATEMP(x) + (u.umonnum == -1) ? ABASE(x) : MBASE(x)) */
X#define    MCURR(x)    (u.macurr.a[x])
X#define    AMAX(x)        (u.amax.a[x])
X#define    MMAX(x)        (u.mamax.a[x])
X
X#define    ATEMP(x)    (u.atemp.a[x])
X#define    ATIME(x)    (u.atime.a[x])
X
Xstruct    attribs {
X
X    schar    a[A_MAX];
X};
X
X#endif /* ATTRIB_H /* */
END_OF_FILE
if test 786 -ne `wc -c <'include/attrib.h'`; then
    echo shar: \"'include/attrib.h'\" unpacked with wrong size!
fi
# end of 'include/attrib.h'
fi
if test -f 'src/lev_comp.y' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'src/lev_comp.y'\"
else
echo shar: Extracting \"'src/lev_comp.y'\" \(23359 characters\)
sed "s/^X//" >'src/lev_comp.y' <<'END_OF_FILE'
X%{
X/*    SCCS Id: @(#)lev_comp.c    3.0    89/07/02
X/*    Copyright (c) 1989 by Jean-Christophe Collet */
X/* NetHack may be freely redistributed.  See license for details. */
X
X/*
X * This file contains the Level Compiler code
X * It may handle special mazes & special room-levels
X */
X
X/* block some unused #defines to avoid overloading some cpp's */
X#define MONDATA_H
X#include "hack.h"
X#include "sp_lev.h"
X#include <fcntl.h>
X
X#ifdef AMIGA
Xchar *fgets();
X# define    alloc   malloc
X# undef     fopen
X# undef     printf
X# undef     Printf
X# define    Printf  printf
X# define    memset(addr,val,len)    setmem(addr,len,val)
X#endif
X
X#ifdef MSDOS
X# undef exit
X#endif
X
X#define MAX_REGISTERS    10
X#define ERR        (-1)
X
Xstruct reg {
X    int x1, y1;
X    int x2, y2;
X}        current_region;
X
Xstruct coord {
X    int x;
X    int y;
X}        current_coord;
X
Xstruct {
X    char *name;
X    short type;
X} trap_types[TRAPNUM-1] = {
X    "monster",    MONST_TRAP,
X    "statue",    STATUE_TRAP,
X    "bear",        BEAR_TRAP,
X    "arrow",    ARROW_TRAP,
X    "dart",        DART_TRAP,
X    "trapdoor",    TRAPDOOR,
X    "teleport",    TELEP_TRAP,
X    "pit",        PIT,
X    "sleeping gas",    SLP_GAS_TRAP,
X    "magic",    MGTRP,
X    "board",    SQBRD,
X    "web",        WEB,
X    "spiked pit",    SPIKED_PIT,
X    "level teleport",LEVEL_TELEP,
X#ifdef SPELLS
X    "anti magic",    ANTI_MAGIC,
X#endif
X    "rust",        RUST_TRAP
X#ifdef POLYSELF
X    , "polymorph",    POLY_TRAP
X#endif
X#ifdef ARMY
X    , "land mine",    LANDMINE
X#endif
X  };
X
Xstruct {
X    char *name;
X    int type;
X} room_types[SHOPBASE-1] = {
X    /* for historical reasons, room types are not contiguous numbers */
X    /* (type 1 is skipped) */
X    "ordinary",    OROOM,
X#ifdef THRONES
X    "throne",    COURT,
X#endif
X    "swamp",    SWAMP,
X    "vault",    VAULT,
X    "beehive",    BEEHIVE,
X    "morgue",    MORGUE,
X#ifdef ARMY
X    "barracks",    BARRACKS,
X#endif
X    "zoo",        ZOO,
X    "temple",    TEMPLE,
X    "shop",        SHOPBASE,
X};
X
Xshort db_dirs[4] = {
X    DB_NORTH,
X    DB_EAST,
X    DB_SOUTH,
X    DB_WEST
X};
X
X#ifdef ALTARS
Xstatic altar *tmpaltar[256];
X#endif /* ALTARS /**/
Xstatic lad *tmplad[256];
Xstatic dig *tmpdig[256];
Xstatic char *tmpmap[ROWNO];
Xstatic region *tmpreg[16];
Xstatic door *tmpdoor[256];
Xstatic trap *tmptrap[256];
Xstatic monster *tmpmonst[256];
Xstatic object *tmpobj[256];
Xstatic drawbridge *tmpdb[256];
Xstatic walk *tmpwalk[256];
Xstatic mazepart *tmppart[10];
Xstatic room *tmproom[MAXNROFROOMS];
Xstatic specialmaze maze;
X
Xstatic char olist[MAX_REGISTERS], mlist[MAX_REGISTERS];
Xstatic struct coord plist[MAX_REGISTERS];
Xstatic int n_olist = 0, n_mlist = 0, n_plist = 0;
X
Xunsigned int nreg = 0, ndoor = 0, ntrap = 0, nmons = 0, nobj = 0;
Xunsigned int ndb = 0, nwalk = 0, npart = 0, ndig = 0, nlad = 0;
X#ifdef ALTARS
Xunsigned int naltar = 0;
X#endif /* ALTARS /*/
X
Xunsigned int max_x_map, max_y_map;
X
Xextern int fatal_error;
Xextern char* fname;
X
Xboolean check_monster_char(), check_object_char();
Xvoid scan_map(), store_part(), write_maze();
X
X%}
X
X%union
X{
X    int    i;
X    char*    map;
X}
X
X
X%token    <i> CHAR INTEGER
X%token    <i> MAZE_ID LEVEL_ID GEOMETRY_ID
X%token    <i> OBJECT_ID MONSTER_ID TRAP_ID DOOR_ID DRAWBRIDGE_ID MAZEWALK_ID
X%token    <i> REGION_ID RANDOM_OBJECTS_ID RANDOM_MONSTERS_ID RANDOM_PLACES_ID
X%token    <i> ALTAR_ID LADDER_ID NON_DIGGABLE_ID ROOM_ID
X%token    <i> DOOR_STATE LIGHT_STATE
X%token    <i> DIRECTION RANDOM_TYPE O_REGISTER M_REGISTER P_REGISTER A_REGISTER
X%token    <i> ALIGNMENT LEFT_OR_RIGHT CENTER TOP_OR_BOT ALTAR_TYPE UP_OR_DOWN
X%token  <i> ',' ':' '(' ')' '[' ']'
X%token    <map> STRING MAP_ID
X%type    <map> string maze_def m_name o_name
X%start    file
X
X%%
Xfile        : /* notthing */
X        | levels ;
X
Xlevels        : level
X        | levels level ;
X
Xlevel        : maze_level ;
X
Xmaze_level    : maze_def regions
X          {
X              int fout, i;
X
X              if (fatal_error > 0)
X                  fprintf(stderr,"%s : %d errors detected. No output created!\n", fname, fatal_error);
X              else {
X                  fout = open($1, O_WRONLY | O_CREAT
X#ifdef MSDOS
X                          | O_BINARY
X#endif /* MSDOS */
X                          , 0644);
X                  if (fout < 0) {
X                      yyerror("Can't open output file!!");
X                      exit(1);
X                  }
X                  maze.numpart = npart;
X                  maze.parts = (mazepart**) alloc(sizeof(mazepart*)*npart);
X                  for(i=0;i<npart;i++)
X                      maze.parts[i] = tmppart[i];
X                  write_maze(fout, &maze);
X                  (void) close(fout);
X                  npart = 0;
X              }
X          }
X
Xmaze_def    : MAZE_ID ':' string
X          {
X              $$ = $3;
X          }
X
Xregions        : aregion
X        | regions aregion;
X
Xaregion        : map_definition reg_init map_details
X          {
X            store_part();
X          }
X
Xmap_definition    : map_geometry MAP_ID
X          {
X            tmppart[npart] = (mazepart *) alloc(sizeof(mazepart));
X            tmppart[npart]->halign = $<i>1 % 10;
X            tmppart[npart]->valign = $<i>1 / 10;
X            tmppart[npart]->nrobjects = 0;
X            tmppart[npart]->nloc = 0;
X            tmppart[npart]->nrmonst = 0;
X            scan_map($2);
X          }
X
Xmap_geometry    : GEOMETRY_ID ':' h_justif ',' v_justif
X          {
X              $<i>$ = $<i>3 + ( $<i>5 * 10 );
X          }
X
Xh_justif    : LEFT_OR_RIGHT
X        | CENTER ;
X
Xv_justif    : TOP_OR_BOT
X        | CENTER ;
X
Xreg_init    : /* nothing */
X        | reg_init init_reg ;
X
Xinit_reg    : RANDOM_OBJECTS_ID ':' object_list
X          {
X              if (tmppart[npart]->nrobjects)
X                  yyerror("Object registers already initialized!");
X              else {
X                  tmppart[npart]->robjects = (char *) alloc(n_olist);
X                  memcpy(tmppart[npart]->robjects, olist, n_olist);
X                  tmppart[npart]->nrobjects = n_olist;
X              }
X          }
X        | RANDOM_PLACES_ID ':' place_list
X          {
X              if (tmppart[npart]->nloc)
X                  yyerror("Location registers already initialized!");
X              else {
X                  register int i;
X                  tmppart[npart]->rloc_x = (char *) alloc(n_plist);
X                  tmppart[npart]->rloc_y = (char *) alloc(n_plist);
X                  for(i=0;i<n_plist;i++) {
X                      tmppart[npart]->rloc_x[i] = plist[i].x;
X                      tmppart[npart]->rloc_y[i] = plist[i].y;
X                  }
X                  tmppart[npart]->nloc = n_plist;
X              }
X          }
X        | RANDOM_MONSTERS_ID ':' monster_list
X          {
X              if (tmppart[npart]->nrmonst)
X                  yyerror("Monster registers already initialized!");
X              else {
X                  tmppart[npart]->rmonst = (char *) alloc(n_mlist);
X                  memcpy(tmppart[npart]->rmonst, mlist, n_mlist);
X                  tmppart[npart]->nrmonst = n_mlist;
X              }
X          }
X
Xobject_list    : object
X          {
X              if (n_olist < MAX_REGISTERS)
X                  olist[n_olist++] = $<i>1;
X              else
X                  yyerror("Object list too long!");
X          }
X        | object_list ',' object
X          {
X              if (n_olist < MAX_REGISTERS)
X                  olist[n_olist++] = $<i>3;
X              else
X                  yyerror("Object list too long!");
X          }
X
Xmonster_list    : monster
X          {
X              if (n_mlist < MAX_REGISTERS)
X                  mlist[n_mlist++] = $<i>1;
X              else
X                  yyerror("Monster list too long!");
X          }
X        | monster_list ',' monster
X          {
X              if (n_mlist < MAX_REGISTERS)
X                  mlist[n_mlist++] = $<i>3;
X              else
X                  yyerror("Monster list too long!");
X          }
X
Xplace_list    : place
X          {
X              if (n_plist < MAX_REGISTERS)
X                  plist[n_plist++] = current_coord;
X              else
X                  yyerror("Location list too long!");
X          }
X        | place_list ',' place
X          {
X              if (n_plist < MAX_REGISTERS)
X                  plist[n_plist++] = current_coord;
X              else
X                  yyerror("Location list too long!");
X          }
X
Xmap_details    : /* nothing */
X        | map_details map_detail ;
X
Xmap_detail    : monster_detail
X        | object_detail
X        | door_detail
X        | trap_detail
X        | drawbridge_detail
X        | region_detail
X        | altar_detail
X        | mazewalk_detail
X        | ladder_detail
X        | diggable_detail ;
X
Xmonster_detail    : MONSTER_ID ':' monster_c ',' m_name ',' coordinate
X          {
X              int token;
X
X              tmpmonst[nmons] = (monster *) alloc(sizeof(monster));
X              tmpmonst[nmons]->x = current_coord.x;
X              tmpmonst[nmons]->y = current_coord.y;
X              tmpmonst[nmons]->class = $<i>3;
X              if (!$5)
X                  tmpmonst[nmons]->id = -1;
X              else {
X                  token = get_monster_id($5, (char) $<i>3);
X                  if (token == ERR) {
X                      yywarning("Illegal monster name!  Making random monster.");
X                      tmpmonst[nmons]->id = -1;
X                  } else
X                      tmpmonst[nmons]->id = token;
X              }
X              nmons++;
X          }
X
Xobject_detail    : OBJECT_ID ':' object_c ',' o_name ',' coordinate
X          {
X              int token;
X
X              tmpobj[nobj] = (object *) alloc(sizeof(object));
X              tmpobj[nobj]->x = current_coord.x;
X              tmpobj[nobj]->y = current_coord.y;
X              tmpobj[nobj]->class = $<i>3;
X              if (!$5)
X                  tmpobj[nobj]->id = -1;
X              else {
X                  token = get_object_id($5, (char) $<i>3);
X                  if (token == ERR) {
X                      yywarning("Illegal object name!  Making random object.");
X                      tmpobj[nobj]->id = -1;
X                  } else
X                      tmpobj[nobj]->id = token;
X              }
X              nobj++;
X          }
X
Xdoor_detail    : DOOR_ID ':' door_state ',' coordinate
X          {
X            tmpdoor[ndoor] = (door *) alloc(sizeof(door));
X            tmpdoor[ndoor]->x = current_coord.x;
X            tmpdoor[ndoor]->y = current_coord.y;
X            tmpdoor[ndoor]->mask = $<i>3;
X            ndoor++;
X          }
X
Xtrap_detail    : TRAP_ID ':' trap_name ',' coordinate
X          {
X            tmptrap[ntrap] = (trap *) alloc(sizeof(trap));
X            tmptrap[ntrap]->x = current_coord.x;
X            tmptrap[ntrap]->y = current_coord.y;
X            tmptrap[ntrap]->type = $<i>3;
X            ntrap++;
X          }
X
Xdrawbridge_detail: DRAWBRIDGE_ID ':' coordinate ',' DIRECTION ',' door_state
X           {
X            tmpdb[ndb] = (drawbridge *) alloc(sizeof(drawbridge));
X            tmpdb[ndb]->x = current_coord.x;
X            tmpdb[ndb]->y = current_coord.y;
X            tmpdb[ndb]->dir = db_dirs[$5];
X            if ( $<i>7 == D_ISOPEN )
X              tmpdb[ndb]->open = 1;
X            else if ( $<i>7 == D_CLOSED )
X              tmpdb[ndb]->open = 0;
X            else
X              yyerror("A drawbridge can only be open or closed!");
X            ndb++;
X           }
X
Xmazewalk_detail    : MAZEWALK_ID ':' coordinate ',' DIRECTION
X          {
X            tmpwalk[nwalk] = (walk *) alloc(sizeof(walk));
X            tmpwalk[nwalk]->x = current_coord.x;
X            tmpwalk[nwalk]->y = current_coord.y;
X            tmpwalk[nwalk]->dir = $5;
X            nwalk++;
X          }
X
Xladder_detail    : LADDER_ID ':' coordinate ',' UP_OR_DOWN
X          {
X            tmplad[nlad] = (lad *) alloc(sizeof(lad));
X            tmplad[nlad]->x = current_coord.x;
X            tmplad[nlad]->y = current_coord.y;
X            tmplad[nlad]->up = $<i>5;
X            nlad++;
X          }
X
Xdiggable_detail    : NON_DIGGABLE_ID ':' region
X          {
X            tmpdig[ndig] = (dig *) alloc(sizeof(dig));
X            tmpdig[ndig]->x1 = current_region.x1;
X            tmpdig[ndig]->y1 = current_region.y1;
X            tmpdig[ndig]->x2 = current_region.x2;
X            tmpdig[ndig]->y2 = current_region.y2;
X            ndig++;
X          }
X
Xregion_detail    : REGION_ID ':' region ',' light_state ',' room_type
X          {
X            tmpreg[nreg] = (region *) alloc(sizeof(region));
X            tmpreg[nreg]->x1 = current_region.x1;
X            tmpreg[nreg]->y1 = current_region.y1;
X            tmpreg[nreg]->x2 = current_region.x2;
X            tmpreg[nreg]->y2 = current_region.y2;
X            tmpreg[nreg]->rlit = $<i>5;
X            tmpreg[nreg]->rtype = $<i>7;
X            nreg++;
X          }
X
Xaltar_detail    : ALTAR_ID ':' coordinate ',' alignment ',' altar_type
X          {
X#ifndef ALTARS
X            yywarning("Altars are not allowed in this version!  Ignoring...");
X#else
X            tmpaltar[naltar] = (altar *) alloc(sizeof(altar));
X            tmpaltar[naltar]->x = current_coord.x;
X            tmpaltar[naltar]->y = current_coord.y;
X            tmpaltar[naltar]->align = $<i>5;
X            tmpaltar[naltar]->shrine = $<i>7;
X            naltar++;
X#endif /* ALTARS */
X          }
X
Xmonster_c    : monster
X        | RANDOM_TYPE
X          {
X              $<i>$ = - MAX_REGISTERS - 1;
X          }
X        | m_register ;
X
Xobject_c    : object
X        | RANDOM_TYPE
X          {
X              $<i>$ = - MAX_REGISTERS - 1;
X          }
X        | o_register;
X
Xm_name        : string
X        | RANDOM_TYPE
X          {
X              $$ = (char *) 0;
X          }
X
Xo_name        : string
X        | RANDOM_TYPE
X          {
X              $$ = (char *) 0;
X          }
X
Xtrap_name    : string
X          {
X              int token = get_trap_type($1);
X            if (token == ERR)
X                yyerror("unknown trap type!");
X            $<i>$ = token;
X          }
X        | RANDOM_TYPE
X
Xroom_type    : string
X          {
X            int token = get_room_type($1);
X            if (token == ERR) {
X                yywarning("Unknown room type!  Making ordinary room...");
X                $<i>$ = OROOM;
X            } else
X                $<i>$ = token;
X          }
X        | RANDOM_TYPE
X
Xcoordinate    : coord
X        | p_register
X        | RANDOM_TYPE
X          {
X              current_coord.x = current_coord.y = -MAX_REGISTERS-1;
X          }
X
Xdoor_state    : DOOR_STATE
X        | RANDOM_TYPE
X
Xlight_state    : LIGHT_STATE
X        | RANDOM_TYPE
X
Xalignment    : ALIGNMENT
X        | a_register
X        | RANDOM_TYPE
X          {
X              $<i>$ = - MAX_REGISTERS - 1;
X          }
X
Xaltar_type    : ALTAR_TYPE
X        | RANDOM_TYPE
X
Xp_register    : P_REGISTER '[' INTEGER ']'
X          {
X            if ( $3 >= MAX_REGISTERS ) {
X                yyerror("Register Index overflow!");
X            } else {
X                current_coord.x = current_coord.y = - $3 - 1;
X            }
X          }
X
Xo_register    : O_REGISTER '[' INTEGER ']'
X          {
X            if ( $3 >= MAX_REGISTERS ) {
X                yyerror("Register Index overflow!");
X            } else {
X                $<i>$ = - $3 - 1;
X            }
X          }
X
Xm_register    : M_REGISTER '[' INTEGER ']'
X          {
X            if ( $3 >= MAX_REGISTERS ) {
X                yyerror("Register Index overflow!");
X            } else {
X                $<i>$ = - $3 - 1;
X            }
X          }
X
Xa_register    : A_REGISTER '[' INTEGER ']'
X          {
X            if ( $3 >= 3 ) {
X                yyerror("Register Index overflow!");
X            } else {
X                $<i>$ = - $3 - 1;
X            }
X          }
X
Xplace        : coord
X
Xmonster        : CHAR
X          {
X            if (check_monster_char($1))
X                $<i>$ = $1 ;
X            else {
X                yyerror("unknown monster class!");
X                $<i>$ = ERR;
X            }
X          }
X
Xobject        : CHAR
X          {
X            char c;
X
X            c = $1;
X#ifndef SPELLS
X            if ( c == '+') {
X                c = '?';
X                yywarning("Spellbooks are not allowed in this version! (converted into scroll)");
X            }
X#endif
X            if (check_object_char(c))
X                $<i>$ = c;
X            else {
X                yyerror("Unknown char class!");
X                $<i>$ = ERR;
X            }
X          }
Xstring        : STRING
X
Xcoord        : '(' INTEGER ',' INTEGER ')'
X          {
X                if ($2 < 0 || $2 > max_x_map ||
X                $4 < 0 || $4 > max_y_map)
X                yyerror("Coordinates out of map range!");
X            current_coord.x = $2;
X            current_coord.y = $4;
X          }
X
Xregion        : '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')'
X          {
X                if ($2 < 0 || $2 > max_x_map ||
X                $4 < 0 || $4 > max_y_map ||
X                $6 < 0 || $6 > max_x_map ||
X                $8 < 0 || $8 > max_y_map)
X                yyerror("Region out of map range!");
X            current_region.x1 = $2;
X            current_region.y1 = $4;
X            current_region.x2 = $6;
X            current_region.y2 = $8;
X          }
X
X
X%%
X
X/*
X * Find the type of a room in the table, knowing its name.
X */
X
Xint
Xget_room_type(s)
Xchar *s;
X{
X    register int i;
X
X    for(i=0; i < SHOPBASE -1; i++)
X        if (!strcmp(s, room_types[i].name))
X        return room_types[i].type;
X    return ERR;
X}
X
X/*
X * Find the type of a trap in the table, knowing its name.
X */
X
Xint
Xget_trap_type(s)
Xchar *s;
X{
X    register int i;
X
X    for(i=0; i < TRAPNUM - 1; i++)
X        if(!strcmp(s,trap_types[i].name))
X        return(trap_types[i].type);
X    return ERR;
X}
X
X/*
X * Find the index of a monster in the table, knowing its name.
X */
X
Xint
Xget_monster_id(s, c)
Xchar *s;
Xchar c;
X{
X    register int i;
X
X    for(i=0; mons[i].mname[0]; i++)
X        if(!strncmp(s, mons[i].mname, strlen(mons[i].mname))
X           && c == mons[i].mlet)
X        return i;
X    return ERR;
X}
X
X/*
X * Find the index of an object in the table, knowing its name.
X */
X
Xint
Xget_object_id(s, c)
Xchar *s;
Xchar c;
X{
X    register int i;
X
X    for(i=0; i<=NROFOBJECTS;i++)
X        if(objects[i].oc_name &&
X           !strncmp(s, objects[i].oc_name, strlen(objects[i].oc_name))
X           && c == objects[i].oc_olet)
X        return i;
X    return ERR;
X}
X
X/*
X * Is the character 'c' a valid monster class ?
X */
X
Xboolean
Xcheck_monster_char(c)
Xchar c;
X{
X    register int i;
X
X    for(i=0; mons[i].mname[0]; i++)
X        if( c ==  mons[i].mlet)
X        return 1;
X    return(0);
X}
X
X/*
X * Is the character 'c' a valid object class ?
X */
X
Xboolean
Xcheck_object_char(c)
Xchar c;
X{
X    register int i;
X
X    for(i=0; i<=NROFOBJECTS;i++)
X        if( c == objects[i].oc_olet)
X        return 1;
X    return 0;
X}
X
X/*
X * Yep! LEX gives us the map in a raw mode.
X * Just analyze it here.
X */
X
Xvoid scan_map(map)
Xchar *map;
X{
X    register int i, len;
X    register char *s1, *s2;
X    int max_len = 0;
X    int max_hig = 0;
X
X    /* First : find the max width of the map */
X
X    s1 = map;
X    while (s1 && *s1) {
X        s2 = index(s1, '\n');
X        if (s2) {
X            if (s2-s1 > max_len)
X                max_len = s2-s1;
X            s1 = s2 + 1;
X        } else {
X            if (strlen(s1) > max_len)
X                max_len = strlen(s1);
X            s1 = (char *) 0;
X        }
X    }
X
X    /* Then parse it now */
X
X    while (map && *map) {
X        tmpmap[max_hig] = (char *) alloc(max_len);
X        s1 = index(map, '\n');
X        if (s1) {
X            len = s1 - map;
X            s1++;
X        } else {
X            len = strlen(map);
X            s1 = map + len;
X        }
X        for(i=0; i<len; i++)
X            switch(map[i]) {
X              case '-' : tmpmap[max_hig][i] = HWALL; break;
X              case '|' : tmpmap[max_hig][i] = VWALL; break;
X              case '+' : tmpmap[max_hig][i] = DOOR; break;
X              case 'S' : tmpmap[max_hig][i] = SDOOR; break;
X              case '{' :
X#ifdef FOUNTAINS
X                  tmpmap[max_hig][i] = FOUNTAIN;
X#else
X                  tmpmap[max_hig][i] = ROOM;
X                  yywarning("Fountains are not allowed in this version!  Ignoring...");
X#endif
X                  break;
X              case '\\' :
X#ifdef THRONES
X                  tmpmap[max_hig][i] = THRONE;
X#else
X                  tmpmap[max_hig][i] = ROOM;
X                  yywarning("Thrones are not allowed in this version!  Ignoring...");
X#endif
X                  break;
X              case 'K' :
X#ifdef SINKS
X                  tmpmap[max_hig][i] = SINK;
X#else
X                  tmpmap[max_hig][i] = ROOM;
X                  yywarning("Sinks are not allowed in this version!  Ignoring...");
X#endif
X                  break;
X              case '}' : tmpmap[max_hig][i] = MOAT; break;
X              case '#' : tmpmap[max_hig][i] = CORR; break;
X              default  : tmpmap[max_hig][i] = ROOM; break;
X            }
X        while(i < max_len)
X            tmpmap[max_hig][i++] = ROOM;
X        map = s1;
X        max_hig++;
X    }
X
X    /* Memorize boundaries */
X
X    max_x_map = max_len - 1;
X    max_y_map = max_hig - 1;
X
X    /* Store the map into the mazepart structure */
X
X    tmppart[npart]->xsize = max_len;
X    tmppart[npart]->ysize = max_hig;
X    tmppart[npart]->map = (char **) alloc(max_hig*sizeof(char *));
X    for(i = 0; i< max_hig; i++)
X        tmppart[npart]->map[i] = tmpmap[i];
X}
X
X/*
X * Here we want to store the maze part we just got.
X */
X
Xvoid
Xstore_part()
X{
X    register int i;
X
X    /* Ok, We got the whole part, now we store it. */
X
X    /* The Regions */
X
X    if(tmppart[npart]->nreg = nreg) {
X        tmppart[npart]->regions = (region**)alloc(sizeof(region*) * nreg);
X        for(i=0;i<nreg;i++)
X            tmppart[npart]->regions[i] = tmpreg[i];
X    }
X    nreg = 0;
X
X    /* the doors */
X
X    if(tmppart[npart]->ndoor = ndoor) {
X        tmppart[npart]->doors = (door **)alloc(sizeof(door *) * ndoor);
X        for(i=0;i<ndoor;i++)
X            tmppart[npart]->doors[i] = tmpdoor[i];
X    }
X    ndoor = 0;
X
X    /* the traps */
X
X    if(tmppart[npart]->ntraps = ntrap) {
X        tmppart[npart]->traps = (trap **)alloc(sizeof(trap*) * ntrap);
X        for(i=0;i<ntrap;i++)
X            tmppart[npart]->traps[i] = tmptrap[i];
X    }
X    ntrap = 0;
X
X    /* the monsters */
X
X    if(tmppart[npart]->nmonster = nmons) {
X        tmppart[npart]->monsters = (monster**)alloc(sizeof(monster*)*nmons);
X        for(i=0;i<nmons;i++)
X            tmppart[npart]->monsters[i] = tmpmonst[i];
X    }
X    nmons = 0;
X
X    /* the objects */
X
X    if(tmppart[npart]->nobjects = nobj) {
X        tmppart[npart]->objects = (object**)alloc(sizeof(object*)*nobj);
X        for(i=0;i<nobj;i++)
X            tmppart[npart]->objects[i] = tmpobj[i];
X    }
X    nobj = 0;
X
X    /* the drawbridges */
X
X    if(tmppart[npart]->ndrawbridge = ndb) {
X        tmppart[npart]->drawbridges = (drawbridge**)alloc(sizeof(drawbridge*)*ndb);
X        for(i=0;i<ndb;i++)
X            tmppart[npart]->drawbridges[i] = tmpdb[i];
X    }
X    ndb = 0;
X
X    /* The walkmaze directives */
X
X    if(tmppart[npart]->nwalk = nwalk) {
X        tmppart[npart]->walks = (walk**)alloc(sizeof(walk*)*nwalk);
X        for(i=0;i<nwalk;i++)
X            tmppart[npart]->walks[i] = tmpwalk[i];
X    }
X    nwalk = 0;
X
X    /* The non_diggable directives */
X
X    if(tmppart[npart]->ndig = ndig) {
X        tmppart[npart]->digs = (dig **) alloc(sizeof(dig*) * ndig);
X        for(i=0;i<ndig;i++)
X            tmppart[npart]->digs[i] = tmpdig[i];
X    }
X    ndig = 0;
X
X    /* The ladders */
X
X    if(tmppart[npart]->nlad = nlad) {
X        tmppart[npart]->lads = (lad **) alloc(sizeof(lad*) * nlad);
X        for(i=0;i<nlad;i++)
X            tmppart[npart]->lads[i] = tmplad[i];
X    }
X    nlad = 0;
X#ifdef ALTARS
X    /* The altars */
X
X    if(tmppart[npart]->naltar = naltar) {
X        tmppart[npart]->altars = (altar**)alloc(sizeof(altar*) * naltar);
X        for(i=0;i<naltar;i++)
X            tmppart[npart]->altars[i] = tmpaltar[i];
X    }
X    naltar = 0;
X#endif /* ALTARS /**/
X    npart++;
X    n_plist = n_mlist = n_olist = 0;
X}
X
X/*
X * Here we write the structure of the maze in the specified file (fd).
X * Also, we have to free the memory allocated via alloc()
X */
X
Xvoid
Xwrite_maze(fd, maze)
Xint fd;
Xspecialmaze *maze;
X{
X    char c;
X    short i,j;
X    mazepart *pt;
X
X    c = 2;
X    (void) write(fd, &c, 1);    /* Header for special mazes */
X    (void) write(fd, &(maze->numpart), 1);    /* Number of parts */
X    for(i=0;i<maze->numpart;i++) {
X        pt = maze->parts[i];
X
X        /* First, write the map */
X
X        (void) write(fd, &(pt->halign), 1);
X        (void) write(fd, &(pt->valign), 1);
X        (void) write(fd, &(pt->xsize), 1);
X        (void) write(fd, &(pt->ysize), 1);
X        for(j=0;j<pt->ysize;j++) {
X            (void) write(fd, pt->map[j], pt->xsize);
X            free(pt->map[j]);
X        }
X        free(pt->map);
X
X        /* The random registers */
X        (void) write(fd, &(pt->nrobjects), 1);
X        if(pt->nrobjects) {
X            (void) write(fd, pt->robjects, pt->nrobjects);
X            free(pt->robjects);
X        }
X        (void) write(fd, &(pt->nloc), 1);
X        if(pt->nloc) {
X        (void) write(fd,pt->rloc_x, pt->nloc);
X        (void) write(fd,pt->rloc_y, pt->nloc);
X        free(pt->rloc_x);
X        free(pt->rloc_y);
X        }
X        (void) write(fd,&(pt->nrmonst), 1);
X        if(pt->nrmonst) {
X            (void) write(fd, pt->rmonst, pt->nrmonst);
X            free(pt->rmonst);
X        }
X
X        /* subrooms */
X        (void) write(fd, &(pt->nreg), 1);
X        for(j=0;j<pt->nreg;j++) {
X            (void) write(fd,(genericptr_t) pt->regions[j], sizeof(region));
X            free(pt->regions[j]);
X        }
X        if(pt->nreg > 0)
X        free(pt->regions);
X
X        /* the doors */
X        (void) write(fd,&(pt->ndoor),1);
X        for(j=0;j<pt->ndoor;j++) {
X            (void) write(fd,(genericptr_t) pt->doors[j], sizeof(door));
X            free(pt->doors[j]);
X        }
X        if (pt->ndoor > 0)
X        free(pt->doors);
X
X        /* The traps */
X        (void) write(fd,&(pt->ntraps), 1);
X        for(j=0;j<pt->ntraps;j++) {
X            (void) write(fd,(genericptr_t) pt->traps[j], sizeof(trap));
X            free(pt->traps[j]);
X        }
X        if (pt->ntraps)
X        free(pt->traps);
X
X        /* The monsters */
X        (void) write(fd, &(pt->nmonster), 1);
X        for(j=0;j<pt->nmonster;j++) {
X            (void) write(fd,(genericptr_t) pt->monsters[j], sizeof(monster));
X            free(pt->monsters[j]);
X        }
X        if (pt->nmonster > 0)
X        free(pt->monsters);
X
X        /* The objects */
X        (void) write(fd, &(pt->nobjects), 1);
X        for(j=0;j<pt->nobjects;j++) {
X            (void) write(fd,(genericptr_t) pt->objects[j], sizeof(object));
X            free(pt->objects[j]);
X        }
X        if(pt->nobjects > 0)
X        free(pt->objects);
X
X        /* The drawbridges */
X        (void) write(fd, &(pt->ndrawbridge),1);
X        for(j=0;j<pt->ndrawbridge;j++) {
X            (void) write(fd,(genericptr_t) pt->drawbridges[j], sizeof(drawbridge));
X            free(pt->drawbridges[j]);
X        }
X        if(pt->ndrawbridge > 0)
X        free(pt->drawbridges);
X
X        /* The mazewalk directives */
X        (void) write(fd, &(pt->nwalk), 1);
X        for(j=0; j<pt->nwalk; j++) {
X            (void) write(fd,(genericptr_t) pt->walks[j], sizeof(walk));
X            free(pt->walks[j]);
X        }
X        if (pt->nwalk > 0)
X        free(pt->walks);
X
X        /* The non_diggable directives */
X        (void) write(fd, &(pt->ndig), 1);
X        for(j=0;j<pt->ndig;j++) {
X            (void) write(fd,(genericptr_t) pt->digs[j], sizeof(dig));
X            free(pt->digs[j]);
X        }
X        if (pt->ndig > 0)
X        free(pt->digs);
X
X        /* The ladders */
X        (void) write(fd, &(pt->nlad), 1);
X        for(j=0;j<pt->nlad;j++) {
X            (void) write(fd,(genericptr_t) pt->lads[j], sizeof(lad));
X            free(pt->lads[j]);
X        }
X        if (pt->nlad > 0)
X        free(pt->lads);
X#ifdef ALTARS
X        /* The altars */
X        (void) write(fd, &(pt->naltar), 1);
X        for(j=0;j<pt->naltar;j++) {
X            (void) write(fd,(genericptr_t) pt->altars[j], sizeof(altar));
X            free(pt->altars[j]);
X        }
X        if (pt->naltar > 0)
X        free(pt->altars);
X#endif /* ALTARS /**/
X        free(pt);
X    }
X}
END_OF_FILE
if test 23359 -ne `wc -c <'src/lev_comp.y'`; then
    echo shar: \"'src/lev_comp.y'\" unpacked with wrong size!
fi
# end of 'src/lev_comp.y'
fi
if test -f 'src/mklev.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'src/mklev.c'\"
else
echo shar: Extracting \"'src/mklev.c'\" \(27014 characters\)
sed "s/^X//" >'src/mklev.c' <<'END_OF_FILE'
X/*    SCCS Id: @(#)mklev.c    3.0    88/11/24
X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
X/* NetHack may be freely redistributed.  See license for details. */
X
X#include "hack.h"
X
X/* for UNIX, Rand #def'd to (long)lrand48() or (long)random() */
X/* croom->lx etc are schar (width <= int), so % arith ensures that */
X/* conversion of result to int is reasonable */
X
X#ifdef SINKS
Xstatic void mksink();
X#endif
X#ifdef ALTARS
Xstatic void mkaltar();
X#endif
X
Xint
Xsomex(croom)
Xregister struct mkroom *croom;
X{
X    return rn2(croom->hx-croom->lx+1) + croom->lx;
X}
X
Xint
Xsomey(croom)
Xregister struct mkroom *croom;
X{
X    return rn2(croom->hy-croom->ly+1) + croom->ly;
X}
X
X#define    XLIM    4    /* define minimum required space around a room */
X#define    YLIM    3
Xboolean secret;        /* TRUE while making a vault: increase [XY]LIM */
Xstruct rm zerorm;
Xschar nxcor;
Xboolean goldseen;
X
X/* Definitions used by makerooms() and addrs() */
X#define    MAXRS    50    /* max lth of temp rectangle table - arbitrary */
Xstruct rectangle {
X    xchar rlx,rly,rhx,rhy;
X} rs[MAXRS+1];
Xint rscnt,rsmax;    /* 0..rscnt-1: currently under consideration */
X            /* rscnt..rsmax: discarded */
X
Xstatic void
Xaddrsx(lx,ly,hx,hy,discarded)
Xregister int lx,ly,hx,hy;
Xboolean discarded;        /* piece of a discarded area */
X{
X    register struct rectangle *rsp;
X
X    /* check inclusions */
X    for(rsp = rs; rsp < &rs[rsmax]; rsp++) {
X        if(lx >= rsp->rlx && hx <= rsp->rhx &&
X           ly >= rsp->rly && hy <= rsp->rhy)
X            return;
X    }
X
X    /* make a new entry */
X    if(rsmax >= MAXRS) {
X#ifdef WIZARD
X        if(wizard) pline("MAXRS may be too small.");
X#endif
X        return;
X    }
X    rsmax++;
X    if(!discarded) {
X        *rsp = rs[rscnt];
X        rsp = &rs[rscnt];
X        rscnt++;
X    }
X    rsp->rlx = lx;
X    rsp->rly = ly;
X    rsp->rhx = hx;
X    rsp->rhy = hy;
X}
X
Xstatic void
Xaddrs(lowx,lowy,hix,hiy)
Xregister int lowx,lowy,hix,hiy;
X{
X    register struct rectangle *rsp;
X    register int lx,ly,hx,hy,xlim,ylim;
X    boolean discarded;
X
X    xlim = XLIM + secret;
X    ylim = YLIM + secret;
X
X    /* walk down since rscnt and rsmax change */
X    for(rsp = &rs[rsmax-1]; rsp >= rs; rsp--) {
X
X        if((lx = rsp->rlx) > hix || (ly = rsp->rly) > hiy ||
X           (hx = rsp->rhx) < lowx || (hy = rsp->rhy) < lowy)
X            continue;
X        if((discarded = (rsp >= &rs[rscnt]))) {
X            *rsp = rs[--rsmax];
X        } else {
X            rsmax--;
X            rscnt--;
X            *rsp = rs[rscnt];
X            if(rscnt != rsmax)
X                rs[rscnt] = rs[rsmax];
X        }
X        if(lowy - ly > 2*ylim + 4)
X            addrsx(lx,ly,hx,lowy-2,discarded);
X        if(lowx - lx > 2*xlim + 4)
X            addrsx(lx,ly,lowx-2,hy,discarded);
X        if(hy - hiy > 2*ylim + 4)
X            addrsx(lx,hiy+2,hx,hy,discarded);
X        if(hx - hix > 2*xlim + 4)
X            addrsx(hix+2,ly,hx,hy,discarded);
X    }
X}
X
Xstatic int
Xcomp(x,y)
Xregister struct mkroom *x,*y;
X{
X    if(x->lx < y->lx) return(-1);
X    return(x->lx > y->lx);
X}
X
Xstatic void
Xfinddpos(cc, xl,yl,xh,yh)
Xcoord    *cc;
Xxchar    xl,yl,xh,yh;
X{
X    register xchar x, y;
X
X    x = (xl == xh) ? xl : (xl + rn2(xh-xl+1));
X    y = (yl == yh) ? yl : (yl + rn2(yh-yl+1));
X    if(okdoor(x, y))
X        goto gotit;
X
X    for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++)
X        if(okdoor(x, y))
X            goto gotit;
X
X    for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++)
X        if(IS_DOOR(levl[x][y].typ) || levl[x][y].typ == SDOOR)
X            goto gotit;
X    /* cannot find something reasonable -- strange */
X    x = xl;
X    y = yh;
Xgotit:
X    cc->x = x;
X    cc->y = y;
X    return;
X}
X
X/* Only called from makerooms() and makebigroom() */
Xstatic int
Xmaker(lowx,ddx,lowy,ddy,lit)
Xschar lowx,ddx,lowy,ddy;
Xboolean lit;
X{
X    register struct mkroom *croom;
X    register int x, y, hix = lowx+ddx, hiy = lowy+ddy;
X    register int xlim = XLIM + secret, ylim = YLIM + secret;
X
X    if(nroom >= MAXNROFROOMS) return(0);
X    if(lowx < XLIM) lowx = XLIM;
X    if(lowy < YLIM) lowy = YLIM;
X    if(hix > COLNO-XLIM-1) hix = COLNO-XLIM-1;
X    if(hiy > ROWNO-YLIM-1) hiy = ROWNO-YLIM-1;
Xchk:
X    if(hix <= lowx || hiy <= lowy) return(0);
X
X    /* check area around room (and make room smaller if necessary) */
X    for(x = lowx - xlim; x <= hix + xlim; x++) {
X        for(y = lowy - ylim; y <= hiy + ylim; y++) {
X            if(levl[x][y].typ) {
X#ifdef WIZARD
X                if(wizard && !secret)
X                pline("Strange area [%d,%d] in maker().",x,y);
X#endif
X                if(!rn2(3)) return(0);
X                if(x < lowx)
X                    lowx = x+xlim+1;
X                else
X                    hix = x-xlim-1;
X                if(y < lowy)
X                    lowy = y+ylim+1;
X                else
X                    hiy = y-ylim-1;
X                goto chk;
X            }
X        }
X    }
X
X    croom = &rooms[nroom];
X
X    /* on low levels the room is lit (usually) */
X    /* secret vaults are always lit */
X    /* some other rooms may require lighting */
X    if((rnd(dlevel) < 10 && rn2(77)) || secret || lit) {
X        for(x = lowx-1; x <= hix+1; x++)
X            for(y = lowy-1; y <= hiy+1; y++)
X                levl[x][y].lit = 1;
X        croom->rlit = 1;
X    } else
X        croom->rlit = 0;
X    croom->lx = lowx;
X    croom->hx = hix;
X    croom->ly = lowy;
X    croom->hy = hiy;
X    croom->rtype = OROOM;
X    croom->doorct = 0;
X    /* if we're not making a vault, doorindex will still be 0
X     * if we are, we'll have problems adding niches to the previous room
X     * unless fdoor is at least doorindex
X     */
X    croom->fdoor = doorindex;
X
X    for(x = lowx-1; x <= hix+1; x++)
X        for(y = lowy-1; y <= hiy+1; y += (hiy-lowy+2)) {
X        levl[x][y].typ = HWALL;
X        levl[x][y].scrsym = HWALL_SYM;
X        }
X    for(x = lowx-1; x <= hix+1; x += (hix-lowx+2))
X        for(y = lowy; y <= hiy; y++) {
X        levl[x][y].typ = VWALL;
X        levl[x][y].scrsym = VWALL_SYM;
X        }
X    for(x = lowx; x <= hix; x++)
X        for(y = lowy; y <= hiy; y++) {
X        levl[x][y].typ = ROOM;
X        levl[x][y].scrsym = ROOM_SYM;
X        }
X    levl[lowx-1][lowy-1].typ = TLCORNER;
X    levl[hix+1][lowy-1].typ = TRCORNER;
X    levl[lowx-1][hiy+1].typ = BLCORNER;
X    levl[hix+1][hiy+1].typ = BRCORNER;
X    levl[lowx-1][lowy-1].scrsym = TLCORN_SYM;
X    levl[hix+1][lowy-1].scrsym = TRCORN_SYM;
X    levl[lowx-1][hiy+1].scrsym = BLCORN_SYM;
X    levl[hix+1][hiy+1].scrsym = BRCORN_SYM;
X
X    smeq[nroom] = nroom;
X    croom++;
X    croom->hx = -1;
X    nroom++;
X    return(1);
X}
X
Xstatic int
Xmakerooms() {
Xregister struct rectangle *rsp;
Xregister int lx, ly, hx, hy, lowx, lowy, hix, hiy, dx, dy;
Xint tryct = 0, xlim, ylim;
X
X    /* init */
X    xlim = XLIM + secret;
X    ylim = YLIM + secret;
X    if(nroom == 0) {
X        rsp = rs;
X        rsp->rlx = rsp->rly = 0;
X        rsp->rhx = COLNO-1;
X        rsp->rhy = ROWNO-1;
X        rsmax = 1;
X    }
X    rscnt = rsmax;
X
X    /* make rooms until satisfied */
X    while(rscnt > 0 && nroom < MAXNROFROOMS-1) {
X        if(!secret && nroom > (MAXNROFROOMS/4) &&
X           !rn2((MAXNROFROOMS-nroom)*(MAXNROFROOMS-nroom)))
X            return 0;
X
X        /* pick a rectangle */
X        rsp = &rs[rn2(rscnt)];
X        hx = rsp->rhx;
X        hy = rsp->rhy;
X        lx = rsp->rlx;
X        ly = rsp->rly;
X
X        /* find size of room */
X        if(secret)
X            dx = dy = 1;
X        else {
X            dx = 2 + rn2((hx-lx-8 > 20) ? 12 : 8);
X            dy = 2 + rn2(4);
X            if(dx*dy > 50)
X                dy = 50/dx;
X        }
X
X        /* look whether our room will fit */
X        if(hx-lx < dx + (dx>>1) + 2*xlim ||
X           hy-ly < dy + dy/3 + 2*ylim) {
X                    /* no, too small */
X                    /* maybe we throw this area out */
X            if(secret || !rn2(MAXNROFROOMS+1-nroom-tryct)) {
X                rscnt--;
X                rs[rsmax] = *rsp;
X                *rsp = rs[rscnt];
X                rs[rscnt] = rs[rsmax];
X                tryct = 0;
X            } else
X                tryct++;
X            continue;
X        }
X
X        lowx = lx + xlim + rn2(hx - lx - dx - 2*xlim + 1);
X        lowy = ly + ylim + rn2(hy - ly - dy - 2*ylim + 1);
X        hix = lowx + dx;
X        hiy = lowy + dy;
X
X        if(maker(lowx, dx, lowy, dy, FALSE)) {
X            if(secret) return(1);
X            addrs(lowx-1, lowy-1, hix+1, hiy+1);
X            tryct = 0;
X        } else
X            if(tryct++ > 100)
X                break;
X    }
X    return(0);    /* failed to make vault - very strange */
X}
X
Xstatic void
Xjoin(a,b)
Xregister int a, b;
X{
X    coord cc,tt;
X    register int tx, ty, xx, yy;
X    register struct rm *crm;
X    register struct mkroom *croom, *troom;
X    register int dx, dy, dix, diy, cct;
X
X    croom = &rooms[a];
X    troom = &rooms[b];
X
X    /* find positions cc and tt for doors in croom and troom
X       and direction for a corridor between them */
X
X    if(troom->hx < 0 || croom->hx < 0 || doorindex >= DOORMAX) return;
X    if(troom->lx > croom->hx) {
X        dx = 1;
X        dy = 0;
X        xx = croom->hx+1;
X        tx = troom->lx-1;
X        finddpos(&cc, xx, croom->ly, xx, croom->hy);
X        finddpos(&tt, tx, troom->ly, tx, troom->hy);
X    } else if(troom->hy < croom->ly) {
X        dy = -1;
X        dx = 0;
X        yy = croom->ly-1;
X        finddpos(&cc, croom->lx, yy, croom->hx, yy);
X        ty = troom->hy+1;
X        finddpos(&tt, troom->lx, ty, troom->hx, ty);
X    } else if(troom->hx < croom->lx) {
X        dx = -1;
X        dy = 0;
X        xx = croom->lx-1;
X        tx = troom->hx+1;
X        finddpos(&cc, xx, croom->ly, xx, croom->hy);
X        finddpos(&tt, tx, troom->ly, tx, troom->hy);
X    } else {
X        dy = 1;
X        dx = 0;
X        yy = croom->hy+1;
X        ty = troom->ly-1;
X        finddpos(&cc, croom->lx, yy, croom->hx, yy);
X        finddpos(&tt, troom->lx, ty, troom->hx, ty);
X    }
X    xx = cc.x;
X    yy = cc.y;
X    tx = tt.x - dx;
X    ty = tt.y - dy;
X    if(nxcor && levl[xx+dx][yy+dy].typ)
X        return;
X    dodoor(xx,yy,croom);
X
X    cct = 0;
X    while(xx != tx || yy != ty) {
X        xx += dx;
X        yy += dy;
X
X        /* loop: dig corridor at [xx,yy] and find new [xx,yy] */
X        if(cct++ > 500 || (nxcor && !rn2(35)))
X        return;
X
X        if(xx == COLNO-1 || xx == 0 || yy == 0 || yy == ROWNO-1)
X        return;        /* impossible */
X
X        crm = &levl[xx][yy];
X        if(!(crm->typ)) {
X        if(rn2(100)) {
X            crm->typ = CORR;
X            crm->scrsym = CORR_SYM;
X            if(nxcor && !rn2(50))
X                (void) mksobj_at(BOULDER, xx, yy);
X        } else {
X            crm->typ = SCORR;
X            crm->scrsym = STONE_SYM;
X        }
X        } else
X        if(crm->typ != CORR && crm->typ != SCORR) {
X        /* strange ... */
X        return;
X        }
X
X        /* find next corridor position */
X        dix = abs(xx-tx);
X        diy = abs(yy-ty);
X
X        /* do we have to change direction ? */
X        if(dy && dix > diy) {
X        register int ddx = (xx > tx) ? -1 : 1;
X
X        crm = &levl[xx+ddx][yy];
X        if(!crm->typ || crm->typ == CORR || crm->typ == SCORR) {
X            dx = ddx;
X            dy = 0;
X            continue;
X        }
X        } else if(dx && diy > dix) {
X        register int ddy = (yy > ty) ? -1 : 1;
X
X        crm = &levl[xx][yy+ddy];
X        if(!crm->typ || crm->typ == CORR || crm->typ == SCORR) {
X            dy = ddy;
X            dx = 0;
X            continue;
X        }
X        }
X
X        /* continue straight on? */
X        crm = &levl[xx+dx][yy+dy];
X        if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
X        continue;
X
X        /* no, what must we do now?? */
X        if(dx) {
X        dx = 0;
X        dy = (ty < yy) ? -1 : 1;
X        crm = &levl[xx+dx][yy+dy];
X        if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
X            continue;
X        dy = -dy;
X        continue;
X        } else {
X        dy = 0;
X        dx = (tx < xx) ? -1 : 1;
X        crm = &levl[xx+dx][yy+dy];
X        if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
X            continue;
X        dx = -dx;
X        continue;
X        }
X    }
X
X    /* we succeeded in digging the corridor */
X    dodoor(tt.x, tt.y, troom);
X
X    if(smeq[a] < smeq[b])
X        smeq[b] = smeq[a];
X    else
X        smeq[a] = smeq[b];
X}
X
Xstatic void
Xmakecorridors() {
X    register int a, b;
X
X    nxcor = 0;
X    for(a = 0; a < nroom-1; a++)
X        join(a, a+1);
X    for(a = 0; a < nroom-2; a++)
X        if(smeq[a] != smeq[a+2])
X        join(a, a+2);
X    for(a = 0; a < nroom; a++)
X        for(b = 0; b < nroom; b++)
X        if(smeq[a] != smeq[b])
X            join(a, b);
X    if(nroom > 2)
X        for(nxcor = rn2(nroom) + 4; nxcor; nxcor--) {
X        a = rn2(nroom);
X        b = rn2(nroom-2);
X        if(b >= a) b += 2;
X        join(a, b);
X        }
X}
X
Xstatic void
Xdosdoor(x,y,aroom,type)
Xregister int x, y;
Xregister struct mkroom *aroom;
Xregister int type;
X{
X    register struct mkroom *broom;
X    register int tmp;
X    boolean shdoor = in_shop(x, y);
X
X    if(!IS_WALL(levl[x][y].typ)) /* avoid SDOORs with DOOR_SYM as scrsym */
X        type = DOOR;
X    levl[x][y].typ = type;
X    if(type == DOOR) {
X        levl[x][y].scrsym = DOOR_SYM;
X        if(!rn2(3)) {      /* is it a locked door, closed, or a doorway? */
X        if(!rn2(5))
X            levl[x][y].doormask = D_ISOPEN;
X        else if(!rn2(4))
X            levl[x][y].doormask = D_LOCKED;
X        else
X            levl[x][y].doormask = D_CLOSED;
X
X        if (levl[x][y].doormask != D_ISOPEN && !shdoor && !rn2(25))
X            levl[x][y].doormask |= D_TRAPPED;
X        } else {
X        if(shdoor)    levl[x][y].doormask = D_ISOPEN;
X        else        levl[x][y].doormask = D_NODOOR;
X        }
X    } else { /* SDOOR */
X        if(shdoor || !rn2(5))    levl[x][y].doormask = D_LOCKED;
X        else            levl[x][y].doormask = D_CLOSED;
X
X        if(!shdoor && !rn2(20)) levl[x][y].doormask |= D_TRAPPED;
X    }
X    aroom->doorct++;
X    broom = aroom+1;
X    if(broom->hx < 0) tmp = doorindex; else
X    for(tmp = doorindex; tmp > broom->fdoor; tmp--)
X        doors[tmp] = doors[tmp-1];
X    doorindex++;
X    doors[tmp].x = x;
X    doors[tmp].y = y;
X    for( ; broom->hx >= 0; broom++) broom->fdoor++;
X}
X
Xstatic boolean
Xplace_niche(aroom,dy,xx,yy)
Xregister struct mkroom *aroom;
Xint *dy, *xx, *yy;
X{
X    coord dd;
X
X    if(rn2(2)) {
X        *dy = 1;
X        finddpos(&dd, aroom->lx, aroom->hy+1, aroom->hx, aroom->hy+1);
X    } else {
X        *dy = -1;
X        finddpos(&dd, aroom->lx, aroom->ly-1, aroom->hx, aroom->ly-1);
X    }
X    *xx = dd.x;
X    *yy = dd.y;
X    return(levl[*xx][(*yy)+(*dy)].typ == STONE);
X}
X
X#ifdef ORACLE
Xboolean
Xplace_oracle(aroom,dy,xx,yy)
Xregister struct mkroom *aroom;
Xint *dy, *xx, *yy;
X{
X    if(!place_niche(aroom,dy,xx,yy)) return FALSE;
X
X    dosdoor(*xx,*yy,aroom,DOOR);
X    levl[*xx][*yy].doormask = D_NODOOR;
X    return TRUE;
X}
X#endif
X
X/* there should be one of these per trap */
Xconst char *engravings[] = {    "", "", "", "", "", "",
X                "?la? ?as ?er?", "ad ae?ar um",
X                "", "", "", "" ,""
X                , "", "ad ae?ar um"
X#ifdef SPELLS
X                ,""
X#endif
X                ,""
X#ifdef POLYSELF
X                ,""
X#endif
X                ,""
X                };
X
Xstatic void
Xmakeniche(trap_type)
Xint trap_type;
X{
X    register struct mkroom *aroom;
X    register struct rm *rm;
X    register int vct = 8;
X    int dy, xx, yy;
X    register struct trap *ttmp;
X
X    if(doorindex < DOORMAX)
X      while(vct--) {
X        aroom = &rooms[rn2(nroom)];
X        if(aroom->rtype != OROOM) continue;    /* not an ordinary room */
X        if(aroom->doorct == 1 && rn2(5)) continue;
X        if(!place_niche(aroom,&dy,&xx,&yy)) continue;
X
X        rm = &levl[xx][yy+dy];
X        if(trap_type || !rn2(4)) {
X
X        rm->typ = SCORR;
X        rm->scrsym = STONE_SYM;
X        if(trap_type) {
X            ttmp = maketrap(xx, yy+dy, trap_type);
X            ttmp->once = 1;
X            if (strlen(engravings[trap_type]) > 0)
X            make_engr_at(xx, yy-dy, engravings[trap_type]);
X        }
X        dosdoor(xx, yy, aroom, SDOOR);
X        } else {
X        rm->typ = CORR;
X        rm->scrsym = CORR_SYM;
X        if(rn2(7))
X            dosdoor(xx, yy, aroom, rn2(5) ? SDOOR : DOOR);
X        else {
X            (void) mksobj_at(SCR_TELEPORTATION, xx, yy+dy);
X            if(!rn2(3)) (void) mkobj_at(0, xx, yy+dy);
X        }
X        }
X        return;
X    }
X}
X
Xstatic void
Xmake_niches()
X{
X    register int ct = rnd((nroom>>1) + 1);
X    boolean    ltptr = TRUE,
X        vamp = TRUE;
X
X    while(ct--) {
X
X        if(dlevel > 15 && !rn2(6) && ltptr) {
X
X            ltptr = FALSE;
X            makeniche(LEVEL_TELEP);
X        } else if (dlevel > 5 && dlevel < 25
X               && !rn2(6) && vamp) {
X
X            vamp = FALSE;
X            makeniche(TRAPDOOR);
X        } else    makeniche(NO_TRAP);
X    }
X}
X
Xstatic void
Xmakebigroom()
X{
X    register int x,y,n;
X    register struct mkroom *croom;
X    register struct monst *tmonst;
X
X    /* make biggest possible room; make sure it's lit */
X    (void) maker(XLIM, COLNO - 2*XLIM - 1, YLIM, ROWNO - 2*YLIM - 1, TRUE);
X    croom = &rooms[0];
X
X    /* add extra monsters and goodies */
X    n = 10 + rn2(15);
X    while (n--) {
X        x = somex(croom);
X        y = somey(croom);
X        tmonst = makemon((struct permonst *) 0,x,y);
X        if (tmonst && tmonst->data==&mons[PM_GIANT_SPIDER])
X            (void) maketrap(x,y,WEB);
X        if (tmonst && rn2(2))
X            tmonst->msleep = 1;
X    }
X    n = 6 + rn2(10);
X    while (n--)
X        (void) mkobj_at(0,somex(croom),somey(croom));
X}
X
Xstatic void
Xmakevtele()
X{
X    makeniche(TELEP_TRAP);
X}
X
X#define rntwixt(L1,L2)    rn1((L2)-(L1),L1)
X
Xstatic void
Xinit_levels()
X{
X#if defined(STRONGHOLD) && defined(MUSIC)
X    register int x;
X#endif
X
X#ifdef LINT    /* handle constant in conditional context */
X    medusa_level = 0;
X#else
X    medusa_level = rn1(3, HELLLEVEL - 5);
X#endif /* LINT */
X#ifdef STRONGHOLD
X    stronghold_level = rn1(5, medusa_level)+1;
X# ifdef MUSIC
X    for (x=0; x<5; x++)
X        tune[x] = 'A' + rn2(7);
X    tune[5] = 0;
X# endif
X    /* The tower will be on 3 levels */
X    tower_level = rntwixt(stronghold_level, MAXLEVEL-2)+1;
X    /* We don't want the wizard in Vlad's tower */
X    do
X        wiz_level = rntwixt(stronghold_level, MAXLEVEL)+1;
X    while (wiz_level >= tower_level && wiz_level <= tower_level + 2);
X#else
X    wiz_level     = rntwixt(medusa_level, MAXLEVEL)+1;
X#endif /* STRONGHOLD /**/
X#ifdef WIZARD
X    if (!rn2(15) || wizard)
X#else
X    if (!rn2(15))
X#endif
X        /* between the middle of the dungeon and the medusa level */
X        bigroom_level = rntwixt(HELLLEVEL>>1, medusa_level);
X#ifdef REINCARNATION
X# ifdef WIZARD
X    if (!rn2(3) || wizard)
X# else
X    if (!rn2(3))
X# endif
X        rogue_level = rn1(5,10);
X#endif
X#ifdef ORACLE
X    oracle_level = rn1(4,5);
X#endif
X}
X
X#undef rntwixt
X
Xstatic void
Xmakelevel() {
X    register struct mkroom *croom, *troom;
X    register unsigned int tryct;
X    register int x,y;
X    struct monst *tmonst;    /* always put a web with a spider */
X
X    nroom = 0;
X    doorindex = 0;
X    rooms[0].hx = -1;    /* in case we are in a maze */
X
X    for(x=0; x<COLNO; x++) for(y=0; y<ROWNO; y++)
X        levl[x][y] = zerorm;
X
X    oinit();    /* assign level dependent obj probabilities */
X    fountsound = 0;
X    sinksound = 0;
X
X    if (wiz_level == 0)
X        init_levels();
X    if (
X#ifndef STRONGHOLD
X        Inhell
X#else
X        dlevel >= stronghold_level || dlevel < 0
X#endif
X        || (dlevel > medusa_level && rn2(5))
X       ) {
X        makemaz();
X        return;
X    }
X
X    /* construct the rooms */
X    nroom = 0;
X    secret = FALSE;
X
X#ifdef REINCARNATION
X    if (dlevel == rogue_level) {
X        makeroguerooms();
X        makerogueghost();
X    } else
X#endif
X    if (dlevel == bigroom_level)
X        makebigroom();
X    else
X        (void) makerooms();
X
X    /* construct stairs (up and down in different rooms if possible) */
X    croom = &rooms[rn2(nroom)];
X    xdnstair = somex(croom);
X    ydnstair = somey(croom);
X    levl[xdnstair][ydnstair].scrsym = DN_SYM;
X    levl[xdnstair][ydnstair].typ = STAIRS;
X#ifdef MEDUSA
X    if (dlevel == medusa_level) {
X        struct monst *mtmp;
X
X        if (mtmp = makemon(&mons[PM_MEDUSA], xdnstair, ydnstair))
X            mtmp->msleep = 1;
X        for (tryct = rn1(1,3); tryct; tryct--) {
X            x = somex(croom); y = somey(croom);
X            if (goodpos(x,y))
X                (void) mk_tt_statue(x, y);
X        }
X    }
X#endif
X    if(nroom > 1) {
X        troom = croom;
X        croom = &rooms[rn2(nroom-1)];
X        if(croom >= troom) croom++;
X    }
X    xupstair = somex(croom);    /* %% < and > might be in the same place */
X    yupstair = somey(croom);
X    levl[xupstair][yupstair].scrsym = UP_SYM;
X    levl[xupstair][yupstair].typ = STAIRS;
X#ifdef STRONGHOLD
X    xdnladder = ydnladder = xupladder = yupladder = 0;
X#endif
X    is_maze_lev = FALSE;
X
X#ifdef SYSV
X    qsort((genericptr_t) rooms, (unsigned)nroom, sizeof(struct mkroom), comp);
X#else
X    qsort((genericptr_t) rooms, nroom, sizeof(struct mkroom), comp);
X#endif
X#ifdef REINCARNATION
X    if (dlevel == rogue_level) {
X       You("feel as though you were here in a previous lifetime.");
X       return;
X    }
X#endif
X    makecorridors();
X    make_niches();
X
X    /* make a secret treasure vault, not connected to the rest */
X    if(nroom <= (MAXNROFROOMS/2)) if(rn2(3)) {
X
X        troom = &rooms[nroom];
X        secret = TRUE;
X        if(makerooms()) {
X            troom->rtype = VAULT;        /* treasure vault */
X            for(x = troom->lx; x <= troom->hx; x++)
X            for(y = troom->ly; y <= troom->hy; y++)
X                mkgold((long)(rnd(dlevel*100) + 50), x, y);
X            if(!rn2(3))
X                makevtele();
X        }
X    }
X
X#ifdef WIZARD
X    if(wizard && getenv("SHOPTYPE")) mkroom(SHOPBASE); else
X#endif
X#ifdef ORACLE
X    if(dlevel == oracle_level) mkroom(DELPHI);
X    /*  It is possible that we find no good place to set up Delphi.
X     *  It is also possible to get more than one Delphi using bones levels.
X     *  The first is not a problem; the second is a minor nuisance.
X     */
X    else
X#endif
X    if(dlevel > 1 && dlevel < medusa_level && rn2(dlevel) < 3) mkroom(SHOPBASE);
X    else
X#ifdef THRONES
X    if(dlevel > 4 && !rn2(6)) mkroom(COURT);
X    else
X#endif
X    if(dlevel > 6 && !rn2(7)) mkroom(ZOO);
X    else
X#ifdef ALTARS
X    if(dlevel > 8 && !rn2(5)) mkroom(TEMPLE);
X    else
X#endif
X    if(dlevel > 9 && !rn2(5) && !(mons[PM_KILLER_BEE].geno & G_GENOD))
X        mkroom(BEEHIVE);
X    else
X    if(dlevel > 11 && !rn2(6)) mkroom(MORGUE);
X    else
X#ifdef ARMY
X    if(dlevel > 14 && !rn2(4) && !(mons[PM_SOLDIER].geno & G_GENOD))
X        mkroom(BARRACKS);
X    else
X#endif
X    if(dlevel > 18 && !rn2(6)) mkroom(SWAMP);
X
X
X    /* for each room: put things inside */
X    for(croom = rooms; croom->hx > 0; croom++) {
X        register boolean boxinlev = FALSE;
X
X        if(croom->rtype != OROOM) continue;
X
X        /* put a sleeping monster inside */
X        /* Note: monster may be on the stairs. This cannot be
X           avoided: maybe the player fell through a trapdoor
X           while a monster was on the stairs. Conclusion:
X           we have to check for monsters on the stairs anyway. */
X
X        if(u.uhave_amulet || !rn2(3)) {
X            x = somex(croom); y = somey(croom);
X#ifdef REINCARNATION
X            if (dlevel == rogue_level)
X            tmonst = makemon(roguemon(), x, y);
X            else
X#endif
X            tmonst = makemon((struct permonst *) 0, x,y);
X            if (tmonst && tmonst->data == &mons[PM_GIANT_SPIDER])
X            (void) maketrap (x,y,WEB);
X        }
X        /* put traps and mimics inside */
X        goldseen = FALSE;
X        while(!rn2(8-(dlevel/6))) mktrap(0,0,croom);
X        if(!goldseen && !rn2(3)) mkgold(0L, somex(croom), somey(croom));
X#ifdef REINCARNATION
X        if (dlevel == rogue_level) goto skip_nonrogue;
X#endif
X#ifdef FOUNTAINS
X        if(!rn2(10)) mkfount(0,croom);
X#endif
X#ifdef SINKS
X        if(!rn2(60)) mksink(croom);
X#endif
X#ifdef ALTARS
X        if(!rn2(60)) mkaltar(croom);
X#endif
X        /* put statues inside */
X#ifdef MEDUSA
X        if(!rn2(dlevel == medusa_level ? 1 : 20)) {
X            if (!rn2(dlevel == medusa_level ? 2 : 50))
X                (void) mk_tt_statue(somex(croom), somey(croom));
X            else {
X                struct obj *otmp =
X                    mkstatue((struct permonst *)0,
X                        somex(croom), somey(croom));
X                if (dlevel == medusa_level && otmp)
X                    otmp->spe = 0;
X                /* Medusa statues don't contain books */
X            }
X        }
X#else
X        if(!rn2(20))
X                (void) mkstatue((struct permonst *)0,
X                        somex(croom), somey(croom));
X#endif
X
X        /* put box/chest inside */
X        if(!rn2(20) && !boxinlev) {
X
X            boxinlev = TRUE;
X            (void) mksobj_at((rn2(3)) ? LARGE_BOX : CHEST,
X                     somex(croom), somey(croom));
X        }
X
X#ifdef REINCARNATION
X    skip_nonrogue:
X#endif
X        if(!rn2(3)) {
X            (void) mkobj_at(0, somex(croom), somey(croom));
X            tryct = 0;
X            while(!rn2(5)) {
X                if(++tryct > 100){
X                    Printf("tryct overflow4\n");
X                    break;
X                }
X                (void) mkobj_at(0, somex(croom), somey(croom));
X            }
X        }
X    }
X}
X
Xvoid
Xmklev()
X{
X    if(getbones()) return;
X
X    in_mklev = TRUE;
X    makelevel();
X    bound_digging();
X    in_mklev = FALSE;
X}
X
Xstatic boolean
Xbydoor(x, y)
Xregister xchar x, y;
X{
X    register boolean tmp1, tmp2;
X
X    /* break up large expression to help some compilers */
X    tmp1 = (IS_DOOR(levl[x+1][y].typ) || levl[x+1][y].typ == SDOOR ||
X        IS_DOOR(levl[x-1][y].typ) || levl[x-1][y].typ == SDOOR);
X    tmp2 = (IS_DOOR(levl[x][y+1].typ) || levl[x][y+1].typ == SDOOR ||
X        IS_DOOR(levl[x][y-1].typ) || levl[x][y-1].typ == SDOOR);
X    return(tmp1 || tmp2);
X}
X
X/* see whether it is allowable to create a door at [x,y] */
Xint
Xokdoor(x,y)
Xregister xchar x, y;
X{
X    register boolean near_door = bydoor(x, y);
X
X    return((levl[x][y].typ == HWALL || levl[x][y].typ == VWALL) &&
X               doorindex < DOORMAX && !near_door);
X}
X
Xvoid
Xdodoor(x,y,aroom)
Xregister int x, y;
Xregister struct mkroom *aroom;
X{
X    if(doorindex >= DOORMAX) {
X        impossible("DOORMAX exceeded?");
X        return;
X    }
X    if(!okdoor(x,y) && nxcor)
X        return;
X    dosdoor(x,y,aroom,rn2(8) ? DOOR : SDOOR);
X}
X
Xstatic boolean
Xoccupied(x, y)
Xregister xchar x, y;
X{
X    return(t_at(x, y) || levl[x][y].typ == STAIRS
X#ifdef FOUNTAINS
X        || IS_FOUNTAIN(levl[x][y].typ)
X#endif
X#ifdef THRONES
X        || IS_THRONE(levl[x][y].typ)
X#endif
X#ifdef SINKS
X        || IS_SINK(levl[x][y].typ)
X#endif
X#ifdef ALTARS
X        || levl[x][y].typ == ALTAR
X#endif
X        );
X}
X
X/* make a trap somewhere (in croom if mazeflag = 0) */
Xvoid
Xmktrap(num, mazeflag, croom)
Xregister int num, mazeflag;
Xregister struct mkroom *croom;
X{
X    register struct trap *ttmp;
X    register int kind,nomonst,nomimic,nospider,
X#ifdef POLYSELF
X            nopoly,
X#endif
X            nospikes, nolevltp,
X            nolandmine,
X            tryct = 0;
X
X    xchar mx,my;
X
X    if(!num || num >= TRAPNUM) {
X        nomonst = (dlevel < 4) ? 1 : 0;
X        nolevltp = (dlevel < 5) ? 1 : 0;
X        nospikes = (dlevel < 6) ? 1 : 0;
X        nospider = (dlevel < 7) ? 1 : 0;
X#ifdef POLYSELF
X        nopoly = (dlevel < 6) ? 1 : 0;
X#endif
X        nolandmine = (dlevel < 5) ? 1 : 0;
X        nomimic = (dlevel < 9 || goldseen ) ? 1 : 0;
X        if((mons[PM_SMALL_MIMIC].geno & G_GENOD) &&
X           (mons[PM_LARGE_MIMIC].geno & G_GENOD) &&
X           (mons[PM_GIANT_MIMIC].geno & G_GENOD))
X            nomimic = 1;
X        if(mons[PM_GIANT_SPIDER].geno & G_GENOD)
X            nospider = 1;
X
X        do {
X#ifdef REINCARNATION
X            if (dlevel==rogue_level) {
X            switch(rn2(7)) {
X                 case 0: kind = BEAR_TRAP; break;
X                 case 1: kind = ARROW_TRAP; break;
X                 case 2: kind = DART_TRAP; break;
X                 case 3: kind = TRAPDOOR; break;
X                 case 4: kind = PIT; break;
X                 case 5: kind = SLP_GAS_TRAP; break;
X                 case 6: kind = RUST_TRAP; break;
X            }
X            } else
X#endif
X                kind = rnd(TRAPNUM-1);
X            if((kind == MONST_TRAP && (nomonst && nomimic))
X            || ((kind == WEB) && nospider)
X            || (kind == SPIKED_PIT && nospikes)
X            || (kind == LEVEL_TELEP && nolevltp)
X#ifdef POLYSELF
X            || (kind == POLY_TRAP && nopoly)
X#endif
X            || (kind == LANDMINE && nolandmine)
X            )  kind = NO_TRAP;
X        } while(kind == NO_TRAP);
X    } else kind = num;
X
X    if(kind == MONST_TRAP && !nomimic && !rn2(4) && !mazeflag) {
X        register struct monst *mtmp;
X
X        do {
X            if(++tryct > 200) return;
X            /* note: fakedoor maybe on actual door */
X            if(rn2(2)){
X                if(rn2(2))    mx = croom->hx+1;
X                else    mx = croom->lx-1;
X                my = somey(croom);
X            } else {
X                if(rn2(2))    my = croom->hy+1;
X                else    my = croom->ly-1;
X                mx = somex(croom);
X            }
X        } while(levl[mx][my].mmask);
X
X        if((mtmp = makemon(mkclass(S_MIMIC), mx, my))) {
X            mtmp->mimic = 1;
X            mtmp->mappearance = DOOR_SYM;
X        }
X        return;
X    }
X
X    do {
X        if(++tryct > 200)
X            return;
X        if(mazeflag){
X            coord mm;
X            mazexy(&mm);
X            mx = mm.x;
X            my = mm.y;
X        } else {
X            mx = somex(croom);
X            my = somey(croom);
X        }
X    } while(occupied(mx, my));
X
X    ttmp = maketrap(mx, my, kind);
X    if (kind == WEB) (void) makemon(&mons[PM_GIANT_SPIDER], mx, my);
X    if(mazeflag && !rn2(10) && ttmp->ttyp < MONST_TRAP)
X        ttmp->tseen = 1;
X}
X
X#ifdef FOUNTAINS
Xvoid
Xmkfount(mazeflag,croom)
Xregister struct mkroom *croom;
Xregister int mazeflag;
X{
X    register xchar mx,my;
X    register int tryct = 0;
X
X    do {
X        if(++tryct > 200) return;
X        if(mazeflag) {
X         coord mm;
X         mazexy(&mm);
X         mx = mm.x;
X         my = mm.y;
X        } else {
X         mx = somex(croom);
X         my = somey(croom);
X        }
X    } while(occupied(mx, my) || bydoor(mx, my));
X
X    /* Put a fountain at mx, my */
X    levl[mx][my].typ = FOUNTAIN;
X    levl[mx][my].scrsym = FOUNTAIN_SYM;
X
X    fountsound++;
X}
X#endif /* FOUNTAINS /**/
X
X#ifdef SINKS
Xstatic void
Xmksink(croom)
Xregister struct mkroom *croom;
X{
X    register xchar mx,my;
X    register int tryct = 0;
X
X    do {
X        if(++tryct > 200) return;
X        mx = somex(croom);
X        my = somey(croom);
X    } while(occupied(mx, my) || bydoor(mx, my));
X
X    /* Put a sink at mx, my */
X    levl[mx][my].typ = SINK;
X    levl[mx][my].scrsym = SINK_SYM;
X
X    sinksound++;
X}
X#endif /* SINKS /**/
X
X
X#ifdef ALTARS
Xstatic void
Xmkaltar(croom)
Xregister struct mkroom *croom;
X{
X    register xchar mx,my;
X    register int tryct = 0;
X
X    if(croom->rtype != OROOM) return;
X
X    do {
X        if(++tryct > 200) return;
X        mx = somex(croom);
X        my = somey(croom);
X    } while(occupied(mx, my) || bydoor(mx, my));
X
X    /* Put an altar at mx, my */
X    levl[mx][my].typ = ALTAR;
X    levl[mx][my].scrsym = ALTAR_SYM;
X    /* 0 - A_CHAOS, 1 - A_NEUTRAL, 2 - A_LAW */
X    levl[mx][my].altarmask = rn2((int)A_LAW+1);
X}
X#endif /* ALTARS /**/
END_OF_FILE
if test 27014 -ne `wc -c <'src/mklev.c'`; then
    echo shar: \"'src/mklev.c'\" unpacked with wrong size!
fi
# end of 'src/mklev.c'
fi
echo shar: End of archive 20 \(of 38\).
cp /dev/null ark20isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 38 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0