#37287 #37353 (2.2.0.89) 型の置換を継続中。 / Ongoing type replacement.

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

diff --git a/src/load.c b/src/load.c
index feaa555..db94d99 100644 (file)
--- a/src/load.c
+++ b/src/load.c
@@ -339,6 +339,7 @@ static void rd_item_old(object_type *o_ptr)
 {
        char buf[128];
        byte_hack tmp8u;
+       s16b tmp16s;
 
 
        /* Kind */
@@ -351,8 +352,10 @@ static void rd_item_old(object_type *o_ptr)
        o_ptr->ix = (POSITION)tmp8u;
 
        /* Type/Subtype */
-       rd_byte(&o_ptr->tval);
-       rd_byte(&o_ptr->sval);
+       rd_byte(&tmp8u);
+       o_ptr->tval = tmp8u;
+       rd_byte(&tmp8u);
+       o_ptr->sval = tmp8u;
 
        if (z_older_than(10, 4, 4))
        {
@@ -365,21 +368,30 @@ static void rd_item_old(object_type *o_ptr)
        rd_s16b(&o_ptr->pval);
 
        rd_byte(&o_ptr->discount);
-       rd_byte(&o_ptr->number);
+       rd_byte(&tmp8u);
+       o_ptr->number = (ITEM_NUMBER)tmp8u;
        rd_s16b(&o_ptr->weight);
 
-       rd_byte(&o_ptr->name1);
-       rd_byte(&o_ptr->name2);
+       rd_byte(&tmp8u);
+       o_ptr->name1 = tmp8u;
+
+       rd_byte(&tmp8u);
+       o_ptr->name2 = tmp8u;
+
        rd_s16b(&o_ptr->timeout);
 
        rd_s16b(&o_ptr->to_h);
-       rd_s16b(&o_ptr->to_d);
+       
+       rd_s16b(&tmp16s);
+       o_ptr->to_d = tmp16s;
        rd_s16b(&o_ptr->to_a);
 
        rd_s16b(&o_ptr->ac);
 
-       rd_byte(&o_ptr->dd);
-       rd_byte(&o_ptr->ds);
+       rd_byte(&tmp8u);
+       o_ptr->dd = tmp8u;
+       rd_byte(&tmp8u);
+       o_ptr->ds = tmp8u;
 
        rd_byte(&o_ptr->ident);
 
@@ -597,6 +609,7 @@ static void rd_item(object_type *o_ptr)
        u32b flags;
        char buf[128];
        byte_hack tmp8u;
+       s16b tmp16s;
 
        if (h_older_than(1, 5, 0, 0))
        {
@@ -628,21 +641,36 @@ static void rd_item(object_type *o_ptr)
 
        if (flags & SAVE_ITEM_DISCOUNT) rd_byte(&o_ptr->discount);
        else o_ptr->discount = 0;
-       if (flags & SAVE_ITEM_NUMBER) rd_byte(&o_ptr->number);
+       if (flags & SAVE_ITEM_NUMBER) {
+               rd_byte(&tmp8u);
+               o_ptr->number = tmp8u;
+       }       
        else o_ptr->number = 1;
 
        rd_s16b(&o_ptr->weight);
 
-       if (flags & SAVE_ITEM_NAME1) rd_byte(&o_ptr->name1);
+       if (flags & SAVE_ITEM_NAME1)
+       {
+               rd_byte(&tmp8u);
+               o_ptr->name1 = tmp8u;
+       }
        else o_ptr->name1 = 0;
-       if (flags & SAVE_ITEM_NAME2) rd_byte(&o_ptr->name2);
+       if (flags & SAVE_ITEM_NAME2)
+       {
+               rd_byte(&tmp8u);
+               o_ptr->name2 = tmp8u;
+       }
        else o_ptr->name2 = 0;
        if (flags & SAVE_ITEM_TIMEOUT) rd_s16b(&o_ptr->timeout);
        else o_ptr->timeout = 0;
 
        if (flags & SAVE_ITEM_TO_H) rd_s16b(&o_ptr->to_h);
        else o_ptr->to_h = 0;
-       if (flags & SAVE_ITEM_TO_D) rd_s16b(&o_ptr->to_d);
+       if (flags & SAVE_ITEM_TO_D)
+       {
+               rd_s16b(&tmp16s);
+               o_ptr->to_d = tmp16s;
+       }
        else o_ptr->to_d = 0;
        if (flags & SAVE_ITEM_TO_A) rd_s16b(&o_ptr->to_a);
        else o_ptr->to_a = 0;
@@ -650,9 +678,17 @@ static void rd_item(object_type *o_ptr)
        if (flags & SAVE_ITEM_AC) rd_s16b(&o_ptr->ac);
        else o_ptr->ac = 0;
 
-       if (flags & SAVE_ITEM_DD) rd_byte(&o_ptr->dd);
+       if (flags & SAVE_ITEM_DD)
+       {
+                rd_byte(&tmp8u);
+                o_ptr->dd = tmp8u;
+       }
        else o_ptr->dd = 0;
-       if (flags & SAVE_ITEM_DS) rd_byte(&o_ptr->ds);
+       if (flags & SAVE_ITEM_DS)
+       {
+               rd_byte(&tmp8u);
+               o_ptr->ds = tmp8u;
+       }
        else o_ptr->ds = 0;
 
        if (flags & SAVE_ITEM_IDENT) rd_byte(&o_ptr->ident);
@@ -779,6 +815,8 @@ static void rd_item(object_type *o_ptr)
 static void rd_monster_old(monster_type *m_ptr)
 {
        byte tmp8u;
+       s16b tmp16s;
+       u32b tmp32u;
        char buf[128];
 
        /* Read the monster race */
@@ -806,15 +844,19 @@ static void rd_monster_old(monster_type *m_ptr)
        rd_byte(&tmp8u);
        m_ptr->fx = (POSITION)tmp8u;
 
-       rd_s16b(&m_ptr->hp);
-       rd_s16b(&m_ptr->maxhp);
+       rd_s16b(&tmp16s);
+       m_ptr->hp = tmp16s;
+       rd_s16b(&tmp16s);
+       m_ptr->maxhp = tmp16s;
+
        if (z_older_than(11, 0, 5))
        {
                m_ptr->max_maxhp = m_ptr->maxhp;
        }
        else
        {
-               rd_s16b(&m_ptr->max_maxhp);
+               rd_s16b(&tmp16s);
+               m_ptr->max_maxhp = (HIT_POINT)tmp16s;
        }
        if(h_older_than(2, 1, 2, 1))
        {
@@ -862,14 +904,15 @@ static void rd_monster_old(monster_type *m_ptr)
        }
        else if (z_older_than(10,0,11))
        {
-               s16b tmp16s;
                rd_s16b(&tmp16s);
                reset_target(m_ptr);
        }
        else
        {
-               rd_s16b(&m_ptr->target_y);
-               rd_s16b(&m_ptr->target_x);
+               rd_s16b(&tmp16s);
+               m_ptr->target_y = (POSITION)tmp16s;
+               rd_s16b(&tmp16s);
+               m_ptr->target_x = (POSITION)tmp16s;
        }
 
        rd_byte(&tmp8u);
@@ -883,7 +926,8 @@ static void rd_monster_old(monster_type *m_ptr)
        if (z_older_than(10, 4, 5))
                m_ptr->exp = 0;
        else
-               rd_u32b(&m_ptr->exp);
+               rd_u32b(&tmp32u);
+               m_ptr->exp = tmp32u;
 
        if (z_older_than(10, 2, 2))
        {
@@ -928,6 +972,8 @@ static void rd_monster(monster_type *m_ptr)
        u32b flags;
        char buf[128];
        byte tmp8u;
+       s16b tmp16s;
+       u32b tmp32u;
 
        if (h_older_than(1, 5, 0, 0))
        {
@@ -949,9 +995,13 @@ static void rd_monster(monster_type *m_ptr)
        rd_byte(&tmp8u);
        m_ptr->fx = (POSITION)tmp8u;
 
-       rd_s16b(&m_ptr->hp);
-       rd_s16b(&m_ptr->maxhp);
-       rd_s16b(&m_ptr->max_maxhp);
+       rd_s16b(&tmp16s);
+       m_ptr->hp = (HIT_POINT)tmp16s;
+       rd_s16b(&tmp16s);
+       m_ptr->maxhp = (HIT_POINT)tmp16s;
+       rd_s16b(&tmp16s);
+       m_ptr->max_maxhp = (HIT_POINT)tmp16s;
+
        if(h_older_than(2, 1, 2, 1))
        {
                m_ptr->dealt_damage = 0;
@@ -1006,9 +1056,17 @@ static void rd_monster(monster_type *m_ptr)
        }
        else m_ptr->mtimed[MTIMED_MONFEAR] = 0;
 
-       if (flags & SAVE_MON_TARGET_Y) rd_s16b(&m_ptr->target_y);
+       if (flags & SAVE_MON_TARGET_Y)
+       {
+               rd_s16b(&tmp16s);
+               m_ptr->target_y = (POSITION)tmp16s;
+       }
        else m_ptr->target_y = 0;
-       if (flags & SAVE_MON_TARGET_X) rd_s16b(&m_ptr->target_x);
+       if (flags & SAVE_MON_TARGET_X)
+       {
+               rd_s16b(&tmp16s);
+               m_ptr->target_x = (POSITION)tmp16s;
+       }
        else m_ptr->target_x = 0;
 
        if (flags & SAVE_MON_INVULNER)
@@ -1021,7 +1079,11 @@ static void rd_monster(monster_type *m_ptr)
        if (flags & SAVE_MON_SMART) rd_u32b(&m_ptr->smart);
        else m_ptr->smart = 0;
 
-       if (flags & SAVE_MON_EXP) rd_u32b(&m_ptr->exp);
+       if (flags & SAVE_MON_EXP)
+       {
+               rd_u32b(&tmp32u);
+               m_ptr->exp = (EXP)tmp32u;
+       }
        else m_ptr->exp = 0;
 
        m_ptr->mflag = 0; /* Not saved */
@@ -1090,7 +1152,7 @@ static void rd_monster(monster_type *m_ptr)
  * @param r_idx 読み込み先モンスターID
  * @return なし
  */
-static void rd_lore(int r_idx)
+static void rd_lore(MONRACE_IDX r_idx)
 {
        byte tmp8u;
 
@@ -1586,6 +1648,7 @@ static void rd_ghost(void)
 static void load_quick_start(void)
 {
        byte tmp8u;
+       s16b tmp16s;
        int i;
 
        if (z_older_than(11, 0, 13))
@@ -1598,8 +1661,10 @@ static void load_quick_start(void)
        rd_byte(&previous_char.prace);
        rd_byte(&previous_char.pclass);
        rd_byte(&previous_char.pseikaku);
-       rd_byte(&previous_char.realm1);
-       rd_byte(&previous_char.realm2);
+       rd_byte(&tmp8u);
+       previous_char.realm1 = (REALM_IDX)tmp8u;
+       rd_byte(&tmp8u);
+       previous_char.realm2 = (REALM_IDX)tmp8u;
 
        rd_s16b(&previous_char.age);
        rd_s16b(&previous_char.ht);
@@ -1610,7 +1675,11 @@ static void load_quick_start(void)
        for (i = 0; i < 6; i++) rd_s16b(&previous_char.stat_max[i]);
        for (i = 0; i < 6; i++) rd_s16b(&previous_char.stat_max_max[i]);
 
-       for (i = 0; i < PY_MAX_LEVEL; i++) rd_s16b(&previous_char.player_hp[i]);
+       for (i = 0; i < PY_MAX_LEVEL; i++)
+       {
+               rd_s16b(&tmp16s);
+               previous_char.player_hp[i] = (HIT_POINT)tmp16s;
+       }
 
        rd_s16b(&previous_char.chaos_patron);
 
@@ -1635,6 +1704,7 @@ static void rd_extra(void)
 
        byte tmp8u;
        s16b tmp16s;
+       s32b tmp32s;
        u16b tmp16u;
 
        rd_string(p_ptr->name, sizeof(p_ptr->name));
@@ -1662,8 +1732,10 @@ static void rd_extra(void)
        rd_byte(&p_ptr->pclass);
        rd_byte(&p_ptr->pseikaku);
        rd_byte(&p_ptr->psex);
-       rd_byte(&p_ptr->realm1);
-       rd_byte(&p_ptr->realm2);
+       rd_byte(&tmp8u);
+       p_ptr->realm1 = (REALM_IDX)tmp8u;
+       rd_byte(&tmp8u);
+       p_ptr->realm2 = (REALM_IDX)tmp8u;
        rd_byte(&tmp8u); /* oops */
 
        if (z_older_than(10, 4, 4))
@@ -1675,7 +1747,8 @@ static void rd_extra(void)
        }
 
        /* Special Race/Class info */
-       rd_byte(&p_ptr->hitdie);
+       rd_byte(&tmp8u);
+       p_ptr->hitdie = tmp8u;
        rd_u16b(&p_ptr->expfact);
 
        /* Age/Height/Weight */
@@ -1756,8 +1829,10 @@ static void rd_extra(void)
        else
        {
                rd_byte(&p_ptr->start_race);
-               rd_s32b(&p_ptr->old_race1);
-               rd_s32b(&p_ptr->old_race2);
+               rd_s32b(&tmp32s);
+               p_ptr->old_race1 = (BIT_FLAGS)tmp32s;
+               rd_s32b(&tmp32s);
+               p_ptr->old_race2 = (BIT_FLAGS)tmp32s;
                rd_s16b(&p_ptr->old_realm);
        }
 
@@ -1789,8 +1864,10 @@ static void rd_extra(void)
        {
                for (i = 0; i < MAX_MANE; i++)
                {
-                       rd_s16b(&p_ptr->mane_spell[i]);
-                       rd_s16b(&p_ptr->mane_dam[i]);
+                       rd_s16b(&tmp16s);
+                       p_ptr->mane_spell[i] = (SPELL_IDX)tmp16s;
+                       rd_s16b(&tmp16s);
+                       p_ptr->mane_dam[i] = (SPELL_IDX)tmp16s;
                }
                rd_s16b(&p_ptr->mane_num);
        }
@@ -1852,8 +1929,11 @@ static void rd_extra(void)
        rd_byte(&p_ptr->exit_bldg);
        rd_byte(&tmp8u);
 
-       rd_s16b(&p_ptr->oldpx);
-       rd_s16b(&p_ptr->oldpy);
+       rd_s16b(&tmp16s);
+       p_ptr->oldpx = (POSITION)tmp16s;
+       rd_s16b(&tmp16s);
+       p_ptr->oldpy = (POSITION)tmp16s;
+
        if (z_older_than(10, 3, 13) && !dun_level && !p_ptr->inside_arena) {p_ptr->oldpy = 33;p_ptr->oldpx = 131;}
 
        /* Was p_ptr->rewards[MAX_BACT] */
@@ -1903,7 +1983,8 @@ static void rd_extra(void)
        rd_s16b(&p_ptr->max_plv);
        if (z_older_than(10, 3, 8))
        {
-               rd_s16b(&max_dlv[DUNGEON_ANGBAND]);
+               rd_s16b(&tmp16s);
+               max_dlv[DUNGEON_ANGBAND] = tmp16s;
        }
        else
        {
@@ -1913,7 +1994,8 @@ static void rd_extra(void)
 
                for(i = 0; i < max; i++)
                {
-                       rd_s16b(&max_dlv[i]);
+                       rd_s16b(&tmp16s);
+                       max_dlv[i] = tmp16s;
                        if (max_dlv[i] > d_info[i].maxdepth) max_dlv[i] = d_info[i].maxdepth;
                }
        }
@@ -2041,7 +2123,8 @@ static void rd_extra(void)
                else
                {
                        rd_s16b(&p_ptr->tim_res_time);
-                       rd_byte(&p_ptr->mimic_form);
+                       rd_byte(&tmp8u);
+                       p_ptr->mimic_form = (IDX)tmp8u;
                        rd_s16b(&p_ptr->tim_mimic);
                        rd_s16b(&p_ptr->tim_sh_fire);
                }
@@ -2258,13 +2341,13 @@ static void rd_extra(void)
        }
        else if (z_older_than(10, 3, 10))
        {
-               s32b tmp32s;
                rd_s32b(&tmp32s);
                p_ptr->visit = 1L;
        }
        else
        {
-               rd_s32b(&p_ptr->visit);
+               rd_s32b(&tmp32s);
+               p_ptr->visit = (BIT_FLAGS)tmp32s;
        }
        if (!z_older_than(11, 0, 5))
        {
@@ -2460,23 +2543,31 @@ static errr rd_dungeon_old(void)
        /*** Basic info ***/
 
        /* Header info */
-       rd_s16b(&dun_level);
+       rd_s16b(&tmp16s);
+       dun_level = (DEPTH)tmp16s;
        if (z_older_than(10, 3, 8)) dungeon_type = DUNGEON_ANGBAND;
-       else rd_byte(&dungeon_type);
+       else
+       { 
+               rd_byte(&tmp8u);
+               dungeon_type = (IDX)tmp8u;
+       }
 
        /* Set the base level for old versions */
        base_level = dun_level;
 
-       rd_s16b(&base_level);
+       rd_s16b(&tmp16s);
+       base_level = (DEPTH)tmp16s;
 
        rd_s16b(&num_repro);
        rd_s16b(&tmp16s);
-       p_ptr->y = (int)tmp16s;
+       p_ptr->y = (POSITION)tmp16s;
        rd_s16b(&tmp16s);
-       p_ptr->x = (int)tmp16s;
+       p_ptr->x = (POSITION)tmp16s;
        if (z_older_than(10, 3, 13) && !dun_level && !p_ptr->inside_arena) {p_ptr->y = 33;p_ptr->x = 131;}
-       rd_s16b(&cur_hgt);
-       rd_s16b(&cur_wid);
+       rd_s16b(&tmp16s);
+       cur_hgt = (POSITION)tmp16s;
+       rd_s16b(&tmp16s);
+       cur_wid = (POSITION)tmp16s;
        rd_s16b(&tmp16s); /* max_panel_rows */
        rd_s16b(&tmp16s); /* max_panel_cols */
 
@@ -2809,7 +2900,7 @@ static errr rd_dungeon_old(void)
        /* Read the monsters */
        for (i = 1; i < limit; i++)
        {
-               int m_idx;
+               MONSTER_IDX m_idx;
                monster_type *m_ptr;
 
                /* Get a new record */
@@ -2887,7 +2978,8 @@ static errr rd_saved_floor(saved_floor_type *sf_ptr)
        {
                /*** Not a saved floor ***/
 
-               rd_s16b(&dun_level);
+               rd_s16b(&tmp16s);
+               dun_level = (DEPTH)tmp16s;
                base_level = dun_level;
        }
        else
@@ -2917,7 +3009,8 @@ static errr rd_saved_floor(saved_floor_type *sf_ptr)
                if (tmp16s != sf_ptr->lower_floor_id) return 171;
        }
 
-       rd_s16b(&base_level);
+       rd_s16b(&tmp16s);
+       base_level = (DEPTH)tmp16s;
        rd_s16b(&num_repro);
 
        rd_u16b(&tmp16u);
@@ -2926,8 +3019,10 @@ static errr rd_saved_floor(saved_floor_type *sf_ptr)
        rd_u16b(&tmp16u);
        p_ptr->x = (int)tmp16u;
 
-       rd_s16b(&cur_hgt);
-       rd_s16b(&cur_wid);
+       rd_s16b(&tmp16s);
+       cur_hgt = (POSITION)tmp16s;
+       rd_s16b(&tmp16s);
+       cur_wid = (POSITION)tmp16s;
 
        rd_byte(&p_ptr->feeling);
 
@@ -3054,7 +3149,7 @@ static errr rd_saved_floor(saved_floor_type *sf_ptr)
        /* Read the dungeon items */
        for (i = 1; i < limit; i++)
        {
-               int o_idx;
+               IDX o_idx;
                object_type *o_ptr;
 
 
@@ -3113,7 +3208,7 @@ static errr rd_saved_floor(saved_floor_type *sf_ptr)
        for (i = 1; i < limit; i++)
        {
                cave_type *c_ptr;
-               int m_idx;
+               MONSTER_IDX m_idx;
                monster_type *m_ptr;
 
                /* Get a new record */
@@ -3155,6 +3250,8 @@ static errr rd_saved_floor(saved_floor_type *sf_ptr)
 static errr rd_dungeon(void)
 {
        errr err = 0;
+       s16b tmp16s;
+       byte_hack tmp8u;
        byte num;
        int i;
 
@@ -3183,8 +3280,8 @@ static errr rd_dungeon(void)
        rd_s16b(&max_floor_id);
 
        /* Current dungeon type */
-       rd_byte(&dungeon_type);
-
+       rd_byte(&tmp8u);
+       dungeon_type = (DUNGEON_IDX)tmp8u;
 
        /* Number of the saved_floors array elements */
        rd_byte(&num);
@@ -3207,7 +3304,10 @@ static errr rd_dungeon(void)
 
                        rd_s16b(&sf_ptr->floor_id);
                        rd_byte(&sf_ptr->savefile_id);
-                       rd_s16b(&sf_ptr->dun_level);
+
+                       rd_s16b(&tmp16s);
+                       sf_ptr->dun_level = (DEPTH)tmp16s;
+
                        rd_s32b(&sf_ptr->last_visit);
                        rd_u32b(&sf_ptr->visit_mark);
                        rd_s16b(&sf_ptr->upper_floor_id);
@@ -3219,7 +3319,6 @@ static errr rd_dungeon(void)
                for (i = 0; i < num; i++)
                {
                        saved_floor_type *sf_ptr = &saved_floors[i];
-                       byte tmp8u;
 
                        /* Unused element */
                        if (!sf_ptr->floor_id) continue;
@@ -3303,6 +3402,7 @@ static errr rd_savefile_new_aux(void)
 
        byte tmp8u;
        u16b tmp16u;
+       s16b tmp16s;
        u32b tmp32u;
 
 #ifdef VERIFY_CHECKSUMS
@@ -3400,7 +3500,7 @@ static errr rd_savefile_new_aux(void)
        for (i = 0; i < tmp16u; i++)
        {
                /* Read the lore */
-               rd_lore(i);
+               rd_lore((MONRACE_IDX)i);
        }
 
        if (arg_fiddle) note(_("モンスターの思い出をロードしました", "Loaded Monster Memory"));
@@ -3470,7 +3570,8 @@ static errr rd_savefile_new_aux(void)
                                quest_type* const q_ptr = &quest[i];
                                
                                rd_s16b(&q_ptr->status);
-                               rd_s16b(&q_ptr->level);
+                               rd_s16b(&tmp16s);
+                               q_ptr->level = tmp16s;
 
                                if (z_older_than(11, 0, 6))
                                {
@@ -3523,7 +3624,7 @@ static errr rd_savefile_new_aux(void)
                                                else
                                                {
                                                        init_flags = INIT_ASSIGN;
-                                                       p_ptr->inside_quest = i;
+                                                       p_ptr->inside_quest = (QUEST_IDX)i;
 
                                                        process_dungeon_file("q_info.txt", 0, 0, 0, 0);
                                                        p_ptr->inside_quest = old_inside_quest;
@@ -3652,7 +3753,8 @@ static errr rd_savefile_new_aux(void)
        /* Read the player_hp array */
        for (i = 0; i < tmp16u; i++)
        {
-               rd_s16b(&p_ptr->player_hp[i]);
+               rd_s16b(&tmp16s);
+               p_ptr->player_hp[i] = (HIT_POINT)tmp16s;
        }
 
        /* Important -- Initialize the sex */
@@ -3721,7 +3823,8 @@ static errr rd_savefile_new_aux(void)
 
        for (i = 0; i < 64; i++)
        {
-               rd_byte(&p_ptr->spell_order[i]);
+               rd_byte(&tmp8u);
+               p_ptr->spell_order[i] = (SPELL_IDX)tmp8u;
        }