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