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)
{
    strcpy(scores[dest].hs_name, 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: ");
    strncpy(scores[NUMSPOTS - 1].hs_name, "Player", MAXLOGNAME);
    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++) {
        strncpy(scores[i].hs_name, "HelenOS Team", MAXLOGNAME);
        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 || strcmp(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 (strcmp(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 && */
/*          strcmp(sp->hs_name, me) == 0) { */
/*          putpad(SOstr); */
/*          highlight = 1; */
/*      } */
/*      (void)printf("%s", buf); */
/*      if (highlight) { */
/*          putpad(SEstr); */
/*          highlight = 0; */
/*      } */
/*  } */
/* } */
 
/** @}
 */
 
 

Rev 3386	Rev 4263
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>
-		59	#include <kbd/keycode.h>
-		60	#include <stdlib.h>
58	/* #include <time.h> */	61	/* #include <time.h> */
59	/* #include <term.h> */	62	/* #include <term.h> */
60	/* #include <unistd.h> */	63	/* #include <unistd.h> */
61	/* #include <sys/param.h> */	64	/* #include <sys/param.h> */
62	/* #include <sys/stat.h> */	65	/* #include <sys/stat.h> */
63	/* #include <sys/types.h> */	66	/* #include <sys/types.h> */
64		67
65	#include "pathnames.h"	68	#include "pathnames.h"
66	#include "screen.h"	69	#include "screen.h"
67	#include "tetris.h"	70	#include "tetris.h"
68	#include "scores.h"	71	#include "scores.h"
69		72
70	/*	73	/*
71	* 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
72	* room for our current score (whether or not it is high).	75	* room for our current score (whether or not it is high).
73	*	76	*
74	* 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.
75	* 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
76	* that level.	79	* that level.
77	*/	80	*/
78	#define NUMSPOTS (MAXHISCORES + 1)	81	#define NUMSPOTS (MAXHISCORES + 1)
79	#define NLEVELS (MAXLEVEL + 1)	82	#define NLEVELS (MAXLEVEL + 1)
80		83
81	/* static time_t now; */	84	/* static time_t now; */
82	/* static int nscores; */	85	/* static int nscores; */
83	/* static int gotscores; */	86	/* static int gotscores; */
84	/* static struct highscore scores[NUMSPOTS]; */	87	/* static struct highscore scores[NUMSPOTS]; */
85	static struct highscore scores[NUMSPOTS];	88	static struct highscore scores[NUMSPOTS];
86		89
87	/* static int checkscores(struct highscore , int); /	90	/* static int checkscores(struct highscore , int); /
88	/* static int cmpscores(const void , const void ); */	91	/* static int cmpscores(const void , const void ); */
89	/* static void getscores(FILE *); /	92	/* static void getscores(FILE *); /
90	/* static void printem(int, int, struct highscore , int, const char ); */	93	/* static void printem(int, int, struct highscore , int, const char ); */
91	/* static char thisuser(void); /	94	/* static char thisuser(void); /
92		95
93	void showscores(int firstgame)	96	void showscores(int firstgame)
94	{	97	{
95	int i;	98	int i;
96		99
97	clear_screen();	100	clear_screen();
98	moveto(10, 0);	101	moveto(10, 0);
99	printf("\tRank \tLevel \tName\t points\n");	102	printf("\tRank \tLevel \tName\t points\n");
100	printf("\t========================================================\n");	103	printf("\t========================================================\n");
101	for (i = 0; i < NUMSPOTS - 1; i++) {	104	for (i = 0; i < NUMSPOTS - 1; i++) {
102	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);
103	}	106	}
104	if (!firstgame) {	107	if (!firstgame) {
105	printf("\t========================================================\n");	108	printf("\t========================================================\n");
106	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);
107	}	110	}
108	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.");
109	getchar();	112	getchar();
110	}	113	}
111		114
112	/** Copy from hiscore table score with index src to dest	115	/** Copy from hiscore table score with index src to dest
113	*	116	*
114	*/	117	*/
115	static void copyhiscore(int dest, int src)	118	static void copyhiscore(int dest, int src)
116	{	119	{
117	strcpy(scores[dest].hs_name, scores[src].hs_name);	120	strcpy(scores[dest].hs_name, scores[src].hs_name);
118	scores[dest].hs_score = scores[src].hs_score;	121	scores[dest].hs_score = scores[src].hs_score;
119	scores[dest].hs_level = scores[src].hs_level;	122	scores[dest].hs_level = scores[src].hs_level;
120	}	123	}
121		124
122	void insertscore(int score, int level)	125	void insertscore(int score, int level)
123	{	126	{
124	int i,j;	127	int i,j;
125	int key;	128	size_t off;
126		129	kbd_event_t ev;
127		130
128	clear_screen();	131	clear_screen();
129	moveto(10 , 10);	132	moveto(10 , 10);
130	puts("Insert your name: ");	133	puts("Insert your name: ");
131	strncpy(scores[NUMSPOTS - 1].hs_name, "Player", MAXLOGNAME);	134	strncpy(scores[NUMSPOTS - 1].hs_name, "Player", MAXLOGNAME);
132	i = 6;	135	i = 6; off = 6;
133		136
134	moveto(10 , 28);	137	moveto(10 , 28);
135	printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");	138	printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
-		139
-		140	while (1) {
136	key = getchar();	141	fflush(stdout);
-		142	if (kbd_get_event(&ev) != EOK)
-		143	exit(1);
-		144
137	while(key != '\n') {	145	if (ev.type == KE_RELEASE)
-		146	continue;
-		147
-		148	if (ev.key == KC_ENTER \|\| ev.key == KC_NENTER)
-		149	break;
-		150
138	if (key == '\b') {	151	if (ev.key == KC_BACKSPACE) {
139	if (i > 0)	152	if (i > 0) {
-		153	wchar_t uc;
-		154
-		155	--i;
-		156	while (off > 0) {
-		157	--off;
-		158	size_t otmp = off;
-		159	uc = str_decode(scores[NUMSPOTS - 1].hs_name,
-		160	&otmp, STR_BOUNDS(MAXLOGNAME) + 1);
-		161	if (uc != U_SPECIAL)
-		162	break;
-		163	}
-		164
140	scores[NUMSPOTS - 1].hs_name[--i] = '\0';	165	scores[NUMSPOTS - 1].hs_name[off] = '\0';
-		166	}
141	} else {	167	} else if (ev.c != '\0') {
142	if (i < (MAXLOGNAME - 1))	168	if (i < (MAXLOGNAME - 1)) {
143	scores[NUMSPOTS - 1].hs_name[i++] = key;	169	if (chr_encode(ev.c, scores[NUMSPOTS - 1].hs_name,
-		170	&off, STR_BOUNDS(MAXLOGNAME) + 1) == EOK) {
-		171	++i;
-		172	}
144	scores[NUMSPOTS - 1].hs_name[i] = '\0';	173	scores[NUMSPOTS - 1].hs_name[off] = '\0';
-		174	}
145	}	175	}
146		176
147	moveto(10 , 28);	177	moveto(10 , 28);
148	printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");	178	printf("%s%.*s",scores[NUMSPOTS - 1].hs_name,MAXLOGNAME-i,"........................................");
149		-
150	key = getchar();	-
151	}	179	}
152		180
153	scores[NUMSPOTS - 1].hs_score = score;	181	scores[NUMSPOTS - 1].hs_score = score;
154	scores[NUMSPOTS - 1].hs_level = level;	182	scores[NUMSPOTS - 1].hs_level = level;
155		183
156	i = NUMSPOTS-1;	184	i = NUMSPOTS-1;
157	while ((i > 0) && (scores[i - 1].hs_score < score))	185	while ((i > 0) && (scores[i - 1].hs_score < score))
158	i--;	186	i--;
159		187
160	for (j = NUMSPOTS - 2; j > i; j--) {	188	for (j = NUMSPOTS - 2; j > i; j--) {
161	copyhiscore(j,j-1);	189	copyhiscore(j,j-1);
162	}	190	}
163	copyhiscore(i, NUMSPOTS - 1);	191	copyhiscore(i, NUMSPOTS - 1);
164	}	192	}
165		193
166	void initscores(void)	194	void initscores(void)
167	{	195	{
168	int i;	196	int i;
169	for(i = 0; i < NUMSPOTS; i++) {	197	for(i = 0; i < NUMSPOTS; i++) {
170	strncpy(scores[i].hs_name, "HelenOS Team", MAXLOGNAME);	198	strncpy(scores[i].hs_name, "HelenOS Team", MAXLOGNAME);
171	scores[i].hs_score = (NUMSPOTS - i) * 200;	199	scores[i].hs_score = (NUMSPOTS - i) * 200;
172	scores[i].hs_level = (i + 1 > MAXLEVEL?MAXLEVEL:i + 1);	200	scores[i].hs_level = (i + 1 > MAXLEVEL?MAXLEVEL:i + 1);
173	}	201	}
174	}	202	}
175		203
176	/*	204	/*
177	* Read the score file. Can be called from savescore (before showscores)	205	* Read the score file. Can be called from savescore (before showscores)
178	* or showscores (if savescore will not be called). If the given pointer	206	* or showscores (if savescore will not be called). If the given pointer
179	* is not NULL, sets *fpp to an open file pointer that corresponds to a	207	* is not NULL, sets *fpp to an open file pointer that corresponds to a
180	* read/write score file that is locked with LOCK_EX. Otherwise, the	208	* read/write score file that is locked with LOCK_EX. Otherwise, the
181	* file is locked with LOCK_SH for the read and closed before return.	209	* file is locked with LOCK_SH for the read and closed before return.
182	*	210	*
183	* Note, we assume closing the stdio file releases the lock.	211	* Note, we assume closing the stdio file releases the lock.
184	*/	212	*/
185	/* static void */	213	/* static void */
186	/* getscores(FILE *fpp) /	214	/* getscores(FILE *fpp) /
187	/* { */	215	/* { */
188	/* int sd, mint, lck, mask, i; */	216	/* int sd, mint, lck, mask, i; */
189	/* char mstr, human; */	217	/* char mstr, human; */
190	/* FILE sf; /	218	/* FILE sf; /
191		219
192	/* if (fpp != NULL) { */	220	/* if (fpp != NULL) { */
193	/* mint = O_RDWR \| O_CREAT; */	221	/* mint = O_RDWR \| O_CREAT; */
194	/* mstr = "r+"; */	222	/* mstr = "r+"; */
195	/* human = "read/write"; */	223	/* human = "read/write"; */
196	/* lck = LOCK_EX; */	224	/* lck = LOCK_EX; */
197	/* } else { */	225	/* } else { */
198	/* mint = O_RDONLY; */	226	/* mint = O_RDONLY; */
199	/* mstr = "r"; */	227	/* mstr = "r"; */
200	/* human = "reading"; */	228	/* human = "reading"; */
201	/* lck = LOCK_SH; */	229	/* lck = LOCK_SH; */
202	/* } */	230	/* } */
203	/* setegid(egid); */	231	/* setegid(egid); */
204	/* mask = umask(S_IWOTH); */	232	/* mask = umask(S_IWOTH); */
205	/* sd = open(_PATH_SCOREFILE, mint, 0666); */	233	/* sd = open(_PATH_SCOREFILE, mint, 0666); */
206	/* (void)umask(mask); */	234	/* (void)umask(mask); */
207	/* setegid(gid); */	235	/* setegid(gid); */
208	/* if (sd < 0) { */	236	/* if (sd < 0) { */
209	/* if (fpp == NULL) { */	237	/* if (fpp == NULL) { */
210	/* nscores = 0; */	238	/* nscores = 0; */
211	/* return; */	239	/* return; */
212	/* } */	240	/* } */
213	/* err(1, "cannot open %s for %s", _PATH_SCOREFILE, human); */	241	/* err(1, "cannot open %s for %s", _PATH_SCOREFILE, human); */
214	/* } */	242	/* } */
215	/* setegid(egid); */	243	/* setegid(egid); */
216	/* if ((sf = fdopen(sd, mstr)) == NULL) */	244	/* if ((sf = fdopen(sd, mstr)) == NULL) */
217	/* err(1, "cannot fdopen %s for %s", _PATH_SCOREFILE, human); */	245	/* err(1, "cannot fdopen %s for %s", _PATH_SCOREFILE, human); */
218	/* setegid(gid); */	246	/* setegid(gid); */
219		247
220	/* /\* */	248	/* /\* */
221	/* * Grab a lock. */	249	/* * Grab a lock. */
222	/* \/ /	250	/* \/ /
223	/* if (flock(sd, lck)) */	251	/* if (flock(sd, lck)) */
224	/* warn("warning: score file %s cannot be locked", */	252	/* warn("warning: score file %s cannot be locked", */
225	/* _PATH_SCOREFILE); */	253	/* _PATH_SCOREFILE); */
226		254
227	/* nscores = fread(scores, sizeof(scores[0]), MAXHISCORES, sf); */	255	/* nscores = fread(scores, sizeof(scores[0]), MAXHISCORES, sf); */
228	/* if (ferror(sf)) */	256	/* if (ferror(sf)) */
229	/* err(1, "error reading %s", _PATH_SCOREFILE); */	257	/* err(1, "error reading %s", _PATH_SCOREFILE); */
230	/* for (i = 0; i < nscores; i++) */	258	/* for (i = 0; i < nscores; i++) */
231	/* if (scores[i].hs_level < MINLEVEL \|\| */	259	/* if (scores[i].hs_level < MINLEVEL \|\| */
232	/* scores[i].hs_level > MAXLEVEL) */	260	/* scores[i].hs_level > MAXLEVEL) */
233	/* errx(1, "scorefile %s corrupt", _PATH_SCOREFILE); */	261	/* errx(1, "scorefile %s corrupt", _PATH_SCOREFILE); */
234		262
235	/* if (fpp) */	263	/* if (fpp) */
236	/* fpp = sf; /	264	/* fpp = sf; /
237	/* else */	265	/* else */
238	/* (void)fclose(sf); */	266	/* (void)fclose(sf); */
239	/* } */	267	/* } */
240		268
241	void	269	void
242	savescore(int level)	270	savescore(int level)
243	{	271	{
244	return;	272	return;
245	}	273	}
246	/* struct highscore sp; /	274	/* struct highscore sp; /
247	/* int i; */	275	/* int i; */
248	/* int change; */	276	/* int change; */
249	/* FILE sf; /	277	/* FILE sf; /
250	/* const char me; /	278	/* const char me; /
251		279
252	/* getscores(&sf); */	280	/* getscores(&sf); */
253	/* gotscores = 1; */	281	/* gotscores = 1; */
254	/* (void)time(&now); */	282	/* (void)time(&now); */
255		283
256	/* /\* */	284	/* /\* */
257	/* * Allow at most one score per person per level -- see if we */	285	/* * Allow at most one score per person per level -- see if we */
258	/* * can replace an existing score, or (easiest) do nothing. */	286	/* * can replace an existing score, or (easiest) do nothing. */
259	/* * Otherwise add new score at end (there is always room). */	287	/* * Otherwise add new score at end (there is always room). */
260	/* \/ /	288	/* \/ /
261	/* change = 0; */	289	/* change = 0; */
262	/* me = thisuser(); */	290	/* me = thisuser(); */
263	/* for (i = 0, sp = &scores[0]; i < nscores; i++, sp++) { */	291	/* for (i = 0, sp = &scores[0]; i < nscores; i++, sp++) { */
264	/* if (sp->hs_level != level \|\| strcmp(sp->hs_name, me) != 0) */	292	/* if (sp->hs_level != level \|\| strcmp(sp->hs_name, me) != 0) */
265	/* continue; */	293	/* continue; */
266	/* if (score > sp->hs_score) { */	294	/* if (score > sp->hs_score) { */
267	/* (void)printf("%s bettered %s %d score of %d!\n", */	295	/* (void)printf("%s bettered %s %d score of %d!\n", */
268	/* "\nYou", "your old level", level, */	296	/* "\nYou", "your old level", level, */
269	/* sp->hs_score * sp->hs_level); */	297	/* sp->hs_score * sp->hs_level); */
270	/* sp->hs_score = score; /\* new score \/ /	298	/* sp->hs_score = score; /\* new score \/ /
271	/* sp->hs_time = now; /\* and time \/ /	299	/* sp->hs_time = now; /\* and time \/ /
272	/* change = 1; */	300	/* change = 1; */
273	/* } else if (score == sp->hs_score) { */	301	/* } else if (score == sp->hs_score) { */
274	/* (void)printf("%s tied %s %d high score.\n", */	302	/* (void)printf("%s tied %s %d high score.\n", */
275	/* "\nYou", "your old level", level); */	303	/* "\nYou", "your old level", level); */
276	/* sp->hs_time = now; /\* renew it \/ /	304	/* sp->hs_time = now; /\* renew it \/ /
277	/* change = 1; /\* gotta rewrite, sigh \/ /	305	/* change = 1; /\* gotta rewrite, sigh \/ /
278	/* } /\* else new score < old score: do nothing \/ /	306	/* } /\* else new score < old score: do nothing \/ /
279	/* break; */	307	/* break; */
280	/* } */	308	/* } */
281	/* if (i >= nscores) { */	309	/* if (i >= nscores) { */
282	/* strlcpy(sp->hs_name, me, sizeof sp->hs_name); */	310	/* strlcpy(sp->hs_name, me, sizeof sp->hs_name); */
283	/* sp->hs_level = level; */	311	/* sp->hs_level = level; */
284	/* sp->hs_score = score; */	312	/* sp->hs_score = score; */
285	/* sp->hs_time = now; */	313	/* sp->hs_time = now; */
286	/* nscores++; */	314	/* nscores++; */
287	/* change = 1; */	315	/* change = 1; */
288	/* } */	316	/* } */
289		317
290	/* if (change) { */	318	/* if (change) { */
291	/* /\* */	319	/* /\* */
292	/* * Sort & clean the scores, then rewrite. */	320	/* * Sort & clean the scores, then rewrite. */
293	/* \/ /	321	/* \/ /
294	/* nscores = checkscores(scores, nscores); */	322	/* nscores = checkscores(scores, nscores); */
295	/* rewind(sf); */	323	/* rewind(sf); */
296	/* if (fwrite(scores, sizeof(sp), nscores, sf) != nscores \|\| /	324	/* if (fwrite(scores, sizeof(sp), nscores, sf) != nscores \|\| /
297	/* fflush(sf) == EOF) */	325	/* fflush(sf) == EOF) */
298	/* warnx("error writing %s: %s\n\t-- %s", */	326	/* warnx("error writing %s: %s\n\t-- %s", */
299	/* _PATH_SCOREFILE, strerror(errno), */	327	/* _PATH_SCOREFILE, strerror(errno), */
300	/* "high scores may be damaged"); */	328	/* "high scores may be damaged"); */
301	/* } */	329	/* } */
302	/* (void)fclose(sf); /\* releases lock \/ /	330	/* (void)fclose(sf); /\* releases lock \/ /
303	/* } */	331	/* } */
304		332
305	/*	333	/*
306	* Get login name, or if that fails, get something suitable.	334	* Get login name, or if that fails, get something suitable.
307	* The result is always trimmed to fit in a score.	335	* The result is always trimmed to fit in a score.
308	*/	336	*/
309	/* static char * */	337	/* static char * */
310	/* thisuser(void) */	338	/* thisuser(void) */
311	/* { */	339	/* { */
312	/* const char p; /	340	/* const char p; /
313	/* struct passwd pw; /	341	/* struct passwd pw; /
314	/* static char u[sizeof(scores[0].hs_name)]; */	342	/* static char u[sizeof(scores[0].hs_name)]; */
315		343
316	/* if (u[0]) */	344	/* if (u[0]) */
317	/* return (u); */	345	/* return (u); */
318	/* p = getlogin(); */	346	/* p = getlogin(); */
319	/* if (p == NULL \|\| p == '\0') { /	347	/* if (p == NULL \|\| p == '\0') { /
320	/* pw = getpwuid(getuid()); */	348	/* pw = getpwuid(getuid()); */
321	/* if (pw != NULL) */	349	/* if (pw != NULL) */
322	/* p = pw->pw_name; */	350	/* p = pw->pw_name; */
323	/* else */	351	/* else */
324	/* p = " ???"; */	352	/* p = " ???"; */
325	/* } */	353	/* } */
326	/* strlcpy(u, p, sizeof(u)); */	354	/* strlcpy(u, p, sizeof(u)); */
327	/* return (u); */	355	/* return (u); */
328	/* } */	356	/* } */
329		357
330	/*	358	/*
331	* Score comparison function for qsort.	359	* Score comparison function for qsort.
332	*	360	*
333	* If two scores are equal, the person who had the score first is	361	* If two scores are equal, the person who had the score first is
334	* listed first in the highscore file.	362	* listed first in the highscore file.
335	*/	363	*/
336	/* static int */	364	/* static int */
337	/* cmpscores(const void x, const void y) */	365	/* cmpscores(const void x, const void y) */
338	/* { */	366	/* { */
339	/* const struct highscore a, b; */	367	/* const struct highscore a, b; */
340	/* long l; */	368	/* long l; */
341		369
342	/* a = x; */	370	/* a = x; */
343	/* b = y; */	371	/* b = y; */
344	/* l = (long)b->hs_level * b->hs_score - (long)a->hs_level * a->hs_score; */	372	/* l = (long)b->hs_level * b->hs_score - (long)a->hs_level * a->hs_score; */
345	/* if (l < 0) */	373	/* if (l < 0) */
346	/* return (-1); */	374	/* return (-1); */
347	/* if (l > 0) */	375	/* if (l > 0) */
348	/* return (1); */	376	/* return (1); */
349	/* if (a->hs_time < b->hs_time) */	377	/* if (a->hs_time < b->hs_time) */
350	/* return (-1); */	378	/* return (-1); */
351	/* if (a->hs_time > b->hs_time) */	379	/* if (a->hs_time > b->hs_time) */
352	/* return (1); */	380	/* return (1); */
353	/* return (0); */	381	/* return (0); */
354	/* } */	382	/* } */
355		383
356	/*	384	/*
357	* If we've added a score to the file, we need to check the file and ensure	385	* If we've added a score to the file, we need to check the file and ensure
358	* that this player has only a few entries. The number of entries is	386	* that this player has only a few entries. The number of entries is
359	* controlled by MAXSCORES, and is to ensure that the highscore file is not	387	* controlled by MAXSCORES, and is to ensure that the highscore file is not
360	* monopolised by just a few people. People who no longer have accounts are	388	* monopolised by just a few people. People who no longer have accounts are
361	* only allowed the highest score. Scores older than EXPIRATION seconds are	389	* only allowed the highest score. Scores older than EXPIRATION seconds are
362	* removed, unless they are someone's personal best.	390	* removed, unless they are someone's personal best.
363	* Caveat: the highest score on each level is always kept.	391	* Caveat: the highest score on each level is always kept.
364	*/	392	*/
365	/* static int */	393	/* static int */
366	/* checkscores(struct highscore hs, int num) /	394	/* checkscores(struct highscore hs, int num) /
367	/* { */	395	/* { */
368	/* struct highscore sp; /	396	/* struct highscore sp; /
369	/* int i, j, k, numnames; */	397	/* int i, j, k, numnames; */
370	/* int levelfound[NLEVELS]; */	398	/* int levelfound[NLEVELS]; */
371	/* struct peruser { */	399	/* struct peruser { */
372	/* char name; /	400	/* char name; /
373	/* int times; */	401	/* int times; */
374	/* } count[NUMSPOTS]; */	402	/* } count[NUMSPOTS]; */
375	/* struct peruser pu; /	403	/* struct peruser pu; /
376		404
377	/* /\* */	405	/* /\* */
378	/* * Sort so that highest totals come first. */	406	/* * Sort so that highest totals come first. */
379	/* * */	407	/* * */
380	/* * levelfound[i] becomes set when the first high score for that */	408	/* * levelfound[i] becomes set when the first high score for that */
381	/* * level is encountered. By definition this is the highest score. */	409	/* * level is encountered. By definition this is the highest score. */
382	/* \/ /	410	/* \/ /
383	/* qsort((void )hs, nscores, sizeof(hs), cmpscores); */	411	/* qsort((void )hs, nscores, sizeof(hs), cmpscores); */
384	/* for (i = MINLEVEL; i < NLEVELS; i++) */	412	/* for (i = MINLEVEL; i < NLEVELS; i++) */
385	/* levelfound[i] = 0; */	413	/* levelfound[i] = 0; */
386	/* numnames = 0; */	414	/* numnames = 0; */
387	/* for (i = 0, sp = hs; i < num;) { */	415	/* for (i = 0, sp = hs; i < num;) { */
388	/* /\* */	416	/* /\* */
389	/* * This is O(n^2), but do you think we care? */	417	/* * This is O(n^2), but do you think we care? */
390	/* \/ /	418	/* \/ /
391	/* for (j = 0, pu = count; j < numnames; j++, pu++) */	419	/* for (j = 0, pu = count; j < numnames; j++, pu++) */
392	/* if (strcmp(sp->hs_name, pu->name) == 0) */	420	/* if (strcmp(sp->hs_name, pu->name) == 0) */
393	/* break; */	421	/* break; */
394	/* if (j == numnames) { */	422	/* if (j == numnames) { */
395	/* /\* */	423	/* /\* */
396	/* * Add new user, set per-user count to 1. */	424	/* * Add new user, set per-user count to 1. */
397	/* \/ /	425	/* \/ /
398	/* pu->name = sp->hs_name; */	426	/* pu->name = sp->hs_name; */
399	/* pu->times = 1; */	427	/* pu->times = 1; */
400	/* numnames++; */	428	/* numnames++; */
401	/* } else { */	429	/* } else { */
402	/* /\* */	430	/* /\* */
403	/* * Two ways to keep this score: */	431	/* * Two ways to keep this score: */
404	/* * - Not too many (per user), still has acct, & */	432	/* * - Not too many (per user), still has acct, & */
405	/* * score not dated; or */	433	/* * score not dated; or */
406	/* * - High score on this level. */	434	/* * - High score on this level. */
407	/* \/ /	435	/* \/ /
408	/* if ((pu->times < MAXSCORES && */	436	/* if ((pu->times < MAXSCORES && */
409	/* getpwnam(sp->hs_name) != NULL && */	437	/* getpwnam(sp->hs_name) != NULL && */
410	/* sp->hs_time + EXPIRATION >= now) \|\| */	438	/* sp->hs_time + EXPIRATION >= now) \|\| */
411	/* levelfound[sp->hs_level] == 0) */	439	/* levelfound[sp->hs_level] == 0) */
412	/* pu->times++; */	440	/* pu->times++; */
413	/* else { */	441	/* else { */
414	/* /\* */	442	/* /\* */
415	/* * Delete this score, do not count it, */	443	/* * Delete this score, do not count it, */
416	/* * do not pass go, do not collect $200. */	444	/* * do not pass go, do not collect $200. */
417	/* \/ /	445	/* \/ /
418	/* num--; */	446	/* num--; */
419	/* for (k = i; k < num; k++) */	447	/* for (k = i; k < num; k++) */
420	/* hs[k] = hs[k + 1]; */	448	/* hs[k] = hs[k + 1]; */
421	/* continue; */	449	/* continue; */
422	/* } */	450	/* } */
423	/* } */	451	/* } */
424	/* levelfound[sp->hs_level] = 1; */	452	/* levelfound[sp->hs_level] = 1; */
425	/* i++, sp++; */	453	/* i++, sp++; */
426	/* } */	454	/* } */
427	/* return (num > MAXHISCORES ? MAXHISCORES : num); */	455	/* return (num > MAXHISCORES ? MAXHISCORES : num); */
428	/* } */	456	/* } */
429		457
430	/*	458	/*
431	* Show current scores. This must be called after savescore, if	459	* Show current scores. This must be called after savescore, if
432	* savescore is called at all, for two reasons:	460	* savescore is called at all, for two reasons:
433	* - Showscores munches the time field.	461	* - Showscores munches the time field.
434	* - Even if that were not the case, a new score must be recorded	462	* - Even if that were not the case, a new score must be recorded
435	* before it can be shown anyway.	463	* before it can be shown anyway.
436	*/	464	*/
437	/*	465	/*
438	void	466	void
439	showscores(int level)	467	showscores(int level)
440	{	468	{
441	return;	469	return;
442	}	470	}
443	*/	471	*/
444	/* struct highscore sp; /	472	/* struct highscore sp; /
445	/* int i, n, c; */	473	/* int i, n, c; */
446	/* const char me; /	474	/* const char me; /
447	/* int levelfound[NLEVELS]; */	475	/* int levelfound[NLEVELS]; */
448		476
449	/* if (!gotscores) */	477	/* if (!gotscores) */
450	/* getscores((FILE *)NULL); /	478	/* getscores((FILE *)NULL); /
451	/* (void)printf("\n\t\t Tetris High Scores\n"); */	479	/* (void)printf("\n\t\t Tetris High Scores\n"); */
452		480
453	/* /\* */	481	/* /\* */
454	/* * If level == 0, the person has not played a game but just asked for */	482	/* * If level == 0, the person has not played a game but just asked for */
455	/* * the high scores; we do not need to check for printing in highlight */	483	/* * the high scores; we do not need to check for printing in highlight */
456	/* * mode. If SOstr is null, we can't do highlighting anyway. */	484	/* * mode. If SOstr is null, we can't do highlighting anyway. */
457	/* \/ /	485	/* \/ /
458	/* me = level && SOstr ? thisuser() : NULL; */	486	/* me = level && SOstr ? thisuser() : NULL; */
459		487
460	/* /\* */	488	/* /\* */
461	/* * Set times to 0 except for high score on each level. */	489	/* * Set times to 0 except for high score on each level. */
462	/* \/ /	490	/* \/ /
463	/* for (i = MINLEVEL; i < NLEVELS; i++) */	491	/* for (i = MINLEVEL; i < NLEVELS; i++) */
464	/* levelfound[i] = 0; */	492	/* levelfound[i] = 0; */
465	/* for (i = 0, sp = scores; i < nscores; i++, sp++) { */	493	/* for (i = 0, sp = scores; i < nscores; i++, sp++) { */
466	/* if (levelfound[sp->hs_level]) */	494	/* if (levelfound[sp->hs_level]) */
467	/* sp->hs_time = 0; */	495	/* sp->hs_time = 0; */
468	/* else { */	496	/* else { */
469	/* sp->hs_time = 1; */	497	/* sp->hs_time = 1; */
470	/* levelfound[sp->hs_level] = 1; */	498	/* levelfound[sp->hs_level] = 1; */

Subversion Repositories HelenOS

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