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