summarylogtreecommitdiffstats
path: root/dump-343.diff
diff options
context:
space:
mode:
authoranthraxx2015-06-18 18:01:35 +0200
committeranthraxx2015-06-18 18:01:35 +0200
commit6da4b2d92663c59ff9ab7ccec39b07649db3f2dc (patch)
tree720a671d6d22ba269599142f595e99c28fb19571 /dump-343.diff
downloadaur-nethack-patch.tar.gz
addpkg: nethack-patch 3.4.3-8
Diffstat (limited to 'dump-343.diff')
-rw-r--r--dump-343.diff1993
1 files changed, 1993 insertions, 0 deletions
diff --git a/dump-343.diff b/dump-343.diff
new file mode 100644
index 000000000000..6ada1ec6bd07
--- /dev/null
+++ b/dump-343.diff
@@ -0,0 +1,1993 @@
+Nethack 3.4.3 dump patch, version 1.5
+diff -bNurdX diff_ign.txt nethack-3.4.3/dat/opthelp nethack-3.4.3-dump/dat/opthelp
+--- nethack-3.4.3/dat/opthelp 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/dat/opthelp 2011-08-13 15:12:43.000000000 +0300
+@@ -92,6 +92,9 @@
+ boulder override the default boulder symbol with another default: [`]
+ disclose the types of information you want offered at the end of the
+ game [ni na nv ng nc]
++dumpfile the name of the file where to dump the disclosure information
++ when the game ends (only if the patch has been compiled in)
++ [none]
+ fruit the name of a fruit you enjoy eating [slime mold]
+ (basically a whimsy which NetHack uses from time to time).
+ menustyle user interface for selection of multiple objects:
+diff -bNurdX diff_ign.txt nethack-3.4.3/doc/Guidebook.mn nethack-3.4.3-dump/doc/Guidebook.mn
+--- nethack-3.4.3/doc/Guidebook.mn 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/doc/Guidebook.mn 2011-08-13 15:12:43.000000000 +0300
+@@ -1770,6 +1770,12 @@
+ .lp dogname
+ Name your starting dog (ex. ``dogname:Fang'').
+ Cannot be set with the `O' command.
++.lp dumpfile
++The name of a file where the disclosure information is written when the
++game ends. You may use the macro %n that will be replaced with the name
++of your player character. The game must have write permissions to the
++directory where the file is written. Normally /tmp may be used for unix
++systems.
+ .lp dungeon
+ Set the graphics symbols for displaying the dungeon
+ (default \&``\ |--------||.-|++##.##<><>_|\e\e#{}.}..##\ #}'').
+diff -bNurdX diff_ign.txt nethack-3.4.3/doc/Guidebook.tex nethack-3.4.3-dump/doc/Guidebook.tex
+--- nethack-3.4.3/doc/Guidebook.tex 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/doc/Guidebook.tex 2011-08-13 15:12:43.000000000 +0300
+@@ -2209,6 +2209,13 @@
+ Name your starting dog (ex.\ ``{\tt dogname:Fang}'').
+ Cannot be set with the `{\tt O}' command.
+ %.lp
++\item[\ib{dumpfile}]
++The name of a file where the disclosure information is written when the
++game ends. You may use the macro %n that will be replaced with the name
++of your player character. The game must have write permissions to the
++directory where the file is written. Normally /tmp may be used for unix
++systems.
++%.lp
+ \item[\ib{dungeon}]
+ Set the graphics symbols for displaying the dungeon (default
+ ``\verb& |--------||.-|++##& \verb&.##<><>_|\\#{}.}..## #}&'').
+diff -bNurdX diff_ign.txt nethack-3.4.3/doc/Guidebook.txt nethack-3.4.3-dump/doc/Guidebook.txt
+--- nethack-3.4.3/doc/Guidebook.txt 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/doc/Guidebook.txt 2011-08-13 15:12:43.000000000 +0300
+@@ -2274,6 +2274,13 @@
+ Name your starting dog (ex. ``dogname:Fang''). Cannot be set
+ with the `O' command.
+
++ dumpfile
++ The name of a file where the disclosure information is
++ written when the game ends. You may use the macro %n that
++ will be replaced with the name of your player character.
++ The game must have write permissions to the directory where
++ the file is written. Normally /tmp may be used for unixes.
++
+ dungeon
+ Set the graphics symbols for displaying the dungeon (default
+ `` |--------||.-|++##.##<><>_|\\#{}.}..## #}''). The dungeon
+diff -bNurdX diff_ign.txt nethack-3.4.3/include/config.h nethack-3.4.3-dump/include/config.h
+--- nethack-3.4.3/include/config.h 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/include/config.h 2011-08-13 15:12:43.000000000 +0300
+@@ -350,6 +350,10 @@
+
+ /*#define GOLDOBJ */ /* Gold is kept on obj chains - Helge Hafting */
+ /*#define AUTOPICKUP_EXCEPTIONS */ /* exceptions to autopickup */
++#define DUMP_LOG /* Dump game end information to a file */
++/* #define DUMP_FN "/tmp/%n.nh" */ /* Fixed dumpfile name, if you want
++ * to prevent definition by users */
++#define DUMPMSGS 20 /* Number of latest messages in the dump file */
+
+ /* End of Section 5 */
+
+diff -bNurdX diff_ign.txt nethack-3.4.3/include/decl.h nethack-3.4.3-dump/include/decl.h
+--- nethack-3.4.3/include/decl.h 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/include/decl.h 2011-08-13 15:12:43.000000000 +0300
+@@ -184,6 +184,9 @@
+ E long done_money;
+ #endif
+ E char killer_buf[BUFSZ];
++#ifdef DUMP_LOG
++E char dump_fn[]; /* dumpfile name (dump patch) */
++#endif
+ E const char *configfile;
+ E NEARDATA char plname[PL_NSIZ];
+ E NEARDATA char dogname[];
+diff -bNurdX diff_ign.txt nethack-3.4.3/include/extern.h nethack-3.4.3-dump/include/extern.h
+--- nethack-3.4.3/include/extern.h 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/include/extern.h 2011-08-13 15:13:25.000000000 +0300
+@@ -131,6 +131,10 @@
+ E int FDECL(describe_level, (char *));
+ E const char *FDECL(rank_of, (int,SHORT_P,BOOLEAN_P));
+ E void NDECL(bot);
++#ifdef DUMP_LOG
++E void FDECL(bot1str, (char *));
++E void FDECL(bot2str, (char *));
++#endif
+
+ /* ### cmd.c ### */
+
+@@ -166,6 +170,10 @@
+ E int NDECL(extcmd_via_menu);
+ E void FDECL(enlightenment, (int));
+ E void FDECL(show_conduct, (int));
++#ifdef DUMP_LOG
++E void FDECL(dump_enlightenment, (int));
++E void FDECL(dump_conduct, (int));
++#endif
+ E int FDECL(xytod, (SCHAR_P,SCHAR_P));
+ E void FDECL(dtoxy, (coord *,int));
+ E int FDECL(movecmd, (CHAR_P));
+@@ -281,6 +289,9 @@
+ E void FDECL(row_refresh, (int,int,int));
+ E void NDECL(cls);
+ E void FDECL(flush_screen, (int));
++#ifdef DUMP_LOG
++E void NDECL(dump_screen);
++#endif
+ E int FDECL(back_to_glyph, (XCHAR_P,XCHAR_P));
+ E int FDECL(zapdir_to_glyph, (int,int,int));
+ E int FDECL(glyph_at, (XCHAR_P,XCHAR_P));
+@@ -553,6 +564,10 @@
+ #if !defined(MAKEDEFS_C) && !defined(LEV_LEX_C)
+ E void FDECL(done, (int));
+ E void FDECL(container_contents, (struct obj *,BOOLEAN_P,BOOLEAN_P));
++#ifdef DUMP_LOG
++E void FDECL(dump, (char *, char *));
++E void FDECL(do_containerconts, (struct obj *,BOOLEAN_P,BOOLEAN_P,BOOLEAN_P,BOOLEAN_P));
++#endif
+ E void FDECL(terminate, (int));
+ E int NDECL(num_genocides);
+
+@@ -745,6 +760,7 @@
+ E char *FDECL(yymmdd, (time_t));
+ #endif
+ E long FDECL(yyyymmdd, (time_t));
++E struct tm *getlt();
+ E int NDECL(phase_of_the_moon);
+ E boolean NDECL(friday_13th);
+ E int NDECL(night);
+@@ -790,6 +806,9 @@
+ E char *FDECL(xprname, (struct obj *,const char *,CHAR_P,BOOLEAN_P,long,long));
+ E int NDECL(ddoinv);
+ E char FDECL(display_inventory, (const char *,BOOLEAN_P));
++#ifdef DUMP_LOG
++E char FDECL(dump_inventory, (const char *,BOOLEAN_P,BOOLEAN_P));
++#endif
+ E int FDECL(display_binventory, (int,int,BOOLEAN_P));
+ E struct obj *FDECL(display_cinventory,(struct obj *));
+ E struct obj *FDECL(display_minventory,(struct monst *,int,char *));
+@@ -2237,6 +2256,9 @@
+ E int NDECL(abon);
+ E int NDECL(dbon);
+ E int NDECL(enhance_weapon_skill);
++#ifdef DUMP_LOG
++E void NDECL(dump_weapon_skill);
++#endif
+ E void FDECL(unrestrict_weapon_skill, (int));
+ E void FDECL(use_skill, (int,int));
+ E void FDECL(add_weapon_skill, (int));
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/botl.c nethack-3.4.3-dump/src/botl.c
+--- nethack-3.4.3/src/botl.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/botl.c 2011-08-13 15:12:43.000000000 +0300
+@@ -165,10 +165,16 @@
+ }
+ #endif
+
++#ifdef DUMP_LOG
++void bot1str(char *newbot1)
++#else
+ STATIC_OVL void
+ bot1()
++#endif
+ {
++#ifndef DUMP_LOG
+ char newbot1[MAXCO];
++#endif
+ register char *nb;
+ register int i,j;
+
+@@ -215,6 +221,15 @@
+ if (flags.showscore)
+ Sprintf(nb = eos(nb), " S:%ld", botl_score());
+ #endif
++#ifdef DUMP_LOG
++}
++STATIC_OVL void
++bot1()
++{
++ char newbot1[MAXCO];
++
++ bot1str(newbot1);
++#endif
+ curs(WIN_STATUS, 1, 0);
+ putstr(WIN_STATUS, 0, newbot1);
+ }
+@@ -242,10 +257,17 @@
+ return ret;
+ }
+
++#ifdef DUMP_LOG
++void bot2str(newbot2)
++char* newbot2;
++#else
+ STATIC_OVL void
+ bot2()
++#endif
+ {
++#ifndef DUMP_LOG
+ char newbot2[MAXCO];
++#endif
+ register char *nb;
+ int hp, hpmax;
+ int cap = near_capacity();
+@@ -292,6 +314,14 @@
+ if(Slimed) Sprintf(nb = eos(nb), " Slime");
+ if(cap > UNENCUMBERED)
+ Sprintf(nb = eos(nb), " %s", enc_stat[cap]);
++#ifdef DUMP_LOG
++}
++STATIC_OVL void
++bot2()
++{
++ char newbot2[MAXCO];
++ bot2str(newbot2);
++#endif
+ curs(WIN_STATUS, 1, 1);
+ putstr(WIN_STATUS, 0, newbot2);
+ }
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/cmd.c nethack-3.4.3-dump/src/cmd.c
+--- nethack-3.4.3/src/cmd.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/cmd.c 2011-08-13 15:12:43.000000000 +0300
+@@ -1126,6 +1126,305 @@
+ return;
+ }
+
++#ifdef DUMP_LOG
++void
++dump_enlightenment(final)
++int final;
++{
++ int ltmp;
++ char buf[BUFSZ];
++ char buf2[BUFSZ];
++ const char *enc_stat[] = { /* copied from botl.c */
++ "",
++ "burdened",
++ "stressed",
++ "strained",
++ "overtaxed",
++ "overloaded"
++ };
++ char *youwere = " You were ";
++ char *youhave = " You have ";
++ char *youhad = " You had ";
++ char *youcould = " You could ";
++
++ dump("", "Final attributes");
++
++#ifdef ELBERETH
++ if (u.uevent.uhand_of_elbereth) {
++ static const char * const hofe_titles[3] = {
++ "the Hand of Elbereth",
++ "the Envoy of Balance",
++ "the Glory of Arioch"
++ };
++ dump(youwere,
++ (char *)hofe_titles[u.uevent.uhand_of_elbereth - 1]);
++ }
++#endif
++
++ if (u.ualign.record >= 20)
++ dump(youwere, "piously aligned");
++ else if (u.ualign.record > 13)
++ dump(youwere, "devoutly aligned");
++ else if (u.ualign.record > 8)
++ dump(youwere, "fervently aligned");
++ else if (u.ualign.record > 3)
++ dump(youwere, "stridently aligned");
++ else if (u.ualign.record == 3)
++ dump(youwere, "aligned");
++ else if (u.ualign.record > 0)
++ dump(youwere, "haltingly aligned");
++ else if (u.ualign.record == 0)
++ dump(youwere, "nominally aligned");
++ else if (u.ualign.record >= -3) dump(youhave, "strayed");
++ else if (u.ualign.record >= -8) dump(youhave, "sinned");
++ else dump(" You have ", "transgressed");
++ Sprintf(buf, " %d", u.ualign.record);
++ dump(" Your alignment was ", buf);
++
++
++ /*** Resistances to troubles ***/
++ if (Fire_resistance) dump(youwere, "fire resistant");
++ if (Cold_resistance) dump(youwere, "cold resistant");
++ if (Sleep_resistance) dump(youwere, "sleep resistant");
++ if (Disint_resistance) dump(youwere, "disintegration-resistant");
++ if (Shock_resistance) dump(youwere, "shock resistant");
++ if (Poison_resistance) dump(youwere, "poison resistant");
++ if (Drain_resistance) dump(youwere, "level-drain resistant");
++ if (Sick_resistance) dump(youwere, "immune to sickness");
++ if (Antimagic) dump(youwere, "magic-protected");
++ if (Acid_resistance) dump(youwere, "acid resistant");
++ if (Stone_resistance) dump(youwere, "petrification resistant");
++ if (Invulnerable) dump(youwere, "invulnerable");
++ if (u.uedibility) dump(youcould, "recognize detrimental food");
++
++ /*** Troubles ***/
++ if (Halluc_resistance) dump(" ", "You resisted hallucinations");
++ if (Hallucination) dump(youwere, "hallucinating");
++ if (Stunned) dump(youwere, "stunned");
++ if (Confusion) dump(youwere, "confused");
++ if (Blinded) dump(youwere, "blinded");
++ if (Sick) {
++ if (u.usick_type & SICK_VOMITABLE)
++ dump(youwere, "sick from food poisoning");
++ if (u.usick_type & SICK_NONVOMITABLE)
++ dump(youwere, "sick from illness");
++ }
++ if (Stoned) dump(youwere, "turning to stone");
++ if (Slimed) dump(youwere, "turning into slime");
++ if (Strangled)
++ dump(youwere, (u.uburied) ? "buried" : "being strangled");
++ if (Glib) {
++ Sprintf(buf, "slippery %s", makeplural(body_part(FINGER)));
++ dump(youhad, buf);
++ }
++ if (Fumbling) dump(" ", "You fumbled");
++ if (Wounded_legs
++#ifdef STEED
++ && !u.usteed
++#endif
++ ) {
++ Sprintf(buf, "wounded %s", makeplural(body_part(LEG)));
++ dump(youhad, buf);
++ }
++#ifdef STEED
++ if (Wounded_legs && u.usteed) {
++ Strcpy(buf, x_monnam(u.usteed, ARTICLE_YOUR, (char *)0,
++ SUPPRESS_SADDLE | SUPPRESS_HALLUCINATION, FALSE));
++ *buf = highc(*buf);
++ Strcat(buf, " had wounded legs");
++ dump(" ", buf);
++ }
++#endif
++ if (Sleeping) dump(" ", "You fell asleep");
++ if (Hunger) dump(" ", "You hungered rapidly");
++
++ /*** Vision and senses ***/
++ if (See_invisible) dump(" ", "You saw invisible");
++ if (Blind_telepat) dump(youwere, "telepathic");
++ if (Warning) dump(youwere, "warned");
++ if (Warn_of_mon && flags.warntype) {
++ Sprintf(buf, "aware of the presence of %s",
++ (flags.warntype & M2_ORC) ? "orcs" :
++ (flags.warntype & M2_DEMON) ? "demons" :
++ something);
++ dump(youwere, buf);
++ }
++ if (Undead_warning) dump(youwere, "warned of undead");
++ if (Searching) dump(youhad, "automatic searching");
++ if (Clairvoyant) dump(youwere, "clairvoyant");
++ if (Infravision) dump(youhad, "infravision");
++ if (Detect_monsters)
++ dump(youwere, "sensing the presence of monsters");
++ if (u.umconf) dump(youwere, "going to confuse monsters");
++
++ /*** Appearance and behavior ***/
++ if (Adornment) {
++ int adorn = 0;
++ if(uleft && uleft->otyp == RIN_ADORNMENT) adorn += uleft->spe;
++ if(uright && uright->otyp == RIN_ADORNMENT) adorn += uright->spe;
++ if (adorn < 0)
++ dump(youwere, "poorly adorned");
++ else
++ dump(youwere, "adorned");
++ }
++ if (Invisible) dump(youwere, "invisible");
++ else if (Invis) dump(youwere, "invisible to others");
++ /* ordinarily "visible" is redundant; this is a special case for
++ the situation when invisibility would be an expected attribute */
++ else if ((HInvis || EInvis || pm_invisible(youmonst.data)) && BInvis)
++ dump(youwere, "visible");
++ if (Displaced) dump(youwere, "displaced");
++ if (Stealth) dump(youwere, "stealthy");
++ if (Aggravate_monster) dump(" ", "You aggravated monsters");
++ if (Conflict) dump(" ", "You caused conflict");
++
++ /*** Transportation ***/
++ if (Jumping) dump(youcould, "jump");
++ if (Teleportation) dump(youcould, "teleport");
++ if (Teleport_control) dump(youhad, "teleport control");
++ if (Lev_at_will) dump(youwere, "levitating, at will");
++ else if (Levitation)
++ dump(youwere, "levitating"); /* without control */
++ else if (Flying) dump(youcould, "fly");
++ if (Wwalking) dump(youcould, "walk on water");
++ if (Swimming) dump(youcould, "swim");
++ if (Breathless) dump(youcould, "survive without air");
++ else if (Amphibious) dump(youcould, "breathe water");
++ if (Passes_walls) dump(youcould, "walk through walls");
++#ifdef STEED
++ if (u.usteed && (final < 2 || strcmp(killer, "riding accident"))) {
++ Sprintf(buf, "riding %s", y_monnam(u.usteed));
++ dump(youwere, buf);
++ }
++#endif
++ if (u.uswallow) {
++ Sprintf(buf, "swallowed by %s", a_monnam(u.ustuck));
++#ifdef WIZARD
++ if (wizard) Sprintf(eos(buf), " (%u)", u.uswldtim);
++#endif
++ dump(youwere, buf);
++ } else if (u.ustuck) {
++ Sprintf(buf, "%s %s",
++ (Upolyd && sticks(youmonst.data)) ? "holding" : "held by",
++ a_monnam(u.ustuck));
++ dump(youwere, buf);
++ }
++
++ /*** Physical attributes ***/
++ if (u.uhitinc)
++ dump(youhad,
++ enlght_combatinc("to hit", u.uhitinc, final, buf));
++ if (u.udaminc)
++ dump(youhad,
++ enlght_combatinc("damage", u.udaminc, final, buf));
++ if (Slow_digestion) dump(youhad, "slower digestion");
++ if (Regeneration) dump(" ", "You regenerated");
++ if (u.uspellprot || Protection) {
++ int prot = 0;
++
++ if(uleft && uleft->otyp == RIN_PROTECTION) prot += uleft->spe;
++ if(uright && uright->otyp == RIN_PROTECTION) prot += uright->spe;
++ if (HProtection & INTRINSIC) prot += u.ublessed;
++ prot += u.uspellprot;
++
++ if (prot < 0)
++ dump(youwere, "ineffectively protected");
++ else
++ dump(youwere, "protected");
++ }
++ if (Protection_from_shape_changers)
++ dump(youwere, "protected from shape changers");
++ if (Polymorph) dump(youwere, "polymorphing");
++ if (Polymorph_control) dump(youhad, "polymorph control");
++ if (u.ulycn >= LOW_PM) {
++ Strcpy(buf, an(mons[u.ulycn].mname));
++ dump(youwere, buf);
++ }
++ if (Upolyd) {
++ if (u.umonnum == u.ulycn) Strcpy(buf, "in beast form");
++ else Sprintf(buf, "polymorphed into %s",
++ an(youmonst.data->mname));
++#ifdef WIZARD
++ if (wizard) Sprintf(eos(buf), " (%d)", u.mtimedone);
++#endif
++ dump(youwere, buf);
++ }
++ if (Unchanging)
++ dump(youcould, "not change from your current form");
++ if (Fast) dump(youwere, Very_fast ? "very fast" : "fast");
++ if (Reflecting) dump(youhad, "reflection");
++ if (Free_action) dump(youhad, "free action");
++ if (Fixed_abil) dump(youhad, "fixed abilities");
++ if (Lifesaved)
++ dump(" ", "Your life would have been saved");
++ if (u.twoweap) dump(youwere, "wielding two weapons at once");
++
++ /*** Miscellany ***/
++ if (Luck) {
++ ltmp = abs((int)Luck);
++ Sprintf(buf, "%s%slucky (%d)",
++ ltmp >= 10 ? "extremely " : ltmp >= 5 ? "very " : "",
++ Luck < 0 ? "un" : "", Luck);
++ dump(youwere, buf);
++ }
++#ifdef WIZARD
++ else if (wizard) dump(" ", "Your luck was zero");
++#endif
++ if (u.moreluck > 0) dump(youhad, "extra luck");
++ else if (u.moreluck < 0) dump(youhad, "reduced luck");
++ if (carrying(LUCKSTONE) || stone_luck(TRUE)) {
++ ltmp = stone_luck(FALSE);
++ if (ltmp <= 0)
++ dump(" ", "Bad luck did not time out for you");
++ if (ltmp >= 0)
++ dump(" ", "Good luck did not time out for you");
++ }
++
++ if (u.ugangr) {
++ Sprintf(buf, " %sangry with you",
++ u.ugangr > 6 ? "extremely " : u.ugangr > 3 ? "very " : "");
++#ifdef WIZARD
++ if (wizard) Sprintf(eos(buf), " (%d)", u.ugangr);
++#endif
++ Sprintf(buf2, "%s was %s", u_gname(), buf);
++ dump(" ", buf2);
++ }
++
++ {
++ const char *p;
++
++ buf[0] = '\0';
++ if (final < 2) { /* quit/escaped/ascended */
++ p = "survived after being killed ";
++ switch (u.umortality) {
++ case 0: p = "survived"; break;
++ case 1: Strcpy(buf, "once"); break;
++ case 2: Strcpy(buf, "twice"); break;
++ case 3: Strcpy(buf, "thrice"); break;
++ default: Sprintf(buf, "%d times", u.umortality);
++ break;
++ }
++ } else { /* game ended in character's death */
++ p = "are dead";
++ switch (u.umortality) {
++ case 0: impossible("dead without dying?");
++ case 1: break; /* just "are dead" */
++ default: Sprintf(buf, " (%d%s time!)", u.umortality,
++ ordin(u.umortality));
++ break;
++ }
++ }
++ if (p) {
++ Sprintf(buf2, "You %s %s", p, buf);
++ dump(" ", buf2);
++ }
++ }
++ dump("", "");
++ return;
++
++} /* dump_enlightenment */
++#endif
++
+ /*
+ * Courtesy function for non-debug, non-explorer mode players
+ * to help refresh them about who/what they are.
+@@ -1341,6 +1640,99 @@
+ destroy_nhwindow(en_win);
+ }
+
++#ifdef DUMP_LOG
++void
++dump_conduct(final)
++int final;
++{
++ char buf[BUFSZ];
++ int ngenocided;
++
++ dump("", "Voluntary challenges");
++
++ if (!u.uconduct.food)
++ dump("", " You went without food");
++ /* But beverages are okay */
++ else if (!u.uconduct.unvegan)
++ dump("", " You followed a strict vegan diet");
++ else if (!u.uconduct.unvegetarian)
++ dump("", " You were a vegetarian");
++ else if (Role_if(PM_MONK) && u.uconduct.unvegetarian < 10) {
++ sprintf(buf, " You ate non-vegetarian food %ld time%s.",
++ u.uconduct.unvegetarian, plur(u.uconduct.unvegetarian));
++ dump("", buf);
++ }
++
++ if (!u.uconduct.gnostic)
++ dump("", " You were an atheist");
++
++ if (!u.uconduct.weaphit)
++ dump("", " You never hit with a wielded weapon");
++ else if (Role_if(PM_MONK) && u.uconduct.weaphit < 10) {
++ Sprintf(buf, " You hit with a wielded weapon %ld time%s",
++ u.uconduct.weaphit, plur(u.uconduct.weaphit));
++ dump("", buf);
++ }
++#ifdef WIZARD
++ else if (wizard) {
++ Sprintf(buf, "hit with a wielded weapon %ld time%s",
++ u.uconduct.weaphit, plur(u.uconduct.weaphit));
++ dump(" You ", buf);
++ }
++#endif
++ if (!u.uconduct.killer)
++ dump("", " You were a pacifist");
++
++ if (!u.uconduct.literate)
++ dump("", " You were illiterate");
++#ifdef WIZARD
++ else if (wizard) {
++ Sprintf(buf, "read items or engraved %ld time%s",
++ u.uconduct.literate, plur(u.uconduct.literate));
++ dump(" You ", buf);
++ }
++#endif
++
++ ngenocided = num_genocides();
++ if (ngenocided == 0) {
++ dump("", " You never genocided any monsters");
++ } else {
++ Sprintf(buf, "genocided %d type%s of monster%s",
++ ngenocided, plur(ngenocided), plur(ngenocided));
++ dump(" You ", buf);
++ }
++
++ if (!u.uconduct.polypiles)
++ dump("", " You never polymorphed an object");
++ else {
++ Sprintf(buf, "polymorphed %ld item%s",
++ u.uconduct.polypiles, plur(u.uconduct.polypiles));
++ dump(" You ", buf);
++ }
++
++ if (!u.uconduct.polyselfs)
++ dump("", " You never changed form");
++ else {
++ Sprintf(buf, "changed form %ld time%s",
++ u.uconduct.polyselfs, plur(u.uconduct.polyselfs));
++ dump(" You ", buf);
++ }
++
++ if (!u.uconduct.wishes)
++ dump("", " You used no wishes");
++ else {
++ Sprintf(buf, "used %ld wish%s",
++ u.uconduct.wishes, (u.uconduct.wishes > 1L) ? "es" : "");
++ dump(" You ", buf);
++
++ if (!u.uconduct.wisharti)
++ dump("", " You did not wish for any artifacts");
++ }
++
++ dump("", "");
++}
++#endif /* DUMP_LOG */
++
+ #endif /* OVLB */
+ #ifdef OVL1
+
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/decl.c nethack-3.4.3-dump/src/decl.c
+--- nethack-3.4.3/src/decl.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/decl.c 2011-08-13 15:12:43.000000000 +0300
+@@ -209,6 +209,15 @@
+
+ NEARDATA struct mvitals mvitals[NUMMONS];
+
++/* originally from end.c */
++#ifdef DUMP_LOG
++#ifdef DUMP_FN
++char dump_fn[] = DUMP_FN;
++#else
++char dump_fn[PL_PSIZ] = DUMMY;
++#endif
++#endif /* DUMP_LOG */
++
+ NEARDATA struct c_color_names c_color_names = {
+ "black", "amber", "golden",
+ "light blue", "red", "green",
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/display.c nethack-3.4.3-dump/src/display.c
+--- nethack-3.4.3/src/display.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/display.c 2011-08-13 15:12:43.000000000 +0300
+@@ -1370,6 +1370,106 @@
+
+ /* ========================================================================= */
+
++#ifdef DUMP_LOG
++/* D: Added to dump screen to output file */
++STATIC_PTR uchar get_glyph_char(glyph)
++int glyph;
++{
++ uchar ch;
++ register int offset;
++
++ if (glyph >= NO_GLYPH)
++ return ' ';
++
++ /*
++ * Map the glyph back to a character.
++ *
++ * Warning: For speed, this makes an assumption on the order of
++ * offsets. The order is set in display.h.
++ */
++ if ((offset = (glyph - GLYPH_WARNING_OFF)) >= 0) { /* a warning flash */
++ ch = def_warnsyms[offset].sym;
++ } else if ((offset = (glyph - GLYPH_SWALLOW_OFF)) >= 0) { /* swallow */
++ /* see swallow_to_glyph() in display.c */
++ ch = (uchar) defsyms[S_sw_tl + (offset & 0x7)].sym;
++ } else if ((offset = (glyph - GLYPH_ZAP_OFF)) >= 0) { /* zap beam */
++ /* see zapdir_to_glyph() in display.c */
++ ch = defsyms[S_vbeam + (offset & 0x3)].sym;
++ } else if ((offset = (glyph - GLYPH_CMAP_OFF)) >= 0) { /* cmap */
++ ch = defsyms[offset].sym;
++ } else if ((offset = (glyph - GLYPH_OBJ_OFF)) >= 0) { /* object */
++ ch = def_oc_syms[(int)objects[offset].oc_class];
++ } else if ((offset = (glyph - GLYPH_RIDDEN_OFF)) >= 0) { /* mon ridden */
++ ch = def_monsyms[(int)mons[offset].mlet];
++ } else if ((offset = (glyph - GLYPH_BODY_OFF)) >= 0) { /* a corpse */
++ ch = def_oc_syms[(int)objects[CORPSE].oc_class];
++ } else if ((offset = (glyph - GLYPH_DETECT_OFF)) >= 0) { /* mon detect */
++ ch = def_monsyms[(int)mons[offset].mlet];
++ } else if ((offset = (glyph - GLYPH_INVIS_OFF)) >= 0) { /* invisible */
++ ch = DEF_INVISIBLE;
++ } else if ((offset = (glyph - GLYPH_PET_OFF)) >= 0) { /* a pet */
++ ch = def_monsyms[(int)mons[offset].mlet];
++ } else { /* a monster */
++ ch = monsyms[(int)mons[glyph].mlet];
++ }
++ return ch;
++}
++
++#ifdef TTY_GRAPHICS
++extern const char * FDECL(compress_str, (const char *));
++#else
++const char*
++compress_str(str) /* copied from win/tty/wintty.c */
++const char *str;
++{
++ static char cbuf[BUFSZ];
++ /* compress in case line too long */
++ if((int)strlen(str) >= 80) {
++ register const char *bp0 = str;
++ register char *bp1 = cbuf;
++
++ do {
++ if(*bp0 != ' ' || bp0[1] != ' ')
++ *bp1++ = *bp0;
++ } while(*bp0++);
++ } else
++ return str;
++ return cbuf;
++}
++#endif /* TTY_GRAPHICS */
++
++/* Take a screen dump */
++void dump_screen()
++{
++ register int x,y;
++ int lastc;
++ /* D: botl.c has a closer approximation to the size, but we'll go with
++ * this */
++ char buf[300], *ptr;
++
++ for (y = 0; y < ROWNO; y++) {
++ lastc = 0;
++ ptr = buf;
++ for (x = 1; x < COLNO; x++) {
++ uchar c = get_glyph_char(gbuf[y][x].glyph);
++ *ptr++ = c;
++ if (c != ' ')
++ lastc = x;
++ }
++ buf[lastc] = '\0';
++ dump("", buf);
++ }
++ dump("", "");
++ bot1str(buf);
++ ptr = (char *) compress_str((const char *) buf);
++ dump("", ptr);
++ bot2str(buf);
++ dump("", buf);
++ dump("", "");
++ dump("", "");
++}
++#endif /* DUMP_LOG */
++
+ /*
+ * back_to_glyph()
+ *
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/end.c nethack-3.4.3-dump/src/end.c
+--- nethack-3.4.3/src/end.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/end.c 2011-08-13 15:13:29.000000000 +0300
+@@ -40,7 +40,15 @@
+ STATIC_DCL void FDECL(artifact_score, (struct obj *,BOOLEAN_P,winid));
+ STATIC_DCL void FDECL(savelife, (int));
+ STATIC_DCL void FDECL(list_vanquished, (CHAR_P,BOOLEAN_P));
++#ifdef DUMP_LOG
++extern char msgs[][BUFSZ];
++extern int lastmsg;
++extern void NDECL(dump_spells);
++void FDECL(do_vanquished, (int, BOOLEAN_P, BOOLEAN_P));
++STATIC_DCL void FDECL(list_genocided, (int, BOOLEAN_P, BOOLEAN_P));
++#else
+ STATIC_DCL void FDECL(list_genocided, (CHAR_P,BOOLEAN_P));
++#endif /* DUMP_LOG */
+ STATIC_DCL boolean FDECL(should_query_disclose_option, (int,char *));
+
+ #if defined(__BEOS__) || defined(MICRO) || defined(WIN32) || defined(OS2)
+@@ -86,6 +94,74 @@
+
+ extern const char * const killed_by_prefix[]; /* from topten.c */
+
++#ifdef DUMP_LOG
++FILE *dump_fp = (FILE *)0; /* file pointer for dumps */
++/* functions dump_init, dump_exit and dump are from the dump patch */
++
++void
++dump_init ()
++{
++ if (dump_fn[0]) {
++ char *actual_fn = dump_fn;
++ char *p = (char *) strstr(dump_fn, "%n");
++ if (p) {
++ int new_dump_fn_len = strlen(dump_fn)+strlen(plname)-2; /* %n */
++ char *new_dump_fn = (char *) alloc((unsigned)(new_dump_fn_len+1));
++ char *q = new_dump_fn;
++ strncpy(q, dump_fn, p-dump_fn);
++ q += p-dump_fn;
++ strncpy(q, plname, strlen(plname) + 1);
++ regularize(q);
++ q[strlen(plname)] = '\0';
++ q += strlen(q);
++ p += 2; /* skip "%n" */
++ strncpy(q, p, strlen(p));
++ new_dump_fn[new_dump_fn_len] = '\0';
++ actual_fn = new_dump_fn;
++ }
++ p = (char*) strstr(actual_fn, "%d");
++ if (p) {
++ int new_len = strlen(actual_fn) + 13; /* date length - "%d" + 1 */
++ char *new_dump_fn = (char *) alloc((unsigned)(new_len));
++ char *q = new_dump_fn;
++ struct tm *lt = getlt();
++ long t = (long)lt->tm_hour * 10000L + (long)lt->tm_min * 100L
++ + (long)lt->tm_sec;
++ strncpy(q, actual_fn, p - actual_fn);
++ q += p - actual_fn;
++ sprintf(q, "%ld%06ld", yyyymmdd(0), t);
++ q += 14;
++ p += 2; /* skip "%d" */
++ strncpy(q, p, strlen(p));
++ q[strlen(p)]='\0';
++ if (actual_fn != dump_fn) free(actual_fn);
++ actual_fn = new_dump_fn;
++ }
++ dump_fp = fopen (actual_fn, "w");
++ if (actual_fn != dump_fn) free(actual_fn);
++
++ if (!dump_fp) {
++ pline("Can't open %s for output.", dump_fn);
++ pline("Dump file not created.");
++ }
++ }
++}
++
++void
++dump_exit ()
++{
++ if (dump_fp)
++ fclose (dump_fp);
++}
++
++void dump (pre, str)
++ char *pre, *str;
++{
++ if (dump_fp)
++ fprintf (dump_fp, "%s%s\n", pre, str);
++}
++#endif /* DUMP_LOG */
++
+ /*ARGSUSED*/
+ void
+ done1(sig_unused) /* called as signal() handler, so sent at least one arg */
+@@ -366,18 +442,30 @@
+ ask = should_query_disclose_option('i', &defquery);
+ if (!done_stopprint) {
+ c = ask ? yn_function(qbuf, ynqchars, defquery) : defquery;
+- if (c == 'y') {
++ } else {
++ c = 'n';
++ }
++ {
++#ifdef DUMP_LOG
++ boolean want_disp = (c == 'y')? TRUE: FALSE;
++#endif
+ struct obj *obj;
+
+ for (obj = invent; obj; obj = obj->nobj) {
+ makeknown(obj->otyp);
+ obj->known = obj->bknown = obj->dknown = obj->rknown = 1;
+ }
++#ifdef DUMP_LOG
++ (void) dump_inventory((char *)0, TRUE, want_disp);
++ do_containerconts(invent, TRUE, TRUE, TRUE, want_disp);
++#else
++ if (c == 'y') {
+ (void) display_inventory((char *)0, TRUE);
+ container_contents(invent, TRUE, TRUE);
+ }
+- if (c == 'q') done_stopprint++;
++#endif /* DUMP_LOG */
+ }
++ if (c == 'q') done_stopprint++;
+ }
+
+ ask = should_query_disclose_option('a', &defquery);
+@@ -388,14 +476,28 @@
+ enlightenment(how >= PANICKED ? 1 : 2); /* final */
+ if (c == 'q') done_stopprint++;
+ }
++#ifdef DUMP_LOG
++ if (dump_fp) {
++ dump_enlightenment((int) (how >= PANICKED ? 1 : 2));
++ dump_spells();
++ }
++#endif
+
+ ask = should_query_disclose_option('v', &defquery);
++#ifdef DUMP_LOG
++ do_vanquished(defquery, ask, TRUE);
++#else
+ if (!done_stopprint)
+ list_vanquished(defquery, ask);
++#endif
+
+ ask = should_query_disclose_option('g', &defquery);
++#ifdef DUMP_LOG
++ list_genocided(defquery, ask,TRUE);
++#else
+ if (!done_stopprint)
+ list_genocided(defquery, ask);
++#endif
+
+ ask = should_query_disclose_option('c', &defquery);
+ if (!done_stopprint) {
+@@ -405,6 +507,12 @@
+ show_conduct(how >= PANICKED ? 1 : 2);
+ if (c == 'q') done_stopprint++;
+ }
++#ifdef DUMP_LOG
++ if (dump_fp) {
++ dump_conduct(how >= PANICKED ? 1 : 2);
++ dump_weapon_skill();
++ }
++#endif
+ }
+
+ /* try to get the player back in a viable state after being killed */
+@@ -523,6 +631,11 @@
+ otmp->oartifact ? artifact_name(xname(otmp), &dummy) :
+ OBJ_NAME(objects[otmp->otyp]),
+ value, currency(value), points);
++#ifdef DUMP_LOG
++ if (dump_fp)
++ dump("", pbuf);
++ if (endwin != WIN_ERR)
++#endif
+ putstr(endwin, 0, pbuf);
+ }
+ }
+@@ -542,6 +655,7 @@
+ boolean bones_ok, have_windows = iflags.window_inited;
+ struct obj *corpse = (struct obj *)0;
+ long umoney;
++ int i;
+
+ if (how == TRICKED) {
+ if (killer) {
+@@ -614,6 +728,36 @@
+ program_state.gameover = 1;
+ /* in case of a subsequent panic(), there's no point trying to save */
+ program_state.something_worth_saving = 0;
++#ifdef DUMP_LOG
++ /* D: Grab screen dump right here */
++ if (dump_fn[0]) {
++ dump_init();
++ Sprintf(pbuf, "%s, %s %s %s %s", plname,
++ aligns[1 - u.ualign.type].adj,
++ genders[flags.female].adj,
++ urace.adj,
++ (flags.female && urole.name.f)?
++ urole.name.f : urole.name.m);
++ dump("", pbuf);
++# ifdef DUMPMSGS
++ if (lastmsg >= 0) {
++ dump ("", "Latest messages");
++ for (i = lastmsg + 1; i < DUMPMSGS; i++) {
++ if (msgs[i] && strcmp(msgs[i], "") )
++ dump (" ", msgs[i]);
++ }
++ for (i = 0; i <= lastmsg; i++) {
++ if (msgs[i] && strcmp(msgs[i], "") )
++ dump (" ", msgs[i]);
++ }
++ dump ("","");
++ }
++# endif /* DUMPMSGS */
++ /* D: Add a line for clearance from the screen dump */
++ dump("", "");
++ dump_screen();
++ }
++#endif /* DUMP_LOG */
+ /* render vision subsystem inoperative */
+ iflags.vision_inited = 0;
+ /* might have been killed while using a disposable item, so make sure
+@@ -692,8 +836,9 @@
+
+ if (have_windows) display_nhwindow(WIN_MESSAGE, FALSE);
+
+- if (strcmp(flags.end_disclose, "none") && how != PANICKED)
++ if (strcmp(flags.end_disclose, "none") && how != PANICKED) {
+ disclose(how, taken);
++ }
+ /* finish_paybill should be called after disclosure but before bones */
+ if (bones_ok && taken) finish_paybill();
+
+@@ -770,15 +915,18 @@
+ /* don't bother counting to see whether it should be plural */
+ }
+
+- if (!done_stopprint) {
+ Sprintf(pbuf, "%s %s the %s...", Goodbye(), plname,
+ how != ASCENDED ?
+ (const char *) ((flags.female && urole.name.f) ?
+ urole.name.f : urole.name.m) :
+ (const char *) (flags.female ? "Demigoddess" : "Demigod"));
++ if (!done_stopprint) {
+ putstr(endwin, 0, pbuf);
+ putstr(endwin, 0, "");
+ }
++#ifdef DUMP_LOG
++ if (dump_fp) dump("", pbuf);
++#endif
+
+ if (how == ESCAPED || how == ASCENDED) {
+ register struct monst *mtmp;
+@@ -805,31 +953,39 @@
+ keepdogs(TRUE);
+ viz_array[0][0] |= IN_SIGHT; /* need visibility for naming */
+ mtmp = mydogs;
+- if (!done_stopprint) Strcpy(pbuf, "You");
++ Strcpy(pbuf, "You");
+ if (mtmp) {
+ while (mtmp) {
+- if (!done_stopprint)
+ Sprintf(eos(pbuf), " and %s", mon_nam(mtmp));
+ if (mtmp->mtame)
+ u.urexp += mtmp->mhp;
+ mtmp = mtmp->nmon;
+ }
+ if (!done_stopprint) putstr(endwin, 0, pbuf);
++#ifdef DUMP_LOG
++ if (dump_fp) dump("", pbuf);
++#endif
+ pbuf[0] = '\0';
+ } else {
+ if (!done_stopprint) Strcat(pbuf, " ");
+ }
+- if (!done_stopprint) {
+ Sprintf(eos(pbuf), "%s with %ld point%s,",
+ how==ASCENDED ? "went to your reward" :
+ "escaped from the dungeon",
+ u.urexp, plur(u.urexp));
++#ifdef DUMP_LOG
++ if (dump_fp) dump("", pbuf);
++#endif
++ if (!done_stopprint) {
+ putstr(endwin, 0, pbuf);
+ }
+
+ if (!done_stopprint)
+ artifact_score(invent, FALSE, endwin); /* list artifacts */
+-
++#ifdef DUMP_LOG
++ else
++ artifact_score(invent, FALSE, WIN_ERR);
++#endif
+ /* list valuables here */
+ for (val = valuables; val->list; val++) {
+ sort_valuables(val->list, val->size);
+@@ -855,10 +1011,13 @@
+ count, plur(count));
+ }
+ putstr(endwin, 0, pbuf);
++#ifdef DUMP_LOG
++ if (dump_fp) dump("", pbuf);
++#endif
+ }
+ }
+
+- } else if (!done_stopprint) {
++ } else {
+ /* did not escape or ascend */
+ if (u.uz.dnum == 0 && u.uz.dlevel <= 0) {
+ /* level teleported out of the dungeon; `how' is DIED,
+@@ -878,21 +1037,32 @@
+
+ Sprintf(eos(pbuf), " with %ld point%s,",
+ u.urexp, plur(u.urexp));
+- putstr(endwin, 0, pbuf);
++ if (!done_stopprint) putstr(endwin, 0, pbuf);
++#ifdef DUMP_LOG
++ if (dump_fp) dump("", pbuf);
++#endif
+ }
+
+- if (!done_stopprint) {
+ Sprintf(pbuf, "and %ld piece%s of gold, after %ld move%s.",
+ umoney, plur(umoney), moves, plur(moves));
+- putstr(endwin, 0, pbuf);
++ if (!done_stopprint) putstr(endwin, 0, pbuf);
++#ifdef DUMP_LOG
++ if (dump_fp) {
++ dump("", pbuf);
++ Sprintf(pbuf, "Killer: %s", killer);
++ dump("", pbuf);
+ }
+- if (!done_stopprint) {
++#endif
+ Sprintf(pbuf,
+ "You were level %d with a maximum of %d hit point%s when you %s.",
+ u.ulevel, u.uhpmax, plur(u.uhpmax), ends[how]);
++ if (!done_stopprint) {
+ putstr(endwin, 0, pbuf);
+ putstr(endwin, 0, "");
+ }
++#ifdef DUMP_LOG
++ if (dump_fp) dump("", pbuf);
++#endif
+ if (!done_stopprint)
+ display_nhwindow(endwin, TRUE);
+ if (endwin != WIN_ERR)
+@@ -909,6 +1079,9 @@
+ exit_nhwindows((char *)0);
+ topten(how);
+ }
++#ifdef DUMP_LOG
++ if (dump_fp) dump_exit();
++#endif
+
+ if(done_stopprint) { raw_print(""); raw_print(""); }
+ terminate(EXIT_SUCCESS);
+@@ -919,6 +1092,16 @@
+ container_contents(list, identified, all_containers)
+ struct obj *list;
+ boolean identified, all_containers;
++#ifdef DUMP_LOG
++{
++ do_containerconts(list, identified, all_containers, FALSE, TRUE);
++}
++
++void do_containerconts(list, identified, all_containers, want_dump, want_disp)
++struct obj *list;
++boolean identified, all_containers, want_dump, want_disp;
++#endif
++/* The original container_contents function */
+ {
+ register struct obj *box, *obj;
+ char buf[BUFSZ];
+@@ -928,25 +1111,62 @@
+ if (box->otyp == BAG_OF_TRICKS) {
+ continue; /* wrong type of container */
+ } else if (box->cobj) {
+- winid tmpwin = create_nhwindow(NHW_MENU);
++ winid tmpwin;
++#ifdef DUMP_LOG
++ if (want_disp)
++#endif
++ tmpwin = create_nhwindow(NHW_MENU);
+ Sprintf(buf, "Contents of %s:", the(xname(box)));
++#ifdef DUMP_LOG
++ if (want_disp) {
++#endif
+ putstr(tmpwin, 0, buf);
+ putstr(tmpwin, 0, "");
++#ifdef DUMP_LOG
++ }
++ if (dump_fp) dump("", buf);
++#endif
+ for (obj = box->cobj; obj; obj = obj->nobj) {
+ if (identified) {
+ makeknown(obj->otyp);
+ obj->known = obj->bknown =
+ obj->dknown = obj->rknown = 1;
+ }
++#ifdef DUMP_LOG
++ if (want_dump) dump(" ", doname(obj));
++ if (want_disp)
++#endif
+ putstr(tmpwin, 0, doname(obj));
+ }
++#ifdef DUMP_LOG
++ if (want_dump) dump("","");
++ if (want_disp) {
++#endif
+ display_nhwindow(tmpwin, TRUE);
+ destroy_nhwindow(tmpwin);
+- if (all_containers)
++#ifdef DUMP_LOG
++ }
++ if (all_containers) {
++ do_containerconts(box->cobj, identified, TRUE,
++ want_dump, want_disp);
++#else
++ if (all_containers) {
+ container_contents(box->cobj, identified, TRUE);
++#endif /* DUMP_LOG */
++ }
+ } else {
++#ifdef DUMP_LOG
++ if (want_disp) {
++#endif
+ pline("%s empty.", Tobjnam(box, "are"));
+ display_nhwindow(WIN_MESSAGE, FALSE);
++#ifdef DUMP_LOG
++ }
++ if (want_dump) {
++ dump(The(xname(box)), " is empty.");
++ dump("", "");
++ }
++#endif
+ }
+ }
+ if (!all_containers)
+@@ -977,6 +1197,17 @@
+ list_vanquished(defquery, ask)
+ char defquery;
+ boolean ask;
++#ifdef DUMP_LOG
++{
++ do_vanquished(defquery, ask, FALSE);
++}
++
++void
++do_vanquished(defquery, ask, want_dump)
++int defquery;
++boolean ask;
++boolean want_dump;
++#endif
+ {
+ register int i, lev;
+ int ntypes = 0, max_lev = 0, nkilled;
+@@ -996,13 +1227,22 @@
+ * includes all dead monsters, not just those killed by the player
+ */
+ if (ntypes != 0) {
+- c = ask ? yn_function("Do you want an account of creatures vanquished?",
++#ifdef DUMP_LOG
++ c = done_stopprint ? 'n': ask ?
++#else
++ c = ask ?
++#endif
++ yn_function("Do you want an account of creatures vanquished?",
+ ynqchars, defquery) : defquery;
+ if (c == 'q') done_stopprint++;
+ if (c == 'y') {
+ klwin = create_nhwindow(NHW_MENU);
+ putstr(klwin, 0, "Vanquished creatures:");
+ putstr(klwin, 0, "");
++#ifdef DUMP_LOG
++ } /* the original end of block removed by the patch */
++ if (want_dump) dump("", "Vanquished creatures");
++#endif
+
+ /* countdown by monster "toughness" */
+ for (lev = max_lev; lev >= 0; lev--)
+@@ -1030,20 +1270,32 @@
+ Sprintf(buf, "%d %s",
+ nkilled, makeplural(mons[i].mname));
+ }
+- putstr(klwin, 0, buf);
++ if (c == 'y') putstr(klwin, 0, buf);
++#ifdef DUMP_LOG
++ if (want_dump) dump(" ", buf);
++#endif
+ }
+ /*
+ * if (Hallucination)
+ * putstr(klwin, 0, "and a partridge in a pear tree");
+ */
+ if (ntypes > 1) {
+- putstr(klwin, 0, "");
++ if (c == 'y') putstr(klwin, 0, "");
+ Sprintf(buf, "%ld creatures vanquished.", total_killed);
+- putstr(klwin, 0, buf);
++ if (c == 'y') putstr(klwin, 0, buf);
++#ifdef DUMP_LOG
++ if (want_dump) dump(" ", buf);
++#endif
+ }
++ if (c == 'y') {
+ display_nhwindow(klwin, TRUE);
+ destroy_nhwindow(klwin);
+ }
++#ifdef DUMP_LOG
++ if (want_dump) dump("", "");
++#else
++ } /* the original end of if (c == 'y') */
++#endif
+ }
+ }
+
+@@ -1059,10 +1311,18 @@
+ return n;
+ }
+
++#ifdef DUMP_LOG
++STATIC_OVL void
++list_genocided(defquery, ask, want_dump)
++int defquery;
++boolean ask;
++boolean want_dump;
++#else
+ STATIC_OVL void
+ list_genocided(defquery, ask)
+ char defquery;
+ boolean ask;
++#endif
+ {
+ register int i;
+ int ngenocided;
+@@ -1079,8 +1339,13 @@
+ if (c == 'q') done_stopprint++;
+ if (c == 'y') {
+ klwin = create_nhwindow(NHW_MENU);
+- putstr(klwin, 0, "Genocided species:");
++ Sprintf(buf, "Genocided species:");
++ putstr(klwin, 0, buf);
+ putstr(klwin, 0, "");
++#ifdef DUMP_LOG
++ }
++ if (want_dump) dump("", "Genocided species");
++#endif
+
+ for (i = LOW_PM; i < NUMMONS; i++)
+ if (mvitals[i].mvflags & G_GENOD) {
+@@ -1090,13 +1355,22 @@
+ mons[i].mname);
+ else
+ Strcpy(buf, makeplural(mons[i].mname));
+- putstr(klwin, 0, buf);
++ if (c == 'y') putstr(klwin, 0, buf);
++#ifdef DUMP_LOG
++ if (want_dump) dump(" ", buf);
++#endif
+ }
+
+- putstr(klwin, 0, "");
++ if (c == 'y') putstr(klwin, 0, "");
+ Sprintf(buf, "%d species genocided.", ngenocided);
+- putstr(klwin, 0, buf);
+-
++ if (c == 'y') putstr(klwin, 0, buf);
++#ifdef DUMP_LOG
++ if (want_dump) {
++ dump(" ", buf);
++ dump("", "");
++ }
++ if (c == 'y') {
++#endif
+ display_nhwindow(klwin, TRUE);
+ destroy_nhwindow(klwin);
+ }
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/hacklib.c nethack-3.4.3-dump/src/hacklib.c
+--- nethack-3.4.3/src/hacklib.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/hacklib.c 2011-08-13 15:13:33.000000000 +0300
+@@ -455,7 +455,7 @@
+ #if defined(AMIGA) && !defined(AZTEC_C) && !defined(__SASC_60) && !defined(_DCC) && !defined(__GNUC__)
+ extern struct tm *FDECL(localtime,(time_t *));
+ #endif
+-static struct tm *NDECL(getlt);
++struct tm *NDECL(getlt);
+
+ void
+ setrandom()
+@@ -485,7 +485,7 @@
+ #endif
+ }
+
+-static struct tm *
++struct tm *
+ getlt()
+ {
+ time_t date;
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/invent.c nethack-3.4.3-dump/src/invent.c
+--- nethack-3.4.3/src/invent.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/invent.c 2011-08-13 15:12:43.000000000 +0300
+@@ -19,7 +19,12 @@
+ STATIC_DCL boolean FDECL(putting_on, (const char *));
+ STATIC_PTR int FDECL(ckunpaid,(struct obj *));
+ STATIC_PTR int FDECL(ckvalidcat,(struct obj *));
++#ifdef DUMP_LOG
++static char FDECL(display_pickinv,
++ (const char *,BOOLEAN_P, long *, BOOLEAN_P, BOOLEAN_P));
++#else
+ static char FDECL(display_pickinv, (const char *,BOOLEAN_P, long *));
++#endif /* DUMP_LOG */
+ #ifdef OVLB
+ STATIC_DCL boolean FDECL(this_type_only, (struct obj *));
+ STATIC_DCL void NDECL(dounpaid);
+@@ -1017,7 +1022,11 @@
+ if (ilet == '?' && !*lets && *altlets)
+ allowed_choices = altlets;
+ ilet = display_pickinv(allowed_choices, TRUE,
+- allowcnt ? &ctmp : (long *)0);
++ allowcnt ? &ctmp : (long *)0
++#ifdef DUMP_LOG
++ , FALSE, TRUE
++#endif
++ );
+ if(!ilet) continue;
+ if (allowcnt && ctmp >= 0) {
+ cnt = ctmp;
+@@ -1689,11 +1698,21 @@
+ * inventory and return a count as well as a letter. If out_cnt is not null,
+ * any count returned from the menu selection is placed here.
+ */
++#ifdef DUMP_LOG
++static char
++display_pickinv(lets, want_reply, out_cnt, want_dump, want_disp)
++register const char *lets;
++boolean want_reply;
++long* out_cnt;
++boolean want_dump;
++boolean want_disp;
++#else
+ static char
+ display_pickinv(lets, want_reply, out_cnt)
+ register const char *lets;
+ boolean want_reply;
+ long* out_cnt;
++#endif
+ {
+ struct obj *otmp;
+ char ilet, ret;
+@@ -1704,6 +1723,9 @@
+ anything any;
+ menu_item *selected;
+
++#ifdef DUMP_LOG
++ if (want_disp) {
++#endif
+ /* overriden by global flag */
+ if (flags.perm_invent) {
+ win = (lets && *lets) ? local_win : WIN_INVEN;
+@@ -1713,6 +1735,11 @@
+ } else
+ win = WIN_INVEN;
+
++#ifdef DUMP_LOG
++ }
++ if (want_dump) dump("", "Your inventory");
++#endif
++
+ /*
+ Exit early if no inventory -- but keep going if we are doing
+ a permanent inventory update. We need to keep going so the
+@@ -1725,11 +1752,24 @@
+ to here is short circuited away.
+ */
+ if (!invent && !(flags.perm_invent && !lets && !want_reply)) {
++#ifdef DUMP_LOG
++ if (want_disp) {
++#endif
+ #ifndef GOLDOBJ
+ pline("Not carrying anything%s.", u.ugold ? " except gold" : "");
+ #else
+ pline("Not carrying anything.");
+ #endif
++#ifdef DUMP_LOG
++ }
++ if (want_dump) {
++#ifdef GOLDOBJ
++ dump(" ", "Not carrying anything");
++#else
++ dump(" Not carrying anything", u.ugold ? " except gold." : ".");
++#endif
++ }
++#endif
+ return 0;
+ }
+
+@@ -1743,16 +1783,31 @@
+ ret = '\0';
+ for (otmp = invent; otmp; otmp = otmp->nobj) {
+ if (otmp->invlet == lets[0]) {
++#ifdef DUMP_LOG
++ if (want_disp) {
++#endif
+ ret = message_menu(lets[0],
+ want_reply ? PICK_ONE : PICK_NONE,
+ xprname(otmp, (char *)0, lets[0], TRUE, 0L, 0L));
+ if (out_cnt) *out_cnt = -1L; /* select all */
++#ifdef DUMP_LOG
++ }
++ if (want_dump) {
++ char letbuf[7];
++ sprintf(letbuf, " %c - ", lets[0]);
++ dump(letbuf,
++ xprname(otmp, (char *)0, lets[0], TRUE, 0L, 0L));
++ }
++#endif
+ break;
+ }
+ }
+ return ret;
+ }
+
++#ifdef DUMP_LOG
++ if (want_disp)
++#endif
+ start_menu(win);
+ nextclass:
+ classcount = 0;
+@@ -1763,11 +1818,24 @@
+ if (!flags.sortpack || otmp->oclass == *invlet) {
+ if (flags.sortpack && !classcount) {
+ any.a_void = 0; /* zero */
++#ifdef DUMP_LOG
++ if (want_dump)
++ dump(" ", let_to_name(*invlet, FALSE));
++ if (want_disp)
++#endif
+ add_menu(win, NO_GLYPH, &any, 0, 0, iflags.menu_headings,
+ let_to_name(*invlet, FALSE), MENU_UNSELECTED);
+ classcount++;
+ }
+ any.a_char = ilet;
++#ifdef DUMP_LOG
++ if (want_dump) {
++ char letbuf[7];
++ sprintf(letbuf, " %c - ", ilet);
++ dump(letbuf, doname(otmp));
++ }
++ if (want_disp)
++#endif
+ add_menu(win, obj_to_glyph(otmp),
+ &any, ilet, 0, ATR_NONE, doname(otmp),
+ MENU_UNSELECTED);
+@@ -1783,6 +1851,9 @@
+ }
+ #endif
+ }
++#ifdef DUMP_LOG
++ if (want_disp) {
++#endif
+ end_menu(win, (char *) 0);
+
+ n = select_menu(win, want_reply ? PICK_ONE : PICK_NONE, &selected);
+@@ -1792,6 +1863,10 @@
+ free((genericptr_t)selected);
+ } else
+ ret = !n ? '\0' : '\033'; /* cancelled */
++#ifdef DUMP_LOG
++ } /* want_disp */
++ if (want_dump) dump("", "");
++#endif
+
+ return ret;
+ }
+@@ -1808,9 +1883,24 @@
+ register const char *lets;
+ boolean want_reply;
+ {
+- return display_pickinv(lets, want_reply, (long *)0);
++ return display_pickinv(lets, want_reply, (long *)0
++#ifdef DUMP_LOG
++ , FALSE , TRUE
++#endif
++ );
+ }
+
++#ifdef DUMP_LOG
++/* See display_inventory. This is the same thing WITH dumpfile creation */
++char
++dump_inventory(lets, want_reply, want_disp)
++register const char *lets;
++boolean want_reply, want_disp;
++{
++ return display_pickinv(lets, want_reply, (long *)0, TRUE, want_disp);
++}
++#endif
++
+ /*
+ * Returns the number of unpaid items within the given list. This includes
+ * contained objects.
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/options.c nethack-3.4.3-dump/src/options.c
+--- nethack-3.4.3/src/options.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/options.c 2011-08-13 15:12:43.000000000 +0300
+@@ -224,6 +224,14 @@
+ SET_IN_GAME },
+ { "dogname", "the name of your (first) dog (e.g., dogname:Fang)",
+ PL_PSIZ, DISP_IN_GAME },
++#ifdef DUMP_LOG
++ { "dumpfile", "where to dump data (e.g., dumpfile:/tmp/dump.nh)",
++#ifdef DUMP_FN
++ PL_PSIZ, DISP_IN_GAME },
++#else
++ PL_PSIZ, SET_IN_GAME },
++#endif
++#endif
+ { "dungeon", "the symbols to use in drawing the dungeon map",
+ MAXDCHARS+1, SET_IN_FILE },
+ { "effects", "the symbols to use in drawing special effects",
+@@ -1077,6 +1085,19 @@
+ return;
+ }
+
++#ifdef DUMP_LOG
++ fullname = "dumpfile";
++ if (match_optname(opts, fullname, 3, TRUE)) {
++#ifndef DUMP_FN
++ if (negated) bad_negation(fullname, FALSE);
++ else if ((op = string_for_opt(opts, !tfrom_file)) != 0
++ && strlen(op) > 1)
++ nmcpy(dump_fn, op, PL_PSIZ);
++#endif
++ return;
++ }
++#endif
++
+ fullname = "horsename";
+ if (match_optname(opts, fullname, 5, TRUE)) {
+ if (negated) bad_negation(fullname, FALSE);
+@@ -2933,6 +2954,10 @@
+ }
+ else if (!strcmp(optname, "dogname"))
+ Sprintf(buf, "%s", dogname[0] ? dogname : none );
++#ifdef DUMP_LOG
++ else if (!strcmp(optname, "dumpfile"))
++ Sprintf(buf, "%s", dump_fn[0] ? dump_fn: none );
++#endif
+ else if (!strcmp(optname, "dungeon"))
+ Sprintf(buf, "%s", to_be_done);
+ else if (!strcmp(optname, "effects"))
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/pline.c nethack-3.4.3-dump/src/pline.c
+--- nethack-3.4.3/src/pline.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/pline.c 2011-08-13 15:12:43.000000000 +0300
+@@ -15,6 +15,11 @@
+
+ static char *FDECL(You_buf, (int));
+
++#if defined(DUMP_LOG) && defined(DUMPMSGS)
++char msgs[DUMPMSGS][BUFSZ];
++int lastmsg = -1;
++#endif
++
+ /*VARARGS1*/
+ /* Note that these declarations rely on knowledge of the internals
+ * of the variable argument handling stuff in "tradstdc.h"
+@@ -55,6 +60,12 @@
+ Vsprintf(pbuf,line,VA_ARGS);
+ line = pbuf;
+ }
++#if defined(DUMP_LOG) && defined(DUMPMSGS)
++ if (DUMPMSGS > 0 && !program_state.gameover) {
++ lastmsg = (lastmsg + 1) % DUMPMSGS;
++ strncpy(msgs[lastmsg], line, BUFSZ);
++ }
++#endif
+ if (!iflags.window_inited) {
+ raw_print(line);
+ return;
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/spell.c nethack-3.4.3-dump/src/spell.c
+--- nethack-3.4.3/src/spell.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/spell.c 2011-08-13 15:12:43.000000000 +0300
+@@ -1114,6 +1114,35 @@
+ return FALSE;
+ }
+
++#ifdef DUMP_LOG
++void
++dump_spells()
++{
++ int i;
++ char buf[BUFSZ];
++
++ if (spellid(0) == NO_SPELL) {
++ dump("", "You didn't know any spells.");
++ dump("", "");
++ return;
++ }
++ dump("", "Spells known in the end");
++
++ Sprintf(buf, "%-20s Level %-12s Fail", " Name", "Category");
++ dump(" ",buf);
++ for (i = 0; i < MAXSPELL && spellid(i) != NO_SPELL; i++) {
++ Sprintf(buf, "%c - %-20s %2d%s %-12s %3d%%",
++ spellet(i), spellname(i), spellev(i),
++ spellknow(i) ? " " : "*",
++ spelltypemnemonic(spell_skilltype(spellid(i))),
++ 100 - percent_success(i));
++ dump(" ", buf);
++ }
++ dump("","");
++
++} /* dump_spells */
++#endif
++
+ /* Integer square root function without using floating point. */
+ STATIC_OVL int
+ isqrt(val)
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/topten.c nethack-3.4.3-dump/src/topten.c
+--- nethack-3.4.3/src/topten.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/topten.c 2011-08-13 15:12:43.000000000 +0300
+@@ -358,6 +358,12 @@
+ "Since you were in %s mode, the score list will not be checked.",
+ wizard ? "wizard" : "discover");
+ topten_print(pbuf);
++#ifdef DUMP_LOG
++ if (dump_fn[0]) {
++ dump("", pbuf);
++ dump("", "");
++ }
++#endif
+ }
+ goto showwin;
+ }
+@@ -378,6 +384,9 @@
+ }
+
+ HUP topten_print("");
++#ifdef DUMP_LOG
++ dump("", "");
++#endif
+
+ /* assure minimum number of points */
+ if(t0->points < POINTSMIN) t0->points = 0;
+@@ -422,6 +431,10 @@
+ t1->points);
+ topten_print(pbuf);
+ topten_print("");
++#ifdef DUMP_LOG
++ dump("", pbuf);
++ dump("", "");
++#endif
+ }
+ }
+ if(occ_cnt < 0) {
+@@ -452,17 +465,27 @@
+ goto destroywin;
+ }
+ #endif /* UPDATE_RECORD_IN_PLACE */
+- if(!done_stopprint) if(rank0 > 0){
+- if(rank0 <= 10)
++ if(rank0 > 0){
++ if(rank0 <= 10) {
++ if(!done_stopprint)
+ topten_print("You made the top ten list!");
+- else {
++#ifdef DUMP_LOG
++ dump("", "You made the top ten list!");
++#endif
++ } else {
+ char pbuf[BUFSZ];
+ Sprintf(pbuf,
+ "You reached the %d%s place on the top %d list.",
+ rank0, ordin(rank0), ENTRYMAX);
+- topten_print(pbuf);
++ if(!done_stopprint) topten_print(pbuf);
++#ifdef DUMP_LOG
++ dump("", pbuf);
++#endif
+ }
+- topten_print("");
++ if(!done_stopprint) topten_print("");
++#ifdef DUMP_LOG
++ dump("", "");
++#endif
+ }
+ }
+ if(rank0 == 0) rank0 = rank1;
+@@ -475,7 +498,7 @@
+ && rank >= rank0
+ #endif
+ ) writeentry(rfile, t1);
+- if (done_stopprint) continue;
++ /* if (done_stopprint) continue; */
+ if (rank > flags.end_top &&
+ (rank < rank0 - flags.end_around ||
+ rank > rank0 + flags.end_around) &&
+@@ -488,8 +511,12 @@
+ )) continue;
+ if (rank == rank0 - flags.end_around &&
+ rank0 > flags.end_top + flags.end_around + 1 &&
+- !flags.end_own)
+- topten_print("");
++ !flags.end_own) {
++ if(!done_stopprint) topten_print("");
++#ifdef DUMP_LOG
++ dump("", "");
++#endif
++ }
+ if(rank != rank0)
+ outentry(rank, t1, FALSE);
+ else if(!rank1)
+@@ -546,7 +573,10 @@
+ bp = eos(linebuf);
+ while(bp < linebuf + COLNO - 9) *bp++ = ' ';
+ Strcpy(bp, "Hp [max]");
+- topten_print(linebuf);
++ if(!done_stopprint) topten_print(linebuf);
++#ifdef DUMP_LOG
++ dump("", linebuf);
++#endif
+ }
+
+ /* so>0: standout line; so=0: ordinary line */
+@@ -664,9 +694,16 @@
+ if (so) {
+ while (bp < linebuf + (COLNO-1)) *bp++ = ' ';
+ *bp = 0;
+- topten_print_bold(linebuf);
+- } else
+- topten_print(linebuf);
++ if(!done_stopprint) topten_print_bold(linebuf);
++#ifdef DUMP_LOG
++ dump("*", linebuf[0]==' '? linebuf+1: linebuf);
++#endif
++ } else {
++ if(!done_stopprint) topten_print(linebuf);
++#ifdef DUMP_LOG
++ dump(" ", linebuf[0]==' '? linebuf+1: linebuf);
++#endif
++ }
+ Sprintf(linebuf, "%15s %s", "", linebuf3);
+ lngr = strlen(linebuf);
+ }
+@@ -688,9 +725,12 @@
+ if (so >= COLNO) so = COLNO-1;
+ while (bp < linebuf + so) *bp++ = ' ';
+ *bp = 0;
+- topten_print_bold(linebuf);
++ if(!done_stopprint) topten_print_bold(linebuf);
+ } else
+- topten_print(linebuf);
++ if(!done_stopprint) topten_print(linebuf);
++#ifdef DUMP_LOG
++ dump(" ", linebuf[0]==' '? linebuf+1: linebuf);
++#endif
+ }
+
+ STATIC_OVL int
+diff -bNurdX diff_ign.txt nethack-3.4.3/src/weapon.c nethack-3.4.3-dump/src/weapon.c
+--- nethack-3.4.3/src/weapon.c 2003-12-08 01:39:13.000000000 +0200
++++ nethack-3.4.3-dump/src/weapon.c 2011-08-13 15:12:43.000000000 +0300
+@@ -9,6 +9,10 @@
+ */
+ #include "hack.h"
+
++#ifdef DUMP_LOG
++STATIC_DCL int FDECL(enhance_skill, (boolean));
++#endif
++
+ /* Categories whose names don't come from OBJ_NAME(objects[type])
+ */
+ #define PN_BARE_HANDED (-1) /* includes martial arts */
+@@ -851,6 +855,23 @@
+ */
+ int
+ enhance_weapon_skill()
++#ifdef DUMP_LOG
++{
++ return enhance_skill(FALSE);
++}
++
++void dump_weapon_skill()
++{
++ enhance_skill(TRUE);
++}
++
++int enhance_skill(boolean want_dump)
++/* This is the original enhance_weapon_skill() function slightly modified
++ * to write the skills to the dump file. I added the wrapper functions just
++ * because it looked like the easiest way to add a parameter to the
++ * function call. - Jukka Lahtinen, August 2001
++ */
++#endif
+ {
+ int pass, i, n, len, longest,
+ to_advance, eventually_advance, maxxed_cnt;
+@@ -860,8 +881,15 @@
+ anything any;
+ winid win;
+ boolean speedy = FALSE;
++#ifdef DUMP_LOG
++ char buf2[BUFSZ];
++ boolean logged;
++#endif
+
+ #ifdef WIZARD
++#ifdef DUMP_LOG
++ if (!want_dump)
++#endif
+ if (wizard && yn("Advance skills without practice?") == 'y')
+ speedy = TRUE;
+ #endif
+@@ -878,6 +906,11 @@
+ else if (peaked_skill(i)) maxxed_cnt++;
+ }
+
++#ifdef DUMP_LOG
++ if (want_dump)
++ dump("","Your skills at the end");
++ else {
++#endif
+ win = create_nhwindow(NHW_MENU);
+ start_menu(win);
+
+@@ -905,6 +938,9 @@
+ add_menu(win, NO_GLYPH, &any, 0, 0, ATR_NONE,
+ "", MENU_UNSELECTED);
+ }
++#ifdef DUMP_LOG
++ } /* want_dump or not */
++#endif
+
+ /* List the skills, making ones that could be advanced
+ selectable. List the miscellaneous skills first.
+@@ -916,8 +952,26 @@
+ /* Print headings for skill types */
+ any.a_void = 0;
+ if (i == skill_ranges[pass].first)
++#ifdef DUMP_LOG
++ if (want_dump) {
++ dump(" ",(char *)skill_ranges[pass].name);
++ logged=FALSE;
++ } else
++#endif
+ add_menu(win, NO_GLYPH, &any, 0, 0, iflags.menu_headings,
+ skill_ranges[pass].name, MENU_UNSELECTED);
++#ifdef DUMP_LOG
++ if (want_dump) {
++ if (P_SKILL(i) > P_UNSKILLED) {
++ Sprintf(buf2,"%-*s [%s]",
++ longest, P_NAME(i),skill_level_name(i, buf));
++ dump(" ",buf2);
++ logged=TRUE;
++ } else if (i == skill_ranges[pass].last && !logged) {
++ dump(" ","(none)");
++ }
++ } else {
++#endif
+
+ if (P_RESTRICTED(i)) continue;
+ /*
+@@ -962,6 +1016,9 @@
+ any.a_int = can_advance(i, speedy) ? i+1 : 0;
+ add_menu(win, NO_GLYPH, &any, 0, 0, ATR_NONE,
+ buf, MENU_UNSELECTED);
++#ifdef DUMP_LOG
++ } /* !want_dump */
++#endif
+ }
+
+ Strcpy(buf, (to_advance > 0) ? "Pick a skill to advance:" :
+@@ -971,6 +1028,12 @@
+ Sprintf(eos(buf), " (%d slot%s available)",
+ u.weapon_slots, plur(u.weapon_slots));
+ #endif
++#ifdef DUMP_LOG
++ if (want_dump) {
++ dump("","");
++ n=0;
++ } else {
++#endif
+ end_menu(win, buf);
+ n = select_menu(win, to_advance ? PICK_ONE : PICK_NONE, &selected);
+ destroy_nhwindow(win);
+@@ -987,6 +1050,9 @@
+ }
+ }
+ }
++#ifdef DUMP_LOG
++ }
++#endif
+ } while (speedy && n > 0);
+ return 0;
+ }
+diff -bNurdX diff_ign.txt nethack-3.4.3/win/tty/wintty.c nethack-3.4.3-dump/win/tty/wintty.c
+--- nethack-3.4.3/win/tty/wintty.c 2003-12-08 01:39:14.000000000 +0200
++++ nethack-3.4.3-dump/win/tty/wintty.c 2011-08-13 15:12:43.000000000 +0300
+@@ -162,7 +162,7 @@
+ STATIC_DCL void FDECL(process_menu_window, (winid,struct WinDesc *));
+ STATIC_DCL void FDECL(process_text_window, (winid,struct WinDesc *));
+ STATIC_DCL tty_menu_item *FDECL(reverse, (tty_menu_item *));
+-STATIC_DCL const char * FDECL(compress_str, (const char *));
++const char * FDECL(compress_str, (const char *));
+ STATIC_DCL void FDECL(tty_putsym, (winid, int, int, CHAR_P));
+ static char *FDECL(copy_of, (const char *));
+ STATIC_DCL void FDECL(bail, (const char *)); /* __attribute__((noreturn)) */
+@@ -1722,7 +1722,7 @@
+ }
+
+
+-STATIC_OVL const char*
++const char*
+ compress_str(str)
+ const char *str;
+ {