[Fix] #39944 backwardsEric氏の報告による、grid_bold_type のfloor列挙子と math.h のfloor()がコンフリクトを起こ...

diff --git a/src/floor-generate.c b/src/floor-generate.c
index 564f703..55e5afe 100644 (file)
--- a/src/floor-generate.c
+++ b/src/floor-generate.c
@@ -644,22 +644,22 @@ static bool cave_gen(player_type *player_ptr)
                {
                        for (x = 0; x < floor_ptr->width; x++)
                        {
-                               place_bold(player_ptr, y, x, floor);
+                               place_bold(player_ptr, y, x, gb_floor);
                        }
                }
 
                /* Special boundary walls -- Top and bottom */
                for (x = 0; x < floor_ptr->width; x++)
                {
-                       place_bold(player_ptr, 0, x, extra);
-                       place_bold(player_ptr, floor_ptr->height - 1, x, extra);
+                       place_bold(player_ptr, 0, x, gb_extra);
+                       place_bold(player_ptr, floor_ptr->height - 1, x, gb_extra);
                }
 
                /* Special boundary walls -- Left and right */
                for (y = 1; y < (floor_ptr->height - 1); y++)
                {
-                       place_bold(player_ptr, y, 0, extra);
-                       place_bold(player_ptr, y, floor_ptr->width - 1, extra);
+                       place_bold(player_ptr, y, 0, gb_extra);
+                       place_bold(player_ptr, y, floor_ptr->width - 1, gb_extra);
                }
        }
        else
@@ -669,7 +669,7 @@ static bool cave_gen(player_type *player_ptr)
                {
                        for (x = 0; x < floor_ptr->width; x++)
                        {
-                               place_bold(player_ptr, y, x, extra);
+                               place_bold(player_ptr, y, x, gb_extra);
                        }
                }
        }
@@ -835,7 +835,7 @@ static bool cave_gen(player_type *player_ptr)
                                        /* Clear mimic type */
                                        g_ptr->mimic = 0;
 
-                                       place_grid(player_ptr, g_ptr, floor);
+                                       place_grid(player_ptr, g_ptr, gb_floor);
                                }
                        }
 
@@ -851,7 +851,7 @@ static bool cave_gen(player_type *player_ptr)
                                g_ptr->mimic = 0;
 
                                /* Clear previous contents, add up floor */
-                               place_grid(player_ptr, g_ptr, floor);
+                               place_grid(player_ptr, g_ptr, gb_floor);
 
                                /* Occasional doorway */
                                if ((randint0(100) < dun_tun_pen) && !(dungeon_ptr->flags1 & DF1_NO_DOORS))
@@ -1022,35 +1022,35 @@ static void build_arena(player_type *player_ptr, POSITION *start_y, POSITION *st
        for (i = y_height; i <= y_height + 5; i++)
                for (j = x_left; j <= x_right; j++)
                {
-                       place_bold(player_ptr, i, j, extra_perm);
+                       place_bold(player_ptr, i, j, gb_extra_perm);
                        floor_ptr->grid_array[i][j].info |= (CAVE_GLOW | CAVE_MARK);
                }
        for (i = y_depth; i >= y_depth - 5; i--)
                for (j = x_left; j <= x_right; j++)
                {
-                       place_bold(player_ptr, i, j, extra_perm);
+                       place_bold(player_ptr, i, j, gb_extra_perm);
                        floor_ptr->grid_array[i][j].info |= (CAVE_GLOW | CAVE_MARK);
                }
        for (j = x_left; j <= x_left + 17; j++)
                for (i = y_height; i <= y_depth; i++)
                {
-                       place_bold(player_ptr, i, j, extra_perm);
+                       place_bold(player_ptr, i, j, gb_extra_perm);
                        floor_ptr->grid_array[i][j].info |= (CAVE_GLOW | CAVE_MARK);
                }
        for (j = x_right; j >= x_right - 17; j--)
                for (i = y_height; i <= y_depth; i++)
                {
-                       place_bold(player_ptr, i, j, extra_perm);
+                       place_bold(player_ptr, i, j, gb_extra_perm);
                        floor_ptr->grid_array[i][j].info |= (CAVE_GLOW | CAVE_MARK);
                }
 
-       place_bold(player_ptr, y_height + 6, x_left + 18, extra_perm);
+       place_bold(player_ptr, y_height + 6, x_left + 18, gb_extra_perm);
        floor_ptr->grid_array[y_height + 6][x_left + 18].info |= (CAVE_GLOW | CAVE_MARK);
-       place_bold(player_ptr, y_depth - 6, x_left + 18, extra_perm);
+       place_bold(player_ptr, y_depth - 6, x_left + 18, gb_extra_perm);
        floor_ptr->grid_array[y_depth - 6][x_left + 18].info |= (CAVE_GLOW | CAVE_MARK);
-       place_bold(player_ptr, y_height + 6, x_right - 18, extra_perm);
+       place_bold(player_ptr, y_height + 6, x_right - 18, gb_extra_perm);
        floor_ptr->grid_array[y_height + 6][x_right - 18].info |= (CAVE_GLOW | CAVE_MARK);
-       place_bold(player_ptr, y_depth - 6, x_right - 18, extra_perm);
+       place_bold(player_ptr, y_depth - 6, x_right - 18, gb_extra_perm);
        floor_ptr->grid_array[y_depth - 6][x_right - 18].info |= (CAVE_GLOW | CAVE_MARK);
 
        *start_y = y_height + 5;
@@ -1080,7 +1080,7 @@ static void generate_challenge_arena(player_type *challanger_ptr)
                for (x = 0; x < MAX_WID; x++)
                {
                        /* Create "solid" perma-wall */
-                       place_bold(challanger_ptr, y, x, solid_perm);
+                       place_bold(challanger_ptr, y, x, gb_solid_perm);
 
                        /* Illuminate and memorize the walls */
                        floor_ptr->grid_array[y][x].info |= (CAVE_GLOW | CAVE_MARK);
@@ -1130,35 +1130,35 @@ static void build_battle(player_type *player_ptr, POSITION *y, POSITION *x)
        for (i = y_height; i <= y_height + 5; i++)
                for (j = x_left; j <= x_right; j++)
                {
-                       place_bold(player_ptr, i, j, extra_perm);
+                       place_bold(player_ptr, i, j, gb_extra_perm);
                        floor_ptr->grid_array[i][j].info |= (CAVE_GLOW | CAVE_MARK);
                }
        for (i = y_depth; i >= y_depth - 3; i--)
                for (j = x_left; j <= x_right; j++)
                {
-                       place_bold(player_ptr, i, j, extra_perm);
+                       place_bold(player_ptr, i, j, gb_extra_perm);
                        floor_ptr->grid_array[i][j].info |= (CAVE_GLOW | CAVE_MARK);
                }
        for (j = x_left; j <= x_left + 17; j++)
                for (i = y_height; i <= y_depth; i++)
                {
-                       place_bold(player_ptr, i, j, extra_perm);
+                       place_bold(player_ptr, i, j, gb_extra_perm);
                        floor_ptr->grid_array[i][j].info |= (CAVE_GLOW | CAVE_MARK);
                }
        for (j = x_right; j >= x_right - 17; j--)
                for (i = y_height; i <= y_depth; i++)
                {
-                       place_bold(player_ptr, i, j, extra_perm);
+                       place_bold(player_ptr, i, j, gb_extra_perm);
                        floor_ptr->grid_array[i][j].info |= (CAVE_GLOW | CAVE_MARK);
                }
 
-       place_bold(player_ptr, y_height+6, x_left+18, extra_perm);
+       place_bold(player_ptr, y_height+6, x_left+18, gb_extra_perm);
        floor_ptr->grid_array[y_height+6][x_left+18].info |= (CAVE_GLOW | CAVE_MARK);
-       place_bold(player_ptr, y_depth-4, x_left+18, extra_perm);
+       place_bold(player_ptr, y_depth-4, x_left+18, gb_extra_perm);
        floor_ptr->grid_array[y_depth-4][x_left+18].info |= (CAVE_GLOW | CAVE_MARK);
-       place_bold(player_ptr, y_height+6, x_right-18, extra_perm);
+       place_bold(player_ptr, y_height+6, x_right-18, gb_extra_perm);
        floor_ptr->grid_array[y_height+6][x_right-18].info |= (CAVE_GLOW | CAVE_MARK);
-       place_bold(player_ptr, y_depth-4, x_right-18, extra_perm);
+       place_bold(player_ptr, y_depth-4, x_right-18, gb_extra_perm);
        floor_ptr->grid_array[y_depth-4][x_right-18].info |= (CAVE_GLOW | CAVE_MARK);
 
        for (i = y_height + 1; i <= y_height + 5; i++)
@@ -1194,7 +1194,7 @@ static void generate_gambling_arena(player_type *creature_ptr)
                for (x = 0; x < MAX_WID; x++)
                {
                        /* Create "solid" perma-wall */
-                       place_bold(creature_ptr, y, x, solid_perm);
+                       place_bold(creature_ptr, y, x, gb_solid_perm);
 
                        /* Illuminate and memorize the walls */
                        floor_ptr->grid_array[y][x].info |= (CAVE_GLOW | CAVE_MARK);
@@ -1246,7 +1246,7 @@ static void generate_fixed_floor(player_type *player_ptr)
        {
                for (x = 0; x < floor_ptr->width; x++)
                {
-                       place_bold(player_ptr, y, x, solid_perm);
+                       place_bold(player_ptr, y, x, gb_solid_perm);
                }
        }
 
@@ -1689,7 +1689,7 @@ bool build_tunnel(player_type *player_ptr, POSITION row1, POSITION col1, POSITIO
                                        if (is_outer_bold(floor_ptr, y, x))
                                        {
                                                /* Change the wall to a "solid" wall */
-                                               place_bold(player_ptr, y, x, solid_noperm);
+                                               place_bold(player_ptr, y, x, gb_solid_noperm);
                                        }
                                }
                        }
@@ -1840,7 +1840,7 @@ static bool set_tunnel(player_type *player_ptr, POSITION *x, POSITION *y, bool a
                                if (is_outer_bold(floor_ptr, j, i))
                                {
                                        /* Change the wall to a "solid" wall */
-                                       place_bold(player_ptr, j, i, solid_noperm);
+                                       place_bold(player_ptr, j, i, gb_solid_noperm);
                                }
                        }
                }
@@ -1848,7 +1848,7 @@ static bool set_tunnel(player_type *player_ptr, POSITION *x, POSITION *y, bool a
                /* Clear mimic type */
                floor_ptr->grid_array[*y][*x].mimic = 0;
 
-               place_bold(player_ptr, *y, *x, floor);
+               place_bold(player_ptr, *y, *x, gb_floor);
 
                return TRUE;
        }
@@ -1880,7 +1880,7 @@ static bool set_tunnel(player_type *player_ptr, POSITION *x, POSITION *y, bool a
                if (i == 0)
                {
                        /* Failed for some reason: hack - ignore the solidness */
-                       place_grid(player_ptr, g_ptr, outer);
+                       place_grid(player_ptr, g_ptr, gb_outer);
                        dx = 0;
                        dy = 0;
                }
@@ -2138,7 +2138,7 @@ bool build_tunnel2(player_type *player_ptr, POSITION x1, POSITION y1, POSITION x
                        if (i == 0)
                        {
                                /* Failed for some reason: hack - ignore the solidness */
-                               place_bold(player_ptr, y3, x3, outer);
+                               place_bold(player_ptr, y3, x3, gb_outer);
                                dx = 0;
                                dy = 0;
                        }

diff --git a/src/floor-save.c b/src/floor-save.c
index cea5893..477d736 100644 (file)
--- a/src/floor-save.c
+++ b/src/floor-save.c
@@ -373,7 +373,7 @@ static void build_dead_end(player_type *creature_ptr)
                for (x = 0; x < MAX_WID; x++)
                {
                        /* Create "solid" perma-wall */
-                       place_bold(creature_ptr, y, x, solid_perm);
+                       place_bold(creature_ptr, y, x, gb_solid_perm);
                }
        }
 
@@ -382,7 +382,7 @@ static void build_dead_end(player_type *creature_ptr)
        creature_ptr->x = creature_ptr->current_floor_ptr->width / 2;
 
        /* Give one square */
-       place_bold(creature_ptr, creature_ptr->y, creature_ptr->x, floor);
+       place_bold(creature_ptr, creature_ptr->y, creature_ptr->x, gb_floor);
 
        wipe_generate_random_floor_flags(creature_ptr->current_floor_ptr);
 }

diff --git a/src/floor.c b/src/floor.c
index 6f52621..05fcc28 100644 (file)
--- a/src/floor.c
+++ b/src/floor.c
@@ -90,7 +90,7 @@ void place_locked_door(player_type *player_ptr, POSITION y, POSITION x)
        floor_type *floor_ptr = player_ptr->current_floor_ptr;
        if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_DOORS)
        {
-               place_bold(player_ptr, y, x, floor);
+               place_bold(player_ptr, y, x, gb_floor);
                return;
        }
 
@@ -113,7 +113,7 @@ void place_secret_door(player_type *player_ptr, POSITION y, POSITION x, int type
        floor_type *floor_ptr = player_ptr->current_floor_ptr;
        if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_DOORS)
        {
-               place_bold(player_ptr, y, x, floor);
+               place_bold(player_ptr, y, x, gb_floor);
                return;
        }
 
@@ -275,8 +275,8 @@ void add_door(player_type *player_ptr, POSITION x, POSITION y)
                place_secret_door(player_ptr, y, x, DOOR_DEFAULT);
 
                /* set boundarys so don't get wide doors */
-               place_bold(player_ptr, y, x - 1, solid);
-               place_bold(player_ptr, y, x + 1, solid);
+               place_bold(player_ptr, y, x - 1, gb_solid);
+               place_bold(player_ptr, y, x + 1, gb_solid);
        }
 
        /* look at:
@@ -294,8 +294,8 @@ void add_door(player_type *player_ptr, POSITION x, POSITION y)
                place_secret_door(player_ptr, y, x, DOOR_DEFAULT);
 
                /* set boundarys so don't get wide doors */
-               place_bold(player_ptr, y - 1, x, solid);
-               place_bold(player_ptr, y + 1, x, solid);
+               place_bold(player_ptr, y - 1, x, gb_solid);
+               place_bold(player_ptr, y + 1, x, gb_solid);
        }
 }
 
@@ -791,7 +791,7 @@ void place_random_door(player_type *player_ptr, POSITION y, POSITION x, bool roo
 
        if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_DOORS)
        {
-               place_bold(player_ptr, y, x, floor);
+               place_bold(player_ptr, y, x, gb_floor);
                return;
        }
 
@@ -855,7 +855,7 @@ void place_random_door(player_type *player_ptr, POSITION y, POSITION x, bool roo
        }
        else
        {
-               place_bold(player_ptr, y, x, floor);
+               place_bold(player_ptr, y, x, gb_floor);
        }
 
        delete_monster(player_ptr, y, x);
@@ -938,7 +938,7 @@ void place_closed_door(player_type *player_ptr, POSITION y, POSITION x, int type
        floor_type *floor_ptr = player_ptr->current_floor_ptr;
        if (d_info[floor_ptr->dungeon_idx].flags1 & DF1_NO_DOORS)
        {
-               place_bold(player_ptr, y, x, floor);
+               place_bold(player_ptr, y, x, gb_floor);
                return;
        }
 
@@ -969,7 +969,7 @@ void place_closed_door(player_type *player_ptr, POSITION y, POSITION x, int type
 
        if (feat == feat_none)
        {
-               place_bold(player_ptr, y, x, floor);
+               place_bold(player_ptr, y, x, gb_floor);
                return;
        }
 
@@ -1585,7 +1585,7 @@ void set_floor(player_type *player_ptr, POSITION x, POSITION y)
 
        /* Set to be floor if is a wall (don't touch lakes). */
        if (is_extra_bold(floor_ptr, y, x))
-               place_bold(player_ptr, y, x, floor);
+               place_bold(player_ptr, y, x, gb_floor);
 }
 
 

diff --git a/src/grid.c b/src/grid.c
index cb5c7bc..9c107ac 100644 (file)
--- a/src/grid.c
+++ b/src/grid.c
@@ -257,7 +257,7 @@ void place_bound_perm_wall(player_type *player_ptr, grid_type *g_ptr)
        }
 
        /* Add "solid" perma-wall */
-       place_grid(player_ptr, g_ptr, solid_perm);
+       place_grid(player_ptr, g_ptr, gb_solid_perm);
 }
 
 /*!
@@ -1217,42 +1217,42 @@ void place_grid(player_type *player_ptr, grid_type *g_ptr, grid_bold_type gb_typ
 {
        switch (gb_type)
        {
-       case floor:
+       case gb_floor:
        {
                g_ptr->feat = feat_ground_type[randint0(100)];
                g_ptr->info |= CAVE_FLOOR;
                break;
        }
-       case extra:
+       case gb_extra:
        {
                g_ptr->feat = feat_wall_type[randint0(100)];
                g_ptr->info |= CAVE_EXTRA;
                break;
        }
-       case extra_perm:
+       case gb_extra_perm:
        {
                // No such grid
                return;
        }
-       case inner:
+       case gb_inner:
        {
                g_ptr->feat = feat_wall_inner;
                g_ptr->info |= CAVE_INNER;
                break;
        }
-       case inner_perm:
+       case gb_inner_perm:
        {
                g_ptr->feat = feat_permanent;
                g_ptr->info |= CAVE_INNER;
                break;
        }
-       case outer:
+       case gb_outer:
        {
                g_ptr->feat = feat_wall_outer;
                g_ptr->info |= CAVE_OUTER;
                break;
        }
-       case outer_noperm:
+       case gb_outer_noperm:
        {
                feature_type *f_ptr = &f_info[feat_wall_outer];
                if (permanent_wall(f_ptr))
@@ -1267,18 +1267,18 @@ void place_grid(player_type *player_ptr, grid_type *g_ptr, grid_bold_type gb_typ
                g_ptr->info |= (CAVE_OUTER | CAVE_VAULT);
                break;
        }
-       case solid:
+       case gb_solid:
        {
                // No such grid
                return;
        }
-       case solid_perm:
+       case gb_solid_perm:
        {
                g_ptr->feat = feat_permanent;
                g_ptr->info |= CAVE_SOLID;
                break;
        }
-       case solid_noperm:
+       case gb_solid_noperm:
        {
                // No such grid
                return;
@@ -1310,49 +1310,49 @@ void place_bold(player_type *player_ptr, POSITION y, POSITION x, grid_bold_type
        floor_type *floor_ptr = player_ptr->current_floor_ptr;
        switch (gb_type)
        {
-       case floor:
+       case gb_floor:
        {
                set_cave_feat(floor_ptr, y, x, feat_ground_type[randint0(100)]);
                floor_ptr->grid_array[y][x].info &= ~(CAVE_MASK);
                add_cave_info(floor_ptr, y, x, CAVE_FLOOR);
                break;
        }
-       case extra:
+       case gb_extra:
        {
                set_cave_feat(floor_ptr, y, x, feat_wall_type[randint0(100)]);
                floor_ptr->grid_array[y][x].info &= ~(CAVE_MASK);
                add_cave_info(floor_ptr, y, x, CAVE_EXTRA);
                break;
        }
-       case extra_perm:
+       case gb_extra_perm:
        {
                set_cave_feat(floor_ptr, y, x, feat_permanent);
                floor_ptr->grid_array[y][x].info &= ~(CAVE_MASK);
                add_cave_info(floor_ptr, y, x, CAVE_EXTRA);
                break;
        }
-       case inner:
+       case gb_inner:
        {
                set_cave_feat(floor_ptr, y, x, feat_wall_inner);
                floor_ptr->grid_array[y][x].info &= ~(CAVE_MASK);
                add_cave_info(floor_ptr, y, x, CAVE_INNER);
                break;
        }
-       case inner_perm:
+       case gb_inner_perm:
        {
                set_cave_feat(floor_ptr, y, x, feat_permanent);
                floor_ptr->grid_array[y][x].info &= ~(CAVE_MASK);
                add_cave_info(floor_ptr, y, x, CAVE_INNER);
                break;
        }
-       case outer:
+       case gb_outer:
        {
                set_cave_feat(floor_ptr, y, x, feat_wall_outer);
                floor_ptr->grid_array[y][x].info &= ~(CAVE_MASK);
                add_cave_info(floor_ptr, y, x, CAVE_OUTER);
                break;
        }
-       case outer_noperm:
+       case gb_outer_noperm:
        {
                feature_type *_f_ptr = &f_info[feat_wall_outer];
                if (permanent_wall(_f_ptr)) set_cave_feat(floor_ptr, y, x, (s16b)feat_state(player_ptr, feat_wall_outer, FF_UNPERM));
@@ -1361,14 +1361,14 @@ void place_bold(player_type *player_ptr, POSITION y, POSITION x, grid_bold_type
                add_cave_info(floor_ptr, y, x, (CAVE_OUTER | CAVE_VAULT));
                break;
        }
-       case solid:
+       case gb_solid:
        {
                set_cave_feat(floor_ptr, y, x, feat_permanent);
                floor_ptr->grid_array[y][x].info &= ~(CAVE_MASK);
                add_cave_info(floor_ptr, y, x, CAVE_SOLID);
                break;
        }
-       case solid_perm:
+       case gb_solid_perm:
        {
                feature_type *f_ptr = &f_info[feat_wall_solid];
                if ((floor_ptr->grid_array[y][x].info & CAVE_VAULT) && permanent_wall(f_ptr))

diff --git a/src/grid.h b/src/grid.h
index 4a22f0a..e34c94e 100644 (file)
--- a/src/grid.h
+++ b/src/grid.h
@@ -206,16 +206,16 @@ extern bool cave_player_teleportable_bold(player_type *player_ptr, POSITION y, P
 
 typedef enum grid_bold_type
 {
-       floor,
-       extra,
-       extra_perm,
-       inner,
-       inner_perm,
-       outer,
-       outer_noperm,
-       solid,
-       solid_perm,
-       solid_noperm
+       gb_floor,
+       gb_extra,
+       gb_extra_perm,
+       gb_inner,
+       gb_inner_perm,
+       gb_outer,
+       gb_outer_noperm,
+       gb_solid,
+       gb_solid_perm,
+       gb_solid_noperm
 } grid_bold_type;
 
 extern void place_grid(player_type *player_ptr, grid_type *g_ptr, grid_bold_type pg_type);

diff --git a/src/rooms-normal.c b/src/rooms-normal.c
index 27f163b..a9704a4 100644 (file)
--- a/src/rooms-normal.c
+++ b/src/rooms-normal.c
@@ -67,7 +67,7 @@ bool build_type1(player_type *player_ptr)
                for (x = x1 - 1; x <= x2 + 1; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                        g_ptr->info |= (CAVE_ROOM);
                        if (light) g_ptr->info |= (CAVE_GLOW);
                }
@@ -77,16 +77,16 @@ bool build_type1(player_type *player_ptr)
        for (y = y1 - 1; y <= y2 + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1 - 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y][x2 + 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
        for (x = x1 - 1; x <= x2 + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1 - 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y2 + 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
 
 
@@ -122,7 +122,7 @@ bool build_type1(player_type *player_ptr)
                        for (x = x1; x <= x2; x += 2)
                        {
                                g_ptr = &floor_ptr->grid_array[y][x];
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                        }
                }
        }
@@ -133,16 +133,16 @@ bool build_type1(player_type *player_ptr)
                if ((y1 + 4 < y2) && (x1 + 4 < x2))
                {
                        g_ptr = &floor_ptr->grid_array[y1 + 1][x1 + 1];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
 
                        g_ptr = &floor_ptr->grid_array[y1 + 1][x2 - 1];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
 
                        g_ptr = &floor_ptr->grid_array[y2 - 1][x1 + 1];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
 
                        g_ptr = &floor_ptr->grid_array[y2 - 1][x2 - 1];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                }
        }
 
@@ -152,16 +152,16 @@ bool build_type1(player_type *player_ptr)
                for (y = y1 + 2; y <= y2 - 2; y += 2)
                {
                        g_ptr = &floor_ptr->grid_array[y][x1];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr = &floor_ptr->grid_array[y][x2];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                }
                for (x = x1 + 2; x <= x2 - 2; x += 2)
                {
                        g_ptr = &floor_ptr->grid_array[y1][x];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr = &floor_ptr->grid_array[y2][x];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                }
        }
        /* Hack -- Occasional divided room */
@@ -175,26 +175,26 @@ bool build_type1(player_type *player_ptr)
                        /* Horizontal wall */
                        for (x = x1; x <= x2; x++)
                        {
-                               place_bold(player_ptr, yval, x, inner);
+                               place_bold(player_ptr, yval, x, gb_inner);
                                if (curtain2) floor_ptr->grid_array[yval][x].feat = feat_door[DOOR_CURTAIN].closed;
                        }
 
                        /* Prevent edge of wall from being tunneled */
-                       place_bold(player_ptr, yval, x1 - 1, solid);
-                       place_bold(player_ptr, yval, x2 + 1, solid);
+                       place_bold(player_ptr, yval, x1 - 1, gb_solid);
+                       place_bold(player_ptr, yval, x2 + 1, gb_solid);
                }
                else
                {
                        /* Vertical wall */
                        for (y = y1; y <= y2; y++)
                        {
-                               place_bold(player_ptr, y, xval, inner);
+                               place_bold(player_ptr, y, xval, gb_inner);
                                if (curtain2) floor_ptr->grid_array[y][xval].feat = feat_door[DOOR_CURTAIN].closed;
                        }
 
                        /* Prevent edge of wall from being tunneled */
-                       place_bold(player_ptr, y1 - 1, xval, solid);
-                       place_bold(player_ptr, y2 + 1, xval, solid);
+                       place_bold(player_ptr, y1 - 1, xval, gb_solid);
+                       place_bold(player_ptr, y2 + 1, xval, gb_solid);
                }
 
                place_random_door(player_ptr, yval, xval, TRUE);
@@ -243,7 +243,7 @@ bool build_type2(player_type *player_ptr)
                for (x = x1a - 1; x <= x2a + 1; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                        g_ptr->info |= (CAVE_ROOM);
                        if (light) g_ptr->info |= (CAVE_GLOW);
                }
@@ -255,7 +255,7 @@ bool build_type2(player_type *player_ptr)
                for (x = x1b - 1; x <= x2b + 1; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                        g_ptr->info |= (CAVE_ROOM);
                        if (light) g_ptr->info |= (CAVE_GLOW);
                }
@@ -266,32 +266,32 @@ bool build_type2(player_type *player_ptr)
        for (y = y1a - 1; y <= y2a + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1a - 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y][x2a + 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
        for (x = x1a - 1; x <= x2a + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1a - 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y2a + 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
 
        /* Place the walls around room "b" */
        for (y = y1b - 1; y <= y2b + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1b - 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y][x2b + 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
        for (x = x1b - 1; x <= x2b + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1b - 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y2b + 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
 
 
@@ -302,7 +302,7 @@ bool build_type2(player_type *player_ptr)
                for (x = x1a; x <= x2a; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                }
        }
 
@@ -312,7 +312,7 @@ bool build_type2(player_type *player_ptr)
                for (x = x1b; x <= x2b; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                }
        }
 
@@ -379,7 +379,7 @@ bool build_type3(player_type *player_ptr)
                for (x = x1a - 1; x <= x2a + 1; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                        g_ptr->info |= (CAVE_ROOM);
                        if (light) g_ptr->info |= (CAVE_GLOW);
                }
@@ -391,7 +391,7 @@ bool build_type3(player_type *player_ptr)
                for (x = x1b - 1; x <= x2b + 1; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                        g_ptr->info |= (CAVE_ROOM);
                        if (light) g_ptr->info |= (CAVE_GLOW);
                }
@@ -402,32 +402,32 @@ bool build_type3(player_type *player_ptr)
        for (y = y1a - 1; y <= y2a + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1a - 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y][x2a + 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
        for (x = x1a - 1; x <= x2a + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1a - 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y2a + 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
 
        /* Place the walls around room "b" */
        for (y = y1b - 1; y <= y2b + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1b - 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y][x2b + 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
        for (x = x1b - 1; x <= x2b + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1b - 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y2b + 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
 
 
@@ -437,7 +437,7 @@ bool build_type3(player_type *player_ptr)
                for (x = x1a; x <= x2a; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                }
        }
 
@@ -447,7 +447,7 @@ bool build_type3(player_type *player_ptr)
                for (x = x1b; x <= x2b; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                }
        }
 
@@ -464,7 +464,7 @@ bool build_type3(player_type *player_ptr)
                        for (x = x1a; x <= x2a; x++)
                        {
                                g_ptr = &floor_ptr->grid_array[y][x];
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                        }
                }
                break;
@@ -477,16 +477,16 @@ bool build_type3(player_type *player_ptr)
                for (y = y1b; y <= y2b; y++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x1a];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr = &floor_ptr->grid_array[y][x2a];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                }
                for (x = x1a; x <= x2a; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y1b][x];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr = &floor_ptr->grid_array[y2b][x];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                }
 
                /* Place a secret door on the inner room */
@@ -521,9 +521,9 @@ bool build_type3(player_type *player_ptr)
                        {
                                if (y == yval) continue;
                                g_ptr = &floor_ptr->grid_array[y][x1a - 1];
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                                g_ptr = &floor_ptr->grid_array[y][x2a + 1];
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                        }
 
                        /* Pinch the north/south sides */
@@ -531,9 +531,9 @@ bool build_type3(player_type *player_ptr)
                        {
                                if (x == xval) continue;
                                g_ptr = &floor_ptr->grid_array[y1b - 1][x];
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                                g_ptr = &floor_ptr->grid_array[y2b + 1][x];
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                        }
 
                        /* Sometimes shut using secret doors */
@@ -554,22 +554,22 @@ bool build_type3(player_type *player_ptr)
                else if (one_in_(3))
                {
                        g_ptr = &floor_ptr->grid_array[yval][xval];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr = &floor_ptr->grid_array[y1b][xval];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr = &floor_ptr->grid_array[y2b][xval];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr = &floor_ptr->grid_array[yval][x1a];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr = &floor_ptr->grid_array[yval][x2a];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                }
 
                /* Occasionally put a pillar in the center */
                else if (one_in_(3))
                {
                        g_ptr = &floor_ptr->grid_array[yval][xval];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                }
 
                break;
@@ -617,7 +617,7 @@ bool build_type4(player_type *player_ptr)
                for (x = x1 - 1; x <= x2 + 1; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                        g_ptr->info |= (CAVE_ROOM);
                        if (light) g_ptr->info |= (CAVE_GLOW);
                }
@@ -627,16 +627,16 @@ bool build_type4(player_type *player_ptr)
        for (y = y1 - 1; y <= y2 + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1 - 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y][x2 + 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
        for (x = x1 - 1; x <= x2 + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1 - 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y2 + 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
 
 
@@ -650,16 +650,16 @@ bool build_type4(player_type *player_ptr)
        for (y = y1 - 1; y <= y2 + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1 - 1];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
                g_ptr = &floor_ptr->grid_array[y][x2 + 1];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
        }
        for (x = x1 - 1; x <= x2 + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1 - 1][x];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
                g_ptr = &floor_ptr->grid_array[y2 + 1][x];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
        }
 
 
@@ -703,7 +703,7 @@ bool build_type4(player_type *player_ptr)
                                {
                                        if ((x == xval) && (y == yval)) continue;
                                        g_ptr = &floor_ptr->grid_array[y][x];
-                                       place_grid(player_ptr, g_ptr, inner);
+                                       place_grid(player_ptr, g_ptr, gb_inner);
                                }
                        }
 
@@ -755,7 +755,7 @@ bool build_type4(player_type *player_ptr)
                                for (x = xval - 1; x <= xval + 1; x++)
                                {
                                        g_ptr = &floor_ptr->grid_array[y][x];
-                                       place_grid(player_ptr, g_ptr, inner);
+                                       place_grid(player_ptr, g_ptr, gb_inner);
                                }
                        }
 
@@ -768,12 +768,12 @@ bool build_type4(player_type *player_ptr)
                                        for (x = xval - 5 - tmp; x <= xval - 3 - tmp; x++)
                                        {
                                                g_ptr = &floor_ptr->grid_array[y][x];
-                                               place_grid(player_ptr, g_ptr, inner);
+                                               place_grid(player_ptr, g_ptr, gb_inner);
                                        }
                                        for (x = xval + 3 + tmp; x <= xval + 5 + tmp; x++)
                                        {
                                                g_ptr = &floor_ptr->grid_array[y][x];
-                                               place_grid(player_ptr, g_ptr, inner);
+                                               place_grid(player_ptr, g_ptr, gb_inner);
                                        }
                                }
                        }
@@ -789,16 +789,16 @@ bool build_type4(player_type *player_ptr)
                                for (x = xval - 5; x <= xval + 5; x++)
                                {
                                        g_ptr = &floor_ptr->grid_array[yval - 1][x];
-                                       place_grid(player_ptr, g_ptr, inner);
+                                       place_grid(player_ptr, g_ptr, gb_inner);
                                        g_ptr = &floor_ptr->grid_array[yval + 1][x];
-                                       place_grid(player_ptr, g_ptr, inner);
+                                       place_grid(player_ptr, g_ptr, gb_inner);
                                }
 
                                /* Close off the left/right edges */
                                g_ptr = &floor_ptr->grid_array[yval][xval - 5];
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                                g_ptr = &floor_ptr->grid_array[yval][xval + 5];
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
 
                                /* Secret doors (random top/bottom) */
                                place_secret_door(player_ptr, yval - 3 + (randint1(2) * 2), xval - 3, door_type);
@@ -836,7 +836,7 @@ bool build_type4(player_type *player_ptr)
                                        if (0x1 & (x + y))
                                        {
                                                g_ptr = &floor_ptr->grid_array[y][x];
-                                               place_grid(player_ptr, g_ptr, inner);
+                                               place_grid(player_ptr, g_ptr, gb_inner);
                                        }
                                }
                        }
@@ -866,12 +866,12 @@ bool build_type4(player_type *player_ptr)
                        for (y = y1; y <= y2; y++)
                        {
                                g_ptr = &floor_ptr->grid_array[y][xval];
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                        }
                        for (x = x1; x <= x2; x++)
                        {
                                g_ptr = &floor_ptr->grid_array[yval][x];
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                        }
 
                        /* Doors into the rooms */
@@ -941,12 +941,12 @@ bool build_type11(player_type *player_ptr)
                        if (distance(y0, x0, y, x) <= rad - 1)
                        {
                                /* inside- so is floor */
-                               place_bold(player_ptr, y, x, floor);
+                               place_bold(player_ptr, y, x, gb_floor);
                        }
                        else if (distance(y0, x0, y, x) <= rad + 1)
                        {
                                /* make granite outside so arena works */
-                               place_bold(player_ptr, y, x, extra);
+                               place_bold(player_ptr, y, x, gb_extra);
                        }
                }
        }
@@ -1001,23 +1001,23 @@ bool build_type12(player_type *player_ptr)
                        if (dist2(y0, x0, y, x, h1, h2, h3, h4) <= rad - 1)
                        {
                                /* inside - so is floor */
-                               place_bold(player_ptr, y, x, floor);
+                               place_bold(player_ptr, y, x, gb_floor);
                        }
                        else if (distance(y0, x0, y, x) < 3)
                        {
-                               place_bold(player_ptr, y, x, floor);
+                               place_bold(player_ptr, y, x, gb_floor);
                        }
                        else
                        {
                                /* make granite outside so arena works */
-                               place_bold(player_ptr, y, x, extra);
+                               place_bold(player_ptr, y, x, gb_extra);
                        }
 
                        /* proper boundary for arena */
                        if (((y + rad) == y0) || ((y - rad) == y0) ||
                                ((x + rad) == x0) || ((x - rad) == x0))
                        {
-                               place_bold(player_ptr, y, x, extra);
+                               place_bold(player_ptr, y, x, gb_extra);
                        }
                }
        }

diff --git a/src/rooms-pitnest.c b/src/rooms-pitnest.c
index 252809d..796c678 100644 (file)
--- a/src/rooms-pitnest.c
+++ b/src/rooms-pitnest.c
@@ -355,7 +355,7 @@ bool build_type5(player_type *player_ptr)
                for (x = x1 - 1; x <= x2 + 1; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                        g_ptr->info |= (CAVE_ROOM);
                }
        }
@@ -364,16 +364,16 @@ bool build_type5(player_type *player_ptr)
        for (y = y1 - 1; y <= y2 + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1 - 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y][x2 + 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
        for (x = x1 - 1; x <= x2 + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1 - 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y2 + 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
 
 
@@ -387,17 +387,17 @@ bool build_type5(player_type *player_ptr)
        for (y = y1 - 1; y <= y2 + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1 - 1];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
                g_ptr = &floor_ptr->grid_array[y][x2 + 1];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
        }
 
        for (x = x1 - 1; x <= x2 + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1 - 1][x];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
                g_ptr = &floor_ptr->grid_array[y2 + 1][x];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
        }
        for (y = y1; y <= y2; y++)
        {
@@ -564,7 +564,7 @@ bool build_type6(player_type *player_ptr)
                for (x = x1 - 1; x <= x2 + 1; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                        g_ptr->info |= (CAVE_ROOM);
                }
        }
@@ -573,16 +573,16 @@ bool build_type6(player_type *player_ptr)
        for (y = y1 - 1; y <= y2 + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1 - 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y][x2 + 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
        for (x = x1 - 1; x <= x2 + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1 - 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y2 + 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
 
        /* Advance to the center room */
@@ -595,16 +595,16 @@ bool build_type6(player_type *player_ptr)
        for (y = y1 - 1; y <= y2 + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1 - 1];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
                g_ptr = &floor_ptr->grid_array[y][x2 + 1];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
        }
        for (x = x1 - 1; x <= x2 + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1 - 1][x];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
                g_ptr = &floor_ptr->grid_array[y2 + 1][x];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
        }
        for (y = y1; y <= y2; y++)
        {
@@ -873,7 +873,7 @@ bool build_type13(player_type *player_ptr)
                for (x = x1 - 1; x <= x2 + 1; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr->info |= (CAVE_ROOM);
                }
        }
@@ -882,11 +882,11 @@ bool build_type13(player_type *player_ptr)
        for (x = x1 + 3; x <= x2 - 3; x++)
        {
                g_ptr = &floor_ptr->grid_array[yval - 2][x];
-               place_grid(player_ptr, g_ptr, floor);
+               place_grid(player_ptr, g_ptr, gb_floor);
                add_cave_info(floor_ptr, yval - 2, x, CAVE_ICKY);
 
                g_ptr = &floor_ptr->grid_array[yval + 2][x];
-               place_grid(player_ptr, g_ptr, floor);
+               place_grid(player_ptr, g_ptr, gb_floor);
                add_cave_info(floor_ptr, yval + 2, x, CAVE_ICKY);
        }
 
@@ -894,11 +894,11 @@ bool build_type13(player_type *player_ptr)
        for (x = x1 + 5; x <= x2 - 5; x++)
        {
                g_ptr = &floor_ptr->grid_array[yval - 3][x];
-               place_grid(player_ptr, g_ptr, floor);
+               place_grid(player_ptr, g_ptr, gb_floor);
                add_cave_info(floor_ptr, yval - 3, x, CAVE_ICKY);
 
                g_ptr = &floor_ptr->grid_array[yval + 3][x];
-               place_grid(player_ptr, g_ptr, floor);
+               place_grid(player_ptr, g_ptr, gb_floor);
                add_cave_info(floor_ptr, yval + 3, x, CAVE_ICKY);
        }
 
@@ -906,27 +906,27 @@ bool build_type13(player_type *player_ptr)
        for (x = x1; x <= x2; x++)
        {
                g_ptr = &floor_ptr->grid_array[yval][x];
-               place_grid(player_ptr, g_ptr, floor);
+               place_grid(player_ptr, g_ptr, gb_floor);
                g_ptr = &floor_ptr->grid_array[y1][x];
-               place_grid(player_ptr, g_ptr, floor);
+               place_grid(player_ptr, g_ptr, gb_floor);
                g_ptr = &floor_ptr->grid_array[y2][x];
-               place_grid(player_ptr, g_ptr, floor);
+               place_grid(player_ptr, g_ptr, gb_floor);
        }
 
        /* Place the outer walls */
        for (y = y1 - 1; y <= y2 + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1 - 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y][x2 + 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
        for (x = x1 - 1; x <= x2 + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1 - 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y2 + 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
 
        /* Random corridor */
@@ -934,26 +934,26 @@ bool build_type13(player_type *player_ptr)
        {
                for (y = y1; y <= yval; y++)
                {
-                       place_bold(player_ptr, y, x2, floor);
-                       place_bold(player_ptr, y, x1 - 1, solid);
+                       place_bold(player_ptr, y, x2, gb_floor);
+                       place_bold(player_ptr, y, x1 - 1, gb_solid);
                }
                for (y = yval; y <= y2 + 1; y++)
                {
-                       place_bold(player_ptr, y, x1, floor);
-                       place_bold(player_ptr, y, x2 + 1, solid);
+                       place_bold(player_ptr, y, x1, gb_floor);
+                       place_bold(player_ptr, y, x2 + 1, gb_solid);
                }
        }
        else
        {
                for (y = yval; y <= y2 + 1; y++)
                {
-                       place_bold(player_ptr, y, x1, floor);
-                       place_bold(player_ptr, y, x2 + 1, solid);
+                       place_bold(player_ptr, y, x1, gb_floor);
+                       place_bold(player_ptr, y, x2 + 1, gb_solid);
                }
                for (y = y1; y <= yval; y++)
                {
-                       place_bold(player_ptr, y, x2, floor);
-                       place_bold(player_ptr, y, x1 - 1, solid);
+                       place_bold(player_ptr, y, x2, gb_floor);
+                       place_bold(player_ptr, y, x1 - 1, gb_solid);
                }
        }
 

diff --git a/src/rooms-special.c b/src/rooms-special.c
index ede0618..a37012f 100644 (file)
--- a/src/rooms-special.c
+++ b/src/rooms-special.c
@@ -48,7 +48,7 @@ bool build_type15(player_type *player_ptr)
                for (x = x1 - 1; x <= x2 + 1; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                        g_ptr->feat = feat_glass_floor;
                        g_ptr->info |= (CAVE_ROOM);
                        if (light) g_ptr->info |= (CAVE_GLOW);
@@ -59,20 +59,20 @@ bool build_type15(player_type *player_ptr)
        for (y = y1 - 1; y <= y2 + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1 - 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr->feat = feat_glass_wall;
                g_ptr = &floor_ptr->grid_array[y][x2 + 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr->feat = feat_glass_wall;
        }
 
        for (x = x1 - 1; x <= x2 + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1 - 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr->feat = feat_glass_wall;
                g_ptr = &floor_ptr->grid_array[y2 + 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr->feat = feat_glass_wall;
        }
 
@@ -96,7 +96,7 @@ bool build_type15(player_type *player_ptr)
                        for (dir2 = 0; dir2 < 8; dir2++)
                        {
                                g_ptr = &floor_ptr->grid_array[y + ddy_ddd[dir2]][x + ddx_ddd[dir2]];
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                                g_ptr->feat = feat_glass_wall;
                        }
                }
@@ -107,7 +107,7 @@ bool build_type15(player_type *player_ptr)
                        y = yval + 2 * ddy_ddd[dir1];
                        x = xval + 2 * ddx_ddd[dir1];
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, inner_perm);
+                       place_grid(player_ptr, g_ptr, gb_inner_perm);
                        g_ptr->feat = feat_permanent_glass_wall;
                        floor_ptr->grid_array[yval + ddy_ddd[dir1]][xval + ddx_ddd[dir1]].info |= (CAVE_ICKY);
                }
@@ -134,19 +134,19 @@ bool build_type15(player_type *player_ptr)
 
                /* Pillars */
                g_ptr = &floor_ptr->grid_array[y1 + 1][x1 + 1];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
                g_ptr->feat = feat_glass_wall;
 
                g_ptr = &floor_ptr->grid_array[y1 + 1][x2 - 1];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
                g_ptr->feat = feat_glass_wall;
 
                g_ptr = &floor_ptr->grid_array[y2 - 1][x1 + 1];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
                g_ptr->feat = feat_glass_wall;
 
                g_ptr = &floor_ptr->grid_array[y2 - 1][x2 - 1];
-               place_grid(player_ptr, g_ptr, inner);
+               place_grid(player_ptr, g_ptr, gb_inner);
                g_ptr->feat = feat_glass_wall;
                get_mon_num_prep(player_ptr, vault_aux_lite, NULL);
 
@@ -157,7 +157,7 @@ bool build_type15(player_type *player_ptr)
                for (dir1 = 0; dir1 < 8; dir1++)
                {
                        g_ptr = &floor_ptr->grid_array[yval + ddy_ddd[dir1]][xval + ddx_ddd[dir1]];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr->feat = feat_glass_wall;
                }
 
@@ -188,27 +188,27 @@ bool build_type15(player_type *player_ptr)
                for (y = yval - 2; y <= yval + 2; y++)
                {
                        g_ptr = &floor_ptr->grid_array[y][xval - 3];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr->feat = feat_glass_wall;
                        g_ptr = &floor_ptr->grid_array[y][xval + 3];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr->feat = feat_glass_wall;
                }
 
                for (x = xval - 2; x <= xval + 2; x++)
                {
                        g_ptr = &floor_ptr->grid_array[yval - 3][x];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr->feat = feat_glass_wall;
                        g_ptr = &floor_ptr->grid_array[yval + 3][x];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr->feat = feat_glass_wall;
                }
 
                for (dir1 = 4; dir1 < 8; dir1++)
                {
                        g_ptr = &floor_ptr->grid_array[yval + 2 * ddy_ddd[dir1]][xval + 2 * ddx_ddd[dir1]];
-                       place_grid(player_ptr, g_ptr, inner);
+                       place_grid(player_ptr, g_ptr, gb_inner);
                        g_ptr->feat = feat_glass_wall;
                }
 

diff --git a/src/rooms-trap.c b/src/rooms-trap.c
index 1ec4b6c..72e35d9 100644 (file)
--- a/src/rooms-trap.c
+++ b/src/rooms-trap.c
@@ -55,7 +55,7 @@ bool build_type14(player_type *player_ptr)
                for (x = x1 - 1; x <= x2 + 1; x++)
                {
                        g_ptr = &floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                        g_ptr->info |= (CAVE_ROOM);
                        if (light) g_ptr->info |= (CAVE_GLOW);
                }
@@ -65,16 +65,16 @@ bool build_type14(player_type *player_ptr)
        for (y = y1 - 1; y <= y2 + 1; y++)
        {
                g_ptr = &floor_ptr->grid_array[y][x1 - 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y][x2 + 1];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
        for (x = x1 - 1; x <= x2 + 1; x++)
        {
                g_ptr = &floor_ptr->grid_array[y1 - 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
                g_ptr = &floor_ptr->grid_array[y2 + 1][x];
-               place_grid(player_ptr, g_ptr, outer);
+               place_grid(player_ptr, g_ptr, gb_outer);
        }
 
        if (floor_ptr->dun_level < 30 + randint1(30))

diff --git a/src/rooms-vault.c b/src/rooms-vault.c
index 40498e1..379dc65 100644 (file)
--- a/src/rooms-vault.c
+++ b/src/rooms-vault.c
@@ -88,9 +88,9 @@ static void build_bubble_vault(player_type *player_ptr, POSITION x0, POSITION y0
        {
                int side_x = x0 - xhsize + i;
 
-               place_bold(player_ptr, y0 - yhsize + 0, side_x, outer_noperm);
+               place_bold(player_ptr, y0 - yhsize + 0, side_x, gb_outer_noperm);
                floor_ptr->grid_array[y0 - yhsize + 0][side_x].info |= (CAVE_ROOM | CAVE_ICKY);
-               place_bold(player_ptr, y0 - yhsize + ysize - 1, side_x, outer_noperm);
+               place_bold(player_ptr, y0 - yhsize + ysize - 1, side_x, gb_outer_noperm);
                floor_ptr->grid_array[y0 - yhsize + ysize - 1][side_x].info |= (CAVE_ROOM | CAVE_ICKY);
        }
 
@@ -99,9 +99,9 @@ static void build_bubble_vault(player_type *player_ptr, POSITION x0, POSITION y0
        {
                int side_y = y0 - yhsize + i;
 
-               place_bold(player_ptr, side_y, x0 - xhsize + 0, outer_noperm);
+               place_bold(player_ptr, side_y, x0 - xhsize + 0, gb_outer_noperm);
                floor_ptr->grid_array[side_y][x0 - xhsize + 0].info |= (CAVE_ROOM | CAVE_ICKY);
-               place_bold(player_ptr, side_y, x0 - xhsize + xsize - 1, outer_noperm);
+               place_bold(player_ptr, side_y, x0 - xhsize + xsize - 1, gb_outer_noperm);
                floor_ptr->grid_array[side_y][x0 - xhsize + xsize - 1].info |= (CAVE_ROOM | CAVE_ICKY);
        }
 
@@ -143,12 +143,12 @@ static void build_bubble_vault(player_type *player_ptr, POSITION x0, POSITION y0
                        if (((min2 - min1) <= 2) && (!(min1 < 3)))
                        {
                                /* Boundary at midpoint+ not at inner region of bubble */
-                               place_bold(player_ptr, y0 - yhsize + y, x0 - xhsize + x, outer_noperm);
+                               place_bold(player_ptr, y0 - yhsize + y, x0 - xhsize + x, gb_outer_noperm);
                        }
                        else
                        {
                                /* middle of a bubble */
-                               place_bold(player_ptr, y0 - yhsize + y, x0 - xhsize + x, floor);
+                               place_bold(player_ptr, y0 - yhsize + y, x0 - xhsize + x, gb_floor);
                        }
 
                        /* clean up rest of flags */
@@ -190,7 +190,7 @@ static void build_room_vault(player_type *player_ptr, POSITION x0, POSITION y0,
                {
                        POSITION y = y0 - yhsize + y1;
 
-                       place_bold(player_ptr, y, x, extra);
+                       place_bold(player_ptr, y, x, gb_extra);
                        floor_ptr->grid_array[y][x].info &= (~CAVE_ICKY);
                }
        }
@@ -364,7 +364,7 @@ static void build_vault(player_type *player_ptr, POSITION yval, POSITION xval, P
                        g_ptr = &floor_ptr->grid_array[y][x];
 
                        /* Lay down a floor */
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
 
                        /* Remove any mimic */
                        g_ptr->mimic = 0;
@@ -377,28 +377,28 @@ static void build_vault(player_type *player_ptr, POSITION yval, POSITION xval, P
                        {
                                /* Granite wall (outer) */
                        case '%':
-                               place_grid(player_ptr, g_ptr, outer_noperm);
+                               place_grid(player_ptr, g_ptr, gb_outer_noperm);
                                break;
 
                                /* Granite wall (inner) */
                        case '#':
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                                break;
 
                                /* Glass wall (inner) */
                        case '$':
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                                g_ptr->feat = feat_glass_wall;
                                break;
 
                                /* Permanent wall (inner) */
                        case 'X':
-                               place_grid(player_ptr, g_ptr, inner_perm);
+                               place_grid(player_ptr, g_ptr, gb_inner_perm);
                                break;
 
                                /* Permanent glass wall (inner) */
                        case 'Y':
-                               place_grid(player_ptr, g_ptr, inner_perm);
+                               place_grid(player_ptr, g_ptr, gb_inner_perm);
                                g_ptr->feat = feat_permanent_glass_wall;
                                break;
 
@@ -848,19 +848,19 @@ static void build_target_vault(player_type *player_ptr, POSITION x0, POSITION y0
                        if (dist2(y0, x0, y, x, h1, h2, h3, h4) <= rad - 1)
                        {
                                /* inside- so is floor */
-                               place_bold(player_ptr, y, x, floor);
+                               place_bold(player_ptr, y, x, gb_floor);
                        }
                        else
                        {
                                /* make granite outside so arena works */
-                               place_bold(player_ptr, y, x, extra);
+                               place_bold(player_ptr, y, x, gb_extra);
                        }
 
                        /* proper boundary for arena */
                        if (((y + rad) == y0) || ((y - rad) == y0) ||
                                ((x + rad) == x0) || ((x - rad) == x0))
                        {
-                               place_bold(player_ptr, y, x, extra);
+                               place_bold(player_ptr, y, x, gb_extra);
                        }
                }
        }
@@ -876,7 +876,7 @@ static void build_target_vault(player_type *player_ptr, POSITION x0, POSITION y0
                        if (dist2(y0, x0, y, x, h1, h2, h3, h4) == rad / 2)
                        {
                                /* Make an internal wall */
-                               place_bold(player_ptr, y, x, inner);
+                               place_bold(player_ptr, y, x, gb_inner);
                        }
                }
        }
@@ -884,27 +884,27 @@ static void build_target_vault(player_type *player_ptr, POSITION x0, POSITION y0
        /* Add perpendicular walls */
        for (x = x0 - rad; x <= x0 + rad; x++)
        {
-               place_bold(player_ptr, y0, x, inner);
+               place_bold(player_ptr, y0, x, gb_inner);
        }
 
        for (y = y0 - rad; y <= y0 + rad; y++)
        {
-               place_bold(player_ptr, y, x0, inner);
+               place_bold(player_ptr, y, x0, gb_inner);
        }
 
        /* Make inner vault */
        for (y = y0 - 1; y <= y0 + 1; y++)
        {
-               place_bold(player_ptr, y, x0 - 1, inner);
-               place_bold(player_ptr, y, x0 + 1, inner);
+               place_bold(player_ptr, y, x0 - 1, gb_inner);
+               place_bold(player_ptr, y, x0 + 1, gb_inner);
        }
        for (x = x0 - 1; x <= x0 + 1; x++)
        {
-               place_bold(player_ptr, y0 - 1, x, inner);
-               place_bold(player_ptr, y0 + 1, x, inner);
+               place_bold(player_ptr, y0 - 1, x, gb_inner);
+               place_bold(player_ptr, y0 + 1, x, gb_inner);
        }
 
-       place_bold(player_ptr, y0, x0, floor);
+       place_bold(player_ptr, y0, x0, gb_floor);
 
 
        /* Add doors to vault */
@@ -1055,7 +1055,7 @@ static void build_mini_c_vault(player_type *player_ptr, POSITION x0, POSITION y0
 
                floor_ptr->grid_array[y1 - 2][x].info |= (CAVE_ROOM | CAVE_ICKY);
 
-               place_bold(player_ptr, y1 - 2, x, outer_noperm);
+               place_bold(player_ptr, y1 - 2, x, gb_outer_noperm);
        }
 
        for (x = x1 - 2; x <= x2 + 2; x++)
@@ -1064,7 +1064,7 @@ static void build_mini_c_vault(player_type *player_ptr, POSITION x0, POSITION y0
 
                floor_ptr->grid_array[y2 + 2][x].info |= (CAVE_ROOM | CAVE_ICKY);
 
-               place_bold(player_ptr, y2 + 2, x, outer_noperm);
+               place_bold(player_ptr, y2 + 2, x, gb_outer_noperm);
        }
 
        for (y = y1 - 2; y <= y2 + 2; y++)
@@ -1073,7 +1073,7 @@ static void build_mini_c_vault(player_type *player_ptr, POSITION x0, POSITION y0
 
                floor_ptr->grid_array[y][x1 - 2].info |= (CAVE_ROOM | CAVE_ICKY);
 
-               place_bold(player_ptr, y, x1 - 2, outer_noperm);
+               place_bold(player_ptr, y, x1 - 2, gb_outer_noperm);
        }
 
        for (y = y1 - 2; y <= y2 + 2; y++)
@@ -1082,7 +1082,7 @@ static void build_mini_c_vault(player_type *player_ptr, POSITION x0, POSITION y0
 
                floor_ptr->grid_array[y][x2 + 2].info |= (CAVE_ROOM | CAVE_ICKY);
 
-               place_bold(player_ptr, y, x2 + 2, outer_noperm);
+               place_bold(player_ptr, y, x2 + 2, gb_outer_noperm);
        }
 
        for (y = y1 - 1; y <= y2 + 1; y++)
@@ -1094,7 +1094,7 @@ static void build_mini_c_vault(player_type *player_ptr, POSITION x0, POSITION y0
                        g_ptr->info |= (CAVE_ROOM | CAVE_ICKY);
 
                        /* Permanent walls */
-                       place_grid(player_ptr, g_ptr, inner_perm);
+                       place_grid(player_ptr, g_ptr, gb_inner_perm);
                }
        }
 
@@ -1119,7 +1119,7 @@ static void build_mini_c_vault(player_type *player_ptr, POSITION x0, POSITION y0
                        /* If total is odd- and is a floor then make a wall */
                        if ((total % 2 == 1) && is_floor_bold(floor_ptr, y, x))
                        {
-                               place_bold(player_ptr, y, x, inner);
+                               place_bold(player_ptr, y, x, gb_inner);
                        }
                }
        }
@@ -1129,15 +1129,15 @@ static void build_mini_c_vault(player_type *player_ptr, POSITION x0, POSITION y0
        {
                /* left and right */
                y = randint1(dy) + dy / 2;
-               place_bold(player_ptr, y1 + y, x1 - 1, inner);
-               place_bold(player_ptr, y1 + y, x2 + 1, inner);
+               place_bold(player_ptr, y1 + y, x1 - 1, gb_inner);
+               place_bold(player_ptr, y1 + y, x2 + 1, gb_inner);
        }
        else
        {
                /* top and bottom */
                x = randint1(dx) + dx / 2;
-               place_bold(player_ptr, y1 - 1, x1 + x, inner);
-               place_bold(player_ptr, y2 + 1, x1 + x, inner);
+               place_bold(player_ptr, y1 - 1, x1 + x, gb_inner);
+               place_bold(player_ptr, y2 + 1, x1 + x, gb_inner);
        }
 
        /* Fill with monsters and treasure, highest difficulty */
@@ -1177,7 +1177,7 @@ static void build_castle_vault(player_type *player_ptr, POSITION x0, POSITION y0
                {
                        floor_ptr->grid_array[y][x].info |= (CAVE_ROOM | CAVE_ICKY);
                        /* Make everything a floor */
-                       place_bold(player_ptr, y, x, floor);
+                       place_bold(player_ptr, y, x, gb_floor);
                }
        }
 

diff --git a/src/rooms.c b/src/rooms.c
index e3a9c4c..a88ef89 100644 (file)
--- a/src/rooms.c
+++ b/src/rooms.c
@@ -139,14 +139,14 @@ void build_small_room(player_type *player_ptr, POSITION x0, POSITION y0)
        floor_type *floor_ptr = player_ptr->current_floor_ptr;
        for (y = y0 - 1; y <= y0 + 1; y++)
        {
-               place_bold(player_ptr, y, x0 - 1, inner);
-               place_bold(player_ptr, y, x0 + 1, inner);
+               place_bold(player_ptr, y, x0 - 1, gb_inner);
+               place_bold(player_ptr, y, x0 + 1, gb_inner);
        }
 
        for (x = x0 - 1; x <= x0 + 1; x++)
        {
-               place_bold(player_ptr, y0 - 1, x, inner);
-               place_bold(player_ptr, y0 + 1, x, inner);
+               place_bold(player_ptr, y0 - 1, x, gb_inner);
+               place_bold(player_ptr, y0 + 1, x, gb_inner);
        }
 
        /* Place a secret door on one side */
@@ -162,7 +162,7 @@ void build_small_room(player_type *player_ptr, POSITION x0, POSITION y0)
        floor_ptr->grid_array[y0][x0].mimic = 0;
 
        /* Add inner open space */
-       place_bold(player_ptr, y0, x0, floor);
+       place_bold(player_ptr, y0, x0, gb_floor);
 }
 
 /*!
@@ -832,7 +832,7 @@ static bool hack_isnt_wall(player_type *player_ptr, POSITION y, POSITION x, int
                /* if greater than cutoff then is a wall */
                else
                {
-                       place_bold(player_ptr, y, x, outer);
+                       place_bold(player_ptr, y, x, gb_outer);
                        return FALSE;
                }
        }
@@ -971,7 +971,7 @@ bool generate_fracave(player_type *player_ptr, POSITION y0, POSITION x0, POSITIO
                {
                        for (y = 0; y <= ysize; ++y)
                        {
-                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, extra);
+                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, gb_extra);
                                floor_ptr->grid_array[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY | CAVE_ROOM);
                        }
                }
@@ -989,30 +989,30 @@ bool generate_fracave(player_type *player_ptr, POSITION y0, POSITION x0, POSITIO
                if ((floor_ptr->grid_array[0 + y0 - yhsize][i + x0 - xhsize].info & CAVE_ICKY) && (room))
                {
                        /* Next to a 'filled' region? - set to be room walls */
-                       place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, outer);
+                       place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, gb_outer);
                        if (light) floor_ptr->grid_array[y0 + 0 - yhsize][x0 + i - xhsize].info |= (CAVE_GLOW);
                        floor_ptr->grid_array[y0 + 0 - yhsize][x0 + i - xhsize].info |= (CAVE_ROOM);
-                       place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, outer);
+                       place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, gb_outer);
                }
                else
                {
                        /* set to be normal granite */
-                       place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, extra);
+                       place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, gb_extra);
                }
 
                /* bottom boundary */
                if ((floor_ptr->grid_array[ysize + y0 - yhsize][i + x0 - xhsize].info & CAVE_ICKY) && (room))
                {
                        /* Next to a 'filled' region? - set to be room walls */
-                       place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, outer);
+                       place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, gb_outer);
                        if (light) floor_ptr->grid_array[y0 + ysize - yhsize][x0 + i - xhsize].info |= (CAVE_GLOW);
                        floor_ptr->grid_array[y0 + ysize - yhsize][x0 + i - xhsize].info |= (CAVE_ROOM);
-                       place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, outer);
+                       place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, gb_outer);
                }
                else
                {
                        /* set to be normal granite */
-                       place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, extra);
+                       place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, gb_extra);
                }
 
                /* clear the icky flag-don't need it any more */
@@ -1027,29 +1027,29 @@ bool generate_fracave(player_type *player_ptr, POSITION y0, POSITION x0, POSITIO
                if ((floor_ptr->grid_array[i + y0 - yhsize][0 + x0 - xhsize].info & CAVE_ICKY) && room)
                {
                        /* room boundary */
-                       place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, outer);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, gb_outer);
                        if (light) floor_ptr->grid_array[y0 + i - yhsize][x0 + 0 - xhsize].info |= (CAVE_GLOW);
                        floor_ptr->grid_array[y0 + i - yhsize][x0 + 0 - xhsize].info |= (CAVE_ROOM);
-                       place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, outer);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, gb_outer);
                }
                else
                {
                        /* outside room */
-                       place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, extra);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, gb_extra);
                }
                /* right boundary */
                if ((floor_ptr->grid_array[i + y0 - yhsize][xsize + x0 - xhsize].info & CAVE_ICKY) && room)
                {
                        /* room boundary */
-                       place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, outer);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, gb_outer);
                        if (light) floor_ptr->grid_array[y0 + i - yhsize][x0 + xsize - xhsize].info |= (CAVE_GLOW);
                        floor_ptr->grid_array[y0 + i - yhsize][x0 + xsize - xhsize].info |= (CAVE_ROOM);
-                       place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, outer);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, gb_outer);
                }
                else
                {
                        /* outside room */
-                       place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, extra);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, gb_extra);
                }
 
                /* clear icky flag -done with it */
@@ -1086,14 +1086,14 @@ bool generate_fracave(player_type *player_ptr, POSITION y0, POSITION x0, POSITIO
                                else
                                {
 
-                                       place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, extra);
+                                       place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, gb_extra);
                                        floor_ptr->grid_array[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ROOM);
                                }
                        }
                        else
                        {
                                /* Clear the unconnected regions */
-                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, extra);
+                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, gb_extra);
                                floor_ptr->grid_array[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY | CAVE_ROOM);
                        }
                }
@@ -1245,7 +1245,7 @@ bool generate_lake(player_type *player_ptr, POSITION y0, POSITION x0, POSITION x
                {
                        for (y = 0; y <= ysize; ++y)
                        {
-                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, floor);
+                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, gb_floor);
                                floor_ptr->grid_array[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY);
                        }
                }
@@ -1255,8 +1255,8 @@ bool generate_lake(player_type *player_ptr, POSITION y0, POSITION x0, POSITION x
        /* Do boundarys- set to normal granite */
        for (i = 0; i <= xsize; ++i)
        {
-               place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, extra);
-               place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, extra);
+               place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, gb_extra);
+               place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, gb_extra);
 
                /* clear the icky flag-don't need it any more */
                floor_ptr->grid_array[y0 + 0 - yhsize][x0 + i - xhsize].info &= ~(CAVE_ICKY);
@@ -1267,8 +1267,8 @@ bool generate_lake(player_type *player_ptr, POSITION y0, POSITION x0, POSITION x
 
        for (i = 1; i < ysize; ++i)
        {
-               place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, extra);
-               place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, extra);
+               place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, gb_extra);
+               place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, gb_extra);
 
                /* clear icky flag -done with it */
                floor_ptr->grid_array[y0 + i - yhsize][x0 + 0 - xhsize].info &= ~(CAVE_ICKY);
@@ -1284,7 +1284,7 @@ bool generate_lake(player_type *player_ptr, POSITION y0, POSITION x0, POSITION x
                        /* Fill unconnected regions with granite */
                        if ((!(floor_ptr->grid_array[y0 + y - yhsize][x0 + x - xhsize].info & CAVE_ICKY)) ||
                                is_outer_bold(floor_ptr, y0 + y - yhsize, x0 + x - xhsize))
-                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, extra);
+                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, gb_extra);
 
                        /* turn off icky flag (no longer needed.) */
                        floor_ptr->grid_array[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ICKY | CAVE_ROOM);
@@ -1531,18 +1531,18 @@ void build_room(player_type *player_ptr, POSITION x1, POSITION x2, POSITION y1,
        floor_type *floor_ptr = player_ptr->current_floor_ptr;
        for (i = 0; i <= xsize; i++)
        {
-               place_bold(player_ptr, y1, x1 + i, outer_noperm);
+               place_bold(player_ptr, y1, x1 + i, gb_outer_noperm);
                floor_ptr->grid_array[y1][x1 + i].info |= (CAVE_ROOM | CAVE_ICKY);
-               place_bold(player_ptr, y2, x1 + i, outer_noperm);
+               place_bold(player_ptr, y2, x1 + i, gb_outer_noperm);
                floor_ptr->grid_array[y2][x1 + i].info |= (CAVE_ROOM | CAVE_ICKY);
        }
 
        /* Left and right boundaries */
        for (i = 1; i < ysize; i++)
        {
-               place_bold(player_ptr, y1 + i, x1, outer_noperm);
+               place_bold(player_ptr, y1 + i, x1, gb_outer_noperm);
                floor_ptr->grid_array[y1 + i][x1].info |= (CAVE_ROOM | CAVE_ICKY);
-               place_bold(player_ptr, y1 + i, x2, outer_noperm);
+               place_bold(player_ptr, y1 + i, x2, gb_outer_noperm);
                floor_ptr->grid_array[y1 + i][x2].info |= (CAVE_ROOM | CAVE_ICKY);
        }
 
@@ -1554,7 +1554,7 @@ void build_room(player_type *player_ptr, POSITION x1, POSITION x2, POSITION y1,
                        if (is_extra_bold(floor_ptr, y1 + y, x1 + x))
                        {
                                /* clear the untouched region */
-                               place_bold(player_ptr, y1 + y, x1 + x, floor);
+                               place_bold(player_ptr, y1 + y, x1 + x, gb_floor);
                                floor_ptr->grid_array[y1 + y][x1 + x].info |= (CAVE_ROOM | CAVE_ICKY);
                        }
                        else
@@ -1598,7 +1598,7 @@ void r_visit(player_type *player_ptr, POSITION y1, POSITION x1, POSITION y2, POS
        visited[node] = 1;
        x = 2 * (node % m) + x1;
        y = 2 * (node / m) + y1;
-       place_bold(player_ptr, y, x, floor);
+       place_bold(player_ptr, y, x, gb_floor);
 
        /* setup order of adjacent node visits */
        if (one_in_(3))
@@ -1638,7 +1638,7 @@ void r_visit(player_type *player_ptr, POSITION y1, POSITION x1, POSITION y2, POS
                        /* (0,+) - check for bottom boundary */
                        if ((node / m < n - 1) && (visited[node + m] == 0))
                        {
-                               place_bold(player_ptr, y + 1, x, floor);
+                               place_bold(player_ptr, y + 1, x, gb_floor);
                                r_visit(player_ptr, y1, x1, y2, x2, node + m, dir, visited);
                        }
                        break;
@@ -1646,7 +1646,7 @@ void r_visit(player_type *player_ptr, POSITION y1, POSITION x1, POSITION y2, POS
                        /* (0,-) - check for top boundary */
                        if ((node / m > 0) && (visited[node - m] == 0))
                        {
-                               place_bold(player_ptr, y - 1, x, floor);
+                               place_bold(player_ptr, y - 1, x, gb_floor);
                                r_visit(player_ptr, y1, x1, y2, x2, node - m, dir, visited);
                        }
                        break;
@@ -1654,7 +1654,7 @@ void r_visit(player_type *player_ptr, POSITION y1, POSITION x1, POSITION y2, POS
                        /* (+,0) - check for right boundary */
                        if ((node % m < m - 1) && (visited[node + 1] == 0))
                        {
-                               place_bold(player_ptr, y, x + 1, floor);
+                               place_bold(player_ptr, y, x + 1, gb_floor);
                                r_visit(player_ptr, y1, x1, y2, x2, node + 1, dir, visited);
                        }
                        break;
@@ -1662,7 +1662,7 @@ void r_visit(player_type *player_ptr, POSITION y1, POSITION x1, POSITION y2, POS
                        /* (-,0) - check for left boundary */
                        if ((node % m > 0) && (visited[node - 1] == 0))
                        {
-                               place_bold(player_ptr, y, x - 1, floor);
+                               place_bold(player_ptr, y, x - 1, gb_floor);
                                r_visit(player_ptr, y1, x1, y2, x2, node - 1, dir, visited);
                        }
                } /* end switch */
@@ -1703,15 +1703,15 @@ void build_maze_vault(player_type *player_ptr, POSITION x0, POSITION y0, POSITIO
                        if (is_vault) g_ptr->info |= CAVE_ICKY;
                        if ((x == x1 - 1) || (x == x2 + 1) || (y == y1 - 1) || (y == y2 + 1))
                        {
-                               place_grid(player_ptr, g_ptr, outer);
+                               place_grid(player_ptr, g_ptr, gb_outer);
                        }
                        else if (!is_vault)
                        {
-                               place_grid(player_ptr, g_ptr, extra);
+                               place_grid(player_ptr, g_ptr, gb_extra);
                        }
                        else
                        {
-                               place_grid(player_ptr, g_ptr, inner);
+                               place_grid(player_ptr, g_ptr, gb_inner);
                        }
                        if (light) g_ptr->info |= (CAVE_GLOW);
                }
@@ -1790,15 +1790,15 @@ void build_recursive_room(player_type *player_ptr, POSITION x1, POSITION y1, POS
                /* top and bottom */
                for (x = x1; x <= x2; x++)
                {
-                       place_bold(player_ptr, y1, x, outer);
-                       place_bold(player_ptr, y2, x, outer);
+                       place_bold(player_ptr, y1, x, gb_outer);
+                       place_bold(player_ptr, y2, x, gb_outer);
                }
 
                /* left and right */
                for (y = y1 + 1; y < y2; y++)
                {
-                       place_bold(player_ptr, y, x1, outer);
-                       place_bold(player_ptr, y, x2, outer);
+                       place_bold(player_ptr, y, x1, gb_outer);
+                       place_bold(player_ptr, y, x2, gb_outer);
                }
 
                /* Make a couple of entrances */
@@ -1806,15 +1806,15 @@ void build_recursive_room(player_type *player_ptr, POSITION x1, POSITION y1, POS
                {
                        /* left and right */
                        y = randint1(ysize) + y1;
-                       place_bold(player_ptr, y, x1, floor);
-                       place_bold(player_ptr, y, x2, floor);
+                       place_bold(player_ptr, y, x1, gb_floor);
+                       place_bold(player_ptr, y, x2, gb_floor);
                }
                else
                {
                        /* top and bottom */
                        x = randint1(xsize) + x1;
-                       place_bold(player_ptr, y1, x, floor);
-                       place_bold(player_ptr, y2, x, floor);
+                       place_bold(player_ptr, y1, x, gb_floor);
+                       place_bold(player_ptr, y2, x, gb_floor);
                }
 
                /* Select size of keep */
@@ -1853,7 +1853,7 @@ void build_recursive_room(player_type *player_ptr, POSITION x1, POSITION y1, POS
                        {
                                for (x = x1; x < x2; x++)
                                {
-                                       place_bold(player_ptr, y, x, inner);
+                                       place_bold(player_ptr, y, x, gb_inner);
                                }
                        }
 
@@ -1865,15 +1865,15 @@ void build_recursive_room(player_type *player_ptr, POSITION x1, POSITION y1, POS
                /* top and bottom */
                for (x = x1 + 1; x <= x2 - 1; x++)
                {
-                       place_bold(player_ptr, y1 + 1, x, inner);
-                       place_bold(player_ptr, y2 - 1, x, inner);
+                       place_bold(player_ptr, y1 + 1, x, gb_inner);
+                       place_bold(player_ptr, y2 - 1, x, gb_inner);
                }
 
                /* left and right */
                for (y = y1 + 1; y <= y2 - 1; y++)
                {
-                       place_bold(player_ptr, y, x1 + 1, inner);
-                       place_bold(player_ptr, y, x2 - 1, inner);
+                       place_bold(player_ptr, y, x1 + 1, gb_inner);
+                       place_bold(player_ptr, y, x2 - 1, gb_inner);
                }
 
                /* Make a door */
@@ -1882,12 +1882,12 @@ void build_recursive_room(player_type *player_ptr, POSITION x1, POSITION y1, POS
                if (one_in_(2))
                {
                        /* left */
-                       place_bold(player_ptr, y, x1 + 1, floor);
+                       place_bold(player_ptr, y, x1 + 1, gb_floor);
                }
                else
                {
                        /* right */
-                       place_bold(player_ptr, y, x2 - 1, floor);
+                       place_bold(player_ptr, y, x2 - 1, gb_floor);
                }
 
                /* Build the room */
@@ -1904,7 +1904,7 @@ void build_recursive_room(player_type *player_ptr, POSITION x1, POSITION y1, POS
                        {
                                for (x = x1; x < x2; x++)
                                {
-                                       place_bold(player_ptr, y, x, inner);
+                                       place_bold(player_ptr, y, x, gb_inner);
                                }
                        }
                        return;
@@ -1925,7 +1925,7 @@ void build_recursive_room(player_type *player_ptr, POSITION x1, POSITION y1, POS
                        {
                                for (x = x1; x < x2; x++)
                                {
-                                       place_bold(player_ptr, y, x, inner);
+                                       place_bold(player_ptr, y, x, gb_inner);
                                }
                        }
                        return;
@@ -1982,7 +1982,7 @@ void add_outer_wall(player_type *player_ptr, POSITION x, POSITION y, int light,
        else if (is_extra_bold(floor_ptr, y, x))
        {
                /* Set bounding walls */
-               place_bold(player_ptr, y, x, outer);
+               place_bold(player_ptr, y, x, gb_outer);
                if (light) g_ptr->info |= CAVE_GLOW;
        }
        else if (permanent_wall(f_ptr))
@@ -2034,7 +2034,7 @@ void generate_room_floor(player_type *player_ptr, POSITION y1, POSITION x1, POSI
                {
                        /* Point to grid */
                        g_ptr = &player_ptr->current_floor_ptr->grid_array[y][x];
-                       place_grid(player_ptr, g_ptr, floor);
+                       place_grid(player_ptr, g_ptr, gb_floor);
                        g_ptr->info |= (CAVE_ROOM);
                        if (light) g_ptr->info |= (CAVE_GLOW);
                }
@@ -2050,7 +2050,7 @@ void generate_fill_perm_bold(player_type *player_ptr, POSITION y1, POSITION x1,
                for (x = x1; x <= x2; x++)
                {
                        /* Point to grid */
-                       place_bold(player_ptr, y, x, inner_perm);
+                       place_bold(player_ptr, y, x, gb_inner_perm);
                }
        }
 }

diff --git a/src/spells-floor.c b/src/spells-floor.c
index 55ba2c5..1a3099c 100644 (file)
--- a/src/spells-floor.c
+++ b/src/spells-floor.c
@@ -605,7 +605,7 @@ bool destroy_area(player_type *caster_ptr, POSITION y1, POSITION x1, POSITION r,
                        if (t < 20)
                        {
                                /* Create granite wall */
-                               place_grid(caster_ptr, g_ptr, extra);
+                               place_grid(caster_ptr, g_ptr, gb_extra);
                        }
                        else if (t < 70)
                        {
@@ -620,7 +620,7 @@ bool destroy_area(player_type *caster_ptr, POSITION y1, POSITION x1, POSITION r,
                        else
                        {
                                /* Create floor */
-                               place_grid(caster_ptr, g_ptr, floor);
+                               place_grid(caster_ptr, g_ptr, gb_floor);
                        }
 
                        /* Clear garbage of hidden trap or door */