src/object2.c

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