Fix two typos

[dragonfly.git] / games / larn / scores.c

/* scores.c                      Larn is copyrighted 1986 by Noah Morgan.
 * $FreeBSD: src/games/larn/scores.c,v 1.6 1999/11/16 02:57:24 billf Exp $
 * $DragonFly: src/games/larn/scores.c,v 1.4 2006/08/26 17:05:05 pavalos Exp $
 *
 *      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
 *
 */
#include <sys/types.h>
#include <sys/times.h>
#include <sys/stat.h>
#include "header.h"

static int      readboard(void);
static int      writeboard(void);
static int      winshou(void);
static int      shou(int);
static int      sortboard(void);
static void     newscore(long, char *, int, int);
static void     new1sub(long, int, char *, long);
static void     new2sub(long, int, char *, int);
static void     diedsub(int);

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                                          */
#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 const 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 int
readboard(void)
        {
        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 int
writeboard(void)
        {
        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
 */
int
makeboard(void)
        {
        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,0660);
        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.
 */
int
hashewon(void)
        {
        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);
        }

/*
 *      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(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;
                                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 int
winshou(void)
        {
        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");

                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 int
shou(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");
                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;
                                }
                }
        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";

void
showscores(void)
        {
        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
 */
void
showallscores(void)
        {
        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');
        lflush();
        }

/*
 *      sortboard()             Function to sort the scoreboard
 *
 *      Returns 0 if no sorting done, else returns 1
 */
static int
sortboard(void)
        {
        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++;
                }
        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 void
newscore(long score, char *whoo, int whyded, int winner)
        {
        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 void
new1sub(long score, int i, char *whoo, long taxes)
        {
        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;
                }
        }

/*
 *      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 void
new2sub(long score, int i, char *whoo, int whyded)
        {
        int j;
        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;

void
died(int x)
        {
        int f,win;
        char ch;
        const char *mod;
        time_t zzz;
#ifdef EXTRA
        long i;
        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 */
        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);
        diedsub(x);     /* print out the score line */  lflush();

        set_score_output();
        if ((wizard == 0) && (c[GOLD] > 0))     /*      wizards can't score             */
                {
#ifndef NOLOG
                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(1);
                                }
                        chmod(logfile,0660);
                        }
                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();
#endif /* NOLOG */

/*      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(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;
 */
static void
diedsub(int x)
        {
        char ch;
        const char *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[(int)level]);  else lprc('\n');
        }

/*
 *      diedlog()       Subroutine to read a log file and print it out in ascii format
 */
void
diedlog(void)
        {
        int n;
        char *p;
        struct stat stbuf;
        lcreat((char*)0);
        if (lopen(logfile)<0)
                {
                lprintf("Can't locate log file <%s>\n",logfile);
                return;
                }
        if (fstat(fd,&stbuf) < 0)
                {
                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 */

int
getplid(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 */
        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 */