]> git.cameronkatri.com Git - bsdgames-darwin.git/blobdiff - robots/score.c
Fix merge conflicts
[bsdgames-darwin.git] / robots / score.c
index d96c8dff50b0f3ffcbffe23a6216a76159dec1be..91a2f38a0bea08b6457eef4ca45ccac787f4e069 100644 (file)
@@ -1,4 +1,4 @@
-/*     $NetBSD: score.c,v 1.3 1995/04/22 10:09:12 cgd Exp $    */
+/*     $NetBSD: score.c,v 1.24 2021/04/13 01:50:46 mrg Exp $   */
 
 /*
  * Copyright (c) 1980, 1993
  * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *     This product includes software developed by the University of
- *     California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 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.
  *
  * SUCH DAMAGE.
  */
 
+#include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)score.c    8.1 (Berkeley) 5/31/93";
 #else
-static char rcsid[] = "$NetBSD: score.c,v 1.3 1995/04/22 10:09:12 cgd Exp $";
+__RCSID("$NetBSD: score.c,v 1.24 2021/04/13 01:50:46 mrg Exp $");
 #endif
 #endif /* not lint */
 
-# include      "robots.h"
-# include      <sys/types.h>
-# include      <pwd.h>
-# include      "pathnames.h"
+#include <curses.h>
+#include <err.h>
+#include <fcntl.h>
+#include <pwd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "robots.h"
+#include "pathnames.h"
 
-typedef struct {
-       int     s_uid;
-       int     s_score;
-       char    s_name[MAXNAME];
-} SCORE;
+const char *Scorefile = _PATH_SCORE;
 
-typedef struct passwd  PASSWD;
+int Max_per_uid = MAX_PER_UID;
 
-char   *Scorefile = _PATH_SCORE;
+static SCORE Top[MAXSCORES];
 
-int    Max_per_uid = MAX_PER_UID;
+static uint32_t numscores, max_uid;
 
-static SCORE   Top[MAXSCORES];
+static int cmp_sc(const void *, const void *);
+static void set_name(SCORE *);
 
 /*
- * score:
- *     Post the player's score, if reasonable, and then print out the
- *     top list.
+ * read_score:
+ *     Read the score file in MI format
  */
-score()
+static void
+read_score(int inf)
 {
-       register int    inf;
-       register SCORE  *scp;
-       register int    uid;
-       register bool   done_show = FALSE;
-       static int      numscores, max_uid;
-
-       Newscore = FALSE;
-       if ((inf = open(Scorefile, 2)) < 0) {
-               perror(Scorefile);
-               return;
+       SCORE *scp;
+
+       if (read(inf, &max_uid, sizeof max_uid) == sizeof max_uid &&
+           read(inf, Top, sizeof Top) == sizeof Top) {
+               max_uid = ntohl(max_uid);
+               for (scp = Top; scp < &Top[MAXSCORES]; scp++) {
+                        scp->s_uid = ntohl(scp->s_uid);
+                        scp->s_score = ntohl(scp->s_score);
+                        scp->s_auto = ntohl(scp->s_auto);
+                        scp->s_level = ntohl(scp->s_level);
+               }
        }
-
-       if (read(inf, &max_uid, sizeof max_uid) == sizeof max_uid)
-               read(inf, Top, sizeof Top);
        else {
                for (scp = Top; scp < &Top[MAXSCORES]; scp++)
-                       scp->s_score = -1;
+                       scp->s_score = 0;
                max_uid = Max_per_uid;
        }
+}
+
+/*
+ * write_score:
+ *     Write the score file in MI format
+ */
+static void
+write_score(int inf)
+{
+       SCORE *scp;
+
+       lseek(inf, 0L, SEEK_SET);
+
+       max_uid = htonl(max_uid);
+       write(inf, &max_uid, sizeof max_uid);
+
+       for (scp = Top; scp < &Top[MAXSCORES]; scp++) {
+                scp->s_uid = htonl(scp->s_uid);
+                scp->s_score = htonl(scp->s_score);
+                scp->s_auto = htonl(scp->s_auto);
+                scp->s_level = htonl(scp->s_level);
+       }
+
+       write(inf, Top, sizeof Top);
+}
+
+
+/*
+ * score:
+ *     Post the player's score, if reasonable, and then print out the
+ *     top list.
+ */
+void
+score(int score_wfd)
+{
+       int inf = score_wfd;
+       SCORE *scp;
+       uint32_t uid;
+       bool done_show = false;
+
+       Newscore = false;
+       if (inf < 0)
+               return;
+
+       read_score(inf);
 
        uid = getuid();
        if (Top[MAXSCORES-1].s_score <= Score) {
                numscores = 0;
                for (scp = Top; scp < &Top[MAXSCORES]; scp++)
-                       if (scp->s_score < 0 ||
-                           (scp->s_uid == uid && ++numscores == max_uid)) {
+                       if ((scp->s_uid == uid && ++numscores == max_uid)) {
                                if (scp->s_score > Score)
                                        break;
                                scp->s_score = Score;
                                scp->s_uid = uid;
+                               scp->s_auto = Auto_bot;
+                               scp->s_level = Level;
                                set_name(scp);
-                               Newscore = TRUE;
+                               Newscore = true;
                                break;
                        }
                if (scp == &Top[MAXSCORES]) {
                        Top[MAXSCORES-1].s_score = Score;
                        Top[MAXSCORES-1].s_uid = uid;
+                       Top[MAXSCORES-1].s_auto = Auto_bot;
+                       Top[MAXSCORES-1].s_level = Level;
                        set_name(&Top[MAXSCORES-1]);
-                       Newscore = TRUE;
+                       Newscore = true;
                }
                if (Newscore)
                        qsort(Top, MAXSCORES, sizeof Top[0], cmp_sc);
        }
 
        if (!Newscore) {
-               Full_clear = FALSE;
-               close(inf);
+               Full_clear = false;
+               lseek(inf, 0, SEEK_SET);
                return;
        }
        else
-               Full_clear = TRUE;
+               Full_clear = true;
+
+       move(1, 15);
+       printw("%5.5s %5.5s %-9.9s %-8.8s %5.5s", "Rank", "Score", "User",
+           " ", "Level");
 
        for (scp = Top; scp < &Top[MAXSCORES]; scp++) {
-               if (scp->s_score < 0)
+               if (scp->s_score == 0)
                        break;
-               move((scp - Top) + 1, 15);
+               move((scp - Top) + 2, 15);
                if (!done_show && scp->s_uid == uid && scp->s_score == Score)
                        standout();
-               printw(" %d\t%d\t%-8.8s ", (scp - Top) + 1, scp->s_score, scp->s_name);
+               printw("%5ld %5d %-8.8s %-9.9s %5d",
+                   (long)(scp - Top) + 1, scp->s_score, scp->s_name,
+                   scp->s_auto ? "(autobot)" : "", scp->s_level);
                if (!done_show && scp->s_uid == uid && scp->s_score == Score) {
                        standend();
-                       done_show = TRUE;
+                       done_show = true;
                }
        }
        Num_scores = scp - Top;
        refresh();
 
        if (Newscore) {
-               lseek(inf, 0L, 0);
-               write(inf, &max_uid, sizeof max_uid);
-               write(inf, Top, sizeof Top);
+               write_score(inf);
        }
-       close(inf);
+       lseek(inf, 0, SEEK_SET);
 }
 
-set_name(scp)
-register SCORE *scp;
+static void
+set_name(SCORE *scp)
 {
-       register PASSWD *pp;
+       struct passwd *pp;
 
        if ((pp = getpwuid(scp->s_uid)) == NULL)
-               pp->pw_name = "???";
-       strncpy(scp->s_name, pp->pw_name, MAXNAME);
+               strncpy(scp->s_name, "???", MAXNAME - 1);
+       else
+               strncpy(scp->s_name, pp->pw_name, MAXNAME - 1);
+       scp->s_name[MAXNAME - 1] = '\0';
 }
 
 /*
  * cmp_sc:
  *     Compare two scores.
  */
-cmp_sc(s1, s2)
-register SCORE *s1, *s2;
+static int
+cmp_sc(const void *s1, const void *s2)
 {
-       return s2->s_score - s1->s_score;
+       return ((const SCORE *)s2)->s_score - ((const SCORE *)s1)->s_score;
 }
 
 /*
  * show_score:
  *     Show the score list for the '-s' option.
  */
-show_score()
+void
+show_score(void)
 {
-       register SCORE  *scp;
-       register int    inf;
-       static int      max_score;
+       SCORE *scp;
+       int inf;
 
-       if ((inf = open(Scorefile, 0)) < 0) {
-               perror(Scorefile);
+       if ((inf = open(Scorefile, O_RDONLY)) < 0) {
+               warn("opening `%s'", Scorefile);
                return;
        }
 
-       for (scp = Top; scp < &Top[MAXSCORES]; scp++)
-               scp->s_score = -1;
-
-       read(inf, &max_score, sizeof max_score);
-       read(inf, Top, sizeof Top);
+       read_score(inf);
        close(inf);
        inf = 1;
+       printf("%5.5s %5.5s %-9.9s %-8.8s %5.5s\n", "Rank", "Score", "User",
+           " ", "Level");
        for (scp = Top; scp < &Top[MAXSCORES]; scp++)
-               if (scp->s_score >= 0)
-                       printf("%d\t%d\t%.*s\n", inf++, scp->s_score, sizeof scp->s_name, scp->s_name);
+               if (scp->s_score > 0)
+                       printf("%5d %5d %-8.8s %-9.9s %5d\n",
+                           inf++, scp->s_score, scp->s_name,
+                           scp->s_auto ? "(autobot)" :  "", scp->s_level);
 }