games/tetris/scores.c

   1 /*      $OpenBSD: scores.c,v 1.22 2016/08/27 02:00:10 guenther Exp $    */
   2 /*      $NetBSD: scores.c,v 1.2 1995/04/22 07:42:38 cgd Exp $   */
   3
   4 /*-
   5  * Copyright (c) 1992, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * Chris Torek and Darren F. Provine.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  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
  21  *    without specific prior written permission.
  22  *
  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
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  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
  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
  33  * SUCH DAMAGE.
  34  *
  35  *      @(#)scores.c    8.1 (Berkeley) 5/31/93
  36  */
  37
  38 /*
  39  * Score code for Tetris, by Darren Provine (kilroy@gboro.glassboro.edu)
  40  * modified 22 January 1992, to limit the number of entries any one
  41  * person has.
  42  *
  43  * Major whacks since then.
  44  */
  45 #include <err.h>
  46 #include <errno.h>
  47 #include <fcntl.h>
  48 #include <limits.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <term.h>
  53 #include <time.h>
  54 #include <unistd.h>
  55
  56 #include "scores.h"
  57 #include "screen.h"
  58 #include "tetris.h"
  59
  60 /*
  61  * Within this code, we can hang onto one extra "high score", leaving
  62  * room for our current score (whether or not it is high).
  63  *
  64  * We also sometimes keep tabs on the "highest" score on each level.
  65  * As long as the scores are kept sorted, this is simply the first one at
  66  * that level.
  67  */
  68 #define NUMSPOTS (MAXHISCORES + 1)
  69 #define NLEVELS (MAXLEVEL + 1)
  70
  71 static time_t now;
  72 static unsigned int nscores;
  73 static int gotscores;
  74 static struct highscore scores[NUMSPOTS];
  75
  76 static int checkscores(struct highscore *, unsigned int);
  77 static int cmpscores(const void *, const void *);
  78 static void getscores(FILE **);
  79 static void printem(int, int, struct highscore *, int, const char *);
  80 static char *thisuser(void);
  81
  82 /*
  83  * Read the score file.  Can be called from savescore (before showscores)
  84  * or showscores (if savescore will not be called).  If the given pointer
  85  * is not NULL, sets *fpp to an open file pointer that corresponds to a
  86  * read/write score file that is locked with LOCK_EX.  Otherwise, the
  87  * file is locked with LOCK_SH for the read and closed before return.
  88  *
  89  * Note, we assume closing the stdio file releases the lock.
  90  */
  91 static void
  92 getscores(FILE **fpp)
  93 {
  94         int sd, mint, ret;
  95         unsigned int i;
  96         const char *mstr, *human, *home;
  97         char scorepath[PATH_MAX];
  98         FILE *sf;
  99
 100         if (fpp != NULL) {
 101                 mint = O_RDWR | O_CREAT;
 102                 mstr = "r+";
 103                 human = "read/write";
 104                 *fpp = NULL;
 105         } else {
 106                 mint = O_RDONLY;
 107                 mstr = "r";
 108                 human = "reading";
 109         }
 110
 111         home = getenv("HOME");
 112         if (home == NULL || *home == '\0')
 113                 err(1, "getenv");
 114
 115         ret = snprintf(scorepath, sizeof(scorepath), "%s/%s", home, ".tetris.scores");
 116         if (ret < 0 || ret >= PATH_MAX)
 117                 errc(1, ENAMETOOLONG, "%s/%s", home, ".tetris.scores");
 118
 119         sd = open(scorepath, mint, 0666);
 120         if (sd < 0) {
 121                 if (fpp == NULL) {
 122                         nscores = 0;
 123                         return;
 124                 }
 125                 err(1, "cannot open %s for %s", scorepath, human);
 126         }
 127         if ((sf = fdopen(sd, mstr)) == NULL)
 128                 err(1, "cannot fdopen %s for %s", scorepath, human);
 129
 130         nscores = fread(scores, sizeof(scores[0]), MAXHISCORES, sf);
 131         if (ferror(sf))
 132                 err(1, "error reading %s", scorepath);
 133         for (i = 0; i < nscores; i++)
 134                 if (scores[i].hs_level < MINLEVEL ||
 135                     scores[i].hs_level > MAXLEVEL)
 136                         errx(1, "scorefile %s corrupt", scorepath);
 137
 138         if (fpp)
 139                 *fpp = sf;
 140         else
 141                 fclose(sf);
 142 }
 143
 144 void
 145 savescore(int level)
 146 {
 147         struct highscore *sp;
 148         unsigned int i;
 149         int change;
 150         FILE *sf;
 151         const char *me;
 152
 153         getscores(&sf);
 154         gotscores = 1;
 155         time(&now);
 156
 157         /*
 158          * Allow at most one score per person per level -- see if we
 159          * can replace an existing score, or (easiest) do nothing.
 160          * Otherwise add new score at end (there is always room).
 161          */
 162         change = 0;
 163         me = thisuser();
 164         for (i = 0, sp = &scores[0]; i < nscores; i++, sp++) {
 165                 if (sp->hs_level != level || strcmp(sp->hs_name, me) != 0)
 166                         continue;
 167                 if (score > sp->hs_score) {
 168                         printf("%s bettered %s %d score of %d!\n",
 169                             "\nYou", "your old level", level,
 170                             sp->hs_score * sp->hs_level);
 171                         sp->hs_score = score;   /* new score */
 172                         sp->hs_time = now;      /* and time */
 173                         change = 1;
 174                 } else if (score == sp->hs_score) {
 175                         printf("%s tied %s %d high score.\n",
 176                             "\nYou", "your old level", level);
 177                         sp->hs_time = now;      /* renew it */
 178                         change = 1;             /* gotta rewrite, sigh */
 179                 } /* else new score < old score: do nothing */
 180                 break;
 181         }
 182         if (i >= nscores) {
 183                 strlcpy(sp->hs_name, me, sizeof sp->hs_name);
 184                 sp->hs_level = level;
 185                 sp->hs_score = score;
 186                 sp->hs_time = now;
 187                 nscores++;
 188                 change = 1;
 189         }
 190
 191         if (change) {
 192                 /*
 193                  * Sort & clean the scores, then rewrite.
 194                  */
 195                 nscores = checkscores(scores, nscores);
 196                 if (fseek(sf, 0L, SEEK_SET) == -1)
 197                         err(1, "fseek");
 198                 if (fwrite(scores, sizeof(*sp), nscores, sf) != nscores ||
 199                     fflush(sf) == EOF)
 200                         warnx("error writing scorefile: %s\n\t-- %s",
 201                             strerror(errno),
 202                             "high scores may be damaged");
 203         }
 204         fclose(sf);     /* releases lock */
 205 }
 206
 207 /*
 208  * Get login name, or if that fails, get something suitable.
 209  * The result is always trimmed to fit in a score.
 210  */
 211 static char *
 212 thisuser(void)
 213 {
 214         const char *p;
 215         static char u[sizeof(scores[0].hs_name)];
 216
 217         if (u[0])
 218                 return (u);
 219         p = getenv("LOGNAME");
 220         if (p == NULL || *p == '\0')
 221                 p = getenv("USER");
 222         if (p == NULL || *p == '\0')
 223                 p = getlogin();
 224         if (p == NULL || *p == '\0')
 225                 p = "  ???";
 226         strlcpy(u, p, sizeof(u));
 227         return (u);
 228 }
 229
 230 /*
 231  * Score comparison function for qsort.
 232  *
 233  * If two scores are equal, the person who had the score first is
 234  * listed first in the highscore file.
 235  */
 236 static int
 237 cmpscores(const void *x, const void *y)
 238 {
 239         const struct highscore *a, *b;
 240         long l;
 241
 242         a = x;
 243         b = y;
 244         l = (long)b->hs_level * b->hs_score - (long)a->hs_level * a->hs_score;
 245         if (l < 0)
 246                 return (-1);
 247         if (l > 0)
 248                 return (1);
 249         if (a->hs_time < b->hs_time)
 250                 return (-1);
 251         if (a->hs_time > b->hs_time)
 252                 return (1);
 253         return (0);
 254 }
 255
 256 /*
 257  * If we've added a score to the file, we need to check the file and ensure
 258  * that this player has only a few entries.  The number of entries is
 259  * controlled by MAXSCORES, and is to ensure that the highscore file is not
 260  * monopolised by just a few people.  People who no longer have accounts are
 261  * only allowed the highest score.  Scores older than EXPIRATION seconds are
 262  * removed, unless they are someone's personal best.
 263  * Caveat:  the highest score on each level is always kept.
 264  */
 265 static int
 266 checkscores(struct highscore *hs, unsigned int num)
 267 {
 268         struct highscore *sp;
 269         unsigned int i, j, k, nrnames;
 270         int levelfound[NLEVELS];
 271         struct peruser {
 272                 char *name;
 273                 int times;
 274         } count[NUMSPOTS];
 275         struct peruser *pu;
 276
 277         /*
 278          * Sort so that highest totals come first.
 279          *
 280          * levelfound[i] becomes set when the first high score for that
 281          * level is encountered.  By definition this is the highest score.
 282          */
 283         qsort((void *)hs, nscores, sizeof(*hs), cmpscores);
 284         for (i = MINLEVEL; i < NLEVELS; i++)
 285                 levelfound[i] = 0;
 286         nrnames = 0;
 287         for (i = 0, sp = hs; i < num;) {
 288                 /*
 289                  * This is O(n^2), but do you think we care?
 290                  */
 291                 for (j = 0, pu = count; j < nrnames; j++, pu++)
 292                         if (strcmp(sp->hs_name, pu->name) == 0)
 293                                 break;
 294                 if (j == nrnames) {
 295                         /*
 296                          * Add new user, set per-user count to 1.
 297                          */
 298                         pu->name = sp->hs_name;
 299                         pu->times = 1;
 300                         nrnames++;
 301                 } else {
 302                         /*
 303                          * Two ways to keep this score:
 304                          * - Not too many (per user), still has acct, &
 305                          *      score not dated; or
 306                          * - High score on this level.
 307                          */
 308                         if ((pu->times < MAXSCORES &&
 309                              sp->hs_time + EXPIRATION >= now) ||
 310                             levelfound[sp->hs_level] == 0)
 311                                 pu->times++;
 312                         else {
 313                                 /*
 314                                  * Delete this score, do not count it,
 315                                  * do not pass go, do not collect $200.
 316                                  */
 317                                 num--;
 318                                 for (k = i; k < num; k++)
 319                                         hs[k] = hs[k + 1];
 320                                 continue;
 321                         }
 322                 }
 323                 levelfound[sp->hs_level] = 1;
 324                 i++, sp++;
 325         }
 326         return (num > MAXHISCORES ? MAXHISCORES : num);
 327 }
 328
 329 /*
 330  * Show current scores.  This must be called after savescore, if
 331  * savescore is called at all, for two reasons:
 332  * - Showscores munches the time field.
 333  * - Even if that were not the case, a new score must be recorded
 334  *   before it can be shown anyway.
 335  */
 336 void
 337 showscores(int level)
 338 {
 339         struct highscore *sp;
 340         unsigned int i, n;
 341         int c;
 342         const char *me;
 343         int levelfound[NLEVELS];
 344
 345         if (!gotscores)
 346                 getscores((FILE **)NULL);
 347         printf("\n\t\t    Tetris High Scores\n");
 348
 349         /*
 350          * If level == 0, the person has not played a game but just asked for
 351          * the high scores; we do not need to check for printing in highlight
 352          * mode.  If SOstr is null, we can't do highlighting anyway.
 353          */
 354         me = level && SOstr ? thisuser() : NULL;
 355
 356         /*
 357          * Set times to 0 except for high score on each level.
 358          */
 359         for (i = MINLEVEL; i < NLEVELS; i++)
 360                 levelfound[i] = 0;
 361         for (i = 0, sp = scores; i < nscores; i++, sp++) {
 362                 if (levelfound[sp->hs_level])
 363                         sp->hs_time = 0;
 364                 else {
 365                         sp->hs_time = 1;
 366                         levelfound[sp->hs_level] = 1;
 367                 }
 368         }
 369
 370         /*
 371          * Page each screenful of scores.
 372          */
 373         for (i = 0, sp = scores; i < nscores; sp += n) {
 374                 n = 20;
 375                 if (i + n > nscores)
 376                         n = nscores - i;
 377                 printem(level, i + 1, sp, n, me);
 378                 if ((i += n) < nscores) {
 379                         printf("\nHit RETURN to continue.");
 380                         fflush(stdout);
 381                         while ((c = getchar()) != '\n')
 382                                 if (c == EOF)
 383                                         break;
 384                         printf("\n");
 385                 }
 386         }
 387
 388         if (nscores == 0)
 389                 printf("\t\t\t      - none to date.\n");
 390 }
 391
 392 static void
 393 printem(int level, int offset, struct highscore *hs, int n, const char *me)
 394 {
 395         struct highscore *sp;
 396         int row, highlight;
 397         unsigned int i;
 398         char buf[100];
 399 #define TITLE "Rank  Score   Name                          (points/level)"
 400 #define TITL2 "=========================================================="
 401
 402         printf("%s\n%s\n", TITLE, TITL2);
 403
 404         highlight = 0;
 405
 406         for (row = 0; row < n; row++) {
 407                 sp = &hs[row];
 408                 snprintf(buf, sizeof(buf),
 409                     "%3d%c %6d  %-31s (%6d on %d)\n",
 410                     row + offset, sp->hs_time ? '*' : ' ',
 411                     sp->hs_score * sp->hs_level,
 412                     sp->hs_name, sp->hs_score, sp->hs_level);
 413                 /* Print leaders every three lines */
 414                 if ((row + 1) % 3 == 0) {
 415                         for (i = 0; i < sizeof(buf); i++)
 416                                 if (buf[i] == ' ')
 417                                         buf[i] = '_';
 418                 }
 419                 /*
 420                  * Highlight if appropriate.  This works because
 421                  * we only get one score per level.
 422                  */
 423                 if (me != NULL &&
 424                     sp->hs_level == level &&
 425                     sp->hs_score == score &&
 426                     strcmp(sp->hs_name, me) == 0) {
 427                         putpad(SOstr);
 428                         highlight = 1;
 429                 }
 430                 printf("%s", buf);
 431                 if (highlight) {
 432                         putpad(SEstr);
 433                         highlight = 0;
 434                 }
 435         }
 436 }