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