src/object2.c

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