src/files.c

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