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