src/object2.c

   1 /*!
   2  * @file object2.c
   3  * @brief オブジェクトの実装 / Object code, part 2
   4  * @date 2014/01/11
   5  * @author
   6  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke\n
   7  *\n
   8  * This software may be copied and distributed for educational, research,\n
   9  * and not for profit purposes provided that this copyright and statement\n
  10  * are included in all such copies.  Other copyrights may also apply.\n
  11  * 2014 Deskull rearranged comment for Doxygen.\n
  12  */
  13
  14 #include "angband.h"
  15 #include "object-hook.h"
  16 #include "object-curse.h"
  17
  18 static void one_sustain(object_type *o_ptr);
  19
  20
  21 static cptr const kaji_tips[5] =
  22 {
  23 #ifdef JP
  24         "現在持っているエッセンスの一覧を表示する。",
  25         "アイテムからエッセンスを取り出す。エッセンスを取られたアイテムは全く魔法がかかっていない初期状態に戻る。",
  26         "既にエッセンスが付加されたアイテムからエッセンスのみ消し去る。エッセンスは手に入らない。",
  27         "アイテムにエッセンスを付加する。既にエッセンスが付加されたアイテムやアーティファクトには付加できない。",
  28         "武器や防具を強化したり、攻撃で傷つかないようにしたりする。エッセンスが付加されたアイテムやアーティファクトに対しても使用できる。",
  29 #else
  30         "Display essences you have.",
  31         "Extract essences from an item. The item become non magical.",
  32         "Remove added essences from an equipment which was improved before. The removed essence will be ruined.",
  33         "Add essences to an item. The improved items or artifacts cannot be reimprove.",
  34         "Enchant an equipment or make an equiment element-proofed. The improved items and artifacts can be enchanted too.",
  35 #endif
  36 };
  37
  38 /*!
  39  * @brief 対象のオブジェクトにランダムな能力維持を一つ付加する。/ Choose one random sustain
  40  * @details 重複の抑止はない。
  41  * @param o_ptr 対象のオブジェクト構造体ポインタ
  42  * @return なし
  43  */
  44 static void one_sustain(object_type *o_ptr)
  45 {
  46         switch (randint0(6))
  47         {
  48         case 0: add_flag(o_ptr->art_flags, TR_SUST_STR); break;
  49         case 1: add_flag(o_ptr->art_flags, TR_SUST_INT); break;
  50         case 2: add_flag(o_ptr->art_flags, TR_SUST_WIS); break;
  51         case 3: add_flag(o_ptr->art_flags, TR_SUST_DEX); break;
  52         case 4: add_flag(o_ptr->art_flags, TR_SUST_CON); break;
  53         case 5: add_flag(o_ptr->art_flags, TR_SUST_CHR); break;
  54         }
  55 }
  56
  57 /*!
  58  * @brief 床上、モンスター所持でスタックされたアイテムを削除しスタックを補完する / Excise a dungeon object from any stacks
  59  * @param o_idx 削除対象のオブジェクト構造体ポインタ
  60  * @return なし
  61  */
  62 void excise_object_idx(OBJECT_IDX o_idx)
  63 {
  64         object_type *j_ptr;
  65
  66         OBJECT_IDX this_o_idx, next_o_idx = 0;
  67         OBJECT_IDX prev_o_idx = 0;
  68
  69         /* Object */
  70         j_ptr = &o_list[o_idx];
  71
  72         /* Monster */
  73         if (j_ptr->held_m_idx)
  74         {
  75                 monster_type *m_ptr;
  76
  77                 /* Monster */
  78                 m_ptr = &m_list[j_ptr->held_m_idx];
  79
  80                 /* Scan all objects in the grid */
  81                 for (this_o_idx = m_ptr->hold_o_idx; this_o_idx; this_o_idx = next_o_idx)
  82                 {
  83                         object_type *o_ptr;
  84                         o_ptr = &o_list[this_o_idx];
  85
  86                         /* Acquire next object */
  87                         next_o_idx = o_ptr->next_o_idx;
  88
  89                         if (this_o_idx == o_idx)
  90                         {
  91                                 /* No previous */
  92                                 if (prev_o_idx == 0)
  93                                 {
  94                                         /* Remove from list */
  95                                         m_ptr->hold_o_idx = next_o_idx;
  96                                 }
  97
  98                                 /* Real previous */
  99                                 else
 100                                 {
 101                                         object_type *k_ptr;
 102
 103                                         /* Previous object */
 104                                         k_ptr = &o_list[prev_o_idx];
 105
 106                                         /* Remove from list */
 107                                         k_ptr->next_o_idx = next_o_idx;
 108                                 }
 109
 110                                 /* Forget next pointer */
 111                                 o_ptr->next_o_idx = 0;
 112
 113                                 break;
 114                         }
 115
 116                         /* Save prev_o_idx */
 117                         prev_o_idx = this_o_idx;
 118                 }
 119         }
 120
 121         /* Dungeon */
 122         else
 123         {
 124                 cave_type *c_ptr;
 125
 126                 POSITION y = j_ptr->iy;
 127                 POSITION x = j_ptr->ix;
 128
 129                 /* Grid */
 130                 c_ptr = &cave[y][x];
 131
 132                 /* Scan all objects in the grid */
 133                 for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
 134                 {
 135                         object_type *o_ptr;
 136                         o_ptr = &o_list[this_o_idx];
 137
 138                         /* Acquire next object */
 139                         next_o_idx = o_ptr->next_o_idx;
 140
 141                         if (this_o_idx == o_idx)
 142                         {
 143                                 /* No previous */
 144                                 if (prev_o_idx == 0)
 145                                 {
 146                                         /* Remove from list */
 147                                         c_ptr->o_idx = next_o_idx;
 148                                 }
 149
 150                                 /* Real previous */
 151                                 else
 152                                 {
 153                                         object_type *k_ptr;
 154
 155                                         /* Previous object */
 156                                         k_ptr = &o_list[prev_o_idx];
 157
 158                                         /* Remove from list */
 159                                         k_ptr->next_o_idx = next_o_idx;
 160                                 }
 161
 162                                 /* Forget next pointer */
 163                                 o_ptr->next_o_idx = 0;
 164
 165                                 break;
 166                         }
 167
 168                         /* Save prev_o_idx */
 169                         prev_o_idx = this_o_idx;
 170                 }
 171         }
 172 }
 173
 174 /*!
 175  * @brief オブジェクトを削除する /
 176  * Delete a dungeon object
 177  * @param o_idx 削除対象のオブジェクト構造体ポインタ
 178  * @return なし
 179  * @details
 180  * Handle "stacks" of objects correctly.
 181  */
 182 void delete_object_idx(OBJECT_IDX o_idx)
 183 {
 184         object_type *j_ptr;
 185
 186         /* Excise */
 187         excise_object_idx(o_idx);
 188
 189         /* Object */
 190         j_ptr = &o_list[o_idx];
 191
 192         /* Dungeon floor */
 193         if (!(j_ptr->held_m_idx))
 194         {
 195                 POSITION y, x;
 196
 197                 y = j_ptr->iy;
 198                 x = j_ptr->ix;
 199
 200                 /* Visual update */
 201                 lite_spot(y, x);
 202         }
 203         object_wipe(j_ptr);
 204
 205         /* Count objects */
 206         o_cnt--;
 207 }
 208
 209
 210 /*!
 211  * @brief フロアにマスに落ちているオブジェクトを全て削除する / Deletes all objects at given location
 212  * Delete a dungeon object
 213  * @param y 削除したフロアマスのY座標
 214  * @param x 削除したフロアマスのX座標
 215  * @return なし
 216  */
 217 void delete_object(POSITION y, POSITION x)
 218 {
 219         cave_type *c_ptr;
 220         OBJECT_IDX this_o_idx, next_o_idx = 0;
 221
 222         /* Refuse "illegal" locations */
 223         if (!in_bounds(y, x)) return;
 224
 225         /* Grid */
 226         c_ptr = &cave[y][x];
 227
 228         /* Scan all objects in the grid */
 229         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
 230         {
 231                 object_type *o_ptr;
 232                 o_ptr = &o_list[this_o_idx];
 233
 234                 /* Acquire next object */
 235                 next_o_idx = o_ptr->next_o_idx;
 236                 object_wipe(o_ptr);
 237
 238                 /* Count objects */
 239                 o_cnt--;
 240         }
 241
 242         /* Objects are gone */
 243         c_ptr->o_idx = 0;
 244
 245         /* Visual update */
 246         lite_spot(y, x);
 247 }
 248
 249
 250 /*!
 251  * @brief グローバルオブジェクト配列に対し指定範囲のオブジェクトを整理してIDの若い順に寄せる /
 252  * Move an object from index i1 to index i2 in the object list
 253  * @param i1 整理したい配列の始点
 254  * @param i2 整理したい配列の終点
 255  * @return なし
 256  */
 257 static void compact_objects_aux(OBJECT_IDX i1, OBJECT_IDX i2)
 258 {
 259         OBJECT_IDX i;
 260         cave_type *c_ptr;
 261         object_type *o_ptr;
 262
 263         /* Do nothing */
 264         if (i1 == i2) return;
 265
 266         /* Repair objects */
 267         for (i = 1; i < o_max; i++)
 268         {
 269                 o_ptr = &o_list[i];
 270
 271                 /* Skip "dead" objects */
 272                 if (!o_ptr->k_idx) continue;
 273
 274                 /* Repair "next" pointers */
 275                 if (o_ptr->next_o_idx == i1)
 276                 {
 277                         /* Repair */
 278                         o_ptr->next_o_idx = i2;
 279                 }
 280         }
 281         o_ptr = &o_list[i1];
 282
 283         /* Monster */
 284         if (o_ptr->held_m_idx)
 285         {
 286                 monster_type *m_ptr;
 287
 288                 /* Acquire monster */
 289                 m_ptr = &m_list[o_ptr->held_m_idx];
 290
 291                 /* Repair monster */
 292                 if (m_ptr->hold_o_idx == i1)
 293                 {
 294                         /* Repair */
 295                         m_ptr->hold_o_idx = i2;
 296                 }
 297         }
 298
 299         /* Dungeon */
 300         else
 301         {
 302                 POSITION y, x;
 303
 304                 /* Acquire location */
 305                 y = o_ptr->iy;
 306                 x = o_ptr->ix;
 307
 308                 /* Acquire grid */
 309                 c_ptr = &cave[y][x];
 310
 311                 /* Repair grid */
 312                 if (c_ptr->o_idx == i1)
 313                 {
 314                         /* Repair */
 315                         c_ptr->o_idx = i2;
 316                 }
 317         }
 318
 319         /* Structure copy */
 320         o_list[i2] = o_list[i1];
 321
 322         /* Wipe the hole */
 323         object_wipe(o_ptr);
 324 }
 325
 326
 327 /*!
 328  * @brief グローバルオブジェクト配列から優先度の低いものを削除し、データを圧縮する。 /
 329  * Compact and Reorder the object list.
 330  * @param size 最低でも減らしたいオブジェクト数の水準
 331  * @return なし
 332  * @details
 333  * （危険なので使用には注意すること）
 334  * This function can be very dangerous, use with caution!\n
 335  *\n
 336  * When actually "compacting" objects, we base the saving throw on a\n
 337  * combination of object level, distance from player, and current\n
 338  * "desperation".\n
 339  *\n
 340  * After "compacting" (if needed), we "reorder" the objects into a more\n
 341  * compact order, and we reset the allocation info, and the "live" array.\n
 342  */
 343 void compact_objects(int size)
 344 {
 345         OBJECT_IDX i;
 346         POSITION y, x;
 347         int num, cnt;
 348         int cur_lev, cur_dis, chance;
 349         object_type *o_ptr;
 350
 351         /* Compact */
 352         if (size)
 353         {
 354                 msg_print(_("アイテム情報を圧縮しています...", "Compacting objects..."));
 355                 p_ptr->redraw |= (PR_MAP);
 356                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
 357         }
 358
 359
 360         /* Compact at least 'size' objects */
 361         for (num = 0, cnt = 1; num < size; cnt++)
 362         {
 363                 /* Get more vicious each iteration */
 364                 cur_lev = 5 * cnt;
 365
 366                 /* Get closer each iteration */
 367                 cur_dis = 5 * (20 - cnt);
 368
 369                 /* Examine the objects */
 370                 for (i = 1; i < o_max; i++)
 371                 {
 372                         o_ptr = &o_list[i];
 373
 374                         /* Skip dead objects */
 375                         if (!o_ptr->k_idx) continue;
 376
 377                         /* Hack -- High level objects start out "immune" */
 378                         if (k_info[o_ptr->k_idx].level > cur_lev) continue;
 379
 380                         /* Monster */
 381                         if (o_ptr->held_m_idx)
 382                         {
 383                                 monster_type *m_ptr;
 384
 385                                 /* Acquire monster */
 386                                 m_ptr = &m_list[o_ptr->held_m_idx];
 387
 388                                 /* Get the location */
 389                                 y = m_ptr->fy;
 390                                 x = m_ptr->fx;
 391
 392                                 /* Monsters protect their objects */
 393                                 if (randint0(100) < 90) continue;
 394                         }
 395
 396                         /* Dungeon */
 397                         else
 398                         {
 399                                 /* Get the location */
 400                                 y = o_ptr->iy;
 401                                 x = o_ptr->ix;
 402                         }
 403
 404                         /* Nearby objects start out "immune" */
 405                         if ((cur_dis > 0) && (distance(p_ptr->y, p_ptr->x, y, x) < cur_dis)) continue;
 406
 407                         /* Saving throw */
 408                         chance = 90;
 409
 410                         /* Hack -- only compact artifacts in emergencies */
 411                         if ((object_is_fixed_artifact(o_ptr) || o_ptr->art_name) &&
 412                             (cnt < 1000)) chance = 100;
 413
 414                         /* Apply the saving throw */
 415                         if (randint0(100) < chance) continue;
 416
 417                         delete_object_idx(i);
 418
 419                         /* Count it */
 420                         num++;
 421                 }
 422         }
 423
 424
 425         /* Excise dead objects (backwards!) */
 426         for (i = o_max - 1; i >= 1; i--)
 427         {
 428                 o_ptr = &o_list[i];
 429
 430                 /* Skip real objects */
 431                 if (o_ptr->k_idx) continue;
 432
 433                 /* Move last object into open hole */
 434                 compact_objects_aux(o_max - 1, i);
 435
 436                 /* Compress "o_max" */
 437                 o_max--;
 438         }
 439 }
 440
 441
 442 /*!
 443  * @brief グローバルオブジェクト配列を初期化する /
 444  * Delete all the items when player leaves the level
 445  * @note we do NOT visually reflect these (irrelevant) changes
 446  * @details
 447  * Hack -- we clear the "c_ptr->o_idx" field for every grid,
 448  * and the "m_ptr->next_o_idx" field for every monster, since
 449  * we know we are clearing every object.  Technically, we only
 450  * clear those fields for grids/monsters containing objects,
 451  * and we clear it once for every such object.
 452  * @return なし
 453  */
 454 void wipe_o_list(void)
 455 {
 456         int i;
 457
 458         /* Delete the existing objects */
 459         for (i = 1; i < o_max; i++)
 460         {
 461                 object_type *o_ptr = &o_list[i];
 462
 463                 /* Skip dead objects */
 464                 if (!o_ptr->k_idx) continue;
 465
 466                 /* Mega-Hack -- preserve artifacts */
 467                 if (!character_dungeon || preserve_mode)
 468                 {
 469                         /* Hack -- Preserve unknown artifacts */
 470                         if (object_is_fixed_artifact(o_ptr) && !object_is_known(o_ptr))
 471                         {
 472                                 /* Mega-Hack -- Preserve the artifact */
 473                                 a_info[o_ptr->name1].cur_num = 0;
 474                         }
 475                 }
 476
 477                 /* Monster */
 478                 if (o_ptr->held_m_idx)
 479                 {
 480                         monster_type *m_ptr;
 481
 482                         /* Monster */
 483                         m_ptr = &m_list[o_ptr->held_m_idx];
 484
 485                         /* Hack -- see above */
 486                         m_ptr->hold_o_idx = 0;
 487                 }
 488
 489                 /* Dungeon */
 490                 else
 491                 {
 492                         cave_type *c_ptr;
 493
 494                         /* Access location */
 495                         POSITION y = o_ptr->iy;
 496                         POSITION x = o_ptr->ix;
 497
 498                         /* Access grid */
 499                         c_ptr = &cave[y][x];
 500
 501                         /* Hack -- see above */
 502                         c_ptr->o_idx = 0;
 503                 }
 504                 object_wipe(o_ptr);
 505         }
 506
 507         /* Reset "o_max" */
 508         o_max = 1;
 509
 510         /* Reset "o_cnt" */
 511         o_cnt = 0;
 512 }
 513
 514
 515 /*!
 516  * @brief グローバルオブジェクト配列から空きを取得する /
 517  * Acquires and returns the index of a "free" object.
 518  * @return 開いているオブジェクト要素のID
 519  * @details
 520  * This routine should almost never fail, but in case it does,
 521  * we must be sure to handle "failure" of this routine.
 522  */
 523 OBJECT_IDX o_pop(void)
 524 {
 525         OBJECT_IDX i;
 526
 527         /* Initial allocation */
 528         if (o_max < max_o_idx)
 529         {
 530                 /* Get next space */
 531                 i = o_max;
 532
 533                 /* Expand object array */
 534                 o_max++;
 535
 536                 /* Count objects */
 537                 o_cnt++;
 538
 539                 /* Use this object */
 540                 return (i);
 541         }
 542
 543
 544         /* Recycle dead objects */
 545         for (i = 1; i < o_max; i++)
 546         {
 547                 object_type *o_ptr;
 548                 o_ptr = &o_list[i];
 549
 550                 /* Skip live objects */
 551                 if (o_ptr->k_idx) continue;
 552
 553                 /* Count objects */
 554                 o_cnt++;
 555
 556                 /* Use this object */
 557                 return (i);
 558         }
 559
 560
 561         /* Warn the player (except during dungeon creation) */
 562         if (character_dungeon) msg_print(_("アイテムが多すぎる！", "Too many objects!"));
 563
 564         return (0);
 565 }
 566
 567
 568 /*!
 569  * @brief オブジェクト生成テーブルに生成制約を加える /
 570  * Apply a "object restriction function" to the "object allocation table"
 571  * @return 常に0を返す。
 572  * @details 生成の制約はグローバルのget_obj_num_hook関数ポインタで加える
 573  */
 574 static errr get_obj_num_prep(void)
 575 {
 576         int i;
 577
 578         /* Get the entry */
 579         alloc_entry *table = alloc_kind_table;
 580
 581         /* Scan the allocation table */
 582         for (i = 0; i < alloc_kind_size; i++)
 583         {
 584                 /* Accept objects which pass the restriction, if any */
 585                 if (!get_obj_num_hook || (*get_obj_num_hook)(table[i].index))
 586                 {
 587                         /* Accept this object */
 588                         table[i].prob2 = table[i].prob1;
 589                 }
 590
 591                 /* Do not use this object */
 592                 else
 593                 {
 594                         /* Decline this object */
 595                         table[i].prob2 = 0;
 596                 }
 597         }
 598
 599         /* Success */
 600         return (0);
 601 }
 602
 603
 604 /*!
 605  * @brief オブジェクト生成テーブルからアイテムを取得する /
 606  * Choose an object kind that seems "appropriate" to the given level
 607  * @param level 生成階
 608  * @return 選ばれたオブジェクトベースID
 609  * @details
 610  * This function uses the "prob2" field of the "object allocation table",\n
 611  * and various local information, to calculate the "prob3" field of the\n
 612  * same table, which is then used to choose an "appropriate" object, in\n
 613  * a relatively efficient manner.\n
 614  *\n
 615  * It is (slightly) more likely to acquire an object of the given level\n
 616  * than one of a lower level.  This is done by choosing several objects\n
 617  * appropriate to the given level and keeping the "hardest" one.\n
 618  *\n
 619  * Note that if no objects are "appropriate", then this function will\n
 620  * fail, and return zero, but this should *almost* never happen.\n
 621  */
 622 OBJECT_IDX get_obj_num(DEPTH level)
 623 {
 624         int i, j, p;
 625         KIND_OBJECT_IDX k_idx;
 626         long value, total;
 627         object_kind     *k_ptr;
 628         alloc_entry     *table = alloc_kind_table;
 629
 630         if (level > MAX_DEPTH - 1) level = MAX_DEPTH - 1;
 631
 632         /* Boost level */
 633         if ((level > 0) && !(d_info[dungeon_type].flags1 & DF1_BEGINNER))
 634         {
 635                 /* Occasional "boost" */
 636                 if (one_in_(GREAT_OBJ))
 637                 {
 638                         /* What a bizarre calculation */
 639                         level = 1 + (level * MAX_DEPTH / randint1(MAX_DEPTH));
 640                 }
 641         }
 642
 643         /* Reset total */
 644         total = 0L;
 645
 646         /* Process probabilities */
 647         for (i = 0; i < alloc_kind_size; i++)
 648         {
 649                 /* Objects are sorted by depth */
 650                 if (table[i].level > level) break;
 651
 652                 /* Default */
 653                 table[i].prob3 = 0;
 654
 655                 /* Access the index */
 656                 k_idx = table[i].index;
 657
 658                 /* Access the actual kind */
 659                 k_ptr = &k_info[k_idx];
 660
 661                 /* Hack -- prevent embedded chests */
 662                 if (opening_chest && (k_ptr->tval == TV_CHEST)) continue;
 663
 664                 /* Accept */
 665                 table[i].prob3 = table[i].prob2;
 666
 667                 /* Total */
 668                 total += table[i].prob3;
 669         }
 670
 671         /* No legal objects */
 672         if (total <= 0) return (0);
 673
 674
 675         /* Pick an object */
 676         value = randint0(total);
 677
 678         /* Find the object */
 679         for (i = 0; i < alloc_kind_size; i++)
 680         {
 681                 /* Found the entry */
 682                 if (value < table[i].prob3) break;
 683
 684                 /* Decrement */
 685                 value = value - table[i].prob3;
 686         }
 687
 688
 689         /* Power boost */
 690         p = randint0(100);
 691
 692         /* Try for a "better" object once (50%) or twice (10%) */
 693         if (p < 60)
 694         {
 695                 /* Save old */
 696                 j = i;
 697
 698                 /* Pick a object */
 699                 value = randint0(total);
 700
 701                 /* Find the object */
 702                 for (i = 0; i < alloc_kind_size; i++)
 703                 {
 704                         /* Found the entry */
 705                         if (value < table[i].prob3) break;
 706
 707                         /* Decrement */
 708                         value = value - table[i].prob3;
 709                 }
 710
 711                 /* Keep the "best" one */
 712                 if (table[i].level < table[j].level) i = j;
 713         }
 714
 715         /* Try for a "better" object twice (10%) */
 716         if (p < 10)
 717         {
 718                 /* Save old */
 719                 j = i;
 720
 721                 /* Pick a object */
 722                 value = randint0(total);
 723
 724                 /* Find the object */
 725                 for (i = 0; i < alloc_kind_size; i++)
 726                 {
 727                         /* Found the entry */
 728                         if (value < table[i].prob3) break;
 729
 730                         /* Decrement */
 731                         value = value - table[i].prob3;
 732                 }
 733
 734                 /* Keep the "best" one */
 735                 if (table[i].level < table[j].level) i = j;
 736         }
 737
 738         return (table[i].index);
 739 }
 740
 741
 742 /*!
 743  * @brief オブジェクトを鑑定済にする /
 744  * Known is true when the "attributes" of an object are "known".
 745  * @param o_ptr 鑑定済にするオブジェクトの構造体参照ポインタ
 746  * @return なし
 747  * These include tohit, todam, toac, cost, and pval (charges).\n
 748  *\n
 749  * Note that "knowing" an object gives you everything that an "awareness"\n
 750  * gives you, and much more.  In fact, the player is always "aware" of any\n
 751  * item of which he has full "knowledge".\n
 752  *\n
 753  * But having full knowledge of, say, one "wand of wonder", does not, by\n
 754  * itself, give you knowledge, or even awareness, of other "wands of wonder".\n
 755  * It happens that most "identify" routines (including "buying from a shop")\n
 756  * will make the player "aware" of the object as well as fully "know" it.\n
 757  *\n
 758  * This routine also removes any inscriptions generated by "feelings".\n
 759  */
 760 void object_known(object_type *o_ptr)
 761 {
 762         /* Remove "default inscriptions" */
 763         o_ptr->feeling = FEEL_NONE;
 764
 765         /* Clear the "Felt" info */
 766         o_ptr->ident &= ~(IDENT_SENSE);
 767
 768         /* Clear the "Empty" info */
 769         o_ptr->ident &= ~(IDENT_EMPTY);
 770
 771         /* Now we know about the item */
 772         o_ptr->ident |= (IDENT_KNOWN);
 773 }
 774
 775 /*!
 776  * @brief オブジェクトを＊鑑定＊済にする /
 777  * The player is now aware of the effects of the given object.
 778  * @param o_ptr ＊鑑定＊済にするオブジェクトの構造体参照ポインタ
 779  * @return なし
 780  */
 781 void object_aware(object_type *o_ptr)
 782 {
 783         bool mihanmei = !object_is_aware(o_ptr);
 784
 785         /* Fully aware of the effects */
 786         k_info[o_ptr->k_idx].aware = TRUE;
 787
 788         if(mihanmei && !(k_info[o_ptr->k_idx].gen_flags & TRG_INSTA_ART) && record_ident &&
 789            !p_ptr->is_dead && ((o_ptr->tval >= TV_AMULET && o_ptr->tval <= TV_POTION) || (o_ptr->tval == TV_FOOD)))
 790         {
 791                 object_type forge;
 792                 object_type *q_ptr;
 793                 char o_name[MAX_NLEN];
 794
 795                 q_ptr = &forge;
 796                 object_copy(q_ptr, o_ptr);
 797
 798                 q_ptr->number = 1;
 799                 object_desc(o_name, q_ptr, OD_NAME_ONLY);
 800
 801                 do_cmd_write_nikki(NIKKI_HANMEI, 0, o_name);
 802         }
 803 }
 804
 805 /*!
 806  * @brief オブジェクトを試行済にする /
 807  * Something has been "sampled"
 808  * @param o_ptr 試行済にするオブジェクトの構造体参照ポインタ
 809  * @return なし
 810  */
 811 void object_tried(object_type *o_ptr)
 812 {
 813         /* Mark it as tried (even if "aware") */
 814         k_info[o_ptr->k_idx].tried = TRUE;
 815 }
 816
 817 /*!
 818 * @brief 重度擬似鑑定の判断処理 / Return a "feeling" (or NULL) about an item.  Method 1 (Heavy).
 819 * @param o_ptr 擬似鑑定を行うオブジェクトの参照ポインタ。
 820 * @return 擬似鑑定結果のIDを返す。
 821 */
 822 byte value_check_aux1(object_type *o_ptr)
 823 {
 824         /* Artifacts */
 825         if (object_is_artifact(o_ptr))
 826         {
 827                 /* Cursed/Broken */
 828                 if (object_is_cursed(o_ptr) || object_is_broken(o_ptr)) return FEEL_TERRIBLE;
 829
 830                 /* Normal */
 831                 return FEEL_SPECIAL;
 832         }
 833
 834         /* Ego-Items */
 835         if (object_is_ego(o_ptr))
 836         {
 837                 /* Cursed/Broken */
 838                 if (object_is_cursed(o_ptr) || object_is_broken(o_ptr)) return FEEL_WORTHLESS;
 839
 840                 /* Normal */
 841                 return FEEL_EXCELLENT;
 842         }
 843
 844         /* Cursed items */
 845         if (object_is_cursed(o_ptr)) return FEEL_CURSED;
 846
 847         /* Broken items */
 848         if (object_is_broken(o_ptr)) return FEEL_BROKEN;
 849
 850         if ((o_ptr->tval == TV_RING) || (o_ptr->tval == TV_AMULET)) return FEEL_AVERAGE;
 851
 852         /* Good "armor" bonus */
 853         if (o_ptr->to_a > 0) return FEEL_GOOD;
 854
 855         /* Good "weapon" bonus */
 856         if (o_ptr->to_h + o_ptr->to_d > 0) return FEEL_GOOD;
 857
 858         /* Default to "average" */
 859         return FEEL_AVERAGE;
 860 }
 861
 862 /*!
 863 * @brief 軽度擬似鑑定の判断処理 / Return a "feeling" (or NULL) about an item.  Method 2 (Light).
 864 * @param o_ptr 擬似鑑定を行うオブジェクトの参照ポインタ。
 865 * @return 擬似鑑定結果のIDを返す。
 866 */
 867 byte value_check_aux2(object_type *o_ptr)
 868 {
 869         /* Cursed items (all of them) */
 870         if (object_is_cursed(o_ptr)) return FEEL_CURSED;
 871
 872         /* Broken items (all of them) */
 873         if (object_is_broken(o_ptr)) return FEEL_BROKEN;
 874
 875         /* Artifacts -- except cursed/broken ones */
 876         if (object_is_artifact(o_ptr)) return FEEL_UNCURSED;
 877
 878         /* Ego-Items -- except cursed/broken ones */
 879         if (object_is_ego(o_ptr)) return FEEL_UNCURSED;
 880
 881         /* Good armor bonus */
 882         if (o_ptr->to_a > 0) return FEEL_UNCURSED;
 883
 884         /* Good weapon bonuses */
 885         if (o_ptr->to_h + o_ptr->to_d > 0) return FEEL_UNCURSED;
 886
 887         /* No feeling */
 888         return FEEL_NONE;
 889 }
 890
 891 /*!
 892  * @brief 未鑑定なベースアイテムの基本価格を返す /
 893  * Return the "value" of an "unknown" item Make a guess at the value of non-aware items
 894  * @param o_ptr 未鑑定価格を確認したいオブジェクトの構造体参照ポインタ
 895  * @return オブジェクトの未鑑定価格
 896  */
 897 static s32b object_value_base(object_type *o_ptr)
 898 {
 899         /* Aware item -- use template cost */
 900         if (object_is_aware(o_ptr)) return (k_info[o_ptr->k_idx].cost);
 901
 902         /* Analyze the type */
 903         switch (o_ptr->tval)
 904         {
 905
 906                 /* Un-aware Food */
 907                 case TV_FOOD: return (5L);
 908
 909                 /* Un-aware Potions */
 910                 case TV_POTION: return (20L);
 911
 912                 /* Un-aware Scrolls */
 913                 case TV_SCROLL: return (20L);
 914
 915                 /* Un-aware Staffs */
 916                 case TV_STAFF: return (70L);
 917
 918                 /* Un-aware Wands */
 919                 case TV_WAND: return (50L);
 920
 921                 /* Un-aware Rods */
 922                 case TV_ROD: return (90L);
 923
 924                 /* Un-aware Rings */
 925                 case TV_RING: return (45L);
 926
 927                 /* Un-aware Amulets */
 928                 case TV_AMULET: return (45L);
 929
 930                 /* Figurines, relative to monster level */
 931                 case TV_FIGURINE:
 932                 {
 933                         DEPTH level = r_info[o_ptr->pval].level;
 934                         if (level < 20) return level*50L;
 935                         else if (level < 30) return 1000+(level-20)*150L;
 936                         else if (level < 40) return 2500+(level-30)*350L;
 937                         else if (level < 50) return 6000+(level-40)*800L;
 938                         else return 14000+(level-50)*2000L;
 939                 }
 940
 941                 case TV_CAPTURE:
 942                         if (!o_ptr->pval) return 1000L;
 943                         else return ((r_info[o_ptr->pval].level) * 50L + 1000);
 944         }
 945
 946         /* Paranoia -- Oops */
 947         return (0L);
 948 }
 949
 950
 951 /*!
 952  * @brief オブジェクトのフラグ類から価格を算出する /
 953  * Return the value of the flags the object has...
 954  * @param o_ptr フラグ価格を確認したいオブジェクトの構造体参照ポインタ
 955  * @param plusses フラグに与える価格の基本重み
 956  * @return オブジェクトのフラグ価格
 957  */
 958 s32b flag_cost(object_type *o_ptr, int plusses)
 959 {
 960         s32b total = 0;
 961         BIT_FLAGS flgs[TR_FLAG_SIZE];
 962         s32b tmp_cost;
 963         int count;
 964         int i;
 965         object_kind *k_ptr = &k_info[o_ptr->k_idx];
 966
 967         object_flags(o_ptr, flgs);
 968
 969         /*
 970          * Exclude fixed flags of the base item.
 971          * pval bonuses of base item will be treated later.
 972          */
 973         for (i = 0; i < TR_FLAG_SIZE; i++)
 974                 flgs[i] &= ~(k_ptr->flags[i]);
 975
 976         /* Exclude fixed flags of the fixed artifact. */
 977         if (object_is_fixed_artifact(o_ptr))
 978         {
 979                 artifact_type *a_ptr = &a_info[o_ptr->name1];
 980
 981                 for (i = 0; i < TR_FLAG_SIZE; i++)
 982                         flgs[i] &= ~(a_ptr->flags[i]);
 983         }
 984
 985         /* Exclude fixed flags of the ego-item. */
 986         else if (object_is_ego(o_ptr))
 987         {
 988                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
 989
 990                 for (i = 0; i < TR_FLAG_SIZE; i++)
 991                         flgs[i] &= ~(e_ptr->flags[i]);
 992         }
 993
 994
 995         /*
 996          * Calucurate values of remaining flags
 997          */
 998         if (have_flag(flgs, TR_STR)) total += (1500 * plusses);
 999         if (have_flag(flgs, TR_INT)) total += (1500 * plusses);
1000         if (have_flag(flgs, TR_WIS)) total += (1500 * plusses);
1001         if (have_flag(flgs, TR_DEX)) total += (1500 * plusses);
1002         if (have_flag(flgs, TR_CON)) total += (1500 * plusses);
1003         if (have_flag(flgs, TR_CHR)) total += (750 * plusses);
1004         if (have_flag(flgs, TR_MAGIC_MASTERY)) total += (600 * plusses);
1005         if (have_flag(flgs, TR_STEALTH)) total += (250 * plusses);
1006         if (have_flag(flgs, TR_SEARCH)) total += (100 * plusses);
1007         if (have_flag(flgs, TR_INFRA)) total += (150 * plusses);
1008         if (have_flag(flgs, TR_TUNNEL)) total += (175 * plusses);
1009         if ((have_flag(flgs, TR_SPEED)) && (plusses > 0))
1010                 total += (10000 + (2500 * plusses));
1011         if ((have_flag(flgs, TR_BLOWS)) && (plusses > 0))
1012                 total += (10000 + (2500 * plusses));
1013
1014         tmp_cost = 0;
1015         count = 0;
1016         if (have_flag(flgs, TR_CHAOTIC)) {total += 5000;count++;}
1017         if (have_flag(flgs, TR_VAMPIRIC)) {total += 6500;count++;}
1018         if (have_flag(flgs, TR_FORCE_WEAPON)) {tmp_cost += 2500;count++;}
1019         if (have_flag(flgs, TR_KILL_ANIMAL)) {tmp_cost += 2800;count++;}
1020         else if (have_flag(flgs, TR_SLAY_ANIMAL)) {tmp_cost += 1800;count++;}
1021         if (have_flag(flgs, TR_KILL_EVIL)) {tmp_cost += 3300;count++;}
1022         else if (have_flag(flgs, TR_SLAY_EVIL)) {tmp_cost += 2300;count++;}
1023         if (have_flag(flgs, TR_KILL_HUMAN)) {tmp_cost += 2800;count++;}
1024         else if (have_flag(flgs, TR_SLAY_HUMAN)) {tmp_cost += 1800;count++;}
1025         if (have_flag(flgs, TR_KILL_UNDEAD)) {tmp_cost += 2800;count++;}
1026         else if (have_flag(flgs, TR_SLAY_UNDEAD)) {tmp_cost += 1800;count++;}
1027         if (have_flag(flgs, TR_KILL_DEMON)) {tmp_cost += 2800;count++;}
1028         else if (have_flag(flgs, TR_SLAY_DEMON)) {tmp_cost += 1800;count++;}
1029         if (have_flag(flgs, TR_KILL_ORC)) {tmp_cost += 2500;count++;}
1030         else if (have_flag(flgs, TR_SLAY_ORC)) {tmp_cost += 1500;count++;}
1031         if (have_flag(flgs, TR_KILL_TROLL)) {tmp_cost += 2800;count++;}
1032         else if (have_flag(flgs, TR_SLAY_TROLL)) {tmp_cost += 1800;count++;}
1033         if (have_flag(flgs, TR_KILL_GIANT)) {tmp_cost += 2800;count++;}
1034         else if (have_flag(flgs, TR_SLAY_GIANT)) {tmp_cost += 1800;count++;}
1035         if (have_flag(flgs, TR_KILL_DRAGON)) {tmp_cost += 2800;count++;}
1036         else if (have_flag(flgs, TR_SLAY_DRAGON)) {tmp_cost += 1800;count++;}
1037
1038         if (have_flag(flgs, TR_VORPAL)) {tmp_cost += 2500;count++;}
1039         if (have_flag(flgs, TR_IMPACT)) {tmp_cost += 2500;count++;}
1040         if (have_flag(flgs, TR_BRAND_POIS)) {tmp_cost += 3800;count++;}
1041         if (have_flag(flgs, TR_BRAND_ACID)) {tmp_cost += 3800;count++;}
1042         if (have_flag(flgs, TR_BRAND_ELEC)) {tmp_cost += 3800;count++;}
1043         if (have_flag(flgs, TR_BRAND_FIRE)) {tmp_cost += 2500;count++;}
1044         if (have_flag(flgs, TR_BRAND_COLD)) {tmp_cost += 2500;count++;}
1045         total += (tmp_cost * count);
1046
1047         if (have_flag(flgs, TR_SUST_STR)) total += 850;
1048         if (have_flag(flgs, TR_SUST_INT)) total += 850;
1049         if (have_flag(flgs, TR_SUST_WIS)) total += 850;
1050         if (have_flag(flgs, TR_SUST_DEX)) total += 850;
1051         if (have_flag(flgs, TR_SUST_CON)) total += 850;
1052         if (have_flag(flgs, TR_SUST_CHR)) total += 250;
1053         if (have_flag(flgs, TR_RIDING)) total += 0;
1054         if (have_flag(flgs, TR_EASY_SPELL)) total += 1500;
1055         if (have_flag(flgs, TR_THROW)) total += 5000;
1056         if (have_flag(flgs, TR_FREE_ACT)) total += 4500;
1057         if (have_flag(flgs, TR_HOLD_EXP)) total += 8500;
1058
1059         tmp_cost = 0;
1060         count = 0;
1061         if (have_flag(flgs, TR_IM_ACID)) {tmp_cost += 15000;count += 2;}
1062         if (have_flag(flgs, TR_IM_ELEC)) {tmp_cost += 15000;count += 2;}
1063         if (have_flag(flgs, TR_IM_FIRE)) {tmp_cost += 15000;count += 2;}
1064         if (have_flag(flgs, TR_IM_COLD)) {tmp_cost += 15000;count += 2;}
1065         if (have_flag(flgs, TR_REFLECT)) {tmp_cost += 5000;count += 2;}
1066         if (have_flag(flgs, TR_RES_ACID)) {tmp_cost += 500;count++;}
1067         if (have_flag(flgs, TR_RES_ELEC)) {tmp_cost += 500;count++;}
1068         if (have_flag(flgs, TR_RES_FIRE)) {tmp_cost += 500;count++;}
1069         if (have_flag(flgs, TR_RES_COLD)) {tmp_cost += 500;count++;}
1070         if (have_flag(flgs, TR_RES_POIS)) {tmp_cost += 1000;count += 2;}
1071         if (have_flag(flgs, TR_RES_FEAR)) {tmp_cost += 1000;count += 2;}
1072         if (have_flag(flgs, TR_RES_LITE)) {tmp_cost += 800;count += 2;}
1073         if (have_flag(flgs, TR_RES_DARK)) {tmp_cost += 800;count += 2;}
1074         if (have_flag(flgs, TR_RES_BLIND)) {tmp_cost += 900;count += 2;}
1075         if (have_flag(flgs, TR_RES_CONF)) {tmp_cost += 900;count += 2;}
1076         if (have_flag(flgs, TR_RES_SOUND)) {tmp_cost += 900;count += 2;}
1077         if (have_flag(flgs, TR_RES_SHARDS)) {tmp_cost += 900;count += 2;}
1078         if (have_flag(flgs, TR_RES_NETHER)) {tmp_cost += 900;count += 2;}
1079         if (have_flag(flgs, TR_RES_NEXUS)) {tmp_cost += 900;count += 2;}
1080         if (have_flag(flgs, TR_RES_CHAOS)) {tmp_cost += 1000;count += 2;}
1081         if (have_flag(flgs, TR_RES_DISEN)) {tmp_cost += 2000;count += 2;}
1082         total += (tmp_cost * count);
1083
1084         if (have_flag(flgs, TR_SH_FIRE)) total += 5000;
1085         if (have_flag(flgs, TR_SH_ELEC)) total += 5000;
1086         if (have_flag(flgs, TR_SH_COLD)) total += 5000;
1087         if (have_flag(flgs, TR_NO_TELE)) total -= 10000;
1088         if (have_flag(flgs, TR_NO_MAGIC)) total += 2500;
1089         if (have_flag(flgs, TR_TY_CURSE)) total -= 15000;
1090         if (have_flag(flgs, TR_HIDE_TYPE)) total += 0;
1091         if (have_flag(flgs, TR_SHOW_MODS)) total += 0;
1092         if (have_flag(flgs, TR_LEVITATION)) total += 1250;
1093         if (have_flag(flgs, TR_LITE_1)) total += 1500;
1094         if (have_flag(flgs, TR_LITE_2)) total += 2500;
1095         if (have_flag(flgs, TR_LITE_3)) total += 4000;
1096         if (have_flag(flgs, TR_LITE_M1)) total -= 1500;
1097         if (have_flag(flgs, TR_LITE_M2)) total -= 2500;
1098         if (have_flag(flgs, TR_LITE_M3)) total -= 4000;
1099         if (have_flag(flgs, TR_SEE_INVIS)) total += 2000;
1100         if (have_flag(flgs, TR_TELEPATHY)) total += 20000;
1101         if (have_flag(flgs, TR_ESP_ANIMAL)) total += 1000;
1102         if (have_flag(flgs, TR_ESP_UNDEAD)) total += 1000;
1103         if (have_flag(flgs, TR_ESP_DEMON)) total += 1000;
1104         if (have_flag(flgs, TR_ESP_ORC)) total += 1000;
1105         if (have_flag(flgs, TR_ESP_TROLL)) total += 1000;
1106         if (have_flag(flgs, TR_ESP_GIANT)) total += 1000;
1107         if (have_flag(flgs, TR_ESP_DRAGON)) total += 1000;
1108         if (have_flag(flgs, TR_ESP_HUMAN)) total += 1000;
1109         if (have_flag(flgs, TR_ESP_EVIL)) total += 15000;
1110         if (have_flag(flgs, TR_ESP_GOOD)) total += 2000;
1111         if (have_flag(flgs, TR_ESP_NONLIVING)) total += 2000;
1112         if (have_flag(flgs, TR_ESP_UNIQUE)) total += 10000;
1113         if (have_flag(flgs, TR_SLOW_DIGEST)) total += 750;
1114         if (have_flag(flgs, TR_REGEN)) total += 2500;
1115         if (have_flag(flgs, TR_WARNING)) total += 2000;
1116         if (have_flag(flgs, TR_DEC_MANA)) total += 10000;
1117         if (have_flag(flgs, TR_XTRA_MIGHT)) total += 2250;
1118         if (have_flag(flgs, TR_XTRA_SHOTS)) total += 10000;
1119         if (have_flag(flgs, TR_IGNORE_ACID)) total += 100;
1120         if (have_flag(flgs, TR_IGNORE_ELEC)) total += 100;
1121         if (have_flag(flgs, TR_IGNORE_FIRE)) total += 100;
1122         if (have_flag(flgs, TR_IGNORE_COLD)) total += 100;
1123         if (have_flag(flgs, TR_ACTIVATE)) total += 100;
1124         if (have_flag(flgs, TR_DRAIN_EXP)) total -= 12500;
1125         if (have_flag(flgs, TR_DRAIN_HP)) total -= 12500;
1126         if (have_flag(flgs, TR_DRAIN_MANA)) total -= 12500;
1127         if (have_flag(flgs, TR_CALL_ANIMAL)) total -= 12500;
1128         if (have_flag(flgs, TR_CALL_DEMON)) total -= 10000;
1129         if (have_flag(flgs, TR_CALL_DRAGON)) total -= 10000;
1130         if (have_flag(flgs, TR_CALL_UNDEAD)) total -= 10000;
1131         if (have_flag(flgs, TR_COWARDICE)) total -= 5000;
1132         if (have_flag(flgs, TR_LOW_MELEE)) total -= 5000;
1133         if (have_flag(flgs, TR_LOW_AC)) total -= 5000;
1134         if (have_flag(flgs, TR_LOW_MAGIC)) total -= 15000;
1135         if (have_flag(flgs, TR_FAST_DIGEST)) total -= 10000;
1136         if (have_flag(flgs, TR_SLOW_REGEN)) total -= 10000;
1137         if (have_flag(flgs, TR_TELEPORT))
1138         {
1139                 if (object_is_cursed(o_ptr))
1140                         total -= 7500;
1141                 else
1142                         total += 250;
1143         }
1144         if (have_flag(flgs, TR_AGGRAVATE)) total -= 10000;
1145         if (have_flag(flgs, TR_BLESSED)) total += 750;
1146         if (o_ptr->curse_flags & TR_ADD_L_CURSE) total -= 5000;
1147         if (o_ptr->curse_flags & TR_ADD_H_CURSE) total -= 12500;
1148         if (o_ptr->curse_flags & TRC_CURSED) total -= 5000;
1149         if (o_ptr->curse_flags & TRC_HEAVY_CURSE) total -= 12500;
1150         if (o_ptr->curse_flags & TRC_PERMA_CURSE) total -= 15000;
1151
1152         /* Also, give some extra for activatable powers... */
1153         if (o_ptr->art_name && (have_flag(o_ptr->art_flags, TR_ACTIVATE)))
1154         {
1155                 const activation_type* const act_ptr = find_activation_info(o_ptr);
1156                 if (act_ptr) {
1157                         total += act_ptr->value;
1158                 }
1159         }
1160
1161         return total;
1162 }
1163
1164
1165 /*!
1166  * @brief オブジェクトの真の価格を算出する /
1167  * Return the value of the flags the object has...
1168  * @param o_ptr 本価格を確認したいオブジェクトの構造体参照ポインタ
1169  * @return オブジェクトの本価格
1170  * @details
1171  * Return the "real" price of a "known" item, not including discounts\n
1172  *\n
1173  * Wand and staffs get cost for each charge\n
1174  *\n
1175  * Armor is worth an extra 100 gold per bonus point to armor class.\n
1176  *\n
1177  * Weapons are worth an extra 100 gold per bonus point (AC,TH,TD).\n
1178  *\n
1179  * Missiles are only worth 5 gold per bonus point, since they\n
1180  * usually appear in groups of 20, and we want the player to get\n
1181  * the same amount of cash for any "equivalent" item.  Note that\n
1182  * missiles never have any of the "pval" flags, and in fact, they\n
1183  * only have a few of the available flags, primarily of the "slay"\n
1184  * and "brand" and "ignore" variety.\n
1185  *\n
1186  * Armor with a negative armor bonus is worthless.\n
1187  * Weapons with negative hit+damage bonuses are worthless.\n
1188  *\n
1189  * Every wearable item with a "pval" bonus is worth extra (see below).\n
1190  */
1191 PRICE object_value_real(object_type *o_ptr)
1192 {
1193         PRICE value;
1194         BIT_FLAGS flgs[TR_FLAG_SIZE];
1195         object_kind *k_ptr = &k_info[o_ptr->k_idx];
1196
1197
1198         /* Hack -- "worthless" items */
1199         if (!k_info[o_ptr->k_idx].cost) return (0L);
1200
1201         /* Base cost */
1202         value = k_info[o_ptr->k_idx].cost;
1203
1204         /* Extract some flags */
1205         object_flags(o_ptr, flgs);
1206
1207         /* Artifact */
1208         if (object_is_fixed_artifact(o_ptr))
1209         {
1210                 artifact_type *a_ptr = &a_info[o_ptr->name1];
1211
1212                 /* Hack -- "worthless" artifacts */
1213                 if (!a_ptr->cost) return (0L);
1214
1215                 /* Hack -- Use the artifact cost instead */
1216                 value = a_ptr->cost;
1217                 value += flag_cost(o_ptr, o_ptr->pval);
1218
1219                 /* Don't add pval bonuses etc. */
1220                 return (value);
1221         }
1222
1223         /* Ego-Item */
1224         else if (object_is_ego(o_ptr))
1225         {
1226                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
1227
1228                 /* Hack -- "worthless" ego-items */
1229                 if (!e_ptr->cost) return (0L);
1230
1231                 /* Hack -- Reward the ego-item with a bonus */
1232                 value += e_ptr->cost;
1233                 value += flag_cost(o_ptr, o_ptr->pval);
1234         }
1235
1236         else
1237         {
1238                 int i;
1239                 bool flag = FALSE;
1240
1241                 for (i = 0; i < TR_FLAG_SIZE; i++)
1242                         if (o_ptr->art_flags[i]) flag = TRUE;
1243
1244                 if (flag) value += flag_cost(o_ptr, o_ptr->pval);
1245         }
1246
1247         /* Analyze pval bonus for normal object */
1248         switch (o_ptr->tval)
1249         {
1250         case TV_SHOT:
1251         case TV_ARROW:
1252         case TV_BOLT:
1253         case TV_BOW:
1254         case TV_DIGGING:
1255         case TV_HAFTED:
1256         case TV_POLEARM:
1257         case TV_SWORD:
1258         case TV_BOOTS:
1259         case TV_GLOVES:
1260         case TV_HELM:
1261         case TV_CROWN:
1262         case TV_SHIELD:
1263         case TV_CLOAK:
1264         case TV_SOFT_ARMOR:
1265         case TV_HARD_ARMOR:
1266         case TV_DRAG_ARMOR:
1267         case TV_LITE:
1268         case TV_AMULET:
1269         case TV_RING:
1270                 /* No pval */
1271                 if (!o_ptr->pval) break;
1272
1273                 /* Hack -- Negative "pval" is always bad */
1274                 if (o_ptr->pval < 0) return (0L);
1275
1276                 /* Give credit for stat bonuses */
1277                 if (have_flag(flgs, TR_STR)) value += (o_ptr->pval * 200L);
1278                 if (have_flag(flgs, TR_INT)) value += (o_ptr->pval * 200L);
1279                 if (have_flag(flgs, TR_WIS)) value += (o_ptr->pval * 200L);
1280                 if (have_flag(flgs, TR_DEX)) value += (o_ptr->pval * 200L);
1281                 if (have_flag(flgs, TR_CON)) value += (o_ptr->pval * 200L);
1282                 if (have_flag(flgs, TR_CHR)) value += (o_ptr->pval * 200L);
1283
1284                 /* Give credit for stealth and searching */
1285                 if (have_flag(flgs, TR_MAGIC_MASTERY)) value += (o_ptr->pval * 100);
1286                 if (have_flag(flgs, TR_STEALTH)) value += (o_ptr->pval * 100L);
1287                 if (have_flag(flgs, TR_SEARCH)) value += (o_ptr->pval * 100L);
1288
1289                 /* Give credit for infra-vision and tunneling */
1290                 if (have_flag(flgs, TR_INFRA)) value += (o_ptr->pval * 50L);
1291                 if (have_flag(flgs, TR_TUNNEL)) value += (o_ptr->pval * 50L);
1292
1293                 /* Give credit for extra attacks */
1294                 if (have_flag(flgs, TR_BLOWS)) value += (o_ptr->pval * 5000L);
1295
1296                 /* Give credit for speed bonus */
1297                 if (have_flag(flgs, TR_SPEED)) value += (o_ptr->pval * 10000L);
1298
1299                 break;
1300         }
1301
1302
1303         /* Analyze the item */
1304         switch (o_ptr->tval)
1305         {
1306                 /* Wands/Staffs */
1307                 case TV_WAND:
1308                 {
1309                         /* Pay extra for charges, depending on standard number of
1310                          * charges.  Handle new-style wands correctly. -LM-
1311                          */
1312                         value += (value * o_ptr->pval / o_ptr->number / (k_ptr->pval * 2));
1313
1314                         break;
1315                 }
1316                 case TV_STAFF:
1317                 {
1318                         /* Pay extra for charges, depending on standard number of
1319                          * charges.  -LM-
1320                          */
1321                         value += (value * o_ptr->pval / (k_ptr->pval * 2));
1322
1323                         break;
1324                 }
1325
1326                 /* Rings/Amulets */
1327                 case TV_RING:
1328                 case TV_AMULET:
1329                 {
1330                         /* Hack -- negative bonuses are bad */
1331                         if (o_ptr->to_h + o_ptr->to_d + o_ptr->to_a < 0) return (0L);
1332
1333                         /* Give credit for bonuses */
1334                         value += ((o_ptr->to_h + o_ptr->to_d + o_ptr->to_a) * 200L);
1335
1336                         break;
1337                 }
1338
1339                 /* Armor */
1340                 case TV_BOOTS:
1341                 case TV_GLOVES:
1342                 case TV_CLOAK:
1343                 case TV_CROWN:
1344                 case TV_HELM:
1345                 case TV_SHIELD:
1346                 case TV_SOFT_ARMOR:
1347                 case TV_HARD_ARMOR:
1348                 case TV_DRAG_ARMOR:
1349                 {
1350                         /* Hack -- negative armor bonus */
1351                         if (o_ptr->to_a < 0) return (0L);
1352
1353                         /* Give credit for bonuses */
1354                         value += (((o_ptr->to_h - k_ptr->to_h) + (o_ptr->to_d - k_ptr->to_d)) * 200L + (o_ptr->to_a) * 100L);
1355
1356                         break;
1357                 }
1358
1359                 /* Bows/Weapons */
1360                 case TV_BOW:
1361                 case TV_DIGGING:
1362                 case TV_HAFTED:
1363                 case TV_SWORD:
1364                 case TV_POLEARM:
1365                 {
1366                         /* Hack -- negative hit/damage bonuses */
1367                         if (o_ptr->to_h + o_ptr->to_d < 0) return (0L);
1368
1369                         /* Factor in the bonuses */
1370                         value += ((o_ptr->to_h + o_ptr->to_d + o_ptr->to_a) * 100L);
1371
1372                         /* Hack -- Factor in extra damage dice and sides */
1373                         value += (o_ptr->dd - k_ptr->dd) * o_ptr->ds * 250L;
1374                         value += (o_ptr->ds - k_ptr->ds) * o_ptr->dd * 250L;
1375
1376                         break;
1377                 }
1378
1379                 /* Ammo */
1380                 case TV_SHOT:
1381                 case TV_ARROW:
1382                 case TV_BOLT:
1383                 {
1384                         /* Hack -- negative hit/damage bonuses */
1385                         if (o_ptr->to_h + o_ptr->to_d < 0) return (0L);
1386
1387                         /* Factor in the bonuses */
1388                         value += ((o_ptr->to_h + o_ptr->to_d) * 5L);
1389
1390                         /* Hack -- Factor in extra damage dice and sides */
1391                         value += (o_ptr->dd - k_ptr->dd) * o_ptr->ds * 5L;
1392                         value += (o_ptr->ds - k_ptr->ds) * o_ptr->dd * 5L;
1393
1394                         break;
1395                 }
1396
1397                 /* Figurines, relative to monster level */
1398                 case TV_FIGURINE:
1399                 {
1400                         DEPTH level = r_info[o_ptr->pval].level;
1401                         if (level < 20) value = level*50L;
1402                         else if (level < 30) value = 1000+(level-20)*150L;
1403                         else if (level < 40) value = 2500+(level-30)*350L;
1404                         else if (level < 50) value = 6000+(level-40)*800L;
1405                         else value = 14000+(level-50)*2000L;
1406                         break;
1407                 }
1408
1409                 case TV_CAPTURE:
1410                 {
1411                         if (!o_ptr->pval) value = 1000L;
1412                         else value = ((r_info[o_ptr->pval].level) * 50L + 1000);
1413                         break;
1414                 }
1415
1416                 case TV_CHEST:
1417                 {
1418                         if (!o_ptr->pval) value = 0L;
1419                         break;
1420                 }
1421         }
1422
1423         /* Worthless object */
1424         if (value < 0) return 0L;
1425
1426         /* Return the value */
1427         return (value);
1428 }
1429
1430
1431 /*!
1432  * @brief オブジェクト価格算出のメインルーチン /
1433  * Return the price of an item including plusses (and charges)
1434  * @param o_ptr 判明している現価格を確認したいオブジェクトの構造体参照ポインタ
1435  * @return オブジェクトの判明している現価格
1436  * @details
1437  * This function returns the "value" of the given item (qty one)\n
1438  *\n
1439  * Never notice "unknown" bonuses or properties, including "curses",\n
1440  * since that would give the player information he did not have.\n
1441  *\n
1442  * Note that discounted items stay discounted forever, even if\n
1443  * the discount is "forgotten" by the player via memory loss.\n
1444  */
1445 PRICE object_value(object_type *o_ptr)
1446 {
1447         PRICE value;
1448
1449         /* Unknown items -- acquire a base value */
1450         if (object_is_known(o_ptr))
1451         {
1452                 /* Broken items -- worthless */
1453                 if (object_is_broken(o_ptr)) return (0L);
1454
1455                 /* Cursed items -- worthless */
1456                 if (object_is_cursed(o_ptr)) return (0L);
1457
1458                 /* Real value (see above) */
1459                 value = object_value_real(o_ptr);
1460         }
1461
1462         /* Known items -- acquire the actual value */
1463         else
1464         {
1465                 /* Hack -- Felt broken items */
1466                 if ((o_ptr->ident & (IDENT_SENSE)) && object_is_broken(o_ptr)) return (0L);
1467
1468                 /* Hack -- Felt cursed items */
1469                 if ((o_ptr->ident & (IDENT_SENSE)) && object_is_cursed(o_ptr)) return (0L);
1470
1471                 /* Base value (see above) */
1472                 value = object_value_base(o_ptr);
1473         }
1474
1475
1476         /* Apply discount (if any) */
1477         if (o_ptr->discount) value -= (value * o_ptr->discount / 100L);
1478
1479
1480         /* Return the final value */
1481         return (value);
1482 }
1483
1484
1485
1486 /*!
1487  * @brief 破壊可能なアイテムかを返す /
1488  * Determines whether an object can be destroyed, and makes fake inscription.
1489  * @param o_ptr 破壊可能かを確認したいオブジェクトの構造体参照ポインタ
1490  * @return オブジェクトが破壊可能ならばTRUEを返す
1491  */
1492 bool can_player_destroy_object(object_type *o_ptr)
1493 {
1494         /* Artifacts cannot be destroyed */
1495         if (!object_is_artifact(o_ptr)) return TRUE;
1496
1497         /* If object is unidentified, makes fake inscription */
1498         if (!object_is_known(o_ptr))
1499         {
1500                 byte feel = FEEL_SPECIAL;
1501
1502                 /* Hack -- Handle icky artifacts */
1503                 if (object_is_cursed(o_ptr) || object_is_broken(o_ptr)) feel = FEEL_TERRIBLE;
1504
1505                 /* Hack -- inscribe the artifact */
1506                 o_ptr->feeling = feel;
1507
1508                 /* We have "felt" it (again) */
1509                 o_ptr->ident |= (IDENT_SENSE);
1510
1511                 /* Combine the pack */
1512                 p_ptr->notice |= (PN_COMBINE);
1513
1514                 p_ptr->window |= (PW_INVEN | PW_EQUIP);
1515
1516                 return FALSE;
1517         }
1518
1519         /* Identified artifact -- Nothing to do */
1520         return FALSE;
1521 }
1522
1523
1524 /*!
1525  * @brief 魔法棒やロッドのスロット分割時に使用回数を分配する /
1526  * Distribute charges of rods or wands.
1527  * @param o_ptr 分割元オブジェクトの構造体参照ポインタ source item
1528  * @param q_ptr 分割先オブジェクトの構造体参照ポインタ target item, must be of the same type as o_ptr
1529  * @param amt 分割したい回数量 number of items that are transfered
1530  * @return なし
1531  * @details
1532  * Hack -- If rods or wands are dropped, the total maximum timeout or\n
1533  * charges need to be allocated between the two stacks.  If all the items\n
1534  * are being dropped, it makes for a neater message to leave the original\n
1535  * stack's pval alone. -LM-\n
1536  */
1537 void distribute_charges(object_type *o_ptr, object_type *q_ptr, int amt)
1538 {
1539         if ((o_ptr->tval == TV_WAND) || (o_ptr->tval == TV_ROD))
1540         {
1541                 q_ptr->pval = o_ptr->pval * amt / o_ptr->number;
1542                 if (amt < o_ptr->number) o_ptr->pval -= q_ptr->pval;
1543
1544                 /* Hack -- Rods also need to have their timeouts distributed.  The
1545                  * dropped stack will accept all time remaining to charge up to its
1546                  * maximum.
1547                  */
1548                 if ((o_ptr->tval == TV_ROD) && (o_ptr->timeout))
1549                 {
1550                         if (q_ptr->pval > o_ptr->timeout)
1551                                 q_ptr->timeout = o_ptr->timeout;
1552                         else
1553                                 q_ptr->timeout = q_ptr->pval;
1554
1555                         if (amt < o_ptr->number) o_ptr->timeout -= q_ptr->timeout;
1556                 }
1557         }
1558 }
1559
1560 /*!
1561  * @brief 魔法棒やロッドの使用回数を減らす /
1562  * @param o_ptr オブジェクトの構造体参照ポインタ source item
1563  * @param amt 減らしたい回数量 number of items that are transfered
1564  * @return なし
1565  * @details
1566  * Hack -- If rods or wand are destroyed, the total maximum timeout or\n
1567  * charges of the stack needs to be reduced, unless all the items are\n
1568  * being destroyed. -LM-\n
1569  */
1570 void reduce_charges(object_type *o_ptr, int amt)
1571 {
1572         if (((o_ptr->tval == TV_WAND) || (o_ptr->tval == TV_ROD)) &&
1573                 (amt < o_ptr->number))
1574         {
1575                 o_ptr->pval -= o_ptr->pval * amt / o_ptr->number;
1576         }
1577 }
1578
1579 /*
1580  * Determine if an item can "absorb" a second item
1581  *
1582  * See "object_absorb()" for the actual "absorption" code.
1583  *
1584  * If permitted, we allow staffs (if they are known to have equal charges
1585  * and both are either known or confirmed empty) and wands (if both are
1586  * either known or confirmed empty) and rods (in all cases) to combine.
1587  * Staffs will unstack (if necessary) when they are used, but wands and
1588  * rods will only unstack if one is dropped. -LM-
1589  *
1590  * If permitted, we allow weapons/armor to stack, if fully "known".
1591  *
1592  * Missiles will combine if both stacks have the same "known" status.
1593  * This is done to make unidentified stacks of missiles useful.
1594  *
1595  * Food, potions, scrolls, and "easy know" items always stack.
1596  *
1597  * Chests, and activatable items, never stack (for various reasons).
1598  */
1599
1600 /*
1601  * A "stack" of items is limited to less than or equal to 99 items (hard-coded).
1602  */
1603 #define MAX_STACK_SIZE 99
1604
1605
1606 /*!
1607  * @brief 両オブジェクトをスロットに重ね合わせ可能な最大数を返す。
1608  * Determine if an item can partly absorb a second item. Return maximum number of stack.
1609  * @param o_ptr 検証したいオブジェクトの構造体参照ポインタ1
1610  * @param j_ptr 検証したいオブジェクトの構造体参照ポインタ2
1611  * @return 重ね合わせ可能なアイテム数
1612  */
1613 int object_similar_part(object_type *o_ptr, object_type *j_ptr)
1614 {
1615         int i;
1616
1617         /* Default maximum number of stack */
1618         int max_num = MAX_STACK_SIZE;
1619
1620         /* Require identical object types */
1621         if (o_ptr->k_idx != j_ptr->k_idx) return 0;
1622
1623
1624         /* Analyze the items */
1625         switch (o_ptr->tval)
1626         {
1627                 /* Chests and Statues*/
1628                 case TV_CHEST:
1629                 case TV_CARD:
1630                 case TV_CAPTURE:
1631                 {
1632                         /* Never okay */
1633                         return 0;
1634                 }
1635
1636                 case TV_STATUE:
1637                 {
1638                         if ((o_ptr->sval != SV_PHOTO) || (j_ptr->sval != SV_PHOTO)) return 0;
1639                         if (o_ptr->pval != j_ptr->pval) return 0;
1640                         break;
1641                 }
1642
1643                 /* Figurines and Corpses*/
1644                 case TV_FIGURINE:
1645                 case TV_CORPSE:
1646                 {
1647                         /* Same monster */
1648                         if (o_ptr->pval != j_ptr->pval) return 0;
1649
1650                         /* Assume okay */
1651                         break;
1652                 }
1653
1654                 /* Food and Potions and Scrolls */
1655                 case TV_FOOD:
1656                 case TV_POTION:
1657                 case TV_SCROLL:
1658                 {
1659                         /* Assume okay */
1660                         break;
1661                 }
1662
1663                 /* Staffs */
1664                 case TV_STAFF:
1665                 {
1666                         /* Require either knowledge or known empty for both staffs. */
1667                         if ((!(o_ptr->ident & (IDENT_EMPTY)) &&
1668                                 !object_is_known(o_ptr)) ||
1669                                 (!(j_ptr->ident & (IDENT_EMPTY)) &&
1670                                 !object_is_known(j_ptr))) return 0;
1671
1672                         /* Require identical charges, since staffs are bulky. */
1673                         if (o_ptr->pval != j_ptr->pval) return 0;
1674
1675                         /* Assume okay */
1676                         break;
1677                 }
1678
1679                 /* Wands */
1680                 case TV_WAND:
1681                 {
1682                         /* Require either knowledge or known empty for both wands. */
1683                         if ((!(o_ptr->ident & (IDENT_EMPTY)) &&
1684                                 !object_is_known(o_ptr)) ||
1685                                 (!(j_ptr->ident & (IDENT_EMPTY)) &&
1686                                 !object_is_known(j_ptr))) return 0;
1687
1688                         /* Wand charges combine in O&ZAngband.  */
1689
1690                         /* Assume okay */
1691                         break;
1692                 }
1693
1694                 /* Staffs and Wands and Rods */
1695                 case TV_ROD:
1696                 {
1697                         /* Prevent overflaw of timeout */
1698                         max_num = MIN(max_num, MAX_SHORT / k_info[o_ptr->k_idx].pval);
1699
1700                         /* Assume okay */
1701                         break;
1702                 }
1703
1704                 /* Weapons and Armor */
1705                 case TV_BOW:
1706                 case TV_DIGGING:
1707                 case TV_HAFTED:
1708                 case TV_POLEARM:
1709                 case TV_SWORD:
1710                 case TV_BOOTS:
1711                 case TV_GLOVES:
1712                 case TV_HELM:
1713                 case TV_CROWN:
1714                 case TV_SHIELD:
1715                 case TV_CLOAK:
1716                 case TV_SOFT_ARMOR:
1717                 case TV_HARD_ARMOR:
1718                 case TV_DRAG_ARMOR:
1719
1720                 /* Rings, Amulets, Lites */
1721                 case TV_RING:
1722                 case TV_AMULET:
1723                 case TV_LITE:
1724                 case TV_WHISTLE:
1725                 {
1726                         /* Require full knowledge of both items */
1727                         if (!object_is_known(o_ptr) || !object_is_known(j_ptr)) return 0;
1728
1729                         /* Fall through */
1730                 }
1731
1732                 /* Missiles */
1733                 case TV_BOLT:
1734                 case TV_ARROW:
1735                 case TV_SHOT:
1736                 {
1737                         /* Require identical knowledge of both items */
1738                         if (object_is_known(o_ptr) != object_is_known(j_ptr)) return 0;
1739                         if (o_ptr->feeling != j_ptr->feeling) return 0;
1740
1741                         /* Require identical "bonuses" */
1742                         if (o_ptr->to_h != j_ptr->to_h) return 0;
1743                         if (o_ptr->to_d != j_ptr->to_d) return 0;
1744                         if (o_ptr->to_a != j_ptr->to_a) return 0;
1745
1746                         /* Require identical "pval" code */
1747                         if (o_ptr->pval != j_ptr->pval) return 0;
1748
1749                         /* Artifacts never stack */
1750                         if (object_is_artifact(o_ptr) || object_is_artifact(j_ptr)) return 0;
1751
1752                         /* Require identical "ego-item" names */
1753                         if (o_ptr->name2 != j_ptr->name2) return 0;
1754
1755                         /* Require identical added essence  */
1756                         if (o_ptr->xtra3 != j_ptr->xtra3) return 0;
1757                         if (o_ptr->xtra4 != j_ptr->xtra4) return 0;
1758
1759                         /* Hack -- Never stack "powerful" items */
1760                         if (o_ptr->xtra1 || j_ptr->xtra1) return 0;
1761
1762                         /* Hack -- Never stack recharging items */
1763                         if (o_ptr->timeout || j_ptr->timeout) return 0;
1764
1765                         /* Require identical "values" */
1766                         if (o_ptr->ac != j_ptr->ac) return 0;
1767                         if (o_ptr->dd != j_ptr->dd) return 0;
1768                         if (o_ptr->ds != j_ptr->ds) return 0;
1769
1770                         /* Probably okay */
1771                         break;
1772                 }
1773
1774                 /* Various */
1775                 default:
1776                 {
1777                         /* Require knowledge */
1778                         if (!object_is_known(o_ptr) || !object_is_known(j_ptr)) return 0;
1779
1780                         /* Probably okay */
1781                         break;
1782                 }
1783         }
1784
1785
1786         /* Hack -- Identical art_flags! */
1787         for (i = 0; i < TR_FLAG_SIZE; i++)
1788                 if (o_ptr->art_flags[i] != j_ptr->art_flags[i]) return 0;
1789
1790         /* Hack -- Require identical "cursed" status */
1791         if (o_ptr->curse_flags != j_ptr->curse_flags) return 0;
1792
1793         /* Hack -- Require identical "broken" status */
1794         if ((o_ptr->ident & (IDENT_BROKEN)) != (j_ptr->ident & (IDENT_BROKEN))) return 0;
1795
1796
1797         /* Hack -- require semi-matching "inscriptions" */
1798         if (o_ptr->inscription && j_ptr->inscription &&
1799             (o_ptr->inscription != j_ptr->inscription))
1800                 return 0;
1801
1802         /* Hack -- normally require matching "inscriptions" */
1803         if (!stack_force_notes && (o_ptr->inscription != j_ptr->inscription)) return 0;
1804
1805         /* Hack -- normally require matching "discounts" */
1806         if (!stack_force_costs && (o_ptr->discount != j_ptr->discount)) return 0;
1807
1808
1809         /* They match, so they must be similar */
1810         return max_num;
1811 }
1812
1813 /*!
1814  * @brief 両オブジェクトをスロットに重ねることができるかどうかを返す。
1815  * Determine if an item can absorb a second item.
1816  * @param o_ptr 検証したいオブジェクトの構造体参照ポインタ1
1817  * @param j_ptr 検証したいオブジェクトの構造体参照ポインタ2
1818  * @return 重ね合わせ可能ならばTRUEを返す。
1819  */
1820 bool object_similar(object_type *o_ptr, object_type *j_ptr)
1821 {
1822         int total = o_ptr->number + j_ptr->number;
1823         int max_num;
1824
1825         /* Are these objects similar? */
1826         max_num = object_similar_part(o_ptr, j_ptr);
1827
1828         /* Return if not similar */
1829         if (!max_num) return FALSE;
1830
1831         /* Maximal "stacking" limit */
1832         if (total > max_num) return (0);
1833
1834
1835         /* They match, so they must be similar */
1836         return (TRUE);
1837 }
1838
1839
1840 /*!
1841  * @brief 両オブジェクトをスロットに重ね合わせる。
1842  * Allow one item to "absorb" another, assuming they are similar
1843  * @param o_ptr 重ね合わせ先のオブジェクトの構造体参照ポインタ
1844  * @param j_ptr 重ね合わせ元のオブジェクトの構造体参照ポインタ
1845  * @return なし
1846  */
1847 void object_absorb(object_type *o_ptr, object_type *j_ptr)
1848 {
1849         int max_num = object_similar_part(o_ptr, j_ptr);
1850         int total = o_ptr->number + j_ptr->number;
1851         int diff = (total > max_num) ? total - max_num : 0;
1852
1853         /* Combine quantity, lose excess items */
1854         o_ptr->number = (total > max_num) ? max_num : total;
1855
1856         /* Hack -- blend "known" status */
1857         if (object_is_known(j_ptr)) object_known(o_ptr);
1858
1859         /* Hack -- clear "storebought" if only one has it */
1860         if (((o_ptr->ident & IDENT_STORE) || (j_ptr->ident & IDENT_STORE)) &&
1861             (!((o_ptr->ident & IDENT_STORE) && (j_ptr->ident & IDENT_STORE))))
1862         {
1863                 if (j_ptr->ident & IDENT_STORE) j_ptr->ident &= 0xEF;
1864                 if (o_ptr->ident & IDENT_STORE) o_ptr->ident &= 0xEF;
1865         }
1866
1867         /* Hack -- blend "mental" status */
1868         if (j_ptr->ident & (IDENT_MENTAL)) o_ptr->ident |= (IDENT_MENTAL);
1869
1870         /* Hack -- blend "inscriptions" */
1871         if (j_ptr->inscription) o_ptr->inscription = j_ptr->inscription;
1872
1873         /* Hack -- blend "feelings" */
1874         if (j_ptr->feeling) o_ptr->feeling = j_ptr->feeling;
1875
1876         /* Hack -- could average discounts */
1877         /* Hack -- save largest discount */
1878         if (o_ptr->discount < j_ptr->discount) o_ptr->discount = j_ptr->discount;
1879
1880         /* Hack -- if rods are stacking, add the pvals (maximum timeouts) and current timeouts together. -LM- */
1881         if (o_ptr->tval == TV_ROD)
1882         {
1883                 o_ptr->pval += j_ptr->pval * (j_ptr->number - diff) / j_ptr->number;
1884                 o_ptr->timeout += j_ptr->timeout * (j_ptr->number - diff) / j_ptr->number;
1885         }
1886
1887         /* Hack -- if wands are stacking, combine the charges. -LM- */
1888         if (o_ptr->tval == TV_WAND)
1889         {
1890                 o_ptr->pval += j_ptr->pval * (j_ptr->number - diff) / j_ptr->number;
1891         }
1892 }
1893
1894
1895 /*!
1896  * @brief tvalとsvalに対応するベースアイテムのIDを返す。
1897  * Find the index of the object_kind with the given tval and sval
1898  * @param tval 検索したいベースアイテムのtval
1899  * @param sval 検索したいベースアイテムのsval
1900  * @return なし
1901  */
1902 IDX lookup_kind(OBJECT_TYPE_VALUE tval, OBJECT_SUBTYPE_VALUE sval)
1903 {
1904         IDX k;
1905         int num = 0;
1906         IDX bk = 0;
1907
1908         /* Look for it */
1909         for (k = 1; k < max_k_idx; k++)
1910         {
1911                 object_kind *k_ptr = &k_info[k];
1912
1913                 /* Require correct tval */
1914                 if (k_ptr->tval != tval) continue;
1915
1916                 /* Found a match */
1917                 if (k_ptr->sval == sval) return (k);
1918
1919                 /* Ignore illegal items */
1920                 if (sval != SV_ANY) continue;
1921
1922                 /* Apply the randomizer */
1923                 if (!one_in_(++num)) continue;
1924
1925                 /* Use this value */
1926                 bk = k;
1927         }
1928
1929         /* Return this choice */
1930         if (sval == SV_ANY)
1931         {
1932                 return bk;
1933         }
1934
1935 #if 0
1936         msg_format(_("アイテムがない (%d,%d)", "No object (%d,%d)"), tval, sval);
1937 #endif
1938
1939
1940         return (0);
1941 }
1942
1943
1944 /*!
1945  * @brief オブジェクトを初期化する
1946  * Wipe an object clean.
1947  * @param o_ptr 初期化したいオブジェクトの構造体参照ポインタ
1948  * @return なし
1949  */
1950 void object_wipe(object_type *o_ptr)
1951 {
1952         /* Wipe the structure */
1953         (void)WIPE(o_ptr, object_type);
1954 }
1955
1956
1957 /*!
1958  * @brief オブジェクトを複製する
1959  * Wipe an object clean.
1960  * @param o_ptr 複製元のオブジェクトの構造体参照ポインタ
1961  * @param j_ptr 複製先のオブジェクトの構造体参照ポインタ
1962  * @return なし
1963  */
1964 void object_copy(object_type *o_ptr, object_type *j_ptr)
1965 {
1966         /* Copy the structure */
1967         (void)COPY(o_ptr, j_ptr, object_type);
1968 }
1969
1970
1971 /*!
1972  * @brief オブジェクト構造体にベースアイテムを作成する
1973  * Prepare an object based on an object kind.
1974  * @param o_ptr 代入したいオブジェクトの構造体参照ポインタ
1975  * @param k_idx 新たに作成したいベースアイテム情報のID
1976  * @return なし
1977  */
1978 void object_prep(object_type *o_ptr, KIND_OBJECT_IDX k_idx)
1979 {
1980         object_kind *k_ptr = &k_info[k_idx];
1981
1982         /* Clear the record */
1983         object_wipe(o_ptr);
1984
1985         /* Save the kind index */
1986         o_ptr->k_idx = k_idx;
1987
1988         /* Efficiency -- tval/sval */
1989         o_ptr->tval = k_ptr->tval;
1990         o_ptr->sval = k_ptr->sval;
1991
1992         /* Default "pval" */
1993         o_ptr->pval = k_ptr->pval;
1994
1995         /* Default number */
1996         o_ptr->number = 1;
1997
1998         /* Default weight */
1999         o_ptr->weight = k_ptr->weight;
2000
2001         /* Default magic */
2002         o_ptr->to_h = k_ptr->to_h;
2003         o_ptr->to_d = k_ptr->to_d;
2004         o_ptr->to_a = k_ptr->to_a;
2005
2006         /* Default power */
2007         o_ptr->ac = k_ptr->ac;
2008         o_ptr->dd = k_ptr->dd;
2009         o_ptr->ds = k_ptr->ds;
2010
2011         /* Default activation */
2012         if (k_ptr->act_idx > 0) o_ptr->xtra2 = (XTRA8)k_ptr->act_idx;
2013
2014         /* Hack -- worthless items are always "broken" */
2015         if (k_info[o_ptr->k_idx].cost <= 0) o_ptr->ident |= (IDENT_BROKEN);
2016
2017         /* Hack -- cursed items are always "cursed" */
2018         if (k_ptr->gen_flags & (TRG_CURSED)) o_ptr->curse_flags |= (TRC_CURSED);
2019         if (k_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2020         if (k_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
2021         if (k_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
2022         if (k_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
2023         if (k_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
2024 }
2025
2026
2027 /*!
2028  * @brief 上質以上のオブジェクトに与えるための各種ボーナスを正規乱数も加えて算出する。
2029  * Help determine an "enchantment bonus" for an object.
2030  * @param max ボーナス値の限度
2031  * @param level ボーナス値に加味する基準生成階
2032  * @return 算出されたボーナス値
2033  * @details
2034  * To avoid floating point but still provide a smooth distribution of bonuses,\n
2035  * we simply round the results of division in such a way as to "average" the\n
2036  * correct floating point value.\n
2037  *\n
2038  * This function has been changed.  It uses "randnor()" to choose values from\n
2039  * a normal distribution, whose mean moves from zero towards the max as the\n
2040  * level increases, and whose standard deviation is equal to 1/4 of the max,\n
2041  * and whose values are forced to lie between zero and the max, inclusive.\n
2042  *\n
2043  * Since the "level" rarely passes 100 before Morgoth is dead, it is very\n
2044  * rare to get the "full" enchantment on an object, even a deep levels.\n
2045  *\n
2046  * It is always possible (albeit unlikely) to get the "full" enchantment.\n
2047  *\n
2048  * A sample distribution of values from "m_bonus(10, N)" is shown below:\n
2049  *\n
2050  *   N       0     1     2     3     4     5     6     7     8     9    10\n
2051  * ---    ----  ----  ----  ----  ----  ----  ----  ----  ----  ----  ----\n
2052  *   0   66.37 13.01  9.73  5.47  2.89  1.31  0.72  0.26  0.12  0.09  0.03\n
2053  *   8   46.85 24.66 12.13  8.13  4.20  2.30  1.05  0.36  0.19  0.08  0.05\n
2054  *  16   30.12 27.62 18.52 10.52  6.34  3.52  1.95  0.90  0.31  0.15  0.05\n
2055  *  24   22.44 15.62 30.14 12.92  8.55  5.30  2.39  1.63  0.62  0.28  0.11\n
2056  *  32   16.23 11.43 23.01 22.31 11.19  7.18  4.46  2.13  1.20  0.45  0.41\n
2057  *  40   10.76  8.91 12.80 29.51 16.00  9.69  5.90  3.43  1.47  0.88  0.65\n
2058  *  48    7.28  6.81 10.51 18.27 27.57 11.76  7.85  4.99  2.80  1.22  0.94\n
2059  *  56    4.41  4.73  8.52 11.96 24.94 19.78 11.06  7.18  3.68  1.96  1.78\n
2060  *  64    2.81  3.07  5.65  9.17 13.01 31.57 13.70  9.30  6.04  3.04  2.64\n
2061  *  72    1.87  1.99  3.68  7.15 10.56 20.24 25.78 12.17  7.52  4.42  4.62\n
2062  *  80    1.02  1.23  2.78  4.75  8.37 12.04 27.61 18.07 10.28  6.52  7.33\n
2063  *  88    0.70  0.57  1.56  3.12  6.34 10.06 15.76 30.46 12.58  8.47 10.38\n
2064  *  96    0.27  0.60  1.25  2.28  4.30  7.60 10.77 22.52 22.51 11.37 16.53\n
2065  * 104    0.22  0.42  0.77  1.36  2.62  5.33  8.93 13.05 29.54 15.23 22.53\n
2066  * 112    0.15  0.20  0.56  0.87  2.00  3.83  6.86 10.06 17.89 27.31 30.27\n
2067  * 120    0.03  0.11  0.31  0.46  1.31  2.48  4.60  7.78 11.67 25.53 45.72\n
2068  * 128    0.02  0.01  0.13  0.33  0.83  1.41  3.24  6.17  9.57 14.22 64.07\n
2069  */
2070 int m_bonus(int max, DEPTH level)
2071 {
2072         int bonus, stand, extra, value;
2073
2074
2075         /* Paranoia -- enforce maximal "level" */
2076         if (level > MAX_DEPTH - 1) level = MAX_DEPTH - 1;
2077
2078
2079         /* The "bonus" moves towards the max */
2080         bonus = ((max * level) / MAX_DEPTH);
2081
2082         /* Hack -- determine fraction of error */
2083         extra = ((max * level) % MAX_DEPTH);
2084
2085         /* Hack -- simulate floating point computations */
2086         if (randint0(MAX_DEPTH) < extra) bonus++;
2087
2088
2089         /* The "stand" is equal to one quarter of the max */
2090         stand = (max / 4);
2091
2092         /* Hack -- determine fraction of error */
2093         extra = (max % 4);
2094
2095         /* Hack -- simulate floating point computations */
2096         if (randint0(4) < extra) stand++;
2097
2098
2099         /* Choose an "interesting" value */
2100         value = randnor(bonus, stand);
2101
2102         /* Enforce the minimum value */
2103         if (value < 0) return (0);
2104
2105         /* Enforce the maximum value */
2106         if (value > max) return (max);
2107         return (value);
2108 }
2109
2110
2111 /*!
2112  * @brief デバッグ時にアイテム生成情報をメッセージに出力する / Cheat -- describe a created object for the user
2113  * @param o_ptr デバッグ出力するオブジェクトの構造体参照ポインタ
2114  * @return なし
2115  */
2116 static void object_mention(object_type *o_ptr)
2117 {
2118         char o_name[MAX_NLEN];
2119
2120         object_aware(o_ptr);
2121         object_known(o_ptr);
2122
2123         /* Mark the item as fully known */
2124         o_ptr->ident |= (IDENT_MENTAL);
2125
2126         /* Description */
2127         object_desc(o_name, o_ptr, 0);
2128         msg_format_wizard(CHEAT_OBJECT, _("%sを生成しました。", "%s was generated."), o_name);
2129 }
2130
2131 /*!
2132  * @brief INSTA_ART型の固定アーティファクトの生成を確率に応じて試行する。
2133  * Mega-Hack -- Attempt to create one of the "Special Objects"
2134  * @param o_ptr 生成に割り当てたいオブジェクトの構造体参照ポインタ
2135  * @return 生成に成功したらTRUEを返す。
2136  * @details
2137  * We are only called from "make_object()", and we assume that\n
2138  * "apply_magic()" is called immediately after we return.\n
2139  *\n
2140  * Note -- see "make_artifact()" and "apply_magic()"\n
2141  */
2142 static bool make_artifact_special(object_type *o_ptr)
2143 {
2144         IDX i;
2145         KIND_OBJECT_IDX k_idx = 0;
2146
2147         /*! @note 地上ではキャンセルする / No artifacts in the town */
2148         if (!dun_level) return (FALSE);
2149
2150         /*! @note get_obj_num_hookによる指定がある場合は生成をキャンセルする / Themed object */
2151         if (get_obj_num_hook) return (FALSE);
2152
2153         /*! @note 全固定アーティファクト中からIDの若い順に生成対象とその確率を走査する / Check the artifact list (just the "specials") */
2154         for (i = 0; i < max_a_idx; i++)
2155         {
2156                 artifact_type *a_ptr = &a_info[i];
2157
2158                 /*! @note アーティファクト名が空の不正なデータは除外する / Skip "empty" artifacts */
2159                 if (!a_ptr->name) continue;
2160
2161                 /*! @note 既に生成回数がカウントされたアーティファクト、QUESTITEMと非INSTA_ARTは除外 / Cannot make an artifact twice */
2162                 if (a_ptr->cur_num) continue;
2163                 if (a_ptr->gen_flags & TRG_QUESTITEM) continue;
2164                 if (!(a_ptr->gen_flags & TRG_INSTA_ART)) continue;
2165
2166                 /*! @note アーティファクト生成階が現在に対して足りない場合は高確率で1/(不足階層*2)を満たさないと生成リストに加えられない /
2167                  *  XXX XXX Enforce minimum "depth" (loosely) */
2168                 if (a_ptr->level > object_level)
2169                 {
2170                         /* @note  / Acquire the "out-of-depth factor". Roll for out-of-depth creation. */
2171                         int d = (a_ptr->level - object_level) * 2;
2172                         if (!one_in_(d)) continue;
2173                 }
2174
2175                 /*! @note 1/(レア度)の確率を満たさないと除外される / Artifact "rarity roll" */
2176                 if (!one_in_(a_ptr->rarity)) continue;
2177
2178                 /*! @note INSTA_ART型固定アーティファクトのベースアイテムもチェック対象とする。ベースアイテムの生成階層が足りない場合1/(不足階層*5) を満たさないと除外される。 /
2179                  *  Find the base object. XXX XXX Enforce minimum "object" level (loosely). Acquire the "out-of-depth factor". Roll for out-of-depth creation. */
2180                 k_idx = lookup_kind(a_ptr->tval, a_ptr->sval);
2181                 if (k_info[k_idx].level > object_level)
2182                 {
2183                         int d = (k_info[k_idx].level - object_level) * 5;
2184                         if (!one_in_(d)) continue;
2185                 }
2186
2187                 /*! @note 前述の条件を満たしたら、後のIDのアーティファクトはチェックせずすぐ確定し生成処理に移す /
2188                  * Assign the template. Mega-Hack -- mark the item as an artifact. Hack: Some artifacts get random extra powers. Success. */
2189                 object_prep(o_ptr, k_idx);
2190
2191                 o_ptr->name1 = i;
2192                 random_artifact_resistance(o_ptr, a_ptr);
2193                 return (TRUE);
2194         }
2195
2196         /*! @note 全INSTA_ART固定アーティファクトを試行しても決まらなかった場合 FALSEを返す / Failure */
2197         return (FALSE);
2198 }
2199
2200
2201 /*!
2202  * @brief 非INSTA_ART型の固定アーティファクトの生成を確率に応じて試行する。
2203  * Mega-Hack -- Attempt to create one of the "Special Objects"
2204  * @param o_ptr 生成に割り当てたいオブジェクトの構造体参照ポインタ
2205  * @return 生成に成功したらTRUEを返す。
2206  * @details
2207  * Attempt to change an object into an artifact\n
2208  * This routine should only be called by "apply_magic()"\n
2209  * Note -- see "make_artifact_special()" and "apply_magic()"\n
2210  */
2211 static bool make_artifact(object_type *o_ptr)
2212 {
2213         IDX i;
2214
2215
2216         /* No artifacts in the town */
2217         if (!dun_level) return (FALSE);
2218
2219         /* Paranoia -- no "plural" artifacts */
2220         if (o_ptr->number != 1) return (FALSE);
2221
2222         /* Check the artifact list (skip the "specials") */
2223         for (i = 0; i < max_a_idx; i++)
2224         {
2225                 artifact_type *a_ptr = &a_info[i];
2226
2227                 /* Skip "empty" items */
2228                 if (!a_ptr->name) continue;
2229
2230                 /* Cannot make an artifact twice */
2231                 if (a_ptr->cur_num) continue;
2232
2233                 if (a_ptr->gen_flags & TRG_QUESTITEM) continue;
2234
2235                 if (a_ptr->gen_flags & TRG_INSTA_ART) continue;
2236
2237                 /* Must have the correct fields */
2238                 if (a_ptr->tval != o_ptr->tval) continue;
2239                 if (a_ptr->sval != o_ptr->sval) continue;
2240
2241                 /* XXX XXX Enforce minimum "depth" (loosely) */
2242                 if (a_ptr->level > dun_level)
2243                 {
2244                         /* Acquire the "out-of-depth factor" */
2245                         int d = (a_ptr->level - dun_level) * 2;
2246
2247                         /* Roll for out-of-depth creation */
2248                         if (!one_in_(d)) continue;
2249                 }
2250
2251                 /* We must make the "rarity roll" */
2252                 if (!one_in_(a_ptr->rarity)) continue;
2253
2254                 /* Hack -- mark the item as an artifact */
2255                 o_ptr->name1 = i;
2256
2257                 /* Hack: Some artifacts get random extra powers */
2258                 random_artifact_resistance(o_ptr, a_ptr);
2259
2260                 /* Success */
2261                 return (TRUE);
2262         }
2263
2264         /* Failure */
2265         return (FALSE);
2266 }
2267
2268
2269 /*!
2270  * @brief アイテムのエゴをレア度の重みに合わせてランダムに選択する
2271  * Choose random ego type
2272  * @param slot 取得したいエゴの装備部位
2273  * @param good TRUEならば通常のエゴ、FALSEならば呪いのエゴが選択対象となる。
2274  * @return 選択されたエゴ情報のID、万一選択できなかった場合はmax_e_idxが返る。
2275  */
2276 static byte get_random_ego(byte slot, bool good)
2277 {
2278         int i, value;
2279         ego_item_type *e_ptr;
2280
2281         long total = 0L;
2282
2283         for (i = 1; i < max_e_idx; i++)
2284         {
2285                 e_ptr = &e_info[i];
2286
2287                 if (e_ptr->slot == slot
2288                     && ((good && e_ptr->rating) || (!good && !e_ptr->rating)) )
2289                 {
2290                         if (e_ptr->rarity)
2291                                 total += (255 / e_ptr->rarity);
2292                 }
2293         }
2294
2295         value = randint1(total);
2296
2297         for (i = 1; i < max_e_idx; i++)
2298         {
2299                 e_ptr = &e_info[i];
2300
2301                 if (e_ptr->slot == slot
2302                     && ((good && e_ptr->rating) || (!good && !e_ptr->rating)) )
2303                 {
2304                         if (e_ptr->rarity)
2305                                 value -= (255 / e_ptr->rarity);
2306                         if (value <= 0L) break;
2307                 }
2308         }
2309         return (byte)i;
2310 }
2311
2312
2313 /*!
2314  * @brief 武器系オブジェクトに生成ランクごとの強化を与えるサブルーチン
2315  * Apply magic to an item known to be a "weapon"
2316  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2317  * @param level 生成基準階
2318  * @param power 生成ランク
2319  * @return なし
2320  * @details
2321  * Hack -- note special base damage dice boosting\n
2322  * Hack -- note special processing for weapon/digger\n
2323  */
2324 static void a_m_aux_1(object_type *o_ptr, DEPTH level, int power)
2325 {
2326         HIT_PROB tohit1 = randint1(5) + (HIT_PROB)m_bonus(5, level);
2327         HIT_POINT todam1 = randint1(5) + (HIT_POINT)m_bonus(5, level);
2328
2329         HIT_PROB tohit2 = (HIT_PROB)m_bonus(10, level);
2330         HIT_POINT todam2 = (HIT_POINT)m_bonus(10, level);
2331
2332         if ((o_ptr->tval == TV_BOLT) || (o_ptr->tval == TV_ARROW) || (o_ptr->tval == TV_SHOT))
2333         {
2334                 tohit2 = (tohit2+1)/2;
2335                 todam2 = (todam2+1)/2;
2336         }
2337
2338         /* Good */
2339         if (power > 0)
2340         {
2341                 /* Enchant */
2342                 o_ptr->to_h += tohit1;
2343                 o_ptr->to_d += todam1;
2344
2345                 /* Very good */
2346                 if (power > 1)
2347                 {
2348                         /* Enchant again */
2349                         o_ptr->to_h += tohit2;
2350                         o_ptr->to_d += todam2;
2351                 }
2352         }
2353
2354         /* Cursed */
2355         else if (power < 0)
2356         {
2357                 /* Penalize */
2358                 o_ptr->to_h -= tohit1;
2359                 o_ptr->to_d -= todam1;
2360
2361                 /* Very cursed */
2362                 if (power < -1)
2363                 {
2364                         /* Penalize again */
2365                         o_ptr->to_h -= tohit2;
2366                         o_ptr->to_d -= todam2;
2367                 }
2368
2369                 /* Cursed (if "bad") */
2370                 if (o_ptr->to_h + o_ptr->to_d < 0) o_ptr->curse_flags |= TRC_CURSED;
2371         }
2372
2373         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_DIAMOND_EDGE)) return;
2374
2375         /* Analyze type */
2376         switch (o_ptr->tval)
2377         {
2378                 case TV_DIGGING:
2379                 {
2380                         /* Very good */
2381                         if (power > 1)
2382                         {
2383                                 if (one_in_(30) || (power > 2)) /* power > 2 is debug only */
2384                                         create_artifact(o_ptr, FALSE);
2385                                 else
2386                                         /* Special Ego-item */
2387                                         o_ptr->name2 = EGO_DIGGING;
2388                         }
2389
2390                         /* Very bad */
2391                         else if (power < -1)
2392                         {
2393                                 /* Hack -- Horrible digging bonus */
2394                                 o_ptr->pval = 0 - (5 + randint1(5));
2395                         }
2396
2397                         /* Bad */
2398                         else if (power < 0)
2399                         {
2400                                 /* Hack -- Reverse digging bonus */
2401                                 o_ptr->pval = 0 - (o_ptr->pval);
2402                         }
2403
2404                         break;
2405                 }
2406
2407
2408                 case TV_HAFTED:
2409                 case TV_POLEARM:
2410                 case TV_SWORD:
2411                 {
2412                         /* Very Good */
2413                         if (power > 1)
2414                         {
2415                                 if (one_in_(40) || (power > 2)) /* power > 2 is debug only */
2416                                 {
2417                                         create_artifact(o_ptr, FALSE);
2418                                         break;
2419                                 }
2420                                 while (1)
2421                                 {
2422                                         /* Roll for an ego-item */
2423                                         o_ptr->name2 = get_random_ego(INVEN_RARM, TRUE);
2424                                         if (o_ptr->name2 == EGO_SHARPNESS && o_ptr->tval != TV_SWORD)
2425                                                 continue;
2426                                         if (o_ptr->name2 == EGO_EARTHQUAKES && o_ptr->tval != TV_HAFTED)
2427                                                 continue;
2428                                         if (o_ptr->name2 == EGO_WEIRD && o_ptr->tval != TV_SWORD)
2429                                                 continue;
2430                                         break;
2431                                 }
2432
2433                                 switch (o_ptr->name2)
2434                                 {
2435                                 case EGO_HA:
2436                                         if (one_in_(4) && (level > 40))
2437                                                 add_flag(o_ptr->art_flags, TR_BLOWS);
2438                                         break;
2439                                 case EGO_DF:
2440                                         if (one_in_(3))
2441                                                 add_flag(o_ptr->art_flags, TR_RES_POIS);
2442                                         if (one_in_(3))
2443                                                 add_flag(o_ptr->art_flags, TR_WARNING);
2444                                         break;
2445                                 case EGO_KILL_DRAGON:
2446                                         if (one_in_(3))
2447                                                 add_flag(o_ptr->art_flags, TR_RES_POIS);
2448                                         break;
2449                                 case EGO_WEST:
2450                                         if (one_in_(3))
2451                                                 add_flag(o_ptr->art_flags, TR_RES_FEAR);
2452                                         break;
2453                                 case EGO_SLAYING_WEAPON:
2454                                         if (one_in_(3)) /* double damage */
2455                                                 o_ptr->dd *= 2;
2456                                         else
2457                                         {
2458                                                 do
2459                                                 {
2460                                                         o_ptr->dd++;
2461                                                 }
2462                                                 while (one_in_(o_ptr->dd));
2463
2464                                                 do
2465                                                 {
2466                                                         o_ptr->ds++;
2467                                                 }
2468                                                 while (one_in_(o_ptr->ds));
2469                                         }
2470
2471                                         if (one_in_(5))
2472                                         {
2473                                                 add_flag(o_ptr->art_flags, TR_BRAND_POIS);
2474                                         }
2475                                         if (o_ptr->tval == TV_SWORD && one_in_(3))
2476                                         {
2477                                                 add_flag(o_ptr->art_flags, TR_VORPAL);
2478                                         }
2479                                         break;
2480                                 case EGO_TRUMP:
2481                                         if (one_in_(5))
2482                                                 add_flag(o_ptr->art_flags, TR_SLAY_DEMON);
2483                                         if (one_in_(7))
2484                                                 one_ability(o_ptr);
2485                                         break;
2486                                 case EGO_PATTERN:
2487                                         if (one_in_(3))
2488                                                 add_flag(o_ptr->art_flags, TR_HOLD_EXP);
2489                                         if (one_in_(3))
2490                                                 add_flag(o_ptr->art_flags, TR_DEX);
2491                                         if (one_in_(5))
2492                                                 add_flag(o_ptr->art_flags, TR_RES_FEAR);
2493                                         break;
2494                                 case EGO_SHARPNESS:
2495                                         o_ptr->pval = (PARAMETER_VALUE)m_bonus(5, level) + 1;
2496                                         break;
2497                                 case EGO_EARTHQUAKES:
2498                                         if (one_in_(3) && (level > 60))
2499                                                 add_flag(o_ptr->art_flags, TR_BLOWS);
2500                                         else
2501                                                 o_ptr->pval = (PARAMETER_VALUE)m_bonus(3, level);
2502                                         break;
2503                                 case EGO_VAMPIRIC:
2504                                         if (one_in_(5))
2505                                                 add_flag(o_ptr->art_flags, TR_SLAY_HUMAN);
2506                                         break;
2507                                 case EGO_DEMON:
2508
2509                                         if(one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2510                                         one_in_(3) ?
2511                                                 add_flag(o_ptr->art_flags, TR_DRAIN_EXP) :
2512                                                 one_in_(2) ?
2513                                                         add_flag(o_ptr->art_flags, TR_DRAIN_HP) :
2514                                                         add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2515
2516
2517                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_CHAOTIC);
2518                                         if (one_in_(4)) add_flag(o_ptr->art_flags, TR_BLOWS);
2519                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2520                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_CALL_DEMON);
2521                                         break;
2522                                 }
2523
2524                                 if (!o_ptr->art_name)
2525                                 {
2526                                         /* Hack -- Super-charge the damage dice */
2527                                         while (one_in_(10L * o_ptr->dd * o_ptr->ds)) o_ptr->dd++;
2528
2529                                         /* Hack -- Lower the damage dice */
2530                                         if (o_ptr->dd > 9) o_ptr->dd = 9;
2531                                 }
2532                         }
2533
2534                         /* Very cursed */
2535                         else if (power < -1)
2536                         {
2537                                 /* Roll for ego-item */
2538                                 if (randint0(MAX_DEPTH) < level)
2539                                 {
2540                                         while(1)
2541                                         {
2542                                                 o_ptr->name2 = get_random_ego(INVEN_RARM, FALSE);
2543                                                 if (o_ptr->name2 == EGO_WEIRD && o_ptr->tval != TV_SWORD)
2544                                                 {
2545                                                         continue;
2546                                                 }
2547                                                 break;
2548                                         }
2549                                         switch (o_ptr->name2)
2550                                         {
2551                                         case EGO_MORGUL:
2552                                                 if (one_in_(6)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2553                                                 if (one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2554                                         case EGO_WEIRD:
2555                                                 if (one_in_(4)) add_flag(o_ptr->art_flags, TR_BRAND_POIS);
2556                                                 if (one_in_(4)) add_flag(o_ptr->art_flags, TR_RES_NETHER);
2557                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_NO_MAGIC);
2558                                                 if (one_in_(6)) add_flag(o_ptr->art_flags, TR_NO_TELE);
2559                                                 if (one_in_(6)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2560                                                 if (one_in_(6)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2561                                         }
2562                                 }
2563                         }
2564
2565                         break;
2566                 }
2567
2568
2569                 case TV_BOW:
2570                 {
2571                         /* Very good */
2572                         if (power > 1)
2573                         {
2574                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2575                                 {
2576                                         create_artifact(o_ptr, FALSE);
2577                                         break;
2578                                 }
2579                                 o_ptr->name2 = get_random_ego(INVEN_BOW, TRUE);
2580                         }
2581
2582                         break;
2583                 }
2584
2585
2586                 case TV_BOLT:
2587                 case TV_ARROW:
2588                 case TV_SHOT:
2589                 {
2590                         /* Very good */
2591                         if (power > 1)
2592                         {
2593                                 if (power > 2) /* power > 2 is debug only */
2594                                 {
2595                                         create_artifact(o_ptr, FALSE);
2596                                         break;
2597                                 }
2598
2599                                 o_ptr->name2 = get_random_ego(INVEN_AMMO, TRUE);
2600
2601                                 switch (o_ptr->name2)
2602                                 {
2603                                 case EGO_SLAYING_BOLT:
2604                                         o_ptr->dd++;
2605                                         break;
2606                                 }
2607
2608                                 /* Hack -- super-charge the damage dice */
2609                                 while (one_in_(10L * o_ptr->dd * o_ptr->ds)) o_ptr->dd++;
2610
2611                                 /* Hack -- restrict the damage dice */
2612                                 if (o_ptr->dd > 9) o_ptr->dd = 9;
2613                         }
2614
2615                         /* Very cursed */
2616                         else if (power < -1)
2617                         {
2618                                 /* Roll for ego-item */
2619                                 if (randint0(MAX_DEPTH) < level)
2620                                 {
2621                                         o_ptr->name2 = get_random_ego(INVEN_AMMO, FALSE);
2622                                 }
2623                         }
2624
2625                         break;
2626                 }
2627         }
2628 }
2629
2630 /*!
2631  * @brief ドラゴン装備にランダムな耐性を与える
2632  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2633  * @return なし
2634  */
2635 static void dragon_resist(object_type * o_ptr)
2636 {
2637         do
2638         {
2639                 if (one_in_(4))
2640                         one_dragon_ele_resistance(o_ptr);
2641                 else
2642                         one_high_resistance(o_ptr);
2643         }
2644         while (one_in_(2));
2645 }
2646
2647 /*!
2648  * @brief オブジェクトにランダムな強いESPを与える
2649  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2650  * @return なし
2651  */
2652 static bool add_esp_strong(object_type *o_ptr)
2653 {
2654         bool nonliv = FALSE;
2655
2656         switch (randint1(3))
2657         {
2658         case 1: add_flag(o_ptr->art_flags, TR_ESP_EVIL); break;
2659         case 2: add_flag(o_ptr->art_flags, TR_TELEPATHY); break;
2660         case 3: add_flag(o_ptr->art_flags, TR_ESP_NONLIVING); nonliv = TRUE; break;
2661         }
2662
2663         return nonliv;
2664 }
2665
2666 /*!
2667  * @brief オブジェクトにランダムな弱いESPを与える
2668  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2669  * @param extra TRUEならばESPの最大付与数が増える(TRUE -> 3+1d6 / FALSE -> 1d3)
2670  * @return なし
2671  */
2672 static void add_esp_weak(object_type *o_ptr, bool extra)
2673 {
2674         int i;
2675         u32b weak_esp_list[] = {
2676                 TR_ESP_ANIMAL,
2677                 TR_ESP_UNDEAD,
2678                 TR_ESP_DEMON,
2679                 TR_ESP_ORC,
2680                 TR_ESP_TROLL,
2681                 TR_ESP_GIANT,
2682                 TR_ESP_DRAGON,
2683                 TR_ESP_HUMAN,
2684                 TR_ESP_GOOD,
2685                 TR_ESP_UNIQUE,
2686         };
2687         const int MAX_ESP_WEAK = sizeof(weak_esp_list) / sizeof(weak_esp_list[0]);
2688         const int add_count = MIN(MAX_ESP_WEAK, (extra) ? (3 + randint1(randint1(6))) : randint1(3));
2689
2690         /* Add unduplicated weak esp flags randomly */
2691         for (i = 0; i < add_count; ++ i)
2692         {
2693                 int choice = rand_range(i, MAX_ESP_WEAK - 1);
2694
2695                 add_flag(o_ptr->art_flags, weak_esp_list[choice]);
2696                 weak_esp_list[choice] = weak_esp_list[i];
2697         }
2698 }
2699
2700
2701 /*!
2702  * @brief 防具系オブジェクトに生成ランクごとの強化を与えるサブルーチン
2703  * Apply magic to an item known to be "armor"
2704  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2705  * @param level 生成基準階
2706  * @param power 生成ランク
2707  * @return なし
2708  * @details
2709  * Hack -- note special processing for crown/helm\n
2710  * Hack -- note special processing for robe of permanence\n
2711  */
2712 static void a_m_aux_2(object_type *o_ptr, DEPTH level, int power)
2713 {
2714         ARMOUR_CLASS toac1 = (ARMOUR_CLASS)randint1(5) + m_bonus(5, level);
2715         ARMOUR_CLASS toac2 = (ARMOUR_CLASS)m_bonus(10, level);
2716
2717         /* Good */
2718         if (power > 0)
2719         {
2720                 /* Enchant */
2721                 o_ptr->to_a += toac1;
2722
2723                 /* Very good */
2724                 if (power > 1)
2725                 {
2726                         /* Enchant again */
2727                         o_ptr->to_a += toac2;
2728                 }
2729         }
2730
2731         /* Cursed */
2732         else if (power < 0)
2733         {
2734                 /* Penalize */
2735                 o_ptr->to_a -= toac1;
2736
2737                 /* Very cursed */
2738                 if (power < -1)
2739                 {
2740                         /* Penalize again */
2741                         o_ptr->to_a -= toac2;
2742                 }
2743
2744                 /* Cursed (if "bad") */
2745                 if (o_ptr->to_a < 0) o_ptr->curse_flags |= TRC_CURSED;
2746         }
2747
2748
2749         /* Analyze type */
2750         switch (o_ptr->tval)
2751         {
2752                 case TV_DRAG_ARMOR:
2753                 {
2754                         if (one_in_(50) || (power > 2)) /* power > 2 is debug only */
2755                                 create_artifact(o_ptr, FALSE);
2756                         break;
2757                 }
2758
2759                 case TV_HARD_ARMOR:
2760                 case TV_SOFT_ARMOR:
2761                 {
2762                         /* Very good */
2763                         if (power > 1)
2764                         {
2765                                 /* Hack -- Try for "Robes of the Magi" */
2766                                 if ((o_ptr->tval == TV_SOFT_ARMOR) &&
2767                                     (o_ptr->sval == SV_ROBE) &&
2768                                     (randint0(100) < 15))
2769                                 {
2770                                         if (one_in_(5))
2771                                         {
2772                                                 o_ptr->name2 = EGO_YOIYAMI;
2773                                                 o_ptr->k_idx = lookup_kind(TV_SOFT_ARMOR, SV_YOIYAMI_ROBE);
2774                                                 o_ptr->sval = SV_YOIYAMI_ROBE;
2775                                                 o_ptr->ac = 0;
2776                                                 o_ptr->to_a = 0;
2777                                         }
2778                                         else
2779                                         {
2780                                                 o_ptr->name2 = EGO_PERMANENCE;
2781                                         }
2782                                         break;
2783                                 }
2784
2785                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2786                                 {
2787                                         create_artifact(o_ptr, FALSE);
2788                                         break;
2789                                 }
2790
2791                                 while (1)
2792                                 {
2793                                         bool okay_flag = TRUE;
2794
2795                                         o_ptr->name2 = get_random_ego(INVEN_BODY, TRUE);
2796
2797                                         switch (o_ptr->name2)
2798                                         {
2799                                                 case EGO_DWARVEN:
2800                                                         if (o_ptr->tval != TV_HARD_ARMOR)
2801                                                         {
2802                                                                 okay_flag = FALSE;
2803                                                         }
2804                                                 break;
2805                                                 case EGO_DRUID:
2806                                                         if (o_ptr->tval != TV_SOFT_ARMOR)
2807                                                         {
2808                                                                 okay_flag = FALSE;
2809                                                         }
2810                                                 break;
2811                                                 default:
2812                                                 break;
2813                                         }
2814
2815                                         if (okay_flag) break;
2816                                 }
2817                                 switch (o_ptr->name2)
2818                                 {
2819                                   case EGO_RESISTANCE:
2820                                         if (one_in_(4))
2821                                                 add_flag(o_ptr->art_flags, TR_RES_POIS);
2822                                                 break;
2823                                   case EGO_DWARVEN:
2824                                         o_ptr->weight = (2 * k_info[o_ptr->k_idx].weight / 3);
2825                                         o_ptr->ac = k_info[o_ptr->k_idx].ac + 5;
2826                                         break;
2827
2828                                   case EGO_A_DEMON:
2829                                         if(one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2830                                         one_in_(3) ?
2831                                                 add_flag(o_ptr->art_flags, TR_DRAIN_EXP) :
2832                                                 one_in_(2) ?
2833                                                         add_flag(o_ptr->art_flags, TR_DRAIN_HP) :
2834                                                         add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2835
2836                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
2837                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_ADD_L_CURSE);
2838                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2839                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
2840                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2841                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
2842                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2843                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_CALL_DEMON);
2844                                         break;
2845                                   case EGO_A_MORGUL:
2846                                         if (one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2847                                         if (one_in_(9)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2848                                         if (one_in_(4)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2849                                         if (one_in_(6)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
2850                                         if (one_in_(9)) add_flag(o_ptr->art_flags, TR_NO_MAGIC);
2851                                         if (one_in_(9)) add_flag(o_ptr->art_flags, TR_NO_TELE);
2852                                         break;
2853                                   default:
2854                                         break;
2855                                 }
2856                         }
2857
2858                         break;
2859                 }
2860
2861                 case TV_SHIELD:
2862                 {
2863
2864                         if (o_ptr->sval == SV_DRAGON_SHIELD)
2865                         {
2866                                 dragon_resist(o_ptr);
2867                                 if (!one_in_(3)) break;
2868                         }
2869
2870                         /* Very good */
2871                         if (power > 1)
2872                         {
2873                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2874                                 {
2875                                         create_artifact(o_ptr, FALSE);
2876                                         break;
2877                                 }
2878
2879                                 while(1)
2880                                 {
2881                                         o_ptr->name2 = get_random_ego(INVEN_LARM, TRUE);
2882                                         if (o_ptr->sval != SV_SMALL_METAL_SHIELD && o_ptr->sval != SV_LARGE_METAL_SHIELD
2883                                                                 && o_ptr->name2 == EGO_S_DWARVEN)
2884                                         {
2885                                                 continue;
2886                                         }
2887                                         break;
2888                                 }
2889
2890                                 switch (o_ptr->name2)
2891                                 {
2892                                 case EGO_ENDURANCE:
2893                                         if (!one_in_(3)) one_high_resistance(o_ptr);
2894                                         if (one_in_(4)) add_flag(o_ptr->art_flags, TR_RES_POIS);
2895                                         break;
2896                                 case EGO_REFLECTION:
2897                                         if (o_ptr->sval == SV_MIRROR_SHIELD)
2898                                                 o_ptr->name2 = 0;
2899                                         break;
2900
2901                                 case EGO_S_DWARVEN:
2902                                         o_ptr->weight = (2 * k_info[o_ptr->k_idx].weight / 3);
2903                                         o_ptr->ac = k_info[o_ptr->k_idx].ac + 3;
2904                                         break;
2905                                 }
2906                         }
2907                         break;
2908                 }
2909
2910                 case TV_GLOVES:
2911                 {
2912                         if (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)
2913                         {
2914                                 dragon_resist(o_ptr);
2915                                 if (!one_in_(3)) break;
2916                         }
2917                         if (power > 1)
2918                         {
2919                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2920                                 {
2921                                         create_artifact(o_ptr, FALSE);
2922                                         break;
2923                                 }
2924                                 o_ptr->name2 = get_random_ego(INVEN_HANDS, TRUE);
2925                         }
2926
2927                         /* Very cursed */
2928                         else if (power < -1)
2929                         {
2930                                 o_ptr->name2 = get_random_ego(INVEN_HANDS, FALSE);
2931                         }
2932
2933                         break;
2934                 }
2935
2936                 case TV_BOOTS:
2937                 {
2938                         if (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)
2939                         {
2940                                 dragon_resist(o_ptr);
2941                                 if (!one_in_(3)) break;
2942                         }
2943                         /* Very good */
2944                         if (power > 1)
2945                         {
2946                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2947                                 {
2948                                         create_artifact(o_ptr, FALSE);
2949                                         break;
2950                                 }
2951                                 o_ptr->name2 = get_random_ego(INVEN_FEET, TRUE);
2952
2953                                 switch (o_ptr->name2)
2954                                 {
2955                                 case EGO_SLOW_DESCENT:
2956                                         if (one_in_(2))
2957                                         {
2958                                                 one_high_resistance(o_ptr);
2959                                         }
2960                                         break;
2961                                 }
2962                         }
2963                         /* Very cursed */
2964                         else if (power < -1)
2965                         {
2966                                 o_ptr->name2 = get_random_ego(INVEN_FEET, FALSE);
2967                         }
2968
2969                         break;
2970                 }
2971
2972                 case TV_CROWN:
2973                 {
2974                         /* Very good */
2975                         if (power > 1)
2976                         {
2977                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2978                                 {
2979                                         create_artifact(o_ptr, FALSE);
2980                                         break;
2981                                 }
2982                                 while (1)
2983                                 {
2984                                         bool ok_flag = TRUE;
2985                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, TRUE);
2986
2987                                         switch (o_ptr->name2)
2988                                         {
2989                                         case EGO_TELEPATHY:
2990                                                 if (add_esp_strong(o_ptr)) add_esp_weak(o_ptr, TRUE);
2991                                                 else add_esp_weak(o_ptr, FALSE);
2992                                                 break;
2993                                         case EGO_MAGI:
2994                                         case EGO_MIGHT:
2995                                         case EGO_REGENERATION:
2996                                         case EGO_LORDLINESS:
2997                                         case EGO_BASILISK:
2998                                                 break;
2999                                         case EGO_SEEING:
3000                                                 if (one_in_(3))
3001                                                 {
3002                                                         if (one_in_(2)) add_esp_strong(o_ptr);
3003                                                         else add_esp_weak(o_ptr, FALSE);
3004                                                 }
3005                                                 break;
3006                                         default:/* not existing crown (wisdom,lite, etc...) */
3007                                                 ok_flag = FALSE;
3008                                         }
3009                                         if (ok_flag)
3010                                                 break; /* while (1) */
3011                                 }
3012                                 break;
3013                         }
3014
3015                         /* Very cursed */
3016                         else if (power < -1)
3017                         {
3018                                 while (1)
3019                                 {
3020                                         bool ok_flag = TRUE;
3021                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, FALSE);
3022
3023                                         switch (o_ptr->name2)
3024                                         {
3025                                           case EGO_ANCIENT_CURSE:
3026                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_NO_MAGIC);
3027                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_NO_TELE);
3028                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
3029                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
3030                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
3031                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
3032                                                 break;
3033                                         }
3034                                         if (ok_flag)
3035                                                 break; /* while (1) */
3036                                 }
3037                         }
3038
3039                         break;
3040                 }
3041
3042                 case TV_HELM:
3043                 {
3044                         if (o_ptr->sval == SV_DRAGON_HELM)
3045                         {
3046                                 dragon_resist(o_ptr);
3047                                 if (!one_in_(3)) break;
3048                         }
3049
3050                         /* Very good */
3051                         if (power > 1)
3052                         {
3053                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
3054                                 {
3055                                         create_artifact(o_ptr, FALSE);
3056                                         break;
3057                                 }
3058                                 while (1)
3059                                 {
3060                                         bool ok_flag = TRUE;
3061                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, TRUE);
3062
3063                                         switch (o_ptr->name2)
3064                                         {
3065                                         case EGO_BRILLIANCE:
3066                                         case EGO_DARK:
3067                                         case EGO_INFRAVISION:
3068                                         case EGO_H_PROTECTION:
3069                                                 break;
3070                                         case EGO_SEEING:
3071                                                 if (one_in_(7))
3072                                                 {
3073                                                         if (one_in_(2)) add_esp_strong(o_ptr);
3074                                                         else add_esp_weak(o_ptr, FALSE);
3075                                                 }
3076                                                 break;
3077                                         case EGO_LITE:
3078                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_LITE_1);
3079                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_LITE_2);
3080                                                 break;
3081                                         case EGO_H_DEMON:
3082                                                 if(one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
3083                                                 one_in_(3) ?
3084                                                         add_flag(o_ptr->art_flags, TR_DRAIN_EXP) :
3085                                                         one_in_(2) ?
3086                                                                 add_flag(o_ptr->art_flags, TR_DRAIN_HP) :
3087                                                                 add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
3088
3089                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
3090                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_ADD_L_CURSE);
3091                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
3092                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
3093                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
3094                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
3095                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
3096                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_CALL_DEMON);
3097                                                 break;
3098                                         default:/* not existing helm (Magi, Might, etc...)*/
3099                                                 ok_flag = FALSE;
3100                                         }
3101                                         if (ok_flag)
3102                                                 break; /* while (1) */
3103                                 }
3104                                 break;
3105                         }
3106                         /* Very cursed */
3107                         else if (power < -1)
3108                         {
3109                                 while (1)
3110                                 {
3111                                         bool ok_flag = TRUE;
3112                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, FALSE);
3113
3114                                         switch (o_ptr->name2)
3115                                         {
3116                                           case EGO_ANCIENT_CURSE:
3117                                                 ok_flag = FALSE;
3118                                         }
3119                                         if (ok_flag)
3120                                                 break; /* while (1) */
3121                                 }
3122                         }
3123                         break;
3124                 }
3125
3126                 case TV_CLOAK:
3127                 {
3128                         /* Very good */
3129                         if (power > 1)
3130                         {
3131                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
3132                                 {
3133                                         create_artifact(o_ptr, FALSE);
3134                                         break;
3135                                 }
3136                                 o_ptr->name2 = get_random_ego(INVEN_OUTER, TRUE);
3137
3138                                 switch (o_ptr->name2)
3139                                 {
3140                                 case EGO_BAT:
3141                                         o_ptr->to_d -= 6;
3142                                         o_ptr->to_h -= 6;
3143                                         break;
3144                                 case EGO_NAZGUL:
3145                                         o_ptr->to_d -= 3;
3146                                         o_ptr->to_h -= 3;
3147                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_COWARDICE);
3148                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_CALL_UNDEAD);
3149                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_SLOW_REGEN);
3150                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
3151                                         break;
3152                                 }
3153
3154                         }
3155
3156                         /* Very cursed */
3157                         else if (power < -1)
3158                         {
3159                                 o_ptr->name2 = get_random_ego(INVEN_OUTER, FALSE);
3160                         }
3161
3162                         break;
3163                 }
3164         }
3165
3166 }
3167
3168
3169 /*!
3170  * @brief 装飾品系オブジェクトに生成ランクごとの強化を与えるサブルーチン
3171  * Apply magic to an item known to be a "ring" or "amulet"
3172  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
3173  * @param level 生成基準階
3174  * @param power 生成ランク
3175  * @return なし
3176  * @details
3177  * Hack -- note special "pval boost" code for ring of speed\n
3178  * Hack -- note that some items must be cursed (or blessed)\n
3179  */
3180 static void a_m_aux_3(object_type *o_ptr, DEPTH level, int power)
3181 {
3182         /* Apply magic (good or bad) according to type */
3183         switch (o_ptr->tval)
3184         {
3185                 case TV_RING:
3186                 {
3187                         /* Analyze */
3188                         switch (o_ptr->sval)
3189                         {
3190                                 case SV_RING_ATTACKS:
3191                                 {
3192                                         /* Stat bonus */
3193                                         o_ptr->pval = (PARAMETER_VALUE)m_bonus(2, level);
3194                                         if (one_in_(15)) o_ptr->pval++;
3195                                         if (o_ptr->pval < 1) o_ptr->pval = 1;
3196
3197                                         /* Cursed */
3198                                         if (power < 0)
3199                                         {
3200                                                 /* Broken */
3201                                                 o_ptr->ident |= (IDENT_BROKEN);
3202
3203                                                 /* Cursed */
3204                                                 o_ptr->curse_flags |= TRC_CURSED;
3205
3206                                                 /* Reverse pval */
3207                                                 o_ptr->pval = 0 - (o_ptr->pval);
3208                                         }
3209
3210                                         break;
3211                                 }
3212
3213                                 case SV_RING_SHOTS:
3214                                 {
3215                                         break;
3216                                 }
3217
3218                                 /* Strength, Constitution, Dexterity, Intelligence */
3219                                 case SV_RING_STR:
3220                                 case SV_RING_CON:
3221                                 case SV_RING_DEX:
3222                                 {
3223                                         /* Stat bonus */
3224                                         o_ptr->pval = 1 + (PARAMETER_VALUE)m_bonus(5, level);
3225
3226                                         /* Cursed */
3227                                         if (power < 0)
3228                                         {
3229                                                 /* Broken */
3230                                                 o_ptr->ident |= (IDENT_BROKEN);
3231
3232                                                 /* Cursed */
3233                                                 o_ptr->curse_flags |= TRC_CURSED;
3234
3235                                                 /* Reverse pval */
3236                                                 o_ptr->pval = 0 - (o_ptr->pval);
3237                                         }
3238
3239                                         break;
3240                                 }
3241
3242                                 /* Ring of Speed! */
3243                                 case SV_RING_SPEED:
3244                                 {
3245                                         /* Base speed (1 to 10) */
3246                                         o_ptr->pval = randint1(5) + (PARAMETER_VALUE)m_bonus(5, level);
3247
3248                                         /* Super-charge the ring */
3249                                         while (randint0(100) < 50) o_ptr->pval++;
3250
3251                                         /* Cursed Ring */
3252                                         if (power < 0)
3253                                         {
3254                                                 /* Broken */
3255                                                 o_ptr->ident |= (IDENT_BROKEN);
3256
3257                                                 /* Cursed */
3258                                                 o_ptr->curse_flags |= TRC_CURSED;
3259
3260                                                 /* Reverse pval */
3261                                                 o_ptr->pval = 0 - (o_ptr->pval);
3262
3263                                                 break;
3264                                         }
3265
3266                                         break;
3267                                 }
3268
3269                                 case SV_RING_LORDLY:
3270                                 {
3271                                         do
3272                                         {
3273                                                 one_lordly_high_resistance(o_ptr);
3274                                         }
3275                                         while (one_in_(4));
3276
3277                                         /* Bonus to armor class */
3278                                         o_ptr->to_a = 10 + randint1(5) + (ARMOUR_CLASS)m_bonus(10, level);
3279                                 }
3280                                 break;
3281
3282                                 case SV_RING_WARNING:
3283                                 {
3284                                         if (one_in_(3)) one_low_esp(o_ptr);
3285                                         break;
3286                                 }
3287
3288                                 /* Searching */
3289                                 case SV_RING_SEARCHING:
3290                                 {
3291                                         /* Bonus to searching */
3292                                         o_ptr->pval = 1 + (PARAMETER_VALUE)m_bonus(5, level);
3293
3294                                         /* Cursed */
3295                                         if (power < 0)
3296                                         {
3297                                                 /* Broken */
3298                                                 o_ptr->ident |= (IDENT_BROKEN);
3299
3300                                                 /* Cursed */
3301                                                 o_ptr->curse_flags |= TRC_CURSED;
3302
3303                                                 /* Reverse pval */
3304                                                 o_ptr->pval = 0 - (o_ptr->pval);
3305                                         }
3306
3307                                         break;
3308                                 }
3309
3310                                 /* Flames, Acid, Ice */
3311                                 case SV_RING_FLAMES:
3312                                 case SV_RING_ACID:
3313                                 case SV_RING_ICE:
3314                                 case SV_RING_ELEC:
3315                                 {
3316                                         /* Bonus to armor class */
3317                                         o_ptr->to_a = 5 + randint1(5) + (ARMOUR_CLASS)m_bonus(10, level);
3318                                         break;
3319                                 }
3320
3321                                 /* Weakness, Stupidity */
3322                                 case SV_RING_WEAKNESS:
3323                                 case SV_RING_STUPIDITY:
3324                                 {
3325                                         /* Broken */
3326                                         o_ptr->ident |= (IDENT_BROKEN);
3327
3328                                         /* Cursed */
3329                                         o_ptr->curse_flags |= TRC_CURSED;
3330
3331                                         /* Penalize */
3332                                         o_ptr->pval = 0 - (1 + (PARAMETER_VALUE)m_bonus(5, level));
3333                                         if (power > 0) power = 0 - power;
3334
3335                                         break;
3336                                 }
3337
3338                                 /* WOE, Stupidity */
3339                                 case SV_RING_WOE:
3340                                 {
3341                                         /* Broken */
3342                                         o_ptr->ident |= (IDENT_BROKEN);
3343
3344                                         /* Cursed */
3345                                         o_ptr->curse_flags |= TRC_CURSED;
3346
3347                                         /* Penalize */
3348                                         o_ptr->to_a = 0 - (5 + (ARMOUR_CLASS)m_bonus(10, level));
3349                                         o_ptr->pval = 0 - (1 + (PARAMETER_VALUE)m_bonus(5, level));
3350                                         if (power > 0) power = 0 - power;
3351
3352                                         break;
3353                                 }
3354
3355                                 /* Ring of damage */
3356                                 case SV_RING_DAMAGE:
3357                                 {
3358                                         /* Bonus to damage */
3359                                         o_ptr->to_d = 1 + randint1(5) + (HIT_POINT)m_bonus(16, level);
3360
3361                                         /* Cursed */
3362                                         if (power < 0)
3363                                         {
3364                                                 /* Broken */
3365                                                 o_ptr->ident |= (IDENT_BROKEN);
3366
3367                                                 /* Cursed */
3368                                                 o_ptr->curse_flags |= TRC_CURSED;
3369
3370                                                 /* Reverse bonus */
3371                                                 o_ptr->to_d = 0 - o_ptr->to_d;
3372                                         }
3373
3374                                         break;
3375                                 }
3376
3377                                 /* Ring of Accuracy */
3378                                 case SV_RING_ACCURACY:
3379                                 {
3380                                         /* Bonus to hit */
3381                                         o_ptr->to_h = 1 + randint1(5) + (HIT_PROB)m_bonus(16, level);
3382
3383                                         /* Cursed */
3384                                         if (power < 0)
3385                                         {
3386                                                 /* Broken */
3387                                                 o_ptr->ident |= (IDENT_BROKEN);
3388
3389                                                 /* Cursed */
3390                                                 o_ptr->curse_flags |= TRC_CURSED;
3391
3392                                                 /* Reverse tohit */
3393                                                 o_ptr->to_h = 0 - o_ptr->to_h;
3394                                         }
3395
3396                                         break;
3397                                 }
3398
3399                                 /* Ring of Protection */
3400                                 case SV_RING_PROTECTION:
3401                                 {
3402                                         /* Bonus to armor class */
3403                                         o_ptr->to_a = 5 + randint1(8) + (ARMOUR_CLASS)m_bonus(10, level);
3404
3405                                         /* Cursed */
3406                                         if (power < 0)
3407                                         {
3408                                                 /* Broken */
3409                                                 o_ptr->ident |= (IDENT_BROKEN);
3410
3411                                                 /* Cursed */
3412                                                 o_ptr->curse_flags |= TRC_CURSED;
3413
3414                                                 /* Reverse toac */
3415                                                 o_ptr->to_a = 0 - o_ptr->to_a;
3416                                         }
3417
3418                                         break;
3419                                 }
3420
3421                                 /* Ring of Slaying */
3422                                 case SV_RING_SLAYING:
3423                                 {
3424                                         /* Bonus to damage and to hit */
3425                                         o_ptr->to_d = randint1(5) + (HIT_POINT)m_bonus(12, level);
3426                                         o_ptr->to_h = randint1(5) + (HIT_PROB)m_bonus(12, level);
3427
3428                                         /* Cursed */
3429                                         if (power < 0)
3430                                         {
3431                                                 /* Broken */
3432                                                 o_ptr->ident |= (IDENT_BROKEN);
3433
3434                                                 /* Cursed */
3435                                                 o_ptr->curse_flags |= TRC_CURSED;
3436
3437                                                 /* Reverse bonuses */
3438                                                 o_ptr->to_h = 0 - o_ptr->to_h;
3439                                                 o_ptr->to_d = 0 - o_ptr->to_d;
3440                                         }
3441
3442                                         break;
3443                                 }
3444
3445                                 case SV_RING_MUSCLE:
3446                                 {
3447                                         o_ptr->pval = 1 + (PARAMETER_VALUE)m_bonus(3, level);
3448                                         if (one_in_(4)) o_ptr->pval++;
3449
3450                                         /* Cursed */
3451                                         if (power < 0)
3452                                         {
3453                                                 /* Broken */
3454                                                 o_ptr->ident |= (IDENT_BROKEN);
3455
3456                                                 /* Cursed */
3457                                                 o_ptr->curse_flags |= TRC_CURSED;
3458
3459                                                 /* Reverse bonuses */
3460                                                 o_ptr->pval = 0 - o_ptr->pval;
3461                                         }
3462
3463                                         break;
3464                                 }
3465                                 case SV_RING_AGGRAVATION:
3466                                 {
3467                                         /* Broken */
3468                                         o_ptr->ident |= (IDENT_BROKEN);
3469
3470                                         /* Cursed */
3471                                         o_ptr->curse_flags |= TRC_CURSED;
3472
3473                                         if (power > 0) power = 0 - power;
3474                                         break;
3475                                 }
3476                         }
3477                         if ((one_in_(400) && (power > 0) && !object_is_cursed(o_ptr) && (level > 79))
3478                             || (power > 2)) /* power > 2 is debug only */
3479                         {
3480                                 o_ptr->pval = MIN(o_ptr->pval, 4);
3481                                 /* Randart amulet */
3482                                 create_artifact(o_ptr, FALSE);
3483                         }
3484                         else if ((power == 2) && one_in_(2))
3485                         {
3486                                 while(!o_ptr->name2)
3487                                 {
3488                                         int tmp = m_bonus(10, level);
3489                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3490                                         switch(randint1(28))
3491                                         {
3492                                         case 1: case 2:
3493                                                 o_ptr->name2 = EGO_RING_THROW;
3494                                                 break;
3495                                         case 3: case 4:
3496                                                 if (have_flag(k_ptr->flags, TR_REGEN)) break;
3497                                                 o_ptr->name2 = EGO_RING_REGEN;
3498                                                 break;
3499                                         case 5: case 6:
3500                                                 if (have_flag(k_ptr->flags, TR_LITE_1)) break;
3501                                                 o_ptr->name2 = EGO_RING_LITE;
3502                                                 break;
3503                                         case 7: case 8:
3504                                                 if (have_flag(k_ptr->flags, TR_TELEPORT)) break;
3505                                                 o_ptr->name2 = EGO_RING_TELEPORT;
3506                                                 break;
3507                                         case 9: case 10:
3508                                                 if (o_ptr->to_h) break;
3509                                                 o_ptr->name2 = EGO_RING_TO_H;
3510                                                 break;
3511                                         case 11: case 12:
3512                                                 if (o_ptr->to_d) break;
3513                                                 o_ptr->name2 = EGO_RING_TO_D;
3514                                                 break;
3515                                         case 13:
3516                                                 if ((o_ptr->to_h) || (o_ptr->to_d)) break;
3517                                                 o_ptr->name2 = EGO_RING_SLAY;
3518                                                 break;
3519                                         case 14:
3520                                                 if ((have_flag(k_ptr->flags, TR_STR)) || o_ptr->to_h || o_ptr->to_d) break;
3521                                                 o_ptr->name2 = EGO_RING_WIZARD;
3522                                                 break;
3523                                         case 15:
3524                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3525                                                 o_ptr->name2 = EGO_RING_HERO;
3526                                                 break;
3527                                         case 16:
3528                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3529                                                 if (tmp > 8) o_ptr->name2 = EGO_RING_MANA_BALL;
3530                                                 else if (tmp > 4) o_ptr->name2 = EGO_RING_MANA_BOLT;
3531                                                 else o_ptr->name2 = EGO_RING_MAGIC_MIS;
3532                                                 break;
3533                                         case 17:
3534                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3535                                                 if (!(have_flag(k_ptr->flags, TR_RES_FIRE)) && (have_flag(k_ptr->flags, TR_RES_COLD) || have_flag(k_ptr->flags, TR_RES_ELEC) || have_flag(k_ptr->flags, TR_RES_ACID))) break;
3536                                                 if (tmp > 7) o_ptr->name2 = EGO_RING_DRAGON_F;
3537                                                 else if (tmp > 3) o_ptr->name2 = EGO_RING_FIRE_BALL;
3538                                                 else o_ptr->name2 = EGO_RING_FIRE_BOLT;
3539                                                 break;
3540                                         case 18:
3541                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3542                                                 if (!(have_flag(k_ptr->flags, TR_RES_COLD)) && (have_flag(k_ptr->flags, TR_RES_FIRE) || have_flag(k_ptr->flags, TR_RES_ELEC) || have_flag(k_ptr->flags, TR_RES_ACID))) break;
3543                                                 if (tmp > 7) o_ptr->name2 = EGO_RING_DRAGON_C;
3544                                                 else if (tmp > 3) o_ptr->name2 = EGO_RING_COLD_BALL;
3545                                                 else o_ptr->name2 = EGO_RING_COLD_BOLT;
3546                                                 break;
3547                                         case 19:
3548                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3549                                                 if (!(have_flag(k_ptr->flags, TR_RES_ELEC)) && (have_flag(k_ptr->flags, TR_RES_COLD) || have_flag(k_ptr->flags, TR_RES_FIRE) || have_flag(k_ptr->flags, TR_RES_ACID))) break;
3550                                                 if (tmp > 4) o_ptr->name2 = EGO_RING_ELEC_BALL;
3551                                                 else o_ptr->name2 = EGO_RING_ELEC_BOLT;
3552                                                 break;
3553                                         case 20:
3554                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3555                                                 if (!(have_flag(k_ptr->flags, TR_RES_ACID)) && (have_flag(k_ptr->flags, TR_RES_COLD) || have_flag(k_ptr->flags, TR_RES_ELEC) || have_flag(k_ptr->flags, TR_RES_FIRE))) break;
3556                                                 if (tmp > 4) o_ptr->name2 = EGO_RING_ACID_BALL;
3557                                                 else o_ptr->name2 = EGO_RING_ACID_BOLT;
3558                                                 break;
3559                                         case 21: case 22: case 23: case 24: case 25: case 26:
3560                                                 switch (o_ptr->sval)
3561                                                 {
3562                                                 case SV_RING_SPEED:
3563                                                         if (!one_in_(3)) break;
3564                                                         o_ptr->name2 = EGO_RING_D_SPEED;
3565                                                         break;
3566                                                 case SV_RING_DAMAGE:
3567                                                 case SV_RING_ACCURACY:
3568                                                 case SV_RING_SLAYING:
3569                                                         if (one_in_(2)) break;
3570                                                         if (one_in_(2)) o_ptr->name2 = EGO_RING_HERO;
3571                                                         else
3572                                                         {
3573                                                                 o_ptr->name2 = EGO_RING_BERSERKER;
3574                                                                 o_ptr->to_h -= 2+randint1(4);
3575                                                                 o_ptr->to_d += 2+randint1(4);
3576                                                         }
3577                                                         break;
3578                                                 case SV_RING_PROTECTION:
3579                                                         o_ptr->name2 = EGO_RING_SUPER_AC;
3580                                                         o_ptr->to_a += 7 + m_bonus(5, level);
3581                                                         break;
3582                                                 case SV_RING_RES_FEAR:
3583                                                         o_ptr->name2 = EGO_RING_HERO;
3584                                                         break;
3585                                                 case SV_RING_SHOTS:
3586                                                         if (one_in_(2)) break;
3587                                                         o_ptr->name2 = EGO_RING_HUNTER;
3588                                                         break;
3589                                                 case SV_RING_SEARCHING:
3590                                                         o_ptr->name2 = EGO_RING_STEALTH;
3591                                                         break;
3592                                                 case SV_RING_TELEPORTATION:
3593                                                         o_ptr->name2 = EGO_RING_TELE_AWAY;
3594                                                         break;
3595                                                 case SV_RING_RES_BLINDNESS:
3596                                                         if (one_in_(2))
3597                                                                 o_ptr->name2 = EGO_RING_RES_LITE;
3598                                                         else
3599                                                                 o_ptr->name2 = EGO_RING_RES_DARK;
3600                                                         break;
3601                                                 case SV_RING_LORDLY:
3602                                                         if (!one_in_(20)) break;
3603                                                         one_lordly_high_resistance(o_ptr);
3604                                                         one_lordly_high_resistance(o_ptr);
3605                                                         o_ptr->name2 = EGO_RING_TRUE;
3606                                                         break;
3607                                                 case SV_RING_SUSTAIN:
3608                                                         if (!one_in_(4)) break;
3609                                                         o_ptr->name2 = EGO_RING_RES_TIME;
3610                                                         break;
3611                                                 case SV_RING_FLAMES:
3612                                                         if (!one_in_(2)) break;
3613                                                         o_ptr->name2 = EGO_RING_DRAGON_F;
3614                                                         break;
3615                                                 case SV_RING_ICE:
3616                                                         if (!one_in_(2)) break;
3617                                                         o_ptr->name2 = EGO_RING_DRAGON_C;
3618                                                         break;
3619                                                 case SV_RING_WARNING:
3620                                                         if (!one_in_(2)) break;
3621                                                         o_ptr->name2 = EGO_RING_M_DETECT;
3622                                                         break;
3623                                                 default:
3624                                                         break;
3625                                                 }
3626                                                 break;
3627                                         }
3628                                 }
3629                                 /* Uncurse it */
3630                                 o_ptr->curse_flags = 0L;
3631                         }
3632                         else if ((power == -2) && one_in_(2))
3633                         {
3634                                 if (o_ptr->to_h > 0) o_ptr->to_h = 0-o_ptr->to_h;
3635                                 if (o_ptr->to_d > 0) o_ptr->to_d = 0-o_ptr->to_d;
3636                                 if (o_ptr->to_a > 0) o_ptr->to_a = 0-o_ptr->to_a;
3637                                 if (o_ptr->pval > 0) o_ptr->pval = 0-o_ptr->pval;
3638                                 o_ptr->art_flags[0] = 0;
3639                                 o_ptr->art_flags[1] = 0;
3640                                 while(!o_ptr->name2)
3641                                 {
3642                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3643                                         switch(randint1(5))
3644                                         {
3645                                         case 1:
3646                                                 if (have_flag(k_ptr->flags, TR_DRAIN_EXP)) break;
3647                                                 o_ptr->name2 = EGO_RING_DRAIN_EXP;
3648                                                 break;
3649                                         case 2:
3650                                                 o_ptr->name2 = EGO_RING_NO_MELEE;
3651                                                 break;
3652                                         case 3:
3653                                                 if (have_flag(k_ptr->flags, TR_AGGRAVATE)) break;
3654                                                 o_ptr->name2 = EGO_RING_AGGRAVATE;
3655                                                 break;
3656                                         case 4:
3657                                                 if (have_flag(k_ptr->flags, TR_TY_CURSE)) break;
3658                                                 o_ptr->name2 = EGO_RING_TY_CURSE;
3659                                                 break;
3660                                         case 5:
3661                                                 o_ptr->name2 = EGO_RING_ALBINO;
3662                                                 break;
3663                                         }
3664                                 }
3665                                 /* Broken */
3666                                 o_ptr->ident |= (IDENT_BROKEN);
3667
3668                                 /* Cursed */
3669                                 o_ptr->curse_flags |= (TRC_CURSED | TRC_HEAVY_CURSE);
3670                         }
3671                         break;
3672                 }
3673
3674                 case TV_AMULET:
3675                 {
3676                         /* Analyze */
3677                         switch (o_ptr->sval)
3678                         {
3679                                 /* Amulet of wisdom/charisma */
3680                                 case SV_AMULET_INTELLIGENCE:
3681                                 case SV_AMULET_WISDOM:
3682                                 case SV_AMULET_CHARISMA:
3683                                 {
3684                                         o_ptr->pval = 1 + (PARAMETER_VALUE)m_bonus(5, level);
3685
3686                                         /* Cursed */
3687                                         if (power < 0)
3688                                         {
3689                                                 /* Broken */
3690                                                 o_ptr->ident |= (IDENT_BROKEN);
3691
3692                                                 /* Cursed */
3693                                                 o_ptr->curse_flags |= (TRC_CURSED);
3694
3695                                                 /* Reverse bonuses */
3696                                                 o_ptr->pval = 0 - o_ptr->pval;
3697                                         }
3698
3699                                         break;
3700                                 }
3701
3702                                 /* Amulet of brilliance */
3703                                 case SV_AMULET_BRILLIANCE:
3704                                 {
3705                                         o_ptr->pval = 1 + m_bonus(3, level);
3706                                         if (one_in_(4)) o_ptr->pval++;
3707
3708                                         /* Cursed */
3709                                         if (power < 0)
3710                                         {
3711                                                 /* Broken */
3712                                                 o_ptr->ident |= (IDENT_BROKEN);
3713
3714                                                 /* Cursed */
3715                                                 o_ptr->curse_flags |= (TRC_CURSED);
3716
3717                                                 /* Reverse bonuses */
3718                                                 o_ptr->pval = 0 - o_ptr->pval;
3719                                         }
3720
3721                                         break;
3722                                 }
3723
3724                                 case SV_AMULET_NO_MAGIC: case SV_AMULET_NO_TELE:
3725                                 {
3726                                         if (power < 0)
3727                                         {
3728                                                 o_ptr->curse_flags |= (TRC_CURSED);
3729                                         }
3730                                         break;
3731                                 }
3732
3733                                 case SV_AMULET_RESISTANCE:
3734                                 {
3735                                         if (one_in_(5)) one_high_resistance(o_ptr);
3736                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_RES_POIS);
3737                                 }
3738                                 break;
3739
3740                                 /* Amulet of searching */
3741                                 case SV_AMULET_SEARCHING:
3742                                 {
3743                                         o_ptr->pval = randint1(2) + (PARAMETER_VALUE)m_bonus(4, level);
3744
3745                                         /* Cursed */
3746                                         if (power < 0)
3747                                         {
3748                                                 /* Broken */
3749                                                 o_ptr->ident |= (IDENT_BROKEN);
3750
3751                                                 /* Cursed */
3752                                                 o_ptr->curse_flags |= (TRC_CURSED);
3753
3754                                                 /* Reverse bonuses */
3755                                                 o_ptr->pval = 0 - (o_ptr->pval);
3756                                         }
3757
3758                                         break;
3759                                 }
3760
3761                                 /* Amulet of the Magi -- never cursed */
3762                                 case SV_AMULET_THE_MAGI:
3763                                 {
3764                                         o_ptr->pval = randint1(5) + (PARAMETER_VALUE)m_bonus(5, level);
3765                                         o_ptr->to_a = randint1(5) + (ARMOUR_CLASS)m_bonus(5, level);
3766
3767                                         /* gain one low ESP */
3768                                         add_esp_weak(o_ptr, FALSE);
3769
3770                                         break;
3771                                 }
3772
3773                                 /* Amulet of Doom -- always cursed */
3774                                 case SV_AMULET_DOOM:
3775                                 {
3776                                         /* Broken */
3777                                         o_ptr->ident |= (IDENT_BROKEN);
3778
3779                                         /* Cursed */
3780                                         o_ptr->curse_flags |= (TRC_CURSED);
3781
3782                                         /* Penalize */
3783                                         o_ptr->pval = 0 - (randint1(5) + (PARAMETER_VALUE)m_bonus(5, level));
3784                                         o_ptr->to_a = 0 - (randint1(5) + (ARMOUR_CLASS)m_bonus(5, level));
3785                                         if (power > 0) power = 0 - power;
3786
3787                                         break;
3788                                 }
3789
3790                                 case SV_AMULET_MAGIC_MASTERY:
3791                                 {
3792                                         o_ptr->pval = 1 + (PARAMETER_VALUE)m_bonus(4, level);
3793
3794                                         /* Cursed */
3795                                         if (power < 0)
3796                                         {
3797                                                 /* Broken */
3798                                                 o_ptr->ident |= (IDENT_BROKEN);
3799
3800                                                 /* Cursed */
3801                                                 o_ptr->curse_flags |= (TRC_CURSED);
3802
3803                                                 /* Reverse bonuses */
3804                                                 o_ptr->pval = 0 - o_ptr->pval;
3805                                         }
3806
3807                                         break;
3808                                 }
3809                         }
3810                         if ((one_in_(150) && (power > 0) && !object_is_cursed(o_ptr) && (level > 79))
3811                             || (power > 2)) /* power > 2 is debug only */
3812                         {
3813                                 o_ptr->pval = MIN(o_ptr->pval, 4);
3814                                 /* Randart amulet */
3815                                 create_artifact(o_ptr, FALSE);
3816                         }
3817                         else if ((power == 2) && one_in_(2))
3818                         {
3819                                 while(!o_ptr->name2)
3820                                 {
3821                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3822                                         switch(randint1(21))
3823                                         {
3824                                         case 1: case 2:
3825                                                 if (have_flag(k_ptr->flags, TR_SLOW_DIGEST)) break;
3826                                                 o_ptr->name2 = EGO_AMU_SLOW_D;
3827                                                 break;
3828                                         case 3: case 4:
3829                                                 if (o_ptr->pval) break;
3830                                                 o_ptr->name2 = EGO_AMU_INFRA;
3831                                                 break;
3832                                         case 5: case 6:
3833                                                 if (have_flag(k_ptr->flags, TR_SEE_INVIS)) break;
3834                                                 o_ptr->name2 = EGO_AMU_SEE_INVIS;
3835                                                 break;
3836                                         case 7: case 8:
3837                                                 if (have_flag(k_ptr->flags, TR_HOLD_EXP)) break;
3838                                                 o_ptr->name2 = EGO_AMU_HOLD_EXP;
3839                                                 break;
3840                                         case 9:
3841                                                 if (have_flag(k_ptr->flags, TR_LEVITATION)) break;
3842                                                 o_ptr->name2 = EGO_AMU_LEVITATION;
3843                                                 break;
3844                                         case 10: case 11: case 21:
3845                                                 o_ptr->name2 = EGO_AMU_AC;
3846                                                 break;
3847                                         case 12:
3848                                                 if (have_flag(k_ptr->flags, TR_RES_FIRE)) break;
3849                                                 if (m_bonus(10, level) > 8)
3850                                                         o_ptr->name2 = EGO_AMU_RES_FIRE_;
3851                                                 else
3852                                                         o_ptr->name2 = EGO_AMU_RES_FIRE;
3853                                                 break;
3854                                         case 13:
3855                                                 if (have_flag(k_ptr->flags, TR_RES_COLD)) break;
3856                                                 if (m_bonus(10, level) > 8)
3857                                                         o_ptr->name2 = EGO_AMU_RES_COLD_;
3858                                                 else
3859                                                         o_ptr->name2 = EGO_AMU_RES_COLD;
3860                                                 break;
3861                                         case 14:
3862                                                 if (have_flag(k_ptr->flags, TR_RES_ELEC)) break;
3863                                                 if (m_bonus(10, level) > 8)
3864                                                         o_ptr->name2 = EGO_AMU_RES_ELEC_;
3865                                                 else
3866                                                         o_ptr->name2 = EGO_AMU_RES_ELEC;
3867                                                 break;
3868                                         case 15:
3869                                                 if (have_flag(k_ptr->flags, TR_RES_ACID)) break;
3870                                                 if (m_bonus(10, level) > 8)
3871                                                         o_ptr->name2 = EGO_AMU_RES_ACID_;
3872                                                 else
3873                                                         o_ptr->name2 = EGO_AMU_RES_ACID;
3874                                                 break;
3875                                         case 16: case 17: case 18: case 19: case 20:
3876                                                 switch (o_ptr->sval)
3877                                                 {
3878                                                 case SV_AMULET_TELEPORT:
3879                                                         if (m_bonus(10, level) > 9) o_ptr->name2 = EGO_AMU_D_DOOR;
3880                                                         else if (one_in_(2)) o_ptr->name2 = EGO_AMU_JUMP;
3881                                                         else o_ptr->name2 = EGO_AMU_TELEPORT;
3882                                                         break;
3883                                                 case SV_AMULET_RESIST_ACID:
3884                                                         if ((m_bonus(10, level) > 6) && one_in_(2)) o_ptr->name2 = EGO_AMU_RES_ACID_;
3885                                                         break;
3886                                                 case SV_AMULET_SEARCHING:
3887                                                         o_ptr->name2 = EGO_AMU_STEALTH;
3888                                                         break;
3889                                                 case SV_AMULET_BRILLIANCE:
3890                                                         if (!one_in_(3)) break;
3891                                                         o_ptr->name2 = EGO_AMU_IDENT;
3892                                                         break;
3893                                                 case SV_AMULET_CHARISMA:
3894                                                         if (!one_in_(3)) break;
3895                                                         o_ptr->name2 = EGO_AMU_CHARM;
3896                                                         break;
3897                                                 case SV_AMULET_THE_MAGI:
3898                                                         if (one_in_(2)) break;
3899                                                         o_ptr->name2 = EGO_AMU_GREAT;
3900                                                         break;
3901                                                 case SV_AMULET_RESISTANCE:
3902                                                         if (!one_in_(5)) break;
3903                                                         o_ptr->name2 = EGO_AMU_DEFENDER;
3904                                                         break;
3905                                                 case SV_AMULET_TELEPATHY:
3906                                                         if (!one_in_(3)) break;
3907                                                         o_ptr->name2 = EGO_AMU_DETECTION;
3908                                                         break;
3909                                                 }
3910                                         }
3911                                 }
3912                                 /* Uncurse it */
3913                                 o_ptr->curse_flags = 0L;
3914                         }
3915                         else if ((power == -2) && one_in_(2))
3916                         {
3917                                 if (o_ptr->to_h > 0) o_ptr->to_h = 0-o_ptr->to_h;
3918                                 if (o_ptr->to_d > 0) o_ptr->to_d = 0-o_ptr->to_d;
3919                                 if (o_ptr->to_a > 0) o_ptr->to_a = 0-o_ptr->to_a;
3920                                 if (o_ptr->pval > 0) o_ptr->pval = 0-o_ptr->pval;
3921                                 o_ptr->art_flags[0] = 0;
3922                                 o_ptr->art_flags[1] = 0;
3923                                 while(!o_ptr->name2)
3924                                 {
3925                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3926                                         switch(randint1(5))
3927                                         {
3928                                         case 1:
3929                                                 if (have_flag(k_ptr->flags, TR_DRAIN_EXP)) break;
3930                                                 o_ptr->name2 = EGO_AMU_DRAIN_EXP;
3931                                                 break;
3932                                         case 2:
3933                                                 o_ptr->name2 = EGO_AMU_FOOL;
3934                                                 break;
3935                                         case 3:
3936                                                 if (have_flag(k_ptr->flags, TR_AGGRAVATE)) break;
3937                                                 o_ptr->name2 = EGO_AMU_AGGRAVATE;
3938                                                 break;
3939                                         case 4:
3940                                                 if (have_flag(k_ptr->flags, TR_TY_CURSE)) break;
3941                                                 o_ptr->name2 = EGO_AMU_TY_CURSE;
3942                                                 break;
3943                                         case 5:
3944                                                 o_ptr->name2 = EGO_AMU_NAIVETY;
3945                                                 break;
3946                                         }
3947                                 }
3948                                 /* Broken */
3949                                 o_ptr->ident |= (IDENT_BROKEN);
3950
3951                                 /* Cursed */
3952                                 o_ptr->curse_flags |= (TRC_CURSED | TRC_HEAVY_CURSE);
3953                         }
3954                         break;
3955                 }
3956         }
3957 }
3958
3959 /*!
3960  * @brief モンスターが人形のベースにできるかを返す
3961  * @param r_idx チェックしたいモンスター種族のID
3962  * @return 人形にできるならTRUEを返す
3963  */
3964 static bool item_monster_okay(MONRACE_IDX r_idx)
3965 {
3966         monster_race *r_ptr = &r_info[r_idx];
3967
3968         /* No uniques */
3969         if (r_ptr->flags1 & RF1_UNIQUE) return (FALSE);
3970         if (r_ptr->flags7 & RF7_KAGE) return (FALSE);
3971         if (r_ptr->flagsr & RFR_RES_ALL) return (FALSE);
3972         if (r_ptr->flags7 & RF7_NAZGUL) return (FALSE);
3973         if (r_ptr->flags1 & RF1_FORCE_DEPTH) return (FALSE);
3974         if (r_ptr->flags7 & RF7_UNIQUE2) return (FALSE);
3975
3976         return (TRUE);
3977 }
3978
3979
3980 /*!
3981  * @brief その他雑多のオブジェクトに生成ランクごとの強化を与えるサブルーチン
3982  * Apply magic to an item known to be "boring"
3983  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
3984  * @param level 生成基準階
3985  * @param power 生成ランク
3986  * @return なし
3987  * @details
3988  * Hack -- note the special code for various items
3989  */
3990 static void a_m_aux_4(object_type *o_ptr, DEPTH level, int power)
3991 {
3992         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3993
3994         /* Unused */
3995         (void)level;
3996
3997         /* Apply magic (good or bad) according to type */
3998         switch (o_ptr->tval)
3999         {
4000                 case TV_WHISTLE:
4001                 {
4002 #if 0
4003                         /* Cursed */
4004                         if (power < 0)
4005                         {
4006                                 /* Broken */
4007                                 o_ptr->ident |= (IDENT_BROKEN);
4008
4009                                 /* Cursed */
4010                                 o_ptr->curse_flags |= (TRC_CURSED);
4011                         }
4012 #endif
4013                         break;
4014                 }
4015                 case TV_FLASK:
4016                 {
4017                         o_ptr->xtra4 = o_ptr->pval;
4018                         o_ptr->pval = 0;
4019                         break;
4020                 }
4021                 case TV_LITE:
4022                 {
4023                         /* Hack -- Torches -- random fuel */
4024                         if (o_ptr->sval == SV_LITE_TORCH)
4025                         {
4026                                 if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
4027                                 o_ptr->pval = 0;
4028                         }
4029
4030                         /* Hack -- Lanterns -- random fuel */
4031                         if (o_ptr->sval == SV_LITE_LANTERN)
4032                         {
4033                                 if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
4034                                 o_ptr->pval = 0;
4035                         }
4036
4037                         if (power > 2) /* power > 2 is debug only */
4038                         {
4039                                 create_artifact(o_ptr, FALSE);
4040                         }
4041                         else if ((power == 2) || ((power == 1) && one_in_(3)))
4042                         {
4043                                 while (!o_ptr->name2)
4044                                 {
4045                                         while (1)
4046                                         {
4047                                                 bool okay_flag = TRUE;
4048
4049                                                 o_ptr->name2 = get_random_ego(INVEN_LITE, TRUE);
4050
4051                                                 switch (o_ptr->name2)
4052                                                 {
4053                                                 case EGO_LITE_LONG:
4054                                                         if (o_ptr->sval == SV_LITE_FEANOR)
4055                                                                 okay_flag = FALSE;
4056                                                 }
4057                                                 if (okay_flag)
4058                                                         break;
4059                                         }
4060                                 }
4061                         }
4062                         else if (power == -2)
4063                         {
4064                                 o_ptr->name2 = get_random_ego(INVEN_LITE, FALSE);
4065
4066                                 switch (o_ptr->name2)
4067                                 {
4068                                 case EGO_LITE_DARKNESS:
4069                                         o_ptr->xtra4 = 0;
4070
4071                                         if (o_ptr->sval == SV_LITE_TORCH)
4072                                         {
4073                                                 add_flag(o_ptr->art_flags, TR_LITE_M1);
4074                                         }
4075                                         else if (o_ptr->sval == SV_LITE_LANTERN)
4076                                         {
4077                                                 add_flag(o_ptr->art_flags, TR_LITE_M2);
4078                                         }
4079                                         else if (o_ptr->sval == SV_LITE_FEANOR)
4080                                         {
4081                                                 add_flag(o_ptr->art_flags, TR_LITE_M3);
4082                                         }
4083                                         break;
4084                                 }
4085                         }
4086
4087                         break;
4088                 }
4089
4090                 case TV_WAND:
4091                 case TV_STAFF:
4092                 {
4093                         /* The wand or staff gets a number of initial charges equal
4094                          * to between 1/2 (+1) and the full object kind's pval. -LM-
4095                          */
4096                         o_ptr->pval = k_ptr->pval / 2 + randint1((k_ptr->pval + 1) / 2);
4097                         break;
4098                 }
4099
4100                 case TV_ROD:
4101                 {
4102                         /* Transfer the pval. -LM- */
4103                         o_ptr->pval = k_ptr->pval;
4104                         break;
4105                 }
4106
4107                 case TV_CAPTURE:
4108                 {
4109                         o_ptr->pval = 0;
4110                         object_aware(o_ptr);
4111                         object_known(o_ptr);
4112                         break;
4113                 }
4114
4115                 case TV_FIGURINE:
4116                 {
4117                         PARAMETER_VALUE i = 1;
4118                         int check;
4119
4120                         monster_race *r_ptr;
4121
4122                         /* Pick a random non-unique monster race */
4123                         while (1)
4124                         {
4125                                 i = randint1(max_r_idx - 1);
4126
4127                                 if (!item_monster_okay(i)) continue;
4128                                 if (i == MON_TSUCHINOKO) continue;
4129
4130                                 r_ptr = &r_info[i];
4131
4132                                 check = (dun_level < r_ptr->level) ? (r_ptr->level - dun_level) : 0;
4133
4134                                 /* Ignore dead monsters */
4135                                 if (!r_ptr->rarity) continue;
4136
4137                                 /* Ignore uncommon monsters */
4138                                 if (r_ptr->rarity > 100) continue;
4139
4140                                 /* Prefer less out-of-depth monsters */
4141                                 if (randint0(check)) continue;
4142
4143                                 break;
4144                         }
4145
4146                         o_ptr->pval = i;
4147
4148                         /* Some figurines are cursed */
4149                         if (one_in_(6)) o_ptr->curse_flags |= TRC_CURSED;
4150
4151                         break;
4152                 }
4153
4154                 case TV_CORPSE:
4155                 {
4156                         PARAMETER_VALUE i = 1;
4157                         int check;
4158
4159                         u32b match = 0;
4160
4161                         monster_race *r_ptr;
4162
4163                         if (o_ptr->sval == SV_SKELETON)
4164                         {
4165                                 match = RF9_DROP_SKELETON;
4166                         }
4167                         else if (o_ptr->sval == SV_CORPSE)
4168                         {
4169                                 match = RF9_DROP_CORPSE;
4170                         }
4171
4172                         /* Hack -- Remove the monster restriction */
4173                         get_mon_num_prep(item_monster_okay, NULL);
4174
4175                         /* Pick a random non-unique monster race */
4176                         while (1)
4177                         {
4178                                 i = get_mon_num(dun_level);
4179
4180                                 r_ptr = &r_info[i];
4181
4182                                 check = (dun_level < r_ptr->level) ? (r_ptr->level - dun_level) : 0;
4183
4184                                 /* Ignore dead monsters */
4185                                 if (!r_ptr->rarity) continue;
4186
4187                                 /* Ignore corpseless monsters */
4188                                 if (!(r_ptr->flags9 & match)) continue;
4189
4190                                 /* Prefer less out-of-depth monsters */
4191                                 if (randint0(check)) continue;
4192
4193                                 break;
4194                         }
4195
4196                         o_ptr->pval = i;
4197
4198
4199                         object_aware(o_ptr);
4200                         object_known(o_ptr);
4201                         break;
4202                 }
4203
4204                 case TV_STATUE:
4205                 {
4206                         PARAMETER_VALUE i = 1;
4207
4208                         monster_race *r_ptr;
4209
4210                         /* Pick a random monster race */
4211                         while (1)
4212                         {
4213                                 i = randint1(max_r_idx - 1);
4214
4215                                 r_ptr = &r_info[i];
4216
4217                                 /* Ignore dead monsters */
4218                                 if (!r_ptr->rarity) continue;
4219
4220                                 break;
4221                         }
4222
4223                         o_ptr->pval = i;
4224
4225                         if (cheat_peek)
4226                         {
4227                                 msg_format(_("%sの像", "Statue of %s"), r_name + r_ptr->name);
4228                         }
4229                         object_aware(o_ptr);
4230                         object_known(o_ptr);
4231
4232                         break;
4233                 }
4234
4235                 case TV_CHEST:
4236                 {
4237                         DEPTH obj_level = k_info[o_ptr->k_idx].level;
4238
4239                         /* Hack -- skip ruined chests */
4240                         if (obj_level <= 0) break;
4241
4242                         /* Hack -- pick a "difficulty" */
4243                         o_ptr->pval = randint1(obj_level);
4244                         if (o_ptr->sval == SV_CHEST_KANDUME) o_ptr->pval = 6;
4245
4246                         o_ptr->xtra3 = dun_level + 5;
4247
4248                         /* Never exceed "difficulty" of 55 to 59 */
4249                         if (o_ptr->pval > 55) o_ptr->pval = 55 + (byte)randint0(5);
4250
4251                         break;
4252                 }
4253         }
4254 }
4255
4256 /*!
4257  * @brief 生成されたベースアイテムに魔法的な強化を与えるメインルーチン
4258  * Complete the "creation" of an object by applying "magic" to the item
4259  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
4260  * @param lev 生成基準階
4261  * @param mode 生成オプション
4262  * @return なし
4263  * @details
4264  * This includes not only rolling for random bonuses, but also putting the\n
4265  * finishing touches on ego-items and artifacts, giving charges to wands and\n
4266  * staffs, giving fuel to lites, and placing traps on chests.\n
4267  *\n
4268  * In particular, note that "Instant Artifacts", if "created" by an external\n
4269  * routine, must pass through this function to complete the actual creation.\n
4270  *\n
4271  * The base "chance" of the item being "good" increases with the "level"\n
4272  * parameter, which is usually derived from the dungeon level, being equal\n
4273  * to the level plus 10, up to a maximum of 75.  If "good" is true, then\n
4274  * the object is guaranteed to be "good".  If an object is "good", then\n
4275  * the chance that the object will be "great" (ego-item or artifact), also\n
4276  * increases with the "level", being equal to half the level, plus 5, up to\n
4277  * a maximum of 20.  If "great" is true, then the object is guaranteed to be\n
4278  * "great".  At dungeon level 65 and below, 15/100 objects are "great".\n
4279  *\n
4280  * If the object is not "good", there is a chance it will be "cursed", and\n
4281  * if it is "cursed", there is a chance it will be "broken".  These chances\n
4282  * are related to the "good" / "great" chances above.\n
4283  *\n
4284  * Otherwise "normal" rings and amulets will be "good" half the time and\n
4285  * "cursed" half the time, unless the ring/amulet is always good or cursed.\n
4286  *\n
4287  * If "okay" is true, and the object is going to be "great", then there is\n
4288  * a chance that an artifact will be created.  This is true even if both the\n
4289  * "good" and "great" arguments are false.  As a total hack, if "great" is\n
4290  * true, then the item gets 3 extra "attempts" to become an artifact.\n
4291  */
4292 void apply_magic(object_type *o_ptr, DEPTH lev, BIT_FLAGS mode)
4293 {
4294         int i, rolls, f1, f2, power;
4295
4296         if (p_ptr->pseikaku == SEIKAKU_MUNCHKIN) lev += randint0(p_ptr->lev/2+10);
4297
4298         /* Maximum "level" for various things */
4299         if (lev > MAX_DEPTH - 1) lev = MAX_DEPTH - 1;
4300
4301         /* Base chance of being "good" */
4302         f1 = lev + 10;
4303
4304         /* Maximal chance of being "good" */
4305         if (f1 > d_info[dungeon_type].obj_good) f1 = d_info[dungeon_type].obj_good;
4306
4307         /* Base chance of being "great" */
4308         f2 = f1 * 2 / 3;
4309
4310         /* Maximal chance of being "great" */
4311         if ((p_ptr->pseikaku != SEIKAKU_MUNCHKIN) && (f2 > d_info[dungeon_type].obj_great))
4312                 f2 = d_info[dungeon_type].obj_great;
4313
4314         if (p_ptr->muta3 & MUT3_GOOD_LUCK)
4315         {
4316                 f1 += 5;
4317                 f2 += 2;
4318         }
4319         else if(p_ptr->muta3 & MUT3_BAD_LUCK)
4320         {
4321                 f1 -= 5;
4322                 f2 -= 2;
4323         }
4324
4325         /* Assume normal */
4326         power = 0;
4327
4328         /* Roll for "good" */
4329         if ((mode & AM_GOOD) || magik(f1))
4330         {
4331                 /* Assume "good" */
4332                 power = 1;
4333
4334                 /* Roll for "great" */
4335                 if ((mode & AM_GREAT) || magik(f2))
4336                 {
4337                         power = 2;
4338
4339                         /* Roll for "special" */
4340                         if (mode & AM_SPECIAL) power = 3;
4341                 }
4342         }
4343
4344         /* Roll for "cursed" */
4345         else if (magik(f1))
4346         {
4347                 /* Assume "cursed" */
4348                 power = -1;
4349
4350                 /* Roll for "broken" */
4351                 if (magik(f2)) power = -2;
4352         }
4353
4354         /* Apply curse */
4355         if (mode & AM_CURSED)
4356         {
4357                 /* Assume 'cursed' */
4358                 if (power > 0)
4359                 {
4360                         power = 0 - power;
4361                 }
4362                 /* Everything else gets more badly cursed */
4363                 else
4364                 {
4365                         power--;
4366                 }
4367         }
4368
4369         /* Assume no rolls */
4370         rolls = 0;
4371
4372         /* Get one roll if excellent */
4373         if (power >= 2) rolls = 1;
4374
4375         /* Hack -- Get four rolls if forced great or special */
4376         if (mode & (AM_GREAT | AM_SPECIAL)) rolls = 4;
4377
4378         /* Hack -- Get no rolls if not allowed */
4379         if ((mode & AM_NO_FIXED_ART) || o_ptr->name1) rolls = 0;
4380
4381         /* Roll for artifacts if allowed */
4382         for (i = 0; i < rolls; i++)
4383         {
4384                 /* Roll for an artifact */
4385                 if (make_artifact(o_ptr)) break;
4386                 if ((p_ptr->muta3 & MUT3_GOOD_LUCK) && one_in_(77))
4387                 {
4388                         if (make_artifact(o_ptr)) break;
4389                 }
4390         }
4391
4392
4393         /* Hack -- analyze artifacts */
4394         if (object_is_fixed_artifact(o_ptr))
4395         {
4396                 artifact_type *a_ptr = &a_info[o_ptr->name1];
4397
4398                 /* Hack -- Mark the artifact as "created" */
4399                 a_ptr->cur_num = 1;
4400
4401                 /* Hack -- Memorize location of artifact in saved floors */
4402                 if (character_dungeon)
4403                         a_ptr->floor_id = p_ptr->floor_id;
4404
4405                 /* Extract the other fields */
4406                 o_ptr->pval = a_ptr->pval;
4407                 o_ptr->ac = a_ptr->ac;
4408                 o_ptr->dd = a_ptr->dd;
4409                 o_ptr->ds = a_ptr->ds;
4410                 o_ptr->to_a = a_ptr->to_a;
4411                 o_ptr->to_h = a_ptr->to_h;
4412                 o_ptr->to_d = a_ptr->to_d;
4413                 o_ptr->weight = a_ptr->weight;
4414                 o_ptr->xtra2 = a_ptr->act_idx;
4415
4416                 if (o_ptr->name1 == ART_MILIM)
4417                 {
4418                     if(p_ptr->pseikaku == SEIKAKU_SEXY)
4419                     {
4420                         o_ptr->pval = 3;
4421                     }
4422                 }
4423
4424                 /* Hack -- extract the "broken" flag */
4425                 if (!a_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
4426
4427                 /* Hack -- extract the "cursed" flag */
4428                 if (a_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
4429                 if (a_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
4430                 if (a_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
4431                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4432                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4433                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4434
4435                 return;
4436         }
4437
4438
4439         /* Apply magic */
4440         switch (o_ptr->tval)
4441         {
4442                 case TV_DIGGING:
4443                 case TV_HAFTED:
4444                 case TV_BOW:
4445                 case TV_SHOT:
4446                 case TV_ARROW:
4447                 case TV_BOLT:
4448                 {
4449                         if (power) a_m_aux_1(o_ptr, lev, power);
4450                         break;
4451                 }
4452
4453                 case TV_POLEARM:
4454                 {
4455                         if (power && !(o_ptr->sval == SV_DEATH_SCYTHE)) a_m_aux_1(o_ptr, lev, power);
4456                         break;
4457                 }
4458
4459                 case TV_SWORD:
4460                 {
4461                         if (power && !(o_ptr->sval == SV_DOKUBARI)) a_m_aux_1(o_ptr, lev, power);
4462                         break;
4463                 }
4464
4465                 case TV_DRAG_ARMOR:
4466                 case TV_HARD_ARMOR:
4467                 case TV_SOFT_ARMOR:
4468                 case TV_SHIELD:
4469                 case TV_HELM:
4470                 case TV_CROWN:
4471                 case TV_CLOAK:
4472                 case TV_GLOVES:
4473                 case TV_BOOTS:
4474                 {
4475                         /* Elven Cloak and Black Clothes ... */
4476                         if (((o_ptr->tval == TV_CLOAK) && (o_ptr->sval == SV_ELVEN_CLOAK)) ||
4477                             ((o_ptr->tval == TV_SOFT_ARMOR) && (o_ptr->sval == SV_KUROSHOUZOKU)))
4478                                 o_ptr->pval = randint1(4);
4479
4480 #if 1
4481                         if (power ||
4482                              ((o_ptr->tval == TV_HELM) && (o_ptr->sval == SV_DRAGON_HELM)) ||
4483                              ((o_ptr->tval == TV_SHIELD) && (o_ptr->sval == SV_DRAGON_SHIELD)) ||
4484                              ((o_ptr->tval == TV_GLOVES) && (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)) ||
4485                              ((o_ptr->tval == TV_BOOTS) && (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)))
4486                                 a_m_aux_2(o_ptr, lev, power);
4487 #else
4488                         if (power) a_m_aux_2(o_ptr, lev, power);
4489 #endif
4490                         break;
4491                 }
4492
4493                 case TV_RING:
4494                 case TV_AMULET:
4495                 {
4496                         if (!power && (randint0(100) < 50)) power = -1;
4497                         a_m_aux_3(o_ptr, lev, power);
4498                         break;
4499                 }
4500
4501                 default:
4502                 {
4503                         a_m_aux_4(o_ptr, lev, power);
4504                         break;
4505                 }
4506         }
4507
4508         if ((o_ptr->tval == TV_SOFT_ARMOR) &&
4509             (o_ptr->sval == SV_ABUNAI_MIZUGI) &&
4510             (p_ptr->pseikaku == SEIKAKU_SEXY))
4511         {
4512                 o_ptr->pval = 3;
4513                 add_flag(o_ptr->art_flags, TR_STR);
4514                 add_flag(o_ptr->art_flags, TR_INT);
4515                 add_flag(o_ptr->art_flags, TR_WIS);
4516                 add_flag(o_ptr->art_flags, TR_DEX);
4517                 add_flag(o_ptr->art_flags, TR_CON);
4518                 add_flag(o_ptr->art_flags, TR_CHR);
4519         }
4520
4521         /* Hack -- analyze ego-items */
4522         if (object_is_ego(o_ptr))
4523         {
4524                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
4525
4526                 /* Hack -- acquire "broken" flag */
4527                 if (!e_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
4528
4529                 /* Hack -- acquire "cursed" flag */
4530                 if (e_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
4531                 if (e_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
4532                 if (e_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
4533                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4534                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4535                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4536
4537                 if (e_ptr->gen_flags & (TRG_ONE_SUSTAIN)) one_sustain(o_ptr);
4538                 if (e_ptr->gen_flags & (TRG_XTRA_POWER)) one_ability(o_ptr);
4539                 if (e_ptr->gen_flags & (TRG_XTRA_H_RES)) one_high_resistance(o_ptr);
4540                 if (e_ptr->gen_flags & (TRG_XTRA_E_RES)) one_ele_resistance(o_ptr);
4541                 if (e_ptr->gen_flags & (TRG_XTRA_D_RES)) one_dragon_ele_resistance(o_ptr);
4542                 if (e_ptr->gen_flags & (TRG_XTRA_L_RES)) one_lordly_high_resistance(o_ptr);
4543                 if (e_ptr->gen_flags & (TRG_XTRA_RES)) one_resistance(o_ptr);
4544                 if (e_ptr->gen_flags & (TRG_XTRA_DICE))
4545                 {
4546                         do
4547                         {
4548                                 o_ptr->dd++;
4549                         }
4550                         while (one_in_(o_ptr->dd));
4551
4552                         if (o_ptr->dd > 9) o_ptr->dd = 9;
4553                 }
4554
4555                 /* Hack -- apply activatin index if needed */
4556                 if (e_ptr->act_idx) o_ptr->xtra2 = (XTRA8)e_ptr->act_idx;
4557
4558                 /* Hack -- apply extra penalties if needed */
4559                 if ((object_is_cursed(o_ptr) || object_is_broken(o_ptr)) && !(e_ptr->gen_flags & (TRG_POWERFUL)))
4560                 {
4561                         /* Hack -- obtain bonuses */
4562                         if (e_ptr->max_to_h) o_ptr->to_h -= randint1(e_ptr->max_to_h);
4563                         if (e_ptr->max_to_d) o_ptr->to_d -= randint1(e_ptr->max_to_d);
4564                         if (e_ptr->max_to_a) o_ptr->to_a -= randint1(e_ptr->max_to_a);
4565
4566                         /* Hack -- obtain pval */
4567                         if (e_ptr->max_pval) o_ptr->pval -= randint1(e_ptr->max_pval);
4568                 }
4569
4570                 /* Hack -- apply extra bonuses if needed */
4571                 else
4572                 {
4573                         /* Hack -- obtain bonuses */
4574                         if (e_ptr->max_to_h)
4575                         {
4576                                 if (e_ptr->max_to_h > 127)
4577                                         o_ptr->to_h -= randint1(256-e_ptr->max_to_h);
4578                                 else o_ptr->to_h += randint1(e_ptr->max_to_h);
4579                         }
4580                         if (e_ptr->max_to_d)
4581                         {
4582                                 if (e_ptr->max_to_d > 127)
4583                                         o_ptr->to_d -= randint1(256-e_ptr->max_to_d);
4584                                 else o_ptr->to_d += randint1(e_ptr->max_to_d);
4585                         }
4586                         if (e_ptr->max_to_a)
4587                         {
4588                                 if (e_ptr->max_to_a > 127)
4589                                         o_ptr->to_a -= randint1(256-e_ptr->max_to_a);
4590                                 else o_ptr->to_a += randint1(e_ptr->max_to_a);
4591                         }
4592
4593                         /* Accuracy ego must have high to_h */
4594                         if(o_ptr->name2 == EGO_ACCURACY)
4595                         {
4596                                 while(o_ptr->to_h < o_ptr->to_d + 10)
4597                                 {
4598                                         o_ptr->to_h += 5;
4599                                         o_ptr->to_d -= 5;
4600                                 }
4601                                 o_ptr->to_h = MAX(o_ptr->to_h, 15);
4602                         }
4603
4604                         /* Accuracy ego must have high to_h */
4605                         if(o_ptr->name2 == EGO_VELOCITY)
4606                         {
4607                                 while(o_ptr->to_d < o_ptr->to_h + 10)
4608                                 {
4609                                         o_ptr->to_d += 5;
4610                                         o_ptr->to_h -= 5;
4611                                 }
4612                                 o_ptr->to_d = MAX(o_ptr->to_d, 15);
4613                         }
4614
4615                         /* Protection ego must have high to_a */
4616                         if((o_ptr->name2 == EGO_PROTECTION) || (o_ptr->name2 == EGO_S_PROTECTION) || (o_ptr->name2 == EGO_H_PROTECTION))
4617                         {
4618                                 o_ptr->to_a = MAX(o_ptr->to_a, 15);
4619                         }
4620
4621                         /* Hack -- obtain pval */
4622                         if (e_ptr->max_pval)
4623                         {
4624                                 if ((o_ptr->name2 == EGO_HA) && (have_flag(o_ptr->art_flags, TR_BLOWS)))
4625                                 {
4626                                         o_ptr->pval++;
4627                                         if ((lev > 60) && one_in_(3) && ((o_ptr->dd*(o_ptr->ds+1)) < 15)) o_ptr->pval++;
4628                                 }
4629                                 else if (o_ptr->name2 == EGO_DEMON)
4630                                 {
4631                                         if(have_flag(o_ptr->art_flags, TR_BLOWS))
4632                                         {
4633                                                 o_ptr->pval += randint1(2);
4634                                         }
4635                                         else
4636                                         {
4637                                                 o_ptr->pval += randint1(e_ptr->max_pval);
4638                                         }
4639                                 }
4640                                 else if (o_ptr->name2 == EGO_ATTACKS)
4641                                 {
4642                                         o_ptr->pval = randint1(e_ptr->max_pval*lev/100+1);
4643                                         if (o_ptr->pval > 3) o_ptr->pval = 3;
4644                                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA))
4645                                                 o_ptr->pval += randint1(2);
4646                                 }
4647                                 else if (o_ptr->name2 == EGO_BAT)
4648                                 {
4649                                         o_ptr->pval = randint1(e_ptr->max_pval);
4650                                         if (o_ptr->sval == SV_ELVEN_CLOAK) o_ptr->pval += randint1(2);
4651                                 }
4652                                 else if (o_ptr->name2 == EGO_A_DEMON || o_ptr->name2 == EGO_DRUID || o_ptr->name2 == EGO_OLOG)
4653                                 {
4654                                         o_ptr->pval = randint1(e_ptr->max_pval);
4655                                 }
4656                                 else
4657                                 {
4658                                         o_ptr->pval += randint1(e_ptr->max_pval);
4659                                 }
4660
4661
4662                         }
4663                         if ((o_ptr->name2 == EGO_SPEED) && (lev < 50))
4664                         {
4665                                 o_ptr->pval = randint1(o_ptr->pval);
4666                         }
4667                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA) && (o_ptr->pval > 2) && (o_ptr->name2 != EGO_ATTACKS))
4668                                 o_ptr->pval = 2;
4669                 }
4670
4671                 return;
4672         }
4673
4674         /* Examine real objects */
4675         if (o_ptr->k_idx)
4676         {
4677                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
4678
4679                 /* Hack -- acquire "broken" flag */
4680                 if (!k_info[o_ptr->k_idx].cost) o_ptr->ident |= (IDENT_BROKEN);
4681
4682                 /* Hack -- acquire "cursed" flag */
4683                 if (k_ptr->gen_flags & (TRG_CURSED)) o_ptr->curse_flags |= (TRC_CURSED);
4684                 if (k_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= TRC_HEAVY_CURSE;
4685                 if (k_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= TRC_PERMA_CURSE;
4686                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4687                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4688                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4689         }
4690
4691
4692 }
4693
4694
4695 /*!
4696  * @brief ベースアイテムが上質として扱われるかどうかを返す。
4697  * Hack -- determine if a template is "good"
4698  * @param k_idx 判定したいベースアイテムのID
4699  * @return ベースアイテムが上質ならばTRUEを返す。
4700  */
4701 static bool kind_is_good(KIND_OBJECT_IDX k_idx)
4702 {
4703         object_kind *k_ptr = &k_info[k_idx];
4704
4705         /* Analyze the item type */
4706         switch (k_ptr->tval)
4707         {
4708                 /* Armor -- Good unless damaged */
4709                 case TV_HARD_ARMOR:
4710                 case TV_SOFT_ARMOR:
4711                 case TV_DRAG_ARMOR:
4712                 case TV_SHIELD:
4713                 case TV_CLOAK:
4714                 case TV_BOOTS:
4715                 case TV_GLOVES:
4716                 case TV_HELM:
4717                 case TV_CROWN:
4718                 {
4719                         if (k_ptr->to_a < 0) return (FALSE);
4720                         return (TRUE);
4721                 }
4722
4723                 /* Weapons -- Good unless damaged */
4724                 case TV_BOW:
4725                 case TV_SWORD:
4726                 case TV_HAFTED:
4727                 case TV_POLEARM:
4728                 case TV_DIGGING:
4729                 {
4730                         if (k_ptr->to_h < 0) return (FALSE);
4731                         if (k_ptr->to_d < 0) return (FALSE);
4732                         return (TRUE);
4733                 }
4734
4735                 /* Ammo -- Arrows/Bolts are good */
4736                 case TV_BOLT:
4737                 case TV_ARROW:
4738                 {
4739                         return (TRUE);
4740                 }
4741
4742                 /* Books -- High level books are good (except Arcane books) */
4743                 case TV_LIFE_BOOK:
4744                 case TV_SORCERY_BOOK:
4745                 case TV_NATURE_BOOK:
4746                 case TV_CHAOS_BOOK:
4747                 case TV_DEATH_BOOK:
4748                 case TV_TRUMP_BOOK:
4749                 case TV_CRAFT_BOOK:
4750                 case TV_DAEMON_BOOK:
4751                 case TV_CRUSADE_BOOK:
4752                 case TV_MUSIC_BOOK:
4753                 case TV_HISSATSU_BOOK:
4754                 case TV_HEX_BOOK:
4755                 {
4756                         if (k_ptr->sval >= SV_BOOK_MIN_GOOD) return (TRUE);
4757                         return (FALSE);
4758                 }
4759
4760                 /* Rings -- Rings of Speed are good */
4761                 case TV_RING:
4762                 {
4763                         if (k_ptr->sval == SV_RING_SPEED) return (TRUE);
4764                         if (k_ptr->sval == SV_RING_LORDLY) return (TRUE);
4765                         return (FALSE);
4766                 }
4767
4768                 /* Amulets -- Amulets of the Magi and Resistance are good */
4769                 case TV_AMULET:
4770                 {
4771                         if (k_ptr->sval == SV_AMULET_THE_MAGI) return (TRUE);
4772                         if (k_ptr->sval == SV_AMULET_RESISTANCE) return (TRUE);
4773                         return (FALSE);
4774                 }
4775         }
4776
4777         /* Assume not good */
4778         return (FALSE);
4779 }
4780
4781 /*!
4782  * @brief 生成階に応じたベースアイテムの生成を行う。
4783  * Attempt to make an object (normal or good/great)
4784  * @param j_ptr 生成結果を収めたいオブジェクト構造体の参照ポインタ
4785  * @param mode オプションフラグ
4786  * @return 生成に成功したらTRUEを返す。
4787  * @details
4788  * This routine plays nasty games to generate the "special artifacts".\n
4789  * This routine uses "object_level" for the "generation level".\n
4790  * We assume that the given object has been "wiped".\n
4791  */
4792 bool make_object(object_type *j_ptr, BIT_FLAGS mode)
4793 {
4794         PERCENTAGE prob;
4795         DEPTH base;
4796
4797
4798         /* Chance of "special object" */
4799         prob = ((mode & AM_GOOD) ? 10 : 1000);
4800
4801         /* Base level for the object */
4802         base = ((mode & AM_GOOD) ? (object_level + 10) : object_level);
4803
4804
4805         /* Generate a special object, or a normal object */
4806         if (!one_in_(prob) || !make_artifact_special(j_ptr))
4807         {
4808                 KIND_OBJECT_IDX k_idx;
4809
4810                 /* Good objects */
4811                 if ((mode & AM_GOOD) && !get_obj_num_hook)
4812                 {
4813                         /* Activate restriction (if already specified, use that) */
4814                         get_obj_num_hook = kind_is_good;
4815                 }
4816
4817                 /* Restricted objects - prepare allocation table */
4818                 if (get_obj_num_hook) get_obj_num_prep();
4819
4820                 /* Pick a random object */
4821                 k_idx = get_obj_num(base);
4822
4823                 /* Restricted objects */
4824                 if (get_obj_num_hook)
4825                 {
4826                         /* Clear restriction */
4827                         get_obj_num_hook = NULL;
4828
4829                         /* Reset allocation table to default */
4830                         get_obj_num_prep();
4831                 }
4832
4833                 /* Handle failure */
4834                 if (!k_idx) return (FALSE);
4835
4836                 /* Prepare the object */
4837                 object_prep(j_ptr, k_idx);
4838         }
4839
4840         /* Apply magic (allow artifacts) */
4841         apply_magic(j_ptr, object_level, mode);
4842
4843         /* Hack -- generate multiple spikes/missiles */
4844         switch (j_ptr->tval)
4845         {
4846                 case TV_SPIKE:
4847                 case TV_SHOT:
4848                 case TV_ARROW:
4849                 case TV_BOLT:
4850                 {
4851                         if (!j_ptr->name1)
4852                                 j_ptr->number = (byte)damroll(6, 7);
4853                 }
4854         }
4855
4856         if (cheat_peek) object_mention(j_ptr);
4857
4858         /* Success */
4859         return (TRUE);
4860 }
4861
4862
4863 /*!
4864  * @brief フロアの指定位置に生成階に応じたベースアイテムの生成を行う。
4865  * Attempt to place an object (normal or good/great) at the given location.
4866  * @param y 配置したいフロアのY座標
4867  * @param x 配置したいフロアのX座標
4868  * @param mode オプションフラグ
4869  * @return 生成に成功したらTRUEを返す。
4870  * @details
4871  * This routine plays nasty games to generate the "special artifacts".\n
4872  * This routine uses "object_level" for the "generation level".\n
4873  * This routine requires a clean floor grid destination.\n
4874  */
4875 void place_object(POSITION y, POSITION x, BIT_FLAGS mode)
4876 {
4877         OBJECT_IDX o_idx;
4878
4879         /* Acquire grid */
4880         cave_type *c_ptr = &cave[y][x];
4881
4882         object_type forge;
4883         object_type *q_ptr;
4884
4885
4886         /* Paranoia -- check bounds */
4887         if (!in_bounds(y, x)) return;
4888
4889         /* Require floor space */
4890         if (!cave_drop_bold(y, x)) return;
4891
4892         /* Avoid stacking on other objects */
4893         if (c_ptr->o_idx) return;
4894
4895         q_ptr = &forge;
4896         object_wipe(q_ptr);
4897
4898         /* Make an object (if possible) */
4899         if (!make_object(q_ptr, mode)) return;
4900
4901
4902         /* Make an object */
4903         o_idx = o_pop();
4904
4905         /* Success */
4906         if (o_idx)
4907         {
4908                 object_type *o_ptr;
4909                 o_ptr = &o_list[o_idx];
4910
4911                 /* Structure Copy */
4912                 object_copy(o_ptr, q_ptr);
4913
4914                 o_ptr->iy = y;
4915                 o_ptr->ix = x;
4916
4917                 /* Build a stack */
4918                 o_ptr->next_o_idx = c_ptr->o_idx;
4919
4920                 /* Place the object */
4921                 c_ptr->o_idx = o_idx;
4922
4923                 note_spot(y, x);
4924
4925                 lite_spot(y, x);
4926         }
4927         else
4928         {
4929                 /* Hack -- Preserve artifacts */
4930                 if (object_is_fixed_artifact(q_ptr))
4931                 {
4932                         a_info[q_ptr->name1].cur_num = 0;
4933                 }
4934         }
4935 }
4936
4937
4938 /*!
4939  * @brief 生成階に応じた財宝オブジェクトの生成を行う。
4940  * Make a treasure object
4941  * @param j_ptr 生成結果を収めたいオブジェクト構造体の参照ポインタ
4942  * @return 生成に成功したらTRUEを返す。
4943  * @details
4944  * The location must be a legal, clean, floor grid.
4945  */
4946 bool make_gold(object_type *j_ptr)
4947 {
4948         int i;
4949         s32b base;
4950
4951         /* Hack -- Pick a Treasure variety */
4952         i = ((randint1(object_level + 2) + 2) / 2) - 1;
4953
4954         /* Apply "extra" magic */
4955         if (one_in_(GREAT_OBJ))
4956         {
4957                 i += randint1(object_level + 1);
4958         }
4959
4960         /* Hack -- Creeping Coins only generate "themselves" */
4961         if (coin_type) i = coin_type;
4962
4963         /* Do not create "illegal" Treasure Types */
4964         if (i >= MAX_GOLD) i = MAX_GOLD - 1;
4965
4966         /* Prepare a gold object */
4967         object_prep(j_ptr, OBJ_GOLD_LIST + i);
4968
4969         /* Hack -- Base coin cost */
4970         base = k_info[OBJ_GOLD_LIST + i].cost;
4971
4972         /* Determine how much the treasure is "worth" */
4973         j_ptr->pval = (base + (8L * randint1(base)) + randint1(8));
4974
4975         /* Success */
4976         return (TRUE);
4977 }
4978
4979
4980 /*!
4981  * @brief フロアの指定位置に生成階に応じた財宝オブジェクトの生成を行う。
4982  * Places a treasure (Gold or Gems) at given location
4983  * @param y 配置したいフロアのY座標
4984  * @param x 配置したいフロアのX座標
4985  * @return 生成に成功したらTRUEを返す。
4986  * @details
4987  * The location must be a legal, clean, floor grid.
4988  */
4989 void place_gold(POSITION y, POSITION x)
4990 {
4991         OBJECT_IDX o_idx;
4992
4993         /* Acquire grid */
4994         cave_type *c_ptr = &cave[y][x];
4995
4996         object_type forge;
4997         object_type *q_ptr;
4998
4999
5000         /* Paranoia -- check bounds */
5001         if (!in_bounds(y, x)) return;
5002
5003         /* Require floor space */
5004         if (!cave_drop_bold(y, x)) return;
5005
5006         /* Avoid stacking on other objects */
5007         if (c_ptr->o_idx) return;
5008
5009         q_ptr = &forge;
5010         object_wipe(q_ptr);
5011
5012         /* Make some gold */
5013         if (!make_gold(q_ptr)) return;
5014
5015         /* Make an object */
5016         o_idx = o_pop();
5017
5018         /* Success */
5019         if (o_idx)
5020         {
5021                 object_type *o_ptr;
5022                 o_ptr = &o_list[o_idx];
5023
5024                 /* Copy the object */
5025                 object_copy(o_ptr, q_ptr);
5026
5027                 /* Save location */
5028                 o_ptr->iy = y;
5029                 o_ptr->ix = x;
5030
5031                 /* Build a stack */
5032                 o_ptr->next_o_idx = c_ptr->o_idx;
5033
5034                 /* Place the object */
5035                 c_ptr->o_idx = o_idx;
5036
5037                 note_spot(y, x);
5038
5039                 lite_spot(y, x);
5040         }
5041 }
5042
5043
5044 /*!
5045  * @brief 生成済のオブジェクトをフロアの所定の位置に落とす。
5046  * Let an object fall to the ground at or near a location.
5047  * @param j_ptr 落としたいオブジェクト構造体の参照ポインタ
5048  * @param chance ドロップの成功率(%)
5049  * @param y 配置したいフロアのY座標
5050  * @param x 配置したいフロアのX座標
5051  * @return 生成に成功したらオブジェクトのIDを返す。
5052  * @details
5053  * The initial location is assumed to be "in_bounds()".\n
5054  *\n
5055  * This function takes a parameter "chance".  This is the percentage\n
5056  * chance that the item will "disappear" instead of drop.  If the object\n
5057  * has been thrown, then this is the chance of disappearance on contact.\n
5058  *\n
5059  * Hack -- this function uses "chance" to determine if it should produce\n
5060  * some form of "description" of the drop event (under the player).\n
5061  *\n
5062  * We check several locations to see if we can find a location at which\n
5063  * the object can combine, stack, or be placed.  Artifacts will try very\n
5064  * hard to be placed, including "teleporting" to a useful grid if needed.\n
5065  */
5066 OBJECT_IDX drop_near(object_type *j_ptr, PERCENTAGE chance, POSITION y, POSITION x)
5067 {
5068         int i, k, d, s;
5069
5070         int bs, bn;
5071         POSITION by, bx;
5072         POSITION dy, dx;
5073         POSITION ty, tx = 0;
5074
5075         OBJECT_IDX o_idx = 0;
5076         OBJECT_IDX this_o_idx, next_o_idx = 0;
5077
5078         cave_type *c_ptr;
5079
5080         char o_name[MAX_NLEN];
5081
5082         bool flag = FALSE;
5083         bool done = FALSE;
5084
5085 #ifndef JP
5086         /* Extract plural */
5087         bool plural = (j_ptr->number != 1);
5088 #endif
5089
5090         /* Describe object */
5091         object_desc(o_name, j_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
5092
5093
5094         /* Handle normal "breakage" */
5095         if (!object_is_artifact(j_ptr) && (randint0(100) < chance))
5096         {
5097 #ifdef JP
5098                 msg_format("%sは消えた。", o_name);
5099 #else
5100                 msg_format("The %s disappear%s.", o_name, (plural ? "" : "s"));
5101 #endif
5102                 /* Debug */
5103                 if (p_ptr->wizard) msg_print(_("(破損)", "(breakage)"));
5104
5105                 /* Failure */
5106                 return (0);
5107         }
5108
5109
5110         /* Score */
5111         bs = -1;
5112
5113         /* Picker */
5114         bn = 0;
5115
5116         /* Default */
5117         by = y;
5118         bx = x;
5119
5120         /* Scan local grids */
5121         for (dy = -3; dy <= 3; dy++)
5122         {
5123                 /* Scan local grids */
5124                 for (dx = -3; dx <= 3; dx++)
5125                 {
5126                         bool comb = FALSE;
5127
5128                         /* Calculate actual distance */
5129                         d = (dy * dy) + (dx * dx);
5130
5131                         /* Ignore distant grids */
5132                         if (d > 10) continue;
5133
5134                         ty = y + dy;
5135                         tx = x + dx;
5136
5137                         /* Skip illegal grids */
5138                         if (!in_bounds(ty, tx)) continue;
5139
5140                         /* Require line of projection */
5141                         if (!projectable(y, x, ty, tx)) continue;
5142
5143                         /* Obtain grid */
5144                         c_ptr = &cave[ty][tx];
5145
5146                         /* Require floor space */
5147                         if (!cave_drop_bold(ty, tx)) continue;
5148
5149                         /* No objects */
5150                         k = 0;
5151
5152                         /* Scan objects in that grid */
5153                         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
5154                         {
5155                                 object_type *o_ptr;
5156                                 o_ptr = &o_list[this_o_idx];
5157
5158                                 /* Acquire next object */
5159                                 next_o_idx = o_ptr->next_o_idx;
5160
5161                                 /* Check for possible combination */
5162                                 if (object_similar(o_ptr, j_ptr)) comb = TRUE;
5163
5164                                 /* Count objects */
5165                                 k++;
5166                         }
5167
5168                         /* Add new object */
5169                         if (!comb) k++;
5170
5171                         /* Paranoia */
5172                         if (k > 99) continue;
5173
5174                         /* Calculate score */
5175                         s = 1000 - (d + k * 5);
5176
5177                         /* Skip bad values */
5178                         if (s < bs) continue;
5179
5180                         /* New best value */
5181                         if (s > bs) bn = 0;
5182
5183                         /* Apply the randomizer to equivalent values */
5184                         if ((++bn >= 2) && !one_in_(bn)) continue;
5185
5186                         /* Keep score */
5187                         bs = s;
5188
5189                         /* Track it */
5190                         by = ty;
5191                         bx = tx;
5192
5193                         flag = TRUE;
5194                 }
5195         }
5196
5197
5198         /* Handle lack of space */
5199         if (!flag && !object_is_artifact(j_ptr))
5200         {
5201 #ifdef JP
5202                 msg_format("%sは消えた。", o_name);
5203 #else
5204                 msg_format("The %s disappear%s.", o_name, (plural ? "" : "s"));
5205 #endif
5206
5207
5208                 /* Debug */
5209                 if (p_ptr->wizard) msg_print(_("(床スペースがない)", "(no floor space)"));
5210
5211                 /* Failure */
5212                 return (0);
5213         }
5214
5215
5216         /* Find a grid */
5217         for (i = 0; !flag && (i < 1000); i++)
5218         {
5219                 /* Bounce around */
5220                 ty = rand_spread(by, 1);
5221                 tx = rand_spread(bx, 1);
5222
5223                 /* Verify location */
5224                 if (!in_bounds(ty, tx)) continue;
5225
5226                 /* Bounce to that location */
5227                 by = ty;
5228                 bx = tx;
5229
5230                 /* Require floor space */
5231                 if (!cave_drop_bold(by, bx)) continue;
5232
5233                 flag = TRUE;
5234         }
5235
5236
5237         if (!flag)
5238         {
5239                 int candidates = 0, pick;
5240
5241                 for (ty = 1; ty < cur_hgt - 1; ty++)
5242                 {
5243                         for (tx = 1; tx < cur_wid - 1; tx++)
5244                         {
5245                                 /* A valid space found */
5246                                 if (cave_drop_bold(ty, tx)) candidates++;
5247                         }
5248                 }
5249
5250                 /* No valid place! */
5251                 if (!candidates)
5252                 {
5253 #ifdef JP
5254                         msg_format("%sは消えた。", o_name);
5255 #else
5256                         msg_format("The %s disappear%s.", o_name, (plural ? "" : "s"));
5257 #endif
5258
5259                         /* Debug */
5260                         if (p_ptr->wizard) msg_print(_("(床スペースがない)", "(no floor space)"));
5261
5262                         /* Mega-Hack -- preserve artifacts */
5263                         if (preserve_mode)
5264                         {
5265                                 /* Hack -- Preserve unknown artifacts */
5266                                 if (object_is_fixed_artifact(j_ptr) && !object_is_known(j_ptr))
5267                                 {
5268                                         /* Mega-Hack -- Preserve the artifact */
5269                                         a_info[j_ptr->name1].cur_num = 0;
5270                                 }
5271                         }
5272
5273                         /* Failure */
5274                         return 0;
5275                 }
5276
5277                 /* Choose a random one */
5278                 pick = randint1(candidates);
5279
5280                 for (ty = 1; ty < cur_hgt - 1; ty++)
5281                 {
5282                         for (tx = 1; tx < cur_wid - 1; tx++)
5283                         {
5284                                 if (cave_drop_bold(ty, tx))
5285                                 {
5286                                         pick--;
5287
5288                                         /* Is this a picked one? */
5289                                         if (!pick) break;
5290                                 }
5291                         }
5292
5293                         if (!pick) break;
5294                 }
5295
5296                 by = ty;
5297                 bx = tx;
5298         }
5299
5300
5301         /* Grid */
5302         c_ptr = &cave[by][bx];
5303
5304         /* Scan objects in that grid for combination */
5305         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
5306         {
5307                 object_type *o_ptr;
5308                 o_ptr = &o_list[this_o_idx];
5309
5310                 /* Acquire next object */
5311                 next_o_idx = o_ptr->next_o_idx;
5312
5313                 /* Check for combination */
5314                 if (object_similar(o_ptr, j_ptr))
5315                 {
5316                         /* Combine the items */
5317                         object_absorb(o_ptr, j_ptr);
5318
5319                         /* Success */
5320                         done = TRUE;
5321
5322                         break;
5323                 }
5324         }
5325
5326         /* Get new object */
5327         if (!done) o_idx = o_pop();
5328
5329         /* Failure */
5330         if (!done && !o_idx)
5331         {
5332 #ifdef JP
5333                 msg_format("%sは消えた。", o_name);
5334 #else
5335                 msg_format("The %s disappear%s.",
5336                            o_name, (plural ? "" : "s"));
5337 #endif
5338
5339
5340                 /* Debug */
5341                 if (p_ptr->wizard) msg_print(_("(アイテムが多過ぎる)", "(too many objects)"));
5342
5343                 /* Hack -- Preserve artifacts */
5344                 if (object_is_fixed_artifact(j_ptr))
5345                 {
5346                         a_info[j_ptr->name1].cur_num = 0;
5347                 }
5348
5349                 /* Failure */
5350                 return (0);
5351         }
5352
5353         /* Stack */
5354         if (!done)
5355         {
5356                 /* Structure copy */
5357                 object_copy(&o_list[o_idx], j_ptr);
5358
5359                 /* Access new object */
5360                 j_ptr = &o_list[o_idx];
5361
5362                 /* Locate */
5363                 j_ptr->iy = by;
5364                 j_ptr->ix = bx;
5365
5366                 /* No monster */
5367                 j_ptr->held_m_idx = 0;
5368
5369                 /* Build a stack */
5370                 j_ptr->next_o_idx = c_ptr->o_idx;
5371
5372                 /* Place the object */
5373                 c_ptr->o_idx = o_idx;
5374
5375                 /* Success */
5376                 done = TRUE;
5377         }
5378
5379         /* Note the spot */
5380         note_spot(by, bx);
5381
5382         /* Draw the spot */
5383         lite_spot(by, bx);
5384
5385         sound(SOUND_DROP);
5386
5387         /* Mega-Hack -- no message if "dropped" by player */
5388         /* Message when an object falls under the player */
5389         if (chance && player_bold(by, bx))
5390         {
5391                 msg_print(_("何かが足下に転がってきた。", "You feel something roll beneath your feet."));
5392         }
5393
5394         return (o_idx);
5395 }
5396
5397
5398 /*!
5399  * @brief 獲得ドロップを行う。
5400  * Scatter some "great" objects near the player
5401  * @param y1 配置したいフロアのY座標
5402  * @param x1 配置したいフロアのX座標
5403  * @param num 獲得の処理回数
5404  * @param great TRUEならば必ず高級品以上を落とす
5405  * @param special TRUEならば必ず特別品を落とす
5406  * @param known TRUEならばオブジェクトが必ず＊鑑定＊済になる
5407  * @return なし
5408  */
5409 void acquirement(POSITION y1, POSITION x1, int num, bool great, bool special, bool known)
5410 {
5411         object_type *i_ptr;
5412         object_type object_type_body;
5413         BIT_FLAGS mode = AM_GOOD | (great || special ? AM_GREAT : 0L) | (special ? AM_SPECIAL : 0L) ;
5414
5415         /* Acquirement */
5416         while (num--)
5417         {
5418                 i_ptr = &object_type_body;
5419                 object_wipe(i_ptr);
5420
5421                 /* Make a good (or great) object (if possible) */
5422                 if (!make_object(i_ptr, mode)) continue;
5423
5424                 if (known)
5425                 {
5426                         object_aware(i_ptr);
5427                         object_known(i_ptr);
5428                 }
5429
5430                 /* Drop the object */
5431                 (void)drop_near(i_ptr, -1, y1, x1);
5432         }
5433 }
5434
5435 /*
5436  * Scatter some "amusing" objects near the player
5437  */
5438
5439 #define AMS_NOTHING   0x00 /* No restriction */
5440 #define AMS_NO_UNIQUE 0x01 /* Don't make the amusing object of uniques */
5441 #define AMS_FIXED_ART 0x02 /* Make a fixed artifact based on the amusing object */
5442 #define AMS_MULTIPLE  0x04 /* Drop 1-3 objects for one type */
5443 #define AMS_PILE      0x08 /* Drop 1-99 pile objects for one type */
5444
5445 typedef struct
5446 {
5447         OBJECT_TYPE_VALUE tval;
5448         OBJECT_SUBTYPE_VALUE sval;
5449         PERCENTAGE prob;
5450         byte flag;
5451 } amuse_type;
5452
5453 amuse_type amuse_info[] =
5454 {
5455         { TV_BOTTLE, SV_ANY, 5, AMS_NOTHING },
5456         { TV_JUNK, SV_ANY, 3, AMS_MULTIPLE },
5457         { TV_SPIKE, SV_ANY, 10, AMS_PILE },
5458         { TV_STATUE, SV_ANY, 15, AMS_NOTHING },
5459         { TV_CORPSE, SV_ANY, 15, AMS_NO_UNIQUE },
5460         { TV_SKELETON, SV_ANY, 10, AMS_NO_UNIQUE },
5461         { TV_FIGURINE, SV_ANY, 10, AMS_NO_UNIQUE },
5462         { TV_PARCHMENT, SV_ANY, 1, AMS_NOTHING },
5463         { TV_POLEARM, SV_TSURIZAO, 3, AMS_NOTHING }, //Fishing Pole of Taikobo
5464         { TV_SWORD, SV_BROKEN_DAGGER, 3, AMS_FIXED_ART }, //Broken Dagger of Magician
5465         { TV_SWORD, SV_BROKEN_DAGGER, 10, AMS_NOTHING },
5466         { TV_SWORD, SV_BROKEN_SWORD, 5, AMS_NOTHING },
5467         { TV_SCROLL, SV_SCROLL_AMUSEMENT, 10, AMS_NOTHING },
5468
5469         { 0, 0, 0 }
5470 };
5471
5472 /*!
5473  * @brief 誰得ドロップを行う。
5474  * @param y1 配置したいフロアのY座標
5475  * @param x1 配置したいフロアのX座標
5476  * @param num 誰得の処理回数
5477  * @param known TRUEならばオブジェクトが必ず＊鑑定＊済になる
5478  * @return なし
5479  */
5480 void amusement(POSITION y1, POSITION x1, int num, bool known)
5481 {
5482         object_type *i_ptr;
5483         object_type object_type_body;
5484         int n, t = 0;
5485
5486         for (n = 0; amuse_info[n].tval != 0; n++)
5487         {
5488                 t += amuse_info[n].prob;
5489         }
5490
5491         /* Acquirement */
5492         while (num)
5493         {
5494                 int i;
5495                 KIND_OBJECT_IDX k_idx;
5496                 ARTIFACT_IDX a_idx = 0;
5497                 int r = randint0(t);
5498                 bool insta_art, fixed_art;
5499
5500                 for (i = 0; ; i++)
5501                 {
5502                         r -= amuse_info[i].prob;
5503                         if (r <= 0) break;
5504                 }
5505                 i_ptr = &object_type_body;
5506                 object_wipe(i_ptr);
5507                 k_idx = lookup_kind(amuse_info[i].tval, amuse_info[i].sval);
5508
5509                 /* Paranoia - reroll if nothing */
5510                 if (!k_idx) continue;
5511
5512                 /* Search an artifact index if need */
5513                 insta_art = (k_info[k_idx].gen_flags & TRG_INSTA_ART);
5514                 fixed_art = (amuse_info[i].flag & AMS_FIXED_ART);
5515
5516                 if (insta_art || fixed_art)
5517                 {
5518                         for (a_idx = 1; a_idx < max_a_idx; a_idx++)
5519                         {
5520                                 if (insta_art && !(a_info[a_idx].gen_flags & TRG_INSTA_ART)) continue;
5521                                 if (a_info[a_idx].tval != k_info[k_idx].tval) continue;
5522                                 if (a_info[a_idx].sval != k_info[k_idx].sval) continue;
5523                                 if (a_info[a_idx].cur_num > 0) continue;
5524                                 break;
5525                         }
5526
5527                         if (a_idx >= max_a_idx) continue;
5528                 }
5529
5530                 /* Make an object (if possible) */
5531                 object_prep(i_ptr, k_idx);
5532                 if (a_idx) i_ptr->name1 = a_idx;
5533                 apply_magic(i_ptr, 1, AM_NO_FIXED_ART);
5534
5535                 if (amuse_info[i].flag & AMS_NO_UNIQUE)
5536                 {
5537                         if (r_info[i_ptr->pval].flags1 & RF1_UNIQUE) continue;
5538                 }
5539
5540                 if (amuse_info[i].flag & AMS_MULTIPLE) i_ptr->number = randint1(3);
5541                 if (amuse_info[i].flag & AMS_PILE) i_ptr->number = randint1(99);
5542
5543                 if (known)
5544                 {
5545                         object_aware(i_ptr);
5546                         object_known(i_ptr);
5547                 }
5548
5549                 /* Paranoia - reroll if nothing */
5550                 if (!(i_ptr->k_idx)) continue;
5551
5552                 /* Drop the object */
5553                 (void)drop_near(i_ptr, -1, y1, x1);
5554
5555                 num--;
5556         }
5557 }
5558
5559
5560 /*!
5561  * @brief 魔道具の使用回数の残量を示すメッセージを表示する /
5562  * Describe the charges on an item in the inventory.
5563  * @param item 残量を表示したいプレイヤーのアイテム所持スロット
5564  * @return なし
5565  */
5566 void inven_item_charges(INVENTORY_IDX item)
5567 {
5568         object_type *o_ptr = &inventory[item];
5569
5570         /* Require staff/wand */
5571         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5572
5573         /* Require known item */
5574         if (!object_is_known(o_ptr)) return;
5575
5576 #ifdef JP
5577         if (o_ptr->pval <= 0)
5578         {
5579                 msg_print("もう魔力が残っていない。");
5580         }
5581         else
5582         {
5583                 msg_format("あと %d 回分の魔力が残っている。", o_ptr->pval);
5584         }
5585 #else
5586         /* Multiple charges */
5587         if (o_ptr->pval != 1)
5588         {
5589                 msg_format("You have %d charges remaining.", o_ptr->pval);
5590         }
5591
5592         /* Single charge */
5593         else
5594         {
5595                 msg_format("You have %d charge remaining.", o_ptr->pval);
5596         }
5597 #endif
5598
5599 }
5600
5601 /*!
5602  * @brief アイテムの残り所持数メッセージを表示する /
5603  * Describe an item in the inventory.
5604  * @param item 残量を表示したいプレイヤーのアイテム所持スロット
5605  * @return なし
5606  */
5607 void inven_item_describe(INVENTORY_IDX item)
5608 {
5609         object_type *o_ptr = &inventory[item];
5610         char        o_name[MAX_NLEN];
5611
5612         object_desc(o_name, o_ptr, 0);
5613
5614 #ifdef JP
5615         /* "no more" の場合はこちらで表示する */
5616         if (o_ptr->number <= 0)
5617         {
5618                 /*FIRST*//*ここはもう通らないかも */
5619                 msg_format("もう%sを持っていない。", o_name);
5620         }
5621         else
5622         {
5623                 /* アイテム名を英日切り替え機能対応 */
5624                 msg_format("まだ %sを持っている。", o_name);
5625         }
5626 #else
5627         msg_format("You have %s.", o_name);
5628 #endif
5629
5630 }
5631
5632 /*!
5633  * @brief アイテムを増やし残り所持数メッセージを表示する /
5634  * Increase the "number" of an item in the inventory
5635  * @param item 所持数を増やしたいプレイヤーのアイテム所持スロット
5636  * @param num 増やしたい量
5637  * @return なし
5638  */
5639 void inven_item_increase(INVENTORY_IDX item, int num)
5640 {
5641         object_type *o_ptr = &inventory[item];
5642
5643         /* Apply */
5644         num += o_ptr->number;
5645
5646         /* Bounds check */
5647         if (num > 255) num = 255;
5648         else if (num < 0) num = 0;
5649
5650         /* Un-apply */
5651         num -= (ITEM_NUMBER)o_ptr->number;
5652
5653         /* Change the number and weight */
5654         if (num)
5655         {
5656                 /* Add the number */
5657                 o_ptr->number += num;
5658
5659                 /* Add the weight */
5660                 p_ptr->total_weight += (num * o_ptr->weight);
5661
5662                 /* Recalculate bonuses */
5663                 p_ptr->update |= (PU_BONUS);
5664
5665                 /* Recalculate mana XXX */
5666                 p_ptr->update |= (PU_MANA);
5667
5668                 /* Combine the pack */
5669                 p_ptr->notice |= (PN_COMBINE);
5670
5671                 p_ptr->window |= (PW_INVEN | PW_EQUIP);
5672
5673                 /* Hack -- Clear temporary elemental brands if player takes off weapons */
5674                 if (!o_ptr->number && p_ptr->ele_attack)
5675                 {
5676                         if ((item == INVEN_RARM) || (item == INVEN_LARM))
5677                         {
5678                                 if (!buki_motteruka(INVEN_RARM + INVEN_LARM - item))
5679                                 {
5680                                         /* Clear all temporary elemental brands */
5681                                         set_ele_attack(0, 0);
5682                                 }
5683                         }
5684                 }
5685         }
5686 }
5687
5688 /*!
5689  * @brief 所持アイテムスロットから所持数のなくなったアイテムを消去する /
5690  * Erase an inventory slot if it has no more items
5691  * @param item 消去したいプレイヤーのアイテム所持スロット
5692  * @return なし
5693  */
5694 void inven_item_optimize(INVENTORY_IDX item)
5695 {
5696         object_type *o_ptr = &inventory[item];
5697
5698         /* Only optimize real items */
5699         if (!o_ptr->k_idx) return;
5700
5701         /* Only optimize empty items */
5702         if (o_ptr->number) return;
5703
5704         /* The item is in the pack */
5705         if (item < INVEN_RARM)
5706         {
5707                 int i;
5708
5709                 /* One less item */
5710                 inven_cnt--;
5711
5712                 /* Slide everything down */
5713                 for (i = item; i < INVEN_PACK; i++)
5714                 {
5715                         /* Structure copy */
5716                         inventory[i] = inventory[i+1];
5717                 }
5718
5719                 /* Erase the "final" slot */
5720                 object_wipe(&inventory[i]);
5721
5722                 p_ptr->window |= (PW_INVEN);
5723         }
5724
5725         /* The item is being wielded */
5726         else
5727         {
5728                 /* One less item */
5729                 equip_cnt--;
5730
5731                 /* Erase the empty slot */
5732                 object_wipe(&inventory[item]);
5733
5734                 /* Recalculate bonuses */
5735                 p_ptr->update |= (PU_BONUS);
5736
5737                 /* Recalculate torch */
5738                 p_ptr->update |= (PU_TORCH);
5739
5740                 /* Recalculate mana XXX */
5741                 p_ptr->update |= (PU_MANA);
5742
5743                 p_ptr->window |= (PW_EQUIP);
5744         }
5745
5746         p_ptr->window |= (PW_SPELL);
5747 }
5748
5749 /*!
5750  * @brief 床上の魔道具の残り残量メッセージを表示する /
5751  * Describe the charges on an item on the floor.
5752  * @param item メッセージの対象にしたいアイテム所持スロット
5753  * @return なし
5754  */
5755 void floor_item_charges(INVENTORY_IDX item)
5756 {
5757         object_type *o_ptr = &o_list[item];
5758
5759         /* Require staff/wand */
5760         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5761
5762         /* Require known item */
5763         if (!object_is_known(o_ptr)) return;
5764
5765 #ifdef JP
5766         if (o_ptr->pval <= 0)
5767         {
5768                 msg_print("この床上のアイテムは、もう魔力が残っていない。");
5769         }
5770         else
5771         {
5772                 msg_format("この床上のアイテムは、あと %d 回分の魔力が残っている。", o_ptr->pval);
5773         }
5774 #else
5775         /* Multiple charges */
5776         if (o_ptr->pval != 1)
5777         {
5778                 msg_format("There are %d charges remaining.", o_ptr->pval);
5779         }
5780
5781         /* Single charge */
5782         else
5783         {
5784                 msg_format("There is %d charge remaining.", o_ptr->pval);
5785         }
5786 #endif
5787
5788 }
5789
5790 /*!
5791  * @brief 床上のアイテムの残り数メッセージを表示する /
5792  * Describe the charges on an item on the floor.
5793  * @param item メッセージの対象にしたいアイテム所持スロット
5794  * @return なし
5795  */
5796 void floor_item_describe(INVENTORY_IDX item)
5797 {
5798         object_type *o_ptr = &o_list[item];
5799         char        o_name[MAX_NLEN];
5800
5801         object_desc(o_name, o_ptr, 0);
5802
5803 #ifdef JP
5804         /* "no more" の場合はこちらで表示を分ける */
5805         if (o_ptr->number <= 0)
5806         {
5807                 msg_format("床上には、もう%sはない。", o_name);
5808         }
5809         else
5810         {
5811                 msg_format("床上には、まだ %sがある。", o_name);
5812         }
5813 #else
5814         msg_format("You see %s.", o_name);
5815 #endif
5816
5817 }
5818
5819
5820 /*!
5821  * @brief 床上のアイテムの数を増やす /
5822  * Increase the "number" of an item on the floor
5823  * @param item 増やしたいアイテムの所持スロット
5824  * @param num 増やしたいアイテムの数
5825  * @return なし
5826  */
5827 void floor_item_increase(INVENTORY_IDX item, int num)
5828 {
5829         object_type *o_ptr = &o_list[item];
5830
5831         /* Apply */
5832         num += o_ptr->number;
5833
5834         /* Bounds check */
5835         if (num > 255) num = 255;
5836         else if (num < 0) num = 0;
5837
5838         /* Un-apply */
5839         num -= (int)o_ptr->number;
5840
5841         /* Change the number */
5842         o_ptr->number += (ITEM_NUMBER)num;
5843 }
5844
5845
5846 /*!
5847  * @brief 床上の数の無くなったアイテムスロットを消去する /
5848  * Optimize an item on the floor (destroy "empty" items)
5849  * @param item 消去したいアイテムの所持スロット
5850  * @return なし
5851  */
5852 void floor_item_optimize(INVENTORY_IDX item)
5853 {
5854         object_type *o_ptr = &o_list[item];
5855
5856         /* Paranoia -- be sure it exists */
5857         if (!o_ptr->k_idx) return;
5858
5859         /* Only optimize empty items */
5860         if (o_ptr->number) return;
5861
5862         delete_object_idx(item);
5863 }
5864
5865
5866 /*!
5867  * @brief アイテムを拾う際にザックから溢れずに済むかを判定する /
5868  * Check if we have space for an item in the pack without overflow
5869  * @param o_ptr 拾いたいオブジェクトの構造体参照ポインタ
5870  * @return 溢れずに済むならTRUEを返す
5871  */
5872 bool inven_carry_okay(object_type *o_ptr)
5873 {
5874         int j;
5875
5876         /* Empty slot? */
5877         if (inven_cnt < INVEN_PACK) return (TRUE);
5878
5879         /* Similar slot? */
5880         for (j = 0; j < INVEN_PACK; j++)
5881         {
5882                 object_type *j_ptr = &inventory[j];
5883
5884                 /* Skip non-objects */
5885                 if (!j_ptr->k_idx) continue;
5886
5887                 /* Check if the two items can be combined */
5888                 if (object_similar(j_ptr, o_ptr)) return (TRUE);
5889         }
5890
5891         return (FALSE);
5892 }
5893
5894 /*!
5895  * @brief オブジェクトを定義された基準に従いソートするための関数 /
5896  * Check if we have space for an item in the pack without overflow
5897  * @param o_ptr 比較対象オブジェクトの構造体参照ポインタ1
5898  * @param o_value o_ptrのアイテム価値（手動であらかじめ代入する必要がある？）
5899  * @param j_ptr 比較対象オブジェクトの構造体参照ポインタ2
5900  * @return o_ptrの方が上位ならばTRUEを返す。
5901  */
5902 bool object_sort_comp(object_type *o_ptr, s32b o_value, object_type *j_ptr)
5903 {
5904         int o_type, j_type;
5905
5906         /* Use empty slots */
5907         if (!j_ptr->k_idx) return TRUE;
5908
5909         /* Hack -- readable books always come first */
5910         if ((o_ptr->tval == REALM1_BOOK) &&
5911             (j_ptr->tval != REALM1_BOOK)) return TRUE;
5912         if ((j_ptr->tval == REALM1_BOOK) &&
5913             (o_ptr->tval != REALM1_BOOK)) return FALSE;
5914
5915         if ((o_ptr->tval == REALM2_BOOK) &&
5916             (j_ptr->tval != REALM2_BOOK)) return TRUE;
5917         if ((j_ptr->tval == REALM2_BOOK) &&
5918             (o_ptr->tval != REALM2_BOOK)) return FALSE;
5919
5920         /* Objects sort by decreasing type */
5921         if (o_ptr->tval > j_ptr->tval) return TRUE;
5922         if (o_ptr->tval < j_ptr->tval) return FALSE;
5923
5924         /* Non-aware (flavored) items always come last */
5925         /* Can happen in the home */
5926         if (!object_is_aware(o_ptr)) return FALSE;
5927         if (!object_is_aware(j_ptr)) return TRUE;
5928
5929         /* Objects sort by increasing sval */
5930         if (o_ptr->sval < j_ptr->sval) return TRUE;
5931         if (o_ptr->sval > j_ptr->sval) return FALSE;
5932
5933         /* Unidentified objects always come last */
5934         /* Objects in the home can be unknown */
5935         if (!object_is_known(o_ptr)) return FALSE;
5936         if (!object_is_known(j_ptr)) return TRUE;
5937
5938         /* Fixed artifacts, random artifacts and ego items */
5939         if (object_is_fixed_artifact(o_ptr)) o_type = 3;
5940         else if (o_ptr->art_name) o_type = 2;
5941         else if (object_is_ego(o_ptr)) o_type = 1;
5942         else o_type = 0;
5943
5944         if (object_is_fixed_artifact(j_ptr)) j_type = 3;
5945         else if (j_ptr->art_name) j_type = 2;
5946         else if (object_is_ego(j_ptr)) j_type = 1;
5947         else j_type = 0;
5948
5949         if (o_type < j_type) return TRUE;
5950         if (o_type > j_type) return FALSE;
5951
5952         switch (o_ptr->tval)
5953         {
5954         case TV_FIGURINE:
5955         case TV_STATUE:
5956         case TV_CORPSE:
5957         case TV_CAPTURE:
5958                 if (r_info[o_ptr->pval].level < r_info[j_ptr->pval].level) return TRUE;
5959                 if ((r_info[o_ptr->pval].level == r_info[j_ptr->pval].level) && (o_ptr->pval < j_ptr->pval)) return TRUE;
5960                 return FALSE;
5961
5962         case TV_SHOT:
5963         case TV_ARROW:
5964         case TV_BOLT:
5965                 /* Objects sort by increasing hit/damage bonuses */
5966                 if (o_ptr->to_h + o_ptr->to_d < j_ptr->to_h + j_ptr->to_d) return TRUE;
5967                 if (o_ptr->to_h + o_ptr->to_d > j_ptr->to_h + j_ptr->to_d) return FALSE;
5968                 break;
5969
5970         /* Hack:  otherwise identical rods sort by
5971         increasing recharge time --dsb */
5972         case TV_ROD:
5973                 if (o_ptr->pval < j_ptr->pval) return TRUE;
5974                 if (o_ptr->pval > j_ptr->pval) return FALSE;
5975                 break;
5976         }
5977
5978         /* Objects sort by decreasing value */
5979         return o_value > object_value(j_ptr);
5980 }
5981
5982
5983 /*!
5984  * @brief オブジェクトをプレイヤーが拾って所持スロットに納めるメインルーチン /
5985  * Add an item to the players inventory, and return the slot used.
5986  * @param o_ptr 拾うオブジェクトの構造体参照ポインタ
5987  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
5988  * @details
5989  * If the new item can combine with an existing item in the inventory,\n
5990  * it will do so, using "object_similar()" and "object_absorb()", else,\n
5991  * the item will be placed into the "proper" location in the inventory.\n
5992  *\n
5993  * This function can be used to "over-fill" the player's pack, but only\n
5994  * once, and such an action must trigger the "overflow" code immediately.\n
5995  * Note that when the pack is being "over-filled", the new item must be\n
5996  * placed into the "overflow" slot, and the "overflow" must take place\n
5997  * before the pack is reordered, but (optionally) after the pack is\n
5998  * combined.  This may be tricky.  See "dungeon.c" for info.\n
5999  *\n
6000  * Note that this code must remove any location/stack information\n
6001  * from the object once it is placed into the inventory.\n
6002  */
6003 s16b inven_carry(object_type *o_ptr)
6004 {
6005         INVENTORY_IDX i, j, k;
6006         INVENTORY_IDX n = -1;
6007
6008         object_type *j_ptr;
6009
6010
6011         /* Check for combining */
6012         for (j = 0; j < INVEN_PACK; j++)
6013         {
6014                 j_ptr = &inventory[j];
6015
6016                 /* Skip non-objects */
6017                 if (!j_ptr->k_idx) continue;
6018
6019                 /* Hack -- track last item */
6020                 n = j;
6021
6022                 /* Check if the two items can be combined */
6023                 if (object_similar(j_ptr, o_ptr))
6024                 {
6025                         /* Combine the items */
6026                         object_absorb(j_ptr, o_ptr);
6027
6028                         /* Increase the weight */
6029                         p_ptr->total_weight += (o_ptr->number * o_ptr->weight);
6030
6031                         /* Recalculate bonuses */
6032                         p_ptr->update |= (PU_BONUS);
6033
6034                         p_ptr->window |= (PW_INVEN);
6035
6036                         /* Success */
6037                         return (j);
6038                 }
6039         }
6040
6041
6042         /* Paranoia */
6043         if (inven_cnt > INVEN_PACK) return (-1);
6044
6045         /* Find an empty slot */
6046         for (j = 0; j <= INVEN_PACK; j++)
6047         {
6048                 j_ptr = &inventory[j];
6049
6050                 /* Use it if found */
6051                 if (!j_ptr->k_idx) break;
6052         }
6053
6054         /* Use that slot */
6055         i = j;
6056
6057
6058         /* Reorder the pack */
6059         if (i < INVEN_PACK)
6060         {
6061                 /* Get the "value" of the item */
6062                 s32b o_value = object_value(o_ptr);
6063
6064                 /* Scan every occupied slot */
6065                 for (j = 0; j < INVEN_PACK; j++)
6066                 {
6067                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
6068                 }
6069
6070                 /* Use that slot */
6071                 i = j;
6072
6073                 /* Slide objects */
6074                 for (k = n; k >= i; k--)
6075                 {
6076                         /* Hack -- Slide the item */
6077                         object_copy(&inventory[k+1], &inventory[k]);
6078                 }
6079
6080                 /* Wipe the empty slot */
6081                 object_wipe(&inventory[i]);
6082         }
6083
6084
6085         /* Copy the item */
6086         object_copy(&inventory[i], o_ptr);
6087
6088         /* Access new object */
6089         j_ptr = &inventory[i];
6090
6091         /* Forget stack */
6092         j_ptr->next_o_idx = 0;
6093
6094         /* Forget monster */
6095         j_ptr->held_m_idx = 0;
6096
6097         /* Forget location */
6098         j_ptr->iy = j_ptr->ix = 0;
6099
6100         /* Player touches it, and no longer marked */
6101         j_ptr->marked = OM_TOUCHED;
6102
6103         /* Increase the weight */
6104         p_ptr->total_weight += (j_ptr->number * j_ptr->weight);
6105
6106         /* Count the items */
6107         inven_cnt++;
6108
6109         /* Recalculate bonuses */
6110         p_ptr->update |= (PU_BONUS);
6111
6112         /* Combine and Reorder pack */
6113         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
6114
6115         p_ptr->window |= (PW_INVEN);
6116
6117         /* Return the slot */
6118         return (i);
6119 }
6120
6121
6122 /*!
6123  * @brief 装備スロットからオブジェクトを外すメインルーチン /
6124  * Take off (some of) a non-cursed equipment item
6125  * @param item オブジェクトを外したい所持テーブルのID
6126  * @param amt 外したい個数
6127  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
6128  * @details
6129  * Note that only one item at a time can be wielded per slot.\n
6130  * Note that taking off an item when "full" may cause that item\n
6131  * to fall to the ground.\n
6132  * Return the inventory slot into which the item is placed.\n
6133  */
6134 INVENTORY_IDX inven_takeoff(INVENTORY_IDX item, ITEM_NUMBER amt)
6135 {
6136         INVENTORY_IDX slot;
6137
6138         object_type forge;
6139         object_type *q_ptr;
6140
6141         object_type *o_ptr;
6142
6143         cptr act;
6144
6145         char o_name[MAX_NLEN];
6146
6147
6148         /* Get the item to take off */
6149         o_ptr = &inventory[item];
6150
6151         /* Paranoia */
6152         if (amt <= 0) return (-1);
6153
6154         /* Verify */
6155         if (amt > o_ptr->number) amt = o_ptr->number;
6156         q_ptr = &forge;
6157
6158         /* Obtain a local object */
6159         object_copy(q_ptr, o_ptr);
6160
6161         /* Modify quantity */
6162         q_ptr->number = amt;
6163
6164         object_desc(o_name, q_ptr, 0);
6165
6166         /* Took off weapon */
6167         if (((item == INVEN_RARM) || (item == INVEN_LARM)) &&
6168             object_is_melee_weapon(o_ptr))
6169         {
6170                 act = _("を装備からはずした", "You were wielding");
6171         }
6172
6173         /* Took off bow */
6174         else if (item == INVEN_BOW)
6175         {
6176                 act = _("を装備からはずした", "You were holding");
6177         }
6178
6179         /* Took off light */
6180         else if (item == INVEN_LITE)
6181         {
6182                 act = _("を光源からはずした", "You were holding");
6183         }
6184
6185         /* Took off something */
6186         else
6187         {
6188                 act = _("を装備からはずした", "You were wearing");
6189         }
6190
6191         /* Modify, Optimize */
6192         inven_item_increase(item, -amt);
6193         inven_item_optimize(item);
6194
6195         /* Carry the object */
6196         slot = inven_carry(q_ptr);
6197
6198 #ifdef JP
6199         msg_format("%s(%c)%s。", o_name, index_to_label(slot), act);
6200 #else
6201         msg_format("%s %s (%c).", act, o_name, index_to_label(slot));
6202 #endif
6203
6204
6205         /* Return slot */
6206         return (slot);
6207 }
6208
6209
6210 /*!
6211  * @brief 所持スロットから床下にオブジェクトを落とすメインルーチン /
6212  * Drop (some of) a non-cursed inventory/equipment item
6213  * @param item 所持テーブルのID
6214  * @param amt 落としたい個数
6215  * @return なし
6216  * @details
6217  * The object will be dropped "near" the current location
6218  */
6219 void inven_drop(INVENTORY_IDX item, ITEM_NUMBER amt)
6220 {
6221         object_type forge;
6222         object_type *q_ptr;
6223         object_type *o_ptr;
6224
6225         char o_name[MAX_NLEN];
6226
6227
6228         /* Access original object */
6229         o_ptr = &inventory[item];
6230
6231         /* Error check */
6232         if (amt <= 0) return;
6233
6234         /* Not too many */
6235         if (amt > o_ptr->number) amt = o_ptr->number;
6236
6237
6238         /* Take off equipment */
6239         if (item >= INVEN_RARM)
6240         {
6241                 /* Take off first */
6242                 item = inven_takeoff(item, amt);
6243
6244                 /* Access original object */
6245                 o_ptr = &inventory[item];
6246         }
6247
6248         q_ptr = &forge;
6249
6250         /* Obtain local object */
6251         object_copy(q_ptr, o_ptr);
6252
6253         /* Distribute charges of wands or rods */
6254         distribute_charges(o_ptr, q_ptr, amt);
6255
6256         /* Modify quantity */
6257         q_ptr->number = amt;
6258
6259         /* Describe local object */
6260         object_desc(o_name, q_ptr, 0);
6261
6262         msg_format(_("%s(%c)を落とした。", "You drop %s (%c)."), o_name, index_to_label(item));
6263
6264         /* Drop it near the player */
6265         (void)drop_near(q_ptr, 0, p_ptr->y, p_ptr->x);
6266
6267         /* Modify, Describe, Optimize */
6268         inven_item_increase(item, -amt);
6269         inven_item_describe(item);
6270         inven_item_optimize(item);
6271 }
6272
6273
6274 /*!
6275  * @brief プレイヤーの所持スロットに存在するオブジェクトをまとめなおす /
6276  * Combine items in the pack
6277  * @return なし
6278  * @details
6279  * Note special handling of the "overflow" slot
6280  */
6281 void combine_pack(void)
6282 {
6283         int             i, j, k;
6284         object_type     *o_ptr;
6285         object_type     *j_ptr;
6286         bool            flag = FALSE, combined;
6287
6288         do
6289         {
6290                 combined = FALSE;
6291
6292                 /* Combine the pack (backwards) */
6293                 for (i = INVEN_PACK; i > 0; i--)
6294                 {
6295                         o_ptr = &inventory[i];
6296
6297                         /* Skip empty items */
6298                         if (!o_ptr->k_idx) continue;
6299
6300                         /* Scan the items above that item */
6301                         for (j = 0; j < i; j++)
6302                         {
6303                                 int max_num;
6304
6305                                 j_ptr = &inventory[j];
6306
6307                                 /* Skip empty items */
6308                                 if (!j_ptr->k_idx) continue;
6309
6310                                 /*
6311                                  * Get maximum number of the stack if these
6312                                  * are similar, get zero otherwise.
6313                                  */
6314                                 max_num = object_similar_part(j_ptr, o_ptr);
6315
6316                                 /* Can we (partialy) drop "o_ptr" onto "j_ptr"? */
6317                                 if (max_num && j_ptr->number < max_num)
6318                                 {
6319                                         if (o_ptr->number + j_ptr->number <= max_num)
6320                                         {
6321                                                 /* Take note */
6322                                                 flag = TRUE;
6323
6324                                                 /* Add together the item counts */
6325                                                 object_absorb(j_ptr, o_ptr);
6326
6327                                                 /* One object is gone */
6328                                                 inven_cnt--;
6329
6330                                                 /* Slide everything down */
6331                                                 for (k = i; k < INVEN_PACK; k++)
6332                                                 {
6333                                                         /* Structure copy */
6334                                                         inventory[k] = inventory[k+1];
6335                                                 }
6336
6337                                                 /* Erase the "final" slot */
6338                                                 object_wipe(&inventory[k]);
6339                                         }
6340                                         else
6341                                         {
6342                                                 int old_num = o_ptr->number;
6343                                                 int remain = j_ptr->number + o_ptr->number - max_num;
6344 #if 0
6345                                                 o_ptr->number -= remain;
6346 #endif
6347                                                 /* Add together the item counts */
6348                                                 object_absorb(j_ptr, o_ptr);
6349
6350                                                 o_ptr->number = remain;
6351
6352                                                 /* Hack -- if rods are stacking, add the pvals (maximum timeouts) and current timeouts together. -LM- */
6353                                                 if (o_ptr->tval == TV_ROD)
6354                                                 {
6355                                                         o_ptr->pval =  o_ptr->pval * remain / old_num;
6356                                                         o_ptr->timeout = o_ptr->timeout * remain / old_num;
6357                                                 }
6358
6359                                                 /* Hack -- if wands are stacking, combine the charges. -LM- */
6360                                                 if (o_ptr->tval == TV_WAND)
6361                                                 {
6362                                                         o_ptr->pval = o_ptr->pval * remain / old_num;
6363                                                 }
6364                                         }
6365
6366                                         p_ptr->window |= (PW_INVEN);
6367
6368                                         /* Take note */
6369                                         combined = TRUE;
6370
6371                                         break;
6372                                 }
6373                         }
6374                 }
6375         }
6376         while (combined);
6377
6378         if (flag) msg_print(_("ザックの中のアイテムをまとめ直した。", "You combine some items in your pack."));
6379 }
6380
6381 /*!
6382  * @brief プレイヤーの所持スロットに存在するオブジェクトを並び替える /
6383  * Reorder items in the pack
6384  * @return なし
6385  * @details
6386  * Note special handling of the "overflow" slot
6387  */
6388 void reorder_pack(void)
6389 {
6390         int             i, j, k;
6391         s32b            o_value;
6392         object_type     forge;
6393         object_type     *q_ptr;
6394         object_type     *o_ptr;
6395         bool            flag = FALSE;
6396
6397
6398         /* Re-order the pack (forwards) */
6399         for (i = 0; i < INVEN_PACK; i++)
6400         {
6401                 /* Mega-Hack -- allow "proper" over-flow */
6402                 if ((i == INVEN_PACK) && (inven_cnt == INVEN_PACK)) break;
6403
6404                 o_ptr = &inventory[i];
6405
6406                 /* Skip empty slots */
6407                 if (!o_ptr->k_idx) continue;
6408
6409                 /* Get the "value" of the item */
6410                 o_value = object_value(o_ptr);
6411
6412                 /* Scan every occupied slot */
6413                 for (j = 0; j < INVEN_PACK; j++)
6414                 {
6415                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
6416                 }
6417
6418                 /* Never move down */
6419                 if (j >= i) continue;
6420
6421                 /* Take note */
6422                 flag = TRUE;
6423                 q_ptr = &forge;
6424
6425                 /* Save a copy of the moving item */
6426                 object_copy(q_ptr, &inventory[i]);
6427
6428                 /* Slide the objects */
6429                 for (k = i; k > j; k--)
6430                 {
6431                         /* Slide the item */
6432                         object_copy(&inventory[k], &inventory[k-1]);
6433                 }
6434
6435                 /* Insert the moving item */
6436                 object_copy(&inventory[j], q_ptr);
6437
6438                 p_ptr->window |= (PW_INVEN);
6439         }
6440
6441         if (flag) msg_print(_("ザックの中のアイテムを並べ直した。", "You reorder some items in your pack."));
6442 }
6443
6444 /*!
6445  * @brief 現在アクティブになっているウィンドウにオブジェクトの詳細を表示する /
6446  * Hack -- display an object kind in the current window
6447  * @param k_idx ベースアイテムの参照ID
6448  * @return なし
6449  * @details
6450  * Include list of usable spells for readible books
6451  */
6452 void display_koff(KIND_OBJECT_IDX k_idx)
6453 {
6454         int y;
6455
6456         object_type forge;
6457         object_type *q_ptr;
6458         int         sval;
6459         REALM_IDX   use_realm;
6460
6461         char o_name[MAX_NLEN];
6462
6463
6464         /* Erase the window */
6465         for (y = 0; y < Term->hgt; y++)
6466         {
6467                 /* Erase the line */
6468                 Term_erase(0, y, 255);
6469         }
6470
6471         /* No info */
6472         if (!k_idx) return;
6473         q_ptr = &forge;
6474
6475         /* Prepare the object */
6476         object_prep(q_ptr, k_idx);
6477         object_desc(o_name, q_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY | OD_STORE));
6478
6479         /* Mention the object name */
6480         Term_putstr(0, 0, -1, TERM_WHITE, o_name);
6481
6482         /* Access the item's sval */
6483         sval = q_ptr->sval;
6484         use_realm = tval2realm(q_ptr->tval);
6485
6486         /* Warriors are illiterate */
6487         if (p_ptr->realm1 || p_ptr->realm2)
6488         {
6489                 if ((use_realm != p_ptr->realm1) && (use_realm != p_ptr->realm2)) return;
6490         }
6491         else
6492         {
6493                 if ((p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE)) return;
6494                 if (!is_magic(use_realm)) return;
6495                 if ((p_ptr->pclass == CLASS_RED_MAGE) && (use_realm != REALM_ARCANE) && (sval > 1)) return;
6496         }
6497
6498         /* Display spells in readible books */
6499         {
6500                 int     spell = -1;
6501                 int     num = 0;
6502                 SPELL_IDX    spells[64];
6503
6504                 /* Extract spells */
6505                 for (spell = 0; spell < 32; spell++)
6506                 {
6507                         /* Check for this spell */
6508                         if (fake_spell_flags[sval] & (1L << spell))
6509                         {
6510                                 /* Collect this spell */
6511                                 spells[num++] = spell;
6512                         }
6513                 }
6514
6515                 /* Print spells */
6516                 print_spells(0, spells, num, 2, 0, use_realm);
6517         }
6518 }
6519
6520 /*!
6521  * @brief 警告を放つアイテムを選択する /
6522  * Choose one of items that have warning flag
6523  * Calculate spell damages
6524  * @return 警告を行う
6525  */
6526 object_type *choose_warning_item(void)
6527 {
6528         int i;
6529         int choices[INVEN_TOTAL - INVEN_RARM];
6530         int number = 0;
6531
6532         /* Paranoia -- Player has no warning ability */
6533         if (!p_ptr->warning) return NULL;
6534
6535         /* Search Inventory */
6536         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
6537         {
6538                 BIT_FLAGS flgs[TR_FLAG_SIZE];
6539                 object_type *o_ptr = &inventory[i];
6540
6541                 object_flags(o_ptr, flgs);
6542                 if (have_flag(flgs, TR_WARNING))
6543                 {
6544                         choices[number] = i;
6545                         number++;
6546                 }
6547         }
6548
6549         /* Choice one of them */
6550         return number ? &inventory[choices[randint0(number)]] : NULL;
6551 }
6552
6553 /*!
6554  * @brief 警告基準を定めるために魔法の効果属性に基づいて最大魔法ダメージを計算する /
6555  * Calculate spell damages
6556  * @param m_ptr 魔法を行使するモンスターの構造体参照ポインタ
6557  * @param typ 効果属性のID
6558  * @param dam 基本ダメージ
6559  * @param max 算出した最大ダメージを返すポインタ
6560  * @return なし
6561  */
6562 static void spell_damcalc(monster_type *m_ptr, EFFECT_ID typ, HIT_POINT dam, int *max)
6563 {
6564         monster_race *r_ptr = &r_info[m_ptr->r_idx];
6565         int          rlev = r_ptr->level;
6566         bool         ignore_wraith_form = FALSE;
6567
6568         /* Vulnerability, resistance and immunity */
6569         switch (typ)
6570         {
6571         case GF_ELEC:
6572                 if (p_ptr->immune_elec)
6573                 {
6574                         dam = 0;
6575                         ignore_wraith_form = TRUE;
6576                 }
6577                 else
6578                 {
6579                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6580                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6581                         if (prace_is_(RACE_ANDROID)) dam += dam / 3;
6582                         if (p_ptr->resist_elec) dam = (dam + 2) / 3;
6583                         if (IS_OPPOSE_ELEC())
6584                                 dam = (dam + 2) / 3;
6585                 }
6586                 break;
6587
6588         case GF_POIS:
6589                 if (p_ptr->resist_pois) dam = (dam + 2) / 3;
6590                 if (IS_OPPOSE_POIS()) dam = (dam + 2) / 3;
6591                 break;
6592
6593         case GF_ACID:
6594                 if (p_ptr->immune_acid)
6595                 {
6596                         dam = 0;
6597                         ignore_wraith_form = TRUE;
6598                 }
6599                 else
6600                 {
6601                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6602                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6603                         if (p_ptr->resist_acid) dam = (dam + 2) / 3;
6604                         if (IS_OPPOSE_ACID()) dam = (dam + 2) / 3;
6605                 }
6606                 break;
6607
6608         case GF_COLD:
6609         case GF_ICE:
6610                 if (p_ptr->immune_cold)
6611                 {
6612                         dam = 0;
6613                         ignore_wraith_form = TRUE;
6614                 }
6615                 else
6616                 {
6617                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6618                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6619                         if (p_ptr->resist_cold) dam = (dam + 2) / 3;
6620                         if (IS_OPPOSE_COLD()) dam = (dam + 2) / 3;
6621                 }
6622                 break;
6623
6624         case GF_FIRE:
6625                 if (p_ptr->immune_fire)
6626                 {
6627                         dam = 0;
6628                         ignore_wraith_form = TRUE;
6629                 }
6630                 else
6631                 {
6632                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6633                         if (prace_is_(RACE_ENT)) dam += dam / 3;
6634                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6635                         if (p_ptr->resist_fire) dam = (dam + 2) / 3;
6636                         if (IS_OPPOSE_FIRE()) dam = (dam + 2) / 3;
6637                 }
6638                 break;
6639
6640         case GF_PSY_SPEAR:
6641                 ignore_wraith_form = TRUE;
6642                 break;
6643
6644         case GF_ARROW:
6645                 if (!p_ptr->blind &&
6646                     ((inventory[INVEN_RARM].k_idx && (inventory[INVEN_RARM].name1 == ART_ZANTETSU)) ||
6647                      (inventory[INVEN_LARM].k_idx && (inventory[INVEN_LARM].name1 == ART_ZANTETSU))))
6648                 {
6649                         dam = 0;
6650                         ignore_wraith_form = TRUE;
6651                 }
6652                 break;
6653
6654         case GF_LITE:
6655                 if (p_ptr->resist_lite) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6656                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE)) dam *= 2;
6657                 else if (prace_is_(RACE_S_FAIRY)) dam = dam * 4 / 3;
6658
6659                 /*
6660                  * Cannot use "ignore_wraith_form" strictly (for "random one damage")
6661                  * "dam *= 2;" for later "dam /= 2"
6662                  */
6663                 if (p_ptr->wraith_form) dam *= 2;
6664                 break;
6665
6666         case GF_DARK:
6667                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE) || p_ptr->wraith_form)
6668                 {
6669                         dam = 0;
6670                         ignore_wraith_form = TRUE;
6671                 }
6672                 else if (p_ptr->resist_dark) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6673                 break;
6674
6675         case GF_SHARDS:
6676                 if (p_ptr->resist_shard) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6677                 break;
6678
6679         case GF_SOUND:
6680                 if (p_ptr->resist_sound) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6681                 break;
6682
6683         case GF_CONFUSION:
6684                 if (p_ptr->resist_conf) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6685                 break;
6686
6687         case GF_CHAOS:
6688                 if (p_ptr->resist_chaos) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6689                 break;
6690
6691         case GF_NETHER:
6692                 if (prace_is_(RACE_SPECTRE))
6693                 {
6694                         dam = 0;
6695                         ignore_wraith_form = TRUE;
6696                 }
6697                 else if (p_ptr->resist_neth) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6698                 break;
6699
6700         case GF_DISENCHANT:
6701                 if (p_ptr->resist_disen) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6702                 break;
6703
6704         case GF_NEXUS:
6705                 if (p_ptr->resist_nexus) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6706                 break;
6707
6708         case GF_TIME:
6709                 if (p_ptr->resist_time) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6710                 break;
6711
6712         case GF_GRAVITY:
6713                 if (p_ptr->levitation) dam = (dam * 2) / 3;
6714                 break;
6715
6716         case GF_ROCKET:
6717                 if (p_ptr->resist_shard) dam /= 2;
6718                 break;
6719
6720         case GF_NUKE:
6721                 if (p_ptr->resist_pois) dam = (2 * dam + 2) / 5;
6722                 if (IS_OPPOSE_POIS()) dam = (2 * dam + 2) / 5;
6723                 break;
6724
6725         case GF_DEATH_RAY:
6726                 if (p_ptr->mimic_form)
6727                 {
6728                         if (mimic_info[p_ptr->mimic_form].MIMIC_FLAGS & MIMIC_IS_NONLIVING)
6729                         {
6730                                 dam = 0;
6731                                 ignore_wraith_form = TRUE;
6732                         }
6733                 }
6734                 else
6735                 {
6736                         switch (p_ptr->prace)
6737                         {
6738                         case RACE_GOLEM:
6739                         case RACE_SKELETON:
6740                         case RACE_ZOMBIE:
6741                         case RACE_VAMPIRE:
6742                         case RACE_DEMON:
6743                         case RACE_SPECTRE:
6744                                 dam = 0;
6745                                 ignore_wraith_form = TRUE;
6746                                 break;
6747                         }
6748                 }
6749                 break;
6750
6751         case GF_HOLY_FIRE:
6752                 if (p_ptr->align > 10) dam /= 2;
6753                 else if (p_ptr->align < -10) dam *= 2;
6754                 break;
6755
6756         case GF_HELL_FIRE:
6757                 if (p_ptr->align > 10) dam *= 2;
6758                 break;
6759
6760         case GF_MIND_BLAST:
6761         case GF_BRAIN_SMASH:
6762                 if (100 + rlev / 2 <= MAX(5, p_ptr->skill_sav))
6763                 {
6764                         dam = 0;
6765                         ignore_wraith_form = TRUE;
6766                 }
6767                 break;
6768
6769         case GF_CAUSE_1:
6770         case GF_CAUSE_2:
6771         case GF_CAUSE_3:
6772         case GF_HAND_DOOM:
6773                 if (100 + rlev / 2 <= p_ptr->skill_sav)
6774                 {
6775                         dam = 0;
6776                         ignore_wraith_form = TRUE;
6777                 }
6778                 break;
6779
6780         case GF_CAUSE_4:
6781                 if ((100 + rlev / 2 <= p_ptr->skill_sav) && (m_ptr->r_idx != MON_KENSHIROU))
6782                 {
6783                         dam = 0;
6784                         ignore_wraith_form = TRUE;
6785                 }
6786                 break;
6787         }
6788
6789         if (p_ptr->wraith_form && !ignore_wraith_form)
6790         {
6791                 dam /= 2;
6792                 if (!dam) dam = 1;
6793         }
6794
6795         if (dam > *max) *max = dam;
6796 }
6797
6798 /*!
6799 * @brief 警告基準を定めるために魔法の効果属性に基づいて最大魔法ダメージを計算する。 /
6800 * Calculate spell damages
6801 * @param spell_num RF4ならRF4_SPELL_STARTのように32区切りのベースとなる数値
6802 * @param typ 効果属性のID
6803 * @param m_idx 魔法を行使するモンスターのID
6804 * @param max 算出した最大ダメージを返すポインタ
6805 * @return なし
6806 */
6807 void spell_damcalc_by_spellnum(int spell_num, EFFECT_ID typ, MONSTER_IDX m_idx, int *max)
6808 {
6809     monster_type *m_ptr = &m_list[m_idx];
6810     HIT_POINT dam = monspell_damage((spell_num), m_idx, DAM_MAX);
6811     spell_damcalc(m_ptr, typ, dam, max);
6812 }
6813
6814 /*!
6815  * @brief 警告基準を定めるためにモンスターの打撃最大ダメージを算出する /
6816  * Calculate blow damages
6817  * @param m_ptr 打撃を行使するモンスターの構造体参照ポインタ
6818  * @param blow_ptr モンスターの打撃能力の構造体参照ポインタ
6819  * @return 算出された最大ダメージを返す。
6820  */
6821 static int blow_damcalc(monster_type *m_ptr, monster_blow *blow_ptr)
6822 {
6823         int  dam = blow_ptr->d_dice * blow_ptr->d_side;
6824         int  dummy_max = 0;
6825         bool check_wraith_form = TRUE;
6826
6827         if (blow_ptr->method != RBM_EXPLODE)
6828         {
6829                 ARMOUR_CLASS ac = p_ptr->ac + p_ptr->to_a;
6830
6831                 switch (blow_ptr->effect)
6832                 {
6833                 case RBE_SUPERHURT:
6834                 {
6835                         int tmp_dam = dam - (dam * ((ac < 150) ? ac : 150) / 250);
6836                         dam = MAX(dam, tmp_dam * 2);
6837                         break;
6838                 }
6839
6840                 case RBE_HURT:
6841                 case RBE_SHATTER:
6842                         dam -= (dam * ((ac < 150) ? ac : 150) / 250);
6843                         break;
6844
6845                 case RBE_ACID:
6846                         spell_damcalc(m_ptr, GF_ACID, dam, &dummy_max);
6847                         dam = dummy_max;
6848                         check_wraith_form = FALSE;
6849                         break;
6850
6851                 case RBE_ELEC:
6852                         spell_damcalc(m_ptr, GF_ELEC, dam, &dummy_max);
6853                         dam = dummy_max;
6854                         check_wraith_form = FALSE;
6855                         break;
6856
6857                 case RBE_FIRE:
6858                         spell_damcalc(m_ptr, GF_FIRE, dam, &dummy_max);
6859                         dam = dummy_max;
6860                         check_wraith_form = FALSE;
6861                         break;
6862
6863                 case RBE_COLD:
6864                         spell_damcalc(m_ptr, GF_COLD, dam, &dummy_max);
6865                         dam = dummy_max;
6866                         check_wraith_form = FALSE;
6867                         break;
6868
6869                 case RBE_DR_MANA:
6870                         dam = 0;
6871                         check_wraith_form = FALSE;
6872                         break;
6873                 }
6874
6875                 if (check_wraith_form && p_ptr->wraith_form)
6876                 {
6877                         dam /= 2;
6878                         if (!dam) dam = 1;
6879                 }
6880         }
6881         else
6882         {
6883                 dam = (dam + 1) / 2;
6884                 spell_damcalc(m_ptr, mbe_info[blow_ptr->effect].explode_type, dam, &dummy_max);
6885                 dam = dummy_max;
6886         }
6887
6888         return dam;
6889 }
6890
6891 /*!
6892  * @brief プレイヤーが特定地点へ移動した場合に警告を発する処理 /
6893  * Examine the grid (xx,yy) and warn the player if there are any danger
6894  * @param xx 危険性を調査するマスのX座標
6895  * @param yy 危険性を調査するマスのY座標
6896  * @return 警告を無視して進むことを選択するかか問題が無ければTRUE、警告に従ったならFALSEを返す。
6897  */
6898 bool process_warning(POSITION xx, POSITION yy)
6899 {
6900         POSITION mx, my;
6901         cave_type *c_ptr;
6902         char o_name[MAX_NLEN];
6903
6904 #define WARNING_AWARE_RANGE 12
6905         int dam_max = 0;
6906         static int old_damage = 0;
6907
6908         for (mx = xx - WARNING_AWARE_RANGE; mx < xx + WARNING_AWARE_RANGE + 1; mx++)
6909         {
6910                 for (my = yy - WARNING_AWARE_RANGE; my < yy + WARNING_AWARE_RANGE + 1; my++)
6911                 {
6912                         int dam_max0 = 0;
6913                         monster_type *m_ptr;
6914                         monster_race *r_ptr;
6915
6916                         if (!in_bounds(my, mx) || (distance(my, mx, yy, xx) > WARNING_AWARE_RANGE)) continue;
6917
6918                         c_ptr = &cave[my][mx];
6919
6920                         if (!c_ptr->m_idx) continue;
6921
6922                         m_ptr = &m_list[c_ptr->m_idx];
6923
6924                         if (MON_CSLEEP(m_ptr)) continue;
6925                         if (!is_hostile(m_ptr)) continue;
6926
6927                         r_ptr = &r_info[m_ptr->r_idx];
6928
6929                         /* Monster spells (only powerful ones)*/
6930                         if (projectable(my, mx, yy, xx))
6931             {
6932                                 BIT_FLAGS f4 = r_ptr->flags4;
6933                                 BIT_FLAGS f5 = r_ptr->a_ability_flags1;
6934                                 BIT_FLAGS f6 = r_ptr->a_ability_flags2;
6935
6936                                 if (!(d_info[dungeon_type].flags1 & DF1_NO_MAGIC))
6937                                 {
6938                                         if (f4 & RF4_BA_CHAO) spell_damcalc_by_spellnum(MS_BALL_CHAOS, GF_CHAOS, c_ptr->m_idx, &dam_max0);
6939                                         if (f5 & RF5_BA_MANA) spell_damcalc_by_spellnum(MS_BALL_MANA, GF_MANA, c_ptr->m_idx, &dam_max0);
6940                                         if (f5 & RF5_BA_DARK) spell_damcalc_by_spellnum(MS_BALL_DARK, GF_DARK, c_ptr->m_idx, &dam_max0);
6941                                         if (f5 & RF5_BA_LITE) spell_damcalc_by_spellnum(MS_STARBURST, GF_LITE, c_ptr->m_idx, &dam_max0);
6942                                         if (f6 & RF6_HAND_DOOM) spell_damcalc_by_spellnum(MS_HAND_DOOM, GF_HAND_DOOM, c_ptr->m_idx, &dam_max0);
6943                                         if (f6 & RF6_PSY_SPEAR) spell_damcalc_by_spellnum(MS_PSY_SPEAR, GF_PSY_SPEAR, c_ptr->m_idx, &dam_max0);
6944                                 }
6945                                 if (f4 & RF4_ROCKET) spell_damcalc_by_spellnum(MS_ROCKET, GF_ROCKET, c_ptr->m_idx, &dam_max0);
6946                                 if (f4 & RF4_BR_ACID) spell_damcalc_by_spellnum(MS_BR_ACID, GF_ACID, c_ptr->m_idx, &dam_max0);
6947                                 if (f4 & RF4_BR_ELEC) spell_damcalc_by_spellnum(MS_BR_ELEC, GF_ELEC, c_ptr->m_idx, &dam_max0);
6948                                 if (f4 & RF4_BR_FIRE) spell_damcalc_by_spellnum(MS_BR_FIRE, GF_FIRE, c_ptr->m_idx, &dam_max0);
6949                                 if (f4 & RF4_BR_COLD) spell_damcalc_by_spellnum(MS_BR_COLD, GF_COLD, c_ptr->m_idx, &dam_max0);
6950                                 if (f4 & RF4_BR_POIS) spell_damcalc_by_spellnum(MS_BR_POIS, GF_POIS, c_ptr->m_idx, &dam_max0);
6951                                 if (f4 & RF4_BR_NETH) spell_damcalc_by_spellnum(MS_BR_NETHER, GF_NETHER, c_ptr->m_idx, &dam_max0);
6952                                 if (f4 & RF4_BR_LITE) spell_damcalc_by_spellnum(MS_BR_LITE, GF_LITE, c_ptr->m_idx, &dam_max0);
6953                                 if (f4 & RF4_BR_DARK) spell_damcalc_by_spellnum(MS_BR_DARK, GF_DARK, c_ptr->m_idx, &dam_max0);
6954                                 if (f4 & RF4_BR_CONF) spell_damcalc_by_spellnum(MS_BR_CONF, GF_CONFUSION, c_ptr->m_idx, &dam_max0);
6955                                 if (f4 & RF4_BR_SOUN) spell_damcalc_by_spellnum(MS_BR_SOUND, GF_SOUND, c_ptr->m_idx, &dam_max0);
6956                                 if (f4 & RF4_BR_CHAO) spell_damcalc_by_spellnum(MS_BR_CHAOS, GF_CHAOS, c_ptr->m_idx, &dam_max0);
6957                                 if (f4 & RF4_BR_DISE) spell_damcalc_by_spellnum(MS_BR_DISEN, GF_DISENCHANT, c_ptr->m_idx, &dam_max0);
6958                                 if (f4 & RF4_BR_NEXU) spell_damcalc_by_spellnum(MS_BR_NEXUS, GF_NEXUS, c_ptr->m_idx, &dam_max0);
6959                                 if (f4 & RF4_BR_TIME) spell_damcalc_by_spellnum(MS_BR_TIME, GF_TIME, c_ptr->m_idx, &dam_max0);
6960                                 if (f4 & RF4_BR_INER) spell_damcalc_by_spellnum(MS_BR_INERTIA, GF_INERTIAL, c_ptr->m_idx, &dam_max0);
6961                                 if (f4 & RF4_BR_GRAV) spell_damcalc_by_spellnum(MS_BR_GRAVITY, GF_GRAVITY, c_ptr->m_idx, &dam_max0);
6962                                 if (f4 & RF4_BR_SHAR) spell_damcalc_by_spellnum(MS_BR_SHARDS, GF_SHARDS, c_ptr->m_idx, &dam_max0);
6963                                 if (f4 & RF4_BR_PLAS) spell_damcalc_by_spellnum(MS_BR_PLASMA, GF_PLASMA, c_ptr->m_idx, &dam_max0);
6964                                 if (f4 & RF4_BR_WALL) spell_damcalc_by_spellnum(MS_BR_FORCE, GF_FORCE, c_ptr->m_idx, &dam_max0);
6965                                 if (f4 & RF4_BR_MANA) spell_damcalc_by_spellnum(MS_BR_MANA, GF_MANA, c_ptr->m_idx, &dam_max0);
6966                                 if (f4 & RF4_BR_NUKE) spell_damcalc_by_spellnum(MS_BR_NUKE, GF_NUKE, c_ptr->m_idx, &dam_max0);
6967                                 if (f4 & RF4_BR_DISI) spell_damcalc_by_spellnum(MS_BR_DISI, GF_DISINTEGRATE, c_ptr->m_idx, &dam_max0);
6968                         }
6969
6970                         /* Monster melee attacks */
6971                         if (!(r_ptr->flags1 & RF1_NEVER_BLOW) && !(d_info[dungeon_type].flags1 & DF1_NO_MELEE))
6972                         {
6973                                 if (mx <= xx + 1 && mx >= xx - 1 && my <= yy + 1 && my >= yy - 1)
6974                                 {
6975                                         int m;
6976                                         int dam_melee = 0;
6977                                         for (m = 0; m < 4; m++)
6978                                         {
6979                                                 /* Skip non-attacks */
6980                                                 if (!r_ptr->blow[m].method || (r_ptr->blow[m].method == RBM_SHOOT)) continue;
6981
6982                                                 /* Extract the attack info */
6983                                                 dam_melee += blow_damcalc(m_ptr, &r_ptr->blow[m]);
6984                                                 if (r_ptr->blow[m].method == RBM_EXPLODE) break;
6985                                         }
6986                                         if (dam_melee > dam_max0) dam_max0 = dam_melee;
6987                                 }
6988                         }
6989
6990                         /* Contribution from this monster */
6991                         dam_max += dam_max0;
6992                 }
6993         }
6994
6995         /* Prevent excessive warning */
6996         if (dam_max > old_damage)
6997         {
6998                 old_damage = dam_max * 3 / 2;
6999
7000                 if (dam_max > p_ptr->chp / 2)
7001                 {
7002                         object_type *o_ptr = choose_warning_item();
7003
7004                         if (o_ptr)
7005                 object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7006             else
7007                 strcpy(o_name, _("体", "body")); /* Warning ability without item */
7008             msg_format(_("%sが鋭く震えた！", "Your %s pulsates sharply!"), o_name);
7009
7010                         disturb(FALSE, TRUE);
7011             return get_check(_("本当にこのまま進むか？", "Really want to go ahead? "));
7012                 }
7013         }
7014         else old_damage = old_damage / 2;
7015
7016         c_ptr = &cave[yy][xx];
7017         if (((!easy_disarm && is_trap(c_ptr->feat))
7018             || (c_ptr->mimic && is_trap(c_ptr->feat))) && !one_in_(13))
7019         {
7020                 object_type *o_ptr = choose_warning_item();
7021
7022                 if (o_ptr)
7023             object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7024         else
7025             strcpy(o_name, _("体", "body")); /* Warning ability without item */
7026         msg_format(_("%sが鋭く震えた！", "Your %s pulsates sharply!"), o_name);
7027                 disturb(FALSE, TRUE);
7028         return get_check(_("本当にこのまま進むか？", "Really want to go ahead? "));
7029         }
7030
7031         return TRUE;
7032 }
7033
7034 /*!
7035  * エッセンス情報の構造体 / A structure for smithing
7036  */
7037 typedef struct {
7038         int add;       /* TR flag number or special essence id */
7039         cptr add_name; /* Name of this ability */
7040         ESSENCE_IDX type;      /* Menu number */
7041         int essence;   /* Index for carrying essences */
7042         int value;     /* Needed value to add this ability */
7043 } essence_type;
7044
7045
7046 /*!
7047  * エッセンス情報テーブル Smithing type data for Weapon smith
7048  */
7049 #ifdef JP
7050 static essence_type essence_info[] =
7051 {
7052         {TR_STR, "腕力", 4, TR_STR, 20},
7053         {TR_INT, "知能", 4, TR_INT, 20},
7054         {TR_WIS, "賢さ", 4, TR_WIS, 20},
7055         {TR_DEX, "器用さ", 4, TR_DEX, 20},
7056         {TR_CON, "耐久力", 4, TR_CON, 20},
7057         {TR_CHR, "魅力", 4, TR_CHR, 20},
7058         {TR_MAGIC_MASTERY, "魔力支配", 4, TR_MAGIC_MASTERY, 20},
7059         {TR_STEALTH, "隠密", 4, TR_STEALTH, 40},
7060         {TR_SEARCH, "探索", 4, TR_SEARCH, 15},
7061         {TR_INFRA, "赤外線視力", 4, TR_INFRA, 15},
7062         {TR_TUNNEL, "採掘", 4, TR_TUNNEL, 15},
7063         {TR_SPEED, "スピード", 4, TR_SPEED, 12},
7064         {TR_BLOWS, "追加攻撃", 1, TR_BLOWS, 20},
7065         {TR_CHAOTIC, "カオス攻撃", 1, TR_CHAOTIC, 15},
7066         {TR_VAMPIRIC, "吸血攻撃", 1, TR_VAMPIRIC, 60},
7067         {TR_IMPACT, "地震発動", 7, TR_IMPACT, 15},
7068         {TR_BRAND_POIS, "毒殺", 1, TR_BRAND_POIS, 20},
7069         {TR_BRAND_ACID, "溶解", 1, TR_BRAND_ACID, 20},
7070         {TR_BRAND_ELEC, "電撃", 1, TR_BRAND_ELEC, 20},
7071         {TR_BRAND_FIRE, "焼棄", 1, TR_BRAND_FIRE, 20},
7072         {TR_BRAND_COLD, "凍結", 1, TR_BRAND_COLD, 20},
7073         {TR_SUST_STR, "腕力維持", 3, TR_SUST_STR, 15},
7074         {TR_SUST_INT, "知能維持", 3, TR_SUST_STR, 15},
7075         {TR_SUST_WIS, "賢さ維持", 3, TR_SUST_STR, 15},
7076         {TR_SUST_DEX, "器用さ維持", 3, TR_SUST_STR, 15},
7077         {TR_SUST_CON, "耐久力維持", 3, TR_SUST_STR, 15},
7078         {TR_SUST_CHR, "魅力維持", 3, TR_SUST_STR, 15},
7079         {TR_IM_ACID, "酸免疫", 2, TR_IM_ACID, 20},
7080         {TR_IM_ELEC, "電撃免疫", 2, TR_IM_ACID, 20},
7081         {TR_IM_FIRE, "火炎免疫", 2, TR_IM_ACID, 20},
7082         {TR_IM_COLD, "冷気免疫", 2, TR_IM_ACID, 20},
7083         {TR_REFLECT, "反射", 2, TR_REFLECT, 20},
7084         {TR_FREE_ACT, "麻痺知らず", 3, TR_FREE_ACT, 20},
7085         {TR_HOLD_EXP, "経験値維持", 3, TR_HOLD_EXP, 20},
7086         {TR_RES_ACID, "耐酸", 2, TR_RES_ACID, 15},
7087         {TR_RES_ELEC, "耐電撃", 2, TR_RES_ELEC, 15},
7088         {TR_RES_FIRE, "耐火炎", 2, TR_RES_FIRE, 15},
7089         {TR_RES_COLD, "耐冷気", 2, TR_RES_COLD, 15},
7090         {TR_RES_POIS, "耐毒", 2, TR_RES_POIS, 25},
7091         {TR_RES_FEAR, "耐恐怖", 2, TR_RES_FEAR, 20},
7092         {TR_RES_LITE, "耐閃光", 2, TR_RES_LITE, 20},
7093         {TR_RES_DARK, "耐暗黒", 2, TR_RES_DARK, 20},
7094         {TR_RES_BLIND, "耐盲目", 2, TR_RES_BLIND, 20},
7095         {TR_RES_CONF, "耐混乱", 2, TR_RES_CONF, 20},
7096         {TR_RES_SOUND, "耐轟音", 2, TR_RES_SOUND, 20},
7097         {TR_RES_SHARDS, "耐破片", 2, TR_RES_SHARDS, 20},
7098         {TR_RES_NETHER, "耐地獄", 2, TR_RES_NETHER, 20},
7099         {TR_RES_NEXUS, "耐因果混乱", 2, TR_RES_NEXUS, 20},
7100         {TR_RES_CHAOS, "耐カオス", 2, TR_RES_CHAOS, 20},
7101         {TR_RES_DISEN, "耐劣化", 2, TR_RES_DISEN, 20},
7102         {TR_SH_FIRE, "", 0, -2, 0},
7103         {TR_SH_ELEC, "", 0, -2, 0},
7104         {TR_SH_COLD, "", 0, -2, 0},
7105         {TR_NO_MAGIC, "反魔法", 3, TR_NO_MAGIC, 15},
7106         {TR_WARNING, "警告", 3, TR_WARNING, 20},
7107         {TR_LEVITATION, "浮遊", 3, TR_LEVITATION, 20},
7108         {TR_LITE_1, "永久光源", 3, TR_LITE_1, 15},
7109         {TR_LITE_2, "", 0, -2, 0},
7110         {TR_LITE_3, "", 0, -2, 0},
7111         {TR_SEE_INVIS, "可視透明", 3, TR_SEE_INVIS, 20},
7112         {TR_TELEPATHY, "テレパシー", 6, TR_TELEPATHY, 15},
7113         {TR_SLOW_DIGEST, "遅消化", 3, TR_SLOW_DIGEST, 15},
7114         {TR_REGEN, "急速回復", 3, TR_REGEN, 20},
7115         {TR_TELEPORT, "テレポート", 3, TR_TELEPORT, 25},
7116
7117         {TR_SLAY_EVIL, "邪悪倍打", 5, TR_SLAY_EVIL, 100},
7118         {TR_KILL_EVIL, "邪悪倍倍打", 0, TR_SLAY_EVIL, 60},
7119         {TR_SLAY_ANIMAL, "動物倍打", 5, TR_SLAY_ANIMAL, 20},
7120         {TR_KILL_ANIMAL, "動物倍倍打", 5, TR_SLAY_ANIMAL, 60},
7121         {TR_SLAY_UNDEAD, "不死倍打", 5, TR_SLAY_UNDEAD, 20},
7122         {TR_KILL_UNDEAD, "不死倍倍打", 5, TR_SLAY_UNDEAD, 60},
7123         {TR_SLAY_DEMON, "悪魔倍打", 5, TR_SLAY_DEMON, 20},
7124         {TR_KILL_DEMON, "悪魔倍倍打", 5, TR_SLAY_DEMON, 60},
7125         {TR_SLAY_ORC, "オーク倍打", 5, TR_SLAY_ORC, 15},
7126         {TR_KILL_ORC, "オーク倍倍打", 5, TR_SLAY_ORC, 60},
7127         {TR_SLAY_TROLL, "トロル倍打", 5, TR_SLAY_TROLL, 15},
7128         {TR_KILL_TROLL, "トロル倍倍打", 5, TR_SLAY_TROLL, 60},
7129         {TR_SLAY_GIANT, "巨人倍打", 5, TR_SLAY_GIANT, 20},
7130         {TR_KILL_GIANT, "巨人倍倍打", 5, TR_SLAY_GIANT, 60},
7131         {TR_SLAY_DRAGON, "竜倍打", 5, TR_SLAY_DRAGON, 20},
7132         {TR_KILL_DRAGON, "竜倍倍打", 5, TR_SLAY_DRAGON, 60},
7133         {TR_SLAY_HUMAN, "人間倍打", 5, TR_SLAY_HUMAN, 20},
7134         {TR_KILL_HUMAN, "人間倍倍打", 5, TR_SLAY_HUMAN, 60},
7135
7136         {TR_ESP_ANIMAL, "動物ESP", 6, TR_SLAY_ANIMAL, 40},
7137         {TR_ESP_UNDEAD, "不死ESP", 6, TR_SLAY_UNDEAD, 40},
7138         {TR_ESP_DEMON, "悪魔ESP", 6, TR_SLAY_DEMON, 40},
7139         {TR_ESP_ORC, "オークESP", 6, TR_SLAY_ORC, 40},
7140         {TR_ESP_TROLL, "トロルESP", 6, TR_SLAY_TROLL, 40},
7141         {TR_ESP_GIANT, "巨人ESP", 6, TR_SLAY_GIANT, 40},
7142         {TR_ESP_DRAGON, "竜ESP", 6, TR_SLAY_DRAGON, 40},
7143         {TR_ESP_HUMAN, "人間ESP", 6, TR_SLAY_HUMAN, 40},
7144
7145         {ESSENCE_ATTACK, "攻撃", 10, TR_ES_ATTACK, 30},
7146         {ESSENCE_AC, "防御", 10, TR_ES_AC, 15},
7147         {ESSENCE_TMP_RES_ACID, "酸耐性発動", 7, TR_RES_ACID, 50},
7148         {ESSENCE_TMP_RES_ELEC, "電撃耐性発動", 7, TR_RES_ELEC, 50},
7149         {ESSENCE_TMP_RES_FIRE, "火炎耐性発動", 7, TR_RES_FIRE, 50},
7150         {ESSENCE_TMP_RES_COLD, "冷気耐性発動", 7, TR_RES_COLD, 50},
7151         {ESSENCE_SH_FIRE, "火炎オーラ", 7, -1, 50},
7152         {ESSENCE_SH_ELEC, "電撃オーラ", 7, -1, 50},
7153         {ESSENCE_SH_COLD, "冷気オーラ", 7, -1, 50},
7154         {ESSENCE_RESISTANCE, "全耐性", 2, -1, 150},
7155         {ESSENCE_SUSTAIN, "装備保持", 10, -1, 10},
7156         {ESSENCE_SLAY_GLOVE, "殺戮の小手", 1, TR_ES_ATTACK, 200},
7157
7158         {-1, NULL, 0, -1, 0}
7159 };
7160 #else
7161 static essence_type essence_info[] =
7162 {
7163         {TR_STR, "strength", 4, TR_STR, 20},
7164         {TR_INT, "intelligence", 4, TR_INT, 20},
7165         {TR_WIS, "wisdom", 4, TR_WIS, 20},
7166         {TR_DEX, "dexterity", 4, TR_DEX, 20},
7167         {TR_CON, "constitution", 4, TR_CON, 20},
7168         {TR_CHR, "charisma", 4, TR_CHR, 20},
7169         {TR_MAGIC_MASTERY, "magic mastery", 4, TR_MAGIC_MASTERY, 20},
7170         {TR_STEALTH, "stealth", 4, TR_STEALTH, 40},
7171         {TR_SEARCH, "serching", 4, TR_SEARCH, 15},
7172         {TR_INFRA, "infravision", 4, TR_INFRA, 15},
7173         {TR_TUNNEL, "digging", 4, TR_TUNNEL, 15},
7174         {TR_SPEED, "speed", 4, TR_SPEED, 12},
7175         {TR_BLOWS, "extra attack", 1, TR_BLOWS, 20},
7176         {TR_CHAOTIC, "chaos brand", 1, TR_CHAOTIC, 15},
7177         {TR_VAMPIRIC, "vampiric brand", 1, TR_VAMPIRIC, 60},
7178         {TR_IMPACT, "quake activation", 7, TR_IMPACT, 15},
7179         {TR_BRAND_POIS, "poison brand", 1, TR_BRAND_POIS, 20},
7180         {TR_BRAND_ACID, "acid brand", 1, TR_BRAND_ACID, 20},
7181         {TR_BRAND_ELEC, "electric brand", 1, TR_BRAND_ELEC, 20},
7182         {TR_BRAND_FIRE, "fire brand", 1, TR_BRAND_FIRE, 20},
7183         {TR_BRAND_COLD, "cold brand", 1, TR_BRAND_COLD, 20},
7184         {TR_SUST_STR, "sustain strength", 3, TR_SUST_STR, 15},
7185         {TR_SUST_INT, "sustain intelligence", 3, TR_SUST_STR, 15},
7186         {TR_SUST_WIS, "sustain wisdom", 3, TR_SUST_STR, 15},
7187         {TR_SUST_DEX, "sustain dexterity", 3, TR_SUST_STR, 15},
7188         {TR_SUST_CON, "sustain constitution", 3, TR_SUST_STR, 15},
7189         {TR_SUST_CHR, "sustain charisma", 3, TR_SUST_STR, 15},
7190         {TR_IM_ACID, "acid immunity", 2, TR_IM_ACID, 20},
7191         {TR_IM_ELEC, "electric immunity", 2, TR_IM_ACID, 20},
7192         {TR_IM_FIRE, "fire immunity", 2, TR_IM_ACID, 20},
7193         {TR_IM_COLD, "cold immunity", 2, TR_IM_ACID, 20},
7194         {TR_REFLECT, "reflection", 2, TR_REFLECT, 20},
7195         {TR_FREE_ACT, "free action", 3, TR_FREE_ACT, 20},
7196         {TR_HOLD_EXP, "hold experience", 3, TR_HOLD_EXP, 20},
7197         {TR_RES_ACID, "resistance to acid", 2, TR_RES_ACID, 15},
7198         {TR_RES_ELEC, "resistance to electric", 2, TR_RES_ELEC, 15},
7199         {TR_RES_FIRE, "resistance to fire", 2, TR_RES_FIRE, 15},
7200         {TR_RES_COLD, "resistance to cold", 2, TR_RES_COLD, 15},
7201         {TR_RES_POIS, "resistance to poison", 2, TR_RES_POIS, 25},
7202         {TR_RES_FEAR, "resistance to fear", 2, TR_RES_FEAR, 20},
7203         {TR_RES_LITE, "resistance to light", 2, TR_RES_LITE, 20},
7204         {TR_RES_DARK, "resistance to dark", 2, TR_RES_DARK, 20},
7205         {TR_RES_BLIND, "resistance to blind", 2, TR_RES_BLIND, 20},
7206         {TR_RES_CONF, "resistance to confusion", 2, TR_RES_CONF, 20},
7207         {TR_RES_SOUND, "resistance to sound", 2, TR_RES_SOUND, 20},
7208         {TR_RES_SHARDS, "resistance to shard", 2, TR_RES_SHARDS, 20},
7209         {TR_RES_NETHER, "resistance to nether", 2, TR_RES_NETHER, 20},
7210         {TR_RES_NEXUS, "resistance to nexus", 2, TR_RES_NEXUS, 20},
7211         {TR_RES_CHAOS, "resistance to chaos", 2, TR_RES_CHAOS, 20},
7212         {TR_RES_DISEN, "resistance to disenchantment", 2, TR_RES_DISEN, 20},
7213         {TR_SH_FIRE, "", 0, -2, 0},
7214         {TR_SH_ELEC, "", 0, -2, 0},
7215         {TR_SH_COLD, "", 0, -2, 0},
7216         {TR_NO_MAGIC, "anti magic", 3, TR_NO_MAGIC, 15},
7217         {TR_WARNING, "warning", 3, TR_WARNING, 20},
7218         {TR_LEVITATION, "levitation", 3, TR_LEVITATION, 20},
7219         {TR_LITE_1, "permanent light", 3, TR_LITE_1, 15},
7220         {TR_LITE_2, "", 0, -2, 0},
7221         {TR_LITE_3, "", 0, -2, 0},
7222         {TR_SEE_INVIS, "see invisible", 3, TR_SEE_INVIS, 20},
7223         {TR_TELEPATHY, "telepathy", 6, TR_TELEPATHY, 15},
7224         {TR_SLOW_DIGEST, "slow digestion", 3, TR_SLOW_DIGEST, 15},
7225         {TR_REGEN, "regeneration", 3, TR_REGEN, 20},
7226         {TR_TELEPORT, "teleport", 3, TR_TELEPORT, 25},
7227
7228         {TR_SLAY_EVIL, "slay evil", 5, TR_SLAY_EVIL, 100},
7229         {TR_SLAY_ANIMAL, "slay animal", 5, TR_SLAY_ANIMAL, 20},
7230         {TR_KILL_ANIMAL, "kill animal", 5, TR_SLAY_ANIMAL, 60},
7231         {TR_KILL_EVIL, "kill evil", 0, TR_SLAY_EVIL, 60},
7232         {TR_SLAY_UNDEAD, "slay undead", 5, TR_SLAY_UNDEAD, 20},
7233         {TR_KILL_UNDEAD, "kill undead", 5, TR_SLAY_UNDEAD, 60},
7234         {TR_SLAY_DEMON, "slay demon", 5, TR_SLAY_DEMON, 20},
7235         {TR_KILL_DEMON, "kill demon", 5, TR_SLAY_DEMON, 60},
7236         {TR_SLAY_ORC, "slay orc", 5, TR_SLAY_ORC, 15},
7237         {TR_KILL_ORC, "kill orc", 5, TR_SLAY_ORC, 60},
7238         {TR_SLAY_TROLL, "slay troll", 5, TR_SLAY_TROLL, 15},
7239         {TR_KILL_TROLL, "kill troll", 5, TR_SLAY_TROLL, 60},
7240         {TR_SLAY_GIANT, "slay giant", 5, TR_SLAY_GIANT, 20},
7241         {TR_KILL_GIANT, "kill giant", 5, TR_SLAY_GIANT, 60},
7242         {TR_SLAY_DRAGON, "slay dragon", 5, TR_SLAY_DRAGON, 20},
7243         {TR_KILL_DRAGON, "kill dragon", 5, TR_SLAY_DRAGON, 60},
7244         {TR_SLAY_HUMAN, "slay human", 5, TR_SLAY_HUMAN, 20},
7245         {TR_KILL_HUMAN, "kill human", 5, TR_SLAY_HUMAN, 60},
7246
7247         {TR_ESP_ANIMAL, "sense animal", 6, TR_SLAY_ANIMAL, 40},
7248         {TR_ESP_UNDEAD, "sense undead", 6, TR_SLAY_UNDEAD, 40},
7249         {TR_ESP_DEMON, "sense demon", 6, TR_SLAY_DEMON, 40},
7250         {TR_ESP_ORC, "sense orc", 6, TR_SLAY_ORC, 40},
7251         {TR_ESP_TROLL, "sense troll", 6, TR_SLAY_TROLL, 40},
7252         {TR_ESP_GIANT, "sense giant", 6, TR_SLAY_GIANT, 40},
7253         {TR_ESP_DRAGON, "sense dragon", 6, TR_SLAY_DRAGON, 40},
7254         {TR_ESP_HUMAN, "sense human", 6, TR_SLAY_HUMAN, 40},
7255
7256         {ESSENCE_ATTACK, "weapon enchant", 10, TR_ES_ATTACK, 30},
7257         {ESSENCE_AC, "armor enchant", 10, TR_ES_AC, 15},
7258         {ESSENCE_TMP_RES_ACID, "resist acid activation", 7, TR_RES_ACID, 50},
7259         {ESSENCE_TMP_RES_ELEC, "resist electricity activation", 7, TR_RES_ELEC, 50},
7260         {ESSENCE_TMP_RES_FIRE, "resist fire activation", 7, TR_RES_FIRE, 50},
7261         {ESSENCE_TMP_RES_COLD, "resist cold activation", 7, TR_RES_COLD, 50},
7262         {ESSENCE_SH_FIRE, "fiery sheath", 7, -1, 50},
7263         {ESSENCE_SH_ELEC, "electric sheath", 7, -1, 50},
7264         {ESSENCE_SH_COLD, "sheath of coldness", 7, -1, 50},
7265         {ESSENCE_RESISTANCE, "resistance", 2, -1, 150},
7266         {ESSENCE_SUSTAIN, "elements proof", 10, -1, 10},
7267         {ESSENCE_SLAY_GLOVE, "gauntlets of slaying", 1, TR_ES_ATTACK, 200},
7268
7269         {-1, NULL, 0, -1, 0}
7270 };
7271 #endif
7272
7273
7274 /*!
7275  * エッセンス名テーブル / Essense names for Weapon smith
7276  */
7277 #ifdef JP
7278 cptr essence_name[] =
7279 {
7280         "腕力",
7281         "知能",
7282         "賢さ",
7283         "器用さ",
7284         "耐久力",
7285         "魅力",
7286         "魔力支配",
7287         "",
7288         "隠密",
7289         "探索",
7290         "赤外線視力",
7291         "採掘",
7292         "スピード",
7293         "追加攻撃",
7294         "カオス攻撃",
7295         "吸血攻撃",
7296         "動物倍打",
7297         "邪悪倍打",
7298         "不死倍打",
7299         "悪魔倍打",
7300         "オーク倍打",
7301         "トロル倍打",
7302         "巨人倍打",
7303         "竜倍打",
7304         "",
7305         "",
7306         "地震",
7307         "毒殺",
7308         "溶解",
7309         "電撃",
7310         "焼棄",
7311         "凍結",
7312         "能力維持",
7313         "",
7314         "",
7315         "",
7316         "",
7317         "",
7318         "",
7319         "",
7320         "免疫",
7321         "",
7322         "",
7323         "",
7324         "",
7325         "反射",
7326         "麻痺知らず",
7327         "経験値維持",
7328         "耐酸",
7329         "耐電撃",
7330         "耐火炎",
7331         "耐冷気",
7332         "耐毒",
7333         "耐恐怖",
7334         "耐閃光",
7335         "耐暗黒",
7336         "耐盲目",
7337         "耐混乱",
7338         "耐轟音",
7339         "耐破片",
7340         "耐地獄",
7341         "耐因果混乱",
7342         "耐カオス",
7343         "耐劣化",
7344         "",
7345         "",
7346         "人間倍打",
7347         "",
7348         "",
7349         "反魔法",
7350         "",
7351         "",
7352         "警告",
7353         "",
7354         "",
7355         "",
7356         "浮遊",
7357         "永久光源",
7358         "可視透明",
7359         "テレパシー",
7360         "遅消化",
7361         "急速回復",
7362         "",
7363         "",
7364         "",
7365         "",
7366         "",
7367         "",
7368         "",
7369         "",
7370         "テレポート",
7371         "",
7372         "",
7373         "攻撃",
7374         "防御",
7375
7376         NULL
7377 };
7378
7379 #else
7380
7381 cptr essence_name[] =
7382 {
7383         "strength",
7384         "intelligen.",
7385         "wisdom",
7386         "dexterity",
7387         "constitut.",
7388         "charisma",
7389         "magic mast.",
7390         "",
7391         "stealth",
7392         "serching",
7393         "infravision",
7394         "digging",
7395         "speed",
7396         "extra atk",
7397         "chaos brand",
7398         "vampiric",
7399         "slay animal",
7400         "slay evil",
7401         "slay undead",
7402         "slay demon",
7403         "slay orc",
7404         "slay troll",
7405         "slay giant",
7406         "slay dragon",
7407         "",
7408         "",
7409         "quake",
7410         "pois. brand",
7411         "acid brand",
7412         "elec. brand",
7413         "fire brand",
7414         "cold brand",
7415         "sustain",
7416         "",
7417         "",
7418         "",
7419         "",
7420         "",
7421         "",
7422         "",
7423         "immunity",
7424         "",
7425         "",
7426         "",
7427         "",
7428         "reflection",
7429         "free action",
7430         "hold exp",
7431         "res. acid",
7432         "res. elec.",
7433         "res. fire",
7434         "res. cold",
7435         "res. poison",
7436         "res. fear",
7437         "res. light",
7438         "res. dark",
7439         "res. blind",
7440         "res.confuse",
7441         "res. sound",
7442         "res. shard",
7443         "res. nether",
7444         "res. nexus",
7445         "res. chaos",
7446         "res. disen.",
7447         "",
7448         "",
7449         "slay human",
7450         "",
7451         "",
7452         "anti magic",
7453         "",
7454         "",
7455         "warning",
7456         "",
7457         "",
7458         "",
7459         "levitation",
7460         "perm. light",
7461         "see invis.",
7462         "telepathy",
7463         "slow dige.",
7464         "regen.",
7465         "",
7466         "",
7467         "",
7468         "",
7469         "",
7470         "",
7471         "",
7472         "",
7473         "teleport",
7474         "",
7475         "",
7476         "weapon enc.",
7477         "armor enc.",
7478
7479         NULL
7480 };
7481 #endif
7482
7483 /*!
7484  * @brief 所持しているエッセンス一覧を表示する
7485  * @return なし
7486  */
7487 static void display_essence(void)
7488 {
7489         int i, num = 0;
7490
7491         screen_save();
7492         for (i = 1; i < 22; i++)
7493         {
7494                 prt("",i,0);
7495         }
7496         prt(_("エッセンス   個数     エッセンス   個数     エッセンス   個数",
7497                   "Essence      Num      Essence      Num      Essence      Num "), 1, 8);
7498         for (i = 0; essence_name[i]; i++)
7499         {
7500                 if (!essence_name[i][0]) continue;
7501                 prt(format("%-11s %5d", essence_name[i], p_ptr->magic_num1[i]), 2+num%21, 8+num/21*22);
7502                 num++;
7503         }
7504         prt(_("現在所持しているエッセンス", "List of all essences you have."), 0, 0);
7505         (void)inkey();
7506         screen_load();
7507         return;
7508 }
7509
7510 /*!
7511  * @brief エッセンスの抽出処理
7512  * @return なし
7513  */
7514 static void drain_essence(void)
7515 {
7516         int drain_value[sizeof(p_ptr->magic_num1) / sizeof(s32b)];
7517         int i;
7518         OBJECT_IDX item;
7519         int dec = 4;
7520         bool observe = FALSE;
7521         int old_ds, old_dd, old_to_h, old_to_d, old_ac, old_to_a, old_pval, old_name2;
7522         TIME_EFFECT old_timeout;
7523         BIT_FLAGS old_flgs[TR_FLAG_SIZE], new_flgs[TR_FLAG_SIZE];
7524         object_type *o_ptr;
7525         cptr q, s;
7526         POSITION iy, ix;
7527         byte_hack marked;
7528         ITEM_NUMBER number;
7529         OBJECT_IDX next_o_idx;
7530         WEIGHT weight;
7531
7532         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7533                 drain_value[i] = 0;
7534
7535         item_tester_hook = object_is_weapon_armour_ammo;
7536         item_tester_no_ryoute = TRUE;
7537
7538         q = _("どのアイテムから抽出しますか？", "Extract from which item? ");
7539         s = _("抽出できるアイテムがありません。", "You have nothing you can extract from.");
7540
7541         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
7542
7543         /* Get the item (in the pack) */
7544         if (item >= 0)
7545         {
7546                 o_ptr = &inventory[item];
7547         }
7548
7549         /* Get the item (on the floor) */
7550         else
7551         {
7552                 o_ptr = &o_list[0 - item];
7553         }
7554
7555         if (object_is_known(o_ptr) && !object_is_nameless(o_ptr))
7556         {
7557                 char o_name[MAX_NLEN];
7558                 object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7559                 if (!get_check(format(_("本当に%sから抽出してよろしいですか？", "Really extract from %s? "), o_name))) return;
7560         }
7561
7562         p_ptr->energy_use = 100;
7563
7564         object_flags(o_ptr, old_flgs);
7565         if (have_flag(old_flgs, TR_KILL_DRAGON)) add_flag(old_flgs, TR_SLAY_DRAGON);
7566         if (have_flag(old_flgs, TR_KILL_ANIMAL)) add_flag(old_flgs, TR_SLAY_ANIMAL);
7567         if (have_flag(old_flgs, TR_KILL_EVIL)) add_flag(old_flgs, TR_SLAY_EVIL);
7568         if (have_flag(old_flgs, TR_KILL_UNDEAD)) add_flag(old_flgs, TR_SLAY_UNDEAD);
7569         if (have_flag(old_flgs, TR_KILL_DEMON)) add_flag(old_flgs, TR_SLAY_DEMON);
7570         if (have_flag(old_flgs, TR_KILL_ORC)) add_flag(old_flgs, TR_SLAY_ORC);
7571         if (have_flag(old_flgs, TR_KILL_TROLL)) add_flag(old_flgs, TR_SLAY_TROLL);
7572         if (have_flag(old_flgs, TR_KILL_GIANT)) add_flag(old_flgs, TR_SLAY_GIANT);
7573         if (have_flag(old_flgs, TR_KILL_HUMAN)) add_flag(old_flgs, TR_SLAY_HUMAN);
7574
7575         old_to_a = o_ptr->to_a;
7576         old_ac = o_ptr->ac;
7577         old_to_h = o_ptr->to_h;
7578         old_to_d = o_ptr->to_d;
7579         old_ds = o_ptr->ds;
7580         old_dd = o_ptr->dd;
7581         old_pval = o_ptr->pval;
7582         old_name2 = o_ptr->name2;
7583         old_timeout = o_ptr->timeout;
7584         if (o_ptr->curse_flags & (TRC_CURSED | TRC_HEAVY_CURSE | TRC_PERMA_CURSE)) dec--;
7585         if (have_flag(old_flgs, TR_ADD_L_CURSE)) dec--;
7586         if (have_flag(old_flgs, TR_ADD_H_CURSE)) dec--;
7587         if (have_flag(old_flgs, TR_AGGRAVATE)) dec--;
7588         if (have_flag(old_flgs, TR_NO_TELE)) dec--;
7589         if (have_flag(old_flgs, TR_DRAIN_EXP)) dec--;
7590         if (have_flag(old_flgs, TR_DRAIN_HP)) dec--;
7591         if (have_flag(old_flgs, TR_DRAIN_MANA)) dec--;
7592         if (have_flag(old_flgs, TR_CALL_ANIMAL)) dec--;
7593         if (have_flag(old_flgs, TR_CALL_DEMON)) dec--;
7594         if (have_flag(old_flgs, TR_CALL_DRAGON)) dec--;
7595         if (have_flag(old_flgs, TR_CALL_UNDEAD)) dec--;
7596         if (have_flag(old_flgs, TR_COWARDICE)) dec--;
7597         if (have_flag(old_flgs, TR_LOW_MELEE)) dec--;
7598         if (have_flag(old_flgs, TR_LOW_AC)) dec--;
7599         if (have_flag(old_flgs, TR_LOW_MAGIC)) dec--;
7600         if (have_flag(old_flgs, TR_FAST_DIGEST)) dec--;
7601         if (have_flag(old_flgs, TR_SLOW_REGEN)) dec--;
7602         if (have_flag(old_flgs, TR_TY_CURSE)) dec--;
7603
7604         iy = o_ptr->iy;
7605         ix = o_ptr->ix;
7606         next_o_idx = o_ptr->next_o_idx;
7607         marked = o_ptr->marked;
7608         weight = o_ptr->weight;
7609         number = o_ptr->number;
7610
7611         object_prep(o_ptr, o_ptr->k_idx);
7612
7613         o_ptr->iy=iy;
7614         o_ptr->ix=ix;
7615         o_ptr->next_o_idx=next_o_idx;
7616         o_ptr->marked=marked;
7617         o_ptr->number = number;
7618         if (o_ptr->tval == TV_DRAG_ARMOR) o_ptr->timeout = old_timeout;
7619         if (item >= 0) p_ptr->total_weight += (o_ptr->weight*o_ptr->number - weight*number);
7620         o_ptr->ident |= (IDENT_MENTAL);
7621         object_aware(o_ptr);
7622         object_known(o_ptr);
7623
7624         object_flags(o_ptr, new_flgs);
7625
7626         for (i = 0; essence_info[i].add_name; i++)
7627         {
7628                 essence_type *es_ptr = &essence_info[i];
7629                 PARAMETER_VALUE pval = 0;
7630
7631                 if (es_ptr->add < TR_FLAG_MAX && is_pval_flag(es_ptr->add) && old_pval)
7632                         pval = (have_flag(new_flgs, es_ptr->add)) ? old_pval - o_ptr->pval : old_pval;
7633
7634                 if (es_ptr->add < TR_FLAG_MAX &&
7635                     (!have_flag(new_flgs, es_ptr->add) || pval) &&
7636                     have_flag(old_flgs, es_ptr->add))
7637                 {
7638                         if (pval)
7639                         {
7640                                 drain_value[es_ptr->essence] += 10 * pval;
7641                         }
7642                         else if (es_ptr->essence != -2)
7643                         {
7644                                 drain_value[es_ptr->essence] += 10;
7645                         }
7646                         else if (es_ptr->add == TR_SH_FIRE)
7647                         {
7648                                 drain_value[TR_BRAND_FIRE] += 10;
7649                                 drain_value[TR_RES_FIRE] += 10;
7650                         }
7651                         else if (es_ptr->add == TR_SH_ELEC)
7652                         {
7653                                 drain_value[TR_BRAND_ELEC] += 10;
7654                                 drain_value[TR_RES_ELEC] += 10;
7655                         }
7656                         else if (es_ptr->add == TR_SH_COLD)
7657                         {
7658                                 drain_value[TR_BRAND_COLD] += 10;
7659                                 drain_value[TR_RES_COLD] += 10;
7660                         }
7661                         else if (es_ptr->add == TR_LITE_2)
7662                         {
7663                                 drain_value[TR_LITE_1] += 20;
7664                         }
7665                         else if (es_ptr->add == TR_LITE_3)
7666                         {
7667                                 drain_value[TR_LITE_1] += 30;
7668                         }
7669                 }
7670         }
7671
7672         if ((have_flag(old_flgs, TR_FORCE_WEAPON)) && !(have_flag(new_flgs, TR_FORCE_WEAPON)))
7673         {
7674                 drain_value[TR_INT] += 5;
7675                 drain_value[TR_WIS] += 5;
7676         }
7677         if ((have_flag(old_flgs, TR_VORPAL)) && !(have_flag(new_flgs, TR_VORPAL)))
7678         {
7679                 drain_value[TR_BRAND_POIS] += 5;
7680                 drain_value[TR_BRAND_ACID] += 5;
7681                 drain_value[TR_BRAND_ELEC] += 5;
7682                 drain_value[TR_BRAND_FIRE] += 5;
7683                 drain_value[TR_BRAND_COLD] += 5;
7684         }
7685         if ((have_flag(old_flgs, TR_DEC_MANA)) && !(have_flag(new_flgs, TR_DEC_MANA)))
7686         {
7687                 drain_value[TR_INT] += 10;
7688         }
7689         if ((have_flag(old_flgs, TR_XTRA_MIGHT)) && !(have_flag(new_flgs, TR_XTRA_MIGHT)))
7690         {
7691                 drain_value[TR_STR] += 10;
7692         }
7693         if ((have_flag(old_flgs, TR_XTRA_SHOTS)) && !(have_flag(new_flgs, TR_XTRA_SHOTS)))
7694         {
7695                 drain_value[TR_DEX] += 10;
7696         }
7697         if (old_name2 == EGO_2WEAPON)
7698         {
7699                 drain_value[TR_DEX] += 20;
7700         }
7701         if (object_is_weapon_ammo(o_ptr))
7702         {
7703                 if (old_ds > o_ptr->ds) drain_value[TR_ES_ATTACK] += (old_ds-o_ptr->ds)*10;
7704
7705                 if (old_dd > o_ptr->dd) drain_value[TR_ES_ATTACK] += (old_dd-o_ptr->dd)*10;
7706         }
7707         if (old_to_h > o_ptr->to_h) drain_value[TR_ES_ATTACK] += (old_to_h-o_ptr->to_h)*10;
7708         if (old_to_d > o_ptr->to_d) drain_value[TR_ES_ATTACK] += (old_to_d-o_ptr->to_d)*10;
7709         if (old_ac > o_ptr->ac) drain_value[TR_ES_AC] += (old_ac-o_ptr->ac)*10;
7710         if (old_to_a > o_ptr->to_a) drain_value[TR_ES_AC] += (old_to_a-o_ptr->to_a)*10;
7711
7712         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7713         {
7714                 drain_value[i] *= number;
7715                 drain_value[i] = drain_value[i] * dec / 4;
7716                 drain_value[i] = MAX(drain_value[i], 0);
7717                 if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) drain_value[i] /= 10;
7718                 if (drain_value[i])
7719                 {
7720                         observe = TRUE;
7721                 }
7722         }
7723         if (!observe)
7724         {
7725                 msg_print(_("エッセンスは抽出できませんでした。", "You were not able to extract any essence."));
7726         }
7727         else
7728         {
7729                 msg_print(_("抽出したエッセンス:", "Extracted essences:"));
7730
7731                 for (i = 0; essence_name[i]; i++)
7732                 {
7733                         if (!essence_name[i][0]) continue;
7734                         if (!drain_value[i]) continue;
7735
7736                         p_ptr->magic_num1[i] += drain_value[i];
7737                         p_ptr->magic_num1[i] = MIN(20000, p_ptr->magic_num1[i]);
7738                         msg_print(NULL);
7739                         msg_format("%s...%d%s", essence_name[i], drain_value[i], _("。", ". "));
7740                 }
7741         }
7742
7743         /* Apply autodestroy/inscription to the drained item */
7744         autopick_alter_item(item, TRUE);
7745
7746         /* Combine the pack */
7747         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
7748
7749         p_ptr->window |= (PW_INVEN);
7750 }
7751
7752 /*!
7753  * @brief 付加するエッセンスの大別を選択する
7754  * @return 選んだエッセンスの大別ID
7755  */
7756 static COMMAND_CODE choose_essence(void)
7757 {
7758         COMMAND_CODE mode = 0;
7759         char choice;
7760         COMMAND_CODE menu_line = (use_menu ? 1 : 0);
7761
7762 #ifdef JP
7763         cptr menu_name[] = {
7764                 "武器属性",
7765                 "耐性",
7766                 "能力",
7767                 "数値",
7768                 "スレイ",
7769                 "ESP",
7770                 "その他"
7771         };
7772 #else
7773         cptr menu_name[] = {
7774                 "Brand weapon",
7775                 "Resistance",
7776                 "Ability",
7777                 "Magic number",
7778                 "Slay",
7779                 "ESP",
7780                 "Others"
7781         };
7782 #endif
7783         const COMMAND_CODE mode_max = 7;
7784
7785         if (repeat_pull(&mode) && 1 <= mode && mode <= mode_max)
7786                 return mode;
7787         mode = 0;
7788         if (use_menu)
7789         {
7790                 screen_save();
7791
7792                 while(!mode)
7793                 {
7794                         int i;
7795                         for (i = 0; i < mode_max; i++)
7796 #ifdef JP
7797                                 prt(format(" %s %s", (menu_line == 1+i) ? "》" : "  ", menu_name[i]), 2 + i, 14);
7798                         prt("どの種類のエッセンス付加を行いますか？", 0, 0);
7799 #else
7800                                 prt(format(" %s %s", (menu_line == 1+i) ? "> " : "  ", menu_name[i]), 2 + i, 14);
7801                         prt("Choose from menu.", 0, 0);
7802 #endif
7803
7804                         choice = inkey();
7805                         switch(choice)
7806                         {
7807                         case ESCAPE:
7808                         case 'z':
7809                         case 'Z':
7810                                 screen_load();
7811                                 return 0;
7812                         case '2':
7813                         case 'j':
7814                         case 'J':
7815                                 menu_line++;
7816                                 break;
7817                         case '8':
7818                         case 'k':
7819                         case 'K':
7820                                 menu_line += mode_max - 1;
7821                                 break;
7822                         case '\r':
7823                         case '\n':
7824                         case 'x':
7825                         case 'X':
7826                                 mode = menu_line;
7827                                 break;
7828                         }
7829                         if (menu_line > mode_max) menu_line -= mode_max;
7830                 }
7831                 screen_load();
7832         }
7833         else
7834         {
7835                 screen_save();
7836                 while (!mode)
7837                 {
7838                         int i;
7839
7840                         for (i = 0; i < mode_max; i++)
7841                                 prt(format("  %c) %s", 'a' + i, menu_name[i]), 2 + i, 14);
7842
7843                         if (!get_com(_("何を付加しますか:", "Command :"), &choice, TRUE))
7844                         {
7845                                 screen_load();
7846                                 return 0;
7847                         }
7848
7849                         if (isupper(choice)) choice = (char)tolower(choice);
7850
7851                         if ('a' <= choice && choice <= 'a' + (char)mode_max - 1)
7852                                 mode = (int)choice - 'a' + 1;
7853                 }
7854                 screen_load();
7855         }
7856
7857         repeat_push(mode);
7858         return mode;
7859 }
7860
7861 /*!
7862  * @brief エッセンスを実際に付加する
7863  * @param mode エッセンスの大別ID
7864  * @return なし
7865  */
7866 static void add_essence(ESSENCE_IDX mode)
7867 {
7868         OBJECT_IDX item;
7869         int max_num = 0;
7870         COMMAND_CODE i;
7871         bool flag,redraw;
7872         char choice;
7873         cptr            q, s;
7874         object_type *o_ptr;
7875         int ask = TRUE;
7876         char out_val[160];
7877         int num[22];
7878         char o_name[MAX_NLEN];
7879         int use_essence;
7880         essence_type *es_ptr;
7881         bool able[22] = { 0 };
7882
7883         int menu_line = (use_menu ? 1 : 0);
7884
7885         for (i = 0; essence_info[i].add_name; i++)
7886         {
7887                 es_ptr = &essence_info[i];
7888
7889                 if (es_ptr->type != mode) continue;
7890                 num[max_num++] = i;
7891         }
7892
7893         if (!repeat_pull(&i) || i<0 || i>=max_num)
7894         {
7895
7896         /* Nothing chosen yet */
7897         flag = FALSE;
7898
7899         /* No redraw yet */
7900         redraw = FALSE;
7901
7902         /* Build a prompt */
7903         (void) strnfmt(out_val, 78, _("('*'で一覧, ESCで中断) どの能力を付加しますか？", "(*=List, ESC=exit) Add which ability? "));
7904         if (use_menu) screen_save();
7905
7906         /* Get a spell from the user */
7907
7908         choice = (always_show_list || use_menu) ? ESCAPE:1;
7909         while (!flag)
7910         {
7911                 if( choice==ESCAPE ) choice = ' ';
7912                 else if( !get_com(out_val, &choice, FALSE) )break;
7913
7914                 if (use_menu && choice != ' ')
7915                 {
7916                         switch(choice)
7917                         {
7918                                 case '0':
7919                                 {
7920                                         screen_load();
7921                                         return;
7922                                 }
7923
7924                                 case '8':
7925                                 case 'k':
7926                                 case 'K':
7927                                 {
7928                                         menu_line += (max_num-1);
7929                                         break;
7930                                 }
7931
7932                                 case '2':
7933                                 case 'j':
7934                                 case 'J':
7935                                 {
7936                                         menu_line++;
7937                                         break;
7938                                 }
7939
7940                                 case '4':
7941                                 case 'h':
7942                                 case 'H':
7943                                 {
7944                                         menu_line = 1;
7945                                         break;
7946                                 }
7947                                 case '6':
7948                                 case 'l':
7949                                 case 'L':
7950                                 {
7951                                         menu_line = max_num;
7952                                         break;
7953                                 }
7954
7955                                 case 'x':
7956                                 case 'X':
7957                                 case '\r':
7958                                 case '\n':
7959                                 {
7960                                         i = menu_line - 1;
7961                                         ask = FALSE;
7962                                         break;
7963                                 }
7964                         }
7965                         if (menu_line > max_num) menu_line -= max_num;
7966                 }
7967                 /* Request redraw */
7968                 if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask))
7969                 {
7970                         /* Show the list */
7971                         if (!redraw || use_menu)
7972                         {
7973                                 byte y, x = 10;
7974                                 int ctr;
7975                                 char dummy[80], dummy2[80];
7976                                 byte col;
7977
7978                                 strcpy(dummy, "");
7979
7980                                 /* Show list */
7981                                 redraw = TRUE;
7982
7983                                 /* Save the screen */
7984                                 if (!use_menu) screen_save();
7985
7986                                 for (y = 1; y < 24; y++)
7987                                         prt("", y, x);
7988
7989                                 /* Print header(s) */
7990 #ifdef JP
7991                                 prt(format("   %-43s %6s/%s", "能力(必要エッセンス)", "必要数", "所持数"), 1, x);
7992
7993 #else
7994                                 prt(format("   %-43s %6s/%s", "Ability (needed essence)", "Needs", "Possess"), 1, x);
7995 #endif
7996                                 /* Print list */
7997                                 for (ctr = 0; ctr < max_num; ctr++)
7998                                 {
7999                                         es_ptr = &essence_info[num[ctr]];
8000
8001                                         if (use_menu)
8002                                         {
8003                                                 if (ctr == (menu_line-1))
8004                                                         strcpy(dummy, _("》 ", ">  "));
8005                                                 else strcpy(dummy, "   ");
8006
8007                                         }
8008                                         /* letter/number for power selection */
8009                                         else
8010                                         {
8011                                                 sprintf(dummy, "%c) ",I2A(ctr));
8012                                         }
8013
8014                                         strcat(dummy, es_ptr->add_name);
8015
8016                                         col = TERM_WHITE;
8017                                         able[ctr] = TRUE;
8018
8019                                         if (es_ptr->essence != -1)
8020                                         {
8021                                                 strcat(dummy, format("(%s)", essence_name[es_ptr->essence]));
8022                                                 if (p_ptr->magic_num1[es_ptr->essence] < es_ptr->value) able[ctr] = FALSE;
8023                                         }
8024                                         else
8025                                         {
8026                                                 switch(es_ptr->add)
8027                                                 {
8028                                                 case ESSENCE_SH_FIRE:
8029                                                         strcat(dummy, _("(焼棄+耐火炎)", "(brand fire + res.fire)"));
8030                                                         if (p_ptr->magic_num1[TR_BRAND_FIRE] < es_ptr->value) able[ctr] = FALSE;
8031                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8032                                                         break;
8033                                                 case ESSENCE_SH_ELEC:
8034                                                         strcat(dummy, _("(電撃+耐電撃)", "(brand elec. + res. elec.)"));
8035                                                         if (p_ptr->magic_num1[TR_BRAND_ELEC] < es_ptr->value) able[ctr] = FALSE;
8036                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8037                                                         break;
8038                                                 case ESSENCE_SH_COLD:
8039                                                         strcat(dummy, _("(凍結+耐冷気)", "(brand cold + res. cold)"));
8040                                                         if (p_ptr->magic_num1[TR_BRAND_COLD] < es_ptr->value) able[ctr] = FALSE;
8041                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8042                                                         break;
8043                                                 case ESSENCE_RESISTANCE:
8044                                                         strcat(dummy, _("(耐火炎+耐冷気+耐電撃+耐酸)", "(r.fire+r.cold+r.elec+r.acid)"));
8045                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8046                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8047                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8048                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8049                                                         break;
8050                                                 case ESSENCE_SUSTAIN:
8051                                                         strcat(dummy, _("(耐火炎+耐冷気+耐電撃+耐酸)", "(r.fire+r.cold+r.elec+r.acid)"));
8052                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8053                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8054                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8055                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8056                                                         break;
8057                                                 }
8058                                         }
8059
8060                                         if (!able[ctr]) col = TERM_RED;
8061
8062                                         if (es_ptr->essence != -1)
8063                                         {
8064                                                 sprintf(dummy2, "%-49s %3d/%d", dummy, es_ptr->value, (int)p_ptr->magic_num1[es_ptr->essence]);
8065                                         }
8066                                         else
8067                                         {
8068                                                 sprintf(dummy2, "%-49s %3d/(\?\?)", dummy, es_ptr->value);
8069                                         }
8070
8071                                         c_prt(col, dummy2, ctr+2, x);
8072                                 }
8073                         }
8074
8075                         /* Hide the list */
8076                         else
8077                         {
8078                                 /* Hide list */
8079                                 redraw = FALSE;
8080
8081                                 /* Restore the screen */
8082                                 screen_load();
8083                         }
8084
8085                         /* Redo asking */
8086                         continue;
8087                 }
8088
8089                 if (!use_menu)
8090                 {
8091                         /* Note verify */
8092                         ask = (isupper(choice));
8093
8094                         /* Lowercase */
8095                         if (ask) choice = (char)tolower(choice);
8096
8097                         /* Extract request */
8098                         i = (islower(choice) ? A2I(choice) : -1);
8099                 }
8100
8101                 /* Totally Illegal */
8102                 if ((i < 0) || (i >= max_num) || !able[i])
8103                 {
8104                         bell();
8105                         continue;
8106                 }
8107
8108                 /* Verify it */
8109                 if (ask)
8110                 {
8111                         char tmp_val[160];
8112
8113                         /* Prompt */
8114                         (void) strnfmt(tmp_val, 78, _("%sを付加しますか？ ", "Add the abilitiy of %s? "), essence_info[num[i]].add_name);
8115
8116                         /* Belay that order */
8117                         if (!get_check(tmp_val)) continue;
8118                 }
8119
8120                 /* Stop the loop */
8121                 flag = TRUE;
8122         }
8123
8124         /* Restore the screen */
8125         if (redraw) screen_load();
8126
8127         if (!flag) return;
8128
8129         repeat_push(i);
8130         }
8131         es_ptr = &essence_info[num[i]];
8132
8133         if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8134                 item_tester_tval = TV_GLOVES;
8135         else if (mode == 1 || mode == 5)
8136                 item_tester_hook = item_tester_hook_melee_ammo;
8137         else if (es_ptr->add == ESSENCE_ATTACK)
8138                 item_tester_hook = object_allow_enchant_weapon;
8139         else if (es_ptr->add == ESSENCE_AC)
8140                 item_tester_hook = object_is_armour;
8141         else
8142                 item_tester_hook = object_is_weapon_armour_ammo;
8143         item_tester_no_ryoute = TRUE;
8144
8145         q = _("どのアイテムを改良しますか？", "Improve which item? ");
8146         s = _("改良できるアイテムがありません。", "You have nothing to improve.");
8147
8148         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8149
8150         /* Get the item (in the pack) */
8151         if (item >= 0)
8152         {
8153                 o_ptr = &inventory[item];
8154         }
8155
8156         /* Get the item (on the floor) */
8157         else
8158         {
8159                 o_ptr = &o_list[0 - item];
8160         }
8161
8162         if ((mode != 10) && (object_is_artifact(o_ptr) || object_is_smith(o_ptr)))
8163         {
8164                 msg_print(_("そのアイテムはこれ以上改良できない。", "This item is no more able to be improved."));
8165                 return;
8166         }
8167
8168         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8169
8170         use_essence = es_ptr->value;
8171         if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) use_essence = (use_essence+9)/10;
8172         if (o_ptr->number > 1)
8173         {
8174                 use_essence *= o_ptr->number;
8175                 msg_format(_("%d個あるのでエッセンスは%d必要です。", "It will take %d essences."), o_ptr->number, use_essence);
8176         }
8177
8178         if (es_ptr->essence != -1)
8179         {
8180                 if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8181                 {
8182                         msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8183                         return;
8184                 }
8185                 if (is_pval_flag(es_ptr->add))
8186                 {
8187                         if (o_ptr->pval < 0)
8188                         {
8189                                 msg_print(_("このアイテムの能力修正を強化することはできない。", "You cannot increase magic number of this item."));
8190                                 return;
8191                         }
8192                         else if (es_ptr->add == TR_BLOWS)
8193                         {
8194                                 if (o_ptr->pval > 1)
8195                                 {
8196                                         if (!get_check(_("修正値は1になります。よろしいですか？", "The magic number of this weapon will become 1. Are you sure? "))) return;
8197                                 }
8198
8199                                 o_ptr->pval = 1;
8200                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8201                         }
8202                         else if (o_ptr->pval > 0)
8203                         {
8204                                 use_essence *= o_ptr->pval;
8205                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8206                         }
8207                         else
8208                         {
8209                                 char tmp[80];
8210                                 char tmp_val[160];
8211                                 PARAMETER_VALUE pval;
8212                                 PARAMETER_VALUE limit = MIN(5, p_ptr->magic_num1[es_ptr->essence]/es_ptr->value);
8213
8214                                 sprintf(tmp, _("いくつ付加しますか？ (1-%d): ", "Enchant how many? (1-%d): "), limit);
8215                                 strcpy(tmp_val, "1");
8216
8217                                 if (!get_string(tmp, tmp_val, 1)) return;
8218                                 pval = (PARAMETER_VALUE)atoi(tmp_val);
8219                                 if (pval > limit) pval = limit;
8220                                 else if (pval < 1) pval = 1;
8221                                 o_ptr->pval += pval;
8222                                 use_essence *= pval;
8223                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8224                         }
8225
8226                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8227                         {
8228                                 msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8229                                 return;
8230                         }
8231                 }
8232                 else if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8233                 {
8234                         char tmp_val[160];
8235                         int val;
8236                         HIT_PROB get_to_h;
8237                         HIT_POINT get_to_d;
8238
8239                         strcpy(tmp_val, "1");
8240                         if (!get_string(format(_("いくつ付加しますか？ (1-%d):", "Enchant how many? (1-%d):"), p_ptr->lev/7+3), tmp_val, 2)) return;
8241                         val = atoi(tmp_val);
8242                         if (val > p_ptr->lev/7+3) val = p_ptr->lev/7+3;
8243                         else if (val < 1) val = 1;
8244                         use_essence *= val;
8245                         msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8246                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8247                         {
8248                                 msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8249                                 return;
8250                         }
8251                         get_to_h = ((val+1)/2+randint0(val/2+1));
8252                         get_to_d = ((val+1)/2+randint0(val/2+1));
8253                         o_ptr->xtra4 = (get_to_h<<8)+get_to_d;
8254                         o_ptr->to_h += get_to_h;
8255                         o_ptr->to_d += get_to_d;
8256                 }
8257                 p_ptr->magic_num1[es_ptr->essence] -= use_essence;
8258                 if (es_ptr->add == ESSENCE_ATTACK)
8259                 {
8260                         if ((o_ptr->to_h >= p_ptr->lev/5+5) && (o_ptr->to_d >= p_ptr->lev/5+5))
8261                         {
8262                                 msg_print(_("改良に失敗した。", "You failed to enchant."));
8263                                 p_ptr->energy_use = 100;
8264                                 return;
8265                         }
8266                         else
8267                         {
8268                                 if (o_ptr->to_h < p_ptr->lev/5+5) o_ptr->to_h++;
8269                                 if (o_ptr->to_d < p_ptr->lev/5+5) o_ptr->to_d++;
8270                         }
8271                 }
8272                 else if (es_ptr->add == ESSENCE_AC)
8273                 {
8274                         if (o_ptr->to_a >= p_ptr->lev/5+5)
8275                         {
8276                                 msg_print(_("改良に失敗した。", "You failed to enchant."));
8277                                 p_ptr->energy_use = 100;
8278                                 return;
8279                         }
8280                         else
8281                         {
8282                                 if (o_ptr->to_a < p_ptr->lev/5+5) o_ptr->to_a++;
8283                         }
8284                 }
8285                 else
8286                 {
8287                         o_ptr->xtra3 = es_ptr->add + 1;
8288                 }
8289         }
8290         else
8291         {
8292                 bool success = TRUE;
8293
8294                 switch(es_ptr->add)
8295                 {
8296                 case ESSENCE_SH_FIRE:
8297                         if ((p_ptr->magic_num1[TR_BRAND_FIRE] < use_essence) || (p_ptr->magic_num1[TR_RES_FIRE] < use_essence))
8298                         {
8299                                 success = FALSE;
8300                                 break;
8301                         }
8302                         p_ptr->magic_num1[TR_BRAND_FIRE] -= use_essence;
8303                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8304                         break;
8305                 case ESSENCE_SH_ELEC:
8306                         if ((p_ptr->magic_num1[TR_BRAND_ELEC] < use_essence) || (p_ptr->magic_num1[TR_RES_ELEC] < use_essence))
8307                         {
8308                                 success = FALSE;
8309                                 break;
8310                         }
8311                         p_ptr->magic_num1[TR_BRAND_ELEC] -= use_essence;
8312                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8313                         break;
8314                 case ESSENCE_SH_COLD:
8315                         if ((p_ptr->magic_num1[TR_BRAND_COLD] < use_essence) || (p_ptr->magic_num1[TR_RES_COLD] < use_essence))
8316                         {
8317                                 success = FALSE;
8318                                 break;
8319                         }
8320                         p_ptr->magic_num1[TR_BRAND_COLD] -= use_essence;
8321                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8322                         break;
8323                 case ESSENCE_RESISTANCE:
8324                 case ESSENCE_SUSTAIN:
8325                         if ((p_ptr->magic_num1[TR_RES_ACID] < use_essence) || (p_ptr->magic_num1[TR_RES_ELEC] < use_essence) || (p_ptr->magic_num1[TR_RES_FIRE] < use_essence) || (p_ptr->magic_num1[TR_RES_COLD] < use_essence))
8326                         {
8327                                 success = FALSE;
8328                                 break;
8329                         }
8330                         p_ptr->magic_num1[TR_RES_ACID] -= use_essence;
8331                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8332                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8333                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8334                         break;
8335                 }
8336                 if (!success)
8337                 {
8338                         msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8339                         return;
8340                 }
8341                 if (es_ptr->add == ESSENCE_SUSTAIN)
8342                 {
8343                         add_flag(o_ptr->art_flags, TR_IGNORE_ACID);
8344                         add_flag(o_ptr->art_flags, TR_IGNORE_ELEC);
8345                         add_flag(o_ptr->art_flags, TR_IGNORE_FIRE);
8346                         add_flag(o_ptr->art_flags, TR_IGNORE_COLD);
8347                 }
8348                 else
8349                 {
8350                         o_ptr->xtra3 = es_ptr->add + 1;
8351                 }
8352         }
8353
8354         p_ptr->energy_use = 100;
8355
8356 #ifdef JP
8357         msg_format("%sに%sの能力を付加しました。", o_name, es_ptr->add_name);
8358 #else
8359         msg_format("You have added ability of %s to %s.", es_ptr->add_name, o_name);
8360 #endif
8361
8362         /* Combine the pack */
8363         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8364
8365         p_ptr->window |= (PW_INVEN);
8366 }
8367
8368 /*!
8369  * @brief エッセンスを消去する
8370  * @return なし
8371  */
8372 static void erase_essence(void)
8373 {
8374         OBJECT_IDX item;
8375         cptr q, s;
8376         object_type *o_ptr;
8377         char o_name[MAX_NLEN];
8378         BIT_FLAGS flgs[TR_FLAG_SIZE];
8379
8380         item_tester_hook = object_is_smith;
8381
8382         q = _("どのアイテムのエッセンスを消去しますか？", "Remove from which item? ");
8383         s = _("エッセンスを付加したアイテムがありません。", "You have nothing to remove essence.");
8384
8385         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8386
8387         /* Get the item (in the pack) */
8388         if (item >= 0)
8389         {
8390                 o_ptr = &inventory[item];
8391         }
8392
8393         /* Get the item (on the floor) */
8394         else
8395         {
8396                 o_ptr = &o_list[0 - item];
8397         }
8398
8399         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8400         if (!get_check(format(_("よろしいですか？ [%s]", "Are you sure? [%s]"), o_name))) return;
8401
8402         p_ptr->energy_use = 100;
8403
8404         if (o_ptr->xtra3 == 1+ESSENCE_SLAY_GLOVE)
8405         {
8406                 o_ptr->to_h -= (o_ptr->xtra4>>8);
8407                 o_ptr->to_d -= (o_ptr->xtra4 & 0x000f);
8408                 o_ptr->xtra4 = 0;
8409                 if (o_ptr->to_h < 0) o_ptr->to_h = 0;
8410                 if (o_ptr->to_d < 0) o_ptr->to_d = 0;
8411         }
8412         o_ptr->xtra3 = 0;
8413         object_flags(o_ptr, flgs);
8414         if (!(have_pval_flags(flgs))) o_ptr->pval = 0;
8415         msg_print(_("エッセンスを取り去った。", "You removed all essence you have added."));
8416
8417         /* Combine the pack */
8418         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8419
8420         p_ptr->window |= (PW_INVEN);
8421 }
8422
8423 /*!
8424  * @brief 鍛冶コマンドのメインルーチン
8425  * @param only_browse TRUEならばエッセンス一覧の表示のみを行う
8426  * @return なし
8427  */
8428 void do_cmd_kaji(bool only_browse)
8429 {
8430         COMMAND_CODE mode = 0;
8431         char choice;
8432
8433         COMMAND_CODE menu_line = (use_menu ? 1 : 0);
8434
8435         if (!only_browse)
8436         {
8437                 if (p_ptr->confused)
8438                 {
8439                         msg_print(_("混乱していて作業できない！", "You are too confused!"));
8440                         return;
8441                 }
8442                 if (p_ptr->blind)
8443                 {
8444                         msg_print(_("目が見えなくて作業できない！", "You are blind!"));
8445                         return;
8446                 }
8447                 if (p_ptr->image)
8448                 {
8449                         msg_print(_("うまく見えなくて作業できない！", "You are hallucinating!"));
8450                         return;
8451                 }
8452         }
8453
8454         if (!(repeat_pull(&mode) && 1 <= mode && mode <= 5))
8455         {
8456         if (only_browse) screen_save();
8457         do {
8458         if (!only_browse) screen_save();
8459         if (use_menu)
8460         {
8461                 while(!mode)
8462                 {
8463 #ifdef JP
8464                         prt(format(" %s エッセンス一覧", (menu_line == 1) ? "》" : "  "), 2, 14);
8465                         prt(format(" %s エッセンス抽出", (menu_line == 2) ? "》" : "  "), 3, 14);
8466                         prt(format(" %s エッセンス消去", (menu_line == 3) ? "》" : "  "), 4, 14);
8467                         prt(format(" %s エッセンス付加", (menu_line == 4) ? "》" : "  "), 5, 14);
8468                         prt(format(" %s 武器/防具強化", (menu_line == 5) ? "》" : "  "), 6, 14);
8469                         prt(format("どの種類の技術を%sますか？", only_browse ? "調べ" : "使い"), 0, 0);
8470 #else
8471                         prt(format(" %s List essences", (menu_line == 1) ? "> " : "  "), 2, 14);
8472                         prt(format(" %s Extract essence", (menu_line == 2) ? "> " : "  "), 3, 14);
8473                         prt(format(" %s Remove essence", (menu_line == 3) ? "> " : "  "), 4, 14);
8474                         prt(format(" %s Add essence", (menu_line == 4) ? "> " : "  "), 5, 14);
8475                         prt(format(" %s Enchant weapon/armor", (menu_line == 5) ? "> " : "  "), 6, 14);
8476                         prt(format("Choose command from menu."), 0, 0);
8477 #endif
8478                         choice = inkey();
8479                         switch(choice)
8480                         {
8481                         case ESCAPE:
8482                         case 'z':
8483                         case 'Z':
8484                                 screen_load();
8485                                 return;
8486                         case '2':
8487                         case 'j':
8488                         case 'J':
8489                                 menu_line++;
8490                                 break;
8491                         case '8':
8492                         case 'k':
8493                         case 'K':
8494                                 menu_line+= 4;
8495                                 break;
8496                         case '\r':
8497                         case '\n':
8498                         case 'x':
8499                         case 'X':
8500                                 mode = menu_line;
8501                                 break;
8502                         }
8503                         if (menu_line > 5) menu_line -= 5;
8504                 }
8505         }
8506
8507         else
8508         {
8509                 while (!mode)
8510                 {
8511                         prt(_("  a) エッセンス一覧", "  a) List essences"), 2, 14);
8512                         prt(_("  b) エッセンス抽出", "  b) Extract essence"), 3, 14);
8513                         prt(_("  c) エッセンス消去", "  c) Remove essence"), 4, 14);
8514                         prt(_("  d) エッセンス付加", "  d) Add essence"), 5, 14);
8515                         prt(_("  e) 武器/防具強化", "  e) Enchant weapon/armor"), 6, 14);
8516 #ifdef JP
8517                         if (!get_com(format("どの能力を%sますか:", only_browse ? "調べ" : "使い"), &choice, TRUE))
8518 #else
8519                         if (!get_com("Command :", &choice, TRUE))
8520 #endif
8521                         {
8522                                 screen_load();
8523                                 return;
8524                         }
8525                         switch (choice)
8526                         {
8527                         case 'A':
8528                         case 'a':
8529                                 mode = 1;
8530                                 break;
8531                         case 'B':
8532                         case 'b':
8533                                 mode = 2;
8534                                 break;
8535                         case 'C':
8536                         case 'c':
8537                                 mode = 3;
8538                                 break;
8539                         case 'D':
8540                         case 'd':
8541                                 mode = 4;
8542                                 break;
8543                         case 'E':
8544                         case 'e':
8545                                 mode = 5;
8546                                 break;
8547                         }
8548                 }
8549         }
8550
8551         if (only_browse)
8552         {
8553                 char temp[62*5];
8554                 int line, j;
8555
8556                 /* Clear lines, position cursor  (really should use strlen here) */
8557                 Term_erase(14, 21, 255);
8558                 Term_erase(14, 20, 255);
8559                 Term_erase(14, 19, 255);
8560                 Term_erase(14, 18, 255);
8561                 Term_erase(14, 17, 255);
8562                 Term_erase(14, 16, 255);
8563
8564                 roff_to_buf(kaji_tips[mode-1], 62, temp, sizeof(temp));
8565                 for(j=0, line = 17;temp[j];j+=(1+strlen(&temp[j])))
8566                 {
8567                         prt(&temp[j], line, 15);
8568                         line++;
8569                 }
8570                 mode = 0;
8571         }
8572         if (!only_browse) screen_load();
8573         } while (only_browse);
8574         repeat_push(mode);
8575         }
8576         switch(mode)
8577         {
8578                 case 1: display_essence();break;
8579                 case 2: drain_essence();break;
8580                 case 3: erase_essence();break;
8581                 case 4:
8582                         mode = choose_essence();
8583                         if (mode == 0)
8584                                 break;
8585                         add_essence(mode);
8586                         break;
8587                 case 5: add_essence(10);break;
8588         }
8589 }
8590
8591
8592 /*!
8593  * @brief 投擲時たいまつに投げやすい/焼棄/アンデッドスレイの特別効果を返す。
8594  * Torches have special abilities when they are flaming.
8595  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8596  * @param flgs 特別に追加するフラグを返す参照ポインタ
8597  * @return なし
8598  */
8599 void torch_flags(object_type *o_ptr, BIT_FLAGS *flgs)
8600 {
8601         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8602         {
8603                 if (o_ptr->xtra4 > 0)
8604                 {
8605                         add_flag(flgs, TR_BRAND_FIRE);
8606                         add_flag(flgs, TR_KILL_UNDEAD);
8607                         add_flag(flgs, TR_THROW);
8608                 }
8609         }
8610 }
8611
8612 /*!
8613  * @brief 投擲時たいまつにダイスを与える。
8614  * Torches have special abilities when they are flaming.
8615  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8616  * @param dd 特別なダイス数を返す参照ポインタ
8617  * @param ds 特別なダイス面数を返す参照ポインタ
8618  * @return なし
8619  */
8620 void torch_dice(object_type *o_ptr, DICE_NUMBER *dd, DICE_SID *ds)
8621 {
8622         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8623         {
8624                 if (o_ptr->xtra4 > 0)
8625                 {
8626                         (*dd) = 1;
8627                         (*ds) = 6;
8628                 }
8629         }
8630 }
8631
8632 /*!
8633  * @brief 投擲時命中したたいまつの寿命を縮める。
8634  * Torches have special abilities when they are flaming.
8635  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8636  * @return なし
8637  */
8638 void torch_lost_fuel(object_type *o_ptr)
8639 {
8640         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8641         {
8642                 o_ptr->xtra4 -= (FUEL_TORCH / 25);
8643                 if (o_ptr->xtra4 < 0) o_ptr->xtra4 = 0;
8644         }
8645 }