src/load/lore-loader.cpp

   1 #include "load/lore-loader.h"
   2 #include "game-option/runtime-arguments.h"
   3 #include "load/angband-version-comparer.h"
   4 #include "load/load-util.h"
   5 #include "load/old/load-v1-5-0.h"
   6 #include "load/savedata-old-flag-types.h"
   7 #include "monster-race/monster-race.h"
   8 #include "system/angband.h"
   9 #include "system/monster-race-info.h"
  10 #include "system/system-variables.h"
  11 #include "util/bit-flags-calculator.h"
  12 #include "util/enum-converter.h"
  13
  14 static void migrate_old_misc_flags(MonsterRaceInfo *r_ptr, BIT_FLAGS old_flags1, BIT_FLAGS old_flags2)
  15 {
  16     if (!loading_savefile_version_is_older_than(20)) {
  17         rd_FlagGroup(r_ptr->r_misc_flags, rd_byte);
  18         return;
  19     }
  20
  21     constexpr auto SIZE_OF_RF1 = 6;
  22     struct flag_list_ver20 {
  23         SavedataLoreOlderThan20FlagType old_flag;
  24         MonsterMiscType flag;
  25     };
  26     const std::vector<flag_list_ver20> flag_list = {
  27         { SavedataLoreOlderThan20FlagType::RF1_QUESTOR, MonsterMiscType::QUESTOR },
  28         { SavedataLoreOlderThan20FlagType::RF1_FORCE_DEPTH, MonsterMiscType::FORCE_DEPTH },
  29         { SavedataLoreOlderThan20FlagType::RF1_FORCE_MAXHP, MonsterMiscType::FORCE_MAXHP },
  30         { SavedataLoreOlderThan20FlagType::RF1_FRIENDS, MonsterMiscType::HAS_FRIENDS },
  31         { SavedataLoreOlderThan20FlagType::RF1_ESCORT, MonsterMiscType::ESCORT },
  32         { SavedataLoreOlderThan20FlagType::RF1_ESCORTS, MonsterMiscType::MORE_ESCORT },
  33         { SavedataLoreOlderThan20FlagType::RF2_REFLECTING, MonsterMiscType::REFLECTING },
  34         { SavedataLoreOlderThan20FlagType::RF2_INVISIBLE, MonsterMiscType::INVISIBLE },
  35         { SavedataLoreOlderThan20FlagType::RF2_COLD_BLOOD, MonsterMiscType::COLD_BLOOD },
  36         { SavedataLoreOlderThan20FlagType::RF2_EMPTY_MIND, MonsterMiscType::EMPTY_MIND },
  37         { SavedataLoreOlderThan20FlagType::RF2_WEIRD_MIND, MonsterMiscType::WEIRD_MIND },
  38         { SavedataLoreOlderThan20FlagType::RF2_MULTIPLY, MonsterMiscType::MULTIPLY },
  39         { SavedataLoreOlderThan20FlagType::RF2_REGENERATE, MonsterMiscType::REGENERATE },
  40         { SavedataLoreOlderThan20FlagType::RF2_POWERFUL, MonsterMiscType::POWERFUL },
  41         { SavedataLoreOlderThan20FlagType::RF2_ELDRITCH_HORROR, MonsterMiscType::ELDRITCH_HORROR },
  42     };
  43
  44     if (old_flags1 == 0 && old_flags2 == 0) {
  45         return;
  46     }
  47
  48     for (uint16_t i = 0; i < flag_list.size(); i++) {
  49         const auto &f = flag_list[i];
  50         if (i < SIZE_OF_RF1) {
  51             if (any_bits(old_flags1, f.old_flag)) {
  52                 r_ptr->r_misc_flags.set(f.flag);
  53             }
  54         } else {
  55             if (any_bits(old_flags2, f.old_flag)) {
  56                 r_ptr->r_misc_flags.set(f.flag);
  57             }
  58         }
  59     }
  60 }
  61
  62 static void migrate_old_feature_flags(MonsterRaceInfo *r_ptr, BIT_FLAGS old_flags)
  63 {
  64     if (!loading_savefile_version_is_older_than(19)) {
  65         rd_FlagGroup(r_ptr->feature_flags, rd_byte);
  66         return;
  67     }
  68
  69     if (any_bits(old_flags, enum2i(SavedataLoreOlderThan19FlagType::RF2_PASS_WALL))) {
  70         r_ptr->r_feature_flags.set(MonsterFeatureType::PASS_WALL);
  71     }
  72     if (any_bits(old_flags, enum2i(SavedataLoreOlderThan19FlagType::RF2_KILL_WALL))) {
  73         r_ptr->r_feature_flags.set(MonsterFeatureType::KILL_WALL);
  74     }
  75 }
  76
  77 static void migrate_old_aura_flags(MonsterRaceInfo *r_ptr, BIT_FLAGS old_flags2, BIT_FLAGS old_flags3)
  78 {
  79     if (!loading_savefile_version_is_older_than(10)) {
  80         rd_FlagGroup(r_ptr->r_aura_flags, rd_byte);
  81         return;
  82     }
  83
  84     if (any_bits(old_flags2, SavedataLoreOlderThan10FlagType::AURA_FIRE_OLD)) {
  85         r_ptr->r_aura_flags.set(MonsterAuraType::FIRE);
  86     }
  87
  88     if (any_bits(old_flags3, SavedataLoreOlderThan10FlagType::AURA_COLD_OLD)) {
  89         r_ptr->r_aura_flags.set(MonsterAuraType::COLD);
  90     }
  91
  92     if (any_bits(old_flags2, SavedataLoreOlderThan10FlagType::AURA_ELEC_OLD)) {
  93         r_ptr->r_aura_flags.set(MonsterAuraType::ELEC);
  94     }
  95 }
  96
  97 static void migrate_old_resistance_flags(MonsterRaceInfo *r_ptr, BIT_FLAGS old_flags)
  98 {
  99     if (!loading_savefile_version_is_older_than(14)) {
 100         return;
 101     }
 102
 103     struct flag_list_ver14 {
 104         SavedataLoreOlderThan14FlagType old_flag;
 105         MonsterResistanceType flag;
 106     };
 107     const std::vector<flag_list_ver14> flag_list = {
 108         { SavedataLoreOlderThan14FlagType::RFR_IM_ACID, MonsterResistanceType::IMMUNE_ACID },
 109         { SavedataLoreOlderThan14FlagType::RFR_IM_ELEC, MonsterResistanceType::IMMUNE_ELEC },
 110         { SavedataLoreOlderThan14FlagType::RFR_IM_FIRE, MonsterResistanceType::IMMUNE_FIRE },
 111         { SavedataLoreOlderThan14FlagType::RFR_IM_COLD, MonsterResistanceType::IMMUNE_COLD },
 112         { SavedataLoreOlderThan14FlagType::RFR_IM_POIS, MonsterResistanceType::IMMUNE_POISON },
 113         { SavedataLoreOlderThan14FlagType::RFR_RES_LITE, MonsterResistanceType::RESIST_LITE },
 114         { SavedataLoreOlderThan14FlagType::RFR_RES_DARK, MonsterResistanceType::RESIST_DARK },
 115         { SavedataLoreOlderThan14FlagType::RFR_RES_NETH, MonsterResistanceType::RESIST_NETHER },
 116         { SavedataLoreOlderThan14FlagType::RFR_RES_WATE, MonsterResistanceType::RESIST_WATER },
 117         { SavedataLoreOlderThan14FlagType::RFR_RES_PLAS, MonsterResistanceType::RESIST_PLASMA },
 118         { SavedataLoreOlderThan14FlagType::RFR_RES_SHAR, MonsterResistanceType::RESIST_SHARDS },
 119         { SavedataLoreOlderThan14FlagType::RFR_RES_SOUN, MonsterResistanceType::RESIST_SOUND },
 120         { SavedataLoreOlderThan14FlagType::RFR_RES_CHAO, MonsterResistanceType::RESIST_CHAOS },
 121         { SavedataLoreOlderThan14FlagType::RFR_RES_NEXU, MonsterResistanceType::RESIST_NEXUS },
 122         { SavedataLoreOlderThan14FlagType::RFR_RES_DISE, MonsterResistanceType::RESIST_DISENCHANT },
 123         { SavedataLoreOlderThan14FlagType::RFR_RES_WALL, MonsterResistanceType::RESIST_FORCE },
 124         { SavedataLoreOlderThan14FlagType::RFR_RES_INER, MonsterResistanceType::RESIST_INERTIA },
 125         { SavedataLoreOlderThan14FlagType::RFR_RES_TIME, MonsterResistanceType::RESIST_TIME },
 126         { SavedataLoreOlderThan14FlagType::RFR_RES_GRAV, MonsterResistanceType::RESIST_GRAVITY },
 127         { SavedataLoreOlderThan14FlagType::RFR_RES_ALL, MonsterResistanceType::RESIST_ALL },
 128         { SavedataLoreOlderThan14FlagType::RFR_RES_TELE, MonsterResistanceType::RESIST_TELEPORT }
 129     };
 130
 131     if (old_flags == 0) {
 132         return;
 133     }
 134
 135     for (const auto &f : flag_list) {
 136         if (any_bits(old_flags, f.old_flag)) {
 137             r_ptr->r_resistance_flags.set(f.flag);
 138         }
 139     }
 140 }
 141
 142 static void migrate_old_drop_flags(MonsterRaceInfo *r_ptr, BIT_FLAGS old_flags1)
 143 {
 144     if (!loading_savefile_version_is_older_than(18)) {
 145         rd_FlagGroup(r_ptr->r_drop_flags, rd_byte);
 146         return;
 147     }
 148
 149     struct flag_list_ver18 {
 150         SavedataLoreOlderThan18FlagType old_flag;
 151         MonsterDropType flag;
 152     };
 153
 154     std::vector<flag_list_ver18> flag_list = {
 155         { SavedataLoreOlderThan18FlagType::RF1_ONLY_GOLD, MonsterDropType::ONLY_GOLD },
 156         { SavedataLoreOlderThan18FlagType::RF1_ONLY_ITEM, MonsterDropType::ONLY_ITEM },
 157         { SavedataLoreOlderThan18FlagType::RF1_DROP_GOOD, MonsterDropType::DROP_GOOD },
 158         { SavedataLoreOlderThan18FlagType::RF1_DROP_GREAT, MonsterDropType::DROP_GREAT },
 159         { SavedataLoreOlderThan18FlagType::RF1_DROP_60, MonsterDropType::DROP_60 },
 160         { SavedataLoreOlderThan18FlagType::RF1_DROP_90, MonsterDropType::DROP_90 },
 161         { SavedataLoreOlderThan18FlagType::RF1_DROP_1D2, MonsterDropType::DROP_1D2 },
 162         { SavedataLoreOlderThan18FlagType::RF1_DROP_2D2, MonsterDropType::DROP_2D2 },
 163         { SavedataLoreOlderThan18FlagType::RF1_DROP_3D2, MonsterDropType::DROP_3D2 },
 164         { SavedataLoreOlderThan18FlagType::RF1_DROP_4D2, MonsterDropType::DROP_4D2 },
 165     };
 166
 167     for (const auto &l : flag_list) {
 168         if (any_bits(old_flags1, enum2i(l.old_flag))) {
 169             r_ptr->r_drop_flags.set(l.flag);
 170         }
 171     }
 172 }
 173
 174 static void migrate_old_no_debuff_flags(MonsterRaceInfo *r_ptr, BIT_FLAGS old_flags3)
 175 {
 176     if (!loading_savefile_version_is_older_than(19)) {
 177         return;
 178     }
 179
 180     struct flag_list_ver19 {
 181         SavedataLoreOlderThan19FlagType_No_Debuff old_flag;
 182         MonsterResistanceType flag;
 183     };
 184
 185     const std::vector<flag_list_ver19> flag_list = {
 186         { SavedataLoreOlderThan19FlagType_No_Debuff::RF3_NO_FEAR, MonsterResistanceType::NO_FEAR },
 187         { SavedataLoreOlderThan19FlagType_No_Debuff::RF3_NO_STUN, MonsterResistanceType::NO_STUN },
 188         { SavedataLoreOlderThan19FlagType_No_Debuff::RF3_NO_CONF, MonsterResistanceType::NO_CONF },
 189         { SavedataLoreOlderThan19FlagType_No_Debuff::RF3_NO_SLEEP, MonsterResistanceType::NO_SLEEP },
 190     };
 191
 192     for (const auto &l : flag_list) {
 193         if (any_bits(old_flags3, l.old_flag)) {
 194             r_ptr->r_resistance_flags.set(l.flag);
 195         }
 196     }
 197 }
 198
 199 static void migrate_old_resistance_and_ability_flags(MonsterRaceInfo *r_ptr, BIT_FLAGS f3, const MonsterRaceId r_idx)
 200 {
 201     if (loading_savefile_version_is_older_than(3)) {
 202         BIT_FLAGS r_flagsr = 0;
 203         uint32_t f4 = rd_u32b();
 204         uint32_t f5 = rd_u32b();
 205         uint32_t f6 = rd_u32b();
 206         if (h_older_than(1, 5, 0, 3)) {
 207             set_old_lore(r_ptr, f3, f4, r_idx);
 208         } else {
 209             r_flagsr = rd_u32b();
 210         }
 211
 212         migrate_bitflag_to_flaggroup(r_ptr->r_ability_flags, f4, sizeof(uint32_t) * 8 * 0);
 213         migrate_bitflag_to_flaggroup(r_ptr->r_ability_flags, f5, sizeof(uint32_t) * 8 * 1);
 214         migrate_bitflag_to_flaggroup(r_ptr->r_ability_flags, f6, sizeof(uint32_t) * 8 * 2);
 215
 216         migrate_old_resistance_flags(r_ptr, r_flagsr);
 217     } else if (loading_savefile_version_is_older_than(14)) {
 218         BIT_FLAGS r_flagsr = rd_u32b();
 219         rd_FlagGroup(r_ptr->r_ability_flags, rd_byte);
 220
 221         migrate_old_resistance_flags(r_ptr, r_flagsr);
 222     } else {
 223         rd_FlagGroup(r_ptr->r_resistance_flags, rd_byte);
 224         rd_FlagGroup(r_ptr->r_ability_flags, rd_byte);
 225     }
 226 }
 227
 228 static void migrate_old_kind_flags(MonsterRaceInfo *r_ptr, BIT_FLAGS old_flags1, BIT_FLAGS old_flags2, BIT_FLAGS old_flags3)
 229 {
 230     if (!loading_savefile_version_is_older_than(12)) {
 231         rd_FlagGroup(r_ptr->r_kind_flags, rd_byte);
 232         return;
 233     }
 234
 235     struct flag_list_ver12 {
 236         SavedataLoreOlderThan12FlagType check_flag;
 237         MonsterKindType flag;
 238     };
 239
 240     const std::vector<flag_list_ver12> flag1 = {
 241         { SavedataLoreOlderThan12FlagType::RF1_UNIQUE, MonsterKindType::UNIQUE },
 242     };
 243
 244     const std::vector<flag_list_ver12> flag2 = {
 245         { SavedataLoreOlderThan12FlagType::RF2_HUMAN, MonsterKindType::HUMAN },
 246         { SavedataLoreOlderThan12FlagType::RF2_QUANTUM, MonsterKindType::QUANTUM },
 247     };
 248
 249     const std::vector<flag_list_ver12> flag3 = {
 250         { SavedataLoreOlderThan12FlagType::RF3_ORC, MonsterKindType::ORC },
 251         { SavedataLoreOlderThan12FlagType::RF3_TROLL, MonsterKindType::TROLL },
 252         { SavedataLoreOlderThan12FlagType::RF3_GIANT, MonsterKindType::GIANT },
 253         { SavedataLoreOlderThan12FlagType::RF3_DRAGON, MonsterKindType::DRAGON },
 254         { SavedataLoreOlderThan12FlagType::RF3_DEMON, MonsterKindType::DEMON },
 255         { SavedataLoreOlderThan12FlagType::RF3_AMBERITE, MonsterKindType::AMBERITE },
 256         { SavedataLoreOlderThan12FlagType::RF3_ANGEL, MonsterKindType::ANGEL },
 257         { SavedataLoreOlderThan12FlagType::RF3_DRAGON, MonsterKindType::DRAGON },
 258         { SavedataLoreOlderThan12FlagType::RF3_EVIL, MonsterKindType::EVIL },
 259         { SavedataLoreOlderThan12FlagType::RF3_GOOD, MonsterKindType::GOOD },
 260         { SavedataLoreOlderThan12FlagType::RF3_ANIMAL, MonsterKindType::ANIMAL },
 261         { SavedataLoreOlderThan12FlagType::RF3_UNDEAD, MonsterKindType::UNDEAD },
 262
 263     };
 264
 265     for (const auto &f : flag1) {
 266         if (any_bits(old_flags1, f.check_flag)) {
 267             r_ptr->r_kind_flags.set(f.flag);
 268         }
 269     }
 270
 271     for (const auto &f : flag2) {
 272         if (any_bits(old_flags2, f.check_flag)) {
 273             r_ptr->r_kind_flags.set(f.flag);
 274         }
 275     }
 276
 277     for (const auto &f : flag3) {
 278         if (any_bits(old_flags3, f.check_flag)) {
 279             r_ptr->r_kind_flags.set(f.flag);
 280         }
 281     }
 282 }
 283
 284 static void migrate_old_behavior_flags(MonsterRaceInfo *r_ptr, BIT_FLAGS old_flags1, BIT_FLAGS old_flags2)
 285 {
 286     if (!loading_savefile_version_is_older_than(11)) {
 287         rd_FlagGroup(r_ptr->r_behavior_flags, rd_byte);
 288         return;
 289     }
 290
 291     struct flag_list_ver11 {
 292         SavedataLoreOlderThan11FlagType check_flag;
 293         MonsterBehaviorType flag;
 294     };
 295
 296     const std::vector<flag_list_ver11> flag1 = {
 297         { SavedataLoreOlderThan11FlagType::RF1_NEVER_BLOW, MonsterBehaviorType::NEVER_BLOW },
 298         { SavedataLoreOlderThan11FlagType::RF1_NEVER_MOVE, MonsterBehaviorType::NEVER_MOVE },
 299         { SavedataLoreOlderThan11FlagType::RF1_RAND_25, MonsterBehaviorType::RAND_MOVE_25 },
 300         { SavedataLoreOlderThan11FlagType::RF1_RAND_50, MonsterBehaviorType::RAND_MOVE_50 },
 301     };
 302
 303     const std::vector<flag_list_ver11> flag2 = {
 304         { SavedataLoreOlderThan11FlagType::RF2_OPEN_DOOR, MonsterBehaviorType::OPEN_DOOR },
 305         { SavedataLoreOlderThan11FlagType::RF2_BASH_DOOR, MonsterBehaviorType::BASH_DOOR },
 306         { SavedataLoreOlderThan11FlagType::RF2_MOVE_BODY, MonsterBehaviorType::MOVE_BODY },
 307         { SavedataLoreOlderThan11FlagType::RF2_KILL_BODY, MonsterBehaviorType::KILL_BODY },
 308         { SavedataLoreOlderThan11FlagType::RF2_TAKE_ITEM, MonsterBehaviorType::TAKE_ITEM },
 309         { SavedataLoreOlderThan11FlagType::RF2_KILL_ITEM, MonsterBehaviorType::KILL_ITEM },
 310         { SavedataLoreOlderThan11FlagType::RF2_STUPID, MonsterBehaviorType::STUPID },
 311         { SavedataLoreOlderThan11FlagType::RF2_SMART, MonsterBehaviorType::SMART },
 312     };
 313
 314     for (const auto &f : flag1) {
 315         if (any_bits(old_flags1, f.check_flag)) {
 316             r_ptr->r_behavior_flags.set(f.flag);
 317         }
 318     }
 319
 320     for (const auto &f : flag2) {
 321         if (any_bits(old_flags2, f.check_flag)) {
 322             r_ptr->r_behavior_flags.set(f.flag);
 323         }
 324     }
 325 }
 326
 327 /*!
 328  * @brief モンスターの思い出を読み込む / Read the monster lore
 329  * @param r_ptr 読み込み先モンスター種族情報へのポインタ
 330  * @param r_idx 読み込み先モンスターID(種族特定用)
 331  */
 332 static void rd_lore(MonsterRaceInfo *r_ptr, const MonsterRaceId r_idx)
 333 {
 334     r_ptr->r_sights = rd_s16b();
 335     r_ptr->r_deaths = rd_s16b();
 336     r_ptr->r_pkills = rd_s16b();
 337
 338     if (h_older_than(1, 7, 0, 5)) {
 339         r_ptr->r_akills = r_ptr->r_pkills;
 340     } else {
 341         r_ptr->r_akills = rd_s16b();
 342     }
 343
 344     r_ptr->r_tkills = rd_s16b();
 345
 346     r_ptr->r_wake = rd_byte();
 347     r_ptr->r_ignore = rd_byte();
 348
 349     r_ptr->r_can_evolve = rd_byte() > 0;
 350     if (loading_savefile_version_is_older_than(6)) {
 351         // かつては未使用フラグr_ptr->r_xtra2だった.
 352         strip_bytes(1);
 353     }
 354
 355     r_ptr->r_drop_gold = rd_byte();
 356     r_ptr->r_drop_item = rd_byte();
 357
 358     strip_bytes(1);
 359     r_ptr->r_cast_spell = rd_byte();
 360
 361     r_ptr->r_blows[0] = rd_byte();
 362     r_ptr->r_blows[1] = rd_byte();
 363     r_ptr->r_blows[2] = rd_byte();
 364     r_ptr->r_blows[3] = rd_byte();
 365
 366     if (loading_savefile_version_is_older_than(21)) {
 367         auto r_flags1 = rd_u32b();
 368         auto r_flags2 = rd_u32b();
 369         auto r_flags3 = rd_u32b();
 370
 371         migrate_old_no_debuff_flags(r_ptr, r_flags3);
 372         migrate_old_resistance_and_ability_flags(r_ptr, r_flags3, r_idx);
 373         migrate_old_aura_flags(r_ptr, r_flags2, r_flags3);
 374         migrate_old_behavior_flags(r_ptr, r_flags1, r_flags2);
 375         migrate_old_kind_flags(r_ptr, r_flags1, r_flags2, r_flags3);
 376         migrate_old_drop_flags(r_ptr, r_flags1);
 377         migrate_old_feature_flags(r_ptr, r_flags2);
 378         if (!loading_savefile_version_is_older_than(20)) {
 379             rd_FlagGroup(r_ptr->r_special_flags, rd_byte);
 380         }
 381         migrate_old_misc_flags(r_ptr, r_flags1, r_flags2);
 382     } else {
 383         rd_FlagGroup(r_ptr->r_resistance_flags, rd_byte);
 384         rd_FlagGroup(r_ptr->r_ability_flags, rd_byte);
 385         rd_FlagGroup(r_ptr->r_aura_flags, rd_byte);
 386         rd_FlagGroup(r_ptr->r_behavior_flags, rd_byte);
 387         rd_FlagGroup(r_ptr->r_kind_flags, rd_byte);
 388         rd_FlagGroup(r_ptr->r_drop_flags, rd_byte);
 389         rd_FlagGroup(r_ptr->r_feature_flags, rd_byte);
 390         rd_FlagGroup(r_ptr->r_special_flags, rd_byte);
 391         rd_FlagGroup(r_ptr->r_misc_flags, rd_byte);
 392     }
 393
 394     r_ptr->max_num = rd_byte();
 395     r_ptr->floor_id = rd_s16b();
 396
 397     if (!loading_savefile_version_is_older_than(4)) {
 398         r_ptr->defeat_level = rd_s16b();
 399         r_ptr->defeat_time = rd_u32b();
 400     }
 401
 402     strip_bytes(1);
 403
 404     r_ptr->r_resistance_flags &= r_ptr->resistance_flags;
 405     r_ptr->r_ability_flags &= r_ptr->ability_flags;
 406     r_ptr->r_aura_flags &= r_ptr->aura_flags;
 407     r_ptr->r_behavior_flags &= r_ptr->behavior_flags;
 408     r_ptr->r_drop_flags &= r_ptr->drop_flags;
 409     r_ptr->r_kind_flags &= r_ptr->kind_flags;
 410     r_ptr->r_feature_flags &= r_ptr->feature_flags;
 411     r_ptr->r_special_flags &= r_ptr->special_flags;
 412     r_ptr->r_misc_flags &= r_ptr->misc_flags;
 413 }
 414
 415 void load_lore(void)
 416 {
 417     auto loading_max_r_idx = rd_u16b();
 418     MonsterRaceInfo dummy;
 419     for (auto i = 0U; i < loading_max_r_idx; i++) {
 420         auto r_idx = static_cast<MonsterRaceId>(i);
 421         auto *r_ptr = i < monraces_info.size() ? &monraces_info[r_idx] : &dummy;
 422         rd_lore(r_ptr, r_idx);
 423     }
 424
 425     for (size_t i = loading_max_r_idx; i < monraces_info.size(); i++) {
 426         auto monrace_id = i2enum<MonsterRaceId>(i);
 427         auto &monrace = monraces_info[monrace_id];
 428         auto max_num = MAX_MONSTER_NUM;
 429         if (monrace.kind_flags.has(MonsterKindType::UNIQUE) || monrace.population_flags.has(MonsterPopulationType::ONLY_ONE)) {
 430             max_num = MAX_UNIQUE_NUM;
 431         } else if (monrace.population_flags.has(MonsterPopulationType::NAZGUL)) {
 432             max_num = MAX_NAZGUL_NUM;
 433         }
 434
 435         monrace.max_num = max_num;
 436     }
 437
 438     load_note(_("モンスターの思い出をロードしました", "Loaded Monster Memory"));
 439 }