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                                 if((o_ptr->name2 == EGO_PROTECTION) || (o_ptr->name2 == EGO_S_PROTECTION))
4405                                 {
4406                                         o_ptr->to_a = MAX(o_ptr->to_a, 15);
4407                                 }
4408                         }
4409
4410                         /* Hack -- obtain pval */
4411                         if (e_ptr->max_pval)
4412                         {
4413                                 if ((o_ptr->name2 == EGO_HA) && (have_flag(o_ptr->art_flags, TR_BLOWS)))
4414                                 {
4415                                         o_ptr->pval++;
4416                                         if ((lev > 60) && one_in_(3) && ((o_ptr->dd*(o_ptr->ds+1)) < 15)) o_ptr->pval++;
4417                                 }
4418                                 else if (o_ptr->name2 == EGO_DEMON)
4419                                 {
4420                                         o_ptr->curse_flags |= (TRC_CURSED);
4421                                         if(one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
4422                                         if(have_flag(o_ptr->art_flags, TR_BLOWS))
4423                                         {
4424                                                 o_ptr->pval += randint1(2);
4425                                         }
4426                                         else
4427                                         {
4428                                                 o_ptr->pval += randint1(e_ptr->max_pval);
4429                                         }
4430                                 }
4431                                 else if (o_ptr->name2 == EGO_ATTACKS)
4432                                 {
4433                                         o_ptr->pval = randint1(e_ptr->max_pval*lev/100+1);
4434                                         if (o_ptr->pval > 3) o_ptr->pval = 3;
4435                                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA))
4436                                                 o_ptr->pval += randint1(2);
4437                                 }
4438                                 else if (o_ptr->name2 == EGO_BAT)
4439                                 {
4440                                         o_ptr->pval = randint1(e_ptr->max_pval);
4441                                         if (o_ptr->sval == SV_ELVEN_CLOAK) o_ptr->pval += randint1(2);
4442                                 }
4443                                 else
4444                                 {
4445                                         o_ptr->pval += randint1(e_ptr->max_pval);
4446                                 }
4447                         }
4448                         if ((o_ptr->name2 == EGO_SPEED) && (lev < 50))
4449                         {
4450                                 o_ptr->pval = randint1(o_ptr->pval);
4451                         }
4452                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA) && (o_ptr->pval > 2) && (o_ptr->name2 != EGO_ATTACKS))
4453                                 o_ptr->pval = 2;
4454                 }
4455
4456                 /* Cheat -- describe the item */
4457                 if (cheat_peek) object_mention(o_ptr);
4458
4459                 /* Done */
4460                 return;
4461         }
4462
4463         /* Examine real objects */
4464         if (o_ptr->k_idx)
4465         {
4466                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
4467
4468                 /* Hack -- acquire "broken" flag */
4469                 if (!k_info[o_ptr->k_idx].cost) o_ptr->ident |= (IDENT_BROKEN);
4470
4471                 /* Hack -- acquire "cursed" flag */
4472                 if (k_ptr->gen_flags & (TRG_CURSED)) o_ptr->curse_flags |= (TRC_CURSED);
4473                 if (k_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= TRC_HEAVY_CURSE;
4474                 if (k_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= TRC_PERMA_CURSE;
4475                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4476                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4477                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4478         }
4479 }
4480
4481
4482 /*
4483  * Hack -- determine if a template is "good"
4484  */
4485 static bool kind_is_good(int k_idx)
4486 {
4487         object_kind *k_ptr = &k_info[k_idx];
4488
4489         /* Analyze the item type */
4490         switch (k_ptr->tval)
4491         {
4492                 /* Armor -- Good unless damaged */
4493                 case TV_HARD_ARMOR:
4494                 case TV_SOFT_ARMOR:
4495                 case TV_DRAG_ARMOR:
4496                 case TV_SHIELD:
4497                 case TV_CLOAK:
4498                 case TV_BOOTS:
4499                 case TV_GLOVES:
4500                 case TV_HELM:
4501                 case TV_CROWN:
4502                 {
4503                         if (k_ptr->to_a < 0) return (FALSE);
4504                         return (TRUE);
4505                 }
4506
4507                 /* Weapons -- Good unless damaged */
4508                 case TV_BOW:
4509                 case TV_SWORD:
4510                 case TV_HAFTED:
4511                 case TV_POLEARM:
4512                 case TV_DIGGING:
4513                 {
4514                         if (k_ptr->to_h < 0) return (FALSE);
4515                         if (k_ptr->to_d < 0) return (FALSE);
4516                         return (TRUE);
4517                 }
4518
4519                 /* Ammo -- Arrows/Bolts are good */
4520                 case TV_BOLT:
4521                 case TV_ARROW:
4522                 {
4523                         return (TRUE);
4524                 }
4525
4526                 /* Books -- High level books are good (except Arcane books) */
4527                 case TV_LIFE_BOOK:
4528                 case TV_SORCERY_BOOK:
4529                 case TV_NATURE_BOOK:
4530                 case TV_CHAOS_BOOK:
4531                 case TV_DEATH_BOOK:
4532                 case TV_TRUMP_BOOK:
4533                 case TV_CRAFT_BOOK:
4534                 case TV_DAEMON_BOOK:
4535                 case TV_CRUSADE_BOOK:
4536                 case TV_MUSIC_BOOK:
4537                 case TV_HISSATSU_BOOK:
4538                 case TV_HEX_BOOK:
4539                 {
4540                         if (k_ptr->sval >= SV_BOOK_MIN_GOOD) return (TRUE);
4541                         return (FALSE);
4542                 }
4543
4544                 /* Rings -- Rings of Speed are good */
4545                 case TV_RING:
4546                 {
4547                         if (k_ptr->sval == SV_RING_SPEED) return (TRUE);
4548                         if (k_ptr->sval == SV_RING_LORDLY) return (TRUE);
4549                         return (FALSE);
4550                 }
4551
4552                 /* Amulets -- Amulets of the Magi and Resistance are good */
4553                 case TV_AMULET:
4554                 {
4555                         if (k_ptr->sval == SV_AMULET_THE_MAGI) return (TRUE);
4556                         if (k_ptr->sval == SV_AMULET_RESISTANCE) return (TRUE);
4557                         return (FALSE);
4558                 }
4559         }
4560
4561         /* Assume not good */
4562         return (FALSE);
4563 }
4564
4565
4566 /*
4567  * Attempt to make an object (normal or good/great)
4568  *
4569  * This routine plays nasty games to generate the "special artifacts".
4570  *
4571  * This routine uses "object_level" for the "generation level".
4572  *
4573  * We assume that the given object has been "wiped".
4574  */
4575 bool make_object(object_type *j_ptr, u32b mode)
4576 {
4577         int prob, base;
4578         byte obj_level;
4579
4580
4581         /* Chance of "special object" */
4582         prob = ((mode & AM_GOOD) ? 10 : 1000);
4583
4584         /* Base level for the object */
4585         base = ((mode & AM_GOOD) ? (object_level + 10) : object_level);
4586
4587
4588         /* Generate a special object, or a normal object */
4589         if (!one_in_(prob) || !make_artifact_special(j_ptr))
4590         {
4591                 int k_idx;
4592
4593                 /* Good objects */
4594                 if ((mode & AM_GOOD) && !get_obj_num_hook)
4595                 {
4596                         /* Activate restriction (if already specified, use that) */
4597                         get_obj_num_hook = kind_is_good;
4598                 }
4599
4600                 /* Restricted objects - prepare allocation table */
4601                 if (get_obj_num_hook) get_obj_num_prep();
4602
4603                 /* Pick a random object */
4604                 k_idx = get_obj_num(base);
4605
4606                 /* Restricted objects */
4607                 if (get_obj_num_hook)
4608                 {
4609                         /* Clear restriction */
4610                         get_obj_num_hook = NULL;
4611
4612                         /* Reset allocation table to default */
4613                         get_obj_num_prep();
4614                 }
4615
4616                 /* Handle failure */
4617                 if (!k_idx) return (FALSE);
4618
4619                 /* Prepare the object */
4620                 object_prep(j_ptr, k_idx);
4621         }
4622
4623         /* Apply magic (allow artifacts) */
4624         apply_magic(j_ptr, object_level, mode);
4625
4626         /* Hack -- generate multiple spikes/missiles */
4627         switch (j_ptr->tval)
4628         {
4629                 case TV_SPIKE:
4630                 case TV_SHOT:
4631                 case TV_ARROW:
4632                 case TV_BOLT:
4633                 {
4634                         if (!j_ptr->name1)
4635                                 j_ptr->number = (byte)damroll(6, 7);
4636                 }
4637         }
4638
4639         obj_level = k_info[j_ptr->k_idx].level;
4640         if (object_is_fixed_artifact(j_ptr)) obj_level = a_info[j_ptr->name1].level;
4641
4642         /* Notice "okay" out-of-depth objects */
4643         if (!object_is_cursed(j_ptr) && !object_is_broken(j_ptr) &&
4644             (obj_level > dun_level))
4645         {
4646                 /* Cheat -- peek at items */
4647                 if (cheat_peek) object_mention(j_ptr);
4648         }
4649
4650         /* Success */
4651         return (TRUE);
4652 }
4653
4654
4655 /*
4656  * Attempt to place an object (normal or good/great) at the given location.
4657  *
4658  * This routine plays nasty games to generate the "special artifacts".
4659  *
4660  * This routine uses "object_level" for the "generation level".
4661  *
4662  * This routine requires a clean floor grid destination.
4663  */
4664 void place_object(int y, int x, u32b mode)
4665 {
4666         s16b o_idx;
4667
4668         /* Acquire grid */
4669         cave_type *c_ptr = &cave[y][x];
4670
4671         object_type forge;
4672         object_type *q_ptr;
4673
4674
4675         /* Paranoia -- check bounds */
4676         if (!in_bounds(y, x)) return;
4677
4678         /* Require floor space */
4679         if (!cave_drop_bold(y, x)) return;
4680
4681         /* Avoid stacking on other objects */
4682         if (c_ptr->o_idx) return;
4683
4684
4685         /* Get local object */
4686         q_ptr = &forge;
4687
4688         /* Wipe the object */
4689         object_wipe(q_ptr);
4690
4691         /* Make an object (if possible) */
4692         if (!make_object(q_ptr, mode)) return;
4693
4694
4695         /* Make an object */
4696         o_idx = o_pop();
4697
4698         /* Success */
4699         if (o_idx)
4700         {
4701                 object_type *o_ptr;
4702
4703                 /* Acquire object */
4704                 o_ptr = &o_list[o_idx];
4705
4706                 /* Structure Copy */
4707                 object_copy(o_ptr, q_ptr);
4708
4709                 /* Location */
4710                 o_ptr->iy = y;
4711                 o_ptr->ix = x;
4712
4713                 /* Build a stack */
4714                 o_ptr->next_o_idx = c_ptr->o_idx;
4715
4716                 /* Place the object */
4717                 c_ptr->o_idx = o_idx;
4718
4719                 /* Notice */
4720                 note_spot(y, x);
4721
4722                 /* Redraw */
4723                 lite_spot(y, x);
4724         }
4725         else
4726         {
4727                 /* Hack -- Preserve artifacts */
4728                 if (object_is_fixed_artifact(q_ptr))
4729                 {
4730                         a_info[q_ptr->name1].cur_num = 0;
4731                 }
4732         }
4733 }
4734
4735
4736 /*
4737  * Make a treasure object
4738  *
4739  * The location must be a legal, clean, floor grid.
4740  */
4741 bool make_gold(object_type *j_ptr)
4742 {
4743         int i;
4744
4745         s32b base;
4746
4747
4748         /* Hack -- Pick a Treasure variety */
4749         i = ((randint1(object_level + 2) + 2) / 2) - 1;
4750
4751         /* Apply "extra" magic */
4752         if (one_in_(GREAT_OBJ))
4753         {
4754                 i += randint1(object_level + 1);
4755         }
4756
4757         /* Hack -- Creeping Coins only generate "themselves" */
4758         if (coin_type) i = coin_type;
4759
4760         /* Do not create "illegal" Treasure Types */
4761         if (i >= MAX_GOLD) i = MAX_GOLD - 1;
4762
4763         /* Prepare a gold object */
4764         object_prep(j_ptr, OBJ_GOLD_LIST + i);
4765
4766         /* Hack -- Base coin cost */
4767         base = k_info[OBJ_GOLD_LIST+i].cost;
4768
4769         /* Determine how much the treasure is "worth" */
4770         j_ptr->pval = (base + (8L * randint1(base)) + randint1(8));
4771
4772         /* Success */
4773         return (TRUE);
4774 }
4775
4776
4777 /*
4778  * Places a treasure (Gold or Gems) at given location
4779  *
4780  * The location must be a legal, clean, floor grid.
4781  */
4782 void place_gold(int y, int x)
4783 {
4784         s16b o_idx;
4785
4786         /* Acquire grid */
4787         cave_type *c_ptr = &cave[y][x];
4788
4789
4790         object_type forge;
4791         object_type *q_ptr;
4792
4793
4794         /* Paranoia -- check bounds */
4795         if (!in_bounds(y, x)) return;
4796
4797         /* Require floor space */
4798         if (!cave_drop_bold(y, x)) return;
4799
4800         /* Avoid stacking on other objects */
4801         if (c_ptr->o_idx) return;
4802
4803
4804         /* Get local object */
4805         q_ptr = &forge;
4806
4807         /* Wipe the object */
4808         object_wipe(q_ptr);
4809
4810         /* Make some gold */
4811         if (!make_gold(q_ptr)) return;
4812
4813
4814         /* Make an object */
4815         o_idx = o_pop();
4816
4817         /* Success */
4818         if (o_idx)
4819         {
4820                 object_type *o_ptr;
4821
4822                 /* Acquire object */
4823                 o_ptr = &o_list[o_idx];
4824
4825                 /* Copy the object */
4826                 object_copy(o_ptr, q_ptr);
4827
4828                 /* Save location */
4829                 o_ptr->iy = y;
4830                 o_ptr->ix = x;
4831
4832                 /* Build a stack */
4833                 o_ptr->next_o_idx = c_ptr->o_idx;
4834
4835                 /* Place the object */
4836                 c_ptr->o_idx = o_idx;
4837
4838                 /* Notice */
4839                 note_spot(y, x);
4840
4841                 /* Redraw */
4842                 lite_spot(y, x);
4843         }
4844 }
4845
4846
4847 /*
4848  * Let an object fall to the ground at or near a location.
4849  *
4850  * The initial location is assumed to be "in_bounds()".
4851  *
4852  * This function takes a parameter "chance".  This is the percentage
4853  * chance that the item will "disappear" instead of drop.  If the object
4854  * has been thrown, then this is the chance of disappearance on contact.
4855  *
4856  * Hack -- this function uses "chance" to determine if it should produce
4857  * some form of "description" of the drop event (under the player).
4858  *
4859  * We check several locations to see if we can find a location at which
4860  * the object can combine, stack, or be placed.  Artifacts will try very
4861  * hard to be placed, including "teleporting" to a useful grid if needed.
4862  */
4863 s16b drop_near(object_type *j_ptr, int chance, int y, int x)
4864 {
4865         int i, k, d, s;
4866
4867         int bs, bn;
4868         int by, bx;
4869         int dy, dx;
4870         int ty, tx = 0;
4871
4872         s16b o_idx = 0;
4873
4874         s16b this_o_idx, next_o_idx = 0;
4875
4876         cave_type *c_ptr;
4877
4878         char o_name[MAX_NLEN];
4879
4880         bool flag = FALSE;
4881         bool done = FALSE;
4882
4883 #ifndef JP
4884         /* Extract plural */
4885         bool plural = (j_ptr->number != 1);
4886 #endif
4887
4888         /* Describe object */
4889         object_desc(o_name, j_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
4890
4891
4892         /* Handle normal "breakage" */
4893         if (!object_is_artifact(j_ptr) && (randint0(100) < chance))
4894         {
4895                 /* Message */
4896 #ifdef JP
4897                 msg_format("%s¤Ï¾Ã¤¨¤¿¡£", o_name);
4898 #else
4899                 msg_format("The %s disappear%s.",
4900                            o_name, (plural ? "" : "s"));
4901 #endif
4902
4903
4904                 /* Debug */
4905 #ifdef JP
4906                 if (p_ptr->wizard) msg_print("(ÇËÂ»)");
4907 #else
4908                 if (p_ptr->wizard) msg_print("(breakage)");
4909 #endif
4910
4911
4912                 /* Failure */
4913                 return (0);
4914         }
4915
4916
4917         /* Score */
4918         bs = -1;
4919
4920         /* Picker */
4921         bn = 0;
4922
4923         /* Default */
4924         by = y;
4925         bx = x;
4926
4927         /* Scan local grids */
4928         for (dy = -3; dy <= 3; dy++)
4929         {
4930                 /* Scan local grids */
4931                 for (dx = -3; dx <= 3; dx++)
4932                 {
4933                         bool comb = FALSE;
4934
4935                         /* Calculate actual distance */
4936                         d = (dy * dy) + (dx * dx);
4937
4938                         /* Ignore distant grids */
4939                         if (d > 10) continue;
4940
4941                         /* Location */
4942                         ty = y + dy;
4943                         tx = x + dx;
4944
4945                         /* Skip illegal grids */
4946                         if (!in_bounds(ty, tx)) continue;
4947
4948                         /* Require line of projection */
4949                         if (!projectable(y, x, ty, tx)) continue;
4950
4951                         /* Obtain grid */
4952                         c_ptr = &cave[ty][tx];
4953
4954                         /* Require floor space */
4955                         if (!cave_drop_bold(ty, tx)) continue;
4956
4957                         /* No objects */
4958                         k = 0;
4959
4960                         /* Scan objects in that grid */
4961                         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
4962                         {
4963                                 object_type *o_ptr;
4964
4965                                 /* Acquire object */
4966                                 o_ptr = &o_list[this_o_idx];
4967
4968                                 /* Acquire next object */
4969                                 next_o_idx = o_ptr->next_o_idx;
4970
4971                                 /* Check for possible combination */
4972                                 if (object_similar(o_ptr, j_ptr)) comb = TRUE;
4973
4974                                 /* Count objects */
4975                                 k++;
4976                         }
4977
4978                         /* Add new object */
4979                         if (!comb) k++;
4980
4981                         /* Paranoia */
4982                         if (k > 99) continue;
4983
4984                         /* Calculate score */
4985                         s = 1000 - (d + k * 5);
4986
4987                         /* Skip bad values */
4988                         if (s < bs) continue;
4989
4990                         /* New best value */
4991                         if (s > bs) bn = 0;
4992
4993                         /* Apply the randomizer to equivalent values */
4994                         if ((++bn >= 2) && !one_in_(bn)) continue;
4995
4996                         /* Keep score */
4997                         bs = s;
4998
4999                         /* Track it */
5000                         by = ty;
5001                         bx = tx;
5002
5003                         /* Okay */
5004                         flag = TRUE;
5005                 }
5006         }
5007
5008
5009         /* Handle lack of space */
5010         if (!flag && !object_is_artifact(j_ptr))
5011         {
5012                 /* Message */
5013 #ifdef JP
5014                 msg_format("%s¤Ï¾Ã¤¨¤¿¡£", o_name);
5015 #else
5016                 msg_format("The %s disappear%s.",
5017                            o_name, (plural ? "" : "s"));
5018 #endif
5019
5020
5021                 /* Debug */
5022 #ifdef JP
5023                 if (p_ptr->wizard) msg_print("(¾²¥¹¥Ú¡¼¥¹¤¬¤Ê¤¤)");
5024 #else
5025                 if (p_ptr->wizard) msg_print("(no floor space)");
5026 #endif
5027
5028
5029                 /* Failure */
5030                 return (0);
5031         }
5032
5033
5034         /* Find a grid */
5035         for (i = 0; !flag && (i < 1000); i++)
5036         {
5037                 /* Bounce around */
5038                 ty = rand_spread(by, 1);
5039                 tx = rand_spread(bx, 1);
5040
5041                 /* Verify location */
5042                 if (!in_bounds(ty, tx)) continue;
5043
5044                 /* Bounce to that location */
5045                 by = ty;
5046                 bx = tx;
5047
5048                 /* Require floor space */
5049                 if (!cave_drop_bold(by, bx)) continue;
5050
5051                 /* Okay */
5052                 flag = TRUE;
5053         }
5054
5055
5056         if (!flag)
5057         {
5058                 int candidates = 0, pick;
5059
5060                 for (ty = 1; ty < cur_hgt - 1; ty++)
5061                 {
5062                         for (tx = 1; tx < cur_wid - 1; tx++)
5063                         {
5064                                 /* A valid space found */
5065                                 if (cave_drop_bold(ty, tx)) candidates++;
5066                         }
5067                 }
5068
5069                 /* No valid place! */
5070                 if (!candidates)
5071                 {
5072                         /* Message */
5073 #ifdef JP
5074                         msg_format("%s¤Ï¾Ã¤¨¤¿¡£", o_name);
5075 #else
5076                         msg_format("The %s disappear%s.", o_name, (plural ? "" : "s"));
5077 #endif
5078
5079                         /* Debug */
5080 #ifdef JP
5081                         if (p_ptr->wizard) msg_print("(¾²¥¹¥Ú¡¼¥¹¤¬¤Ê¤¤)");
5082 #else
5083                         if (p_ptr->wizard) msg_print("(no floor space)");
5084 #endif
5085
5086                         /* Mega-Hack -- preserve artifacts */
5087                         if (preserve_mode)
5088                         {
5089                                 /* Hack -- Preserve unknown artifacts */
5090                                 if (object_is_fixed_artifact(j_ptr) && !object_is_known(j_ptr))
5091                                 {
5092                                         /* Mega-Hack -- Preserve the artifact */
5093                                         a_info[j_ptr->name1].cur_num = 0;
5094                                 }
5095                         }
5096
5097                         /* Failure */
5098                         return 0;
5099                 }
5100
5101                 /* Choose a random one */
5102                 pick = randint1(candidates);
5103
5104                 for (ty = 1; ty < cur_hgt - 1; ty++)
5105                 {
5106                         for (tx = 1; tx < cur_wid - 1; tx++)
5107                         {
5108                                 if (cave_drop_bold(ty, tx))
5109                                 {
5110                                         pick--;
5111
5112                                         /* Is this a picked one? */
5113                                         if (!pick) break;
5114                                 }
5115                         }
5116
5117                         if (!pick) break;
5118                 }
5119
5120                 by = ty;
5121                 bx = tx;
5122         }
5123
5124
5125         /* Grid */
5126         c_ptr = &cave[by][bx];
5127
5128         /* Scan objects in that grid for combination */
5129         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
5130         {
5131                 object_type *o_ptr;
5132
5133                 /* Acquire object */
5134                 o_ptr = &o_list[this_o_idx];
5135
5136                 /* Acquire next object */
5137                 next_o_idx = o_ptr->next_o_idx;
5138
5139                 /* Check for combination */
5140                 if (object_similar(o_ptr, j_ptr))
5141                 {
5142                         /* Combine the items */
5143                         object_absorb(o_ptr, j_ptr);
5144
5145                         /* Success */
5146                         done = TRUE;
5147
5148                         /* Done */
5149                         break;
5150                 }
5151         }
5152
5153         /* Get new object */
5154         if (!done) o_idx = o_pop();
5155
5156         /* Failure */
5157         if (!done && !o_idx)
5158         {
5159                 /* Message */
5160 #ifdef JP
5161                 msg_format("%s¤Ï¾Ã¤¨¤¿¡£", o_name);
5162 #else
5163                 msg_format("The %s disappear%s.",
5164                            o_name, (plural ? "" : "s"));
5165 #endif
5166
5167
5168                 /* Debug */
5169 #ifdef JP
5170                 if (p_ptr->wizard) msg_print("(¥¢¥¤¥Æ¥à¤¬Â¿²á¤®¤ë)");
5171 #else
5172                 if (p_ptr->wizard) msg_print("(too many objects)");
5173 #endif
5174
5175
5176                 /* Hack -- Preserve artifacts */
5177                 if (object_is_fixed_artifact(j_ptr))
5178                 {
5179                         a_info[j_ptr->name1].cur_num = 0;
5180                 }
5181
5182                 /* Failure */
5183                 return (0);
5184         }
5185
5186         /* Stack */
5187         if (!done)
5188         {
5189                 /* Structure copy */
5190                 object_copy(&o_list[o_idx], j_ptr);
5191
5192                 /* Access new object */
5193                 j_ptr = &o_list[o_idx];
5194
5195                 /* Locate */
5196                 j_ptr->iy = by;
5197                 j_ptr->ix = bx;
5198
5199                 /* No monster */
5200                 j_ptr->held_m_idx = 0;
5201
5202                 /* Build a stack */
5203                 j_ptr->next_o_idx = c_ptr->o_idx;
5204
5205                 /* Place the object */
5206                 c_ptr->o_idx = o_idx;
5207
5208                 /* Success */
5209                 done = TRUE;
5210         }
5211
5212         /* Note the spot */
5213         note_spot(by, bx);
5214
5215         /* Draw the spot */
5216         lite_spot(by, bx);
5217
5218         /* Sound */
5219         sound(SOUND_DROP);
5220
5221         /* Mega-Hack -- no message if "dropped" by player */
5222         /* Message when an object falls under the player */
5223         if (chance && player_bold(by, bx))
5224         {
5225 #ifdef JP
5226                 msg_print("²¿¤«¤¬Â²¼¤ËÅ¾¤¬¤Ã¤Æ¤¤¿¡£");
5227 #else
5228                 msg_print("You feel something roll beneath your feet.");
5229 #endif
5230
5231         }
5232
5233         /* XXX XXX XXX */
5234
5235         /* Result */
5236         return (o_idx);
5237 }
5238
5239
5240 /*
5241  * Scatter some "great" objects near the player
5242  */
5243 void acquirement(int y1, int x1, int num, bool great, bool known)
5244 {
5245         object_type *i_ptr;
5246         object_type object_type_body;
5247         u32b mode = AM_GOOD | (great ? AM_GREAT : 0L);
5248
5249         /* Acquirement */
5250         while (num--)
5251         {
5252                 /* Get local object */
5253                 i_ptr = &object_type_body;
5254
5255                 /* Wipe the object */
5256                 object_wipe(i_ptr);
5257
5258                 /* Make a good (or great) object (if possible) */
5259                 if (!make_object(i_ptr, mode)) continue;
5260
5261                 if (known)
5262                 {
5263                         object_aware(i_ptr);
5264                         object_known(i_ptr);
5265                 }
5266
5267                 /* Drop the object */
5268                 (void)drop_near(i_ptr, -1, y1, x1);
5269         }
5270 }
5271
5272
5273 /*
5274  * Scatter some "amusing" objects near the player
5275  */
5276
5277 #define AMS_NOTHING   0x00 /* No restriction */
5278 #define AMS_NO_UNIQUE 0x01 /* Don't make the amusing object of uniques */
5279 #define AMS_FIXED_ART 0x02 /* Make a fixed artifact based on the amusing object */
5280 #define AMS_MULTIPLE  0x04 /* Drop 1-3 objects for one type */
5281 #define AMS_PILE      0x08 /* Drop 1-99 pile objects for one type */
5282
5283 typedef struct
5284 {
5285         int tval;
5286         int sval;
5287         int prob;
5288         byte flag;
5289 } amuse_type;
5290
5291 amuse_type amuse_info[] =
5292 {
5293         { TV_BOTTLE, SV_ANY, 5, AMS_NOTHING },
5294         { TV_JUNK, SV_ANY, 3, AMS_MULTIPLE },
5295         { TV_SPIKE, SV_ANY, 10, AMS_PILE },
5296         { TV_STATUE, SV_ANY, 15, AMS_NOTHING },
5297         { TV_CORPSE, SV_ANY, 15, AMS_NO_UNIQUE },
5298         { TV_SKELETON, SV_ANY, 10, AMS_NO_UNIQUE },
5299         { TV_FIGURINE, SV_ANY, 10, AMS_NO_UNIQUE },
5300         { TV_PARCHMENT, SV_ANY, 1, AMS_NOTHING },
5301         { TV_POLEARM, SV_TSURIZAO, 3, AMS_NOTHING }, //Fishing Pole of Taikobo
5302         { TV_SWORD, SV_BROKEN_DAGGER, 3, AMS_FIXED_ART }, //Broken Dagger of Magician
5303         { TV_SWORD, SV_BROKEN_DAGGER, 10, AMS_NOTHING },
5304         { TV_SWORD, SV_BROKEN_SWORD, 5, AMS_NOTHING },
5305         { TV_SCROLL, SV_SCROLL_AMUSEMENT, 10, AMS_NOTHING },
5306
5307         { 0, 0, 0 }
5308 };
5309
5310 void amusement(int y1, int x1, int num, bool known)
5311 {
5312         object_type *i_ptr;
5313         object_type object_type_body;
5314         int n, t = 0;
5315
5316         for (n = 0; amuse_info[n].tval != 0; n++)
5317         {
5318                 t += amuse_info[n].prob;
5319         }
5320
5321         /* Acquirement */
5322         while (num)
5323         {
5324                 int i, k_idx, a_idx = 0;
5325                 int r = randint0(t);
5326                 bool insta_art, fixed_art;
5327
5328                 for (i = 0; ; i++)
5329                 {
5330                         r -= amuse_info[i].prob;
5331                         if (r <= 0) break;
5332                 }
5333
5334                 /* Get local object */
5335                 i_ptr = &object_type_body;
5336
5337                 /* Wipe the object */
5338                 object_wipe(i_ptr);
5339
5340                 /* Wipe the object */
5341                 k_idx = lookup_kind(amuse_info[i].tval, amuse_info[i].sval);
5342
5343                 /* Paranoia - reroll if nothing */
5344                 if (!k_idx) continue;
5345
5346                 /* Search an artifact index if need */
5347                 insta_art = (k_info[k_idx].gen_flags & TRG_INSTA_ART);
5348                 fixed_art = (amuse_info[i].flag & AMS_FIXED_ART);
5349
5350                 if (insta_art || fixed_art)
5351                 {
5352                         for (a_idx = 1; a_idx < max_a_idx; a_idx++)
5353                         {
5354                                 if (insta_art && !(a_info[a_idx].gen_flags & TRG_INSTA_ART)) continue;
5355                                 if (a_info[a_idx].tval != k_info[k_idx].tval) continue;
5356                                 if (a_info[a_idx].sval != k_info[k_idx].sval) continue;
5357                                 if (a_info[a_idx].cur_num > 0) continue;
5358                                 break;
5359                         }
5360
5361                         if (a_idx >= max_a_idx) continue;
5362                 }
5363
5364                 /* Make an object (if possible) */
5365                 object_prep(i_ptr, k_idx);
5366                 if (a_idx) i_ptr->name1 = a_idx;
5367                 apply_magic(i_ptr, 1, AM_NO_FIXED_ART);
5368
5369                 if (amuse_info[i].flag & AMS_NO_UNIQUE)
5370                 {
5371                         if (r_info[i_ptr->pval].flags1 & RF1_UNIQUE) continue;
5372                 }
5373
5374                 if (amuse_info[i].flag & AMS_MULTIPLE) i_ptr->number = randint1(3);
5375                 if (amuse_info[i].flag & AMS_PILE) i_ptr->number = randint1(99);
5376
5377                 if (known)
5378                 {
5379                         object_aware(i_ptr);
5380                         object_known(i_ptr);
5381                 }
5382
5383                 /* Paranoia - reroll if nothing */
5384                 if (!(i_ptr->k_idx)) continue;
5385
5386                 /* Drop the object */
5387                 (void)drop_near(i_ptr, -1, y1, x1);
5388
5389                 num--;
5390         }
5391 }
5392
5393
5394 #define MAX_NORMAL_TRAPS 18
5395
5396 /* See init_feat_variables() in init2.c */
5397 static s16b normal_traps[MAX_NORMAL_TRAPS];
5398
5399 /*
5400  * Initialize arrays for normal traps
5401  */
5402 void init_normal_traps(void)
5403 {
5404         int cur_trap = 0;
5405
5406         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TRAPDOOR");
5407         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_PIT");
5408         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SPIKED_PIT");
5409         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_POISON_PIT");
5410         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TY_CURSE");
5411         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TELEPORT");
5412         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_FIRE");
5413         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_ACID");
5414         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SLOW");
5415         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_STR");
5416         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_DEX");
5417         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_CON");
5418         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_BLIND");
5419         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_CONFUSE");
5420         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_POISON");
5421         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SLEEP");
5422         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TRAPS");
5423         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_ALARM");
5424 }
5425
5426 /*
5427  * Get random trap
5428  *
5429  * XXX XXX XXX This routine should be redone to reflect trap "level".
5430  * That is, it does not make sense to have spiked pits at 50 feet.
5431  * Actually, it is not this routine, but the "trap instantiation"
5432  * code, which should also check for "trap doors" on quest levels.
5433  */
5434 s16b choose_random_trap(void)
5435 {
5436         s16b feat;
5437
5438         /* Pick a trap */
5439         while (1)
5440         {
5441                 /* Hack -- pick a trap */
5442                 feat = normal_traps[randint0(MAX_NORMAL_TRAPS)];
5443
5444                 /* Accept non-trapdoors */
5445                 if (!have_flag(f_info[feat].flags, FF_MORE)) break;
5446
5447                 /* Hack -- no trap doors on special levels */
5448                 if (p_ptr->inside_arena || quest_number(dun_level)) continue;
5449
5450                 /* Hack -- no trap doors on the deepest level */
5451                 if (dun_level >= d_info[dungeon_type].maxdepth) continue;
5452
5453                 break;
5454         }
5455
5456         return feat;
5457 }
5458
5459 /*
5460  * Disclose an invisible trap
5461  */
5462 void disclose_grid(int y, int x)
5463 {
5464         cave_type *c_ptr = &cave[y][x];
5465
5466         if (cave_have_flag_grid(c_ptr, FF_SECRET))
5467         {
5468                 /* No longer hidden */
5469                 cave_alter_feat(y, x, FF_SECRET);
5470         }
5471         else if (c_ptr->mimic)
5472         {
5473                 /* No longer hidden */
5474                 c_ptr->mimic = 0;
5475
5476                 /* Notice */
5477                 note_spot(y, x);
5478
5479                 /* Redraw */
5480                 lite_spot(y, x);
5481         }
5482 }
5483
5484
5485 /*
5486  * Places a random trap at the given location.
5487  *
5488  * The location must be a legal, naked, floor grid.
5489  *
5490  * Note that all traps start out as "invisible" and "untyped", and then
5491  * when they are "discovered" (by detecting them or setting them off),
5492  * the trap is "instantiated" as a visible, "typed", trap.
5493  */
5494 void place_trap(int y, int x)
5495 {
5496         cave_type *c_ptr = &cave[y][x];
5497
5498         /* Paranoia -- verify location */
5499         if (!in_bounds(y, x)) return;
5500
5501         /* Require empty, clean, floor grid */
5502         if (!cave_clean_bold(y, x)) return;
5503
5504         /* Place an invisible trap */
5505         c_ptr->mimic = c_ptr->feat;
5506         c_ptr->feat = choose_random_trap();
5507 }
5508
5509
5510 /*
5511  * Describe the charges on an item in the inventory.
5512  */
5513 void inven_item_charges(int item)
5514 {
5515         object_type *o_ptr = &inventory[item];
5516
5517         /* Require staff/wand */
5518         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5519
5520         /* Require known item */
5521         if (!object_is_known(o_ptr)) return;
5522
5523 #ifdef JP
5524         if (o_ptr->pval <= 0)
5525         {
5526                 msg_print("¤â¤¦ËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤Ê¤¤¡£");
5527         }
5528         else
5529         {
5530                 msg_format("¤¢¤È %d ²óÊ¬¤ÎËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤ë¡£", o_ptr->pval);
5531         }
5532 #else
5533         /* Multiple charges */
5534         if (o_ptr->pval != 1)
5535         {
5536                 /* Print a message */
5537                 msg_format("You have %d charges remaining.", o_ptr->pval);
5538         }
5539
5540         /* Single charge */
5541         else
5542         {
5543                 /* Print a message */
5544                 msg_format("You have %d charge remaining.", o_ptr->pval);
5545         }
5546 #endif
5547
5548 }
5549
5550
5551 /*
5552  * Describe an item in the inventory.
5553  */
5554 void inven_item_describe(int item)
5555 {
5556         object_type *o_ptr = &inventory[item];
5557         char        o_name[MAX_NLEN];
5558
5559         /* Get a description */
5560         object_desc(o_name, o_ptr, 0);
5561
5562         /* Print a message */
5563 #ifdef JP
5564         /* "no more" ¤Î¾ì¹ç¤Ï¤³¤Á¤é¤ÇÉ½¼¨¤¹¤ë */
5565         if (o_ptr->number <= 0)
5566         {
5567                 /*FIRST*//*¤³¤³¤Ï¤â¤¦ÄÌ¤é¤Ê¤¤¤«¤â */
5568                 msg_format("¤â¤¦%s¤ò»ý¤Ã¤Æ¤¤¤Ê¤¤¡£", o_name);
5569         }
5570         else
5571         {
5572                 /* ¥¢¥¤¥Æ¥àÌ¾¤ò±ÑÆüÀÚ¤êÂØ¤¨µ¡Ç½ÂÐ±þ */
5573                 msg_format("¤Þ¤À %s¤ò»ý¤Ã¤Æ¤¤¤ë¡£", o_name);
5574         }
5575 #else
5576         msg_format("You have %s.", o_name);
5577 #endif
5578
5579 }
5580
5581
5582 /*
5583  * Increase the "number" of an item in the inventory
5584  */
5585 void inven_item_increase(int item, int num)
5586 {
5587         object_type *o_ptr = &inventory[item];
5588
5589         /* Apply */
5590         num += o_ptr->number;
5591
5592         /* Bounds check */
5593         if (num > 255) num = 255;
5594         else if (num < 0) num = 0;
5595
5596         /* Un-apply */
5597         num -= o_ptr->number;
5598
5599         /* Change the number and weight */
5600         if (num)
5601         {
5602                 /* Add the number */
5603                 o_ptr->number += num;
5604
5605                 /* Add the weight */
5606                 p_ptr->total_weight += (num * o_ptr->weight);
5607
5608                 /* Recalculate bonuses */
5609                 p_ptr->update |= (PU_BONUS);
5610
5611                 /* Recalculate mana XXX */
5612                 p_ptr->update |= (PU_MANA);
5613
5614                 /* Combine the pack */
5615                 p_ptr->notice |= (PN_COMBINE);
5616
5617                 /* Window stuff */
5618                 p_ptr->window |= (PW_INVEN | PW_EQUIP);
5619
5620                 /* Hack -- Clear temporary elemental brands if player takes off weapons */
5621                 if (!o_ptr->number && p_ptr->ele_attack)
5622                 {
5623                         if ((item == INVEN_RARM) || (item == INVEN_LARM))
5624                         {
5625                                 if (!buki_motteruka(INVEN_RARM + INVEN_LARM - item))
5626                                 {
5627                                         /* Clear all temporary elemental brands */
5628                                         set_ele_attack(0, 0);
5629                                 }
5630                         }
5631                 }
5632         }
5633 }
5634
5635
5636 /*
5637  * Erase an inventory slot if it has no more items
5638  */
5639 void inven_item_optimize(int item)
5640 {
5641         object_type *o_ptr = &inventory[item];
5642
5643         /* Only optimize real items */
5644         if (!o_ptr->k_idx) return;
5645
5646         /* Only optimize empty items */
5647         if (o_ptr->number) return;
5648
5649         /* The item is in the pack */
5650         if (item < INVEN_RARM)
5651         {
5652                 int i;
5653
5654                 /* One less item */
5655                 inven_cnt--;
5656
5657                 /* Slide everything down */
5658                 for (i = item; i < INVEN_PACK; i++)
5659                 {
5660                         /* Structure copy */
5661                         inventory[i] = inventory[i+1];
5662                 }
5663
5664                 /* Erase the "final" slot */
5665                 object_wipe(&inventory[i]);
5666
5667                 /* Window stuff */
5668                 p_ptr->window |= (PW_INVEN);
5669         }
5670
5671         /* The item is being wielded */
5672         else
5673         {
5674                 /* One less item */
5675                 equip_cnt--;
5676
5677                 /* Erase the empty slot */
5678                 object_wipe(&inventory[item]);
5679
5680                 /* Recalculate bonuses */
5681                 p_ptr->update |= (PU_BONUS);
5682
5683                 /* Recalculate torch */
5684                 p_ptr->update |= (PU_TORCH);
5685
5686                 /* Recalculate mana XXX */
5687                 p_ptr->update |= (PU_MANA);
5688
5689                 /* Window stuff */
5690                 p_ptr->window |= (PW_EQUIP);
5691         }
5692
5693         /* Window stuff */
5694         p_ptr->window |= (PW_SPELL);
5695 }
5696
5697
5698 /*
5699  * Describe the charges on an item on the floor.
5700  */
5701 void floor_item_charges(int item)
5702 {
5703         object_type *o_ptr = &o_list[item];
5704
5705         /* Require staff/wand */
5706         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5707
5708         /* Require known item */
5709         if (!object_is_known(o_ptr)) return;
5710
5711 #ifdef JP
5712         if (o_ptr->pval <= 0)
5713         {
5714                 msg_print("¤³¤Î¾²¾å¤Î¥¢¥¤¥Æ¥à¤Ï¡¢¤â¤¦ËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤Ê¤¤¡£");
5715         }
5716         else
5717         {
5718                 msg_format("¤³¤Î¾²¾å¤Î¥¢¥¤¥Æ¥à¤Ï¡¢¤¢¤È %d ²óÊ¬¤ÎËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤ë¡£", o_ptr->pval);
5719         }
5720 #else
5721         /* Multiple charges */
5722         if (o_ptr->pval != 1)
5723         {
5724                 /* Print a message */
5725                 msg_format("There are %d charges remaining.", o_ptr->pval);
5726         }
5727
5728         /* Single charge */
5729         else
5730         {
5731                 /* Print a message */
5732                 msg_format("There is %d charge remaining.", o_ptr->pval);
5733         }
5734 #endif
5735
5736 }
5737
5738
5739 /*
5740  * Describe an item in the inventory.
5741  */
5742 void floor_item_describe(int item)
5743 {
5744         object_type *o_ptr = &o_list[item];
5745         char        o_name[MAX_NLEN];
5746
5747         /* Get a description */
5748         object_desc(o_name, o_ptr, 0);
5749
5750         /* Print a message */
5751 #ifdef JP
5752         /* "no more" ¤Î¾ì¹ç¤Ï¤³¤Á¤é¤ÇÉ½¼¨¤òÊ¬¤±¤ë */
5753         if (o_ptr->number <= 0)
5754         {
5755                 msg_format("¾²¾å¤Ë¤Ï¡¢¤â¤¦%s¤Ï¤Ê¤¤¡£", o_name);
5756         }
5757         else
5758         {
5759                 msg_format("¾²¾å¤Ë¤Ï¡¢¤Þ¤À %s¤¬¤¢¤ë¡£", o_name);
5760         }
5761 #else
5762         msg_format("You see %s.", o_name);
5763 #endif
5764
5765 }
5766
5767
5768 /*
5769  * Increase the "number" of an item on the floor
5770  */
5771 void floor_item_increase(int item, int num)
5772 {
5773         object_type *o_ptr = &o_list[item];
5774
5775         /* Apply */
5776         num += o_ptr->number;
5777
5778         /* Bounds check */
5779         if (num > 255) num = 255;
5780         else if (num < 0) num = 0;
5781
5782         /* Un-apply */
5783         num -= o_ptr->number;
5784
5785         /* Change the number */
5786         o_ptr->number += num;
5787 }
5788
5789
5790 /*
5791  * Optimize an item on the floor (destroy "empty" items)
5792  */
5793 void floor_item_optimize(int item)
5794 {
5795         object_type *o_ptr = &o_list[item];
5796
5797         /* Paranoia -- be sure it exists */
5798         if (!o_ptr->k_idx) return;
5799
5800         /* Only optimize empty items */
5801         if (o_ptr->number) return;
5802
5803         /* Delete the object */
5804         delete_object_idx(item);
5805 }
5806
5807
5808 /*
5809  * Check if we have space for an item in the pack without overflow
5810  */
5811 bool inven_carry_okay(object_type *o_ptr)
5812 {
5813         int j;
5814
5815         /* Empty slot? */
5816         if (inven_cnt < INVEN_PACK) return (TRUE);
5817
5818         /* Similar slot? */
5819         for (j = 0; j < INVEN_PACK; j++)
5820         {
5821                 object_type *j_ptr = &inventory[j];
5822
5823                 /* Skip non-objects */
5824                 if (!j_ptr->k_idx) continue;
5825
5826                 /* Check if the two items can be combined */
5827                 if (object_similar(j_ptr, o_ptr)) return (TRUE);
5828         }
5829
5830         /* Nope */
5831         return (FALSE);
5832 }
5833
5834
5835 bool object_sort_comp(object_type *o_ptr, s32b o_value, object_type *j_ptr)
5836 {
5837         int o_type, j_type;
5838
5839         /* Use empty slots */
5840         if (!j_ptr->k_idx) return TRUE;
5841
5842         /* Hack -- readable books always come first */
5843         if ((o_ptr->tval == REALM1_BOOK) &&
5844             (j_ptr->tval != REALM1_BOOK)) return TRUE;
5845         if ((j_ptr->tval == REALM1_BOOK) &&
5846             (o_ptr->tval != REALM1_BOOK)) return FALSE;
5847
5848         if ((o_ptr->tval == REALM2_BOOK) &&
5849             (j_ptr->tval != REALM2_BOOK)) return TRUE;
5850         if ((j_ptr->tval == REALM2_BOOK) &&
5851             (o_ptr->tval != REALM2_BOOK)) return FALSE;
5852
5853         /* Objects sort by decreasing type */
5854         if (o_ptr->tval > j_ptr->tval) return TRUE;
5855         if (o_ptr->tval < j_ptr->tval) return FALSE;
5856
5857         /* Non-aware (flavored) items always come last */
5858         /* Can happen in the home */
5859         if (!object_is_aware(o_ptr)) return FALSE;
5860         if (!object_is_aware(j_ptr)) return TRUE;
5861
5862         /* Objects sort by increasing sval */
5863         if (o_ptr->sval < j_ptr->sval) return TRUE;
5864         if (o_ptr->sval > j_ptr->sval) return FALSE;
5865
5866         /* Unidentified objects always come last */
5867         /* Objects in the home can be unknown */
5868         if (!object_is_known(o_ptr)) return FALSE;
5869         if (!object_is_known(j_ptr)) return TRUE;
5870
5871         /* Fixed artifacts, random artifacts and ego items */
5872         if (object_is_fixed_artifact(o_ptr)) o_type = 3;
5873         else if (o_ptr->art_name) o_type = 2;
5874         else if (object_is_ego(o_ptr)) o_type = 1;
5875         else o_type = 0;
5876
5877         if (object_is_fixed_artifact(j_ptr)) j_type = 3;
5878         else if (j_ptr->art_name) j_type = 2;
5879         else if (object_is_ego(j_ptr)) j_type = 1;
5880         else j_type = 0;
5881
5882         if (o_type < j_type) return TRUE;
5883         if (o_type > j_type) return FALSE;
5884
5885         switch (o_ptr->tval)
5886         {
5887         case TV_FIGURINE:
5888         case TV_STATUE:
5889         case TV_CORPSE:
5890         case TV_CAPTURE:
5891                 if (r_info[o_ptr->pval].level < r_info[j_ptr->pval].level) return TRUE;
5892                 if ((r_info[o_ptr->pval].level == r_info[j_ptr->pval].level) && (o_ptr->pval < j_ptr->pval)) return TRUE;
5893                 return FALSE;
5894
5895         case TV_SHOT:
5896         case TV_ARROW:
5897         case TV_BOLT:
5898                 /* Objects sort by increasing hit/damage bonuses */
5899                 if (o_ptr->to_h + o_ptr->to_d < j_ptr->to_h + j_ptr->to_d) return TRUE;
5900                 if (o_ptr->to_h + o_ptr->to_d > j_ptr->to_h + j_ptr->to_d) return FALSE;
5901                 break;
5902
5903         /* Hack:  otherwise identical rods sort by
5904         increasing recharge time --dsb */
5905         case TV_ROD:
5906                 if (o_ptr->pval < j_ptr->pval) return TRUE;
5907                 if (o_ptr->pval > j_ptr->pval) return FALSE;
5908                 break;
5909         }
5910
5911         /* Objects sort by decreasing value */
5912         return o_value > object_value(j_ptr);
5913 }
5914
5915
5916 /*
5917  * Add an item to the players inventory, and return the slot used.
5918  *
5919  * If the new item can combine with an existing item in the inventory,
5920  * it will do so, using "object_similar()" and "object_absorb()", else,
5921  * the item will be placed into the "proper" location in the inventory.
5922  *
5923  * This function can be used to "over-fill" the player's pack, but only
5924  * once, and such an action must trigger the "overflow" code immediately.
5925  * Note that when the pack is being "over-filled", the new item must be
5926  * placed into the "overflow" slot, and the "overflow" must take place
5927  * before the pack is reordered, but (optionally) after the pack is
5928  * combined.  This may be tricky.  See "dungeon.c" for info.
5929  *
5930  * Note that this code must remove any location/stack information
5931  * from the object once it is placed into the inventory.
5932  */
5933 s16b inven_carry(object_type *o_ptr)
5934 {
5935         int i, j, k;
5936         int n = -1;
5937
5938         object_type *j_ptr;
5939
5940
5941         /* Check for combining */
5942         for (j = 0; j < INVEN_PACK; j++)
5943         {
5944                 j_ptr = &inventory[j];
5945
5946                 /* Skip non-objects */
5947                 if (!j_ptr->k_idx) continue;
5948
5949                 /* Hack -- track last item */
5950                 n = j;
5951
5952                 /* Check if the two items can be combined */
5953                 if (object_similar(j_ptr, o_ptr))
5954                 {
5955                         /* Combine the items */
5956                         object_absorb(j_ptr, o_ptr);
5957
5958                         /* Increase the weight */
5959                         p_ptr->total_weight += (o_ptr->number * o_ptr->weight);
5960
5961                         /* Recalculate bonuses */
5962                         p_ptr->update |= (PU_BONUS);
5963
5964                         /* Window stuff */
5965                         p_ptr->window |= (PW_INVEN);
5966
5967                         /* Success */
5968                         return (j);
5969                 }
5970         }
5971
5972
5973         /* Paranoia */
5974         if (inven_cnt > INVEN_PACK) return (-1);
5975
5976         /* Find an empty slot */
5977         for (j = 0; j <= INVEN_PACK; j++)
5978         {
5979                 j_ptr = &inventory[j];
5980
5981                 /* Use it if found */
5982                 if (!j_ptr->k_idx) break;
5983         }
5984
5985         /* Use that slot */
5986         i = j;
5987
5988
5989         /* Reorder the pack */
5990         if (i < INVEN_PACK)
5991         {
5992                 /* Get the "value" of the item */
5993                 s32b o_value = object_value(o_ptr);
5994
5995                 /* Scan every occupied slot */
5996                 for (j = 0; j < INVEN_PACK; j++)
5997                 {
5998                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
5999                 }
6000
6001                 /* Use that slot */
6002                 i = j;
6003
6004                 /* Slide objects */
6005                 for (k = n; k >= i; k--)
6006                 {
6007                         /* Hack -- Slide the item */
6008                         object_copy(&inventory[k+1], &inventory[k]);
6009                 }
6010
6011                 /* Wipe the empty slot */
6012                 object_wipe(&inventory[i]);
6013         }
6014
6015
6016         /* Copy the item */
6017         object_copy(&inventory[i], o_ptr);
6018
6019         /* Access new object */
6020         j_ptr = &inventory[i];
6021
6022         /* Forget stack */
6023         j_ptr->next_o_idx = 0;
6024
6025         /* Forget monster */
6026         j_ptr->held_m_idx = 0;
6027
6028         /* Forget location */
6029         j_ptr->iy = j_ptr->ix = 0;
6030
6031         /* Player touches it, and no longer marked */
6032         j_ptr->marked = OM_TOUCHED;
6033
6034         /* Increase the weight */
6035         p_ptr->total_weight += (j_ptr->number * j_ptr->weight);
6036
6037         /* Count the items */
6038         inven_cnt++;
6039
6040         /* Recalculate bonuses */
6041         p_ptr->update |= (PU_BONUS);
6042
6043         /* Combine and Reorder pack */
6044         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
6045
6046         /* Window stuff */
6047         p_ptr->window |= (PW_INVEN);
6048
6049         /* Return the slot */
6050         return (i);
6051 }
6052
6053
6054 /*
6055  * Take off (some of) a non-cursed equipment item
6056  *
6057  * Note that only one item at a time can be wielded per slot.
6058  *
6059  * Note that taking off an item when "full" may cause that item
6060  * to fall to the ground.
6061  *
6062  * Return the inventory slot into which the item is placed.
6063  */
6064 s16b inven_takeoff(int item, int amt)
6065 {
6066         int slot;
6067
6068         object_type forge;
6069         object_type *q_ptr;
6070
6071         object_type *o_ptr;
6072
6073         cptr act;
6074
6075         char o_name[MAX_NLEN];
6076
6077
6078         /* Get the item to take off */
6079         o_ptr = &inventory[item];
6080
6081         /* Paranoia */
6082         if (amt <= 0) return (-1);
6083
6084         /* Verify */
6085         if (amt > o_ptr->number) amt = o_ptr->number;
6086
6087         /* Get local object */
6088         q_ptr = &forge;
6089
6090         /* Obtain a local object */
6091         object_copy(q_ptr, o_ptr);
6092
6093         /* Modify quantity */
6094         q_ptr->number = amt;
6095
6096         /* Describe the object */
6097         object_desc(o_name, q_ptr, 0);
6098
6099         /* Took off weapon */
6100         if (((item == INVEN_RARM) || (item == INVEN_LARM)) &&
6101             object_is_melee_weapon(o_ptr))
6102         {
6103 #ifdef JP
6104                 act = "¤òÁõÈ÷¤«¤é¤Ï¤º¤·¤¿";
6105 #else
6106                 act = "You were wielding";
6107 #endif
6108
6109         }
6110
6111         /* Took off bow */
6112         else if (item == INVEN_BOW)
6113         {
6114 #ifdef JP
6115                 act = "¤òÁõÈ÷¤«¤é¤Ï¤º¤·¤¿";
6116 #else
6117                 act = "You were holding";
6118 #endif
6119
6120         }
6121
6122         /* Took off light */
6123         else if (item == INVEN_LITE)
6124         {
6125 #ifdef JP
6126                 act = "¤ò¸÷¸»¤«¤é¤Ï¤º¤·¤¿";
6127 #else
6128                 act = "You were holding";
6129 #endif
6130
6131         }
6132
6133         /* Took off something */
6134         else
6135         {
6136 #ifdef JP
6137                 act = "¤òÁõÈ÷¤«¤é¤Ï¤º¤·¤¿";
6138 #else
6139                 act = "You were wearing";
6140 #endif
6141
6142         }
6143
6144         /* Modify, Optimize */
6145         inven_item_increase(item, -amt);
6146         inven_item_optimize(item);
6147
6148         /* Carry the object */
6149         slot = inven_carry(q_ptr);
6150
6151         /* Message */
6152 #ifdef JP
6153         msg_format("%s(%c)%s¡£", o_name, index_to_label(slot), act);
6154 #else
6155         msg_format("%s %s (%c).", act, o_name, index_to_label(slot));
6156 #endif
6157
6158
6159         /* Return slot */
6160         return (slot);
6161 }
6162
6163
6164 /*
6165  * Drop (some of) a non-cursed inventory/equipment item
6166  *
6167  * The object will be dropped "near" the current location
6168  */
6169 void inven_drop(int item, int amt)
6170 {
6171         object_type forge;
6172         object_type *q_ptr;
6173
6174         object_type *o_ptr;
6175
6176         char o_name[MAX_NLEN];
6177
6178
6179         /* Access original object */
6180         o_ptr = &inventory[item];
6181
6182         /* Error check */
6183         if (amt <= 0) return;
6184
6185         /* Not too many */
6186         if (amt > o_ptr->number) amt = o_ptr->number;
6187
6188
6189         /* Take off equipment */
6190         if (item >= INVEN_RARM)
6191         {
6192                 /* Take off first */
6193                 item = inven_takeoff(item, amt);
6194
6195                 /* Access original object */
6196                 o_ptr = &inventory[item];
6197         }
6198
6199
6200         /* Get local object */
6201         q_ptr = &forge;
6202
6203         /* Obtain local object */
6204         object_copy(q_ptr, o_ptr);
6205
6206         /* Distribute charges of wands or rods */
6207         distribute_charges(o_ptr, q_ptr, amt);
6208
6209         /* Modify quantity */
6210         q_ptr->number = amt;
6211
6212         /* Describe local object */
6213         object_desc(o_name, q_ptr, 0);
6214
6215         /* Message */
6216 #ifdef JP
6217         msg_format("%s(%c)¤òÍî¤È¤·¤¿¡£", o_name, index_to_label(item));
6218 #else
6219         msg_format("You drop %s (%c).", o_name, index_to_label(item));
6220 #endif
6221
6222
6223         /* Drop it near the player */
6224         (void)drop_near(q_ptr, 0, py, px);
6225
6226         /* Modify, Describe, Optimize */
6227         inven_item_increase(item, -amt);
6228         inven_item_describe(item);
6229         inven_item_optimize(item);
6230 }
6231
6232
6233 /*
6234  * Combine items in the pack
6235  *
6236  * Note special handling of the "overflow" slot
6237  */
6238 void combine_pack(void)
6239 {
6240         int             i, j, k;
6241         object_type     *o_ptr;
6242         object_type     *j_ptr;
6243         bool            flag = FALSE, combined;
6244
6245         do
6246         {
6247                 combined = FALSE;
6248
6249                 /* Combine the pack (backwards) */
6250                 for (i = INVEN_PACK; i > 0; i--)
6251                 {
6252                         /* Get the item */
6253                         o_ptr = &inventory[i];
6254
6255                         /* Skip empty items */
6256                         if (!o_ptr->k_idx) continue;
6257
6258                         /* Scan the items above that item */
6259                         for (j = 0; j < i; j++)
6260                         {
6261                                 int max_num;
6262
6263                                 /* Get the item */
6264                                 j_ptr = &inventory[j];
6265
6266                                 /* Skip empty items */
6267                                 if (!j_ptr->k_idx) continue;
6268
6269                                 /*
6270                                  * Get maximum number of the stack if these
6271                                  * are similar, get zero otherwise.
6272                                  */
6273                                 max_num = object_similar_part(j_ptr, o_ptr);
6274
6275                                 /* Can we (partialy) drop "o_ptr" onto "j_ptr"? */
6276                                 if (max_num && j_ptr->number < max_num)
6277                                 {
6278                                         if (o_ptr->number + j_ptr->number <= max_num)
6279                                         {
6280                                                 /* Take note */
6281                                                 flag = TRUE;
6282
6283                                                 /* Add together the item counts */
6284                                                 object_absorb(j_ptr, o_ptr);
6285
6286                                                 /* One object is gone */
6287                                                 inven_cnt--;
6288
6289                                                 /* Slide everything down */
6290                                                 for (k = i; k < INVEN_PACK; k++)
6291                                                 {
6292                                                         /* Structure copy */
6293                                                         inventory[k] = inventory[k+1];
6294                                                 }
6295
6296                                                 /* Erase the "final" slot */
6297                                                 object_wipe(&inventory[k]);
6298                                         }
6299                                         else
6300                                         {
6301                                                 int old_num = o_ptr->number;
6302                                                 int remain = j_ptr->number + o_ptr->number - max_num;
6303 #if 0
6304                                                 o_ptr->number -= remain;
6305 #endif
6306                                                 /* Add together the item counts */
6307                                                 object_absorb(j_ptr, o_ptr);
6308
6309                                                 o_ptr->number = remain;
6310
6311                                                 /* Hack -- if rods are stacking, add the pvals (maximum timeouts) and current timeouts together. -LM- */
6312                                                 if (o_ptr->tval == TV_ROD)
6313                                                 {
6314                                                         o_ptr->pval =  o_ptr->pval * remain / old_num;
6315                                                         o_ptr->timeout = o_ptr->timeout * remain / old_num;
6316                                                 }
6317
6318                                                 /* Hack -- if wands are stacking, combine the charges. -LM- */
6319                                                 if (o_ptr->tval == TV_WAND)
6320                                                 {
6321                                                         o_ptr->pval = o_ptr->pval * remain / old_num;
6322                                                 }
6323                                         }
6324
6325                                         /* Window stuff */
6326                                         p_ptr->window |= (PW_INVEN);
6327
6328                                         /* Take note */
6329                                         combined = TRUE;
6330
6331                                         /* Done */
6332                                         break;
6333                                 }
6334                         }
6335                 }
6336         }
6337         while (combined);
6338
6339         /* Message */
6340 #ifdef JP
6341         if (flag) msg_print("¥¶¥Ã¥¯¤ÎÃæ¤Î¥¢¥¤¥Æ¥à¤ò¤Þ¤È¤áÄ¾¤·¤¿¡£");
6342 #else
6343         if (flag) msg_print("You combine some items in your pack.");
6344 #endif
6345 }
6346
6347
6348 /*
6349  * Reorder items in the pack
6350  *
6351  * Note special handling of the "overflow" slot
6352  */
6353 void reorder_pack(void)
6354 {
6355         int             i, j, k;
6356         s32b            o_value;
6357         object_type     forge;
6358         object_type     *q_ptr;
6359         object_type     *o_ptr;
6360         bool            flag = FALSE;
6361
6362
6363         /* Re-order the pack (forwards) */
6364         for (i = 0; i < INVEN_PACK; i++)
6365         {
6366                 /* Mega-Hack -- allow "proper" over-flow */
6367                 if ((i == INVEN_PACK) && (inven_cnt == INVEN_PACK)) break;
6368
6369                 /* Get the item */
6370                 o_ptr = &inventory[i];
6371
6372                 /* Skip empty slots */
6373                 if (!o_ptr->k_idx) continue;
6374
6375                 /* Get the "value" of the item */
6376                 o_value = object_value(o_ptr);
6377
6378                 /* Scan every occupied slot */
6379                 for (j = 0; j < INVEN_PACK; j++)
6380                 {
6381                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
6382                 }
6383
6384                 /* Never move down */
6385                 if (j >= i) continue;
6386
6387                 /* Take note */
6388                 flag = TRUE;
6389
6390                 /* Get local object */
6391                 q_ptr = &forge;
6392
6393                 /* Save a copy of the moving item */
6394                 object_copy(q_ptr, &inventory[i]);
6395
6396                 /* Slide the objects */
6397                 for (k = i; k > j; k--)
6398                 {
6399                         /* Slide the item */
6400                         object_copy(&inventory[k], &inventory[k-1]);
6401                 }
6402
6403                 /* Insert the moving item */
6404                 object_copy(&inventory[j], q_ptr);
6405
6406                 /* Window stuff */
6407                 p_ptr->window |= (PW_INVEN);
6408         }
6409
6410         /* Message */
6411 #ifdef JP
6412         if (flag) msg_print("¥¶¥Ã¥¯¤ÎÃæ¤Î¥¢¥¤¥Æ¥à¤òÊÂ¤ÙÄ¾¤·¤¿¡£");
6413 #else
6414         if (flag) msg_print("You reorder some items in your pack.");
6415 #endif
6416
6417 }
6418
6419
6420 /*
6421  * Hack -- display an object kind in the current window
6422  *
6423  * Include list of usable spells for readible books
6424  */
6425 void display_koff(int k_idx)
6426 {
6427         int y;
6428
6429         object_type forge;
6430         object_type *q_ptr;
6431         int         sval;
6432         int         use_realm;
6433
6434         char o_name[MAX_NLEN];
6435
6436
6437         /* Erase the window */
6438         for (y = 0; y < Term->hgt; y++)
6439         {
6440                 /* Erase the line */
6441                 Term_erase(0, y, 255);
6442         }
6443
6444         /* No info */
6445         if (!k_idx) return;
6446
6447         /* Get local object */
6448         q_ptr = &forge;
6449
6450         /* Prepare the object */
6451         object_prep(q_ptr, k_idx);
6452
6453         /* Describe */
6454         object_desc(o_name, q_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY | OD_STORE));
6455
6456         /* Mention the object name */
6457         Term_putstr(0, 0, -1, TERM_WHITE, o_name);
6458
6459         /* Access the item's sval */
6460         sval = q_ptr->sval;
6461         use_realm = tval2realm(q_ptr->tval);
6462
6463         /* Warriors are illiterate */
6464         if (p_ptr->realm1 || p_ptr->realm2)
6465         {
6466                 if ((use_realm != p_ptr->realm1) && (use_realm != p_ptr->realm2)) return;
6467         }
6468         else
6469         {
6470                 if ((p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE)) return;
6471                 if (!is_magic(use_realm)) return;
6472                 if ((p_ptr->pclass == CLASS_RED_MAGE) && (use_realm != REALM_ARCANE) && (sval > 1)) return;
6473         }
6474
6475         /* Display spells in readible books */
6476         {
6477                 int     spell = -1;
6478                 int     num = 0;
6479                 byte    spells[64];
6480
6481                 /* Extract spells */
6482                 for (spell = 0; spell < 32; spell++)
6483                 {
6484                         /* Check for this spell */
6485                         if (fake_spell_flags[sval] & (1L << spell))
6486                         {
6487                                 /* Collect this spell */
6488                                 spells[num++] = spell;
6489                         }
6490                 }
6491
6492                 /* Print spells */
6493                 print_spells(0, spells, num, 2, 0, use_realm);
6494         }
6495 }
6496
6497 /* Choose one of items that have warning flag */
6498 object_type *choose_warning_item(void)
6499 {
6500         int i;
6501         int choices[INVEN_TOTAL - INVEN_RARM];
6502         int number = 0;
6503
6504         /* Paranoia -- Player has no warning ability */
6505         if (!p_ptr->warning) return NULL;
6506
6507         /* Search Inventory */
6508         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
6509         {
6510                 u32b flgs[TR_FLAG_SIZE];
6511                 object_type *o_ptr = &inventory[i];
6512
6513                 object_flags(o_ptr, flgs);
6514                 if (have_flag(flgs, TR_WARNING))
6515                 {
6516                         choices[number] = i;
6517                         number++;
6518                 }
6519         }
6520
6521         /* Choice one of them */
6522         return number ? &inventory[choices[randint0(number)]] : NULL;
6523 }
6524
6525 /* Calculate spell damages */
6526 static void spell_damcalc(monster_type *m_ptr, int typ, int dam, int limit, int *max)
6527 {
6528         monster_race *r_ptr = &r_info[m_ptr->r_idx];
6529         int          rlev = r_ptr->level;
6530         bool         ignore_wraith_form = FALSE;
6531
6532         if (limit) dam = (dam > limit) ? limit : dam;
6533
6534         /* Vulnerability, resistance and immunity */
6535         switch (typ)
6536         {
6537         case GF_ELEC:
6538                 if (p_ptr->immune_elec)
6539                 {
6540                         dam = 0;
6541                         ignore_wraith_form = TRUE;
6542                 }
6543                 else
6544                 {
6545                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6546                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6547                         if (prace_is_(RACE_ANDROID)) dam += dam / 3;
6548                         if (p_ptr->resist_elec) dam = (dam + 2) / 3;
6549                         if (IS_OPPOSE_ELEC())
6550                                 dam = (dam + 2) / 3;
6551                 }
6552                 break;
6553
6554         case GF_POIS:
6555                 if (p_ptr->resist_pois) dam = (dam + 2) / 3;
6556                 if (IS_OPPOSE_POIS()) dam = (dam + 2) / 3;
6557                 break;
6558
6559         case GF_ACID:
6560                 if (p_ptr->immune_acid)
6561                 {
6562                         dam = 0;
6563                         ignore_wraith_form = TRUE;
6564                 }
6565                 else
6566                 {
6567                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6568                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6569                         if (p_ptr->resist_acid) dam = (dam + 2) / 3;
6570                         if (IS_OPPOSE_ACID()) dam = (dam + 2) / 3;
6571                 }
6572                 break;
6573
6574         case GF_COLD:
6575         case GF_ICE:
6576                 if (p_ptr->immune_cold)
6577                 {
6578                         dam = 0;
6579                         ignore_wraith_form = TRUE;
6580                 }
6581                 else
6582                 {
6583                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6584                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6585                         if (p_ptr->resist_cold) dam = (dam + 2) / 3;
6586                         if (IS_OPPOSE_COLD()) dam = (dam + 2) / 3;
6587                 }
6588                 break;
6589
6590         case GF_FIRE:
6591                 if (p_ptr->immune_fire)
6592                 {
6593                         dam = 0;
6594                         ignore_wraith_form = TRUE;
6595                 }
6596                 else
6597                 {
6598                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6599                         if (prace_is_(RACE_ENT)) dam += dam / 3;
6600                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6601                         if (p_ptr->resist_fire) dam = (dam + 2) / 3;
6602                         if (IS_OPPOSE_FIRE()) dam = (dam + 2) / 3;
6603                 }
6604                 break;
6605
6606         case GF_PSY_SPEAR:
6607                 ignore_wraith_form = TRUE;
6608                 break;
6609
6610         case GF_ARROW:
6611                 if (!p_ptr->blind &&
6612                     ((inventory[INVEN_RARM].k_idx && (inventory[INVEN_RARM].name1 == ART_ZANTETSU)) ||
6613                      (inventory[INVEN_LARM].k_idx && (inventory[INVEN_LARM].name1 == ART_ZANTETSU))))
6614                 {
6615                         dam = 0;
6616                         ignore_wraith_form = TRUE;
6617                 }
6618                 break;
6619
6620         case GF_LITE:
6621                 if (p_ptr->resist_lite) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6622                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE)) dam *= 2;
6623                 else if (prace_is_(RACE_S_FAIRY)) dam = dam * 4 / 3;
6624
6625                 /*
6626                  * Cannot use "ignore_wraith_form" strictly (for "random one damage")
6627                  * "dam *= 2;" for later "dam /= 2"
6628                  */
6629                 if (p_ptr->wraith_form) dam *= 2;
6630                 break;
6631
6632         case GF_DARK:
6633                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE) || p_ptr->wraith_form)
6634                 {
6635                         dam = 0;
6636                         ignore_wraith_form = TRUE;
6637                 }
6638                 else if (p_ptr->resist_dark) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6639                 break;
6640
6641         case GF_SHARDS:
6642                 if (p_ptr->resist_shard) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6643                 break;
6644
6645         case GF_SOUND:
6646                 if (p_ptr->resist_sound) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6647                 break;
6648
6649         case GF_CONFUSION:
6650                 if (p_ptr->resist_conf) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6651                 break;
6652
6653         case GF_CHAOS:
6654                 if (p_ptr->resist_chaos) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6655                 break;
6656
6657         case GF_NETHER:
6658                 if (prace_is_(RACE_SPECTRE))
6659                 {
6660                         dam = 0;
6661                         ignore_wraith_form = TRUE;
6662                 }
6663                 else if (p_ptr->resist_neth) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6664                 break;
6665
6666         case GF_DISENCHANT:
6667                 if (p_ptr->resist_disen) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6668                 break;
6669
6670         case GF_NEXUS:
6671                 if (p_ptr->resist_nexus) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6672                 break;
6673
6674         case GF_TIME:
6675                 if (p_ptr->resist_time) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6676                 break;
6677
6678         case GF_GRAVITY:
6679                 if (p_ptr->levitation) dam = (dam * 2) / 3;
6680                 break;
6681
6682         case GF_ROCKET:
6683                 if (p_ptr->resist_shard) dam /= 2;
6684                 break;
6685
6686         case GF_NUKE:
6687                 if (p_ptr->resist_pois) dam = (2 * dam + 2) / 5;
6688                 if (IS_OPPOSE_POIS()) dam = (2 * dam + 2) / 5;
6689                 break;
6690
6691         case GF_DEATH_RAY:
6692                 if (p_ptr->mimic_form)
6693                 {
6694                         if (mimic_info[p_ptr->mimic_form].MIMIC_FLAGS & MIMIC_IS_NONLIVING)
6695                         {
6696                                 dam = 0;
6697                                 ignore_wraith_form = TRUE;
6698                         }
6699                 }
6700                 else
6701                 {
6702                         switch (p_ptr->prace)
6703                         {
6704                         case RACE_GOLEM:
6705                         case RACE_SKELETON:
6706                         case RACE_ZOMBIE:
6707                         case RACE_VAMPIRE:
6708                         case RACE_DEMON:
6709                         case RACE_SPECTRE:
6710                                 dam = 0;
6711                                 ignore_wraith_form = TRUE;
6712                                 break;
6713                         }
6714                 }
6715                 break;
6716
6717         case GF_HOLY_FIRE:
6718                 if (p_ptr->align > 10) dam /= 2;
6719                 else if (p_ptr->align < -10) dam *= 2;
6720                 break;
6721
6722         case GF_HELL_FIRE:
6723                 if (p_ptr->align > 10) dam *= 2;
6724                 break;
6725
6726         case GF_MIND_BLAST:
6727         case GF_BRAIN_SMASH:
6728                 if (100 + rlev / 2 <= MAX(5, p_ptr->skill_sav))
6729                 {
6730                         dam = 0;
6731                         ignore_wraith_form = TRUE;
6732                 }
6733                 break;
6734
6735         case GF_CAUSE_1:
6736         case GF_CAUSE_2:
6737         case GF_CAUSE_3:
6738         case GF_HAND_DOOM:
6739                 if (100 + rlev / 2 <= p_ptr->skill_sav)
6740                 {
6741                         dam = 0;
6742                         ignore_wraith_form = TRUE;
6743                 }
6744                 break;
6745
6746         case GF_CAUSE_4:
6747                 if ((100 + rlev / 2 <= p_ptr->skill_sav) && (m_ptr->r_idx != MON_KENSHIROU))
6748                 {
6749                         dam = 0;
6750                         ignore_wraith_form = TRUE;
6751                 }
6752                 break;
6753         }
6754
6755         if (p_ptr->wraith_form && !ignore_wraith_form)
6756         {
6757                 dam /= 2;
6758                 if (!dam) dam = 1;
6759         }
6760
6761         if (dam > *max) *max = dam;
6762 }
6763
6764 /* Calculate blow damages */
6765 static int blow_damcalc(monster_type *m_ptr, monster_blow *blow_ptr)
6766 {
6767         int  dam = blow_ptr->d_dice * blow_ptr->d_side;
6768         int  dummy_max = 0;
6769         bool check_wraith_form = TRUE;
6770
6771         if (blow_ptr->method != RBM_EXPLODE)
6772         {
6773                 int ac = p_ptr->ac + p_ptr->to_a;
6774
6775                 switch (blow_ptr->effect)
6776                 {
6777                 case RBE_SUPERHURT:
6778                 {
6779                         int tmp_dam = dam - (dam * ((ac < 150) ? ac : 150) / 250);
6780                         dam = MAX(dam, tmp_dam * 2);
6781                         break;
6782                 }
6783
6784                 case RBE_HURT:
6785                 case RBE_SHATTER:
6786                         dam -= (dam * ((ac < 150) ? ac : 150) / 250);
6787                         break;
6788
6789                 case RBE_ACID:
6790                         spell_damcalc(m_ptr, GF_ACID, dam, 0, &dummy_max);
6791                         dam = dummy_max;
6792                         check_wraith_form = FALSE;
6793                         break;
6794
6795                 case RBE_ELEC:
6796                         spell_damcalc(m_ptr, GF_ELEC, dam, 0, &dummy_max);
6797                         dam = dummy_max;
6798                         check_wraith_form = FALSE;
6799                         break;
6800
6801                 case RBE_FIRE:
6802                         spell_damcalc(m_ptr, GF_FIRE, dam, 0, &dummy_max);
6803                         dam = dummy_max;
6804                         check_wraith_form = FALSE;
6805                         break;
6806
6807                 case RBE_COLD:
6808                         spell_damcalc(m_ptr, GF_COLD, dam, 0, &dummy_max);
6809                         dam = dummy_max;
6810                         check_wraith_form = FALSE;
6811                         break;
6812
6813                 case RBE_DR_MANA:
6814                         dam = 0;
6815                         check_wraith_form = FALSE;
6816                         break;
6817                 }
6818
6819                 if (check_wraith_form && p_ptr->wraith_form)
6820                 {
6821                         dam /= 2;
6822                         if (!dam) dam = 1;
6823                 }
6824         }
6825         else
6826         {
6827                 dam = (dam + 1) / 2;
6828                 spell_damcalc(m_ptr, mbe_info[blow_ptr->effect].explode_type, dam, 0, &dummy_max);
6829                 dam = dummy_max;
6830         }
6831
6832         return dam;
6833 }
6834
6835 /* Examine the grid (xx,yy) and warn the player if there are any danger */
6836 bool process_warning(int xx, int yy)
6837 {
6838         int mx, my;
6839         cave_type *c_ptr;
6840         char o_name[MAX_NLEN];
6841
6842 #define WARNING_AWARE_RANGE 12
6843         int dam_max = 0;
6844         static int old_damage = 0;
6845
6846         for (mx = xx - WARNING_AWARE_RANGE; mx < xx + WARNING_AWARE_RANGE + 1; mx++)
6847         {
6848                 for (my = yy - WARNING_AWARE_RANGE; my < yy + WARNING_AWARE_RANGE + 1; my++)
6849                 {
6850                         int dam_max0 = 0;
6851                         monster_type *m_ptr;
6852                         monster_race *r_ptr;
6853
6854                         if (!in_bounds(my, mx) || (distance(my, mx, yy, xx) > WARNING_AWARE_RANGE)) continue;
6855
6856                         c_ptr = &cave[my][mx];
6857
6858                         if (!c_ptr->m_idx) continue;
6859
6860                         m_ptr = &m_list[c_ptr->m_idx];
6861
6862                         if (MON_CSLEEP(m_ptr)) continue;
6863                         if (!is_hostile(m_ptr)) continue;
6864
6865                         r_ptr = &r_info[m_ptr->r_idx];
6866
6867                         /* Monster spells (only powerful ones)*/
6868                         if (projectable(my, mx, yy, xx))
6869                         {
6870                                 int breath_dam_div3 = m_ptr->hp / 3;
6871                                 int breath_dam_div6 = m_ptr->hp / 6;
6872                                 u32b f4 = r_ptr->flags4;
6873                                 u32b f5 = r_ptr->flags5;
6874                                 u32b f6 = r_ptr->flags6;
6875
6876                                 if (!(d_info[dungeon_type].flags1 & DF1_NO_MAGIC))
6877                                 {
6878                                         int rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
6879                                         int storm_dam = rlev * 4 + 150;
6880                                         bool powerful = (bool)(r_ptr->flags2 & RF2_POWERFUL);
6881
6882                                         if (f4 & RF4_BA_CHAO) spell_damcalc(m_ptr, GF_CHAOS, rlev * (powerful ? 3 : 2) + 100, 0, &dam_max0);
6883                                         if (f5 & RF5_BA_MANA) spell_damcalc(m_ptr, GF_MANA, storm_dam, 0, &dam_max0);
6884                                         if (f5 & RF5_BA_DARK) spell_damcalc(m_ptr, GF_DARK, storm_dam, 0, &dam_max0);
6885                                         if (f5 & RF5_BA_LITE) spell_damcalc(m_ptr, GF_LITE, storm_dam, 0, &dam_max0);
6886                                         if (f6 & RF6_HAND_DOOM) spell_damcalc(m_ptr, GF_HAND_DOOM, p_ptr->chp * 6 / 10, 0, &dam_max0);
6887                                         if (f6 & RF6_PSY_SPEAR) spell_damcalc(m_ptr, GF_PSY_SPEAR, powerful ? (rlev * 2 + 150) : (rlev * 3 / 2 + 100), 0, &dam_max0);
6888                                 }
6889                                 if (f4 & RF4_ROCKET) spell_damcalc(m_ptr, GF_ROCKET, m_ptr->hp / 4, 800, &dam_max0);
6890                                 if (f4 & RF4_BR_ACID) spell_damcalc(m_ptr, GF_ACID, breath_dam_div3, 1600, &dam_max0);
6891                                 if (f4 & RF4_BR_ELEC) spell_damcalc(m_ptr, GF_ELEC, breath_dam_div3, 1600, &dam_max0);
6892                                 if (f4 & RF4_BR_FIRE) spell_damcalc(m_ptr, GF_FIRE, breath_dam_div3, 1600, &dam_max0);
6893                                 if (f4 & RF4_BR_COLD) spell_damcalc(m_ptr, GF_COLD, breath_dam_div3, 1600, &dam_max0);
6894                                 if (f4 & RF4_BR_POIS) spell_damcalc(m_ptr, GF_POIS, breath_dam_div3, 800, &dam_max0);
6895                                 if (f4 & RF4_BR_NETH) spell_damcalc(m_ptr, GF_NETHER, breath_dam_div6, 550, &dam_max0);
6896                                 if (f4 & RF4_BR_LITE) spell_damcalc(m_ptr, GF_LITE, breath_dam_div6, 400, &dam_max0);
6897                                 if (f4 & RF4_BR_DARK) spell_damcalc(m_ptr, GF_DARK, breath_dam_div6, 400, &dam_max0);
6898                                 if (f4 & RF4_BR_CONF) spell_damcalc(m_ptr, GF_CONFUSION, breath_dam_div6, 450, &dam_max0);
6899                                 if (f4 & RF4_BR_SOUN) spell_damcalc(m_ptr, GF_SOUND, breath_dam_div6, 450, &dam_max0);
6900                                 if (f4 & RF4_BR_CHAO) spell_damcalc(m_ptr, GF_CHAOS, breath_dam_div6, 600, &dam_max0);
6901                                 if (f4 & RF4_BR_DISE) spell_damcalc(m_ptr, GF_DISENCHANT, breath_dam_div6, 500, &dam_max0);
6902                                 if (f4 & RF4_BR_NEXU) spell_damcalc(m_ptr, GF_NEXUS, breath_dam_div3, 250, &dam_max0);
6903                                 if (f4 & RF4_BR_TIME) spell_damcalc(m_ptr, GF_TIME, breath_dam_div3, 150, &dam_max0);
6904                                 if (f4 & RF4_BR_INER) spell_damcalc(m_ptr, GF_INERTIA, breath_dam_div6, 200, &dam_max0);
6905                                 if (f4 & RF4_BR_GRAV) spell_damcalc(m_ptr, GF_GRAVITY, breath_dam_div3, 200, &dam_max0);
6906                                 if (f4 & RF4_BR_SHAR) spell_damcalc(m_ptr, GF_SHARDS, breath_dam_div6, 500, &dam_max0);
6907                                 if (f4 & RF4_BR_PLAS) spell_damcalc(m_ptr, GF_PLASMA, breath_dam_div6, 150, &dam_max0);
6908                                 if (f4 & RF4_BR_WALL) spell_damcalc(m_ptr, GF_FORCE, breath_dam_div6, 200, &dam_max0);
6909                                 if (f4 & RF4_BR_MANA) spell_damcalc(m_ptr, GF_MANA, breath_dam_div3, 250, &dam_max0);
6910                                 if (f4 & RF4_BR_NUKE) spell_damcalc(m_ptr, GF_NUKE, breath_dam_div3, 800, &dam_max0);
6911                                 if (f4 & RF4_BR_DISI) spell_damcalc(m_ptr, GF_DISINTEGRATE, breath_dam_div6, 150, &dam_max0);
6912                         }
6913
6914                         /* Monster melee attacks */
6915                         if (!(r_ptr->flags1 & RF1_NEVER_BLOW) && !(d_info[dungeon_type].flags1 & DF1_NO_MELEE))
6916                         {
6917                                 if (mx <= xx + 1 && mx >= xx - 1 && my <= yy + 1 && my >= yy - 1)
6918                                 {
6919                                         int m;
6920                                         int dam_melee = 0;
6921                                         for (m = 0; m < 4; m++)
6922                                         {
6923                                                 /* Skip non-attacks */
6924                                                 if (!r_ptr->blow[m].method || (r_ptr->blow[m].method == RBM_SHOOT)) continue;
6925
6926                                                 /* Extract the attack info */
6927                                                 dam_melee += blow_damcalc(m_ptr, &r_ptr->blow[m]);
6928                                                 if (r_ptr->blow[m].method == RBM_EXPLODE) break;
6929                                         }
6930                                         if (dam_melee > dam_max0) dam_max0 = dam_melee;
6931                                 }
6932                         }
6933
6934                         /* Contribution from this monster */
6935                         dam_max += dam_max0;
6936                 }
6937         }
6938
6939         /* Prevent excessive warning */
6940         if (dam_max > old_damage)
6941         {
6942                 old_damage = dam_max * 3 / 2;
6943
6944                 if (dam_max > p_ptr->chp / 2)
6945                 {
6946                         object_type *o_ptr = choose_warning_item();
6947
6948                         if (o_ptr) object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
6949 #ifdef JP
6950                         else strcpy(o_name, "ÂÎ"); /* Warning ability without item */
6951                         msg_format("%s¤¬±Ô¤¯¿Ì¤¨¤¿¡ª", o_name);
6952 #else
6953                         else strcpy(o_name, "body"); /* Warning ability without item */
6954                         msg_format("Your %s pulsates sharply!", o_name);
6955 #endif
6956                         disturb(0, 1);
6957 #ifdef JP
6958                         return get_check("ËÜÅö¤Ë¤³¤Î¤Þ¤Þ¿Ê¤à¤«¡©");
6959 #else
6960                         return get_check("Really want to go ahead? ");
6961 #endif
6962                 }
6963         }
6964         else old_damage = old_damage / 2;
6965
6966         c_ptr = &cave[yy][xx];
6967         if (((!easy_disarm && is_trap(c_ptr->feat))
6968             || (c_ptr->mimic && is_trap(c_ptr->feat))) && !one_in_(13))
6969         {
6970                 object_type *o_ptr = choose_warning_item();
6971
6972                 if (o_ptr) object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
6973 #ifdef JP
6974                 else strcpy(o_name, "ÂÎ"); /* Warning ability without item */
6975                 msg_format("%s¤¬¿Ì¤¨¤¿¡ª", o_name);
6976 #else
6977                 else strcpy(o_name, "body"); /* Warning ability without item */
6978                 msg_format("Your %s pulsates!", o_name);
6979 #endif
6980                 disturb(0, 1);
6981 #ifdef JP
6982                 return get_check("ËÜÅö¤Ë¤³¤Î¤Þ¤Þ¿Ê¤à¤«¡©");
6983 #else
6984                 return get_check("Really want to go ahead? ");
6985 #endif
6986         }
6987
6988         return TRUE;
6989 }
6990
6991
6992 static bool item_tester_hook_melee_ammo(object_type *o_ptr)
6993 {
6994         switch (o_ptr->tval)
6995         {
6996                 case TV_HAFTED:
6997                 case TV_POLEARM:
6998                 case TV_DIGGING:
6999                 case TV_BOLT:
7000                 case TV_ARROW:
7001                 case TV_SHOT:
7002                 {
7003                         return (TRUE);
7004                 }
7005                 case TV_SWORD:
7006                 {
7007                         if (o_ptr->sval != SV_DOKUBARI) return (TRUE);
7008                 }
7009         }
7010
7011         return (FALSE);
7012 }
7013
7014
7015 /*
7016  *  A structure for smithing
7017  */
7018 typedef struct {
7019         int add;       /* TR flag number or special essence id */
7020         cptr add_name; /* Name of this ability */
7021         int type;      /* Menu number */
7022         int essence;   /* Index for carrying essences */
7023         int value;     /* Needed value to add this ability */
7024 } essence_type;
7025
7026
7027 /*
7028  *  Smithing type data for Weapon smith
7029  */
7030 #ifdef JP
7031 static essence_type essence_info[] =
7032 {
7033         {TR_STR, "ÏÓÎÏ", 4, TR_STR, 20},
7034         {TR_INT, "ÃÎÇ½", 4, TR_INT, 20},
7035         {TR_WIS, "¸¤µ", 4, TR_WIS, 20},
7036         {TR_DEX, "´ïÍÑ¤µ", 4, TR_DEX, 20},
7037         {TR_CON, "ÂÑµ×ÎÏ", 4, TR_CON, 20},
7038         {TR_CHR, "Ì¥ÎÏ", 4, TR_CHR, 20},
7039         {TR_MAGIC_MASTERY, "ËâÎÏ»ÙÇÛ", 4, TR_MAGIC_MASTERY, 20},
7040         {TR_STEALTH, "±£Ì©", 4, TR_STEALTH, 40},
7041         {TR_SEARCH, "Ãµº÷", 4, TR_SEARCH, 15},
7042         {TR_INFRA, "ÀÖ³°Àþ»ëÎÏ", 4, TR_INFRA, 15},
7043         {TR_TUNNEL, "ºÎ·¡", 4, TR_TUNNEL, 15},
7044         {TR_SPEED, "¥¹¥Ô¡¼¥É", 4, TR_SPEED, 12},
7045         {TR_BLOWS, "ÄÉ²Ã¹¶·â", 1, TR_BLOWS, 20},
7046         {TR_CHAOTIC, "¥«¥ª¥¹¹¶·â", 1, TR_CHAOTIC, 15},
7047         {TR_VAMPIRIC, "µÛ·ì¹¶·â", 1, TR_VAMPIRIC, 60},
7048         {TR_IMPACT, "ÃÏ¿ÌÈ¯Æ°", 7, TR_IMPACT, 15},
7049         {TR_BRAND_POIS, "ÆÇ»¦", 1, TR_BRAND_POIS, 20},
7050         {TR_BRAND_ACID, "ÍÏ²ò", 1, TR_BRAND_ACID, 20},
7051         {TR_BRAND_ELEC, "ÅÅ·â", 1, TR_BRAND_ELEC, 20},
7052         {TR_BRAND_FIRE, "¾Æ´þ", 1, TR_BRAND_FIRE, 20},
7053         {TR_BRAND_COLD, "Åà·ë", 1, TR_BRAND_COLD, 20},
7054         {TR_SUST_STR, "ÏÓÎÏ°Ý»ý", 3, TR_SUST_STR, 15},
7055         {TR_SUST_INT, "ÃÎÇ½°Ý»ý", 3, TR_SUST_STR, 15},
7056         {TR_SUST_WIS, "¸¤µ°Ý»ý", 3, TR_SUST_STR, 15},
7057         {TR_SUST_DEX, "´ïÍÑ¤µ°Ý»ý", 3, TR_SUST_STR, 15},
7058         {TR_SUST_CON, "ÂÑµ×ÎÏ°Ý»ý", 3, TR_SUST_STR, 15},
7059         {TR_SUST_CHR, "Ì¥ÎÏ°Ý»ý", 3, TR_SUST_STR, 15},
7060         {TR_IM_ACID, "»ÀÌÈ±Ö", 2, TR_IM_ACID, 20},
7061         {TR_IM_ELEC, "ÅÅ·âÌÈ±Ö", 2, TR_IM_ACID, 20},
7062         {TR_IM_FIRE, "²Ð±êÌÈ±Ö", 2, TR_IM_ACID, 20},
7063         {TR_IM_COLD, "Îäµ¤ÌÈ±Ö", 2, TR_IM_ACID, 20},
7064         {TR_REFLECT, "È¿¼Í", 2, TR_REFLECT, 20},
7065         {TR_FREE_ACT, "ËãáãÃÎ¤é¤º", 3, TR_FREE_ACT, 20},
7066         {TR_HOLD_LIFE, "À¸Ì¿ÎÏ°Ý»ý", 3, TR_HOLD_LIFE, 20},
7067         {TR_RES_ACID, "ÂÑ»À", 2, TR_RES_ACID, 15},
7068         {TR_RES_ELEC, "ÂÑÅÅ·â", 2, TR_RES_ELEC, 15},
7069         {TR_RES_FIRE, "ÂÑ²Ð±ê", 2, TR_RES_FIRE, 15},
7070         {TR_RES_COLD, "ÂÑÎäµ¤", 2, TR_RES_COLD, 15},
7071         {TR_RES_POIS, "ÂÑÆÇ", 2, TR_RES_POIS, 25},
7072         {TR_RES_FEAR, "ÂÑ¶²ÉÝ", 2, TR_RES_FEAR, 20},
7073         {TR_RES_LITE, "ÂÑÁ®¸÷", 2, TR_RES_LITE, 20},
7074         {TR_RES_DARK, "ÂÑ°Å¹õ", 2, TR_RES_DARK, 20},
7075         {TR_RES_BLIND, "ÂÑÌÕÌÜ", 2, TR_RES_BLIND, 20},
7076         {TR_RES_CONF, "ÂÑº®Íð", 2, TR_RES_CONF, 20},
7077         {TR_RES_SOUND, "ÂÑ¹ì²»", 2, TR_RES_SOUND, 20},
7078         {TR_RES_SHARDS, "ÂÑÇËÊÒ", 2, TR_RES_SHARDS, 20},
7079         {TR_RES_NETHER, "ÂÑÃÏ¹ö", 2, TR_RES_NETHER, 20},
7080         {TR_RES_NEXUS, "ÂÑ°ø²Ìº®Íð", 2, TR_RES_NEXUS, 20},
7081         {TR_RES_CHAOS, "ÂÑ¥«¥ª¥¹", 2, TR_RES_CHAOS, 20},
7082         {TR_RES_DISEN, "ÂÑÎô²½", 2, TR_RES_DISEN, 20},
7083         {TR_SH_FIRE, "", 0, -2, 0},
7084         {TR_SH_ELEC, "", 0, -2, 0},
7085         {TR_SH_COLD, "", 0, -2, 0},
7086         {TR_NO_MAGIC, "È¿ËâË¡", 3, TR_NO_MAGIC, 15},
7087         {TR_WARNING, "·Ù¹ð", 3, TR_WARNING, 20},
7088         {TR_LEVITATION, "ÉâÍ·", 3, TR_LEVITATION, 20},
7089         {TR_LITE, "±Êµ×¸÷¸»", 3, TR_LITE, 15},
7090         {TR_SEE_INVIS, "²Ä»ëÆ©ÌÀ", 3, TR_SEE_INVIS, 20},
7091         {TR_TELEPATHY, "¥Æ¥ì¥Ñ¥·¡¼", 6, TR_TELEPATHY, 15},
7092         {TR_SLOW_DIGEST, "ÃÙ¾Ã²½", 3, TR_SLOW_DIGEST, 15},
7093         {TR_REGEN, "µÞÂ®²óÉü", 3, TR_REGEN, 20},
7094         {TR_TELEPORT, "¥Æ¥ì¥Ý¡¼¥È", 3, TR_TELEPORT, 25},
7095
7096         {TR_SLAY_EVIL, "¼Ù°ÇÜÂÇ", 5, TR_SLAY_EVIL, 100},
7097         {TR_KILL_EVIL, "¼Ù°ÇÜÇÜÂÇ", 0, TR_SLAY_EVIL, 60},
7098         {TR_SLAY_ANIMAL, "Æ°ÊªÇÜÂÇ", 5, TR_SLAY_ANIMAL, 20},
7099         {TR_KILL_ANIMAL, "Æ°ÊªÇÜÇÜÂÇ", 5, TR_SLAY_ANIMAL, 60},
7100         {TR_SLAY_UNDEAD, "ÉÔ»àÇÜÂÇ", 5, TR_SLAY_UNDEAD, 20},
7101         {TR_KILL_UNDEAD, "ÉÔ»àÇÜÇÜÂÇ", 5, TR_SLAY_UNDEAD, 60},
7102         {TR_SLAY_DEMON, "°ËâÇÜÂÇ", 5, TR_SLAY_DEMON, 20},
7103         {TR_KILL_DEMON, "°ËâÇÜÇÜÂÇ", 5, TR_SLAY_DEMON, 60},
7104         {TR_SLAY_ORC, "¥ª¡¼¥¯ÇÜÂÇ", 5, TR_SLAY_ORC, 15},
7105         {TR_KILL_ORC, "¥ª¡¼¥¯ÇÜÇÜÂÇ", 5, TR_SLAY_ORC, 60},
7106         {TR_SLAY_TROLL, "¥È¥í¥ëÇÜÂÇ", 5, TR_SLAY_TROLL, 15},
7107         {TR_KILL_TROLL, "¥È¥í¥ëÇÜÇÜÂÇ", 5, TR_SLAY_TROLL, 60},
7108         {TR_SLAY_GIANT, "µð¿ÍÇÜÂÇ", 5, TR_SLAY_GIANT, 20},
7109         {TR_KILL_GIANT, "µð¿ÍÇÜÇÜÂÇ", 5, TR_SLAY_GIANT, 60},
7110         {TR_SLAY_DRAGON, "ÎµÇÜÂÇ", 5, TR_SLAY_DRAGON, 20},
7111         {TR_KILL_DRAGON, "ÎµÇÜÇÜÂÇ", 5, TR_SLAY_DRAGON, 60},
7112         {TR_SLAY_HUMAN, "¿Í´ÖÇÜÂÇ", 5, TR_SLAY_HUMAN, 20},
7113         {TR_KILL_HUMAN, "¿Í´ÖÇÜÇÜÂÇ", 5, TR_SLAY_HUMAN, 60},
7114
7115         {TR_ESP_ANIMAL, "ưʪESP", 6, TR_SLAY_ANIMAL, 40},
7116         {TR_ESP_UNDEAD, "ÉÔ»àESP", 6, TR_SLAY_UNDEAD, 40},
7117         {TR_ESP_DEMON, "°ËâESP", 6, TR_SLAY_DEMON, 40},
7118         {TR_ESP_ORC, "¥ª¡¼¥¯ESP", 6, TR_SLAY_ORC, 40},
7119         {TR_ESP_TROLL, "¥È¥í¥ëESP", 6, TR_SLAY_TROLL, 40},
7120         {TR_ESP_GIANT, "µð¿ÍESP", 6, TR_SLAY_GIANT, 40},
7121         {TR_ESP_DRAGON, "εESP", 6, TR_SLAY_DRAGON, 40},
7122         {TR_ESP_HUMAN, "¿Í´ÖESP", 6, TR_SLAY_HUMAN, 40},
7123
7124         {ESSENCE_ATTACK, "¹¶·â", 10, TR_ES_ATTACK, 30},
7125         {ESSENCE_AC, "ËÉ¸æ", 10, TR_ES_AC, 15},
7126         {ESSENCE_TMP_RES_ACID, "»ÀÂÑÀÈ¯Æ°", 7, TR_RES_ACID, 50},
7127         {ESSENCE_TMP_RES_ELEC, "ÅÅ·âÂÑÀÈ¯Æ°", 7, TR_RES_ELEC, 50},
7128         {ESSENCE_TMP_RES_FIRE, "²Ð±êÂÑÀÈ¯Æ°", 7, TR_RES_FIRE, 50},
7129         {ESSENCE_TMP_RES_COLD, "Îäµ¤ÂÑÀÈ¯Æ°", 7, TR_RES_COLD, 50},
7130         {ESSENCE_SH_FIRE, "²Ð±ê¥ª¡¼¥é", 7, -1, 50},
7131         {ESSENCE_SH_ELEC, "ÅÅ·â¥ª¡¼¥é", 7, -1, 50},
7132         {ESSENCE_SH_COLD, "Îäµ¤¥ª¡¼¥é", 7, -1, 50},
7133         {ESSENCE_RESISTANCE, "Á´ÂÑÀ", 2, -1, 150},
7134         {ESSENCE_SUSTAIN, "ÁõÈ÷ÊÝ»ý", 10, -1, 10},
7135         {ESSENCE_SLAY_GLOVE, "»¦Ù¤¤Î¾®¼ê", 1, TR_ES_ATTACK, 200},
7136
7137         {-1, NULL, 0, -1, 0}
7138 };
7139 #else
7140 static essence_type essence_info[] =
7141 {
7142         {TR_STR, "strength", 4, TR_STR, 20},
7143         {TR_INT, "intelligence", 4, TR_INT, 20},
7144         {TR_WIS, "wisdom", 4, TR_WIS, 20},
7145         {TR_DEX, "dexterity", 4, TR_DEX, 20},
7146         {TR_CON, "constitution", 4, TR_CON, 20},
7147         {TR_CHR, "charisma", 4, TR_CHR, 20},
7148         {TR_MAGIC_MASTERY, "magic mastery", 4, TR_MAGIC_MASTERY, 20},
7149         {TR_STEALTH, "stealth", 4, TR_STEALTH, 40},
7150         {TR_SEARCH, "serching", 4, TR_SEARCH, 15},
7151         {TR_INFRA, "infravision", 4, TR_INFRA, 15},
7152         {TR_TUNNEL, "digging", 4, TR_TUNNEL, 15},
7153         {TR_SPEED, "speed", 4, TR_SPEED, 12},
7154         {TR_BLOWS, "extra attack", 1, TR_BLOWS, 20},
7155         {TR_CHAOTIC, "chaos brand", 1, TR_CHAOTIC, 15},
7156         {TR_VAMPIRIC, "vampiric brand", 1, TR_VAMPIRIC, 60},
7157         {TR_IMPACT, "quake activation", 7, TR_IMPACT, 15},
7158         {TR_BRAND_POIS, "poison brand", 1, TR_BRAND_POIS, 20},
7159         {TR_BRAND_ACID, "acid brand", 1, TR_BRAND_ACID, 20},
7160         {TR_BRAND_ELEC, "electric brand", 1, TR_BRAND_ELEC, 20},
7161         {TR_BRAND_FIRE, "fire brand", 1, TR_BRAND_FIRE, 20},
7162         {TR_BRAND_COLD, "cold brand", 1, TR_BRAND_COLD, 20},
7163         {TR_SUST_STR, "sustain strength", 3, TR_SUST_STR, 15},
7164         {TR_SUST_INT, "sustain intelligence", 3, TR_SUST_STR, 15},
7165         {TR_SUST_WIS, "sustain wisdom", 3, TR_SUST_STR, 15},
7166         {TR_SUST_DEX, "sustain dexterity", 3, TR_SUST_STR, 15},
7167         {TR_SUST_CON, "sustain constitution", 3, TR_SUST_STR, 15},
7168         {TR_SUST_CHR, "sustain charisma", 3, TR_SUST_STR, 15},
7169         {TR_IM_ACID, "acid immunity", 2, TR_IM_ACID, 20},
7170         {TR_IM_ELEC, "electric immunity", 2, TR_IM_ACID, 20},
7171         {TR_IM_FIRE, "fire immunity", 2, TR_IM_ACID, 20},
7172         {TR_IM_COLD, "cold immunity", 2, TR_IM_ACID, 20},
7173         {TR_REFLECT, "reflection", 2, TR_REFLECT, 20},
7174         {TR_FREE_ACT, "free action", 3, TR_FREE_ACT, 20},
7175         {TR_HOLD_LIFE, "hold life", 3, TR_HOLD_LIFE, 20},
7176         {TR_RES_ACID, "resistance to acid", 2, TR_RES_ACID, 15},
7177         {TR_RES_ELEC, "resistance to electric", 2, TR_RES_ELEC, 15},
7178         {TR_RES_FIRE, "resistance to fire", 2, TR_RES_FIRE, 15},
7179         {TR_RES_COLD, "resistance to cold", 2, TR_RES_COLD, 15},
7180         {TR_RES_POIS, "resistance to poison", 2, TR_RES_POIS, 25},
7181         {TR_RES_FEAR, "resistance to fear", 2, TR_RES_FEAR, 20},
7182         {TR_RES_LITE, "resistance to light", 2, TR_RES_LITE, 20},
7183         {TR_RES_DARK, "resistance to dark", 2, TR_RES_DARK, 20},
7184         {TR_RES_BLIND, "resistance to blind", 2, TR_RES_BLIND, 20},
7185         {TR_RES_CONF, "resistance to confusion", 2, TR_RES_CONF, 20},
7186         {TR_RES_SOUND, "resistance to sound", 2, TR_RES_SOUND, 20},
7187         {TR_RES_SHARDS, "resistance to shard", 2, TR_RES_SHARDS, 20},
7188         {TR_RES_NETHER, "resistance to nether", 2, TR_RES_NETHER, 20},
7189         {TR_RES_NEXUS, "resistance to nexus", 2, TR_RES_NEXUS, 20},
7190         {TR_RES_CHAOS, "resistance to chaos", 2, TR_RES_CHAOS, 20},
7191         {TR_RES_DISEN, "resistance to disenchantment", 2, TR_RES_DISEN, 20},
7192         {TR_SH_FIRE, "", 0, -2, 0},
7193         {TR_SH_ELEC, "", 0, -2, 0},
7194         {TR_SH_COLD, "", 0, -2, 0},
7195         {TR_NO_MAGIC, "anti magic", 3, TR_NO_MAGIC, 15},
7196         {TR_WARNING, "warning", 3, TR_WARNING, 20},
7197         {TR_LEVITATION, "levitation", 3, TR_LEVITATION, 20},
7198         {TR_LITE, "permanent light", 3, TR_LITE, 15},
7199         {TR_SEE_INVIS, "see invisible", 3, TR_SEE_INVIS, 20},
7200         {TR_TELEPATHY, "telepathy", 6, TR_TELEPATHY, 15},
7201         {TR_SLOW_DIGEST, "slow digestion", 3, TR_SLOW_DIGEST, 15},
7202         {TR_REGEN, "regeneration", 3, TR_REGEN, 20},
7203         {TR_TELEPORT, "teleport", 3, TR_TELEPORT, 25},
7204
7205         {TR_SLAY_EVIL, "slay evil", 5, TR_SLAY_EVIL, 100},
7206         {TR_SLAY_ANIMAL, "slay animal", 5, TR_SLAY_ANIMAL, 20},
7207         {TR_KILL_ANIMAL, "kill animal", 5, TR_SLAY_ANIMAL, 60},
7208         {TR_KILL_EVIL, "kill evil", 0, TR_SLAY_EVIL, 60},
7209         {TR_SLAY_UNDEAD, "slay undead", 5, TR_SLAY_UNDEAD, 20},
7210         {TR_KILL_UNDEAD, "kill undead", 5, TR_SLAY_UNDEAD, 60},
7211         {TR_SLAY_DEMON, "slay demon", 5, TR_SLAY_DEMON, 20},
7212         {TR_KILL_DEMON, "kill demon", 5, TR_SLAY_DEMON, 60},
7213         {TR_SLAY_ORC, "slay orc", 5, TR_SLAY_ORC, 15},
7214         {TR_KILL_ORC, "kill orc", 5, TR_SLAY_ORC, 60},
7215         {TR_SLAY_TROLL, "slay troll", 5, TR_SLAY_TROLL, 15},
7216         {TR_KILL_TROLL, "kill troll", 5, TR_SLAY_TROLL, 60},
7217         {TR_SLAY_GIANT, "slay giant", 5, TR_SLAY_GIANT, 20},
7218         {TR_KILL_GIANT, "kill giant", 5, TR_SLAY_GIANT, 60},
7219         {TR_SLAY_DRAGON, "slay dragon", 5, TR_SLAY_DRAGON, 20},
7220         {TR_KILL_DRAGON, "kill dragon", 5, TR_SLAY_DRAGON, 60},
7221         {TR_SLAY_HUMAN, "slay human", 5, TR_SLAY_HUMAN, 20},
7222         {TR_KILL_HUMAN, "kill human", 5, TR_SLAY_HUMAN, 60},
7223
7224         {TR_ESP_ANIMAL, "sense animal", 6, TR_SLAY_ANIMAL, 40},
7225         {TR_ESP_UNDEAD, "sense undead", 6, TR_SLAY_UNDEAD, 40},
7226         {TR_ESP_DEMON, "sense demon", 6, TR_SLAY_DEMON, 40},
7227         {TR_ESP_ORC, "sense orc", 6, TR_SLAY_ORC, 40},
7228         {TR_ESP_TROLL, "sense troll", 6, TR_SLAY_TROLL, 40},
7229         {TR_ESP_GIANT, "sense giant", 6, TR_SLAY_GIANT, 40},
7230         {TR_ESP_DRAGON, "sense dragon", 6, TR_SLAY_DRAGON, 40},
7231         {TR_ESP_HUMAN, "sense human", 6, TR_SLAY_HUMAN, 40},
7232
7233         {ESSENCE_ATTACK, "weapon enchant", 10, TR_ES_ATTACK, 30},
7234         {ESSENCE_AC, "armor enchant", 10, TR_ES_AC, 15},
7235         {ESSENCE_TMP_RES_ACID, "resist acid activation", 7, TR_RES_ACID, 50},
7236         {ESSENCE_TMP_RES_ELEC, "resist electricity activation", 7, TR_RES_ELEC, 50},
7237         {ESSENCE_TMP_RES_FIRE, "resist fire activation", 7, TR_RES_FIRE, 50},
7238         {ESSENCE_TMP_RES_COLD, "resist cold activation", 7, TR_RES_COLD, 50},
7239         {ESSENCE_SH_FIRE, "fiery sheath", 7, -1, 50},
7240         {ESSENCE_SH_ELEC, "electric sheath", 7, -1, 50},
7241         {ESSENCE_SH_COLD, "sheath of coldness", 7, -1, 50},
7242         {ESSENCE_RESISTANCE, "resistance", 2, -1, 150},
7243         {ESSENCE_SUSTAIN, "elements proof", 10, -1, 10},
7244         {ESSENCE_SLAY_GLOVE, "gauntlets of slaying", 1, TR_ES_ATTACK, 200},
7245
7246         {-1, NULL, 0, -1, 0}
7247 };
7248 #endif
7249
7250
7251 /*
7252  *  Essense names for Weapon smith
7253  */
7254 #ifdef JP
7255 static cptr essence_name[] =
7256 {
7257         "ÏÓÎÏ",
7258         "ÃÎÇ½",
7259         "¸¤µ",
7260         "´ïÍÑ¤µ",
7261         "ÂÑµ×ÎÏ",
7262         "Ì¥ÎÏ",
7263         "ËâÎÏ»ÙÇÛ",
7264         "",
7265         "±£Ì©",
7266         "Ãµº÷",
7267         "ÀÖ³°Àþ»ëÎÏ",
7268         "ºÎ·¡",
7269         "¥¹¥Ô¡¼¥É",
7270         "ÄÉ²Ã¹¶·â",
7271         "¥«¥ª¥¹¹¶·â",
7272         "µÛ·ì¹¶·â",
7273         "Æ°ÊªÇÜÂÇ",
7274         "¼Ù°ÇÜÂÇ",
7275         "ÉÔ»àÇÜÂÇ",
7276         "°ËâÇÜÂÇ",
7277         "¥ª¡¼¥¯ÇÜÂÇ",
7278         "¥È¥í¥ëÇÜÂÇ",
7279         "µð¿ÍÇÜÂÇ",
7280         "ÎµÇÜÂÇ",
7281         "",
7282         "",
7283         "ÃÏ¿Ì",
7284         "ÆÇ»¦",
7285         "ÍÏ²ò",
7286         "ÅÅ·â",
7287         "¾Æ´þ",
7288         "Åà·ë",
7289         "Ç½ÎÏ°Ý»ý",
7290         "",
7291         "",
7292         "",
7293         "",
7294         "",
7295         "",
7296         "",
7297         "ÌÈ±Ö",
7298         "",
7299         "",
7300         "",
7301         "",
7302         "È¿¼Í",
7303         "ËãáãÃÎ¤é¤º",
7304         "À¸Ì¿ÎÏ°Ý»ý",
7305         "ÂÑ»À",
7306         "ÂÑÅÅ·â",
7307         "ÂÑ²Ð±ê",
7308         "ÂÑÎäµ¤",
7309         "ÂÑÆÇ",
7310         "ÂÑ¶²ÉÝ",
7311         "ÂÑÁ®¸÷",
7312         "ÂÑ°Å¹õ",
7313         "ÂÑÌÕÌÜ",
7314         "ÂÑº®Íð",
7315         "ÂÑ¹ì²»",
7316         "ÂÑÇËÊÒ",
7317         "ÂÑÃÏ¹ö",
7318         "ÂÑ°ø²Ìº®Íð",
7319         "ÂÑ¥«¥ª¥¹",
7320         "ÂÑÎô²½",
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         NULL
7354 };
7355
7356 #else
7357
7358 static cptr essence_name[] =
7359 {
7360         "strength",
7361         "intelligen.",
7362         "wisdom",
7363         "dexterity",
7364         "constitut.",
7365         "charisma",
7366         "magic mast.",
7367         "",
7368         "stealth",
7369         "serching",
7370         "infravision",
7371         "digging",
7372         "speed",
7373         "extra atk",
7374         "chaos brand",
7375         "vampiric",
7376         "slay animal",
7377         "slay evil",
7378         "slay undead",
7379         "slay demon",
7380         "slay orc",
7381         "slay troll",
7382         "slay giant",
7383         "slay dragon",
7384         "",
7385         "",
7386         "quake",
7387         "pois. brand",
7388         "acid brand",
7389         "elec. brand",
7390         "fire brand",
7391         "cold brand",
7392         "sustain",
7393         "",
7394         "",
7395         "",
7396         "",
7397         "",
7398         "",
7399         "",
7400         "immunity",
7401         "",
7402         "",
7403         "",
7404         "",
7405         "reflection",
7406         "free action",
7407         "hold life",
7408         "res. acid",
7409         "res. elec.",
7410         "res. fire",
7411         "res. cold",
7412         "res. poison",
7413         "res. fear",
7414         "res. light",
7415         "res. dark",
7416         "res. blind",
7417         "res.confuse",
7418         "res. sound",
7419         "res. shard",
7420         "res. nether",
7421         "res. nexus",
7422         "res. chaos",
7423         "res. disen.",
7424         "",
7425         "",
7426         "slay human",
7427         "",
7428         "",
7429         "anti magic",
7430         "",
7431         "",
7432         "warning",
7433         "",
7434         "",
7435         "",
7436         "levitation",
7437         "perm. light",
7438         "see invis.",
7439         "telepathy",
7440         "slow dige.",
7441         "regen.",
7442         "",
7443         "",
7444         "",
7445         "",
7446         "",
7447         "",
7448         "",
7449         "",
7450         "teleport",
7451         "",
7452         "",
7453         "weapon enc.",
7454         "armor enc.",
7455
7456         NULL
7457 };
7458 #endif
7459
7460
7461 static void display_essence(void)
7462 {
7463         int i, num = 0;
7464
7465         screen_save();
7466         for (i = 1; i < 22; i++)
7467         {
7468                 prt("",i,0);
7469         }
7470 #ifdef JP
7471         prt("¥¨¥Ã¥»¥ó¥¹   ¸Ä¿ô     ¥¨¥Ã¥»¥ó¥¹   ¸Ä¿ô     ¥¨¥Ã¥»¥ó¥¹   ¸Ä¿ô", 1, 8);
7472 #else
7473         prt("Essence      Num      Essence      Num      Essence      Num ", 1, 8);
7474 #endif
7475         for (i = 0; essence_name[i]; i++)
7476         {
7477                 if (!essence_name[i][0]) continue;
7478                 prt(format("%-11s %5d", essence_name[i], p_ptr->magic_num1[i]), 2+num%21, 8+num/21*22);
7479                 num++;
7480         }
7481 #ifdef JP
7482         prt("¸½ºß½ê»ý¤·¤Æ¤¤¤ë¥¨¥Ã¥»¥ó¥¹", 0, 0);
7483 #else
7484         prt("List of all essences you have.", 0, 0);
7485 #endif
7486         (void)inkey();
7487         screen_load();
7488         return;
7489 }
7490
7491 static void drain_essence(void)
7492 {
7493         int drain_value[sizeof(p_ptr->magic_num1) / sizeof(s32b)];
7494         int i, item;
7495         int dec = 4;
7496         bool observe = FALSE;
7497         int old_ds, old_dd, old_to_h, old_to_d, old_ac, old_to_a, old_pval, old_name2, old_timeout;
7498         u32b old_flgs[TR_FLAG_SIZE], new_flgs[TR_FLAG_SIZE];
7499         object_type *o_ptr;
7500         cptr            q, s;
7501         byte iy, ix, marked, number;
7502         s16b next_o_idx, weight;
7503
7504         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7505                 drain_value[i] = 0;
7506
7507         item_tester_hook = object_is_weapon_armour_ammo;
7508         item_tester_no_ryoute = TRUE;
7509
7510         /* Get an item */
7511 #ifdef JP
7512         q = "¤É¤Î¥¢¥¤¥Æ¥à¤«¤éÃê½Ð¤·¤Þ¤¹¤«¡©";
7513         s = "Ãê½Ð¤Ç¤¤ë¥¢¥¤¥Æ¥à¤¬¤¢¤ê¤Þ¤»¤ó¡£";
7514 #else
7515         q = "Extract from which item? ";
7516         s = "You have nothing you can extract from.";
7517 #endif
7518
7519         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
7520
7521         /* Get the item (in the pack) */
7522         if (item >= 0)
7523         {
7524                 o_ptr = &inventory[item];
7525         }
7526
7527         /* Get the item (on the floor) */
7528         else
7529         {
7530                 o_ptr = &o_list[0 - item];
7531         }
7532
7533         if (object_is_known(o_ptr) && !object_is_nameless(o_ptr))
7534         {
7535                 char o_name[MAX_NLEN];
7536                 object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7537 #ifdef JP
7538                 if (!get_check(format("ËÜÅö¤Ë%s¤«¤éÃê½Ð¤·¤Æ¤è¤í¤·¤¤¤Ç¤¹¤«¡©", o_name))) return;
7539 #else
7540                 if (!get_check(format("Really extract from %s? ", o_name))) return;
7541 #endif
7542         }
7543
7544         energy_use = 100;
7545
7546         object_flags(o_ptr, old_flgs);
7547         if (have_flag(old_flgs, TR_KILL_DRAGON)) add_flag(old_flgs, TR_SLAY_DRAGON);
7548         if (have_flag(old_flgs, TR_KILL_ANIMAL)) add_flag(old_flgs, TR_SLAY_ANIMAL);
7549         if (have_flag(old_flgs, TR_KILL_EVIL)) add_flag(old_flgs, TR_SLAY_EVIL);
7550         if (have_flag(old_flgs, TR_KILL_UNDEAD)) add_flag(old_flgs, TR_SLAY_UNDEAD);
7551         if (have_flag(old_flgs, TR_KILL_DEMON)) add_flag(old_flgs, TR_SLAY_DEMON);
7552         if (have_flag(old_flgs, TR_KILL_ORC)) add_flag(old_flgs, TR_SLAY_ORC);
7553         if (have_flag(old_flgs, TR_KILL_TROLL)) add_flag(old_flgs, TR_SLAY_TROLL);
7554         if (have_flag(old_flgs, TR_KILL_GIANT)) add_flag(old_flgs, TR_SLAY_GIANT);
7555         if (have_flag(old_flgs, TR_KILL_HUMAN)) add_flag(old_flgs, TR_SLAY_HUMAN);
7556
7557         old_to_a = o_ptr->to_a;
7558         old_ac = o_ptr->ac;
7559         old_to_h = o_ptr->to_h;
7560         old_to_d = o_ptr->to_d;
7561         old_ds = o_ptr->ds;
7562         old_dd = o_ptr->dd;
7563         old_pval = o_ptr->pval;
7564         old_name2 = o_ptr->name2;
7565         old_timeout = o_ptr->timeout;
7566         if (o_ptr->curse_flags & (TRC_CURSED | TRC_HEAVY_CURSE | TRC_PERMA_CURSE)) dec--;
7567         if (have_flag(old_flgs, TR_ADD_L_CURSE)) dec--;
7568         if (have_flag(old_flgs, TR_ADD_H_CURSE)) dec--;
7569         if (have_flag(old_flgs, TR_AGGRAVATE)) dec--;
7570         if (have_flag(old_flgs, TR_NO_TELE)) dec--;
7571         if (have_flag(old_flgs, TR_DRAIN_EXP)) dec--;
7572         if (have_flag(old_flgs, TR_DRAIN_HP)) dec--;
7573         if (have_flag(old_flgs, TR_DRAIN_MANA)) dec--;
7574         if (have_flag(old_flgs, TR_TY_CURSE)) dec--;
7575
7576         iy = o_ptr->iy;
7577         ix = o_ptr->ix;
7578         next_o_idx = o_ptr->next_o_idx;
7579         marked = o_ptr->marked;
7580         weight = o_ptr->weight;
7581         number = o_ptr->number;
7582
7583         object_prep(o_ptr, o_ptr->k_idx);
7584
7585         o_ptr->iy=iy;
7586         o_ptr->ix=ix;
7587         o_ptr->next_o_idx=next_o_idx;
7588         o_ptr->marked=marked;
7589         o_ptr->number = number;
7590         if (o_ptr->tval == TV_DRAG_ARMOR) o_ptr->timeout = old_timeout;
7591         if (item >= 0) p_ptr->total_weight += (o_ptr->weight*o_ptr->number - weight*number);
7592         o_ptr->ident |= (IDENT_MENTAL);
7593         object_aware(o_ptr);
7594         object_known(o_ptr);
7595
7596         object_flags(o_ptr, new_flgs);
7597
7598         for (i = 0; essence_info[i].add_name; i++)
7599         {
7600                 essence_type *es_ptr = &essence_info[i];
7601                 int pval = 0;
7602
7603                 if (es_ptr->add < TR_FLAG_MAX && is_pval_flag(es_ptr->add) && old_pval)
7604                         pval = (have_flag(new_flgs, es_ptr->add)) ? old_pval - o_ptr->pval : old_pval;
7605
7606                 if (es_ptr->add < TR_FLAG_MAX &&
7607                     (!have_flag(new_flgs, es_ptr->add) || pval) &&
7608                     have_flag(old_flgs, es_ptr->add))
7609                 {
7610                         if (pval)
7611                         {
7612                                 drain_value[es_ptr->essence] += 10 * pval;
7613                         }
7614                         else if (es_ptr->essence != -2)
7615                         {
7616                                 drain_value[es_ptr->essence] += 10;
7617                         }
7618                         else if (es_ptr->add == TR_SH_FIRE)
7619                         {
7620                                 drain_value[TR_BRAND_FIRE] += 10;
7621                                 drain_value[TR_RES_FIRE] += 10;
7622                         }
7623                         else if (es_ptr->add == TR_SH_ELEC)
7624                         {
7625                                 drain_value[TR_BRAND_ELEC] += 10;
7626                                 drain_value[TR_RES_ELEC] += 10;
7627                         }
7628                         else if (es_ptr->add == TR_SH_COLD)
7629                         {
7630                                 drain_value[TR_BRAND_COLD] += 10;
7631                                 drain_value[TR_RES_COLD] += 10;
7632                         }
7633                 }
7634         }
7635
7636         if ((have_flag(old_flgs, TR_FORCE_WEAPON)) && !(have_flag(new_flgs, TR_FORCE_WEAPON)))
7637         {
7638                 drain_value[TR_INT] += 5;
7639                 drain_value[TR_WIS] += 5;
7640         }
7641         if ((have_flag(old_flgs, TR_VORPAL)) && !(have_flag(new_flgs, TR_VORPAL)))
7642         {
7643                 drain_value[TR_BRAND_POIS] += 5;
7644                 drain_value[TR_BRAND_ACID] += 5;
7645                 drain_value[TR_BRAND_ELEC] += 5;
7646                 drain_value[TR_BRAND_FIRE] += 5;
7647                 drain_value[TR_BRAND_COLD] += 5;
7648         }
7649         if ((have_flag(old_flgs, TR_DEC_MANA)) && !(have_flag(new_flgs, TR_DEC_MANA)))
7650         {
7651                 drain_value[TR_INT] += 10;
7652         }
7653         if ((have_flag(old_flgs, TR_XTRA_MIGHT)) && !(have_flag(new_flgs, TR_XTRA_MIGHT)))
7654         {
7655                 drain_value[TR_STR] += 10;
7656         }
7657         if ((have_flag(old_flgs, TR_XTRA_SHOTS)) && !(have_flag(new_flgs, TR_XTRA_SHOTS)))
7658         {
7659                 drain_value[TR_DEX] += 10;
7660         }
7661         if (old_name2 == EGO_2WEAPON)
7662         {
7663                 drain_value[TR_DEX] += 20;
7664         }
7665         if (object_is_weapon_ammo(o_ptr))
7666         {
7667                 if (old_ds > o_ptr->ds) drain_value[TR_ES_ATTACK] += (old_ds-o_ptr->ds)*10;
7668
7669                 if (old_dd > o_ptr->dd) drain_value[TR_ES_ATTACK] += (old_dd-o_ptr->dd)*10;
7670         }
7671         if (old_to_h > o_ptr->to_h) drain_value[TR_ES_ATTACK] += (old_to_h-o_ptr->to_h)*10;
7672         if (old_to_d > o_ptr->to_d) drain_value[TR_ES_ATTACK] += (old_to_d-o_ptr->to_d)*10;
7673         if (old_ac > o_ptr->ac) drain_value[TR_ES_AC] += (old_ac-o_ptr->ac)*10;
7674         if (old_to_a > o_ptr->to_a) drain_value[TR_ES_AC] += (old_to_a-o_ptr->to_a)*10;
7675
7676         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7677         {
7678                 drain_value[i] *= number;
7679                 drain_value[i] = drain_value[i] * dec / 4;
7680                 drain_value[i] = MAX(drain_value[i], 0);
7681                 if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) drain_value[i] /= 10;
7682                 if (drain_value[i])
7683                 {
7684                         observe = TRUE;
7685                 }
7686         }
7687         if (!observe)
7688         {
7689                 msg_print(_("¥¨¥Ã¥»¥ó¥¹¤ÏÃê½Ð¤Ç¤¤Þ¤»¤ó¤Ç¤·¤¿¡£", "You were not able to extract any essence."));
7690         }
7691         else
7692         {
7693                 msg_print(_("Ãê½Ð¤·¤¿¥¨¥Ã¥»¥ó¥¹:", "Extracted essences:"));
7694
7695                 for (i = 0; essence_name[i]; i++)
7696                 {
7697                         if (!essence_name[i][0]) continue;
7698                         if (!drain_value[i]) continue;
7699
7700                         p_ptr->magic_num1[i] += drain_value[i];
7701                         p_ptr->magic_num1[i] = MIN(20000, p_ptr->magic_num1[i]);
7702                         msg_print(NULL);
7703                         msg_format("%s...%d%s", essence_name[i], drain_value[i], _("¡£", ". "));
7704                 }
7705         }
7706
7707         /* Apply autodestroy/inscription to the drained item */
7708         autopick_alter_item(item, TRUE);
7709
7710         /* Combine the pack */
7711         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
7712
7713         /* Window stuff */
7714         p_ptr->window |= (PW_INVEN);
7715 }
7716
7717
7718
7719 static int choose_essence(void)
7720 {
7721         int mode = 0;
7722         char choice;
7723         int menu_line = (use_menu ? 1 : 0);
7724
7725 #ifdef JP
7726         cptr menu_name[] = {
7727                 "Éð´ïÂ°À",
7728                 "ÂÑÀ",
7729                 "Ç½ÎÏ",
7730                 "¿ôÃÍ",
7731                 "¥¹¥ì¥¤",
7732                 "ESP",
7733                 "¤½¤ÎÂ¾"
7734         };
7735 #else
7736         cptr menu_name[] = {
7737                 "Brand weapon",
7738                 "Resistance",
7739                 "Ability",
7740                 "Magic number",
7741                 "Slay",
7742                 "ESP",
7743                 "Others"
7744         };
7745 #endif
7746         const int mode_max = 7;
7747
7748 #ifdef ALLOW_REPEAT
7749         if (repeat_pull(&mode) && 1 <= mode && mode <= mode_max)
7750                 return mode;
7751         mode = 0;
7752 #endif /* ALLOW_REPEAT */
7753
7754         if (use_menu)
7755         {
7756                 screen_save();
7757
7758                 while(!mode)
7759                 {
7760                         int i;
7761                         for (i = 0; i < mode_max; i++)
7762 #ifdef JP
7763                                 prt(format(" %s %s", (menu_line == 1+i) ? "¡Õ" : "  ", menu_name[i]), 2 + i, 14);
7764                         prt("¤É¤Î¼ïÎà¤Î¥¨¥Ã¥»¥ó¥¹ÉÕ²Ã¤ò¹Ô¤¤¤Þ¤¹¤«¡©", 0, 0);
7765 #else
7766                                 prt(format(" %s %s", (menu_line == 1+i) ? "> " : "  ", menu_name[i]), 2 + i, 14);
7767                         prt("Choose from menu.", 0, 0);
7768 #endif
7769
7770                         choice = inkey();
7771                         switch(choice)
7772                         {
7773                         case ESCAPE:
7774                         case 'z':
7775                         case 'Z':
7776                                 screen_load();
7777                                 return 0;
7778                         case '2':
7779                         case 'j':
7780                         case 'J':
7781                                 menu_line++;
7782                                 break;
7783                         case '8':
7784                         case 'k':
7785                         case 'K':
7786                                 menu_line += mode_max - 1;
7787                                 break;
7788                         case '\r':
7789                         case '\n':
7790                         case 'x':
7791                         case 'X':
7792                                 mode = menu_line;
7793                                 break;
7794                         }
7795                         if (menu_line > mode_max) menu_line -= mode_max;
7796                 }
7797                 screen_load();
7798         }
7799         else
7800         {
7801                 screen_save();
7802                 while (!mode)
7803                 {
7804                         int i;
7805
7806                         for (i = 0; i < mode_max; i++)
7807                                 prt(format("  %c) %s", 'a' + i, menu_name[i]), 2 + i, 14);
7808
7809 #ifdef JP
7810                         if (!get_com("²¿¤òÉÕ²Ã¤·¤Þ¤¹¤«:", &choice, TRUE))
7811 #else
7812                         if (!get_com("Command :", &choice, TRUE))
7813 #endif
7814                         {
7815                                 screen_load();
7816                                 return 0;
7817                         }
7818
7819                         if (isupper(choice)) choice = tolower(choice);
7820
7821                         if ('a' <= choice && choice <= 'a' + (char)mode_max - 1)
7822                                 mode = (int)choice - 'a' + 1;
7823                 }
7824                 screen_load();
7825         }
7826
7827 #ifdef ALLOW_REPEAT
7828         repeat_push(mode);
7829 #endif /* ALLOW_REPEAT */
7830         return mode;
7831 }
7832
7833 static void add_essence(int mode)
7834 {
7835         int item, max_num = 0;
7836         int i;
7837         bool flag,redraw;
7838         char choice;
7839         cptr            q, s;
7840         object_type *o_ptr;
7841         int ask = TRUE;
7842         char out_val[160];
7843         int num[22];
7844         char o_name[MAX_NLEN];
7845         int use_essence;
7846         essence_type *es_ptr;
7847
7848         int menu_line = (use_menu ? 1 : 0);
7849
7850         for (i = 0; essence_info[i].add_name; i++)
7851         {
7852                 es_ptr = &essence_info[i];
7853
7854                 if (es_ptr->type != mode) continue;
7855                 num[max_num++] = i;
7856         }
7857
7858 #ifdef ALLOW_REPEAT
7859         if (!repeat_pull(&i) || i<0 || i>=max_num)
7860         {
7861 #endif /* ALLOW_REPEAT */
7862
7863
7864         /* Nothing chosen yet */
7865         flag = FALSE;
7866
7867         /* No redraw yet */
7868         redraw = FALSE;
7869
7870         /* Build a prompt */
7871 #ifdef JP
7872         (void) strnfmt(out_val, 78, "('*'¤Ç°ìÍ÷, ESC¤ÇÃæÃÇ) ¤É¤ÎÇ½ÎÏ¤òÉÕ²Ã¤·¤Þ¤¹¤«¡©");
7873 #else
7874         (void)strnfmt(out_val, 78, "(*=List, ESC=exit) Add which ability? ");
7875 #endif
7876         if (use_menu) screen_save();
7877
7878         /* Get a spell from the user */
7879
7880         choice = (always_show_list || use_menu) ? ESCAPE:1;
7881         while (!flag)
7882         {
7883                 bool able[22];
7884                 if( choice==ESCAPE ) choice = ' ';
7885                 else if( !get_com(out_val, &choice, FALSE) )break;
7886
7887                 if (use_menu && choice != ' ')
7888                 {
7889                         switch(choice)
7890                         {
7891                                 case '0':
7892                                 {
7893                                         screen_load();
7894                                         return;
7895                                 }
7896
7897                                 case '8':
7898                                 case 'k':
7899                                 case 'K':
7900                                 {
7901                                         menu_line += (max_num-1);
7902                                         break;
7903                                 }
7904
7905                                 case '2':
7906                                 case 'j':
7907                                 case 'J':
7908                                 {
7909                                         menu_line++;
7910                                         break;
7911                                 }
7912
7913                                 case '4':
7914                                 case 'h':
7915                                 case 'H':
7916                                 {
7917                                         menu_line = 1;
7918                                         break;
7919                                 }
7920                                 case '6':
7921                                 case 'l':
7922                                 case 'L':
7923                                 {
7924                                         menu_line = max_num;
7925                                         break;
7926                                 }
7927
7928                                 case 'x':
7929                                 case 'X':
7930                                 case '\r':
7931                                 case '\n':
7932                                 {
7933                                         i = menu_line - 1;
7934                                         ask = FALSE;
7935                                         break;
7936                                 }
7937                         }
7938                         if (menu_line > max_num) menu_line -= max_num;
7939                 }
7940                 /* Request redraw */
7941                 if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask))
7942                 {
7943                         /* Show the list */
7944                         if (!redraw || use_menu)
7945                         {
7946                                 byte y, x = 10;
7947                                 int ctr;
7948                                 char dummy[80], dummy2[80];
7949                                 byte col;
7950
7951                                 strcpy(dummy, "");
7952
7953                                 /* Show list */
7954                                 redraw = TRUE;
7955
7956                                 /* Save the screen */
7957                                 if (!use_menu) screen_save();
7958
7959                                 for (y = 1; y < 24; y++)
7960                                         prt("", y, x);
7961
7962                                 /* Print header(s) */
7963 #ifdef JP
7964                                 prt(format("   %-43s %6s/%s", "Ç½ÎÏ(É¬Í×¥¨¥Ã¥»¥ó¥¹)", "É¬Í×¿ô", "½ê»ý¿ô"), 1, x);
7965
7966 #else
7967                                 prt(format("   %-43s %6s/%s", "Ability (needed essence)", "Needs", "Possess"), 1, x);
7968 #endif
7969                                 /* Print list */
7970                                 for (ctr = 0; ctr < max_num; ctr++)
7971                                 {
7972                                         es_ptr = &essence_info[num[ctr]];
7973
7974                                         if (use_menu)
7975                                         {
7976                                                 if (ctr == (menu_line-1))
7977 #ifdef JP
7978                                                         strcpy(dummy, "¡Õ ");
7979 #else
7980                                                         strcpy(dummy, ">  ");
7981 #endif
7982                                                 else strcpy(dummy, "   ");
7983
7984                                         }
7985                                         /* letter/number for power selection */
7986                                         else
7987                                         {
7988                                                 sprintf(dummy, "%c) ",I2A(ctr));
7989                                         }
7990
7991                                         strcat(dummy, es_ptr->add_name);
7992
7993                                         col = TERM_WHITE;
7994                                         able[ctr] = TRUE;
7995
7996                                         if (es_ptr->essence != -1)
7997                                         {
7998                                                 strcat(dummy, format("(%s)", essence_name[es_ptr->essence]));
7999                                                 if (p_ptr->magic_num1[es_ptr->essence] < es_ptr->value) able[ctr] = FALSE;
8000                                         }
8001                                         else
8002                                         {
8003                                                 switch(es_ptr->add)
8004                                                 {
8005                                                 case ESSENCE_SH_FIRE:
8006 #ifdef JP
8007                                                         strcat(dummy, "(¾Æ´þ+ÂÑ²Ð±ê)");
8008 #else
8009                                                         strcat(dummy, "(brand fire + res.fire)");
8010 #endif
8011                                                         if (p_ptr->magic_num1[TR_BRAND_FIRE] < es_ptr->value) able[ctr] = FALSE;
8012                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8013                                                         break;
8014                                                 case ESSENCE_SH_ELEC:
8015 #ifdef JP
8016                                                         strcat(dummy, "(ÅÅ·â+ÂÑÅÅ·â)");
8017 #else
8018                                                         strcat(dummy, "(brand elec. + res. elec.)");
8019 #endif
8020                                                         if (p_ptr->magic_num1[TR_BRAND_ELEC] < es_ptr->value) able[ctr] = FALSE;
8021                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8022                                                         break;
8023                                                 case ESSENCE_SH_COLD:
8024 #ifdef JP
8025                                                         strcat(dummy, "(Åà·ë+ÂÑÎäµ¤)");
8026 #else
8027                                                         strcat(dummy, "(brand cold + res. cold)");
8028 #endif
8029                                                         if (p_ptr->magic_num1[TR_BRAND_COLD] < es_ptr->value) able[ctr] = FALSE;
8030                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8031                                                         break;
8032                                                 case ESSENCE_RESISTANCE:
8033 #ifdef JP
8034                                                         strcat(dummy, "(ÂÑ²Ð±ê+ÂÑÎäµ¤+ÂÑÅÅ·â+ÂÑ»À)");
8035 #else
8036                                                         strcat(dummy, "(r.fire+r.cold+r.elec+r.acid)");
8037 #endif
8038                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8039                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8040                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8041                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8042                                                         break;
8043                                                 case ESSENCE_SUSTAIN:
8044 #ifdef JP
8045                                                         strcat(dummy, "(ÂÑ²Ð±ê+ÂÑÎäµ¤+ÂÑÅÅ·â+ÂÑ»À)");
8046 #else
8047                                                         strcat(dummy, "(r.fire+r.cold+r.elec+r.acid)");
8048 #endif
8049                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8050                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8051                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8052                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8053                                                         break;
8054                                                 }
8055                                         }
8056
8057                                         if (!able[ctr]) col = TERM_RED;
8058
8059                                         if (es_ptr->essence != -1)
8060                                         {
8061                                                 sprintf(dummy2, "%-49s %3d/%d", dummy, es_ptr->value, (int)p_ptr->magic_num1[es_ptr->essence]);
8062                                         }
8063                                         else
8064                                         {
8065                                                 sprintf(dummy2, "%-49s %3d/(\?\?)", dummy, es_ptr->value);
8066                                         }
8067
8068                                         c_prt(col, dummy2, ctr+2, x);
8069                                 }
8070                         }
8071
8072                         /* Hide the list */
8073                         else
8074                         {
8075                                 /* Hide list */
8076                                 redraw = FALSE;
8077
8078                                 /* Restore the screen */
8079                                 screen_load();
8080                         }
8081
8082                         /* Redo asking */
8083                         continue;
8084                 }
8085
8086                 if (!use_menu)
8087                 {
8088                         /* Note verify */
8089                         ask = (isupper(choice));
8090
8091                         /* Lowercase */
8092                         if (ask) choice = tolower(choice);
8093
8094                         /* Extract request */
8095                         i = (islower(choice) ? A2I(choice) : -1);
8096                 }
8097
8098                 /* Totally Illegal */
8099                 if ((i < 0) || (i >= max_num) || !able[i])
8100                 {
8101                         bell();
8102                         continue;
8103                 }
8104
8105                 /* Verify it */
8106                 if (ask)
8107                 {
8108                         char tmp_val[160];
8109
8110                         /* Prompt */
8111 #ifdef JP
8112                         (void) strnfmt(tmp_val, 78, "%s¤òÉÕ²Ã¤·¤Þ¤¹¤«¡© ", essence_info[num[i]].add_name);
8113 #else
8114                         (void) strnfmt(tmp_val, 78, "Add the abilitiy of %s? ", essence_info[num[i]].add_name);
8115 #endif
8116
8117                         /* Belay that order */
8118                         if (!get_check(tmp_val)) continue;
8119                 }
8120
8121                 /* Stop the loop */
8122                 flag = TRUE;
8123         }
8124
8125         /* Restore the screen */
8126         if (redraw) screen_load();
8127
8128         if (!flag) return;
8129
8130 #ifdef ALLOW_REPEAT
8131         repeat_push(i);
8132         }
8133 #endif /* ALLOW_REPEAT */
8134
8135         es_ptr = &essence_info[num[i]];
8136
8137         if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8138                 item_tester_tval = TV_GLOVES;
8139         else if (mode == 1 || mode == 5)
8140                 item_tester_hook = item_tester_hook_melee_ammo;
8141         else if (es_ptr->add == ESSENCE_ATTACK)
8142                 item_tester_hook = object_allow_enchant_weapon;
8143         else if (es_ptr->add == ESSENCE_AC)
8144                 item_tester_hook = object_is_armour;
8145         else
8146                 item_tester_hook = object_is_weapon_armour_ammo;
8147         item_tester_no_ryoute = TRUE;
8148
8149         /* Get an item */
8150 #ifdef JP
8151         q = "¤É¤Î¥¢¥¤¥Æ¥à¤ò²þÎÉ¤·¤Þ¤¹¤«¡©";
8152         s = "²þÎÉ¤Ç¤¤ë¥¢¥¤¥Æ¥à¤¬¤¢¤ê¤Þ¤»¤ó¡£";
8153 #else
8154         q = "Improve which item? ";
8155         s = "You have nothing to improve.";
8156 #endif
8157
8158         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8159
8160         /* Get the item (in the pack) */
8161         if (item >= 0)
8162         {
8163                 o_ptr = &inventory[item];
8164         }
8165
8166         /* Get the item (on the floor) */
8167         else
8168         {
8169                 o_ptr = &o_list[0 - item];
8170         }
8171
8172         if ((mode != 10) && (object_is_artifact(o_ptr) || object_is_smith(o_ptr)))
8173         {
8174 #ifdef JP
8175                 msg_print("¤½¤Î¥¢¥¤¥Æ¥à¤Ï¤³¤ì°Ê¾å²þÎÉ¤Ç¤¤Ê¤¤¡£");
8176 #else
8177                 msg_print("This item is no more able to be improved.");
8178 #endif
8179                 return;
8180         }
8181
8182         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8183
8184         use_essence = es_ptr->value;
8185         if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) use_essence = (use_essence+9)/10;
8186         if (o_ptr->number > 1)
8187         {
8188                 use_essence *= o_ptr->number;
8189 #ifdef JP
8190                 msg_format("%d¸Ä¤¢¤ë¤Î¤Ç¥¨¥Ã¥»¥ó¥¹¤Ï%dÉ¬Í×¤Ç¤¹¡£", o_ptr->number, use_essence);
8191 #else
8192                 msg_format("It will take %d essences.",use_essence);
8193 #endif
8194
8195         }
8196
8197         if (es_ptr->essence != -1)
8198         {
8199                 if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8200                 {
8201 #ifdef JP
8202                         msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
8203 #else
8204                         msg_print("You don't have enough essences.");
8205 #endif
8206                         return;
8207                 }
8208                 if (is_pval_flag(es_ptr->add))
8209                 {
8210                         if (o_ptr->pval < 0)
8211                         {
8212 #ifdef JP
8213                                 msg_print("¤³¤Î¥¢¥¤¥Æ¥à¤ÎÇ½ÎÏ½¤Àµ¤ò¶¯²½¤¹¤ë¤³¤È¤Ï¤Ç¤¤Ê¤¤¡£");
8214 #else
8215                                 msg_print("You cannot increase magic number of this item.");
8216 #endif
8217                                 return;
8218                         }
8219                         else if (es_ptr->add == TR_BLOWS)
8220                         {
8221                                 if (o_ptr->pval > 1)
8222                                 {
8223 #ifdef JP
8224                                         if (!get_check("½¤ÀµÃÍ¤Ï1¤Ë¤Ê¤ê¤Þ¤¹¡£¤è¤í¤·¤¤¤Ç¤¹¤«¡©")) return;
8225 #else
8226                                         if (!get_check("The magic number of this weapon will become 1. Are you sure? ")) return;
8227 #endif
8228                                 }
8229
8230                                 o_ptr->pval = 1;
8231 #ifdef JP
8232                                 msg_format("¥¨¥Ã¥»¥ó¥¹¤ò%d¸Ä»ÈÍÑ¤·¤Þ¤¹¡£", use_essence);
8233 #else
8234                                 msg_format("It will take %d essences.", use_essence);
8235 #endif
8236                         }
8237                         else if (o_ptr->pval > 0)
8238                         {
8239                                 use_essence *= o_ptr->pval;
8240 #ifdef JP
8241                                 msg_format("¥¨¥Ã¥»¥ó¥¹¤ò%d¸Ä»ÈÍÑ¤·¤Þ¤¹¡£", use_essence);
8242 #else
8243                                 msg_format("It will take %d essences.", use_essence);
8244 #endif
8245                         }
8246                         else
8247                         {
8248                                 char tmp[80];
8249                                 char tmp_val[160];
8250                                 int pval;
8251                                 int limit = MIN(5, p_ptr->magic_num1[es_ptr->essence]/es_ptr->value);
8252
8253 #ifdef JP
8254                                 sprintf(tmp, "¤¤¤¯¤ÄÉÕ²Ã¤·¤Þ¤¹¤«¡© (1-%d): ", limit);
8255 #else
8256                                 sprintf(tmp, "Enchant how many? (1-%d): ", limit);
8257 #endif
8258                                 strcpy(tmp_val, "1");
8259
8260                                 if (!get_string(tmp, tmp_val, 1)) return;
8261                                 pval = atoi(tmp_val);
8262                                 if (pval > limit) pval = limit;
8263                                 else if (pval < 1) pval = 1;
8264                                 o_ptr->pval += pval;
8265                                 use_essence *= pval;
8266 #ifdef JP
8267                                 msg_format("¥¨¥Ã¥»¥ó¥¹¤ò%d¸Ä»ÈÍÑ¤·¤Þ¤¹¡£", use_essence);
8268 #else
8269                                 msg_format("It will take %d essences.", use_essence);
8270 #endif
8271                         }
8272
8273                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8274                         {
8275 #ifdef JP
8276                                 msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
8277 #else
8278                                 msg_print("You don't have enough essences.");
8279 #endif
8280                                 return;
8281                         }
8282                 }
8283                 else if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8284                 {
8285                         char tmp_val[160];
8286                         int val;
8287                         int get_to_h, get_to_d;
8288
8289                         strcpy(tmp_val, "1");
8290 #ifdef JP
8291                         if (!get_string(format("¤¤¤¯¤ÄÉÕ²Ã¤·¤Þ¤¹¤«¡© (1-%d):", p_ptr->lev/7+3), tmp_val, 2)) return;
8292 #else
8293                         if (!get_string(format("Enchant how many? (1-%d):", p_ptr->lev/7+3), tmp_val, 2)) return;
8294 #endif
8295                         val = atoi(tmp_val);
8296                         if (val > p_ptr->lev/7+3) val = p_ptr->lev/7+3;
8297                         else if (val < 1) val = 1;
8298                         use_essence *= val;
8299 #ifdef JP
8300                         msg_format("¥¨¥Ã¥»¥ó¥¹¤ò%d¸Ä»ÈÍÑ¤·¤Þ¤¹¡£", use_essence);
8301 #else
8302                         msg_format("It will take %d essences.", use_essence);
8303 #endif
8304                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8305                         {
8306 #ifdef JP
8307                                 msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
8308 #else
8309                                 msg_print("You don't have enough essences.");
8310 #endif
8311                                 return;
8312                         }
8313                         get_to_h = ((val+1)/2+randint0(val/2+1));
8314                         get_to_d = ((val+1)/2+randint0(val/2+1));
8315                         o_ptr->xtra4 = (get_to_h<<8)+get_to_d;
8316                         o_ptr->to_h += get_to_h;
8317                         o_ptr->to_d += get_to_d;
8318                 }
8319                 p_ptr->magic_num1[es_ptr->essence] -= use_essence;
8320                 if (es_ptr->add == ESSENCE_ATTACK)
8321                 {
8322                         if ((o_ptr->to_h >= p_ptr->lev/5+5) && (o_ptr->to_d >= p_ptr->lev/5+5))
8323                         {
8324 #ifdef JP
8325                                 msg_print("²þÎÉ¤Ë¼ºÇÔ¤·¤¿¡£");
8326 #else
8327                                 msg_print("You failed to enchant.");
8328 #endif
8329                                 energy_use = 100;
8330                                 return;
8331                         }
8332                         else
8333                         {
8334                                 if (o_ptr->to_h < p_ptr->lev/5+5) o_ptr->to_h++;
8335                                 if (o_ptr->to_d < p_ptr->lev/5+5) o_ptr->to_d++;
8336                         }
8337                 }
8338                 else if (es_ptr->add == ESSENCE_AC)
8339                 {
8340                         if (o_ptr->to_a >= p_ptr->lev/5+5)
8341                         {
8342 #ifdef JP
8343                                 msg_print("²þÎÉ¤Ë¼ºÇÔ¤·¤¿¡£");
8344 #else
8345                                 msg_print("You failed to enchant.");
8346 #endif
8347                                 energy_use = 100;
8348                                 return;
8349                         }
8350                         else
8351                         {
8352                                 if (o_ptr->to_a < p_ptr->lev/5+5) o_ptr->to_a++;
8353                         }
8354                 }
8355                 else
8356                 {
8357                         o_ptr->xtra3 = es_ptr->add + 1;
8358                 }
8359         }
8360         else
8361         {
8362                 bool success = TRUE;
8363
8364                 switch(es_ptr->add)
8365                 {
8366                 case ESSENCE_SH_FIRE:
8367                         if ((p_ptr->magic_num1[TR_BRAND_FIRE] < use_essence) || (p_ptr->magic_num1[TR_RES_FIRE] < use_essence))
8368                         {
8369                                 success = FALSE;
8370                                 break;
8371                         }
8372                         p_ptr->magic_num1[TR_BRAND_FIRE] -= use_essence;
8373                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8374                         break;
8375                 case ESSENCE_SH_ELEC:
8376                         if ((p_ptr->magic_num1[TR_BRAND_ELEC] < use_essence) || (p_ptr->magic_num1[TR_RES_ELEC] < use_essence))
8377                         {
8378                                 success = FALSE;
8379                                 break;
8380                         }
8381                         p_ptr->magic_num1[TR_BRAND_ELEC] -= use_essence;
8382                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8383                         break;
8384                 case ESSENCE_SH_COLD:
8385                         if ((p_ptr->magic_num1[TR_BRAND_COLD] < use_essence) || (p_ptr->magic_num1[TR_RES_COLD] < use_essence))
8386                         {
8387                                 success = FALSE;
8388                                 break;
8389                         }
8390                         p_ptr->magic_num1[TR_BRAND_COLD] -= use_essence;
8391                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8392                         break;
8393                 case ESSENCE_RESISTANCE:
8394                 case ESSENCE_SUSTAIN:
8395                         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))
8396                         {
8397                                 success = FALSE;
8398                                 break;
8399                         }
8400                         p_ptr->magic_num1[TR_RES_ACID] -= use_essence;
8401                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8402                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8403                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8404                         break;
8405                 }
8406                 if (!success)
8407                 {
8408 #ifdef JP
8409                         msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
8410 #else
8411                         msg_print("You don't have enough essences.");
8412 #endif
8413                         return;
8414                 }
8415                 if (es_ptr->add == ESSENCE_SUSTAIN)
8416                 {
8417                         add_flag(o_ptr->art_flags, TR_IGNORE_ACID);
8418                         add_flag(o_ptr->art_flags, TR_IGNORE_ELEC);
8419                         add_flag(o_ptr->art_flags, TR_IGNORE_FIRE);
8420                         add_flag(o_ptr->art_flags, TR_IGNORE_COLD);
8421                 }
8422                 else
8423                 {
8424                         o_ptr->xtra3 = es_ptr->add + 1;
8425                 }
8426         }
8427
8428         energy_use = 100;
8429
8430 #ifdef JP
8431         msg_format("%s¤Ë%s¤ÎÇ½ÎÏ¤òÉÕ²Ã¤·¤Þ¤·¤¿¡£", o_name, es_ptr->add_name);
8432 #else
8433         msg_format("You have added ability of %s to %s.", es_ptr->add_name, o_name);
8434 #endif
8435
8436         /* Combine the pack */
8437         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8438
8439         /* Window stuff */
8440         p_ptr->window |= (PW_INVEN);
8441 }
8442
8443
8444 static void erase_essence(void)
8445 {
8446         int item;
8447         cptr q, s;
8448         object_type *o_ptr;
8449         char o_name[MAX_NLEN];
8450         u32b flgs[TR_FLAG_SIZE];
8451
8452         item_tester_hook = object_is_smith;
8453
8454         /* Get an item */
8455 #ifdef JP
8456         q = "¤É¤Î¥¢¥¤¥Æ¥à¤Î¥¨¥Ã¥»¥ó¥¹¤ò¾Ãµî¤·¤Þ¤¹¤«¡©";
8457         s = "¥¨¥Ã¥»¥ó¥¹¤òÉÕ²Ã¤·¤¿¥¢¥¤¥Æ¥à¤¬¤¢¤ê¤Þ¤»¤ó¡£";
8458 #else
8459         q = "Remove from which item? ";
8460         s = "You have nothing to remove essence.";
8461 #endif
8462
8463         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8464
8465         /* Get the item (in the pack) */
8466         if (item >= 0)
8467         {
8468                 o_ptr = &inventory[item];
8469         }
8470
8471         /* Get the item (on the floor) */
8472         else
8473         {
8474                 o_ptr = &o_list[0 - item];
8475         }
8476
8477         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8478 #ifdef JP
8479         if (!get_check(format("¤è¤í¤·¤¤¤Ç¤¹¤«¡© [%s]", o_name))) return;
8480 #else
8481         if (!get_check(format("Are you sure? [%s]", o_name))) return;
8482 #endif
8483
8484         energy_use = 100;
8485
8486         if (o_ptr->xtra3 == 1+ESSENCE_SLAY_GLOVE)
8487         {
8488                 o_ptr->to_h -= (o_ptr->xtra4>>8);
8489                 o_ptr->to_d -= (o_ptr->xtra4 & 0x000f);
8490                 o_ptr->xtra4 = 0;
8491                 if (o_ptr->to_h < 0) o_ptr->to_h = 0;
8492                 if (o_ptr->to_d < 0) o_ptr->to_d = 0;
8493         }
8494         o_ptr->xtra3 = 0;
8495         object_flags(o_ptr, flgs);
8496         if (!(have_pval_flags(flgs))) o_ptr->pval = 0;
8497 #ifdef JP
8498         msg_print("¥¨¥Ã¥»¥ó¥¹¤ò¼è¤êµî¤Ã¤¿¡£");
8499 #else
8500         msg_print("You removed all essence you have added.");
8501 #endif
8502
8503         /* Combine the pack */
8504         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8505
8506         /* Window stuff */
8507         p_ptr->window |= (PW_INVEN);
8508 }
8509
8510 void do_cmd_kaji(bool only_browse)
8511 {
8512         int mode = 0;
8513         char choice;
8514
8515         int menu_line = (use_menu ? 1 : 0);
8516
8517         if (!only_browse)
8518         {
8519                 if (p_ptr->confused)
8520                 {
8521 #ifdef JP
8522                         msg_print("º®Íð¤·¤Æ¤¤¤Æºî¶È¤Ç¤¤Ê¤¤¡ª");
8523 #else
8524                         msg_print("You are too confused!");
8525 #endif
8526
8527                         return;
8528                 }
8529                 if (p_ptr->blind)
8530                 {
8531 #ifdef JP
8532                         msg_print("ÌÜ¤¬¸«¤¨¤Ê¤¯¤Æºî¶È¤Ç¤¤Ê¤¤¡ª");
8533 #else
8534                         msg_print("You are blind!");
8535 #endif
8536
8537                         return;
8538                 }
8539                 if (p_ptr->image)
8540                 {
8541 #ifdef JP
8542                         msg_print("¤¦¤Þ¤¯¸«¤¨¤Ê¤¯¤Æºî¶È¤Ç¤¤Ê¤¤¡ª");
8543 #else
8544                         msg_print("You are hallucinating!");
8545 #endif
8546
8547                         return;
8548                 }
8549         }
8550
8551 #ifdef ALLOW_REPEAT
8552         if (!(repeat_pull(&mode) && 1 <= mode && mode <= 5))
8553         {
8554 #endif /* ALLOW_REPEAT */
8555
8556         if (only_browse) screen_save();
8557         do {
8558         if (!only_browse) screen_save();
8559         if (use_menu)
8560         {
8561                 while(!mode)
8562                 {
8563 #ifdef JP
8564                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹°ìÍ÷", (menu_line == 1) ? "¡Õ" : "  "), 2, 14);
8565                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹Ãê½Ð", (menu_line == 2) ? "¡Õ" : "  "), 3, 14);
8566                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹¾Ãµî", (menu_line == 3) ? "¡Õ" : "  "), 4, 14);
8567                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹ÉÕ²Ã", (menu_line == 4) ? "¡Õ" : "  "), 5, 14);
8568                         prt(format(" %s Éð´ï/ËÉ¶ñ¶¯²½", (menu_line == 5) ? "¡Õ" : "  "), 6, 14);
8569                         prt(format("¤É¤Î¼ïÎà¤Îµ»½Ñ¤ò%s¤Þ¤¹¤«¡©", only_browse ? "Ä´¤Ù" : "»È¤¤"), 0, 0);
8570 #else
8571                         prt(format(" %s List essences", (menu_line == 1) ? "> " : "  "), 2, 14);
8572                         prt(format(" %s Extract essence", (menu_line == 2) ? "> " : "  "), 3, 14);
8573                         prt(format(" %s Remove essence", (menu_line == 3) ? "> " : "  "), 4, 14);
8574                         prt(format(" %s Add essence", (menu_line == 4) ? "> " : "  "), 5, 14);
8575                         prt(format(" %s Enchant weapon/armor", (menu_line == 5) ? "> " : "  "), 6, 14);
8576                         prt(format("Choose command from menu."), 0, 0);
8577 #endif
8578                         choice = inkey();
8579                         switch(choice)
8580                         {
8581                         case ESCAPE:
8582                         case 'z':
8583                         case 'Z':
8584                                 screen_load();
8585                                 return;
8586                         case '2':
8587                         case 'j':
8588                         case 'J':
8589                                 menu_line++;
8590                                 break;
8591                         case '8':
8592                         case 'k':
8593                         case 'K':
8594                                 menu_line+= 4;
8595                                 break;
8596                         case '\r':
8597                         case '\n':
8598                         case 'x':
8599                         case 'X':
8600                                 mode = menu_line;
8601                                 break;
8602                         }
8603                         if (menu_line > 5) menu_line -= 5;
8604                 }
8605         }
8606
8607         else
8608         {
8609                 while (!mode)
8610                 {
8611 #ifdef JP
8612                         prt("  a) ¥¨¥Ã¥»¥ó¥¹°ìÍ÷", 2, 14);
8613                         prt("  b) ¥¨¥Ã¥»¥ó¥¹Ãê½Ð", 3, 14);
8614                         prt("  c) ¥¨¥Ã¥»¥ó¥¹¾Ãµî", 4, 14);
8615                         prt("  d) ¥¨¥Ã¥»¥ó¥¹ÉÕ²Ã", 5, 14);
8616                         prt("  e) Éð´ï/ËÉ¶ñ¶¯²½", 6, 14);
8617                         if (!get_com(format("¤É¤ÎÇ½ÎÏ¤ò%s¤Þ¤¹¤«:", only_browse ? "Ä´¤Ù" : "»È¤¤"), &choice, TRUE))
8618 #else
8619                         prt("  a) List essences", 2, 14);
8620                         prt("  b) Extract essence", 3, 14);
8621                         prt("  c) Remove essence", 4, 14);
8622                         prt("  d) Add essence", 5, 14);
8623                         prt("  e) Enchant weapon/armor", 6, 14);
8624                         if (!get_com("Command :", &choice, TRUE))
8625 #endif
8626                         {
8627                                 screen_load();
8628                                 return;
8629                         }
8630                         switch (choice)
8631                         {
8632                         case 'A':
8633                         case 'a':
8634                                 mode = 1;
8635                                 break;
8636                         case 'B':
8637                         case 'b':
8638                                 mode = 2;
8639                                 break;
8640                         case 'C':
8641                         case 'c':
8642                                 mode = 3;
8643                                 break;
8644                         case 'D':
8645                         case 'd':
8646                                 mode = 4;
8647                                 break;
8648                         case 'E':
8649                         case 'e':
8650                                 mode = 5;
8651                                 break;
8652                         }
8653                 }
8654         }
8655
8656         if (only_browse)
8657         {
8658                 char temp[62*5];
8659                 int line, j;
8660
8661                 /* Clear lines, position cursor  (really should use strlen here) */
8662                 Term_erase(14, 21, 255);
8663                 Term_erase(14, 20, 255);
8664                 Term_erase(14, 19, 255);
8665                 Term_erase(14, 18, 255);
8666                 Term_erase(14, 17, 255);
8667                 Term_erase(14, 16, 255);
8668
8669                 roff_to_buf(kaji_tips[mode-1], 62, temp, sizeof(temp));
8670                 for(j=0, line = 17;temp[j];j+=(1+strlen(&temp[j])))
8671                 {
8672                         prt(&temp[j], line, 15);
8673                         line++;
8674                 }
8675                 mode = 0;
8676         }
8677         if (!only_browse) screen_load();
8678         } while (only_browse);
8679 #ifdef ALLOW_REPEAT
8680         repeat_push(mode);
8681         }
8682 #endif /* ALLOW_REPEAT */
8683
8684         switch(mode)
8685         {
8686                 case 1: display_essence();break;
8687                 case 2: drain_essence();break;
8688                 case 3: erase_essence();break;
8689                 case 4:
8690                         mode = choose_essence();
8691                         if (mode == 0)
8692                                 break;
8693                         add_essence(mode);
8694                         break;
8695                 case 5: add_essence(10);break;
8696         }
8697 }
8698
8699
8700 /*
8701  * Torches have special abilities when they are flaming.
8702  */
8703 void torch_flags(object_type *o_ptr, u32b *flgs)
8704 {
8705         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8706         {
8707                 if (o_ptr->xtra4 > 0)
8708                 {
8709                         add_flag(flgs, TR_BRAND_FIRE);
8710                         add_flag(flgs, TR_KILL_UNDEAD);
8711                         add_flag(flgs, TR_THROW);
8712                 }
8713         }
8714 }
8715
8716 void torch_dice(object_type *o_ptr, int *dd, int *ds)
8717 {
8718         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8719         {
8720                 if (o_ptr->xtra4 > 0)
8721                 {
8722                         (*dd) = 1;
8723                         (*ds) = 6;
8724                 }
8725         }
8726 }
8727
8728 void torch_lost_fuel(object_type *o_ptr)
8729 {
8730         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8731         {
8732                 o_ptr->xtra4 -= (FUEL_TORCH / 25);
8733                 if (o_ptr->xtra4 < 0) o_ptr->xtra4 = 0;
8734         }
8735 }