root/trunk/src/cave.c

/*
 * File: cave.c
 * Purpose: Lighting and update functions
 *
 * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
 *
 * This work is free software; you can redistribute it and/or modify it
 * under the terms of either:
 *
 * a) the GNU General Public License as published by the Free Software
 *    Foundation, version 2, or
 *
 * b) the "Angband licence":
 *    This software may be copied and distributed for educational, research,
 *    and not for profit purposes provided that this copyright and statement
 *    are included in all such copies.  Other copyrights may also apply.
 */
#include "angband.h"
#include "tvalsval.h"
#include "game-event.h"

/*
 * Support for Adam Bolt's tileset, lighting and transparency effects
 * by Robert Ruehlmann (rr9@thangorodrim.net)
 */

/*
 * Approximate distance between two points.
 *
 * When either the X or Y component dwarfs the other component,
 * this function is almost perfect, and otherwise, it tends to
 * over-estimate about one grid per fifteen grids of distance.
 *
 * Algorithm: hypot(dy,dx) = max(dy,dx) + min(dy,dx) / 2
 */
int distance(int y1, int x1, int y2, int x2)
{
        int ay, ax;

        /* Find the absolute y/x distance components */
        ay = (y1 > y2) ? (y1 - y2) : (y2 - y1);
        ax = (x1 > x2) ? (x1 - x2) : (x2 - x1);

        /* Hack -- approximate the distance */
        return ((ay > ax) ? (ay + (ax>>1)) : (ax + (ay>>1)));
}


/*
 * A simple, fast, integer-based line-of-sight algorithm.  By Joseph Hall,
 * 4116 Brewster Drive, Raleigh NC 27606.  Email to jnh@ecemwl.ncsu.edu.
 *
 * This function returns TRUE if a "line of sight" can be traced from the
 * center of the grid (x1,y1) to the center of the grid (x2,y2), with all
 * of the grids along this path (except for the endpoints) being non-wall
 * grids.  Actually, the "chess knight move" situation is handled by some
 * special case code which allows the grid diagonally next to the player
 * to be obstructed, because this yields better gameplay semantics.  This
 * algorithm is totally reflexive, except for "knight move" situations.
 *
 * Because this function uses (short) ints for all calculations, overflow
 * may occur if dx and dy exceed 90.
 *
 * Once all the degenerate cases are eliminated, we determine the "slope"
 * ("m"), and we use special "fixed point" mathematics in which we use a
 * special "fractional component" for one of the two location components
 * ("qy" or "qx"), which, along with the slope itself, are "scaled" by a
 * scale factor equal to "abs(dy*dx*2)" to keep the math simple.  Then we
 * simply travel from start to finish along the longer axis, starting at
 * the border between the first and second tiles (where the y offset is
 * thus half the slope), using slope and the fractional component to see
 * when motion along the shorter axis is necessary.  Since we assume that
 * vision is not blocked by "brushing" the corner of any grid, we must do
 * some special checks to avoid testing grids which are "brushed" but not
 * actually "entered".
 *
 * Angband three different "line of sight" type concepts, including this
 * function (which is used almost nowhere), the "project()" method (which
 * is used for determining the paths of projectables and spells and such),
 * and the "update_view()" concept (which is used to determine which grids
 * are "viewable" by the player, which is used for many things, such as
 * determining which grids are illuminated by the player's torch, and which
 * grids and monsters can be "seen" by the player, etc).
 */
bool los(int y1, int x1, int y2, int x2)
{
        /* Delta */
        int dx, dy;

        /* Absolute */
        int ax, ay;

        /* Signs */
        int sx, sy;

        /* Fractions */
        int qx, qy;

        /* Scanners */
        int tx, ty;

        /* Scale factors */
        int f1, f2;

        /* Slope, or 1/Slope, of LOS */
        int m;


        /* Extract the offset */
        dy = y2 - y1;
        dx = x2 - x1;

        /* Extract the absolute offset */
        ay = ABS(dy);
        ax = ABS(dx);


        /* Handle adjacent (or identical) grids */
        if ((ax < 2) && (ay < 2)) return (TRUE);


        /* Directly South/North */
        if (!dx)
        {
                /* South -- check for walls */
                if (dy > 0)
                {
                        for (ty = y1 + 1; ty < y2; ty++)
                        {
                                if (!cave_floor_bold(ty, x1)) return (FALSE);
                        }
                }

                /* North -- check for walls */
                else
                {
                        for (ty = y1 - 1; ty > y2; ty--)
                        {
                                if (!cave_floor_bold(ty, x1)) return (FALSE);
                        }
                }

                /* Assume los */
                return (TRUE);
        }

        /* Directly East/West */
        if (!dy)
        {
                /* East -- check for walls */
                if (dx > 0)
                {
                        for (tx = x1 + 1; tx < x2; tx++)
                        {
                                if (!cave_floor_bold(y1, tx)) return (FALSE);
                        }
                }

                /* West -- check for walls */
                else
                {
                        for (tx = x1 - 1; tx > x2; tx--)
                        {
                                if (!cave_floor_bold(y1, tx)) return (FALSE);
                        }
                }

                /* Assume los */
                return (TRUE);
        }


        /* Extract some signs */
        sx = (dx < 0) ? -1 : 1;
        sy = (dy < 0) ? -1 : 1;


        /* Vertical "knights" */
        if (ax == 1)
        {
                if (ay == 2)
                {
                        if (cave_floor_bold(y1 + sy, x1)) return (TRUE);
                }
        }

        /* Horizontal "knights" */
        else if (ay == 1)
        {
                if (ax == 2)
                {
                        if (cave_floor_bold(y1, x1 + sx)) return (TRUE);
                }
        }


        /* Calculate scale factor div 2 */
        f2 = (ax * ay);

        /* Calculate scale factor */
        f1 = f2 << 1;


        /* Travel horizontally */
        if (ax >= ay)
        {
                /* Let m = dy / dx * 2 * (dy * dx) = 2 * dy * dy */
                qy = ay * ay;
                m = qy << 1;

                tx = x1 + sx;

                /* Consider the special case where slope == 1. */
                if (qy == f2)
                {
                        ty = y1 + sy;
                        qy -= f1;
                }
                else
                {
                        ty = y1;
                }

                /* Note (below) the case (qy == f2), where */
                /* the LOS exactly meets the corner of a tile. */
                while (x2 - tx)
                {
                        if (!cave_floor_bold(ty, tx)) return (FALSE);

                        qy += m;

                        if (qy < f2)
                        {
                                tx += sx;
                        }
                        else if (qy > f2)
                        {
                                ty += sy;
                                if (!cave_floor_bold(ty, tx)) return (FALSE);
                                qy -= f1;
                                tx += sx;
                        }
                        else
                        {
                                ty += sy;
                                qy -= f1;
                                tx += sx;
                        }
                }
        }

        /* Travel vertically */
        else
        {
                /* Let m = dx / dy * 2 * (dx * dy) = 2 * dx * dx */
                qx = ax * ax;
                m = qx << 1;

                ty = y1 + sy;

                if (qx == f2)
                {
                        tx = x1 + sx;
                        qx -= f1;
                }
                else
                {
                        tx = x1;
                }

                /* Note (below) the case (qx == f2), where */
                /* the LOS exactly meets the corner of a tile. */
                while (y2 - ty)
                {
                        if (!cave_floor_bold(ty, tx)) return (FALSE);

                        qx += m;

                        if (qx < f2)
                        {
                                ty += sy;
                        }
                        else if (qx > f2)
                        {
                                tx += sx;
                                if (!cave_floor_bold(ty, tx)) return (FALSE);
                                qx -= f1;
                                ty += sy;
                        }
                        else
                        {
                                tx += sx;
                                qx -= f1;
                                ty += sy;
                        }
                }
        }

        /* Assume los */
        return (TRUE);
}




/*
 * Returns true if the player's grid is dark
 */
bool no_lite(void)
{
        return (!player_can_see_bold(p_ptr->py, p_ptr->px));
}




/*
 * Determine if a given location may be "destroyed"
 *
 * Used by destruction spells, and for placing stairs, etc.
 */
bool cave_valid_bold(int y, int x)
{
        object_type *o_ptr;

        /* Forbid perma-grids */
        if (cave_perma_bold(y, x)) return (FALSE);

        /* Check objects */
        for (o_ptr = get_first_object(y, x); o_ptr; o_ptr = get_next_object(o_ptr))
        {
                /* Forbid artifact grids */
                if (artifact_p(o_ptr)) return (FALSE);
        }

        /* Accept */
        return (TRUE);
}


/*
 * Hack -- Hallucinatory monster
 */
static u16b hallucinatory_monster(void)
{
        monster_race *r_ptr;
        
        byte a;
        char c;
        
        while (1)
        {
                /* Select a random monster */
                r_ptr = &r_info[randint0(z_info->r_max)];
                
                /* Skip non-entries */
                if (!r_ptr->name) continue;
                
                /* Retrieve attr/char */
                a = r_ptr->x_attr;
                c = r_ptr->x_char;
                
                /* Encode */
                return (PICT(a,c));
        }
}


/*
 * Hack -- Hallucinatory object
 */
static u16b hallucinatory_object(void)
{
        object_kind *k_ptr;
        
        byte a;
        char c;
        
        while (1)
        {
                /* Select a random object */
                k_ptr = &k_info[randint0(z_info->k_max - 1) + 1];
                
                /* Skip non-entries */
                if (!k_ptr->name) continue;
                
                /* Retrieve attr/char (HACK - without flavors) */
                a = k_ptr->x_attr;
                c = k_ptr->x_char;
                
                /* HACK - Skip empty entries */
                if ((a == 0) || (c == 0)) continue;
                
                /* Encode */
                return (PICT(a,c));
        }
}



/*
 * The 16x16 tile of the terrain supports lighting
 */
bool feat_supports_lighting(int feat)
{
        /* Pseudo graphics don't support lighting */
        if (use_graphics == GRAPHICS_PSEUDO) return FALSE;

        if ((use_graphics != GRAPHICS_DAVID_GERVAIS) &&
            (feat >= FEAT_TRAP_HEAD) && (feat <= FEAT_TRAP_TAIL))
        {
                return TRUE;
        }

        switch (feat)
        {
                case FEAT_FLOOR:
                case FEAT_INVIS:
                case FEAT_SECRET:
                case FEAT_MAGMA:
                case FEAT_QUARTZ:
                case FEAT_MAGMA_H:
                case FEAT_QUARTZ_H:
                case FEAT_WALL_EXTRA:
                case FEAT_WALL_INNER:
                case FEAT_WALL_OUTER:
                case FEAT_WALL_SOLID:
                case FEAT_PERM_EXTRA:
                case FEAT_PERM_INNER:
                case FEAT_PERM_OUTER:
                case FEAT_PERM_SOLID:
                        return TRUE;
                default:
                        return FALSE;
        }
}

/*
 * This function modifies the attr/char pair for an empty floor space
 * to reflect the various lighting options available.
 *
 * For text, this means changing the colouring for view_yellow_lite or
 * view_bright_lite, and for graphics it means modifying the char to
 * use a different tile in the tileset.  These modifications are different
 * for different sets, depending on the tiles available, and their position 
 * in the set.
 */
static void special_lighting_floor(byte *a, char *c, enum grid_light_level lighting, bool in_view)
{
        /* The floor starts off "lit" - i.e. rendered in white or the default 
         * tile. */

        if (lighting == LIGHT_TORCH && view_yellow_lite)
        {
                /* 
                 * view_yellow_lite distinguishes between torchlit and 
                 * permanently-lit areas 
                 */
                switch (use_graphics)
                {
                        case GRAPHICS_NONE:
                        case GRAPHICS_PSEUDO:
                                /* Use "yellow" */
                                if (*a == TERM_WHITE) *a = TERM_YELLOW;
                                break;
                        case GRAPHICS_ADAM_BOLT:
                                *c += 2;
                                break;
                        case GRAPHICS_DAVID_GERVAIS:
                                *c -= 1;
                                                break;
                }
        }
        else if (lighting == LIGHT_DARK)
        {
                /* Use a dark tile */
                switch (use_graphics)
                {
                        case GRAPHICS_NONE:
                        case GRAPHICS_PSEUDO:
                                /* Use "dark gray" */
                                if (*a == TERM_WHITE) *a = TERM_L_DARK;
                                break;
                        case GRAPHICS_ADAM_BOLT:
                        case GRAPHICS_DAVID_GERVAIS:
                                *c += 1;
                                break;
                }
        }
        else
        {
                /* 
                 * view_bright_lite makes tiles that aren't in the "eyeline" 
                 * of the player show up dimmer than those that are.
                 */
                if (view_bright_lite && !in_view)
                {
                        switch (use_graphics)
                        {
                                case GRAPHICS_NONE:
                                case GRAPHICS_PSEUDO:
                                        /* Use "gray" */
                                        if (*a == TERM_WHITE) *a = TERM_SLATE;
                                        else if (*a == TERM_L_GREEN) *a = TERM_GREEN;
                                        break;
                                case GRAPHICS_ADAM_BOLT:
                                case GRAPHICS_DAVID_GERVAIS:
                                        *c += 1;
                                        break;
                        }
                }
        }
}

/*
 * This function modifies the attr/char pair for a wall (or other "interesting"
 * grids to show them as more-or-less lit.  Note that how walls are drawn 
 * isn't directly related to how they are lit - walls are always "lit".
 * The lighting effects we use are as a visual cue to emphasise blindness 
 * and to show field-of-view (view_bright_lite).
 *
 * For text, we change the attr and for graphics we modify the char to
 * use a different tile in the tileset.  These modifications are different
 * for different sets, depending on the tiles available, and their position 
 * in the set.
 */
static void special_wall_display(byte *a, char *c, bool in_view, int feat)
{
        /* Grids currently in view are left alone, rendered as "white" */
        if (in_view) return;

        /* When blind, we make walls and other "white" things dark */
        if (p_ptr->timed[TMD_BLIND])
        {
                switch (use_graphics)
                {
                        case GRAPHICS_NONE:
                        case GRAPHICS_PSEUDO:
                                /* Use "dark gray" */
                                if (*a == TERM_WHITE) *a = TERM_L_DARK;
                                break;
                        case GRAPHICS_ADAM_BOLT:
                        case GRAPHICS_DAVID_GERVAIS:
                                if (feat_supports_lighting(feat)) *c += 1;
                                break;
                }
        }

        /* Handle "view_bright_lite" by dimming walls not "in view" */
        else if (view_bright_lite)
        {
                switch (use_graphics)
                {
                        case GRAPHICS_NONE:
                        case GRAPHICS_PSEUDO:
                                /* Use "gray" */
                                if (*a == TERM_WHITE) *a = TERM_SLATE;
                                break;
                        case GRAPHICS_ADAM_BOLT:
                        case GRAPHICS_DAVID_GERVAIS:
                                if (feat_supports_lighting(feat)) *c += 1;
                                break;
                }
        }
        else
        {
                /* Use a brightly lit tile */
                switch (use_graphics)
                {
                        case GRAPHICS_ADAM_BOLT:
                                if (feat_supports_lighting(feat)) *c += 2;
                                break;
                        case GRAPHICS_DAVID_GERVAIS:
                                if (feat_supports_lighting(feat)) *c -= 1;
                                break;
                }
        }
}


/* 
 * Checks if a square is at the (inner) edge of a trap detect area 
 */ 
bool dtrap_edge(int y, int x) 
{ 
        /* Check if the square is a dtrap in the first place */ 
        if (!cave_info2[y][x] & CAVE2_DTRAP) return FALSE; 

        /* Check for non-dtrap adjacent grids */ 
        if (in_bounds_fully(y + 1, x    ) && (!cave_info2[y + 1][x    ] & CAVE2_DTRAP)) return TRUE; 
        if (in_bounds_fully(y    , x + 1) && (!cave_info2[y    ][x + 1] & CAVE2_DTRAP)) return TRUE; 
        if (in_bounds_fully(y - 1, x    ) && (!cave_info2[y - 1][x    ] & CAVE2_DTRAP)) return TRUE; 
        if (in_bounds_fully(y    , x - 1) && (!cave_info2[y    ][x - 1] & CAVE2_DTRAP)) return TRUE; 

        return FALSE; 
} 


/*
 * This function takes a pointer to a grid info struct describing the 
 * contents of a grid location (as obtained through the function map_info)
 * and fills in the character and attr pairs for display.
 *
 * ap and cp are filled with the attr/char pair for the monster, object or 
 * floor tile that is at the "top" of the grid (monsters covering objects, 
 * which cover floor, assuming all are present).
 *
 * tap and tcp are filled with the attr/char pair for the floor, regardless
 * of what is on it.  This can be used by graphical displays with
 * transparency to place an object onto a floor tile, is desired.
 *
 * Any lighting effects are also applied to these pairs, clear monsters allow
 * the underlying colour or feature to show through (ATTR_CLEAR and
 * CHAR_CLEAR), multi-hued colour-changing (ATTR_MULTI) is applied, and so on.
 * Technically, the flag "CHAR_MULTI" is supposed to indicate that a monster 
 * looks strange when examined, but this flag is currently ignored.
 *
 * NOTES:
 * This is called pretty frequently, whenever a grid on the map display
 * needs updating, so don't overcomplicate it.
 *
 * The "zero" entry in the feature/object/monster arrays are
 * used to provide "special" attr/char codes, with "monster zero" being
 * used for the player attr/char, "object zero" being used for the "pile"
 * attr/char, and "feature zero" being used for the "darkness" attr/char.
 *
 * TODO:
 * The transformations for tile colors, or brightness for the 16x16
 * tiles should be handled differently.  One possibility would be to
 * extend feature_type with attr/char definitions for the different states.
 * This will probably be done outside of the current text->graphics mappings
 * though.
 */
void grid_data_as_text(grid_data *g, byte *ap, char *cp, byte *tap, char *tcp)
{
        byte a;
        char c;
        
        feature_type *f_ptr = &f_info[g->f_idx];

        /* Normal attr and char */
        a = f_ptr->x_attr;
        c = f_ptr->x_char;

        /* Check for trap detection boundaries */
        if (g->trapborder && g->f_idx == FEAT_FLOOR) a = TERM_L_GREEN;

        /* Special lighting effects */
        if (g->f_idx <= FEAT_INVIS && view_special_lite)
                special_lighting_floor(&a, &c, g->lighting, g->in_view);

        /* Special lighting effects (walls only) */
        if (g->f_idx > FEAT_INVIS && view_granite_lite) 
                special_wall_display(&a, &c, g->in_view, g->f_idx);
                
        /* Save the terrain info for the transparency effects */
        (*tap) = a;
        (*tcp) = c;


        /* If there's an object, deal with that. */
        if (g->first_k_idx)
        {
                if (g->hallucinate)
                {
                        /* Just pick a random object to display. */
                        int i = hallucinatory_object();
                        
                        a = PICT_A(i);
                        c = PICT_C(i);
                }
                else
                {
                        object_kind *k_ptr = &k_info[g->first_k_idx];
                        
                        /* Normal attr and char */
                        a = object_kind_attr(g->first_k_idx);
                        c = object_kind_char(g->first_k_idx);
                        
                        if (show_piles && g->multiple_objects)
                        {
                                /* Get the "pile" feature instead */
                                k_ptr = &k_info[0];
                                
                                a = k_ptr->x_attr;
                                c = k_ptr->x_char;
                        }
                }
        }

        /* If there's a monster */
        if (g->m_idx > 0)
        {
                if (g->hallucinate)
                {
                        /* Just pick a random monster to display. */
                        int i = hallucinatory_monster();
                        
                        a = PICT_A(i);
                        c = PICT_C(i);
                }
                else
                {
                        monster_type *m_ptr = &mon_list[g->m_idx];
                        monster_race *r_ptr = &r_info[m_ptr->r_idx];
                                
                        byte da;
                        char dc;
                        
                        /* Desired attr & char*/
                        da = r_ptr->x_attr;
                        dc = r_ptr->x_char;
                        
                        /* Special attr/char codes */
                        if ((da & 0x80) && (dc & 0x80))
                        {
                                /* Use attr */
                                a = da;
                                
                                /* Use char */
                                c = dc;
                        }
                        
                        /* Multi-hued monster */
                        else if (r_ptr->flags[0] & (RF0_ATTR_MULTI))
                        {
                                /* Multi-hued attr */
                                a = randint1(15);
                                
                                /* Normal char */
                                c = dc;
                        }
                        
                        /* Normal monster (not "clear" in any way) */
                        else if (!(r_ptr->flags[0] & (RF0_ATTR_CLEAR | RF0_CHAR_CLEAR)))
                        {
                                /* Use attr */
                                a = da;

                                /* Desired attr & char */
                                da = r_ptr->x_attr;
                                dc = r_ptr->x_char;
                                
                                /* Use char */
                                c = dc;
                        }
                        
                        /* Hack -- Bizarre grid under monster */
                        else if ((a & 0x80) || (c & 0x80))
                        {
                                /* Use attr */
                                a = da;
                                
                                /* Use char */
                                c = dc;
                        }
                        
                        /* Normal char, Clear attr, monster */
                        else if (!(r_ptr->flags[0] & (RF0_CHAR_CLEAR)))
                        {
                                /* Normal char */
                                c = dc;
                        }
                                
                        /* Normal attr, Clear char, monster */
                        else if (!(r_ptr->flags[0] & (RF0_ATTR_CLEAR)))
                        {
                                /* Normal attr */
                                        a = da;
                        }
                }
        }

        /* Handle "player" */
        else if (g->is_player)
        {
                monster_race *r_ptr = &r_info[0];

                /* Get the "player" attr */
                a = r_ptr->x_attr;
                if ((hp_changes_color) && (arg_graphics == GRAPHICS_NONE))
                {
                        switch(p_ptr->chp * 10 / p_ptr->mhp)
                        {
                                case 10:
                                case  9: 
                                {
                                        a = TERM_WHITE; 
                                        break;
                                }
                                case  8:
                                case  7:
                                {
                                        a = TERM_YELLOW;
                                        break;
                                }
                                case  6:
                                case  5:
                                {
                                        a = TERM_ORANGE;
                                        break;
                                }
                                case  4:
                                case  3:
                                {
                                        a = TERM_L_RED;
                                        break;
                                }
                                case  2:
                                case  1: