/*	$NetBSD: driver.c,v 1.36 2021/05/02 12:50:45 rillig Exp $	*/
/*
 * 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 <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: driver.c,v 1.36 2021/05/02 12:50:45 rillig Exp $");
#endif /* not lint */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/un.h>

#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <net/if.h>

#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <err.h>

#include "hunt.h"
#include "pathnames.h"

/*
 * There are three listening sockets in this daemon:
 *    - a datagram socket that listens on a well known port
 *    - a stream socket for general player connections
 *    - a second stream socket that prints the stats/scores
 *
 * These are (now) named as follows:
 *    - contact (contactsock, contactaddr, etc.)
 *    - hunt (huntsock, huntaddr, etc.)
 *    - stat (statsock, stataddr, etc.)
 *
 * Until being cleaned up in 2014 the code used an assortment of
 * inconsistent and confusing names to refer to the pieces of these:
 *
 *    test_port -> contactaddr
 *    Test_port -> contactport
 *    Test_socket -> contactsock
 *
 *    sock_port -> huntport
 *    Socket -> huntsock
 *
 *    Daemon -> both stataddr and huntaddr
 *    stat_port -> statport
 *    status -> statsock
 *
 * It isn't clear to me what purpose contactsocket is supposed to
 * serve; maybe it was supposed to avoid asking inetd to support
 * tcp/wait sockets? Anyway, we can't really change the protocol at
 * this point. (To complicate matters, contactsocket doesn't exist if
 * using AF_UNIX sockets; you just connect to the game socket.)
 *
 * When using internet sockets:
 *    - the contact socket listens on INADDR_ANY using the game port
 *      (either specified or the default: CONTACT_PORT, currently
 *      spelled TEST_PORT)
 *    - the hunt socket listens on INADDR_ANY using whatever port
 *    - the stat socket listens on INADDR_ANY using whatever port
 *
 * When using AF_UNIX sockets:
 *    - the contact socket isn't used
 *    - the hunt socket listens on the game socket (either a specified path
 *      or /tmp/hunt)
 *    - the stat socket listens on its own socket (huntsocket's path +
 *      ".stats")
 */

static bool localmode;			/* true -> AF_UNIX; false -> AF_INET */
static bool inetd_spawned;		/* invoked via inetd? */
static bool standard_port = true;	/* listening on standard port? */

static struct sockaddr_storage huntaddr;
static struct sockaddr_storage stataddr;
static socklen_t huntaddrlen;
static socklen_t stataddrlen;

static uint16_t contactport = TEST_PORT;
static uint16_t	huntport;		/* port # of tcp listen socket */
static uint16_t	statport;		/* port # of statistics tcp socket */

static const char *huntsockpath = PATH_HUNTSOCKET;
static char *statsockpath;

static int contactsock;			/* socket to answer datagrams */
int huntsock;				/* main socket */
static int statsock;			/* stat socket */

#ifdef VOLCANO
static int volcano = 0;			/* Explosion size */
#endif

static void clear_scores(void);
static bool havechar(PLAYER *, int);
static void init(void);
static void makeboots(void);
static void send_stats(void);
static void zap(PLAYER *, bool, int);

static int
getnum(const char *s, unsigned long *ret)
{
	char *t;

	errno = 0;
	*ret = strtoul(s, &t, 0);
	if (errno || *t != '\0') {
		return -1;
	}
	return 0;
}

static __dead void
usage(const char *av0)
{
	fprintf(stderr, "Usage: %s [-s] [-p portnumber|socketpath]\n", av0);
	exit(1);
}

static void
makeaddr(const char *path, uint16_t port,
	 struct sockaddr_storage *ss, socklen_t *len)
{
	struct sockaddr_in *sin;
	struct sockaddr_un *sun;

	if (path == NULL) {
		sin = (struct sockaddr_in *)ss;
		sin->sin_family = AF_INET;
		sin->sin_addr.s_addr = INADDR_ANY;
		sin->sin_port = htons(port);
		*len = sizeof(*sin);
	} else {
		sun = (struct sockaddr_un *)ss;
		sun->sun_family = AF_UNIX;
		strlcpy(sun->sun_path, path, sizeof(sun->sun_path));
		*len = SUN_LEN(sun);
	}
}

static uint16_t
getsockport(int sock)
{
	struct sockaddr_storage addr;
	socklen_t len;

	len = sizeof(addr);
	if (getsockname(sock, (struct sockaddr *)&addr, &len) < 0)  {
		complain(LOG_ERR, "getsockname");
		exit(1);
	}
	switch (addr.ss_family) {
	    case AF_INET:
		return ntohs(((struct sockaddr_in *)&addr)->sin_port);
	    case AF_INET6:
		return ntohs(((struct sockaddr_in6 *)&addr)->sin6_port);
	    default:
		break;
	}
	return 0;
}

/*
 * main:
 *	The main program.
 */
int
main(int ac, char **av)
{
	PLAYER *pp;
	unsigned long optargnum;
	uint16_t msg, reply;
	struct sockaddr_storage msgaddr;
	socklen_t msgaddrlen;
	static bool first = true;
	static bool server = false;
	int c, i;
	const int linger = 90 * 1000;

	while ((c = getopt(ac, av, "sp:")) != -1) {
		switch (c) {
		  case 's':
			server = true;
			break;
		  case 'p':
			standard_port = false;
			if (getnum(optarg, &optargnum) < 0) {
				localmode = true;
				huntsockpath = optarg;
			} else if (optargnum < 0xffff) {
				localmode = false;
				contactport = optargnum;
			} else {
				usage(av[0]);
			}
			break;
		  default:
			usage(av[0]);
		}
	}
	if (optind < ac)
		usage(av[0]);

	asprintf(&statsockpath, "%s.stats", huntsockpath);
	init();


again:
	do {
		errno = 0;
		while (poll(fdset, 3+MAXPL+MAXMON, INFTIM) < 0)
		{
			if (errno != EINTR)
				complain(LOG_WARNING, "poll");
			errno = 0;
		}
		if (!localmode && fdset[2].revents & POLLIN) {
			msgaddrlen = sizeof(msgaddr);
			(void) recvfrom(contactsock, &msg, sizeof msg,
				0, (struct sockaddr *)&msgaddr, &msgaddrlen);
			switch (ntohs(msg)) {
			  case C_MESSAGE:
				if (Nplayer <= 0)
					break;
				reply = htons((u_short) Nplayer);
				(void) sendto(contactsock, &reply,
					sizeof reply, 0,
					(struct sockaddr *)&msgaddr,
					msgaddrlen);
				break;
			  case C_SCORES:
				reply = htons(statport);
				(void) sendto(contactsock, &reply,
					sizeof reply, 0,
					(struct sockaddr *)&msgaddr,
					msgaddrlen);
				break;
			  case C_PLAYER:
			  case C_MONITOR:
				if (msg == C_MONITOR && Nplayer <= 0)
					break;
				reply = htons(huntport);
				(void) sendto(contactsock, &reply,
					sizeof reply, 0,
					(struct sockaddr *)&msgaddr,
					msgaddrlen);
				break;
			}
		}

		{
			for (pp = Player, i = 0; pp < End_player; pp++, i++)
				if (havechar(pp, i + 3)) {
					execute(pp);
					pp->p_nexec++;
				}
#ifdef MONITOR
			for (pp = Monitor, i = 0; pp < End_monitor; pp++, i++)
				if (havechar(pp, i + MAXPL + 3)) {
					mon_execute(pp);
					pp->p_nexec++;
				}
#endif
			moveshots();
			for (pp = Player, i = 0; pp < End_player; )
				if (pp->p_death[0] != '\0')
					zap(pp, true, i + 3);
				else
					pp++, i++;
#ifdef MONITOR
			for (pp = Monitor, i = 0; pp < End_monitor; )
				if (pp->p_death[0] != '\0')
					zap(pp, false, i + MAXPL + 3);
				else
					pp++, i++;
#endif
		}
		if (fdset[0].revents & POLLIN)
			if (answer()) {
				if (first) {
					/* announce start of game? */
				}
				first = false;
			}
		if (fdset[1].revents & POLLIN)
			send_stats();
		for (pp = Player, i = 0; pp < End_player; pp++, i++) {
			if (fdset[i + 3].revents & POLLIN)
				sendcom(pp, READY, pp->p_nexec);
			pp->p_nexec = 0;
			(void) fflush(pp->p_output);
		}
#ifdef MONITOR
		for (pp = Monitor, i = 0; pp < End_monitor; pp++, i++) {
			if (fdset[i + MAXPL + 3].revents & POLLIN)
				sendcom(pp, READY, pp->p_nexec);
			pp->p_nexec = 0;
			(void) fflush(pp->p_output);
		}
#endif
	} while (Nplayer > 0);

	if (poll(fdset, 3+MAXPL+MAXMON, linger) > 0) {
		goto again;
	}
	if (server) {
		clear_scores();
		makemaze();
		clearwalls();
#ifdef BOOTS
		makeboots();
#endif
		first = true;
		goto again;
	}

#ifdef MONITOR
	for (pp = Monitor, i = 0; pp < End_monitor; i++)
		zap(pp, false, i + MAXPL + 3);
#endif
	cleanup(0);
	/* NOTREACHED */
	return(0);
}

/*
 * init:
 *	Initialize the global parameters.
 */
static void
init(void)
{
	int i;
	struct sockaddr_storage stdinaddr;
	struct sockaddr_storage contactaddr;
	socklen_t contactaddrlen;
	socklen_t len;

#ifndef DEBUG
#ifdef TIOCNOTTY
	(void) ioctl(fileno(stdout), TIOCNOTTY, NULL);
#endif
	(void) setpgrp(getpid(), getpid());
	(void) signal(SIGHUP, SIG_IGN);
	(void) signal(SIGINT, SIG_IGN);
	(void) signal(SIGQUIT, SIG_IGN);
	(void) signal(SIGTERM, cleanup);
#endif

	(void) chdir("/var/tmp");	/* just in case it core dumps */
	(void) umask(0);		/* No privacy at all! */
	(void) signal(SIGPIPE, SIG_IGN);

#ifdef LOG
	openlog("huntd", LOG_PID, LOG_DAEMON);
#endif

	/*
	 * check for inetd
	 */
	len = sizeof(stdinaddr);
	if (getsockname(STDIN_FILENO, (struct sockaddr *)&stdinaddr,
			&len) >= 0) {
		inetd_spawned = true;
		/* force localmode, assimilate stdin as appropriate */
		if (stdinaddr.ss_family == AF_UNIX) {
			localmode = true;
			contactsock = -1;
			huntsock = STDIN_FILENO;
		}
		else {
			localmode = false;
			contactsock = STDIN_FILENO;
			huntsock = -1;
		}
	} else {
		/* keep value of localmode; no sockets yet */
		contactsock = -1;
		huntsock = -1;
	}

	/*
	 * initialize contact socket
	 */
	if (!localmode && contactsock < 0) {
		makeaddr(NULL, contactport, &contactaddr, &contactaddrlen);
		contactsock = socket(AF_INET, SOCK_DGRAM, 0);
		if (bind(contactsock, (struct sockaddr *) &contactaddr,
			 contactaddrlen) < 0) {
			complain(LOG_ERR, "bind");
			exit(1);
		}
		(void) listen(contactsock, 5);
	}

	/*
	 * Initialize main socket
	 */
	if (huntsock < 0) {
		makeaddr(localmode ? huntsockpath : NULL, 0, &huntaddr,
			 &huntaddrlen);
		huntsock = socket(huntaddr.ss_family, SOCK_STREAM, 0);
		if (bind(huntsock, (struct sockaddr *)&huntaddr,
			 huntaddrlen) < 0) {
			if (errno == EADDRINUSE)
				exit(0);
			else {
				complain(LOG_ERR, "bind");
				cleanup(1);
			}
		}
		(void) listen(huntsock, 5);
	}

	/*
	 * Initialize statistics socket
	 */
	makeaddr(localmode ? statsockpath : NULL, 0, &stataddr, &stataddrlen);
	statsock = socket(stataddr.ss_family, SOCK_STREAM, 0);
	if (bind(statsock, (struct sockaddr *)&stataddr, stataddrlen) < 0) {
		if (errno == EADDRINUSE)
			exit(0);
		else {
			complain(LOG_ERR, "bind");
			cleanup(1);
		}
	}
	(void) listen(statsock, 5);

	if (!localmode) {
		contactport = getsockport(contactsock);
		statport = getsockport(statsock);
		huntport = getsockport(huntsock);
		if (contactport != TEST_PORT) {
			standard_port = false;
		}
	}

	/*
	 * Initialize minimal poll mask
	 */
	fdset[0].fd = huntsock;
	fdset[0].events = POLLIN;
	fdset[1].fd = statsock;
	fdset[1].events = POLLIN;
	if (localmode) {
		fdset[2].fd = -1;
		fdset[2].events = 0;
	} else {
		fdset[2].fd = contactsock;
		fdset[2].events = POLLIN;
	}

	srandom(time(NULL));
	makemaze();
#ifdef BOOTS
	makeboots();
#endif

	for (i = 0; i < NASCII; i++)
		See_over[i] = true;
	See_over[DOOR] = false;
	See_over[WALL1] = false;
	See_over[WALL2] = false;
	See_over[WALL3] = false;
#ifdef REFLECT
	See_over[WALL4] = false;
	See_over[WALL5] = false;
#endif

}

#ifdef BOOTS
/*
 * makeboots:
 *	Put the boots in the maze
 */
static void
makeboots(void)
{
	int x, y;
	PLAYER *pp;

	do {
		x = rand_num(WIDTH - 1) + 1;
		y = rand_num(HEIGHT - 1) + 1;
	} while (Maze[y][x] != SPACE);
	Maze[y][x] = BOOT_PAIR;
	for (pp = Boot; pp < &Boot[NBOOTS]; pp++)
		pp->p_flying = -1;
}
#endif


/*
 * checkdam:
 *	Check the damage to the given player, and see if s/he is killed
 */
void
checkdam(PLAYER *ouch, PLAYER *gotcha, IDENT *credit, int amt,
	 char this_shot_type)
{
	const char *cp;

	if (ouch->p_death[0] != '\0')
		return;
#ifdef BOOTS
	if (this_shot_type == SLIME)
		switch (ouch->p_nboots) {
		  default:
			break;
		  case 1:
			amt = (amt + 1) / 2;
			break;
		  case 2:
			if (gotcha != NULL)
				message(gotcha, "He has boots on!");
			return;
		}
#endif
	ouch->p_damage += amt;
	if (ouch->p_damage <= ouch->p_damcap) {
		(void) snprintf(Buf, sizeof(Buf), "%2d", ouch->p_damage);
		cgoto(ouch, STAT_DAM_ROW, STAT_VALUE_COL);
		outstr(ouch, Buf, 2);
		return;
	}

	/* Someone DIED */
	switch (this_shot_type) {
	  default:
		cp = "Killed";
		break;
#ifdef FLY
	  case FALL:
		cp = "Killed on impact";
		break;
#endif
	  case KNIFE:
		cp = "Stabbed to death";
		ouch->p_ammo = 0;		/* No exploding */
		break;
	  case SHOT:
		cp = "Shot to death";
		break;
	  case GRENADE:
	  case SATCHEL:
	  case BOMB:
		cp = "Bombed";
		break;
	  case MINE:
	  case GMINE:
		cp = "Blown apart";
		break;
#ifdef	OOZE
	  case SLIME:
		cp = "Slimed";
		if (credit != NULL)
			credit->i_slime++;
		break;
#endif
#ifdef	VOLCANO
	  case LAVA:
		cp = "Baked";
		break;
#endif
#ifdef DRONE
	  case DSHOT:
		cp = "Eliminated";
		break;
#endif
	}
	if (credit == NULL) {
		(void) snprintf(ouch->p_death, sizeof(ouch->p_death),
			"| %s by %s |", cp,
			(this_shot_type == MINE || this_shot_type == GMINE) ?
			"a mine" : "act of God");
		return;
	}

	(void) snprintf(ouch->p_death, sizeof(ouch->p_death),
		"| %s by %s |", cp, credit->i_name);

	if (ouch == gotcha) {		/* No use killing yourself */
		credit->i_kills--;
		credit->i_bkills++;
	}
	else if (ouch->p_ident->i_team == ' '
	|| ouch->p_ident->i_team != credit->i_team) {
		credit->i_kills++;
		credit->i_gkills++;
	}
	else {
		credit->i_kills--;
		credit->i_bkills++;
	}
	credit->i_score = credit->i_kills / (double) credit->i_entries;
	ouch->p_ident->i_deaths++;
	if (ouch->p_nchar == 0)
		ouch->p_ident->i_stillb++;
	if (gotcha == NULL)
		return;
	gotcha->p_damcap += STABDAM;
	gotcha->p_damage -= STABDAM;
	if (gotcha->p_damage < 0)
		gotcha->p_damage = 0;
	(void) snprintf(Buf, sizeof(Buf), "%2d/%2d", gotcha->p_damage,
			gotcha->p_damcap);
	cgoto(gotcha, STAT_DAM_ROW, STAT_VALUE_COL);
	outstr(gotcha, Buf, 5);
	(void) snprintf(Buf, sizeof(Buf), "%3d",
			(gotcha->p_damcap - MAXDAM) / 2);
	cgoto(gotcha, STAT_KILL_ROW, STAT_VALUE_COL);
	outstr(gotcha, Buf, 3);
	(void) snprintf(Buf, sizeof(Buf), "%5.2f", gotcha->p_ident->i_score);
	for (ouch = Player; ouch < End_player; ouch++) {
		cgoto(ouch, STAT_PLAY_ROW + 1 + (gotcha - Player),
			STAT_NAME_COL);
		outstr(ouch, Buf, 5);
	}
#ifdef MONITOR
	for (ouch = Monitor; ouch < End_monitor; ouch++) {
		cgoto(ouch, STAT_PLAY_ROW + 1 + (gotcha - Player),
			STAT_NAME_COL);
		outstr(ouch, Buf, 5);
	}
#endif
}

/*
 * zap:
 *	Kill off a player and take him out of the game.
 */
static void
zap(PLAYER *pp, bool was_player, int i)
{
	int n, len;
	BULLET *bp;
	PLAYER *np;
	int x, y;

	if (was_player) {
		if (pp->p_undershot)
			fixshots(pp->p_y, pp->p_x, pp->p_over);
		drawplayer(pp, false);
		Nplayer--;
	}

	len = strlen(pp->p_death);	/* Display the cause of death */
	x = (WIDTH - len) / 2;
	cgoto(pp, HEIGHT / 2, x);
	outstr(pp, pp->p_death, len);
	for (n = 1; n < len; n++)
		pp->p_death[n] = '-';
	pp->p_death[0] = '+';
	pp->p_death[len - 1] = '+';
	cgoto(pp, HEIGHT / 2 - 1, x);
	outstr(pp, pp->p_death, len);
	cgoto(pp, HEIGHT / 2 + 1, x);
	outstr(pp, pp->p_death, len);
	cgoto(pp, HEIGHT, 0);

#ifdef MONITOR
	if (was_player) {
#endif
		for (bp = Bullets; bp != NULL; bp = bp->b_next) {
			if (bp->b_owner == pp)
				bp->b_owner = NULL;
			if (bp->b_x == pp->p_x && bp->b_y == pp->p_y)
				bp->b_over = SPACE;
		}

		n = rand_num(pp->p_ammo);
		x = rand_num(pp->p_ammo);
		if (x > n)
			n = x;
		if (pp->p_ammo == 0)
			x = 0;
		else if (n == pp->p_ammo - 1) {
			x = pp->p_ammo;
			len = SLIME;
		}
		else {
			for (x = MAXBOMB - 1; x > 0; x--)
				if (n >= shot_req[x])
					break;
			for (y = MAXSLIME - 1; y > 0; y--)
				if (n >= slime_req[y])
					break;
			if (y >= 0 && slime_req[y] > shot_req[x]) {
				x = slime_req[y];
				len = SLIME;
			}
			else if (x != 0) {
				len = shot_type[x];
				x = shot_req[x];
			}
		}
		if (x > 0) {
			(void) add_shot(len, pp->p_y, pp->p_x, pp->p_face, x,
				NULL, true, SPACE);
			(void) snprintf(Buf, sizeof(Buf), "%s detonated.",
				pp->p_ident->i_name);
			for (np = Player; np < End_player; np++)
				message(np, Buf);
#ifdef MONITOR
			for (np = Monitor; np < End_monitor; np++)
				message(np, Buf);
#endif
#ifdef BOOTS
			while (pp->p_nboots-- > 0) {
				for (np = Boot; np < &Boot[NBOOTS]; np++)
					if (np->p_flying < 0)
						break;
				if (np >= &Boot[NBOOTS])
					err(1, "Too many boots");
				np->p_undershot = false;
				np->p_x = pp->p_x;
				np->p_y = pp->p_y;
				np->p_flying = rand_num(20);
				np->p_flyx = 2 * rand_num(6) - 5;
				np->p_flyy = 2 * rand_num(6) - 5;
				np->p_over = SPACE;
				np->p_face = BOOT;
				showexpl(np->p_y, np->p_x, BOOT);
			}
#endif
		}
#ifdef BOOTS
		else if (pp->p_nboots > 0) {
			if (pp->p_nboots == 2)
				Maze[pp->p_y][pp->p_x] = BOOT_PAIR;
			else
				Maze[pp->p_y][pp->p_x] = BOOT;
			if (pp->p_undershot)
				fixshots(pp->p_y, pp->p_x,
					Maze[pp->p_y][pp->p_x]);
		}
#endif

#ifdef VOLCANO
		volcano += pp->p_ammo - x;
		if (rand_num(100) < volcano / 50) {
			do {
				x = rand_num(WIDTH / 2) + WIDTH / 4;
				y = rand_num(HEIGHT / 2) + HEIGHT / 4;
			} while (Maze[y][x] != SPACE);
			(void) add_shot(LAVA, y, x, LEFTS, volcano,
				NULL, true, SPACE);
			for (np = Player; np < End_player; np++)
				message(np, "Volcano eruption.");
			volcano = 0;
		}
#endif

#ifdef DRONE
		if (rand_num(100) < 2) {
			do {
				x = rand_num(WIDTH / 2) + WIDTH / 4;
				y = rand_num(HEIGHT / 2) + HEIGHT / 4;
			} while (Maze[y][x] != SPACE);
			add_shot(DSHOT, y, x, rand_dir(),
				shot_req[MINDSHOT +
				rand_num(MAXBOMB - MINDSHOT)],
				NULL, false, SPACE);
		}
#endif

		sendcom(pp, ENDWIN);
		(void) putc(' ', pp->p_output);
		(void) fclose(pp->p_output);

		End_player--;
		if (pp != End_player) {
			memcpy(pp, End_player, sizeof (PLAYER));
			fdset[i] = fdset[End_player - Player + 3];
			fdset[End_player - Player + 3].fd = -1;
			(void) snprintf(Buf, sizeof(Buf), "%5.2f%c%-10.10s %c",
				pp->p_ident->i_score, stat_char(pp),
				pp->p_ident->i_name, pp->p_ident->i_team);
			n = STAT_PLAY_ROW + 1 + (pp - Player);
			for (np = Player; np < End_player; np++) {
				cgoto(np, n, STAT_NAME_COL);
				outstr(np, Buf, STAT_NAME_LEN);
			}
#ifdef MONITOR
			for (np = Monitor; np < End_monitor; np++) {
				cgoto(np, n, STAT_NAME_COL);
				outstr(np, Buf, STAT_NAME_LEN);
			}
#endif
		} else
			fdset[i].fd = -1;

		/* Erase the last player */
		n = STAT_PLAY_ROW + 1 + Nplayer;
		for (np = Player; np < End_player; np++) {
			cgoto(np, n, STAT_NAME_COL);
			ce(np);
		}
#ifdef MONITOR
		for (np = Monitor; np < End_monitor; np++) {
			cgoto(np, n, STAT_NAME_COL);
			ce(np);
		}
	}
	else {
		sendcom(pp, ENDWIN);
		(void) putc(LAST_PLAYER, pp->p_output);
		(void) fclose(pp->p_output);

		End_monitor--;
		if (pp != End_monitor) {
			memcpy(pp, End_monitor, sizeof (PLAYER));
			fdset[i] = fdset[End_monitor - Monitor + MAXPL + 3];
			fdset[End_monitor - Monitor + MAXPL + 3].fd = -1;
			(void) snprintf(Buf, sizeof(Buf), "%5.5s %-10.10s %c",
				" ",
				pp->p_ident->i_name, pp->p_ident->i_team);
			n = STAT_MON_ROW + 1 + (pp - Player);
			for (np = Player; np < End_player; np++) {
				cgoto(np, n, STAT_NAME_COL);
				outstr(np, Buf, STAT_NAME_LEN);
			}
			for (np = Monitor; np < End_monitor; np++) {
				cgoto(np, n, STAT_NAME_COL);
				outstr(np, Buf, STAT_NAME_LEN);
			}
		} else
			fdset[i].fd = -1;

		/* Erase the last monitor */
		n = STAT_MON_ROW + 1 + (End_monitor - Monitor);
		for (np = Player; np < End_player; np++) {
			cgoto(np, n, STAT_NAME_COL);
			ce(np);
		}
		for (np = Monitor; np < End_monitor; np++) {
			cgoto(np, n, STAT_NAME_COL);
			ce(np);
		}
	}
#endif
}

/*
 * rand_num:
 *	Return a random number in a given range.
 */
int
rand_num(int range)
{
	return (range == 0 ? 0 : random() % range);
}

/*
 * havechar:
 *	Check to see if we have any characters in the input queue; if
 *	we do, read them, stash them away, and return true; else return
 *	false.
 */
static bool
havechar(PLAYER *pp, int i)
{

	if (pp->p_ncount < pp->p_nchar)
		return true;
	if (!(fdset[i].revents & POLLIN))
		return false;
check_again:
	pp->p_nchar = read(pp->p_fd, pp->p_cbuf, sizeof pp->p_cbuf);
	if (pp->p_nchar < 0 && errno == EINTR) {
		goto check_again;
	} else if (pp->p_nchar <= 0) {
		if (errno == EINTR)
		pp->p_cbuf[0] = 'q';
	}
	pp->p_ncount = 0;
	return true;
}

/*
 * cleanup:
 *	Exit with the given value, cleaning up any droppings lying around
 */
void
cleanup(int exitval)
{
	PLAYER *pp;

	for (pp = Player; pp < End_player; pp++) {
		cgoto(pp, HEIGHT, 0);
		sendcom(pp, ENDWIN);
		(void) putc(LAST_PLAYER, pp->p_output);
		(void) fclose(pp->p_output);
	}
#ifdef MONITOR
	for (pp = Monitor; pp < End_monitor; pp++) {
		cgoto(pp, HEIGHT, 0);
		sendcom(pp, ENDWIN);
		(void) putc(LAST_PLAYER, pp->p_output);
		(void) fclose(pp->p_output);
	}
#endif
	(void) close(huntsock);
#ifdef AF_UNIX_HACK
	(void) unlink(huntsockpath);
#endif

	exit(exitval);
}

/*
 * send_stats:
 *	Print stats to requestor
 */
static void
send_stats(void)
{
	IDENT *ip;
	FILE *fp;
	int s;
	struct sockaddr_storage newaddr;
	socklen_t socklen;

	/*
	 * Get the output stream ready
	 */
	socklen = sizeof(newaddr);
	s = accept(statsock, (struct sockaddr *)&newaddr, &socklen);
	if (s < 0) {
		if (errno == EINTR)
			return;
		complain(LOG_WARNING, "accept");
		return;
	}
	fp = fdopen(s, "w");
	if (fp == NULL) {
		complain(LOG_WARNING, "fdopen");
		(void) close(s);
		return;
	}

	/*
	 * Send output to requestor
	 */
	fputs("Name\t\tScore\tDucked\tAbsorb\tFaced\tShot\tRobbed\tMissed\tSlimeK\n", fp);
	for (ip = Scores; ip != NULL; ip = ip->i_next) {
		fprintf(fp, "%s\t", ip->i_name);
		if (strlen(ip->i_name) < 8)
			putc('\t', fp);
		fprintf(fp, "%.2f\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
			ip->i_score, ip->i_ducked, ip->i_absorbed,
			ip->i_faced, ip->i_shot, ip->i_robbed,
			ip->i_missed, ip->i_slime);
	}
	fputs("\n\nName\t\tEnemy\tFriend\tDeaths\tStill\tSaved\n", fp);
	for (ip = Scores; ip != NULL; ip = ip->i_next) {
		if (ip->i_team == ' ') {
			fprintf(fp, "%s\t", ip->i_name);
			if (strlen(ip->i_name) < 8)
				putc('\t', fp);
		}
		else {
			fprintf(fp, "%s[%c]\t", ip->i_name, ip->i_team);
			if (strlen(ip->i_name) + 3 < 8)
				putc('\t', fp);
		}
		fprintf(fp, "%d\t%d\t%d\t%d\t%d\n",
			ip->i_gkills, ip->i_bkills, ip->i_deaths,
			ip->i_stillb, ip->i_saved);
	}

	(void) fclose(fp);
}

/*
 * clear_scores:
 *	Clear out the scores so the next session start clean
 */
static void
clear_scores(void)
{
	IDENT *ip, *nextip;

	for (ip = Scores; ip != NULL; ip = nextip) {
		nextip = ip->i_next;
		(void) free(ip);
	}
	Scores = NULL;
}