/* scores.c
 *
 *  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
 */
#ifdef VMS
# include <types.h>
# include <stat.h>
#else
# include <sys/types.h>
# ifndef MSDOS
#  ifndef AMIGA
#   include <sys/times.h>
#  endif AMIGA
# endif MSDOS
# include <sys/stat.h>
#endif
#include "header.h"
#include "larndefs.h"
#include "monsters.h"
#include "objects.h"
#include "player.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        */
# ifndef MAIL           /* dgk */
    char hasmail;       /* 1 if mail is to be read, 0 otherwise */
# endif
    char who[40];       /* the name of the character                        */
    };

struct log_fmt          /* 102 bytes struct for the log file                */
    {
    long score;         /* the players score                                */
    long diedtime;      /* time when game was over                          */
    short cavelev;      /* level in caves                                   */
    short diff;         /* difficulty player played at                      */
#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                                     */
#endif
    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 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",
    "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",
/*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
 *
 *  returns -1 if unable to read in the scoreboard, returns 0 if all is OK
 */
static readboard()
    {
    if (lopen(scorefile)<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
 *
 *  returns -1 if unable to write the scoreboard, returns 0 if all is OK
 */
static writeboard()
    {
    set_score_output();
    if (lcreat(scorefile)<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)
 *
 *  returns -1 if unable to write the scoreboard, returns 0 if all is OK
 */
makeboard()
    {
    register 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;
        }
    if (writeboard()) return(-1);
    chmod(scorefile,0666);
    return(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.
 */
hashewon()
    {
    register int i;
    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);
            }
    return(0);
    }

# ifndef MAIL           /* dgk */
checkmail()
{
    register int    i;
    long        gold, taxes;

    if (readboard() < 0)
        return;         /* can't find scoreboard */
    for (i = 0; i < SCORESIZE; i++) /* search through winners scoreboard */
        if (winr[i].suid == userid
        &&  winr[i].score > 0
        &&  winr[i].hasmail) {
            winr[i].hasmail = 0;
            gold = taxes = winr[i].taxes;
            writeboard();

            /* Intuit the amount of gold -- should have changed
             * the score file, but ...  TAXRATE is an fraction.
             */
            while ((gold * TAXRATE) < taxes)
                gold += taxes;
            readmail(gold);
        }
}
# endif


/*
 *  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.
 */
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 */
                {
                amt = winr[i].taxes;
                if (x < amt) amt=x;     /* don't overpay taxes (Ughhhhh) */
                winr[i].taxes -= amt;
                outstanding_taxes -= amt;
                if (writeboard()<0) return(0);
                return(amt);
                }
    return(0L); /* couldn't find user on winning scoreboard */
    }

/*
 *  winshou()       Subroutine to print out the winning scoreboard
 *
 *  Returns the number of players on scoreboard that were shown 
 */
static 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)
        {
        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);
                    }
                break;
                }
            }
        }
    return(count);  /* return number of people on scoreboard */
    }

/*
 *  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 
 */
static 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)
        {
        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]) show3(n);
                        lprcat("\n\n");
                        }
                    else lprc('\n');
                    }
                j=SCORESIZE;
                }
        }
    return(count);  /* return the number of players just shown */
    }

/*
 *  showscores()        Function to show the scoreboard on the terminal
 *
 *  Returns nothing of value
 */
static char esb[] = "The scoreboard is empty.\n";
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');
    lflush();
    }

/*
 *  showallscores() Function to show scores and the iven lists that go with them
 *
 *  Returns nothing of value
 */
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][0]=' ';
    for (i=0; i<MAXSCROLL; i++) scrollname[i][0]=' ';
    i=winshou();  j=shou(1);
    if (i+j==0) lprcat(esb); else lprc('\n');
    lflush();
    }

/*
 *  sortboard()     Function to sort the scoreboard
 *
 *  Returns 0 if no sorting done, else returns 1
 */
static 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; }
        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; }
        winr[j].order = pos++;
        }
    return(1);
    }

/*
 *  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);
 */
static newscore(score, whoo, whyded, winner)
    long score;
    int winner, whyded;
    char *whoo;
    {
    register int i;
    long taxes;
    if (readboard() < 0) return;    /*  do the scoreboard   */
    /* 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; }
        }
    }

/*
 *  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
 */
static new1sub(score,i,whoo,taxes)
    long score,taxes;
    int i;
    char *whoo;
    {
    register struct wscofmt *p;
    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;
# ifndef MAIL           /* dgk */
        p->hasmail = 1;
# endif
        }
    }

/*
 *  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
 */
static new2sub(score,i,whoo,whyded)
    long score;
    int i,whyded;
    char *whoo;
    {
    register int j;
    register struct scofmt *p;
    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]; }
        }
    }

/*
 *  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!)
 *
 *      < 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;
died(x)
    int x;
    {
    register int f,win;
    char ch,*mod;
    long zzz,i;
# ifdef EXTRA
    struct tms cputime;
# endif
    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:
    clearvt100();  lflush();  f=0;
    if (ckpflag) unlink(ckpfile);   /* remove checkpoint file if used */
# ifdef MSDOS
    if (swapfd) {
        close(swapfd);
        (void) unlink(swapfile);/* Remove swapfile */
    }
    unsetraw();
# endif
    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 */
    newscore(c[GOLD], logname, x, win);
    diedsub(x); /* print out the score line */  lflush();

    set_score_output();
    if ((wizard == 0) && (c[GOLD] > 0))     /*  wizards can't score     */
        {
        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");
                sncbr();  resetscroll();  lflush();  exit();
                }
            chmod(logfile,0666);
            }
        strcpy(logg.who,loginname);
        logg.score = c[GOLD];       logg.diff = c[HARDGAME];
        if (x < 256)
            {
            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;
#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];
#endif
        lwrite((char*)&logg,sizeof(struct log_fmt));     lwclose();

/*  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 */
# ifdef MAIL
    if (x == 263) mailbill();
# endif
    exit();
    }

/*
 *  diedsub(x) Subroutine to print out the line showing the player when he is killed
 *      int x;
 */
static diedsub(x)
int x;
    {
    register char ch,*mod;
    lprintf("Score: %d, Diff: %d,  %s ",(long)c[GOLD],(long)c[HARDGAME],logname);
    if (x < 256)
        {
        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');
    }

/*
 *  diedlog()   Subroutine to read a log file and print it out in ascii format
 */
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);
        return;
        }
#ifdef AMIGA
    if (stat(logfile,&stbuf) < 0)
#else
    if (fstat(fd,&stbuf) < 0)
#endif /* AMIGA */
        {
        lprintf("Can't  stat log file <%s>\n",logfile);
        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);
#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));
#endif
        }
        lflush();  lrclose();  return;
    }

#ifndef UIDSCORE
/*
 *  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   
 */
static int havepid= -1; /* playerid # if previously done */
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? */
        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 */
            }
        }
    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 */
    lwclose();
    lcreat((char*)0);   /* re-open terminal channel */
    return(high);
    }
#endif UIDSCORE