OSDN Git Service

Separate 'massacre' process to independent function.
[hengband/hengband.git] / src / init2.c
index b6270c2..2b18c02 100644 (file)
@@ -1202,7 +1202,7 @@ static byte store_table[MAX_STORES][STORE_CHOICES][2] =
                /* Magic-User store */
 
                { TV_RING, SV_RING_PROTECTION },
-               { TV_RING, SV_RING_FEATHER_FALL },
+               { TV_RING, SV_RING_LEVITATION_FALL },
                { TV_RING, SV_RING_PROTECTION },
                { TV_RING, SV_RING_RESIST_FIRE },
 
@@ -1368,10 +1368,10 @@ static byte store_table[MAX_STORES][STORE_CHOICES][2] =
                { TV_ARCANE_BOOK, 2 },
                { TV_ARCANE_BOOK, 3 },
 
-               { TV_ENCHANT_BOOK, 0 },
-               { TV_ENCHANT_BOOK, 0 },
-               { TV_ENCHANT_BOOK, 1 },
-               { TV_ENCHANT_BOOK, 1 },
+               { TV_CRAFT_BOOK, 0 },
+               { TV_CRAFT_BOOK, 0 },
+               { TV_CRAFT_BOOK, 1 },
+               { TV_CRAFT_BOOK, 1 },
 
                { TV_DAEMON_BOOK, 0 },
                { TV_DAEMON_BOOK, 0 },
@@ -1382,6 +1382,11 @@ static byte store_table[MAX_STORES][STORE_CHOICES][2] =
                { TV_MUSIC_BOOK, 0 },
                { TV_MUSIC_BOOK, 1 },
                { TV_MUSIC_BOOK, 1 },
+
+               { TV_HEX_BOOK, 0 },
+               { TV_HEX_BOOK, 0 },
+               { TV_HEX_BOOK, 1 },
+               { TV_HEX_BOOK, 1 },
        },
 
        {
@@ -1589,6 +1594,165 @@ static errr init_quests(void)
 }
 
 
+static bool feat_tag_is_not_found = FALSE;
+
+
+s16b f_tag_to_index_in_init(cptr str)
+{
+       s16b feat = f_tag_to_index(str);
+
+       if (feat < 0) feat_tag_is_not_found = TRUE;
+
+       return feat;
+}
+
+
+/*
+ * Initialize feature variables
+ */
+static errr init_feat_variables(void)
+{
+       int i;
+
+       /* Nothing */
+       feat_none = f_tag_to_index_in_init("NONE");
+
+       /* Floor */
+       feat_floor = f_tag_to_index_in_init("FLOOR");
+
+       /* Objects */
+       feat_glyph = f_tag_to_index_in_init("GLYPH");
+       feat_explosive_rune = f_tag_to_index_in_init("EXPLOSIVE_RUNE");
+       feat_mirror = f_tag_to_index_in_init("MIRROR");
+
+       /* Doors */
+       feat_door[DOOR_DOOR].open = f_tag_to_index_in_init("OPEN_DOOR");
+       feat_door[DOOR_DOOR].broken = f_tag_to_index_in_init("BROKEN_DOOR");
+       feat_door[DOOR_DOOR].closed = f_tag_to_index_in_init("CLOSED_DOOR");
+
+       /* Locked doors */
+       for (i = 1; i < MAX_LJ_DOORS; i++)
+       {
+               s16b door = f_tag_to_index(format("LOCKED_DOOR_%d", i));
+               if (door < 0) break;
+               feat_door[DOOR_DOOR].locked[i - 1] = door;
+       }
+       if (i == 1) return PARSE_ERROR_UNDEFINED_TERRAIN_TAG;
+       feat_door[DOOR_DOOR].num_locked = i - 1;
+
+       /* Jammed doors */
+       for (i = 0; i < MAX_LJ_DOORS; i++)
+       {
+               s16b door = f_tag_to_index(format("JAMMED_DOOR_%d", i));
+               if (door < 0) break;
+               feat_door[DOOR_DOOR].jammed[i] = door;
+       }
+       if (!i) return PARSE_ERROR_UNDEFINED_TERRAIN_TAG;
+       feat_door[DOOR_DOOR].num_jammed = i;
+
+       /* Glass doors */
+       feat_door[DOOR_GLASS_DOOR].open = f_tag_to_index_in_init("OPEN_GLASS_DOOR");
+       feat_door[DOOR_GLASS_DOOR].broken = f_tag_to_index_in_init("BROKEN_GLASS_DOOR");
+       feat_door[DOOR_GLASS_DOOR].closed = f_tag_to_index_in_init("CLOSED_GLASS_DOOR");
+
+       /* Locked glass doors */
+       for (i = 1; i < MAX_LJ_DOORS; i++)
+       {
+               s16b door = f_tag_to_index(format("LOCKED_GLASS_DOOR_%d", i));
+               if (door < 0) break;
+               feat_door[DOOR_GLASS_DOOR].locked[i - 1] = door;
+       }
+       if (i == 1) return PARSE_ERROR_UNDEFINED_TERRAIN_TAG;
+       feat_door[DOOR_GLASS_DOOR].num_locked = i - 1;
+
+       /* Jammed glass doors */
+       for (i = 0; i < MAX_LJ_DOORS; i++)
+       {
+               s16b door = f_tag_to_index(format("JAMMED_GLASS_DOOR_%d", i));
+               if (door < 0) break;
+               feat_door[DOOR_GLASS_DOOR].jammed[i] = door;
+       }
+       if (!i) return PARSE_ERROR_UNDEFINED_TERRAIN_TAG;
+       feat_door[DOOR_GLASS_DOOR].num_jammed = i;
+
+       /* Curtains */
+       feat_door[DOOR_CURTAIN].open = f_tag_to_index_in_init("OPEN_CURTAIN");
+       feat_door[DOOR_CURTAIN].broken = feat_door[DOOR_CURTAIN].open;
+       feat_door[DOOR_CURTAIN].closed = f_tag_to_index_in_init("CLOSED_CURTAIN");
+       feat_door[DOOR_CURTAIN].locked[0] = feat_door[DOOR_CURTAIN].closed;
+       feat_door[DOOR_CURTAIN].num_locked = 1;
+       feat_door[DOOR_CURTAIN].jammed[0] = feat_door[DOOR_CURTAIN].closed;
+       feat_door[DOOR_CURTAIN].num_jammed = 1;
+
+       /* Stairs */
+       feat_up_stair = f_tag_to_index_in_init("UP_STAIR");
+       feat_down_stair = f_tag_to_index_in_init("DOWN_STAIR");
+       feat_entrance = f_tag_to_index_in_init("ENTRANCE");
+
+       /* Normal traps */
+       init_normal_traps();
+
+       /* Special traps */
+       feat_trap_open = f_tag_to_index_in_init("TRAP_OPEN");
+       feat_trap_armageddon = f_tag_to_index_in_init("TRAP_ARMAGEDDON");
+       feat_trap_piranha = f_tag_to_index_in_init("TRAP_PIRANHA");
+
+       /* Rubble */
+       feat_rubble = f_tag_to_index_in_init("RUBBLE");
+
+       /* Seams */
+       feat_magma_vein = f_tag_to_index_in_init("MAGMA_VEIN");
+       feat_quartz_vein = f_tag_to_index_in_init("QUARTZ_VEIN");
+
+       /* Walls */
+       feat_granite = f_tag_to_index_in_init("GRANITE");
+       feat_permanent = f_tag_to_index_in_init("PERMANENT");
+
+       /* Glass floor */
+       feat_glass_floor = f_tag_to_index_in_init("GLASS_FLOOR");
+
+       /* Glass walls */
+       feat_glass_wall = f_tag_to_index_in_init("GLASS_WALL");
+       feat_permanent_glass_wall = f_tag_to_index_in_init("PERMANENT_GLASS_WALL");
+
+       /* Pattern */
+       feat_pattern_start = f_tag_to_index_in_init("PATTERN_START");
+       feat_pattern_1 = f_tag_to_index_in_init("PATTERN_1");
+       feat_pattern_2 = f_tag_to_index_in_init("PATTERN_2");
+       feat_pattern_3 = f_tag_to_index_in_init("PATTERN_3");
+       feat_pattern_4 = f_tag_to_index_in_init("PATTERN_4");
+       feat_pattern_end = f_tag_to_index_in_init("PATTERN_END");
+       feat_pattern_old = f_tag_to_index_in_init("PATTERN_OLD");
+       feat_pattern_exit = f_tag_to_index_in_init("PATTERN_EXIT");
+       feat_pattern_corrupted = f_tag_to_index_in_init("PATTERN_CORRUPTED");
+
+       /* Various */
+       feat_black_market = f_tag_to_index_in_init("BLACK_MARKET");
+       feat_town = f_tag_to_index_in_init("TOWN");
+
+       /* Terrains */
+       feat_deep_water = f_tag_to_index_in_init("DEEP_WATER");
+       feat_shallow_water = f_tag_to_index_in_init("SHALLOW_WATER");
+       feat_deep_lava = f_tag_to_index_in_init("DEEP_LAVA");
+       feat_shallow_lava = f_tag_to_index_in_init("SHALLOW_LAVA");
+       feat_dirt = f_tag_to_index_in_init("DIRT");
+       feat_grass = f_tag_to_index_in_init("GRASS");
+       feat_flower = f_tag_to_index_in_init("FLOWER");
+       feat_brake = f_tag_to_index_in_init("BRAKE");
+       feat_tree = f_tag_to_index_in_init("TREE");
+       feat_mountain = f_tag_to_index_in_init("MOUNTAIN");
+       feat_swamp = f_tag_to_index_in_init("SWAMP");
+
+       /* Unknown grid (not detected) */
+       feat_undetected = f_tag_to_index_in_init("UNDETECTED");
+
+       /* Wilderness terrains */
+       init_wilderness_terrains();
+
+       return feat_tag_is_not_found ? PARSE_ERROR_UNDEFINED_TERRAIN_TAG : 0;
+}
+
+
 /*
  * Initialize some other arrays
  */
@@ -1605,6 +1769,12 @@ static errr init_other(void)
        /* Allocate and Wipe the monster list */
        C_MAKE(m_list, max_m_idx, monster_type);
 
+       /* Allocate and Wipe the monster process list */
+       for (i = 0; i < MAX_MTIMED; i++)
+       {
+               C_MAKE(mproc_list[i], max_m_idx, s16b);
+       }
+
        /* Allocate and Wipe the max dungeon level */
        C_MAKE(max_dlv, max_d_idx, s16b);
 
@@ -1627,7 +1797,7 @@ static errr init_other(void)
        C_MAKE(macro__buf, 1024, char);
 
        /* Quark variables */
-       C_MAKE(quark__str, QUARK_MAX, cptr);
+       quark_init();
 
        /* Message variables */
        C_MAKE(message__ptr, MESSAGE_MAX, u16b);
@@ -1708,6 +1878,121 @@ static errr init_other(void)
 }
 
 
+/*
+ * Initialize some other arrays
+ */
+static errr init_object_alloc(void)
+{
+       int i, j;
+       object_kind *k_ptr;
+       alloc_entry *table;
+       s16b num[MAX_DEPTH];
+       s16b aux[MAX_DEPTH];
+
+
+       /*** Analyze object allocation info ***/
+
+       /* Clear the "aux" array */
+       (void)C_WIPE(&aux, MAX_DEPTH, s16b);
+
+       /* Clear the "num" array */
+       (void)C_WIPE(&num, MAX_DEPTH, s16b);
+
+       /* Free the old "alloc_kind_table" (if it exists) */
+       if (alloc_kind_table)
+       {
+               C_KILL(alloc_kind_table, alloc_kind_size, alloc_entry);
+       }
+
+       /* Size of "alloc_kind_table" */
+       alloc_kind_size = 0;
+
+       /* Scan the objects */
+       for (i = 1; i < max_k_idx; i++)
+       {
+               k_ptr = &k_info[i];
+
+               /* Scan allocation pairs */
+               for (j = 0; j < 4; j++)
+               {
+                       /* Count the "legal" entries */
+                       if (k_ptr->chance[j])
+                       {
+                               /* Count the entries */
+                               alloc_kind_size++;
+
+                               /* Group by level */
+                               num[k_ptr->locale[j]]++;
+                       }
+               }
+       }
+
+       /* Collect the level indexes */
+       for (i = 1; i < MAX_DEPTH; i++)
+       {
+               /* Group by level */
+               num[i] += num[i-1];
+       }
+
+       /* Paranoia */
+#ifdef JP
+if (!num[0]) quit("Ä®¤Î¥¢¥¤¥Æ¥à¤¬¤Ê¤¤¡ª");
+#else
+       if (!num[0]) quit("No town objects!");
+#endif
+
+
+
+       /*** Initialize object allocation info ***/
+
+       /* Allocate the alloc_kind_table */
+       C_MAKE(alloc_kind_table, alloc_kind_size, alloc_entry);
+
+       /* Access the table entry */
+       table = alloc_kind_table;
+
+       /* Scan the objects */
+       for (i = 1; i < max_k_idx; i++)
+       {
+               k_ptr = &k_info[i];
+
+               /* Scan allocation pairs */
+               for (j = 0; j < 4; j++)
+               {
+                       /* Count the "legal" entries */
+                       if (k_ptr->chance[j])
+                       {
+                               int p, x, y, z;
+
+                               /* Extract the base level */
+                               x = k_ptr->locale[j];
+
+                               /* Extract the base probability */
+                               p = (100 / k_ptr->chance[j]);
+
+                               /* Skip entries preceding our locale */
+                               y = (x > 0) ? num[x-1] : 0;
+
+                               /* Skip previous entries at this locale */
+                               z = y + aux[x];
+
+                               /* Load the entry */
+                               table[z].index = i;
+                               table[z].level = x;
+                               table[z].prob1 = p;
+                               table[z].prob2 = p;
+                               table[z].prob3 = p;
+
+                               /* Another entry complete for this locale */
+                               aux[x]++;
+                       }
+               }
+       }
+
+       /* Success */
+       return (0);
+}
+
 
 /*
  * Initialize some other arrays
@@ -1728,7 +2013,7 @@ static errr init_alloc(void)
        for (i = 1; i < max_r_idx; i++)
        {
                elements[i].tag = r_info[i].level;
-               elements[i].pointer = (void*)i;
+               elements[i].index = i;
        }
 
        tag_sort(elements, max_r_idx);
@@ -1745,7 +2030,7 @@ static errr init_alloc(void)
        for (i = 1; i < max_r_idx; i++)
        {
                /* Get the i'th race */
-               r_ptr = &r_info[(int)elements[i].pointer];
+               r_ptr = &r_info[elements[i].index];
 
                /* Count valid pairs */
                if (r_ptr->rarity)
@@ -1759,7 +2044,7 @@ static errr init_alloc(void)
                        p = (100 / r_ptr->rarity);
 
                        /* Load the entry */
-                       alloc_race_table[i].index = (int)elements[i].pointer;
+                       alloc_race_table[i].index = elements[i].index;
                        alloc_race_table[i].level = x;
                        alloc_race_table[i].prob1 = p;
                        alloc_race_table[i].prob2 = p;
@@ -2053,7 +2338,7 @@ void init_angband(void)
        }
 
        /* Flush it */
-       Term_fresh();
+       Term_flush();
 
 
        /*** Verify (or create) the "high score" file ***/
@@ -2121,9 +2406,11 @@ if (init_misc()) quit("
 #ifdef JP
        note("[¥Ç¡¼¥¿¤Î½é´ü²½Ãæ... (ÃÏ·Á)]");
        if (init_f_info()) quit("ÃÏ·Á½é´ü²½ÉÔǽ");
+       if (init_feat_variables()) quit("ÃÏ·Á½é´ü²½ÉÔǽ");
 #else
        note("[Initializing arrays... (features)]");
        if (init_f_info()) quit("Cannot initialize features");
+       if (init_feat_variables()) quit("Cannot initialize features");
 #endif