src/object2.c

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