src/object2.c

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