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