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