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