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