Changed the type of data_table to be unsigned char[] instead of char[],

[bsdgames-darwin.git] / larn / scores.c

diff --git a/larn/scores.c b/larn/scores.c
index 3a96271c7f3334bf7bdd9e58d7231f3bf6807115..71d399e198135cb1a2b71a155ab17aaa89b2288b 100644 (file)
--- a/larn/scores.c
+++ b/larn/scores.c
@@ -1,672 +1,834 @@
-#ifndef lint
-static char rcsid[] = "$NetBSD: scores.c,v 1.6 1996/05/22 00:36:14 mrg Exp $";
-#endif /* not lint */
+/*     $NetBSD: scores.c,v 1.12 2004/02/13 11:36:08 wiz Exp $  */

 
 

-/* scores.c                     Larn is copyrighted 1986 by Noah Morgan.
- *
- *     Functions in this file are:
- *
- *     readboard()     Function to read in the scoreboard into a static buffer
- *     writeboard()    Function to write the scoreboard from readboard()'s buffer
- *     makeboard()     Function to create a new scoreboard (wipe out old one)
- *     hashewon()       Function to return 1 if player has won a game before, else 0
- *     long paytaxes(x)         Function to pay taxes if any are due
- *     winshou()               Subroutine to print out the winning scoreboard
- *     shou(x)                 Subroutine to print out the non-winners scoreboard
- *     showscores()            Function to show the scoreboard on the terminal
- *     showallscores() Function to show scores and the iven lists that go with them
- *     sortboard()             Function to sort the scoreboard
- *     newscore(score, whoo, whyded, winner)   Function to add entry to scoreboard
- *     new1sub(score,i,whoo,taxes)               Subroutine to put player into a 
- *     new2sub(score,i,whoo,whyded)              Subroutine to put player into a 
- *     died(x)         Subroutine to record who played larn, and what the score was
- *     diedsub(x) Subroutine to print out a line showing player when he is killed
- *     diedlog()       Subroutine to read a log file and print it out in ascii format
- *     getplid(name)           Function to get players id # from id file
- *
+/*
+ * scores.c                     Larn is copyrighted 1986 by Noah Morgan.
+ * 
+ * Functions in this file are:
+ * 
+ * readboard()         Function to read in the scoreboard into a static buffer
+ * writeboard()        Function to write the scoreboard from readboard()'s buffer
+ * makeboard()         Function to create a new scoreboard (wipe out old one)
+ * hashewon()   Function to return 1 if player has won a game before, else 0
+ * long paytaxes(x)     Function to pay taxes if any are due winshou()
+ * ubroutine to print out the winning scoreboard shou(x)
+ * ubroutine to print out the non-winners scoreboard showscores()
+ * unction to show the scoreboard on the terminal showallscores()
+ * Function to show scores and the iven lists that go with them sortboard()
+ * unction to sort the scoreboard newscore(score, whoo, whyded, winner)
+ * Function to add entry to scoreboard new1sub(score,i,whoo,taxes)
+ * Subroutine to put player into a new2sub(score,i,whoo,whyded)
+ * Subroutine to put player into a died(x)     Subroutine to record who
+ * played larn, and what the score was diedsub(x) Subroutine to print out a
+ * line showing player when he is killed diedlog()     Subroutine to read a
+ * log file and print it out in ascii format getplid(name)
+ * on to get players id # from id file
+ * 

  */
  */

+#include <sys/cdefs.h>
+#ifndef lint
+__RCSID("$NetBSD: scores.c,v 1.12 2004/02/13 11:36:08 wiz Exp $");
+#endif                         /* not lint */

 #include <sys/types.h>
 #include <sys/times.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/times.h>
 #include <sys/stat.h>

-#include "header.h"
+#include <stdio.h>

 #include <string.h>
 #include <string.h>

+#include <unistd.h>
+#include <stdlib.h>
+#include "header.h"
+#include "extern.h"

 
 

-struct scofmt                  /*      This is the structure for the scoreboard                */
-       {
-       long score;                     /* the score of the player                                                      */
-       long suid;                      /* the user id number of the player                             */
-       short what;                     /* the number of the monster that killed player         */
-       short level;            /* the level player was on when he died                         */
-       short hardlev;          /* the level of difficulty player played at             */
-       short order;            /* the relative ordering place of this entry            */
-       char who[40];           /* the name of the character                                            */
-       char sciv[26][2];       /* this is the inventory list of the character          */
-       };
-struct wscofmt                 /* This is the structure for the winning scoreboard */
-       {
-       long score;                     /* the score of the player                                                      */
-       long timeused;          /* the time used in mobuls to win the game                      */
-       long taxes;                     /* taxes he owes to LRS                                                         */
-       long suid;                      /* the user id number of the player                             */
-       short hardlev;          /* the level of difficulty player played at             */
-       short order;            /* the relative ordering place of this entry            */
-       char who[40];           /* the name of the character                                            */
-       };
+struct scofmt {                        /* This is the structure for the scoreboard              */
+       long            score;  /* the score of the player                                                       */
+       long            suid;   /* the user id number of the player                              */
+       short           what;   /* the number of the monster that killed
+                                * player        */
+       short           level;  /* the level player was on when he died                          */
+       short           hardlev;/* the level of difficulty player played at              */
+       short           order;  /* the relative ordering place of this entry             */
+       char            who[40];/* the name of the character                                             */
+       char            sciv[26][2];    /* this is the inventory list of the
+                                        * character             */
+};
+struct wscofmt {               /* This is the structure for the winning
+                                * scoreboard */
+       long            score;  /* the score of the player                                                       */
+       long            timeused;       /* the time used in mobuls to win the
+                                        * game                          */
+       long            taxes;  /* taxes he owes to LRS                                                          */
+       long            suid;   /* the user id number of the player                              */
+       short           hardlev;/* the level of difficulty player played at              */
+       short           order;  /* the relative ordering place of this entry             */
+       char            who[40];/* the name of the character                                             */
+};

 
 

-struct log_fmt                 /* 102 bytes struct for the log file                            */
-       {
-       long score;                     /* the players score                                                            */
-       time_t diedtime;        /* time when game was over                                                      */
-       short cavelev;          /* level in caves                                                                       */
-       short diff;                     /* difficulty player played at                                          */
+struct log_fmt {               /* 102 bytes struct for the log file                             */
+       long            score;  /* the players score                                                             */
+       time_t          diedtime;       /* time when game was over                                                       */
+       short           cavelev;/* level in caves                                                                        */
+       short           diff;   /* difficulty player played at                                           */

 #ifdef EXTRA
 #ifdef EXTRA

-       long elapsedtime;       /* real time of game in seconds                                         */
-       long bytout;            /* bytes input and output                                                       */
-       long bytin;
-       long moves;                     /* number of moves made by player                                       */
-       short ac;                       /* armor class of player                                                        */
-       short hp,hpmax;         /* players hitpoints                                                            */
-       short cputime;          /* cpu time needed in seconds                                           */
-       short killed,spused;/* monsters killed and spells cast                                  */
-       short usage;            /* usage of the cpu in %                                                        */
-       short lev;                      /* player level                                                                         */
+       long            elapsedtime;    /* real time of game in seconds                                          */
+       long            bytout; /* bytes input and output                                                        */
+       long            bytin;
+       long            moves;  /* number of moves made by player                                        */
+       short           ac;     /* armor class of player                                                         */
+       short           hp, hpmax;      /* players hitpoints                                                             */
+       short           cputime;/* CPU time needed in seconds                                            */
+       short           killed, spused; /* monsters killed and spells cast                                       */
+       short           usage;  /* usage of the CPU in %                                                         */
+       short           lev;    /* player level                                                                          */

 #endif
 #endif

-       char who[12];           /* player name                                                                          */
-       char what[46];          /* what happened to player                                                      */
-       };
+       char            who[12];/* player name                                                                           */
+       char            what[46];       /* what happened to player                                                       */
+};

 
 static struct scofmt sco[SCORESIZE];   /* the structure for the scoreboard  */
 static struct wscofmt winr[SCORESIZE]; /* struct for the winning scoreboard */
 
 static struct scofmt sco[SCORESIZE];   /* the structure for the scoreboard  */
 static struct wscofmt winr[SCORESIZE]; /* struct for the winning scoreboard */

-static struct log_fmt logg;                            /* structure for the log file            */
-static char *whydead[] = {
+static struct log_fmt logg;    /* structure for the log file            */
+static char    *whydead[] = {

        "quit", "suspended", "self - annihilated", "shot by an arrow",
        "hit by a dart", "fell into a pit", "fell into a bottomless pit",
        "a winner", "trapped in solid rock", "killed by a missing save file",
        "killed by an old save file", "caught by the greedy cheater checker trap",
        "quit", "suspended", "self - annihilated", "shot by an arrow",
        "hit by a dart", "fell into a pit", "fell into a bottomless pit",
        "a winner", "trapped in solid rock", "killed by a missing save file",
        "killed by an old save file", "caught by the greedy cheater checker trap",

-       "killed by a protected save file","killed his family and committed suicide",
+       "killed by a protected save file", "killed his family and committed suicide",

        "erased by a wayward finger", "fell through a bottomless trap door",
        "fell through a trap door", "drank some poisonous water",
        "fried by an electric shock", "slipped on a volcano shaft",
        "killed by a stupid act of frustration", "attacked by a revolting demon",
        "hit by his own magic", "demolished by an unseen attacker",
        "fell into the dreadful sleep", "killed by an exploding chest",
        "erased by a wayward finger", "fell through a bottomless trap door",
        "fell through a trap door", "drank some poisonous water",
        "fried by an electric shock", "slipped on a volcano shaft",
        "killed by a stupid act of frustration", "attacked by a revolting demon",
        "hit by his own magic", "demolished by an unseen attacker",
        "fell into the dreadful sleep", "killed by an exploding chest",

-/*26*/ "killed by a missing maze data file", "annihilated in a sphere",
-       "died a post mortem death","wasted by a malloc() failure"
-       };
+        /* 26 */ "killed by a missing maze data file", "annihilated in a sphere",
+       "died a post mortem death", "wasted by a malloc() failure"
+};

 
 /*
 
 /*

- *     readboard()     Function to read in the scoreboard into a static buffer
+ * readboard()         Function to read in the scoreboard into a static buffer

  *
  *

- *     returns -1 if unable to read in the scoreboard, returns 0 if all is OK
+ * returns -1 if unable to read in the scoreboard, returns 0 if all is OK

  */
  */

+int

 readboard()
 readboard()

-       {
-       int i;
+{
+       int             i;

 
        seteuid(euid);
        i = lopen(scorefile);
        seteuid(uid);
 
        seteuid(euid);
        i = lopen(scorefile);
        seteuid(uid);

-       if (i<0)
-         { lprcat("Can't read scoreboard\n"); lflush(); return(-1); }
-       lrfill((char*)sco,sizeof(sco));         lrfill((char*)winr,sizeof(winr));
-       lrclose();  lcreat((char*)0);  return(0);
+       if (i < 0) {
+               lprcat("Can't read scoreboard\n");
+               lflush();
+               return (-1);

        }
        }

+       lrfill((char *) sco, sizeof(sco));
+       lrfill((char *) winr, sizeof(winr));
+       lrclose();
+       lcreat((char *) 0);
+       return (0);
+}

 
 /*
 
 /*

- *     writeboard()    Function to write the scoreboard from readboard()'s buffer
+ * writeboard()        Function to write the scoreboard from readboard()'s buffer

  *
  *

- *     returns -1 if unable to write the scoreboard, returns 0 if all is OK
+ * returns -1 if unable to write the scoreboard, returns 0 if all is OK

  */
  */

+int

 writeboard()
 writeboard()

-       {
-       int i;
+{
+       int             i;

 
        set_score_output();
        seteuid(euid);
        i = lcreat(scorefile);
        seteuid(uid);
 
        set_score_output();
        seteuid(euid);
        i = lcreat(scorefile);
        seteuid(uid);

-       if (i<0)
-         { lprcat("Can't write scoreboard\n"); lflush(); return(-1); }
-       lwrite((char*)sco,sizeof(sco));         lwrite((char*)winr,sizeof(winr));
-       lwclose();  lcreat((char*)0);  return(0);
+       if (i < 0) {
+               lprcat("Can't write scoreboard\n");
+               lflush();
+               return (-1);

        }
        }

+       lwrite((char *) sco, sizeof(sco));
+       lwrite((char *) winr, sizeof(winr));
+       lwclose();
+       lcreat((char *) 0);
+       return (0);
+}

 
 /*
 
 /*

- *     makeboard()             Function to create a new scoreboard (wipe out old one)
+ * makeboard()                 Function to create a new scoreboard (wipe out old one)

  *
  *

- *     returns -1 if unable to write the scoreboard, returns 0 if all is OK
+ * returns -1 if unable to write the scoreboard, returns 0 if all is OK

  */
  */

+int

 makeboard()
 makeboard()

-       {
-       register int i;
-       for (i=0; i<SCORESIZE; i++)
-               {
+{
+       int    i;
+       for (i = 0; i < SCORESIZE; i++) {

                winr[i].taxes = winr[i].score = sco[i].score = 0;
                winr[i].order = sco[i].order = i;
                winr[i].taxes = winr[i].score = sco[i].score = 0;
                winr[i].order = sco[i].order = i;

-               }
-       if (writeboard()) return(-1);
+       }
+       if (writeboard())
+               return (-1);

        seteuid(euid);
        seteuid(euid);

-       chmod(scorefile,0660);
+       chmod(scorefile, 0660);

        seteuid(uid);
        seteuid(uid);

-       return(0);
-       }
+       return (0);
+}

 
 /*
 
 /*

- *     hashewon()       Function to return 1 if player has won a game before, else 0
+ * hashewon()   Function to return 1 if player has won a game before, else 0

  *
  *

- *     This function also sets c[HARDGAME] to appropriate value -- 0 if not a
- *     winner, otherwise the next level of difficulty listed in the winners
- *     scoreboard.  This function also sets outstanding_taxes to the value in
- *     the winners scoreboard.
+ * This function also sets c[HARDGAME] to appropriate value -- 0 if not a
+ * winner, otherwise the next level of difficulty listed in the winners
+ * scoreboard.  This function also sets outstanding_taxes to the value in
+ * the winners scoreboard.

  */
  */

+int

 hashewon()
 hashewon()

-       {
-       register int i;
+{
+       int    i;

        c[HARDGAME] = 0;
        c[HARDGAME] = 0;

-       if (readboard() < 0) return(0); /* can't find scoreboard */
-       for (i=0; i<SCORESIZE; i++)     /* search through winners scoreboard */
-          if (winr[i].suid == userid)
-                 if (winr[i].score > 0)
-                       {
-                       c[HARDGAME]=winr[i].hardlev+1;  outstanding_taxes=winr[i].taxes;
-                       return(1);
+       if (readboard() < 0)
+               return (0);     /* can't find scoreboard */
+       for (i = 0; i < SCORESIZE; i++) /* search through winners scoreboard */
+               if (winr[i].suid == userid)
+                       if (winr[i].score > 0) {
+                               c[HARDGAME] = winr[i].hardlev + 1;
+                               outstanding_taxes = winr[i].taxes;
+                               return (1);

                        }
                        }

-       return(0);
-       }
+       return (0);
+}

 
 /*
 
 /*

- *     long paytaxes(x)                 Function to pay taxes if any are due
+ * long paytaxes(x)             Function to pay taxes if any are due

  *
  *

- *     Enter with the amount (in gp) to pay on the taxes.
- *     Returns amount actually paid.
+ * Enter with the amount (in gp) to pay on the taxes.
+ * Returns amount actually paid.

  */
  */

-long paytaxes(x)
-       long x;
-       {
-       register int i;
-       register long amt;
-       if (x<0) return(0L);
-       if (readboard()<0) return(0L);
-       for (i=0; i<SCORESIZE; i++)
-               if (winr[i].suid == userid)     /* look for players winning entry */
-                       if (winr[i].score>0) /* search for a winning entry for the player */
-                               {
+long 
+paytaxes(x)
+       long            x;
+{
+       int    i;
+       long   amt;
+       if (x < 0)
+               return (0L);
+       if (readboard() < 0)
+               return (0L);
+       for (i = 0; i < SCORESIZE; i++)
+               if (winr[i].suid == userid)     /* look for players winning
+                                                * entry */
+                       if (winr[i].score > 0) {        /* search for a winning
+                                                        * entry for the player */

                                amt = winr[i].taxes;
                                amt = winr[i].taxes;

-                               if (x < amt) amt=x;             /* don't overpay taxes (Ughhhhh) */
+                               if (x < amt)
+                                       amt = x;        /* don't overpay taxes
+                                                        * (Ughhhhh) */

                                winr[i].taxes -= amt;
                                outstanding_taxes -= amt;
                                winr[i].taxes -= amt;
                                outstanding_taxes -= amt;

-                               if (writeboard()<0) return(0);
-                               return(amt);
-                               }
-       return(0L);     /* couldn't find user on winning scoreboard */
-       }
+                               if (writeboard() < 0)
+                                       return (0);
+                               return (amt);
+                       }
+       return (0L);            /* couldn't find user on winning scoreboard */
+}

 
 /*
 
 /*

- *     winshou()               Subroutine to print out the winning scoreboard
+ * winshou()           Subroutine to print out the winning scoreboard

  *
  *

- *     Returns the number of players on scoreboard that were shown 
+ * Returns the number of players on scoreboard that were shown

  */
  */

+int

 winshou()
 winshou()

-       {
-       register struct wscofmt *p;
-       register int i,j,count;
-       for (count=j=i=0; i<SCORESIZE; i++) /* is there anyone on the scoreboard? */
-               if (winr[i].score != 0)
-                       { j++; break; }
-       if (j)
-               {
+{
+       struct wscofmt *p;
+       int    i, j, count;
+       for (count = j = i = 0; i < SCORESIZE; i++)     /* is there anyone on
+                                                        * the scoreboard? */
+               if (winr[i].score != 0) {
+                       j++;
+                       break;
+               }
+       if (j) {

                lprcat("\n  Score    Difficulty   Time Needed   Larn Winners List\n");
 
                lprcat("\n  Score    Difficulty   Time Needed   Larn Winners List\n");
 

-               for (i=0; i<SCORESIZE; i++)     /* this loop is needed to print out the */
-                 for (j=0; j<SCORESIZE; j++) /* winners in order */
-                       {
-                       p = &winr[j];   /* pointer to the scoreboard entry */
-                       if (p->order == i)
-                               {
-                               if (p->score)
-                                       {
-                                       count++;
-                                       lprintf("%10d     %2d      %5d Mobuls   %s \n",
-                                       (long)p->score,(long)p->hardlev,(long)p->timeused,p->who);
+               for (i = 0; i < SCORESIZE; i++) /* this loop is needed to
+                                                * print out the */
+                       for (j = 0; j < SCORESIZE; j++) {       /* winners in order */
+                               p = &winr[j];   /* pointer to the scoreboard
+                                                * entry */
+                               if (p->order == i) {
+                                       if (p->score) {
+                                               count++;
+                                               lprintf("%10d     %2d      %5d Mobuls   %s \n",
+                                                       (long) p->score, (long) p->hardlev, (long) p->timeused, p->who);

                                        }
                                        }

-                               break;
+                                       break;

                                }
                        }
                                }
                        }

-               }
-       return(count);  /* return number of people on scoreboard */

        }
        }

+       return (count);         /* return number of people on scoreboard */
+}

 
 /*
 
 /*

- *     shou(x)                 Subroutine to print out the non-winners scoreboard
- *             int x;
+ * shou(x)                     Subroutine to print out the non-winners scoreboard
+ *     int x;

  *
  *

- *     Enter with 0 to list the scores, enter with 1 to list inventories too
- *     Returns the number of players on scoreboard that were shown 
+ * Enter with 0 to list the scores, enter with 1 to list inventories too
+ * Returns the number of players on scoreboard that were shown

  */
  */

+int

 shou(x)
 shou(x)

-       int x;
-       {
-       register int i,j,n,k;
-       int count;
-       for (count=j=i=0; i<SCORESIZE; i++)     /* is the scoreboard empty? */
-               if (sco[i].score!= 0)
-                       { j++; break; }
-       if (j)
-               {
+       int             x;
+{
+       int    i, j, n, k;
+       int             count;
+       for (count = j = i = 0; i < SCORESIZE; i++)     /* is the scoreboard
+                                                        * empty? */
+               if (sco[i].score != 0) {
+                       j++;
+                       break;
+               }
+       if (j) {

                lprcat("\n   Score   Difficulty   Larn Visitor Log\n");
                lprcat("\n   Score   Difficulty   Larn Visitor Log\n");

-               for (i=0; i<SCORESIZE; i++) /* be sure to print them out in order */
-                 for (j=0; j<SCORESIZE; j++)
-                       if (sco[j].order == i)
-                               {
-                               if (sco[j].score)
-                                       {
-                                       count++;
-                                       lprintf("%10d     %2d       %s ",
-                                               (long)sco[j].score,(long)sco[j].hardlev,sco[j].who);
-                                       if (sco[j].what < 256) lprintf("killed by a %s",monster[sco[j].what].name);
-                                               else lprintf("%s",whydead[sco[j].what - 256]);
-                                       if (x != 263) lprintf(" on %s",levelname[sco[j].level]);
-                                       if (x)
-                                               {
-                                               for (n=0; n<26; n++) { iven[n]=sco[j].sciv[n][0]; ivenarg[n]=sco[j].sciv[n][1]; }
-                                               for (k=1; k<99; k++)
-                                                 for (n=0; n<26; n++)
-                                                       if (k==iven[n])  { srcount=0; show3(n); }
-                                               lprcat("\n\n");
-                                               }
-                                       else lprc('\n');
+               for (i = 0; i < SCORESIZE; i++) /* be sure to print them out
+                                                * in order */
+                       for (j = 0; j < SCORESIZE; j++)
+                               if (sco[j].order == i) {
+                                       if (sco[j].score) {
+                                               count++;
+                                               lprintf("%10d     %2d       %s ",
+                                                       (long) sco[j].score, (long) sco[j].hardlev, sco[j].who);
+                                               if (sco[j].what < 256)
+                                                       lprintf("killed by a %s", monster[sco[j].what].name);
+                                               else
+                                                       lprintf("%s", whydead[sco[j].what - 256]);
+                                               if (x != 263)
+                                                       lprintf(" on %s", levelname[sco[j].level]);
+                                               if (x) {
+                                                       for (n = 0; n < 26; n++) {
+                                                               iven[n] = sco[j].sciv[n][0];
+                                                               ivenarg[n] = sco[j].sciv[n][1];
+                                                       }
+                                                       for (k = 1; k < 99; k++)
+                                                               for (n = 0; n < 26; n++)
+                                                                       if (k == iven[n]) {
+                                                                               srcount = 0;
+                                                                               show3(n);
+                                                                       }
+                                                       lprcat("\n\n");
+                                               } else
+                                                       lprc('\n');

                                        }
                                        }

-                               j=SCORESIZE;
+                                       j = SCORESIZE;

                                }
                                }

-               }
-       return(count);  /* return the number of players just shown */

        }
        }

+       return (count);         /* return the number of players just shown */
+}

 
 /*
 
 /*

- *     showscores()            Function to show the scoreboard on the terminal
+ * showscores()                Function to show the scoreboard on the terminal

  *
  *

- *     Returns nothing of value
+ * Returns nothing of value

  */
  */

-static char esb[] = "The scoreboard is empty.\n";
+static char     esb[] = "The scoreboard is empty.\n";
+void

 showscores()
 showscores()

-       {
-       register int i,j;
-       lflush();  lcreat((char*)0);  if (readboard()<0) return;
-       i=winshou();    j=shou(0);      
-       if (i+j == 0) lprcat(esb); else lprc('\n');
+{
+       int    i, j;

        lflush();
        lflush();

-       }
+       lcreat((char *) 0);
+       if (readboard() < 0)
+               return;
+       i = winshou();
+       j = shou(0);
+       if (i + j == 0)
+               lprcat(esb);
+       else
+               lprc('\n');
+       lflush();
+}

 
 /*
 
 /*

- *     showallscores() Function to show scores and the iven lists that go with them
+ * showallscores()     Function to show scores and the iven lists that go with them

  *
  *

- *     Returns nothing of value
+ * Returns nothing of value

  */
  */

+void

 showallscores()
 showallscores()

-       {
-       register int i,j;
-       lflush();  lcreat((char*)0);  if (readboard()<0) return;
-       c[WEAR] = c[WIELD] = c[SHIELD] = -1;  /* not wielding or wearing anything */
-       for (i=0; i<MAXPOTION; i++) potionname[i]=potionhide[i];
-       for (i=0; i<MAXSCROLL; i++) scrollname[i]=scrollhide[i];
-       i=winshou();  j=shou(1);
-       if (i+j==0) lprcat(esb); else lprc('\n');
+{
+       int    i, j;

        lflush();
        lflush();

-       }
+       lcreat((char *) 0);
+       if (readboard() < 0)
+               return;
+       c[WEAR] = c[WIELD] = c[SHIELD] = -1;    /* not wielding or wearing
+                                                * anything */
+       for (i = 0; i < MAXPOTION; i++)
+               potionname[i] = potionhide[i];
+       for (i = 0; i < MAXSCROLL; i++)
+               scrollname[i] = scrollhide[i];
+       i = winshou();
+       j = shou(1);
+       if (i + j == 0)
+               lprcat(esb);
+       else
+               lprc('\n');
+       lflush();
+}

 
 /*
 
 /*

- *     sortboard()             Function to sort the scoreboard
+ * sortboard()         Function to sort the scoreboard

  *
  *

- *     Returns 0 if no sorting done, else returns 1
+ * Returns 0 if no sorting done, else returns 1

  */
  */

+int

 sortboard()
 sortboard()

-       {
-       register int i,j,pos;
-       long jdat;
-       for (i=0; i<SCORESIZE; i++) sco[i].order = winr[i].order = -1;
-       pos=0;  while (pos < SCORESIZE)
-               {
-               jdat=0;
-               for (i=0; i<SCORESIZE; i++)
-                       if ((sco[i].order < 0) && (sco[i].score >= jdat))
-                               { j=i;  jdat=sco[i].score; }
+{
+       int    i, j = 0, pos;
+       long            jdat;
+       for (i = 0; i < SCORESIZE; i++)
+               sco[i].order = winr[i].order = -1;
+       pos = 0;
+       while (pos < SCORESIZE) {
+               jdat = 0;
+               for (i = 0; i < SCORESIZE; i++)
+                       if ((sco[i].order < 0) && (sco[i].score >= jdat)) {
+                               j = i;
+                               jdat = sco[i].score;
+                       }

                sco[j].order = pos++;
                sco[j].order = pos++;

-               }
-       pos=0;  while (pos < SCORESIZE)
-               {
-               jdat=0;
-               for (i=0; i<SCORESIZE; i++)
-                       if ((winr[i].order < 0) && (winr[i].score >= jdat))
-                               { j=i;  jdat=winr[i].score; }
+       }
+       pos = 0;
+       while (pos < SCORESIZE) {
+               jdat = 0;
+               for (i = 0; i < SCORESIZE; i++)
+                       if ((winr[i].order < 0) && (winr[i].score >= jdat)) {
+                               j = i;
+                               jdat = winr[i].score;
+                       }

                winr[j].order = pos++;
                winr[j].order = pos++;

-               }
-       return(1);

        }
        }

+       return (1);
+}

 
 /*
 
 /*

- *     newscore(score, whoo, whyded, winner)   Function to add entry to scoreboard
- *             int score, winner, whyded;
- *             char *whoo;
+ * newscore(score, whoo, whyded, winner)       Function to add entry to scoreboard
+ *     int score, winner, whyded;
+ *     char *whoo;

  *
  *

- *     Enter with the total score in gp in score,  players name in whoo,
- *             died() reason # in whyded, and TRUE/FALSE in winner if a winner
- *     ex.             newscore(1000, "player 1", 32, 0);
+ * Enter with the total score in gp in score,  players name in whoo,
+ *     died() reason # in whyded, and TRUE/FALSE in winner if a winner
+ * ex.         newscore(1000, "player 1", 32, 0);

  */
  */

+void

 newscore(score, whoo, whyded, winner)
 newscore(score, whoo, whyded, winner)

-       long score;
-       int winner, whyded;
-       char *whoo;
-       {
-       register int i;
-       long taxes;
-       if (readboard() < 0) return;    /*      do the scoreboard       */
+       long            score;
+       int             winner, whyded;
+       char           *whoo;
+{
+       int    i;
+       long            taxes;
+       if (readboard() < 0)
+               return;         /* do the scoreboard     */

        /* if a winner then delete all non-winning scores */
        /* if a winner then delete all non-winning scores */

-       if (cheat) winner=0;    /* if he cheated, don't let him win */
-       if (winner)
-               {
-               for (i=0; i<SCORESIZE; i++) if (sco[i].suid == userid) sco[i].score=0;
-               taxes = score*TAXRATE;
-               score += 100000*c[HARDGAME];    /* bonus for winning */
-       /* if he has a slot on the winning scoreboard update it if greater score */
-               for (i=0; i<SCORESIZE; i++) if (winr[i].suid == userid)
-                               { new1sub(score,i,whoo,taxes); return; }
-       /* he had no entry. look for last entry and see if he has a greater score */
-               for (i=0; i<SCORESIZE; i++) if (winr[i].order == SCORESIZE-1)
-                               { new1sub(score,i,whoo,taxes); return; }
-               }
-       else if (!cheat) /* for not winning scoreboard */
-               {
-       /* if he has a slot on the scoreboard update it if greater score */
-               for (i=0; i<SCORESIZE; i++) if (sco[i].suid == userid)
-                               { new2sub(score,i,whoo,whyded); return; }
-       /* he had no entry. look for last entry and see if he has a greater score */
-               for (i=0; i<SCORESIZE; i++) if (sco[i].order == SCORESIZE-1)
-                               { new2sub(score,i,whoo,whyded); return; }
-               }
+       if (cheat)
+               winner = 0;     /* if he cheated, don't let him win */
+       if (winner) {
+               for (i = 0; i < SCORESIZE; i++)
+                       if (sco[i].suid == userid)
+                               sco[i].score = 0;
+               taxes = score * TAXRATE;
+               score += 100000 * c[HARDGAME];  /* bonus for winning */
+               /*
+                * if he has a slot on the winning scoreboard update it if
+                * greater score
+                */
+               for (i = 0; i < SCORESIZE; i++)
+                       if (winr[i].suid == userid) {
+                               new1sub(score, i, whoo, taxes);
+                               return;
+                       }
+               /*
+                * he had no entry. look for last entry and see if he has a
+                * greater score
+                */
+               for (i = 0; i < SCORESIZE; i++)
+                       if (winr[i].order == SCORESIZE - 1) {
+                               new1sub(score, i, whoo, taxes);
+                               return;
+                       }
+       } else if (!cheat) {    /* for not winning scoreboard */
+               /*
+                * if he has a slot on the scoreboard update it if greater
+                * score
+                */
+               for (i = 0; i < SCORESIZE; i++)
+                       if (sco[i].suid == userid) {
+                               new2sub(score, i, whoo, whyded);
+                               return;
+                       }
+               /*
+                * he had no entry. look for last entry and see if he has a
+                * greater score
+                */
+               for (i = 0; i < SCORESIZE; i++)
+                       if (sco[i].order == SCORESIZE - 1) {
+                               new2sub(score, i, whoo, whyded);
+                               return;
+                       }

        }
        }

+}

 
 /*
 
 /*

- *     new1sub(score,i,whoo,taxes)       Subroutine to put player into a 
- *             int score,i,whyded,taxes;                 winning scoreboard entry if his score
- *             char *whoo;                                       is high enough
+ * new1sub(score,i,whoo,taxes)           Subroutine to put player into a
+ *     int score,i,whyded,taxes;                 winning scoreboard entry if his score
+ *     char *whoo;                                       is high enough

  *
  *

- *     Enter with the total score in gp in score,  players name in whoo,
- *             died() reason # in whyded, and TRUE/FALSE in winner if a winner
- *             slot in scoreboard in i, and the tax bill in taxes.
- *     Returns nothing of value
+ * Enter with the total score in gp in score,  players name in whoo,
+ *     died() reason # in whyded, and TRUE/FALSE in winner if a winner
+ *     slot in scoreboard in i, and the tax bill in taxes.
+ * Returns nothing of value

  */
  */

-new1sub(score,i,whoo,taxes)
-       long score,taxes;
-       int i;
-       char *whoo;
-       {
-       register struct wscofmt *p;
+void
+new1sub(score, i, whoo, taxes)
+       long            score, taxes;
+       int             i;
+       char           *whoo;
+{
+       struct wscofmt *p;

        p = &winr[i];
        p->taxes += taxes;
        p = &winr[i];
        p->taxes += taxes;

-       if ((score >= p->score) || (c[HARDGAME] > p->hardlev))
-               {
-               strcpy(p->who,whoo);            p->score=score;
-               p->hardlev=c[HARDGAME];         p->suid=userid;
-               p->timeused=gtime/100;
-               }
+       if ((score >= p->score) || (c[HARDGAME] > p->hardlev)) {
+               strcpy(p->who, whoo);
+               p->score = score;
+               p->hardlev = c[HARDGAME];
+               p->suid = userid;
+               p->timeused = gltime / 100;

        }
        }

+}

 
 /*
 
 /*

- *     new2sub(score,i,whoo,whyded)              Subroutine to put player into a 
- *             int score,i,whyded,taxes;                 non-winning scoreboard entry if his
- *             char *whoo;                                       score is high enough
+ * new2sub(score,i,whoo,whyded)                  Subroutine to put player into a
+ *     int score,i,whyded,taxes;                 non-winning scoreboard entry if his
+ *     char *whoo;                                       score is high enough

  *
  *

- *     Enter with the total score in gp in score,  players name in whoo,
- *             died() reason # in whyded, and slot in scoreboard in i.
- *     Returns nothing of value
+ * Enter with the total score in gp in score,  players name in whoo,
+ *     died() reason # in whyded, and slot in scoreboard in i.
+ * Returns nothing of value

  */
  */

-new2sub(score,i,whoo,whyded)
-       long score;
-       int i,whyded;
-       char *whoo;
-       {
-       register int j;
-       register struct scofmt *p;
+void
+new2sub(score, i, whoo, whyded)
+       long            score;
+       int             i, whyded;
+       char           *whoo;
+{
+       int    j;
+       struct scofmt *p;

        p = &sco[i];
        p = &sco[i];

-       if ((score >= p->score) || (c[HARDGAME] > p->hardlev))
-               {
-               strcpy(p->who,whoo);  p->score=score;
-               p->what=whyded;       p->hardlev=c[HARDGAME];
-               p->suid=userid;           p->level=level;
-               for (j=0; j<26; j++)
-                       { p->sciv[j][0]=iven[j]; p->sciv[j][1]=ivenarg[j]; }
+       if ((score >= p->score) || (c[HARDGAME] > p->hardlev)) {
+               strcpy(p->who, whoo);
+               p->score = score;
+               p->what = whyded;
+               p->hardlev = c[HARDGAME];
+               p->suid = userid;
+               p->level = level;
+               for (j = 0; j < 26; j++) {
+                       p->sciv[j][0] = iven[j];
+                       p->sciv[j][1] = ivenarg[j];

                }
        }
                }
        }

+}

 
 /*
 
 /*

- *     died(x)         Subroutine to record who played larn, and what the score was
- *             int x;
+ * died(x)     Subroutine to record who played larn, and what the score was
+ *     int x;

  *
  *

- *     if x < 0 then don't show scores
- *     died() never returns! (unless c[LIFEPROT] and a reincarnatable death!)
+ * if x < 0 then don't show scores
+ * died() never returns! (unless c[LIFEPROT] and a reincarnatable death!)

  *
  *

- *             < 256   killed by the monster number
- *             256             quit
- *             257             suspended
- *             258             self - annihilated
- *             259             shot by an arrow
- *             260             hit by a dart
- *             261             fell into a pit
- *             262             fell into a bottomless pit
- *             263             a winner
- *             264             trapped in solid rock
- *             265             killed by a missing save file
- *             266             killed by an old save file
- *             267             caught by the greedy cheater checker trap
- *             268             killed by a protected save file
- *             269             killed his family and killed himself
- *             270             erased by a wayward finger
- *             271             fell through a bottomless trap door
- *             272             fell through a trap door
- *             273             drank some poisonous water
- *             274             fried by an electric shock
- *             275             slipped on a volcano shaft
- *             276             killed by a stupid act of frustration
- *             277             attacked by a revolting demon
- *             278             hit by his own magic
- *             279             demolished by an unseen attacker
- *             280             fell into the dreadful sleep
- *             281             killed by an exploding chest
- *             282             killed by a missing maze data file
- *             283             killed by a sphere of annihilation
- *             284             died a post mortem death
- *             285             malloc() failure
- *             300             quick quit -- don't put on scoreboard
+ *     < 256   killed by the monster number
+ *     256             quit
+ *     257             suspended
+ *     258             self - annihilated
+ *     259             shot by an arrow
+ *     260             hit by a dart
+ *     261             fell into a pit
+ *     262             fell into a bottomless pit
+ *     263             a winner
+ *     264             trapped in solid rock
+ *     265             killed by a missing save file
+ *     266             killed by an old save file
+ *     267             caught by the greedy cheater checker trap
+ *     268             killed by a protected save file
+ *     269             killed his family and killed himself
+ *     270             erased by a wayward finger
+ *     271             fell through a bottomless trap door
+ *     272             fell through a trap door
+ *     273             drank some poisonous water
+ *     274             fried by an electric shock
+ *     275             slipped on a volcano shaft
+ *     276             killed by a stupid act of frustration
+ *     277             attacked by a revolting demon
+ *     278             hit by his own magic
+ *     279             demolished by an unseen attacker
+ *     280             fell into the dreadful sleep
+ *     281             killed by an exploding chest
+ *     282             killed by a missing maze data file
+ *     283             killed by a sphere of annihilation
+ *     284             died a post mortem death
+ *     285             malloc() failure
+ *     300             quick quit -- don't put on scoreboard

  */
 
  */
 

-static int scorerror;
+static int      scorerror;
+void

 died(x)
 died(x)

-       int x;
-       {
-       register int f,win;
-       char ch,*mod;
-       time_t zzz;
-       long i;
-       struct tms cputime;
-       if (c[LIFEPROT]>0) /* if life protection */
-               {
-               switch((x>0) ? x : -x)
-                       {
-                       case 256: case 257: case 262: case 263: case 265: case 266:
-                       case 267: case 268: case 269: case 271: case 282: case 284:
-                       case 285: case 300:  goto invalid; /* can't be saved */
-                       };
-               --c[LIFEPROT]; c[HP]=1; --c[CONSTITUTION];
-               cursors(); lprcat("\nYou feel wiiieeeeerrrrrd all over! "); beep();
-               lflush();  sleep(4);
-               return; /* only case where died() returns */
-               }
+       int             x;
+{
+       int    f, win;
+       char            ch, *mod;
+       time_t          zzz;
+       if (c[LIFEPROT] > 0) {  /* if life protection */
+               switch ((x > 0) ? x : -x) {
+               case 256:
+               case 257:
+               case 262:
+               case 263:
+               case 265:
+               case 266:
+               case 267:
+               case 268:
+               case 269:
+               case 271:
+               case 282:
+               case 284:
+               case 285:
+               case 300:
+                       goto invalid;   /* can't be saved */
+               };
+               --c[LIFEPROT];
+               c[HP] = 1;
+               --c[CONSTITUTION];
+               cursors();
+               lprcat("\nYou feel wiiieeeeerrrrrd all over! ");
+               beep();
+               lflush();
+               sleep(4);
+               return;         /* only case where died() returns */
+       }

 invalid:
 invalid:

-       clearvt100();  lflush();  f=0;
-       if (ckpflag) unlink(ckpfile);   /* remove checkpoint file if used */
-       if (x<0) { f++; x = -x; }       /* if we are not to display the scores */
-       if ((x == 300) || (x == 257))  exit();  /* for quick exit or saved game */
-       if (x == 263)  win = 1;  else  win = 0;
-       c[GOLD] += c[BANKACCOUNT];   c[BANKACCOUNT] = 0;
-               /*      now enter the player at the end of the scoreboard */
+       clearvt100();
+       lflush();
+       f = 0;
+       if (ckpflag)
+               unlink(ckpfile);/* remove checkpoint file if used */
+       if (x < 0) {
+               f++;
+               x = -x;
+       }                       /* if we are not to display the scores */
+       if ((x == 300) || (x == 257))
+               exit(0);                /* for quick exit or saved game */
+       if (x == 263)
+               win = 1;
+       else
+               win = 0;
+       c[GOLD] += c[BANKACCOUNT];
+       c[BANKACCOUNT] = 0;
+       /* now enter the player at the end of the scoreboard */

        newscore(c[GOLD], logname, x, win);
        newscore(c[GOLD], logname, x, win);

-       diedsub(x);     /* print out the score line */  lflush();
+       diedsub(x);             /* print out the score line */
+       lflush();

 
        set_score_output();
 
        set_score_output();

-       if ((wizard == 0) && (c[GOLD] > 0))     /*      wizards can't score             */
-               {
+       if ((wizard == 0) && (c[GOLD] > 0)) {   /* wizards can't score           */

 #ifndef NOLOG
 #ifndef NOLOG

-               if (lappend(logfile)<0)  /* append to file */
-                       {
-                       if (lcreat(logfile)<0) /* and can't create new log file */
-                       {
-                               lcreat((char*)0);
+               seteuid(euid);
+               if (lappend(logfile) < 0) {     /* append to file */
+                       if (lcreat(logfile) < 0) {      /* and can't create new
+                                                        * log file */
+                               lcreat((char *) 0);

                                lprcat("\nCan't open record file:  I can't post your score.\n");
                                lprcat("\nCan't open record file:  I can't post your score.\n");

-                               sncbr();  resetscroll();  lflush();  exit();
-                               }
+                               sncbr();
+                               resetscroll();
+                               lflush();
+                               exit(0);
+                       }

                        seteuid(euid);
                        seteuid(euid);

-                       chmod(logfile,0660);
+                       chmod(logfile, 0660);

                        seteuid(uid);
                        seteuid(uid);

-                       }
-               strcpy(logg.who,loginname);
-               logg.score = c[GOLD];           logg.diff = c[HARDGAME];
-               if (x < 256)
-                       {
+               }
+               seteuid(uid);
+               strcpy(logg.who, loginname);
+               logg.score = c[GOLD];
+               logg.diff = c[HARDGAME];
+               if (x < 256) {

                        ch = *monster[x].name;
                        ch = *monster[x].name;

-                       if (ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u')
-                               mod="an";  else mod="a";
-                       sprintf(logg.what,"killed by %s %s",mod,monster[x].name);
-                       }
-               else sprintf(logg.what,"%s",whydead[x - 256]);
-               logg.cavelev=level;
-               time(&zzz);       /* get cpu time -- write out score info */
-               logg.diedtime=zzz;
+                       if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
+                               mod = "an";
+                       else
+                               mod = "a";
+                       snprintf(logg.what, sizeof(logg.what),
+                           "killed by %s %s", mod, monster[x].name);
+               } else
+                       snprintf(logg.what, sizeof(logg.what),
+                           "%s", whydead[x - 256]);
+               logg.cavelev = level;
+               time(&zzz);     /* get CPU time -- write out score info */
+               logg.diedtime = zzz;

 #ifdef EXTRA
 #ifdef EXTRA

-               times(&cputime);  /* get cpu time -- write out score info */
-               logg.cputime = i = (cputime.tms_utime + cputime.tms_stime)/60 + c[CPUTIME];
-               logg.lev=c[LEVEL];                      logg.ac=c[AC];
-               logg.hpmax=c[HPMAX];            logg.hp=c[HP];
-               logg.elapsedtime=(zzz-initialtime+59)/60;
-               logg.usage=(10000*i)/(zzz-initialtime);
-               logg.bytin=c[BYTESIN];          logg.bytout=c[BYTESOUT];
-               logg.moves=c[MOVESMADE];        logg.spused=c[SPELLSCAST];
-               logg.killed=c[MONSTKILLED];
+               times(&cputime);/* get CPU time -- write out score info */
+               logg.cputime = i = (cputime.tms_utime + cputime.tms_stime) / 60 + c[CPUTIME];
+               logg.lev = c[LEVEL];
+               logg.ac = c[AC];
+               logg.hpmax = c[HPMAX];
+               logg.hp = c[HP];
+               logg.elapsedtime = (zzz - initialtime + 59) / 60;
+               logg.usage = (10000 * i) / (zzz - initialtime);
+               logg.bytin = c[BYTESIN];
+               logg.bytout = c[BYTESOUT];
+               logg.moves = c[MOVESMADE];
+               logg.spused = c[SPELLSCAST];
+               logg.killed = c[MONSTKILLED];

 #endif
 #endif

-               lwrite((char*)&logg,sizeof(struct log_fmt));     lwclose();
-#endif NOLOG
+               lwrite((char *) &logg, sizeof(struct log_fmt));
+               lwclose();
+#endif /* NOLOG */

 
 

-/*     now for the scoreboard maintenance -- not for a suspended game  */
-               if (x != 257)
-                       {
-                       if (sortboard())  scorerror = writeboard();
-                       }
+               /*
+                * now for the scoreboard maintenance -- not for a suspended
+                * game
+                */
+               if (x != 257) {
+                       if (sortboard())
+                               scorerror = writeboard();

                }
                }

-       if ((x==256) || (x==257) || (f != 0)) exit();
-       if (scorerror == 0) showscores();       /* if we updated the scoreboard */
-       if (x == 263) mailbill();               exit();

        }
        }

+       if ((x == 256) || (x == 257) || (f != 0))
+               exit(0);
+       if (scorerror == 0)
+               showscores();   /* if we updated the scoreboard */
+       if (x == 263)
+               mailbill();
+       exit(0);
+}

 
 /*
 
 /*

- *     diedsub(x) Subroutine to print out the line showing the player when he is killed
- *             int x;
+ * diedsub(x) Subroutine to print out the line showing the player when he is killed
+ *     int x;

  */
  */

+void

 diedsub(x)
 diedsub(x)

-int x;
-       {
-       register char ch,*mod;
-       lprintf("Score: %d, Diff: %d,  %s ",(long)c[GOLD],(long)c[HARDGAME],logname);
-       if (x < 256)
-               {
+       int             x;
+{
+       char   ch, *mod;
+       lprintf("Score: %d, Diff: %d,  %s ", (long) c[GOLD], (long) c[HARDGAME], logname);
+       if (x < 256) {

                ch = *monster[x].name;
                ch = *monster[x].name;

-               if (ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u')
-                       mod="an";  else mod="a";
-               lprintf("killed by %s %s",mod,monster[x].name);
-               }
-       else lprintf("%s",whydead[x - 256]);
-       if (x != 263) lprintf(" on %s\n",levelname[level]);  else lprc('\n');
-       }
+               if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
+                       mod = "an";
+               else
+                       mod = "a";
+               lprintf("killed by %s %s", mod, monster[x].name);
+       } else
+               lprintf("%s", whydead[x - 256]);
+       if (x != 263)
+               lprintf(" on %s\n", levelname[level]);
+       else
+               lprc('\n');
+}

 
 /*
 
 /*

- *     diedlog()       Subroutine to read a log file and print it out in ascii format
+ * diedlog()   Subroutine to read a log file and print it out in ascii format

  */
  */

+void

 diedlog()
 diedlog()

-       {
-       register int n;
-       register char *p;
-       struct stat stbuf;
-       lcreat((char*)0);
-       if (lopen(logfile)<0)
-               {
-               lprintf("Can't locate log file <%s>\n",logfile);
+{
+       int    n;
+       char  *p;
+       struct stat     stbuf;
+       lcreat((char *) 0);
+       if (lopen(logfile) < 0) {
+               lprintf("Can't locate log file <%s>\n", logfile);

                return;
                return;

-               }
-       if (fstat(fd,&stbuf) < 0)
-               {
-               lprintf("Can't  stat log file <%s>\n",logfile);
+       }
+       if (fstat(fd, &stbuf) < 0) {
+               lprintf("Can't  stat log file <%s>\n", logfile);

                return;
                return;

-               }
-       for (n=stbuf.st_size/sizeof(struct log_fmt); n>0; --n)
-               {
-               lrfill((char*)&logg,sizeof(struct log_fmt));
-               p = ctime(&logg.diedtime); p[16]='\n'; p[17]=0;
-               lprintf("Score: %d, Diff: %d,  %s %s on %d at %s",(long)(logg.score),(long)(logg.diff),logg.who,logg.what,(long)(logg.cavelev),p+4);
+       }
+       for (n = stbuf.st_size / sizeof(struct log_fmt); n > 0; --n) {
+               lrfill((char *) &logg, sizeof(struct log_fmt));
+               p = ctime(&logg.diedtime);
+               p[16] = '\n';
+               p[17] = 0;
+               lprintf("Score: %d, Diff: %d,  %s %s on %d at %s", (long) (logg.score), (long) (logg.diff), logg.who, logg.what, (long) (logg.cavelev), p + 4);

 #ifdef EXTRA
 #ifdef EXTRA

-               if (logg.moves<=0) logg.moves=1;
-               lprintf("  Experience Level: %d,  AC: %d,  HP: %d/%d,  Elapsed Time: %d minutes\n",(long)(logg.lev),(long)(logg.ac),(long)(logg.hp),(long)(logg.hpmax),(long)(logg.elapsedtime));
-               lprintf("  CPU time used: %d seconds,  Machine usage: %d.%02d%%\n",(long)(logg.cputime),(long)(logg.usage/100),(long)(logg.usage%100));
-               lprintf("  BYTES in: %d, out: %d, moves: %d, deaths: %d, spells cast: %d\n",(long)(logg.bytin),(long)(logg.bytout),(long)(logg.moves),(long)(logg.killed),(long)(logg.spused));
-               lprintf("  out bytes per move: %d,  time per move: %d ms\n",(long)(logg.bytout/logg.moves),(long)((logg.cputime*1000)/logg.moves));
+               if (logg.moves <= 0)
+                       logg.moves = 1;
+               lprintf("  Experience Level: %d,  AC: %d,  HP: %d/%d,  Elapsed Time: %d minutes\n", (long) (logg.lev), (long) (logg.ac), (long) (logg.hp), (long) (logg.hpmax), (long) (logg.elapsedtime));
+               lprintf("  CPU time used: %d seconds,  Machine usage: %d.%02d%%\n", (long) (logg.cputime), (long) (logg.usage / 100), (long) (logg.usage % 100));
+               lprintf("  BYTES in: %d, out: %d, moves: %d, deaths: %d, spells cast: %d\n", (long) (logg.bytin), (long) (logg.bytout), (long) (logg.moves), (long) (logg.killed), (long) (logg.spused));
+               lprintf("  out bytes per move: %d,  time per move: %d ms\n", (long) (logg.bytout / logg.moves), (long) ((logg.cputime * 1000) / logg.moves));

 #endif
 #endif

-               }
-               lflush();  lrclose();  return;

        }
        }

+       lflush();
+       lrclose();
+       return;
+}

 
 #ifndef UIDSCORE
 /*
 
 #ifndef UIDSCORE
 /*

- *     getplid(name)           Function to get players id # from id file
+ * getplid(name)               Function to get players id # from id file

  *
  *

- *     Enter with the name of the players character in name.
- *     Returns the id # of the players character, or -1 if failure.
- *     This routine will try to find the name in the id file, if its not there,
- *     it will try to make a new entry in the file.  Only returns -1 if can't
- *     find him in the file, and can't make a new entry in the file.
- *     Format of playerids file:
- *                     Id # in ascii     \n     character name     \n   
+ * Enter with the name of the players character in name.
+ * Returns the id # of the players character, or -1 if failure.
+ * This routine will try to find the name in the id file, if its not there,
+ * it will try to make a new entry in the file.  Only returns -1 if can't
+ * find him in the file, and can't make a new entry in the file.
+ * Format of playerids file:
+ *             Id # in ascii     \n     character name     \n

  */
  */

-static int havepid= -1;        /* playerid # if previously done */
+static int      havepid = -1;  /* playerid # if previously done */
+int

 getplid(nam)
 getplid(nam)

-       char *nam;
-       {
-       int fd7,high=999,no;
-       register char *p,*p2;
-       char name[80];
-       if (havepid != -1) return(havepid);     /* already did it */
-       lflush();       /* flush any pending I/O */
-       sprintf(name,"%s\n",nam);       /* append a \n to name */
-       if (lopen(playerids) < 0)       /* no file, make it */
-               {
-               if ((fd7=creat(playerids,0666)) < 0)  return(-1); /* can't make it */
-               close(fd7);  goto addone;       /* now append new playerid record to file */
-               }
-       for (;;)        /* now search for the name in the player id file */
-               {
-               p = lgetl();  if (p==NULL) break;       /* EOF? */
+       char           *nam;
+{
+       int             fd7, high = 999, no;
+       char  *p, *p2;
+       char            name[80];
+       if (havepid != -1)
+               return (havepid);       /* already did it */
+       lflush();               /* flush any pending I/O */
+       snprintf(name, sizeof(name), "%s\n", nam);/* append a \n to name */
+       if (lopen(playerids) < 0) {     /* no file, make it */
+               if ((fd7 = creat(playerids, 0666)) < 0)
+                       return (-1);    /* can't make it */
+               close(fd7);
+               goto addone;    /* now append new playerid record to file */
+       }
+       for (;;) {              /* now search for the name in the player id
+                                * file */
+               p = lgetl();
+               if (p == NULL)
+                       break;  /* EOF? */

                no = atoi(p);   /* the id # */
                no = atoi(p);   /* the id # */

-               p2= lgetl();  if (p2==NULL) break;      /* EOF? */
-               if (no>high) high=no;   /* accumulate highest id # */
-               if (strcmp(p2,name)==0) /* we found him */
-                       {
-                       return(no);     /* his id number */
-                       }
+               p2 = lgetl();
+               if (p2 == NULL)
+                       break;  /* EOF? */
+               if (no > high)
+                       high = no;      /* accumulate highest id # */
+               if (strcmp(p2, name) == 0) {    /* we found him */
+                       return (no);    /* his id number */

                }
                }

+       }

        lrclose();
        /* if we get here, we didn't find him in the file -- put him there */
 addone:
        lrclose();
        /* if we get here, we didn't find him in the file -- put him there */
 addone:

-       if (lappend(playerids) < 0) return(-1); /* can't open file for append */
-       lprintf("%d\n%s",(long)++high,name);  /* new id # and name */
+       if (lappend(playerids) < 0)
+               return (-1);    /* can't open file for append */
+       lprintf("%d\n%s", (long) ++high, name); /* new id # and name */

        lwclose();
        lwclose();

-       lcreat((char*)0);       /* re-open terminal channel */
-       return(high);
-       }
-#endif UIDSCORE
-
+       lcreat((char *) 0);     /* re-open terminal channel */
+       return (high);
+}
+#endif /* UIDSCORE */