src/object2.c

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