/* $NetBSD: create.c,v 1.12 2012/06/19 05:30:43 dholland Exp $   */

/* create.c             Larn is copyrighted 1986 by Noah Morgan. */

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: create.c,v 1.12 2012/06/19 05:30:43 dholland Exp $");
#endif                          /* not lint */

#include "header.h"
#include "extern.h"
#include <unistd.h>

static void makemaze(int);
static int cannedlevel(int);
static void treasureroom(int);
static void troom(int, int, int, int, int, int);
static void makeobject(int);
static void fillmroom(int, int, int);
static void froom(int, int, int);
static void fillroom(int, int);
static void sethp(int);
static void checkgen(void);

/*
        makeplayer()

        subroutine to create the player and the players attributes
        this is called at the beginning of a game and at no other time
 */
void
makeplayer(void)
{
        int i;
        scbr();
        clear();
        c[HPMAX] = c[HP] = 10;  /* start player off with 15 hit points   */
        c[LEVEL] = 1;           /* player starts at level one            */
        c[SPELLMAX] = c[SPELLS] = 1;    /* total # spells starts off as 3 */
        c[REGENCOUNTER] = 16;
        c[ECOUNTER] = 96;       /* start regeneration correctly */
        c[SHIELD] = c[WEAR] = c[WIELD] = -1;
        for (i = 0; i < 26; i++)
                iven[i] = 0;
        spelknow[0] = spelknow[1] = 1;  /* he knows protection, magic missile */
        if (c[HARDGAME] <= 0) {
                iven[0] = OLEATHER;
                iven[1] = ODAGGER;
                ivenarg[1] = ivenarg[0] = c[WEAR] = 0;
                c[WIELD] = 1;
        }
        playerx = rnd(MAXX - 2);
        playery = rnd(MAXY - 2);
        oldx = 0;
        oldy = 25;
        gltime = 0;             /* time clock starts at zero     */
        cbak[SPELLS] = -50;
        for (i = 0; i < 6; i++)
                c[i] = 12;      /* make the attributes, ie str, int, etc. */
        recalc();
}


/*
        newcavelevel(level)
        int level;

        function to enter a new level.  This routine must be called anytime the
        player changes levels.  If that level is unknown it will be created.
        A new set of monsters will be created for a new level, and existing
        levels will get a few more monsters.
        Note that it is here we remove genocided monsters from the present level.
 */
void
newcavelevel(int x)
{
        int             i, j;
        if (beenhere[level])
                savelevel();    /* put the level back into storage       */
        level = x;              /* get the new level and put in working
                                 * storage */
        if (beenhere[x]) {
                getlevel();
                sethp(0);
                checkgen();
                return;
        }

        /* fill in new level */
        for (i = 0; i < MAXY; i++)
                for (j = 0; j < MAXX; j++)
                        know[j][i] = mitem[j][i] = 0;
        makemaze(x);
        makeobject(x);
        beenhere[x] = 1;
        sethp(1);
        checkgen();             /* wipe out any genocided monsters */

#if WIZID
        if (wizard || x == 0)
#else
        if (x == 0)
#endif
                for (j = 0; j < MAXY; j++)
                        for (i = 0; i < MAXX; i++)
                                know[i][j] = 1;
}

/*
        makemaze(level)
        int level;

        subroutine to make the caverns for a given level.  only walls are made.
 */
static int      mx, mxl, mxh, my, myl, myh, tmp2;

static void
makemaze(int k)
{
        int             i, j, tmp;
        int             z;
        if (k > 1 && (rnd(17) <= 4 || k == MAXLEVEL - 1 || k == MAXLEVEL + MAXVLEVEL - 1)) {
                if (cannedlevel(k))
                        return;         /* read maze from data file */
        }
        if (k == 0)
                tmp = 0;
        else
                tmp = OWALL;
        for (i = 0; i < MAXY; i++)
                for (j = 0; j < MAXX; j++)
                        item[j][i] = tmp;
        if (k == 0)
                return;
        eat(1, 1);
        if (k == 1)
                item[33][MAXY - 1] = 0; /* exit from dungeon */

        /* now for open spaces -- not on level 10        */
        if (k != MAXLEVEL - 1) {
                tmp2 = rnd(3) + 3;
                for (tmp = 0; tmp < tmp2; tmp++) {
                        my = rnd(11) + 2;
                        myl = my - rnd(2);
                        myh = my + rnd(2);
                        if (k < MAXLEVEL) {
                                mx = rnd(44) + 5;
                                mxl = mx - rnd(4);
                                mxh = mx + rnd(12) + 3;
                                z = 0;
                        } else {
                                mx = rnd(60) + 3;
                                mxl = mx - rnd(2);
                                mxh = mx + rnd(2);
                                z = makemonst(k);
                        }
                        for (i = mxl; i < mxh; i++)
                                for (j = myl; j < myh; j++) {
                                        item[i][j] = 0;
                                        if ((mitem[i][j] = z))
                                                hitp[i][j] = monster[z].hitpoints;
                                }
                }
        }
        if (k != MAXLEVEL - 1) {
                my = rnd(MAXY - 2);
                for (i = 1; i < MAXX - 1; i++)
                        item[i][my] = 0;
        }
        if (k > 1)
                treasureroom(k);
}

/*
        function to eat away a filled in maze
 */
void
eat(int xx, int yy)
{
        int             dir, try;
        dir = rnd(4);
        try = 2;
        while (try) {
                switch (dir) {
                case 1:
                        if (xx <= 2)
                                break;  /* west  */
                        if ((item[xx - 1][yy] != OWALL) || (item[xx - 2][yy] != OWALL))
                                break;
                        item[xx - 1][yy] = item[xx - 2][yy] = 0;
                        eat(xx - 2, yy);
                        break;

                case 2:
                        if (xx >= MAXX - 3)
                                break;  /* east  */
                        if ((item[xx + 1][yy] != OWALL) || (item[xx + 2][yy] != OWALL))
                                break;
                        item[xx + 1][yy] = item[xx + 2][yy] = 0;
                        eat(xx + 2, yy);
                        break;

                case 3:
                        if (yy <= 2)
                                break;  /* south         */
                        if ((item[xx][yy - 1] != OWALL) || (item[xx][yy - 2] != OWALL))
                                break;
                        item[xx][yy - 1] = item[xx][yy - 2] = 0;
                        eat(xx, yy - 2);
                        break;

                case 4:
                        if (yy >= MAXY - 3)
                                break;  /* north         */
                        if ((item[xx][yy + 1] != OWALL) || (item[xx][yy + 2] != OWALL))
                                break;
                        item[xx][yy + 1] = item[xx][yy + 2] = 0;
                        eat(xx, yy + 2);
                        break;
                };
                if (++dir > 4) {
                        dir = 1;
                        --try;
                }
        }
}

/*
 *      function to read in a maze from a data file
 *
 *      Format of maze data file:  1st character = # of mazes in file (ascii digit)
 *                              For each maze: 18 lines (1st 17 used) 67 characters per line
 *
 *      Special characters in maze data file:
 *
 *              #       wall                    D       door                    .       random monster
 *              ~       eye of larn             !       cure dianthroritis
 *              -       random object
 */
static int
cannedlevel(int k)
{
        char           *row;
        int             i, j;
        int             it, arg, mit, marg;
        if (lopen(larnlevels) < 0) {
                write(1, "Can't open the maze data file\n", 30);
                died(-282);
                return (0);
        }
        i = lgetc();
        if (i <= '0') {
                died(-282);
                return (0);
        }
        for (i = 18 * rund(i - '0'); i > 0; i--)
                lgetl();        /* advance to desired maze */
        for (i = 0; i < MAXY; i++) {
                row = lgetl();
                for (j = 0; j < MAXX; j++) {
                        it = mit = arg = marg = 0;
                        switch (*row++) {
                        case '#':
                                it = OWALL;
                                break;
                        case 'D':
                                it = OCLOSEDDOOR;
                                arg = rnd(30);
                                break;
                        case '~':
                                if (k != MAXLEVEL - 1)
                                        break;
                                it = OLARNEYE;
                                mit = rund(8) + DEMONLORD;
                                marg = monster[mit].hitpoints;
                                break;
                        case '!':
                                if (k != MAXLEVEL + MAXVLEVEL - 1)
                                        break;
                                it = OPOTION;
                                arg = 21;
                                mit = DEMONLORD + 7;
                                marg = monster[mit].hitpoints;
                                break;
                        case '.':
                                if (k < MAXLEVEL)
                                        break;
                                mit = makemonst(k + 1);
                                marg = monster[mit].hitpoints;
                                break;
                        case '-':
                                it = newobject(k + 1, &arg);
                                break;
                        };
                        item[j][i] = it;
                        iarg[j][i] = arg;
                        mitem[j][i] = mit;
                        hitp[j][i] = marg;

#if WIZID
                        know[j][i] = (wizard) ? 1 : 0;
#else
                        know[j][i] = 0;
#endif
                }
        }
        lrclose();
        return (1);
}

/*
        function to make a treasure room on a level
        level 10's treasure room has the eye in it and demon lords
        level V3 has potion of cure dianthroritis and demon prince
 */
static void
treasureroom(int lv)
{
        int             tx, ty, xsize, ysize;

        for (tx = 1 + rnd(10); tx < MAXX - 10; tx += 10)
                if ((lv == MAXLEVEL - 1) || (lv == MAXLEVEL + MAXVLEVEL - 1) || rnd(13) == 2) {
                        xsize = rnd(6) + 3;
                        ysize = rnd(3) + 3;
                        ty = rnd(MAXY - 9) + 1; /* upper left corner of room */
                        if (lv == MAXLEVEL - 1 || lv == MAXLEVEL + MAXVLEVEL - 1)
                                troom(lv, xsize, ysize, tx = tx + rnd(MAXX - 24), ty, rnd(3) + 6);
                        else
                                troom(lv, xsize, ysize, tx, ty, rnd(9));
                }
}

/*
 *      subroutine to create a treasure room of any size at a given location
 *      room is filled with objects and monsters
 *      the coordinate given is that of the upper left corner of the room
 */
static void
troom(int lv, int xsize, int ysize, int tx, int ty, int glyph)
{
        int             i, j;
        int             tp1, tp2;
        for (j = ty - 1; j <= ty + ysize; j++)
                for (i = tx - 1; i <= tx + xsize; i++)  /* clear out space for
                                                         * room */
                        item[i][j] = 0;
        for (j = ty; j < ty + ysize; j++)
                for (i = tx; i < tx + xsize; i++) {     /* now put in the walls */
                        item[i][j] = OWALL;
                        mitem[i][j] = 0;
                }
        for (j = ty + 1; j < ty + ysize - 1; j++)
                for (i = tx + 1; i < tx + xsize - 1; i++)       /* now clear out
                                                                 * interior */
                        item[i][j] = 0;

        switch (rnd(2)) {       /* locate the door on the treasure room */
        case 1:
                item[i = tx + rund(xsize)][j = ty + (ysize - 1) * rund(2)] = OCLOSEDDOOR;
                iarg[i][j] = glyph;     /* on horizontal walls */
                break;
        case 2:
                item[i = tx + (xsize - 1) * rund(2)][j = ty + rund(ysize)] = OCLOSEDDOOR;
                iarg[i][j] = glyph;     /* on vertical walls */
                break;
        };

        tp1 = playerx;
        tp2 = playery;
        playery = ty + (ysize >> 1);
        if (c[HARDGAME] < 2)
                for (playerx = tx + 1; playerx <= tx + xsize - 2; playerx += 2)
                        for (i = 0, j = rnd(6); i <= j; i++) {
                                something(lv + 2);
                                createmonster(makemonst(lv + 1));
                        }
        else
                for (playerx = tx + 1; playerx <= tx + xsize - 2; playerx += 2)
                        for (i = 0, j = rnd(4); i <= j; i++) {
                                something(lv + 2);
                                createmonster(makemonst(lv + 3));
                        }

        playerx = tp1;
        playery = tp2;
}


/*
        ***********
        MAKE_OBJECT
        ***********
        subroutine to create the objects in the maze for the given level
 */
static void
makeobject(int j)
{
        int             i;
        if (j == 0) {
                fillroom(OENTRANCE, 0); /* entrance to dungeon                   */
                fillroom(ODNDSTORE, 0); /* the DND STORE                                 */
                fillroom(OSCHOOL, 0);   /* college of Larn                               */
                fillroom(OBANK, 0);     /* 1st national bank of larn     */
                fillroom(OVOLDOWN, 0);  /* volcano shaft to temple       */
                fillroom(OHOME, 0);     /* the players home & family     */
                fillroom(OTRADEPOST, 0);        /* the trading post                      */
                fillroom(OLRS, 0);      /* the larn revenue service      */
                return;
        }
        if (j == MAXLEVEL)
                fillroom(OVOLUP, 0);    /* volcano shaft up from the temple */

        /* make the fixed objects in the maze STAIRS     */
        if ((j > 0) && (j != MAXLEVEL - 1) && (j != MAXLEVEL + MAXVLEVEL - 1))
                fillroom(OSTAIRSDOWN, 0);
        if ((j > 1) && (j != MAXLEVEL))
                fillroom(OSTAIRSUP, 0);

        /* make the random objects in the maze           */

        fillmroom(rund(3), OBOOK, j);
        fillmroom(rund(3), OALTAR, 0);
        fillmroom(rund(3), OSTATUE, 0);
        fillmroom(rund(3), OPIT, 0);
        fillmroom(rund(3), OFOUNTAIN, 0);
        fillmroom(rnd(3) - 2, OIVTELETRAP, 0);
        fillmroom(rund(2), OTHRONE, 0);
        fillmroom(rund(2), OMIRROR, 0);
        fillmroom(rund(2), OTRAPARROWIV, 0);
        fillmroom(rnd(3) - 2, OIVDARTRAP, 0);
        fillmroom(rund(3), OCOOKIE, 0);
        if (j == 1)
                fillmroom(1, OCHEST, j);
        else
                fillmroom(rund(2), OCHEST, j);
        if ((j != MAXLEVEL - 1) && (j != MAXLEVEL + MAXVLEVEL - 1))
                fillmroom(rund(2), OIVTRAPDOOR, 0);
        if (j <= 10) {
                fillmroom((rund(2)), ODIAMOND, rnd(10 * j + 1) + 10);
                fillmroom(rund(2), ORUBY, rnd(6 * j + 1) + 6);
                fillmroom(rund(2), OEMERALD, rnd(4 * j + 1) + 4);
                fillmroom(rund(2), OSAPPHIRE, rnd(3 * j + 1) + 2);
        }
        for (i = 0; i < rnd(4) + 3; i++)
                fillroom(OPOTION, newpotion()); /* make a POTION         */
        for (i = 0; i < rnd(5) + 3; i++)
                fillroom(OSCROLL, newscroll()); /* make a SCROLL         */
        for (i = 0; i < rnd(12) + 11; i++)
                fillroom(OGOLDPILE, 12 * rnd(j + 1) + (j << 3) + 10);   /* make GOLD     */
        if (j == 5)
                fillroom(OBANK2, 0);    /* branch office of the bank */
        froom(2, ORING, 0);     /* a ring mail                   */
        froom(1, OSTUDLEATHER, 0);      /* a studded leather     */
        froom(3, OSPLINT, 0);   /* a splint mail                 */
        froom(5, OSHIELD, rund(3));     /* a shield                              */
        froom(2, OBATTLEAXE, rund(3));  /* a battle axe                  */
        froom(5, OLONGSWORD, rund(3));  /* a long sword                  */
        froom(5, OFLAIL, rund(3));      /* a flail                               */
        froom(4, OREGENRING, rund(3));  /* ring of regeneration */
        froom(1, OPROTRING, rund(3));   /* ring of protection    */
        froom(2, OSTRRING, 4);  /* ring of strength + 4 */
        froom(7, OSPEAR, rnd(5));       /* a spear                               */
        froom(3, OORBOFDRAGON, 0);      /* orb of dragon slaying */
        froom(4, OSPIRITSCARAB, 0);     /* scarab of negate spirit */
        froom(4, OCUBEofUNDEAD, 0);     /* cube of undead control        */
        froom(2, ORINGOFEXTRA, 0);      /* ring of extra regen           */
        froom(3, ONOTHEFT, 0);  /* device of antitheft           */
        froom(2, OSWORDofSLASHING, 0);  /* sword of slashing */
        if (c[BESSMANN] == 0) {
                froom(4, OHAMMER, 0);   /* Bessman's flailing hammer */
                c[BESSMANN] = 1;
        }
        if (c[HARDGAME] < 3 || (rnd(4) == 3)) {
                if (j > 3) {
                        froom(3, OSWORD, 3);    /* sunsword + 3                  */
                        froom(5, O2SWORD, rnd(4));      /* a two handed sword    */
                        froom(3, OBELT, 4);     /* belt of striking              */
                        froom(3, OENERGYRING, 3);       /* energy ring                   */
                        froom(4, OPLATE, 5);    /* platemail + 5                 */
                }
        }
}

/*
        subroutine to fill in a number of objects of the same kind
 */

static void
fillmroom(int n, int what_i, int arg)
{
        int             i;
        char            what;

        /* truncate to char width (just in case it matters) */
        what = (char)what_i;
        for (i = 0; i < n; i++)
                fillroom(what, arg);
}

static void
froom(int n, int theitem, int arg)
{
        if (rnd(151) < n)
                fillroom(theitem, arg);
}

/*
        subroutine to put an object into an empty room
 *      uses a random walk
 */
static void
fillroom(int what_i, int arg)
{
        int             x, y;
        char            what;

        /* truncate to char width (just in case it matters) */
        what = (char)what_i;

#ifdef EXTRA
        c[FILLROOM]++;
#endif

        x = rnd(MAXX - 2);
        y = rnd(MAXY - 2);
        while (item[x][y]) {

#ifdef EXTRA
                c[RANDOMWALK]++;/* count up these random walks */
#endif

                x += rnd(3) - 2;
                y += rnd(3) - 2;
                if (x > MAXX - 2)
                        x = 1;
                if (x < 1)
                        x = MAXX - 2;
                if (y > MAXY - 2)
                        y = 1;
                if (y < 1)
                        y = MAXY - 2;
        }
        item[x][y] = what;
        iarg[x][y] = arg;
}

/*
        subroutine to put monsters into an empty room without walls or other
        monsters
 */
int
fillmonst(int what)
{
        int             x, y, trys;
        for (trys = 5; trys > 0; --trys) {      /* max # of creation attempts */
                x = rnd(MAXX - 2);
                y = rnd(MAXY - 2);
                if ((item[x][y] == 0) && (mitem[x][y] == 0) && ((playerx != x) || (playery != y))) {
                        mitem[x][y] = what;
                        know[x][y] = 0;
                        hitp[x][y] = monster[what].hitpoints;
                        return (0);
                }
        }
        return (-1);            /* creation failure */
}

/*
        creates an entire set of monsters for a level
        must be done when entering a new level
        if sethp(1) then wipe out old monsters else leave them there
 */
static void
sethp(int flg)
{
        int             i, j;
        if (flg)
                for (i = 0; i < MAXY; i++)
                        for (j = 0; j < MAXX; j++)
                                stealth[j][i] = 0;
        if (level == 0) {
                c[TELEFLAG] = 0;
                return;
        }                       /* if teleported and found level 1 then know
                                 * level we are on */
        if (flg)
                j = rnd(12) + 2 + (level >> 1);
        else
                j = (level >> 1) + 1;
        for (i = 0; i < j; i++)
                fillmonst(makemonst(level));
        positionplayer();
}

/*
 *      Function to destroy all genocided monsters on the present level
 */
static void
checkgen(void)
{
        int             x, y;
        for (y = 0; y < MAXY; y++)
                for (x = 0; x < MAXX; x++)
                        if (monster[mitem[x][y]].genocided)
                                mitem[x][y] = 0;        /* no more monster */
}