src/object2.c

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