/*
    outside.c  -  functions for dealing with the "outside" level

    XRogue: Expeditions into the Dungeons of Doom
    Copyright (C) 1991 Robert Pietkivitch
    All rights reserved.
    
    Based on "Advanced Rogue"
    Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
    All rights reserved.

    See the file LICENSE.TXT for full copyright and licensing information.
*/

#include <curses.h>
#include "rogue.h"

char rnd_terrain(void);
char get_terrain(char one, char two, char three, char four);

/*
 * init_terrain:
 *      Get the single "outside room" set up correctly
 */

void
init_terrain(void)
{
    register struct room *rp;

    for (rp = rooms; rp < &rooms[MAXROOMS]; rp++) {
            rp->r_flags = ISGONE;       /* kill all rooms */
            rp->r_fires = NULL;         /* no fires */
    }
    rp = &rooms[0];                     /* point to only room */
    rp->r_flags = ISDARK;               /* outside is always dark */
    rp->r_pos.x = 0;                    /* room fills whole screen */
    rp->r_pos.y = 1;
    rp->r_max.x = cols;
    rp->r_max.y = lines - 3;
}

void
do_terrain(int basey, int basex, int deltay, int deltax, bool fresh)
{
    register int cury, curx;        /* Current y and x positions */

    /* Lay out the boundary */
    for (cury=1; cury<lines-2; cury++) {        /* Vertical "walls" */
        mvaddch(cury, 0, VERTWALL);
        mvaddch(cury, cols-1, VERTWALL);
    }
    for (curx=0; curx<cols; curx++) {           /* Horizontal "walls" */
        mvaddch(1, curx, HORZWALL);
        mvaddch(lines-3, curx, HORZWALL);
    }

    /* If we are not continuing, let's start out with a line of terrain */
    if (fresh) {
        char ch;        /* Next char to add */

        /* Move to the starting point (should be (1, 0)) */
        move(basey, basex);
        curx = basex;

        /* Start with some random terrain */
        if (basex == 0) {
            ch = rnd_terrain();
            addch(ch);
        }
        else ch = mvinch(basey, basex);

        curx += deltax;

        /* Fill in the rest of the line */
        while (curx > 0 && curx < cols-1) {
            /* Put in the next piece */
            ch = get_terrain(ch, '\0', '\0', '\0');
            mvaddch(basey, curx, ch);
            curx += deltax;
        }

        basey++;        /* Advance to next line */
    }

    /* Fill in the rest of the lines */
    cury = basey;
    while (cury > 1 && cury < lines - 3) {
        curx = basex;
        while (curx > 0 && curx < cols-1) {
            register char left, top_left, top, top_right;
            register int left_pos, top_pos;

            /* Get the surrounding terrain */
            left_pos = curx - deltax;
            top_pos = cury - deltay;

            left = mvinch(cury, left_pos);
            top_left = mvinch(top_pos, left_pos);
            top = mvinch(top_pos, curx);
            top_right = mvinch(top_pos, curx + deltax);

            /* Put the piece of terrain on the map */
            mvaddch(cury, curx, get_terrain(left, top_left, top, top_right));

            /* Get the next x coordinate */
            curx += deltax;
        }

        /* Get the next y coordinate */
        cury += deltay;
    }
        /* The deeper we go.. */
        if (level > 40)         genmonsters(20, (bool) 0);
        else if (level > 10)    genmonsters(15, (bool) 0);
        else                    genmonsters(10, (bool) 0);

        /* sometimes they're real angry */
        if (rnd(100) < 65) {
            /* protect good guys */
            if (player.t_ctype == C_PALADIN ||
                player.t_ctype == C_RANGER  || player.t_ctype == C_MONK) {
                    aggravate(TRUE, FALSE);
            }
            else {
                aggravate(TRUE, TRUE);
            }
        }
}

/*
 * do_paths:
 *      draw at least a single path-way through the terrain
 */

/*
 * rnd_terrain:
 *      return a weighted, random type of outside terrain
 */

char
rnd_terrain(void)
{
    int chance = rnd(100);

    /* Meadow is most likely */
    if (chance < 40) return(FLOOR);

    /* Next comes forest */
    if (chance < 65) return(FOREST);

    /* Then comes lakes */
    if (chance < 85) return(POOL);

    /* Finally, mountains */
    return(WALL);
}


/*
 * get_terrain:
 *      return a terrain weighted by what is surrounding
 */

char
get_terrain(char one, char two, char three, char four)
{
    register int i;
    int forest = 0, mountain = 0, lake = 0, meadow = 0, total = 0;
    char surrounding[4];

    surrounding[0] = one;
    surrounding[1] = two;
    surrounding[2] = three;
    surrounding[3] = four;

    for (i=0; i<4; i++) 
        switch (surrounding[i]) {
            case FOREST:
                forest++;
                total++;
            
            when WALL:
                mountain++;
                total++;

            when POOL:
                lake++;
                total++;

            when FLOOR:
                meadow++;
                total++;
        }

    /* Should we continue mountain? */
    if (rnd(total+1) < mountain) return(WALL);

    /* Should we continue lakes? */
    if (rnd(total+1) < lake) return(POOL);

    /* Should we continue meadow? */
    if (rnd(total+1) < meadow) return(FLOOR);

    /* Should we continue forest? */
    if (rnd(total+2) < forest) return(FOREST);

    /* Return something random */
    return(rnd_terrain());
}

/*
 * lake_check:
 *      Determine if the player would drown
 */

/*UNUSED*/
/* void
 * lake_check(place)
 * register coord *place;
 * {
 * }
 */