Subversion Repositories HelenOS

Rev

Rev 1965 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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