WebSVN – HelenOS – Diff – /branches/network/uspace/app/tetris/scores.c


/*  $OpenBSD: scores.c,v 1.11 2006/04/20 03:25:36 ray Exp $ */
/*  $NetBSD: scores.c,v 1.2 1995/04/22 07:42:38 cgd Exp $   */
 
/*-
 * Copyright (c) 1992, 1993
 *  The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Chris Torek and Darren F. Provine.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *  @(#)scores.c    8.1 (Berkeley) 5/31/93
 */
 
/** @addtogroup tetris
 * @{
 */
/** @file
 */
 
/*
 * Score code for Tetris, by Darren Provine (kilroy@gboro.glassboro.edu)
 * modified 22 January 1992, to limit the number of entries any one
 * person has.
 *
 * Major whacks since then.
 */
#include <errno.h>
/* #include <err.h> */
/* #include <fcntl.h> */
/* #include <pwd.h> */
#include <stdio.h>
/* #include <stdlib.h> */
#include <string.h>
#include <kbd/kbd.h>
#include <kbd/keycode.h>
#include <stdlib.h>
/* #include <time.h> */
/* #include <term.h> */
/* #include <unistd.h> */
/* #include <sys/param.h> */
/* #include <sys/stat.h> */
/* #include <sys/types.h> */
 
#include "pathnames.h"
#include "screen.h"
#include "tetris.h"
#include "scores.h"
 
/*
 * Within this code, we can hang onto one extra "high score", leaving
 * room for our current score (whether or not it is high).
 *
 * We also sometimes keep tabs on the "highest" score on each level.
 * As long as the scores are kept sorted, this is simply the first one at
 * that level.
 */
#define NUMSPOTS (MAXHISCORES + 1)
#define NLEVELS (MAXLEVEL + 1)
 
/* static time_t now; */
/* static int nscores; */
/* static int gotscores; */
/* static struct highscore scores[NUMSPOTS]; */
static struct highscore scores[NUMSPOTS];
 
/* static int checkscores(struct highscore *, int); */
/* static int cmpscores(const void *, const void *); */
/* static void getscores(FILE **); */
/* static void printem(int, int, struct highscore *, int, const char *); */
/* static char *thisuser(void); */
 
void showscores(int firstgame)
{
    int i;
   
    clear_screen();
    moveto(10, 0);
    printf("\tRank \tLevel \tName\t                     points\n");
    printf("\t========================================================\n");
    for (i = 0; i < NUMSPOTS - 1; i++) {
        printf("\t%6d %6d %-16s %20d\n", i+1, scores[i].hs_level, scores[i].hs_name, scores[i].hs_score);
    }
    if (!firstgame) {
        printf("\t========================================================\n");
        printf("\t  Last %6d %-16s %20d\n", scores[NUMSPOTS - 1].hs_level, scores[NUMSPOTS - 1].hs_name, scores[NUMSPOTS - 1].hs_score);
    }
    printf("\n\n\n\n\tPress any key to return to main menu.");
    getchar();
}
 
/** Copy from hiscore table score with index src to dest
 *
 */
static void copyhiscore(int dest, int src)
{
    str_cpy(scores[dest].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
        scores[src].hs_name);
    scores[dest].hs_score = scores[src].hs_score;  
    scores[dest].hs_level = scores[src].hs_level;
}
 
void insertscore(int score, int level)
{
    int i,j;
    size_t off;
    kbd_event_t ev;
   
    clear_screen();
    moveto(10 , 10);
    puts("Insert your name: ");
    str_cpy(scores[NUMSPOTS - 1].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
        "Player");
    i = 6; off = 6;
 
    moveto(10 , 28);
    printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
 
    while (1) {
        fflush(stdout);
        if (kbd_get_event(&ev) != EOK)
            exit(1);
 
        if (ev.type == KE_RELEASE)
            continue;
 
        if (ev.key == KC_ENTER || ev.key == KC_NENTER)
            break;
 
        if (ev.key == KC_BACKSPACE) {
            if (i > 0) {
                wchar_t uc;
 
                --i;
                while (off > 0) {
                    --off;
                    size_t otmp = off;
                    uc = str_decode(scores[NUMSPOTS - 1].hs_name,
                        &otmp, STR_BOUNDS(MAXLOGNAME) + 1);
                    if (uc != U_SPECIAL)
                        break;
                }
 
                scores[NUMSPOTS - 1].hs_name[off] = '\0';
            }
        } else if (ev.c != '\0') {
            if (i < (MAXLOGNAME - 1)) {
                if (chr_encode(ev.c, scores[NUMSPOTS - 1].hs_name,
                    &off, STR_BOUNDS(MAXLOGNAME) + 1) == EOK) {
                    ++i;
                }
                scores[NUMSPOTS - 1].hs_name[off] = '\0';
            }
        }
       
        moveto(10 , 28);
        printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
    }
   
    scores[NUMSPOTS - 1].hs_score = score; 
    scores[NUMSPOTS - 1].hs_level = level;
   
    i = NUMSPOTS-1;
    while ((i > 0) && (scores[i - 1].hs_score < score))
        i--;
 
    for (j = NUMSPOTS - 2; j > i; j--) {
        copyhiscore(j,j-1);
    }
    copyhiscore(i, NUMSPOTS - 1);  
}
 
void initscores(void)
{
    int i;
    for(i = 0; i < NUMSPOTS; i++) {
        str_cpy(scores[i].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, "HelenOS Team");
        scores[i].hs_score = (NUMSPOTS - i) * 200; 
        scores[i].hs_level = (i + 1 > MAXLEVEL?MAXLEVEL:i + 1);
    }
}
 
/*
 * Read the score file.  Can be called from savescore (before showscores)
 * or showscores (if savescore will not be called).  If the given pointer
 * is not NULL, sets *fpp to an open file pointer that corresponds to a
 * read/write score file that is locked with LOCK_EX.  Otherwise, the
 * file is locked with LOCK_SH for the read and closed before return.
 *
 * Note, we assume closing the stdio file releases the lock.
 */
/* static void */
/* getscores(FILE **fpp) */
/* { */
/*  int sd, mint, lck, mask, i; */
/*  char *mstr, *human; */
/*  FILE *sf; */
 
/*  if (fpp != NULL) { */
/*      mint = O_RDWR | O_CREAT; */
/*      mstr = "r+"; */
/*      human = "read/write"; */
/*      lck = LOCK_EX; */
/*  } else { */
/*      mint = O_RDONLY; */
/*      mstr = "r"; */
/*      human = "reading"; */
/*      lck = LOCK_SH; */
/*  } */
/*  setegid(egid); */
/*  mask = umask(S_IWOTH); */
/*  sd = open(_PATH_SCOREFILE, mint, 0666); */
/*  (void)umask(mask); */
/*  setegid(gid); */
/*  if (sd < 0) { */
/*      if (fpp == NULL) { */
/*          nscores = 0; */
/*          return; */
/*      } */
/*      err(1, "cannot open %s for %s", _PATH_SCOREFILE, human); */
/*  } */
/*  setegid(egid); */
/*  if ((sf = fdopen(sd, mstr)) == NULL) */
/*      err(1, "cannot fdopen %s for %s", _PATH_SCOREFILE, human); */
/*  setegid(gid); */
 
/*  /\* */
/*   * Grab a lock. */
/*   *\/ */
/*  if (flock(sd, lck)) */
/*      warn("warning: score file %s cannot be locked", */
/*          _PATH_SCOREFILE); */
 
/*  nscores = fread(scores, sizeof(scores[0]), MAXHISCORES, sf); */
/*  if (ferror(sf)) */
/*      err(1, "error reading %s", _PATH_SCOREFILE); */
/*  for (i = 0; i < nscores; i++) */
/*      if (scores[i].hs_level < MINLEVEL || */
/*          scores[i].hs_level > MAXLEVEL) */
/*          errx(1, "scorefile %s corrupt", _PATH_SCOREFILE); */
 
/*  if (fpp) */
/*      *fpp = sf; */
/*  else */
/*      (void)fclose(sf); */
/* } */
 
void
savescore(int level)
{
    return;
}
/*  struct highscore *sp; */
/*  int i; */
/*  int change; */
/*  FILE *sf; */
/*  const char *me; */
 
/*  getscores(&sf); */
/*  gotscores = 1; */
/*  (void)time(&now); */
 
/*  /\* */
/*   * Allow at most one score per person per level -- see if we */
/*   * can replace an existing score, or (easiest) do nothing. */
/*   * Otherwise add new score at end (there is always room). */
/*   *\/ */
/*  change = 0; */
/*  me = thisuser(); */
/*  for (i = 0, sp = &scores[0]; i < nscores; i++, sp++) { */
/*      if (sp->hs_level != level || str_cmp(sp->hs_name, me) != 0) */
/*          continue; */
/*      if (score > sp->hs_score) { */
/*          (void)printf("%s bettered %s %d score of %d!\n", */
/*              "\nYou", "your old level", level, */
/*              sp->hs_score * sp->hs_level); */
/*          sp->hs_score = score;   /\* new score *\/ */
/*          sp->hs_time = now;  /\* and time *\/ */
/*          change = 1; */
/*      } else if (score == sp->hs_score) { */
/*          (void)printf("%s tied %s %d high score.\n", */
/*              "\nYou", "your old level", level); */
/*          sp->hs_time = now;  /\* renew it *\/ */
/*          change = 1;     /\* gotta rewrite, sigh *\/ */
/*      } /\* else new score < old score: do nothing *\/ */
/*      break; */
/*  } */
/*  if (i >= nscores) { */
/*      strlcpy(sp->hs_name, me, sizeof sp->hs_name); */
/*      sp->hs_level = level; */
/*      sp->hs_score = score; */
/*      sp->hs_time = now; */
/*      nscores++; */
/*      change = 1; */
/*  } */
 
/*  if (change) { */
/*      /\* */
/*       * Sort & clean the scores, then rewrite. */
/*       *\/ */
/*      nscores = checkscores(scores, nscores); */
/*      rewind(sf); */
/*      if (fwrite(scores, sizeof(*sp), nscores, sf) != nscores || */
/*          fflush(sf) == EOF) */
/*          warnx("error writing %s: %s\n\t-- %s", */
/*              _PATH_SCOREFILE, strerror(errno), */
/*              "high scores may be damaged"); */
/*  } */
/*  (void)fclose(sf);   /\* releases lock *\/ */
/* } */
 
/*
 * Get login name, or if that fails, get something suitable.
 * The result is always trimmed to fit in a score.
 */
/* static char * */
/* thisuser(void) */
/* { */
/*  const char *p; */
/*  struct passwd *pw; */
/*  static char u[sizeof(scores[0].hs_name)]; */
 
/*  if (u[0]) */
/*      return (u); */
/*  p = getlogin(); */
/*  if (p == NULL || *p == '\0') { */
/*      pw = getpwuid(getuid()); */
/*      if (pw != NULL) */
/*          p = pw->pw_name; */
/*      else */
/*          p = "  ???"; */
/*  } */
/*  strlcpy(u, p, sizeof(u)); */
/*  return (u); */
/* } */
 
/*
 * Score comparison function for qsort.
 *
 * If two scores are equal, the person who had the score first is
 * listed first in the highscore file.
 */
/* static int */
/* cmpscores(const void *x, const void *y) */
/* { */
/*  const struct highscore *a, *b; */
/*  long l; */
 
/*  a = x; */
/*  b = y; */
/*  l = (long)b->hs_level * b->hs_score - (long)a->hs_level * a->hs_score; */
/*  if (l < 0) */
/*      return (-1); */
/*  if (l > 0) */
/*      return (1); */
/*  if (a->hs_time < b->hs_time) */
/*      return (-1); */
/*  if (a->hs_time > b->hs_time) */
/*      return (1); */
/*  return (0); */
/* } */
 
/*
 * If we've added a score to the file, we need to check the file and ensure
 * that this player has only a few entries.  The number of entries is
 * controlled by MAXSCORES, and is to ensure that the highscore file is not
 * monopolised by just a few people.  People who no longer have accounts are
 * only allowed the highest score.  Scores older than EXPIRATION seconds are
 * removed, unless they are someone's personal best.
 * Caveat:  the highest score on each level is always kept.
 */
/* static int */
/* checkscores(struct highscore *hs, int num) */
/* { */
/*  struct highscore *sp; */
/*  int i, j, k, numnames; */
/*  int levelfound[NLEVELS]; */
/*  struct peruser { */
/*      char *name; */
/*      int times; */
/*  } count[NUMSPOTS]; */
/*  struct peruser *pu; */
 
/*  /\* */
/*   * Sort so that highest totals come first. */
/*   * */
/*   * levelfound[i] becomes set when the first high score for that */
/*   * level is encountered.  By definition this is the highest score. */
/*   *\/ */
/*  qsort((void *)hs, nscores, sizeof(*hs), cmpscores); */
/*  for (i = MINLEVEL; i < NLEVELS; i++) */
/*      levelfound[i] = 0; */
/*  numnames = 0; */
/*  for (i = 0, sp = hs; i < num;) { */
/*      /\* */
/*       * This is O(n^2), but do you think we care? */
/*       *\/ */
/*      for (j = 0, pu = count; j < numnames; j++, pu++) */
/*          if (str_cmp(sp->hs_name, pu->name) == 0) */
/*              break; */
/*      if (j == numnames) { */
/*          /\* */
/*           * Add new user, set per-user count to 1. */
/*           *\/ */
/*          pu->name = sp->hs_name; */
/*          pu->times = 1; */
/*          numnames++; */
/*      } else { */
/*          /\* */
/*           * Two ways to keep this score: */
/*           * - Not too many (per user), still has acct, & */
/*           *  score not dated; or */
/*           * - High score on this level. */
/*           *\/ */
/*          if ((pu->times < MAXSCORES && */
/*               getpwnam(sp->hs_name) != NULL && */
/*               sp->hs_time + EXPIRATION >= now) || */
/*              levelfound[sp->hs_level] == 0) */
/*              pu->times++; */
/*          else { */
/*              /\* */
/*               * Delete this score, do not count it, */
/*               * do not pass go, do not collect $200. */
/*               *\/ */
/*              num--; */
/*              for (k = i; k < num; k++) */
/*                  hs[k] = hs[k + 1]; */
/*              continue; */
/*          } */
/*      } */
/*      levelfound[sp->hs_level] = 1; */
/*      i++, sp++; */
/*  } */
/*  return (num > MAXHISCORES ? MAXHISCORES : num); */
/* } */
 
/*
 * Show current scores.  This must be called after savescore, if
 * savescore is called at all, for two reasons:
 * - Showscores munches the time field.
 * - Even if that were not the case, a new score must be recorded
 *   before it can be shown anyway.
 */
/*
void
showscores(int level)
{
    return;
}
*/
/*  struct highscore *sp; */
/*  int i, n, c; */
/*  const char *me; */
/*  int levelfound[NLEVELS]; */
 
/*  if (!gotscores) */
/*      getscores((FILE **)NULL); */
/*  (void)printf("\n\t\t    Tetris High Scores\n"); */
 
/*  /\* */
/*   * If level == 0, the person has not played a game but just asked for */
/*   * the high scores; we do not need to check for printing in highlight */
/*   * mode.  If SOstr is null, we can't do highlighting anyway. */
/*   *\/ */
/*  me = level && SOstr ? thisuser() : NULL; */
 
/*  /\* */
/*   * Set times to 0 except for high score on each level. */
/*   *\/ */
/*  for (i = MINLEVEL; i < NLEVELS; i++) */
/*      levelfound[i] = 0; */
/*  for (i = 0, sp = scores; i < nscores; i++, sp++) { */
/*      if (levelfound[sp->hs_level]) */
/*          sp->hs_time = 0; */
/*      else { */
/*          sp->hs_time = 1; */
/*          levelfound[sp->hs_level] = 1; */
/*      } */
/*  } */
 
/*  /\* */
/*   * Page each screenful of scores. */
/*   *\/ */
/*  for (i = 0, sp = scores; i < nscores; sp += n) { */
/*      n = 20; */
/*      if (i + n > nscores) */
/*          n = nscores - i; */
/*      printem(level, i + 1, sp, n, me); */
/*      if ((i += n) < nscores) { */
/*          (void)printf("\nHit RETURN to continue."); */
/*          (void)fflush(stdout); */
/*          while ((c = getchar()) != '\n') */
/*              if (c == EOF) */
/*                  break; */
/*          (void)printf("\n"); */
/*      } */
/*  } */
 
/*  if (nscores == 0) */
/*      printf("\t\t\t      - none to date.\n"); */
/* } */
 
/* static void */
/* printem(int level, int offset, struct highscore *hs, int n, const char *me) */
/* { */
/*  struct highscore *sp; */
/*  int row, highlight, i; */
/*  char buf[100]; */
/* #define  TITLE "Rank  Score   Name                          (points/level)" */
/* #define  TITL2 "==========================================================" */
 
/*  printf("%s\n%s\n", TITLE, TITL2); */
 
/*  highlight = 0; */
 
/*  for (row = 0; row < n; row++) { */
/*      sp = &hs[row]; */
/*      (void)snprintf(buf, sizeof(buf), */
/*          "%3d%c %6d  %-31s (%6d on %d)\n", */
/*          row + offset, sp->hs_time ? '*' : ' ', */
/*          sp->hs_score * sp->hs_level, */
/*          sp->hs_name, sp->hs_score, sp->hs_level); */
/*      /\* Print leaders every three lines *\/ */
/*      if ((row + 1) % 3 == 0) { */
/*          for (i = 0; i < sizeof(buf); i++) */
/*              if (buf[i] == ' ') */
/*                  buf[i] = '_'; */
/*      } */
/*      /\* */
/*       * Highlight if appropriate.  This works because */
/*       * we only get one score per level. */
/*       *\/ */
/*      if (me != NULL && */
/*          sp->hs_level == level && */
/*          sp->hs_score == score && */
/*          str_cmp(sp->hs_name, me) == 0) { */
/*          putpad(SOstr); */
/*          highlight = 1; */
/*      } */
/*      (void)printf("%s", buf); */
/*      if (highlight) { */
/*          putpad(SEstr); */
/*          highlight = 0; */
/*      } */
/*  } */
/* } */
 
/** @}
 */
 
 

Rev 4263	Rev 4327
1	/* $OpenBSD: scores.c,v 1.11 2006/04/20 03:25:36 ray Exp $ */	1	/* $OpenBSD: scores.c,v 1.11 2006/04/20 03:25:36 ray Exp $ */
2	/* $NetBSD: scores.c,v 1.2 1995/04/22 07:42:38 cgd Exp $ */	2	/* $NetBSD: scores.c,v 1.2 1995/04/22 07:42:38 cgd Exp $ */
3		3
4	/*-	4	/*-
5	* Copyright (c) 1992, 1993	5	* Copyright (c) 1992, 1993
6	* The Regents of the University of California. All rights reserved.	6	* The Regents of the University of California. All rights reserved.
7	*	7	*
8	* This code is derived from software contributed to Berkeley by	8	* This code is derived from software contributed to Berkeley by
9	* Chris Torek and Darren F. Provine.	9	* Chris Torek and Darren F. Provine.
10	*	10	*
11	* Redistribution and use in source and binary forms, with or without	11	* Redistribution and use in source and binary forms, with or without
12	* modification, are permitted provided that the following conditions	12	* modification, are permitted provided that the following conditions
13	* are met:	13	* are met:
14	* 1. Redistributions of source code must retain the above copyright	14	* 1. Redistributions of source code must retain the above copyright
15	* notice, this list of conditions and the following disclaimer.	15	* notice, this list of conditions and the following disclaimer.
16	* 2. Redistributions in binary form must reproduce the above copyright	16	* 2. Redistributions in binary form must reproduce the above copyright
17	* notice, this list of conditions and the following disclaimer in the	17	* notice, this list of conditions and the following disclaimer in the
18	* documentation and/or other materials provided with the distribution.	18	* documentation and/or other materials provided with the distribution.
19	* 3. Neither the name of the University nor the names of its contributors	19	* 3. Neither the name of the University nor the names of its contributors
20	* may be used to endorse or promote products derived from this software	20	* may be used to endorse or promote products derived from this software
21	* without specific prior written permission.	21	* without specific prior written permission.
22	*	22	*
23	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND	23	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	24	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE	25	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE	26	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL	27	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS	28	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)	29	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT	30	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY	31	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF	32	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33	* SUCH DAMAGE.	33	* SUCH DAMAGE.
34	*	34	*
35	* @(#)scores.c 8.1 (Berkeley) 5/31/93	35	* @(#)scores.c 8.1 (Berkeley) 5/31/93
36	*/	36	*/
37		37
38	/** @addtogroup tetris	38	/** @addtogroup tetris
39	* @{	39	* @{
40	*/	40	*/
41	/** @file	41	/** @file
42	*/	42	*/
43		43
44	/*	44	/*
45	* Score code for Tetris, by Darren Provine (kilroy@gboro.glassboro.edu)	45	* Score code for Tetris, by Darren Provine (kilroy@gboro.glassboro.edu)
46	* modified 22 January 1992, to limit the number of entries any one	46	* modified 22 January 1992, to limit the number of entries any one
47	* person has.	47	* person has.
48	*	48	*
49	* Major whacks since then.	49	* Major whacks since then.
50	*/	50	*/
51	#include <errno.h>	51	#include <errno.h>
52	/* #include <err.h> */	52	/* #include <err.h> */
53	/* #include <fcntl.h> */	53	/* #include <fcntl.h> */
54	/* #include <pwd.h> */	54	/* #include <pwd.h> */
55	#include <stdio.h>	55	#include <stdio.h>
56	/* #include <stdlib.h> */	56	/* #include <stdlib.h> */
57	#include <string.h>	57	#include <string.h>
58	#include <kbd/kbd.h>	58	#include <kbd/kbd.h>
59	#include <kbd/keycode.h>	59	#include <kbd/keycode.h>
60	#include <stdlib.h>	60	#include <stdlib.h>
61	/* #include <time.h> */	61	/* #include <time.h> */
62	/* #include <term.h> */	62	/* #include <term.h> */
63	/* #include <unistd.h> */	63	/* #include <unistd.h> */
64	/* #include <sys/param.h> */	64	/* #include <sys/param.h> */
65	/* #include <sys/stat.h> */	65	/* #include <sys/stat.h> */
66	/* #include <sys/types.h> */	66	/* #include <sys/types.h> */
67		67
68	#include "pathnames.h"	68	#include "pathnames.h"
69	#include "screen.h"	69	#include "screen.h"
70	#include "tetris.h"	70	#include "tetris.h"
71	#include "scores.h"	71	#include "scores.h"
72		72
73	/*	73	/*
74	* Within this code, we can hang onto one extra "high score", leaving	74	* Within this code, we can hang onto one extra "high score", leaving
75	* room for our current score (whether or not it is high).	75	* room for our current score (whether or not it is high).
76	*	76	*
77	* We also sometimes keep tabs on the "highest" score on each level.	77	* We also sometimes keep tabs on the "highest" score on each level.
78	* As long as the scores are kept sorted, this is simply the first one at	78	* As long as the scores are kept sorted, this is simply the first one at
79	* that level.	79	* that level.
80	*/	80	*/
81	#define NUMSPOTS (MAXHISCORES + 1)	81	#define NUMSPOTS (MAXHISCORES + 1)
82	#define NLEVELS (MAXLEVEL + 1)	82	#define NLEVELS (MAXLEVEL + 1)
83		83
84	/* static time_t now; */	84	/* static time_t now; */
85	/* static int nscores; */	85	/* static int nscores; */
86	/* static int gotscores; */	86	/* static int gotscores; */
87	/* static struct highscore scores[NUMSPOTS]; */	87	/* static struct highscore scores[NUMSPOTS]; */
88	static struct highscore scores[NUMSPOTS];	88	static struct highscore scores[NUMSPOTS];
89		89
90	/* static int checkscores(struct highscore , int); /	90	/* static int checkscores(struct highscore , int); /
91	/* static int cmpscores(const void , const void ); */	91	/* static int cmpscores(const void , const void ); */
92	/* static void getscores(FILE *); /	92	/* static void getscores(FILE *); /
93	/* static void printem(int, int, struct highscore , int, const char ); */	93	/* static void printem(int, int, struct highscore , int, const char ); */
94	/* static char thisuser(void); /	94	/* static char thisuser(void); /
95		95
96	void showscores(int firstgame)	96	void showscores(int firstgame)
97	{	97	{
98	int i;	98	int i;
99		99
100	clear_screen();	100	clear_screen();
101	moveto(10, 0);	101	moveto(10, 0);
102	printf("\tRank \tLevel \tName\t points\n");	102	printf("\tRank \tLevel \tName\t points\n");
103	printf("\t========================================================\n");	103	printf("\t========================================================\n");
104	for (i = 0; i < NUMSPOTS - 1; i++) {	104	for (i = 0; i < NUMSPOTS - 1; i++) {
105	printf("\t%6d %6d %-16s %20d\n", i+1, scores[i].hs_level, scores[i].hs_name, scores[i].hs_score);	105	printf("\t%6d %6d %-16s %20d\n", i+1, scores[i].hs_level, scores[i].hs_name, scores[i].hs_score);
106	}	106	}
107	if (!firstgame) {	107	if (!firstgame) {
108	printf("\t========================================================\n");	108	printf("\t========================================================\n");
109	printf("\t Last %6d %-16s %20d\n", scores[NUMSPOTS - 1].hs_level, scores[NUMSPOTS - 1].hs_name, scores[NUMSPOTS - 1].hs_score);	109	printf("\t Last %6d %-16s %20d\n", scores[NUMSPOTS - 1].hs_level, scores[NUMSPOTS - 1].hs_name, scores[NUMSPOTS - 1].hs_score);
110	}	110	}
111	printf("\n\n\n\n\tPress any key to return to main menu.");	111	printf("\n\n\n\n\tPress any key to return to main menu.");
112	getchar();	112	getchar();
113	}	113	}
114		114
115	/** Copy from hiscore table score with index src to dest	115	/** Copy from hiscore table score with index src to dest
116	*	116	*
117	*/	117	*/
118	static void copyhiscore(int dest, int src)	118	static void copyhiscore(int dest, int src)
119	{	119	{
120	strcpy(scores[dest].hs_name, scores[src].hs_name);	120	str_cpy(scores[dest].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
-		121	scores[src].hs_name);
121	scores[dest].hs_score = scores[src].hs_score;	122	scores[dest].hs_score = scores[src].hs_score;
122	scores[dest].hs_level = scores[src].hs_level;	123	scores[dest].hs_level = scores[src].hs_level;
123	}	124	}
124		125
125	void insertscore(int score, int level)	126	void insertscore(int score, int level)
126	{	127	{
127	int i,j;	128	int i,j;
128	size_t off;	129	size_t off;
129	kbd_event_t ev;	130	kbd_event_t ev;
130		131
131	clear_screen();	132	clear_screen();
132	moveto(10 , 10);	133	moveto(10 , 10);
133	puts("Insert your name: ");	134	puts("Insert your name: ");
134	strncpy(scores[NUMSPOTS - 1].hs_name, "Player", MAXLOGNAME);	135	str_cpy(scores[NUMSPOTS - 1].hs_name, STR_BOUNDS(MAXLOGNAME) + 1,
-		136	"Player");
135	i = 6; off = 6;	137	i = 6; off = 6;
136		138
137	moveto(10 , 28);	139	moveto(10 , 28);
138	printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");	140	printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
139		141
140	while (1) {	142	while (1) {
141	fflush(stdout);	143	fflush(stdout);
142	if (kbd_get_event(&ev) != EOK)	144	if (kbd_get_event(&ev) != EOK)
143	exit(1);	145	exit(1);
144		146
145	if (ev.type == KE_RELEASE)	147	if (ev.type == KE_RELEASE)
146	continue;	148	continue;
147		149
148	if (ev.key == KC_ENTER \|\| ev.key == KC_NENTER)	150	if (ev.key == KC_ENTER \|\| ev.key == KC_NENTER)
149	break;	151	break;
150		152
151	if (ev.key == KC_BACKSPACE) {	153	if (ev.key == KC_BACKSPACE) {
152	if (i > 0) {	154	if (i > 0) {
153	wchar_t uc;	155	wchar_t uc;
154		156
155	--i;	157	--i;
156	while (off > 0) {	158	while (off > 0) {
157	--off;	159	--off;
158	size_t otmp = off;	160	size_t otmp = off;
159	uc = str_decode(scores[NUMSPOTS - 1].hs_name,	161	uc = str_decode(scores[NUMSPOTS - 1].hs_name,
160	&otmp, STR_BOUNDS(MAXLOGNAME) + 1);	162	&otmp, STR_BOUNDS(MAXLOGNAME) + 1);
161	if (uc != U_SPECIAL)	163	if (uc != U_SPECIAL)
162	break;	164	break;
163	}	165	}
164		166
165	scores[NUMSPOTS - 1].hs_name[off] = '\0';	167	scores[NUMSPOTS - 1].hs_name[off] = '\0';
166	}	168	}
167	} else if (ev.c != '\0') {	169	} else if (ev.c != '\0') {
168	if (i < (MAXLOGNAME - 1)) {	170	if (i < (MAXLOGNAME - 1)) {
169	if (chr_encode(ev.c, scores[NUMSPOTS - 1].hs_name,	171	if (chr_encode(ev.c, scores[NUMSPOTS - 1].hs_name,
170	&off, STR_BOUNDS(MAXLOGNAME) + 1) == EOK) {	172	&off, STR_BOUNDS(MAXLOGNAME) + 1) == EOK) {
171	++i;	173	++i;
172	}	174	}
173	scores[NUMSPOTS - 1].hs_name[off] = '\0';	175	scores[NUMSPOTS - 1].hs_name[off] = '\0';
174	}	176	}
175	}	177	}
176		178
177	moveto(10 , 28);	179	moveto(10 , 28);
178	printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");	180	printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
179	}	181	}
180		182
181	scores[NUMSPOTS - 1].hs_score = score;	183	scores[NUMSPOTS - 1].hs_score = score;
182	scores[NUMSPOTS - 1].hs_level = level;	184	scores[NUMSPOTS - 1].hs_level = level;
183		185
184	i = NUMSPOTS-1;	186	i = NUMSPOTS-1;
185	while ((i > 0) && (scores[i - 1].hs_score < score))	187	while ((i > 0) && (scores[i - 1].hs_score < score))
186	i--;	188	i--;
187		189
188	for (j = NUMSPOTS - 2; j > i; j--) {	190	for (j = NUMSPOTS - 2; j > i; j--) {
189	copyhiscore(j,j-1);	191	copyhiscore(j,j-1);
190	}	192	}
191	copyhiscore(i, NUMSPOTS - 1);	193	copyhiscore(i, NUMSPOTS - 1);
192	}	194	}
193		195
194	void initscores(void)	196	void initscores(void)
195	{	197	{
196	int i;	198	int i;
197	for(i = 0; i < NUMSPOTS; i++) {	199	for(i = 0; i < NUMSPOTS; i++) {
198	strncpy(scores[i].hs_name, "HelenOS Team", MAXLOGNAME);	200	str_cpy(scores[i].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, "HelenOS Team");
199	scores[i].hs_score = (NUMSPOTS - i) * 200;	201	scores[i].hs_score = (NUMSPOTS - i) * 200;
200	scores[i].hs_level = (i + 1 > MAXLEVEL?MAXLEVEL:i + 1);	202	scores[i].hs_level = (i + 1 > MAXLEVEL?MAXLEVEL:i + 1);
201	}	203	}
202	}	204	}
203		205
204	/*	206	/*
205	* Read the score file. Can be called from savescore (before showscores)	207	* Read the score file. Can be called from savescore (before showscores)
206	* or showscores (if savescore will not be called). If the given pointer	208	* or showscores (if savescore will not be called). If the given pointer
207	* is not NULL, sets *fpp to an open file pointer that corresponds to a	209	* is not NULL, sets *fpp to an open file pointer that corresponds to a
208	* read/write score file that is locked with LOCK_EX. Otherwise, the	210	* read/write score file that is locked with LOCK_EX. Otherwise, the
209	* file is locked with LOCK_SH for the read and closed before return.	211	* file is locked with LOCK_SH for the read and closed before return.
210	*	212	*
211	* Note, we assume closing the stdio file releases the lock.	213	* Note, we assume closing the stdio file releases the lock.
212	*/	214	*/
213	/* static void */	215	/* static void */
214	/* getscores(FILE *fpp) /	216	/* getscores(FILE *fpp) /
215	/* { */	217	/* { */
216	/* int sd, mint, lck, mask, i; */	218	/* int sd, mint, lck, mask, i; */
217	/* char mstr, human; */	219	/* char mstr, human; */
218	/* FILE sf; /	220	/* FILE sf; /
219		221
220	/* if (fpp != NULL) { */	222	/* if (fpp != NULL) { */
221	/* mint = O_RDWR \| O_CREAT; */	223	/* mint = O_RDWR \| O_CREAT; */
222	/* mstr = "r+"; */	224	/* mstr = "r+"; */
223	/* human = "read/write"; */	225	/* human = "read/write"; */
224	/* lck = LOCK_EX; */	226	/* lck = LOCK_EX; */
225	/* } else { */	227	/* } else { */
226	/* mint = O_RDONLY; */	228	/* mint = O_RDONLY; */
227	/* mstr = "r"; */	229	/* mstr = "r"; */
228	/* human = "reading"; */	230	/* human = "reading"; */
229	/* lck = LOCK_SH; */	231	/* lck = LOCK_SH; */
230	/* } */	232	/* } */
231	/* setegid(egid); */	233	/* setegid(egid); */
232	/* mask = umask(S_IWOTH); */	234	/* mask = umask(S_IWOTH); */
233	/* sd = open(_PATH_SCOREFILE, mint, 0666); */	235	/* sd = open(_PATH_SCOREFILE, mint, 0666); */
234	/* (void)umask(mask); */	236	/* (void)umask(mask); */
235	/* setegid(gid); */	237	/* setegid(gid); */
236	/* if (sd < 0) { */	238	/* if (sd < 0) { */
237	/* if (fpp == NULL) { */	239	/* if (fpp == NULL) { */
238	/* nscores = 0; */	240	/* nscores = 0; */
239	/* return; */	241	/* return; */
240	/* } */	242	/* } */
241	/* err(1, "cannot open %s for %s", _PATH_SCOREFILE, human); */	243	/* err(1, "cannot open %s for %s", _PATH_SCOREFILE, human); */
242	/* } */	244	/* } */
243	/* setegid(egid); */	245	/* setegid(egid); */
244	/* if ((sf = fdopen(sd, mstr)) == NULL) */	246	/* if ((sf = fdopen(sd, mstr)) == NULL) */
245	/* err(1, "cannot fdopen %s for %s", _PATH_SCOREFILE, human); */	247	/* err(1, "cannot fdopen %s for %s", _PATH_SCOREFILE, human); */
246	/* setegid(gid); */	248	/* setegid(gid); */
247		249
248	/* /\* */	250	/* /\* */
249	/* * Grab a lock. */	251	/* * Grab a lock. */
250	/* \/ /	252	/* \/ /
251	/* if (flock(sd, lck)) */	253	/* if (flock(sd, lck)) */
252	/* warn("warning: score file %s cannot be locked", */	254	/* warn("warning: score file %s cannot be locked", */
253	/* _PATH_SCOREFILE); */	255	/* _PATH_SCOREFILE); */
254		256
255	/* nscores = fread(scores, sizeof(scores[0]), MAXHISCORES, sf); */	257	/* nscores = fread(scores, sizeof(scores[0]), MAXHISCORES, sf); */
256	/* if (ferror(sf)) */	258	/* if (ferror(sf)) */
257	/* err(1, "error reading %s", _PATH_SCOREFILE); */	259	/* err(1, "error reading %s", _PATH_SCOREFILE); */
258	/* for (i = 0; i < nscores; i++) */	260	/* for (i = 0; i < nscores; i++) */
259	/* if (scores[i].hs_level < MINLEVEL \|\| */	261	/* if (scores[i].hs_level < MINLEVEL \|\| */
260	/* scores[i].hs_level > MAXLEVEL) */	262	/* scores[i].hs_level > MAXLEVEL) */
261	/* errx(1, "scorefile %s corrupt", _PATH_SCOREFILE); */	263	/* errx(1, "scorefile %s corrupt", _PATH_SCOREFILE); */
262		264
263	/* if (fpp) */	265	/* if (fpp) */
264	/* fpp = sf; /	266	/* fpp = sf; /
265	/* else */	267	/* else */
266	/* (void)fclose(sf); */	268	/* (void)fclose(sf); */
267	/* } */	269	/* } */
268		270
269	void	271	void
270	savescore(int level)	272	savescore(int level)
271	{	273	{
272	return;	274	return;
273	}	275	}
274	/* struct highscore sp; /	276	/* struct highscore sp; /
275	/* int i; */	277	/* int i; */
276	/* int change; */	278	/* int change; */
277	/* FILE sf; /	279	/* FILE sf; /
278	/* const char me; /	280	/* const char me; /
279		281
280	/* getscores(&sf); */	282	/* getscores(&sf); */
281	/* gotscores = 1; */	283	/* gotscores = 1; */
282	/* (void)time(&now); */	284	/* (void)time(&now); */
283		285
284	/* /\* */	286	/* /\* */
285	/* * Allow at most one score per person per level -- see if we */	287	/* * Allow at most one score per person per level -- see if we */
286	/* * can replace an existing score, or (easiest) do nothing. */	288	/* * can replace an existing score, or (easiest) do nothing. */
287	/* * Otherwise add new score at end (there is always room). */	289	/* * Otherwise add new score at end (there is always room). */
288	/* \/ /	290	/* \/ /
289	/* change = 0; */	291	/* change = 0; */
290	/* me = thisuser(); */	292	/* me = thisuser(); */
291	/* for (i = 0, sp = &scores[0]; i < nscores; i++, sp++) { */	293	/* for (i = 0, sp = &scores[0]; i < nscores; i++, sp++) { */
292	/* if (sp->hs_level != level \|\| strcmp(sp->hs_name, me) != 0) */	294	/* if (sp->hs_level != level \|\| str_cmp(sp->hs_name, me) != 0) */
293	/* continue; */	295	/* continue; */
294	/* if (score > sp->hs_score) { */	296	/* if (score > sp->hs_score) { */
295	/* (void)printf("%s bettered %s %d score of %d!\n", */	297	/* (void)printf("%s bettered %s %d score of %d!\n", */
296	/* "\nYou", "your old level", level, */	298	/* "\nYou", "your old level", level, */
297	/* sp->hs_score * sp->hs_level); */	299	/* sp->hs_score * sp->hs_level); */
298	/* sp->hs_score = score; /\* new score \/ /	300	/* sp->hs_score = score; /\* new score \/ /
299	/* sp->hs_time = now; /\* and time \/ /	301	/* sp->hs_time = now; /\* and time \/ /
300	/* change = 1; */	302	/* change = 1; */
301	/* } else if (score == sp->hs_score) { */	303	/* } else if (score == sp->hs_score) { */
302	/* (void)printf("%s tied %s %d high score.\n", */	304	/* (void)printf("%s tied %s %d high score.\n", */
303	/* "\nYou", "your old level", level); */	305	/* "\nYou", "your old level", level); */
304	/* sp->hs_time = now; /\* renew it \/ /	306	/* sp->hs_time = now; /\* renew it \/ /
305	/* change = 1; /\* gotta rewrite, sigh \/ /	307	/* change = 1; /\* gotta rewrite, sigh \/ /
306	/* } /\* else new score < old score: do nothing \/ /	308	/* } /\* else new score < old score: do nothing \/ /
307	/* break; */	309	/* break; */
308	/* } */	310	/* } */
309	/* if (i >= nscores) { */	311	/* if (i >= nscores) { */
310	/* strlcpy(sp->hs_name, me, sizeof sp->hs_name); */	312	/* strlcpy(sp->hs_name, me, sizeof sp->hs_name); */
311	/* sp->hs_level = level; */	313	/* sp->hs_level = level; */
312	/* sp->hs_score = score; */	314	/* sp->hs_score = score; */
313	/* sp->hs_time = now; */	315	/* sp->hs_time = now; */
314	/* nscores++; */	316	/* nscores++; */
315	/* change = 1; */	317	/* change = 1; */
316	/* } */	318	/* } */
317		319
318	/* if (change) { */	320	/* if (change) { */
319	/* /\* */	321	/* /\* */
320	/* * Sort & clean the scores, then rewrite. */	322	/* * Sort & clean the scores, then rewrite. */
321	/* \/ /	323	/* \/ /
322	/* nscores = checkscores(scores, nscores); */	324	/* nscores = checkscores(scores, nscores); */
323	/* rewind(sf); */	325	/* rewind(sf); */
324	/* if (fwrite(scores, sizeof(sp), nscores, sf) != nscores \|\| /	326	/* if (fwrite(scores, sizeof(sp), nscores, sf) != nscores \|\| /
325	/* fflush(sf) == EOF) */	327	/* fflush(sf) == EOF) */
326	/* warnx("error writing %s: %s\n\t-- %s", */	328	/* warnx("error writing %s: %s\n\t-- %s", */
327	/* _PATH_SCOREFILE, strerror(errno), */	329	/* _PATH_SCOREFILE, strerror(errno), */
328	/* "high scores may be damaged"); */	330	/* "high scores may be damaged"); */
329	/* } */	331	/* } */
330	/* (void)fclose(sf); /\* releases lock \/ /	332	/* (void)fclose(sf); /\* releases lock \/ /
331	/* } */	333	/* } */
332		334
333	/*	335	/*
334	* Get login name, or if that fails, get something suitable.	336	* Get login name, or if that fails, get something suitable.
335	* The result is always trimmed to fit in a score.	337	* The result is always trimmed to fit in a score.
336	*/	338	*/
337	/* static char * */	339	/* static char * */
338	/* thisuser(void) */	340	/* thisuser(void) */
339	/* { */	341	/* { */
340	/* const char p; /	342	/* const char p; /
341	/* struct passwd pw; /	343	/* struct passwd pw; /
342	/* static char u[sizeof(scores[0].hs_name)]; */	344	/* static char u[sizeof(scores[0].hs_name)]; */
343		345
344	/* if (u[0]) */	346	/* if (u[0]) */
345	/* return (u); */	347	/* return (u); */
346	/* p = getlogin(); */	348	/* p = getlogin(); */
347	/* if (p == NULL \|\| p == '\0') { /	349	/* if (p == NULL \|\| p == '\0') { /
348	/* pw = getpwuid(getuid()); */	350	/* pw = getpwuid(getuid()); */
349	/* if (pw != NULL) */	351	/* if (pw != NULL) */
350	/* p = pw->pw_name; */	352	/* p = pw->pw_name; */
351	/* else */	353	/* else */
352	/* p = " ???"; */	354	/* p = " ???"; */
353	/* } */	355	/* } */
354	/* strlcpy(u, p, sizeof(u)); */	356	/* strlcpy(u, p, sizeof(u)); */
355	/* return (u); */	357	/* return (u); */
356	/* } */	358	/* } */
357		359
358	/*	360	/*
359	* Score comparison function for qsort.	361	* Score comparison function for qsort.
360	*	362	*
361	* If two scores are equal, the person who had the score first is	363	* If two scores are equal, the person who had the score first is
362	* listed first in the highscore file.	364	* listed first in the highscore file.
363	*/	365	*/
364	/* static int */	366	/* static int */
365	/* cmpscores(const void x, const void y) */	367	/* cmpscores(const void x, const void y) */
366	/* { */	368	/* { */
367	/* const struct highscore a, b; */	369	/* const struct highscore a, b; */
368	/* long l; */	370	/* long l; */
369		371
370	/* a = x; */	372	/* a = x; */
371	/* b = y; */	373	/* b = y; */
372	/* l = (long)b->hs_level * b->hs_score - (long)a->hs_level * a->hs_score; */	374	/* l = (long)b->hs_level * b->hs_score - (long)a->hs_level * a->hs_score; */
373	/* if (l < 0) */	375	/* if (l < 0) */
374	/* return (-1); */	376	/* return (-1); */
375	/* if (l > 0) */	377	/* if (l > 0) */
376	/* return (1); */	378	/* return (1); */
377	/* if (a->hs_time < b->hs_time) */	379	/* if (a->hs_time < b->hs_time) */
378	/* return (-1); */	380	/* return (-1); */
379	/* if (a->hs_time > b->hs_time) */	381	/* if (a->hs_time > b->hs_time) */
380	/* return (1); */	382	/* return (1); */
381	/* return (0); */	383	/* return (0); */
382	/* } */	384	/* } */
383		385
384	/*	386	/*
385	* If we've added a score to the file, we need to check the file and ensure	387	* If we've added a score to the file, we need to check the file and ensure
386	* that this player has only a few entries. The number of entries is	388	* that this player has only a few entries. The number of entries is
387	* controlled by MAXSCORES, and is to ensure that the highscore file is not	389	* controlled by MAXSCORES, and is to ensure that the highscore file is not
388	* monopolised by just a few people. People who no longer have accounts are	390	* monopolised by just a few people. People who no longer have accounts are
389	* only allowed the highest score. Scores older than EXPIRATION seconds are	391	* only allowed the highest score. Scores older than EXPIRATION seconds are
390	* removed, unless they are someone's personal best.	392	* removed, unless they are someone's personal best.
391	* Caveat: the highest score on each level is always kept.	393	* Caveat: the highest score on each level is always kept.
392	*/	394	*/
393	/* static int */	395	/* static int */
394	/* checkscores(struct highscore hs, int num) /	396	/* checkscores(struct highscore hs, int num) /
395	/* { */	397	/* { */
396	/* struct highscore sp; /	398	/* struct highscore sp; /
397	/* int i, j, k, numnames; */	399	/* int i, j, k, numnames; */
398	/* int levelfound[NLEVELS]; */	400	/* int levelfound[NLEVELS]; */
399	/* struct peruser { */	401	/* struct peruser { */
400	/* char name; /	402	/* char name; /
401	/* int times; */	403	/* int times; */
402	/* } count[NUMSPOTS]; */	404	/* } count[NUMSPOTS]; */
403	/* struct peruser pu; /	405	/* struct peruser pu; /
404		406
405	/* /\* */	407	/* /\* */
406	/* * Sort so that highest totals come first. */	408	/* * Sort so that highest totals come first. */
407	/* * */	409	/* * */
408	/* * levelfound[i] becomes set when the first high score for that */	410	/* * levelfound[i] becomes set when the first high score for that */
409	/* * level is encountered. By definition this is the highest score. */	411	/* * level is encountered. By definition this is the highest score. */
410	/* \/ /	412	/* \/ /
411	/* qsort((void )hs, nscores, sizeof(hs), cmpscores); */	413	/* qsort((void )hs, nscores, sizeof(hs), cmpscores); */
412	/* for (i = MINLEVEL; i < NLEVELS; i++) */	414	/* for (i = MINLEVEL; i < NLEVELS; i++) */
413	/* levelfound[i] = 0; */	415	/* levelfound[i] = 0; */
414	/* numnames = 0; */	416	/* numnames = 0; */
415	/* for (i = 0, sp = hs; i < num;) { */	417	/* for (i = 0, sp = hs; i < num;) { */
416	/* /\* */	418	/* /\* */
417	/* * This is O(n^2), but do you think we care? */	419	/* * This is O(n^2), but do you think we care? */
418	/* \/ /	420	/* \/ /
419	/* for (j = 0, pu = count; j < numnames; j++, pu++) */	421	/* for (j = 0, pu = count; j < numnames; j++, pu++) */
420	/* if (strcmp(sp->hs_name, pu->name) == 0) */	422	/* if (str_cmp(sp->hs_name, pu->name) == 0) */
421	/* break; */	423	/* break; */
422	/* if (j == numnames) { */	424	/* if (j == numnames) { */
423	/* /\* */	425	/* /\* */
424	/* * Add new user, set per-user count to 1. */	426	/* * Add new user, set per-user count to 1. */
425	/* \/ /	427	/* \/ /
426	/* pu->name = sp->hs_name; */	428	/* pu->name = sp->hs_name; */
427	/* pu->times = 1; */	429	/* pu->times = 1; */
428	/* numnames++; */	430	/* numnames++; */
429	/* } else { */	431	/* } else { */
430	/* /\* */	432	/* /\* */
431	/* * Two ways to keep this score: */	433	/* * Two ways to keep this score: */
432	/* * - Not too many (per user), still has acct, & */	434	/* * - Not too many (per user), still has acct, & */
433	/* * score not dated; or */	435	/* * score not dated; or */
434	/* * - High score on this level. */	436	/* * - High score on this level. */
435	/* \/ /	437	/* \/ /
436	/* if ((pu->times < MAXSCORES && */	438	/* if ((pu->times < MAXSCORES && */
437	/* getpwnam(sp->hs_name) != NULL && */	439	/* getpwnam(sp->hs_name) != NULL && */
438	/* sp->hs_time + EXPIRATION >= now) \|\| */	440	/* sp->hs_time + EXPIRATION >= now) \|\| */
439	/* levelfound[sp->hs_level] == 0) */	441	/* levelfound[sp->hs_level] == 0) */
440	/* pu->times++; */	442	/* pu->times++; */
441	/* else { */	443	/* else { */
442	/* /\* */	444	/* /\* */
443	/* * Delete this score, do not count it, */	445	/* * Delete this score, do not count it, */
444	/* * do not pass go, do not collect $200. */	446	/* * do not pass go, do not collect $200. */
445	/* \/ /	447	/* \/ /
446	/* num--; */	448	/* num--; */
447	/* for (k = i; k < num; k++) */	449	/* for (k = i; k < num; k++) */
448	/* hs[k] = hs[k + 1]; */	450	/* hs[k] = hs[k + 1]; */
449	/* continue; */	451	/* continue; */
450	/* } */	452	/* } */
451	/* } */	453	/* } */
452	/* levelfound[sp->hs_level] = 1; */	454	/* levelfound[sp->hs_level] = 1; */
453	/* i++, sp++; */	455	/* i++, sp++; */
454	/* } */	456	/* } */
455	/* return (num > MAXHISCORES ? MAXHISCORES : num); */	457	/* return (num > MAXHISCORES ? MAXHISCORES : num); */
456	/* } */	458	/* } */
457		459
458	/*	460	/*
459	* Show current scores. This must be called after savescore, if	461	* Show current scores. This must be called after savescore, if
460	* savescore is called at all, for two reasons:	462	* savescore is called at all, for two reasons:
461	* - Showscores munches the time field.	463	* - Showscores munches the time field.
462	* - Even if that were not the case, a new score must be recorded	464	* - Even if that were not the case, a new score must be recorded
463	* before it can be shown anyway.	465	* before it can be shown anyway.
464	*/	466	*/
465	/*	467	/*
466	void	468	void
467	showscores(int level)	469	showscores(int level)
468	{	470	{
469	return;	471	return;
470	}	472	}
471	*/	473	*/
472	/* struct highscore sp; /	474	/* struct highscore sp; /
473	/* int i, n, c; */	475	/* int i, n, c; */
474	/* const char me; /	476	/* const char me; /
475	/* int levelfound[NLEVELS]; */	477	/* int levelfound[NLEVELS]; */
476		478
477	/* if (!gotscores) */	479	/* if (!gotscores) */
478	/* getscores((FILE *)NULL); /	480	/* getscores((FILE *)NULL); /
479	/* (void)printf("\n\t\t Tetris High Scores\n"); */	481	/* (void)printf("\n\t\t Tetris High Scores\n"); */
480		482
481	/* /\* */	483	/* /\* */
482	/* * If level == 0, the person has not played a game but just asked for */	484	/* * If level == 0, the person has not played a game but just asked for */
483	/* * the high scores; we do not need to check for printing in highlight */	485	/* * the high scores; we do not need to check for printing in highlight */
484	/* * mode. If SOstr is null, we can't do highlighting anyway. */	486	/* * mode. If SOstr is null, we can't do highlighting anyway. */
485	/* \/ /	487	/* \/ /
486	/* me = level && SOstr ? thisuser() : NULL; */	488	/* me = level && SOstr ? thisuser() : NULL; */
487		489
488	/* /\* */	490	/* /\* */
489	/* * Set times to 0 except for high score on each level. */	491	/* * Set times to 0 except for high score on each level. */
490	/* \/ /	492	/* \/ /
491	/* for (i = MINLEVEL; i < NLEVELS; i++) */	493	/* for (i = MINLEVEL; i < NLEVELS; i++) */
492	/* levelfound[i] = 0; */	494	/* levelfound[i] = 0; */
493	/* for (i = 0, sp = scores; i < nscores; i++, sp++) { */	495	/* for (i = 0, sp = scores; i < nscores; i++, sp++) { */
494	/* if (levelfound[sp->hs_level]) */	496	/* if (levelfound[sp->hs_level]) */
495	/* sp->hs_time = 0; */	497	/* sp->hs_time = 0; */
496	/* else { */	498	/* else { */
497	/* sp->hs_time = 1; */	499	/* sp->hs_time = 1; */
498	/* levelfound[sp->hs_level] = 1; */	500	/* levelfound[sp->hs_level] = 1; */

Subversion Repositories HelenOS

(root)/branches/network/uspace/app/tetris/scores.c – Rev 4263 → 4327