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
4781
4782         /* Chance of "special object" */
4783         prob = ((mode & AM_GOOD) ? 10 : 1000);
4784
4785         /* Base level for the object */
4786         base = ((mode & AM_GOOD) ? (object_level + 10) : object_level);
4787
4788
4789         /* Generate a special object, or a normal object */
4790         if (!one_in_(prob) || !make_artifact_special(j_ptr))
4791         {
4792                 IDX k_idx;
4793
4794                 /* Good objects */
4795                 if ((mode & AM_GOOD) && !get_obj_num_hook)
4796                 {
4797                         /* Activate restriction (if already specified, use that) */
4798                         get_obj_num_hook = kind_is_good;
4799                 }
4800
4801                 /* Restricted objects - prepare allocation table */
4802                 if (get_obj_num_hook) get_obj_num_prep();
4803
4804                 /* Pick a random object */
4805                 k_idx = get_obj_num(base);
4806
4807                 /* Restricted objects */
4808                 if (get_obj_num_hook)
4809                 {
4810                         /* Clear restriction */
4811                         get_obj_num_hook = NULL;
4812
4813                         /* Reset allocation table to default */
4814                         get_obj_num_prep();
4815                 }
4816
4817                 /* Handle failure */
4818                 if (!k_idx) return (FALSE);
4819
4820                 /* Prepare the object */
4821                 object_prep(j_ptr, k_idx);
4822         }
4823
4824         /* Apply magic (allow artifacts) */
4825         apply_magic(j_ptr, object_level, mode);
4826
4827         /* Hack -- generate multiple spikes/missiles */
4828         switch (j_ptr->tval)
4829         {
4830                 case TV_SPIKE:
4831                 case TV_SHOT:
4832                 case TV_ARROW:
4833                 case TV_BOLT:
4834                 {
4835                         if (!j_ptr->name1)
4836                                 j_ptr->number = (byte)damroll(6, 7);
4837                 }
4838         }
4839
4840         if (cheat_peek) object_mention(j_ptr);
4841
4842         /* Success */
4843         return (TRUE);
4844 }
4845
4846
4847 /*!
4848  * @brief フロアの指定位置に生成階に応じたベースアイテムの生成を行う。
4849  * Attempt to place an object (normal or good/great) at the given location.
4850  * @param y 配置したいフロアのY座標
4851  * @param x 配置したいフロアのX座標
4852  * @param mode オプションフラグ
4853  * @return 生成に成功したらTRUEを返す。
4854  * @details
4855  * This routine plays nasty games to generate the "special artifacts".\n
4856  * This routine uses "object_level" for the "generation level".\n
4857  * This routine requires a clean floor grid destination.\n
4858  */
4859 void place_object(POSITION y, POSITION x, BIT_FLAGS mode)
4860 {
4861         IDX o_idx;
4862
4863         /* Acquire grid */
4864         cave_type *c_ptr = &cave[y][x];
4865
4866         object_type forge;
4867         object_type *q_ptr;
4868
4869
4870         /* Paranoia -- check bounds */
4871         if (!in_bounds(y, x)) return;
4872
4873         /* Require floor space */
4874         if (!cave_drop_bold(y, x)) return;
4875
4876         /* Avoid stacking on other objects */
4877         if (c_ptr->o_idx) return;
4878
4879
4880         /* Get local object */
4881         q_ptr = &forge;
4882
4883         /* Wipe the object */
4884         object_wipe(q_ptr);
4885
4886         /* Make an object (if possible) */
4887         if (!make_object(q_ptr, mode)) return;
4888
4889
4890         /* Make an object */
4891         o_idx = o_pop();
4892
4893         /* Success */
4894         if (o_idx)
4895         {
4896                 object_type *o_ptr;
4897
4898                 /* Acquire object */
4899                 o_ptr = &o_list[o_idx];
4900
4901                 /* Structure Copy */
4902                 object_copy(o_ptr, q_ptr);
4903
4904                 /* Location */
4905                 o_ptr->iy = y;
4906                 o_ptr->ix = x;
4907
4908                 /* Build a stack */
4909                 o_ptr->next_o_idx = c_ptr->o_idx;
4910
4911                 /* Place the object */
4912                 c_ptr->o_idx = o_idx;
4913
4914                 /* Notice */
4915                 note_spot(y, x);
4916
4917                 /* Redraw */
4918                 lite_spot(y, x);
4919         }
4920         else
4921         {
4922                 /* Hack -- Preserve artifacts */
4923                 if (object_is_fixed_artifact(q_ptr))
4924                 {
4925                         a_info[q_ptr->name1].cur_num = 0;
4926                 }
4927         }
4928 }
4929
4930
4931 /*!
4932  * @brief 生成階に応じた財宝オブジェクトの生成を行う。
4933  * Make a treasure object
4934  * @param j_ptr 生成結果を収めたいオブジェクト構造体の参照ポインタ
4935  * @return 生成に成功したらTRUEを返す。
4936  * @details
4937  * The location must be a legal, clean, floor grid.
4938  */
4939 bool make_gold(object_type *j_ptr)
4940 {
4941         int i;
4942
4943         s32b base;
4944
4945
4946         /* Hack -- Pick a Treasure variety */
4947         i = ((randint1(object_level + 2) + 2) / 2) - 1;
4948
4949         /* Apply "extra" magic */
4950         if (one_in_(GREAT_OBJ))
4951         {
4952                 i += randint1(object_level + 1);
4953         }
4954
4955         /* Hack -- Creeping Coins only generate "themselves" */
4956         if (coin_type) i = coin_type;
4957
4958         /* Do not create "illegal" Treasure Types */
4959         if (i >= MAX_GOLD) i = MAX_GOLD - 1;
4960
4961         /* Prepare a gold object */
4962         object_prep(j_ptr, OBJ_GOLD_LIST + i);
4963
4964         /* Hack -- Base coin cost */
4965         base = k_info[OBJ_GOLD_LIST+i].cost;
4966
4967         /* Determine how much the treasure is "worth" */
4968         j_ptr->pval = (base + (8L * randint1(base)) + randint1(8));
4969
4970         /* Success */
4971         return (TRUE);
4972 }
4973
4974
4975 /*!
4976  * @brief フロアの指定位置に生成階に応じた財宝オブジェクトの生成を行う。
4977  * Places a treasure (Gold or Gems) at given location
4978  * @param y 配置したいフロアのY座標
4979  * @param x 配置したいフロアのX座標
4980  * @return 生成に成功したらTRUEを返す。
4981  * @details
4982  * The location must be a legal, clean, floor grid.
4983  */
4984 void place_gold(POSITION y, POSITION x)
4985 {
4986         s16b o_idx;
4987
4988         /* Acquire grid */
4989         cave_type *c_ptr = &cave[y][x];
4990
4991
4992         object_type forge;
4993         object_type *q_ptr;
4994
4995
4996         /* Paranoia -- check bounds */
4997         if (!in_bounds(y, x)) return;
4998
4999         /* Require floor space */
5000         if (!cave_drop_bold(y, x)) return;
5001
5002         /* Avoid stacking on other objects */
5003         if (c_ptr->o_idx) return;
5004
5005
5006         /* Get local object */
5007         q_ptr = &forge;
5008
5009         /* Wipe the object */
5010         object_wipe(q_ptr);
5011
5012         /* Make some gold */
5013         if (!make_gold(q_ptr)) return;
5014
5015
5016         /* Make an object */
5017         o_idx = o_pop();
5018
5019         /* Success */
5020         if (o_idx)
5021         {
5022                 object_type *o_ptr;
5023
5024                 /* Acquire object */
5025                 o_ptr = &o_list[o_idx];
5026
5027                 /* Copy the object */
5028                 object_copy(o_ptr, q_ptr);
5029
5030                 /* Save location */
5031                 o_ptr->iy = y;
5032                 o_ptr->ix = x;
5033
5034                 /* Build a stack */
5035                 o_ptr->next_o_idx = c_ptr->o_idx;
5036
5037                 /* Place the object */
5038                 c_ptr->o_idx = o_idx;
5039
5040                 /* Notice */
5041                 note_spot(y, x);
5042
5043                 /* Redraw */
5044                 lite_spot(y, x);
5045         }
5046 }
5047
5048
5049 /*!
5050  * @brief 生成済のオブジェクトをフロアの所定の位置に落とす。
5051  * Let an object fall to the ground at or near a location.
5052  * @param j_ptr 落としたいオブジェクト構造体の参照ポインタ
5053  * @param chance ドロップの成功率(%)
5054  * @param y 配置したいフロアのY座標
5055  * @param x 配置したいフロアのX座標
5056  * @return 生成に成功したらTRUEを返す。
5057  * @details
5058  * The initial location is assumed to be "in_bounds()".\n
5059  *\n
5060  * This function takes a parameter "chance".  This is the percentage\n
5061  * chance that the item will "disappear" instead of drop.  If the object\n
5062  * has been thrown, then this is the chance of disappearance on contact.\n
5063  *\n
5064  * Hack -- this function uses "chance" to determine if it should produce\n
5065  * some form of "description" of the drop event (under the player).\n
5066  *\n
5067  * We check several locations to see if we can find a location at which\n
5068  * the object can combine, stack, or be placed.  Artifacts will try very\n
5069  * hard to be placed, including "teleporting" to a useful grid if needed.\n
5070  */
5071 s16b drop_near(object_type *j_ptr, int chance, int y, int x)
5072 {
5073         int i, k, d, s;
5074
5075         int bs, bn;
5076         int by, bx;
5077         int dy, dx;
5078         int ty, tx = 0;
5079
5080         s16b o_idx = 0;
5081
5082         s16b this_o_idx, next_o_idx = 0;
5083
5084         cave_type *c_ptr;
5085
5086         char o_name[MAX_NLEN];
5087
5088         bool flag = FALSE;
5089         bool done = FALSE;
5090
5091 #ifndef JP
5092         /* Extract plural */
5093         bool plural = (j_ptr->number != 1);
5094 #endif
5095
5096         /* Describe object */
5097         object_desc(o_name, j_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
5098
5099
5100         /* Handle normal "breakage" */
5101         if (!object_is_artifact(j_ptr) && (randint0(100) < chance))
5102         {
5103                 /* Message */
5104 #ifdef JP
5105                 msg_format("%sは消えた。", o_name);
5106 #else
5107                 msg_format("The %s disappear%s.",
5108                            o_name, (plural ? "" : "s"));
5109 #endif
5110
5111
5112                 /* Debug */
5113                 if (p_ptr->wizard) msg_print(_("(破損)", "(breakage)"));
5114
5115                 /* Failure */
5116                 return (0);
5117         }
5118
5119
5120         /* Score */
5121         bs = -1;
5122
5123         /* Picker */
5124         bn = 0;
5125
5126         /* Default */
5127         by = y;
5128         bx = x;
5129
5130         /* Scan local grids */
5131         for (dy = -3; dy <= 3; dy++)
5132         {
5133                 /* Scan local grids */
5134                 for (dx = -3; dx <= 3; dx++)
5135                 {
5136                         bool comb = FALSE;
5137
5138                         /* Calculate actual distance */
5139                         d = (dy * dy) + (dx * dx);
5140
5141                         /* Ignore distant grids */
5142                         if (d > 10) continue;
5143
5144                         /* Location */
5145                         ty = y + dy;
5146                         tx = x + dx;
5147
5148                         /* Skip illegal grids */
5149                         if (!in_bounds(ty, tx)) continue;
5150
5151                         /* Require line of projection */
5152                         if (!projectable(y, x, ty, tx)) continue;
5153
5154                         /* Obtain grid */
5155                         c_ptr = &cave[ty][tx];
5156
5157                         /* Require floor space */
5158                         if (!cave_drop_bold(ty, tx)) continue;
5159
5160                         /* No objects */
5161                         k = 0;
5162
5163                         /* Scan objects in that grid */
5164                         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
5165                         {
5166                                 object_type *o_ptr;
5167
5168                                 /* Acquire object */
5169                                 o_ptr = &o_list[this_o_idx];
5170
5171                                 /* Acquire next object */
5172                                 next_o_idx = o_ptr->next_o_idx;
5173
5174                                 /* Check for possible combination */
5175                                 if (object_similar(o_ptr, j_ptr)) comb = TRUE;
5176
5177                                 /* Count objects */
5178                                 k++;
5179                         }
5180
5181                         /* Add new object */
5182                         if (!comb) k++;
5183
5184                         /* Paranoia */
5185                         if (k > 99) continue;
5186
5187                         /* Calculate score */
5188                         s = 1000 - (d + k * 5);
5189
5190                         /* Skip bad values */
5191                         if (s < bs) continue;
5192
5193                         /* New best value */
5194                         if (s > bs) bn = 0;
5195
5196                         /* Apply the randomizer to equivalent values */
5197                         if ((++bn >= 2) && !one_in_(bn)) continue;
5198
5199                         /* Keep score */
5200                         bs = s;
5201
5202                         /* Track it */
5203                         by = ty;
5204                         bx = tx;
5205
5206                         /* Okay */
5207                         flag = TRUE;
5208                 }
5209         }
5210
5211
5212         /* Handle lack of space */
5213         if (!flag && !object_is_artifact(j_ptr))
5214         {
5215                 /* Message */
5216 #ifdef JP
5217                 msg_format("%sは消えた。", o_name);
5218 #else
5219                 msg_format("The %s disappear%s.",
5220                            o_name, (plural ? "" : "s"));
5221 #endif
5222
5223
5224                 /* Debug */
5225                 if (p_ptr->wizard) msg_print(_("(床スペースがない)", "(no floor space)"));
5226
5227                 /* Failure */
5228                 return (0);
5229         }
5230
5231
5232         /* Find a grid */
5233         for (i = 0; !flag && (i < 1000); i++)
5234         {
5235                 /* Bounce around */
5236                 ty = rand_spread(by, 1);
5237                 tx = rand_spread(bx, 1);
5238
5239                 /* Verify location */
5240                 if (!in_bounds(ty, tx)) continue;
5241
5242                 /* Bounce to that location */
5243                 by = ty;
5244                 bx = tx;
5245
5246                 /* Require floor space */
5247                 if (!cave_drop_bold(by, bx)) continue;
5248
5249                 /* Okay */
5250                 flag = TRUE;
5251         }
5252
5253
5254         if (!flag)
5255         {
5256                 int candidates = 0, pick;
5257
5258                 for (ty = 1; ty < cur_hgt - 1; ty++)
5259                 {
5260                         for (tx = 1; tx < cur_wid - 1; tx++)
5261                         {
5262                                 /* A valid space found */
5263                                 if (cave_drop_bold(ty, tx)) candidates++;
5264                         }
5265                 }
5266
5267                 /* No valid place! */
5268                 if (!candidates)
5269                 {
5270                         /* Message */
5271 #ifdef JP
5272                         msg_format("%sは消えた。", o_name);
5273 #else
5274                         msg_format("The %s disappear%s.", o_name, (plural ? "" : "s"));
5275 #endif
5276
5277                         /* Debug */
5278                         if (p_ptr->wizard) msg_print(_("(床スペースがない)", "(no floor space)"));
5279
5280                         /* Mega-Hack -- preserve artifacts */
5281                         if (preserve_mode)
5282                         {
5283                                 /* Hack -- Preserve unknown artifacts */
5284                                 if (object_is_fixed_artifact(j_ptr) && !object_is_known(j_ptr))
5285                                 {
5286                                         /* Mega-Hack -- Preserve the artifact */
5287                                         a_info[j_ptr->name1].cur_num = 0;
5288                                 }
5289                         }
5290
5291                         /* Failure */
5292                         return 0;
5293                 }
5294
5295                 /* Choose a random one */
5296                 pick = randint1(candidates);
5297
5298                 for (ty = 1; ty < cur_hgt - 1; ty++)
5299                 {
5300                         for (tx = 1; tx < cur_wid - 1; tx++)
5301                         {
5302                                 if (cave_drop_bold(ty, tx))
5303                                 {
5304                                         pick--;
5305
5306                                         /* Is this a picked one? */
5307                                         if (!pick) break;
5308                                 }
5309                         }
5310
5311                         if (!pick) break;
5312                 }
5313
5314                 by = ty;
5315                 bx = tx;
5316         }
5317
5318
5319         /* Grid */
5320         c_ptr = &cave[by][bx];
5321
5322         /* Scan objects in that grid for combination */
5323         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
5324         {
5325                 object_type *o_ptr;
5326
5327                 /* Acquire object */
5328                 o_ptr = &o_list[this_o_idx];
5329
5330                 /* Acquire next object */
5331                 next_o_idx = o_ptr->next_o_idx;
5332
5333                 /* Check for combination */
5334                 if (object_similar(o_ptr, j_ptr))
5335                 {
5336                         /* Combine the items */
5337                         object_absorb(o_ptr, j_ptr);
5338
5339                         /* Success */
5340                         done = TRUE;
5341
5342                         /* Done */
5343                         break;
5344                 }
5345         }
5346
5347         /* Get new object */
5348         if (!done) o_idx = o_pop();
5349
5350         /* Failure */
5351         if (!done && !o_idx)
5352         {
5353                 /* Message */
5354 #ifdef JP
5355                 msg_format("%sは消えた。", o_name);
5356 #else
5357                 msg_format("The %s disappear%s.",
5358                            o_name, (plural ? "" : "s"));
5359 #endif
5360
5361
5362                 /* Debug */
5363                 if (p_ptr->wizard) msg_print(_("(アイテムが多過ぎる)", "(too many objects)"));
5364
5365                 /* Hack -- Preserve artifacts */
5366                 if (object_is_fixed_artifact(j_ptr))
5367                 {
5368                         a_info[j_ptr->name1].cur_num = 0;
5369                 }
5370
5371                 /* Failure */
5372                 return (0);
5373         }
5374
5375         /* Stack */
5376         if (!done)
5377         {
5378                 /* Structure copy */
5379                 object_copy(&o_list[o_idx], j_ptr);
5380
5381                 /* Access new object */
5382                 j_ptr = &o_list[o_idx];
5383
5384                 /* Locate */
5385                 j_ptr->iy = by;
5386                 j_ptr->ix = bx;
5387
5388                 /* No monster */
5389                 j_ptr->held_m_idx = 0;
5390
5391                 /* Build a stack */
5392                 j_ptr->next_o_idx = c_ptr->o_idx;
5393
5394                 /* Place the object */
5395                 c_ptr->o_idx = o_idx;
5396
5397                 /* Success */
5398                 done = TRUE;
5399         }
5400
5401         /* Note the spot */
5402         note_spot(by, bx);
5403
5404         /* Draw the spot */
5405         lite_spot(by, bx);
5406
5407         /* Sound */
5408         sound(SOUND_DROP);
5409
5410         /* Mega-Hack -- no message if "dropped" by player */
5411         /* Message when an object falls under the player */
5412         if (chance && player_bold(by, bx))
5413         {
5414                 msg_print(_("何かが足下に転がってきた。", "You feel something roll beneath your feet."));
5415         }
5416
5417         /* XXX XXX XXX */
5418
5419         /* Result */
5420         return (o_idx);
5421 }
5422
5423
5424 /*!
5425  * @brief 獲得ドロップを行う。
5426  * Scatter some "great" objects near the player
5427  * @param y1 配置したいフロアのY座標
5428  * @param x1 配置したいフロアのX座標
5429  * @param num 獲得の処理回数
5430  * @param great TRUEならば必ず高級品以上を落とす
5431  * @param special TRUEならば必ず特別品を落とす
5432  * @param known TRUEならばオブジェクトが必ず＊鑑定＊済になる
5433  * @return なし
5434  */
5435 void acquirement(int y1, int x1, int num, bool great, bool special, bool known)
5436 {
5437         object_type *i_ptr;
5438         object_type object_type_body;
5439         BIT_FLAGS mode = AM_GOOD | (great || special ? AM_GREAT : 0L) | (special ? AM_SPECIAL : 0L) ;
5440
5441         /* Acquirement */
5442         while (num--)
5443         {
5444                 /* Get local object */
5445                 i_ptr = &object_type_body;
5446
5447                 /* Wipe the object */
5448                 object_wipe(i_ptr);
5449
5450                 /* Make a good (or great) object (if possible) */
5451                 if (!make_object(i_ptr, mode)) continue;
5452
5453                 if (known)
5454                 {
5455                         object_aware(i_ptr);
5456                         object_known(i_ptr);
5457                 }
5458
5459                 /* Drop the object */
5460                 (void)drop_near(i_ptr, -1, y1, x1);
5461         }
5462 }
5463
5464 /*
5465  * Scatter some "amusing" objects near the player
5466  */
5467
5468 #define AMS_NOTHING   0x00 /* No restriction */
5469 #define AMS_NO_UNIQUE 0x01 /* Don't make the amusing object of uniques */
5470 #define AMS_FIXED_ART 0x02 /* Make a fixed artifact based on the amusing object */
5471 #define AMS_MULTIPLE  0x04 /* Drop 1-3 objects for one type */
5472 #define AMS_PILE      0x08 /* Drop 1-99 pile objects for one type */
5473
5474 typedef struct
5475 {
5476         OBJECT_TYPE_VALUE tval;
5477         OBJECT_SUBTYPE_VALUE sval;
5478         int prob;
5479         byte flag;
5480 } amuse_type;
5481
5482 amuse_type amuse_info[] =
5483 {
5484         { TV_BOTTLE, SV_ANY, 5, AMS_NOTHING },
5485         { TV_JUNK, SV_ANY, 3, AMS_MULTIPLE },
5486         { TV_SPIKE, SV_ANY, 10, AMS_PILE },
5487         { TV_STATUE, SV_ANY, 15, AMS_NOTHING },
5488         { TV_CORPSE, SV_ANY, 15, AMS_NO_UNIQUE },
5489         { TV_SKELETON, SV_ANY, 10, AMS_NO_UNIQUE },
5490         { TV_FIGURINE, SV_ANY, 10, AMS_NO_UNIQUE },
5491         { TV_PARCHMENT, SV_ANY, 1, AMS_NOTHING },
5492         { TV_POLEARM, SV_TSURIZAO, 3, AMS_NOTHING }, //Fishing Pole of Taikobo
5493         { TV_SWORD, SV_BROKEN_DAGGER, 3, AMS_FIXED_ART }, //Broken Dagger of Magician
5494         { TV_SWORD, SV_BROKEN_DAGGER, 10, AMS_NOTHING },
5495         { TV_SWORD, SV_BROKEN_SWORD, 5, AMS_NOTHING },
5496         { TV_SCROLL, SV_SCROLL_AMUSEMENT, 10, AMS_NOTHING },
5497
5498         { 0, 0, 0 }
5499 };
5500
5501 /*!
5502  * @brief 誰得ドロップを行う。
5503  * @param y1 配置したいフロアのY座標
5504  * @param x1 配置したいフロアのX座標
5505  * @param num 誰得の処理回数
5506  * @param known TRUEならばオブジェクトが必ず＊鑑定＊済になる
5507  * @return なし
5508  */
5509 void amusement(int y1, int x1, int num, bool known)
5510 {
5511         object_type *i_ptr;
5512         object_type object_type_body;
5513         int n, t = 0;
5514
5515         for (n = 0; amuse_info[n].tval != 0; n++)
5516         {
5517                 t += amuse_info[n].prob;
5518         }
5519
5520         /* Acquirement */
5521         while (num)
5522         {
5523                 int i;
5524                 IDX k_idx, a_idx = 0;
5525                 int r = randint0(t);
5526                 bool insta_art, fixed_art;
5527
5528                 for (i = 0; ; i++)
5529                 {
5530                         r -= amuse_info[i].prob;
5531                         if (r <= 0) break;
5532                 }
5533
5534                 /* Get local object */
5535                 i_ptr = &object_type_body;
5536
5537                 /* Wipe the object */
5538                 object_wipe(i_ptr);
5539
5540                 /* Wipe the object */
5541                 k_idx = lookup_kind(amuse_info[i].tval, amuse_info[i].sval);
5542
5543                 /* Paranoia - reroll if nothing */
5544                 if (!k_idx) continue;
5545
5546                 /* Search an artifact index if need */
5547                 insta_art = (k_info[k_idx].gen_flags & TRG_INSTA_ART);
5548                 fixed_art = (amuse_info[i].flag & AMS_FIXED_ART);
5549
5550                 if (insta_art || fixed_art)
5551                 {
5552                         for (a_idx = 1; a_idx < max_a_idx; a_idx++)
5553                         {
5554                                 if (insta_art && !(a_info[a_idx].gen_flags & TRG_INSTA_ART)) continue;
5555                                 if (a_info[a_idx].tval != k_info[k_idx].tval) continue;
5556                                 if (a_info[a_idx].sval != k_info[k_idx].sval) continue;
5557                                 if (a_info[a_idx].cur_num > 0) continue;
5558                                 break;
5559                         }
5560
5561                         if (a_idx >= max_a_idx) continue;
5562                 }
5563
5564                 /* Make an object (if possible) */
5565                 object_prep(i_ptr, k_idx);
5566                 if (a_idx) i_ptr->name1 = a_idx;
5567                 apply_magic(i_ptr, 1, AM_NO_FIXED_ART);
5568
5569                 if (amuse_info[i].flag & AMS_NO_UNIQUE)
5570                 {
5571                         if (r_info[i_ptr->pval].flags1 & RF1_UNIQUE) continue;
5572                 }
5573
5574                 if (amuse_info[i].flag & AMS_MULTIPLE) i_ptr->number = randint1(3);
5575                 if (amuse_info[i].flag & AMS_PILE) i_ptr->number = randint1(99);
5576
5577                 if (known)
5578                 {
5579                         object_aware(i_ptr);
5580                         object_known(i_ptr);
5581                 }
5582
5583                 /* Paranoia - reroll if nothing */
5584                 if (!(i_ptr->k_idx)) continue;
5585
5586                 /* Drop the object */
5587                 (void)drop_near(i_ptr, -1, y1, x1);
5588
5589                 num--;
5590         }
5591 }
5592
5593
5594 #define MAX_NORMAL_TRAPS 18
5595
5596 /* See init_feat_variables() in init2.c */
5597 static s16b normal_traps[MAX_NORMAL_TRAPS];
5598
5599 /*!
5600  * @brief タグに従って、基本トラップテーブルを初期化する / Initialize arrays for normal traps
5601  * @return なし
5602  */
5603 void init_normal_traps(void)
5604 {
5605         int cur_trap = 0;
5606
5607         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TRAPDOOR");
5608         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_PIT");
5609         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SPIKED_PIT");
5610         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_POISON_PIT");
5611         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TY_CURSE");
5612         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TELEPORT");
5613         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_FIRE");
5614         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_ACID");
5615         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SLOW");
5616         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_STR");
5617         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_DEX");
5618         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_CON");
5619         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_BLIND");
5620         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_CONFUSE");
5621         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_POISON");
5622         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SLEEP");
5623         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TRAPS");
5624         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_ALARM");
5625 }
5626
5627 /*!
5628  * @brief 基本トラップをランダムに選択する /
5629  * Get random trap
5630  * @return 選択したトラップのID
5631  * @details
5632  * XXX XXX XXX This routine should be redone to reflect trap "level".\n
5633  * That is, it does not make sense to have spiked pits at 50 feet.\n
5634  * Actually, it is not this routine, but the "trap instantiation"\n
5635  * code, which should also check for "trap doors" on quest levels.\n
5636  */
5637 s16b choose_random_trap(void)
5638 {
5639         s16b feat;
5640
5641         /* Pick a trap */
5642         while (1)
5643         {
5644                 /* Hack -- pick a trap */
5645                 feat = normal_traps[randint0(MAX_NORMAL_TRAPS)];
5646
5647                 /* Accept non-trapdoors */
5648                 if (!have_flag(f_info[feat].flags, FF_MORE)) break;
5649
5650                 /* Hack -- no trap doors on special levels */
5651                 if (p_ptr->inside_arena || quest_number(dun_level)) continue;
5652
5653                 /* Hack -- no trap doors on the deepest level */
5654                 if (dun_level >= d_info[dungeon_type].maxdepth) continue;
5655
5656                 break;
5657         }
5658
5659         return feat;
5660 }
5661
5662 /*!
5663  * @brief マスに存在するトラップを秘匿する /
5664  * Disclose an invisible trap
5665  * @param y 秘匿したいマスのY座標
5666  * @param x 秘匿したいマスのX座標
5667  * @return なし
5668  */
5669 void disclose_grid(int y, int x)
5670 {
5671         cave_type *c_ptr = &cave[y][x];
5672
5673         if (cave_have_flag_grid(c_ptr, FF_SECRET))
5674         {
5675                 /* No longer hidden */
5676                 cave_alter_feat(y, x, FF_SECRET);
5677         }
5678         else if (c_ptr->mimic)
5679         {
5680                 /* No longer hidden */
5681                 c_ptr->mimic = 0;
5682
5683                 /* Notice */
5684                 note_spot(y, x);
5685
5686                 /* Redraw */
5687                 lite_spot(y, x);
5688         }
5689 }
5690
5691 /*!
5692  * @brief マスをトラップを配置する /
5693  * The location must be a legal, naked, floor grid.
5694  * @param y 配置したいマスのY座標
5695  * @param x 配置したいマスのX座標
5696  * @return
5697  * Note that all traps start out as "invisible" and "untyped", and then\n
5698  * when they are "discovered" (by detecting them or setting them off),\n
5699  * the trap is "instantiated" as a visible, "typed", trap.\n
5700  */
5701 void place_trap(int y, int x)
5702 {
5703         cave_type *c_ptr = &cave[y][x];
5704
5705         /* Paranoia -- verify location */
5706         if (!in_bounds(y, x)) return;
5707
5708         /* Require empty, clean, floor grid */
5709         if (!cave_clean_bold(y, x)) return;
5710
5711         /* Place an invisible trap */
5712         c_ptr->mimic = c_ptr->feat;
5713         c_ptr->feat = choose_random_trap();
5714 }
5715
5716 /*!
5717  * @brief 魔道具の使用回数の残量を示すメッセージを表示する /
5718  * Describe the charges on an item in the inventory.
5719  * @param item 残量を表示したいプレイヤーのアイテム所持スロット
5720  * @return なし
5721  */
5722 void inven_item_charges(int item)
5723 {
5724         object_type *o_ptr = &inventory[item];
5725
5726         /* Require staff/wand */
5727         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5728
5729         /* Require known item */
5730         if (!object_is_known(o_ptr)) return;
5731
5732 #ifdef JP
5733         if (o_ptr->pval <= 0)
5734         {
5735                 msg_print("もう魔力が残っていない。");
5736         }
5737         else
5738         {
5739                 msg_format("あと %d 回分の魔力が残っている。", o_ptr->pval);
5740         }
5741 #else
5742         /* Multiple charges */
5743         if (o_ptr->pval != 1)
5744         {
5745                 /* Print a message */
5746                 msg_format("You have %d charges remaining.", o_ptr->pval);
5747         }
5748
5749         /* Single charge */
5750         else
5751         {
5752                 /* Print a message */
5753                 msg_format("You have %d charge remaining.", o_ptr->pval);
5754         }
5755 #endif
5756
5757 }
5758
5759 /*!
5760  * @brief アイテムの残り所持数メッセージを表示する /
5761  * Describe an item in the inventory.
5762  * @param item 残量を表示したいプレイヤーのアイテム所持スロット
5763  * @return なし
5764  */
5765 void inven_item_describe(int item)
5766 {
5767         object_type *o_ptr = &inventory[item];
5768         char        o_name[MAX_NLEN];
5769
5770         /* Get a description */
5771         object_desc(o_name, o_ptr, 0);
5772
5773         /* Print a message */
5774 #ifdef JP
5775         /* "no more" の場合はこちらで表示する */
5776         if (o_ptr->number <= 0)
5777         {
5778                 /*FIRST*//*ここはもう通らないかも */
5779                 msg_format("もう%sを持っていない。", o_name);
5780         }
5781         else
5782         {
5783                 /* アイテム名を英日切り替え機能対応 */
5784                 msg_format("まだ %sを持っている。", o_name);
5785         }
5786 #else
5787         msg_format("You have %s.", o_name);
5788 #endif
5789
5790 }
5791
5792 /*!
5793  * @brief アイテムの残り所持数メッセージを表示する /
5794  * Increase the "number" of an item in the inventory
5795  * @param item 所持数を増やしたいプレイヤーのアイテム所持スロット
5796  * @param num 増やしたい量
5797  * @return なし
5798  */
5799 void inven_item_increase(int item, int num)
5800 {
5801         object_type *o_ptr = &inventory[item];
5802
5803         /* Apply */
5804         num += o_ptr->number;
5805
5806         /* Bounds check */
5807         if (num > 255) num = 255;
5808         else if (num < 0) num = 0;
5809
5810         /* Un-apply */
5811         num -= (ITEM_NUMBER)o_ptr->number;
5812
5813         /* Change the number and weight */
5814         if (num)
5815         {
5816                 /* Add the number */
5817                 o_ptr->number += num;
5818
5819                 /* Add the weight */
5820                 p_ptr->total_weight += (num * o_ptr->weight);
5821
5822                 /* Recalculate bonuses */
5823                 p_ptr->update |= (PU_BONUS);
5824
5825                 /* Recalculate mana XXX */
5826                 p_ptr->update |= (PU_MANA);
5827
5828                 /* Combine the pack */
5829                 p_ptr->notice |= (PN_COMBINE);
5830
5831                 /* Window stuff */
5832                 p_ptr->window |= (PW_INVEN | PW_EQUIP);
5833
5834                 /* Hack -- Clear temporary elemental brands if player takes off weapons */
5835                 if (!o_ptr->number && p_ptr->ele_attack)
5836                 {
5837                         if ((item == INVEN_RARM) || (item == INVEN_LARM))
5838                         {
5839                                 if (!buki_motteruka(INVEN_RARM + INVEN_LARM - item))
5840                                 {
5841                                         /* Clear all temporary elemental brands */
5842                                         set_ele_attack(0, 0);
5843                                 }
5844                         }
5845                 }
5846         }
5847 }
5848
5849 /*!
5850  * @brief 所持アイテムスロットから所持数のなくなったアイテムを消去する /
5851  * Erase an inventory slot if it has no more items
5852  * @param item 消去したいプレイヤーのアイテム所持スロット
5853  * @return なし
5854  */
5855 void inven_item_optimize(int item)
5856 {
5857         object_type *o_ptr = &inventory[item];
5858
5859         /* Only optimize real items */
5860         if (!o_ptr->k_idx) return;
5861
5862         /* Only optimize empty items */
5863         if (o_ptr->number) return;
5864
5865         /* The item is in the pack */
5866         if (item < INVEN_RARM)
5867         {
5868                 int i;
5869
5870                 /* One less item */
5871                 inven_cnt--;
5872
5873                 /* Slide everything down */
5874                 for (i = item; i < INVEN_PACK; i++)
5875                 {
5876                         /* Structure copy */
5877                         inventory[i] = inventory[i+1];
5878                 }
5879
5880                 /* Erase the "final" slot */
5881                 object_wipe(&inventory[i]);
5882
5883                 /* Window stuff */
5884                 p_ptr->window |= (PW_INVEN);
5885         }
5886
5887         /* The item is being wielded */
5888         else
5889         {
5890                 /* One less item */
5891                 equip_cnt--;
5892
5893                 /* Erase the empty slot */
5894                 object_wipe(&inventory[item]);
5895
5896                 /* Recalculate bonuses */
5897                 p_ptr->update |= (PU_BONUS);
5898
5899                 /* Recalculate torch */
5900                 p_ptr->update |= (PU_TORCH);
5901
5902                 /* Recalculate mana XXX */
5903                 p_ptr->update |= (PU_MANA);
5904
5905                 /* Window stuff */
5906                 p_ptr->window |= (PW_EQUIP);
5907         }
5908
5909         /* Window stuff */
5910         p_ptr->window |= (PW_SPELL);
5911 }
5912
5913 /*!
5914  * @brief 床上の魔道具の残り残量メッセージを表示する /
5915  * Describe the charges on an item on the floor.
5916  * @param item メッセージの対象にしたいアイテム所持スロット
5917  * @return なし
5918  */
5919 void floor_item_charges(int item)
5920 {
5921         object_type *o_ptr = &o_list[item];
5922
5923         /* Require staff/wand */
5924         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5925
5926         /* Require known item */
5927         if (!object_is_known(o_ptr)) return;
5928
5929 #ifdef JP
5930         if (o_ptr->pval <= 0)
5931         {
5932                 msg_print("この床上のアイテムは、もう魔力が残っていない。");
5933         }
5934         else
5935         {
5936                 msg_format("この床上のアイテムは、あと %d 回分の魔力が残っている。", o_ptr->pval);
5937         }
5938 #else
5939         /* Multiple charges */
5940         if (o_ptr->pval != 1)
5941         {
5942                 /* Print a message */
5943                 msg_format("There are %d charges remaining.", o_ptr->pval);
5944         }
5945
5946         /* Single charge */
5947         else
5948         {
5949                 /* Print a message */
5950                 msg_format("There is %d charge remaining.", o_ptr->pval);
5951         }
5952 #endif
5953
5954 }
5955
5956 /*!
5957  * @brief 床上のアイテムの残り数メッセージを表示する /
5958  * Describe the charges on an item on the floor.
5959  * @param item メッセージの対象にしたいアイテム所持スロット
5960  * @return なし
5961  */
5962 void floor_item_describe(int item)
5963 {
5964         object_type *o_ptr = &o_list[item];
5965         char        o_name[MAX_NLEN];
5966
5967         /* Get a description */
5968         object_desc(o_name, o_ptr, 0);
5969
5970         /* Print a message */
5971 #ifdef JP
5972         /* "no more" の場合はこちらで表示を分ける */
5973         if (o_ptr->number <= 0)
5974         {
5975                 msg_format("床上には、もう%sはない。", o_name);
5976         }
5977         else
5978         {
5979                 msg_format("床上には、まだ %sがある。", o_name);
5980         }
5981 #else
5982         msg_format("You see %s.", o_name);
5983 #endif
5984
5985 }
5986
5987
5988 /*!
5989  * @brief 床上のアイテムの数を増やす /
5990  * Increase the "number" of an item on the floor
5991  * @param item 増やしたいアイテムの所持スロット
5992  * @param num 増やしたいアイテムの数
5993  * @return なし
5994  */
5995 void floor_item_increase(int item, int num)
5996 {
5997         object_type *o_ptr = &o_list[item];
5998
5999         /* Apply */
6000         num += o_ptr->number;
6001
6002         /* Bounds check */
6003         if (num > 255) num = 255;
6004         else if (num < 0) num = 0;
6005
6006         /* Un-apply */
6007         num -= (int)o_ptr->number;
6008
6009         /* Change the number */
6010         o_ptr->number += (ITEM_NUMBER)num;
6011 }
6012
6013
6014 /*!
6015  * @brief 床上の数の無くなったアイテムスロットを消去する /
6016  * Optimize an item on the floor (destroy "empty" items)
6017  * @param item 消去したいアイテムの所持スロット
6018  * @return なし
6019  */
6020 void floor_item_optimize(int item)
6021 {
6022         object_type *o_ptr = &o_list[item];
6023
6024         /* Paranoia -- be sure it exists */
6025         if (!o_ptr->k_idx) return;
6026
6027         /* Only optimize empty items */
6028         if (o_ptr->number) return;
6029
6030         /* Delete the object */
6031         delete_object_idx(item);
6032 }
6033
6034
6035 /*!
6036  * @brief アイテムを拾う際にザックから溢れずに済むかを判定する /
6037  * Check if we have space for an item in the pack without overflow
6038  * @param o_ptr 拾いたいオブジェクトの構造体参照ポインタ
6039  * @return 溢れずに済むならTRUEを返す
6040  */
6041 bool inven_carry_okay(object_type *o_ptr)
6042 {
6043         int j;
6044
6045         /* Empty slot? */
6046         if (inven_cnt < INVEN_PACK) return (TRUE);
6047
6048         /* Similar slot? */
6049         for (j = 0; j < INVEN_PACK; j++)
6050         {
6051                 object_type *j_ptr = &inventory[j];
6052
6053                 /* Skip non-objects */
6054                 if (!j_ptr->k_idx) continue;
6055
6056                 /* Check if the two items can be combined */
6057                 if (object_similar(j_ptr, o_ptr)) return (TRUE);
6058         }
6059
6060         /* Nope */
6061         return (FALSE);
6062 }
6063
6064 /*!
6065  * @brief オブジェクトを定義された基準に従いソートするための関数 /
6066  * Check if we have space for an item in the pack without overflow
6067  * @param o_ptr 比較対象オブジェクトの構造体参照ポインタ1
6068  * @param o_value o_ptrのアイテム価値（手動であらかじめ代入する必要がある？）
6069  * @param j_ptr 比較対象オブジェクトの構造体参照ポインタ2
6070  * @return o_ptrの方が上位ならばTRUEを返す。
6071  */
6072 bool object_sort_comp(object_type *o_ptr, s32b o_value, object_type *j_ptr)
6073 {
6074         int o_type, j_type;
6075
6076         /* Use empty slots */
6077         if (!j_ptr->k_idx) return TRUE;
6078
6079         /* Hack -- readable books always come first */
6080         if ((o_ptr->tval == REALM1_BOOK) &&
6081             (j_ptr->tval != REALM1_BOOK)) return TRUE;
6082         if ((j_ptr->tval == REALM1_BOOK) &&
6083             (o_ptr->tval != REALM1_BOOK)) return FALSE;
6084
6085         if ((o_ptr->tval == REALM2_BOOK) &&
6086             (j_ptr->tval != REALM2_BOOK)) return TRUE;
6087         if ((j_ptr->tval == REALM2_BOOK) &&
6088             (o_ptr->tval != REALM2_BOOK)) return FALSE;
6089
6090         /* Objects sort by decreasing type */
6091         if (o_ptr->tval > j_ptr->tval) return TRUE;
6092         if (o_ptr->tval < j_ptr->tval) return FALSE;
6093
6094         /* Non-aware (flavored) items always come last */
6095         /* Can happen in the home */
6096         if (!object_is_aware(o_ptr)) return FALSE;
6097         if (!object_is_aware(j_ptr)) return TRUE;
6098
6099         /* Objects sort by increasing sval */
6100         if (o_ptr->sval < j_ptr->sval) return TRUE;
6101         if (o_ptr->sval > j_ptr->sval) return FALSE;
6102
6103         /* Unidentified objects always come last */
6104         /* Objects in the home can be unknown */
6105         if (!object_is_known(o_ptr)) return FALSE;
6106         if (!object_is_known(j_ptr)) return TRUE;
6107
6108         /* Fixed artifacts, random artifacts and ego items */
6109         if (object_is_fixed_artifact(o_ptr)) o_type = 3;
6110         else if (o_ptr->art_name) o_type = 2;
6111         else if (object_is_ego(o_ptr)) o_type = 1;
6112         else o_type = 0;
6113
6114         if (object_is_fixed_artifact(j_ptr)) j_type = 3;
6115         else if (j_ptr->art_name) j_type = 2;
6116         else if (object_is_ego(j_ptr)) j_type = 1;
6117         else j_type = 0;
6118
6119         if (o_type < j_type) return TRUE;
6120         if (o_type > j_type) return FALSE;
6121
6122         switch (o_ptr->tval)
6123         {
6124         case TV_FIGURINE:
6125         case TV_STATUE:
6126         case TV_CORPSE:
6127         case TV_CAPTURE:
6128                 if (r_info[o_ptr->pval].level < r_info[j_ptr->pval].level) return TRUE;
6129                 if ((r_info[o_ptr->pval].level == r_info[j_ptr->pval].level) && (o_ptr->pval < j_ptr->pval)) return TRUE;
6130                 return FALSE;
6131
6132         case TV_SHOT:
6133         case TV_ARROW:
6134         case TV_BOLT:
6135                 /* Objects sort by increasing hit/damage bonuses */
6136                 if (o_ptr->to_h + o_ptr->to_d < j_ptr->to_h + j_ptr->to_d) return TRUE;
6137                 if (o_ptr->to_h + o_ptr->to_d > j_ptr->to_h + j_ptr->to_d) return FALSE;
6138                 break;
6139
6140         /* Hack:  otherwise identical rods sort by
6141         increasing recharge time --dsb */
6142         case TV_ROD:
6143                 if (o_ptr->pval < j_ptr->pval) return TRUE;
6144                 if (o_ptr->pval > j_ptr->pval) return FALSE;
6145                 break;
6146         }
6147
6148         /* Objects sort by decreasing value */
6149         return o_value > object_value(j_ptr);
6150 }
6151
6152
6153 /*!
6154  * @brief オブジェクトをプレイヤーが拾って所持スロットに納めるメインルーチン /
6155  * Add an item to the players inventory, and return the slot used.
6156  * @param o_ptr 拾うオブジェクトの構造体参照ポインタ
6157  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
6158  * @details
6159  * If the new item can combine with an existing item in the inventory,\n
6160  * it will do so, using "object_similar()" and "object_absorb()", else,\n
6161  * the item will be placed into the "proper" location in the inventory.\n
6162  *\n
6163  * This function can be used to "over-fill" the player's pack, but only\n
6164  * once, and such an action must trigger the "overflow" code immediately.\n
6165  * Note that when the pack is being "over-filled", the new item must be\n
6166  * placed into the "overflow" slot, and the "overflow" must take place\n
6167  * before the pack is reordered, but (optionally) after the pack is\n
6168  * combined.  This may be tricky.  See "dungeon.c" for info.\n
6169  *\n
6170  * Note that this code must remove any location/stack information\n
6171  * from the object once it is placed into the inventory.\n
6172  */
6173 s16b inven_carry(object_type *o_ptr)
6174 {
6175         INVENTORY_IDX i, j, k;
6176         INVENTORY_IDX n = -1;
6177
6178         object_type *j_ptr;
6179
6180
6181         /* Check for combining */
6182         for (j = 0; j < INVEN_PACK; j++)
6183         {
6184                 j_ptr = &inventory[j];
6185
6186                 /* Skip non-objects */
6187                 if (!j_ptr->k_idx) continue;
6188
6189                 /* Hack -- track last item */
6190                 n = j;
6191
6192                 /* Check if the two items can be combined */
6193                 if (object_similar(j_ptr, o_ptr))
6194                 {
6195                         /* Combine the items */
6196                         object_absorb(j_ptr, o_ptr);
6197
6198                         /* Increase the weight */
6199                         p_ptr->total_weight += (o_ptr->number * o_ptr->weight);
6200
6201                         /* Recalculate bonuses */
6202                         p_ptr->update |= (PU_BONUS);
6203
6204                         /* Window stuff */
6205                         p_ptr->window |= (PW_INVEN);
6206
6207                         /* Success */
6208                         return (j);
6209                 }
6210         }
6211
6212
6213         /* Paranoia */
6214         if (inven_cnt > INVEN_PACK) return (-1);
6215
6216         /* Find an empty slot */
6217         for (j = 0; j <= INVEN_PACK; j++)
6218         {
6219                 j_ptr = &inventory[j];
6220
6221                 /* Use it if found */
6222                 if (!j_ptr->k_idx) break;
6223         }
6224
6225         /* Use that slot */
6226         i = j;
6227
6228
6229         /* Reorder the pack */
6230         if (i < INVEN_PACK)
6231         {
6232                 /* Get the "value" of the item */
6233                 s32b o_value = object_value(o_ptr);
6234
6235                 /* Scan every occupied slot */
6236                 for (j = 0; j < INVEN_PACK; j++)
6237                 {
6238                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
6239                 }
6240
6241                 /* Use that slot */
6242                 i = j;
6243
6244                 /* Slide objects */
6245                 for (k = n; k >= i; k--)
6246                 {
6247                         /* Hack -- Slide the item */
6248                         object_copy(&inventory[k+1], &inventory[k]);
6249                 }
6250
6251                 /* Wipe the empty slot */
6252                 object_wipe(&inventory[i]);
6253         }
6254
6255
6256         /* Copy the item */
6257         object_copy(&inventory[i], o_ptr);
6258
6259         /* Access new object */
6260         j_ptr = &inventory[i];
6261
6262         /* Forget stack */
6263         j_ptr->next_o_idx = 0;
6264
6265         /* Forget monster */
6266         j_ptr->held_m_idx = 0;
6267
6268         /* Forget location */
6269         j_ptr->iy = j_ptr->ix = 0;
6270
6271         /* Player touches it, and no longer marked */
6272         j_ptr->marked = OM_TOUCHED;
6273
6274         /* Increase the weight */
6275         p_ptr->total_weight += (j_ptr->number * j_ptr->weight);
6276
6277         /* Count the items */
6278         inven_cnt++;
6279
6280         /* Recalculate bonuses */
6281         p_ptr->update |= (PU_BONUS);
6282
6283         /* Combine and Reorder pack */
6284         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
6285
6286         /* Window stuff */
6287         p_ptr->window |= (PW_INVEN);
6288
6289         /* Return the slot */
6290         return (i);
6291 }
6292
6293
6294 /*!
6295  * @brief 装備スロットからオブジェクトを外すメインルーチン /
6296  * Take off (some of) a non-cursed equipment item
6297  * @param item オブジェクトを外したい所持テーブルのID
6298  * @param amt 外したい個数
6299  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
6300  * @details
6301  * Note that only one item at a time can be wielded per slot.\n
6302  * Note that taking off an item when "full" may cause that item\n
6303  * to fall to the ground.\n
6304  * Return the inventory slot into which the item is placed.\n
6305  */
6306 INVENTORY_IDX inven_takeoff(INVENTORY_IDX item, ITEM_NUMBER amt)
6307 {
6308         INVENTORY_IDX slot;
6309
6310         object_type forge;
6311         object_type *q_ptr;
6312
6313         object_type *o_ptr;
6314
6315         cptr act;
6316
6317         char o_name[MAX_NLEN];
6318
6319
6320         /* Get the item to take off */
6321         o_ptr = &inventory[item];
6322
6323         /* Paranoia */
6324         if (amt <= 0) return (-1);
6325
6326         /* Verify */
6327         if (amt > o_ptr->number) amt = o_ptr->number;
6328
6329         /* Get local object */
6330         q_ptr = &forge;
6331
6332         /* Obtain a local object */
6333         object_copy(q_ptr, o_ptr);
6334
6335         /* Modify quantity */
6336         q_ptr->number = amt;
6337
6338         /* Describe the object */
6339         object_desc(o_name, q_ptr, 0);
6340
6341         /* Took off weapon */
6342         if (((item == INVEN_RARM) || (item == INVEN_LARM)) &&
6343             object_is_melee_weapon(o_ptr))
6344         {
6345                 act = _("を装備からはずした", "You were wielding");
6346         }
6347
6348         /* Took off bow */
6349         else if (item == INVEN_BOW)
6350         {
6351                 act = _("を装備からはずした", "You were holding");
6352         }
6353
6354         /* Took off light */
6355         else if (item == INVEN_LITE)
6356         {
6357                 act = _("を光源からはずした", "You were holding");
6358         }
6359
6360         /* Took off something */
6361         else
6362         {
6363                 act = _("を装備からはずした", "You were wearing");
6364         }
6365
6366         /* Modify, Optimize */
6367         inven_item_increase(item, -amt);
6368         inven_item_optimize(item);
6369
6370         /* Carry the object */
6371         slot = inven_carry(q_ptr);
6372
6373         /* Message */
6374 #ifdef JP
6375         msg_format("%s(%c)%s。", o_name, index_to_label(slot), act);
6376 #else
6377         msg_format("%s %s (%c).", act, o_name, index_to_label(slot));
6378 #endif
6379
6380
6381         /* Return slot */
6382         return (slot);
6383 }
6384
6385
6386 /*!
6387  * @brief 所持スロットから床下にオブジェクトを落とすメインルーチン /
6388  * Drop (some of) a non-cursed inventory/equipment item
6389  * @param item 所持テーブルのID
6390  * @param amt 落としたい個数
6391  * @return なし
6392  * @details
6393  * The object will be dropped "near" the current location
6394  */
6395 void inven_drop(INVENTORY_IDX item, ITEM_NUMBER amt)
6396 {
6397         object_type forge;
6398         object_type *q_ptr;
6399         object_type *o_ptr;
6400
6401         char o_name[MAX_NLEN];
6402
6403
6404         /* Access original object */
6405         o_ptr = &inventory[item];
6406
6407         /* Error check */
6408         if (amt <= 0) return;
6409
6410         /* Not too many */
6411         if (amt > o_ptr->number) amt = o_ptr->number;
6412
6413
6414         /* Take off equipment */
6415         if (item >= INVEN_RARM)
6416         {
6417                 /* Take off first */
6418                 item = inven_takeoff(item, amt);
6419
6420                 /* Access original object */
6421                 o_ptr = &inventory[item];
6422         }
6423
6424
6425         /* Get local object */
6426         q_ptr = &forge;
6427
6428         /* Obtain local object */
6429         object_copy(q_ptr, o_ptr);
6430
6431         /* Distribute charges of wands or rods */
6432         distribute_charges(o_ptr, q_ptr, amt);
6433
6434         /* Modify quantity */
6435         q_ptr->number = amt;
6436
6437         /* Describe local object */
6438         object_desc(o_name, q_ptr, 0);
6439
6440         /* Message */
6441         msg_format(_("%s(%c)を落とした。", "You drop %s (%c)."), o_name, index_to_label(item));
6442
6443         /* Drop it near the player */
6444         (void)drop_near(q_ptr, 0, p_ptr->y, p_ptr->x);
6445
6446         /* Modify, Describe, Optimize */
6447         inven_item_increase(item, -amt);
6448         inven_item_describe(item);
6449         inven_item_optimize(item);
6450 }
6451
6452
6453 /*!
6454  * @brief プレイヤーの所持スロットに存在するオブジェクトをまとめなおす /
6455  * Combine items in the pack
6456  * @return なし
6457  * @details
6458  * Note special handling of the "overflow" slot
6459  */
6460 void combine_pack(void)
6461 {
6462         int             i, j, k;
6463         object_type     *o_ptr;
6464         object_type     *j_ptr;
6465         bool            flag = FALSE, combined;
6466
6467         do
6468         {
6469                 combined = FALSE;
6470
6471                 /* Combine the pack (backwards) */
6472                 for (i = INVEN_PACK; i > 0; i--)
6473                 {
6474                         /* Get the item */
6475                         o_ptr = &inventory[i];
6476
6477                         /* Skip empty items */
6478                         if (!o_ptr->k_idx) continue;
6479
6480                         /* Scan the items above that item */
6481                         for (j = 0; j < i; j++)
6482                         {
6483                                 int max_num;
6484
6485                                 /* Get the item */
6486                                 j_ptr = &inventory[j];
6487
6488                                 /* Skip empty items */
6489                                 if (!j_ptr->k_idx) continue;
6490
6491                                 /*
6492                                  * Get maximum number of the stack if these
6493                                  * are similar, get zero otherwise.
6494                                  */
6495                                 max_num = object_similar_part(j_ptr, o_ptr);
6496
6497                                 /* Can we (partialy) drop "o_ptr" onto "j_ptr"? */
6498                                 if (max_num && j_ptr->number < max_num)
6499                                 {
6500                                         if (o_ptr->number + j_ptr->number <= max_num)
6501                                         {
6502                                                 /* Take note */
6503                                                 flag = TRUE;
6504
6505                                                 /* Add together the item counts */
6506                                                 object_absorb(j_ptr, o_ptr);
6507
6508                                                 /* One object is gone */
6509                                                 inven_cnt--;
6510
6511                                                 /* Slide everything down */
6512                                                 for (k = i; k < INVEN_PACK; k++)
6513                                                 {
6514                                                         /* Structure copy */
6515                                                         inventory[k] = inventory[k+1];
6516                                                 }
6517
6518                                                 /* Erase the "final" slot */
6519                                                 object_wipe(&inventory[k]);
6520                                         }
6521                                         else
6522                                         {
6523                                                 int old_num = o_ptr->number;
6524                                                 int remain = j_ptr->number + o_ptr->number - max_num;
6525 #if 0
6526                                                 o_ptr->number -= remain;
6527 #endif
6528                                                 /* Add together the item counts */
6529                                                 object_absorb(j_ptr, o_ptr);
6530
6531                                                 o_ptr->number = remain;
6532
6533                                                 /* Hack -- if rods are stacking, add the pvals (maximum timeouts) and current timeouts together. -LM- */
6534                                                 if (o_ptr->tval == TV_ROD)
6535                                                 {
6536                                                         o_ptr->pval =  o_ptr->pval * remain / old_num;
6537                                                         o_ptr->timeout = o_ptr->timeout * remain / old_num;
6538                                                 }
6539
6540                                                 /* Hack -- if wands are stacking, combine the charges. -LM- */
6541                                                 if (o_ptr->tval == TV_WAND)
6542                                                 {
6543                                                         o_ptr->pval = o_ptr->pval * remain / old_num;
6544                                                 }
6545                                         }
6546
6547                                         /* Window stuff */
6548                                         p_ptr->window |= (PW_INVEN);
6549
6550                                         /* Take note */
6551                                         combined = TRUE;
6552
6553                                         /* Done */
6554                                         break;
6555                                 }
6556                         }
6557                 }
6558         }
6559         while (combined);
6560
6561         /* Message */
6562         if (flag) msg_print(_("ザックの中のアイテムをまとめ直した。", "You combine some items in your pack."));
6563 }
6564
6565 /*!
6566  * @brief プレイヤーの所持スロットに存在するオブジェクトを並び替える /
6567  * Reorder items in the pack
6568  * @return なし
6569  * @details
6570  * Note special handling of the "overflow" slot
6571  */
6572 void reorder_pack(void)
6573 {
6574         int             i, j, k;
6575         s32b            o_value;
6576         object_type     forge;
6577         object_type     *q_ptr;
6578         object_type     *o_ptr;
6579         bool            flag = FALSE;
6580
6581
6582         /* Re-order the pack (forwards) */
6583         for (i = 0; i < INVEN_PACK; i++)
6584         {
6585                 /* Mega-Hack -- allow "proper" over-flow */
6586                 if ((i == INVEN_PACK) && (inven_cnt == INVEN_PACK)) break;
6587
6588                 /* Get the item */
6589                 o_ptr = &inventory[i];
6590
6591                 /* Skip empty slots */
6592                 if (!o_ptr->k_idx) continue;
6593
6594                 /* Get the "value" of the item */
6595                 o_value = object_value(o_ptr);
6596
6597                 /* Scan every occupied slot */
6598                 for (j = 0; j < INVEN_PACK; j++)
6599                 {
6600                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
6601                 }
6602
6603                 /* Never move down */
6604                 if (j >= i) continue;
6605
6606                 /* Take note */
6607                 flag = TRUE;
6608
6609                 /* Get local object */
6610                 q_ptr = &forge;
6611
6612                 /* Save a copy of the moving item */
6613                 object_copy(q_ptr, &inventory[i]);
6614
6615                 /* Slide the objects */
6616                 for (k = i; k > j; k--)
6617                 {
6618                         /* Slide the item */
6619                         object_copy(&inventory[k], &inventory[k-1]);
6620                 }
6621
6622                 /* Insert the moving item */
6623                 object_copy(&inventory[j], q_ptr);
6624
6625                 /* Window stuff */
6626                 p_ptr->window |= (PW_INVEN);
6627         }
6628
6629         /* Message */
6630         if (flag) msg_print(_("ザックの中のアイテムを並べ直した。", "You reorder some items in your pack."));
6631 }
6632
6633 /*!
6634  * @brief 現在アクティブになっているウィンドウにオブジェクトの詳細を表示する /
6635  * Hack -- display an object kind in the current window
6636  * @param k_idx ベースアイテムの参照ID
6637  * @return なし
6638  * @details
6639  * Include list of usable spells for readible books
6640  */
6641 void display_koff(IDX k_idx)
6642 {
6643         int y;
6644
6645         object_type forge;
6646         object_type *q_ptr;
6647         int         sval;
6648         REALM_IDX   use_realm;
6649
6650         char o_name[MAX_NLEN];
6651
6652
6653         /* Erase the window */
6654         for (y = 0; y < Term->hgt; y++)
6655         {
6656                 /* Erase the line */
6657                 Term_erase(0, y, 255);
6658         }
6659
6660         /* No info */
6661         if (!k_idx) return;
6662
6663         /* Get local object */
6664         q_ptr = &forge;
6665
6666         /* Prepare the object */
6667         object_prep(q_ptr, k_idx);
6668
6669         /* Describe */
6670         object_desc(o_name, q_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY | OD_STORE));
6671
6672         /* Mention the object name */
6673         Term_putstr(0, 0, -1, TERM_WHITE, o_name);
6674
6675         /* Access the item's sval */
6676         sval = q_ptr->sval;
6677         use_realm = tval2realm(q_ptr->tval);
6678
6679         /* Warriors are illiterate */
6680         if (p_ptr->realm1 || p_ptr->realm2)
6681         {
6682                 if ((use_realm != p_ptr->realm1) && (use_realm != p_ptr->realm2)) return;
6683         }
6684         else
6685         {
6686                 if ((p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE)) return;
6687                 if (!is_magic(use_realm)) return;
6688                 if ((p_ptr->pclass == CLASS_RED_MAGE) && (use_realm != REALM_ARCANE) && (sval > 1)) return;
6689         }
6690
6691         /* Display spells in readible books */
6692         {
6693                 int     spell = -1;
6694                 int     num = 0;
6695                 SPELL_IDX    spells[64];
6696
6697                 /* Extract spells */
6698                 for (spell = 0; spell < 32; spell++)
6699                 {
6700                         /* Check for this spell */
6701                         if (fake_spell_flags[sval] & (1L << spell))
6702                         {
6703                                 /* Collect this spell */
6704                                 spells[num++] = spell;
6705                         }
6706                 }
6707
6708                 /* Print spells */
6709                 print_spells(0, spells, num, 2, 0, use_realm);
6710         }
6711 }
6712
6713 /*!
6714  * @brief 警告を放つアイテムを選択する /
6715  * Choose one of items that have warning flag
6716  * Calculate spell damages
6717  * @return 警告を行う
6718  */
6719 object_type *choose_warning_item(void)
6720 {
6721         int i;
6722         int choices[INVEN_TOTAL - INVEN_RARM];
6723         int number = 0;
6724
6725         /* Paranoia -- Player has no warning ability */
6726         if (!p_ptr->warning) return NULL;
6727
6728         /* Search Inventory */
6729         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
6730         {
6731                 u32b flgs[TR_FLAG_SIZE];
6732                 object_type *o_ptr = &inventory[i];
6733
6734                 object_flags(o_ptr, flgs);
6735                 if (have_flag(flgs, TR_WARNING))
6736                 {
6737                         choices[number] = i;
6738                         number++;
6739                 }
6740         }
6741
6742         /* Choice one of them */
6743         return number ? &inventory[choices[randint0(number)]] : NULL;
6744 }
6745
6746 /*!
6747  * @brief 警告基準を定めるために魔法の効果属性に基づいて最大魔法ダメージを計算する /
6748  * Calculate spell damages
6749  * @param m_ptr 魔法を行使するモンスターの構造体参照ポインタ
6750  * @param typ 効果属性のID
6751  * @param dam 基本ダメージ
6752  * @param max 算出した最大ダメージを返すポインタ
6753  * @return なし
6754  */
6755 static void spell_damcalc(monster_type *m_ptr, int typ, HIT_POINT dam, int *max)
6756 {
6757         monster_race *r_ptr = &r_info[m_ptr->r_idx];
6758         int          rlev = r_ptr->level;
6759         bool         ignore_wraith_form = FALSE;
6760
6761         /* Vulnerability, resistance and immunity */
6762         switch (typ)
6763         {
6764         case GF_ELEC:
6765                 if (p_ptr->immune_elec)
6766                 {
6767                         dam = 0;
6768                         ignore_wraith_form = TRUE;
6769                 }
6770                 else
6771                 {
6772                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6773                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6774                         if (prace_is_(RACE_ANDROID)) dam += dam / 3;
6775                         if (p_ptr->resist_elec) dam = (dam + 2) / 3;
6776                         if (IS_OPPOSE_ELEC())
6777                                 dam = (dam + 2) / 3;
6778                 }
6779                 break;
6780
6781         case GF_POIS:
6782                 if (p_ptr->resist_pois) dam = (dam + 2) / 3;
6783                 if (IS_OPPOSE_POIS()) dam = (dam + 2) / 3;
6784                 break;
6785
6786         case GF_ACID:
6787                 if (p_ptr->immune_acid)
6788                 {
6789                         dam = 0;
6790                         ignore_wraith_form = TRUE;
6791                 }
6792                 else
6793                 {
6794                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6795                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6796                         if (p_ptr->resist_acid) dam = (dam + 2) / 3;
6797                         if (IS_OPPOSE_ACID()) dam = (dam + 2) / 3;
6798                 }
6799                 break;
6800
6801         case GF_COLD:
6802         case GF_ICE:
6803                 if (p_ptr->immune_cold)
6804                 {
6805                         dam = 0;
6806                         ignore_wraith_form = TRUE;
6807                 }
6808                 else
6809                 {
6810                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6811                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6812                         if (p_ptr->resist_cold) dam = (dam + 2) / 3;
6813                         if (IS_OPPOSE_COLD()) dam = (dam + 2) / 3;
6814                 }
6815                 break;
6816
6817         case GF_FIRE:
6818                 if (p_ptr->immune_fire)
6819                 {
6820                         dam = 0;
6821                         ignore_wraith_form = TRUE;
6822                 }
6823                 else
6824                 {
6825                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6826                         if (prace_is_(RACE_ENT)) dam += dam / 3;
6827                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6828                         if (p_ptr->resist_fire) dam = (dam + 2) / 3;
6829                         if (IS_OPPOSE_FIRE()) dam = (dam + 2) / 3;
6830                 }
6831                 break;
6832
6833         case GF_PSY_SPEAR:
6834                 ignore_wraith_form = TRUE;
6835                 break;
6836
6837         case GF_ARROW:
6838                 if (!p_ptr->blind &&
6839                     ((inventory[INVEN_RARM].k_idx && (inventory[INVEN_RARM].name1 == ART_ZANTETSU)) ||
6840                      (inventory[INVEN_LARM].k_idx && (inventory[INVEN_LARM].name1 == ART_ZANTETSU))))
6841                 {
6842                         dam = 0;
6843                         ignore_wraith_form = TRUE;
6844                 }
6845                 break;
6846
6847         case GF_LITE:
6848                 if (p_ptr->resist_lite) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6849                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE)) dam *= 2;
6850                 else if (prace_is_(RACE_S_FAIRY)) dam = dam * 4 / 3;
6851
6852                 /*
6853                  * Cannot use "ignore_wraith_form" strictly (for "random one damage")
6854                  * "dam *= 2;" for later "dam /= 2"
6855                  */
6856                 if (p_ptr->wraith_form) dam *= 2;
6857                 break;
6858
6859         case GF_DARK:
6860                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE) || p_ptr->wraith_form)
6861                 {
6862                         dam = 0;
6863                         ignore_wraith_form = TRUE;
6864                 }
6865                 else if (p_ptr->resist_dark) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6866                 break;
6867
6868         case GF_SHARDS:
6869                 if (p_ptr->resist_shard) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6870                 break;
6871
6872         case GF_SOUND:
6873                 if (p_ptr->resist_sound) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6874                 break;
6875
6876         case GF_CONFUSION:
6877                 if (p_ptr->resist_conf) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6878                 break;
6879
6880         case GF_CHAOS:
6881                 if (p_ptr->resist_chaos) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6882                 break;
6883
6884         case GF_NETHER:
6885                 if (prace_is_(RACE_SPECTRE))
6886                 {
6887                         dam = 0;
6888                         ignore_wraith_form = TRUE;
6889                 }
6890                 else if (p_ptr->resist_neth) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6891                 break;
6892
6893         case GF_DISENCHANT:
6894                 if (p_ptr->resist_disen) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6895                 break;
6896
6897         case GF_NEXUS:
6898                 if (p_ptr->resist_nexus) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6899                 break;
6900
6901         case GF_TIME:
6902                 if (p_ptr->resist_time) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6903                 break;
6904
6905         case GF_GRAVITY:
6906                 if (p_ptr->levitation) dam = (dam * 2) / 3;
6907                 break;
6908
6909         case GF_ROCKET:
6910                 if (p_ptr->resist_shard) dam /= 2;
6911                 break;
6912
6913         case GF_NUKE:
6914                 if (p_ptr->resist_pois) dam = (2 * dam + 2) / 5;
6915                 if (IS_OPPOSE_POIS()) dam = (2 * dam + 2) / 5;
6916                 break;
6917
6918         case GF_DEATH_RAY:
6919                 if (p_ptr->mimic_form)
6920                 {
6921                         if (mimic_info[p_ptr->mimic_form].MIMIC_FLAGS & MIMIC_IS_NONLIVING)
6922                         {
6923                                 dam = 0;
6924                                 ignore_wraith_form = TRUE;
6925                         }
6926                 }
6927                 else
6928                 {
6929                         switch (p_ptr->prace)
6930                         {
6931                         case RACE_GOLEM:
6932                         case RACE_SKELETON:
6933                         case RACE_ZOMBIE:
6934                         case RACE_VAMPIRE:
6935                         case RACE_DEMON:
6936                         case RACE_SPECTRE:
6937                                 dam = 0;
6938                                 ignore_wraith_form = TRUE;
6939                                 break;
6940                         }
6941                 }
6942                 break;
6943
6944         case GF_HOLY_FIRE:
6945                 if (p_ptr->align > 10) dam /= 2;
6946                 else if (p_ptr->align < -10) dam *= 2;
6947                 break;
6948
6949         case GF_HELL_FIRE:
6950                 if (p_ptr->align > 10) dam *= 2;
6951                 break;
6952
6953         case GF_MIND_BLAST:
6954         case GF_BRAIN_SMASH:
6955                 if (100 + rlev / 2 <= MAX(5, p_ptr->skill_sav))
6956                 {
6957                         dam = 0;
6958                         ignore_wraith_form = TRUE;
6959                 }
6960                 break;
6961
6962         case GF_CAUSE_1:
6963         case GF_CAUSE_2:
6964         case GF_CAUSE_3:
6965         case GF_HAND_DOOM:
6966                 if (100 + rlev / 2 <= p_ptr->skill_sav)
6967                 {
6968                         dam = 0;
6969                         ignore_wraith_form = TRUE;
6970                 }
6971                 break;
6972
6973         case GF_CAUSE_4:
6974                 if ((100 + rlev / 2 <= p_ptr->skill_sav) && (m_ptr->r_idx != MON_KENSHIROU))
6975                 {
6976                         dam = 0;
6977                         ignore_wraith_form = TRUE;
6978                 }
6979                 break;
6980         }
6981
6982         if (p_ptr->wraith_form && !ignore_wraith_form)
6983         {
6984                 dam /= 2;
6985                 if (!dam) dam = 1;
6986         }
6987
6988         if (dam > *max) *max = dam;
6989 }
6990
6991 /*!
6992 * @brief 警告基準を定めるために魔法の効果属性に基づいて最大魔法ダメージを計算する。 /
6993 * Calculate spell damages
6994 * @param spell_num RF4ならRF4_SPELL_STARTのように32区切りのベースとなる数値
6995 * @param typ 効果属性のID
6996 * @param m_idx 魔法を行使するモンスターのID
6997 * @param max 算出した最大ダメージを返すポインタ
6998 * @return なし
6999 */
7000 void spell_damcalc_by_spellnum(int spell_num, int typ, MONSTER_IDX m_idx, int *max)
7001 {
7002     monster_type *m_ptr = &m_list[m_idx];
7003     HIT_POINT dam = monspell_damage((spell_num), m_idx, DAM_MAX);
7004     spell_damcalc(m_ptr, typ, dam, max);
7005 }
7006
7007 /*!
7008  * @brief 警告基準を定めるためにモンスターの打撃最大ダメージを算出する /
7009  * Calculate blow damages
7010  * @param m_ptr 打撃を行使するモンスターの構造体参照ポインタ
7011  * @param blow_ptr モンスターの打撃能力の構造体参照ポインタ
7012  * @return 算出された最大ダメージを返す。
7013  */
7014 static int blow_damcalc(monster_type *m_ptr, monster_blow *blow_ptr)
7015 {
7016         int  dam = blow_ptr->d_dice * blow_ptr->d_side;
7017         int  dummy_max = 0;
7018         bool check_wraith_form = TRUE;
7019
7020         if (blow_ptr->method != RBM_EXPLODE)
7021         {
7022                 int ac = p_ptr->ac + p_ptr->to_a;
7023
7024                 switch (blow_ptr->effect)
7025                 {
7026                 case RBE_SUPERHURT:
7027                 {
7028                         int tmp_dam = dam - (dam * ((ac < 150) ? ac : 150) / 250);
7029                         dam = MAX(dam, tmp_dam * 2);
7030                         break;
7031                 }
7032
7033                 case RBE_HURT:
7034                 case RBE_SHATTER:
7035                         dam -= (dam * ((ac < 150) ? ac : 150) / 250);
7036                         break;
7037
7038                 case RBE_ACID:
7039                         spell_damcalc(m_ptr, GF_ACID, dam, &dummy_max);
7040                         dam = dummy_max;
7041                         check_wraith_form = FALSE;
7042                         break;
7043
7044                 case RBE_ELEC:
7045                         spell_damcalc(m_ptr, GF_ELEC, dam, &dummy_max);
7046                         dam = dummy_max;
7047                         check_wraith_form = FALSE;
7048                         break;
7049
7050                 case RBE_FIRE:
7051                         spell_damcalc(m_ptr, GF_FIRE, dam, &dummy_max);
7052                         dam = dummy_max;
7053                         check_wraith_form = FALSE;
7054                         break;
7055
7056                 case RBE_COLD:
7057                         spell_damcalc(m_ptr, GF_COLD, dam, &dummy_max);
7058                         dam = dummy_max;
7059                         check_wraith_form = FALSE;
7060                         break;
7061
7062                 case RBE_DR_MANA:
7063                         dam = 0;
7064                         check_wraith_form = FALSE;
7065                         break;
7066                 }
7067
7068                 if (check_wraith_form && p_ptr->wraith_form)
7069                 {
7070                         dam /= 2;
7071                         if (!dam) dam = 1;
7072                 }
7073         }
7074         else
7075         {
7076                 dam = (dam + 1) / 2;
7077                 spell_damcalc(m_ptr, mbe_info[blow_ptr->effect].explode_type, dam, &dummy_max);
7078                 dam = dummy_max;
7079         }
7080
7081         return dam;
7082 }
7083
7084 /*!
7085  * @brief プレイヤーが特定地点へ移動した場合に警告を発する処理 /
7086  * Examine the grid (xx,yy) and warn the player if there are any danger
7087  * @param xx 危険性を調査するマスのX座標
7088  * @param yy 危険性を調査するマスのY座標
7089  * @return 警告を無視して進むことを選択するかか問題が無ければTRUE、警告に従ったならFALSEを返す。
7090  */
7091 bool process_warning(int xx, int yy)
7092 {
7093         int mx, my;
7094         cave_type *c_ptr;
7095         char o_name[MAX_NLEN];
7096
7097 #define WARNING_AWARE_RANGE 12
7098         int dam_max = 0;
7099         static int old_damage = 0;
7100
7101         for (mx = xx - WARNING_AWARE_RANGE; mx < xx + WARNING_AWARE_RANGE + 1; mx++)
7102         {
7103                 for (my = yy - WARNING_AWARE_RANGE; my < yy + WARNING_AWARE_RANGE + 1; my++)
7104                 {
7105                         int dam_max0 = 0;
7106                         monster_type *m_ptr;
7107                         monster_race *r_ptr;
7108
7109                         if (!in_bounds(my, mx) || (distance(my, mx, yy, xx) > WARNING_AWARE_RANGE)) continue;
7110
7111                         c_ptr = &cave[my][mx];
7112
7113                         if (!c_ptr->m_idx) continue;
7114
7115                         m_ptr = &m_list[c_ptr->m_idx];
7116
7117                         if (MON_CSLEEP(m_ptr)) continue;
7118                         if (!is_hostile(m_ptr)) continue;
7119
7120                         r_ptr = &r_info[m_ptr->r_idx];
7121
7122                         /* Monster spells (only powerful ones)*/
7123                         if (projectable(my, mx, yy, xx))
7124             {
7125                                 u32b f4 = r_ptr->flags4;
7126                                 u32b f5 = r_ptr->a_ability_flags1;
7127                                 u32b f6 = r_ptr->a_ability_flags2;
7128
7129                                 if (!(d_info[dungeon_type].flags1 & DF1_NO_MAGIC))
7130                                 {
7131                     if (f4 & RF4_BA_CHAO) spell_damcalc_by_spellnum(MS_BALL_CHAOS, GF_CHAOS, c_ptr->m_idx,  &dam_max0);
7132                     if (f5 & RF5_BA_MANA) spell_damcalc_by_spellnum(MS_BALL_MANA, GF_MANA, c_ptr->m_idx, &dam_max0);
7133                     if (f5 & RF5_BA_DARK) spell_damcalc_by_spellnum(MS_BALL_DARK, GF_DARK, c_ptr->m_idx, &dam_max0);
7134                     if (f5 & RF5_BA_LITE) spell_damcalc_by_spellnum(MS_STARBURST, GF_LITE, c_ptr->m_idx, &dam_max0);
7135                     if (f6 & RF6_HAND_DOOM) spell_damcalc_by_spellnum(MS_HAND_DOOM, GF_HAND_DOOM, c_ptr->m_idx, &dam_max0);
7136                     if (f6 & RF6_PSY_SPEAR) spell_damcalc_by_spellnum(MS_PSY_SPEAR, GF_PSY_SPEAR, c_ptr->m_idx, &dam_max0);
7137                                 }
7138                 if (f4 & RF4_ROCKET) spell_damcalc_by_spellnum(MS_ROCKET, GF_ROCKET, c_ptr->m_idx, &dam_max0);
7139                 if (f4 & RF4_BR_ACID) spell_damcalc_by_spellnum(MS_BR_ACID, GF_ACID, c_ptr->m_idx, &dam_max0);
7140                 if (f4 & RF4_BR_ELEC) spell_damcalc_by_spellnum(MS_BR_ELEC, GF_ELEC, c_ptr->m_idx, &dam_max0);
7141                 if (f4 & RF4_BR_FIRE) spell_damcalc_by_spellnum(MS_BR_FIRE, GF_FIRE, c_ptr->m_idx, &dam_max0);
7142                 if (f4 & RF4_BR_COLD) spell_damcalc_by_spellnum(MS_BR_COLD, GF_COLD, c_ptr->m_idx, &dam_max0);
7143                 if (f4 & RF4_BR_POIS) spell_damcalc_by_spellnum(MS_BR_POIS, GF_POIS, c_ptr->m_idx, &dam_max0);
7144                 if (f4 & RF4_BR_NETH) spell_damcalc_by_spellnum(MS_BR_NETHER, GF_NETHER, c_ptr->m_idx, &dam_max0);
7145                 if (f4 & RF4_BR_LITE) spell_damcalc_by_spellnum(MS_BR_LITE, GF_LITE, c_ptr->m_idx, &dam_max0);
7146                 if (f4 & RF4_BR_DARK) spell_damcalc_by_spellnum(MS_BR_DARK, GF_DARK, c_ptr->m_idx, &dam_max0);
7147                 if (f4 & RF4_BR_CONF) spell_damcalc_by_spellnum(MS_BR_CONF, GF_CONFUSION, c_ptr->m_idx, &dam_max0);
7148                 if (f4 & RF4_BR_SOUN) spell_damcalc_by_spellnum(MS_BR_SOUND, GF_SOUND, c_ptr->m_idx, &dam_max0);
7149                 if (f4 & RF4_BR_CHAO) spell_damcalc_by_spellnum(MS_BR_CHAOS, GF_CHAOS, c_ptr->m_idx, &dam_max0);
7150                 if (f4 & RF4_BR_DISE) spell_damcalc_by_spellnum(MS_BR_DISEN, GF_DISENCHANT, c_ptr->m_idx, &dam_max0);
7151                 if (f4 & RF4_BR_NEXU) spell_damcalc_by_spellnum(MS_BR_NEXUS, GF_NEXUS, c_ptr->m_idx, &dam_max0);
7152                 if (f4 & RF4_BR_TIME) spell_damcalc_by_spellnum(MS_BR_TIME, GF_TIME, c_ptr->m_idx, &dam_max0);
7153                 if (f4 & RF4_BR_INER) spell_damcalc_by_spellnum(MS_BR_INERTIA, GF_INERTIAL, c_ptr->m_idx, &dam_max0);
7154                 if (f4 & RF4_BR_GRAV) spell_damcalc_by_spellnum(MS_BR_GRAVITY, GF_GRAVITY, c_ptr->m_idx, &dam_max0);
7155                 if (f4 & RF4_BR_SHAR) spell_damcalc_by_spellnum(MS_BR_SHARDS, GF_SHARDS, c_ptr->m_idx, &dam_max0);
7156                 if (f4 & RF4_BR_PLAS) spell_damcalc_by_spellnum(MS_BR_PLASMA, GF_PLASMA, c_ptr->m_idx, &dam_max0);
7157                 if (f4 & RF4_BR_WALL) spell_damcalc_by_spellnum(MS_BR_FORCE, GF_FORCE, c_ptr->m_idx, &dam_max0);
7158                 if (f4 & RF4_BR_MANA) spell_damcalc_by_spellnum(MS_BR_MANA, GF_MANA, c_ptr->m_idx, &dam_max0);
7159                 if (f4 & RF4_BR_NUKE) spell_damcalc_by_spellnum(MS_BR_NUKE, GF_NUKE, c_ptr->m_idx, &dam_max0);
7160                 if (f4 & RF4_BR_DISI) spell_damcalc_by_spellnum(MS_BR_DISI, GF_DISINTEGRATE, c_ptr->m_idx, &dam_max0);
7161                         }
7162
7163                         /* Monster melee attacks */
7164                         if (!(r_ptr->flags1 & RF1_NEVER_BLOW) && !(d_info[dungeon_type].flags1 & DF1_NO_MELEE))
7165                         {
7166                                 if (mx <= xx + 1 && mx >= xx - 1 && my <= yy + 1 && my >= yy - 1)
7167                                 {
7168                                         int m;
7169                                         int dam_melee = 0;
7170                                         for (m = 0; m < 4; m++)
7171                                         {
7172                                                 /* Skip non-attacks */
7173                                                 if (!r_ptr->blow[m].method || (r_ptr->blow[m].method == RBM_SHOOT)) continue;
7174
7175                                                 /* Extract the attack info */
7176                                                 dam_melee += blow_damcalc(m_ptr, &r_ptr->blow[m]);
7177                                                 if (r_ptr->blow[m].method == RBM_EXPLODE) break;
7178                                         }
7179                                         if (dam_melee > dam_max0) dam_max0 = dam_melee;
7180                                 }
7181                         }
7182
7183                         /* Contribution from this monster */
7184                         dam_max += dam_max0;
7185                 }
7186         }
7187
7188         /* Prevent excessive warning */
7189         if (dam_max > old_damage)
7190         {
7191                 old_damage = dam_max * 3 / 2;
7192
7193                 if (dam_max > p_ptr->chp / 2)
7194                 {
7195                         object_type *o_ptr = choose_warning_item();
7196
7197                         if (o_ptr)
7198                 object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7199             else
7200                 strcpy(o_name, _("体", "body")); /* Warning ability without item */
7201             msg_format(_("%sが鋭く震えた！", "Your %s pulsates sharply!"), o_name);
7202
7203                         disturb(0, 1);
7204             return get_check(_("本当にこのまま進むか？", "Really want to go ahead? "));
7205                 }
7206         }
7207         else old_damage = old_damage / 2;
7208
7209         c_ptr = &cave[yy][xx];
7210         if (((!easy_disarm && is_trap(c_ptr->feat))
7211             || (c_ptr->mimic && is_trap(c_ptr->feat))) && !one_in_(13))
7212         {
7213                 object_type *o_ptr = choose_warning_item();
7214
7215                 if (o_ptr)
7216             object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7217         else
7218             strcpy(o_name, _("体", "body")); /* Warning ability without item */
7219         msg_format(_("%sが鋭く震えた！", "Your %s pulsates sharply!"), o_name);
7220                 disturb(0, 1);
7221         return get_check(_("本当にこのまま進むか？", "Really want to go ahead? "));
7222         }
7223
7224         return TRUE;
7225 }
7226
7227 /*!
7228  * @brief エッセンスの付加可能な武器や矢弾かを返す
7229  * @param o_ptr チェックしたいオブジェクトの構造体参照ポインタ
7230  * @return エッセンスの付加可能な武器か矢弾ならばTRUEを返す。
7231  */
7232 static bool item_tester_hook_melee_ammo(object_type *o_ptr)
7233 {
7234         switch (o_ptr->tval)
7235         {
7236                 case TV_HAFTED:
7237                 case TV_POLEARM:
7238                 case TV_DIGGING:
7239                 case TV_BOLT:
7240                 case TV_ARROW:
7241                 case TV_SHOT:
7242                 {
7243                         return (TRUE);
7244                 }
7245                 case TV_SWORD:
7246                 {
7247                         if (o_ptr->sval != SV_DOKUBARI) return (TRUE);
7248                 }
7249         }
7250
7251         return (FALSE);
7252 }
7253
7254
7255 /*!
7256  * エッセンス情報の構造体 / A structure for smithing
7257  */
7258 typedef struct {
7259         int add;       /* TR flag number or special essence id */
7260         cptr add_name; /* Name of this ability */
7261         ESSENCE_IDX type;      /* Menu number */
7262         int essence;   /* Index for carrying essences */
7263         int value;     /* Needed value to add this ability */
7264 } essence_type;
7265
7266
7267 /*!
7268  * エッセンス情報テーブル Smithing type data for Weapon smith
7269  */
7270 #ifdef JP
7271 static essence_type essence_info[] =
7272 {
7273         {TR_STR, "腕力", 4, TR_STR, 20},
7274         {TR_INT, "知能", 4, TR_INT, 20},
7275         {TR_WIS, "賢さ", 4, TR_WIS, 20},
7276         {TR_DEX, "器用さ", 4, TR_DEX, 20},
7277         {TR_CON, "耐久力", 4, TR_CON, 20},
7278         {TR_CHR, "魅力", 4, TR_CHR, 20},
7279         {TR_MAGIC_MASTERY, "魔力支配", 4, TR_MAGIC_MASTERY, 20},
7280         {TR_STEALTH, "隠密", 4, TR_STEALTH, 40},
7281         {TR_SEARCH, "探索", 4, TR_SEARCH, 15},
7282         {TR_INFRA, "赤外線視力", 4, TR_INFRA, 15},
7283         {TR_TUNNEL, "採掘", 4, TR_TUNNEL, 15},
7284         {TR_SPEED, "スピード", 4, TR_SPEED, 12},
7285         {TR_BLOWS, "追加攻撃", 1, TR_BLOWS, 20},
7286         {TR_CHAOTIC, "カオス攻撃", 1, TR_CHAOTIC, 15},
7287         {TR_VAMPIRIC, "吸血攻撃", 1, TR_VAMPIRIC, 60},
7288         {TR_IMPACT, "地震発動", 7, TR_IMPACT, 15},
7289         {TR_BRAND_POIS, "毒殺", 1, TR_BRAND_POIS, 20},
7290         {TR_BRAND_ACID, "溶解", 1, TR_BRAND_ACID, 20},
7291         {TR_BRAND_ELEC, "電撃", 1, TR_BRAND_ELEC, 20},
7292         {TR_BRAND_FIRE, "焼棄", 1, TR_BRAND_FIRE, 20},
7293         {TR_BRAND_COLD, "凍結", 1, TR_BRAND_COLD, 20},
7294         {TR_SUST_STR, "腕力維持", 3, TR_SUST_STR, 15},
7295         {TR_SUST_INT, "知能維持", 3, TR_SUST_STR, 15},
7296         {TR_SUST_WIS, "賢さ維持", 3, TR_SUST_STR, 15},
7297         {TR_SUST_DEX, "器用さ維持", 3, TR_SUST_STR, 15},
7298         {TR_SUST_CON, "耐久力維持", 3, TR_SUST_STR, 15},
7299         {TR_SUST_CHR, "魅力維持", 3, TR_SUST_STR, 15},
7300         {TR_IM_ACID, "酸免疫", 2, TR_IM_ACID, 20},
7301         {TR_IM_ELEC, "電撃免疫", 2, TR_IM_ACID, 20},
7302         {TR_IM_FIRE, "火炎免疫", 2, TR_IM_ACID, 20},
7303         {TR_IM_COLD, "冷気免疫", 2, TR_IM_ACID, 20},
7304         {TR_REFLECT, "反射", 2, TR_REFLECT, 20},
7305         {TR_FREE_ACT, "麻痺知らず", 3, TR_FREE_ACT, 20},
7306         {TR_HOLD_EXP, "経験値維持", 3, TR_HOLD_EXP, 20},
7307         {TR_RES_ACID, "耐酸", 2, TR_RES_ACID, 15},
7308         {TR_RES_ELEC, "耐電撃", 2, TR_RES_ELEC, 15},
7309         {TR_RES_FIRE, "耐火炎", 2, TR_RES_FIRE, 15},
7310         {TR_RES_COLD, "耐冷気", 2, TR_RES_COLD, 15},
7311         {TR_RES_POIS, "耐毒", 2, TR_RES_POIS, 25},
7312         {TR_RES_FEAR, "耐恐怖", 2, TR_RES_FEAR, 20},
7313         {TR_RES_LITE, "耐閃光", 2, TR_RES_LITE, 20},
7314         {TR_RES_DARK, "耐暗黒", 2, TR_RES_DARK, 20},
7315         {TR_RES_BLIND, "耐盲目", 2, TR_RES_BLIND, 20},
7316         {TR_RES_CONF, "耐混乱", 2, TR_RES_CONF, 20},
7317         {TR_RES_SOUND, "耐轟音", 2, TR_RES_SOUND, 20},
7318         {TR_RES_SHARDS, "耐破片", 2, TR_RES_SHARDS, 20},
7319         {TR_RES_NETHER, "耐地獄", 2, TR_RES_NETHER, 20},
7320         {TR_RES_NEXUS, "耐因果混乱", 2, TR_RES_NEXUS, 20},
7321         {TR_RES_CHAOS, "耐カオス", 2, TR_RES_CHAOS, 20},
7322         {TR_RES_DISEN, "耐劣化", 2, TR_RES_DISEN, 20},
7323         {TR_SH_FIRE, "", 0, -2, 0},
7324         {TR_SH_ELEC, "", 0, -2, 0},
7325         {TR_SH_COLD, "", 0, -2, 0},
7326         {TR_NO_MAGIC, "反魔法", 3, TR_NO_MAGIC, 15},
7327         {TR_WARNING, "警告", 3, TR_WARNING, 20},
7328         {TR_LEVITATION, "浮遊", 3, TR_LEVITATION, 20},
7329         {TR_LITE_1, "永久光源", 3, TR_LITE_1, 15},
7330         {TR_LITE_2, "", 0, -2, 0},
7331         {TR_LITE_3, "", 0, -2, 0},
7332         {TR_SEE_INVIS, "可視透明", 3, TR_SEE_INVIS, 20},
7333         {TR_TELEPATHY, "テレパシー", 6, TR_TELEPATHY, 15},
7334         {TR_SLOW_DIGEST, "遅消化", 3, TR_SLOW_DIGEST, 15},
7335         {TR_REGEN, "急速回復", 3, TR_REGEN, 20},
7336         {TR_TELEPORT, "テレポート", 3, TR_TELEPORT, 25},
7337
7338         {TR_SLAY_EVIL, "邪悪倍打", 5, TR_SLAY_EVIL, 100},
7339         {TR_KILL_EVIL, "邪悪倍倍打", 0, TR_SLAY_EVIL, 60},
7340         {TR_SLAY_ANIMAL, "動物倍打", 5, TR_SLAY_ANIMAL, 20},
7341         {TR_KILL_ANIMAL, "動物倍倍打", 5, TR_SLAY_ANIMAL, 60},
7342         {TR_SLAY_UNDEAD, "不死倍打", 5, TR_SLAY_UNDEAD, 20},
7343         {TR_KILL_UNDEAD, "不死倍倍打", 5, TR_SLAY_UNDEAD, 60},
7344         {TR_SLAY_DEMON, "悪魔倍打", 5, TR_SLAY_DEMON, 20},
7345         {TR_KILL_DEMON, "悪魔倍倍打", 5, TR_SLAY_DEMON, 60},
7346         {TR_SLAY_ORC, "オーク倍打", 5, TR_SLAY_ORC, 15},
7347         {TR_KILL_ORC, "オーク倍倍打", 5, TR_SLAY_ORC, 60},
7348         {TR_SLAY_TROLL, "トロル倍打", 5, TR_SLAY_TROLL, 15},
7349         {TR_KILL_TROLL, "トロル倍倍打", 5, TR_SLAY_TROLL, 60},
7350         {TR_SLAY_GIANT, "巨人倍打", 5, TR_SLAY_GIANT, 20},
7351         {TR_KILL_GIANT, "巨人倍倍打", 5, TR_SLAY_GIANT, 60},
7352         {TR_SLAY_DRAGON, "竜倍打", 5, TR_SLAY_DRAGON, 20},
7353         {TR_KILL_DRAGON, "竜倍倍打", 5, TR_SLAY_DRAGON, 60},
7354         {TR_SLAY_HUMAN, "人間倍打", 5, TR_SLAY_HUMAN, 20},
7355         {TR_KILL_HUMAN, "人間倍倍打", 5, TR_SLAY_HUMAN, 60},
7356
7357         {TR_ESP_ANIMAL, "動物ESP", 6, TR_SLAY_ANIMAL, 40},
7358         {TR_ESP_UNDEAD, "不死ESP", 6, TR_SLAY_UNDEAD, 40},
7359         {TR_ESP_DEMON, "悪魔ESP", 6, TR_SLAY_DEMON, 40},
7360         {TR_ESP_ORC, "オークESP", 6, TR_SLAY_ORC, 40},
7361         {TR_ESP_TROLL, "トロルESP", 6, TR_SLAY_TROLL, 40},
7362         {TR_ESP_GIANT, "巨人ESP", 6, TR_SLAY_GIANT, 40},
7363         {TR_ESP_DRAGON, "竜ESP", 6, TR_SLAY_DRAGON, 40},
7364         {TR_ESP_HUMAN, "人間ESP", 6, TR_SLAY_HUMAN, 40},
7365
7366         {ESSENCE_ATTACK, "攻撃", 10, TR_ES_ATTACK, 30},
7367         {ESSENCE_AC, "防御", 10, TR_ES_AC, 15},
7368         {ESSENCE_TMP_RES_ACID, "酸耐性発動", 7, TR_RES_ACID, 50},
7369         {ESSENCE_TMP_RES_ELEC, "電撃耐性発動", 7, TR_RES_ELEC, 50},
7370         {ESSENCE_TMP_RES_FIRE, "火炎耐性発動", 7, TR_RES_FIRE, 50},
7371         {ESSENCE_TMP_RES_COLD, "冷気耐性発動", 7, TR_RES_COLD, 50},
7372         {ESSENCE_SH_FIRE, "火炎オーラ", 7, -1, 50},
7373         {ESSENCE_SH_ELEC, "電撃オーラ", 7, -1, 50},
7374         {ESSENCE_SH_COLD, "冷気オーラ", 7, -1, 50},
7375         {ESSENCE_RESISTANCE, "全耐性", 2, -1, 150},
7376         {ESSENCE_SUSTAIN, "装備保持", 10, -1, 10},
7377         {ESSENCE_SLAY_GLOVE, "殺戮の小手", 1, TR_ES_ATTACK, 200},
7378
7379         {-1, NULL, 0, -1, 0}
7380 };
7381 #else
7382 static essence_type essence_info[] =
7383 {
7384         {TR_STR, "strength", 4, TR_STR, 20},
7385         {TR_INT, "intelligence", 4, TR_INT, 20},
7386         {TR_WIS, "wisdom", 4, TR_WIS, 20},
7387         {TR_DEX, "dexterity", 4, TR_DEX, 20},
7388         {TR_CON, "constitution", 4, TR_CON, 20},
7389         {TR_CHR, "charisma", 4, TR_CHR, 20},
7390         {TR_MAGIC_MASTERY, "magic mastery", 4, TR_MAGIC_MASTERY, 20},
7391         {TR_STEALTH, "stealth", 4, TR_STEALTH, 40},
7392         {TR_SEARCH, "serching", 4, TR_SEARCH, 15},
7393         {TR_INFRA, "infravision", 4, TR_INFRA, 15},
7394         {TR_TUNNEL, "digging", 4, TR_TUNNEL, 15},
7395         {TR_SPEED, "speed", 4, TR_SPEED, 12},
7396         {TR_BLOWS, "extra attack", 1, TR_BLOWS, 20},
7397         {TR_CHAOTIC, "chaos brand", 1, TR_CHAOTIC, 15},
7398         {TR_VAMPIRIC, "vampiric brand", 1, TR_VAMPIRIC, 60},
7399         {TR_IMPACT, "quake activation", 7, TR_IMPACT, 15},
7400         {TR_BRAND_POIS, "poison brand", 1, TR_BRAND_POIS, 20},
7401         {TR_BRAND_ACID, "acid brand", 1, TR_BRAND_ACID, 20},
7402         {TR_BRAND_ELEC, "electric brand", 1, TR_BRAND_ELEC, 20},
7403         {TR_BRAND_FIRE, "fire brand", 1, TR_BRAND_FIRE, 20},
7404         {TR_BRAND_COLD, "cold brand", 1, TR_BRAND_COLD, 20},
7405         {TR_SUST_STR, "sustain strength", 3, TR_SUST_STR, 15},
7406         {TR_SUST_INT, "sustain intelligence", 3, TR_SUST_STR, 15},
7407         {TR_SUST_WIS, "sustain wisdom", 3, TR_SUST_STR, 15},
7408         {TR_SUST_DEX, "sustain dexterity", 3, TR_SUST_STR, 15},
7409         {TR_SUST_CON, "sustain constitution", 3, TR_SUST_STR, 15},
7410         {TR_SUST_CHR, "sustain charisma", 3, TR_SUST_STR, 15},
7411         {TR_IM_ACID, "acid immunity", 2, TR_IM_ACID, 20},
7412         {TR_IM_ELEC, "electric immunity", 2, TR_IM_ACID, 20},
7413         {TR_IM_FIRE, "fire immunity", 2, TR_IM_ACID, 20},
7414         {TR_IM_COLD, "cold immunity", 2, TR_IM_ACID, 20},
7415         {TR_REFLECT, "reflection", 2, TR_REFLECT, 20},
7416         {TR_FREE_ACT, "free action", 3, TR_FREE_ACT, 20},
7417         {TR_HOLD_EXP, "hold experience", 3, TR_HOLD_EXP, 20},
7418         {TR_RES_ACID, "resistance to acid", 2, TR_RES_ACID, 15},
7419         {TR_RES_ELEC, "resistance to electric", 2, TR_RES_ELEC, 15},
7420         {TR_RES_FIRE, "resistance to fire", 2, TR_RES_FIRE, 15},
7421         {TR_RES_COLD, "resistance to cold", 2, TR_RES_COLD, 15},
7422         {TR_RES_POIS, "resistance to poison", 2, TR_RES_POIS, 25},
7423         {TR_RES_FEAR, "resistance to fear", 2, TR_RES_FEAR, 20},
7424         {TR_RES_LITE, "resistance to light", 2, TR_RES_LITE, 20},
7425         {TR_RES_DARK, "resistance to dark", 2, TR_RES_DARK, 20},
7426         {TR_RES_BLIND, "resistance to blind", 2, TR_RES_BLIND, 20},
7427         {TR_RES_CONF, "resistance to confusion", 2, TR_RES_CONF, 20},
7428         {TR_RES_SOUND, "resistance to sound", 2, TR_RES_SOUND, 20},
7429         {TR_RES_SHARDS, "resistance to shard", 2, TR_RES_SHARDS, 20},
7430         {TR_RES_NETHER, "resistance to nether", 2, TR_RES_NETHER, 20},
7431         {TR_RES_NEXUS, "resistance to nexus", 2, TR_RES_NEXUS, 20},
7432         {TR_RES_CHAOS, "resistance to chaos", 2, TR_RES_CHAOS, 20},
7433         {TR_RES_DISEN, "resistance to disenchantment", 2, TR_RES_DISEN, 20},
7434         {TR_SH_FIRE, "", 0, -2, 0},
7435         {TR_SH_ELEC, "", 0, -2, 0},
7436         {TR_SH_COLD, "", 0, -2, 0},
7437         {TR_NO_MAGIC, "anti magic", 3, TR_NO_MAGIC, 15},
7438         {TR_WARNING, "warning", 3, TR_WARNING, 20},
7439         {TR_LEVITATION, "levitation", 3, TR_LEVITATION, 20},
7440         {TR_LITE_1, "permanent light", 3, TR_LITE_1, 15},
7441         {TR_LITE_2, "", 0, -2, 0},
7442         {TR_LITE_3, "", 0, -2, 0},
7443         {TR_SEE_INVIS, "see invisible", 3, TR_SEE_INVIS, 20},
7444         {TR_TELEPATHY, "telepathy", 6, TR_TELEPATHY, 15},
7445         {TR_SLOW_DIGEST, "slow digestion", 3, TR_SLOW_DIGEST, 15},
7446         {TR_REGEN, "regeneration", 3, TR_REGEN, 20},
7447         {TR_TELEPORT, "teleport", 3, TR_TELEPORT, 25},
7448
7449         {TR_SLAY_EVIL, "slay evil", 5, TR_SLAY_EVIL, 100},
7450         {TR_SLAY_ANIMAL, "slay animal", 5, TR_SLAY_ANIMAL, 20},
7451         {TR_KILL_ANIMAL, "kill animal", 5, TR_SLAY_ANIMAL, 60},
7452         {TR_KILL_EVIL, "kill evil", 0, TR_SLAY_EVIL, 60},
7453         {TR_SLAY_UNDEAD, "slay undead", 5, TR_SLAY_UNDEAD, 20},
7454         {TR_KILL_UNDEAD, "kill undead", 5, TR_SLAY_UNDEAD, 60},
7455         {TR_SLAY_DEMON, "slay demon", 5, TR_SLAY_DEMON, 20},
7456         {TR_KILL_DEMON, "kill demon", 5, TR_SLAY_DEMON, 60},
7457         {TR_SLAY_ORC, "slay orc", 5, TR_SLAY_ORC, 15},
7458         {TR_KILL_ORC, "kill orc", 5, TR_SLAY_ORC, 60},
7459         {TR_SLAY_TROLL, "slay troll", 5, TR_SLAY_TROLL, 15},
7460         {TR_KILL_TROLL, "kill troll", 5, TR_SLAY_TROLL, 60},
7461         {TR_SLAY_GIANT, "slay giant", 5, TR_SLAY_GIANT, 20},
7462         {TR_KILL_GIANT, "kill giant", 5, TR_SLAY_GIANT, 60},
7463         {TR_SLAY_DRAGON, "slay dragon", 5, TR_SLAY_DRAGON, 20},
7464         {TR_KILL_DRAGON, "kill dragon", 5, TR_SLAY_DRAGON, 60},
7465         {TR_SLAY_HUMAN, "slay human", 5, TR_SLAY_HUMAN, 20},
7466         {TR_KILL_HUMAN, "kill human", 5, TR_SLAY_HUMAN, 60},
7467
7468         {TR_ESP_ANIMAL, "sense animal", 6, TR_SLAY_ANIMAL, 40},
7469         {TR_ESP_UNDEAD, "sense undead", 6, TR_SLAY_UNDEAD, 40},
7470         {TR_ESP_DEMON, "sense demon", 6, TR_SLAY_DEMON, 40},
7471         {TR_ESP_ORC, "sense orc", 6, TR_SLAY_ORC, 40},
7472         {TR_ESP_TROLL, "sense troll", 6, TR_SLAY_TROLL, 40},
7473         {TR_ESP_GIANT, "sense giant", 6, TR_SLAY_GIANT, 40},
7474         {TR_ESP_DRAGON, "sense dragon", 6, TR_SLAY_DRAGON, 40},
7475         {TR_ESP_HUMAN, "sense human", 6, TR_SLAY_HUMAN, 40},
7476
7477         {ESSENCE_ATTACK, "weapon enchant", 10, TR_ES_ATTACK, 30},
7478         {ESSENCE_AC, "armor enchant", 10, TR_ES_AC, 15},
7479         {ESSENCE_TMP_RES_ACID, "resist acid activation", 7, TR_RES_ACID, 50},
7480         {ESSENCE_TMP_RES_ELEC, "resist electricity activation", 7, TR_RES_ELEC, 50},
7481         {ESSENCE_TMP_RES_FIRE, "resist fire activation", 7, TR_RES_FIRE, 50},
7482         {ESSENCE_TMP_RES_COLD, "resist cold activation", 7, TR_RES_COLD, 50},
7483         {ESSENCE_SH_FIRE, "fiery sheath", 7, -1, 50},
7484         {ESSENCE_SH_ELEC, "electric sheath", 7, -1, 50},
7485         {ESSENCE_SH_COLD, "sheath of coldness", 7, -1, 50},
7486         {ESSENCE_RESISTANCE, "resistance", 2, -1, 150},
7487         {ESSENCE_SUSTAIN, "elements proof", 10, -1, 10},
7488         {ESSENCE_SLAY_GLOVE, "gauntlets of slaying", 1, TR_ES_ATTACK, 200},
7489
7490         {-1, NULL, 0, -1, 0}
7491 };
7492 #endif
7493
7494
7495 /*!
7496  * エッセンス名テーブル / Essense names for Weapon smith
7497  */
7498 #ifdef JP
7499 cptr essence_name[] =
7500 {
7501         "腕力",
7502         "知能",
7503         "賢さ",
7504         "器用さ",
7505         "耐久力",
7506         "魅力",
7507         "魔力支配",
7508         "",
7509         "隠密",
7510         "探索",
7511         "赤外線視力",
7512         "採掘",
7513         "スピード",
7514         "追加攻撃",
7515         "カオス攻撃",
7516         "吸血攻撃",
7517         "動物倍打",
7518         "邪悪倍打",
7519         "不死倍打",
7520         "悪魔倍打",
7521         "オーク倍打",
7522         "トロル倍打",
7523         "巨人倍打",
7524         "竜倍打",
7525         "",
7526         "",
7527         "地震",
7528         "毒殺",
7529         "溶解",
7530         "電撃",
7531         "焼棄",
7532         "凍結",
7533         "能力維持",
7534         "",
7535         "",
7536         "",
7537         "",
7538         "",
7539         "",
7540         "",
7541         "免疫",
7542         "",
7543         "",
7544         "",
7545         "",
7546         "反射",
7547         "麻痺知らず",
7548         "経験値維持",
7549         "耐酸",
7550         "耐電撃",
7551         "耐火炎",
7552         "耐冷気",
7553         "耐毒",
7554         "耐恐怖",
7555         "耐閃光",
7556         "耐暗黒",
7557         "耐盲目",
7558         "耐混乱",
7559         "耐轟音",
7560         "耐破片",
7561         "耐地獄",
7562         "耐因果混乱",
7563         "耐カオス",
7564         "耐劣化",
7565         "",
7566         "",
7567         "人間倍打",
7568         "",
7569         "",
7570         "反魔法",
7571         "",
7572         "",
7573         "警告",
7574         "",
7575         "",
7576         "",
7577         "浮遊",
7578         "永久光源",
7579         "可視透明",
7580         "テレパシー",
7581         "遅消化",
7582         "急速回復",
7583         "",
7584         "",
7585         "",
7586         "",
7587         "",
7588         "",
7589         "",
7590         "",
7591         "テレポート",
7592         "",
7593         "",
7594         "攻撃",
7595         "防御",
7596
7597         NULL
7598 };
7599
7600 #else
7601
7602 cptr essence_name[] =
7603 {
7604         "strength",
7605         "intelligen.",
7606         "wisdom",
7607         "dexterity",
7608         "constitut.",
7609         "charisma",
7610         "magic mast.",
7611         "",
7612         "stealth",
7613         "serching",
7614         "infravision",
7615         "digging",
7616         "speed",
7617         "extra atk",
7618         "chaos brand",
7619         "vampiric",
7620         "slay animal",
7621         "slay evil",
7622         "slay undead",
7623         "slay demon",
7624         "slay orc",
7625         "slay troll",
7626         "slay giant",
7627         "slay dragon",
7628         "",
7629         "",
7630         "quake",
7631         "pois. brand",
7632         "acid brand",
7633         "elec. brand",
7634         "fire brand",
7635         "cold brand",
7636         "sustain",
7637         "",
7638         "",
7639         "",
7640         "",
7641         "",
7642         "",
7643         "",
7644         "immunity",
7645         "",
7646         "",
7647         "",
7648         "",
7649         "reflection",
7650         "free action",
7651         "hold exp",
7652         "res. acid",
7653         "res. elec.",
7654         "res. fire",
7655         "res. cold",
7656         "res. poison",
7657         "res. fear",
7658         "res. light",
7659         "res. dark",
7660         "res. blind",
7661         "res.confuse",
7662         "res. sound",
7663         "res. shard",
7664         "res. nether",
7665         "res. nexus",
7666         "res. chaos",
7667         "res. disen.",
7668         "",
7669         "",
7670         "slay human",
7671         "",
7672         "",
7673         "anti magic",
7674         "",
7675         "",
7676         "warning",
7677         "",
7678         "",
7679         "",
7680         "levitation",
7681         "perm. light",
7682         "see invis.",
7683         "telepathy",
7684         "slow dige.",
7685         "regen.",
7686         "",
7687         "",
7688         "",
7689         "",
7690         "",
7691         "",
7692         "",
7693         "",
7694         "teleport",
7695         "",
7696         "",
7697         "weapon enc.",
7698         "armor enc.",
7699
7700         NULL
7701 };
7702 #endif
7703
7704 /*!
7705  * @brief 所持しているエッセンス一覧を表示する
7706  * @return なし
7707  */
7708 static void display_essence(void)
7709 {
7710         int i, num = 0;
7711
7712         screen_save();
7713         for (i = 1; i < 22; i++)
7714         {
7715                 prt("",i,0);
7716         }
7717         prt(_("エッセンス   個数     エッセンス   個数     エッセンス   個数",
7718                   "Essence      Num      Essence      Num      Essence      Num "), 1, 8);
7719         for (i = 0; essence_name[i]; i++)
7720         {
7721                 if (!essence_name[i][0]) continue;
7722                 prt(format("%-11s %5d", essence_name[i], p_ptr->magic_num1[i]), 2+num%21, 8+num/21*22);
7723                 num++;
7724         }
7725         prt(_("現在所持しているエッセンス", "List of all essences you have."), 0, 0);
7726         (void)inkey();
7727         screen_load();
7728         return;
7729 }
7730
7731 /*!
7732  * @brief エッセンスの抽出処理
7733  * @return なし
7734  */
7735 static void drain_essence(void)
7736 {
7737         int drain_value[sizeof(p_ptr->magic_num1) / sizeof(s32b)];
7738         int i;
7739         OBJECT_IDX item;
7740         int dec = 4;
7741         bool observe = FALSE;
7742         int old_ds, old_dd, old_to_h, old_to_d, old_ac, old_to_a, old_pval, old_name2;
7743         TIME_EFFECT old_timeout;
7744         BIT_FLAGS old_flgs[TR_FLAG_SIZE], new_flgs[TR_FLAG_SIZE];
7745         object_type *o_ptr;
7746         cptr q, s;
7747         POSITION iy, ix;
7748         byte_hack marked;
7749         ITEM_NUMBER number;
7750         OBJECT_IDX next_o_idx;
7751         WEIGHT weight;
7752
7753         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7754                 drain_value[i] = 0;
7755
7756         item_tester_hook = object_is_weapon_armour_ammo;
7757         item_tester_no_ryoute = TRUE;
7758
7759         /* Get an item */
7760         q = _("どのアイテムから抽出しますか？", "Extract from which item? ");
7761         s = _("抽出できるアイテムがありません。", "You have nothing you can extract from.");
7762
7763         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
7764
7765         /* Get the item (in the pack) */
7766         if (item >= 0)
7767         {
7768                 o_ptr = &inventory[item];
7769         }
7770
7771         /* Get the item (on the floor) */
7772         else
7773         {
7774                 o_ptr = &o_list[0 - item];
7775         }
7776
7777         if (object_is_known(o_ptr) && !object_is_nameless(o_ptr))
7778         {
7779                 char o_name[MAX_NLEN];
7780                 object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7781                 if (!get_check(format(_("本当に%sから抽出してよろしいですか？", "Really extract from %s? "), o_name))) return;
7782         }
7783
7784         p_ptr->energy_use = 100;
7785
7786         object_flags(o_ptr, old_flgs);
7787         if (have_flag(old_flgs, TR_KILL_DRAGON)) add_flag(old_flgs, TR_SLAY_DRAGON);
7788         if (have_flag(old_flgs, TR_KILL_ANIMAL)) add_flag(old_flgs, TR_SLAY_ANIMAL);
7789         if (have_flag(old_flgs, TR_KILL_EVIL)) add_flag(old_flgs, TR_SLAY_EVIL);
7790         if (have_flag(old_flgs, TR_KILL_UNDEAD)) add_flag(old_flgs, TR_SLAY_UNDEAD);
7791         if (have_flag(old_flgs, TR_KILL_DEMON)) add_flag(old_flgs, TR_SLAY_DEMON);
7792         if (have_flag(old_flgs, TR_KILL_ORC)) add_flag(old_flgs, TR_SLAY_ORC);
7793         if (have_flag(old_flgs, TR_KILL_TROLL)) add_flag(old_flgs, TR_SLAY_TROLL);
7794         if (have_flag(old_flgs, TR_KILL_GIANT)) add_flag(old_flgs, TR_SLAY_GIANT);
7795         if (have_flag(old_flgs, TR_KILL_HUMAN)) add_flag(old_flgs, TR_SLAY_HUMAN);
7796
7797         old_to_a = o_ptr->to_a;
7798         old_ac = o_ptr->ac;
7799         old_to_h = o_ptr->to_h;
7800         old_to_d = o_ptr->to_d;
7801         old_ds = o_ptr->ds;
7802         old_dd = o_ptr->dd;
7803         old_pval = o_ptr->pval;
7804         old_name2 = o_ptr->name2;
7805         old_timeout = o_ptr->timeout;
7806         if (o_ptr->curse_flags & (TRC_CURSED | TRC_HEAVY_CURSE | TRC_PERMA_CURSE)) dec--;
7807         if (have_flag(old_flgs, TR_ADD_L_CURSE)) dec--;
7808         if (have_flag(old_flgs, TR_ADD_H_CURSE)) dec--;
7809         if (have_flag(old_flgs, TR_AGGRAVATE)) dec--;
7810         if (have_flag(old_flgs, TR_NO_TELE)) dec--;
7811         if (have_flag(old_flgs, TR_DRAIN_EXP)) dec--;
7812         if (have_flag(old_flgs, TR_DRAIN_HP)) dec--;
7813         if (have_flag(old_flgs, TR_DRAIN_MANA)) dec--;
7814         if (have_flag(old_flgs, TR_CALL_ANIMAL)) dec--;
7815         if (have_flag(old_flgs, TR_CALL_DEMON)) dec--;
7816         if (have_flag(old_flgs, TR_CALL_DRAGON)) dec--;
7817         if (have_flag(old_flgs, TR_CALL_UNDEAD)) dec--;
7818         if (have_flag(old_flgs, TR_COWARDICE)) dec--;
7819         if (have_flag(old_flgs, TR_LOW_MELEE)) dec--;
7820         if (have_flag(old_flgs, TR_LOW_AC)) dec--;
7821         if (have_flag(old_flgs, TR_LOW_MAGIC)) dec--;
7822         if (have_flag(old_flgs, TR_FAST_DIGEST)) dec--;
7823         if (have_flag(old_flgs, TR_SLOW_REGEN)) dec--;
7824         if (have_flag(old_flgs, TR_TY_CURSE)) dec--;
7825
7826         iy = o_ptr->iy;
7827         ix = o_ptr->ix;
7828         next_o_idx = o_ptr->next_o_idx;
7829         marked = o_ptr->marked;
7830         weight = o_ptr->weight;
7831         number = o_ptr->number;
7832
7833         object_prep(o_ptr, o_ptr->k_idx);
7834
7835         o_ptr->iy=iy;
7836         o_ptr->ix=ix;
7837         o_ptr->next_o_idx=next_o_idx;
7838         o_ptr->marked=marked;
7839         o_ptr->number = number;
7840         if (o_ptr->tval == TV_DRAG_ARMOR) o_ptr->timeout = old_timeout;
7841         if (item >= 0) p_ptr->total_weight += (o_ptr->weight*o_ptr->number - weight*number);
7842         o_ptr->ident |= (IDENT_MENTAL);
7843         object_aware(o_ptr);
7844         object_known(o_ptr);
7845
7846         object_flags(o_ptr, new_flgs);
7847
7848         for (i = 0; essence_info[i].add_name; i++)
7849         {
7850                 essence_type *es_ptr = &essence_info[i];
7851                 PARAMETER_VALUE pval = 0;
7852
7853                 if (es_ptr->add < TR_FLAG_MAX && is_pval_flag(es_ptr->add) && old_pval)
7854                         pval = (have_flag(new_flgs, es_ptr->add)) ? old_pval - o_ptr->pval : old_pval;
7855
7856                 if (es_ptr->add < TR_FLAG_MAX &&
7857                     (!have_flag(new_flgs, es_ptr->add) || pval) &&
7858                     have_flag(old_flgs, es_ptr->add))
7859                 {
7860                         if (pval)
7861                         {
7862                                 drain_value[es_ptr->essence] += 10 * pval;
7863                         }
7864                         else if (es_ptr->essence != -2)
7865                         {
7866                                 drain_value[es_ptr->essence] += 10;
7867                         }
7868                         else if (es_ptr->add == TR_SH_FIRE)
7869                         {
7870                                 drain_value[TR_BRAND_FIRE] += 10;
7871                                 drain_value[TR_RES_FIRE] += 10;
7872                         }
7873                         else if (es_ptr->add == TR_SH_ELEC)
7874                         {
7875                                 drain_value[TR_BRAND_ELEC] += 10;
7876                                 drain_value[TR_RES_ELEC] += 10;
7877                         }
7878                         else if (es_ptr->add == TR_SH_COLD)
7879                         {
7880                                 drain_value[TR_BRAND_COLD] += 10;
7881                                 drain_value[TR_RES_COLD] += 10;
7882                         }
7883                         else if (es_ptr->add == TR_LITE_2)
7884                         {
7885                                 drain_value[TR_LITE_1] += 20;
7886                         }
7887                         else if (es_ptr->add == TR_LITE_3)
7888                         {
7889                                 drain_value[TR_LITE_1] += 30;
7890                         }
7891                 }
7892         }
7893
7894         if ((have_flag(old_flgs, TR_FORCE_WEAPON)) && !(have_flag(new_flgs, TR_FORCE_WEAPON)))
7895         {
7896                 drain_value[TR_INT] += 5;
7897                 drain_value[TR_WIS] += 5;
7898         }
7899         if ((have_flag(old_flgs, TR_VORPAL)) && !(have_flag(new_flgs, TR_VORPAL)))
7900         {
7901                 drain_value[TR_BRAND_POIS] += 5;
7902                 drain_value[TR_BRAND_ACID] += 5;
7903                 drain_value[TR_BRAND_ELEC] += 5;
7904                 drain_value[TR_BRAND_FIRE] += 5;
7905                 drain_value[TR_BRAND_COLD] += 5;
7906         }
7907         if ((have_flag(old_flgs, TR_DEC_MANA)) && !(have_flag(new_flgs, TR_DEC_MANA)))
7908         {
7909                 drain_value[TR_INT] += 10;
7910         }
7911         if ((have_flag(old_flgs, TR_XTRA_MIGHT)) && !(have_flag(new_flgs, TR_XTRA_MIGHT)))
7912         {
7913                 drain_value[TR_STR] += 10;
7914         }
7915         if ((have_flag(old_flgs, TR_XTRA_SHOTS)) && !(have_flag(new_flgs, TR_XTRA_SHOTS)))
7916         {
7917                 drain_value[TR_DEX] += 10;
7918         }
7919         if (old_name2 == EGO_2WEAPON)
7920         {
7921                 drain_value[TR_DEX] += 20;
7922         }
7923         if (object_is_weapon_ammo(o_ptr))
7924         {
7925                 if (old_ds > o_ptr->ds) drain_value[TR_ES_ATTACK] += (old_ds-o_ptr->ds)*10;
7926
7927                 if (old_dd > o_ptr->dd) drain_value[TR_ES_ATTACK] += (old_dd-o_ptr->dd)*10;
7928         }
7929         if (old_to_h > o_ptr->to_h) drain_value[TR_ES_ATTACK] += (old_to_h-o_ptr->to_h)*10;
7930         if (old_to_d > o_ptr->to_d) drain_value[TR_ES_ATTACK] += (old_to_d-o_ptr->to_d)*10;
7931         if (old_ac > o_ptr->ac) drain_value[TR_ES_AC] += (old_ac-o_ptr->ac)*10;
7932         if (old_to_a > o_ptr->to_a) drain_value[TR_ES_AC] += (old_to_a-o_ptr->to_a)*10;
7933
7934         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7935         {
7936                 drain_value[i] *= number;
7937                 drain_value[i] = drain_value[i] * dec / 4;
7938                 drain_value[i] = MAX(drain_value[i], 0);
7939                 if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) drain_value[i] /= 10;
7940                 if (drain_value[i])
7941                 {
7942                         observe = TRUE;
7943                 }
7944         }
7945         if (!observe)
7946         {
7947                 msg_print(_("エッセンスは抽出できませんでした。", "You were not able to extract any essence."));
7948         }
7949         else
7950         {
7951                 msg_print(_("抽出したエッセンス:", "Extracted essences:"));
7952
7953                 for (i = 0; essence_name[i]; i++)
7954                 {
7955                         if (!essence_name[i][0]) continue;
7956                         if (!drain_value[i]) continue;
7957
7958                         p_ptr->magic_num1[i] += drain_value[i];
7959                         p_ptr->magic_num1[i] = MIN(20000, p_ptr->magic_num1[i]);
7960                         msg_print(NULL);
7961                         msg_format("%s...%d%s", essence_name[i], drain_value[i], _("。", ". "));
7962                 }
7963         }
7964
7965         /* Apply autodestroy/inscription to the drained item */
7966         autopick_alter_item(item, TRUE);
7967
7968         /* Combine the pack */
7969         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
7970
7971         /* Window stuff */
7972         p_ptr->window |= (PW_INVEN);
7973 }
7974
7975 /*!
7976  * @brief 付加するエッセンスの大別を選択する
7977  * @return 選んだエッセンスの大別ID
7978  */
7979 static COMMAND_CODE choose_essence(void)
7980 {
7981         COMMAND_CODE mode = 0;
7982         char choice;
7983         COMMAND_CODE menu_line = (use_menu ? 1 : 0);
7984
7985 #ifdef JP
7986         cptr menu_name[] = {
7987                 "武器属性",
7988                 "耐性",
7989                 "能力",
7990                 "数値",
7991                 "スレイ",
7992                 "ESP",
7993                 "その他"
7994         };
7995 #else
7996         cptr menu_name[] = {
7997                 "Brand weapon",
7998                 "Resistance",
7999                 "Ability",
8000                 "Magic number",
8001                 "Slay",
8002                 "ESP",
8003                 "Others"
8004         };
8005 #endif
8006         const COMMAND_CODE mode_max = 7;
8007
8008 #ifdef ALLOW_REPEAT
8009         if (repeat_pull(&mode) && 1 <= mode && mode <= mode_max)
8010                 return mode;
8011         mode = 0;
8012 #endif /* ALLOW_REPEAT */
8013
8014         if (use_menu)
8015         {
8016                 screen_save();
8017
8018                 while(!mode)
8019                 {
8020                         int i;
8021                         for (i = 0; i < mode_max; i++)
8022 #ifdef JP
8023                                 prt(format(" %s %s", (menu_line == 1+i) ? "》" : "  ", menu_name[i]), 2 + i, 14);
8024                         prt("どの種類のエッセンス付加を行いますか？", 0, 0);
8025 #else
8026                                 prt(format(" %s %s", (menu_line == 1+i) ? "> " : "  ", menu_name[i]), 2 + i, 14);
8027                         prt("Choose from menu.", 0, 0);
8028 #endif
8029
8030                         choice = inkey();
8031                         switch(choice)
8032                         {
8033                         case ESCAPE:
8034                         case 'z':
8035                         case 'Z':
8036                                 screen_load();
8037                                 return 0;
8038                         case '2':
8039                         case 'j':
8040                         case 'J':
8041                                 menu_line++;
8042                                 break;
8043                         case '8':
8044                         case 'k':
8045                         case 'K':
8046                                 menu_line += mode_max - 1;
8047                                 break;
8048                         case '\r':
8049                         case '\n':
8050                         case 'x':
8051                         case 'X':
8052                                 mode = menu_line;
8053                                 break;
8054                         }
8055                         if (menu_line > mode_max) menu_line -= mode_max;
8056                 }
8057                 screen_load();
8058         }
8059         else
8060         {
8061                 screen_save();
8062                 while (!mode)
8063                 {
8064                         int i;
8065
8066                         for (i = 0; i < mode_max; i++)
8067                                 prt(format("  %c) %s", 'a' + i, menu_name[i]), 2 + i, 14);
8068
8069                         if (!get_com(_("何を付加しますか:", "Command :"), &choice, TRUE))
8070                         {
8071                                 screen_load();
8072                                 return 0;
8073                         }
8074
8075                         if (isupper(choice)) choice = (char)tolower(choice);
8076
8077                         if ('a' <= choice && choice <= 'a' + (char)mode_max - 1)
8078                                 mode = (int)choice - 'a' + 1;
8079                 }
8080                 screen_load();
8081         }
8082
8083 #ifdef ALLOW_REPEAT
8084         repeat_push(mode);
8085 #endif /* ALLOW_REPEAT */
8086         return mode;
8087 }
8088
8089 /*!
8090  * @brief エッセンスを実際に付加する
8091  * @param mode エッセンスの大別ID
8092  * @return なし
8093  */
8094 static void add_essence(ESSENCE_IDX mode)
8095 {
8096         OBJECT_IDX item;
8097         int max_num = 0;
8098         COMMAND_CODE i;
8099         bool flag,redraw;
8100         char choice;
8101         cptr            q, s;
8102         object_type *o_ptr;
8103         int ask = TRUE;
8104         char out_val[160];
8105         int num[22];
8106         char o_name[MAX_NLEN];
8107         int use_essence;
8108         essence_type *es_ptr;
8109
8110         int menu_line = (use_menu ? 1 : 0);
8111
8112         for (i = 0; essence_info[i].add_name; i++)
8113         {
8114                 es_ptr = &essence_info[i];
8115
8116                 if (es_ptr->type != mode) continue;
8117                 num[max_num++] = i;
8118         }
8119
8120 #ifdef ALLOW_REPEAT
8121         if (!repeat_pull(&i) || i<0 || i>=max_num)
8122         {
8123 #endif /* ALLOW_REPEAT */
8124
8125
8126         /* Nothing chosen yet */
8127         flag = FALSE;
8128
8129         /* No redraw yet */
8130         redraw = FALSE;
8131
8132         /* Build a prompt */
8133         (void) strnfmt(out_val, 78, _("('*'で一覧, ESCで中断) どの能力を付加しますか？", "(*=List, ESC=exit) Add which ability? "));
8134         if (use_menu) screen_save();
8135
8136         /* Get a spell from the user */
8137
8138         choice = (always_show_list || use_menu) ? ESCAPE:1;
8139         while (!flag)
8140         {
8141                 bool able[22] = {0};
8142                 if( choice==ESCAPE ) choice = ' ';
8143                 else if( !get_com(out_val, &choice, FALSE) )break;
8144
8145                 if (use_menu && choice != ' ')
8146                 {
8147                         switch(choice)
8148                         {
8149                                 case '0':
8150                                 {
8151                                         screen_load();
8152                                         return;
8153                                 }
8154
8155                                 case '8':
8156                                 case 'k':
8157                                 case 'K':
8158                                 {
8159                                         menu_line += (max_num-1);
8160                                         break;
8161                                 }
8162
8163                                 case '2':
8164                                 case 'j':
8165                                 case 'J':
8166                                 {
8167                                         menu_line++;
8168                                         break;
8169                                 }
8170
8171                                 case '4':
8172                                 case 'h':
8173                                 case 'H':
8174                                 {
8175                                         menu_line = 1;
8176                                         break;
8177                                 }
8178                                 case '6':
8179                                 case 'l':
8180                                 case 'L':
8181                                 {
8182                                         menu_line = max_num;
8183                                         break;
8184                                 }
8185
8186                                 case 'x':
8187                                 case 'X':
8188                                 case '\r':
8189                                 case '\n':
8190                                 {
8191                                         i = menu_line - 1;
8192                                         ask = FALSE;
8193                                         break;
8194                                 }
8195                         }
8196                         if (menu_line > max_num) menu_line -= max_num;
8197                 }
8198                 /* Request redraw */
8199                 if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask))
8200                 {
8201                         /* Show the list */
8202                         if (!redraw || use_menu)
8203                         {
8204                                 byte y, x = 10;
8205                                 int ctr;
8206                                 char dummy[80], dummy2[80];
8207                                 byte col;
8208
8209                                 strcpy(dummy, "");
8210
8211                                 /* Show list */
8212                                 redraw = TRUE;
8213
8214                                 /* Save the screen */
8215                                 if (!use_menu) screen_save();
8216
8217                                 for (y = 1; y < 24; y++)
8218                                         prt("", y, x);
8219
8220                                 /* Print header(s) */
8221 #ifdef JP
8222                                 prt(format("   %-43s %6s/%s", "能力(必要エッセンス)", "必要数", "所持数"), 1, x);
8223
8224 #else
8225                                 prt(format("   %-43s %6s/%s", "Ability (needed essence)", "Needs", "Possess"), 1, x);
8226 #endif
8227                                 /* Print list */
8228                                 for (ctr = 0; ctr < max_num; ctr++)
8229                                 {
8230                                         es_ptr = &essence_info[num[ctr]];
8231
8232                                         if (use_menu)
8233                                         {
8234                                                 if (ctr == (menu_line-1))
8235                                                         strcpy(dummy, _("》 ", ">  "));
8236                                                 else strcpy(dummy, "   ");
8237
8238                                         }
8239                                         /* letter/number for power selection */
8240                                         else
8241                                         {
8242                                                 sprintf(dummy, "%c) ",I2A(ctr));
8243                                         }
8244
8245                                         strcat(dummy, es_ptr->add_name);
8246
8247                                         col = TERM_WHITE;
8248                                         able[ctr] = TRUE;
8249
8250                                         if (es_ptr->essence != -1)
8251                                         {
8252                                                 strcat(dummy, format("(%s)", essence_name[es_ptr->essence]));
8253                                                 if (p_ptr->magic_num1[es_ptr->essence] < es_ptr->value) able[ctr] = FALSE;
8254                                         }
8255                                         else
8256                                         {
8257                                                 switch(es_ptr->add)
8258                                                 {
8259                                                 case ESSENCE_SH_FIRE:
8260                                                         strcat(dummy, _("(焼棄+耐火炎)", "(brand fire + res.fire)"));
8261                                                         if (p_ptr->magic_num1[TR_BRAND_FIRE] < es_ptr->value) able[ctr] = FALSE;
8262                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8263                                                         break;
8264                                                 case ESSENCE_SH_ELEC:
8265                                                         strcat(dummy, _("(電撃+耐電撃)", "(brand elec. + res. elec.)"));
8266                                                         if (p_ptr->magic_num1[TR_BRAND_ELEC] < es_ptr->value) able[ctr] = FALSE;
8267                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8268                                                         break;
8269                                                 case ESSENCE_SH_COLD:
8270                                                         strcat(dummy, _("(凍結+耐冷気)", "(brand cold + res. cold)"));
8271                                                         if (p_ptr->magic_num1[TR_BRAND_COLD] < es_ptr->value) able[ctr] = FALSE;
8272                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8273                                                         break;
8274                                                 case ESSENCE_RESISTANCE:
8275                                                         strcat(dummy, _("(耐火炎+耐冷気+耐電撃+耐酸)", "(r.fire+r.cold+r.elec+r.acid)"));
8276                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8277                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8278                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8279                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8280                                                         break;
8281                                                 case ESSENCE_SUSTAIN:
8282                                                         strcat(dummy, _("(耐火炎+耐冷気+耐電撃+耐酸)", "(r.fire+r.cold+r.elec+r.acid)"));
8283                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8284                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8285                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8286                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8287                                                         break;
8288                                                 }
8289                                         }
8290
8291                                         if (!able[ctr]) col = TERM_RED;
8292
8293                                         if (es_ptr->essence != -1)
8294                                         {
8295                                                 sprintf(dummy2, "%-49s %3d/%d", dummy, es_ptr->value, (int)p_ptr->magic_num1[es_ptr->essence]);
8296                                         }
8297                                         else
8298                                         {
8299                                                 sprintf(dummy2, "%-49s %3d/(\?\?)", dummy, es_ptr->value);
8300                                         }
8301
8302                                         c_prt(col, dummy2, ctr+2, x);
8303                                 }
8304                         }
8305
8306                         /* Hide the list */
8307                         else
8308                         {
8309                                 /* Hide list */
8310                                 redraw = FALSE;
8311
8312                                 /* Restore the screen */
8313                                 screen_load();
8314                         }
8315
8316                         /* Redo asking */
8317                         continue;
8318                 }
8319
8320                 if (!use_menu)
8321                 {
8322                         /* Note verify */
8323                         ask = (isupper(choice));
8324
8325                         /* Lowercase */
8326                         if (ask) choice = (char)tolower(choice);
8327
8328                         /* Extract request */
8329                         i = (islower(choice) ? A2I(choice) : -1);
8330                 }
8331
8332                 /* Totally Illegal */
8333                 if ((i < 0) || (i >= max_num) || !able[i])
8334                 {
8335                         bell();
8336                         continue;
8337                 }
8338
8339                 /* Verify it */
8340                 if (ask)
8341                 {
8342                         char tmp_val[160];
8343
8344                         /* Prompt */
8345                         (void) strnfmt(tmp_val, 78, _("%sを付加しますか？ ", "Add the abilitiy of %s? "), essence_info[num[i]].add_name);
8346
8347                         /* Belay that order */
8348                         if (!get_check(tmp_val)) continue;
8349                 }
8350
8351                 /* Stop the loop */
8352                 flag = TRUE;
8353         }
8354
8355         /* Restore the screen */
8356         if (redraw) screen_load();
8357
8358         if (!flag) return;
8359
8360 #ifdef ALLOW_REPEAT
8361         repeat_push(i);
8362         }
8363 #endif /* ALLOW_REPEAT */
8364
8365         es_ptr = &essence_info[num[i]];
8366
8367         if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8368                 item_tester_tval = TV_GLOVES;
8369         else if (mode == 1 || mode == 5)
8370                 item_tester_hook = item_tester_hook_melee_ammo;
8371         else if (es_ptr->add == ESSENCE_ATTACK)
8372                 item_tester_hook = object_allow_enchant_weapon;
8373         else if (es_ptr->add == ESSENCE_AC)
8374                 item_tester_hook = object_is_armour;
8375         else
8376                 item_tester_hook = object_is_weapon_armour_ammo;
8377         item_tester_no_ryoute = TRUE;
8378
8379         /* Get an item */
8380         q = _("どのアイテムを改良しますか？", "Improve which item? ");
8381         s = _("改良できるアイテムがありません。", "You have nothing to improve.");
8382
8383         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8384
8385         /* Get the item (in the pack) */
8386         if (item >= 0)
8387         {
8388                 o_ptr = &inventory[item];
8389         }
8390
8391         /* Get the item (on the floor) */
8392         else
8393         {
8394                 o_ptr = &o_list[0 - item];
8395         }
8396
8397         if ((mode != 10) && (object_is_artifact(o_ptr) || object_is_smith(o_ptr)))
8398         {
8399                 msg_print(_("そのアイテムはこれ以上改良できない。", "This item is no more able to be improved."));
8400                 return;
8401         }
8402
8403         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8404
8405         use_essence = es_ptr->value;
8406         if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) use_essence = (use_essence+9)/10;
8407         if (o_ptr->number > 1)
8408         {
8409                 use_essence *= o_ptr->number;
8410                 msg_format(_("%d個あるのでエッセンスは%d必要です。", "It will take %d essences."), o_ptr->number, use_essence);
8411         }
8412
8413         if (es_ptr->essence != -1)
8414         {
8415                 if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8416                 {
8417                         msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8418                         return;
8419                 }
8420                 if (is_pval_flag(es_ptr->add))
8421                 {
8422                         if (o_ptr->pval < 0)
8423                         {
8424                                 msg_print(_("このアイテムの能力修正を強化することはできない。", "You cannot increase magic number of this item."));
8425                                 return;
8426                         }
8427                         else if (es_ptr->add == TR_BLOWS)
8428                         {
8429                                 if (o_ptr->pval > 1)
8430                                 {
8431                                         if (!get_check(_("修正値は1になります。よろしいですか？", "The magic number of this weapon will become 1. Are you sure? "))) return;
8432                                 }
8433
8434                                 o_ptr->pval = 1;
8435                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8436                         }
8437                         else if (o_ptr->pval > 0)
8438                         {
8439                                 use_essence *= o_ptr->pval;
8440                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8441                         }
8442                         else
8443                         {
8444                                 char tmp[80];
8445                                 char tmp_val[160];
8446                                 PARAMETER_VALUE pval;
8447                                 PARAMETER_VALUE limit = MIN(5, p_ptr->magic_num1[es_ptr->essence]/es_ptr->value);
8448
8449                                 sprintf(tmp, _("いくつ付加しますか？ (1-%d): ", "Enchant how many? (1-%d): "), limit);
8450                                 strcpy(tmp_val, "1");
8451
8452                                 if (!get_string(tmp, tmp_val, 1)) return;
8453                                 pval = (PARAMETER_VALUE)atoi(tmp_val);
8454                                 if (pval > limit) pval = limit;
8455                                 else if (pval < 1) pval = 1;
8456                                 o_ptr->pval += pval;
8457                                 use_essence *= pval;
8458                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8459                         }
8460
8461                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8462                         {
8463                                 msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8464                                 return;
8465                         }
8466                 }
8467                 else if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8468                 {
8469                         char tmp_val[160];
8470                         int val;
8471                         HIT_PROB get_to_h;
8472                         HIT_POINT get_to_d;
8473
8474                         strcpy(tmp_val, "1");
8475                         if (!get_string(format(_("いくつ付加しますか？ (1-%d):", "Enchant how many? (1-%d):"), p_ptr->lev/7+3), tmp_val, 2)) return;
8476                         val = atoi(tmp_val);
8477                         if (val > p_ptr->lev/7+3) val = p_ptr->lev/7+3;
8478                         else if (val < 1) val = 1;
8479                         use_essence *= val;
8480                         msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8481                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8482                         {
8483                                 msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8484                                 return;
8485                         }
8486                         get_to_h = ((val+1)/2+randint0(val/2+1));
8487                         get_to_d = ((val+1)/2+randint0(val/2+1));
8488                         o_ptr->xtra4 = (get_to_h<<8)+get_to_d;
8489                         o_ptr->to_h += get_to_h;
8490                         o_ptr->to_d += get_to_d;
8491                 }
8492                 p_ptr->magic_num1[es_ptr->essence] -= use_essence;
8493                 if (es_ptr->add == ESSENCE_ATTACK)
8494                 {
8495                         if ((o_ptr->to_h >= p_ptr->lev/5+5) && (o_ptr->to_d >= p_ptr->lev/5+5))
8496                         {
8497                                 msg_print(_("改良に失敗した。", "You failed to enchant."));
8498                                 p_ptr->energy_use = 100;
8499                                 return;
8500                         }
8501                         else
8502                         {
8503                                 if (o_ptr->to_h < p_ptr->lev/5+5) o_ptr->to_h++;
8504                                 if (o_ptr->to_d < p_ptr->lev/5+5) o_ptr->to_d++;
8505                         }
8506                 }
8507                 else if (es_ptr->add == ESSENCE_AC)
8508                 {
8509                         if (o_ptr->to_a >= p_ptr->lev/5+5)
8510                         {
8511                                 msg_print(_("改良に失敗した。", "You failed to enchant."));
8512                                 p_ptr->energy_use = 100;
8513                                 return;
8514                         }
8515                         else
8516                         {
8517                                 if (o_ptr->to_a < p_ptr->lev/5+5) o_ptr->to_a++;
8518                         }
8519                 }
8520                 else
8521                 {
8522                         o_ptr->xtra3 = es_ptr->add + 1;
8523                 }
8524         }
8525         else
8526         {
8527                 bool success = TRUE;
8528
8529                 switch(es_ptr->add)
8530                 {
8531                 case ESSENCE_SH_FIRE:
8532                         if ((p_ptr->magic_num1[TR_BRAND_FIRE] < use_essence) || (p_ptr->magic_num1[TR_RES_FIRE] < use_essence))
8533                         {
8534                                 success = FALSE;
8535                                 break;
8536                         }
8537                         p_ptr->magic_num1[TR_BRAND_FIRE] -= use_essence;
8538                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8539                         break;
8540                 case ESSENCE_SH_ELEC:
8541                         if ((p_ptr->magic_num1[TR_BRAND_ELEC] < use_essence) || (p_ptr->magic_num1[TR_RES_ELEC] < use_essence))
8542                         {
8543                                 success = FALSE;
8544                                 break;
8545                         }
8546                         p_ptr->magic_num1[TR_BRAND_ELEC] -= use_essence;
8547                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8548                         break;
8549                 case ESSENCE_SH_COLD:
8550                         if ((p_ptr->magic_num1[TR_BRAND_COLD] < use_essence) || (p_ptr->magic_num1[TR_RES_COLD] < use_essence))
8551                         {
8552                                 success = FALSE;
8553                                 break;
8554                         }
8555                         p_ptr->magic_num1[TR_BRAND_COLD] -= use_essence;
8556                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8557                         break;
8558                 case ESSENCE_RESISTANCE:
8559                 case ESSENCE_SUSTAIN:
8560                         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))
8561                         {
8562                                 success = FALSE;
8563                                 break;
8564                         }
8565                         p_ptr->magic_num1[TR_RES_ACID] -= use_essence;
8566                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8567                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8568                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8569                         break;
8570                 }
8571                 if (!success)
8572                 {
8573                         msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8574                         return;
8575                 }
8576                 if (es_ptr->add == ESSENCE_SUSTAIN)
8577                 {
8578                         add_flag(o_ptr->art_flags, TR_IGNORE_ACID);
8579                         add_flag(o_ptr->art_flags, TR_IGNORE_ELEC);
8580                         add_flag(o_ptr->art_flags, TR_IGNORE_FIRE);
8581                         add_flag(o_ptr->art_flags, TR_IGNORE_COLD);
8582                 }
8583                 else
8584                 {
8585                         o_ptr->xtra3 = es_ptr->add + 1;
8586                 }
8587         }
8588
8589         p_ptr->energy_use = 100;
8590
8591 #ifdef JP
8592         msg_format("%sに%sの能力を付加しました。", o_name, es_ptr->add_name);
8593 #else
8594         msg_format("You have added ability of %s to %s.", es_ptr->add_name, o_name);
8595 #endif
8596
8597         /* Combine the pack */
8598         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8599
8600         /* Window stuff */
8601         p_ptr->window |= (PW_INVEN);
8602 }
8603
8604 /*!
8605  * @brief エッセンスを消去する
8606  * @return なし
8607  */
8608 static void erase_essence(void)
8609 {
8610         OBJECT_IDX item;
8611         cptr q, s;
8612         object_type *o_ptr;
8613         char o_name[MAX_NLEN];
8614         BIT_FLAGS flgs[TR_FLAG_SIZE];
8615
8616         item_tester_hook = object_is_smith;
8617
8618         /* Get an item */
8619         q = _("どのアイテムのエッセンスを消去しますか？", "Remove from which item? ");
8620         s = _("エッセンスを付加したアイテムがありません。", "You have nothing to remove essence.");
8621
8622         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8623
8624         /* Get the item (in the pack) */
8625         if (item >= 0)
8626         {
8627                 o_ptr = &inventory[item];
8628         }
8629
8630         /* Get the item (on the floor) */
8631         else
8632         {
8633                 o_ptr = &o_list[0 - item];
8634         }
8635
8636         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8637         if (!get_check(format(_("よろしいですか？ [%s]", "Are you sure? [%s]"), o_name))) return;
8638
8639         p_ptr->energy_use = 100;
8640
8641         if (o_ptr->xtra3 == 1+ESSENCE_SLAY_GLOVE)
8642         {
8643                 o_ptr->to_h -= (o_ptr->xtra4>>8);
8644                 o_ptr->to_d -= (o_ptr->xtra4 & 0x000f);
8645                 o_ptr->xtra4 = 0;
8646                 if (o_ptr->to_h < 0) o_ptr->to_h = 0;
8647                 if (o_ptr->to_d < 0) o_ptr->to_d = 0;
8648         }
8649         o_ptr->xtra3 = 0;
8650         object_flags(o_ptr, flgs);
8651         if (!(have_pval_flags(flgs))) o_ptr->pval = 0;
8652         msg_print(_("エッセンスを取り去った。", "You removed all essence you have added."));
8653
8654         /* Combine the pack */
8655         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8656
8657         /* Window stuff */
8658         p_ptr->window |= (PW_INVEN);
8659 }
8660
8661 /*!
8662  * @brief 鍛冶コマンドのメインルーチン
8663  * @param only_browse TRUEならばエッセンス一覧の表示のみを行う
8664  * @return なし
8665  */
8666 void do_cmd_kaji(bool only_browse)
8667 {
8668         COMMAND_CODE mode = 0;
8669         char choice;
8670
8671         COMMAND_CODE menu_line = (use_menu ? 1 : 0);
8672
8673         if (!only_browse)
8674         {
8675                 if (p_ptr->confused)
8676                 {
8677                         msg_print(_("混乱していて作業できない！", "You are too confused!"));
8678                         return;
8679                 }
8680                 if (p_ptr->blind)
8681                 {
8682                         msg_print(_("目が見えなくて作業できない！", "You are blind!"));
8683                         return;
8684                 }
8685                 if (p_ptr->image)
8686                 {
8687                         msg_print(_("うまく見えなくて作業できない！", "You are hallucinating!"));
8688                         return;
8689                 }
8690         }
8691
8692 #ifdef ALLOW_REPEAT
8693         if (!(repeat_pull(&mode) && 1 <= mode && mode <= 5))
8694         {
8695 #endif /* ALLOW_REPEAT */
8696
8697         if (only_browse) screen_save();
8698         do {
8699         if (!only_browse) screen_save();
8700         if (use_menu)
8701         {
8702                 while(!mode)
8703                 {
8704 #ifdef JP
8705                         prt(format(" %s エッセンス一覧", (menu_line == 1) ? "》" : "  "), 2, 14);
8706                         prt(format(" %s エッセンス抽出", (menu_line == 2) ? "》" : "  "), 3, 14);
8707                         prt(format(" %s エッセンス消去", (menu_line == 3) ? "》" : "  "), 4, 14);
8708                         prt(format(" %s エッセンス付加", (menu_line == 4) ? "》" : "  "), 5, 14);
8709                         prt(format(" %s 武器/防具強化", (menu_line == 5) ? "》" : "  "), 6, 14);
8710                         prt(format("どの種類の技術を%sますか？", only_browse ? "調べ" : "使い"), 0, 0);
8711 #else
8712                         prt(format(" %s List essences", (menu_line == 1) ? "> " : "  "), 2, 14);
8713                         prt(format(" %s Extract essence", (menu_line == 2) ? "> " : "  "), 3, 14);
8714                         prt(format(" %s Remove essence", (menu_line == 3) ? "> " : "  "), 4, 14);
8715                         prt(format(" %s Add essence", (menu_line == 4) ? "> " : "  "), 5, 14);
8716                         prt(format(" %s Enchant weapon/armor", (menu_line == 5) ? "> " : "  "), 6, 14);
8717                         prt(format("Choose command from menu."), 0, 0);
8718 #endif
8719                         choice = inkey();
8720                         switch(choice)
8721                         {
8722                         case ESCAPE:
8723                         case 'z':
8724                         case 'Z':
8725                                 screen_load();
8726                                 return;
8727                         case '2':
8728                         case 'j':
8729                         case 'J':
8730                                 menu_line++;
8731                                 break;
8732                         case '8':
8733                         case 'k':
8734                         case 'K':
8735                                 menu_line+= 4;
8736                                 break;
8737                         case '\r':
8738                         case '\n':
8739                         case 'x':
8740                         case 'X':
8741                                 mode = menu_line;
8742                                 break;
8743                         }
8744                         if (menu_line > 5) menu_line -= 5;
8745                 }
8746         }
8747
8748         else
8749         {
8750                 while (!mode)
8751                 {
8752 #ifdef JP
8753                         prt("  a) エッセンス一覧", 2, 14);
8754                         prt("  b) エッセンス抽出", 3, 14);
8755                         prt("  c) エッセンス消去", 4, 14);
8756                         prt("  d) エッセンス付加", 5, 14);
8757                         prt("  e) 武器/防具強化", 6, 14);
8758                         if (!get_com(format("どの能力を%sますか:", only_browse ? "調べ" : "使い"), &choice, TRUE))
8759 #else
8760                         prt("  a) List essences", 2, 14);
8761                         prt("  b) Extract essence", 3, 14);
8762                         prt("  c) Remove essence", 4, 14);
8763                         prt("  d) Add essence", 5, 14);
8764                         prt("  e) Enchant weapon/armor", 6, 14);
8765                         if (!get_com("Command :", &choice, TRUE))
8766 #endif
8767                         {
8768                                 screen_load();
8769                                 return;
8770                         }
8771                         switch (choice)
8772                         {
8773                         case 'A':
8774                         case 'a':
8775                                 mode = 1;
8776                                 break;
8777                         case 'B':
8778                         case 'b':
8779                                 mode = 2;
8780                                 break;
8781                         case 'C':
8782                         case 'c':
8783                                 mode = 3;
8784                                 break;
8785                         case 'D':
8786                         case 'd':
8787                                 mode = 4;
8788                                 break;
8789                         case 'E':
8790                         case 'e':
8791                                 mode = 5;
8792                                 break;
8793                         }
8794                 }
8795         }
8796
8797         if (only_browse)
8798         {
8799                 char temp[62*5];
8800                 int line, j;
8801
8802                 /* Clear lines, position cursor  (really should use strlen here) */
8803                 Term_erase(14, 21, 255);
8804                 Term_erase(14, 20, 255);
8805                 Term_erase(14, 19, 255);
8806                 Term_erase(14, 18, 255);
8807                 Term_erase(14, 17, 255);
8808                 Term_erase(14, 16, 255);
8809
8810                 roff_to_buf(kaji_tips[mode-1], 62, temp, sizeof(temp));
8811                 for(j=0, line = 17;temp[j];j+=(1+strlen(&temp[j])))
8812                 {
8813                         prt(&temp[j], line, 15);
8814                         line++;
8815                 }
8816                 mode = 0;
8817         }
8818         if (!only_browse) screen_load();
8819         } while (only_browse);
8820 #ifdef ALLOW_REPEAT
8821         repeat_push(mode);
8822         }
8823 #endif /* ALLOW_REPEAT */
8824
8825         switch(mode)
8826         {
8827                 case 1: display_essence();break;
8828                 case 2: drain_essence();break;
8829                 case 3: erase_essence();break;
8830                 case 4:
8831                         mode = choose_essence();
8832                         if (mode == 0)
8833                                 break;
8834                         add_essence(mode);
8835                         break;
8836                 case 5: add_essence(10);break;
8837         }
8838 }
8839
8840
8841 /*!
8842  * @brief 投擲時たいまつに投げやすい/焼棄/アンデッドスレイの特別効果を返す。
8843  * Torches have special abilities when they are flaming.
8844  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8845  * @param flgs 特別に追加するフラグを返す参照ポインタ
8846  * @return なし
8847  */
8848 void torch_flags(object_type *o_ptr, u32b *flgs)
8849 {
8850         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8851         {
8852                 if (o_ptr->xtra4 > 0)
8853                 {
8854                         add_flag(flgs, TR_BRAND_FIRE);
8855                         add_flag(flgs, TR_KILL_UNDEAD);
8856                         add_flag(flgs, TR_THROW);
8857                 }
8858         }
8859 }
8860
8861 /*!
8862  * @brief 投擲時たいまつにダイスを与える。
8863  * Torches have special abilities when they are flaming.
8864  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8865  * @param dd 特別なダイス数を返す参照ポインタ
8866  * @param ds 特別なダイス面数を返す参照ポインタ
8867  * @return なし
8868  */
8869 void torch_dice(object_type *o_ptr, int *dd, int *ds)
8870 {
8871         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8872         {
8873                 if (o_ptr->xtra4 > 0)
8874                 {
8875                         (*dd) = 1;
8876                         (*ds) = 6;
8877                 }
8878         }
8879 }
8880
8881 /*!
8882  * @brief 投擲時命中したたいまつの寿命を縮める。
8883  * Torches have special abilities when they are flaming.
8884  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8885  * @return なし
8886  */
8887 void torch_lost_fuel(object_type *o_ptr)
8888 {
8889         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8890         {
8891                 o_ptr->xtra4 -= (FUEL_TORCH / 25);
8892                 if (o_ptr->xtra4 < 0) o_ptr->xtra4 = 0;
8893         }
8894 }