Subversion Repositories HelenOS-historic

Rev

Rev 1419 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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