src/object2.c

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