![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scores.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / larn|
Return to scores.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / larn |
1.1 root 1: /* scores.c Larn is copyrighted 1986 by Noah Morgan.
2: *
3: * Functions in this file are:
4: *
5: * readboard() Function to read in the scoreboard into a static buffer
6: * writeboard() Function to write the scoreboard from readboard()'s buffer
7: * makeboard() Function to create a new scoreboard (wipe out old one)
8: * hashewon() Function to return 1 if player has won a game before, else 0
9: * long paytaxes(x) Function to pay taxes if any are due
10: * winshou() Subroutine to print out the winning scoreboard
11: * shou(x) Subroutine to print out the non-winners scoreboard
12: * showscores() Function to show the scoreboard on the terminal
13: * showallscores() Function to show scores and the iven lists that go with them
14: * sortboard() Function to sort the scoreboard
15: * newscore(score, whoo, whyded, winner) Function to add entry to scoreboard
16: * new1sub(score,i,whoo,taxes) Subroutine to put player into a
17: * new2sub(score,i,whoo,whyded) Subroutine to put player into a
18: * died(x) Subroutine to record who played larn, and what the score was
19: * diedsub(x) Subroutine to print out a line showing player when he is killed
20: * diedlog() Subroutine to read a log file and print it out in ascii format
21: * getplid(name) Function to get players id # from id file
22: *
23: */
24: #include <sys/types.h>
25: #include <sys/times.h>
26: #include <sys/stat.h>
27: #include "header.h"
28:
29: struct scofmt /* This is the structure for the scoreboard */
30: {
31: long score; /* the score of the player */
32: long suid; /* the user id number of the player */
33: short what; /* the number of the monster that killed player */
34: short level; /* the level player was on when he died */
35: short hardlev; /* the level of difficulty player played at */
36: short order; /* the relative ordering place of this entry */
37: char who[40]; /* the name of the character */
38: char sciv[26][2]; /* this is the inventory list of the character */
39: };
40: struct wscofmt /* This is the structure for the winning scoreboard */
41: {
42: long score; /* the score of the player */
43: long timeused; /* the time used in mobuls to win the game */
44: long taxes; /* taxes he owes to LRS */
45: long suid; /* the user id number of the player */
46: short hardlev; /* the level of difficulty player played at */
47: short order; /* the relative ordering place of this entry */
48: char who[40]; /* the name of the character */
49: };
50:
51: struct log_fmt /* 102 bytes struct for the log file */
52: {
53: long score; /* the players score */
54: long diedtime; /* time when game was over */
55: short cavelev; /* level in caves */
56: short diff; /* difficulty player played at */
57: #ifdef EXTRA
58: long elapsedtime; /* real time of game in seconds */
59: long bytout; /* bytes input and output */
60: long bytin;
61: long moves; /* number of moves made by player */
62: short ac; /* armor class of player */
63: short hp,hpmax; /* players hitpoints */
64: short cputime; /* cpu time needed in seconds */
65: short killed,spused;/* monsters killed and spells cast */
66: short usage; /* usage of the cpu in % */
67: short lev; /* player level */
68: #endif
69: char who[12]; /* player name */
70: char what[46]; /* what happened to player */
71: };
72:
73: static struct scofmt sco[SCORESIZE]; /* the structure for the scoreboard */
74: static struct wscofmt winr[SCORESIZE]; /* struct for the winning scoreboard */
75: static struct log_fmt logg; /* structure for the log file */
76: static char *whydead[] = {
77: "quit", "suspended", "self - annihilated", "shot by an arrow",
78: "hit by a dart", "fell into a pit", "fell into a bottomless pit",
79: "a winner", "trapped in solid rock", "killed by a missing save file",
80: "killed by an old save file", "caught by the greedy cheater checker trap",
81: "killed by a protected save file","killed his family and committed suicide",
82: "erased by a wayward finger", "fell through a bottomless trap door",
83: "fell through a trap door", "drank some poisonous water",
84: "fried by an electric shock", "slipped on a volcano shaft",
85: "killed by a stupid act of frustration", "attacked by a revolting demon",
86: "hit by his own magic", "demolished by an unseen attacker",
87: "fell into the dreadful sleep", "killed by an exploding chest",
88: /*26*/ "killed by a missing maze data file", "annihilated in a sphere",
89: "died a post mortem death","wasted by a malloc() failure"
90: };
91:
92: /*
93: * readboard() Function to read in the scoreboard into a static buffer
94: *
95: * returns -1 if unable to read in the scoreboard, returns 0 if all is OK
96: */
97: readboard()
98: {
99: if (lopen(scorefile)<0)
100: { lprcat("Can't read scoreboard\n"); lflush(); return(-1); }
101: lrfill((char*)sco,sizeof(sco)); lrfill((char*)winr,sizeof(winr));
102: lrclose(); lcreat((char*)0); return(0);
103: }
104:
105: /*
106: * writeboard() Function to write the scoreboard from readboard()'s buffer
107: *
108: * returns -1 if unable to write the scoreboard, returns 0 if all is OK
109: */
110: writeboard()
111: {
112: set_score_output();
113: if (lcreat(scorefile)<0)
114: { lprcat("Can't write scoreboard\n"); lflush(); return(-1); }
115: lwrite((char*)sco,sizeof(sco)); lwrite((char*)winr,sizeof(winr));
116: lwclose(); lcreat((char*)0); return(0);
117: }
118:
119: /*
120: * makeboard() Function to create a new scoreboard (wipe out old one)
121: *
122: * returns -1 if unable to write the scoreboard, returns 0 if all is OK
123: */
124: makeboard()
125: {
126: register int i;
127: for (i=0; i<SCORESIZE; i++)
128: {
129: winr[i].taxes = winr[i].score = sco[i].score = 0;
130: winr[i].order = sco[i].order = i;
131: }
132: if (writeboard()) return(-1);
133: chmod(scorefile,0660);
134: return(0);
135: }
136:
137: /*
138: * hashewon() Function to return 1 if player has won a game before, else 0
139: *
140: * This function also sets c[HARDGAME] to appropriate value -- 0 if not a
141: * winner, otherwise the next level of difficulty listed in the winners
142: * scoreboard. This function also sets outstanding_taxes to the value in
143: * the winners scoreboard.
144: */
145: hashewon()
146: {
147: register int i;
148: c[HARDGAME] = 0;
149: if (readboard() < 0) return(0); /* can't find scoreboard */
150: for (i=0; i<SCORESIZE; i++) /* search through winners scoreboard */
151: if (winr[i].suid == userid)
152: if (winr[i].score > 0)
153: {
154: c[HARDGAME]=winr[i].hardlev+1; outstanding_taxes=winr[i].taxes;
155: return(1);
156: }
157: return(0);
158: }
159:
160: /*
161: * long paytaxes(x) Function to pay taxes if any are due
162: *
163: * Enter with the amount (in gp) to pay on the taxes.
164: * Returns amount actually paid.
165: */
166: long paytaxes(x)
167: long x;
168: {
169: register int i;
170: register long amt;
171: if (x<0) return(0L);
172: if (readboard()<0) return(0L);
173: for (i=0; i<SCORESIZE; i++)
174: if (winr[i].suid == userid) /* look for players winning entry */
175: if (winr[i].score>0) /* search for a winning entry for the player */
176: {
177: amt = winr[i].taxes;
178: if (x < amt) amt=x; /* don't overpay taxes (Ughhhhh) */
179: winr[i].taxes -= amt;
180: outstanding_taxes -= amt;
181: if (writeboard()<0) return(0);
182: return(amt);
183: }
184: return(0L); /* couldn't find user on winning scoreboard */
185: }
186:
187: /*
188: * winshou() Subroutine to print out the winning scoreboard
189: *
190: * Returns the number of players on scoreboard that were shown
191: */
192: winshou()
193: {
194: register struct wscofmt *p;
195: register int i,j,count;
196: for (count=j=i=0; i<SCORESIZE; i++) /* is there anyone on the scoreboard? */
197: if (winr[i].score != 0)
198: { j++; break; }
199: if (j)
200: {
201: lprcat("\n Score Difficulty Time Needed Larn Winners List\n");
202:
203: for (i=0; i<SCORESIZE; i++) /* this loop is needed to print out the */
204: for (j=0; j<SCORESIZE; j++) /* winners in order */
205: {
206: p = &winr[j]; /* pointer to the scoreboard entry */
207: if (p->order == i)
208: {
209: if (p->score)
210: {
211: count++;
212: lprintf("%10d %2d %5d Mobuls %s \n",
213: (long)p->score,(long)p->hardlev,(long)p->timeused,p->who);
214: }
215: break;
216: }
217: }
218: }
219: return(count); /* return number of people on scoreboard */
220: }
221:
222: /*
223: * shou(x) Subroutine to print out the non-winners scoreboard
224: * int x;
225: *
226: * Enter with 0 to list the scores, enter with 1 to list inventories too
227: * Returns the number of players on scoreboard that were shown
228: */
229: shou(x)
230: int x;
231: {
232: register int i,j,n,k;
233: int count;
234: for (count=j=i=0; i<SCORESIZE; i++) /* is the scoreboard empty? */
235: if (sco[i].score!= 0)
236: { j++; break; }
237: if (j)
238: {
239: lprcat("\n Score Difficulty Larn Visitor Log\n");
240: for (i=0; i<SCORESIZE; i++) /* be sure to print them out in order */
241: for (j=0; j<SCORESIZE; j++)
242: if (sco[j].order == i)
243: {
244: if (sco[j].score)
245: {
246: count++;
247: lprintf("%10d %2d %s ",
248: (long)sco[j].score,(long)sco[j].hardlev,sco[j].who);
249: if (sco[j].what < 256) lprintf("killed by a %s",monster[sco[j].what].name);
250: else lprintf("%s",whydead[sco[j].what - 256]);
251: if (x != 263) lprintf(" on %s",levelname[sco[j].level]);
252: if (x)
253: {
254: for (n=0; n<26; n++) { iven[n]=sco[j].sciv[n][0]; ivenarg[n]=sco[j].sciv[n][1]; }
255: for (k=1; k<99; k++)
256: for (n=0; n<26; n++)
257: if (k==iven[n]) { srcount=0; show3(n); }
258: lprcat("\n\n");
259: }
260: else lprc('\n');
261: }
262: j=SCORESIZE;
263: }
264: }
265: return(count); /* return the number of players just shown */
266: }
267:
268: /*
269: * showscores() Function to show the scoreboard on the terminal
270: *
271: * Returns nothing of value
272: */
273: static char esb[] = "The scoreboard is empty.\n";
274: showscores()
275: {
276: register int i,j;
277: lflush(); lcreat((char*)0); if (readboard()<0) return;
278: i=winshou(); j=shou(0);
279: if (i+j == 0) lprcat(esb); else lprc('\n');
280: lflush();
281: }
282:
283: /*
284: * showallscores() Function to show scores and the iven lists that go with them
285: *
286: * Returns nothing of value
287: */
288: showallscores()
289: {
290: register int i,j;
291: lflush(); lcreat((char*)0); if (readboard()<0) return;
292: c[WEAR] = c[WIELD] = c[SHIELD] = -1; /* not wielding or wearing anything */
293: for (i=0; i<MAXPOTION; i++) potionname[i][0]=' ';
294: for (i=0; i<MAXSCROLL; i++) scrollname[i][0]=' ';
295: i=winshou(); j=shou(1);
296: if (i+j==0) lprcat(esb); else lprc('\n');
297: lflush();
298: }
299:
300: /*
301: * sortboard() Function to sort the scoreboard
302: *
303: * Returns 0 if no sorting done, else returns 1
304: */
305: sortboard()
306: {
307: register int i,j,pos;
308: long jdat;
309: for (i=0; i<SCORESIZE; i++) sco[i].order = winr[i].order = -1;
310: pos=0; while (pos < SCORESIZE)
311: {
312: jdat=0;
313: for (i=0; i<SCORESIZE; i++)
314: if ((sco[i].order < 0) && (sco[i].score >= jdat))
315: { j=i; jdat=sco[i].score; }
316: sco[j].order = pos++;
317: }
318: pos=0; while (pos < SCORESIZE)
319: {
320: jdat=0;
321: for (i=0; i<SCORESIZE; i++)
322: if ((winr[i].order < 0) && (winr[i].score >= jdat))
323: { j=i; jdat=winr[i].score; }
324: winr[j].order = pos++;
325: }
326: return(1);
327: }
328:
329: /*
330: * newscore(score, whoo, whyded, winner) Function to add entry to scoreboard
331: * int score, winner, whyded;
332: * char *whoo;
333: *
334: * Enter with the total score in gp in score, players name in whoo,
335: * died() reason # in whyded, and TRUE/FALSE in winner if a winner
336: * ex. newscore(1000, "player 1", 32, 0);
337: */
338: newscore(score, whoo, whyded, winner)
339: long score;
340: int winner, whyded;
341: char *whoo;
342: {
343: register int i;
344: long taxes;
345: if (readboard() < 0) return; /* do the scoreboard */
346: /* if a winner then delete all non-winning scores */
347: if (cheat) winner=0; /* if he cheated, don't let him win */
348: if (winner)
349: {
350: for (i=0; i<SCORESIZE; i++) if (sco[i].suid == userid) sco[i].score=0;
351: taxes = score*TAXRATE;
352: score += 100000*c[HARDGAME]; /* bonus for winning */
353: /* if he has a slot on the winning scoreboard update it if greater score */
354: for (i=0; i<SCORESIZE; i++) if (winr[i].suid == userid)
355: { new1sub(score,i,whoo,taxes); return; }
356: /* he had no entry. look for last entry and see if he has a greater score */
357: for (i=0; i<SCORESIZE; i++) if (winr[i].order == SCORESIZE-1)
358: { new1sub(score,i,whoo,taxes); return; }
359: }
360: else if (!cheat) /* for not winning scoreboard */
361: {
362: /* if he has a slot on the scoreboard update it if greater score */
363: for (i=0; i<SCORESIZE; i++) if (sco[i].suid == userid)
364: { new2sub(score,i,whoo,whyded); return; }
365: /* he had no entry. look for last entry and see if he has a greater score */
366: for (i=0; i<SCORESIZE; i++) if (sco[i].order == SCORESIZE-1)
367: { new2sub(score,i,whoo,whyded); return; }
368: }
369: }
370:
371: /*
372: * new1sub(score,i,whoo,taxes) Subroutine to put player into a
373: * int score,i,whyded,taxes; winning scoreboard entry if his score
374: * char *whoo; is high enough
375: *
376: * Enter with the total score in gp in score, players name in whoo,
377: * died() reason # in whyded, and TRUE/FALSE in winner if a winner
378: * slot in scoreboard in i, and the tax bill in taxes.
379: * Returns nothing of value
380: */
381: new1sub(score,i,whoo,taxes)
382: long score,taxes;
383: int i;
384: char *whoo;
385: {
386: register struct wscofmt *p;
387: p = &winr[i];
388: p->taxes += taxes;
389: if ((score >= p->score) || (c[HARDGAME] > p->hardlev))
390: {
391: strcpy(p->who,whoo); p->score=score;
392: p->hardlev=c[HARDGAME]; p->suid=userid;
393: p->timeused=gtime/100;
394: }
395: }
396:
397: /*
398: * new2sub(score,i,whoo,whyded) Subroutine to put player into a
399: * int score,i,whyded,taxes; non-winning scoreboard entry if his
400: * char *whoo; score is high enough
401: *
402: * Enter with the total score in gp in score, players name in whoo,
403: * died() reason # in whyded, and slot in scoreboard in i.
404: * Returns nothing of value
405: */
406: new2sub(score,i,whoo,whyded)
407: long score;
408: int i,whyded;
409: char *whoo;
410: {
411: register int j;
412: register struct scofmt *p;
413: p = &sco[i];
414: if ((score >= p->score) || (c[HARDGAME] > p->hardlev))
415: {
416: strcpy(p->who,whoo); p->score=score;
417: p->what=whyded; p->hardlev=c[HARDGAME];
418: p->suid=userid; p->level=level;
419: for (j=0; j<26; j++)
420: { p->sciv[j][0]=iven[j]; p->sciv[j][1]=ivenarg[j]; }
421: }
422: }
423:
424: /*
425: * died(x) Subroutine to record who played larn, and what the score was
426: * int x;
427: *
428: * if x < 0 then don't show scores
429: * died() never returns! (unless c[LIFEPROT] and a reincarnatable death!)
430: *
431: * < 256 killed by the monster number
432: * 256 quit
433: * 257 suspended
434: * 258 self - annihilated
435: * 259 shot by an arrow
436: * 260 hit by a dart
437: * 261 fell into a pit
438: * 262 fell into a bottomless pit
439: * 263 a winner
440: * 264 trapped in solid rock
441: * 265 killed by a missing save file
442: * 266 killed by an old save file
443: * 267 caught by the greedy cheater checker trap
444: * 268 killed by a protected save file
445: * 269 killed his family and killed himself
446: * 270 erased by a wayward finger
447: * 271 fell through a bottomless trap door
448: * 272 fell through a trap door
449: * 273 drank some poisonous water
450: * 274 fried by an electric shock
451: * 275 slipped on a volcano shaft
452: * 276 killed by a stupid act of frustration
453: * 277 attacked by a revolting demon
454: * 278 hit by his own magic
455: * 279 demolished by an unseen attacker
456: * 280 fell into the dreadful sleep
457: * 281 killed by an exploding chest
458: * 282 killed by a missing maze data file
459: * 283 killed by a sphere of annihilation
460: * 284 died a post mortem death
461: * 285 malloc() failure
462: * 300 quick quit -- don't put on scoreboard
463: */
464:
465: static int scorerror;
466: died(x)
467: int x;
468: {
469: register int f,win;
470: char ch,*mod;
471: long zzz,i;
472: struct tms cputime;
473: if (c[LIFEPROT]>0) /* if life protection */
474: {
475: switch((x>0) ? x : -x)
476: {
477: case 256: case 257: case 262: case 263: case 265: case 266:
478: case 267: case 268: case 269: case 271: case 282: case 284:
479: case 285: case 300: goto invalid; /* can't be saved */
480: };
481: --c[LIFEPROT]; c[HP]=1; --c[CONSTITUTION];
482: cursors(); lprcat("\nYou feel wiiieeeeerrrrrd all over! "); beep();
483: lflush(); sleep(4);
484: return; /* only case where died() returns */
485: }
486: invalid:
487: clearvt100(); lflush(); f=0;
488: if (ckpflag) unlink(ckpfile); /* remove checkpoint file if used */
489: if (x<0) { f++; x = -x; } /* if we are not to display the scores */
490: if ((x == 300) || (x == 257)) exit(); /* for quick exit or saved game */
491: if (x == 263) win = 1; else win = 0;
492: c[GOLD] += c[BANKACCOUNT]; c[BANKACCOUNT] = 0;
493: /* now enter the player at the end of the scoreboard */
494: newscore(c[GOLD], logname, x, win);
495: diedsub(x); /* print out the score line */ lflush();
496:
497: set_score_output();
498: if ((wizard == 0) && (c[GOLD] > 0)) /* wizards can't score */
499: {
500: #ifndef NOLOG
501: if (lappend(logfile)<0) /* append to file */
502: {
503: if (lcreat(logfile)<0) /* and can't create new log file */
504: {
505: lcreat((char*)0);
506: lprcat("\nCan't open record file: I can't post your score.\n");
507: sncbr(); resetscroll(); lflush(); exit();
508: }
509: chmod(logfile,0660);
510: }
511: strcpy(logg.who,loginname);
512: logg.score = c[GOLD]; logg.diff = c[HARDGAME];
513: if (x < 256)
514: {
515: ch = *monster[x].name;
516: if (ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u')
517: mod="an"; else mod="a";
518: sprintf(logg.what,"killed by %s %s",mod,monster[x].name);
519: }
520: else sprintf(logg.what,"%s",whydead[x - 256]);
521: logg.cavelev=level;
522: time(&zzz); /* get cpu time -- write out score info */
523: logg.diedtime=zzz;
524: #ifdef EXTRA
525: times(&cputime); /* get cpu time -- write out score info */
526: logg.cputime = i = (cputime.tms_utime + cputime.tms_stime)/60 + c[CPUTIME];
527: logg.lev=c[LEVEL]; logg.ac=c[AC];
528: logg.hpmax=c[HPMAX]; logg.hp=c[HP];
529: logg.elapsedtime=(zzz-initialtime+59)/60;
530: logg.usage=(10000*i)/(zzz-initialtime);
531: logg.bytin=c[BYTESIN]; logg.bytout=c[BYTESOUT];
532: logg.moves=c[MOVESMADE]; logg.spused=c[SPELLSCAST];
533: logg.killed=c[MONSTKILLED];
534: #endif
535: lwrite((char*)&logg,sizeof(struct log_fmt)); lwclose();
536: #endif NOLOG
537:
538: /* now for the scoreboard maintenance -- not for a suspended game */
539: if (x != 257)
540: {
541: if (sortboard()) scorerror = writeboard();
542: }
543: }
544: if ((x==256) || (x==257) || (f != 0)) exit();
545: if (scorerror == 0) showscores(); /* if we updated the scoreboard */
546: if (x == 263) mailbill(); exit();
547: }
548:
549: /*
550: * diedsub(x) Subroutine to print out the line showing the player when he is killed
551: * int x;
552: */
553: diedsub(x)
554: int x;
555: {
556: register char ch,*mod;
557: lprintf("Score: %d, Diff: %d, %s ",(long)c[GOLD],(long)c[HARDGAME],logname);
558: if (x < 256)
559: {
560: ch = *monster[x].name;
561: if (ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u')
562: mod="an"; else mod="a";
563: lprintf("killed by %s %s",mod,monster[x].name);
564: }
565: else lprintf("%s",whydead[x - 256]);
566: if (x != 263) lprintf(" on %s\n",levelname[level]); else lprc('\n');
567: }
568:
569: /*
570: * diedlog() Subroutine to read a log file and print it out in ascii format
571: */
572: diedlog()
573: {
574: register int n;
575: register char *p;
576: struct stat stbuf;
577: lcreat((char*)0);
578: if (lopen(logfile)<0)
579: {
580: lprintf("Can't locate log file <%s>\n",logfile);
581: return;
582: }
583: if (fstat(fd,&stbuf) < 0)
584: {
585: lprintf("Can't stat log file <%s>\n",logfile);
586: return;
587: }
588: for (n=stbuf.st_size/sizeof(struct log_fmt); n>0; --n)
589: {
590: lrfill((char*)&logg,sizeof(struct log_fmt));
591: p = ctime(&logg.diedtime); p[16]='\n'; p[17]=0;
592: 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);
593: #ifdef EXTRA
594: if (logg.moves<=0) logg.moves=1;
595: 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));
596: lprintf(" CPU time used: %d seconds, Machine usage: %d.%02d%%\n",(long)(logg.cputime),(long)(logg.usage/100),(long)(logg.usage%100));
597: 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));
598: lprintf(" out bytes per move: %d, time per move: %d ms\n",(long)(logg.bytout/logg.moves),(long)((logg.cputime*1000)/logg.moves));
599: #endif
600: }
601: lflush(); lrclose(); return;
602: }
603:
604: #ifndef UIDSCORE
605: /*
606: * getplid(name) Function to get players id # from id file
607: *
608: * Enter with the name of the players character in name.
609: * Returns the id # of the players character, or -1 if failure.
610: * This routine will try to find the name in the id file, if its not there,
611: * it will try to make a new entry in the file. Only returns -1 if can't
612: * find him in the file, and can't make a new entry in the file.
613: * Format of playerids file:
614: * Id # in ascii \n character name \n
615: */
616: static int havepid= -1; /* playerid # if previously done */
617: getplid(nam)
618: char *nam;
619: {
620: int fd7,high=999,no;
621: register char *p,*p2;
622: char name[80];
623: if (havepid != -1) return(havepid); /* already did it */
624: lflush(); /* flush any pending I/O */
625: sprintf(name,"%s\n",nam); /* append a \n to name */
626: if (lopen(playerids) < 0) /* no file, make it */
627: {
628: if ((fd7=creat(playerids,0666)) < 0) return(-1); /* can't make it */
629: close(fd7); goto addone; /* now append new playerid record to file */
630: }
631: for (;;) /* now search for the name in the player id file */
632: {
633: p = lgetl(); if (p==NULL) break; /* EOF? */
634: no = atoi(p); /* the id # */
635: p2= lgetl(); if (p2==NULL) break; /* EOF? */
636: if (no>high) high=no; /* accumulate highest id # */
637: if (strcmp(p2,name)==0) /* we found him */
638: {
639: return(no); /* his id number */
640: }
641: }
642: lrclose();
643: /* if we get here, we didn't find him in the file -- put him there */
644: addone:
645: if (lappend(playerids) < 0) return(-1); /* can't open file for append */
646: lprintf("%d\n%s",(long)++high,name); /* new id # and name */
647: lwclose();
648: lcreat((char*)0); /* re-open terminal channel */
649: return(high);
650: }
651: #endif UIDSCORE
652:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.