path: root/games/hunt/huntd/draw.c

/*	$OpenBSD: draw.c,v 1.6 2002/02/16 21:27:10 millert Exp $	*/
/*	$NetBSD: draw.c,v 1.2 1997/10/10 16:33:04 lukem Exp $	*/
/*
 *  Hunt
 *  Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold
 *  San Francisco, California
 */

#include <string.h>

#include "hunt.h"
#include "server.h"
#include "conf.h"

static char	translate(char);
static int	player_sym(PLAYER *, int, int);
static void	drawstatus(PLAYER *);
static void	see(PLAYER *, int);

/*
 * drawmaze:
 *	Draw the entire maze on a player's screen.
 */
void
drawmaze(pp)
	PLAYER	*pp;
{
	int	x;
	char	*sp;
	int	y;
	char	*endp;

	/* Clear the client's screen: */
	clrscr(pp);
	/* Draw the top row of the maze: */
	outstr(pp, pp->p_maze[0], WIDTH);
	for (y = 1; y < HEIGHT - 1; y++) {
		endp = &pp->p_maze[y][WIDTH];
		for (x = 0, sp = pp->p_maze[y]; sp < endp; x++, sp++)
			if (*sp != SPACE) {
				cgoto(pp, y, x);
				/* Draw the player as themselves */
				if (pp->p_x == x && pp->p_y == y)
					outch(pp, translate(*sp));
				/* Possibly draw other players as team nrs */
				else if (is_player(*sp))
					outch(pp, player_sym(pp, y, x));
				else
					outch(pp, *sp);
			}
	}
	/* Draw the last row of the maze: */
	cgoto(pp, HEIGHT - 1, 0);
	outstr(pp, pp->p_maze[HEIGHT - 1], WIDTH);
	drawstatus(pp);
}

/*
 * drawstatus - put up the status lines (this assumes the screen
 *		size is 80x24 with the maze being 64x24)
 */
static void
drawstatus(pp)
	PLAYER	*pp;
{
	int	i;
	PLAYER	*np;

	outyx(pp, STAT_AMMO_ROW, STAT_LABEL_COL, "Ammo:");
	ammo_update(pp);

	outyx(pp, STAT_GUN_ROW,  STAT_LABEL_COL, "Gun:");
	outyx(pp, STAT_GUN_ROW,  STAT_VALUE_COL, "%3s",
		(pp->p_ncshot < conf_maxncshot) ? "ok" : "");

	outyx(pp, STAT_DAM_ROW,  STAT_LABEL_COL, "Damage:");
	outyx(pp, STAT_DAM_ROW,  STAT_VALUE_COL, "%2d/%2d",
		pp->p_damage, pp->p_damcap);

	outyx(pp, STAT_KILL_ROW, STAT_LABEL_COL, "Kills:");
	outyx(pp, STAT_KILL_ROW, STAT_VALUE_COL, "%3d",
		(pp->p_damcap - conf_maxdam) / 2);

	outyx(pp, STAT_PLAY_ROW, STAT_LABEL_COL, "Player:");
	for (i = STAT_PLAY_ROW + 1, np = Player; np < End_player; np++, i++) {
		outyx(pp, i, STAT_NAME_COL, "%5.2f%c%-10.10s %c", 
			np->p_ident->i_score, stat_char(np), 
			np->p_ident->i_name, np->p_ident->i_team);
	}

	outyx(pp, STAT_MON_ROW, STAT_LABEL_COL, "Monitor:");
	for (i = STAT_MON_ROW + 1, np = Monitor; np < End_monitor; np++, i++) {
		outyx(pp, i++, STAT_NAME_COL, "%5.5s %-10.10s %c",
			" ", np->p_ident->i_name, np->p_ident->i_team);
	}
}

/*
 * look
 *	check and update the visible area around the player
 */
void
look(pp)
	PLAYER	*pp;
{
	int	x, y;

	x = pp->p_x;
	y = pp->p_y;

	/*
	 * The player is aware of all objects immediately adjacent to
	 * their position:
	 */
	check(pp, y - 1, x - 1);
	check(pp, y - 1, x    );
	check(pp, y - 1, x + 1);
	check(pp, y    , x - 1);
	check(pp, y    , x    );
	check(pp, y    , x + 1);
	check(pp, y + 1, x - 1);
	check(pp, y + 1, x    );
	check(pp, y + 1, x + 1);

	switch (pp->p_face) {
	  /* The player can see down corridors in directions except behind: */
	  case LEFTS:
		see(pp, LEFTS);
		see(pp, ABOVE);
		see(pp, BELOW);
		break;
	  case RIGHT:
		see(pp, RIGHT);
		see(pp, ABOVE);
		see(pp, BELOW);
		break;
	  case ABOVE:
		see(pp, ABOVE);
		see(pp, LEFTS);
		see(pp, RIGHT);
		break;
	  case BELOW:
		see(pp, BELOW);
		see(pp, LEFTS);
		see(pp, RIGHT);
		break;
	  /* But they don't see too far when they are flying about: */
	  case FLYER:
		break;
	}

	/* Move the cursor back over the player: */
	cgoto(pp, y, x);
}

/*
 * see
 *	Look down a corridor, or towards an open space. This
 *	is a simulation of visibility from the player's perspective.
 */
static void
see(pp, face)
	PLAYER	*pp;
	int	face;
{
	char	*sp;
	int	y, x;

	/* Start from the player's position: */
	x = pp->p_x;
	y = pp->p_y;

	#define seewalk(dx, dy) 					\
		x += (dx);						\
		y += (dy);						\
		sp = &Maze[y][x];					\
		while (See_over[(int)*sp]) {				\
			x += (dx);					\
			y += (dy);					\
			sp += ((dx) + (dy) * sizeof Maze[0]);		\
			check(pp, y + dx, x + dy);			\
			check(pp, y, x);				\
			check(pp, y - dx, x - dy);			\
		}

	switch (face) {
	  case LEFTS:
		seewalk(-1, 0); break;
	  case RIGHT:
		seewalk(1, 0); break;
	  case ABOVE:
		seewalk(0, -1); break;
	  case BELOW:
		seewalk(0, 1); break;
	}
}

/*
 * check
 *	The player is aware of a cell in the maze.
 *	Ensure it is shown properly on their screen.
 */
void
check(pp, y, x)
	PLAYER	*pp;
	int	y, x;
{
	int	index;
	int	ch;
	PLAYER	*rpp;

	if (pp == ALL_PLAYERS) {
		for (pp = Player; pp < End_player; pp++)
			check(pp, y, x);
		for (pp = Monitor; pp < End_monitor; pp++)
			check(pp, y, x);
		return;
	}

	index = y * sizeof Maze[0] + x;
	ch = ((char *) Maze)[index];
	if (ch != ((char *) pp->p_maze)[index]) {
		rpp = pp;
		cgoto(rpp, y, x);
		if (x == rpp->p_x && y == rpp->p_y)
			outch(rpp, translate(ch));
		else if (is_player(ch))
			outch(rpp, player_sym(rpp, y, x));
		else
			outch(rpp, ch);
		((char *) rpp->p_maze)[index] = ch;
	}
}

/*
 * showstat
 *	Update the status of a player on everyone's screen
 */
void
showstat(pp)
	PLAYER	*pp;
{

	outyx(ALL_PLAYERS, 
		STAT_PLAY_ROW + 1 + (pp - Player), STAT_SCAN_COL,
		"%c", stat_char(pp));
}

/*
 * drawplayer:
 *	Draw the player on the screen and show him to everyone who's scanning
 *	unless he is cloaked.
 *	The 'draw' flag when false, causes the 'saved under' character to
 *	be drawn instead of the player; effectively un-drawing the player.
 */
void
drawplayer(pp, draw)
	PLAYER	*pp;
	FLAG	draw;
{
	PLAYER	*newp;
	int	x, y;

	x = pp->p_x;
	y = pp->p_y;

	/* Draw or un-draw the player into the master map: */
	Maze[y][x] = draw ? pp->p_face : pp->p_over;

	/* The monitors can always see this player: */
	for (newp = Monitor; newp < End_monitor; newp++)
		check(newp, y, x);

	/* Check if other players can see this player: */
	for (newp = Player; newp < End_player; newp++) {
		if (!draw) {
			/* When un-drawing, show everyone what was under */
			check(newp, y, x);
			continue;
		}
		if (newp == pp) {
			/* The player can always see themselves: */
			check(newp, y, x);
			continue;
		}
		/* Check if the other player just run out of scans */
		if (newp->p_scan == 0) {
			/* The other player is no longer scanning: */
			newp->p_scan--;
			showstat(newp);
		/* Check if the other play is scannning */
		} else if (newp->p_scan > 0) {
			/* If this player's not cloacked, draw him: */
			if (pp->p_cloak < 0)
				check(newp, y, x);
			/* And this uses up a scan. */
			newp->p_scan--;
		}
	}

	/* Use up one point of cloak time when drawing: */
	if (draw && pp->p_cloak >= 0) {
		pp->p_cloak--;
		/* Check if we ran out of cloak: */
		if (pp->p_cloak < 0)
			showstat(pp);
	}
}

/*
 * message:
 *	Write a message at the bottom of the screen.
 */
void
message(pp, s)
	PLAYER	*pp;
	char	*s;
{
	cgoto(pp, HEIGHT, 0);
	outstr(pp, s, strlen(s));
	ce(pp);
}

/*
 * translate:
 *	Turn a player character into a more personal player character.
 *	ie: {,},!,i becomes <,>,v,^
 */
static char
translate(ch)
	char	ch;
{
	switch (ch) {
	  case LEFTS:
		return '<';
	  case RIGHT:
		return '>';
	  case ABOVE:
		return '^';
	  case BELOW:
		return 'v';
	}
	return ch;
}

/*
 * player_sym:
 *	Return the symbol for the player at (y,x) when viewed by player 'pp'.
 *	ie: - unteamed players appear as {,},!,i
 *	    - unteamed monitors see all players as team digits
 *	    - teamed players see other players on their team, as a digit
 */
static int
player_sym(pp, y, x)
	PLAYER	*pp;
	int	y, x;
{
	PLAYER	*npp;

	npp = play_at(y, x);
	if (npp->p_ident->i_team == ' ')
		return Maze[y][x];
	if (pp->p_ident->i_team == '*')
		return npp->p_ident->i_team;
	if (pp->p_ident->i_team != npp->p_ident->i_team)
		return Maze[y][x];
	return pp->p_ident->i_team;
}