[Refactor] #38997 place_outer_noperm_bold() を削除し、place_grid() に統合 / Removed place_out...

[hengband/hengband.git] / src / rooms.c

diff --git a/src/rooms.c b/src/rooms.c
index a03c45e..e3a9c4c 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_inner_bold(player_ptr, y, x0 - 1);
-               place_inner_bold(player_ptr, y, x0 + 1);
+               place_bold(player_ptr, y, x0 - 1, inner);
+               place_bold(player_ptr, y, x0 + 1, inner);
        }
 
        for (x = x0 - 1; x <= x0 + 1; x++)
        {
-               place_inner_bold(player_ptr, y0 - 1, x);
-               place_inner_bold(player_ptr, y0 + 1, x);
+               place_bold(player_ptr, y0 - 1, x, inner);
+               place_bold(player_ptr, y0 + 1, x, 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_floor_bold(player_ptr, y0, x0);
+       place_bold(player_ptr, y0, x0, 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_outer_bold(player_ptr, y, x);
+                       place_bold(player_ptr, y, x, 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_extra_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize);
+                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, 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_outer_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize);
+                       place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, 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_outer_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize);
+                       place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, outer);
                }
                else
                {
                        /* set to be normal granite */
-                       place_extra_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize);
+                       place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, 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_outer_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize);
+                       place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, 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_outer_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize);
+                       place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, outer);
                }
                else
                {
                        /* set to be normal granite */
-                       place_extra_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize);
+                       place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, 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_outer_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, 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_outer_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, outer);
                }
                else
                {
                        /* outside room */
-                       place_extra_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, extra);
                }
                /* right boundary */
                if ((floor_ptr->grid_array[i + y0 - yhsize][xsize + x0 - xhsize].info & CAVE_ICKY) && room)
                {
                        /* room boundary */
-                       place_outer_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, 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_outer_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, outer);
                }
                else
                {
                        /* outside room */
-                       place_extra_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize);
+                       place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, 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_extra_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize);
+                                       place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, extra);
                                        floor_ptr->grid_array[y0 + y - yhsize][x0 + x - xhsize].info &= ~(CAVE_ROOM);
                                }
                        }
                        else
                        {
                                /* Clear the unconnected regions */
-                               place_extra_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize);
+                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, 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_floor_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize);
+                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, 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_extra_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize);
-               place_extra_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize);
+               place_bold(player_ptr, y0 + 0 - yhsize, x0 + i - xhsize, extra);
+               place_bold(player_ptr, y0 + ysize - yhsize, x0 + i - xhsize, 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_extra_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize);
-               place_extra_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize);
+               place_bold(player_ptr, y0 + i - yhsize, x0 + 0 - xhsize, extra);
+               place_bold(player_ptr, y0 + i - yhsize, x0 + xsize - xhsize, 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_extra_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize);
+                               place_bold(player_ptr, y0 + y - yhsize, x0 + x - xhsize, 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_outer_noperm_bold(player_ptr, y1, x1 + i);
+               place_bold(player_ptr, y1, x1 + i, outer_noperm);
                floor_ptr->grid_array[y1][x1 + i].info |= (CAVE_ROOM | CAVE_ICKY);
-               place_outer_noperm_bold(player_ptr, y2, x1 + i);
+               place_bold(player_ptr, y2, x1 + i, 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_outer_noperm_bold(player_ptr, y1 + i, x1);
+               place_bold(player_ptr, y1 + i, x1, outer_noperm);
                floor_ptr->grid_array[y1 + i][x1].info |= (CAVE_ROOM | CAVE_ICKY);
-               place_outer_noperm_bold(player_ptr, y1 + i, x2);
+               place_bold(player_ptr, y1 + i, x2, 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_floor_bold(player_ptr, y1 + y, x1 + x);
+                               place_bold(player_ptr, y1 + y, x1 + x, 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_floor_bold(player_ptr, y, x);
+       place_bold(player_ptr, y, x, 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_floor_bold(player_ptr, y + 1, x);
+                               place_bold(player_ptr, y + 1, x, 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_floor_bold(player_ptr, y - 1, x);
+                               place_bold(player_ptr, y - 1, x, 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_floor_bold(player_ptr, y, x + 1);
+                               place_bold(player_ptr, y, x + 1, 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_floor_bold(player_ptr, y, x - 1);
+                               place_bold(player_ptr, y, x - 1, floor);
                                r_visit(player_ptr, y1, x1, y2, x2, node - 1, dir, visited);
                        }
                } /* end switch */
@@ -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_outer_bold(player_ptr, y1, x);
-                       place_outer_bold(player_ptr, y2, x);
+                       place_bold(player_ptr, y1, x, outer);
+                       place_bold(player_ptr, y2, x, outer);
                }
 
                /* left and right */
                for (y = y1 + 1; y < y2; y++)
                {
-                       place_outer_bold(player_ptr, y, x1);
-                       place_outer_bold(player_ptr, y, x2);
+                       place_bold(player_ptr, y, x1, outer);
+                       place_bold(player_ptr, y, x2, 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_floor_bold(player_ptr, y, x1);
-                       place_floor_bold(player_ptr, y, x2);
+                       place_bold(player_ptr, y, x1, floor);
+                       place_bold(player_ptr, y, x2, floor);
                }
                else
                {
                        /* top and bottom */
                        x = randint1(xsize) + x1;
-                       place_floor_bold(player_ptr, y1, x);
-                       place_floor_bold(player_ptr, y2, x);
+                       place_bold(player_ptr, y1, x, floor);
+                       place_bold(player_ptr, y2, x, 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_inner_bold(player_ptr, y, x);
+                                       place_bold(player_ptr, y, x, 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_inner_bold(player_ptr, y1 + 1, x);
-                       place_inner_bold(player_ptr, y2 - 1, x);
+                       place_bold(player_ptr, y1 + 1, x, inner);
+                       place_bold(player_ptr, y2 - 1, x, inner);
                }
 
                /* left and right */
                for (y = y1 + 1; y <= y2 - 1; y++)
                {
-                       place_inner_bold(player_ptr, y, x1 + 1);
-                       place_inner_bold(player_ptr, y, x2 - 1);
+                       place_bold(player_ptr, y, x1 + 1, inner);
+                       place_bold(player_ptr, y, x2 - 1, 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_floor_bold(player_ptr, y, x1 + 1);
+                       place_bold(player_ptr, y, x1 + 1, floor);
                }
                else
                {
                        /* right */
-                       place_floor_bold(player_ptr, y, x2 - 1);
+                       place_bold(player_ptr, y, x2 - 1, 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_inner_bold(player_ptr, y, x);
+                                       place_bold(player_ptr, y, x, 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_inner_bold(player_ptr, y, x);
+                                       place_bold(player_ptr, y, x, 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_outer_bold(player_ptr, y, x);
+               place_bold(player_ptr, y, x, outer);
                if (light) g_ptr->info |= CAVE_GLOW;
        }
        else if (permanent_wall(f_ptr))
@@ -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_inner_perm_bold(player_ptr, y, x);
+                       place_bold(player_ptr, y, x, inner_perm);
                }
        }
 }