treasure.cpp

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2013 Mark Wedel and the Crossfire Development Team
 * Copyright (c) 1992 Frank Tore Johansen
 *
 * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
 * welcome to redistribute it under certain conditions. For details, please
 * see COPYING and LICENSE.
 *
 * The authors can be reached via e-mail at <crossfire@metalforge.org>.
 */
 
/*  placing treasure in maps, where appropriate.  */
 
#include "global.h"
 
#include <stdlib.h>
#include <string.h>
 
#include "random_map.h"
#include "rproto.h"
 
#define CONCENTRATED 1 /* all the treasure is at the C's for onions. */
#define HIDDEN 2   /* doors to treasure are hidden. */
#define KEYREQUIRED 4 /* chest has a key, which is placed randomly in the map. */
#define DOORED 8   /* treasure has doors around it. */
#define TRAPPED 16 /* trap dropped in same location as chest. */
#define SPARSE 32  /* 1/2 as much treasure as default */
#define RICH 64   /* 2x as much treasure as default */
#define FILLED 128  /* Fill/tile the entire map with treasure */
#define LAST_OPTION 64  /* set this to the last real option, for random */
 
#define NO_PASS_DOORS 0
#define PASS_DOORS 1
 
static object **surround_by_doors(mapstruct *map, char **layout, int x, int y, int opts);
 
int wall_blocked(mapstruct *m, int x, int y)
{
    int r;
 
    if (OUT_OF_REAL_MAP(m, x, y)) {
        return 1;
    }
    r = GET_MAP_MOVE_BLOCK(m, x, y)&~MOVE_BLOCK_DEFAULT;
    return r;
}
 
void place_treasure(mapstruct *map, char **layout, char *treasure_style, int treasureoptions, RMParms *RP)
{
    int num_treasures;
 
    /* bail out if treasure isn't wanted. */
    if (treasure_style)
        if (!strcmp(treasure_style, "none")) {
            return;
        }
    if (treasureoptions <= 0) {
        treasureoptions = RANDOM()%(2*LAST_OPTION);
    }
 
    /* filter out the mutually exclusive options */
    if ((treasureoptions&RICH) && (treasureoptions&SPARSE)) {
        if (RANDOM()%2) {
            treasureoptions -= 1;
        } else {
            treasureoptions -= 2;
        }
    }
 
    /* pick the number of treasures */
    if (treasureoptions&SPARSE) {
        num_treasures = BC_RANDOM(RP->total_map_hp/600+RP->difficulty/2+1);
    } else if (treasureoptions&RICH) {
        num_treasures = BC_RANDOM(RP->total_map_hp/150+2*RP->difficulty+1);
    } else {
        num_treasures = BC_RANDOM(RP->total_map_hp/300+RP->difficulty+1);
    }
 
    if (num_treasures <= 0) {
        return;
    }
 
    /* all the treasure at one spot in the map. */
    if (treasureoptions&CONCENTRATED) {
        /* map_layout_style global, and is previously set */
        switch (RP->map_layout_style) {
        case ONION_LAYOUT:
        case SPIRAL_LAYOUT:
        case SQUARE_SPIRAL_LAYOUT: {
            int i, j;
 
            /* search the onion for C's or '>', and put treasure there. */
            for (i = 0; i < RP->Xsize; i++) {
                for (j = 0; j < RP->Ysize; j++) {
                    if (layout[i][j] == 'C' || layout[i][j] == '>') {
                        int tdiv = RP->symmetry_used;
                        object **doorlist;
                        object *chest;
 
                        if (tdiv == 3) {
                            tdiv = 2;    /* this symmetry uses a divisor of 2*/
                        }
                        /* don't put a chest on an exit. */
                        chest = place_chest(treasureoptions, i, j, map, num_treasures/tdiv, RP);
                        if (!chest) {
                            continue;    /* if no chest was placed NEXT */
                        }
                        if (treasureoptions&(DOORED|HIDDEN)) {
                            doorlist = find_doors_in_room(map, i, j, RP);
                            lock_and_hide_doors(doorlist, map, treasureoptions, RP);
                            free(doorlist);
                        }
                    }
                }
            }
            break;
        }
        default: {
            int i, j, tries;
            object *chest;
            object **doorlist;
 
            i = j = -1;
            tries = 0;
            while (i == -1 && tries < 100) {
                i = RANDOM()%(RP->Xsize-2)+1;
                j = RANDOM()%(RP->Ysize-2)+1;
                find_enclosed_spot(map, &i, &j, RP);
                if (wall_blocked(map, i, j)) {
                    i = -1;
                }
                tries++;
            }
            chest = place_chest(treasureoptions, i, j, map, num_treasures, RP);
            if (!chest) {
                return;
            }
            i = chest->x;
            j = chest->y;
            if (treasureoptions&(DOORED|HIDDEN)) {
                doorlist = surround_by_doors(map, layout, i, j, treasureoptions);
                lock_and_hide_doors(doorlist, map, treasureoptions, RP);
                free(doorlist);
            }
        }
        }
    } else { /* DIFFUSE treasure layout */
        int ti, i, j;
 
        for (ti = 0; ti < num_treasures; ti++) {
            i = RANDOM()%(RP->Xsize-2)+1;
            j = RANDOM()%(RP->Ysize-2)+1;
            place_chest(treasureoptions, i, j, map, 1, RP);
        }
    }
}
 
object *place_chest(int treasureoptions, int x, int y, mapstruct *map, int n_treasures, RMParms *RP)
{
    object *the_chest = NULL;
    int i, xl, yl;
    treasurelist *tlist;
 
    // Since we scale the stats of the mimic based on the level of the dungeon,
    // we can have no floor to generation difficulty.
    // It is a slim chance at any rate, so it shouldn't be a problem in any case.
    if ((uint32_t)(RANDOM() % 1000000) < (uint32_t)(map->difficulty*map->difficulty*map->difficulty))
    {
        the_chest = create_archetype("mimic");
        // Set the level for the mimic so that it can be given apporpriate stats.
        if (the_chest)
            the_chest->level = map->difficulty;
    }
    else
    {
        mapstruct *chests_map = find_style("/styles/cheststyles", RP->cheststyle, map->difficulty);
        if (chests_map) {
            object *item = pick_random_object(chests_map);
            if (item) {
                the_chest = object_new();
                object_copy_with_inv(item, the_chest, true);
            }
        }
    }
    if (the_chest == NULL) {
        return NULL;
    }
 
    /* first, find a place to put the chest. */
    i = object_find_first_free_spot(the_chest, map, x, y);
    if (i == -1) {
        object_free_drop_inventory(the_chest);
        return NULL;
    }
    xl = x+freearr_x[i];
    yl = y+freearr_y[i];
 
    /* if the placement is blocked, return a fail. */
    if (wall_blocked(map, xl, yl)) {
        object_free_drop_inventory(the_chest);
        return NULL;
    }
 
    // If normal, then do the old behavior.
    if (the_chest->type == TREASURE)
    {
        tlist = find_treasurelist("chest");
        the_chest->randomitems = tlist;
        the_chest->stats.hp = n_treasures;
    }
    // Otherwise, do the mimic treasurelist and don't change hp
    else if (the_chest->type == MIMIC)
    {
        tlist = find_treasurelist("mimic");
        the_chest->randomitems = tlist;
        // TODO: Make mimics on higher levels have more treasure
    }
    /* stick a trap in the chest if required  */
    if (treasureoptions&TRAPPED) {
        mapstruct *trap_map = find_style("/styles/trapstyles", "traps", -1);
        object *the_trap;
 
        if (trap_map) {
            the_trap = pick_random_object(trap_map);
            if (the_trap) {
                object *new_trap;
 
                new_trap = object_new();
                object_copy_with_inv(the_trap, new_trap, true);
                new_trap->stats.Cha = 10+RP->difficulty;
                new_trap->level = BC_RANDOM((3*RP->difficulty)/2);
                if (new_trap->level == 0) {
                    new_trap->level = 1;
                }
                new_trap->x = x;
                new_trap->y = y;
                object_insert_in_ob(new_trap, the_chest);
            }
        }
    }
 
    /* set the chest lock code, and call the keyplacer routine with
     the lockcode.  It's not worth bothering to lock the chest if
     there's only 1 treasure....*/
    if ((treasureoptions&KEYREQUIRED) && n_treasures > 1) {
        char keybuf[256];
 
        snprintf(keybuf, sizeof(keybuf), "%d", (int)RANDOM());
        if (keyplace(map, x, y, keybuf, PASS_DOORS, 1, RP)) {
            the_chest->slaying = add_string(keybuf);
        }
    }
 
    /* actually place the chest. */
    object_insert_in_map_at(the_chest, map, NULL, 0, xl, yl);
    return the_chest;
}
 
object *find_closest_monster(mapstruct *map, int x, int y, RMParms *RP)
{
    int i;
 
    for (i = 0; i < SIZEOFFREE; i++) {
        int lx, ly;
 
        lx = x+freearr_x[i];
        ly = y+freearr_y[i];
        /* boundscheck */
        if (lx >= 0 && ly >= 0 && lx < RP->Xsize && ly < RP->Ysize)
            /* don't bother searching this square unless the map says life exists.*/
            if (GET_MAP_FLAGS(map, lx, ly)&P_IS_ALIVE) {
                FOR_MAP_PREPARE(map, lx, ly, the_monster)
                if (QUERY_FLAG(the_monster, FLAG_MONSTER)) {
                    return the_monster;
                }
                FOR_MAP_FINISH();
            }
    }
    return NULL;
}
 
int keyplace(mapstruct *map, int x, int y, char *keycode, int door_flag, int n_keys, RMParms *RP)
{
    int i, j;
    int kx, ky;
    object *the_keymaster; /* the monster that gets the key. */
    object *the_key;
    char keybuf[256];
    const char *keys[] = { "key2", "blue_key", "brown_key", "darkgray_key", "darkgreen_key", "gray_key", "green_key", "magenta_key", "red_key", "white_key" };
 
    /* get a key and set its keycode */
    the_key = create_archetype(keys[RANDOM() % (sizeof(keys)/sizeof(*keys))]);
    the_key->slaying = add_string(keycode);
    free_string(the_key->name);
    snprintf(keybuf, 256, "key from level %d of %s", RP->dungeon_level-1, RP->dungeon_name[0] != '\0' ? RP->dungeon_name : "a random map");
    the_key->name = add_string(keybuf);
 
    if (door_flag == PASS_DOORS) {
        int tries = 0;
 
        the_keymaster = NULL;
        while (tries < 15 && the_keymaster == NULL) {
            i = (RANDOM()%(RP->Xsize-2))+1;
            j = (RANDOM()%(RP->Ysize-2))+1;
            tries++;
            the_keymaster = find_closest_monster(map, i, j, RP);
        }
        /* if we don't find a good keymaster, drop the key on the ground. */
        if (the_keymaster == NULL) {
            int freeindex;
 
            freeindex = -1;
            for (tries = 0; tries < 15 && freeindex == -1; tries++) {
                kx = (RANDOM()%(RP->Xsize-2))+1;
                ky = (RANDOM()%(RP->Ysize-2))+1;
                freeindex = object_find_first_free_spot(the_key, map, kx, ky);
            }
            if (freeindex != -1) {
                kx += freearr_x[freeindex];
                ky += freearr_y[freeindex];
            }
        }
    } else { /* NO_PASS_DOORS --we have to work harder.*/
        /* don't try to keyplace if we're sitting on a blocked square and
         * NO_PASS_DOORS is set.
        */
        if (n_keys == 1) {
            if (wall_blocked(map, x, y)) {
                return 0;
            }
            the_keymaster = find_monster_in_room(map, x, y, RP);
            if (the_keymaster == NULL) /* if fail, find a spot to drop the key. */
                if (!find_spot_in_room(map, x, y, &kx, &ky, RP)) {
                    return 0;
                }
        } else {
            /* It can happen that spots around that point are all blocked, so
            * try to look farther away if needed
            */
            int sum = 0; /* count how many keys we actually place */
            int distance = 1;
 
            while (distance < 5) {
                /* I'm lazy, so just try to place in all 4 directions. */
                sum += keyplace(map, x+distance, y, keycode, NO_PASS_DOORS, 1, RP);
                sum += keyplace(map, x, y+distance, keycode, NO_PASS_DOORS, 1, RP);
                sum += keyplace(map, x-distance, y, keycode, NO_PASS_DOORS, 1, RP);
                sum += keyplace(map, x, y-distance, keycode, NO_PASS_DOORS, 1, RP);
                if (sum < 2) {  /* we might have made a disconnected map-place more keys. */
                    /* diagonally this time. */
                    keyplace(map, x+distance, y+distance, keycode, NO_PASS_DOORS, 1, RP);
                    keyplace(map, x+distance, y-distance, keycode, NO_PASS_DOORS, 1, RP);
                    keyplace(map, x-distance, y+distance, keycode, NO_PASS_DOORS, 1, RP);
                    keyplace(map, x-distance, y-distance, keycode, NO_PASS_DOORS, 1, RP);
                }
                if (sum > 0) {
                    return 1;
                }
                distance++;
            }
            return 0;
        }
    }
 
    if (the_keymaster == NULL) {
        object_insert_in_map_at(the_key, map, NULL, 0, kx, ky);
        return 1;
    }
 
    object_insert_in_ob(the_key, the_keymaster);
    return 1;
}
 
object *find_monster_in_room_recursive(char **layout, mapstruct *map, int x, int y, RMParms *RP)
{
    int i, j;
 
    /* bounds check x and y */
    if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) {
        return NULL;
    }
 
    /* if the square is blocked or searched already, leave */
    if (layout[x][y] != 0) {
        return NULL;
    }
 
    /* check the current square for a monster.  If there is one,
       set theMonsterToFind and return it. */
    layout[x][y] = 1;
    if (GET_MAP_FLAGS(map, x, y)&P_IS_ALIVE) {
        FOR_MAP_PREPARE(map, x, y, the_monster)
        if (QUERY_FLAG(the_monster, FLAG_ALIVE)) {
            return HEAD(the_monster);
        }
        FOR_MAP_FINISH();
    }
 
    /* now search all the 8 squares around recursively for a monster, in random order */
    for (i = RANDOM()%8, j = 0; j < 8; i++, j++) {
        object *the_monster;
 
        the_monster = find_monster_in_room_recursive(layout, map, x+freearr_x[i%8+1], y+freearr_y[i%8+1], RP);
        if (the_monster != NULL) {
            return the_monster;
        }
    }
    return NULL;
}
 
object *find_monster_in_room(mapstruct *map, int x, int y, RMParms *RP)
{
    char **layout2;
    int i, j;
    object *theMonsterToFind;
 
    layout2 = (char **)calloc(sizeof(char *), RP->Xsize);
    /* allocate and copy the layout, converting C to 0. */
    for (i = 0; i < RP->Xsize; i++) {
        layout2[i] = (char *)calloc(sizeof(char), RP->Ysize);
        for (j = 0; j < RP->Ysize; j++) {
            if (wall_blocked(map, i, j)) {
                layout2[i][j] = '#';
            }
        }
    }
    theMonsterToFind = find_monster_in_room_recursive(layout2, map, x, y, RP);
 
    /* deallocate the temp. layout */
    for (i = 0; i < RP->Xsize; i++) {
        free(layout2[i]);
    }
    free(layout2);
 
    return theMonsterToFind;
}
 
struct free_spots_struct {
    int *room_free_spots_x;             
    int *room_free_spots_y;             
    int number_of_free_spots_in_room;   
};
 
static void find_spot_in_room_recursive(char **layout, int x, int y, RMParms *RP, free_spots_struct *spots)
{
    int i, j;
 
    /* bounds check x and y */
    if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) {
        return;
    }
 
    /* if the square is blocked or searched already, leave */
    if (layout[x][y] != 0) {
        return;
    }
 
    /* set the current square as checked, and add it to the list.
      check off this point */
    layout[x][y] = 1;
    spots->room_free_spots_x[spots->number_of_free_spots_in_room] = x;
    spots->room_free_spots_y[spots->number_of_free_spots_in_room] = y;
    spots->number_of_free_spots_in_room++;
    /* now search all the 8 squares around recursively for free spots, in random order */
    for (i = RANDOM()%8, j = 0; j < 8; i++, j++) {
        find_spot_in_room_recursive(layout, x+freearr_x[i%8+1], y+freearr_y[i%8+1], RP, spots);
    }
}
 
int find_spot_in_room(mapstruct *map, int x, int y, int *kx, int *ky, RMParms *RP)
{
    char **layout2;
    int i, j;
    free_spots_struct spots;
 
    spots.number_of_free_spots_in_room = 0;
    spots.room_free_spots_x = (int *)calloc(sizeof(int), RP->Xsize*RP->Ysize);
    spots.room_free_spots_y = (int *)calloc(sizeof(int), RP->Xsize*RP->Ysize);
 
    layout2 = (char **)calloc(sizeof(char *), RP->Xsize);
    /* allocate and copy the layout, converting C to 0. */
    for (i = 0; i < RP->Xsize; i++) {
        layout2[i] = (char *)calloc(sizeof(char), RP->Ysize);
        for (j = 0; j < RP->Ysize; j++) {
            if (wall_blocked(map, i, j)) {
                layout2[i][j] = '#';
            }
        }
    }
 
    /* setup num_free_spots and room_free_spots */
    find_spot_in_room_recursive(layout2, x, y, RP, &spots);
 
    if (spots.number_of_free_spots_in_room > 0) {
        i = RANDOM()%spots.number_of_free_spots_in_room;
        *kx = spots.room_free_spots_x[i];
        *ky = spots.room_free_spots_y[i];
    }
 
    /* deallocate the temp. layout */
    for (i = 0; i < RP->Xsize; i++) {
        free(layout2[i]);
    }
    free(layout2);
    free(spots.room_free_spots_x);
    free(spots.room_free_spots_y);
 
    if (spots.number_of_free_spots_in_room > 0) {
        return 1;
    }
    return 0;
}
 
void find_enclosed_spot(mapstruct *map, int *cx, int *cy, RMParms *RP)
{
    int x, y;
    int i;
 
    x = *cx;
    y = *cy;
 
    for (i = 0; i <= SIZEOFFREE1; i++) {
        int lx, ly, sindex;
        lx = x+freearr_x[i];
        ly = y+freearr_y[i];
        sindex = surround_flag3(map, lx, ly, RP);
        /* if it's blocked on 3 sides, it's enclosed */
        if (sindex == 7 || sindex == 11 || sindex == 13 || sindex == 14) {
            *cx = lx;
            *cy = ly;
            return;
        }
    }
 
    /* OK, if we got here, we're obviously someplace where there's no enclosed
       spots--try to find someplace which is 2x enclosed.  */
    for (i = 0; i <= SIZEOFFREE1; i++) {
        int lx, ly, sindex;
 
        lx = x+freearr_x[i];
        ly = y+freearr_y[i];
        sindex = surround_flag3(map, lx, ly, RP);
        /* if it's blocked on 3 sides, it's enclosed */
        if (sindex == 3 || sindex == 5 || sindex == 9 || sindex == 6 || sindex == 10 || sindex == 12) {
            *cx = lx;
            *cy = ly;
            return;
        }
    }
 
    /* settle for one surround point */
    for (i = 0; i <= SIZEOFFREE1; i++) {
        int lx, ly, sindex;
 
        lx = x+freearr_x[i];
        ly = y+freearr_y[i];
        sindex = surround_flag3(map, lx, ly, RP);
        /* if it's blocked on 3 sides, it's enclosed */
        if (sindex) {
            *cx = lx;
            *cy = ly;
            return;
        }
    }
 
    /* give up and return the closest free spot. */
    archetype *arch = find_archetype("chest");
    if (arch != NULL) {
        i = object_find_first_free_spot(&arch->clone, map, x, y);
        if (i != -1 && i <= SIZEOFFREE1) {
            *cx = x+freearr_x[i];
            *cy = y+freearr_y[i];
            return;
        }
    }
    /* indicate failure */
    *cx = *cy = -1;
}
 
void remove_monsters(int x, int y, mapstruct *map)
{
    FOR_MAP_PREPARE(map, x, y, tmp) {
        if (QUERY_FLAG(tmp, FLAG_ALIVE)) {
            tmp = HEAD(tmp);
            object_remove(tmp);
            object_free_drop_inventory(tmp);
            tmp = GET_MAP_OB(map, x, y);
            if (tmp == NULL) {
                break;
            }
        }
    }
    FOR_MAP_FINISH();
}
 
static object **surround_by_doors(mapstruct *map, char **layout, int x, int y, int opts)
{
    int i;
    const char *doors[2];
    object **doorlist;
    int ndoors_made = 0;
    doorlist = (object **)calloc(9, sizeof(object *)); /* 9 doors so we can hold termination null */
 
    /* this is a list we pick from, for horizontal and vertical doors */
    if (opts&DOORED) {
        doors[0] = "locked_door2";
        doors[1] = "locked_door1";
    } else {
        doors[0] = "door_1";
        doors[1] = "door_2";
    }
 
    /* place doors in all the 8 adjacent unblocked squares. */
    for (i = 1; i < 9; i++) {
        int x1 = x+freearr_x[i], y1 = y+freearr_y[i];
 
        if (!wall_blocked(map, x1, y1)
                || layout[x1][y1] == '>') {/* place a door */
            object *new_door = create_archetype((freearr_x[i] == 0) ? doors[1] : doors[0]);
            int16_t nx, ny;
 
            nx = x+freearr_x[i];
            ny = y+freearr_y[i];
            remove_monsters(nx, ny, map);
            object_insert_in_map_at(new_door, map, NULL, 0, nx, ny);
            doorlist[ndoors_made] = new_door;
            ndoors_made++;
        }
    }
    return doorlist;
}
 
static object *door_in_square(mapstruct *map, int x, int y)
{
    FOR_MAP_PREPARE(map, x, y, tmp)
    if (tmp->type == DOOR || tmp->type == LOCKED_DOOR) {
        return tmp;
    }
    FOR_MAP_FINISH();
    return NULL;
}
 
void find_doors_in_room_recursive(char **layout, mapstruct *map, int x, int y, object **doorlist, int *ndoors, RMParms *RP)
{
    int i, j;
    object *door;
 
    /* bounds check x and y */
    if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) {
        return;
    }
 
    /* if the square is blocked or searched already, leave */
    if (layout[x][y] == 1) {
        return;
    }
 
    /* check off this point */
    if (layout[x][y] == '#') { /* there could be a door here */
        layout[x][y] = 1;
        door = door_in_square(map, x, y);
        if (door != NULL) {
            doorlist[*ndoors] = door;
            if (*ndoors > 254) { /* eek!  out of memory */
                LOG(llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n");
                return;
            }
            *ndoors = *ndoors+1;
        }
    } else {
        layout[x][y] = 1;
        /* now search all the 8 squares around recursively for free spots, in random order */
        for (i = RANDOM()%8, j = 0; j < 8; i++, j++) {
            find_doors_in_room_recursive(layout, map, x+freearr_x[i%8+1], y+freearr_y[i%8+1], doorlist, ndoors, RP);
        }
    }
}
 
object **find_doors_in_room(mapstruct *map, int x, int y, RMParms *RP)
{
    char **layout2;
    object **doorlist;
    int i, j;
    int ndoors = 0;
 
    doorlist = (object **)calloc(sizeof(*doorlist), 256);
 
 
    layout2 = (char **)calloc(sizeof(char *), RP->Xsize);
    /* allocate and copy the layout, converting C to 0. */
    for (i = 0; i < RP->Xsize; i++) {
        layout2[i] = (char *)calloc(sizeof(char), RP->Ysize);
        for (j = 0; j < RP->Ysize; j++) {
            if (wall_blocked(map, i, j)) {
                layout2[i][j] = '#';
            }
        }
    }
 
    /* setup num_free_spots and room_free_spots */
    find_doors_in_room_recursive(layout2, map, x, y, doorlist, &ndoors, RP);
 
    /* deallocate the temp. layout */
    for (i = 0; i < RP->Xsize; i++) {
        free(layout2[i]);
    }
    free(layout2);
    return doorlist;
}
 
static void remove_adjacent_doors(object *door)
{
    mapstruct *m = door->map;
    int x = door->x;
    int y = door->y;
    int i, flags;
 
    for (i = 1; i <= 8; i++) {
        flags = get_map_flags(m, NULL, x+freearr_x[i], y+freearr_y[i], NULL, NULL);
        if (flags&P_OUT_OF_MAP) {
            continue;
        }
 
        /* Old style doors are living objects.  So if P_IS_ALIVE is not
         * set, can not be a door on this space.
         */
        if (flags&P_IS_ALIVE) {
            FOR_MAP_PREPARE(m, x+freearr_x[i], y+freearr_y[i], tmp) {
                if (tmp->type == DOOR) {
                    object_remove(tmp);
                    object_free_drop_inventory(tmp);
                    break;
                }
            }
            FOR_MAP_FINISH();
        }
    }
}
 
void lock_and_hide_doors(object **doorlist, mapstruct *map, int opts, RMParms *RP)
{
    object *door;
    int i;
 
    /* lock the doors and hide the keys. */
    if (opts&DOORED) {
        for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++) {
            object *new_door = create_archetype("locked_door1");
            char keybuf[256];
 
            door = doorlist[i];
            new_door->face = door->face;
            object_remove(door);
            object_free_drop_inventory(door);
            doorlist[i] = new_door;
            object_insert_in_map_at(new_door, map, NULL, 0, door->x, door->y);
 
            snprintf(keybuf, 256, "%d", (int)RANDOM());
            if (keyplace(map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP)) {
                new_door->slaying = add_string(keybuf);
            }
        }
        for (i = 0; doorlist[i] != NULL; i++) {
            remove_adjacent_doors(doorlist[i]);
        }
    }
 
    /* change the faces of the doors and surrounding walls to hide them. */
    if (opts&HIDDEN) {
        for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++) {
            object *wallface;
 
            door = doorlist[i];
            wallface = retrofit_joined_wall(map, door->x, door->y, 1, RP);
            if (wallface != NULL) {
                retrofit_joined_wall(map, door->x-1, door->y, 0, RP);
                retrofit_joined_wall(map, door->x+1, door->y, 0, RP);
                retrofit_joined_wall(map, door->x, door->y-1, 0, RP);
                retrofit_joined_wall(map, door->x, door->y+1, 0, RP);
                door->face = wallface->face;
                if (!QUERY_FLAG(wallface, FLAG_REMOVED)) {
                    object_remove(wallface);
                }
                object_free_drop_inventory(wallface);
            }
        }
    }
}