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