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