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