]> git.cameronkatri.com Git - bsdgames-darwin.git/blobdiff - hunt/huntd/shots.c
fix unused variable warnings
[bsdgames-darwin.git] / hunt / huntd / shots.c
index 3aa7284ca06b79b4acb2c5c2ddfb8c3acb744562..7a5192fcaa5d1ba31dcce3a5e89d90c100ab74d2 100644 (file)
@@ -1,25 +1,75 @@
+/*     $NetBSD: shots.c,v 1.12 2011/08/31 16:24:56 plunky Exp $        */
 /*
- *  Hunt
- *  Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold
- *  San Francisco, California
+ * Copyright (c) 1983-2003, Regents of the University of California.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are 
+ * met:
+ * 
+ * + Redistributions of source code must retain the above copyright 
+ *   notice, this list of conditions and the following disclaimer.
+ * + 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.
+ * + Neither the name of the University of California, San Francisco nor 
+ *   the names of its contributors may be used to endorse or promote 
+ *   products derived from this software without specific prior written 
+ *   permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-# include      "hunt.h"
-# include      <signal.h>
+#include <sys/cdefs.h>
+#ifndef lint
+__RCSID("$NetBSD: shots.c,v 1.12 2011/08/31 16:24:56 plunky Exp $");
+#endif /* not lint */
 
-# define       PLUS_DELTA(x, max)      if (x < max) x++; else x--
-# define       MINUS_DELTA(x, min)     if (x > min) x--; else x++
+#include <err.h>
+#include <signal.h>
+#include <stdlib.h>
+#include "hunt.h"
+
+#define PLUS_DELTA(x, max)     if (x < max) x++; else x--
+#define MINUS_DELTA(x, min)    if (x > min) x--; else x++
+
+static void chkshot(BULLET *, BULLET *);
+static void chkslime(BULLET *, BULLET *);
+static void explshot(BULLET *, int, int);
+static void find_under(BULLET *, BULLET *);
+static int iswall(int, int);
+static void mark_boot(BULLET *);
+static void mark_player(BULLET *);
+#ifdef DRONE
+static void move_drone(BULLET *);
+#endif
+static void move_flyer(PLAYER *);
+static int move_normal_shot(BULLET *);
+static void move_slime(BULLET *, int, BULLET *);
+static void save_bullet(BULLET *);
+static void zapshot(BULLET *, BULLET *);
 
 /*
  * moveshots:
  *     Move the shots already in the air, taking explosions into account
  */
-moveshots()
+void
+moveshots(void)
 {
-       register BULLET *bp, *next;
-       register PLAYER *pp;
-       register int    x, y;
-       register BULLET *blist;
+       BULLET *bp, *next;
+       PLAYER *pp;
+       int x, y;
+       BULLET *blist;
 
        rollexpl();
        if (Bullets == NULL)
@@ -41,10 +91,10 @@ moveshots()
                Maze[y][x] = bp->b_over;
                for (pp = Player; pp < End_player; pp++)
                        check(pp, y, x);
-# ifdef MONITOR
+#ifdef MONITOR
                for (pp = Monitor; pp < End_monitor; pp++)
                        check(pp, y, x);
-# endif
+#endif
 
                switch (bp->b_type) {
                  case SHOT:
@@ -56,22 +106,22 @@ moveshots()
                                Bullets = bp;
                        }
                        break;
-# ifdef OOZE
+#ifdef OOZE
                  case SLIME:
                        if (bp->b_expl || move_normal_shot(bp)) {
                                bp->b_next = Bullets;
                                Bullets = bp;
                        }
                        break;
-# endif
-# ifdef DRONE
+#endif
+#ifdef DRONE
                  case DSHOT:
                        if (move_drone(bp)) {
                                bp->b_next = Bullets;
                                Bullets = bp;
                        }
                        break;
-# endif
+#endif
                  default:
                        bp->b_next = Bullets;
                        Bullets = bp;
@@ -85,45 +135,45 @@ moveshots()
                next = bp->b_next;
                if (!bp->b_expl) {
                        save_bullet(bp);
-# ifdef MONITOR
+#ifdef MONITOR
                        for (pp = Monitor; pp < End_monitor; pp++)
                                check(pp, bp->b_y, bp->b_x);
-# endif
-# ifdef DRONE
+#endif
+#ifdef DRONE
                        if (bp->b_type == DSHOT)
                                for (pp = Player; pp < End_player; pp++)
                                        if (pp->p_scan >= 0)
                                                check(pp, bp->b_y, bp->b_x);
-# endif
+#endif
                        continue;
                }
 
                chkshot(bp, next);
-               free((char *) bp);
+               free(bp);
        }
 
        for (pp = Player; pp < End_player; pp++)
                Maze[pp->p_y][pp->p_x] = pp->p_face;
 
 ret:
-# ifdef BOOTS
+#ifdef BOOTS
        for (pp = Boot; pp < &Boot[NBOOTS]; pp++)
                if (pp->p_flying >= 0)
                        move_flyer(pp);
-# endif
+#endif
        for (pp = Player; pp < End_player; pp++) {
-# ifdef FLY
+#ifdef FLY
                if (pp->p_flying >= 0)
                        move_flyer(pp);
-# endif
+#endif
                sendcom(pp, REFRESH);   /* Flush out the explosions */
                look(pp);
                sendcom(pp, REFRESH);
        }
-# ifdef MONITOR
+#ifdef MONITOR
        for (pp = Monitor; pp < End_monitor; pp++)
                sendcom(pp, REFRESH);
-# endif
+#endif
 
        return;
 }
@@ -132,11 +182,11 @@ ret:
  * move_normal_shot:
  *     Move a normal shot along its trajectory
  */
-move_normal_shot(bp)
-register BULLET        *bp;
+static int
+move_normal_shot(BULLET *bp)
 {
-       register int    i, x, y;
-       register PLAYER *pp;
+       int i, x, y;
+       PLAYER *pp;
 
        for (i = 0; i < BULSPD; i++) {
                if (bp->b_expl)
@@ -173,7 +223,7 @@ register BULLET     *bp;
                                zapshot(bp->b_next, bp);
                        }
                        break;
-# ifdef        REFLECT
+#ifdef REFLECT
                  case WALL4:   /* reflecting walls */
                        switch (bp->b_face) {
                          case LEFTS:
@@ -190,10 +240,10 @@ register BULLET   *bp;
                                break;
                        }
                        Maze[y][x] = WALL5;
-# ifdef MONITOR
+#ifdef MONITOR
                        for (pp = Monitor; pp < End_monitor; pp++)
                                check(pp, y, x);
-# endif
+#endif
                        break;
                  case WALL5:
                        switch (bp->b_face) {
@@ -211,13 +261,13 @@ register BULLET   *bp;
                                break;
                        }
                        Maze[y][x] = WALL4;
-# ifdef MONITOR
+#ifdef MONITOR
                        for (pp = Monitor; pp < End_monitor; pp++)
                                check(pp, y, x);
-# endif
+#endif
                        break;
-# endif
-# ifdef RANDOM
+#endif
+#ifdef RANDOM
                  case DOOR:
                        switch (rand_num(4)) {
                          case 0:
@@ -234,13 +284,13 @@ register BULLET   *bp;
                                break;
                        }
                        break;
-# endif
-# ifdef FLY
+#endif
+#ifdef FLY
                  case FLYER:
                        pp = play_at(y, x);
                        message(pp, "Zing!");
                        break;
-# endif
+#endif
                  case LEFTS:
                  case RIGHT:
                  case BELOW:
@@ -264,8 +314,9 @@ register BULLET     *bp;
                                        pp->p_ident->i_saved++;
                                message(pp, "Absorbed charge (good shield!)");
                                pp->p_ident->i_absorbed += bp->b_charge;
-                               free((char *) bp);
-                               (void) sprintf(Buf, "%3d", pp->p_ammo);
+                               free(bp);
+                               (void) snprintf(Buf, sizeof(Buf),
+                                               "%3d", pp->p_ammo);
                                cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL);
                                outstr(pp, Buf, 3);
                                return FALSE;
@@ -287,7 +338,7 @@ register BULLET     *bp;
                                message(pp, "Zing!");
                                if (bp->b_owner == NULL)
                                        break;
-                               message(bp->b_owner,
+                               message(bp->b_owner, bp->b_score &&
                                        ((bp->b_score->i_missed & 0x7) == 0x7) ?
                                        "My!  What a bad shot you are!" :
                                        "Missed him");
@@ -297,9 +348,9 @@ register BULLET     *bp;
                         * The shot hit that sucker!  Blow it up.
                         */
                        /* FALLTHROUGH */
-# ifndef RANDOM
+#ifndef RANDOM
                  case DOOR:
-# endif
+#endif
                  case WALL1:
                  case WALL2:
                  case WALL3:
@@ -313,17 +364,17 @@ register BULLET   *bp;
        return TRUE;
 }
 
-# ifdef        DRONE
+#ifdef DRONE
 /*
  * move_drone:
  *     Move the drone to the next square
  */
-move_drone(bp)
-register BULLET        *bp;
+static void
+move_drone(BULLET *bp)
 {
-       register int    mask, count;
-       register int    n, dir;
-       register PLAYER *pp;
+       int mask, count;
+       int n, dir;
+       PLAYER *pp;
 
        /*
         * See if we can give someone a blast
@@ -444,8 +495,8 @@ drone_move:
                        pp = play_at(bp->b_y, bp->b_x);
                        pp->p_ammo += bp->b_charge;
                        message(pp, "**** Absorbed drone ****");
-                       free((char *) bp);
-                       (void) sprintf(Buf, "%3d", pp->p_ammo);
+                       free(bp);
+                       (void) snprintf(Buf, sizeof(buf), "%3d", pp->p_ammo);
                        cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL);
                        outstr(pp, Buf, 3);
                        return FALSE;
@@ -455,14 +506,14 @@ drone_move:
        }
        return TRUE;
 }
-# endif
+#endif
 
 /*
  * save_bullet:
  *     Put this bullet back onto the bullet list
  */
-save_bullet(bp)
-register BULLET        *bp;
+static void
+save_bullet(BULLET *bp)
 {
        bp->b_over = Maze[bp->b_y][bp->b_x];
        switch (bp->b_over) {
@@ -470,15 +521,15 @@ register BULLET   *bp;
          case GRENADE:
          case SATCHEL:
          case BOMB:
-# ifdef OOZE
+#ifdef OOZE
          case SLIME:
-# ifdef VOLCANO
+#ifdef VOLCANO
          case LAVA:
-# endif
-# endif
-# ifdef DRONE
+#endif
+#endif
+#ifdef DRONE
          case DSHOT:
-# endif
+#endif
                find_under(Bullets, bp);
                break;
        }
@@ -488,17 +539,17 @@ register BULLET   *bp;
          case RIGHT:
          case ABOVE:
          case BELOW:
-# ifdef FLY
+#ifdef FLY
          case FLYER:
-# endif
+#endif
                mark_player(bp);
                break;
-# ifdef BOOTS
+#ifdef BOOTS
          case BOOT:
          case BOOT_PAIR:
                mark_boot(bp);
-# endif
-               
+#endif
+
          default:
                Maze[bp->b_y][bp->b_x] = bp->b_type;
                break;
@@ -512,10 +563,10 @@ register BULLET   *bp;
  * move_flyer:
  *     Update the position of a player in flight
  */
-move_flyer(pp)
-register PLAYER        *pp;
+static void
+move_flyer(PLAYER *pp)
 {
-       register int    x, y;
+       int x, y;
 
        if (pp->p_undershot) {
                fixshots(pp->p_y, pp->p_x, pp->p_over);
@@ -561,13 +612,13 @@ again:
          case WALL1:
          case WALL2:
          case WALL3:
-# ifdef        REFLECT
+#ifdef REFLECT
          case WALL4:
          case WALL5:
-# endif
-# ifdef        RANDOM
+#endif
+#ifdef RANDOM
          case DOOR:
-# endif
+#endif
                if (pp->p_flying == 0)
                        pp->p_flying++;
                break;
@@ -577,21 +628,21 @@ again:
        pp->p_y = y;
        pp->p_x = x;
        if (pp->p_flying-- == 0) {
-# ifdef BOOTS
+#ifdef BOOTS
                if (pp->p_face != BOOT && pp->p_face != BOOT_PAIR) {
-# endif
-                       checkdam(pp, (PLAYER *) NULL, (IDENT *) NULL,
+#endif
+                       checkdam(pp, NULL, NULL,
                                rand_num(pp->p_damage / 5), FALL);
                        pp->p_face = rand_dir();
                        showstat(pp);
-# ifdef BOOTS
+#ifdef BOOTS
                }
                else {
                        if (Maze[y][x] == BOOT)
                                pp->p_face = BOOT_PAIR;
                        Maze[y][x] = SPACE;
                }
-# endif
+#endif
        }
        pp->p_over = Maze[y][x];
        Maze[y][x] = pp->p_face;
@@ -602,16 +653,16 @@ again:
  * chkshot
  *     Handle explosions
  */
-chkshot(bp, next)
-register BULLET        *bp;
-BULLET         *next;
+static void
+chkshot(BULLET *bp, BULLET *next)
 {
-       register int    y, x;
-       register int    dy, dx, absdy;
-       register int    delta, damage;
-       register char   expl;
-       register PLAYER *pp;
+       int y, x;
+       int dy, dx, absdy;
+       int delta, damage;
+       char expl;
+       PLAYER *pp;
 
+       delta = 0;
        switch (bp->b_type) {
          case SHOT:
          case MINE:
@@ -621,20 +672,20 @@ BULLET            *next;
          case BOMB:
                delta = bp->b_size - 1;
                break;
-# ifdef        OOZE
+#ifdef OOZE
          case SLIME:
-# ifdef VOLCANO
+#ifdef VOLCANO
          case LAVA:
-# endif
+#endif
                chkslime(bp, next);
                return;
-# endif
-# ifdef DRONE
+#endif
+#ifdef DRONE
          case DSHOT:
                bp->b_type = SLIME;
                chkslime(bp, next);
                return;
-# endif
+#endif
        }
        for (y = bp->b_y - delta; y <= bp->b_y + delta; y++) {
                if (y < 0 || y >= HEIGHT)
@@ -661,9 +712,9 @@ BULLET              *next;
                          case RIGHT:
                          case ABOVE:
                          case BELOW:
-# ifdef FLY
+#ifdef FLY
                          case FLYER:
-# endif
+#endif
                                if (dx < 0)
                                        dx = -dx;
                                if (absdy > dx)
@@ -681,7 +732,7 @@ BULLET              *next;
                                        y, x, LEFTS,
                                        (Maze[y][x] == GMINE) ?
                                        GRENREQ : BULREQ,
-                                       (PLAYER *) NULL, TRUE, SPACE);
+                                       NULL, TRUE, SPACE);
                                Maze[y][x] = SPACE;
                                break;
                        }
@@ -689,28 +740,27 @@ BULLET            *next;
        }
 }
 
-# ifdef        OOZE
+#ifdef OOZE
 /*
  * chkslime:
  *     handle slime shot exploding
  */
-chkslime(bp, next)
-register BULLET        *bp;
-BULLET         *next;
+static void
+chkslime(BULLET *bp, BULLET *next)
 {
-       register BULLET *nbp;
+       BULLET  *nbp;
 
        switch (Maze[bp->b_y][bp->b_x]) {
          case WALL1:
          case WALL2:
          case WALL3:
-# ifdef        REFLECT
+#ifdef REFLECT
          case WALL4:
          case WALL5:
-# endif
-# ifdef        RANDOM
+#endif
+#ifdef RANDOM
          case DOOR:
-# endif
+#endif
                switch (bp->b_face) {
                  case LEFTS:
                        bp->b_x++;
@@ -727,13 +777,13 @@ BULLET            *next;
                }
                break;
        }
-       nbp = (BULLET *) malloc(sizeof (BULLET));
+       nbp = malloc(sizeof(*nbp));
        *nbp = *bp;
-# ifdef VOLCANO
+#ifdef VOLCANO
        move_slime(nbp, nbp->b_type == SLIME ? SLIMESPEED : LAVASPEED, next);
-# else
+#else
        move_slime(nbp, SLIMESPEED, next);
-# endif
+#endif
 }
 
 /*
@@ -741,36 +791,34 @@ BULLET            *next;
  *     move the given slime shot speed times and add it back if
  *     it hasn't fizzled yet
  */
-move_slime(bp, speed, next)
-register BULLET        *bp;
-register int   speed;
-BULLET         *next;
+void
+move_slime(BULLET *bp, int speed, BULLET *next)
 {
-       register int    i, j, dirmask, count;
-       register PLAYER *pp;
-       register BULLET *nbp;
+       int i, j, dirmask, count;
+       PLAYER *pp;
+       BULLET *nbp;
 
        if (speed == 0) {
                if (bp->b_charge <= 0)
-                       free((char *) bp);
+                       free(bp);
                else
                        save_bullet(bp);
                return;
        }
 
-# ifdef VOLCANO
+#ifdef VOLCANO
        showexpl(bp->b_y, bp->b_x, bp->b_type == LAVA ? LAVA : '*');
-# else
+#else
        showexpl(bp->b_y, bp->b_x, '*');
-# endif
+#endif
        switch (Maze[bp->b_y][bp->b_x]) {
          case LEFTS:
          case RIGHT:
          case ABOVE:
          case BELOW:
-# ifdef FLY
+#ifdef FLY
          case FLYER:
-# endif
+#endif
                pp = play_at(bp->b_y, bp->b_x);
                message(pp, "You've been slimed.");
                checkdam(pp, bp->b_owner, bp->b_score, MINDAM, bp->b_type);
@@ -779,16 +827,16 @@ BULLET            *next;
          case GRENADE:
          case SATCHEL:
          case BOMB:
-# ifdef DRONE
+#ifdef DRONE
          case DSHOT:
-# endif
+#endif
                explshot(next, bp->b_y, bp->b_x);
                explshot(Bullets, bp->b_y, bp->b_x);
                break;
        }
 
        if (--bp->b_charge <= 0) {
-               free((char *) bp);
+               free(bp);
                return;
        }
 
@@ -893,15 +941,15 @@ BULLET            *next;
                move_slime(nbp, speed - 1, next);
        }
 
-       free((char *) bp);
+       free(bp);
 }
 
 /*
  * iswall:
  *     returns whether the given location is a wall
  */
-iswall(y, x)
-register int   y, x;
+static int
+iswall(int y, int x)
 {
        if (y < 0 || x < 0 || y >= HEIGHT || x >= WIDTH)
                return TRUE;
@@ -909,34 +957,34 @@ register int      y, x;
          case WALL1:
          case WALL2:
          case WALL3:
-# ifdef        REFLECT
+#ifdef REFLECT
          case WALL4:
          case WALL5:
-# endif
-# ifdef        RANDOM
+#endif
+#ifdef RANDOM
          case DOOR:
-# endif
-# ifdef OOZE
+#endif
+#ifdef OOZE
          case SLIME:
-# ifdef VOLCANO
+#ifdef VOLCANO
          case LAVA:
-# endif
-# endif
+#endif
+#endif
                return TRUE;
        }
        return FALSE;
 }
-# endif
+#endif
 
 /*
  * zapshot:
  *     Take a shot out of the air.
  */
-zapshot(blist, obp)
-register BULLET        *blist, *obp;
+static void
+zapshot(BULLET *blist, BULLET *obp)
 {
-       register BULLET *bp;
-       register FLAG   explode;
+       BULLET *bp;
+       FLAG explode;
 
        explode = FALSE;
        for (bp = blist; bp != NULL; bp = bp->b_next) {
@@ -956,11 +1004,10 @@ register BULLET  *blist, *obp;
  * explshot -
  *     Make all shots at this location blow up
  */
-explshot(blist, y, x)
-register BULLET        *blist;
-register int   y, x;
+void
+explshot(BULLET *blist, int y, int x)
 {
-       register BULLET *bp;
+       BULLET *bp;
 
        for (bp = blist; bp != NULL; bp = bp->b_next)
                if (bp->b_x == x && bp->b_y == y) {
@@ -975,16 +1022,14 @@ register int     y, x;
  *     Return a pointer to the player at the given location
  */
 PLAYER *
-play_at(y, x)
-register int   y, x;
+play_at(int y, int x)
 {
-       register PLAYER *pp;
+       PLAYER *pp;
 
        for (pp = Player; pp < End_player; pp++)
                if (pp->p_x == x && pp->p_y == y)
                        return pp;
-       fprintf(stderr, "driver: couldn't find player at (%d,%d)\n", x, y);
-       abort();
+       errx(1, "driver: couldn't find player at (%d,%d)", x, y);
        /* NOTREACHED */
 }
 
@@ -993,9 +1038,8 @@ register int       y, x;
  *     Return TRUE if the bullet direction faces the opposite direction
  *     of the player in the maze
  */
-opposite(face, dir)
-int    face;
-char   dir;
+int
+opposite(int face, char dir)
 {
        switch (face) {
          case LEFTS:
@@ -1017,10 +1061,9 @@ char     dir;
  *     a pointer to the bullet, otherwise return NULL
  */
 BULLET *
-is_bullet(y, x)
-register int   y, x;
+is_bullet(int y, int x)
 {
-       register BULLET *bp;
+       BULLET *bp;
 
        for (bp = Bullets; bp != NULL; bp = bp->b_next)
                if (bp->b_y == y && bp->b_x == x)
@@ -1033,11 +1076,10 @@ register int    y, x;
  *     change the underlying character of the shots at a location
  *     to the given character.
  */
-fixshots(y, x, over)
-register int   y, x;
-char           over;
+void
+fixshots(int y, int x, char over)
 {
-       register BULLET *bp;
+       BULLET *bp;
 
        for (bp = Bullets; bp != NULL; bp = bp->b_next)
                if (bp->b_y == y && bp->b_x == x)
@@ -1049,10 +1091,10 @@ char            over;
  *     find the underlying character for a bullet when it lands
  *     on another bullet.
  */
-find_under(blist, bp)
-register BULLET        *blist, *bp;
+static void
+find_under(BULLET *blist, BULLET *bp)
 {
-       register BULLET *nbp;
+       BULLET *nbp;
 
        for (nbp = blist; nbp != NULL; nbp = nbp->b_next)
                if (bp->b_y == nbp->b_y && bp->b_x == nbp->b_x) {
@@ -1065,10 +1107,10 @@ register BULLET *blist, *bp;
  * mark_player:
  *     mark a player as under a shot
  */
-mark_player(bp)
-register BULLET        *bp;
+static void
+mark_player(BULLET *bp)
 {
-       register PLAYER *pp;
+       PLAYER *pp;
 
        for (pp = Player; pp < End_player; pp++)
                if (pp->p_y == bp->b_y && pp->p_x == bp->b_x) {
@@ -1077,15 +1119,15 @@ register BULLET *bp;
                }
 }
 
-# ifdef BOOTS
+#ifdef BOOTS
 /*
  * mark_boot:
  *     mark a boot as under a shot
  */
-mark_boot(bp)
-register BULLET        *bp;
+static void
+mark_boot(BULLET *bp)
 {
-       register PLAYER *pp;
+       PLAYER *pp;
 
        for (pp = Boot; pp < &Boot[NBOOTS]; pp++)
                if (pp->p_y == bp->b_y && pp->p_x == bp->b_x) {
@@ -1093,4 +1135,4 @@ register BULLET   *bp;
                        break;
                }
 }
-# endif
+#endif