OSDN Git Service

[Refactor] #38997 place_trees() に floor_type * 引数を追加. / Add floor_type * argument...
[hengband/hengband.git] / src / floor-streams.c
index 254e9b6..7065de0 100644 (file)
  */
 
 #include "angband.h"
-#include "generate.h"
+#include "util.h"
+
+#include "artifact.h"
+#include "floor-generate.h"
+#include "dungeon.h"
+#include "floor.h"
 #include "floor-streams.h"
 #include "grid.h"
+#include "monster.h"
+#include "feature.h"
+#include "object-flavor.h"
+#include "object-hook.h"
+#include "spells.h"
+#include "spells-floor.h"
 
 
 /*!
@@ -39,7 +50,7 @@ static void recursive_river(POSITION x1, POSITION y1, POSITION x2, POSITION y2,
        POSITION changex, changey;
        POSITION ty, tx;
        bool done;
-       cave_type *c_ptr;
+       grid_type *g_ptr;
 
        length = distance(x1, y1, x2, y2);
 
@@ -72,7 +83,7 @@ static void recursive_river(POSITION x1, POSITION y1, POSITION x2, POSITION y2,
                        changey = 0;
                }
 
-               if (!in_bounds(y1 + dy + changey, x1 + dx + changex))
+               if (!in_bounds(p_ptr->current_floor_ptr, y1 + dy + changey, x1 + dx + changex))
                {
                        changex = 0;
                        changey = 0;
@@ -106,38 +117,38 @@ static void recursive_river(POSITION x1, POSITION y1, POSITION x2, POSITION y2,
                                {
                                        for (tx = x - width - 1; tx <= x + width + 1; tx++)
                                        {
-                                               if (!in_bounds2(ty, tx)) continue;
+                                               if (!in_bounds2(p_ptr->current_floor_ptr, ty, tx)) continue;
 
-                                               c_ptr = &cave[ty][tx];
+                                               g_ptr = &p_ptr->current_floor_ptr->grid_array[ty][tx];
 
-                                               if (c_ptr->feat == feat1) continue;
-                                               if (c_ptr->feat == feat2) continue;
+                                               if (g_ptr->feat == feat1) continue;
+                                               if (g_ptr->feat == feat2) continue;
 
                                                if (distance(ty, tx, y, x) > rand_spread(width, 1)) continue;
 
                                                /* Do not convert permanent features */
-                                               if (cave_perma_grid(c_ptr)) continue;
+                                               if (cave_perma_grid(g_ptr)) continue;
 
                                                /*
                                                 * Clear previous contents, add feature
                                                 * The border mainly gets feat2, while the center gets feat1
                                                 */
                                                if (distance(ty, tx, y, x) > width)
-                                                       c_ptr->feat = feat2;
+                                                       g_ptr->feat = feat2;
                                                else
-                                                       c_ptr->feat = feat1;
+                                                       g_ptr->feat = feat1;
 
                                                /* Clear garbage of hidden trap or door */
-                                               c_ptr->mimic = 0;
+                                               g_ptr->mimic = 0;
 
                                                /* Lava terrain glows */
                                                if (have_flag(f_info[feat1].flags, FF_LAVA))
                                                {
-                                                       if (!(d_info[dungeon_type].flags1 & DF1_DARKNESS)) c_ptr->info |= CAVE_GLOW;
+                                                       if (!(d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS)) g_ptr->info |= CAVE_GLOW;
                                                }
 
                                                /* Hack -- don't teleport here */
-                                               c_ptr->info |= CAVE_ICKY;
+                                               g_ptr->info |= CAVE_ICKY;
                                        }
                                }
 
@@ -155,7 +166,7 @@ static void recursive_river(POSITION x1, POSITION y1, POSITION x2, POSITION y2,
  * @param feat2 境界部地形ID
  * @return なし
  */
-void add_river(IDX feat1, IDX feat2)
+void add_river(floor_type *floor_ptr, FEAT_IDX feat1, FEAT_IDX feat2)
 {
        POSITION y2, x2;
        POSITION y1 = 0, x1 = 0;
@@ -163,8 +174,8 @@ void add_river(IDX feat1, IDX feat2)
 
 
        /* Hack -- Choose starting point */
-       y2 = randint1(cur_hgt / 2 - 2) + cur_hgt / 2;
-       x2 = randint1(cur_wid / 2 - 2) + cur_wid / 2;
+       y2 = randint1(floor_ptr->height / 2 - 2) + floor_ptr->height / 2;
+       x2 = randint1(floor_ptr->width / 2 - 2) + floor_ptr->width / 2;
 
        /* Hack -- Choose ending point somewhere on boundary */
        switch(randint1(4))
@@ -172,7 +183,7 @@ void add_river(IDX feat1, IDX feat2)
                case 1:
                {
                        /* top boundary */
-                       x1 = randint1(cur_wid-2)+1;
+                       x1 = randint1(floor_ptr->width-2)+1;
                        y1 = 1;
                        break;
                }
@@ -180,21 +191,21 @@ void add_river(IDX feat1, IDX feat2)
                {
                        /* left boundary */
                        x1 = 1;
-                       y1 = randint1(cur_hgt-2)+1;
+                       y1 = randint1(floor_ptr->height-2)+1;
                        break;
                }
                case 3:
                {
                        /* right boundary */
-                       x1 = cur_wid-1;
-                       y1 = randint1(cur_hgt-2)+1;
+                       x1 = floor_ptr->width-1;
+                       y1 = randint1(floor_ptr->height-2)+1;
                        break;
                }
                case 4:
                {
                        /* bottom boundary */
-                       x1 = randint1(cur_wid-2)+1;
-                       y1 = cur_hgt-1;
+                       x1 = randint1(floor_ptr->width-2)+1;
+                       y1 = floor_ptr->height-1;
                        break;
                }
        }
@@ -226,13 +237,14 @@ void add_river(IDX feat1, IDX feat2)
  * hidden gold types are currently unused.
  * </pre>
  */
-void build_streamer(IDX feat, int chance)
+void build_streamer(FEAT_IDX feat, int chance)
 {
-       int             i, tx, ty;
-       int             y, x, dir;
+       int i;
+       POSITION y, x, tx, ty;
+       DIRECTION dir;
        int dummy = 0;
 
-       cave_type *c_ptr;
+       grid_type *g_ptr;
        feature_type *f_ptr;
 
        feature_type *streamer_ptr = &f_info[feat];
@@ -240,8 +252,8 @@ void build_streamer(IDX feat, int chance)
        bool streamer_may_have_gold = have_flag(streamer_ptr->flags, FF_MAY_HAVE_GOLD);
 
        /* Hack -- Choose starting point */
-       y = rand_spread(cur_hgt / 2, cur_hgt / 6);
-       x = rand_spread(cur_wid / 2, cur_wid / 6);
+       y = rand_spread(p_ptr->current_floor_ptr->height / 2, p_ptr->current_floor_ptr->height / 6);
+       x = rand_spread(p_ptr->current_floor_ptr->width / 2, p_ptr->current_floor_ptr->width / 6);
 
        /* Choose a random compass direction */
        dir = randint0(8);
@@ -261,11 +273,11 @@ void build_streamer(IDX feat, int chance)
                        {
                                ty = rand_spread(y, d);
                                tx = rand_spread(x, d);
-                               if (!in_bounds2(ty, tx)) continue;
+                               if (!in_bounds2(p_ptr->current_floor_ptr, ty, tx)) continue;
                                break;
                        }
-                       c_ptr = &cave[ty][tx];
-                       f_ptr = &f_info[c_ptr->feat];
+                       g_ptr = &p_ptr->current_floor_ptr->grid_array[ty][tx];
+                       f_ptr = &f_info[g_ptr->feat];
 
                        if (have_flag(f_ptr->flags, FF_MOVE) && (have_flag(f_ptr->flags, FF_WATER) || have_flag(f_ptr->flags, FF_LAVA)))
                                continue;
@@ -276,26 +288,24 @@ void build_streamer(IDX feat, int chance)
                        /* Only convert "granite" walls */
                        if (streamer_is_wall)
                        {
-                               if (!is_extra_grid(c_ptr) && !is_inner_grid(c_ptr) && !is_outer_grid(c_ptr) && !is_solid_grid(c_ptr)) continue;
-                               if (is_closed_door(c_ptr->feat)) continue;
+                               if (!is_extra_grid(g_ptr) && !is_inner_grid(g_ptr) && !is_outer_grid(g_ptr) && !is_solid_grid(g_ptr)) continue;
+                               if (is_closed_door(g_ptr->feat)) continue;
                        }
 
-                       if (c_ptr->m_idx && !(have_flag(streamer_ptr->flags, FF_PLACE) && monster_can_cross_terrain(feat, &r_info[m_list[c_ptr->m_idx].r_idx], 0)))
+                       if (g_ptr->m_idx && !(have_flag(streamer_ptr->flags, FF_PLACE) && monster_can_cross_terrain(feat, &r_info[p_ptr->current_floor_ptr->m_list[g_ptr->m_idx].r_idx], 0)))
                        {
                                /* Delete the monster (if any) */
                                delete_monster(ty, tx);
                        }
 
-                       if (c_ptr->o_idx && !have_flag(streamer_ptr->flags, FF_DROP))
+                       if (g_ptr->o_idx && !have_flag(streamer_ptr->flags, FF_DROP))
                        {
                                OBJECT_IDX this_o_idx, next_o_idx = 0;
 
                                /* Scan all objects in the grid */
-                               for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
+                               for (this_o_idx = g_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
                                {
-                                       object_type *o_ptr = &o_list[this_o_idx];
-
-                                       /* Acquire next object */
+                                       object_type *o_ptr = &p_ptr->current_floor_ptr->o_list[this_o_idx];
                                        next_o_idx = o_ptr->next_o_idx;
 
                                        /* Hack -- Preserve unknown artifacts */
@@ -306,7 +316,7 @@ void build_streamer(IDX feat, int chance)
 
                                                if (cheat_peek)
                                                {
-                                                       char o_name[MAX_NLEN];
+                                                       GAME_TEXT o_name[MAX_NLEN];
                                                        object_desc(o_name, o_ptr, (OD_NAME_ONLY | OD_STORE));
                                                        msg_format(_("伝説のアイテム (%s) はストリーマーにより削除された。",
                                                                "Artifact (%s) was deleted by streamer."), o_name);
@@ -319,15 +329,14 @@ void build_streamer(IDX feat, int chance)
                                        }
                                }
 
-                               /* Delete objects */
                                delete_object(ty, tx);
                        }
 
                        /* Clear previous contents, add proper vein type */
-                       c_ptr->feat = feat;
+                       g_ptr->feat = feat;
 
                        /* Paranoia: Clear mimic field */
-                       c_ptr->mimic = 0;
+                       g_ptr->mimic = 0;
 
                        if (streamer_may_have_gold)
                        {
@@ -363,7 +372,7 @@ void build_streamer(IDX feat, int chance)
                }
 
                /* Quit before leaving the dungeon */
-               if (!in_bounds(y, x)) break;
+               if (!in_bounds(p_ptr->current_floor_ptr, y, x)) break;
        }
 }
 
@@ -380,24 +389,24 @@ void build_streamer(IDX feat, int chance)
  * This happens in real world lava tubes.
  * </pre>
  */
-void place_trees(POSITION x, POSITION y)
+void place_trees(floor_type *floor_ptr, POSITION x, POSITION y)
 {
        int i, j;
-       cave_type *c_ptr;
+       grid_type *g_ptr;
 
        /* place trees/ rubble in ovalish distribution */
        for (i = x - 3; i < x + 4; i++)
        {
                for (j = y - 3; j < y + 4; j++)
                {
-                       if (!in_bounds(j, i)) continue;
-                       c_ptr = &cave[j][i];
+                       if (!in_bounds(floor_ptr, j, i)) continue;
+                       g_ptr = &floor_ptr->grid_array[j][i];
 
-                       if (c_ptr->info & CAVE_ICKY) continue;
-                       if (c_ptr->o_idx) continue;
+                       if (g_ptr->info & CAVE_ICKY) continue;
+                       if (g_ptr->o_idx) continue;
 
                        /* Want square to be in the circle and accessable. */
-                       if ((distance(j, i, y, x) < 4) && !cave_perma_grid(c_ptr))
+                       if ((distance(j, i, y, x) < 4) && !cave_perma_grid(g_ptr))
                        {
                                /*
                                 * Clear previous contents, add feature
@@ -406,18 +415,18 @@ void place_trees(POSITION x, POSITION y)
                                if ((distance(j, i, y, x) > 1) || (randint1(100) < 25))
                                {
                                        if (randint1(100) < 75)
-                                               cave[j][i].feat = feat_tree;
+                                               floor_ptr->grid_array[j][i].feat = feat_tree;
                                }
                                else
                                {
-                                       cave[j][i].feat = feat_rubble;
+                                       floor_ptr->grid_array[j][i].feat = feat_rubble;
                                }
 
                                /* Clear garbage of hidden trap or door */
-                               c_ptr->mimic = 0;
+                               g_ptr->mimic = 0;
 
                                /* Light area since is open above */
-                               if (!(d_info[dungeon_type].flags1 & DF1_DARKNESS)) cave[j][i].info |= (CAVE_GLOW | CAVE_ROOM);
+                               if (!(d_info[p_ptr->dungeon_idx].flags1 & DF1_DARKNESS)) floor_ptr->grid_array[j][i].info |= (CAVE_GLOW | CAVE_ROOM);
                        }
                }
        }
@@ -426,7 +435,7 @@ void place_trees(POSITION x, POSITION y)
        if (!ironman_downward && one_in_(3))
        {
                /* up stair */
-               cave[y][x].feat = feat_up_stair;
+               floor_ptr->grid_array[y][x].feat = feat_up_stair;
        }
 }
 
@@ -448,8 +457,8 @@ void destroy_level(void)
        for (n = 0; n < randint1(5); n++)
        {
                /* Pick an epi-center */
-               x1 = rand_range(5, cur_wid - 1 - 5);
-               y1 = rand_range(5, cur_hgt - 1 - 5);
+               x1 = rand_range(5, p_ptr->current_floor_ptr->width - 1 - 5);
+               y1 = rand_range(5, p_ptr->current_floor_ptr->height - 1 - 5);
 
                (void)destroy_area(y1, x1, 15, TRUE);
        }