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