src/files.c

   1 /* File: files.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: code dealing with files (and death) */
  12
  13 #include "angband.h"
  14
  15
  16 /*
  17  * You may or may not want to use the following "#undef".
  18  */
  19 /* #undef _POSIX_SAVED_IDS */
  20
  21
  22 /*
  23  * Hack -- drop permissions
  24  */
  25 void safe_setuid_drop(void)
  26 {
  27
  28 #ifdef SET_UID
  29
  30 # ifdef SAFE_SETUID
  31
  32 #  ifdef SAFE_SETUID_POSIX
  33
  34         if (setuid(getuid()) != 0)
  35         {
  36 #ifdef JP
  37 quit("setuid(): Àµ¤·¤¯µö²Ä¤¬¼è¤ì¤Þ¤»¤ó¡ª");
  38 #else
  39                 quit("setuid(): cannot set permissions correctly!");
  40 #endif
  41
  42         }
  43         if (setgid(getgid()) != 0)
  44         {
  45 #ifdef JP
  46 quit("setgid(): Àµ¤·¤¯µö²Ä¤¬¼è¤ì¤Þ¤»¤ó¡ª");
  47 #else
  48                 quit("setgid(): cannot set permissions correctly!");
  49 #endif
  50
  51         }
  52
  53 #  else
  54
  55         if (setreuid(geteuid(), getuid()) != 0)
  56         {
  57 #ifdef JP
  58 quit("setreuid(): Àµ¤·¤¯µö²Ä¤¬¼è¤ì¤Þ¤»¤ó¡ª");
  59 #else
  60                 quit("setreuid(): cannot set permissions correctly!");
  61 #endif
  62
  63         }
  64         if (setregid(getegid(), getgid()) != 0)
  65         {
  66 #ifdef JP
  67 quit("setregid(): Àµ¤·¤¯µö²Ä¤¬¼è¤ì¤Þ¤»¤ó¡ª");
  68 #else
  69                 quit("setregid(): cannot set permissions correctly!");
  70 #endif
  71
  72         }
  73
  74 #  endif
  75
  76 # endif
  77
  78 #endif
  79
  80 }
  81
  82
  83 /*
  84  * Hack -- grab permissions
  85  */
  86 void safe_setuid_grab(void)
  87 {
  88
  89 #ifdef SET_UID
  90
  91 # ifdef SAFE_SETUID
  92
  93 #  ifdef SAFE_SETUID_POSIX
  94
  95         if (setuid(player_euid) != 0)
  96         {
  97 #ifdef JP
  98 quit("setuid(): Àµ¤·¤¯µö²Ä¤¬¼è¤ì¤Þ¤»¤ó¡ª");
  99 #else
 100                 quit("setuid(): cannot set permissions correctly!");
 101 #endif
 102
 103         }
 104         if (setgid(player_egid) != 0)
 105         {
 106 #ifdef JP
 107 quit("setgid(): Àµ¤·¤¯µö²Ä¤¬¼è¤ì¤Þ¤»¤ó¡ª");
 108 #else
 109                 quit("setgid(): cannot set permissions correctly!");
 110 #endif
 111
 112         }
 113
 114 #  else
 115
 116         if (setreuid(geteuid(), getuid()) != 0)
 117         {
 118 #ifdef JP
 119 quit("setreuid(): Àµ¤·¤¯µö²Ä¤¬¼è¤ì¤Þ¤»¤ó¡ª");
 120 #else
 121                 quit("setreuid(): cannot set permissions correctly!");
 122 #endif
 123
 124         }
 125         if (setregid(getegid(), getgid()) != 0)
 126         {
 127 #ifdef JP
 128 quit("setregid(): Àµ¤·¤¯µö²Ä¤¬¼è¤ì¤Þ¤»¤ó¡ª");
 129 #else
 130                 quit("setregid(): cannot set permissions correctly!");
 131 #endif
 132
 133         }
 134
 135 #  endif /* SAFE_SETUID_POSIX */
 136
 137 # endif /* SAFE_SETUID */
 138
 139 #endif /* SET_UID */
 140
 141 }
 142
 143
 144 /*
 145  * Extract the first few "tokens" from a buffer
 146  *
 147  * This function uses "colon" and "slash" as the delimeter characters.
 148  *
 149  * We never extract more than "num" tokens.  The "last" token may include
 150  * "delimeter" characters, allowing the buffer to include a "string" token.
 151  *
 152  * We save pointers to the tokens in "tokens", and return the number found.
 153  *
 154  * Hack -- Attempt to handle the 'c' character formalism
 155  *
 156  * Hack -- An empty buffer, or a final delimeter, yields an "empty" token.
 157  *
 158  * Hack -- We will always extract at least one token
 159  */
 160 s16b tokenize(char *buf, s16b num, char **tokens, int mode)
 161 {
 162         int i = 0;
 163
 164         char *s = buf;
 165
 166
 167         /* Process */
 168         while (i < num - 1)
 169         {
 170                 char *t;
 171
 172                 /* Scan the string */
 173                 for (t = s; *t; t++)
 174                 {
 175                         /* Found a delimiter */
 176                         if ((*t == ':') || (*t == '/')) break;
 177
 178                         /* Handle single quotes */
 179                         if ((mode & TOKENIZE_CHECKQUOTE) && (*t == '\''))
 180                         {
 181                                 /* Advance */
 182                                 t++;
 183
 184                                 /* Handle backslash */
 185                                 if (*t == '\\') t++;
 186
 187                                 /* Require a character */
 188                                 if (!*t) break;
 189
 190                                 /* Advance */
 191                                 t++;
 192
 193                                 /* Hack -- Require a close quote */
 194                                 if (*t != '\'') *t = '\'';
 195                         }
 196
 197                         /* Handle back-slash */
 198                         if (*t == '\\') t++;
 199                 }
 200
 201                 /* Nothing left */
 202                 if (!*t) break;
 203
 204                 /* Nuke and advance */
 205                 *t++ = '\0';
 206
 207                 /* Save the token */
 208                 tokens[i++] = s;
 209
 210                 /* Advance */
 211                 s = t;
 212         }
 213
 214         /* Save the token */
 215         tokens[i++] = s;
 216
 217         /* Number found */
 218         return (i);
 219 }
 220
 221
 222 /* A number with a name */
 223 typedef struct named_num named_num;
 224
 225 struct named_num
 226 {
 227         cptr name;              /* The name of this thing */
 228         int num;                        /* A number associated with it */
 229 };
 230
 231
 232 /* Index of spell type names */
 233 static named_num gf_desc[] =
 234 {
 235         {"GF_ELEC",                             GF_ELEC                         },
 236         {"GF_POIS",                             GF_POIS                         },
 237         {"GF_ACID",                             GF_ACID                         },
 238         {"GF_COLD",                             GF_COLD                         },
 239         {"GF_FIRE",                                     GF_FIRE                         },
 240         {"GF_PSY_SPEAR",                        GF_PSY_SPEAR                    },
 241         {"GF_MISSILE",                          GF_MISSILE                      },
 242         {"GF_ARROW",                            GF_ARROW                                },
 243         {"GF_PLASMA",                           GF_PLASMA                       },
 244         {"GF_WATER",                            GF_WATER                                },
 245         {"GF_LITE",                                     GF_LITE                         },
 246         {"GF_DARK",                                     GF_DARK                         },
 247         {"GF_LITE_WEAK",                        GF_LITE_WEAK            },
 248         {"GF_DARK_WEAK",                        GF_DARK_WEAK            },
 249         {"GF_SHARDS",                           GF_SHARDS                       },
 250         {"GF_SOUND",                            GF_SOUND                                },
 251         {"GF_CONFUSION",                        GF_CONFUSION            },
 252         {"GF_FORCE",                            GF_FORCE                                },
 253         {"GF_INERTIA",                          GF_INERTIA                      },
 254         {"GF_MANA",                                     GF_MANA                         },
 255         {"GF_METEOR",                           GF_METEOR                       },
 256         {"GF_ICE",                                      GF_ICE                          },
 257         {"GF_CHAOS",                            GF_CHAOS                                },
 258         {"GF_NETHER",                           GF_NETHER                       },
 259         {"GF_DISENCHANT",                       GF_DISENCHANT           },
 260         {"GF_NEXUS",                            GF_NEXUS                                },
 261         {"GF_TIME",                                     GF_TIME                         },
 262         {"GF_GRAVITY",                          GF_GRAVITY                      },
 263         {"GF_KILL_WALL",                        GF_KILL_WALL            },
 264         {"GF_KILL_DOOR",                        GF_KILL_DOOR            },
 265         {"GF_KILL_TRAP",                        GF_KILL_TRAP            },
 266         {"GF_MAKE_WALL",                        GF_MAKE_WALL            },
 267         {"GF_MAKE_DOOR",                        GF_MAKE_DOOR            },
 268         {"GF_MAKE_TRAP",                        GF_MAKE_TRAP            },
 269         {"GF_MAKE_TREE",                        GF_MAKE_TREE            },
 270         {"GF_OLD_CLONE",                        GF_OLD_CLONE            },
 271         {"GF_OLD_POLY",                 GF_OLD_POLY                     },
 272         {"GF_OLD_HEAL",                 GF_OLD_HEAL                     },
 273         {"GF_OLD_SPEED",                        GF_OLD_SPEED            },
 274         {"GF_OLD_SLOW",                 GF_OLD_SLOW                     },
 275         {"GF_OLD_CONF",                 GF_OLD_CONF                     },
 276         {"GF_OLD_SLEEP",                        GF_OLD_SLEEP            },
 277         {"GF_OLD_DRAIN",                        GF_OLD_DRAIN            },
 278         {"GF_AWAY_UNDEAD",              GF_AWAY_UNDEAD          },
 279         {"GF_AWAY_EVIL",                        GF_AWAY_EVIL            },
 280         {"GF_AWAY_ALL",                 GF_AWAY_ALL                     },
 281         {"GF_TURN_UNDEAD",              GF_TURN_UNDEAD          },
 282         {"GF_TURN_EVIL",                        GF_TURN_EVIL            },
 283         {"GF_TURN_ALL",                 GF_TURN_ALL                     },
 284         {"GF_DISP_UNDEAD",              GF_DISP_UNDEAD          },
 285         {"GF_DISP_EVIL",                        GF_DISP_EVIL            },
 286         {"GF_DISP_ALL",                 GF_DISP_ALL                     },
 287         {"GF_DISP_DEMON",                       GF_DISP_DEMON           },
 288         {"GF_DISP_LIVING",              GF_DISP_LIVING          },
 289         {"GF_ROCKET",                           GF_ROCKET                       },
 290         {"GF_NUKE",                                     GF_NUKE                         },
 291         {"GF_MAKE_GLYPH",                       GF_MAKE_GLYPH           },
 292         {"GF_STASIS",                           GF_STASIS                       },
 293         {"GF_STONE_WALL",                       GF_STONE_WALL           },
 294         {"GF_DEATH_RAY",                        GF_DEATH_RAY            },
 295         {"GF_STUN",                                     GF_STUN                         },
 296         {"GF_HOLY_FIRE",                        GF_HOLY_FIRE            },
 297         {"GF_HELL_FIRE",                        GF_HELL_FIRE            },
 298         {"GF_DISINTEGRATE",             GF_DISINTEGRATE },
 299         {"GF_CHARM",                            GF_CHARM                                },
 300         {"GF_CONTROL_UNDEAD",   GF_CONTROL_UNDEAD       },
 301         {"GF_CONTROL_ANIMAL",   GF_CONTROL_ANIMAL       },
 302         {"GF_PSI",                                      GF_PSI                          },
 303         {"GF_PSI_DRAIN",                        GF_PSI_DRAIN            },
 304         {"GF_TELEKINESIS",              GF_TELEKINESIS          },
 305         {"GF_JAM_DOOR",                 GF_JAM_DOOR                     },
 306         {"GF_DOMINATION",                       GF_DOMINATION           },
 307         {"GF_DISP_GOOD",                        GF_DISP_GOOD            },
 308         {"GF_DRAIN_MANA",                       GF_DRAIN_MANA           },
 309         {"GF_MIND_BLAST",                       GF_MIND_BLAST           },
 310         {"GF_BRAIN_SMASH",                      GF_BRAIN_SMASH          },
 311         {"GF_CAUSE_1",                  GF_CAUSE_1              },
 312         {"GF_CAUSE_2",                  GF_CAUSE_2              },
 313         {"GF_CAUSE_3",                  GF_CAUSE_3              },
 314         {"GF_CAUSE_4",                  GF_CAUSE_4              },
 315         {"GF_HAND_DOOM",                        GF_HAND_DOOM            },
 316         {"GF_CAPTURE",                  GF_CAPTURE              },
 317         {"GF_ANIM_DEAD",                        GF_ANIM_DEAD            },
 318         {"GF_CONTROL_LIVING",           GF_CONTROL_LIVING       },
 319         {"GF_IDENTIFY",                 GF_IDENTIFY     },
 320         {"GF_ATTACK",                   GF_ATTACK       },
 321         {"GF_ENGETSU",                  GF_ENGETSU      },
 322         {"GF_GENOCIDE",                 GF_GENOCIDE     },
 323         {"GF_PHOTO",                    GF_PHOTO        },
 324         {"GF_CONTROL_DEMON",    GF_CONTROL_DEMON        },
 325         {"GF_LAVA_FLOW",        GF_LAVA_FLOW    },
 326         {"GF_BLOOD_CURSE",      GF_BLOOD_CURSE  },
 327         {"GF_SEEKER",                   GF_SEEKER                       },
 328         {"GF_SUPER_RAY",                GF_SUPER_RAY                    },
 329         {"GF_STAR_HEAL",                GF_STAR_HEAL                    },
 330         {"GF_WATER_FLOW",               GF_WATER_FLOW                   },
 331         {"GF_CRUSADE",          GF_CRUSADE                      },
 332         {"GF_STASIS_EVIL",                      GF_STASIS_EVIL          },
 333         {"GF_WOUNDS",                   GF_WOUNDS               },
 334         {NULL,                                          0                                               }
 335 };
 336
 337
 338 /*
 339  * Parse a sub-file of the "extra info" (format shown below)
 340  *
 341  * Each "action" line has an "action symbol" in the first column,
 342  * followed by a colon, followed by some command specific info,
 343  * usually in the form of "tokens" separated by colons or slashes.
 344  *
 345  * Blank lines, lines starting with white space, and lines starting
 346  * with pound signs ("#") are ignored (as comments).
 347  *
 348  * Note the use of "tokenize()" to allow the use of both colons and
 349  * slashes as delimeters, while still allowing final tokens which
 350  * may contain any characters including "delimiters".
 351  *
 352  * Note the use of "strtol()" to allow all "integers" to be encoded
 353  * in decimal, hexidecimal, or octal form.
 354  *
 355  * Note that "monster zero" is used for the "player" attr/char, "object
 356  * zero" will be used for the "stack" attr/char, and "feature zero" is
 357  * used for the "nothing" attr/char.
 358  *
 359  * Parse another file recursively, see below for details
 360  *   %:<filename>
 361  *
 362  * Specify the attr/char values for "monsters" by race index
 363  *   R:<num>:<a>:<c>
 364  *
 365  * Specify the attr/char values for "objects" by kind index
 366  *   K:<num>:<a>:<c>
 367  *
 368  * Specify the attr/char values for "features" by feature index
 369  *   F:<num>:<a>:<c>
 370  *
 371  * Specify the attr/char values for unaware "objects" by kind tval
 372  *   U:<tv>:<a>:<c>
 373  *
 374  * Specify the attr/char values for inventory "objects" by kind tval
 375  *   E:<tv>:<a>:<c>
 376  *
 377  * Define a macro action, given an encoded macro action
 378  *   A:<str>
 379  *
 380  * Create a normal macro, given an encoded macro trigger
 381  *   P:<str>
 382  *
 383  * Create a command macro, given an encoded macro trigger
 384  *   C:<str>
 385  *
 386  * Create a keyset mapping
 387  *   S:<key>:<key>:<dir>
 388  *
 389  * Turn an option off, given its name
 390  *   X:<str>
 391  *
 392  * Turn an option on, given its name
 393  *   Y:<str>
 394  *
 395  * Specify visual information, given an index, and some data
 396  *   V:<num>:<kv>:<rv>:<gv>:<bv>
 397  *
 398  * Specify the set of colors to use when drawing a zapped spell
 399  *   Z:<type>:<str>
 400  *
 401  * Specify a macro trigger template and macro trigger names.
 402  *   T:<template>:<modifier chr>:<modifier name1>:<modifier name2>:...
 403  *   T:<trigger>:<keycode>:<shift-keycode>
 404  *
 405  */
 406
 407 errr process_pref_file_command(char *buf)
 408 {
 409         int i, j, n1, n2;
 410
 411         char *zz[16];
 412
 413
 414         /* Require "?:*" format */
 415         if (buf[1] != ':') return 1;
 416
 417
 418         switch (buf[0])
 419         {
 420         /* Mega-Hack -- read external player's history file */
 421         /* Process "H:<history>" */
 422         case 'H':
 423                 add_history_from_pref_line(buf + 2);
 424                 return 0;
 425
 426         /* Process "R:<num>:<a>/<c>" -- attr/char for monster races */
 427         case 'R':
 428                 if (tokenize(buf+2, 3, zz, TOKENIZE_CHECKQUOTE) == 3)
 429                 {
 430                         monster_race *r_ptr;
 431                         i = (huge)strtol(zz[0], NULL, 0);
 432                         n1 = strtol(zz[1], NULL, 0);
 433                         n2 = strtol(zz[2], NULL, 0);
 434                         if (i >= max_r_idx) return 1;
 435                         r_ptr = &r_info[i];
 436                         if (n1) r_ptr->x_attr = n1;
 437                         if (n2) r_ptr->x_char = n2;
 438                         return 0;
 439                 }
 440                 break;
 441
 442         /* Process "K:<num>:<a>/<c>"  -- attr/char for object kinds */
 443         case 'K':
 444                 if (tokenize(buf+2, 3, zz, TOKENIZE_CHECKQUOTE) == 3)
 445                 {
 446                         object_kind *k_ptr;
 447                         i = (huge)strtol(zz[0], NULL, 0);
 448                         n1 = strtol(zz[1], NULL, 0);
 449                         n2 = strtol(zz[2], NULL, 0);
 450                         if (i >= max_k_idx) return 1;
 451                         k_ptr = &k_info[i];
 452                         if (n1) k_ptr->x_attr = n1;
 453                         if (n2) k_ptr->x_char = n2;
 454                         return 0;
 455                 }
 456                 break;
 457
 458         /* Process "F:<num>:<a>/<c>" -- attr/char for terrain features */
 459         case 'F':
 460                 if (tokenize(buf+2, 3, zz, TOKENIZE_CHECKQUOTE) == 3)
 461                 {
 462                         feature_type *f_ptr;
 463                         i = (huge)strtol(zz[0], NULL, 0);
 464                         n1 = strtol(zz[1], NULL, 0);
 465                         n2 = strtol(zz[2], NULL, 0);
 466                         if (i >= max_f_idx) return 1;
 467                         f_ptr = &f_info[i];
 468                         if (n1) f_ptr->x_attr = n1;
 469                         if (n2) f_ptr->x_char = n2;
 470                         return 0;
 471                 }
 472                 break;
 473
 474         /* Process "S:<num>:<a>/<c>" -- attr/char for special things */
 475         case 'S':
 476                 if (tokenize(buf+2, 3, zz, TOKENIZE_CHECKQUOTE) == 3)
 477                 {
 478                         j = (byte)strtol(zz[0], NULL, 0);
 479                         n1 = strtol(zz[1], NULL, 0);
 480                         n2 = strtol(zz[2], NULL, 0);
 481                         misc_to_attr[j] = n1;
 482                         misc_to_char[j] = n2;
 483                         return 0;
 484                 }
 485                 break;
 486
 487         /* Process "U:<tv>:<a>/<c>" -- attr/char for unaware items */
 488         case 'U':
 489                 if (tokenize(buf+2, 3, zz, TOKENIZE_CHECKQUOTE) == 3)
 490                 {
 491                         j = (huge)strtol(zz[0], NULL, 0);
 492                         n1 = strtol(zz[1], NULL, 0);
 493                         n2 = strtol(zz[2], NULL, 0);
 494                         for (i = 1; i < max_k_idx; i++)
 495                         {
 496                                 object_kind *k_ptr = &k_info[i];
 497                                 if (k_ptr->tval == j)
 498                                 {
 499                                         if (n1) k_ptr->d_attr = n1;
 500                                         if (n2) k_ptr->d_char = n2;
 501                                 }
 502                         }
 503                         return 0;
 504                 }
 505                 break;
 506
 507         /* Process "E:<tv>:<a>" -- attribute for inventory objects */
 508         case 'E':
 509                 if (tokenize(buf+2, 2, zz, TOKENIZE_CHECKQUOTE) == 2)
 510                 {
 511                         j = (byte)strtol(zz[0], NULL, 0) % 128;
 512                         n1 = strtol(zz[1], NULL, 0);
 513                         if (n1) tval_to_attr[j] = n1;
 514                         return 0;
 515                 }
 516                 break;
 517
 518         /* Process "A:<str>" -- save an "action" for later */
 519         case 'A':
 520                 text_to_ascii(macro__buf, buf+2);
 521                 return 0;
 522
 523         /* Process "P:<str>" -- normal macro */
 524         case 'P':
 525         {
 526                 char tmp[1024];
 527
 528                 text_to_ascii(tmp, buf+2);
 529                 macro_add(tmp, macro__buf);
 530                 return 0;
 531         }
 532
 533         /* Process "C:<str>" -- create keymap */
 534         case 'C':
 535         {
 536                 int mode;
 537                 char tmp[1024];
 538
 539                 if (tokenize(buf+2, 2, zz, TOKENIZE_CHECKQUOTE) != 2) return 1;
 540
 541                 mode = strtol(zz[0], NULL, 0);
 542                 if ((mode < 0) || (mode >= KEYMAP_MODES)) return 1;
 543
 544                 text_to_ascii(tmp, zz[1]);
 545                 if (!tmp[0] || tmp[1]) return 1;
 546                 i = (byte)(tmp[0]);
 547
 548                 string_free(keymap_act[mode][i]);
 549
 550                 keymap_act[mode][i] = string_make(macro__buf);
 551
 552                 return 0;
 553         }
 554
 555         /* Process "V:<num>:<kv>:<rv>:<gv>:<bv>" -- visual info */
 556         case 'V':
 557                 if (tokenize(buf+2, 5, zz, TOKENIZE_CHECKQUOTE) == 5)
 558                 {
 559                         i = (byte)strtol(zz[0], NULL, 0);
 560                         angband_color_table[i][0] = (byte)strtol(zz[1], NULL, 0);
 561                         angband_color_table[i][1] = (byte)strtol(zz[2], NULL, 0);
 562                         angband_color_table[i][2] = (byte)strtol(zz[3], NULL, 0);
 563                         angband_color_table[i][3] = (byte)strtol(zz[4], NULL, 0);
 564                         return 0;
 565                 }
 566                 break;
 567
 568         /* Process "X:<str>" -- turn option off */
 569         /* Process "Y:<str>" -- turn option on */
 570         case 'X':
 571         case 'Y':
 572                 for (i = 0; option_info[i].o_desc; i++)
 573                 {
 574                         if (option_info[i].o_var &&
 575                             option_info[i].o_text &&
 576                             streq(option_info[i].o_text, buf + 2))
 577                         {
 578                                 int os = option_info[i].o_set;
 579                                 int ob = option_info[i].o_bit;
 580
 581                                 if ((p_ptr->playing || character_xtra) &&
 582                                         (OPT_PAGE_BIRTH == option_info[i].o_page) && !p_ptr->wizard)
 583                                 {
 584 #ifdef JP
 585                                         msg_format("½é´ü¥ª¥×¥·¥ç¥ó¤ÏÊÑ¹¹¤Ç¤¤Þ¤»¤ó! '%s'", buf);
 586 #else
 587                                         msg_format("Birth options can not changed! '%s'", buf);
 588 #endif
 589                                         msg_print(NULL);
 590                                         return 0;
 591                                 }
 592
 593                                 if (buf[0] == 'X')
 594                                 {
 595                                         /* Clear */
 596                                         option_flag[os] &= ~(1L << ob);
 597                                         (*option_info[i].o_var) = FALSE;
 598                                 }
 599                                 else
 600                                 {
 601                                         /* Set */
 602                                         option_flag[os] |= (1L << ob);
 603                                         (*option_info[i].o_var) = TRUE;
 604                                 }
 605                                 return 0;
 606                         }
 607                 }
 608
 609                 /* don't know that option. ignore it.*/
 610 #ifdef JP
 611                 msg_format("¥ª¥×¥·¥ç¥ó¤ÎÌ¾Á°¤¬Àµ¤·¤¯¤¢¤ê¤Þ¤»¤ó¡§ %s", buf);
 612 #else
 613                 msg_format("Ignored invalid option: %s", buf);
 614 #endif
 615                 msg_print(NULL);
 616                 return 0;
 617
 618         /* Process "Z:<type>:<str>" -- set spell color */
 619         case 'Z':
 620         {
 621                 /* Find the colon */
 622                 char *t = my_strchr(buf + 2, ':');
 623
 624                 /* Oops */
 625                 if (!t) return 1;
 626
 627                 /* Nuke the colon */
 628                 *(t++) = '\0';
 629
 630                 for (i = 0; gf_desc[i].name; i++)
 631                 {
 632                         /* Match this type */
 633                         if (streq(gf_desc[i].name, buf + 2))
 634                         {
 635                                 /* Remember this color set */
 636                                 gf_color[gf_desc[i].num] = quark_add(t);
 637
 638                                 /* Success */
 639                                 return 0;
 640                         }
 641                 }
 642
 643                 break;
 644         }
 645
 646         /* Initialize macro trigger names and a template */
 647         /* Process "T:<trigger>:<keycode>:<shift-keycode>" */
 648         /* Process "T:<template>:<modifier chr>:<modifier name>:..." */
 649         case 'T':
 650         {
 651                 int tok = tokenize(buf+2, 2+MAX_MACRO_MOD, zz, 0);
 652
 653                 /* Process "T:<template>:<modifier chr>:<modifier name>:..." */
 654                 if (tok >= 4)
 655                 {
 656                         int i;
 657                         int num;
 658
 659                         if (macro_template != NULL)
 660                         {
 661                                 num = strlen(macro_modifier_chr);
 662
 663                                 /* Kill the template string */
 664                                 string_free(macro_template);
 665                                 macro_template = NULL;
 666
 667                                 /* Kill flag characters of modifier keys */
 668                                 string_free(macro_modifier_chr);
 669
 670                                 /* Kill corresponding modifier names */
 671                                 for (i = 0; i < num; i++)
 672                                 {
 673                                         string_free(macro_modifier_name[i]);
 674                                 }
 675
 676                                 /* Kill trigger name strings */
 677                                 for (i = 0; i < max_macrotrigger; i++)
 678                                 {
 679                                         string_free(macro_trigger_name[i]);
 680                                         string_free(macro_trigger_keycode[0][i]);
 681                                         string_free(macro_trigger_keycode[1][i]);
 682                                 }
 683
 684                                 max_macrotrigger = 0;
 685                         }
 686
 687                         if (*zz[0] == '\0') return 0; /* clear template */
 688
 689                         /* Number of modifier flags */
 690                         num = strlen(zz[1]);
 691
 692                         /* Limit the number */
 693                         num = MIN(MAX_MACRO_MOD, num);
 694
 695                         /* Stop if number of modifier is not correct */
 696                         if (2 + num != tok) return 1;
 697
 698                         /* Get a template string */
 699                         macro_template = string_make(zz[0]);
 700
 701                         /* Get flag characters of modifier keys */
 702                         macro_modifier_chr = string_make(zz[1]);
 703
 704                         /* Get corresponding modifier names */
 705                         for (i = 0; i < num; i++)
 706                         {
 707                                 macro_modifier_name[i] = string_make(zz[2+i]);
 708                         }
 709                 }
 710
 711                 /* Process "T:<trigger>:<keycode>:<shift-keycode>" */
 712                 else if (tok >= 2)
 713                 {
 714                         char buf[1024];
 715                         int m;
 716                         char *t, *s;
 717                         if (max_macrotrigger >= MAX_MACRO_TRIG)
 718                         {
 719 #ifdef JP
 720                                 msg_print("¥Þ¥¯¥í¥È¥ê¥¬¡¼¤ÎÀßÄê¤¬Â¿¤¹¤®¤Þ¤¹!");
 721 #else
 722                                 msg_print("Too many macro triggers!");
 723 #endif
 724                                 return 1;
 725                         }
 726                         m = max_macrotrigger;
 727                         max_macrotrigger++;
 728
 729                         /* Take into account the escape character  */
 730                         t = buf;
 731                         s = zz[0];
 732                         while (*s)
 733                         {
 734                                 if ('\\' == *s) s++;
 735                                 *t++ = *s++;
 736                         }
 737                         *t = '\0';
 738
 739                         /* Get a trigger name */
 740                         macro_trigger_name[m] = string_make(buf);
 741
 742                         /* Get the corresponding key code */
 743                         macro_trigger_keycode[0][m] = string_make(zz[1]);
 744
 745                         if (tok == 3)
 746                         {
 747                                 /* Key code of a combination of it with the shift key */
 748                                 macro_trigger_keycode[1][m] = string_make(zz[2]);
 749                         }
 750                         else
 751                         {
 752                                 macro_trigger_keycode[1][m] = string_make(zz[1]);
 753                         }
 754                 }
 755
 756                 /* No error */
 757                 return 0;
 758         }
 759         }
 760
 761         /* Failure */
 762         return 1;
 763 }
 764
 765
 766 /*
 767  * Helper function for "process_pref_file()"
 768  *
 769  * Input:
 770  *   v: output buffer array
 771  *   f: final character
 772  *
 773  * Output:
 774  *   result
 775  */
 776 cptr process_pref_file_expr(cptr *sp, char *fp)
 777 {
 778         cptr v;
 779
 780         cptr s;
 781
 782         char b1 = '[';
 783         char b2 = ']';
 784
 785         char f = ' ';
 786         static char tmp[8];
 787
 788         /* Initial */
 789         s = (*sp);
 790
 791         /* Skip spaces */
 792         while (isspace(*s)) s++;
 793
 794         /* Default */
 795         v = "?o?o?";
 796
 797         /* Analyze */
 798         if (*s == b1)
 799         {
 800                 const char *p;
 801                 const char *t;
 802
 803                 /* Skip b1 */
 804                 s++;
 805
 806                 /* First */
 807                 t = process_pref_file_expr(&s, &f);
 808
 809                 /* Oops */
 810                 if (!*t)
 811                 {
 812                         /* Nothing */
 813                 }
 814
 815                 /* Function: IOR */
 816                 else if (streq(t, "IOR"))
 817                 {
 818                         v = "0";
 819                         while (*s && (f != b2))
 820                         {
 821                                 t = process_pref_file_expr(&s, &f);
 822                                 if (*t && !streq(t, "0")) v = "1";
 823                         }
 824                 }
 825
 826                 /* Function: AND */
 827                 else if (streq(t, "AND"))
 828                 {
 829                         v = "1";
 830                         while (*s && (f != b2))
 831                         {
 832                                 t = process_pref_file_expr(&s, &f);
 833                                 if (*t && streq(t, "0")) v = "0";
 834                         }
 835                 }
 836
 837                 /* Function: NOT */
 838                 else if (streq(t, "NOT"))
 839                 {
 840                         v = "1";
 841                         while (*s && (f != b2))
 842                         {
 843                                 t = process_pref_file_expr(&s, &f);
 844                                 if (*t && streq(t, "1")) v = "0";
 845                         }
 846                 }
 847
 848                 /* Function: EQU */
 849                 else if (streq(t, "EQU"))
 850                 {
 851                         v = "0";
 852                         if (*s && (f != b2))
 853                         {
 854                                 t = process_pref_file_expr(&s, &f);
 855                         }
 856                         while (*s && (f != b2))
 857                         {
 858                                 p = process_pref_file_expr(&s, &f);
 859                                 if (streq(t, p)) v = "1";
 860                         }
 861                 }
 862
 863                 /* Function: LEQ */
 864                 else if (streq(t, "LEQ"))
 865                 {
 866                         v = "1";
 867                         if (*s && (f != b2))
 868                         {
 869                                 t = process_pref_file_expr(&s, &f);
 870                         }
 871                         while (*s && (f != b2))
 872                         {
 873                                 p = t;
 874                                 t = process_pref_file_expr(&s, &f);
 875                                 if (*t && atoi(p) > atoi(t)) v = "0";
 876                         }
 877                 }
 878
 879                 /* Function: GEQ */
 880                 else if (streq(t, "GEQ"))
 881                 {
 882                         v = "1";
 883                         if (*s && (f != b2))
 884                         {
 885                                 t = process_pref_file_expr(&s, &f);
 886                         }
 887                         while (*s && (f != b2))
 888                         {
 889                                 p = t;
 890                                 t = process_pref_file_expr(&s, &f);
 891
 892                                 /* Compare two numbers instead of string */
 893                                 if (*t && atoi(p) < atoi(t)) v = "0";
 894                         }
 895                 }
 896
 897                 /* Oops */
 898                 else
 899                 {
 900                         while (*s && (f != b2))
 901                         {
 902                                 t = process_pref_file_expr(&s, &f);
 903                         }
 904                 }
 905
 906                 /* Verify ending */
 907                 if (f != b2) v = "?x?x?";
 908
 909                 /* Extract final and Terminate */
 910                 if ((f = *s) != '\0') s++;
 911         }
 912
 913         /* Other */
 914         else
 915         {
 916                 char b[1024];
 917                 int i;
 918
 919                 /* Accept all printables except spaces and brackets */
 920                 for (i = 0; isprint(*s) && !my_strchr(" []", *s); i++)
 921                         b[i] = *s++;
 922
 923                 /* Terminate */
 924                 b[i] = '\0';
 925
 926                 /* Extract final and Terminate */
 927                 if ((f = *s) != '\0') s++;
 928
 929                 /* Variable */
 930                 if (*b == '$')
 931                 {
 932                         /* System */
 933                         if (streq(b+1, "SYS"))
 934                         {
 935                                 v = ANGBAND_SYS;
 936                         }
 937
 938                         else if (streq(b+1, "KEYBOARD"))
 939                         {
 940                                 v = ANGBAND_KEYBOARD;
 941                         }
 942
 943                         /* Graphics */
 944                         else if (streq(b+1, "GRAF"))
 945                         {
 946                                 v = ANGBAND_GRAF;
 947                         }
 948
 949                         /* Monochrome mode */
 950                         else if (streq(b+1, "MONOCHROME"))
 951                         {
 952                                 if (arg_monochrome)
 953                                         v = "ON";
 954                                 else
 955                                         v = "OFF";
 956                         }
 957
 958                         /* Race */
 959                         else if (streq(b+1, "RACE"))
 960                         {
 961 #ifdef JP
 962                                 v = rp_ptr->E_title;
 963 #else
 964                                 v = rp_ptr->title;
 965 #endif
 966                         }
 967
 968                         /* Class */
 969                         else if (streq(b+1, "CLASS"))
 970                         {
 971 #ifdef JP
 972                                 v = cp_ptr->E_title;
 973 #else
 974                                 v = cp_ptr->title;
 975 #endif
 976                         }
 977
 978                         /* Player */
 979                         else if (streq(b+1, "PLAYER"))
 980                         {
 981                                 v = player_base;
 982                         }
 983
 984                         /* First realm */
 985                         else if (streq(b+1, "REALM1"))
 986                         {
 987 #ifdef JP
 988                                 v = E_realm_names[p_ptr->realm1];
 989 #else
 990                                 v = realm_names[p_ptr->realm1];
 991 #endif
 992                         }
 993
 994                         /* Second realm */
 995                         else if (streq(b+1, "REALM2"))
 996                         {
 997 #ifdef JP
 998                                 v = E_realm_names[p_ptr->realm2];
 999 #else
1000                                 v = realm_names[p_ptr->realm2];
1001 #endif
1002                         }
1003
1004                         /* Level */
1005                         else if (streq(b+1, "LEVEL"))
1006                         {
1007                                 sprintf(tmp, "%02d", p_ptr->lev);
1008                                 v = tmp;
1009                         }
1010
1011                         /* Autopick auto-register is in-use or not? */
1012                         else if (streq(b+1, "AUTOREGISTER"))
1013                         {
1014                                 if (p_ptr->autopick_autoregister)
1015                                         v = "1";
1016                                 else
1017                                         v = "0";
1018                         }
1019                 }
1020
1021                 /* Constant */
1022                 else
1023                 {
1024                         v = b;
1025                 }
1026         }
1027
1028         /* Save */
1029         (*fp) = f;
1030
1031         /* Save */
1032         (*sp) = s;
1033
1034         /* Result */
1035         return (v);
1036 }
1037
1038
1039 #define PREF_TYPE_NORMAL   0
1040 #define PREF_TYPE_PICKPREF 1
1041 #define PREF_TYPE_HISTPREF 2
1042
1043 /*
1044  * Open the "user pref file" and parse it.
1045  */
1046 static errr process_pref_file_aux(cptr name, int preftype)
1047 {
1048         FILE *fp;
1049
1050         char buf[1024];
1051
1052         char old[1024];
1053
1054         int line = -1;
1055
1056         errr err = 0;
1057
1058         bool bypass = FALSE;
1059
1060
1061         /* Open the file */
1062         fp = my_fopen(name, "r");
1063
1064         /* No such file */
1065         if (!fp) return (-1);
1066
1067         /* Process the file */
1068         while (0 == my_fgets(fp, buf, sizeof(buf)))
1069         {
1070                 /* Count lines */
1071                 line++;
1072
1073                 /* Skip "empty" lines */
1074                 if (!buf[0]) continue;
1075
1076                 /* Skip "blank" lines */
1077 #ifdef JP
1078                 if (!iskanji(buf[0]))
1079 #endif
1080                 if (isspace(buf[0])) continue;
1081
1082                 /* Skip comments */
1083                 if (buf[0] == '#') continue;
1084
1085
1086                 /* Save a copy */
1087                 strcpy(old, buf);
1088
1089
1090                 /* Process "?:<expr>" */
1091                 if ((buf[0] == '?') && (buf[1] == ':'))
1092                 {
1093                         char f;
1094                         cptr v;
1095                         cptr s;
1096
1097                         /* Start */
1098                         s = buf + 2;
1099
1100                         /* Parse the expr */
1101                         v = process_pref_file_expr(&s, &f);
1102
1103                         /* Set flag */
1104                         bypass = (streq(v, "0") ? TRUE : FALSE);
1105
1106                         /* Continue */
1107                         continue;
1108                 }
1109
1110                 /* Apply conditionals */
1111                 if (bypass) continue;
1112
1113
1114                 /* Process "%:<file>" */
1115                 if (buf[0] == '%')
1116                 {
1117                         static int depth_count = 0;
1118
1119                         /* Ignore if deeper than 20 level */
1120                         if (depth_count > 20) continue;
1121
1122                         /* Count depth level */
1123                         depth_count++;
1124
1125                         /* Process that file if allowed */
1126                         switch (preftype)
1127                         {
1128                         case PREF_TYPE_PICKPREF:
1129                                 (void)process_pickpref_file(buf + 2);
1130                                 break;
1131                         case PREF_TYPE_HISTPREF:
1132                                 (void)process_histpref_file(buf + 2);
1133                                 break;
1134                         default:
1135                                 (void)process_pref_file(buf + 2);
1136                                 break;
1137                         }
1138
1139                         /* Set back depth level */
1140                         depth_count--;
1141
1142                         /* Continue */
1143                         continue;
1144                 }
1145
1146
1147                 /* Process the line */
1148                 err = process_pref_file_command(buf);
1149
1150                 /* This is not original pref line... */
1151                 if (err)
1152                 {
1153                         if (preftype != PREF_TYPE_PICKPREF)
1154                                 break;
1155                         err = process_pickpref_file_line(buf);
1156                 }
1157         }
1158
1159
1160         /* Error */
1161         if (err)
1162         {
1163                 /* Print error message */
1164                 /* ToDo: Add better error messages */
1165 #ifdef JP
1166               msg_format("¥Õ¥¡¥¤¥ë'%s'¤Î%d¹Ô¤Ç¥¨¥é¡¼ÈÖ¹æ%d¤Î¥¨¥é¡¼¡£", name, line, err);
1167               msg_format("('%s'¤ò²òÀÏÃæ)", old);
1168 #else
1169                 msg_format("Error %d in line %d of file '%s'.", err, line, name);
1170                 msg_format("Parsing '%s'", old);
1171 #endif
1172                 msg_print(NULL);
1173         }
1174
1175         /* Close the file */
1176         my_fclose(fp);
1177
1178         /* Result */
1179         return (err);
1180 }
1181
1182
1183
1184 /*
1185  * Process the "user pref file" with the given name
1186  *
1187  * See the functions above for a list of legal "commands".
1188  *
1189  * We also accept the special "?" and "%" directives, which
1190  * allow conditional evaluation and filename inclusion.
1191  */
1192 errr process_pref_file(cptr name)
1193 {
1194         char buf[1024];
1195
1196         errr err1, err2;
1197
1198         /* Build the filename */
1199         path_build(buf, sizeof(buf), ANGBAND_DIR_PREF, name);
1200
1201         /* Process the system pref file */
1202         err1 = process_pref_file_aux(buf, PREF_TYPE_NORMAL);
1203
1204         /* Stop at parser errors, but not at non-existing file */
1205         if (err1 > 0) return err1;
1206
1207
1208         /* Build the filename */
1209         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, name);
1210
1211         /* Process the user pref file */
1212         err2 = process_pref_file_aux(buf, PREF_TYPE_NORMAL);
1213
1214
1215         /* User file does not exist, but read system pref file */
1216         if (err2 < 0 && !err1)
1217                 return -2;
1218
1219         /* Result of user file processing */
1220         return err2;
1221 }
1222
1223
1224
1225 #ifdef CHECK_TIME
1226
1227 /*
1228  * Operating hours for ANGBAND (defaults to non-work hours)
1229  */
1230 static char days[7][29] =
1231 {
1232         "SUN:XXXXXXXXXXXXXXXXXXXXXXXX",
1233         "MON:XXXXXXXX.........XXXXXXX",
1234         "TUE:XXXXXXXX.........XXXXXXX",
1235         "WED:XXXXXXXX.........XXXXXXX",
1236         "THU:XXXXXXXX.........XXXXXXX",
1237         "FRI:XXXXXXXX.........XXXXXXX",
1238         "SAT:XXXXXXXXXXXXXXXXXXXXXXXX"
1239 };
1240
1241 /*
1242  * Restict usage (defaults to no restrictions)
1243  */
1244 static bool check_time_flag = FALSE;
1245
1246 #endif
1247
1248
1249 /*
1250  * Handle CHECK_TIME
1251  */
1252 errr check_time(void)
1253 {
1254
1255 #ifdef CHECK_TIME
1256
1257         time_t      c;
1258         struct tm   *tp;
1259
1260         /* No restrictions */
1261         if (!check_time_flag) return (0);
1262
1263         /* Check for time violation */
1264         c = time((time_t *)0);
1265         tp = localtime(&c);
1266
1267         /* Violation */
1268         if (days[tp->tm_wday][tp->tm_hour + 4] != 'X') return (1);
1269
1270 #endif
1271
1272         /* Success */
1273         return (0);
1274 }
1275
1276
1277
1278 /*
1279  * Initialize CHECK_TIME
1280  */
1281 errr check_time_init(void)
1282 {
1283
1284 #ifdef CHECK_TIME
1285
1286         FILE        *fp;
1287
1288         char    buf[1024];
1289
1290
1291         /* Build the filename */
1292         path_build(buf, sizeof(buf), ANGBAND_DIR_FILE, "time.txt");
1293
1294         /* Open the file */
1295         fp = my_fopen(buf, "r");
1296
1297         /* No file, no restrictions */
1298         if (!fp) return (0);
1299
1300         /* Assume restrictions */
1301         check_time_flag = TRUE;
1302
1303         /* Parse the file */
1304         while (0 == my_fgets(fp, buf, sizeof(buf)))
1305         {
1306                 /* Skip comments and blank lines */
1307                 if (!buf[0] || (buf[0] == '#')) continue;
1308
1309                 /* Chop the buffer */
1310                 buf[29] = '\0';
1311
1312                 /* Extract the info */
1313                 if (prefix(buf, "SUN:")) strcpy(days[0], buf);
1314                 if (prefix(buf, "MON:")) strcpy(days[1], buf);
1315                 if (prefix(buf, "TUE:")) strcpy(days[2], buf);
1316                 if (prefix(buf, "WED:")) strcpy(days[3], buf);
1317                 if (prefix(buf, "THU:")) strcpy(days[4], buf);
1318                 if (prefix(buf, "FRI:")) strcpy(days[5], buf);
1319                 if (prefix(buf, "SAT:")) strcpy(days[6], buf);
1320         }
1321
1322         /* Close it */
1323         my_fclose(fp);
1324
1325 #endif
1326
1327         /* Success */
1328         return (0);
1329 }
1330
1331
1332
1333 #ifdef CHECK_LOAD
1334
1335 #ifndef MAXHOSTNAMELEN
1336 # define MAXHOSTNAMELEN  64
1337 #endif
1338
1339 typedef struct statstime statstime;
1340
1341 struct statstime
1342 {
1343         int                 cp_time[4];
1344         int                 dk_xfer[4];
1345         unsigned int        v_pgpgin;
1346         unsigned int        v_pgpgout;
1347         unsigned int        v_pswpin;
1348         unsigned int        v_pswpout;
1349         unsigned int        v_intr;
1350         int                 if_ipackets;
1351         int                 if_ierrors;
1352         int                 if_opackets;
1353         int                 if_oerrors;
1354         int                 if_collisions;
1355         unsigned int        v_swtch;
1356         long                avenrun[3];
1357         struct timeval      boottime;
1358         struct timeval      curtime;
1359 };
1360
1361 /*
1362  * Maximal load (if any).
1363  */
1364 static int check_load_value = 0;
1365
1366 #endif
1367
1368
1369 /*
1370  * Handle CHECK_LOAD
1371  */
1372 errr check_load(void)
1373 {
1374
1375 #ifdef CHECK_LOAD
1376
1377         struct statstime    st;
1378
1379         /* Success if not checking */
1380         if (!check_load_value) return (0);
1381
1382         /* Check the load */
1383         if (0 == rstat("localhost", &st))
1384         {
1385                 long val1 = (long)(st.avenrun[2]);
1386                 long val2 = (long)(check_load_value) * FSCALE;
1387
1388                 /* Check for violation */
1389                 if (val1 >= val2) return (1);
1390         }
1391
1392 #endif
1393
1394         /* Success */
1395         return (0);
1396 }
1397
1398
1399 /*
1400  * Initialize CHECK_LOAD
1401  */
1402 errr check_load_init(void)
1403 {
1404
1405 #ifdef CHECK_LOAD
1406
1407         FILE        *fp;
1408
1409         char    buf[1024];
1410
1411         char    temphost[MAXHOSTNAMELEN+1];
1412         char    thishost[MAXHOSTNAMELEN+1];
1413
1414
1415         /* Build the filename */
1416         path_build(buf, sizeof(buf), ANGBAND_DIR_FILE, "load.txt");
1417
1418         /* Open the "load" file */
1419         fp = my_fopen(buf, "r");
1420
1421         /* No file, no restrictions */
1422         if (!fp) return (0);
1423
1424         /* Default load */
1425         check_load_value = 100;
1426
1427         /* Get the host name */
1428         (void)gethostname(thishost, (sizeof thishost) - 1);
1429
1430         /* Parse it */
1431         while (0 == my_fgets(fp, buf, sizeof(buf)))
1432         {
1433                 int value;
1434
1435                 /* Skip comments and blank lines */
1436                 if (!buf[0] || (buf[0] == '#')) continue;
1437
1438                 /* Parse, or ignore */
1439                 if (sscanf(buf, "%s%d", temphost, &value) != 2) continue;
1440
1441                 /* Skip other hosts */
1442                 if (!streq(temphost, thishost) &&
1443                     !streq(temphost, "localhost")) continue;
1444
1445                 /* Use that value */
1446                 check_load_value = value;
1447
1448                 /* Done */
1449                 break;
1450         }
1451
1452         /* Close the file */
1453         my_fclose(fp);
1454
1455 #endif
1456
1457         /* Success */
1458         return (0);
1459 }
1460
1461
1462 #define ENTRY_BARE_HAND 0
1463 #define ENTRY_TWO_HANDS 1
1464 #define ENTRY_RIGHT_HAND1 2
1465 #define ENTRY_LEFT_HAND1 3
1466 #define ENTRY_LEFT_HAND2 4
1467 #define ENTRY_RIGHT_HAND2 5
1468 #define ENTRY_POSTURE 6
1469 #define ENTRY_SHOOT_HIT_DAM 7
1470 #define ENTRY_SHOOT_POWER 8
1471 #define ENTRY_SPEED 9
1472 #define ENTRY_BASE_AC 10
1473 #define ENTRY_LEVEL 11
1474 #define ENTRY_CUR_EXP 12
1475 #define ENTRY_MAX_EXP 13
1476 #define ENTRY_EXP_TO_ADV 14
1477 #define ENTRY_GOLD 15
1478 #define ENTRY_DAY 16
1479 #define ENTRY_HP 17
1480 #define ENTRY_SP 18
1481 #define ENTRY_PLAY_TIME 19
1482 #define ENTRY_SKILL_FIGHT 20
1483 #define ENTRY_SKILL_SHOOT 21
1484 #define ENTRY_SKILL_SAVING 22
1485 #define ENTRY_SKILL_STEALTH 23
1486 #define ENTRY_SKILL_PERCEP 24
1487 #define ENTRY_SKILL_SEARCH 25
1488 #define ENTRY_SKILL_DISARM 26
1489 #define ENTRY_SKILL_DEVICE 27
1490 #define ENTRY_BLOWS 28
1491 #define ENTRY_SHOTS 29
1492 #define ENTRY_AVG_DMG 30
1493 #define ENTRY_INFRA 31
1494
1495 #define ENTRY_NAME 32
1496 #define ENTRY_SEX 33
1497 #define ENTRY_RACE 34
1498 #define ENTRY_CLASS 35
1499 #define ENTRY_REALM 36
1500 #define ENTRY_PATRON 37
1501 #define ENTRY_AGE 38
1502 #define ENTRY_HEIGHT 39
1503 #define ENTRY_WEIGHT 40
1504 #define ENTRY_SOCIAL 41
1505 #define ENTRY_ALIGN 42
1506
1507 #define ENTRY_EXP_ANDR 43
1508 #define ENTRY_EXP_TO_ADV_ANDR 44
1509
1510
1511 static struct
1512 {
1513         int col;
1514         int row;
1515         int len;
1516         char header[20];
1517 } disp_player_line[]
1518 #ifdef JP
1519 = {
1520         { 1, 10, 25, "ÂÇ·â½¤Àµ(³ÊÆ®)"},
1521         { 1, 10, 25, "ÂÇ·â½¤Àµ(Î¾¼ê)"},
1522         { 1, 10, 25, "ÂÇ·â½¤Àµ(±¦¼ê)"},
1523         { 1, 10, 25, "ÂÇ·â½¤Àµ(º¸¼ê)"},
1524         { 1, 11, 25, "ÂÇ·â½¤Àµ(º¸¼ê)"},
1525         { 1, 11, 25, "ÂÇ·â½¤Àµ(±¦¼ê)"},
1526         { 1, 11, 25, ""},
1527         { 1, 15, 25, "¼Í·â¹¶·â½¤Àµ"},
1528         { 1, 16, 25, "¼Í·âÉð´ïÇÜÎ¨"},
1529         { 1, 20, 25, "²ÃÂ®"},
1530         { 1, 19, 25, "£Á£Ã"},
1531         {29, 13, 21, "¥ì¥Ù¥ë"},
1532         {29, 14, 21, "·Ð¸³ÃÍ"},
1533         {29, 15, 21, "ºÇÂç·Ð¸³"},
1534         {29, 16, 21, "¼¡¥ì¥Ù¥ë"},
1535         {29, 17, 21, "½ê»ý¶â"},
1536         {29, 19, 21, "ÆüÉÕ"},
1537         {29, 10, 21, "£È£Ð"},
1538         {29, 11, 21, "£Í£Ð"},
1539         {29, 20, 21, "¥×¥ì¥¤»þ´Ö"},
1540         {53, 10, -1, "ÂÇ·â¹¶·â  :"},
1541         {53, 11, -1, "¼Í·â¹¶·â  :"},
1542         {53, 12, -1, "ËâË¡ËÉ¸æ  :"},
1543         {53, 13, -1, "±£Ì©¹ÔÆ°  :"},
1544         {53, 15, -1, "ÃÎ³Ð      :"},
1545         {53, 16, -1, "Ãµº÷      :"},
1546         {53, 17, -1, "²ò½ü      :"},
1547         {53, 18, -1, "ËâË¡Æ»¶ñ  :"},
1548         { 1, 12, 25, "ÂÇ·â²ó¿ô"},
1549         { 1, 17, 25, "¼Í·â²ó¿ô"},
1550         { 1, 13, 25, "Ê¿¶Ñ¥À¥á¡¼¥¸"},
1551         {53, 20, -1, "ÀÖ³°Àþ»ëÎÏ:"},
1552         {26,  1, -1, "Ì¾Á°  : "},
1553         { 1,  3, -1, "ÀÊÌ     : "},
1554         { 1,  4, -1, "¼ïÂ²     : "},
1555         { 1,  5, -1, "¿¦¶È     : "},
1556         { 1,  6, -1, "ËâË¡     : "},
1557         { 1,  7, -1, "¼é¸îËâ¿À : "},
1558         {29,  3, 21, "Ç¯Îð"},
1559         {29,  4, 21, "¿ÈÄ¹"},
1560         {29,  5, 21, "ÂÎ½Å"},
1561         {29,  6, 21, "¼Ò²ñÅªÃÏ°Ì"},
1562         {29,  7, 21, "Â°À"},
1563         {29, 14, 21, "¶¯²½ÅÙ"},
1564         {29, 16, 21, "¼¡¥ì¥Ù¥ë"},
1565 };
1566 #else
1567 = {
1568         { 1, 10, 25, "Bare hand"},
1569         { 1, 10, 25, "Two hands"},
1570         { 1, 10, 25, "Right hand"},
1571         { 1, 10, 25, "Left hand"},
1572         { 1, 11, 25, "Left hand"},
1573         { 1, 11, 25, "Right hand"},
1574         { 1, 11, 25, "Posture"},
1575         { 1, 15, 25, "Shooting"},
1576         { 1, 16, 25, "Multiplier"},
1577         { 1, 20, 25, "Speed"},
1578         { 1, 19, 25, "AC"},
1579         {29, 13, 21, "Level"},
1580         {29, 14, 21, "Experience"},
1581         {29, 15, 21, "Max Exp"},
1582         {29, 16, 21, "Exp to Adv"},
1583         {29, 17, 21, "Gold"},
1584         {29, 19, 21, "Time"},
1585         {29, 10, 21, "Hit point"},
1586         {29, 11, 21, "SP (Mana)"},
1587         {29, 20, 21, "Play time"},
1588         {53, 10, -1, "Fighting   : "},
1589         {53, 11, -1, "Bows/Throw : "},
1590         {53, 12, -1, "SavingThrow: "},
1591         {53, 13, -1, "Stealth    : "},
1592         {53, 15, -1, "Perception : "},
1593         {53, 16, -1, "Searching  : "},
1594         {53, 17, -1, "Disarming  : "},
1595         {53, 18, -1, "MagicDevice: "},
1596         { 1, 12, 25, "Blows/Round"},
1597         { 1, 17, 25, "Shots/Round"},
1598         { 1, 13, 25, "AverageDmg/Rnd"},
1599         {53, 20, -1, "Infra-Vision: "},
1600         {26,  1, -1, "Name  : "},
1601         { 1,  3, -1, "Sex      : "},
1602         { 1,  4, -1, "Race     : "},
1603         { 1,  5, -1, "Class    : "},
1604         { 1,  6, -1, "Magic    : "},
1605         { 1,  7, -1, "Patron   : "},
1606         {29,  3, 21, "Age"},
1607         {29,  4, 21, "Height"},
1608         {29,  5, 21, "Weight"},
1609         {29,  6, 21, "Social Class"},
1610         {29,  7, 21, "Align"},
1611         {29, 14, 21, "Construction"},
1612         {29, 16, 21, "Const to Adv"},
1613 };
1614 #endif
1615
1616 static void display_player_one_line(int entry, cptr val, byte attr)
1617 {
1618         char buf[40];
1619
1620         int row = disp_player_line[entry].row;
1621         int col = disp_player_line[entry].col;
1622         int len = disp_player_line[entry].len;
1623         cptr head = disp_player_line[entry].header;
1624
1625         int head_len = strlen(head);
1626
1627         Term_putstr(col, row, -1, TERM_WHITE, head);
1628
1629         if (!val)
1630                 return;
1631
1632         if (len > 0)
1633         {
1634                 int val_len = len - head_len;
1635                 sprintf(buf, "%*.*s", val_len, val_len, val);
1636                 Term_putstr(col + head_len, row, -1, attr, buf);
1637         }
1638         else
1639         {
1640                 Term_putstr(col + head_len, row, -1, attr, val);
1641         }
1642
1643         return;
1644 }
1645
1646
1647 /*
1648  * Prints the following information on the screen.
1649  */
1650 static void display_player_middle(void)
1651 {
1652         char buf[160];
1653         int show_tohit, show_todam;
1654         object_type *o_ptr;
1655         int tmul = 0;
1656         int e;
1657
1658         if(p_ptr->migite)
1659         {
1660                 show_tohit = p_ptr->dis_to_h[0];
1661                 show_todam = p_ptr->dis_to_d[0];
1662
1663                 o_ptr = &inventory[INVEN_RARM];
1664
1665                 /* Hack -- add in weapon info if known */
1666                 if (object_known_p(o_ptr)) show_tohit += o_ptr->to_h;
1667                 if (object_known_p(o_ptr)) show_todam += o_ptr->to_d;
1668
1669                 /* Melee attacks */
1670                 sprintf(buf, "(%+d,%+d)", show_tohit, show_todam);
1671
1672                 /* Dump the bonuses to hit/dam */
1673                 if(!buki_motteruka(INVEN_RARM) && !buki_motteruka(INVEN_LARM))
1674                         display_player_one_line(ENTRY_BARE_HAND, buf, TERM_L_BLUE);
1675                 else if(p_ptr->ryoute)
1676                         display_player_one_line(ENTRY_TWO_HANDS, buf, TERM_L_BLUE);
1677                 else if (left_hander)
1678                         display_player_one_line(ENTRY_LEFT_HAND1, buf, TERM_L_BLUE);
1679                 else
1680                         display_player_one_line(ENTRY_RIGHT_HAND1, buf, TERM_L_BLUE);
1681         }
1682
1683         if(p_ptr->hidarite)
1684         {
1685                 show_tohit = p_ptr->dis_to_h[1];
1686                 show_todam = p_ptr->dis_to_d[1];
1687
1688                 o_ptr = &inventory[INVEN_LARM];
1689
1690                 /* Hack -- add in weapon info if known */
1691                 if (object_known_p(o_ptr)) show_tohit += o_ptr->to_h;
1692                 if (object_known_p(o_ptr)) show_todam += o_ptr->to_d;
1693
1694                 /* Melee attacks */
1695                 sprintf(buf, "(%+d,%+d)", show_tohit, show_todam);
1696
1697                 /* Dump the bonuses to hit/dam */
1698                 if (left_hander)
1699                         display_player_one_line(ENTRY_RIGHT_HAND2, buf, TERM_L_BLUE);
1700                 else
1701                         display_player_one_line(ENTRY_LEFT_HAND2, buf, TERM_L_BLUE);
1702         }
1703         else if ((p_ptr->pclass == CLASS_MONK) && (empty_hands(TRUE) & EMPTY_HAND_RARM))
1704         {
1705                 int i;
1706                 if (p_ptr->special_defense & KAMAE_MASK)
1707                 {
1708                         for (i = 0; i < MAX_KAMAE; i++)
1709                         {
1710                                 if ((p_ptr->special_defense >> i) & KAMAE_GENBU) break;
1711                         }
1712                         if (i < MAX_KAMAE)
1713 #ifdef JP
1714                                 display_player_one_line(ENTRY_POSTURE, format("%s¤Î¹½¤¨", kamae_shurui[i].desc), TERM_YELLOW);
1715 #else
1716                                 display_player_one_line(ENTRY_POSTURE, format("%s form", kamae_shurui[i].desc), TERM_YELLOW);
1717 #endif
1718                 }
1719                 else
1720 #ifdef JP
1721                                 display_player_one_line(ENTRY_POSTURE, "¹½¤¨¤Ê¤·", TERM_YELLOW);
1722 #else
1723                                 display_player_one_line(ENTRY_POSTURE, "none", TERM_YELLOW);
1724 #endif
1725         }
1726
1727         /* Range weapon */
1728         o_ptr = &inventory[INVEN_BOW];
1729
1730         /* Base skill */
1731         show_tohit = p_ptr->dis_to_h_b;
1732         show_todam = 0;
1733
1734         /* Apply weapon bonuses */
1735         if (object_known_p(o_ptr)) show_tohit += o_ptr->to_h;
1736         if (object_known_p(o_ptr)) show_todam += o_ptr->to_d;
1737
1738         if ((o_ptr->sval == SV_LIGHT_XBOW) || (o_ptr->sval == SV_HEAVY_XBOW))
1739                 show_tohit += p_ptr->weapon_exp[0][o_ptr->sval] / 400;
1740         else
1741                 show_tohit += (p_ptr->weapon_exp[0][o_ptr->sval] - (WEAPON_EXP_MASTER / 2)) / 200;
1742
1743         /* Range attacks */
1744         display_player_one_line(ENTRY_SHOOT_HIT_DAM, format("(%+d,%+d)", show_tohit, show_todam), TERM_L_BLUE);
1745
1746         if (inventory[INVEN_BOW].k_idx)
1747         {
1748                 tmul = bow_tmul(inventory[INVEN_BOW].sval);
1749
1750                 /* Get extra "power" from "extra might" */
1751                 if (p_ptr->xtra_might) tmul++;
1752
1753                 tmul = tmul * (100 + (int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
1754         }
1755
1756         /* shoot power */
1757         display_player_one_line(ENTRY_SHOOT_POWER, format("x%d.%02d", tmul/100, tmul%100), TERM_L_BLUE);
1758
1759         /* Dump the armor class */
1760         display_player_one_line(ENTRY_BASE_AC, format("[%d,%+d]", p_ptr->dis_ac, p_ptr->dis_to_a), TERM_L_BLUE);
1761
1762         /* Dump speed */
1763         {
1764                 int tmp_speed = 0;
1765                 byte attr;
1766                 int i;
1767
1768                 i = p_ptr->pspeed-110;
1769
1770                 /* Hack -- Visually "undo" the Search Mode Slowdown */
1771                 if (p_ptr->action == ACTION_SEARCH) i += 10;
1772
1773                 if (i > 0)
1774                 {
1775                         if (!p_ptr->riding)
1776                                 attr = TERM_L_GREEN;
1777                         else
1778                                 attr = TERM_GREEN;
1779                 }
1780                 else if (i == 0)
1781                 {
1782                         if (!p_ptr->riding)
1783                                 attr = TERM_L_BLUE;
1784                         else
1785                                 attr = TERM_GREEN;
1786                 }
1787                 else
1788                 {
1789                         if (!p_ptr->riding)
1790                                 attr = TERM_L_UMBER;
1791                         else
1792                                 attr = TERM_RED;
1793                 }
1794
1795                 if (!p_ptr->riding)
1796                 {
1797                         if (IS_FAST()) tmp_speed += 10;
1798                         if (p_ptr->slow) tmp_speed -= 10;
1799                         if (p_ptr->lightspeed) tmp_speed = 99;
1800                 }
1801                 else
1802                 {
1803                         if (m_list[p_ptr->riding].fast) tmp_speed += 10;
1804                         if (m_list[p_ptr->riding].slow) tmp_speed -= 10;
1805                 }
1806
1807                 if (tmp_speed)
1808                 {
1809                         if (!p_ptr->riding)
1810                                 sprintf(buf, "(%+d%+d)", i-tmp_speed, tmp_speed);
1811                         else
1812 #ifdef JP
1813                                 sprintf(buf, "¾èÇÏÃæ (%+d%+d)", i-tmp_speed, tmp_speed);
1814 #else
1815                                 sprintf(buf, "Riding (%+d%+d)", i-tmp_speed, tmp_speed);
1816 #endif
1817
1818                         if (tmp_speed > 0)
1819                                 attr = TERM_YELLOW;
1820                         else
1821                                 attr = TERM_VIOLET;
1822                 }
1823                 else
1824                 {
1825                         if (!p_ptr->riding)
1826                                 sprintf(buf, "(%+d)", i);
1827                         else
1828 #ifdef JP
1829                                 sprintf(buf, "¾èÇÏÃæ (%+d)", i);
1830 #else
1831                                 sprintf(buf, "Riding (%+d)", i);
1832 #endif
1833                 }
1834
1835                 display_player_one_line(ENTRY_SPEED, buf, attr);
1836         }
1837
1838         /* Dump character level */
1839         display_player_one_line(ENTRY_LEVEL, format("%d", p_ptr->lev), TERM_L_GREEN);
1840
1841         /* Dump experience */
1842         if (p_ptr->prace == RACE_ANDROID) e = ENTRY_EXP_ANDR;
1843         else e = ENTRY_CUR_EXP;
1844
1845         if (p_ptr->exp >= p_ptr->max_exp)
1846                 display_player_one_line(e, format("%ld", p_ptr->exp), TERM_L_GREEN);
1847         else
1848                 display_player_one_line(e, format("%ld", p_ptr->exp), TERM_YELLOW);
1849
1850         /* Dump max experience */
1851         if (p_ptr->prace == RACE_ANDROID)
1852                 /* Nothing */;
1853         else
1854                 display_player_one_line(ENTRY_MAX_EXP, format("%ld", p_ptr->max_exp), TERM_L_GREEN);
1855
1856         /* Dump exp to advance */
1857         if (p_ptr->prace == RACE_ANDROID) e = ENTRY_EXP_TO_ADV_ANDR;
1858         else e = ENTRY_EXP_TO_ADV;
1859
1860         if (p_ptr->lev >= PY_MAX_LEVEL)
1861                 display_player_one_line(e, "*****", TERM_L_GREEN);
1862         else if (p_ptr->prace == RACE_ANDROID)
1863                 display_player_one_line(e, format("%ld", (s32b)(player_exp_a[p_ptr->lev - 1] * p_ptr->expfact / 100L)), TERM_L_GREEN);
1864         else
1865                 display_player_one_line(e, format("%ld", (s32b)(player_exp[p_ptr->lev - 1] * p_ptr->expfact / 100L)), TERM_L_GREEN);
1866
1867         /* Dump gold */
1868         display_player_one_line(ENTRY_GOLD, format("%ld", p_ptr->au), TERM_L_GREEN);
1869
1870         /* Dump Day */
1871         {
1872                 int day, hour, min;
1873                 extract_day_hour_min(&day, &hour, &min);
1874
1875                 sprintf(buf,
1876 #ifdef JP
1877                         "%dÆüÌÜ %2d:%02d",
1878 #else
1879                         "Day %d %2d:%02d",
1880 #endif
1881                         day, hour, min);
1882         }
1883         display_player_one_line(ENTRY_DAY, buf, TERM_L_GREEN);
1884
1885         /* Dump hit point */
1886         if (p_ptr->chp >= p_ptr->mhp)
1887                 display_player_one_line(ENTRY_HP, format("%4d/%4d", p_ptr->chp , p_ptr->mhp), TERM_L_GREEN);
1888         else if (p_ptr->chp > (p_ptr->mhp * hitpoint_warn) / 10)
1889                 display_player_one_line(ENTRY_HP, format("%4d/%4d", p_ptr->chp , p_ptr->mhp), TERM_YELLOW);
1890         else
1891                 display_player_one_line(ENTRY_HP, format("%4d/%4d", p_ptr->chp , p_ptr->mhp), TERM_RED);
1892
1893         /* Dump mana power */
1894         if (p_ptr->csp >= p_ptr->msp)
1895                 display_player_one_line(ENTRY_SP, format("%4d/%4d", p_ptr->csp , p_ptr->msp), TERM_L_GREEN);
1896         else if (p_ptr->csp > (p_ptr->msp * mana_warn) / 10)
1897                 display_player_one_line(ENTRY_SP, format("%4d/%4d", p_ptr->csp , p_ptr->msp), TERM_YELLOW);
1898         else
1899                 display_player_one_line(ENTRY_SP, format("%4d/%4d", p_ptr->csp , p_ptr->msp), TERM_RED);
1900
1901         /* Dump play time */
1902         display_player_one_line(ENTRY_PLAY_TIME, format("%.2lu:%.2lu:%.2lu", playtime/(60*60), (playtime/60)%60, playtime%60), TERM_L_GREEN);
1903 }
1904
1905
1906 /*
1907  * Hack -- pass color info around this file
1908  */
1909 static byte likert_color = TERM_WHITE;
1910
1911
1912 /*
1913  * Returns a "rating" of x depending on y
1914  */
1915 static cptr likert(int x, int y)
1916 {
1917         static char dummy[20] = "";
1918
1919         /* Paranoia */
1920         if (y <= 0) y = 1;
1921
1922         /* Negative value */
1923         if (x < 0)
1924         {
1925                 likert_color = TERM_L_DARK;
1926 #ifdef JP
1927                 return "ºÇÄã";
1928 #else
1929                 return "Very Bad";
1930 #endif
1931         }
1932
1933         /* Analyze the value */
1934         switch ((x / y))
1935         {
1936         case 0:
1937         case 1:
1938                 likert_color = TERM_RED;
1939 #ifdef JP
1940                 return "°¤¤";
1941 #else
1942                 return "Bad";
1943 #endif
1944
1945         case 2:
1946                 likert_color = TERM_L_RED;
1947 #ifdef JP
1948                 return "Îô¤ë";
1949 #else
1950                 return "Poor";
1951 #endif
1952
1953         case 3:
1954         case 4:
1955                 likert_color = TERM_ORANGE;
1956 #ifdef JP
1957                 return "ÉáÄÌ";
1958 #else
1959                 return "Fair";
1960 #endif
1961
1962         case 5:
1963                 likert_color = TERM_YELLOW;
1964 #ifdef JP
1965                 return "ÎÉ¤¤";
1966 #else
1967                 return "Good";
1968 #endif
1969
1970         case 6:
1971                 likert_color = TERM_YELLOW;
1972 #ifdef JP
1973                 return "ÂçÊÑÎÉ¤¤";
1974 #else
1975                 return "Very Good";
1976 #endif
1977
1978         case 7:
1979         case 8:
1980                 likert_color = TERM_L_GREEN;
1981 #ifdef JP
1982                 return "Âî±Û";
1983 #else
1984                 return "Excellent";
1985 #endif
1986
1987         case 9:
1988         case 10:
1989         case 11:
1990         case 12:
1991         case 13:
1992                 likert_color = TERM_GREEN;
1993 #ifdef JP
1994                 return "Ä¶±Û";
1995 #else
1996                 return "Superb";
1997 #endif
1998
1999         case 14:
2000         case 15:
2001         case 16:
2002         case 17:
2003                 likert_color = TERM_BLUE;
2004 #ifdef JP
2005                 return "±ÑÍºÅª";
2006 #else
2007                 return "Heroic";
2008 #endif
2009
2010         default:
2011                 likert_color = TERM_VIOLET;
2012 #ifdef JP
2013                 sprintf(dummy, "ÅÁÀâÅª[%d]", (int)((((x / y) - 17) * 5) / 2));
2014 #else
2015                 sprintf(dummy, "Legendary[%d]", (int)((((x / y) - 17) * 5) / 2));
2016 #endif
2017                 return dummy;
2018         }
2019 }
2020
2021
2022 /*
2023  * Prints ratings on certain abilities
2024  *
2025  * This code is "imitated" elsewhere to "dump" a character sheet.
2026  */
2027 static void display_player_various(void)
2028 {
2029         int         tmp, damage[2], blows1, blows2, i, basedam;
2030         int                     xthn, xthb, xfos, xsrh;
2031         int                     xdis, xdev, xsav, xstl;
2032         cptr            desc;
2033         int         muta_att = 0;
2034         u32b flgs[TR_FLAG_SIZE];
2035         int             shots, shot_frac;
2036
2037         object_type             *o_ptr;
2038
2039         if (p_ptr->muta2 & MUT2_HORNS)     muta_att++;
2040         if (p_ptr->muta2 & MUT2_SCOR_TAIL) muta_att++;
2041         if (p_ptr->muta2 & MUT2_BEAK)      muta_att++;
2042         if (p_ptr->muta2 & MUT2_TRUNK)     muta_att++;
2043         if (p_ptr->muta2 & MUT2_TENTACLES) muta_att++;
2044
2045         xthn = p_ptr->skill_thn + (p_ptr->to_h_m * BTH_PLUS_ADJ);
2046
2047         /* Shooting Skill (with current bow and normal missile) */
2048         o_ptr = &inventory[INVEN_BOW];
2049         tmp = p_ptr->to_h_b + o_ptr->to_h;
2050         xthb = p_ptr->skill_thb + (tmp * BTH_PLUS_ADJ);
2051
2052         /* If the player is wielding one? */
2053         if (o_ptr->k_idx)
2054         {
2055                 s16b energy_fire = bow_energy(o_ptr->sval);
2056
2057                 /* Calculate shots per round */
2058                 shots = p_ptr->num_fire * 100;
2059                 shot_frac = (shots * 100 / energy_fire) % 100;
2060                 shots = shots / energy_fire;
2061                 if (o_ptr->name1 == ART_CRIMSON)
2062                 {
2063                         shots = 1;
2064                         shot_frac = 0;
2065                         if (p_ptr->pclass == CLASS_ARCHER)
2066                         {
2067                                 /* Extra shot at level 10 */
2068                                 if (p_ptr->lev >= 10) shots++;
2069
2070                                 /* Extra shot at level 30 */
2071                                 if (p_ptr->lev >= 30) shots++;
2072
2073                                 /* Extra shot at level 45 */
2074                                 if (p_ptr->lev >= 45) shots++;
2075                         }
2076                 }
2077         }
2078         else
2079         {
2080                 shots = 0;
2081                 shot_frac = 0;
2082         }
2083
2084         for(i = 0; i < 2; i++)
2085         {
2086                 damage[i] = p_ptr->dis_to_d[i] * 100;
2087                 if (((p_ptr->pclass == CLASS_MONK) || (p_ptr->pclass == CLASS_FORCETRAINER)) && (empty_hands(TRUE) & EMPTY_HAND_RARM))
2088                 {
2089                         int level = p_ptr->lev;
2090                         if (i)
2091                         {
2092                                 damage[i] = 0;
2093                                 break;
2094                         }
2095                         if (p_ptr->pclass == CLASS_FORCETRAINER) level = MAX(1, level - 3);
2096                         if (p_ptr->special_defense & KAMAE_BYAKKO)
2097                                 basedam = monk_ave_damage[level][1];
2098                         else if (p_ptr->special_defense & (KAMAE_GENBU | KAMAE_SUZAKU))
2099                                 basedam = monk_ave_damage[level][2];
2100                         else
2101                                 basedam = monk_ave_damage[level][0];
2102                 }
2103                 else
2104                 {
2105                         o_ptr = &inventory[INVEN_RARM + i];
2106
2107                         /* Average damage per round */
2108                         if (o_ptr->k_idx)
2109                         {
2110                                 if (object_known_p(o_ptr)) damage[i] += o_ptr->to_d * 100;
2111                                 basedam = ((o_ptr->dd + p_ptr->to_dd[i]) * (o_ptr->ds + p_ptr->to_ds[i] + 1)) * 50;
2112                                 object_flags_known(o_ptr, flgs);
2113                                 if ((o_ptr->ident & IDENT_MENTAL) && ((o_ptr->name1 == ART_VORPAL_BLADE) || (o_ptr->name1 == ART_CHAINSWORD)))
2114                                 {
2115                                         /* vorpal blade */
2116                                         basedam *= 5;
2117                                         basedam /= 3;
2118                                 }
2119                                 else if (have_flag(flgs, TR_VORPAL))
2120                                 {
2121                                         /* vorpal flag only */
2122                                         basedam *= 11;
2123                                         basedam /= 9;
2124                                 }
2125                                 if ((p_ptr->pclass != CLASS_SAMURAI) && have_flag(flgs, TR_FORCE_WEAPON) && (p_ptr->csp > (o_ptr->dd * o_ptr->ds / 5)))
2126                                         basedam = basedam * 7 / 2;
2127                         }
2128                         else basedam = 0;
2129                 }
2130                 damage[i] += basedam;
2131                 if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_DOKUBARI)) damage[i] = 1;
2132                 if (damage[i] < 0) damage[i] = 0;
2133         }
2134         blows1 = p_ptr->migite ? p_ptr->num_blow[0]: 0;
2135         blows2 = p_ptr->hidarite ? p_ptr->num_blow[1] : 0;
2136
2137         /* Basic abilities */
2138
2139         xdis = p_ptr->skill_dis;
2140         xdev = p_ptr->skill_dev;
2141         xsav = p_ptr->skill_sav;
2142         xstl = p_ptr->skill_stl;
2143         xsrh = p_ptr->skill_srh;
2144         xfos = p_ptr->skill_fos;
2145
2146
2147         desc = likert(xthn, 12);
2148         display_player_one_line(ENTRY_SKILL_FIGHT, desc, likert_color);
2149
2150         desc = likert(xthb, 12);
2151         display_player_one_line(ENTRY_SKILL_SHOOT, desc, likert_color);
2152
2153         desc = likert(xsav, 7);
2154         display_player_one_line(ENTRY_SKILL_SAVING, desc, likert_color);
2155
2156         /* Hack -- 0 is "minimum stealth value", so print "Very Bad" */
2157         desc = likert((xstl > 0) ? xstl : -1, 1);
2158         display_player_one_line(ENTRY_SKILL_STEALTH, desc, likert_color);
2159
2160         desc = likert(xfos, 6);
2161         display_player_one_line(ENTRY_SKILL_PERCEP, desc, likert_color);
2162
2163         desc = likert(xsrh, 6);
2164         display_player_one_line(ENTRY_SKILL_SEARCH, desc, likert_color);
2165
2166         desc = likert(xdis, 8);
2167         display_player_one_line(ENTRY_SKILL_DISARM, desc, likert_color);
2168
2169         desc = likert(xdev, 6);
2170         display_player_one_line(ENTRY_SKILL_DEVICE, desc, likert_color);
2171
2172         if (!muta_att)
2173                 display_player_one_line(ENTRY_BLOWS, format("%d+%d", blows1, blows2), TERM_L_BLUE);
2174         else
2175                 display_player_one_line(ENTRY_BLOWS, format("%d+%d+%d", blows1, blows2, muta_att), TERM_L_BLUE);
2176
2177         display_player_one_line(ENTRY_SHOTS, format("%d.%02d", shots, shot_frac), TERM_L_BLUE);
2178
2179
2180         if ((damage[0]+damage[1]) == 0)
2181                 desc = "nil!";
2182         else
2183                 desc = format("%d+%d", blows1 * damage[0] / 100, blows2 * damage[1] / 100);
2184
2185         display_player_one_line(ENTRY_AVG_DMG, desc, TERM_L_BLUE);
2186
2187         display_player_one_line(ENTRY_INFRA, format("%d feet", p_ptr->see_infra * 10), TERM_WHITE);
2188 }
2189
2190
2191
2192 /*
2193  * Obtain the "flags" for the player as if he was an item
2194  */
2195 static void player_flags(u32b flgs[TR_FLAG_SIZE])
2196 {
2197         int i;
2198
2199         /* Clear */
2200         for (i = 0; i < TR_FLAG_SIZE; i++)
2201                 flgs[i] = 0L;
2202
2203         /* Classes */
2204         switch (p_ptr->pclass)
2205         {
2206         case CLASS_WARRIOR:
2207                 if (p_ptr->lev > 44)
2208                         add_flag(flgs, TR_REGEN);
2209         case CLASS_SAMURAI:
2210                 if (p_ptr->lev > 29)
2211                         add_flag(flgs, TR_RES_FEAR);
2212                 break;
2213         case CLASS_PALADIN:
2214                 if (p_ptr->lev > 39)
2215                         add_flag(flgs, TR_RES_FEAR);
2216                 break;
2217         case CLASS_CHAOS_WARRIOR:
2218                 if (p_ptr->lev > 29)
2219                         add_flag(flgs, TR_RES_CHAOS);
2220                 if (p_ptr->lev > 39)
2221                         add_flag(flgs, TR_RES_FEAR);
2222                 break;
2223         case CLASS_MONK:
2224         case CLASS_FORCETRAINER:
2225                 if ((p_ptr->lev > 9) && !heavy_armor())
2226                         add_flag(flgs, TR_SPEED);
2227                 if ((p_ptr->lev>24) && !heavy_armor())
2228                         add_flag(flgs, TR_FREE_ACT);
2229                 break;
2230         case CLASS_NINJA:
2231                 if (heavy_armor())
2232                         add_flag(flgs, TR_SPEED);
2233                 else
2234                 {
2235                         if (!inventory[INVEN_LARM].tval || p_ptr->hidarite)
2236                                 add_flag(flgs, TR_SPEED);
2237                         if (p_ptr->lev>24)
2238                                 add_flag(flgs, TR_FREE_ACT);
2239                 }
2240                 add_flag(flgs, TR_SLOW_DIGEST);
2241                 add_flag(flgs, TR_RES_FEAR);
2242                 if (p_ptr->lev > 19) add_flag(flgs, TR_RES_POIS);
2243                 if (p_ptr->lev > 24) add_flag(flgs, TR_SUST_DEX);
2244                 if (p_ptr->lev > 29) add_flag(flgs, TR_SEE_INVIS);
2245                 break;
2246         case CLASS_MINDCRAFTER:
2247                 if (p_ptr->lev > 9)
2248                         add_flag(flgs, TR_RES_FEAR);
2249                 if (p_ptr->lev > 19)
2250                         add_flag(flgs, TR_SUST_WIS);
2251                 if (p_ptr->lev > 29)
2252                         add_flag(flgs, TR_RES_CONF);
2253                 if (p_ptr->lev > 39)
2254                         add_flag(flgs, TR_TELEPATHY);
2255                 break;
2256         case CLASS_BARD:
2257                 add_flag(flgs, TR_RES_SOUND);
2258                 break;
2259         case CLASS_BERSERKER:
2260                 add_flag(flgs, TR_SUST_STR);
2261                 add_flag(flgs, TR_SUST_DEX);
2262                 add_flag(flgs, TR_SUST_CON);
2263                 add_flag(flgs, TR_REGEN);
2264                 add_flag(flgs, TR_FREE_ACT);
2265                 add_flag(flgs, TR_SPEED);
2266                 if (p_ptr->lev > 39) add_flag(flgs, TR_REFLECT);
2267                 break;
2268         case CLASS_MIRROR_MASTER:
2269                 if(p_ptr->lev > 39)add_flag(flgs, TR_REFLECT);
2270                 break;
2271         default:
2272                 break; /* Do nothing */
2273         }
2274
2275         /* Races */
2276         if (p_ptr->mimic_form)
2277         {
2278                 switch(p_ptr->mimic_form)
2279                 {
2280                 case MIMIC_DEMON:
2281                         add_flag(flgs, TR_HOLD_LIFE);
2282                         add_flag(flgs, TR_RES_CHAOS);
2283                         add_flag(flgs, TR_RES_NETHER);
2284                         add_flag(flgs, TR_RES_FIRE);
2285                         add_flag(flgs, TR_SEE_INVIS);
2286                         add_flag(flgs, TR_SPEED);
2287                         break;
2288                 case MIMIC_DEMON_LORD:
2289                         add_flag(flgs, TR_HOLD_LIFE);
2290                         add_flag(flgs, TR_RES_CHAOS);
2291                         add_flag(flgs, TR_RES_NETHER);
2292                         add_flag(flgs, TR_RES_FIRE);
2293                         add_flag(flgs, TR_RES_COLD);
2294                         add_flag(flgs, TR_RES_ELEC);
2295                         add_flag(flgs, TR_RES_ACID);
2296                         add_flag(flgs, TR_RES_POIS);
2297                         add_flag(flgs, TR_RES_CONF);
2298                         add_flag(flgs, TR_RES_DISEN);
2299                         add_flag(flgs, TR_RES_NEXUS);
2300                         add_flag(flgs, TR_RES_FEAR);
2301                         add_flag(flgs, TR_IM_FIRE);
2302                         add_flag(flgs, TR_SH_FIRE);
2303                         add_flag(flgs, TR_SEE_INVIS);
2304                         add_flag(flgs, TR_TELEPATHY);
2305                         add_flag(flgs, TR_FEATHER);
2306                         add_flag(flgs, TR_SPEED);
2307                         break;
2308                 case MIMIC_VAMPIRE:
2309                         add_flag(flgs, TR_HOLD_LIFE);
2310                         add_flag(flgs, TR_RES_DARK);
2311                         add_flag(flgs, TR_RES_NETHER);
2312                         if (p_ptr->pclass != CLASS_NINJA) add_flag(flgs, TR_LITE);
2313                         add_flag(flgs, TR_RES_POIS);
2314                         add_flag(flgs, TR_RES_COLD);
2315                         add_flag(flgs, TR_SEE_INVIS);
2316                         add_flag(flgs, TR_SPEED);
2317                         break;
2318                 }
2319         }
2320         else
2321         {
2322         switch (p_ptr->prace)
2323         {
2324         case RACE_ELF:
2325                 add_flag(flgs, TR_RES_LITE);
2326                 break;
2327         case RACE_HOBBIT:
2328                 add_flag(flgs, TR_SUST_DEX);
2329                 break;
2330         case RACE_GNOME:
2331                 add_flag(flgs, TR_FREE_ACT);
2332                 break;
2333         case RACE_DWARF:
2334                 add_flag(flgs, TR_RES_BLIND);
2335                 break;
2336         case RACE_HALF_ORC:
2337                 add_flag(flgs, TR_RES_DARK);
2338                 break;
2339         case RACE_HALF_TROLL:
2340                 add_flag(flgs, TR_SUST_STR);
2341                 if (p_ptr->lev > 14)
2342                 {
2343                         add_flag(flgs, TR_REGEN);
2344                         if (p_ptr->pclass == CLASS_WARRIOR)
2345                         {
2346                                 add_flag(flgs, TR_SLOW_DIGEST);
2347                                 /*
2348                                  * Let's not make Regeneration a disadvantage
2349                                  * for the poor warriors who can never learn
2350                                  * a spell that satisfies hunger (actually
2351                                  * neither can rogues, but half-trolls are not
2352                                  * supposed to play rogues)
2353                                  */
2354                         }
2355                 }
2356                 break;
2357         case RACE_AMBERITE:
2358                 add_flag(flgs, TR_SUST_CON);
2359                 add_flag(flgs, TR_REGEN); /* Amberites heal fast */
2360                 break;
2361         case RACE_HIGH_ELF:
2362                 add_flag(flgs, TR_RES_LITE);
2363                 add_flag(flgs, TR_SEE_INVIS);
2364                 break;
2365         case RACE_BARBARIAN:
2366                 add_flag(flgs, TR_RES_FEAR);
2367                 break;
2368         case RACE_HALF_OGRE:
2369                 add_flag(flgs, TR_SUST_STR);
2370                 add_flag(flgs, TR_RES_DARK);
2371                 break;
2372         case RACE_HALF_GIANT:
2373                 add_flag(flgs, TR_RES_SHARDS);
2374                 add_flag(flgs, TR_SUST_STR);
2375                 break;
2376         case RACE_HALF_TITAN:
2377                 add_flag(flgs, TR_RES_CHAOS);
2378                 break;
2379         case RACE_CYCLOPS:
2380                 add_flag(flgs, TR_RES_SOUND);
2381                 break;
2382         case RACE_YEEK:
2383                 add_flag(flgs, TR_RES_ACID);
2384                 if (p_ptr->lev > 19)
2385                         add_flag(flgs, TR_IM_ACID);
2386                 break;
2387         case RACE_KLACKON:
2388                 add_flag(flgs, TR_RES_CONF);
2389                 add_flag(flgs, TR_RES_ACID);
2390                 if (p_ptr->lev > 9)
2391                         add_flag(flgs, TR_SPEED);
2392                 break;
2393         case RACE_KOBOLD:
2394                 add_flag(flgs, TR_RES_POIS);
2395                 break;
2396         case RACE_NIBELUNG:
2397                 add_flag(flgs, TR_RES_DISEN);
2398                 add_flag(flgs, TR_RES_DARK);
2399                 break;
2400         case RACE_DARK_ELF:
2401                 add_flag(flgs, TR_RES_DARK);
2402                 if (p_ptr->lev > 19)
2403                         add_flag(flgs, TR_SEE_INVIS);
2404                 break;
2405         case RACE_DRACONIAN:
2406                 add_flag(flgs, TR_FEATHER);
2407                 if (p_ptr->lev > 4)
2408                         add_flag(flgs, TR_RES_FIRE);
2409                 if (p_ptr->lev > 9)
2410                         add_flag(flgs, TR_RES_COLD);
2411                 if (p_ptr->lev > 14)
2412                         add_flag(flgs, TR_RES_ACID);
2413                 if (p_ptr->lev > 19)
2414                         add_flag(flgs, TR_RES_ELEC);
2415                 if (p_ptr->lev > 34)
2416                         add_flag(flgs, TR_RES_POIS);
2417                 break;
2418         case RACE_MIND_FLAYER:
2419                 add_flag(flgs, TR_SUST_INT);
2420                 add_flag(flgs, TR_SUST_WIS);
2421                 if (p_ptr->lev > 14)
2422                         add_flag(flgs, TR_SEE_INVIS);
2423                 if (p_ptr->lev > 29)
2424                         add_flag(flgs, TR_TELEPATHY);
2425                 break;
2426         case RACE_IMP:
2427                 add_flag(flgs, TR_RES_FIRE);
2428                 if (p_ptr->lev > 9)
2429                         add_flag(flgs, TR_SEE_INVIS);
2430                 break;
2431         case RACE_GOLEM:
2432                 add_flag(flgs, TR_SEE_INVIS);
2433                 add_flag(flgs, TR_FREE_ACT);
2434                 add_flag(flgs, TR_RES_POIS);
2435                 add_flag(flgs, TR_SLOW_DIGEST);
2436                 if (p_ptr->lev > 34)
2437                         add_flag(flgs, TR_HOLD_LIFE);
2438                 break;
2439         case RACE_SKELETON:
2440                 add_flag(flgs, TR_SEE_INVIS);
2441                 add_flag(flgs, TR_RES_SHARDS);
2442                 add_flag(flgs, TR_HOLD_LIFE);
2443                 add_flag(flgs, TR_RES_POIS);
2444                 if (p_ptr->lev > 9)
2445                         add_flag(flgs, TR_RES_COLD);
2446                 break;
2447         case RACE_ZOMBIE:
2448                 add_flag(flgs, TR_SEE_INVIS);
2449                 add_flag(flgs, TR_HOLD_LIFE);
2450                 add_flag(flgs, TR_RES_NETHER);
2451                 add_flag(flgs, TR_RES_POIS);
2452                 add_flag(flgs, TR_SLOW_DIGEST);
2453                 if (p_ptr->lev > 4)
2454                         add_flag(flgs, TR_RES_COLD);
2455                 break;
2456         case RACE_VAMPIRE:
2457                 add_flag(flgs, TR_HOLD_LIFE);
2458                 add_flag(flgs, TR_RES_DARK);
2459                 add_flag(flgs, TR_RES_NETHER);
2460                 if (p_ptr->pclass != CLASS_NINJA) add_flag(flgs, TR_LITE);
2461                 add_flag(flgs, TR_RES_POIS);
2462                 add_flag(flgs, TR_RES_COLD);
2463                 break;
2464         case RACE_SPECTRE:
2465                 add_flag(flgs, TR_FEATHER);
2466                 add_flag(flgs, TR_FREE_ACT);
2467                 add_flag(flgs, TR_RES_COLD);
2468                 add_flag(flgs, TR_SEE_INVIS);
2469                 add_flag(flgs, TR_HOLD_LIFE);
2470                 add_flag(flgs, TR_RES_NETHER);
2471                 add_flag(flgs, TR_RES_POIS);
2472                 add_flag(flgs, TR_SLOW_DIGEST);
2473                 /* XXX pass_wall */
2474                 if (p_ptr->lev > 34)
2475                         add_flag(flgs, TR_TELEPATHY);
2476                 break;
2477         case RACE_SPRITE:
2478                 add_flag(flgs, TR_RES_LITE);
2479                 add_flag(flgs, TR_FEATHER);
2480                 if (p_ptr->lev > 9)
2481                         add_flag(flgs, TR_SPEED);
2482                 break;
2483         case RACE_BEASTMAN:
2484                 add_flag(flgs, TR_RES_SOUND);
2485                 add_flag(flgs, TR_RES_CONF);
2486                 break;
2487         case RACE_ANGEL:
2488                 add_flag(flgs, TR_FEATHER);
2489                 add_flag(flgs, TR_SEE_INVIS);
2490                 break;
2491         case RACE_DEMON:
2492                 add_flag(flgs, TR_RES_FIRE);
2493                 add_flag(flgs, TR_RES_NETHER);
2494                 add_flag(flgs, TR_HOLD_LIFE);
2495                 if (p_ptr->lev > 9)
2496                         add_flag(flgs, TR_SEE_INVIS);
2497                 break;
2498         case RACE_DUNADAN:
2499                 add_flag(flgs, TR_SUST_CON);
2500                 break;
2501         case RACE_S_FAIRY:
2502                 add_flag(flgs, TR_FEATHER);
2503                 break;
2504         case RACE_KUTA:
2505                 add_flag(flgs, TR_RES_CONF);
2506                 break;
2507         case RACE_ANDROID:
2508                 add_flag(flgs, TR_FREE_ACT);
2509                 add_flag(flgs, TR_RES_POIS);
2510                 add_flag(flgs, TR_SLOW_DIGEST);
2511                 add_flag(flgs, TR_HOLD_LIFE);
2512                 break;
2513         default:
2514                 ; /* Do nothing */
2515         }
2516         }
2517
2518         /* Mutations */
2519         if (p_ptr->muta3)
2520         {
2521                 if (p_ptr->muta3 & MUT3_FLESH_ROT)
2522                 {
2523                         remove_flag(flgs, TR_REGEN);
2524                 }
2525
2526                 if ((p_ptr->muta3 & MUT3_XTRA_FAT) ||
2527                         (p_ptr->muta3 & MUT3_XTRA_LEGS) ||
2528                         (p_ptr->muta3 & MUT3_SHORT_LEG))
2529                 {
2530                         add_flag(flgs, TR_SPEED);
2531                 }
2532
2533                 if (p_ptr->muta3  & MUT3_ELEC_TOUC)
2534                 {
2535                         add_flag(flgs, TR_SH_ELEC);
2536                 }
2537
2538                 if (p_ptr->muta3 & MUT3_FIRE_BODY)
2539                 {
2540                         add_flag(flgs, TR_SH_FIRE);
2541                         add_flag(flgs, TR_LITE);
2542                 }
2543
2544                 if (p_ptr->muta3 & MUT3_WINGS)
2545                 {
2546                         add_flag(flgs, TR_FEATHER);
2547                 }
2548
2549                 if (p_ptr->muta3 & MUT3_FEARLESS)
2550                 {
2551                         add_flag(flgs, TR_RES_FEAR);
2552                 }
2553
2554                 if (p_ptr->muta3 & MUT3_REGEN)
2555                 {
2556                         add_flag(flgs, TR_REGEN);
2557                 }
2558
2559                 if (p_ptr->muta3 & MUT3_ESP)
2560                 {
2561                         add_flag(flgs, TR_TELEPATHY);
2562                 }
2563
2564                 if (p_ptr->muta3 & MUT3_MOTION)
2565                 {
2566                         add_flag(flgs, TR_FREE_ACT);
2567                 }
2568         }
2569
2570         if (p_ptr->pseikaku == SEIKAKU_SEXY)
2571                 add_flag(flgs, TR_AGGRAVATE);
2572         if (p_ptr->pseikaku == SEIKAKU_MUNCHKIN)
2573         {
2574                 add_flag(flgs, TR_RES_BLIND);
2575                 add_flag(flgs, TR_RES_CONF);
2576                 add_flag(flgs, TR_HOLD_LIFE);
2577                 if (p_ptr->pclass != CLASS_NINJA) add_flag(flgs, TR_LITE);
2578                 if (p_ptr->lev > 9)
2579                         add_flag(flgs, TR_SPEED);
2580         }
2581         if (p_ptr->special_defense & KATA_FUUJIN)
2582                 add_flag(flgs, TR_REFLECT);
2583         if (p_ptr->special_defense & KAMAE_GENBU)
2584                 add_flag(flgs, TR_REFLECT);
2585         if (p_ptr->special_defense & KAMAE_SUZAKU)
2586                 add_flag(flgs, TR_FEATHER);
2587         if (p_ptr->special_defense & KAMAE_SEIRYU)
2588         {
2589                 add_flag(flgs, TR_RES_FIRE);
2590                 add_flag(flgs, TR_RES_COLD);
2591                 add_flag(flgs, TR_RES_ACID);
2592                 add_flag(flgs, TR_RES_ELEC);
2593                 add_flag(flgs, TR_RES_POIS);
2594                 add_flag(flgs, TR_FEATHER);
2595                 add_flag(flgs, TR_SH_FIRE);
2596                 add_flag(flgs, TR_SH_ELEC);
2597                 add_flag(flgs, TR_SH_COLD);
2598         }
2599         if (p_ptr->special_defense & KATA_MUSOU)
2600         {
2601                 add_flag(flgs, TR_RES_FEAR);
2602                 add_flag(flgs, TR_RES_LITE);
2603                 add_flag(flgs, TR_RES_DARK);
2604                 add_flag(flgs, TR_RES_BLIND);
2605                 add_flag(flgs, TR_RES_CONF);
2606                 add_flag(flgs, TR_RES_SOUND);
2607                 add_flag(flgs, TR_RES_SHARDS);
2608                 add_flag(flgs, TR_RES_NETHER);
2609                 add_flag(flgs, TR_RES_NEXUS);
2610                 add_flag(flgs, TR_RES_CHAOS);
2611                 add_flag(flgs, TR_RES_DISEN);
2612                 add_flag(flgs, TR_REFLECT);
2613                 add_flag(flgs, TR_HOLD_LIFE);
2614                 add_flag(flgs, TR_FREE_ACT);
2615                 add_flag(flgs, TR_SH_FIRE);
2616                 add_flag(flgs, TR_SH_ELEC);
2617                 add_flag(flgs, TR_SH_COLD);
2618                 add_flag(flgs, TR_FEATHER);
2619                 add_flag(flgs, TR_LITE);
2620                 add_flag(flgs, TR_SEE_INVIS);
2621                 add_flag(flgs, TR_TELEPATHY);
2622                 add_flag(flgs, TR_SLOW_DIGEST);
2623                 add_flag(flgs, TR_REGEN);
2624                 add_flag(flgs, TR_SUST_STR);
2625                 add_flag(flgs, TR_SUST_INT);
2626                 add_flag(flgs, TR_SUST_WIS);
2627                 add_flag(flgs, TR_SUST_DEX);
2628                 add_flag(flgs, TR_SUST_CON);
2629                 add_flag(flgs, TR_SUST_CHR);
2630         }
2631 }
2632
2633
2634 static void tim_player_flags(u32b flgs[TR_FLAG_SIZE])
2635 {
2636         int i;
2637
2638         /* Clear */
2639         for (i = 0; i < TR_FLAG_SIZE; i++)
2640                 flgs[i] = 0L;
2641
2642         if (IS_HERO() || p_ptr->shero)
2643                 add_flag(flgs, TR_RES_FEAR);
2644         if (p_ptr->tim_invis)
2645                 add_flag(flgs, TR_SEE_INVIS);
2646         if (p_ptr->tim_regen)
2647                 add_flag(flgs, TR_REGEN);
2648         if (IS_TIM_ESP())
2649                 add_flag(flgs, TR_TELEPATHY);
2650         if (IS_FAST() || p_ptr->slow)
2651                 add_flag(flgs, TR_SPEED);
2652
2653         if (IS_OPPOSE_ACID() && !(p_ptr->special_defense & DEFENSE_ACID) && !(prace_is_(RACE_YEEK) && (p_ptr->lev > 19)))
2654                 add_flag(flgs, TR_RES_ACID);
2655         if (IS_OPPOSE_ELEC() && !(p_ptr->special_defense & DEFENSE_ELEC))
2656                 add_flag(flgs, TR_RES_ELEC);
2657         if (IS_OPPOSE_FIRE() && !(p_ptr->special_defense & DEFENSE_FIRE))
2658                 add_flag(flgs, TR_RES_FIRE);
2659         if (IS_OPPOSE_COLD() && !(p_ptr->special_defense & DEFENSE_COLD))
2660                 add_flag(flgs, TR_RES_COLD);
2661         if (IS_OPPOSE_POIS())
2662                 add_flag(flgs, TR_RES_POIS);
2663
2664         if (p_ptr->special_attack & ATTACK_ACID)
2665                 add_flag(flgs, TR_BRAND_ACID);
2666         if (p_ptr->special_attack & ATTACK_ELEC)
2667                 add_flag(flgs, TR_BRAND_ELEC);
2668         if (p_ptr->special_attack & ATTACK_FIRE)
2669                 add_flag(flgs, TR_BRAND_FIRE);
2670         if (p_ptr->special_attack & ATTACK_COLD)
2671                 add_flag(flgs, TR_BRAND_COLD);
2672         if (p_ptr->special_attack & ATTACK_POIS)
2673                 add_flag(flgs, TR_BRAND_POIS);
2674         if (p_ptr->special_defense & DEFENSE_ACID)
2675                 add_flag(flgs, TR_IM_ACID);
2676         if (p_ptr->special_defense & DEFENSE_ELEC)
2677                 add_flag(flgs, TR_IM_ELEC);
2678         if (p_ptr->special_defense & DEFENSE_FIRE)
2679                 add_flag(flgs, TR_IM_FIRE);
2680         if (p_ptr->special_defense & DEFENSE_COLD)
2681                 add_flag(flgs, TR_IM_COLD);
2682         if (p_ptr->wraith_form)
2683                 add_flag(flgs, TR_REFLECT);
2684         /* by henkma */
2685         if (p_ptr->tim_reflect)
2686                 add_flag(flgs, TR_REFLECT);
2687
2688         if (p_ptr->magicdef)
2689         {
2690                 add_flag(flgs, TR_RES_BLIND);
2691                 add_flag(flgs, TR_RES_CONF);
2692                 add_flag(flgs, TR_REFLECT);
2693                 add_flag(flgs, TR_FREE_ACT);
2694                 add_flag(flgs, TR_FEATHER);
2695         }
2696         if (p_ptr->tim_res_nether)
2697         {
2698                 add_flag(flgs, TR_RES_NETHER);
2699         }
2700         if (p_ptr->tim_sh_fire)
2701         {
2702                 add_flag(flgs, TR_SH_FIRE);
2703         }
2704         if (p_ptr->ult_res)
2705         {
2706                 add_flag(flgs, TR_RES_FEAR);
2707                 add_flag(flgs, TR_RES_LITE);
2708                 add_flag(flgs, TR_RES_DARK);
2709                 add_flag(flgs, TR_RES_BLIND);
2710                 add_flag(flgs, TR_RES_CONF);
2711                 add_flag(flgs, TR_RES_SOUND);
2712                 add_flag(flgs, TR_RES_SHARDS);
2713                 add_flag(flgs, TR_RES_NETHER);
2714                 add_flag(flgs, TR_RES_NEXUS);
2715                 add_flag(flgs, TR_RES_CHAOS);
2716                 add_flag(flgs, TR_RES_DISEN);
2717                 add_flag(flgs, TR_REFLECT);
2718                 add_flag(flgs, TR_HOLD_LIFE);
2719                 add_flag(flgs, TR_FREE_ACT);
2720                 add_flag(flgs, TR_SH_FIRE);
2721                 add_flag(flgs, TR_SH_ELEC);
2722                 add_flag(flgs, TR_SH_COLD);
2723                 add_flag(flgs, TR_FEATHER);
2724                 add_flag(flgs, TR_LITE);
2725                 add_flag(flgs, TR_SEE_INVIS);
2726                 add_flag(flgs, TR_TELEPATHY);
2727                 add_flag(flgs, TR_SLOW_DIGEST);
2728                 add_flag(flgs, TR_REGEN);
2729                 add_flag(flgs, TR_SUST_STR);
2730                 add_flag(flgs, TR_SUST_INT);
2731                 add_flag(flgs, TR_SUST_WIS);
2732                 add_flag(flgs, TR_SUST_DEX);
2733                 add_flag(flgs, TR_SUST_CON);
2734                 add_flag(flgs, TR_SUST_CHR);
2735         }
2736 }
2737
2738
2739 /* Mode flags for displaying player flags */
2740 #define DP_CURSE   0x01
2741 #define DP_IMM     0x02
2742 #define DP_WP      0x08
2743
2744
2745 /*
2746  * Equippy chars
2747  */
2748 static void display_player_equippy(int y, int x, u16b mode)
2749 {
2750         int i, max_i;
2751
2752         byte a;
2753         char c;
2754
2755         object_type *o_ptr;
2756
2757         /* Weapon flags need only two column */
2758         if (mode & DP_WP) max_i = INVEN_LARM + 1;
2759         else max_i = INVEN_TOTAL;
2760
2761         /* Dump equippy chars */
2762         for (i = INVEN_RARM; i < max_i; i++)
2763         {
2764                 /* Object */
2765                 o_ptr = &inventory[i];
2766
2767                 a = object_attr(o_ptr);
2768                 c = object_char(o_ptr);
2769
2770                 /* Clear the part of the screen */
2771                 if (!equippy_chars || !o_ptr->k_idx)
2772                 {
2773                         c = ' ';
2774                         a = TERM_DARK;
2775                 }
2776
2777                 /* Dump */
2778                 Term_putch(x + i - INVEN_RARM, y, a, c);
2779         }
2780 }
2781
2782
2783 void print_equippy(void)
2784 {
2785         display_player_equippy(ROW_EQUIPPY, COL_EQUIPPY, 0);
2786 }
2787
2788 /*
2789  *
2790  */
2791
2792 static void known_obj_immunity(u32b flgs[TR_FLAG_SIZE])
2793 {
2794         int i;
2795
2796         /* Clear */
2797         for (i = 0; i < TR_FLAG_SIZE; i++)
2798                 flgs[i] = 0L;
2799
2800         /* Check equipment */
2801         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
2802         {
2803                 u32b o_flgs[TR_FLAG_SIZE];
2804
2805                 object_type *o_ptr;
2806
2807                 /* Object */
2808                 o_ptr = &inventory[i];
2809
2810                 if (!o_ptr->k_idx) continue;
2811
2812                 /* Known flags */
2813                 object_flags_known(o_ptr, o_flgs);
2814
2815                 if (have_flag(o_flgs, TR_IM_ACID)) add_flag(flgs, TR_RES_ACID);
2816                 if (have_flag(o_flgs, TR_IM_ELEC)) add_flag(flgs, TR_RES_ELEC);
2817                 if (have_flag(o_flgs, TR_IM_FIRE)) add_flag(flgs, TR_RES_FIRE);
2818                 if (have_flag(o_flgs, TR_IM_COLD)) add_flag(flgs, TR_RES_COLD);
2819         }
2820 }
2821
2822 static void player_immunity(u32b flgs[TR_FLAG_SIZE])
2823 {
2824         int i;
2825
2826         /* Clear */
2827         for (i = 0; i < TR_FLAG_SIZE; i++)
2828                 flgs[i] = 0L;
2829
2830         if (prace_is_(RACE_SPECTRE))
2831                 add_flag(flgs, TR_RES_NETHER);
2832         if (p_ptr->mimic_form == MIMIC_VAMPIRE || prace_is_(RACE_VAMPIRE))
2833                 add_flag(flgs, TR_RES_DARK);
2834         if (p_ptr->mimic_form == MIMIC_DEMON_LORD)
2835                 add_flag(flgs, TR_RES_FIRE);
2836         else if (prace_is_(RACE_YEEK) && p_ptr->lev > 19)
2837                 add_flag(flgs, TR_RES_ACID);
2838 }
2839
2840 static void tim_player_immunity(u32b flgs[TR_FLAG_SIZE])
2841 {
2842         int i;
2843
2844         /* Clear */
2845         for (i = 0; i < TR_FLAG_SIZE; i++)
2846                 flgs[i] = 0L;
2847
2848         if (p_ptr->special_defense & DEFENSE_ACID)
2849                 add_flag(flgs, TR_RES_ACID);
2850         if (p_ptr->special_defense & DEFENSE_ELEC)
2851                 add_flag(flgs, TR_RES_ELEC);
2852         if (p_ptr->special_defense & DEFENSE_FIRE)
2853                 add_flag(flgs, TR_RES_FIRE);
2854         if (p_ptr->special_defense & DEFENSE_COLD)
2855                 add_flag(flgs, TR_RES_COLD);
2856         if (p_ptr->wraith_form)
2857                 add_flag(flgs, TR_RES_DARK);
2858 }
2859
2860 static void player_vuln_flags(u32b flgs[TR_FLAG_SIZE])
2861 {
2862         int i;
2863
2864         /* Clear */
2865         for (i = 0; i < TR_FLAG_SIZE; i++)
2866                 flgs[i] = 0L;
2867
2868         if ((p_ptr->muta3 & MUT3_VULN_ELEM) || (p_ptr->special_defense & KATA_KOUKIJIN))
2869         {
2870                 add_flag(flgs, TR_RES_ACID);
2871                 add_flag(flgs, TR_RES_ELEC);
2872                 add_flag(flgs, TR_RES_FIRE);
2873                 add_flag(flgs, TR_RES_COLD);
2874         }
2875         if (prace_is_(RACE_ANDROID))
2876                 add_flag(flgs, TR_RES_ELEC);
2877         if (prace_is_(RACE_ENT))
2878                 add_flag(flgs, TR_RES_FIRE);
2879         if (prace_is_(RACE_VAMPIRE) || prace_is_(RACE_S_FAIRY) ||
2880             (p_ptr->mimic_form == MIMIC_VAMPIRE))
2881                 add_flag(flgs, TR_RES_LITE);
2882 }
2883
2884
2885 /*
2886  * A struct for storing misc. flags
2887  */
2888 typedef struct {
2889         u32b player_flags[TR_FLAG_SIZE];
2890         u32b tim_player_flags[TR_FLAG_SIZE];
2891         u32b player_imm[TR_FLAG_SIZE];
2892         u32b tim_player_imm[TR_FLAG_SIZE];
2893         u32b player_vuln[TR_FLAG_SIZE];
2894         u32b known_obj_imm[TR_FLAG_SIZE];
2895 } all_player_flags;
2896
2897
2898 /*
2899  * Helper function, see below
2900  */
2901 static void display_flag_aux(int row, int col, cptr header,
2902                                     int flag1, all_player_flags *f, u16b mode)
2903 {
2904         int     i;
2905         bool    vuln = FALSE;
2906         int max_i;
2907
2908         if (have_flag(f->player_vuln, flag1) &&
2909             !(have_flag(f->known_obj_imm, flag1) ||
2910               have_flag(f->player_imm, flag1) ||
2911               have_flag(f->tim_player_imm, flag1)))
2912                 vuln = TRUE;
2913
2914         /* Header */
2915         if (!(mode & DP_IMM)) c_put_str(TERM_WHITE, header, row, col);
2916
2917         /* Advance */
2918         col += strlen(header) + 1;
2919
2920         /* Weapon flags need only two column */
2921         if (mode & DP_WP) max_i = INVEN_LARM + 1;
2922         else max_i = INVEN_TOTAL;
2923
2924         /* Check equipment */
2925         for (i = INVEN_RARM; i < max_i; i++)
2926         {
2927                 u32b flgs[TR_FLAG_SIZE];
2928                 object_type *o_ptr;
2929
2930                 /* Object */
2931                 o_ptr = &inventory[i];
2932
2933                 /* Known flags */
2934                 object_flags_known(o_ptr, flgs);
2935
2936                 /* Default */
2937                 if (!(mode & DP_IMM))
2938                         c_put_str((byte)(vuln ? TERM_RED : TERM_SLATE), ".", row, col);
2939
2940                 /* Check flags */
2941                 if (mode & DP_CURSE)
2942                 {
2943                         if ((mode & DP_CURSE) && (o_ptr->curse_flags & (TRC_CURSED | TRC_HEAVY_CURSE)))
2944                                 c_put_str(TERM_WHITE, "+", row, col);
2945                         if ((mode & DP_CURSE) && (o_ptr->curse_flags & TRC_PERMA_CURSE))
2946                                 c_put_str(TERM_WHITE, "*", row, col);
2947                 }
2948                 else
2949                 {
2950                         if (have_flag(flgs, flag1))
2951                                 c_put_str((byte)(vuln ? TERM_L_RED : TERM_WHITE),
2952                                           (mode & DP_IMM) ? "*" : "+", row, col);
2953                 }
2954
2955                 /* Advance */
2956                 col++;
2957         }
2958
2959         /* Assume that player flag is already written */
2960         if (mode & DP_IMM) return;
2961
2962         /* Default */
2963         c_put_str((byte)(vuln ? TERM_RED : TERM_SLATE), ".", row, col);
2964
2965         /* Player flags */
2966         if (have_flag(f->player_flags, flag1)) c_put_str((byte)(vuln ? TERM_L_RED : TERM_WHITE), "+", row, col);
2967
2968         /* Timed player flags */
2969         if (have_flag(f->tim_player_flags, flag1)) c_put_str((byte)(vuln ? TERM_ORANGE : TERM_YELLOW), "#", row, col);
2970
2971         /* Immunity */
2972         if (have_flag(f->tim_player_imm, flag1)) c_put_str(TERM_YELLOW, "*", row, col);
2973         if (have_flag(f->player_imm, flag1)) c_put_str(TERM_WHITE, "*", row, col);
2974
2975         /* Vulnerability */
2976         if (vuln) c_put_str(TERM_RED, "v", row, col + 1);
2977 }
2978
2979
2980 /*
2981  * Special display, part 1
2982  */
2983 static void display_player_flag_info(void)
2984 {
2985         int row;
2986         int col;
2987
2988         all_player_flags f;
2989
2990         /* Extract flags and store */
2991         player_flags(f.player_flags);
2992         tim_player_flags(f.tim_player_flags);
2993         player_immunity(f.player_imm);
2994         tim_player_immunity(f.tim_player_imm);
2995         known_obj_immunity(f.known_obj_imm);
2996         player_vuln_flags(f.player_vuln);
2997
2998         /*** Set 1 ***/
2999
3000         row = 12;
3001         col = 1;
3002
3003         display_player_equippy(row-2, col+8, 0);
3004         c_put_str(TERM_WHITE, "abcdefghijkl@", row-1, col+8);
3005
3006 #ifdef JP
3007 display_flag_aux(row+0, col, "ÂÑ»À  :", TR_RES_ACID, &f, 0);
3008 display_flag_aux(row+0, col, "ÂÑ»À  :", TR_IM_ACID, &f, DP_IMM);
3009 display_flag_aux(row+1, col, "ÂÑÅÅ·â:", TR_RES_ELEC, &f, 0);
3010 display_flag_aux(row+1, col, "ÂÑÅÅ·â:", TR_IM_ELEC, &f, DP_IMM);
3011 display_flag_aux(row+2, col, "ÂÑ²Ð±ê:", TR_RES_FIRE, &f, 0);
3012 display_flag_aux(row+2, col, "ÂÑ²Ð±ê:", TR_IM_FIRE, &f, DP_IMM);
3013 display_flag_aux(row+3, col, "ÂÑÎäµ¤:", TR_RES_COLD, &f, 0);
3014 display_flag_aux(row+3, col, "ÂÑÎäµ¤:", TR_IM_COLD, &f, DP_IMM);
3015 display_flag_aux(row+4, col, "ÂÑÆÇ  :", TR_RES_POIS, &f, 0);
3016 display_flag_aux(row+5, col, "ÂÑÁ®¸÷:", TR_RES_LITE, &f, 0);
3017 display_flag_aux(row+6, col, "ÂÑ°Å¹õ:", TR_RES_DARK, &f, 0);
3018 display_flag_aux(row+7, col, "ÂÑÇËÊÒ:", TR_RES_SHARDS, &f, 0);
3019 display_flag_aux(row+8, col, "ÂÑÌÕÌÜ:", TR_RES_BLIND, &f, 0);
3020 display_flag_aux(row+9, col, "ÂÑº®Íð:", TR_RES_CONF, &f, 0);
3021 #else
3022         display_flag_aux(row+0, col, "Acid  :", TR_RES_ACID, &f, 0);
3023         display_flag_aux(row+0, col, "Acid  :", TR_IM_ACID, &f, DP_IMM);
3024         display_flag_aux(row+1, col, "Elec  :", TR_RES_ELEC, &f, 0);
3025         display_flag_aux(row+1, col, "Elec  :", TR_IM_ELEC, &f, DP_IMM);
3026         display_flag_aux(row+2, col, "Fire  :", TR_RES_FIRE, &f, 0);
3027         display_flag_aux(row+2, col, "Fire  :", TR_IM_FIRE, &f, DP_IMM);
3028         display_flag_aux(row+3, col, "Cold  :", TR_RES_COLD, &f, 0);
3029         display_flag_aux(row+3, col, "Cold  :", TR_IM_COLD, &f, DP_IMM);
3030         display_flag_aux(row+4, col, "Poison:", TR_RES_POIS, &f, 0);
3031         display_flag_aux(row+5, col, "Light :", TR_RES_LITE, &f, 0);
3032         display_flag_aux(row+6, col, "Dark  :", TR_RES_DARK, &f, 0);
3033         display_flag_aux(row+7, col, "Shard :", TR_RES_SHARDS, &f, 0);
3034         display_flag_aux(row+8, col, "Blind :", TR_RES_BLIND, &f, 0);
3035         display_flag_aux(row+9, col, "Conf  :", TR_RES_CONF, &f, 0);
3036 #endif
3037
3038
3039         /*** Set 2 ***/
3040
3041         row = 12;
3042         col = 26;
3043
3044         display_player_equippy(row-2, col+8, 0);
3045
3046         c_put_str(TERM_WHITE, "abcdefghijkl@", row-1, col+8);
3047
3048 #ifdef JP
3049 display_flag_aux(row+0, col, "ÂÑ¹ì²»:", TR_RES_SOUND, &f, 0);
3050 display_flag_aux(row+1, col, "ÂÑÃÏ¹ö:", TR_RES_NETHER, &f, 0);
3051 display_flag_aux(row+2, col, "ÂÑ°øº®:", TR_RES_NEXUS, &f, 0);
3052 display_flag_aux(row+3, col, "ÂÑ¥«¥ª:", TR_RES_CHAOS, &f, 0);
3053 display_flag_aux(row+4, col, "ÂÑÎô²½:", TR_RES_DISEN, &f, 0);
3054 display_flag_aux(row+5, col, "ÂÑ¶²ÉÝ:", TR_RES_FEAR, &f, 0);
3055 display_flag_aux(row+6, col, "È¿¼Í  :", TR_REFLECT, &f, 0);
3056 display_flag_aux(row+7, col, "²Ð±ê¥ª:", TR_SH_FIRE, &f, 0);
3057 display_flag_aux(row+8, col, "ÅÅµ¤¥ª:", TR_SH_ELEC, &f, 0);
3058 display_flag_aux(row+9, col, "Îäµ¤¥ª:", TR_SH_COLD, &f, 0);
3059 #else
3060         display_flag_aux(row+0, col, "Sound :", TR_RES_SOUND, &f, 0);
3061         display_flag_aux(row+1, col, "Nether:", TR_RES_NETHER, &f, 0);
3062         display_flag_aux(row+2, col, "Nexus :", TR_RES_NEXUS, &f, 0);
3063         display_flag_aux(row+3, col, "Chaos :", TR_RES_CHAOS, &f, 0);
3064         display_flag_aux(row+4, col, "Disnch:", TR_RES_DISEN, &f, 0);
3065         display_flag_aux(row+5, col, "Fear  :", TR_RES_FEAR, &f, 0);
3066         display_flag_aux(row+6, col, "Reflct:", TR_REFLECT, &f, 0);
3067         display_flag_aux(row+7, col, "AuFire:", TR_SH_FIRE, &f, 0);
3068         display_flag_aux(row+8, col, "AuElec:", TR_SH_ELEC, &f, 0);
3069         display_flag_aux(row+9, col, "AuCold:", TR_SH_COLD, &f, 0);
3070 #endif
3071
3072
3073         /*** Set 3 ***/
3074
3075         row = 12;
3076         col = 51;
3077
3078         display_player_equippy(row-2, col+12, 0);
3079
3080         c_put_str(TERM_WHITE, "abcdefghijkl@", row-1, col+12);
3081
3082 #ifdef JP
3083 display_flag_aux(row+0, col, "²ÃÂ®      :", TR_SPEED, &f, 0);
3084 display_flag_aux(row+1, col, "ÂÑËãáã    :", TR_FREE_ACT, &f, 0);
3085 display_flag_aux(row+2, col, "Æ©ÌÀÂÎ»ëÇ§:", TR_SEE_INVIS, &f, 0);
3086 display_flag_aux(row+3, col, "·Ð¸³ÃÍÊÝ»ý:", TR_HOLD_LIFE, &f, 0);
3087 display_flag_aux(row+4, col, "·Ù¹ð      :", TR_WARNING, &f, 0);
3088 display_flag_aux(row+5, col, "ÃÙ¾Ã²½    :", TR_SLOW_DIGEST, &f, 0);
3089 display_flag_aux(row+6, col, "µÞ²óÉü    :", TR_REGEN, &f, 0);
3090 display_flag_aux(row+7, col, "ÉâÍ·      :", TR_FEATHER, &f, 0);
3091 display_flag_aux(row+8, col, "±Ê±ó¸÷¸»  :", TR_LITE, &f, 0);
3092 display_flag_aux(row+9, col, "¼ö¤¤      :", 0, &f, DP_CURSE);
3093 #else
3094         display_flag_aux(row+0, col, "Speed     :", TR_SPEED, &f, 0);
3095         display_flag_aux(row+1, col, "FreeAction:", TR_FREE_ACT, &f, 0);
3096         display_flag_aux(row+2, col, "SeeInvisi.:", TR_SEE_INVIS, &f, 0);
3097         display_flag_aux(row+3, col, "Hold Life :", TR_HOLD_LIFE, &f, 0);
3098         display_flag_aux(row+4, col, "Warning   :", TR_WARNING, &f, 0);
3099         display_flag_aux(row+5, col, "SlowDigest:", TR_SLOW_DIGEST, &f, 0);
3100         display_flag_aux(row+6, col, "Regene.   :", TR_REGEN, &f, 0);
3101         display_flag_aux(row+7, col, "Levitation:", TR_FEATHER, &f, 0);
3102         display_flag_aux(row+8, col, "Perm Lite :", TR_LITE, &f, 0);
3103         display_flag_aux(row+9, col, "Cursed    :", 0, &f, DP_CURSE);
3104 #endif
3105
3106 }
3107
3108
3109 /*
3110  * Special display, part 2
3111  */
3112 static void display_player_other_flag_info(void)
3113 {
3114         int row;
3115         int col;
3116
3117         all_player_flags f;
3118
3119         /* Extract flags and store */
3120         player_flags(f.player_flags);
3121         tim_player_flags(f.tim_player_flags);
3122         player_immunity(f.player_imm);
3123         tim_player_immunity(f.tim_player_imm);
3124         known_obj_immunity(f.known_obj_imm);
3125         player_vuln_flags(f.player_vuln);
3126
3127         /*** Set 1 ***/
3128
3129         row = 3;
3130         col = 1;
3131
3132         display_player_equippy(row-2, col+12, DP_WP);
3133
3134         c_put_str(TERM_WHITE, "ab@", row-1, col+12);
3135
3136 #ifdef JP
3137         display_flag_aux(row+ 0, col, "¼Ù° ÇÜÂÇ :", TR_SLAY_EVIL, &f, DP_WP);
3138         display_flag_aux(row+ 0, col, "¼Ù° ÇÜÂÇ :", TR_KILL_EVIL, &f, (DP_WP|DP_IMM));
3139         display_flag_aux(row+ 1, col, "ÉÔ»à ÇÜÂÇ :", TR_SLAY_UNDEAD, &f, DP_WP);
3140         display_flag_aux(row+ 1, col, "ÉÔ»à ÇÜÂÇ :", TR_KILL_UNDEAD, &f, (DP_WP|DP_IMM));
3141         display_flag_aux(row+ 2, col, "°Ëâ ÇÜÂÇ :", TR_SLAY_DEMON, &f, DP_WP);
3142         display_flag_aux(row+ 2, col, "°Ëâ ÇÜÂÇ :", TR_KILL_DEMON, &f, (DP_WP|DP_IMM));
3143         display_flag_aux(row+ 3, col, "Î¶ ÇÜÂÇ   :", TR_SLAY_DRAGON, &f, DP_WP);
3144         display_flag_aux(row+ 3, col, "Î¶ ÇÜÂÇ   :", TR_KILL_DRAGON, &f, (DP_WP|DP_IMM));
3145         display_flag_aux(row+ 4, col, "¿Í´Ö ÇÜÂÇ :", TR_SLAY_HUMAN, &f, DP_WP);
3146         display_flag_aux(row+ 4, col, "¿Í´Ö ÇÜÂÇ :", TR_KILL_HUMAN, &f, (DP_WP|DP_IMM));
3147         display_flag_aux(row+ 5, col, "Æ°Êª ÇÜÂÇ :", TR_SLAY_ANIMAL, &f, DP_WP);
3148         display_flag_aux(row+ 5, col, "Æ°Êª ÇÜÂÇ :", TR_KILL_ANIMAL, &f, (DP_WP|DP_IMM));
3149         display_flag_aux(row+ 6, col, "¥ª¡¼¥¯ÇÜÂÇ:", TR_SLAY_ORC, &f, DP_WP);
3150         display_flag_aux(row+ 6, col, "¥ª¡¼¥¯ÇÜÂÇ:", TR_KILL_ORC, &f, (DP_WP|DP_IMM));
3151         display_flag_aux(row+ 7, col, "¥È¥í¥ëÇÜÂÇ:", TR_SLAY_TROLL, &f, DP_WP);
3152         display_flag_aux(row+ 7, col, "¥È¥í¥ëÇÜÂÇ:", TR_KILL_TROLL, &f, (DP_WP|DP_IMM));
3153         display_flag_aux(row+ 8, col, "µð¿Í ÇÜÂÇ :", TR_SLAY_GIANT, &f, DP_WP);
3154         display_flag_aux(row+ 8, col, "µð¿Í ÇÜÂÇ :", TR_KILL_GIANT, &f, (DP_WP|DP_IMM));
3155         display_flag_aux(row+ 9, col, "ÍÏ²ò      :", TR_BRAND_ACID, &f, DP_WP);
3156         display_flag_aux(row+10, col, "ÅÅ·â      :", TR_BRAND_ELEC, &f, DP_WP);
3157         display_flag_aux(row+11, col, "¾Æ´þ      :", TR_BRAND_FIRE, &f, DP_WP);
3158         display_flag_aux(row+12, col, "Åà·ë      :", TR_BRAND_COLD, &f, DP_WP);
3159         display_flag_aux(row+13, col, "ÆÇ»¦      :", TR_BRAND_POIS, &f, DP_WP);
3160         display_flag_aux(row+14, col, "ÀÚ¤ìÌ£    :", TR_VORPAL, &f, DP_WP);
3161         display_flag_aux(row+15, col, "ÃÏ¿Ì      :", TR_IMPACT, &f, DP_WP);
3162         display_flag_aux(row+16, col, "µÛ·ì      :", TR_VAMPIRIC, &f, DP_WP);
3163         display_flag_aux(row+17, col, "¥«¥ª¥¹¸ú²Ì:", TR_CHAOTIC, &f, DP_WP);
3164         display_flag_aux(row+18, col, "ÍýÎÏ      :", TR_FORCE_WEAPON, &f, DP_WP);
3165 #else
3166         display_flag_aux(row+ 0, col, "Slay Evil :", TR_SLAY_EVIL, &f, DP_WP);
3167         display_flag_aux(row+ 0, col, "Slay Evil :", TR_KILL_EVIL, &f, (DP_WP|DP_IMM));
3168         display_flag_aux(row+ 1, col, "Slay Und. :", TR_SLAY_UNDEAD, &f, DP_WP);
3169         display_flag_aux(row+ 1, col, "Slay Und. :", TR_KILL_UNDEAD, &f, (DP_WP|DP_IMM));
3170         display_flag_aux(row+ 2, col, "Slay Demon:", TR_SLAY_DEMON, &f, DP_WP);
3171         display_flag_aux(row+ 2, col, "Slay Demon:", TR_KILL_DEMON, &f, (DP_WP|DP_IMM));
3172         display_flag_aux(row+ 3, col, "Slay Drag.:", TR_SLAY_DRAGON, &f, DP_WP);
3173         display_flag_aux(row+ 3, col, "Slay Drag.:", TR_KILL_DRAGON, &f, (DP_WP|DP_IMM));
3174         display_flag_aux(row+ 4, col, "Slay Human:", TR_SLAY_HUMAN, &f, DP_WP);
3175         display_flag_aux(row+ 4, col, "Slay Human:", TR_KILL_HUMAN, &f, (DP_WP|DP_IMM));
3176         display_flag_aux(row+ 5, col, "Slay Anim.:", TR_SLAY_ANIMAL, &f, DP_WP);
3177         display_flag_aux(row+ 5, col, "Slay Anim.:", TR_KILL_ANIMAL, &f, (DP_WP|DP_IMM));
3178         display_flag_aux(row+ 6, col, "Slay Orc  :", TR_SLAY_ORC, &f, DP_WP);
3179         display_flag_aux(row+ 6, col, "Slay Orc  :", TR_KILL_ORC, &f, (DP_WP|DP_IMM));
3180         display_flag_aux(row+ 7, col, "Slay Troll:", TR_SLAY_TROLL, &f, DP_WP);
3181         display_flag_aux(row+ 7, col, "Slay Troll:", TR_KILL_TROLL, &f, (DP_WP|DP_IMM));
3182         display_flag_aux(row+ 8, col, "Slay Giant:", TR_SLAY_GIANT, &f, DP_WP);
3183         display_flag_aux(row+ 8, col, "Slay Giant:", TR_KILL_GIANT, &f, (DP_WP|DP_IMM));
3184         display_flag_aux(row+ 9, col, "Acid Brand:", TR_BRAND_ACID, &f, DP_WP);
3185         display_flag_aux(row+10, col, "Elec Brand:", TR_BRAND_ELEC, &f, DP_WP);
3186         display_flag_aux(row+11, col, "Fire Brand:", TR_BRAND_FIRE, &f, DP_WP);
3187         display_flag_aux(row+12, col, "Cold Brand:", TR_BRAND_COLD, &f, DP_WP);
3188         display_flag_aux(row+13, col, "Poison Brd:", TR_BRAND_POIS, &f, DP_WP);
3189         display_flag_aux(row+14, col, "Sharpness :", TR_VORPAL, &f, DP_WP);
3190         display_flag_aux(row+15, col, "Quake     :", TR_IMPACT, &f, DP_WP);
3191         display_flag_aux(row+16, col, "Vampiric  :", TR_VAMPIRIC, &f, DP_WP);
3192         display_flag_aux(row+17, col, "Chaotic   :", TR_CHAOTIC, &f, DP_WP);
3193         display_flag_aux(row+18, col, "Force Wep.:", TR_FORCE_WEAPON, &f, DP_WP);
3194 #endif
3195
3196
3197         /*** Set 2 ***/
3198
3199         row = 3;
3200         col = col + 12 + 7;
3201
3202         display_player_equippy(row-2, col+12, 0);
3203         c_put_str(TERM_WHITE, "abcdefghijkl@", row-1, col+12);
3204
3205 #ifdef JP
3206         display_flag_aux(row+ 0, col, "¥Æ¥ì¥Ñ¥·¡¼:", TR_TELEPATHY, &f, 0);
3207         display_flag_aux(row+ 1, col, "¼Ù°ESP   :", TR_ESP_EVIL, &f, 0);
3208         display_flag_aux(row+ 2, col, "ÌµÀ¸ÊªESP :", TR_ESP_NONLIVING, &f, 0);
3209         display_flag_aux(row+ 3, col, "Á±ÎÉESP   :", TR_ESP_GOOD, &f, 0);
3210         display_flag_aux(row+ 4, col, "ÉÔ»àESP   :", TR_ESP_UNDEAD, &f, 0);
3211         display_flag_aux(row+ 5, col, "°ËâESP   :", TR_ESP_DEMON, &f, 0);
3212         display_flag_aux(row+ 6, col, "ζESP     :", TR_ESP_DRAGON, &f, 0);
3213         display_flag_aux(row+ 7, col, "¿Í´ÖESP   :", TR_ESP_HUMAN, &f, 0);
3214         display_flag_aux(row+ 8, col, "ưʪESP   :", TR_ESP_ANIMAL, &f, 0);
3215         display_flag_aux(row+ 9, col, "¥ª¡¼¥¯ESP :", TR_ESP_ORC, &f, 0);
3216         display_flag_aux(row+10, col, "¥È¥í¥ëESP :", TR_ESP_TROLL, &f, 0);
3217         display_flag_aux(row+11, col, "µð¿ÍESP   :", TR_ESP_GIANT, &f, 0);
3218
3219         display_flag_aux(row+13, col, "ÏÓÎÏ°Ý»ý  :", TR_SUST_STR, &f, 0);
3220         display_flag_aux(row+14, col, "ÃÎÎÏ°Ý»ý  :", TR_SUST_INT, &f, 0);
3221         display_flag_aux(row+15, col, "¸¤µ°Ý»ý  :", TR_SUST_WIS, &f, 0);
3222         display_flag_aux(row+16, col, "´ïÍÑ°Ý»ý  :", TR_SUST_DEX, &f, 0);
3223         display_flag_aux(row+17, col, "ÂÑµ×°Ý»ý  :", TR_SUST_CON, &f, 0);
3224         display_flag_aux(row+18, col, "Ì¥ÎÏ°Ý»ý  :", TR_SUST_CHR, &f, 0);
3225 #else
3226         display_flag_aux(row+ 0, col, "Telepathy :", TR_TELEPATHY, &f, 0);
3227         display_flag_aux(row+ 1, col, "ESP Evil  :", TR_ESP_EVIL, &f, 0);
3228         display_flag_aux(row+ 2, col, "ESP Noliv.:", TR_ESP_NONLIVING, &f, 0);
3229         display_flag_aux(row+ 3, col, "ESP Good  :", TR_ESP_GOOD, &f, 0);
3230         display_flag_aux(row+ 4, col, "ESP Undead:", TR_ESP_UNDEAD, &f, 0);
3231         display_flag_aux(row+ 5, col, "ESP Demon :", TR_ESP_DEMON, &f, 0);
3232         display_flag_aux(row+ 6, col, "ESP Dragon:", TR_ESP_DRAGON, &f, 0);
3233         display_flag_aux(row+ 7, col, "ESP Human :", TR_ESP_HUMAN, &f, 0);
3234         display_flag_aux(row+ 8, col, "ESP Animal:", TR_ESP_ANIMAL, &f, 0);
3235         display_flag_aux(row+ 9, col, "ESP Orc   :", TR_ESP_ORC, &f, 0);
3236         display_flag_aux(row+10, col, "ESP Troll :", TR_ESP_TROLL, &f, 0);
3237         display_flag_aux(row+11, col, "ESP Giant :", TR_ESP_GIANT, &f, 0);
3238
3239         display_flag_aux(row+13, col, "Sust Str  :", TR_SUST_STR, &f, 0);
3240         display_flag_aux(row+14, col, "Sust Int  :", TR_SUST_INT, &f, 0);
3241         display_flag_aux(row+15, col, "Sust Wis  :", TR_SUST_WIS, &f, 0);
3242         display_flag_aux(row+16, col, "Sust Dex  :", TR_SUST_DEX, &f, 0);
3243         display_flag_aux(row+17, col, "Sust Con  :", TR_SUST_CON, &f, 0);
3244         display_flag_aux(row+18, col, "Sust Chr  :", TR_SUST_CHR, &f, 0);
3245 #endif
3246
3247
3248         /*** Set 3 ***/
3249
3250         row = 3;
3251         col = col + 12 + 17;
3252
3253         display_player_equippy(row-2, col+14, 0);
3254
3255         c_put_str(TERM_WHITE, "abcdefghijkl@", row-1, col+14);
3256
3257 #ifdef JP
3258         display_flag_aux(row+ 0, col, "ÄÉ²Ã¹¶·â    :", TR_BLOWS, &f, 0);
3259         display_flag_aux(row+ 1, col, "ºÎ·¡        :", TR_TUNNEL, &f, 0);
3260         display_flag_aux(row+ 2, col, "ÀÖ³°Àþ»ëÎÏ  :", TR_INFRA, &f, 0);
3261         display_flag_aux(row+ 3, col, "ËâË¡Æ»¶ñ»ÙÇÛ:", TR_MAGIC_MASTERY, &f, 0);
3262         display_flag_aux(row+ 4, col, "±£Ì©        :", TR_STEALTH, &f, 0);
3263         display_flag_aux(row+ 5, col, "Ãµº÷        :", TR_SEARCH, &f, 0);
3264
3265         display_flag_aux(row+ 7, col, "¾èÇÏ        :", TR_RIDING, &f, 0);
3266         display_flag_aux(row+ 8, col, "ÅêÚ³        :", TR_THROW, &f, 0);
3267         display_flag_aux(row+ 9, col, "½ËÊ¡        :", TR_BLESSED, &f, 0);
3268         display_flag_aux(row+10, col, "È¿¥Æ¥ì¥Ý¡¼¥È:", TR_NO_TELE, &f, 0);
3269         display_flag_aux(row+11, col, "È¿ËâË¡      :", TR_NO_MAGIC, &f, 0);
3270         display_flag_aux(row+12, col, "¾ÃÈñËâÎÏ¸º¾¯:", TR_DEC_MANA, &f, 0);
3271
3272         display_flag_aux(row+14, col, "·Ð¸³ÃÍ¸º¾¯  :", TR_DRAIN_EXP, &f, 0);
3273         display_flag_aux(row+15, col, "Íð¥Æ¥ì¥Ý¡¼¥È:", TR_TELEPORT, &f, 0);
3274         display_flag_aux(row+16, col, "È¿´¶        :", TR_AGGRAVATE, &f, 0);
3275         display_flag_aux(row+17, col, "ÂÀ¸Å¤Î±åÇ°  :", TR_TY_CURSE, &f, 0);
3276 #else
3277         display_flag_aux(row+ 0, col, "Add Blows   :", TR_BLOWS, &f, 0);
3278         display_flag_aux(row+ 1, col, "Add Tunnel  :", TR_TUNNEL, &f, 0);
3279         display_flag_aux(row+ 2, col, "Add Infra   :", TR_INFRA, &f, 0);
3280         display_flag_aux(row+ 3, col, "Add Device  :", TR_MAGIC_MASTERY, &f, 0);
3281         display_flag_aux(row+ 4, col, "Add Stealth :", TR_STEALTH, &f, 0);
3282         display_flag_aux(row+ 5, col, "Add Search  :", TR_SEARCH, &f, 0);
3283
3284         display_flag_aux(row+ 7, col, "Riding      :", TR_RIDING, &f, 0);
3285         display_flag_aux(row+ 8, col, "Throw       :", TR_THROW, &f, 0);
3286         display_flag_aux(row+ 9, col, "Blessed     :", TR_BLESSED, &f, 0);
3287         display_flag_aux(row+10, col, "No Teleport :", TR_NO_TELE, &f, 0);
3288         display_flag_aux(row+11, col, "Anti Magic  :", TR_NO_MAGIC, &f, 0);
3289         display_flag_aux(row+12, col, "Econom. Mana:", TR_DEC_MANA, &f, 0);
3290
3291         display_flag_aux(row+14, col, "Drain Exp   :", TR_DRAIN_EXP, &f, 0);
3292         display_flag_aux(row+15, col, "Rnd.Teleport:", TR_TELEPORT, &f, 0);
3293         display_flag_aux(row+16, col, "Aggravate   :", TR_AGGRAVATE, &f, 0);
3294         display_flag_aux(row+17, col, "TY Curse    :", TR_TY_CURSE, &f, 0);
3295 #endif
3296
3297 }
3298
3299
3300 /*
3301  * Special display, part 2a
3302  */
3303 static void display_player_misc_info(void)
3304 {
3305         char    buf[80];
3306         char    tmp[80];
3307
3308         /* Display basics */
3309 #ifdef JP
3310 put_str("Ì¾Á°  :", 1, 26);
3311 put_str("ÀÊÌ  :", 3, 1);
3312 put_str("¼ïÂ²  :", 4, 1);
3313 put_str("¿¦¶È  :", 5, 1);
3314 #else
3315         put_str("Name  :", 1, 26);
3316         put_str("Sex   :", 3, 1);
3317         put_str("Race  :", 4, 1);
3318         put_str("Class :", 5, 1);
3319 #endif
3320
3321         strcpy(tmp,ap_ptr->title);
3322 #ifdef JP
3323         if(ap_ptr->no == 1)
3324                 strcat(tmp,"¤Î");
3325 #else
3326                 strcat(tmp," ");
3327 #endif
3328         strcat(tmp,player_name);
3329
3330         c_put_str(TERM_L_BLUE, tmp, 1, 34);
3331         c_put_str(TERM_L_BLUE, sp_ptr->title, 3, 9);
3332         c_put_str(TERM_L_BLUE, (p_ptr->mimic_form ? mimic_info[p_ptr->mimic_form].title : rp_ptr->title), 4, 9);
3333         c_put_str(TERM_L_BLUE, cp_ptr->title, 5, 9);
3334
3335         /* Display extras */
3336 #ifdef JP
3337 put_str("¥ì¥Ù¥ë:", 6, 1);
3338 put_str("£È£Ð  :", 7, 1);
3339 put_str("£Í£Ð  :", 8, 1);
3340 #else
3341         put_str("Level :", 6, 1);
3342         put_str("Hits  :", 7, 1);
3343         put_str("Mana  :", 8, 1);
3344 #endif
3345
3346
3347         (void)sprintf(buf, "%d", (int)p_ptr->lev);
3348         c_put_str(TERM_L_BLUE, buf, 6, 9);
3349         (void)sprintf(buf, "%d/%d", (int)p_ptr->chp, (int)p_ptr->mhp);
3350         c_put_str(TERM_L_BLUE, buf, 7, 9);
3351         (void)sprintf(buf, "%d/%d", (int)p_ptr->csp, (int)p_ptr->msp);
3352         c_put_str(TERM_L_BLUE, buf, 8, 9);
3353 }
3354
3355
3356 /*
3357  * Special display, part 2b
3358  *
3359  * How to print out the modifications and sustains.
3360  * Positive mods with no sustain will be light green.
3361  * Positive mods with a sustain will be dark green.
3362  * Sustains (with no modification) will be a dark green 's'.
3363  * Negative mods (from a curse) will be red.
3364  * Huge mods (>9), like from MICoMorgoth, will be a '*'
3365  * No mod, no sustain, will be a slate '.'
3366  */
3367 static void display_player_stat_info(void)
3368 {
3369         int i, e_adj;
3370         int stat_col, stat;
3371         int row, col;
3372
3373         object_type *o_ptr;
3374         u32b flgs[TR_FLAG_SIZE];
3375
3376         byte a;
3377         char c;
3378
3379         char buf[80];
3380
3381
3382         /* Column */
3383         stat_col = 22;
3384
3385         /* Row */
3386         row = 3;
3387
3388         /* Print out the labels for the columns */
3389 #ifdef JP
3390 c_put_str(TERM_WHITE, "Ç½ÎÏ", row, stat_col+1);
3391 c_put_str(TERM_BLUE, "  ´ðËÜ", row, stat_col+7);
3392 c_put_str(TERM_L_BLUE, " ¼ï ¿¦ À Áõ ", row, stat_col+13);
3393 c_put_str(TERM_L_GREEN, "¹ç·×", row, stat_col+28);
3394 c_put_str(TERM_YELLOW, "¸½ºß", row, stat_col+35);
3395 #else
3396         c_put_str(TERM_WHITE, "Stat", row, stat_col+1);
3397         c_put_str(TERM_BLUE, "  Base", row, stat_col+7);
3398         c_put_str(TERM_L_BLUE, "RacClaPerMod", row, stat_col+13);
3399         c_put_str(TERM_L_GREEN, "Actual", row, stat_col+26);
3400         c_put_str(TERM_YELLOW, "Current", row, stat_col+32);
3401 #endif
3402
3403
3404         /* Display the stats */
3405         for (i = 0; i < 6; i++)
3406         {
3407                 int r_adj;
3408
3409                 if (p_ptr->mimic_form) r_adj = mimic_info[p_ptr->mimic_form].r_adj[i];
3410                 else r_adj = rp_ptr->r_adj[i];
3411
3412                 /* Calculate equipment adjustment */
3413                 e_adj = 0;
3414
3415                 /* Icky formula to deal with the 18 barrier */
3416                 if ((p_ptr->stat_max[i] > 18) && (p_ptr->stat_top[i] > 18))
3417                         e_adj = (p_ptr->stat_top[i] - p_ptr->stat_max[i]) / 10;
3418                 if ((p_ptr->stat_max[i] <= 18) && (p_ptr->stat_top[i] <= 18))
3419                         e_adj = p_ptr->stat_top[i] - p_ptr->stat_max[i];
3420                 if ((p_ptr->stat_max[i] <= 18) && (p_ptr->stat_top[i] > 18))
3421                         e_adj = (p_ptr->stat_top[i] - 18) / 10 - p_ptr->stat_max[i] + 18;
3422
3423                 if ((p_ptr->stat_max[i] > 18) && (p_ptr->stat_top[i] <= 18))
3424                         e_adj = p_ptr->stat_top[i] - (p_ptr->stat_max[i] - 19) / 10 - 19;
3425
3426                 if (prace_is_(RACE_ENT))
3427                 {
3428                         switch (i)
3429                         {
3430                                 case A_STR:
3431                                 case A_CON:
3432                                         if (p_ptr->lev > 25) r_adj++;
3433                                         if (p_ptr->lev > 40) r_adj++;
3434                                         if (p_ptr->lev > 45) r_adj++;
3435                                         break;
3436                                 case A_DEX:
3437                                         if (p_ptr->lev > 25) r_adj--;
3438                                         if (p_ptr->lev > 40) r_adj--;
3439                                         if (p_ptr->lev > 45) r_adj--;
3440                                         break;
3441                         }
3442                 }
3443
3444                 e_adj -= r_adj;
3445                 e_adj -= cp_ptr->c_adj[i];
3446                 e_adj -= ap_ptr->a_adj[i];
3447
3448                 if (p_ptr->stat_cur[i] < p_ptr->stat_max[i])
3449                         /* Reduced name of stat */
3450                         c_put_str(TERM_WHITE, stat_names_reduced[i], row + i+1, stat_col+1);
3451                 else
3452                         c_put_str(TERM_WHITE, stat_names[i], row + i+1, stat_col+1);
3453
3454
3455                 /* Internal "natural" max value.  Maxes at 18/100 */
3456                 /* This is useful to see if you are maxed out */
3457                 cnv_stat(p_ptr->stat_max[i], buf);
3458                 if (p_ptr->stat_max[i] == p_ptr->stat_max_max[i])
3459                 {
3460 #ifdef JP
3461                         c_put_str(TERM_WHITE, "!", row + i+1, stat_col + 6);
3462 #else
3463                         c_put_str(TERM_WHITE, "!", row + i+1, stat_col + 4);
3464 #endif
3465                 }
3466                 c_put_str(TERM_BLUE, buf, row + i+1, stat_col + 13 - strlen(buf));
3467
3468                 /* Race, class, and equipment modifiers */
3469                 (void)sprintf(buf, "%3d", r_adj);
3470                 c_put_str(TERM_L_BLUE, buf, row + i+1, stat_col + 13);
3471                 (void)sprintf(buf, "%3d", (int)cp_ptr->c_adj[i]);
3472                 c_put_str(TERM_L_BLUE, buf, row + i+1, stat_col + 16);
3473                 (void)sprintf(buf, "%3d", (int)ap_ptr->a_adj[i]);
3474                 c_put_str(TERM_L_BLUE, buf, row + i+1, stat_col + 19);
3475                 (void)sprintf(buf, "%3d", (int)e_adj);
3476                 c_put_str(TERM_L_BLUE, buf, row + i+1, stat_col + 22);
3477
3478                 /* Actual maximal modified value */
3479                 cnv_stat(p_ptr->stat_top[i], buf);
3480                 c_put_str(TERM_L_GREEN, buf, row + i+1, stat_col + 26);
3481
3482                 /* Only display stat_use if not maximal */
3483                 if (p_ptr->stat_use[i] < p_ptr->stat_top[i])
3484                 {
3485                         cnv_stat(p_ptr->stat_use[i], buf);
3486                         c_put_str(TERM_YELLOW, buf, row + i+1, stat_col + 33);
3487                 }
3488         }
3489
3490         /* Column */
3491         col = stat_col + 41;
3492
3493         /* Header and Footer */
3494         c_put_str(TERM_WHITE, "abcdefghijkl@", row, col);
3495 #ifdef JP
3496 c_put_str(TERM_L_GREEN, "Ç½ÎÏ½¤Àµ", row - 1, col);
3497 #else
3498         c_put_str(TERM_L_GREEN, "Modification", row - 1, col);
3499 #endif
3500
3501
3502         /* Process equipment */
3503         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
3504         {
3505                 /* Access object */
3506                 o_ptr = &inventory[i];
3507
3508                 /* Acquire "known" flags */
3509                 object_flags_known(o_ptr, flgs);
3510
3511                 /* Initialize color based of sign of pval. */
3512                 for (stat = 0; stat < 6; stat++)
3513                 {
3514                         /* Default */
3515                         a = TERM_SLATE;
3516                         c = '.';
3517
3518                         /* Boost */
3519                         if (have_flag(flgs, stat))
3520                         {
3521                                 /* Default */
3522                                 c = '*';
3523
3524                                 /* Good */
3525                                 if (o_ptr->pval > 0)
3526                                 {
3527                                         /* Good */
3528                                         a = TERM_L_GREEN;
3529
3530                                         /* Label boost */
3531                                         if (o_ptr->pval < 10) c = '0' + o_ptr->pval;
3532                                 }
3533
3534                                 if (have_flag(flgs, stat + TR_SUST_STR))
3535                                 {
3536                                         /* Dark green for sustained stats */
3537                                         a = TERM_GREEN;
3538                                 }
3539
3540                                 /* Bad */
3541                                 if (o_ptr->pval < 0)
3542                                 {
3543                                         /* Bad */
3544                                         a = TERM_RED;
3545
3546                                         /* Label boost */
3547                                         if (o_ptr->pval > -10) c = '0' - o_ptr->pval;
3548                                 }
3549                         }
3550
3551                         /* Sustain */
3552                         else if (have_flag(flgs, stat + TR_SUST_STR))
3553                         {
3554                                 /* Dark green "s" */
3555                                 a = TERM_GREEN;
3556                                 c = 's';
3557                         }
3558
3559                         /* Dump proper character */
3560                         Term_putch(col, row + stat+1, a, c);
3561                 }
3562
3563                 /* Advance */
3564                 col++;
3565         }
3566
3567         /* Player flags */
3568         player_flags(flgs);
3569
3570         /* Check stats */
3571         for (stat = 0; stat < 6; stat++)
3572         {
3573                 /* Default */
3574                 a = TERM_SLATE;
3575                 c = '.';
3576
3577                 /* Mutations ... */
3578                 if (p_ptr->muta3 || p_ptr->tsuyoshi)
3579                 {
3580                         int dummy = 0;
3581
3582                         if (stat == A_STR)
3583                         {
3584                                 if (p_ptr->muta3 & MUT3_HYPER_STR) dummy += 4;
3585                                 if (p_ptr->muta3 & MUT3_PUNY) dummy -= 4;
3586                                 if (p_ptr->tsuyoshi) dummy += 4;
3587                         }
3588                         else if (stat == A_WIS || stat == A_INT)
3589                         {
3590                                 if (p_ptr->muta3 & MUT3_HYPER_INT) dummy += 4;
3591                                 if (p_ptr->muta3 & MUT3_MORONIC) dummy -= 4;
3592                         }
3593                         else if (stat == A_DEX)
3594                         {
3595                                 if (p_ptr->muta3 & MUT3_IRON_SKIN) dummy -= 1;
3596                                 if (p_ptr->muta3 & MUT3_LIMBER) dummy += 3;
3597                                 if (p_ptr->muta3 & MUT3_ARTHRITIS) dummy -= 3;
3598                         }
3599                         else if (stat == A_CON)
3600                         {
3601                                 if (p_ptr->muta3 & MUT3_RESILIENT) dummy += 4;
3602                                 if (p_ptr->muta3 & MUT3_XTRA_FAT) dummy += 2;
3603                                 if (p_ptr->muta3 & MUT3_ALBINO) dummy -= 4;
3604                                 if (p_ptr->muta3 & MUT3_FLESH_ROT) dummy -= 2;
3605                                 if (p_ptr->tsuyoshi) dummy += 4;
3606                         }
3607                         else if (stat == A_CHR)
3608                         {
3609                                 if (p_ptr->muta3 & MUT3_SILLY_VOI) dummy -= 4;
3610                                 if (p_ptr->muta3 & MUT3_BLANK_FAC) dummy -= 1;
3611                                 if (p_ptr->muta3 & MUT3_FLESH_ROT) dummy -= 1;
3612                                 if (p_ptr->muta3 & MUT3_SCALES) dummy -= 1;
3613                                 if (p_ptr->muta3 & MUT3_WART_SKIN) dummy -= 2;
3614                                 if (p_ptr->muta3 & MUT3_ILL_NORM) dummy = 0;
3615                         }
3616
3617                         /* Boost */
3618                         if (dummy)
3619                         {
3620                                 /* Default */
3621                                 c = '*';
3622
3623                                 /* Good */
3624                                 if (dummy > 0)
3625                                 {
3626                                         /* Good */
3627                                         a = TERM_L_GREEN;
3628
3629                                         /* Label boost */
3630                                         if (dummy < 10) c = '0' + dummy;
3631                                 }
3632
3633                                 /* Bad */
3634                                 if (dummy < 0)
3635                                 {
3636                                         /* Bad */
3637                                         a = TERM_RED;
3638
3639                                         /* Label boost */
3640                                         if (dummy > -10) c = '0' - dummy;
3641                                 }
3642                         }
3643                 }
3644
3645
3646                 /* Sustain */
3647                 if (have_flag(flgs, stat + TR_SUST_STR))
3648                 {
3649                         /* Dark green "s" */
3650                         a = TERM_GREEN;
3651                         c = 's';
3652                 }
3653
3654
3655                 /* Dump */
3656                 Term_putch(col, row + stat+1, a, c);
3657         }
3658 }
3659
3660
3661 /*
3662  * Display the character on the screen (various modes)
3663  *
3664  * The top one and bottom two lines are left blank.
3665  *
3666  * Mode 0 = standard display with skills
3667  * Mode 1 = standard display with history
3668  * Mode 2 = summary of various things
3669  * Mode 3 = summary of various things (part 2)
3670  * Mode 4 = mutations
3671  */
3672 void display_player(int mode)
3673 {
3674         int i;
3675
3676         char    buf[80];
3677         char    tmp[64];
3678
3679
3680         /* XXX XXX XXX */
3681         if ((p_ptr->muta1 || p_ptr->muta2 || p_ptr->muta3) && display_mutations)
3682                 mode = (mode % 5);
3683         else
3684                 mode = (mode % 4);
3685
3686         /* Erase screen */
3687         clear_from(0);
3688
3689         /* Standard */
3690         if ((mode == 0) || (mode == 1))
3691         {
3692                 /* Name, Sex, Race, Class */
3693 #ifdef JP
3694                 sprintf(tmp, "%s%s%s", ap_ptr->title, ap_ptr->no == 1 ? "¤Î":"", player_name);
3695 #else
3696                 sprintf(tmp, "%s %s", ap_ptr->title, player_name);
3697 #endif
3698
3699                 display_player_one_line(ENTRY_NAME, tmp, TERM_L_BLUE);
3700                 display_player_one_line(ENTRY_SEX, sp_ptr->title, TERM_L_BLUE);
3701                 display_player_one_line(ENTRY_RACE, (p_ptr->mimic_form ? mimic_info[p_ptr->mimic_form].title : rp_ptr->title), TERM_L_BLUE);
3702                 display_player_one_line(ENTRY_CLASS, cp_ptr->title, TERM_L_BLUE);
3703
3704                 if (p_ptr->realm1)
3705                 {
3706                         if (p_ptr->realm2)
3707                                 sprintf(tmp, "%s, %s", realm_names[p_ptr->realm1], realm_names[p_ptr->realm2]);
3708                         else
3709                                 strcpy(tmp, realm_names[p_ptr->realm1]);
3710                         display_player_one_line(ENTRY_REALM, tmp, TERM_L_BLUE);
3711                 }
3712
3713                 if ((p_ptr->pclass == CLASS_CHAOS_WARRIOR) || (p_ptr->muta2 & MUT2_CHAOS_GIFT))
3714                         display_player_one_line(ENTRY_PATRON, chaos_patrons[p_ptr->chaos_patron], TERM_L_BLUE);
3715
3716                 /* Age, Height, Weight, Social */
3717                 /* ¿ÈÄ¹¤Ï¥»¥ó¥Á¥á¡¼¥È¥ë¤Ë¡¢ÂÎ½Å¤Ï¥¥í¥°¥é¥à¤ËÊÑ¹¹¤·¤Æ¤¢¤ê¤Þ¤¹ */
3718 #ifdef JP
3719                 display_player_one_line(ENTRY_AGE, format("%dºÍ" ,(int)p_ptr->age), TERM_L_BLUE);
3720                 display_player_one_line(ENTRY_HEIGHT, format("%dcm" ,(int)((p_ptr->ht*254)/100)), TERM_L_BLUE);
3721                 display_player_one_line(ENTRY_WEIGHT, format("%dkg" ,(int)((p_ptr->wt*4536)/10000)), TERM_L_BLUE);
3722                 display_player_one_line(ENTRY_SOCIAL, format("%d  " ,(int)p_ptr->sc), TERM_L_BLUE);
3723 #else
3724                 display_player_one_line(ENTRY_AGE, format("%d" ,(int)p_ptr->age), TERM_L_BLUE);
3725                 display_player_one_line(ENTRY_HEIGHT, format("%d" ,(int)p_ptr->ht), TERM_L_BLUE);
3726                 display_player_one_line(ENTRY_WEIGHT, format("%d" ,(int)p_ptr->wt), TERM_L_BLUE);
3727                 display_player_one_line(ENTRY_SOCIAL, format("%d" ,(int)p_ptr->sc), TERM_L_BLUE);
3728 #endif
3729                 display_player_one_line(ENTRY_ALIGN, format("%s" ,your_alignment()), TERM_L_BLUE);
3730
3731
3732                 /* Display the stats */
3733                 for (i = 0; i < 6; i++)
3734                 {
3735                         /* Special treatment of "injured" stats */
3736                         if (p_ptr->stat_cur[i] < p_ptr->stat_max[i])
3737                         {
3738                                 int value;
3739
3740                                 /* Use lowercase stat name */
3741                                 put_str(stat_names_reduced[i], 3 + i, 53);
3742
3743                                 /* Get the current stat */
3744                                 value = p_ptr->stat_use[i];
3745
3746                                 /* Obtain the current stat (modified) */
3747                                 cnv_stat(value, buf);
3748
3749                                 /* Display the current stat (modified) */
3750                                 c_put_str(TERM_YELLOW, buf, 3 + i, 60);
3751
3752                                 /* Acquire the max stat */
3753                                 value = p_ptr->stat_top[i];
3754
3755                                 /* Obtain the maximum stat (modified) */
3756                                 cnv_stat(value, buf);
3757
3758                                 /* Display the maximum stat (modified) */
3759                                 c_put_str(TERM_L_GREEN, buf, 3 + i, 67);
3760                         }
3761
3762                         /* Normal treatment of "normal" stats */
3763                         else
3764                         {
3765                                 /* Assume uppercase stat name */
3766                                 put_str(stat_names[i], 3 + i, 53);
3767
3768                                 /* Obtain the current stat (modified) */
3769                                 cnv_stat(p_ptr->stat_use[i], buf);
3770
3771                                 /* Display the current stat (modified) */
3772                                 c_put_str(TERM_L_GREEN, buf, 3 + i, 60);
3773                         }
3774
3775                         if (p_ptr->stat_max[i] == p_ptr->stat_max_max[i])
3776                         {
3777 #ifdef JP
3778                                 c_put_str(TERM_WHITE, "!", 3 + i, 58);
3779 #else
3780                                 c_put_str(TERM_WHITE, "!", 3 + i, 58-2);
3781 #endif
3782                         }
3783                 }
3784
3785                 /* Display "history" info */
3786                 if (mode == 1)
3787                 {
3788                         char statmsg[1000];
3789
3790 #ifdef JP
3791                         put_str("(¥¥ã¥é¥¯¥¿¡¼¤ÎÀ¸¤¤Î©¤Á)", 11, 25);
3792 #else
3793                         put_str("(Character Background)", 11, 25);
3794 #endif
3795
3796                         for (i = 0; i < 4; i++)
3797                         {
3798                                 put_str(p_ptr->history[i], i + 12, 10);
3799                         }
3800
3801                         *statmsg = '\0';
3802
3803                         if (p_ptr->is_dead && p_ptr->total_winner)
3804                         {
3805 #ifdef JP
3806                                 strcpy(statmsg, "¡Ä¤¢¤Ê¤¿¤Ï¾¡Íø¤Î¸å°úÂà¤·¤¿¡£");
3807 #else
3808                                 strcpy(statmsg, "...You retired from the adventure after the winning.");
3809 #endif
3810                         }
3811                         else if (p_ptr->is_dead)
3812                         {
3813                                 if (!dun_level)
3814                                 {
3815 #ifdef JP
3816                                         sprintf(statmsg, "¡Ä¤¢¤Ê¤¿¤Ï%s¤Ç%s¤Ë»¦¤µ¤ì¤¿¡£", map_name(), p_ptr->died_from);
3817 #else
3818                                         sprintf(statmsg, "...You were killed by %s in %s.", p_ptr->died_from, map_name());
3819 #endif
3820                                 }
3821                                 else if (p_ptr->inside_quest && is_fixed_quest_idx(p_ptr->inside_quest))
3822                                 {
3823                                         /* Get the quest text */
3824                                         /* Bewere that INIT_ASSIGN resets the cur_num. */
3825                                         init_flags = INIT_ASSIGN;
3826
3827                                         process_dungeon_file("q_info.txt", 0, 0, 0, 0);
3828
3829 #ifdef JP
3830                                         sprintf(statmsg, "¡Ä¤¢¤Ê¤¿¤Ï¡¢¥¯¥¨¥¹¥È¡Ö%s¡×¤Ç%s¤Ë»¦¤µ¤ì¤¿¡£", quest[p_ptr->inside_quest].name, p_ptr->died_from);
3831 #else
3832                                         sprintf(statmsg, "...You were killed by %s in the quest '%s'.", p_ptr->died_from, quest[p_ptr->inside_quest].name);
3833 #endif
3834                                 }
3835                                 else
3836                                 {
3837 #ifdef JP
3838                                         sprintf(statmsg, "¡Ä¤¢¤Ê¤¿¤Ï¡¢%s¤Î%d³¬¤Ç%s¤Ë»¦¤µ¤ì¤¿¡£", map_name(), dun_level, p_ptr->died_from);
3839 #else
3840                                         sprintf(statmsg, "...You were killed by %s on level %d of %s.", p_ptr->died_from, dun_level, map_name());
3841 #endif
3842                                 }
3843                         }
3844                         else if (character_dungeon)
3845                         {
3846                                 if (!dun_level)
3847                                 {
3848 #ifdef JP
3849                                         sprintf(statmsg, "¡Ä¤¢¤Ê¤¿¤Ï¸½ºß¡¢ %s ¤Ë¤¤¤ë¡£", map_name());
3850 #else
3851                                         sprintf(statmsg, "...Now, you are in %s.", map_name());
3852 #endif
3853                                 }
3854                                 else if (p_ptr->inside_quest && is_fixed_quest_idx(p_ptr->inside_quest))
3855                                 {
3856                                         /* Clear the text */
3857                                         /* Must be done before doing INIT_SHOW_TEXT */
3858                                         for (i = 0; i < 10; i++)
3859                                         {
3860                                                 quest_text[i][0] = '\0';
3861                                         }
3862                                         quest_text_line = 0;
3863
3864                                         /* Get the quest text */
3865                                         init_flags = INIT_SHOW_TEXT;
3866
3867                                         process_dungeon_file("q_info.txt", 0, 0, 0, 0);
3868
3869 #ifdef JP
3870                                         sprintf(statmsg, "¡Ä¤¢¤Ê¤¿¤Ï¸½ºß¡¢ ¥¯¥¨¥¹¥È¡Ö%s¡×¤ò¿ë¹ÔÃæ¤À¡£", quest[p_ptr->inside_quest].name);
3871 #else
3872                                         sprintf(statmsg, "...Now, you are in the quest '%s'.", quest[p_ptr->inside_quest].name);
3873 #endif
3874                                 }
3875                                 else
3876                                 {
3877 #ifdef JP
3878                                         sprintf(statmsg, "¡Ä¤¢¤Ê¤¿¤Ï¸½ºß¡¢ %s ¤Î %d ³¬¤ÇÃµº÷¤·¤Æ¤¤¤ë¡£", map_name(), dun_level);
3879 #else
3880                                         sprintf(statmsg, "...Now, you are exploring level %d of %s.", dun_level, map_name());
3881 #endif
3882                                 }
3883                         }
3884
3885                         if (*statmsg)
3886                         {
3887                                 char temp[64*2], *t;
3888                                 roff_to_buf(statmsg, 60, temp, sizeof(temp));
3889                                 t = temp;
3890                                 for(i=0 ; i<2 ; i++)
3891                                 {
3892                                         if(t[0]==0)
3893                                                 break;
3894                                         else
3895                                         {
3896                                                 put_str(t, i + 5 + 12, 10);
3897                                                 t += strlen(t)+1;
3898                                         }
3899                                 }
3900                         }
3901
3902                 }
3903
3904                 /* Display "various" info */
3905                 else
3906                 {
3907                         display_player_middle();
3908                         display_player_various();
3909                 }
3910         }
3911
3912         /* Special */
3913         else if (mode == 2)
3914         {
3915                 /* See "http://www.cs.berkeley.edu/~davidb/angband.html" */
3916
3917                 /* Dump the info */
3918                 display_player_misc_info();
3919                 display_player_stat_info();
3920                 display_player_flag_info();
3921         }
3922
3923         /* Special */
3924         else if (mode == 3)
3925         {
3926                 display_player_other_flag_info();
3927         }
3928
3929         else if (mode == 4)
3930         {
3931                 do_cmd_knowledge_mutations();
3932         }
3933 }
3934
3935
3936 /*
3937  *
3938  */
3939 static void dump_aux_display_player(FILE *fff)
3940 {
3941         int x, y, i;
3942         byte a;
3943         char c;
3944         char            buf[1024];
3945
3946         /* Display player */
3947         display_player(0);
3948
3949         /* Dump part of the screen */
3950         for (y = 1; y < 22; y++)
3951         {
3952                 /* Dump each row */
3953                 for (x = 0; x < 79; x++)
3954                 {
3955                         /* Get the attr/char */
3956                         (void)(Term_what(x, y, &a, &c));
3957
3958                         /* Dump it */
3959                         buf[x] = c;
3960                 }
3961
3962                 /* End the string */
3963                 buf[x] = '\0';
3964
3965                 /* Kill trailing spaces */
3966                 while ((x > 0) && (buf[x-1] == ' ')) buf[--x] = '\0';
3967
3968                 /* End the row */
3969 #ifdef JP
3970                 fprintf(fff, "%s\n", buf);
3971 #else
3972                 fprintf(fff, "%s\n", buf);
3973 #endif
3974
3975         }
3976
3977         /* Display history */
3978         display_player(1);
3979
3980         /* Dump part of the screen */
3981         for (y = 10; y < 19; y++)
3982         {
3983                 /* Dump each row */
3984                 for (x = 0; x < 79; x++)
3985                 {
3986                         /* Get the attr/char */
3987                         (void)(Term_what(x, y, &a, &c));
3988
3989                         /* Dump it */
3990                         buf[x] = c;
3991                 }
3992
3993                 /* End the string */
3994                 buf[x] = '\0';
3995
3996                 /* Kill trailing spaces */
3997                 while ((x > 0) && (buf[x-1] == ' ')) buf[--x] = '\0';
3998
3999                 /* End the row */
4000                 fprintf(fff, "%s\n", buf);
4001         }
4002
4003         fprintf(fff, "\n");
4004
4005         /* Display flags (part 1) */
4006         display_player(2);
4007
4008         /* Dump part of the screen */
4009         for (y = 2; y < 22; y++)
4010         {
4011                 /* Dump each row */
4012                 for (x = 0; x < 79; x++)
4013                 {
4014                         /* Get the attr/char */
4015                         (void)(Term_what(x, y, &a, &c));
4016
4017                         /* Dump it (Ignore equippy tile graphic) */
4018                         if (a < 128)
4019                                 buf[x] = c;
4020                         else
4021                                 buf[x] = ' ';
4022                 }
4023
4024                 /* End the string */
4025                 buf[x] = '\0';
4026
4027                 /* Kill trailing spaces */
4028                 while ((x > 0) && (buf[x-1] == ' ')) buf[--x] = '\0';
4029
4030                 /* End the row */
4031                 fprintf(fff, "%s\n", buf);
4032         }
4033
4034         fprintf(fff, "\n");
4035
4036         /* Display flags (part 2) */
4037         display_player(3);
4038
4039         /* Dump part of the screen */
4040         for (y = 1; y < 22; y++)
4041         {
4042                 /* Dump each row */
4043                 for (x = 0; x < 79; x++)
4044                 {
4045                         /* Get the attr/char */
4046                         (void)(Term_what(x, y, &a, &c));
4047
4048                         /* Dump it (Ignore equippy tile graphic) */
4049                         if (a < 128)
4050                                 buf[x] = c;
4051                         else
4052                                 buf[x] = ' ';
4053                 }
4054
4055                 /* End the string */
4056                 buf[x] = '\0';
4057
4058                 /* Kill trailing spaces */
4059                 while ((x > 0) && (buf[x-1] == ' ')) buf[--x] = '\0';
4060
4061                 /* End the row */
4062                 fprintf(fff, "%s\n", buf);
4063         }
4064
4065         for (i = 0; (unsigned int) i < (p_ptr->count / 80); i++)
4066                 fprintf(fff, " ");
4067         fprintf(fff, "\n");
4068         for (i = 0; (unsigned int) i < (p_ptr->count % 80); i++)
4069                 fprintf(fff, " ");
4070 }
4071
4072
4073 /*
4074  *
4075  */
4076 static void dump_aux_pet(FILE *fff)
4077 {
4078         int i;
4079         bool pet = FALSE;
4080         char pet_name[80];
4081
4082         for (i = m_max - 1; i >= 1; i--)
4083         {
4084                 monster_type *m_ptr = &m_list[i];
4085
4086                 if (!m_ptr->r_idx) continue;
4087                 if (!is_pet(m_ptr)) continue;
4088                 if (!m_ptr->nickname && (p_ptr->riding != i)) continue;
4089                 if (!pet)
4090                 {
4091 #ifdef JP
4092                         fprintf(fff, "\n  [¼ç¤Ê¥Ú¥Ã¥È]\n\n");
4093 #else
4094                         fprintf(fff, "\n  [leading pets]\n\n");
4095 #endif
4096                         pet = TRUE;
4097                 }
4098                 monster_desc(pet_name, m_ptr, MD_ASSUME_VISIBLE | MD_INDEF_VISIBLE);
4099                 fprintf(fff, "%s\n", pet_name);
4100         }
4101
4102         if (pet) fprintf(fff, "\n");
4103 }
4104
4105
4106 /*
4107  *
4108  */
4109 static void dump_aux_class_special(FILE *fff)
4110 {
4111         if (p_ptr->pclass == CLASS_BLUE_MAGE)
4112         {
4113                 int i = 0;
4114                 int j = 0;
4115                 int l1 = 0;
4116                 int l2 = 0;
4117                 int num = 0;
4118                 int spellnum[MAX_MONSPELLS];
4119                 s32b f4 = 0, f5 = 0, f6 = 0;
4120                 char p[60][80];
4121                 int col = 0;
4122                 bool pcol = FALSE;
4123
4124                 for (i=0;i<60;i++) { p[i][0] = '\0'; }
4125
4126 #ifdef JP
4127                 strcat(p[col], "\n  [³Ø½¬ºÑ¤ß¤ÎÀÄËâË¡]\n");
4128 #else
4129                 strcat(p[col], "\n  [Learned blue magic]\n");
4130 #endif
4131
4132
4133                 for (j=1;j<6;j++)
4134                 {
4135                         col++;
4136                         set_rf_masks(&f4, &f5, &f6, j);
4137                         switch(j)
4138                         {
4139                                 case MONSPELL_TYPE_BOLT:
4140 #ifdef JP
4141                                         strcat(p[col], "\n     [¥Ü¥ë¥È·¿]\n");
4142 #else
4143                                         strcat(p[col], "\n     [Bolt  type]\n");
4144 #endif
4145                                         break;
4146
4147                                 case MONSPELL_TYPE_BALL:
4148 #ifdef JP
4149                                         strcat(p[col], "\n     [¥Ü¡¼¥ë·¿]\n");
4150 #else
4151                                         strcat(p[col], "\n     [Ball  type]\n");
4152 #endif
4153                                         break;
4154
4155                                 case MONSPELL_TYPE_BREATH:
4156 #ifdef JP
4157                                         strcat(p[col], "\n     [¥Ö¥ì¥¹·¿]\n");
4158 #else
4159                                         strcat(p[col], "\n     [  Breath  ]\n");
4160 #endif
4161                                         break;
4162
4163                                 case MONSPELL_TYPE_SUMMON:
4164 #ifdef JP
4165                                         strcat(p[col], "\n     [¾¤´ËâË¡]\n");
4166 #else
4167                                         strcat(p[col], "\n     [Summonning]\n");
4168 #endif
4169                                         break;
4170
4171                                 case MONSPELL_TYPE_OTHER:
4172 #ifdef JP
4173                                         strcat(p[col], "\n     [ ¤½¤ÎÂ¾ ]\n");
4174 #else
4175                                         strcat(p[col], "\n     [Other type]\n");
4176 #endif
4177                                         break;
4178                         }
4179
4180                         for (i = 0, num = 0; i < 32; i++)
4181                         {
4182                                 if ((0x00000001 << i) & f4) spellnum[num++] = i;
4183                         }
4184                         for (; i < 64; i++)
4185                         {
4186                                 if ((0x00000001 << (i - 32)) & f5) spellnum[num++] = i;
4187                         }
4188                         for (; i < 96; i++)
4189                         {
4190                                 if ((0x00000001 << (i - 64)) & f6) spellnum[num++] = i;
4191                         }
4192
4193                         col++;
4194                         pcol = FALSE;
4195                         strcat(p[col], "       ");
4196
4197                         for (i = 0; i < num; i++)
4198                         {
4199                                 if (p_ptr->magic_num2[spellnum[i]])
4200                                 {
4201                                         pcol = TRUE;
4202                                         /* Dump blue magic */
4203                                         l1 = strlen(p[col]);
4204                                         l2 = strlen(monster_powers_short[spellnum[i]]);
4205                                         if ((l1 + l2) >= 75)
4206                                         {
4207                                                 strcat(p[col], "\n");
4208                                                 col++;
4209                                                 strcat(p[col], "       ");
4210                                         }
4211                                         strcat(p[col], monster_powers_short[spellnum[i]]);
4212                                         strcat(p[col], ", ");
4213                                 }
4214                         }
4215
4216                         if (!pcol)
4217                         {
4218 #ifdef JP
4219                                 strcat(p[col], "¤Ê¤·");
4220 #else
4221                                 strcat(p[col], "None");
4222 #endif
4223                         }
4224                         else
4225                         {
4226                                 if (p[col][strlen(p[col])-2] == ',')
4227                                 {
4228                                         p[col][strlen(p[col])-2] = '\0';
4229                                 }
4230                                 else
4231                                 {
4232                                         p[col][strlen(p[col])-10] = '\0';
4233                                 }
4234                         }
4235
4236                         strcat(p[col], "\n");
4237                 }
4238
4239                 for (i=0;i<=col;i++)
4240                 {
4241                         fprintf(fff, p[i]);
4242                 }
4243         }
4244 }
4245
4246
4247 /*
4248  *
4249  */
4250 static void dump_aux_quest(FILE *fff)
4251 {
4252         int i;
4253         int *quest_num;
4254         int dummy;
4255
4256
4257 #ifdef JP
4258         fprintf(fff, "\n\n  [¥¯¥¨¥¹¥È¾ðÊó]\n");
4259 #else
4260         fprintf(fff, "\n\n  [Quest information]\n");
4261 #endif
4262
4263         /* Allocate Memory */
4264         C_MAKE(quest_num, max_quests, int);
4265
4266         /* Sort by compete level */
4267         for (i = 1; i < max_quests; i++) quest_num[i] = i;
4268         ang_sort_comp = ang_sort_comp_quest_num;
4269         ang_sort_swap = ang_sort_swap_quest_num;
4270         ang_sort(quest_num, &dummy, max_quests);
4271
4272         /* Dump Quest Information */
4273         fputc('\n', fff);
4274         do_cmd_knowledge_quests_completed(fff, quest_num);
4275         fputc('\n', fff);
4276         do_cmd_knowledge_quests_failed(fff, quest_num);
4277
4278         /* Free Memory */
4279         C_KILL(quest_num, max_quests, int);
4280 }
4281
4282
4283 /*
4284  *
4285  */
4286 static void dump_aux_last_message(FILE *fff)
4287 {
4288         if (p_ptr->is_dead)
4289         {
4290                 if (!p_ptr->total_winner)
4291                 {
4292                         int i;
4293
4294 #ifdef JP
4295                         fprintf(fff, "\n  [»à¤ÌÄ¾Á°¤Î¥á¥Ã¥»¡¼¥¸]\n\n");
4296 #else
4297                         fprintf(fff, "\n  [Last messages]\n\n");
4298 #endif
4299                         for (i = MIN(message_num(), 30); i >= 0; i--)
4300                         {
4301                                 fprintf(fff,"> %s\n",message_str((s16b)i));
4302                         }
4303                         fprintf(fff, "\n");
4304                 }
4305
4306                 /* Hack -- *Winning* message */
4307                 else if (p_ptr->last_message)
4308                 {
4309 #ifdef JP
4310                         fprintf(fff, "\n  [*¾¡Íø*¥á¥Ã¥»¡¼¥¸]\n\n");
4311 #else
4312                         fprintf(fff, "\n  [*Winning* message]\n\n");
4313 #endif
4314                         fprintf(fff,"  %s\n", p_ptr->last_message);
4315                 }
4316         }
4317 }
4318
4319
4320 /*
4321  *
4322  */
4323 static void dump_aux_recall(FILE *fff)
4324 {
4325         int y;
4326
4327 #ifdef JP
4328         fprintf(fff, "\n\n  [µ¢´Ô¾ì½ê]\n\n");
4329 #else
4330         fprintf(fff, "\n\n  [Recall Depth]\n\n");
4331 #endif
4332
4333         for (y = 1; y < max_d_idx; y++)
4334         {
4335                 bool seiha = FALSE;
4336
4337                 if (!d_info[y].maxdepth) continue;
4338                 if (!max_dlv[y]) continue;
4339                 if (d_info[y].final_guardian)
4340                 {
4341                         if (!r_info[d_info[y].final_guardian].max_num) seiha = TRUE;
4342                 }
4343                 else if (max_dlv[y] == d_info[y].maxdepth) seiha = TRUE;
4344
4345 #ifdef JP
4346                 fprintf(fff, "   %c%-12s: %3d ³¬\n", seiha ? '!' : ' ', d_name+d_info[y].name, max_dlv[y]);
4347 #else
4348                 fprintf(fff, "   %c%-16s: level %3d\n", seiha ? '!' : ' ', d_name+d_info[y].name, max_dlv[y]);
4349 #endif
4350         }
4351 }
4352
4353
4354 /*
4355  *
4356  */
4357 static void dump_aux_options(FILE *fff)
4358 {
4359 #ifdef JP
4360         fprintf(fff, "\n  [¥ª¥×¥·¥ç¥óÀßÄê]\n");
4361 #else
4362         fprintf(fff, "\n  [Option settings]\n");
4363 #endif
4364
4365
4366         if (preserve_mode)
4367 #ifdef JP
4368                 fprintf(fff, "\n ÊÝÂ¸¥â¡¼¥É:         ON");
4369 #else
4370                 fprintf(fff, "\n Preserve Mode:      ON");
4371 #endif
4372
4373         else
4374 #ifdef JP
4375                 fprintf(fff, "\n ÊÝÂ¸¥â¡¼¥É:         OFF");
4376 #else
4377                 fprintf(fff, "\n Preserve Mode:      OFF");
4378 #endif
4379
4380
4381         if (ironman_autoscum)
4382 #ifdef JP
4383                 fprintf(fff, "\n ¼«Æ°Áª¤ê¹¥¤ß:       ALWAYS");
4384 #else
4385                 fprintf(fff, "\n Autoscum:           ALWAYS");
4386 #endif
4387
4388         else if (auto_scum)
4389 #ifdef JP
4390                 fprintf(fff, "\n ¼«Æ°Áª¤ê¹¥¤ß:       ON");
4391 #else
4392                 fprintf(fff, "\n Autoscum:           ON");
4393 #endif
4394
4395         else
4396 #ifdef JP
4397                 fprintf(fff, "\n ¼«Æ°Áª¤ê¹¥¤ß:       OFF");
4398 #else
4399                 fprintf(fff, "\n Autoscum:           OFF");
4400 #endif
4401
4402
4403         if (ironman_small_levels)
4404 #ifdef JP
4405                 fprintf(fff, "\n ¾®¤µ¤¤¥À¥ó¥¸¥ç¥ó:   ALWAYS");
4406 #else
4407                 fprintf(fff, "\n Small Levels:       ALWAYS");
4408 #endif
4409
4410         else if (always_small_levels)
4411 #ifdef JP
4412                 fprintf(fff, "\n ¾®¤µ¤¤¥À¥ó¥¸¥ç¥ó:   ON");
4413 #else
4414                 fprintf(fff, "\n Small Levels:       ON");
4415 #endif
4416
4417         else if (small_levels)
4418 #ifdef JP
4419                 fprintf(fff, "\n ¾®¤µ¤¤¥À¥ó¥¸¥ç¥ó:   ENABLED");
4420 #else
4421                 fprintf(fff, "\n Small Levels:       ENABLED");
4422 #endif
4423
4424         else
4425 #ifdef JP
4426                 fprintf(fff, "\n ¾®¤µ¤¤¥À¥ó¥¸¥ç¥ó:   OFF");
4427 #else
4428                 fprintf(fff, "\n Small Levels:       OFF");
4429 #endif
4430
4431
4432         if (vanilla_town)
4433 #ifdef JP
4434                 fprintf(fff, "\n ¸µÁÄ¤ÎÄ®¤Î¤ß:       ON");
4435 #else
4436                 fprintf(fff, "\n Vanilla Town:       ON");
4437 #endif
4438
4439         else if (lite_town)
4440 #ifdef JP
4441                 fprintf(fff, "\n ¾®µ¬ÌÏ¤ÊÄ®:         ON");
4442 #else
4443                 fprintf(fff, "\n Lite Town:          ON");
4444 #endif
4445
4446
4447         if (ironman_shops)
4448 #ifdef JP
4449                 fprintf(fff, "\n Å¹¤Ê¤·:             ON");
4450 #else
4451                 fprintf(fff, "\n No Shops:           ON");
4452 #endif
4453
4454
4455         if (ironman_downward)
4456 #ifdef JP
4457                 fprintf(fff, "\n ³¬ÃÊ¤ò¾å¤¬¤ì¤Ê¤¤:   ON");
4458 #else
4459                 fprintf(fff, "\n Diving Only:        ON");
4460 #endif
4461
4462
4463         if (ironman_rooms)
4464 #ifdef JP
4465                 fprintf(fff, "\n ÉáÄÌ¤Ç¤Ê¤¤Éô²°:     ON");
4466 #else
4467                 fprintf(fff, "\n Unusual Rooms:      ON");
4468 #endif
4469
4470
4471         if (ironman_nightmare)
4472 #ifdef JP
4473                 fprintf(fff, "\n °Ì´¥â¡¼¥É:         ON");
4474 #else
4475                 fprintf(fff, "\n Nightmare Mode:     ON");
4476 #endif
4477
4478
4479         if (ironman_empty_levels)
4480 #ifdef JP
4481                 fprintf(fff, "\n ¥¢¥ê¡¼¥Ê:           ALWAYS");
4482 #else
4483                 fprintf(fff, "\n Arena Levels:       ALWAYS");
4484 #endif
4485
4486         else if (empty_levels)
4487 #ifdef JP
4488                 fprintf(fff, "\n ¥¢¥ê¡¼¥Ê:           ENABLED");
4489 #else
4490                 fprintf(fff, "\n Arena Levels:       ENABLED");
4491 #endif
4492
4493         else
4494 #ifdef JP
4495                 fprintf(fff, "\n ¥¢¥ê¡¼¥Ê:           OFF");
4496 #else
4497                 fprintf(fff, "\n Arena Levels:       OFF");
4498 #endif
4499
4500
4501 #ifdef JP
4502         fprintf(fff, "\n ¥é¥ó¥À¥à¥¯¥¨¥¹¥È¿ô: %d", number_of_quests());
4503 #else
4504         fprintf(fff, "\n Num. Random Quests: %d", number_of_quests());
4505 #endif
4506
4507         fprintf(fff,"\n");
4508
4509         if (p_ptr->noscore)
4510 #ifdef JP
4511                 fprintf(fff, "\n ²¿¤«ÉÔÀµ¤Ê¤³¤È¤ò¤·¤Æ¤·¤Þ¤Ã¤Æ¤¤¤Þ¤¹¡£");
4512 #else
4513                 fprintf(fff, "\n You have done something illegal.");
4514 #endif
4515
4516         fprintf(fff,"\n");
4517 }
4518
4519
4520 /*
4521  *
4522  */
4523 static void dump_aux_arena(FILE *fff)
4524 {
4525         if (lite_town || vanilla_town) return;
4526
4527         if (p_ptr->arena_number < 0)
4528         {
4529                 if (p_ptr->arena_number <= ARENA_DEFEATED_OLD_VER)
4530                 {
4531 #ifdef JP
4532                         fprintf(fff, "\n Æ®µ»¾ì: ÇÔËÌ\n");
4533 #else
4534                         fprintf(fff, "\n Arena: Defeated\n");
4535 #endif
4536                 }
4537                 else
4538                 {
4539 #ifdef JP
4540                         fprintf(fff, "\n Æ®µ»¾ì: %d²óÀï¤Ç%s¤ÎÁ°¤ËÇÔËÌ\n", -p_ptr->arena_number,
4541                                 r_name + r_info[arena_info[-1 - p_ptr->arena_number].r_idx].name);
4542 #else
4543                         fprintf(fff, "\n Arena: Defeated by %s in the %d%s fight\n",
4544                                 r_name + r_info[arena_info[-1 - p_ptr->arena_number].r_idx].name,
4545                                 -p_ptr->arena_number, get_ordinal_number_suffix(-p_ptr->arena_number));
4546 #endif
4547                 }
4548         }
4549         else if (p_ptr->arena_number > MAX_ARENA_MONS + 2)
4550         {
4551 #ifdef JP
4552                 fprintf(fff, "\n Æ®µ»¾ì: ¿¿¤Î¥Á¥ã¥ó¥Ô¥ª¥ó\n");
4553 #else
4554                 fprintf(fff, "\n Arena: True Champion\n");
4555 #endif
4556         }
4557         else if (p_ptr->arena_number > MAX_ARENA_MONS - 1)
4558         {
4559 #ifdef JP
4560                 fprintf(fff, "\n Æ®µ»¾ì: ¥Á¥ã¥ó¥Ô¥ª¥ó\n");
4561 #else
4562                 fprintf(fff, "\n Arena: Champion\n");
4563 #endif
4564         }
4565         else
4566         {
4567 #ifdef JP
4568                 fprintf(fff, "\n Æ®µ»¾ì: %2d¾¡\n", (p_ptr->arena_number > MAX_ARENA_MONS ? MAX_ARENA_MONS : p_ptr->arena_number));
4569 #else
4570                 fprintf(fff, "\n Arena: %2d Victor%s\n", (p_ptr->arena_number > MAX_ARENA_MONS ? MAX_ARENA_MONS : p_ptr->arena_number), (p_ptr->arena_number > 1) ? "ies" : "y");
4571 #endif
4572         }
4573
4574         fprintf(fff, "\n");
4575 }
4576
4577
4578 /*
4579  *
4580  */
4581 static void dump_aux_monsters(FILE *fff)
4582 {
4583         /* Monsters slain */
4584
4585         int k;
4586         unsigned long uniq_total = 0;
4587         unsigned long norm_total = 0;
4588         s16b *who;
4589
4590         /* Sort by monster level */
4591         u16b why = 2;
4592
4593 #ifdef JP
4594         fprintf(fff, "\n  [ÅÝ¤·¤¿¥â¥ó¥¹¥¿¡¼]\n\n");
4595 #else
4596         fprintf(fff, "\n  [Defeated monsters]\n\n");
4597 #endif
4598
4599         /* Allocate the "who" array */
4600         C_MAKE(who, max_r_idx, s16b);
4601
4602         /* Count monster kills */
4603         for (k = 1; k < max_r_idx; k++)
4604         {
4605                 monster_race *r_ptr = &r_info[k];
4606
4607                 /* Ignore unused index */
4608                 if (!r_ptr->name) continue;
4609
4610                 /* Unique monsters */
4611                 if (r_ptr->flags1 & RF1_UNIQUE)
4612                 {
4613                         bool dead = (r_ptr->max_num == 0);
4614                         if (dead)
4615                         {
4616                                 norm_total++;
4617
4618                                 /* Add a unique monster to the list */
4619                                 who[uniq_total++] = k;
4620                         }
4621                 }
4622
4623                 /* Normal monsters */
4624                 else
4625                 {
4626                         if (r_ptr->r_pkills > 0)
4627                         {
4628                                 norm_total += r_ptr->r_pkills;
4629                         }
4630                 }
4631         }
4632
4633
4634         /* No monsters is defeated */
4635         if (norm_total < 1)
4636         {
4637 #ifdef JP
4638                 fprintf(fff,"¤Þ¤ÀÅ¨¤òÅÝ¤·¤Æ¤¤¤Þ¤»¤ó¡£\n");
4639 #else
4640                 fprintf(fff,"You have defeated no enemies yet.\n");
4641 #endif
4642         }
4643
4644         /* Defeated more than one normal monsters */
4645         else if (uniq_total == 0)
4646         {
4647 #ifdef JP
4648                 fprintf(fff,"%luÂÎ¤ÎÅ¨¤òÅÝ¤·¤Æ¤¤¤Þ¤¹¡£\n", norm_total);
4649 #else
4650                 fprintf(fff,"You have defeated %lu %s.\n", norm_total, norm_total == 1 ? "enemy" : "enemies");
4651 #endif
4652         }
4653
4654         /* Defeated more than one unique monsters */
4655         else /* if (uniq_total > 0) */
4656         {
4657 #ifdef JP
4658                 fprintf(fff, "%luÂÎ¤Î¥æ¥Ë¡¼¥¯¡¦¥â¥ó¥¹¥¿¡¼¤ò´Þ¤à¡¢¹ç·×%luÂÎ¤ÎÅ¨¤òÅÝ¤·¤Æ¤¤¤Þ¤¹¡£\n", uniq_total, norm_total);
4659 #else
4660                 fprintf(fff, "You have defeated %lu %s including %lu unique monster%s in total.\n", norm_total, norm_total == 1 ? "enemy" : "enemies", uniq_total, (uniq_total == 1 ? "" : "s"));
4661 #endif
4662
4663
4664                 /* Select the sort method */
4665                 ang_sort_comp = ang_sort_comp_hook;
4666                 ang_sort_swap = ang_sort_swap_hook;
4667
4668                 /* Sort the array by dungeon depth of monsters */
4669                 ang_sort(who, &why, uniq_total);
4670
4671 #ifdef JP
4672                 fprintf(fff, "\n¡Ô¾å°Ì%luÂÎ¤Î¥æ¥Ë¡¼¥¯¡¦¥â¥ó¥¹¥¿¡¼¡Õ\n", MIN(uniq_total, 10));
4673 #else
4674                 fprintf(fff, "\n< Unique monsters top %lu >\n", MIN(uniq_total, 10));
4675 #endif
4676
4677                 /* Print top 10 */
4678                 for (k = MIN(10, uniq_total); k >= 0; k--)
4679                 {
4680                         monster_race *r_ptr = &r_info[who[k]];
4681
4682 #ifdef JP
4683                         fprintf(fff, "  %-40s (¥ì¥Ù¥ë%3d)\n", (r_name + r_ptr->name), r_ptr->level);
4684 #else
4685                         fprintf(fff, "  %-40s (level %3d)\n", (r_name + r_ptr->name), r_ptr->level);
4686 #endif
4687                 }
4688
4689         }
4690
4691         /* Free the "who" array */
4692         C_KILL(who, max_r_idx, s16b);
4693 }
4694
4695
4696 /*
4697  *
4698  */
4699 static void dump_aux_race_history(FILE *fff)
4700 {
4701         if (p_ptr->old_race1 || p_ptr->old_race2)
4702         {
4703                 int i;
4704
4705 #ifdef JP
4706                 fprintf(fff, "\n\n ¤¢¤Ê¤¿¤Ï%s¤È¤·¤ÆÀ¸¤Þ¤ì¤¿¡£", race_info[p_ptr->start_race].title);
4707 #else
4708                 fprintf(fff, "\n\n You were born as %s.", race_info[p_ptr->start_race].title);
4709 #endif
4710                 for (i = 0; i < MAX_RACES; i++)
4711                 {
4712                         if (p_ptr->start_race == i) continue;
4713                         if (i < 32)
4714                         {
4715                                 if (!(p_ptr->old_race1 & 1L << i)) continue;
4716                         }
4717                         else
4718                         {
4719                                 if (!(p_ptr->old_race2 & 1L << (i-32))) continue;
4720                         }
4721 #ifdef JP
4722                         fprintf(fff, "\n ¤¢¤Ê¤¿¤Ï¤«¤Ä¤Æ%s¤À¤Ã¤¿¡£", race_info[i].title);
4723 #else
4724                         fprintf(fff, "\n You were a %s before.", race_info[i].title);
4725 #endif
4726                 }
4727         }
4728 }
4729
4730
4731 /*
4732  *
4733  */
4734 static void dump_aux_realm_history(FILE *fff)
4735 {
4736         if (p_ptr->old_realm)
4737         {
4738                 int i;
4739
4740                 for (i = 0; i < MAX_MAGIC; i++)
4741                 {
4742                         if (!(p_ptr->old_realm & 1L << i)) continue;
4743 #ifdef JP
4744                         fprintf(fff, "\n ¤¢¤Ê¤¿¤Ï¤«¤Ä¤Æ%sËâË¡¤ò»È¤¨¤¿¡£", realm_names[i+1]);
4745 #else
4746                         fprintf(fff, "\n You were able to use %s magic before.", realm_names[i+1]);
4747 #endif
4748                 }
4749         }
4750 }
4751
4752
4753 /*
4754  *
4755  */
4756 static void dump_aux_virtues(FILE *fff)
4757 {
4758 #ifdef JP
4759         fprintf(fff, "\n\n  [¥×¥ì¥¤¥ä¡¼¤ÎÆÁ]\n\n");
4760 #else
4761         fprintf(fff, "\n\n  [Virtues]\n\n");
4762 #endif
4763
4764 #ifdef JP
4765         fprintf(fff, "Â°À : %s\n", your_alignment());
4766 #else
4767         fprintf(fff, "Your alighnment : %s\n", your_alignment());
4768 #endif
4769
4770         fprintf(fff, "\n");
4771         dump_virtues(fff);
4772 }
4773
4774
4775 /*
4776  *
4777  */
4778 static void dump_aux_mutations(FILE *fff)
4779 {
4780         if (p_ptr->muta1 || p_ptr->muta2 || p_ptr->muta3)
4781         {
4782 #ifdef JP
4783                 fprintf(fff, "\n\n  [ÆÍÁ³ÊÑ°Û]\n\n");
4784 #else
4785                 fprintf(fff, "\n\n  [Mutations]\n\n");
4786 #endif
4787
4788                 dump_mutations(fff);
4789         }
4790
4791         /* Skip some lines */
4792         fprintf(fff, "\n\n");
4793 }
4794
4795
4796 /*
4797  *
4798  */
4799 static void dump_aux_equipment_inventory(FILE *fff)
4800 {
4801         int i;
4802         char o_name[MAX_NLEN];
4803
4804         /* Dump the equipment */
4805         if (equip_cnt)
4806         {
4807 #ifdef JP
4808                 fprintf(fff, "  [¥¥ã¥é¥¯¥¿¤ÎÁõÈ÷]\n\n");
4809 #else
4810                 fprintf(fff, "  [Character Equipment]\n\n");
4811 #endif
4812
4813                 for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
4814                 {
4815                         object_desc(o_name, &inventory[i], TRUE, 3);
4816                         if ((i == INVEN_LARM) && p_ptr->ryoute)
4817 #ifdef JP
4818                                 strcpy(o_name, "(Éð´ï¤òÎ¾¼ê»ý¤Á)");
4819 #else
4820                                 strcpy(o_name, "(wielding with two-hands)");
4821 #endif
4822
4823                         fprintf(fff, "%c) %s\n",
4824                                 index_to_label(i), o_name);
4825                 }
4826                 fprintf(fff, "\n\n");
4827         }
4828
4829         /* Dump the inventory */
4830 #ifdef JP
4831         fprintf(fff, "  [¥¥ã¥é¥¯¥¿¤Î»ý¤ÁÊª]\n\n");
4832 #else
4833         fprintf(fff, "  [Character Inventory]\n\n");
4834 #endif
4835
4836         for (i = 0; i < INVEN_PACK; i++)
4837         {
4838                 /* Don't dump the empty slots */
4839                 if (!inventory[i].k_idx) break;
4840
4841                 /* Dump the inventory slots */
4842                 object_desc(o_name, &inventory[i], TRUE, 3);
4843                 fprintf(fff, "%c) %s\n", index_to_label(i), o_name);
4844         }
4845
4846         /* Add an empty line */
4847         fprintf(fff, "\n\n");
4848 }
4849
4850
4851 /*
4852  *
4853  */
4854 static void dump_aux_home_museum(FILE *fff)
4855 {
4856         char o_name[MAX_NLEN];
4857         store_type  *st_ptr;
4858
4859         /* Do we need it?? */
4860         /* process_dungeon_file("w_info.txt", 0, 0, max_wild_y, max_wild_x); */
4861
4862         /* Print the home */
4863         st_ptr = &town[1].store[STORE_HOME];
4864
4865         /* Home -- if anything there */
4866         if (st_ptr->stock_num)
4867         {
4868                 int i;
4869                 int x = 1;
4870
4871 #ifdef JP
4872                 fprintf(fff, "  [²æ¤¬²È¤Î¥¢¥¤¥Æ¥à]\n");
4873 #else
4874                 fprintf(fff, "  [Home Inventory]\n");
4875 #endif
4876
4877                 /* Dump all available items */
4878                 for (i = 0; i < st_ptr->stock_num; i++)
4879                 {
4880                         if ((i % 12) == 0)
4881 #ifdef JP
4882                                 fprintf(fff, "\n ( %d ¥Ú¡¼¥¸ )\n", x++);
4883 #else
4884                                 fprintf(fff, "\n ( page %d )\n", x++);
4885 #endif
4886                         object_desc(o_name, &st_ptr->stock[i], TRUE, 3);
4887                         fprintf(fff, "%c) %s\n", I2A(i%12), o_name);
4888                 }
4889
4890                 /* Add an empty line */
4891                 fprintf(fff, "\n\n");
4892         }
4893
4894
4895         /* Print the home */
4896         st_ptr = &town[1].store[STORE_MUSEUM];
4897
4898         /* Home -- if anything there */
4899         if (st_ptr->stock_num)
4900         {
4901                 int i;
4902                 int x = 1;
4903
4904 #ifdef JP
4905                 fprintf(fff, "  [ÇîÊª´Û¤Î¥¢¥¤¥Æ¥à]\n");
4906 #else
4907                 fprintf(fff, "  [Museum]\n");
4908 #endif
4909
4910                 /* Dump all available items */
4911                 for (i = 0; i < st_ptr->stock_num; i++)
4912                 {
4913 #ifdef JP
4914                 if ((i % 12) == 0) fprintf(fff, "\n ( %d ¥Ú¡¼¥¸ )\n", x++);
4915                         object_desc(o_name, &st_ptr->stock[i], TRUE, 3);
4916                         fprintf(fff, "%c) %s\n", I2A(i%12), o_name);
4917 #else
4918                 if ((i % 12) == 0) fprintf(fff, "\n ( page %d )\n", x++);
4919                         object_desc(o_name, &st_ptr->stock[i], TRUE, 3);
4920                         fprintf(fff, "%c) %s\n", I2A(i%12), o_name);
4921 #endif
4922
4923                 }
4924
4925                 /* Add an empty line */
4926                 fprintf(fff, "\n\n");
4927         }
4928 }
4929
4930
4931 /*
4932  * Output the character dump to a file
4933  */
4934 errr make_character_dump(FILE *fff)
4935 {
4936 #ifdef JP
4937         fprintf(fff, "  [ÊÑ¶òÈÚÅÜ %d.%d.%d ¥¥ã¥é¥¯¥¿¾ðÊó]\n\n",
4938                 FAKE_VER_MAJOR-10, FAKE_VER_MINOR, FAKE_VER_PATCH);
4939 #else
4940         fprintf(fff, "  [Hengband %d.%d.%d Character Dump]\n\n",
4941                 FAKE_VER_MAJOR-10, FAKE_VER_MINOR, FAKE_VER_PATCH);
4942 #endif
4943
4944         update_playtime();
4945
4946         dump_aux_display_player(fff);
4947         dump_aux_last_message(fff);
4948         dump_aux_options(fff);
4949         dump_aux_recall(fff);
4950         dump_aux_quest(fff);
4951         dump_aux_arena(fff);
4952         dump_aux_monsters(fff);
4953         dump_aux_virtues(fff);
4954         dump_aux_race_history(fff);
4955         dump_aux_realm_history(fff);
4956         dump_aux_class_special(fff);
4957         dump_aux_mutations(fff);
4958         dump_aux_pet(fff);
4959         dump_aux_equipment_inventory(fff);
4960         dump_aux_home_museum(fff);
4961
4962 #ifdef JP
4963         fprintf(fff, "  [¥Á¥§¥Ã¥¯¥µ¥à: \"%s\"]\n\n", get_check_sum());
4964 #else
4965         fprintf(fff, "  [Check Sum: \"%s\"]\n\n", get_check_sum());
4966 #endif
4967
4968         return 0;
4969 }
4970
4971 /*
4972  * Hack -- Dump a character description file
4973  *
4974  * XXX XXX XXX Allow the "full" flag to dump additional info,
4975  * and trigger its usage from various places in the code.
4976  */
4977 errr file_character(cptr name)
4978 {
4979         int             fd = -1;
4980         FILE            *fff = NULL;
4981         char            buf[1024];
4982
4983         /* Build the filename */
4984         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, name);
4985
4986         /* File type is "TEXT" */
4987         FILE_TYPE(FILE_TYPE_TEXT);
4988
4989         /* Check for existing file */
4990         fd = fd_open(buf, O_RDONLY);
4991
4992         /* Existing file */
4993         if (fd >= 0)
4994         {
4995                 char out_val[160];
4996
4997                 /* Close the file */
4998                 (void)fd_close(fd);
4999
5000                 /* Build query */
5001 #ifdef JP
5002                 (void)sprintf(out_val, "¸½Â¸¤¹¤ë¥Õ¥¡¥¤¥ë %s ¤Ë¾å½ñ¤¤·¤Þ¤¹¤«? ", buf);
5003 #else
5004                 (void)sprintf(out_val, "Replace existing file %s? ", buf);
5005 #endif
5006
5007
5008                 /* Ask */
5009                 if (get_check_strict(out_val, CHECK_NO_HISTORY)) fd = -1;
5010         }
5011
5012         /* Open the non-existing file */
5013         if (fd < 0) fff = my_fopen(buf, "w");
5014
5015         /* Invalid file */
5016         if (!fff)
5017         {
5018                 /* Message */
5019 #ifdef JP
5020                 prt("¥¥ã¥é¥¯¥¿¾ðÊó¤Î¥Õ¥¡¥¤¥ë¤Ø¤Î½ñ¤½Ð¤·¤Ë¼ºÇÔ¤·¤Þ¤·¤¿¡ª", 0, 0);
5021 #else
5022                 prt("Character dump failed!", 0, 0);
5023 #endif
5024
5025                 (void)inkey();
5026
5027                 /* Error */
5028                 return (-1);
5029         }
5030
5031         (void)make_character_dump(fff);
5032
5033         /* Close it */
5034         my_fclose(fff);
5035
5036
5037         /* Message */
5038 #ifdef JP
5039 msg_print("¥¥ã¥é¥¯¥¿¾ðÊó¤Î¥Õ¥¡¥¤¥ë¤Ø¤Î½ñ¤½Ð¤·¤ËÀ®¸ù¤·¤Þ¤·¤¿¡£");
5040 #else
5041         msg_print("Character dump successful.");
5042 #endif
5043
5044         msg_print(NULL);
5045
5046         /* Success */
5047         return (0);
5048 }
5049
5050
5051 /*
5052  * Display single line of on-line help file
5053  */
5054 static void show_file_aux_line(cptr str, int cy, cptr shower)
5055 {
5056         byte color = TERM_WHITE;
5057         bool in_tag = FALSE;
5058         int cx = 0;
5059         int i;
5060         char lcstr[1024];
5061
5062         if (shower)
5063         {
5064                 /* Make a lower case version of str for searching */
5065                 strcpy(lcstr, str);
5066                 str_tolower(lcstr);
5067         }
5068
5069         /* Initial cursor position */
5070         Term_gotoxy(cx, cy);
5071
5072         for (i = 0; str[i];)
5073         {
5074                 int len = strlen(&str[i]);
5075                 int showercol = len + 1;
5076                 int bracketcol = len + 1;
5077                 int endcol = len;
5078                 cptr ptr;
5079
5080                 /* Search for a shower string in the line */
5081                 if (shower)
5082                 {
5083                         ptr = my_strstr(&lcstr[i], shower);
5084                         if (ptr) showercol = ptr - &lcstr[i];
5085                 }
5086
5087                 /* Search for a color segment tag */
5088                 ptr = in_tag ? my_strchr(&str[i], ']') : my_strstr(&str[i], "[[[[[");
5089                 if (ptr) bracketcol = ptr - &str[i];
5090
5091                 /* A color tag is found */
5092                 if (bracketcol < endcol) endcol = bracketcol;
5093
5094                 /* The shower string is found before the color tag */
5095                 if (showercol < endcol) endcol = showercol;
5096
5097                 /* Print a segment of the line */
5098                 Term_addstr(endcol, color, &str[i]);
5099                 cx += endcol;
5100                 i += endcol;
5101
5102                 /* Shower string? */
5103                 if (endcol == showercol)
5104                 {
5105                         int showerlen = strlen(shower);
5106
5107                         /* Print the shower string in yellow */
5108                         Term_addstr(showerlen, TERM_YELLOW, &str[i]);
5109                         cx += showerlen;
5110                         i += showerlen;
5111                 }
5112
5113                 /* Colored segment? */
5114                 else if (endcol == bracketcol)
5115                 {
5116                         if (in_tag)
5117                         {
5118                                 /* Found a ']', the end of colored segment */
5119                                 i++;
5120
5121                                 /* Now looking for an another "[[[[[" */
5122                                 in_tag = FALSE;
5123
5124                                 /* Set back to the default color */
5125                                 color = TERM_WHITE;
5126                         }
5127                         else
5128                         {
5129                                 /* Found a "[[[[[", and get a tag color */
5130                                 i += 5;
5131
5132                                 /* Get tag color */
5133                                 color = color_char_to_attr(str[i]);
5134
5135                                 if (color == 255)
5136                                 {
5137                                         /* Illegal color tag */
5138                                         color = TERM_WHITE;
5139
5140                                         /* Print the broken tag as a string */
5141                                         Term_addstr(-1, TERM_WHITE, "[[[[[");
5142                                         cx += 5;
5143                                 }
5144                                 else
5145                                 {
5146                                         /* Skip the color tag */
5147                                         i++;
5148
5149                                         /* Now looking for a ']' */
5150                                         in_tag = TRUE;
5151                                 }
5152                         }
5153                 }
5154
5155         } /* for (i = 0; str[i];) */
5156
5157         /* Clear rest of line */
5158         Term_erase(cx, cy, 255);
5159 }
5160
5161
5162 /*
5163  * Recursive file perusal.
5164  *
5165  * Process various special text in the input file, including
5166  * the "menu" structures used by the "help file" system.
5167  *
5168  * Return FALSE on 'q' to exit from a deep, otherwise TRUE.
5169  */
5170 bool show_file(bool show_version, cptr name, cptr what, int line, int mode)
5171 {
5172         int i, n, skey;
5173
5174         /* Number of "real" lines passed by */
5175         int next = 0;
5176
5177         /* Number of "real" lines in the file */
5178         int size = 0;
5179
5180         /* Backup value for "line" */
5181         int back = 0;
5182
5183         /* This screen has sub-screens */
5184         bool menu = FALSE;
5185
5186         /* Current help file */
5187         FILE *fff = NULL;
5188
5189         /* Find this string (if any) */
5190         cptr find = NULL;
5191
5192         /* Jump to this tag */
5193         cptr tag = NULL;
5194
5195         /* Hold strings to find/show */
5196         char finder_str[81];
5197         char shower_str[81];
5198
5199         /* String to show */
5200         cptr shower = NULL;
5201
5202         /* Filename */
5203         char filename[1024];
5204
5205         /* Describe this thing */
5206         char caption[128];
5207
5208         /* Path buffer */
5209         char path[1024];
5210
5211         /* General buffer */
5212         char buf[1024];
5213
5214         /* Sub-menu information */
5215         char hook[68][32];
5216
5217         bool reverse = (line < 0);
5218
5219         int wid, hgt, rows;
5220
5221         Term_get_size(&wid, &hgt);
5222         rows = hgt - 4;
5223
5224         /* Wipe finder */
5225         strcpy(finder_str, "");
5226
5227         /* Wipe shower */
5228         strcpy(shower_str, "");
5229
5230         /* Wipe caption */
5231         strcpy(caption, "");
5232
5233         /* Wipe the hooks */
5234         for (i = 0; i < 68; i++)
5235         {
5236                 hook[i][0] = '\0';
5237         }
5238
5239         /* Copy the filename */
5240         strcpy(filename, name);
5241
5242         n = strlen(filename);
5243
5244         /* Extract the tag from the filename */
5245         for (i = 0; i < n; i++)
5246         {
5247                 if (filename[i] == '#')
5248                 {
5249                         filename[i] = '\0';
5250                         tag = filename + i + 1;
5251                         break;
5252                 }
5253         }
5254
5255         /* Redirect the name */
5256         name = filename;
5257
5258         /* Hack XXX XXX XXX */
5259         if (what)
5260         {
5261                 /* Caption */
5262                 strcpy(caption, what);
5263
5264                 /* Access the "file" */
5265                 strcpy(path, name);
5266
5267                 /* Open */
5268                 fff = my_fopen(path, "r");
5269         }
5270
5271         /* Look in "help" */
5272         if (!fff)
5273         {
5274                 /* Caption */
5275 #ifdef JP
5276 sprintf(caption, "¥Ø¥ë¥×¡¦¥Õ¥¡¥¤¥ë'%s'", name);
5277 #else
5278                 sprintf(caption, "Help file '%s'", name);
5279 #endif
5280
5281
5282                 /* Build the filename */
5283                 path_build(path, sizeof(path), ANGBAND_DIR_HELP, name);
5284
5285                 /* Open the file */
5286                 fff = my_fopen(path, "r");
5287         }
5288
5289         /* Look in "info" */
5290         if (!fff)
5291         {
5292                 /* Caption */
5293 #ifdef JP
5294 sprintf(caption, "¥¹¥Ý¥¤¥é¡¼¡¦¥Õ¥¡¥¤¥ë'%s'", name);
5295 #else
5296                 sprintf(caption, "Info file '%s'", name);
5297 #endif
5298
5299
5300                 /* Build the filename */
5301                 path_build(path, sizeof(path), ANGBAND_DIR_INFO, name);
5302
5303                 /* Open the file */
5304                 fff = my_fopen(path, "r");
5305         }
5306
5307         /* Look in "info" */
5308         if (!fff)
5309         {
5310                 /* Build the filename */
5311                 path_build(path, sizeof(path), ANGBAND_DIR, name);
5312
5313                 for (i = 0; path[i]; i++)
5314                         if ('\\' == path[i])
5315                                 path[i] = PATH_SEP[0];
5316
5317                 /* Caption */
5318 #ifdef JP
5319 sprintf(caption, "¥¹¥Ý¥¤¥é¡¼¡¦¥Õ¥¡¥¤¥ë'%s'", name);
5320 #else
5321                 sprintf(caption, "Info file '%s'", name);
5322 #endif
5323
5324                 /* Open the file */
5325                 fff = my_fopen(path, "r");
5326         }
5327
5328         /* Oops */
5329         if (!fff)
5330         {
5331                 /* Message */
5332 #ifdef JP
5333 msg_format("'%s'¤ò¥ª¡¼¥×¥ó¤Ç¤¤Þ¤»¤ó¡£", name);
5334 #else
5335                 msg_format("Cannot open '%s'.", name);
5336 #endif
5337
5338                 msg_print(NULL);
5339
5340                 /* Oops */
5341                 return (TRUE);
5342         }
5343
5344
5345         /* Pre-Parse the file */
5346         while (TRUE)
5347         {
5348                 char *str = buf;
5349
5350                 /* Read a line or stop */
5351                 if (my_fgets(fff, buf, sizeof(buf))) break;
5352
5353                 /* XXX Parse "menu" items */
5354                 if (prefix(str, "***** "))
5355                 {
5356                         /* Notice "menu" requests */
5357                         if ((str[6] == '[') && isalpha(str[7]))
5358                         {
5359                                 /* Extract the menu item */
5360                                 int k = str[7] - 'A';
5361
5362                                 /* This is a menu file */
5363                                 menu = TRUE;
5364
5365                                 if ((str[8] == ']') && (str[9] == ' '))
5366                                 {
5367                                         /* Extract the menu item */
5368                                         strncpy(hook[k], str + 10, 31);
5369
5370                                         /* Make sure it's null-terminated */
5371                                         hook[k][31] = '\0';
5372                                 }
5373                         }
5374                         /* Notice "tag" requests */
5375                         else if (str[6] == '<')
5376                         {
5377                                 size_t len = strlen(str);
5378
5379                                 if (str[len - 1] == '>')
5380                                 {
5381                                         str[len - 1] = '\0';
5382                                         if (tag && streq(str + 7, tag)) line = next;
5383                                 }
5384                         }
5385
5386                         /* Skip this */
5387                         continue;
5388                 }
5389
5390                 /* Count the "real" lines */
5391                 next++;
5392         }
5393
5394         /* Save the number of "real" lines */
5395         size = next;
5396
5397         /* start from bottom when reverse mode */
5398         if (line == -1) line = ((size-1)/rows)*rows;
5399
5400         /* Clear screen */
5401         Term_clear();
5402
5403         /* Display the file */
5404         while (TRUE)
5405         {
5406                 /* Restart when necessary */
5407                 if (line >= size - rows) line = size - rows;
5408                 if (line < 0) line = 0;
5409
5410                 /* Re-open the file if needed */
5411                 if (next > line)
5412                 {
5413                         /* Close it */
5414                         my_fclose(fff);
5415
5416                         /* Hack -- Re-Open the file */
5417                         fff = my_fopen(path, "r");
5418
5419                         /* Oops */
5420                         if (!fff) return (FALSE);
5421
5422                         /* File has been restarted */
5423                         next = 0;
5424                 }
5425
5426                 /* Goto the selected line */
5427                 while (next < line)
5428                 {
5429                         /* Get a line */
5430                         if (my_fgets(fff, buf, sizeof(buf))) break;
5431
5432                         /* Skip tags/links */
5433                         if (prefix(buf, "***** ")) continue;
5434
5435                         /* Count the lines */
5436                         next++;
5437                 }
5438
5439                 /* Dump the next 20, or rows, lines of the file */
5440                 for (i = 0; i < rows; )
5441                 {
5442                         cptr str = buf;
5443
5444                         /* Hack -- track the "first" line */
5445                         if (!i) line = next;
5446
5447                         /* Get a line of the file or stop */
5448                         if (my_fgets(fff, buf, sizeof(buf))) break;
5449
5450                         /* Hack -- skip "special" lines */
5451                         if (prefix(buf, "***** ")) continue;
5452
5453                         /* Count the "real" lines */
5454                         next++;
5455
5456                         /* Hack -- keep searching */
5457                         if (find && !i)
5458                         {
5459                                 char lc_buf[1024];
5460
5461                                 /* Make a lower case version of str for searching */
5462                                 strcpy(lc_buf, str);
5463                                 str_tolower(lc_buf);
5464
5465                                 if (!my_strstr(lc_buf, find)) continue;
5466                         }
5467
5468                         /* Hack -- stop searching */
5469                         find = NULL;
5470
5471                         /* Dump the line */
5472                         show_file_aux_line(str, i + 2, shower);
5473
5474                         /* Count the printed lines */
5475                         i++;
5476                 }
5477
5478                 while (i < rows)
5479                 {
5480                         /* Clear rest of line */
5481                         Term_erase(0, i + 2, 255);
5482
5483                         i++;
5484                 }
5485
5486                 /* Hack -- failed search */
5487                 if (find)
5488                 {
5489                         bell();
5490                         line = back;
5491                         find = NULL;
5492                         continue;
5493                 }
5494
5495
5496                 /* Show a general "title" */
5497                 if (show_version)
5498                 {
5499                         prt(format(
5500 #ifdef JP
5501                                 "[ÊÑ¶òÈÚÅÜ %d.%d.%d, %s, %d/%d]",
5502 #else
5503                                 "[Hengband %d.%d.%d, %s, Line %d/%d]",
5504 #endif
5505
5506                            FAKE_VER_MAJOR-10, FAKE_VER_MINOR, FAKE_VER_PATCH,
5507                            caption, line, size), 0, 0);
5508                 }
5509                 else
5510                 {
5511                         prt(format(
5512 #ifdef JP
5513                                 "[%s, %d/%d]",
5514 #else
5515                                 "[%s, Line %d/%d]",
5516 #endif
5517                                 caption, line, size), 0, 0);
5518                 }
5519
5520                 /* Prompt -- small files */
5521                 if (size <= rows)
5522                 {
5523                         /* Wait for it */
5524 #ifdef JP
5525 prt("[¥¡¼:(?)¥Ø¥ë¥× (ESC)½ªÎ»]", hgt - 1, 0);
5526 #else
5527                         prt("[Press ESC to exit.]", hgt - 1, 0);
5528 #endif
5529
5530                 }
5531
5532                 /* Prompt -- large files */
5533                 else
5534                 {
5535 #ifdef JP
5536                         if(reverse)
5537                                 prt("[¥¡¼:(RET/¥¹¥Ú¡¼¥¹)¢¬ (-)¢ (?)¥Ø¥ë¥× (ESC)½ªÎ»]", hgt - 1, 0);
5538                         else
5539                                 prt("[¥¡¼:(RET/¥¹¥Ú¡¼¥¹)¢ (-)¢¬ (?)¥Ø¥ë¥× (ESC)½ªÎ»]", hgt - 1, 0);
5540 #else
5541                         prt("[Press Return, Space, -, =, /, |, or ESC to exit.]", hgt - 1, 0);
5542 #endif
5543                 }
5544
5545                 /* Get a special key code */
5546                 skey = inkey_special();
5547
5548                 /* Show the help for the help */
5549                 if (skey == '?')
5550                 {
5551                         /* Hack - prevent silly recursion */
5552 #ifdef JP
5553                         if (strcmp(name, "jhelpinfo.txt") != 0)
5554                                 show_file(TRUE, "jhelpinfo.txt", NULL, 0, mode);
5555 #else
5556                         if (strcmp(name, "helpinfo.txt") != 0)
5557                                 show_file(TRUE, "helpinfo.txt", NULL, 0, mode);
5558 #endif
5559                 }
5560
5561                 /* Hack -- try showing */
5562                 if (skey == '=')
5563                 {
5564                         /* Get "shower" */
5565 #ifdef JP
5566                         prt("¶¯Ä´: ", hgt - 1, 0);
5567 #else
5568                         prt("Show: ", hgt - 1, 0);
5569 #endif
5570
5571                         (void)askfor_aux(shower_str, 80);
5572
5573                         /* Make it lowercase */
5574                         str_tolower(shower_str);
5575
5576                         /* Show it */
5577                         shower = shower_str;
5578                 }
5579
5580                 /* Hack -- try finding */
5581                 if (skey == '/' || skey == KTRL('s'))
5582                 {
5583                         /* Get "finder" */
5584 #ifdef JP
5585                         prt("¸¡º÷: ", hgt - 1, 0);
5586 #else
5587                         prt("Find: ", hgt - 1, 0);
5588 #endif
5589
5590
5591                         if (askfor_aux(finder_str, 80))
5592                         {
5593                                 /* Find it */
5594                                 find = finder_str;
5595                                 back = line;
5596                                 line = line + 1;
5597
5598                                 /* Make finder lowercase */
5599                                 str_tolower(finder_str);
5600
5601                                 /* Show it */
5602                                 shower = finder_str;
5603                         }
5604                 }
5605
5606                 /* Hack -- go to a specific line */
5607                 if (skey == '#')
5608                 {
5609                         char tmp[81];
5610 #ifdef JP
5611 prt("¹Ô: ", hgt - 1, 0);
5612 #else
5613                         prt("Goto Line: ", hgt - 1, 0);
5614 #endif
5615
5616                         strcpy(tmp, "0");
5617
5618                         if (askfor_aux(tmp, 80))
5619                         {
5620                                 line = atoi(tmp);
5621                         }
5622                 }
5623
5624                 /* Hack -- go to the top line */
5625                 if (skey == SKEY_TOP)
5626                 {
5627                         line = 0;
5628                 }
5629
5630                 /* Hack -- go to the bottom line */
5631                 if (skey == SKEY_BOTTOM)
5632                 {
5633                         line = ((size-1)/rows)*rows;
5634                 }
5635
5636                 /* Hack -- go to a specific file */
5637                 if (skey == '%')
5638                 {
5639                         char tmp[81];
5640 #ifdef JP
5641 prt("¥Õ¥¡¥¤¥ë¡¦¥Í¡¼¥à: ", hgt - 1, 0);
5642 strcpy(tmp, "jhelp.hlp");
5643 #else
5644                         prt("Goto File: ", hgt - 1, 0);
5645                         strcpy(tmp, "help.hlp");
5646 #endif
5647
5648
5649                         if (askfor_aux(tmp, 80))
5650                         {
5651                                 if (!show_file(TRUE, tmp, NULL, 0, mode)) skey = 'q';
5652                         }
5653                 }
5654
5655                 /* Allow backing up */
5656                 if (skey == '-')
5657                 {
5658                         line = line + (reverse ? rows : -rows);
5659                         if (line < 0) line = 0;
5660                 }
5661
5662                 /* One page up */
5663                 if (skey == SKEY_PGUP)
5664                 {
5665                         line = line - rows;
5666                         if (line < 0) line = 0;
5667                 }
5668
5669                 /* Advance a single line */
5670                 if ((skey == '\n') || (skey == '\r'))
5671                 {
5672                         line = line + (reverse ? -1 : 1);
5673                         if (line < 0) line = 0;
5674                 }
5675
5676
5677                 /* Move up / down */
5678                 if (skey == '8' || skey == SKEY_UP)
5679                 {
5680                         line--;
5681                         if (line < 0) line = 0;
5682                 }
5683
5684                 if (skey == '2' || skey == SKEY_DOWN) line++;
5685
5686                 /* Advance one page */
5687                 if (skey == ' ')
5688                 {
5689                         line = line + (reverse ? -rows : rows);
5690                         if (line < 0) line = 0;
5691                 }
5692
5693                 /* One page down */
5694                 if (skey == SKEY_PGDOWN)
5695                 {
5696                         line = line + rows;
5697                 }
5698
5699                 /* Recurse on numbers */
5700                 if (menu)
5701                 {
5702                         int key = -1;
5703
5704                         if (!(skey & SKEY_MASK) && isalpha(skey))
5705                                 key = skey - 'A';
5706
5707                         if ((key > -1) && hook[key][0])
5708                         {
5709                                 /* Recurse on that file */
5710                                 if (!show_file(TRUE, hook[key], NULL, 0, mode))
5711                                         skey = 'q';
5712                         }
5713                 }
5714
5715                 /* Hack, dump to file */
5716                 if (skey == '|')
5717                 {
5718                         FILE *ffp;
5719                         char buff[1024];
5720                         char xtmp[82];
5721
5722                         strcpy (xtmp, "");
5723
5724 #ifdef JP
5725                         if (!get_string("¥Õ¥¡¥¤¥ëÌ¾: ", xtmp, 80))
5726 #else
5727                         if (!get_string("File name: ", xtmp, 80))
5728 #endif
5729                         {
5730                                 continue;
5731                         }
5732
5733                         /* Close it */
5734                         my_fclose(fff);
5735
5736                         /* Build the filename */
5737                         path_build(buff, sizeof(buff), ANGBAND_DIR_USER, xtmp);
5738
5739                         /* Hack -- Re-Open the file */
5740                         fff = my_fopen(path, "r");
5741
5742                         ffp = my_fopen(buff, "w");
5743
5744                         /* Oops */
5745                         if (!(fff && ffp))
5746                         {
5747 #ifdef JP
5748 msg_print("¥Õ¥¡¥¤¥ë¤¬³«¤±¤Þ¤»¤ó¡£");
5749 #else
5750                                 msg_print("Failed to open file.");
5751 #endif
5752
5753                                 skey = ESCAPE;
5754                                 break;
5755                         }
5756
5757                         sprintf(xtmp, "%s: %s", player_name, what);
5758                         my_fputs(ffp, xtmp, 80);
5759                         my_fputs(ffp, "\n", 80);
5760
5761                         while (!my_fgets(fff, buff, sizeof(buff)))
5762                                 my_fputs(ffp, buff, 80);
5763
5764                         /* Close it */
5765                         my_fclose(fff);
5766                         my_fclose(ffp);
5767
5768                         /* Hack -- Re-Open the file */
5769                         fff = my_fopen(path, "r");
5770                 }
5771
5772                 /* Return to last screen */
5773                 if (skey == ESCAPE) break;
5774                 if (skey == '<') break;
5775
5776                 /* Exit on the ^q */
5777                 if (skey == KTRL('q')) skey = 'q';
5778
5779                 /* Exit on the q key */
5780                 if (skey == 'q') break;
5781         }
5782
5783         /* Close the file */
5784         my_fclose(fff);
5785
5786         /* Escape */
5787         if (skey == 'q') return (FALSE);
5788
5789         /* Normal return */
5790         return (TRUE);
5791 }
5792
5793
5794 /*
5795  * Peruse the On-Line-Help
5796  */
5797 void do_cmd_help(void)
5798 {
5799         /* Save screen */
5800         screen_save();
5801
5802         /* Peruse the main help file */
5803 #ifdef JP
5804 (void)show_file(TRUE, "jhelp.hlp", NULL, 0, 0);
5805 #else
5806         (void)show_file(TRUE, "help.hlp", NULL, 0, 0);
5807 #endif
5808
5809
5810         /* Load screen */
5811         screen_load();
5812 }
5813
5814
5815 /*
5816  * Process the player name.
5817  * Extract a clean "base name".
5818  * Build the savefile name if needed.
5819  */
5820 void process_player_name(bool sf)
5821 {
5822         int i, k = 0;
5823
5824
5825         /* Cannot be too long */
5826 #if defined(MACINTOSH) || defined(MSDOS) || defined(USE_EMX) || defined(AMIGA) || defined(ACORN) || defined(VM)
5827 #ifdef MSDOS
5828         if (strlen(player_name) > 8)
5829 #else
5830         if (strlen(player_name) > 15)
5831 #endif
5832         {
5833                 /* Name too long */
5834 #ifdef JP
5835 quit_fmt("'%s'¤È¤¤¤¦Ì¾Á°¤ÏÄ¹¤¹¤®¤Þ¤¹¡ª", player_name);
5836 #else
5837                 quit_fmt("The name '%s' is too long!", player_name);
5838 #endif
5839
5840         }
5841 #endif
5842
5843         /* Cannot contain "icky" characters */
5844         for (i = 0; player_name[i]; i++)
5845         {
5846                 /* No control characters */
5847 #ifdef JP
5848                 if (iskanji(player_name[i])){i++;continue;}
5849                 if (iscntrl( (unsigned char)player_name[i]))
5850 #else
5851                 if (iscntrl(player_name[i]))
5852 #endif
5853
5854                 {
5855                         /* Illegal characters */
5856 #ifdef JP
5857 quit_fmt("'%s' ¤È¤¤¤¦Ì¾Á°¤ÏÉÔÀµ¤Ê¥³¥ó¥È¥í¡¼¥ë¥³¡¼¥É¤ò´Þ¤ó¤Ç¤¤¤Þ¤¹¡£", player_name);
5858 #else
5859                         quit_fmt("The name '%s' contains control chars!", player_name);
5860 #endif
5861
5862                 }
5863         }
5864
5865
5866 #ifdef MACINTOSH
5867
5868         /* Extract "useful" letters */
5869         for (i = 0; player_name[i]; i++)
5870         {
5871 #ifdef JP
5872                 unsigned char c = player_name[i];
5873 #else
5874                 char c = player_name[i];
5875 #endif
5876
5877
5878                 /* Convert "dot" to "underscore" */
5879                 if (c == '.') c = '_';
5880
5881                 /* Accept all the letters */
5882                 player_base[k++] = c;
5883         }
5884
5885 #else
5886
5887         /* Extract "useful" letters */
5888         for (i = 0; player_name[i]; i++)
5889         {
5890 #ifdef JP
5891                 unsigned char c = player_name[i];
5892 #else
5893                 char c = player_name[i];
5894 #endif
5895
5896                 /* Accept some letters */
5897 #ifdef JP
5898                 if(iskanji(c)){
5899                   if(k + 2 >= sizeof(player_base) || !player_name[i+1]) break;
5900                   player_base[k++] = c;
5901                   i++;
5902                   player_base[k++] = player_name[i];
5903                 }
5904 #ifdef SJIS
5905                 else if (iskana(c)) player_base[k++] = c;
5906 #endif
5907                 else
5908 #endif
5909                 /* Convert path separator to underscore */
5910                 if (!strncmp(PATH_SEP, player_name+i, strlen(PATH_SEP))){
5911                         player_base[k++] = '_';
5912                         i += strlen(PATH_SEP);
5913                 }
5914 #ifdef MSDOS
5915                 /* Convert space, dot, and underscore to underscore */
5916                 else if (my_strchr(". _", c)) player_base[k++] = '_';
5917 #endif
5918                 else if (isprint(c)) player_base[k++] = c;
5919         }
5920
5921 #endif
5922
5923
5924 #if defined(MSDOS)
5925
5926         /* Hack -- max length */
5927         if (k > 8) k = 8;
5928
5929 #endif
5930
5931         /* Terminate */
5932         player_base[k] = '\0';
5933
5934         /* Require a "base" name */
5935         if (!player_base[0]) strcpy(player_base, "PLAYER");
5936
5937
5938 #ifdef SAVEFILE_MUTABLE
5939
5940         /* Accept */
5941         sf = TRUE;
5942
5943 #endif
5944         if (!savefile_base[0] && savefile[0])
5945         {
5946                 cptr s;
5947                 s = savefile;
5948                 while (1)
5949                 {
5950                         cptr t;
5951                         t = my_strstr(s, PATH_SEP);
5952                         if (!t)
5953                                 break;
5954                         s = t+1;
5955                 }
5956                 strcpy(savefile_base, s);
5957         }
5958
5959         if (!savefile_base[0] || !savefile[0])
5960                 sf = TRUE;
5961
5962         /* Change the savefile name */
5963         if (sf)
5964         {
5965                 char temp[128];
5966
5967                 strcpy(savefile_base, player_base);
5968
5969 #ifdef SAVEFILE_USE_UID
5970                 /* Rename the savefile, using the player_uid and player_base */
5971                 (void)sprintf(temp, "%d.%s", player_uid, player_base);
5972 #else
5973                 /* Rename the savefile, using the player_base */
5974                 (void)sprintf(temp, "%s", player_base);
5975 #endif
5976
5977 #ifdef VM
5978                 /* Hack -- support "flat directory" usage on VM/ESA */
5979                 (void)sprintf(temp, "%s.sv", player_base);
5980 #endif /* VM */
5981
5982                 /* Build the filename */
5983                 path_build(savefile, sizeof(savefile), ANGBAND_DIR_SAVE, temp);
5984         }
5985 }
5986
5987
5988 /*
5989  * Gets a name for the character, reacting to name changes.
5990  *
5991  * Assumes that "display_player(0)" has just been called
5992  *
5993  * Perhaps we should NOT ask for a name (at "birth()") on
5994  * Unix machines?  XXX XXX
5995  *
5996  * What a horrible name for a global function.  XXX XXX XXX
5997  */
5998 void get_name(void)
5999 {
6000         char tmp[64];
6001
6002         /* Save the player name */
6003         strcpy(tmp, player_name);
6004
6005         /* Prompt for a new name */
6006 #ifdef JP
6007         if (get_string("¥¥ã¥é¥¯¥¿¡¼¤ÎÌ¾Á°¤òÆþÎÏ¤·¤Æ²¼¤µ¤¤: ", tmp, 15))
6008 #else
6009         if (get_string("Enter a name for your character: ", tmp, 15))
6010 #endif
6011         {
6012                 /* Use the name */
6013                 strcpy(player_name, tmp);
6014         }
6015         else if (0 == strlen(player_name))
6016         {
6017                 /* Use default name */
6018                 strcpy(player_name, "PLAYER");
6019         }
6020
6021         strcpy(tmp,ap_ptr->title);
6022 #ifdef JP
6023         if(ap_ptr->no == 1)
6024                 strcat(tmp,"¤Î");
6025 #else
6026         strcat(tmp, " ");
6027 #endif
6028         strcat(tmp,player_name);
6029
6030         /* Re-Draw the name (in light blue) */
6031         Term_erase(34, 1, 255);
6032         c_put_str(TERM_L_BLUE, tmp, 1, 34);
6033
6034         /* Erase the prompt, etc */
6035         clear_from(22);
6036 }
6037
6038
6039
6040 /*
6041  * Hack -- commit suicide
6042  */
6043 void do_cmd_suicide(void)
6044 {
6045         int i;
6046
6047         /* Flush input */
6048         flush();
6049
6050         /* Verify Retirement */
6051         if (p_ptr->total_winner)
6052         {
6053                 /* Verify */
6054 #ifdef JP
6055 if (!get_check_strict("°úÂà¤·¤Þ¤¹¤«? ", CHECK_NO_HISTORY)) return;
6056 #else
6057                 if (!get_check_strict("Do you want to retire? ", CHECK_NO_HISTORY)) return;
6058 #endif
6059
6060         }
6061
6062         /* Verify Suicide */
6063         else
6064         {
6065                 /* Verify */
6066 #ifdef JP
6067 if (!get_check("ËÜÅö¤Ë¼«»¦¤·¤Þ¤¹¤«¡©")) return;
6068 #else
6069                 if (!get_check("Do you really want to commit suicide? ")) return;
6070 #endif
6071         }
6072
6073
6074         if (!p_ptr->noscore)
6075         {
6076                 /* Special Verification for suicide */
6077 #ifdef JP
6078 prt("³ÎÇ§¤Î¤¿¤á '@' ¤ò²¡¤·¤Æ²¼¤µ¤¤¡£", 0, 0);
6079 #else
6080                 prt("Please verify SUICIDE by typing the '@' sign: ", 0, 0);
6081 #endif
6082
6083                 flush();
6084                 i = inkey();
6085                 prt("", 0, 0);
6086                 if (i != '@') return;
6087         }
6088
6089         /* Initialize "last message" buffer */
6090         if (p_ptr->last_message) string_free(p_ptr->last_message);
6091         p_ptr->last_message = NULL;
6092
6093         /* Hack -- Note *winning* message */
6094         if (p_ptr->total_winner && last_words)
6095         {
6096                 char buf[1024] = "";
6097
6098 #ifdef JP
6099                 while (!get_string("*¾¡Íø*¥á¥Ã¥»¡¼¥¸: ", buf, sizeof buf)) ;
6100 #else
6101                 while (!get_string("*Winning* message: ", buf, sizeof buf)) ;
6102 #endif
6103
6104                 if (buf[0])
6105                 {
6106                         p_ptr->last_message = string_make(buf);
6107                         msg_print(p_ptr->last_message);
6108                 }
6109         }
6110
6111         /* Stop playing */
6112         p_ptr->playing = FALSE;
6113
6114         /* Kill the player */
6115         p_ptr->is_dead = TRUE;
6116
6117         /* Leaving */
6118         p_ptr->leaving = TRUE;
6119
6120         if (!p_ptr->total_winner)
6121         {
6122 #ifdef JP
6123                 do_cmd_write_nikki(NIKKI_BUNSHOU, 0, "¥À¥ó¥¸¥ç¥ó¤ÎÃµº÷¤ËÀäË¾¤·¤Æ¼«»¦¤·¤¿¡£");
6124                 do_cmd_write_nikki(NIKKI_GAMESTART, 1, "-------- ¥²¡¼¥à¥ª¡¼¥Ð¡¼ --------");
6125 #else
6126                 do_cmd_write_nikki(NIKKI_BUNSHOU, 0, "give up all hope to commit suicide.");
6127                 do_cmd_write_nikki(NIKKI_GAMESTART, 1, "--------   Game  Over   --------");
6128 #endif
6129                 do_cmd_write_nikki(NIKKI_BUNSHOU, 1, "\n\n\n\n");
6130         }
6131
6132         /* Cause of death */
6133 #ifdef JP
6134 (void)strcpy(p_ptr->died_from, "ÅÓÃæ½ªÎ»");
6135 #else
6136         (void)strcpy(p_ptr->died_from, "Quitting");
6137 #endif
6138
6139 }
6140
6141
6142
6143 /*
6144  * Save the game
6145  */
6146 void do_cmd_save_game(int is_autosave)
6147 {
6148         /* Autosaves do not disturb */
6149         if (is_autosave)
6150         {
6151 #ifdef JP
6152 msg_print("¼«Æ°¥»¡¼¥ÖÃæ");
6153 #else
6154                 msg_print("Autosaving the game...");
6155 #endif
6156
6157         }
6158         else
6159         {
6160                 /* Disturb the player */
6161                 disturb(1, 0);
6162         }
6163
6164         /* Clear messages */
6165         msg_print(NULL);
6166
6167         /* Handle stuff */
6168         handle_stuff();
6169
6170         /* Message */
6171 #ifdef JP
6172 prt("¥²¡¼¥à¤ò¥»¡¼¥Ö¤·¤Æ¤¤¤Þ¤¹...", 0, 0);
6173 #else
6174         prt("Saving game...", 0, 0);
6175 #endif
6176
6177
6178         /* Refresh */
6179         Term_fresh();
6180
6181         /* The player is not dead */
6182 #ifdef JP
6183 (void)strcpy(p_ptr->died_from, "(¥»¡¼¥Ö)");
6184 #else
6185         (void)strcpy(p_ptr->died_from, "(saved)");
6186 #endif
6187
6188
6189         /* Forbid suspend */
6190         signals_ignore_tstp();
6191
6192         /* Save the player */
6193         if (save_player())
6194         {
6195 #ifdef JP
6196 prt("¥²¡¼¥à¤ò¥»¡¼¥Ö¤·¤Æ¤¤¤Þ¤¹... ½ªÎ»", 0, 0);
6197 #else
6198                 prt("Saving game... done.", 0, 0);
6199 #endif
6200
6201         }
6202
6203         /* Save failed (oops) */
6204         else
6205         {
6206 #ifdef JP
6207 prt("¥²¡¼¥à¤ò¥»¡¼¥Ö¤·¤Æ¤¤¤Þ¤¹... ¼ºÇÔ¡ª", 0, 0);
6208 #else
6209                 prt("Saving game... failed!", 0, 0);
6210 #endif
6211
6212         }
6213
6214         /* Allow suspend again */
6215         signals_handle_tstp();
6216
6217         /* Refresh */
6218         Term_fresh();
6219
6220         /* Note that the player is not dead */
6221 #ifdef JP
6222 (void)strcpy(p_ptr->died_from, "(¸µµ¤¤ËÀ¸¤¤Æ¤¤¤ë)");
6223 #else
6224         (void)strcpy(p_ptr->died_from, "(alive and well)");
6225 #endif
6226
6227         /* Update some things */
6228         p_ptr->update |= (PU_VIEW | PU_LITE | PU_MON_LITE | PU_DISTANCE);
6229
6230         /* Update stuff */
6231         update_stuff();
6232 }
6233
6234
6235 /*
6236  * Save the game and exit
6237  */
6238 void do_cmd_save_and_exit(void)
6239 {
6240         p_ptr->playing = FALSE;
6241
6242         /* Leaving */
6243         p_ptr->leaving = TRUE;
6244 #ifdef JP
6245         do_cmd_write_nikki(NIKKI_GAMESTART, 0, "----¥²¡¼¥àÃæÃÇ----");
6246 #else
6247         do_cmd_write_nikki(NIKKI_GAMESTART, 0, "---- Save and Exit Game ----");
6248 #endif
6249 }
6250
6251
6252 /*
6253  * Hack -- Calculates the total number of points earned         -JWT-
6254  */
6255 long total_points(void)
6256 {
6257         int i, mult = 100;
6258         s16b max_dl = 0;
6259         u32b point, point_h, point_l;
6260         int arena_win = MIN(p_ptr->arena_number, MAX_ARENA_MONS);
6261
6262         if (!preserve_mode) mult += 10;
6263         if (!autoroller) mult += 10;
6264         if (!smart_learn) mult -= 20;
6265         if (smart_cheat) mult += 30;
6266         if (ironman_shops) mult += 50;
6267         if (ironman_small_levels) mult += 10;
6268         if (ironman_empty_levels) mult += 20;
6269         if (!powerup_home) mult += 50;
6270         if (ironman_rooms) mult += 100;
6271         if (ironman_nightmare) mult += 100;
6272
6273         if (mult < 5) mult = 5;
6274
6275         for (i = 0; i < max_d_idx; i++)
6276                 if(max_dlv[i] > max_dl)
6277                         max_dl = max_dlv[i];
6278
6279         point_l = (p_ptr->max_max_exp + (100 * max_dl));
6280         point_h = point_l / 0x10000L;
6281         point_l = point_l % 0x10000L;
6282         point_h *= mult;
6283         point_l *= mult;
6284         point_h += point_l / 0x10000L;
6285         point_l %= 0x10000L;
6286
6287         point_l += ((point_h % 100) << 16);
6288         point_h /= 100;
6289         point_l /= 100;
6290
6291         point = (point_h << 16) + (point_l);
6292         if (p_ptr->arena_number >= 0)
6293                 point += (arena_win * arena_win * (arena_win > 29 ? 1000 : 100));
6294
6295         if (ironman_downward) point *= 2;
6296         if (p_ptr->pclass == CLASS_BERSERKER)
6297         {
6298                 if ( p_ptr->prace == RACE_SPECTRE )
6299                         point = point / 5;
6300         }
6301
6302         if ((p_ptr->pseikaku == SEIKAKU_MUNCHKIN) && point)
6303         {
6304                 point = 1;
6305                 if (p_ptr->total_winner) point = 2;
6306         }
6307         if (easy_band) point = (0 - point);
6308
6309         return point;
6310 }
6311
6312
6313
6314 /*
6315  * Centers a string within a 31 character string                -JWT-
6316  */
6317 static void center_string(char *buf, cptr str)
6318 {
6319         int i, j;
6320
6321         /* Total length */
6322         i = strlen(str);
6323
6324         /* Necessary border */
6325         j = 15 - i / 2;
6326
6327         /* Mega-Hack */
6328         (void)sprintf(buf, "%*s%s%*s", j, "", str, 31 - i - j, "");
6329 }
6330
6331
6332 #if 0
6333 /*
6334  * Save a "bones" file for a dead character
6335  *
6336  * Note that we will not use these files until Angband 2.8.0, and
6337  * then we will only use the name and level on which death occured.
6338  *
6339  * Should probably attempt some form of locking...
6340  */
6341 static void make_bones(void)
6342 {
6343         FILE                *fp;
6344
6345         char                str[1024];
6346
6347
6348         /* Ignore wizards and borgs */
6349         if (!(p_ptr->noscore & 0x00FF))
6350         {
6351                 /* Ignore people who die in town */
6352                 if (dun_level)
6353                 {
6354                         char tmp[128];
6355
6356                         /* XXX XXX XXX "Bones" name */
6357                         sprintf(tmp, "bone.%03d", dun_level);
6358
6359                         /* Build the filename */
6360                         path_build(str, sizeof(str), ANGBAND_DIR_BONE, tmp);
6361
6362                         /* Attempt to open the bones file */
6363                         fp = my_fopen(str, "r");
6364
6365                         /* Close it right away */
6366                         if (fp) my_fclose(fp);
6367
6368                         /* Do not over-write a previous ghost */
6369                         if (fp) return;
6370
6371                         /* File type is "TEXT" */
6372                         FILE_TYPE(FILE_TYPE_TEXT);
6373
6374                         /* Grab permissions */
6375                         safe_setuid_grab();
6376
6377                         /* Try to write a new "Bones File" */
6378                         fp = my_fopen(str, "w");
6379
6380                         /* Drop permissions */
6381                         safe_setuid_drop();
6382
6383                         /* Not allowed to write it?  Weird. */
6384                         if (!fp) return;
6385
6386                         /* Save the info */
6387                         fprintf(fp, "%s\n", player_name);
6388                         fprintf(fp, "%d\n", p_ptr->mhp);
6389                         fprintf(fp, "%d\n", p_ptr->prace);
6390                         fprintf(fp, "%d\n", p_ptr->pclass);
6391
6392                         /* Close and save the Bones file */
6393                         my_fclose(fp);
6394                 }
6395         }
6396 }
6397 #endif
6398
6399
6400 /*
6401  * Redefinable "print_tombstone" action
6402  */
6403 bool (*tombstone_aux)(void) = NULL;
6404
6405
6406 /*
6407  * Display a "tomb-stone"
6408  */
6409 static void print_tomb(void)
6410 {
6411         bool done = FALSE;
6412
6413         /* Do we use a special tombstone ? */
6414         if (tombstone_aux)
6415         {
6416                 /* Use tombstone hook */
6417                 done = (*tombstone_aux)();
6418         }
6419
6420         /* Print the text-tombstone */
6421         if (!done)
6422         {
6423                 cptr    p;
6424
6425                 char    tmp[160];
6426
6427                 char    buf[1024];
6428 #ifndef JP
6429                 char    dummy[80];
6430 #endif
6431
6432                 FILE        *fp;
6433
6434                 time_t  ct = time((time_t)0);
6435
6436
6437                 /* Clear screen */
6438                 Term_clear();
6439
6440                 /* Build the filename */
6441 #ifdef JP
6442                 path_build(buf, sizeof(buf), ANGBAND_DIR_FILE, "dead_j.txt");
6443 #else
6444                 path_build(buf, sizeof(buf), ANGBAND_DIR_FILE, "dead.txt");
6445 #endif
6446
6447
6448                 /* Open the News file */
6449                 fp = my_fopen(buf, "r");
6450
6451                 /* Dump */
6452                 if (fp)
6453                 {
6454                         int i = 0;
6455
6456                         /* Dump the file to the screen */
6457                         while (0 == my_fgets(fp, buf, sizeof(buf)))
6458                         {
6459                                 /* Display and advance */
6460                                 put_str(buf, i++, 0);
6461                         }
6462
6463                         /* Close */
6464                         my_fclose(fp);
6465                 }
6466
6467
6468                 /* King or Queen */
6469                 if (p_ptr->total_winner || (p_ptr->lev > PY_MAX_LEVEL))
6470                 {
6471 #ifdef JP
6472                 /* ±ÑÆüÀÚ¤êÂØ¤¨ */
6473                   p= "°ÎÂç¤Ê¤ë¼Ô";
6474 #else
6475                         p = "Magnificent";
6476 #endif
6477
6478                 }
6479
6480                 /* Normal */
6481                 else
6482                 {
6483                         p =  player_title[p_ptr->pclass][(p_ptr->lev - 1) / 5];
6484                 }
6485
6486                 center_string(buf, player_name);
6487                 put_str(buf, 6, 11);
6488
6489 #ifndef JP
6490                 center_string(buf, "the");
6491                 put_str(buf, 7, 11);
6492 #endif
6493
6494                 center_string(buf, p);
6495                 put_str(buf, 8, 11);
6496
6497
6498                 center_string(buf, cp_ptr->title);
6499
6500                 put_str(buf, 10, 11);
6501
6502 #ifdef JP
6503 (void)sprintf(tmp, "¥ì¥Ù¥ë: %d", (int)p_ptr->lev);
6504 #else
6505                 (void)sprintf(tmp, "Level: %d", (int)p_ptr->lev);
6506 #endif
6507
6508                 center_string(buf, tmp);
6509                 put_str(buf, 11, 11);
6510
6511 #ifdef JP
6512 (void)sprintf(tmp, "·Ð¸³ÃÍ: %ld", (long)p_ptr->exp);
6513 #else
6514                 (void)sprintf(tmp, "Exp: %ld", (long)p_ptr->exp);
6515 #endif
6516
6517                 center_string(buf, tmp);
6518                 put_str(buf, 12, 11);
6519
6520 #ifdef JP
6521 (void)sprintf(tmp, "½ê»ý¶â: %ld", (long)p_ptr->au);
6522 #else
6523                 (void)sprintf(tmp, "AU: %ld", (long)p_ptr->au);
6524 #endif
6525
6526                 center_string(buf, tmp);
6527                 put_str(buf, 13, 11);
6528
6529 #ifdef JP
6530         /* Êè¤Ë¹ï¤à¸ÀÍÕ¤ò¥ª¥ê¥¸¥Ê¥ë¤è¤êºÙ¤«¤¯É½¼¨ */
6531         if (streq(p_ptr->died_from, "ÅÓÃæ½ªÎ»"))
6532         {
6533                 strcpy(tmp, "<¼«»¦>");
6534         }
6535         else
6536         {
6537                 if (streq(p_ptr->died_from, "ripe"))
6538                 {
6539                         strcpy(tmp, "°úÂà¸å¤ËÅ·¼÷¤òÁ´¤¦");
6540                 }
6541                 else if (streq(p_ptr->died_from, "Seppuku"))
6542                 {
6543                         strcpy(tmp, "¾¡Íø¤Î¸å¡¢ÀÚÊ¢");
6544                 }
6545                 else
6546                 {
6547                         strcpy(tmp, p_ptr->died_from);
6548                 }
6549         }
6550         center_string(buf, tmp);
6551         put_str(buf, 14, 11);
6552
6553         if(!streq(p_ptr->died_from, "ripe") && !streq(p_ptr->died_from, "Seppuku"))
6554         {
6555                 if( dun_level == 0 )
6556                 {
6557                         cptr town = (p_ptr->town_num ? "³¹" : "¹ÓÌî");
6558                         if(streq(p_ptr->died_from, "ÅÓÃæ½ªÎ»"))
6559                         {
6560                                 sprintf(tmp, "%s¤Ç»à¤ó¤À", town);
6561                         }
6562                         else
6563                         {
6564                                 sprintf(tmp, "¤Ë%s¤Ç»¦¤µ¤ì¤¿", town);
6565                         }
6566                 }
6567                 else
6568                 {
6569                         if(streq(p_ptr->died_from, "ÅÓÃæ½ªÎ»"))
6570                         {
6571                                 sprintf(tmp, "ÃÏ²¼ %d ³¬¤Ç»à¤ó¤À", dun_level);
6572                         }
6573                         else
6574                         {
6575                                 sprintf(tmp, "¤ËÃÏ²¼ %d ³¬¤Ç»¦¤µ¤ì¤¿", dun_level);
6576                         }
6577                 }
6578                 center_string(buf, tmp);
6579                 put_str(buf, 15, 11);
6580         }
6581 #else
6582                 (void)sprintf(tmp, "Killed on Level %d", dun_level);
6583                 center_string(buf, tmp);
6584                 put_str(buf, 14, 11);
6585
6586
6587                 if (strlen(p_ptr->died_from) > 24)
6588                 {
6589                         strncpy(dummy, p_ptr->died_from, 24);
6590                         dummy[24] = '\0';
6591                         (void)sprintf(tmp, "by %s.", dummy);
6592                 }
6593                 else
6594                         (void)sprintf(tmp, "by %s.", p_ptr->died_from);
6595
6596                 center_string(buf, tmp);
6597                 put_str(buf, 15, 11);
6598 #endif
6599
6600
6601
6602                 (void)sprintf(tmp, "%-.24s", ctime(&ct));
6603                 center_string(buf, tmp);
6604                 put_str(buf, 17, 11);
6605
6606 #ifdef JP
6607 msg_format("¤µ¤è¤¦¤Ê¤é¡¢%s!", player_name);
6608 #else
6609                 msg_format("Goodbye, %s!", player_name);
6610 #endif
6611
6612         }
6613 }
6614
6615
6616 /*
6617  * Display some character info
6618  */
6619 static void show_info(void)
6620 {
6621         int             i, j, k, l;
6622         object_type             *o_ptr;
6623         store_type              *st_ptr;
6624
6625         /* Hack -- Know everything in the inven/equip */
6626         for (i = 0; i < INVEN_TOTAL; i++)
6627         {
6628                 o_ptr = &inventory[i];
6629
6630                 /* Skip non-objects */
6631                 if (!o_ptr->k_idx) continue;
6632
6633                 /* Aware and Known */
6634                 object_aware(o_ptr);
6635                 object_known(o_ptr);
6636         }
6637
6638         for (i = 1; i < max_towns; i++)
6639         {
6640                 st_ptr = &town[i].store[STORE_HOME];
6641
6642                 /* Hack -- Know everything in the home */
6643                 for (j = 0; j < st_ptr->stock_num; j++)
6644                 {
6645                         o_ptr = &st_ptr->stock[j];
6646
6647                         /* Skip non-objects */
6648                         if (!o_ptr->k_idx) continue;
6649
6650                         /* Aware and Known */
6651                         object_aware(o_ptr);
6652                         object_known(o_ptr);
6653                 }
6654         }
6655
6656         /* Hack -- Recalculate bonuses */
6657         p_ptr->update |= (PU_BONUS);
6658
6659         /* Handle stuff */
6660         handle_stuff();
6661
6662         /* Flush all input keys */
6663         flush();
6664
6665         /* Flush messages */
6666         msg_print(NULL);
6667
6668
6669         /* Describe options */
6670 #ifdef JP
6671 prt("¥¥ã¥é¥¯¥¿¡¼¤ÎµÏ¿¤ò¥Õ¥¡¥¤¥ë¤Ë½ñ¤½Ð¤¹¤³¤È¤¬¤Ç¤¤Þ¤¹¡£", 21, 0);
6672 prt("¥ê¥¿¡¼¥ó¥¡¼¤Ç¥¥ã¥é¥¯¥¿¡¼¤ò¸«¤Þ¤¹¡£ESC¤ÇÃæÃÇ¤·¤Þ¤¹¡£", 22, 0);
6673 #else
6674         prt("You may now dump a character record to one or more files.", 21, 0);
6675         prt("Then, hit RETURN to see the character, or ESC to abort.", 22, 0);
6676 #endif
6677
6678
6679         /* Dump character records as requested */
6680         while (TRUE)
6681         {
6682                 char out_val[160];
6683
6684                 /* Prompt */
6685 #ifdef JP
6686 put_str("¥Õ¥¡¥¤¥ë¥Í¡¼¥à: ", 23, 0);
6687 #else
6688                 put_str("Filename: ", 23, 0);
6689 #endif
6690
6691
6692                 /* Default */
6693                 strcpy(out_val, "");
6694
6695                 /* Ask for filename (or abort) */
6696                 if (!askfor_aux(out_val, 60)) return;
6697
6698                 /* Return means "show on screen" */
6699                 if (!out_val[0]) break;
6700
6701                 /* Save screen */
6702                 screen_save();
6703
6704                 /* Dump a character file */
6705                 (void)file_character(out_val);
6706
6707                 /* Load screen */
6708                 screen_load();
6709         }
6710
6711         update_playtime();
6712
6713         /* Display player */
6714         display_player(0);
6715
6716         /* Prompt for inventory */
6717 #ifdef JP
6718 prt("²¿¤«¥¡¼¤ò²¡¤¹¤È¤µ¤é¤Ë¾ðÊó¤¬Â³¤¤Þ¤¹ (ESC¤ÇÃæÃÇ): ", 23, 0);
6719 #else
6720         prt("Hit any key to see more information (ESC to abort): ", 23, 0);
6721 #endif
6722
6723
6724         /* Allow abort at this point */
6725         if (inkey() == ESCAPE) return;
6726
6727
6728         /* Show equipment and inventory */
6729
6730         /* Equipment -- if any */
6731         if (equip_cnt)
6732         {
6733                 Term_clear();
6734                 item_tester_full = TRUE;
6735                 (void)show_equip(0);
6736 #ifdef JP
6737 prt("ÁõÈ÷¤·¤Æ¤¤¤¿¥¢¥¤¥Æ¥à: -Â³¤¯-", 0, 0);
6738 #else
6739                 prt("You are using: -more-", 0, 0);
6740 #endif
6741
6742                 if (inkey() == ESCAPE) return;
6743         }
6744
6745         /* Inventory -- if any */
6746         if (inven_cnt)
6747         {
6748                 Term_clear();
6749                 item_tester_full = TRUE;
6750                 (void)show_inven(0);
6751 #ifdef JP
6752 prt("»ý¤Ã¤Æ¤¤¤¿¥¢¥¤¥Æ¥à: -Â³¤¯-", 0, 0);
6753 #else
6754                 prt("You are carrying: -more-", 0, 0);
6755 #endif
6756
6757                 if (inkey() == ESCAPE) return;
6758         }
6759
6760         /* Homes in the different towns */
6761         for (l = 1; l < max_towns; l++)
6762         {
6763                 st_ptr = &town[l].store[STORE_HOME];
6764
6765                 /* Home -- if anything there */
6766                 if (st_ptr->stock_num)
6767                 {
6768                         /* Display contents of the home */
6769                         for (k = 0, i = 0; i < st_ptr->stock_num; k++)
6770                         {
6771                                 /* Clear screen */
6772                                 Term_clear();
6773
6774                                 /* Show 12 items */
6775                                 for (j = 0; (j < 12) && (i < st_ptr->stock_num); j++, i++)
6776                                 {
6777                                         char o_name[MAX_NLEN];
6778                                         char tmp_val[80];
6779
6780                                         /* Acquire item */
6781                                         o_ptr = &st_ptr->stock[i];
6782
6783                                         /* Print header, clear line */
6784                                         sprintf(tmp_val, "%c) ", I2A(j));
6785                                         prt(tmp_val, j+2, 4);
6786
6787                                         /* Display object description */
6788                                         object_desc(o_name, o_ptr, TRUE, 3);
6789                                         c_put_str(tval_to_attr[o_ptr->tval], o_name, j+2, 7);
6790                                 }
6791
6792                                 /* Caption */
6793 #ifdef JP
6794 prt(format("²æ¤¬²È¤ËÃÖ¤¤¤Æ¤¢¤Ã¤¿¥¢¥¤¥Æ¥à ( %d ¥Ú¡¼¥¸): -Â³¤¯-", k+1), 0, 0);
6795 #else
6796                                 prt(format("Your home contains (page %d): -more-", k+1), 0, 0);
6797 #endif
6798
6799
6800                                 /* Wait for it */
6801                                 if (inkey() == ESCAPE) return;
6802                         }
6803                 }
6804         }
6805 }
6806
6807
6808 static bool check_score(void)
6809 {
6810         /* Clear screen */
6811         Term_clear();
6812
6813         /* No score file */
6814         if (highscore_fd < 0)
6815         {
6816 #ifdef JP
6817 msg_print("¥¹¥³¥¢¡¦¥Õ¥¡¥¤¥ë¤¬»ÈÍÑ¤Ç¤¤Þ¤»¤ó¡£");
6818 #else
6819                 msg_print("Score file unavailable.");
6820 #endif
6821
6822                 msg_print(NULL);
6823                 return FALSE;
6824         }
6825
6826 #ifndef SCORE_WIZARDS
6827         /* Wizard-mode pre-empts scoring */
6828         if (p_ptr->noscore & 0x000F)
6829         {
6830 #ifdef JP
6831 msg_print("¥¦¥£¥¶¡¼¥É¡¦¥â¡¼¥É¤Ç¤Ï¥¹¥³¥¢¤¬µÏ¿¤µ¤ì¤Þ¤»¤ó¡£");
6832 #else
6833                 msg_print("Score not registered for wizards.");
6834 #endif
6835
6836                 msg_print(NULL);
6837                 return FALSE;
6838         }
6839 #endif
6840
6841 #ifndef SCORE_BORGS
6842         /* Borg-mode pre-empts scoring */
6843         if (p_ptr->noscore & 0x00F0)
6844         {
6845 #ifdef JP
6846 msg_print("¥Ü¡¼¥°¡¦¥â¡¼¥É¤Ç¤Ï¥¹¥³¥¢¤¬µÏ¿¤µ¤ì¤Þ¤»¤ó¡£");
6847 #else
6848                 msg_print("Score not registered for borgs.");
6849 #endif
6850
6851                 msg_print(NULL);
6852                 return FALSE;
6853         }
6854 #endif
6855
6856 #ifndef SCORE_CHEATERS
6857         /* Cheaters are not scored */
6858         if (p_ptr->noscore & 0xFF00)
6859         {
6860 #ifdef JP
6861 msg_print("º¾µ½¤ò¤ä¤Ã¤¿¿Í¤Ï¥¹¥³¥¢¤¬µÏ¿¤µ¤ì¤Þ¤»¤ó¡£");
6862 #else
6863                 msg_print("Score not registered for cheaters.");
6864 #endif
6865
6866                 msg_print(NULL);
6867                 return FALSE;
6868         }
6869 #endif
6870
6871         /* Interupted */
6872 #ifdef JP
6873 if (!p_ptr->total_winner && streq(p_ptr->died_from, "¶¯À©½ªÎ»"))
6874 #else
6875         if (!p_ptr->total_winner && streq(p_ptr->died_from, "Interrupting"))
6876 #endif
6877
6878         {
6879 #ifdef JP
6880 msg_print("¶¯À©½ªÎ»¤Î¤¿¤á¥¹¥³¥¢¤¬µÏ¿¤µ¤ì¤Þ¤»¤ó¡£");
6881 #else
6882                 msg_print("Score not registered due to interruption.");
6883 #endif
6884
6885                 msg_print(NULL);
6886                 return FALSE;
6887         }
6888
6889         /* Quitter */
6890 #ifdef JP
6891 if (!p_ptr->total_winner && streq(p_ptr->died_from, "ÅÓÃæ½ªÎ»"))
6892 #else
6893         if (!p_ptr->total_winner && streq(p_ptr->died_from, "Quitting"))
6894 #endif
6895
6896         {
6897 #ifdef JP
6898 msg_print("ÅÓÃæ½ªÎ»¤Î¤¿¤á¥¹¥³¥¢¤¬µÏ¿¤µ¤ì¤Þ¤»¤ó¡£");
6899 #else
6900                 msg_print("Score not registered due to quitting.");
6901 #endif
6902
6903                 msg_print(NULL);
6904                 return FALSE;
6905         }
6906         return TRUE;
6907 }
6908
6909 /*
6910  * Close up the current game (player may or may not be dead)
6911  *
6912  * This function is called only from "main.c" and "signals.c".
6913  */
6914 void close_game(void)
6915 {
6916         char buf[1024];
6917         bool do_send = TRUE;
6918
6919 /*      cptr p = "[i:¥¥ã¥é¥¯¥¿¤Î¾ðÊó, f:¥Õ¥¡¥¤¥ë½ñ¤½Ð¤·, t:¥¹¥³¥¢, x:*´ÕÄê*, ESC:¥²¡¼¥à½ªÎ»]"; */
6920
6921         /* Handle stuff */
6922         handle_stuff();
6923
6924         /* Flush the messages */
6925         msg_print(NULL);
6926
6927         /* Flush the input */
6928         flush();
6929
6930
6931         /* No suspending now */
6932         signals_ignore_tstp();
6933
6934
6935         /* Hack -- Character is now "icky" */
6936         character_icky = TRUE;
6937
6938
6939         /* Build the filename */
6940         path_build(buf, sizeof(buf), ANGBAND_DIR_APEX, "scores.raw");
6941
6942         /* Grab permissions */
6943         safe_setuid_grab();
6944
6945         /* Open the high score file, for reading/writing */
6946         highscore_fd = fd_open(buf, O_RDWR);
6947
6948         /* Drop permissions */
6949         safe_setuid_drop();
6950
6951         /* Handle death */
6952         if (p_ptr->is_dead)
6953         {
6954                 /* Handle retirement */
6955                 if (p_ptr->total_winner) kingly();
6956
6957                 /* Save memories */
6958 #ifdef JP
6959                 if (!cheat_save || get_check("»à¤ó¤À¥Ç¡¼¥¿¤ò¥»¡¼¥Ö¤·¤Þ¤¹¤«¡© "))
6960 #else
6961                 if (!cheat_save || get_check("Save death? "))
6962 #endif
6963                 {
6964
6965 #ifdef JP
6966 if (!save_player()) msg_print("¥»¡¼¥Ö¼ºÇÔ¡ª");
6967 #else
6968                         if (!save_player()) msg_print("death save failed!");
6969 #endif
6970                 }
6971                 else do_send = FALSE;
6972
6973                 /* You are dead */
6974                 print_tomb();
6975
6976                 flush();
6977
6978                 /* Show more info */
6979                 show_info();
6980
6981                 /* Clear screen */
6982                 Term_clear();
6983
6984                 if (check_score())
6985                 {
6986                         if ((!send_world_score(do_send)))
6987                         {
6988 #ifdef JP
6989                                 if (get_check_strict("¸å¤Ç¥¹¥³¥¢¤òÅÐÏ¿¤¹¤ë¤¿¤á¤ËÂÔµ¡¤·¤Þ¤¹¤«¡©", (CHECK_NO_ESCAPE | CHECK_NO_HISTORY)))
6990 #else
6991                                 if (get_check_strict("Stand by for later score registration? ", (CHECK_NO_ESCAPE | CHECK_NO_HISTORY)))
6992 #endif
6993                                 {
6994                                         p_ptr->wait_report_score = TRUE;
6995                                         p_ptr->is_dead = FALSE;
6996 #ifdef JP
6997                                         if (!save_player()) msg_print("¥»¡¼¥Ö¼ºÇÔ¡ª");
6998 #else
6999                                         if (!save_player()) msg_print("death save failed!");
7000 #endif
7001                                 }
7002                         }
7003                         if (!p_ptr->wait_report_score)
7004                                 (void)top_twenty();
7005                 }
7006                 else if (highscore_fd >= 0)
7007                 {
7008                         display_scores_aux(0, 10, -1, NULL);
7009                 }
7010 #if 0
7011                 /* Dump bones file */
7012                 make_bones();
7013 #endif
7014         }
7015
7016         /* Still alive */
7017         else
7018         {
7019                 /* Save the game */
7020                 do_cmd_save_game(FALSE);
7021
7022                 /* Prompt for scores XXX XXX XXX */
7023 #ifdef JP
7024 prt("¥ê¥¿¡¼¥ó¥¡¼¤« ESC ¥¡¼¤ò²¡¤·¤Æ²¼¤µ¤¤¡£", 0, 40);
7025 #else
7026                 prt("Press Return (or Escape).", 0, 40);
7027 #endif
7028
7029
7030                 /* Predict score (or ESCAPE) */
7031                 if (inkey() != ESCAPE) predict_score();
7032         }
7033
7034
7035         /* Shut the high score file */
7036         (void)fd_close(highscore_fd);
7037
7038         /* Forget the high score fd */
7039         highscore_fd = -1;
7040
7041         /* Kill all temporal files */
7042         clear_saved_floor_files();
7043
7044         /* Allow suspending now */
7045         signals_handle_tstp();
7046 }
7047
7048
7049 /*
7050  * Handle abrupt death of the visual system
7051  *
7052  * This routine is called only in very rare situations, and only
7053  * by certain visual systems, when they experience fatal errors.
7054  *
7055  * XXX XXX Hack -- clear the death flag when creating a HANGUP
7056  * save file so that player can see tombstone when restart.
7057  */
7058 void exit_game_panic(void)
7059 {
7060         /* If nothing important has happened, just quit */
7061 #ifdef JP
7062 if (!character_generated || character_saved) quit("¶ÛµÞ»öÂÖ");
7063 #else
7064         if (!character_generated || character_saved) quit("panic");
7065 #endif
7066
7067
7068         /* Mega-Hack -- see "msg_print()" */
7069         msg_flag = FALSE;
7070
7071         /* Clear the top line */
7072         prt("", 0, 0);
7073
7074         /* Hack -- turn off some things */
7075         disturb(1, 0);
7076
7077         /* Mega-Hack -- Delay death */
7078         if (p_ptr->chp < 0) p_ptr->is_dead = FALSE;
7079
7080         /* Hardcode panic save */
7081         p_ptr->panic_save = 1;
7082
7083         /* Forbid suspend */
7084         signals_ignore_tstp();
7085
7086         /* Indicate panic save */
7087 #ifdef JP
7088 (void)strcpy(p_ptr->died_from, "(¶ÛµÞ¥»¡¼¥Ö)");
7089 #else
7090         (void)strcpy(p_ptr->died_from, "(panic save)");
7091 #endif
7092
7093
7094         /* Panic save, or get worried */
7095 #ifdef JP
7096 if (!save_player()) quit("¶ÛµÞ¥»¡¼¥Ö¼ºÇÔ¡ª");
7097 #else
7098         if (!save_player()) quit("panic save failed!");
7099 #endif
7100
7101
7102         /* Successful panic save */
7103 #ifdef JP
7104 quit("¶ÛµÞ¥»¡¼¥ÖÀ®¸ù¡ª");
7105 #else
7106         quit("panic save succeeded!");
7107 #endif
7108
7109 }
7110
7111
7112 /*
7113  * Get a random line from a file
7114  * Based on the monster speech patch by Matt Graham,
7115  */
7116 errr get_rnd_line(cptr file_name, int entry, char *output)
7117 {
7118         FILE    *fp;
7119         char    buf[1024];
7120         int     counter, test;
7121         int     line_num = 0;
7122
7123
7124         /* Build the filename */
7125         path_build(buf, sizeof(buf), ANGBAND_DIR_FILE, file_name);
7126
7127         /* Open the file */
7128         fp = my_fopen(buf, "r");
7129
7130         /* Failed */
7131         if (!fp) return -1;
7132
7133         /* Find the entry of the monster */
7134         while (TRUE)
7135         {
7136                 /* Get a line from the file */
7137                 if (my_fgets(fp, buf, sizeof(buf)) == 0)
7138                 {
7139                         /* Count the lines */
7140                         line_num++;
7141
7142                         /* Look for lines starting with 'N:' */
7143                         if ((buf[0] == 'N') && (buf[1] == ':'))
7144                         {
7145                                 /* Allow default lines */
7146                                 if (buf[2] == '*')
7147                                 {
7148                                         /* Default lines */
7149                                         break;
7150                                 }
7151                                 else if (buf[2] == 'M')
7152                                 {
7153                                         if (r_info[entry].flags1 & RF1_MALE) break;
7154                                 }
7155                                 else if (buf[2] == 'F')
7156                                 {
7157                                         if (r_info[entry].flags1 & RF1_FEMALE) break;
7158                                 }
7159                                 /* Get the monster number */
7160                                 else if (sscanf(&(buf[2]), "%d", &test) != EOF)
7161                                 {
7162                                         /* Is it the right number? */
7163                                         if (test == entry) break;
7164                                 }
7165                                 else
7166                                 {
7167                                         /* Error while converting the number */
7168                                         msg_format("Error in line %d of %s!", line_num, file_name);
7169                                         my_fclose(fp);
7170                                         return -1;
7171                                 }
7172                         }
7173                 }
7174                 else
7175                 {
7176                         /* Reached end of file */
7177                         my_fclose(fp);
7178                         return -1;
7179                 }
7180         }
7181
7182         /* Get the random line */
7183         for (counter = 0; ; counter++)
7184         {
7185                 while (TRUE)
7186                 {
7187                         test = my_fgets(fp, buf, sizeof(buf));
7188
7189                         /* Count the lines */
7190                         /* line_num++; No more needed */
7191
7192                         if (!test)
7193                         {
7194                                 /* Ignore lines starting with 'N:' */
7195                                 if ((buf[0] == 'N') && (buf[1] == ':')) continue;
7196
7197                                 if (buf[0] != '#') break;
7198                         }
7199                         else break;
7200                 }
7201
7202                 /* Abort */
7203                 if (!buf[0]) break;
7204
7205                 /* Copy the line */
7206                 if (one_in_(counter + 1)) strcpy(output, buf);
7207         }
7208
7209         /* Close the file */
7210         my_fclose(fp);
7211
7212         /* Success */
7213         return counter ? 0 : -1;
7214 }
7215
7216
7217 #ifdef JP
7218 errr get_rnd_line_jonly(cptr file_name, int entry, char *output, int count)
7219 {
7220         int  i, j, kanji;
7221         errr result = 1;
7222
7223         for (i = 0; i < count; i++)
7224         {
7225                 result = get_rnd_line(file_name, entry, output);
7226                 if (result) break;
7227                 kanji = 0;
7228                 for (j = 0; output[j]; j++) kanji |= iskanji(output[j]);
7229                 if (kanji) break;
7230         }
7231         return result;
7232 }
7233 #endif
7234
7235 /*
7236  * Process file for auto picker/destroyer.
7237  */
7238 errr process_pickpref_file(cptr name)
7239 {
7240         char buf[1024];
7241
7242         errr err = 0;
7243
7244         /* Build the filename */
7245         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, name);
7246
7247         err = process_pref_file_aux(buf, PREF_TYPE_PICKPREF);
7248
7249         /* Result */
7250         return (err);
7251 }
7252
7253
7254 /*
7255  * Process file for player's history editor.
7256  */
7257 errr process_histpref_file(cptr name)
7258 {
7259         char buf[1024];
7260         errr err = 0;
7261         bool old_character_xtra = character_xtra;
7262
7263         /* Build the filename */
7264         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, name);
7265
7266         /* Hack -- prevent modification birth options in this file */
7267         character_xtra = TRUE;
7268
7269         err = process_pref_file_aux(buf, PREF_TYPE_HISTPREF);
7270
7271         character_xtra = old_character_xtra;
7272
7273         /* Result */
7274         return (err);
7275 }
7276
7277
7278 static errr counts_seek(int fd, u32b where, bool flag)
7279 {
7280         huge seekpoint;
7281         char temp1[128], temp2[128];
7282         u32b zero_header[3] = {0L, 0L, 0L};
7283         int i;
7284
7285 #ifdef SAVEFILE_USE_UID
7286         (void)sprintf(temp1, "%d.%s.%d%d%d", player_uid, savefile_base, p_ptr->pclass, p_ptr->pseikaku, p_ptr->age);
7287 #else
7288         (void)sprintf(temp1, "%s.%d%d%d", savefile_base, p_ptr->pclass, p_ptr->pseikaku, p_ptr->age);
7289 #endif
7290         for (i = 0; temp1[i]; i++)
7291                 temp1[i] ^= (i+1) * 63;
7292
7293         seekpoint = 0;
7294         while (1)
7295         {
7296                 if (fd_seek(fd, seekpoint + 3 * sizeof(u32b)))
7297                         return 1;
7298                 if (fd_read(fd, (char*)(temp2), sizeof(temp2)))
7299                 {
7300                         if (!flag)
7301                                 return 1;
7302                         /* add new name */
7303                         fd_seek(fd, seekpoint);
7304                         fd_write(fd, (char*)zero_header, 3*sizeof(u32b));
7305                         fd_write(fd, (char*)(temp1), sizeof(temp1));
7306                         break;
7307                 }
7308
7309                 if (strcmp(temp1, temp2) == 0)
7310                         break;
7311
7312                 seekpoint += 128 + 3 * sizeof(u32b);
7313         }
7314
7315         return fd_seek(fd, seekpoint + where * sizeof(u32b));
7316 }
7317
7318 u32b counts_read(int where)
7319 {
7320         int fd;
7321         u32b count = 0;
7322         char buf[1024];
7323
7324 #ifdef JP
7325         path_build(buf, sizeof(buf), ANGBAND_DIR_DATA, "z_info_j.raw");
7326 #else
7327         path_build(buf, sizeof(buf), ANGBAND_DIR_DATA, "z_info.raw");
7328 #endif
7329         fd = fd_open(buf, O_RDONLY);
7330
7331         if (counts_seek(fd, where, FALSE) ||
7332             fd_read(fd, (char*)(&count), sizeof(u32b)))
7333                 count = 0;
7334
7335         (void)fd_close(fd);
7336
7337         return count;
7338 }
7339
7340 errr counts_write(int where, u32b count)
7341 {
7342         int fd;
7343         char buf[1024];
7344         errr err;
7345
7346 #ifdef JP
7347         path_build(buf, sizeof(buf), ANGBAND_DIR_DATA, "z_info_j.raw");
7348 #else
7349         path_build(buf, sizeof(buf), ANGBAND_DIR_DATA, "z_info.raw");
7350 #endif
7351
7352         /* Grab permissions */
7353         safe_setuid_grab();
7354
7355         fd = fd_open(buf, O_RDWR);
7356
7357         /* Drop permissions */
7358         safe_setuid_drop();
7359
7360         if (fd < 0)
7361         {
7362                 /* File type is "DATA" */
7363                 FILE_TYPE(FILE_TYPE_DATA);
7364
7365                 /* Grab permissions */
7366                 safe_setuid_grab();
7367
7368                 /* Create a new high score file */
7369                 fd = fd_make(buf, 0644);
7370
7371                 /* Drop permissions */
7372                 safe_setuid_drop();
7373         }
7374
7375         /* Grab permissions */
7376         safe_setuid_grab();
7377
7378         err = fd_lock(fd, F_WRLCK);
7379
7380         /* Drop permissions */
7381         safe_setuid_drop();
7382
7383         if (err) return 1;
7384
7385         counts_seek(fd, where, TRUE);
7386         fd_write(fd, (char*)(&count), sizeof(u32b));
7387
7388         /* Grab permissions */
7389         safe_setuid_grab();
7390
7391         err = fd_lock(fd, F_UNLCK);
7392
7393         /* Drop permissions */
7394         safe_setuid_drop();
7395
7396         if (err) return 1;
7397
7398         (void)fd_close(fd);
7399
7400         return 0;
7401 }
7402
7403
7404 #ifdef HANDLE_SIGNALS
7405
7406
7407 #include <signal.h>
7408
7409
7410 /*
7411  * Handle signals -- suspend
7412  *
7413  * Actually suspend the game, and then resume cleanly
7414  */
7415 static void handle_signal_suspend(int sig)
7416 {
7417         /* Disable handler */
7418         (void)signal(sig, SIG_IGN);
7419
7420 #ifdef SIGSTOP
7421
7422         /* Flush output */
7423         Term_fresh();
7424
7425         /* Suspend the "Term" */
7426         Term_xtra(TERM_XTRA_ALIVE, 0);
7427
7428         /* Suspend ourself */
7429         (void)kill(0, SIGSTOP);
7430
7431         /* Resume the "Term" */
7432         Term_xtra(TERM_XTRA_ALIVE, 1);
7433
7434         /* Redraw the term */
7435         Term_redraw();
7436
7437         /* Flush the term */
7438         Term_fresh();
7439
7440 #endif
7441
7442         /* Restore handler */
7443         (void)signal(sig, handle_signal_suspend);
7444 }
7445
7446
7447 /*
7448  * Handle signals -- simple (interrupt and quit)
7449  *
7450  * This function was causing a *huge* number of problems, so it has
7451  * been simplified greatly.  We keep a global variable which counts
7452  * the number of times the user attempts to kill the process, and
7453  * we commit suicide if the user does this a certain number of times.
7454  *
7455  * We attempt to give "feedback" to the user as he approaches the
7456  * suicide thresh-hold, but without penalizing accidental keypresses.
7457  *
7458  * To prevent messy accidents, we should reset this global variable
7459  * whenever the user enters a keypress, or something like that.
7460  */
7461 static void handle_signal_simple(int sig)
7462 {
7463         /* Disable handler */
7464         (void)signal(sig, SIG_IGN);
7465
7466
7467         /* Nothing to save, just quit */
7468         if (!character_generated || character_saved) quit(NULL);
7469
7470
7471         /* Count the signals */
7472         signal_count++;
7473
7474
7475         /* Terminate dead characters */
7476         if (p_ptr->is_dead)
7477         {
7478                 /* Mark the savefile */
7479 #ifdef JP
7480 (void)strcpy(p_ptr->died_from, "¶¯À©½ªÎ»");
7481 #else
7482                 (void)strcpy(p_ptr->died_from, "Abortion");
7483 #endif
7484
7485                 forget_lite();
7486                 forget_view();
7487                 clear_mon_lite();
7488
7489                 /* Close stuff */
7490                 close_game();
7491
7492                 /* Quit */
7493 #ifdef JP
7494 quit("¶¯À©½ªÎ»");
7495 #else
7496                 quit("interrupt");
7497 #endif
7498
7499         }
7500
7501         /* Allow suicide (after 5) */
7502         else if (signal_count >= 5)
7503         {
7504                 /* Cause of "death" */
7505 #ifdef JP
7506 (void)strcpy(p_ptr->died_from, "¶¯À©½ªÎ»Ãæ");
7507 #else
7508                 (void)strcpy(p_ptr->died_from, "Interrupting");
7509 #endif
7510
7511
7512                 forget_lite();
7513                 forget_view();
7514                 clear_mon_lite();
7515
7516                 /* Stop playing */
7517                 p_ptr->playing = FALSE;
7518
7519                 /* Suicide */
7520                 p_ptr->is_dead = TRUE;
7521
7522                 /* Leaving */
7523                 p_ptr->leaving = TRUE;
7524
7525                 /* Close stuff */
7526                 close_game();
7527
7528                 /* Quit */
7529 #ifdef JP
7530 quit("¶¯À©½ªÎ»");
7531 #else
7532                 quit("interrupt");
7533 #endif
7534
7535         }
7536
7537         /* Give warning (after 4) */
7538         else if (signal_count >= 4)
7539         {
7540                 /* Make a noise */
7541                 Term_xtra(TERM_XTRA_NOISE, 0);
7542
7543                 /* Clear the top line */
7544                 Term_erase(0, 0, 255);
7545
7546                 /* Display the cause */
7547 #ifdef JP
7548 Term_putstr(0, 0, -1, TERM_WHITE, "½ÏÎ¸¤Î¾å¤Î¼«»¦¡ª");
7549 #else
7550                 Term_putstr(0, 0, -1, TERM_WHITE, "Contemplating suicide!");
7551 #endif
7552
7553
7554                 /* Flush */
7555                 Term_fresh();
7556         }
7557
7558         /* Give warning (after 2) */
7559         else if (signal_count >= 2)
7560         {
7561                 /* Make a noise */
7562                 Term_xtra(TERM_XTRA_NOISE, 0);
7563         }
7564
7565         /* Restore handler */
7566         (void)signal(sig, handle_signal_simple);
7567 }
7568
7569
7570 /*
7571  * Handle signal -- abort, kill, etc
7572  */
7573 static void handle_signal_abort(int sig)
7574 {
7575         int wid, hgt, rows;
7576
7577         Term_get_size(&wid, &hgt);
7578         rows = hgt - 4;
7579
7580         /* Disable handler */
7581         (void)signal(sig, SIG_IGN);
7582
7583
7584         /* Nothing to save, just quit */
7585         if (!character_generated || character_saved) quit(NULL);
7586
7587
7588         forget_lite();
7589         forget_view();
7590         clear_mon_lite();
7591
7592         /* Clear the bottom line */
7593         Term_erase(0, hgt - 1, 255);
7594
7595         /* Give a warning */
7596         Term_putstr(0, hgt - 1, -1, TERM_RED,
7597 #ifdef JP
7598 "¶²¤í¤·¤¤¥½¥Õ¥È¤Î¥Ð¥°¤¬Èô¤Ó¤«¤«¤Ã¤Æ¤¤¿¡ª");
7599 #else
7600                     "A gruesome software bug LEAPS out at you!");
7601 #endif
7602
7603
7604         /* Message */
7605 #ifdef JP
7606 Term_putstr(45, hgt - 1, -1, TERM_RED, "¶ÛµÞ¥»¡¼¥Ö...");
7607 #else
7608         Term_putstr(45, hgt - 1, -1, TERM_RED, "Panic save...");
7609 #endif
7610
7611
7612         /* Flush output */
7613         Term_fresh();
7614
7615         /* Panic Save */
7616         p_ptr->panic_save = 1;
7617
7618         /* Panic save */
7619 #ifdef JP
7620 (void)strcpy(p_ptr->died_from, "(¶ÛµÞ¥»¡¼¥Ö)");
7621 #else
7622         (void)strcpy(p_ptr->died_from, "(panic save)");
7623 #endif
7624
7625
7626         /* Forbid suspend */
7627         signals_ignore_tstp();
7628
7629         /* Attempt to save */
7630         if (save_player())
7631         {
7632 #ifdef JP
7633 Term_putstr(45, hgt - 1, -1, TERM_RED, "¶ÛµÞ¥»¡¼¥ÖÀ®¸ù¡ª");
7634 #else
7635                 Term_putstr(45, hgt - 1, -1, TERM_RED, "Panic save succeeded!");
7636 #endif
7637
7638         }
7639
7640         /* Save failed */
7641         else
7642         {
7643 #ifdef JP
7644 Term_putstr(45, hgt - 1, -1, TERM_RED, "¶ÛµÞ¥»¡¼¥Ö¼ºÇÔ¡ª");
7645 #else
7646                 Term_putstr(45, hgt - 1, -1, TERM_RED, "Panic save failed!");
7647 #endif
7648
7649         }
7650
7651         /* Flush output */
7652         Term_fresh();
7653
7654         /* Quit */
7655 #ifdef JP
7656 quit("¥½¥Õ¥È¤Î¥Ð¥°");
7657 #else
7658         quit("software bug");
7659 #endif
7660
7661 }
7662
7663
7664
7665
7666 /*
7667  * Ignore SIGTSTP signals (keyboard suspend)
7668  */
7669 void signals_ignore_tstp(void)
7670 {
7671
7672 #ifdef SIGTSTP
7673         (void)signal(SIGTSTP, SIG_IGN);
7674 #endif
7675
7676 }
7677
7678 /*
7679  * Handle SIGTSTP signals (keyboard suspend)
7680  */
7681 void signals_handle_tstp(void)
7682 {
7683
7684 #ifdef SIGTSTP
7685         (void)signal(SIGTSTP, handle_signal_suspend);
7686 #endif
7687
7688 }
7689
7690
7691 /*
7692  * Prepare to handle the relevant signals
7693  */
7694 void signals_init(void)
7695 {
7696
7697 #ifdef SIGHUP
7698         (void)signal(SIGHUP, SIG_IGN);
7699 #endif
7700
7701
7702 #ifdef SIGTSTP
7703         (void)signal(SIGTSTP, handle_signal_suspend);
7704 #endif
7705
7706
7707 #ifdef SIGINT
7708         (void)signal(SIGINT, handle_signal_simple);
7709 #endif
7710
7711 #ifdef SIGQUIT
7712         (void)signal(SIGQUIT, handle_signal_simple);
7713 #endif
7714
7715
7716 #ifdef SIGFPE
7717         (void)signal(SIGFPE, handle_signal_abort);
7718 #endif
7719
7720 #ifdef SIGILL
7721         (void)signal(SIGILL, handle_signal_abort);
7722 #endif
7723
7724 #ifdef SIGTRAP
7725         (void)signal(SIGTRAP, handle_signal_abort);
7726 #endif
7727
7728 #ifdef SIGIOT
7729         (void)signal(SIGIOT, handle_signal_abort);
7730 #endif
7731
7732 #ifdef SIGKILL
7733         (void)signal(SIGKILL, handle_signal_abort);
7734 #endif
7735
7736 #ifdef SIGBUS
7737         (void)signal(SIGBUS, handle_signal_abort);
7738 #endif
7739
7740 #ifdef SIGSEGV
7741         (void)signal(SIGSEGV, handle_signal_abort);
7742 #endif
7743
7744 #ifdef SIGTERM
7745         (void)signal(SIGTERM, handle_signal_abort);
7746 #endif
7747
7748 #ifdef SIGPIPE
7749         (void)signal(SIGPIPE, handle_signal_abort);
7750 #endif
7751
7752 #ifdef SIGEMT
7753         (void)signal(SIGEMT, handle_signal_abort);
7754 #endif
7755
7756 #ifdef SIGDANGER
7757         (void)signal(SIGDANGER, handle_signal_abort);
7758 #endif
7759
7760 #ifdef SIGSYS
7761         (void)signal(SIGSYS, handle_signal_abort);
7762 #endif
7763
7764 #ifdef SIGXCPU
7765         (void)signal(SIGXCPU, handle_signal_abort);
7766 #endif
7767
7768 #ifdef SIGPWR
7769         (void)signal(SIGPWR, handle_signal_abort);
7770 #endif
7771
7772 }
7773
7774
7775 #else   /* HANDLE_SIGNALS */
7776
7777
7778 /*
7779  * Do nothing
7780  */
7781 void signals_ignore_tstp(void)
7782 {
7783 }
7784
7785 /*
7786  * Do nothing
7787  */
7788 void signals_handle_tstp(void)
7789 {
7790 }
7791
7792 /*
7793  * Do nothing
7794  */
7795 void signals_init(void)
7796 {
7797 }
7798 #endif  /* HANDLE_SIGNALS */