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         object_desc(o_name, o_ptr, 0);
5667
5668 #ifdef JP
5669         /* "no more" の場合はこちらで表示する */
5670         if (o_ptr->number <= 0)
5671         {
5672                 /*FIRST*//*ここはもう通らないかも */
5673                 msg_format("もう%sを持っていない。", o_name);
5674         }
5675         else
5676         {
5677                 /* アイテム名を英日切り替え機能対応 */
5678                 msg_format("まだ %sを持っている。", o_name);
5679         }
5680 #else
5681         msg_format("You have %s.", o_name);
5682 #endif
5683
5684 }
5685
5686 /*!
5687  * @brief アイテムを増やし残り所持数メッセージを表示する /
5688  * Increase the "number" of an item in the inventory
5689  * @param item 所持数を増やしたいプレイヤーのアイテム所持スロット
5690  * @param num 増やしたい量
5691  * @return なし
5692  */
5693 void inven_item_increase(INVENTORY_IDX item, int num)
5694 {
5695         object_type *o_ptr = &inventory[item];
5696
5697         /* Apply */
5698         num += o_ptr->number;
5699
5700         /* Bounds check */
5701         if (num > 255) num = 255;
5702         else if (num < 0) num = 0;
5703
5704         /* Un-apply */
5705         num -= (ITEM_NUMBER)o_ptr->number;
5706
5707         /* Change the number and weight */
5708         if (num)
5709         {
5710                 /* Add the number */
5711                 o_ptr->number += num;
5712
5713                 /* Add the weight */
5714                 p_ptr->total_weight += (num * o_ptr->weight);
5715
5716                 /* Recalculate bonuses */
5717                 p_ptr->update |= (PU_BONUS);
5718
5719                 /* Recalculate mana XXX */
5720                 p_ptr->update |= (PU_MANA);
5721
5722                 /* Combine the pack */
5723                 p_ptr->notice |= (PN_COMBINE);
5724
5725                 p_ptr->window |= (PW_INVEN | PW_EQUIP);
5726
5727                 /* Hack -- Clear temporary elemental brands if player takes off weapons */
5728                 if (!o_ptr->number && p_ptr->ele_attack)
5729                 {
5730                         if ((item == INVEN_RARM) || (item == INVEN_LARM))
5731                         {
5732                                 if (!buki_motteruka(INVEN_RARM + INVEN_LARM - item))
5733                                 {
5734                                         /* Clear all temporary elemental brands */
5735                                         set_ele_attack(0, 0);
5736                                 }
5737                         }
5738                 }
5739         }
5740 }
5741
5742 /*!
5743  * @brief 所持アイテムスロットから所持数のなくなったアイテムを消去する /
5744  * Erase an inventory slot if it has no more items
5745  * @param item 消去したいプレイヤーのアイテム所持スロット
5746  * @return なし
5747  */
5748 void inven_item_optimize(INVENTORY_IDX item)
5749 {
5750         object_type *o_ptr = &inventory[item];
5751
5752         /* Only optimize real items */
5753         if (!o_ptr->k_idx) return;
5754
5755         /* Only optimize empty items */
5756         if (o_ptr->number) return;
5757
5758         /* The item is in the pack */
5759         if (item < INVEN_RARM)
5760         {
5761                 int i;
5762
5763                 /* One less item */
5764                 inven_cnt--;
5765
5766                 /* Slide everything down */
5767                 for (i = item; i < INVEN_PACK; i++)
5768                 {
5769                         /* Structure copy */
5770                         inventory[i] = inventory[i+1];
5771                 }
5772
5773                 /* Erase the "final" slot */
5774                 object_wipe(&inventory[i]);
5775
5776                 p_ptr->window |= (PW_INVEN);
5777         }
5778
5779         /* The item is being wielded */
5780         else
5781         {
5782                 /* One less item */
5783                 equip_cnt--;
5784
5785                 /* Erase the empty slot */
5786                 object_wipe(&inventory[item]);
5787
5788                 /* Recalculate bonuses */
5789                 p_ptr->update |= (PU_BONUS);
5790
5791                 /* Recalculate torch */
5792                 p_ptr->update |= (PU_TORCH);
5793
5794                 /* Recalculate mana XXX */
5795                 p_ptr->update |= (PU_MANA);
5796
5797                 p_ptr->window |= (PW_EQUIP);
5798         }
5799
5800         p_ptr->window |= (PW_SPELL);
5801 }
5802
5803 /*!
5804  * @brief 床上の魔道具の残り残量メッセージを表示する /
5805  * Describe the charges on an item on the floor.
5806  * @param item メッセージの対象にしたいアイテム所持スロット
5807  * @return なし
5808  */
5809 void floor_item_charges(INVENTORY_IDX item)
5810 {
5811         object_type *o_ptr = &o_list[item];
5812
5813         /* Require staff/wand */
5814         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5815
5816         /* Require known item */
5817         if (!object_is_known(o_ptr)) return;
5818
5819 #ifdef JP
5820         if (o_ptr->pval <= 0)
5821         {
5822                 msg_print("この床上のアイテムは、もう魔力が残っていない。");
5823         }
5824         else
5825         {
5826                 msg_format("この床上のアイテムは、あと %d 回分の魔力が残っている。", o_ptr->pval);
5827         }
5828 #else
5829         /* Multiple charges */
5830         if (o_ptr->pval != 1)
5831         {
5832                 msg_format("There are %d charges remaining.", o_ptr->pval);
5833         }
5834
5835         /* Single charge */
5836         else
5837         {
5838                 msg_format("There is %d charge remaining.", o_ptr->pval);
5839         }
5840 #endif
5841
5842 }
5843
5844 /*!
5845  * @brief 床上のアイテムの残り数メッセージを表示する /
5846  * Describe the charges on an item on the floor.
5847  * @param item メッセージの対象にしたいアイテム所持スロット
5848  * @return なし
5849  */
5850 void floor_item_describe(INVENTORY_IDX item)
5851 {
5852         object_type *o_ptr = &o_list[item];
5853         char        o_name[MAX_NLEN];
5854
5855         object_desc(o_name, o_ptr, 0);
5856
5857 #ifdef JP
5858         /* "no more" の場合はこちらで表示を分ける */
5859         if (o_ptr->number <= 0)
5860         {
5861                 msg_format("床上には、もう%sはない。", o_name);
5862         }
5863         else
5864         {
5865                 msg_format("床上には、まだ %sがある。", o_name);
5866         }
5867 #else
5868         msg_format("You see %s.", o_name);
5869 #endif
5870
5871 }
5872
5873
5874 /*!
5875  * @brief 床上のアイテムの数を増やす /
5876  * Increase the "number" of an item on the floor
5877  * @param item 増やしたいアイテムの所持スロット
5878  * @param num 増やしたいアイテムの数
5879  * @return なし
5880  */
5881 void floor_item_increase(INVENTORY_IDX item, int num)
5882 {
5883         object_type *o_ptr = &o_list[item];
5884
5885         /* Apply */
5886         num += o_ptr->number;
5887
5888         /* Bounds check */
5889         if (num > 255) num = 255;
5890         else if (num < 0) num = 0;
5891
5892         /* Un-apply */
5893         num -= (int)o_ptr->number;
5894
5895         /* Change the number */
5896         o_ptr->number += (ITEM_NUMBER)num;
5897 }
5898
5899
5900 /*!
5901  * @brief 床上の数の無くなったアイテムスロットを消去する /
5902  * Optimize an item on the floor (destroy "empty" items)
5903  * @param item 消去したいアイテムの所持スロット
5904  * @return なし
5905  */
5906 void floor_item_optimize(INVENTORY_IDX item)
5907 {
5908         object_type *o_ptr = &o_list[item];
5909
5910         /* Paranoia -- be sure it exists */
5911         if (!o_ptr->k_idx) return;
5912
5913         /* Only optimize empty items */
5914         if (o_ptr->number) return;
5915
5916         delete_object_idx(item);
5917 }
5918
5919
5920 /*!
5921  * @brief アイテムを拾う際にザックから溢れずに済むかを判定する /
5922  * Check if we have space for an item in the pack without overflow
5923  * @param o_ptr 拾いたいオブジェクトの構造体参照ポインタ
5924  * @return 溢れずに済むならTRUEを返す
5925  */
5926 bool inven_carry_okay(object_type *o_ptr)
5927 {
5928         int j;
5929
5930         /* Empty slot? */
5931         if (inven_cnt < INVEN_PACK) return (TRUE);
5932
5933         /* Similar slot? */
5934         for (j = 0; j < INVEN_PACK; j++)
5935         {
5936                 object_type *j_ptr = &inventory[j];
5937
5938                 /* Skip non-objects */
5939                 if (!j_ptr->k_idx) continue;
5940
5941                 /* Check if the two items can be combined */
5942                 if (object_similar(j_ptr, o_ptr)) return (TRUE);
5943         }
5944
5945         return (FALSE);
5946 }
5947
5948 /*!
5949  * @brief オブジェクトを定義された基準に従いソートするための関数 /
5950  * Check if we have space for an item in the pack without overflow
5951  * @param o_ptr 比較対象オブジェクトの構造体参照ポインタ1
5952  * @param o_value o_ptrのアイテム価値（手動であらかじめ代入する必要がある？）
5953  * @param j_ptr 比較対象オブジェクトの構造体参照ポインタ2
5954  * @return o_ptrの方が上位ならばTRUEを返す。
5955  */
5956 bool object_sort_comp(object_type *o_ptr, s32b o_value, object_type *j_ptr)
5957 {
5958         int o_type, j_type;
5959
5960         /* Use empty slots */
5961         if (!j_ptr->k_idx) return TRUE;
5962
5963         /* Hack -- readable books always come first */
5964         if ((o_ptr->tval == REALM1_BOOK) &&
5965             (j_ptr->tval != REALM1_BOOK)) return TRUE;
5966         if ((j_ptr->tval == REALM1_BOOK) &&
5967             (o_ptr->tval != REALM1_BOOK)) return FALSE;
5968
5969         if ((o_ptr->tval == REALM2_BOOK) &&
5970             (j_ptr->tval != REALM2_BOOK)) return TRUE;
5971         if ((j_ptr->tval == REALM2_BOOK) &&
5972             (o_ptr->tval != REALM2_BOOK)) return FALSE;
5973
5974         /* Objects sort by decreasing type */
5975         if (o_ptr->tval > j_ptr->tval) return TRUE;
5976         if (o_ptr->tval < j_ptr->tval) return FALSE;
5977
5978         /* Non-aware (flavored) items always come last */
5979         /* Can happen in the home */
5980         if (!object_is_aware(o_ptr)) return FALSE;
5981         if (!object_is_aware(j_ptr)) return TRUE;
5982
5983         /* Objects sort by increasing sval */
5984         if (o_ptr->sval < j_ptr->sval) return TRUE;
5985         if (o_ptr->sval > j_ptr->sval) return FALSE;
5986
5987         /* Unidentified objects always come last */
5988         /* Objects in the home can be unknown */
5989         if (!object_is_known(o_ptr)) return FALSE;
5990         if (!object_is_known(j_ptr)) return TRUE;
5991
5992         /* Fixed artifacts, random artifacts and ego items */
5993         if (object_is_fixed_artifact(o_ptr)) o_type = 3;
5994         else if (o_ptr->art_name) o_type = 2;
5995         else if (object_is_ego(o_ptr)) o_type = 1;
5996         else o_type = 0;
5997
5998         if (object_is_fixed_artifact(j_ptr)) j_type = 3;
5999         else if (j_ptr->art_name) j_type = 2;
6000         else if (object_is_ego(j_ptr)) j_type = 1;
6001         else j_type = 0;
6002
6003         if (o_type < j_type) return TRUE;
6004         if (o_type > j_type) return FALSE;
6005
6006         switch (o_ptr->tval)
6007         {
6008         case TV_FIGURINE:
6009         case TV_STATUE:
6010         case TV_CORPSE:
6011         case TV_CAPTURE:
6012                 if (r_info[o_ptr->pval].level < r_info[j_ptr->pval].level) return TRUE;
6013                 if ((r_info[o_ptr->pval].level == r_info[j_ptr->pval].level) && (o_ptr->pval < j_ptr->pval)) return TRUE;
6014                 return FALSE;
6015
6016         case TV_SHOT:
6017         case TV_ARROW:
6018         case TV_BOLT:
6019                 /* Objects sort by increasing hit/damage bonuses */
6020                 if (o_ptr->to_h + o_ptr->to_d < j_ptr->to_h + j_ptr->to_d) return TRUE;
6021                 if (o_ptr->to_h + o_ptr->to_d > j_ptr->to_h + j_ptr->to_d) return FALSE;
6022                 break;
6023
6024         /* Hack:  otherwise identical rods sort by
6025         increasing recharge time --dsb */
6026         case TV_ROD:
6027                 if (o_ptr->pval < j_ptr->pval) return TRUE;
6028                 if (o_ptr->pval > j_ptr->pval) return FALSE;
6029                 break;
6030         }
6031
6032         /* Objects sort by decreasing value */
6033         return o_value > object_value(j_ptr);
6034 }
6035
6036
6037 /*!
6038  * @brief オブジェクトをプレイヤーが拾って所持スロットに納めるメインルーチン /
6039  * Add an item to the players inventory, and return the slot used.
6040  * @param o_ptr 拾うオブジェクトの構造体参照ポインタ
6041  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
6042  * @details
6043  * If the new item can combine with an existing item in the inventory,\n
6044  * it will do so, using "object_similar()" and "object_absorb()", else,\n
6045  * the item will be placed into the "proper" location in the inventory.\n
6046  *\n
6047  * This function can be used to "over-fill" the player's pack, but only\n
6048  * once, and such an action must trigger the "overflow" code immediately.\n
6049  * Note that when the pack is being "over-filled", the new item must be\n
6050  * placed into the "overflow" slot, and the "overflow" must take place\n
6051  * before the pack is reordered, but (optionally) after the pack is\n
6052  * combined.  This may be tricky.  See "dungeon.c" for info.\n
6053  *\n
6054  * Note that this code must remove any location/stack information\n
6055  * from the object once it is placed into the inventory.\n
6056  */
6057 s16b inven_carry(object_type *o_ptr)
6058 {
6059         INVENTORY_IDX i, j, k;
6060         INVENTORY_IDX n = -1;
6061
6062         object_type *j_ptr;
6063
6064
6065         /* Check for combining */
6066         for (j = 0; j < INVEN_PACK; j++)
6067         {
6068                 j_ptr = &inventory[j];
6069
6070                 /* Skip non-objects */
6071                 if (!j_ptr->k_idx) continue;
6072
6073                 /* Hack -- track last item */
6074                 n = j;
6075
6076                 /* Check if the two items can be combined */
6077                 if (object_similar(j_ptr, o_ptr))
6078                 {
6079                         /* Combine the items */
6080                         object_absorb(j_ptr, o_ptr);
6081
6082                         /* Increase the weight */
6083                         p_ptr->total_weight += (o_ptr->number * o_ptr->weight);
6084
6085                         /* Recalculate bonuses */
6086                         p_ptr->update |= (PU_BONUS);
6087
6088                         p_ptr->window |= (PW_INVEN);
6089
6090                         /* Success */
6091                         return (j);
6092                 }
6093         }
6094
6095
6096         /* Paranoia */
6097         if (inven_cnt > INVEN_PACK) return (-1);
6098
6099         /* Find an empty slot */
6100         for (j = 0; j <= INVEN_PACK; j++)
6101         {
6102                 j_ptr = &inventory[j];
6103
6104                 /* Use it if found */
6105                 if (!j_ptr->k_idx) break;
6106         }
6107
6108         /* Use that slot */
6109         i = j;
6110
6111
6112         /* Reorder the pack */
6113         if (i < INVEN_PACK)
6114         {
6115                 /* Get the "value" of the item */
6116                 s32b o_value = object_value(o_ptr);
6117
6118                 /* Scan every occupied slot */
6119                 for (j = 0; j < INVEN_PACK; j++)
6120                 {
6121                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
6122                 }
6123
6124                 /* Use that slot */
6125                 i = j;
6126
6127                 /* Slide objects */
6128                 for (k = n; k >= i; k--)
6129                 {
6130                         /* Hack -- Slide the item */
6131                         object_copy(&inventory[k+1], &inventory[k]);
6132                 }
6133
6134                 /* Wipe the empty slot */
6135                 object_wipe(&inventory[i]);
6136         }
6137
6138
6139         /* Copy the item */
6140         object_copy(&inventory[i], o_ptr);
6141
6142         /* Access new object */
6143         j_ptr = &inventory[i];
6144
6145         /* Forget stack */
6146         j_ptr->next_o_idx = 0;
6147
6148         /* Forget monster */
6149         j_ptr->held_m_idx = 0;
6150
6151         /* Forget location */
6152         j_ptr->iy = j_ptr->ix = 0;
6153
6154         /* Player touches it, and no longer marked */
6155         j_ptr->marked = OM_TOUCHED;
6156
6157         /* Increase the weight */
6158         p_ptr->total_weight += (j_ptr->number * j_ptr->weight);
6159
6160         /* Count the items */
6161         inven_cnt++;
6162
6163         /* Recalculate bonuses */
6164         p_ptr->update |= (PU_BONUS);
6165
6166         /* Combine and Reorder pack */
6167         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
6168
6169         p_ptr->window |= (PW_INVEN);
6170
6171         /* Return the slot */
6172         return (i);
6173 }
6174
6175
6176 /*!
6177  * @brief 装備スロットからオブジェクトを外すメインルーチン /
6178  * Take off (some of) a non-cursed equipment item
6179  * @param item オブジェクトを外したい所持テーブルのID
6180  * @param amt 外したい個数
6181  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
6182  * @details
6183  * Note that only one item at a time can be wielded per slot.\n
6184  * Note that taking off an item when "full" may cause that item\n
6185  * to fall to the ground.\n
6186  * Return the inventory slot into which the item is placed.\n
6187  */
6188 INVENTORY_IDX inven_takeoff(INVENTORY_IDX item, ITEM_NUMBER amt)
6189 {
6190         INVENTORY_IDX slot;
6191
6192         object_type forge;
6193         object_type *q_ptr;
6194
6195         object_type *o_ptr;
6196
6197         cptr act;
6198
6199         char o_name[MAX_NLEN];
6200
6201
6202         /* Get the item to take off */
6203         o_ptr = &inventory[item];
6204
6205         /* Paranoia */
6206         if (amt <= 0) return (-1);
6207
6208         /* Verify */
6209         if (amt > o_ptr->number) amt = o_ptr->number;
6210
6211         /* Get local object */
6212         q_ptr = &forge;
6213
6214         /* Obtain a local object */
6215         object_copy(q_ptr, o_ptr);
6216
6217         /* Modify quantity */
6218         q_ptr->number = amt;
6219
6220         object_desc(o_name, q_ptr, 0);
6221
6222         /* Took off weapon */
6223         if (((item == INVEN_RARM) || (item == INVEN_LARM)) &&
6224             object_is_melee_weapon(o_ptr))
6225         {
6226                 act = _("を装備からはずした", "You were wielding");
6227         }
6228
6229         /* Took off bow */
6230         else if (item == INVEN_BOW)
6231         {
6232                 act = _("を装備からはずした", "You were holding");
6233         }
6234
6235         /* Took off light */
6236         else if (item == INVEN_LITE)
6237         {
6238                 act = _("を光源からはずした", "You were holding");
6239         }
6240
6241         /* Took off something */
6242         else
6243         {
6244                 act = _("を装備からはずした", "You were wearing");
6245         }
6246
6247         /* Modify, Optimize */
6248         inven_item_increase(item, -amt);
6249         inven_item_optimize(item);
6250
6251         /* Carry the object */
6252         slot = inven_carry(q_ptr);
6253
6254 #ifdef JP
6255         msg_format("%s(%c)%s。", o_name, index_to_label(slot), act);
6256 #else
6257         msg_format("%s %s (%c).", act, o_name, index_to_label(slot));
6258 #endif
6259
6260
6261         /* Return slot */
6262         return (slot);
6263 }
6264
6265
6266 /*!
6267  * @brief 所持スロットから床下にオブジェクトを落とすメインルーチン /
6268  * Drop (some of) a non-cursed inventory/equipment item
6269  * @param item 所持テーブルのID
6270  * @param amt 落としたい個数
6271  * @return なし
6272  * @details
6273  * The object will be dropped "near" the current location
6274  */
6275 void inven_drop(INVENTORY_IDX item, ITEM_NUMBER amt)
6276 {
6277         object_type forge;
6278         object_type *q_ptr;
6279         object_type *o_ptr;
6280
6281         char o_name[MAX_NLEN];
6282
6283
6284         /* Access original object */
6285         o_ptr = &inventory[item];
6286
6287         /* Error check */
6288         if (amt <= 0) return;
6289
6290         /* Not too many */
6291         if (amt > o_ptr->number) amt = o_ptr->number;
6292
6293
6294         /* Take off equipment */
6295         if (item >= INVEN_RARM)
6296         {
6297                 /* Take off first */
6298                 item = inven_takeoff(item, amt);
6299
6300                 /* Access original object */
6301                 o_ptr = &inventory[item];
6302         }
6303
6304
6305         /* Get local object */
6306         q_ptr = &forge;
6307
6308         /* Obtain local object */
6309         object_copy(q_ptr, o_ptr);
6310
6311         /* Distribute charges of wands or rods */
6312         distribute_charges(o_ptr, q_ptr, amt);
6313
6314         /* Modify quantity */
6315         q_ptr->number = amt;
6316
6317         /* Describe local object */
6318         object_desc(o_name, q_ptr, 0);
6319
6320         msg_format(_("%s(%c)を落とした。", "You drop %s (%c)."), o_name, index_to_label(item));
6321
6322         /* Drop it near the player */
6323         (void)drop_near(q_ptr, 0, p_ptr->y, p_ptr->x);
6324
6325         /* Modify, Describe, Optimize */
6326         inven_item_increase(item, -amt);
6327         inven_item_describe(item);
6328         inven_item_optimize(item);
6329 }
6330
6331
6332 /*!
6333  * @brief プレイヤーの所持スロットに存在するオブジェクトをまとめなおす /
6334  * Combine items in the pack
6335  * @return なし
6336  * @details
6337  * Note special handling of the "overflow" slot
6338  */
6339 void combine_pack(void)
6340 {
6341         int             i, j, k;
6342         object_type     *o_ptr;
6343         object_type     *j_ptr;
6344         bool            flag = FALSE, combined;
6345
6346         do
6347         {
6348                 combined = FALSE;
6349
6350                 /* Combine the pack (backwards) */
6351                 for (i = INVEN_PACK; i > 0; i--)
6352                 {
6353                         o_ptr = &inventory[i];
6354
6355                         /* Skip empty items */
6356                         if (!o_ptr->k_idx) continue;
6357
6358                         /* Scan the items above that item */
6359                         for (j = 0; j < i; j++)
6360                         {
6361                                 int max_num;
6362
6363                                 j_ptr = &inventory[j];
6364
6365                                 /* Skip empty items */
6366                                 if (!j_ptr->k_idx) continue;
6367
6368                                 /*
6369                                  * Get maximum number of the stack if these
6370                                  * are similar, get zero otherwise.
6371                                  */
6372                                 max_num = object_similar_part(j_ptr, o_ptr);
6373
6374                                 /* Can we (partialy) drop "o_ptr" onto "j_ptr"? */
6375                                 if (max_num && j_ptr->number < max_num)
6376                                 {
6377                                         if (o_ptr->number + j_ptr->number <= max_num)
6378                                         {
6379                                                 /* Take note */
6380                                                 flag = TRUE;
6381
6382                                                 /* Add together the item counts */
6383                                                 object_absorb(j_ptr, o_ptr);
6384
6385                                                 /* One object is gone */
6386                                                 inven_cnt--;
6387
6388                                                 /* Slide everything down */
6389                                                 for (k = i; k < INVEN_PACK; k++)
6390                                                 {
6391                                                         /* Structure copy */
6392                                                         inventory[k] = inventory[k+1];
6393                                                 }
6394
6395                                                 /* Erase the "final" slot */
6396                                                 object_wipe(&inventory[k]);
6397                                         }
6398                                         else
6399                                         {
6400                                                 int old_num = o_ptr->number;
6401                                                 int remain = j_ptr->number + o_ptr->number - max_num;
6402 #if 0
6403                                                 o_ptr->number -= remain;
6404 #endif
6405                                                 /* Add together the item counts */
6406                                                 object_absorb(j_ptr, o_ptr);
6407
6408                                                 o_ptr->number = remain;
6409
6410                                                 /* Hack -- if rods are stacking, add the pvals (maximum timeouts) and current timeouts together. -LM- */
6411                                                 if (o_ptr->tval == TV_ROD)
6412                                                 {
6413                                                         o_ptr->pval =  o_ptr->pval * remain / old_num;
6414                                                         o_ptr->timeout = o_ptr->timeout * remain / old_num;
6415                                                 }
6416
6417                                                 /* Hack -- if wands are stacking, combine the charges. -LM- */
6418                                                 if (o_ptr->tval == TV_WAND)
6419                                                 {
6420                                                         o_ptr->pval = o_ptr->pval * remain / old_num;
6421                                                 }
6422                                         }
6423
6424                                         p_ptr->window |= (PW_INVEN);
6425
6426                                         /* Take note */
6427                                         combined = TRUE;
6428
6429                                         break;
6430                                 }
6431                         }
6432                 }
6433         }
6434         while (combined);
6435
6436         if (flag) msg_print(_("ザックの中のアイテムをまとめ直した。", "You combine some items in your pack."));
6437 }
6438
6439 /*!
6440  * @brief プレイヤーの所持スロットに存在するオブジェクトを並び替える /
6441  * Reorder items in the pack
6442  * @return なし
6443  * @details
6444  * Note special handling of the "overflow" slot
6445  */
6446 void reorder_pack(void)
6447 {
6448         int             i, j, k;
6449         s32b            o_value;
6450         object_type     forge;
6451         object_type     *q_ptr;
6452         object_type     *o_ptr;
6453         bool            flag = FALSE;
6454
6455
6456         /* Re-order the pack (forwards) */
6457         for (i = 0; i < INVEN_PACK; i++)
6458         {
6459                 /* Mega-Hack -- allow "proper" over-flow */
6460                 if ((i == INVEN_PACK) && (inven_cnt == INVEN_PACK)) break;
6461
6462                 o_ptr = &inventory[i];
6463
6464                 /* Skip empty slots */
6465                 if (!o_ptr->k_idx) continue;
6466
6467                 /* Get the "value" of the item */
6468                 o_value = object_value(o_ptr);
6469
6470                 /* Scan every occupied slot */
6471                 for (j = 0; j < INVEN_PACK; j++)
6472                 {
6473                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
6474                 }
6475
6476                 /* Never move down */
6477                 if (j >= i) continue;
6478
6479                 /* Take note */
6480                 flag = TRUE;
6481
6482                 /* Get local object */
6483                 q_ptr = &forge;
6484
6485                 /* Save a copy of the moving item */
6486                 object_copy(q_ptr, &inventory[i]);
6487
6488                 /* Slide the objects */
6489                 for (k = i; k > j; k--)
6490                 {
6491                         /* Slide the item */
6492                         object_copy(&inventory[k], &inventory[k-1]);
6493                 }
6494
6495                 /* Insert the moving item */
6496                 object_copy(&inventory[j], q_ptr);
6497
6498                 p_ptr->window |= (PW_INVEN);
6499         }
6500
6501         if (flag) msg_print(_("ザックの中のアイテムを並べ直した。", "You reorder some items in your pack."));
6502 }
6503
6504 /*!
6505  * @brief 現在アクティブになっているウィンドウにオブジェクトの詳細を表示する /
6506  * Hack -- display an object kind in the current window
6507  * @param k_idx ベースアイテムの参照ID
6508  * @return なし
6509  * @details
6510  * Include list of usable spells for readible books
6511  */
6512 void display_koff(KIND_OBJECT_IDX k_idx)
6513 {
6514         int y;
6515
6516         object_type forge;
6517         object_type *q_ptr;
6518         int         sval;
6519         REALM_IDX   use_realm;
6520
6521         char o_name[MAX_NLEN];
6522
6523
6524         /* Erase the window */
6525         for (y = 0; y < Term->hgt; y++)
6526         {
6527                 /* Erase the line */
6528                 Term_erase(0, y, 255);
6529         }
6530
6531         /* No info */
6532         if (!k_idx) return;
6533
6534         /* Get local object */
6535         q_ptr = &forge;
6536
6537         /* Prepare the object */
6538         object_prep(q_ptr, k_idx);
6539         object_desc(o_name, q_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY | OD_STORE));
6540
6541         /* Mention the object name */
6542         Term_putstr(0, 0, -1, TERM_WHITE, o_name);
6543
6544         /* Access the item's sval */
6545         sval = q_ptr->sval;
6546         use_realm = tval2realm(q_ptr->tval);
6547
6548         /* Warriors are illiterate */
6549         if (p_ptr->realm1 || p_ptr->realm2)
6550         {
6551                 if ((use_realm != p_ptr->realm1) && (use_realm != p_ptr->realm2)) return;
6552         }
6553         else
6554         {
6555                 if ((p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE)) return;
6556                 if (!is_magic(use_realm)) return;
6557                 if ((p_ptr->pclass == CLASS_RED_MAGE) && (use_realm != REALM_ARCANE) && (sval > 1)) return;
6558         }
6559
6560         /* Display spells in readible books */
6561         {
6562                 int     spell = -1;
6563                 int     num = 0;
6564                 SPELL_IDX    spells[64];
6565
6566                 /* Extract spells */
6567                 for (spell = 0; spell < 32; spell++)
6568                 {
6569                         /* Check for this spell */
6570                         if (fake_spell_flags[sval] & (1L << spell))
6571                         {
6572                                 /* Collect this spell */
6573                                 spells[num++] = spell;
6574                         }
6575                 }
6576
6577                 /* Print spells */
6578                 print_spells(0, spells, num, 2, 0, use_realm);
6579         }
6580 }
6581
6582 /*!
6583  * @brief 警告を放つアイテムを選択する /
6584  * Choose one of items that have warning flag
6585  * Calculate spell damages
6586  * @return 警告を行う
6587  */
6588 object_type *choose_warning_item(void)
6589 {
6590         int i;
6591         int choices[INVEN_TOTAL - INVEN_RARM];
6592         int number = 0;
6593
6594         /* Paranoia -- Player has no warning ability */
6595         if (!p_ptr->warning) return NULL;
6596
6597         /* Search Inventory */
6598         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
6599         {
6600                 BIT_FLAGS flgs[TR_FLAG_SIZE];
6601                 object_type *o_ptr = &inventory[i];
6602
6603                 object_flags(o_ptr, flgs);
6604                 if (have_flag(flgs, TR_WARNING))
6605                 {
6606                         choices[number] = i;
6607                         number++;
6608                 }
6609         }
6610
6611         /* Choice one of them */
6612         return number ? &inventory[choices[randint0(number)]] : NULL;
6613 }
6614
6615 /*!
6616  * @brief 警告基準を定めるために魔法の効果属性に基づいて最大魔法ダメージを計算する /
6617  * Calculate spell damages
6618  * @param m_ptr 魔法を行使するモンスターの構造体参照ポインタ
6619  * @param typ 効果属性のID
6620  * @param dam 基本ダメージ
6621  * @param max 算出した最大ダメージを返すポインタ
6622  * @return なし
6623  */
6624 static void spell_damcalc(monster_type *m_ptr, EFFECT_ID typ, HIT_POINT dam, int *max)
6625 {
6626         monster_race *r_ptr = &r_info[m_ptr->r_idx];
6627         int          rlev = r_ptr->level;
6628         bool         ignore_wraith_form = FALSE;
6629
6630         /* Vulnerability, resistance and immunity */
6631         switch (typ)
6632         {
6633         case GF_ELEC:
6634                 if (p_ptr->immune_elec)
6635                 {
6636                         dam = 0;
6637                         ignore_wraith_form = TRUE;
6638                 }
6639                 else
6640                 {
6641                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6642                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6643                         if (prace_is_(RACE_ANDROID)) dam += dam / 3;
6644                         if (p_ptr->resist_elec) dam = (dam + 2) / 3;
6645                         if (IS_OPPOSE_ELEC())
6646                                 dam = (dam + 2) / 3;
6647                 }
6648                 break;
6649
6650         case GF_POIS:
6651                 if (p_ptr->resist_pois) dam = (dam + 2) / 3;
6652                 if (IS_OPPOSE_POIS()) dam = (dam + 2) / 3;
6653                 break;
6654
6655         case GF_ACID:
6656                 if (p_ptr->immune_acid)
6657                 {
6658                         dam = 0;
6659                         ignore_wraith_form = TRUE;
6660                 }
6661                 else
6662                 {
6663                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6664                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6665                         if (p_ptr->resist_acid) dam = (dam + 2) / 3;
6666                         if (IS_OPPOSE_ACID()) dam = (dam + 2) / 3;
6667                 }
6668                 break;
6669
6670         case GF_COLD:
6671         case GF_ICE:
6672                 if (p_ptr->immune_cold)
6673                 {
6674                         dam = 0;
6675                         ignore_wraith_form = TRUE;
6676                 }
6677                 else
6678                 {
6679                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6680                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6681                         if (p_ptr->resist_cold) dam = (dam + 2) / 3;
6682                         if (IS_OPPOSE_COLD()) dam = (dam + 2) / 3;
6683                 }
6684                 break;
6685
6686         case GF_FIRE:
6687                 if (p_ptr->immune_fire)
6688                 {
6689                         dam = 0;
6690                         ignore_wraith_form = TRUE;
6691                 }
6692                 else
6693                 {
6694                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6695                         if (prace_is_(RACE_ENT)) dam += dam / 3;
6696                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6697                         if (p_ptr->resist_fire) dam = (dam + 2) / 3;
6698                         if (IS_OPPOSE_FIRE()) dam = (dam + 2) / 3;
6699                 }
6700                 break;
6701
6702         case GF_PSY_SPEAR:
6703                 ignore_wraith_form = TRUE;
6704                 break;
6705
6706         case GF_ARROW:
6707                 if (!p_ptr->blind &&
6708                     ((inventory[INVEN_RARM].k_idx && (inventory[INVEN_RARM].name1 == ART_ZANTETSU)) ||
6709                      (inventory[INVEN_LARM].k_idx && (inventory[INVEN_LARM].name1 == ART_ZANTETSU))))
6710                 {
6711                         dam = 0;
6712                         ignore_wraith_form = TRUE;
6713                 }
6714                 break;
6715
6716         case GF_LITE:
6717                 if (p_ptr->resist_lite) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6718                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE)) dam *= 2;
6719                 else if (prace_is_(RACE_S_FAIRY)) dam = dam * 4 / 3;
6720
6721                 /*
6722                  * Cannot use "ignore_wraith_form" strictly (for "random one damage")
6723                  * "dam *= 2;" for later "dam /= 2"
6724                  */
6725                 if (p_ptr->wraith_form) dam *= 2;
6726                 break;
6727
6728         case GF_DARK:
6729                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE) || p_ptr->wraith_form)
6730                 {
6731                         dam = 0;
6732                         ignore_wraith_form = TRUE;
6733                 }
6734                 else if (p_ptr->resist_dark) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6735                 break;
6736
6737         case GF_SHARDS:
6738                 if (p_ptr->resist_shard) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6739                 break;
6740
6741         case GF_SOUND:
6742                 if (p_ptr->resist_sound) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6743                 break;
6744
6745         case GF_CONFUSION:
6746                 if (p_ptr->resist_conf) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6747                 break;
6748
6749         case GF_CHAOS:
6750                 if (p_ptr->resist_chaos) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6751                 break;
6752
6753         case GF_NETHER:
6754                 if (prace_is_(RACE_SPECTRE))
6755                 {
6756                         dam = 0;
6757                         ignore_wraith_form = TRUE;
6758                 }
6759                 else if (p_ptr->resist_neth) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6760                 break;
6761
6762         case GF_DISENCHANT:
6763                 if (p_ptr->resist_disen) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6764                 break;
6765
6766         case GF_NEXUS:
6767                 if (p_ptr->resist_nexus) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6768                 break;
6769
6770         case GF_TIME:
6771                 if (p_ptr->resist_time) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6772                 break;
6773
6774         case GF_GRAVITY:
6775                 if (p_ptr->levitation) dam = (dam * 2) / 3;
6776                 break;
6777
6778         case GF_ROCKET:
6779                 if (p_ptr->resist_shard) dam /= 2;
6780                 break;
6781
6782         case GF_NUKE:
6783                 if (p_ptr->resist_pois) dam = (2 * dam + 2) / 5;
6784                 if (IS_OPPOSE_POIS()) dam = (2 * dam + 2) / 5;
6785                 break;
6786
6787         case GF_DEATH_RAY:
6788                 if (p_ptr->mimic_form)
6789                 {
6790                         if (mimic_info[p_ptr->mimic_form].MIMIC_FLAGS & MIMIC_IS_NONLIVING)
6791                         {
6792                                 dam = 0;
6793                                 ignore_wraith_form = TRUE;
6794                         }
6795                 }
6796                 else
6797                 {
6798                         switch (p_ptr->prace)
6799                         {
6800                         case RACE_GOLEM:
6801                         case RACE_SKELETON:
6802                         case RACE_ZOMBIE:
6803                         case RACE_VAMPIRE:
6804                         case RACE_DEMON:
6805                         case RACE_SPECTRE:
6806                                 dam = 0;
6807                                 ignore_wraith_form = TRUE;
6808                                 break;
6809                         }
6810                 }
6811                 break;
6812
6813         case GF_HOLY_FIRE:
6814                 if (p_ptr->align > 10) dam /= 2;
6815                 else if (p_ptr->align < -10) dam *= 2;
6816                 break;
6817
6818         case GF_HELL_FIRE:
6819                 if (p_ptr->align > 10) dam *= 2;
6820                 break;
6821
6822         case GF_MIND_BLAST:
6823         case GF_BRAIN_SMASH:
6824                 if (100 + rlev / 2 <= MAX(5, p_ptr->skill_sav))
6825                 {
6826                         dam = 0;
6827                         ignore_wraith_form = TRUE;
6828                 }
6829                 break;
6830
6831         case GF_CAUSE_1:
6832         case GF_CAUSE_2:
6833         case GF_CAUSE_3:
6834         case GF_HAND_DOOM:
6835                 if (100 + rlev / 2 <= p_ptr->skill_sav)
6836                 {
6837                         dam = 0;
6838                         ignore_wraith_form = TRUE;
6839                 }
6840                 break;
6841
6842         case GF_CAUSE_4:
6843                 if ((100 + rlev / 2 <= p_ptr->skill_sav) && (m_ptr->r_idx != MON_KENSHIROU))
6844                 {
6845                         dam = 0;
6846                         ignore_wraith_form = TRUE;
6847                 }
6848                 break;
6849         }
6850
6851         if (p_ptr->wraith_form && !ignore_wraith_form)
6852         {
6853                 dam /= 2;
6854                 if (!dam) dam = 1;
6855         }
6856
6857         if (dam > *max) *max = dam;
6858 }
6859
6860 /*!
6861 * @brief 警告基準を定めるために魔法の効果属性に基づいて最大魔法ダメージを計算する。 /
6862 * Calculate spell damages
6863 * @param spell_num RF4ならRF4_SPELL_STARTのように32区切りのベースとなる数値
6864 * @param typ 効果属性のID
6865 * @param m_idx 魔法を行使するモンスターのID
6866 * @param max 算出した最大ダメージを返すポインタ
6867 * @return なし
6868 */
6869 void spell_damcalc_by_spellnum(int spell_num, EFFECT_ID typ, MONSTER_IDX m_idx, int *max)
6870 {
6871     monster_type *m_ptr = &m_list[m_idx];
6872     HIT_POINT dam = monspell_damage((spell_num), m_idx, DAM_MAX);
6873     spell_damcalc(m_ptr, typ, dam, max);
6874 }
6875
6876 /*!
6877  * @brief 警告基準を定めるためにモンスターの打撃最大ダメージを算出する /
6878  * Calculate blow damages
6879  * @param m_ptr 打撃を行使するモンスターの構造体参照ポインタ
6880  * @param blow_ptr モンスターの打撃能力の構造体参照ポインタ
6881  * @return 算出された最大ダメージを返す。
6882  */
6883 static int blow_damcalc(monster_type *m_ptr, monster_blow *blow_ptr)
6884 {
6885         int  dam = blow_ptr->d_dice * blow_ptr->d_side;
6886         int  dummy_max = 0;
6887         bool check_wraith_form = TRUE;
6888
6889         if (blow_ptr->method != RBM_EXPLODE)
6890         {
6891                 ARMOUR_CLASS ac = p_ptr->ac + p_ptr->to_a;
6892
6893                 switch (blow_ptr->effect)
6894                 {
6895                 case RBE_SUPERHURT:
6896                 {
6897                         int tmp_dam = dam - (dam * ((ac < 150) ? ac : 150) / 250);
6898                         dam = MAX(dam, tmp_dam * 2);
6899                         break;
6900                 }
6901
6902                 case RBE_HURT:
6903                 case RBE_SHATTER:
6904                         dam -= (dam * ((ac < 150) ? ac : 150) / 250);
6905                         break;
6906
6907                 case RBE_ACID:
6908                         spell_damcalc(m_ptr, GF_ACID, dam, &dummy_max);
6909                         dam = dummy_max;
6910                         check_wraith_form = FALSE;
6911                         break;
6912
6913                 case RBE_ELEC:
6914                         spell_damcalc(m_ptr, GF_ELEC, dam, &dummy_max);
6915                         dam = dummy_max;
6916                         check_wraith_form = FALSE;
6917                         break;
6918
6919                 case RBE_FIRE:
6920                         spell_damcalc(m_ptr, GF_FIRE, dam, &dummy_max);
6921                         dam = dummy_max;
6922                         check_wraith_form = FALSE;
6923                         break;
6924
6925                 case RBE_COLD:
6926                         spell_damcalc(m_ptr, GF_COLD, dam, &dummy_max);
6927                         dam = dummy_max;
6928                         check_wraith_form = FALSE;
6929                         break;
6930
6931                 case RBE_DR_MANA:
6932                         dam = 0;
6933                         check_wraith_form = FALSE;
6934                         break;
6935                 }
6936
6937                 if (check_wraith_form && p_ptr->wraith_form)
6938                 {
6939                         dam /= 2;
6940                         if (!dam) dam = 1;
6941                 }
6942         }
6943         else
6944         {
6945                 dam = (dam + 1) / 2;
6946                 spell_damcalc(m_ptr, mbe_info[blow_ptr->effect].explode_type, dam, &dummy_max);
6947                 dam = dummy_max;
6948         }
6949
6950         return dam;
6951 }
6952
6953 /*!
6954  * @brief プレイヤーが特定地点へ移動した場合に警告を発する処理 /
6955  * Examine the grid (xx,yy) and warn the player if there are any danger
6956  * @param xx 危険性を調査するマスのX座標
6957  * @param yy 危険性を調査するマスのY座標
6958  * @return 警告を無視して進むことを選択するかか問題が無ければTRUE、警告に従ったならFALSEを返す。
6959  */
6960 bool process_warning(POSITION xx, POSITION yy)
6961 {
6962         POSITION mx, my;
6963         cave_type *c_ptr;
6964         char o_name[MAX_NLEN];
6965
6966 #define WARNING_AWARE_RANGE 12
6967         int dam_max = 0;
6968         static int old_damage = 0;
6969
6970         for (mx = xx - WARNING_AWARE_RANGE; mx < xx + WARNING_AWARE_RANGE + 1; mx++)
6971         {
6972                 for (my = yy - WARNING_AWARE_RANGE; my < yy + WARNING_AWARE_RANGE + 1; my++)
6973                 {
6974                         int dam_max0 = 0;
6975                         monster_type *m_ptr;
6976                         monster_race *r_ptr;
6977
6978                         if (!in_bounds(my, mx) || (distance(my, mx, yy, xx) > WARNING_AWARE_RANGE)) continue;
6979
6980                         c_ptr = &cave[my][mx];
6981
6982                         if (!c_ptr->m_idx) continue;
6983
6984                         m_ptr = &m_list[c_ptr->m_idx];
6985
6986                         if (MON_CSLEEP(m_ptr)) continue;
6987                         if (!is_hostile(m_ptr)) continue;
6988
6989                         r_ptr = &r_info[m_ptr->r_idx];
6990
6991                         /* Monster spells (only powerful ones)*/
6992                         if (projectable(my, mx, yy, xx))
6993             {
6994                                 BIT_FLAGS f4 = r_ptr->flags4;
6995                                 BIT_FLAGS f5 = r_ptr->a_ability_flags1;
6996                                 BIT_FLAGS f6 = r_ptr->a_ability_flags2;
6997
6998                                 if (!(d_info[dungeon_type].flags1 & DF1_NO_MAGIC))
6999                                 {
7000                                         if (f4 & RF4_BA_CHAO) spell_damcalc_by_spellnum(MS_BALL_CHAOS, GF_CHAOS, c_ptr->m_idx, &dam_max0);
7001                                         if (f5 & RF5_BA_MANA) spell_damcalc_by_spellnum(MS_BALL_MANA, GF_MANA, c_ptr->m_idx, &dam_max0);
7002                                         if (f5 & RF5_BA_DARK) spell_damcalc_by_spellnum(MS_BALL_DARK, GF_DARK, c_ptr->m_idx, &dam_max0);
7003                                         if (f5 & RF5_BA_LITE) spell_damcalc_by_spellnum(MS_STARBURST, GF_LITE, c_ptr->m_idx, &dam_max0);
7004                                         if (f6 & RF6_HAND_DOOM) spell_damcalc_by_spellnum(MS_HAND_DOOM, GF_HAND_DOOM, c_ptr->m_idx, &dam_max0);
7005                                         if (f6 & RF6_PSY_SPEAR) spell_damcalc_by_spellnum(MS_PSY_SPEAR, GF_PSY_SPEAR, c_ptr->m_idx, &dam_max0);
7006                                 }
7007                                 if (f4 & RF4_ROCKET) spell_damcalc_by_spellnum(MS_ROCKET, GF_ROCKET, c_ptr->m_idx, &dam_max0);
7008                                 if (f4 & RF4_BR_ACID) spell_damcalc_by_spellnum(MS_BR_ACID, GF_ACID, c_ptr->m_idx, &dam_max0);
7009                                 if (f4 & RF4_BR_ELEC) spell_damcalc_by_spellnum(MS_BR_ELEC, GF_ELEC, c_ptr->m_idx, &dam_max0);
7010                                 if (f4 & RF4_BR_FIRE) spell_damcalc_by_spellnum(MS_BR_FIRE, GF_FIRE, c_ptr->m_idx, &dam_max0);
7011                                 if (f4 & RF4_BR_COLD) spell_damcalc_by_spellnum(MS_BR_COLD, GF_COLD, c_ptr->m_idx, &dam_max0);
7012                                 if (f4 & RF4_BR_POIS) spell_damcalc_by_spellnum(MS_BR_POIS, GF_POIS, c_ptr->m_idx, &dam_max0);
7013                                 if (f4 & RF4_BR_NETH) spell_damcalc_by_spellnum(MS_BR_NETHER, GF_NETHER, c_ptr->m_idx, &dam_max0);
7014                                 if (f4 & RF4_BR_LITE) spell_damcalc_by_spellnum(MS_BR_LITE, GF_LITE, c_ptr->m_idx, &dam_max0);
7015                                 if (f4 & RF4_BR_DARK) spell_damcalc_by_spellnum(MS_BR_DARK, GF_DARK, c_ptr->m_idx, &dam_max0);
7016                                 if (f4 & RF4_BR_CONF) spell_damcalc_by_spellnum(MS_BR_CONF, GF_CONFUSION, c_ptr->m_idx, &dam_max0);
7017                                 if (f4 & RF4_BR_SOUN) spell_damcalc_by_spellnum(MS_BR_SOUND, GF_SOUND, c_ptr->m_idx, &dam_max0);
7018                                 if (f4 & RF4_BR_CHAO) spell_damcalc_by_spellnum(MS_BR_CHAOS, GF_CHAOS, c_ptr->m_idx, &dam_max0);
7019                                 if (f4 & RF4_BR_DISE) spell_damcalc_by_spellnum(MS_BR_DISEN, GF_DISENCHANT, c_ptr->m_idx, &dam_max0);
7020                                 if (f4 & RF4_BR_NEXU) spell_damcalc_by_spellnum(MS_BR_NEXUS, GF_NEXUS, c_ptr->m_idx, &dam_max0);
7021                                 if (f4 & RF4_BR_TIME) spell_damcalc_by_spellnum(MS_BR_TIME, GF_TIME, c_ptr->m_idx, &dam_max0);
7022                                 if (f4 & RF4_BR_INER) spell_damcalc_by_spellnum(MS_BR_INERTIA, GF_INERTIAL, c_ptr->m_idx, &dam_max0);
7023                                 if (f4 & RF4_BR_GRAV) spell_damcalc_by_spellnum(MS_BR_GRAVITY, GF_GRAVITY, c_ptr->m_idx, &dam_max0);
7024                                 if (f4 & RF4_BR_SHAR) spell_damcalc_by_spellnum(MS_BR_SHARDS, GF_SHARDS, c_ptr->m_idx, &dam_max0);
7025                                 if (f4 & RF4_BR_PLAS) spell_damcalc_by_spellnum(MS_BR_PLASMA, GF_PLASMA, c_ptr->m_idx, &dam_max0);
7026                                 if (f4 & RF4_BR_WALL) spell_damcalc_by_spellnum(MS_BR_FORCE, GF_FORCE, c_ptr->m_idx, &dam_max0);
7027                                 if (f4 & RF4_BR_MANA) spell_damcalc_by_spellnum(MS_BR_MANA, GF_MANA, c_ptr->m_idx, &dam_max0);
7028                                 if (f4 & RF4_BR_NUKE) spell_damcalc_by_spellnum(MS_BR_NUKE, GF_NUKE, c_ptr->m_idx, &dam_max0);
7029                                 if (f4 & RF4_BR_DISI) spell_damcalc_by_spellnum(MS_BR_DISI, GF_DISINTEGRATE, c_ptr->m_idx, &dam_max0);
7030                         }
7031
7032                         /* Monster melee attacks */
7033                         if (!(r_ptr->flags1 & RF1_NEVER_BLOW) && !(d_info[dungeon_type].flags1 & DF1_NO_MELEE))
7034                         {
7035                                 if (mx <= xx + 1 && mx >= xx - 1 && my <= yy + 1 && my >= yy - 1)
7036                                 {
7037                                         int m;
7038                                         int dam_melee = 0;
7039                                         for (m = 0; m < 4; m++)
7040                                         {
7041                                                 /* Skip non-attacks */
7042                                                 if (!r_ptr->blow[m].method || (r_ptr->blow[m].method == RBM_SHOOT)) continue;
7043
7044                                                 /* Extract the attack info */
7045                                                 dam_melee += blow_damcalc(m_ptr, &r_ptr->blow[m]);
7046                                                 if (r_ptr->blow[m].method == RBM_EXPLODE) break;
7047                                         }
7048                                         if (dam_melee > dam_max0) dam_max0 = dam_melee;
7049                                 }
7050                         }
7051
7052                         /* Contribution from this monster */
7053                         dam_max += dam_max0;
7054                 }
7055         }
7056
7057         /* Prevent excessive warning */
7058         if (dam_max > old_damage)
7059         {
7060                 old_damage = dam_max * 3 / 2;
7061
7062                 if (dam_max > p_ptr->chp / 2)
7063                 {
7064                         object_type *o_ptr = choose_warning_item();
7065
7066                         if (o_ptr)
7067                 object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7068             else
7069                 strcpy(o_name, _("体", "body")); /* Warning ability without item */
7070             msg_format(_("%sが鋭く震えた！", "Your %s pulsates sharply!"), o_name);
7071
7072                         disturb(FALSE, TRUE);
7073             return get_check(_("本当にこのまま進むか？", "Really want to go ahead? "));
7074                 }
7075         }
7076         else old_damage = old_damage / 2;
7077
7078         c_ptr = &cave[yy][xx];
7079         if (((!easy_disarm && is_trap(c_ptr->feat))
7080             || (c_ptr->mimic && is_trap(c_ptr->feat))) && !one_in_(13))
7081         {
7082                 object_type *o_ptr = choose_warning_item();
7083
7084                 if (o_ptr)
7085             object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7086         else
7087             strcpy(o_name, _("体", "body")); /* Warning ability without item */
7088         msg_format(_("%sが鋭く震えた！", "Your %s pulsates sharply!"), o_name);
7089                 disturb(FALSE, TRUE);
7090         return get_check(_("本当にこのまま進むか？", "Really want to go ahead? "));
7091         }
7092
7093         return TRUE;
7094 }
7095
7096 /*!
7097  * エッセンス情報の構造体 / A structure for smithing
7098  */
7099 typedef struct {
7100         int add;       /* TR flag number or special essence id */
7101         cptr add_name; /* Name of this ability */
7102         ESSENCE_IDX type;      /* Menu number */
7103         int essence;   /* Index for carrying essences */
7104         int value;     /* Needed value to add this ability */
7105 } essence_type;
7106
7107
7108 /*!
7109  * エッセンス情報テーブル Smithing type data for Weapon smith
7110  */
7111 #ifdef JP
7112 static essence_type essence_info[] =
7113 {
7114         {TR_STR, "腕力", 4, TR_STR, 20},
7115         {TR_INT, "知能", 4, TR_INT, 20},
7116         {TR_WIS, "賢さ", 4, TR_WIS, 20},
7117         {TR_DEX, "器用さ", 4, TR_DEX, 20},
7118         {TR_CON, "耐久力", 4, TR_CON, 20},
7119         {TR_CHR, "魅力", 4, TR_CHR, 20},
7120         {TR_MAGIC_MASTERY, "魔力支配", 4, TR_MAGIC_MASTERY, 20},
7121         {TR_STEALTH, "隠密", 4, TR_STEALTH, 40},
7122         {TR_SEARCH, "探索", 4, TR_SEARCH, 15},
7123         {TR_INFRA, "赤外線視力", 4, TR_INFRA, 15},
7124         {TR_TUNNEL, "採掘", 4, TR_TUNNEL, 15},
7125         {TR_SPEED, "スピード", 4, TR_SPEED, 12},
7126         {TR_BLOWS, "追加攻撃", 1, TR_BLOWS, 20},
7127         {TR_CHAOTIC, "カオス攻撃", 1, TR_CHAOTIC, 15},
7128         {TR_VAMPIRIC, "吸血攻撃", 1, TR_VAMPIRIC, 60},
7129         {TR_IMPACT, "地震発動", 7, TR_IMPACT, 15},
7130         {TR_BRAND_POIS, "毒殺", 1, TR_BRAND_POIS, 20},
7131         {TR_BRAND_ACID, "溶解", 1, TR_BRAND_ACID, 20},
7132         {TR_BRAND_ELEC, "電撃", 1, TR_BRAND_ELEC, 20},
7133         {TR_BRAND_FIRE, "焼棄", 1, TR_BRAND_FIRE, 20},
7134         {TR_BRAND_COLD, "凍結", 1, TR_BRAND_COLD, 20},
7135         {TR_SUST_STR, "腕力維持", 3, TR_SUST_STR, 15},
7136         {TR_SUST_INT, "知能維持", 3, TR_SUST_STR, 15},
7137         {TR_SUST_WIS, "賢さ維持", 3, TR_SUST_STR, 15},
7138         {TR_SUST_DEX, "器用さ維持", 3, TR_SUST_STR, 15},
7139         {TR_SUST_CON, "耐久力維持", 3, TR_SUST_STR, 15},
7140         {TR_SUST_CHR, "魅力維持", 3, TR_SUST_STR, 15},
7141         {TR_IM_ACID, "酸免疫", 2, TR_IM_ACID, 20},
7142         {TR_IM_ELEC, "電撃免疫", 2, TR_IM_ACID, 20},
7143         {TR_IM_FIRE, "火炎免疫", 2, TR_IM_ACID, 20},
7144         {TR_IM_COLD, "冷気免疫", 2, TR_IM_ACID, 20},
7145         {TR_REFLECT, "反射", 2, TR_REFLECT, 20},
7146         {TR_FREE_ACT, "麻痺知らず", 3, TR_FREE_ACT, 20},
7147         {TR_HOLD_EXP, "経験値維持", 3, TR_HOLD_EXP, 20},
7148         {TR_RES_ACID, "耐酸", 2, TR_RES_ACID, 15},
7149         {TR_RES_ELEC, "耐電撃", 2, TR_RES_ELEC, 15},
7150         {TR_RES_FIRE, "耐火炎", 2, TR_RES_FIRE, 15},
7151         {TR_RES_COLD, "耐冷気", 2, TR_RES_COLD, 15},
7152         {TR_RES_POIS, "耐毒", 2, TR_RES_POIS, 25},
7153         {TR_RES_FEAR, "耐恐怖", 2, TR_RES_FEAR, 20},
7154         {TR_RES_LITE, "耐閃光", 2, TR_RES_LITE, 20},
7155         {TR_RES_DARK, "耐暗黒", 2, TR_RES_DARK, 20},
7156         {TR_RES_BLIND, "耐盲目", 2, TR_RES_BLIND, 20},
7157         {TR_RES_CONF, "耐混乱", 2, TR_RES_CONF, 20},
7158         {TR_RES_SOUND, "耐轟音", 2, TR_RES_SOUND, 20},
7159         {TR_RES_SHARDS, "耐破片", 2, TR_RES_SHARDS, 20},
7160         {TR_RES_NETHER, "耐地獄", 2, TR_RES_NETHER, 20},
7161         {TR_RES_NEXUS, "耐因果混乱", 2, TR_RES_NEXUS, 20},
7162         {TR_RES_CHAOS, "耐カオス", 2, TR_RES_CHAOS, 20},
7163         {TR_RES_DISEN, "耐劣化", 2, TR_RES_DISEN, 20},
7164         {TR_SH_FIRE, "", 0, -2, 0},
7165         {TR_SH_ELEC, "", 0, -2, 0},
7166         {TR_SH_COLD, "", 0, -2, 0},
7167         {TR_NO_MAGIC, "反魔法", 3, TR_NO_MAGIC, 15},
7168         {TR_WARNING, "警告", 3, TR_WARNING, 20},
7169         {TR_LEVITATION, "浮遊", 3, TR_LEVITATION, 20},
7170         {TR_LITE_1, "永久光源", 3, TR_LITE_1, 15},
7171         {TR_LITE_2, "", 0, -2, 0},
7172         {TR_LITE_3, "", 0, -2, 0},
7173         {TR_SEE_INVIS, "可視透明", 3, TR_SEE_INVIS, 20},
7174         {TR_TELEPATHY, "テレパシー", 6, TR_TELEPATHY, 15},
7175         {TR_SLOW_DIGEST, "遅消化", 3, TR_SLOW_DIGEST, 15},
7176         {TR_REGEN, "急速回復", 3, TR_REGEN, 20},
7177         {TR_TELEPORT, "テレポート", 3, TR_TELEPORT, 25},
7178
7179         {TR_SLAY_EVIL, "邪悪倍打", 5, TR_SLAY_EVIL, 100},
7180         {TR_KILL_EVIL, "邪悪倍倍打", 0, TR_SLAY_EVIL, 60},
7181         {TR_SLAY_ANIMAL, "動物倍打", 5, TR_SLAY_ANIMAL, 20},
7182         {TR_KILL_ANIMAL, "動物倍倍打", 5, TR_SLAY_ANIMAL, 60},
7183         {TR_SLAY_UNDEAD, "不死倍打", 5, TR_SLAY_UNDEAD, 20},
7184         {TR_KILL_UNDEAD, "不死倍倍打", 5, TR_SLAY_UNDEAD, 60},
7185         {TR_SLAY_DEMON, "悪魔倍打", 5, TR_SLAY_DEMON, 20},
7186         {TR_KILL_DEMON, "悪魔倍倍打", 5, TR_SLAY_DEMON, 60},
7187         {TR_SLAY_ORC, "オーク倍打", 5, TR_SLAY_ORC, 15},
7188         {TR_KILL_ORC, "オーク倍倍打", 5, TR_SLAY_ORC, 60},
7189         {TR_SLAY_TROLL, "トロル倍打", 5, TR_SLAY_TROLL, 15},
7190         {TR_KILL_TROLL, "トロル倍倍打", 5, TR_SLAY_TROLL, 60},
7191         {TR_SLAY_GIANT, "巨人倍打", 5, TR_SLAY_GIANT, 20},
7192         {TR_KILL_GIANT, "巨人倍倍打", 5, TR_SLAY_GIANT, 60},
7193         {TR_SLAY_DRAGON, "竜倍打", 5, TR_SLAY_DRAGON, 20},
7194         {TR_KILL_DRAGON, "竜倍倍打", 5, TR_SLAY_DRAGON, 60},
7195         {TR_SLAY_HUMAN, "人間倍打", 5, TR_SLAY_HUMAN, 20},
7196         {TR_KILL_HUMAN, "人間倍倍打", 5, TR_SLAY_HUMAN, 60},
7197
7198         {TR_ESP_ANIMAL, "動物ESP", 6, TR_SLAY_ANIMAL, 40},
7199         {TR_ESP_UNDEAD, "不死ESP", 6, TR_SLAY_UNDEAD, 40},
7200         {TR_ESP_DEMON, "悪魔ESP", 6, TR_SLAY_DEMON, 40},
7201         {TR_ESP_ORC, "オークESP", 6, TR_SLAY_ORC, 40},
7202         {TR_ESP_TROLL, "トロルESP", 6, TR_SLAY_TROLL, 40},
7203         {TR_ESP_GIANT, "巨人ESP", 6, TR_SLAY_GIANT, 40},
7204         {TR_ESP_DRAGON, "竜ESP", 6, TR_SLAY_DRAGON, 40},
7205         {TR_ESP_HUMAN, "人間ESP", 6, TR_SLAY_HUMAN, 40},
7206
7207         {ESSENCE_ATTACK, "攻撃", 10, TR_ES_ATTACK, 30},
7208         {ESSENCE_AC, "防御", 10, TR_ES_AC, 15},
7209         {ESSENCE_TMP_RES_ACID, "酸耐性発動", 7, TR_RES_ACID, 50},
7210         {ESSENCE_TMP_RES_ELEC, "電撃耐性発動", 7, TR_RES_ELEC, 50},
7211         {ESSENCE_TMP_RES_FIRE, "火炎耐性発動", 7, TR_RES_FIRE, 50},
7212         {ESSENCE_TMP_RES_COLD, "冷気耐性発動", 7, TR_RES_COLD, 50},
7213         {ESSENCE_SH_FIRE, "火炎オーラ", 7, -1, 50},
7214         {ESSENCE_SH_ELEC, "電撃オーラ", 7, -1, 50},
7215         {ESSENCE_SH_COLD, "冷気オーラ", 7, -1, 50},
7216         {ESSENCE_RESISTANCE, "全耐性", 2, -1, 150},
7217         {ESSENCE_SUSTAIN, "装備保持", 10, -1, 10},
7218         {ESSENCE_SLAY_GLOVE, "殺戮の小手", 1, TR_ES_ATTACK, 200},
7219
7220         {-1, NULL, 0, -1, 0}
7221 };
7222 #else
7223 static essence_type essence_info[] =
7224 {
7225         {TR_STR, "strength", 4, TR_STR, 20},
7226         {TR_INT, "intelligence", 4, TR_INT, 20},
7227         {TR_WIS, "wisdom", 4, TR_WIS, 20},
7228         {TR_DEX, "dexterity", 4, TR_DEX, 20},
7229         {TR_CON, "constitution", 4, TR_CON, 20},
7230         {TR_CHR, "charisma", 4, TR_CHR, 20},
7231         {TR_MAGIC_MASTERY, "magic mastery", 4, TR_MAGIC_MASTERY, 20},
7232         {TR_STEALTH, "stealth", 4, TR_STEALTH, 40},
7233         {TR_SEARCH, "serching", 4, TR_SEARCH, 15},
7234         {TR_INFRA, "infravision", 4, TR_INFRA, 15},
7235         {TR_TUNNEL, "digging", 4, TR_TUNNEL, 15},
7236         {TR_SPEED, "speed", 4, TR_SPEED, 12},
7237         {TR_BLOWS, "extra attack", 1, TR_BLOWS, 20},
7238         {TR_CHAOTIC, "chaos brand", 1, TR_CHAOTIC, 15},
7239         {TR_VAMPIRIC, "vampiric brand", 1, TR_VAMPIRIC, 60},
7240         {TR_IMPACT, "quake activation", 7, TR_IMPACT, 15},
7241         {TR_BRAND_POIS, "poison brand", 1, TR_BRAND_POIS, 20},
7242         {TR_BRAND_ACID, "acid brand", 1, TR_BRAND_ACID, 20},
7243         {TR_BRAND_ELEC, "electric brand", 1, TR_BRAND_ELEC, 20},
7244         {TR_BRAND_FIRE, "fire brand", 1, TR_BRAND_FIRE, 20},
7245         {TR_BRAND_COLD, "cold brand", 1, TR_BRAND_COLD, 20},
7246         {TR_SUST_STR, "sustain strength", 3, TR_SUST_STR, 15},
7247         {TR_SUST_INT, "sustain intelligence", 3, TR_SUST_STR, 15},
7248         {TR_SUST_WIS, "sustain wisdom", 3, TR_SUST_STR, 15},
7249         {TR_SUST_DEX, "sustain dexterity", 3, TR_SUST_STR, 15},
7250         {TR_SUST_CON, "sustain constitution", 3, TR_SUST_STR, 15},
7251         {TR_SUST_CHR, "sustain charisma", 3, TR_SUST_STR, 15},
7252         {TR_IM_ACID, "acid immunity", 2, TR_IM_ACID, 20},
7253         {TR_IM_ELEC, "electric immunity", 2, TR_IM_ACID, 20},
7254         {TR_IM_FIRE, "fire immunity", 2, TR_IM_ACID, 20},
7255         {TR_IM_COLD, "cold immunity", 2, TR_IM_ACID, 20},
7256         {TR_REFLECT, "reflection", 2, TR_REFLECT, 20},
7257         {TR_FREE_ACT, "free action", 3, TR_FREE_ACT, 20},
7258         {TR_HOLD_EXP, "hold experience", 3, TR_HOLD_EXP, 20},
7259         {TR_RES_ACID, "resistance to acid", 2, TR_RES_ACID, 15},
7260         {TR_RES_ELEC, "resistance to electric", 2, TR_RES_ELEC, 15},
7261         {TR_RES_FIRE, "resistance to fire", 2, TR_RES_FIRE, 15},
7262         {TR_RES_COLD, "resistance to cold", 2, TR_RES_COLD, 15},
7263         {TR_RES_POIS, "resistance to poison", 2, TR_RES_POIS, 25},
7264         {TR_RES_FEAR, "resistance to fear", 2, TR_RES_FEAR, 20},
7265         {TR_RES_LITE, "resistance to light", 2, TR_RES_LITE, 20},
7266         {TR_RES_DARK, "resistance to dark", 2, TR_RES_DARK, 20},
7267         {TR_RES_BLIND, "resistance to blind", 2, TR_RES_BLIND, 20},
7268         {TR_RES_CONF, "resistance to confusion", 2, TR_RES_CONF, 20},
7269         {TR_RES_SOUND, "resistance to sound", 2, TR_RES_SOUND, 20},
7270         {TR_RES_SHARDS, "resistance to shard", 2, TR_RES_SHARDS, 20},
7271         {TR_RES_NETHER, "resistance to nether", 2, TR_RES_NETHER, 20},
7272         {TR_RES_NEXUS, "resistance to nexus", 2, TR_RES_NEXUS, 20},
7273         {TR_RES_CHAOS, "resistance to chaos", 2, TR_RES_CHAOS, 20},
7274         {TR_RES_DISEN, "resistance to disenchantment", 2, TR_RES_DISEN, 20},
7275         {TR_SH_FIRE, "", 0, -2, 0},
7276         {TR_SH_ELEC, "", 0, -2, 0},
7277         {TR_SH_COLD, "", 0, -2, 0},
7278         {TR_NO_MAGIC, "anti magic", 3, TR_NO_MAGIC, 15},
7279         {TR_WARNING, "warning", 3, TR_WARNING, 20},
7280         {TR_LEVITATION, "levitation", 3, TR_LEVITATION, 20},
7281         {TR_LITE_1, "permanent light", 3, TR_LITE_1, 15},
7282         {TR_LITE_2, "", 0, -2, 0},
7283         {TR_LITE_3, "", 0, -2, 0},
7284         {TR_SEE_INVIS, "see invisible", 3, TR_SEE_INVIS, 20},
7285         {TR_TELEPATHY, "telepathy", 6, TR_TELEPATHY, 15},
7286         {TR_SLOW_DIGEST, "slow digestion", 3, TR_SLOW_DIGEST, 15},
7287         {TR_REGEN, "regeneration", 3, TR_REGEN, 20},
7288         {TR_TELEPORT, "teleport", 3, TR_TELEPORT, 25},
7289
7290         {TR_SLAY_EVIL, "slay evil", 5, TR_SLAY_EVIL, 100},
7291         {TR_SLAY_ANIMAL, "slay animal", 5, TR_SLAY_ANIMAL, 20},
7292         {TR_KILL_ANIMAL, "kill animal", 5, TR_SLAY_ANIMAL, 60},
7293         {TR_KILL_EVIL, "kill evil", 0, TR_SLAY_EVIL, 60},
7294         {TR_SLAY_UNDEAD, "slay undead", 5, TR_SLAY_UNDEAD, 20},
7295         {TR_KILL_UNDEAD, "kill undead", 5, TR_SLAY_UNDEAD, 60},
7296         {TR_SLAY_DEMON, "slay demon", 5, TR_SLAY_DEMON, 20},
7297         {TR_KILL_DEMON, "kill demon", 5, TR_SLAY_DEMON, 60},
7298         {TR_SLAY_ORC, "slay orc", 5, TR_SLAY_ORC, 15},
7299         {TR_KILL_ORC, "kill orc", 5, TR_SLAY_ORC, 60},
7300         {TR_SLAY_TROLL, "slay troll", 5, TR_SLAY_TROLL, 15},
7301         {TR_KILL_TROLL, "kill troll", 5, TR_SLAY_TROLL, 60},
7302         {TR_SLAY_GIANT, "slay giant", 5, TR_SLAY_GIANT, 20},
7303         {TR_KILL_GIANT, "kill giant", 5, TR_SLAY_GIANT, 60},
7304         {TR_SLAY_DRAGON, "slay dragon", 5, TR_SLAY_DRAGON, 20},
7305         {TR_KILL_DRAGON, "kill dragon", 5, TR_SLAY_DRAGON, 60},
7306         {TR_SLAY_HUMAN, "slay human", 5, TR_SLAY_HUMAN, 20},
7307         {TR_KILL_HUMAN, "kill human", 5, TR_SLAY_HUMAN, 60},
7308
7309         {TR_ESP_ANIMAL, "sense animal", 6, TR_SLAY_ANIMAL, 40},
7310         {TR_ESP_UNDEAD, "sense undead", 6, TR_SLAY_UNDEAD, 40},
7311         {TR_ESP_DEMON, "sense demon", 6, TR_SLAY_DEMON, 40},
7312         {TR_ESP_ORC, "sense orc", 6, TR_SLAY_ORC, 40},
7313         {TR_ESP_TROLL, "sense troll", 6, TR_SLAY_TROLL, 40},
7314         {TR_ESP_GIANT, "sense giant", 6, TR_SLAY_GIANT, 40},
7315         {TR_ESP_DRAGON, "sense dragon", 6, TR_SLAY_DRAGON, 40},
7316         {TR_ESP_HUMAN, "sense human", 6, TR_SLAY_HUMAN, 40},
7317
7318         {ESSENCE_ATTACK, "weapon enchant", 10, TR_ES_ATTACK, 30},
7319         {ESSENCE_AC, "armor enchant", 10, TR_ES_AC, 15},
7320         {ESSENCE_TMP_RES_ACID, "resist acid activation", 7, TR_RES_ACID, 50},
7321         {ESSENCE_TMP_RES_ELEC, "resist electricity activation", 7, TR_RES_ELEC, 50},
7322         {ESSENCE_TMP_RES_FIRE, "resist fire activation", 7, TR_RES_FIRE, 50},
7323         {ESSENCE_TMP_RES_COLD, "resist cold activation", 7, TR_RES_COLD, 50},
7324         {ESSENCE_SH_FIRE, "fiery sheath", 7, -1, 50},
7325         {ESSENCE_SH_ELEC, "electric sheath", 7, -1, 50},
7326         {ESSENCE_SH_COLD, "sheath of coldness", 7, -1, 50},
7327         {ESSENCE_RESISTANCE, "resistance", 2, -1, 150},
7328         {ESSENCE_SUSTAIN, "elements proof", 10, -1, 10},
7329         {ESSENCE_SLAY_GLOVE, "gauntlets of slaying", 1, TR_ES_ATTACK, 200},
7330
7331         {-1, NULL, 0, -1, 0}
7332 };
7333 #endif
7334
7335
7336 /*!
7337  * エッセンス名テーブル / Essense names for Weapon smith
7338  */
7339 #ifdef JP
7340 cptr essence_name[] =
7341 {
7342         "腕力",
7343         "知能",
7344         "賢さ",
7345         "器用さ",
7346         "耐久力",
7347         "魅力",
7348         "魔力支配",
7349         "",
7350         "隠密",
7351         "探索",
7352         "赤外線視力",
7353         "採掘",
7354         "スピード",
7355         "追加攻撃",
7356         "カオス攻撃",
7357         "吸血攻撃",
7358         "動物倍打",
7359         "邪悪倍打",
7360         "不死倍打",
7361         "悪魔倍打",
7362         "オーク倍打",
7363         "トロル倍打",
7364         "巨人倍打",
7365         "竜倍打",
7366         "",
7367         "",
7368         "地震",
7369         "毒殺",
7370         "溶解",
7371         "電撃",
7372         "焼棄",
7373         "凍結",
7374         "能力維持",
7375         "",
7376         "",
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         NULL
7439 };
7440
7441 #else
7442
7443 cptr essence_name[] =
7444 {
7445         "strength",
7446         "intelligen.",
7447         "wisdom",
7448         "dexterity",
7449         "constitut.",
7450         "charisma",
7451         "magic mast.",
7452         "",
7453         "stealth",
7454         "serching",
7455         "infravision",
7456         "digging",
7457         "speed",
7458         "extra atk",
7459         "chaos brand",
7460         "vampiric",
7461         "slay animal",
7462         "slay evil",
7463         "slay undead",
7464         "slay demon",
7465         "slay orc",
7466         "slay troll",
7467         "slay giant",
7468         "slay dragon",
7469         "",
7470         "",
7471         "quake",
7472         "pois. brand",
7473         "acid brand",
7474         "elec. brand",
7475         "fire brand",
7476         "cold brand",
7477         "sustain",
7478         "",
7479         "",
7480         "",
7481         "",
7482         "",
7483         "",
7484         "",
7485         "immunity",
7486         "",
7487         "",
7488         "",
7489         "",
7490         "reflection",
7491         "free action",
7492         "hold exp",
7493         "res. acid",
7494         "res. elec.",
7495         "res. fire",
7496         "res. cold",
7497         "res. poison",
7498         "res. fear",
7499         "res. light",
7500         "res. dark",
7501         "res. blind",
7502         "res.confuse",
7503         "res. sound",
7504         "res. shard",
7505         "res. nether",
7506         "res. nexus",
7507         "res. chaos",
7508         "res. disen.",
7509         "",
7510         "",
7511         "slay human",
7512         "",
7513         "",
7514         "anti magic",
7515         "",
7516         "",
7517         "warning",
7518         "",
7519         "",
7520         "",
7521         "levitation",
7522         "perm. light",
7523         "see invis.",
7524         "telepathy",
7525         "slow dige.",
7526         "regen.",
7527         "",
7528         "",
7529         "",
7530         "",
7531         "",
7532         "",
7533         "",
7534         "",
7535         "teleport",
7536         "",
7537         "",
7538         "weapon enc.",
7539         "armor enc.",
7540
7541         NULL
7542 };
7543 #endif
7544
7545 /*!
7546  * @brief 所持しているエッセンス一覧を表示する
7547  * @return なし
7548  */
7549 static void display_essence(void)
7550 {
7551         int i, num = 0;
7552
7553         screen_save();
7554         for (i = 1; i < 22; i++)
7555         {
7556                 prt("",i,0);
7557         }
7558         prt(_("エッセンス   個数     エッセンス   個数     エッセンス   個数",
7559                   "Essence      Num      Essence      Num      Essence      Num "), 1, 8);
7560         for (i = 0; essence_name[i]; i++)
7561         {
7562                 if (!essence_name[i][0]) continue;
7563                 prt(format("%-11s %5d", essence_name[i], p_ptr->magic_num1[i]), 2+num%21, 8+num/21*22);
7564                 num++;
7565         }
7566         prt(_("現在所持しているエッセンス", "List of all essences you have."), 0, 0);
7567         (void)inkey();
7568         screen_load();
7569         return;
7570 }
7571
7572 /*!
7573  * @brief エッセンスの抽出処理
7574  * @return なし
7575  */
7576 static void drain_essence(void)
7577 {
7578         int drain_value[sizeof(p_ptr->magic_num1) / sizeof(s32b)];
7579         int i;
7580         OBJECT_IDX item;
7581         int dec = 4;
7582         bool observe = FALSE;
7583         int old_ds, old_dd, old_to_h, old_to_d, old_ac, old_to_a, old_pval, old_name2;
7584         TIME_EFFECT old_timeout;
7585         BIT_FLAGS old_flgs[TR_FLAG_SIZE], new_flgs[TR_FLAG_SIZE];
7586         object_type *o_ptr;
7587         cptr q, s;
7588         POSITION iy, ix;
7589         byte_hack marked;
7590         ITEM_NUMBER number;
7591         OBJECT_IDX next_o_idx;
7592         WEIGHT weight;
7593
7594         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7595                 drain_value[i] = 0;
7596
7597         item_tester_hook = object_is_weapon_armour_ammo;
7598         item_tester_no_ryoute = TRUE;
7599
7600         q = _("どのアイテムから抽出しますか？", "Extract from which item? ");
7601         s = _("抽出できるアイテムがありません。", "You have nothing you can extract from.");
7602
7603         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
7604
7605         /* Get the item (in the pack) */
7606         if (item >= 0)
7607         {
7608                 o_ptr = &inventory[item];
7609         }
7610
7611         /* Get the item (on the floor) */
7612         else
7613         {
7614                 o_ptr = &o_list[0 - item];
7615         }
7616
7617         if (object_is_known(o_ptr) && !object_is_nameless(o_ptr))
7618         {
7619                 char o_name[MAX_NLEN];
7620                 object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7621                 if (!get_check(format(_("本当に%sから抽出してよろしいですか？", "Really extract from %s? "), o_name))) return;
7622         }
7623
7624         p_ptr->energy_use = 100;
7625
7626         object_flags(o_ptr, old_flgs);
7627         if (have_flag(old_flgs, TR_KILL_DRAGON)) add_flag(old_flgs, TR_SLAY_DRAGON);
7628         if (have_flag(old_flgs, TR_KILL_ANIMAL)) add_flag(old_flgs, TR_SLAY_ANIMAL);
7629         if (have_flag(old_flgs, TR_KILL_EVIL)) add_flag(old_flgs, TR_SLAY_EVIL);
7630         if (have_flag(old_flgs, TR_KILL_UNDEAD)) add_flag(old_flgs, TR_SLAY_UNDEAD);
7631         if (have_flag(old_flgs, TR_KILL_DEMON)) add_flag(old_flgs, TR_SLAY_DEMON);
7632         if (have_flag(old_flgs, TR_KILL_ORC)) add_flag(old_flgs, TR_SLAY_ORC);
7633         if (have_flag(old_flgs, TR_KILL_TROLL)) add_flag(old_flgs, TR_SLAY_TROLL);
7634         if (have_flag(old_flgs, TR_KILL_GIANT)) add_flag(old_flgs, TR_SLAY_GIANT);
7635         if (have_flag(old_flgs, TR_KILL_HUMAN)) add_flag(old_flgs, TR_SLAY_HUMAN);
7636
7637         old_to_a = o_ptr->to_a;
7638         old_ac = o_ptr->ac;
7639         old_to_h = o_ptr->to_h;
7640         old_to_d = o_ptr->to_d;
7641         old_ds = o_ptr->ds;
7642         old_dd = o_ptr->dd;
7643         old_pval = o_ptr->pval;
7644         old_name2 = o_ptr->name2;
7645         old_timeout = o_ptr->timeout;
7646         if (o_ptr->curse_flags & (TRC_CURSED | TRC_HEAVY_CURSE | TRC_PERMA_CURSE)) dec--;
7647         if (have_flag(old_flgs, TR_ADD_L_CURSE)) dec--;
7648         if (have_flag(old_flgs, TR_ADD_H_CURSE)) dec--;
7649         if (have_flag(old_flgs, TR_AGGRAVATE)) dec--;
7650         if (have_flag(old_flgs, TR_NO_TELE)) dec--;
7651         if (have_flag(old_flgs, TR_DRAIN_EXP)) dec--;
7652         if (have_flag(old_flgs, TR_DRAIN_HP)) dec--;
7653         if (have_flag(old_flgs, TR_DRAIN_MANA)) dec--;
7654         if (have_flag(old_flgs, TR_CALL_ANIMAL)) dec--;
7655         if (have_flag(old_flgs, TR_CALL_DEMON)) dec--;
7656         if (have_flag(old_flgs, TR_CALL_DRAGON)) dec--;
7657         if (have_flag(old_flgs, TR_CALL_UNDEAD)) dec--;
7658         if (have_flag(old_flgs, TR_COWARDICE)) dec--;
7659         if (have_flag(old_flgs, TR_LOW_MELEE)) dec--;
7660         if (have_flag(old_flgs, TR_LOW_AC)) dec--;
7661         if (have_flag(old_flgs, TR_LOW_MAGIC)) dec--;
7662         if (have_flag(old_flgs, TR_FAST_DIGEST)) dec--;
7663         if (have_flag(old_flgs, TR_SLOW_REGEN)) dec--;
7664         if (have_flag(old_flgs, TR_TY_CURSE)) dec--;
7665
7666         iy = o_ptr->iy;
7667         ix = o_ptr->ix;
7668         next_o_idx = o_ptr->next_o_idx;
7669         marked = o_ptr->marked;
7670         weight = o_ptr->weight;
7671         number = o_ptr->number;
7672
7673         object_prep(o_ptr, o_ptr->k_idx);
7674
7675         o_ptr->iy=iy;
7676         o_ptr->ix=ix;
7677         o_ptr->next_o_idx=next_o_idx;
7678         o_ptr->marked=marked;
7679         o_ptr->number = number;
7680         if (o_ptr->tval == TV_DRAG_ARMOR) o_ptr->timeout = old_timeout;
7681         if (item >= 0) p_ptr->total_weight += (o_ptr->weight*o_ptr->number - weight*number);
7682         o_ptr->ident |= (IDENT_MENTAL);
7683         object_aware(o_ptr);
7684         object_known(o_ptr);
7685
7686         object_flags(o_ptr, new_flgs);
7687
7688         for (i = 0; essence_info[i].add_name; i++)
7689         {
7690                 essence_type *es_ptr = &essence_info[i];
7691                 PARAMETER_VALUE pval = 0;
7692
7693                 if (es_ptr->add < TR_FLAG_MAX && is_pval_flag(es_ptr->add) && old_pval)
7694                         pval = (have_flag(new_flgs, es_ptr->add)) ? old_pval - o_ptr->pval : old_pval;
7695
7696                 if (es_ptr->add < TR_FLAG_MAX &&
7697                     (!have_flag(new_flgs, es_ptr->add) || pval) &&
7698                     have_flag(old_flgs, es_ptr->add))
7699                 {
7700                         if (pval)
7701                         {
7702                                 drain_value[es_ptr->essence] += 10 * pval;
7703                         }
7704                         else if (es_ptr->essence != -2)
7705                         {
7706                                 drain_value[es_ptr->essence] += 10;
7707                         }
7708                         else if (es_ptr->add == TR_SH_FIRE)
7709                         {
7710                                 drain_value[TR_BRAND_FIRE] += 10;
7711                                 drain_value[TR_RES_FIRE] += 10;
7712                         }
7713                         else if (es_ptr->add == TR_SH_ELEC)
7714                         {
7715                                 drain_value[TR_BRAND_ELEC] += 10;
7716                                 drain_value[TR_RES_ELEC] += 10;
7717                         }
7718                         else if (es_ptr->add == TR_SH_COLD)
7719                         {
7720                                 drain_value[TR_BRAND_COLD] += 10;
7721                                 drain_value[TR_RES_COLD] += 10;
7722                         }
7723                         else if (es_ptr->add == TR_LITE_2)
7724                         {
7725                                 drain_value[TR_LITE_1] += 20;
7726                         }
7727                         else if (es_ptr->add == TR_LITE_3)
7728                         {
7729                                 drain_value[TR_LITE_1] += 30;
7730                         }
7731                 }
7732         }
7733
7734         if ((have_flag(old_flgs, TR_FORCE_WEAPON)) && !(have_flag(new_flgs, TR_FORCE_WEAPON)))
7735         {
7736                 drain_value[TR_INT] += 5;
7737                 drain_value[TR_WIS] += 5;
7738         }
7739         if ((have_flag(old_flgs, TR_VORPAL)) && !(have_flag(new_flgs, TR_VORPAL)))
7740         {
7741                 drain_value[TR_BRAND_POIS] += 5;
7742                 drain_value[TR_BRAND_ACID] += 5;
7743                 drain_value[TR_BRAND_ELEC] += 5;
7744                 drain_value[TR_BRAND_FIRE] += 5;
7745                 drain_value[TR_BRAND_COLD] += 5;
7746         }
7747         if ((have_flag(old_flgs, TR_DEC_MANA)) && !(have_flag(new_flgs, TR_DEC_MANA)))
7748         {
7749                 drain_value[TR_INT] += 10;
7750         }
7751         if ((have_flag(old_flgs, TR_XTRA_MIGHT)) && !(have_flag(new_flgs, TR_XTRA_MIGHT)))
7752         {
7753                 drain_value[TR_STR] += 10;
7754         }
7755         if ((have_flag(old_flgs, TR_XTRA_SHOTS)) && !(have_flag(new_flgs, TR_XTRA_SHOTS)))
7756         {
7757                 drain_value[TR_DEX] += 10;
7758         }
7759         if (old_name2 == EGO_2WEAPON)
7760         {
7761                 drain_value[TR_DEX] += 20;
7762         }
7763         if (object_is_weapon_ammo(o_ptr))
7764         {
7765                 if (old_ds > o_ptr->ds) drain_value[TR_ES_ATTACK] += (old_ds-o_ptr->ds)*10;
7766
7767                 if (old_dd > o_ptr->dd) drain_value[TR_ES_ATTACK] += (old_dd-o_ptr->dd)*10;
7768         }
7769         if (old_to_h > o_ptr->to_h) drain_value[TR_ES_ATTACK] += (old_to_h-o_ptr->to_h)*10;
7770         if (old_to_d > o_ptr->to_d) drain_value[TR_ES_ATTACK] += (old_to_d-o_ptr->to_d)*10;
7771         if (old_ac > o_ptr->ac) drain_value[TR_ES_AC] += (old_ac-o_ptr->ac)*10;
7772         if (old_to_a > o_ptr->to_a) drain_value[TR_ES_AC] += (old_to_a-o_ptr->to_a)*10;
7773
7774         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7775         {
7776                 drain_value[i] *= number;
7777                 drain_value[i] = drain_value[i] * dec / 4;
7778                 drain_value[i] = MAX(drain_value[i], 0);
7779                 if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) drain_value[i] /= 10;
7780                 if (drain_value[i])
7781                 {
7782                         observe = TRUE;
7783                 }
7784         }
7785         if (!observe)
7786         {
7787                 msg_print(_("エッセンスは抽出できませんでした。", "You were not able to extract any essence."));
7788         }
7789         else
7790         {
7791                 msg_print(_("抽出したエッセンス:", "Extracted essences:"));
7792
7793                 for (i = 0; essence_name[i]; i++)
7794                 {
7795                         if (!essence_name[i][0]) continue;
7796                         if (!drain_value[i]) continue;
7797
7798                         p_ptr->magic_num1[i] += drain_value[i];
7799                         p_ptr->magic_num1[i] = MIN(20000, p_ptr->magic_num1[i]);
7800                         msg_print(NULL);
7801                         msg_format("%s...%d%s", essence_name[i], drain_value[i], _("。", ". "));
7802                 }
7803         }
7804
7805         /* Apply autodestroy/inscription to the drained item */
7806         autopick_alter_item(item, TRUE);
7807
7808         /* Combine the pack */
7809         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
7810
7811         p_ptr->window |= (PW_INVEN);
7812 }
7813
7814 /*!
7815  * @brief 付加するエッセンスの大別を選択する
7816  * @return 選んだエッセンスの大別ID
7817  */
7818 static COMMAND_CODE choose_essence(void)
7819 {
7820         COMMAND_CODE mode = 0;
7821         char choice;
7822         COMMAND_CODE menu_line = (use_menu ? 1 : 0);
7823
7824 #ifdef JP
7825         cptr menu_name[] = {
7826                 "武器属性",
7827                 "耐性",
7828                 "能力",
7829                 "数値",
7830                 "スレイ",
7831                 "ESP",
7832                 "その他"
7833         };
7834 #else
7835         cptr menu_name[] = {
7836                 "Brand weapon",
7837                 "Resistance",
7838                 "Ability",
7839                 "Magic number",
7840                 "Slay",
7841                 "ESP",
7842                 "Others"
7843         };
7844 #endif
7845         const COMMAND_CODE mode_max = 7;
7846
7847         if (repeat_pull(&mode) && 1 <= mode && mode <= mode_max)
7848                 return mode;
7849         mode = 0;
7850         if (use_menu)
7851         {
7852                 screen_save();
7853
7854                 while(!mode)
7855                 {
7856                         int i;
7857                         for (i = 0; i < mode_max; i++)
7858 #ifdef JP
7859                                 prt(format(" %s %s", (menu_line == 1+i) ? "》" : "  ", menu_name[i]), 2 + i, 14);
7860                         prt("どの種類のエッセンス付加を行いますか？", 0, 0);
7861 #else
7862                                 prt(format(" %s %s", (menu_line == 1+i) ? "> " : "  ", menu_name[i]), 2 + i, 14);
7863                         prt("Choose from menu.", 0, 0);
7864 #endif
7865
7866                         choice = inkey();
7867                         switch(choice)
7868                         {
7869                         case ESCAPE:
7870                         case 'z':
7871                         case 'Z':
7872                                 screen_load();
7873                                 return 0;
7874                         case '2':
7875                         case 'j':
7876                         case 'J':
7877                                 menu_line++;
7878                                 break;
7879                         case '8':
7880                         case 'k':
7881                         case 'K':
7882                                 menu_line += mode_max - 1;
7883                                 break;
7884                         case '\r':
7885                         case '\n':
7886                         case 'x':
7887                         case 'X':
7888                                 mode = menu_line;
7889                                 break;
7890                         }
7891                         if (menu_line > mode_max) menu_line -= mode_max;
7892                 }
7893                 screen_load();
7894         }
7895         else
7896         {
7897                 screen_save();
7898                 while (!mode)
7899                 {
7900                         int i;
7901
7902                         for (i = 0; i < mode_max; i++)
7903                                 prt(format("  %c) %s", 'a' + i, menu_name[i]), 2 + i, 14);
7904
7905                         if (!get_com(_("何を付加しますか:", "Command :"), &choice, TRUE))
7906                         {
7907                                 screen_load();
7908                                 return 0;
7909                         }
7910
7911                         if (isupper(choice)) choice = (char)tolower(choice);
7912
7913                         if ('a' <= choice && choice <= 'a' + (char)mode_max - 1)
7914                                 mode = (int)choice - 'a' + 1;
7915                 }
7916                 screen_load();
7917         }
7918
7919         repeat_push(mode);
7920         return mode;
7921 }
7922
7923 /*!
7924  * @brief エッセンスを実際に付加する
7925  * @param mode エッセンスの大別ID
7926  * @return なし
7927  */
7928 static void add_essence(ESSENCE_IDX mode)
7929 {
7930         OBJECT_IDX item;
7931         int max_num = 0;
7932         COMMAND_CODE i;
7933         bool flag,redraw;
7934         char choice;
7935         cptr            q, s;
7936         object_type *o_ptr;
7937         int ask = TRUE;
7938         char out_val[160];
7939         int num[22];
7940         char o_name[MAX_NLEN];
7941         int use_essence;
7942         essence_type *es_ptr;
7943         bool able[22] = { 0 };
7944
7945         int menu_line = (use_menu ? 1 : 0);
7946
7947         for (i = 0; essence_info[i].add_name; i++)
7948         {
7949                 es_ptr = &essence_info[i];
7950
7951                 if (es_ptr->type != mode) continue;
7952                 num[max_num++] = i;
7953         }
7954
7955         if (!repeat_pull(&i) || i<0 || i>=max_num)
7956         {
7957
7958         /* Nothing chosen yet */
7959         flag = FALSE;
7960
7961         /* No redraw yet */
7962         redraw = FALSE;
7963
7964         /* Build a prompt */
7965         (void) strnfmt(out_val, 78, _("('*'で一覧, ESCで中断) どの能力を付加しますか？", "(*=List, ESC=exit) Add which ability? "));
7966         if (use_menu) screen_save();
7967
7968         /* Get a spell from the user */
7969
7970         choice = (always_show_list || use_menu) ? ESCAPE:1;
7971         while (!flag)
7972         {
7973                 if( choice==ESCAPE ) choice = ' ';
7974                 else if( !get_com(out_val, &choice, FALSE) )break;
7975
7976                 if (use_menu && choice != ' ')
7977                 {
7978                         switch(choice)
7979                         {
7980                                 case '0':
7981                                 {
7982                                         screen_load();
7983                                         return;
7984                                 }
7985
7986                                 case '8':
7987                                 case 'k':
7988                                 case 'K':
7989                                 {
7990                                         menu_line += (max_num-1);
7991                                         break;
7992                                 }
7993
7994                                 case '2':
7995                                 case 'j':
7996                                 case 'J':
7997                                 {
7998                                         menu_line++;
7999                                         break;
8000                                 }
8001
8002                                 case '4':
8003                                 case 'h':
8004                                 case 'H':
8005                                 {
8006                                         menu_line = 1;
8007                                         break;
8008                                 }
8009                                 case '6':
8010                                 case 'l':
8011                                 case 'L':
8012                                 {
8013                                         menu_line = max_num;
8014                                         break;
8015                                 }
8016
8017                                 case 'x':
8018                                 case 'X':
8019                                 case '\r':
8020                                 case '\n':
8021                                 {
8022                                         i = menu_line - 1;
8023                                         ask = FALSE;
8024                                         break;
8025                                 }
8026                         }
8027                         if (menu_line > max_num) menu_line -= max_num;
8028                 }
8029                 /* Request redraw */
8030                 if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask))
8031                 {
8032                         /* Show the list */
8033                         if (!redraw || use_menu)
8034                         {
8035                                 byte y, x = 10;
8036                                 int ctr;
8037                                 char dummy[80], dummy2[80];
8038                                 byte col;
8039
8040                                 strcpy(dummy, "");
8041
8042                                 /* Show list */
8043                                 redraw = TRUE;
8044
8045                                 /* Save the screen */
8046                                 if (!use_menu) screen_save();
8047
8048                                 for (y = 1; y < 24; y++)
8049                                         prt("", y, x);
8050
8051                                 /* Print header(s) */
8052 #ifdef JP
8053                                 prt(format("   %-43s %6s/%s", "能力(必要エッセンス)", "必要数", "所持数"), 1, x);
8054
8055 #else
8056                                 prt(format("   %-43s %6s/%s", "Ability (needed essence)", "Needs", "Possess"), 1, x);
8057 #endif
8058                                 /* Print list */
8059                                 for (ctr = 0; ctr < max_num; ctr++)
8060                                 {
8061                                         es_ptr = &essence_info[num[ctr]];
8062
8063                                         if (use_menu)
8064                                         {
8065                                                 if (ctr == (menu_line-1))
8066                                                         strcpy(dummy, _("》 ", ">  "));
8067                                                 else strcpy(dummy, "   ");
8068
8069                                         }
8070                                         /* letter/number for power selection */
8071                                         else
8072                                         {
8073                                                 sprintf(dummy, "%c) ",I2A(ctr));
8074                                         }
8075
8076                                         strcat(dummy, es_ptr->add_name);
8077
8078                                         col = TERM_WHITE;
8079                                         able[ctr] = TRUE;
8080
8081                                         if (es_ptr->essence != -1)
8082                                         {
8083                                                 strcat(dummy, format("(%s)", essence_name[es_ptr->essence]));
8084                                                 if (p_ptr->magic_num1[es_ptr->essence] < es_ptr->value) able[ctr] = FALSE;
8085                                         }
8086                                         else
8087                                         {
8088                                                 switch(es_ptr->add)
8089                                                 {
8090                                                 case ESSENCE_SH_FIRE:
8091                                                         strcat(dummy, _("(焼棄+耐火炎)", "(brand fire + res.fire)"));
8092                                                         if (p_ptr->magic_num1[TR_BRAND_FIRE] < es_ptr->value) able[ctr] = FALSE;
8093                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8094                                                         break;
8095                                                 case ESSENCE_SH_ELEC:
8096                                                         strcat(dummy, _("(電撃+耐電撃)", "(brand elec. + res. elec.)"));
8097                                                         if (p_ptr->magic_num1[TR_BRAND_ELEC] < es_ptr->value) able[ctr] = FALSE;
8098                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8099                                                         break;
8100                                                 case ESSENCE_SH_COLD:
8101                                                         strcat(dummy, _("(凍結+耐冷気)", "(brand cold + res. cold)"));
8102                                                         if (p_ptr->magic_num1[TR_BRAND_COLD] < es_ptr->value) able[ctr] = FALSE;
8103                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8104                                                         break;
8105                                                 case ESSENCE_RESISTANCE:
8106                                                         strcat(dummy, _("(耐火炎+耐冷気+耐電撃+耐酸)", "(r.fire+r.cold+r.elec+r.acid)"));
8107                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8108                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8109                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8110                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8111                                                         break;
8112                                                 case ESSENCE_SUSTAIN:
8113                                                         strcat(dummy, _("(耐火炎+耐冷気+耐電撃+耐酸)", "(r.fire+r.cold+r.elec+r.acid)"));
8114                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8115                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8116                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8117                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8118                                                         break;
8119                                                 }
8120                                         }
8121
8122                                         if (!able[ctr]) col = TERM_RED;
8123
8124                                         if (es_ptr->essence != -1)
8125                                         {
8126                                                 sprintf(dummy2, "%-49s %3d/%d", dummy, es_ptr->value, (int)p_ptr->magic_num1[es_ptr->essence]);
8127                                         }
8128                                         else
8129                                         {
8130                                                 sprintf(dummy2, "%-49s %3d/(\?\?)", dummy, es_ptr->value);
8131                                         }
8132
8133                                         c_prt(col, dummy2, ctr+2, x);
8134                                 }
8135                         }
8136
8137                         /* Hide the list */
8138                         else
8139                         {
8140                                 /* Hide list */
8141                                 redraw = FALSE;
8142
8143                                 /* Restore the screen */
8144                                 screen_load();
8145                         }
8146
8147                         /* Redo asking */
8148                         continue;
8149                 }
8150
8151                 if (!use_menu)
8152                 {
8153                         /* Note verify */
8154                         ask = (isupper(choice));
8155
8156                         /* Lowercase */
8157                         if (ask) choice = (char)tolower(choice);
8158
8159                         /* Extract request */
8160                         i = (islower(choice) ? A2I(choice) : -1);
8161                 }
8162
8163                 /* Totally Illegal */
8164                 if ((i < 0) || (i >= max_num) || !able[i])
8165                 {
8166                         bell();
8167                         continue;
8168                 }
8169
8170                 /* Verify it */
8171                 if (ask)
8172                 {
8173                         char tmp_val[160];
8174
8175                         /* Prompt */
8176                         (void) strnfmt(tmp_val, 78, _("%sを付加しますか？ ", "Add the abilitiy of %s? "), essence_info[num[i]].add_name);
8177
8178                         /* Belay that order */
8179                         if (!get_check(tmp_val)) continue;
8180                 }
8181
8182                 /* Stop the loop */
8183                 flag = TRUE;
8184         }
8185
8186         /* Restore the screen */
8187         if (redraw) screen_load();
8188
8189         if (!flag) return;
8190
8191         repeat_push(i);
8192         }
8193         es_ptr = &essence_info[num[i]];
8194
8195         if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8196                 item_tester_tval = TV_GLOVES;
8197         else if (mode == 1 || mode == 5)
8198                 item_tester_hook = item_tester_hook_melee_ammo;
8199         else if (es_ptr->add == ESSENCE_ATTACK)
8200                 item_tester_hook = object_allow_enchant_weapon;
8201         else if (es_ptr->add == ESSENCE_AC)
8202                 item_tester_hook = object_is_armour;
8203         else
8204                 item_tester_hook = object_is_weapon_armour_ammo;
8205         item_tester_no_ryoute = TRUE;
8206
8207         q = _("どのアイテムを改良しますか？", "Improve which item? ");
8208         s = _("改良できるアイテムがありません。", "You have nothing to improve.");
8209
8210         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8211
8212         /* Get the item (in the pack) */
8213         if (item >= 0)
8214         {
8215                 o_ptr = &inventory[item];
8216         }
8217
8218         /* Get the item (on the floor) */
8219         else
8220         {
8221                 o_ptr = &o_list[0 - item];
8222         }
8223
8224         if ((mode != 10) && (object_is_artifact(o_ptr) || object_is_smith(o_ptr)))
8225         {
8226                 msg_print(_("そのアイテムはこれ以上改良できない。", "This item is no more able to be improved."));
8227                 return;
8228         }
8229
8230         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8231
8232         use_essence = es_ptr->value;
8233         if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) use_essence = (use_essence+9)/10;
8234         if (o_ptr->number > 1)
8235         {
8236                 use_essence *= o_ptr->number;
8237                 msg_format(_("%d個あるのでエッセンスは%d必要です。", "It will take %d essences."), o_ptr->number, use_essence);
8238         }
8239
8240         if (es_ptr->essence != -1)
8241         {
8242                 if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8243                 {
8244                         msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8245                         return;
8246                 }
8247                 if (is_pval_flag(es_ptr->add))
8248                 {
8249                         if (o_ptr->pval < 0)
8250                         {
8251                                 msg_print(_("このアイテムの能力修正を強化することはできない。", "You cannot increase magic number of this item."));
8252                                 return;
8253                         }
8254                         else if (es_ptr->add == TR_BLOWS)
8255                         {
8256                                 if (o_ptr->pval > 1)
8257                                 {
8258                                         if (!get_check(_("修正値は1になります。よろしいですか？", "The magic number of this weapon will become 1. Are you sure? "))) return;
8259                                 }
8260
8261                                 o_ptr->pval = 1;
8262                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8263                         }
8264                         else if (o_ptr->pval > 0)
8265                         {
8266                                 use_essence *= o_ptr->pval;
8267                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8268                         }
8269                         else
8270                         {
8271                                 char tmp[80];
8272                                 char tmp_val[160];
8273                                 PARAMETER_VALUE pval;
8274                                 PARAMETER_VALUE limit = MIN(5, p_ptr->magic_num1[es_ptr->essence]/es_ptr->value);
8275
8276                                 sprintf(tmp, _("いくつ付加しますか？ (1-%d): ", "Enchant how many? (1-%d): "), limit);
8277                                 strcpy(tmp_val, "1");
8278
8279                                 if (!get_string(tmp, tmp_val, 1)) return;
8280                                 pval = (PARAMETER_VALUE)atoi(tmp_val);
8281                                 if (pval > limit) pval = limit;
8282                                 else if (pval < 1) pval = 1;
8283                                 o_ptr->pval += pval;
8284                                 use_essence *= pval;
8285                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8286                         }
8287
8288                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8289                         {
8290                                 msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8291                                 return;
8292                         }
8293                 }
8294                 else if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8295                 {
8296                         char tmp_val[160];
8297                         int val;
8298                         HIT_PROB get_to_h;
8299                         HIT_POINT get_to_d;
8300
8301                         strcpy(tmp_val, "1");
8302                         if (!get_string(format(_("いくつ付加しますか？ (1-%d):", "Enchant how many? (1-%d):"), p_ptr->lev/7+3), tmp_val, 2)) return;
8303                         val = atoi(tmp_val);
8304                         if (val > p_ptr->lev/7+3) val = p_ptr->lev/7+3;
8305                         else if (val < 1) val = 1;
8306                         use_essence *= val;
8307                         msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8308                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8309                         {
8310                                 msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8311                                 return;
8312                         }
8313                         get_to_h = ((val+1)/2+randint0(val/2+1));
8314                         get_to_d = ((val+1)/2+randint0(val/2+1));
8315                         o_ptr->xtra4 = (get_to_h<<8)+get_to_d;
8316                         o_ptr->to_h += get_to_h;
8317                         o_ptr->to_d += get_to_d;
8318                 }
8319                 p_ptr->magic_num1[es_ptr->essence] -= use_essence;
8320                 if (es_ptr->add == ESSENCE_ATTACK)
8321                 {
8322                         if ((o_ptr->to_h >= p_ptr->lev/5+5) && (o_ptr->to_d >= p_ptr->lev/5+5))
8323                         {
8324                                 msg_print(_("改良に失敗した。", "You failed to enchant."));
8325                                 p_ptr->energy_use = 100;
8326                                 return;
8327                         }
8328                         else
8329                         {
8330                                 if (o_ptr->to_h < p_ptr->lev/5+5) o_ptr->to_h++;
8331                                 if (o_ptr->to_d < p_ptr->lev/5+5) o_ptr->to_d++;
8332                         }
8333                 }
8334                 else if (es_ptr->add == ESSENCE_AC)
8335                 {
8336                         if (o_ptr->to_a >= p_ptr->lev/5+5)
8337                         {
8338                                 msg_print(_("改良に失敗した。", "You failed to enchant."));
8339                                 p_ptr->energy_use = 100;
8340                                 return;
8341                         }
8342                         else
8343                         {
8344                                 if (o_ptr->to_a < p_ptr->lev/5+5) o_ptr->to_a++;
8345                         }
8346                 }
8347                 else
8348                 {
8349                         o_ptr->xtra3 = es_ptr->add + 1;
8350                 }
8351         }
8352         else
8353         {
8354                 bool success = TRUE;
8355
8356                 switch(es_ptr->add)
8357                 {
8358                 case ESSENCE_SH_FIRE:
8359                         if ((p_ptr->magic_num1[TR_BRAND_FIRE] < use_essence) || (p_ptr->magic_num1[TR_RES_FIRE] < use_essence))
8360                         {
8361                                 success = FALSE;
8362                                 break;
8363                         }
8364                         p_ptr->magic_num1[TR_BRAND_FIRE] -= use_essence;
8365                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8366                         break;
8367                 case ESSENCE_SH_ELEC:
8368                         if ((p_ptr->magic_num1[TR_BRAND_ELEC] < use_essence) || (p_ptr->magic_num1[TR_RES_ELEC] < use_essence))
8369                         {
8370                                 success = FALSE;
8371                                 break;
8372                         }
8373                         p_ptr->magic_num1[TR_BRAND_ELEC] -= use_essence;
8374                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8375                         break;
8376                 case ESSENCE_SH_COLD:
8377                         if ((p_ptr->magic_num1[TR_BRAND_COLD] < use_essence) || (p_ptr->magic_num1[TR_RES_COLD] < use_essence))
8378                         {
8379                                 success = FALSE;
8380                                 break;
8381                         }
8382                         p_ptr->magic_num1[TR_BRAND_COLD] -= use_essence;
8383                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8384                         break;
8385                 case ESSENCE_RESISTANCE:
8386                 case ESSENCE_SUSTAIN:
8387                         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))
8388                         {
8389                                 success = FALSE;
8390                                 break;
8391                         }
8392                         p_ptr->magic_num1[TR_RES_ACID] -= use_essence;
8393                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8394                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8395                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8396                         break;
8397                 }
8398                 if (!success)
8399                 {
8400                         msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8401                         return;
8402                 }
8403                 if (es_ptr->add == ESSENCE_SUSTAIN)
8404                 {
8405                         add_flag(o_ptr->art_flags, TR_IGNORE_ACID);
8406                         add_flag(o_ptr->art_flags, TR_IGNORE_ELEC);
8407                         add_flag(o_ptr->art_flags, TR_IGNORE_FIRE);
8408                         add_flag(o_ptr->art_flags, TR_IGNORE_COLD);
8409                 }
8410                 else
8411                 {
8412                         o_ptr->xtra3 = es_ptr->add + 1;
8413                 }
8414         }
8415
8416         p_ptr->energy_use = 100;
8417
8418 #ifdef JP
8419         msg_format("%sに%sの能力を付加しました。", o_name, es_ptr->add_name);
8420 #else
8421         msg_format("You have added ability of %s to %s.", es_ptr->add_name, o_name);
8422 #endif
8423
8424         /* Combine the pack */
8425         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8426
8427         p_ptr->window |= (PW_INVEN);
8428 }
8429
8430 /*!
8431  * @brief エッセンスを消去する
8432  * @return なし
8433  */
8434 static void erase_essence(void)
8435 {
8436         OBJECT_IDX item;
8437         cptr q, s;
8438         object_type *o_ptr;
8439         char o_name[MAX_NLEN];
8440         BIT_FLAGS flgs[TR_FLAG_SIZE];
8441
8442         item_tester_hook = object_is_smith;
8443
8444         q = _("どのアイテムのエッセンスを消去しますか？", "Remove from which item? ");
8445         s = _("エッセンスを付加したアイテムがありません。", "You have nothing to remove essence.");
8446
8447         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8448
8449         /* Get the item (in the pack) */
8450         if (item >= 0)
8451         {
8452                 o_ptr = &inventory[item];
8453         }
8454
8455         /* Get the item (on the floor) */
8456         else
8457         {
8458                 o_ptr = &o_list[0 - item];
8459         }
8460
8461         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8462         if (!get_check(format(_("よろしいですか？ [%s]", "Are you sure? [%s]"), o_name))) return;
8463
8464         p_ptr->energy_use = 100;
8465
8466         if (o_ptr->xtra3 == 1+ESSENCE_SLAY_GLOVE)
8467         {
8468                 o_ptr->to_h -= (o_ptr->xtra4>>8);
8469                 o_ptr->to_d -= (o_ptr->xtra4 & 0x000f);
8470                 o_ptr->xtra4 = 0;
8471                 if (o_ptr->to_h < 0) o_ptr->to_h = 0;
8472                 if (o_ptr->to_d < 0) o_ptr->to_d = 0;
8473         }
8474         o_ptr->xtra3 = 0;
8475         object_flags(o_ptr, flgs);
8476         if (!(have_pval_flags(flgs))) o_ptr->pval = 0;
8477         msg_print(_("エッセンスを取り去った。", "You removed all essence you have added."));
8478
8479         /* Combine the pack */
8480         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8481
8482         p_ptr->window |= (PW_INVEN);
8483 }
8484
8485 /*!
8486  * @brief 鍛冶コマンドのメインルーチン
8487  * @param only_browse TRUEならばエッセンス一覧の表示のみを行う
8488  * @return なし
8489  */
8490 void do_cmd_kaji(bool only_browse)
8491 {
8492         COMMAND_CODE mode = 0;
8493         char choice;
8494
8495         COMMAND_CODE menu_line = (use_menu ? 1 : 0);
8496
8497         if (!only_browse)
8498         {
8499                 if (p_ptr->confused)
8500                 {
8501                         msg_print(_("混乱していて作業できない！", "You are too confused!"));
8502                         return;
8503                 }
8504                 if (p_ptr->blind)
8505                 {
8506                         msg_print(_("目が見えなくて作業できない！", "You are blind!"));
8507                         return;
8508                 }
8509                 if (p_ptr->image)
8510                 {
8511                         msg_print(_("うまく見えなくて作業できない！", "You are hallucinating!"));
8512                         return;
8513                 }
8514         }
8515
8516         if (!(repeat_pull(&mode) && 1 <= mode && mode <= 5))
8517         {
8518         if (only_browse) screen_save();
8519         do {
8520         if (!only_browse) screen_save();
8521         if (use_menu)
8522         {
8523                 while(!mode)
8524                 {
8525 #ifdef JP
8526                         prt(format(" %s エッセンス一覧", (menu_line == 1) ? "》" : "  "), 2, 14);
8527                         prt(format(" %s エッセンス抽出", (menu_line == 2) ? "》" : "  "), 3, 14);
8528                         prt(format(" %s エッセンス消去", (menu_line == 3) ? "》" : "  "), 4, 14);
8529                         prt(format(" %s エッセンス付加", (menu_line == 4) ? "》" : "  "), 5, 14);
8530                         prt(format(" %s 武器/防具強化", (menu_line == 5) ? "》" : "  "), 6, 14);
8531                         prt(format("どの種類の技術を%sますか？", only_browse ? "調べ" : "使い"), 0, 0);
8532 #else
8533                         prt(format(" %s List essences", (menu_line == 1) ? "> " : "  "), 2, 14);
8534                         prt(format(" %s Extract essence", (menu_line == 2) ? "> " : "  "), 3, 14);
8535                         prt(format(" %s Remove essence", (menu_line == 3) ? "> " : "  "), 4, 14);
8536                         prt(format(" %s Add essence", (menu_line == 4) ? "> " : "  "), 5, 14);
8537                         prt(format(" %s Enchant weapon/armor", (menu_line == 5) ? "> " : "  "), 6, 14);
8538                         prt(format("Choose command from menu."), 0, 0);
8539 #endif
8540                         choice = inkey();
8541                         switch(choice)
8542                         {
8543                         case ESCAPE:
8544                         case 'z':
8545                         case 'Z':
8546                                 screen_load();
8547                                 return;
8548                         case '2':
8549                         case 'j':
8550                         case 'J':
8551                                 menu_line++;
8552                                 break;
8553                         case '8':
8554                         case 'k':
8555                         case 'K':
8556                                 menu_line+= 4;
8557                                 break;
8558                         case '\r':
8559                         case '\n':
8560                         case 'x':
8561                         case 'X':
8562                                 mode = menu_line;
8563                                 break;
8564                         }
8565                         if (menu_line > 5) menu_line -= 5;
8566                 }
8567         }
8568
8569         else
8570         {
8571                 while (!mode)
8572                 {
8573                         prt(_("  a) エッセンス一覧", "  a) List essences"), 2, 14);
8574                         prt(_("  b) エッセンス抽出", "  b) Extract essence"), 3, 14);
8575                         prt(_("  c) エッセンス消去", "  c) Remove essence"), 4, 14);
8576                         prt(_("  d) エッセンス付加", "  d) Add essence"), 5, 14);
8577                         prt(_("  e) 武器/防具強化", "  e) Enchant weapon/armor"), 6, 14);
8578 #ifdef JP
8579                         if (!get_com(format("どの能力を%sますか:", only_browse ? "調べ" : "使い"), &choice, TRUE))
8580 #else
8581                         if (!get_com("Command :", &choice, TRUE))
8582 #endif
8583                         {
8584                                 screen_load();
8585                                 return;
8586                         }
8587                         switch (choice)
8588                         {
8589                         case 'A':
8590                         case 'a':
8591                                 mode = 1;
8592                                 break;
8593                         case 'B':
8594                         case 'b':
8595                                 mode = 2;
8596                                 break;
8597                         case 'C':
8598                         case 'c':
8599                                 mode = 3;
8600                                 break;
8601                         case 'D':
8602                         case 'd':
8603                                 mode = 4;
8604                                 break;
8605                         case 'E':
8606                         case 'e':
8607                                 mode = 5;
8608                                 break;
8609                         }
8610                 }
8611         }
8612
8613         if (only_browse)
8614         {
8615                 char temp[62*5];
8616                 int line, j;
8617
8618                 /* Clear lines, position cursor  (really should use strlen here) */
8619                 Term_erase(14, 21, 255);
8620                 Term_erase(14, 20, 255);
8621                 Term_erase(14, 19, 255);
8622                 Term_erase(14, 18, 255);
8623                 Term_erase(14, 17, 255);
8624                 Term_erase(14, 16, 255);
8625
8626                 roff_to_buf(kaji_tips[mode-1], 62, temp, sizeof(temp));
8627                 for(j=0, line = 17;temp[j];j+=(1+strlen(&temp[j])))
8628                 {
8629                         prt(&temp[j], line, 15);
8630                         line++;
8631                 }
8632                 mode = 0;
8633         }
8634         if (!only_browse) screen_load();
8635         } while (only_browse);
8636         repeat_push(mode);
8637         }
8638         switch(mode)
8639         {
8640                 case 1: display_essence();break;
8641                 case 2: drain_essence();break;
8642                 case 3: erase_essence();break;
8643                 case 4:
8644                         mode = choose_essence();
8645                         if (mode == 0)
8646                                 break;
8647                         add_essence(mode);
8648                         break;
8649                 case 5: add_essence(10);break;
8650         }
8651 }
8652
8653
8654 /*!
8655  * @brief 投擲時たいまつに投げやすい/焼棄/アンデッドスレイの特別効果を返す。
8656  * Torches have special abilities when they are flaming.
8657  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8658  * @param flgs 特別に追加するフラグを返す参照ポインタ
8659  * @return なし
8660  */
8661 void torch_flags(object_type *o_ptr, BIT_FLAGS *flgs)
8662 {
8663         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8664         {
8665                 if (o_ptr->xtra4 > 0)
8666                 {
8667                         add_flag(flgs, TR_BRAND_FIRE);
8668                         add_flag(flgs, TR_KILL_UNDEAD);
8669                         add_flag(flgs, TR_THROW);
8670                 }
8671         }
8672 }
8673
8674 /*!
8675  * @brief 投擲時たいまつにダイスを与える。
8676  * Torches have special abilities when they are flaming.
8677  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8678  * @param dd 特別なダイス数を返す参照ポインタ
8679  * @param ds 特別なダイス面数を返す参照ポインタ
8680  * @return なし
8681  */
8682 void torch_dice(object_type *o_ptr, DICE_NUMBER *dd, DICE_SID *ds)
8683 {
8684         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8685         {
8686                 if (o_ptr->xtra4 > 0)
8687                 {
8688                         (*dd) = 1;
8689                         (*ds) = 6;
8690                 }
8691         }
8692 }
8693
8694 /*!
8695  * @brief 投擲時命中したたいまつの寿命を縮める。
8696  * Torches have special abilities when they are flaming.
8697  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8698  * @return なし
8699  */
8700 void torch_lost_fuel(object_type *o_ptr)
8701 {
8702         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8703         {
8704                 o_ptr->xtra4 -= (FUEL_TORCH / 25);
8705                 if (o_ptr->xtra4 < 0) o_ptr->xtra4 = 0;
8706         }
8707 }