xref: /src/games/backgammon/common_source/fancy.c

/*	$NetBSD: fancy.c,v 1.20 2024/11/29 21:48:44 dholland Exp $	*/

/*
 * Copyright (c) 1980, 1993
 *	The 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:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 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. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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
#if 0
static char sccsid[] = "@(#)fancy.c	8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: fancy.c,v 1.20 2024/11/29 21:48:44 dholland Exp $");
#endif
#endif /* not lint */

#include "back.h"

static void bsect(int, int, int, int);
static void fixpos(int, int, int, int, int);
static void fixcol(int, int, int, int, int);
static void newline(void);

/*
 * These need to be declared so they come out as commons, because
 * termcap might or might not define some of them. Our termcap defines
 * PC, BC, and UP only. This is gross.
 *
 * XXX: rewrite this crap using curses.
 */
#if 0
char    PC;			/* padding character */
char   *BC;			/* backspace sequence */
#endif
static char   *CD;		/* clear to end of screen sequence */
static char   *CE;		/* clear to end of line sequence */
static char   *CL;		/* clear screen sequence */
static char   *CM;		/* cursor movement instructions */
static char   *HO;		/* home cursor sequence */
static char   *MC;		/* column cursor movement map */
static char   *ML;		/* row cursor movement map */
static char   *ND;		/* forward cursor sequence */
#if 0
char   *UP;			/* up cursor sequence */
#endif

static int lHO;			/* length of HO */
static int lBC;			/* length of BC */
static int lND;			/* length of ND */
static int lUP;			/* length of UP */
static int CO;			/* number of columns */
static int LI;			/* number of lines */
static int *linect;		/* array of lengths of lines on screen (the
				 * actual screen is not stored) */

 /* two letter codes */
static char tcap[] = "bccdceclcmhomcmlndup";
 /* corresponding strings */
static char **tstr[] = {&BC, &CD, &CE, &CL, &CM, &HO, &MC, &ML, &ND, &UP};

static char tbuf[1024];		/* buffer for decoded termcap entries */

static int oldb[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		     0, 0, 0, 0, 0, 0};

static int oldr;
static int oldw;
 /* "real" cursor positions, so it knows when to reposition. These are -1 if
  * curr and curc are accurate */
static int realr;
static int realc;

void
fboard(void)
{
	int     i, j, l;

	curmove(0, 0);		/* do top line */
	for (i = 0; i < 53; i++)
		fancyc('_');

	curmove(15, 0);		/* do bottom line */
	for (i = 0; i < 53; i++)
		fancyc('_');

	l = 1;			/* do vertical lines */
	for (i = 52; i > -1; i -= 28) {
		curmove((l == 1 ? 1 : 15), i);
		fancyc('|');
		for (j = 0; j < 14; j++) {
			curmove(curr + l, curc - 1);
			fancyc('|');
		}
		if (i == 24)
			i += 32;
		l = -l;		/* alternate directions */
	}

	curmove(2, 1);		/* label positions 13-18 */
	for (i = 13; i < 18; i++) {
		fancyc('1');
		fancyc((i % 10) + '0');
		curmove(curr, curc + 2);
	}
	fancyc('1');
	fancyc('8');

	curmove(2, 29);		/* label positions 19-24 */
	fancyc('1');
	fancyc('9');
	for (i = 20; i < 25; i++) {
		curmove(curr, curc + 2);
		fancyc('2');
		fancyc((i % 10) + '0');
	}

	curmove(14, 1);		/* label positions 12-7 */
	fancyc('1');
	fancyc('2');
	for (i = 11; i > 6; i--) {
		curmove(curr, curc + 2);
		fancyc(i > 9 ? '1' : ' ');
		fancyc((i % 10) + '0');
	}

	curmove(14, 30);	/* label positions 6-1 */
	fancyc('6');
	for (i = 5; i > 0; i--) {
		curmove(curr, curc + 3);
		fancyc(i + '0');
	}

	for (i = 12; i > 6; i--)/* print positions 12-7 */
		if (board[i])
			bsect(board[i], 13, 1 + 4 * (12 - i), -1);

	if (board[0])		/* print red men on bar */
		bsect(board[0], 13, 25, -1);

	for (i = 6; i > 0; i--)	/* print positions 6-1 */
		if (board[i])
			bsect(board[i], 13, 29 + 4 * (6 - i), -1);

	l = (off[1] < 0 ? off[1] + 15 : off[1]);	/* print white's home */
	bsect(l, 3, 54, 1);

	curmove(8, 25);		/* print the word BAR */
	fancyc('B');
	fancyc('A');
	fancyc('R');

	for (i = 13; i < 19; i++)	/* print positions 13-18 */
		if (board[i])
			bsect(board[i], 3, 1 + 4 * (i - 13), 1);

	if (board[25])		/* print white's men on bar */
		bsect(board[25], 3, 25, 1);

	for (i = 19; i < 25; i++)	/* print positions 19-24 */
		if (board[i])
			bsect(board[i], 3, 29 + 4 * (i - 19), 1);

	l = (off[0] < 0 ? off[0] + 15 : off[0]);	/* print red's home */
	bsect(-l, 13, 54, -1);

	for (i = 0; i < 26; i++)/* save board position for refresh later */
		oldb[i] = board[i];
	oldr = (off[1] < 0 ? off[1] + 15 : off[1]);
	oldw = -(off[0] < 0 ? off[0] + 15 : off[0]);
}
/*
 * bsect (b,rpos,cpos,cnext)
 *	Print the contents of a board position.  "b" has the value of the
 * position, "rpos" is the row to start printing, "cpos" is the column to
 * start printing, and "cnext" is positive if the position starts at the top
 * and negative if it starts at the bottom.  The value of "cpos" is checked
 * to see if the position is a player's home, since those are printed
 * differently.
 */
static void
bsect(int b, int rpos, int cpos, int cnext)
{
	int     j;		/* index */
	int     n;		/* number of men on position */
	int     bct;		/* counter */
	int     k;		/* index */
	char    pc;		/* color of men on position */

	bct = 0;
	n = abs(b);		/* initialize n and pc */
	pc = (b > 0 ? 'r' : 'w');

	if (n < 6 && cpos < 54)	/* position cursor at start */
		curmove(rpos, cpos + 1);
	else
		curmove(rpos, cpos);

	for (j = 0; j < 5; j++) {	/* print position row by row */

		for (k = 0; k < 15; k += 5)	/* print men */
			if (n > j + k)
				fancyc(pc);

		if (j < 4) {	/* figure how far to back up for next row */
			if (n < 6) {	/* stop if none left */
				if (j + 1 == n)
					break;
				bct = 1;	/* single column */
			} else {
				if (n < 11) {	/* two columns */
					if (cpos == 54) {	/* home pos */
						if (j + 5 >= n)
							bct = 1;
						else
							bct = 2;
					}
					if (cpos < 54) {	/* not home */
						if (j + 6 >= n)
							bct = 1;
						else
							bct = 2;
					}
				} else {	/* three columns */
					if (j + 10 >= n)
						bct = 2;
					else
						bct = 3;
				}
			}
			/* reposition cursor */
			curmove(curr + cnext, curc - bct);
		}
	}
}

void
refresh(void)
{
	int     i, r, c;

	r = curr;		/* save current position */
	c = curc;

	for (i = 12; i > 6; i--)/* fix positions 12-7 */
		if (board[i] != oldb[i]) {
			fixpos(oldb[i], board[i], 13, 1 + (12 - i) * 4, -1);
			oldb[i] = board[i];
		}
	if (board[0] != oldb[0]) {	/* fix red men on bar */
		fixpos(oldb[0], board[0], 13, 25, -1);
		oldb[0] = board[0];
	}
	for (i = 6; i > 0; i--)	/* fix positions 6-1 */
		if (board[i] != oldb[i]) {
			fixpos(oldb[i], board[i], 13, 29 + (6 - i) * 4, -1);
			oldb[i] = board[i];
		}
	i = -(off[0] < 0 ? off[0] + 15 : off[0]);	/* fix white's home */
	if (oldw != i) {
		fixpos(oldw, i, 13, 54, -1);
		oldw = i;
	}
	for (i = 13; i < 19; i++)	/* fix positions 13-18 */
		if (board[i] != oldb[i]) {
			fixpos(oldb[i], board[i], 3, 1 + (i - 13) * 4, 1);
			oldb[i] = board[i];
		}
	if (board[25] != oldb[25]) {	/* fix white men on bar */
		fixpos(oldb[25], board[25], 3, 25, 1);
		oldb[25] = board[25];
	}
	for (i = 19; i < 25; i++)	/* fix positions 19-24 */
		if (board[i] != oldb[i]) {
			fixpos(oldb[i], board[i], 3, 29 + (i - 19) * 4, 1);
			oldb[i] = board[i];
		}
	i = (off[1] < 0 ? off[1] + 15 : off[1]);	/* fix red's home */
	if (oldr != i) {
		fixpos(oldr, i, 3, 54, 1);
		oldr = i;
	}
	curmove(r, c);		/* return to saved position */
	newpos();
	buflush();
}

static void
fixpos(int cur, int new, int r, int c, int inc)
{
	int     o, n, nv;
	int     ov, nc;
	char    col;

	nc = 0;
	if (cur * new >= 0) {
		ov = abs(cur);
		nv = abs(new);
		col = (cur + new > 0 ? 'r' : 'w');
		o = (ov - 1) / 5;
		n = (nv - 1) / 5;
		if (o == n) {
			if (o == 2)
				nc = c + 2;
			if (o == 1)
				nc = c < 54 ? c : c + 1;
			if (o == 0)
				nc = c < 54 ? c + 1 : c;
			if (ov > nv)
				fixcol(r + inc * (nv - n * 5), nc,
				    abs(ov - nv), ' ', inc);
			else
				fixcol(r + inc * (ov - o * 5), nc,
				    abs(ov - nv), col, inc);
			return;
		} else {
			if (c < 54) {
				if (o + n == 1) {
					if (n) {
						fixcol(r, c, abs(nv - 5), col,
						    inc);
						if (ov != 5)
							fixcol(r + inc * ov,
							    c + 1, abs(ov - 5),
							    col, inc);
					} else {
						fixcol(r, c, abs(ov - 5), ' ',
						    inc);
						if (nv != 5)
							fixcol(r + inc * nv,
							    c + 1, abs(nv - 5),
							    ' ', inc);
					}
					return;
				}
				if (n == 2) {
					if (ov != 10)
						fixcol(r + inc * (ov - 5), c,
						    abs(ov - 10), col, inc);
					fixcol(r, c + 2, abs(nv - 10), col,
					    inc);
				} else {
					if (nv != 10)
						fixcol(r + inc * (nv - 5), c,
						    abs(nv - 10), ' ', inc);
					fixcol(r, c + 2, abs(ov - 10), ' ',
					    inc);
				}
				return;
			}
			if (n > o) {
				fixcol(r + inc * (ov % 5), c + o,
				    abs(5 * n - ov), col, inc);
				if (nv != 5 * n)
					fixcol(r, c + n, abs(5 * n - nv),
					    col, inc);
			} else {
				fixcol(r + inc * (nv % 5), c + n,
				    abs(5 * n - nv), ' ', inc);
				if (ov != 5 * o)
					fixcol(r, c + o, abs(5 * o - ov),
					    ' ', inc);
			}
			return;
		}
	}
	nv = abs(new);
	fixcol(r, c + 1, nv, new > 0 ? 'r' : 'w', inc);
	if (abs(cur) <= abs(new))
		return;
	fixcol(r + inc * new, c + 1, abs(cur + new), ' ', inc);
}

static void
fixcol(int r, int c, int l, int ch, int inc)
{
	int     i;

	curmove(r, c);
	fancyc(ch);
	for (i = 1; i < l; i++) {
		curmove(curr + inc, curc - 1);
		fancyc(ch);
	}
}

void
curmove(int r, int c)
{
	if (curr == r && curc == c)
		return;
	if (realr == -1) {
		realr = curr;
		realc = curc;
	}
	curr = r;
	curc = c;
}

void
newpos(void)
{
	int     r;		/* destination row */
	int     c;		/* destination column */
	int     mode = -1;	/* mode of movement */

	int     ccount = 1000;	/* character count */
	int     i;		/* index */
	int     n;		/* temporary variable */
	char   *m;		/* string containing CM movement */


	m = NULL;
	if (realr == -1)	/* see if already there */
		return;

	r = curr;		/* set current and dest. positions */
	c = curc;
	curr = realr;
	curc = realc;

	/* double check position */
	if (curr == r && curc == c) {
		realr = realc = -1;
		return;
	}
	if (CM) {		/* try CM to get there */
		mode = 0;
		m = (char *) tgoto(CM, c, r);
		ccount = (int)strlen(m);
	}
	/* try HO and local movement */
	if (HO && (n = r + c * lND + lHO) < ccount) {
		mode = 1;
		ccount = n;
	}
	/* try various LF combinations */
	if (r >= curr) {
		/* CR, LF, and ND */
		if ((n = (r - curr) + c * lND + 1) < ccount) {
			mode = 2;
			ccount = n;
		}
		/* LF, ND */
		if (c >= curc && (n = (r - curr) + (c - curc) * lND) < ccount) {
			mode = 3;
			ccount = n;
		}
		/* LF, BS */
		if (c < curc && (n = (r - curr) + (curc - c) * lBC) < ccount) {
			mode = 4;
			ccount = n;
		}
	}
	/* try corresponding UP combinations */
	if (r < curr) {
		/* CR, UP, and ND */
		if ((n = (curr - r) * lUP + c * lND + 1) < ccount) {
			mode = 5;
			ccount = n;
		}
		/* UP and ND */
		if (c >= curc &&
		    (n = (curr - r) * lUP + (c - curc) * lND) < ccount) {
			mode = 6;
			ccount = n;
		}
		/* UP and BS */
		if (c < curc &&
		    (n = (curr - r) * lUP + (curc - c) * lBC) < ccount) {
			mode = 7;
			ccount = n;
		}
	}
	/* space over */
	if (curr == r && c > curc && linect[r] < curc && c - curc < ccount)
		mode = 8;

	switch (mode) {

	case -1:		/* error! */
		write(2, "\r\nInternal cursor error.\r\n", 26);
		getout(0);
		/* NOTREACHED */

		/* direct cursor motion */
	case 0:
		tputs(m, abs(curr - r), addbuf);
		break;

		/* relative to "home" */
	case 1:
		tputs(HO, r, addbuf);
		for (i = 0; i < r; i++)
			addbuf('\012');
		for (i = 0; i < c; i++)
			tputs(ND, 1, addbuf);
		break;

		/* CR and down and over */
	case 2:
		addbuf('\015');
		for (i = 0; i < r - curr; i++)
			addbuf('\012');
		for (i = 0; i < c; i++)
			tputs(ND, 1, addbuf);
		break;

		/* down and over */
	case 3:
		for (i = 0; i < r - curr; i++)
			addbuf('\012');
		for (i = 0; i < c - curc; i++)
			tputs(ND, 1, addbuf);
		break;

		/* down and back */
	case 4:
		for (i = 0; i < r - curr; i++)
			addbuf('\012');
		for (i = 0; i < curc - c; i++)
			addbuf('\010');
		break;

		/* CR and up and over */
	case 5:
		addbuf('\015');
		for (i = 0; i < curr - r; i++)
			tputs(UP, 1, addbuf);
		for (i = 0; i < c; i++)
			tputs(ND, 1, addbuf);
		break;

		/* up and over */
	case 6:
		for (i = 0; i < curr - r; i++)
			tputs(UP, 1, addbuf);
		for (i = 0; i < c - curc; i++)
			tputs(ND, 1, addbuf);
		break;

		/* up and back */
	case 7:
		for (i = 0; i < curr - r; i++)
			tputs(UP, 1, addbuf);
		for (i = 0; i < curc - c; i++) {
			if (BC)
				tputs(BC, 1, addbuf);
			else
				addbuf('\010');
		}
		break;

		/* safe space */
	case 8:
		for (i = 0; i < c - curc; i++)
			addbuf(' ');
	}

	/* fix positions */
	curr = r;
	curc = c;
	realr = -1;
	realc = -1;
}

void
clear(void)
{
	int     i;

	/* double space if can't clear */
	if (CL == NULL) {
		writel("\n\n");
		return;
	}
	curr = curc = 0;	/* fix position markers */
	realr = realc = -1;
	for (i = 0; i < 24; i++)/* clear line counts */
		linect[i] = -1;
	buffnum = -1;		/* ignore leftover buffer contents */
	tputs(CL, CO, addbuf);	/* put CL in buffer */
}

void
fancyc(int c)
{
	int     sp;		/* counts spaces in a tab */

	if (c == '\007') {	/* bells go in blindly */
		addbuf(c);
		return;
	}
	/* process tabs, use spaces if the tab should be erasing things,
	 * otherwise use cursor movement routines.  Note this does not use
	 * hardware tabs at all. */
	if (c == '\t') {
		sp = (curc + 8) & (~7);	/* compute spaces */
		/* check line length */
		if (linect[curr] >= curc || sp < 4) {
			for (; sp > curc; sp--)
				addbuf(' ');
			curc = sp;	/* fix curc */
		} else
			curmove(curr, sp);
		return;
	}
	/* do newline be calling newline */
	if (c == '\n') {
		newline();
		return;
	}
	/* ignore any other control chars */
	if (c < ' ')
		return;

	/* if an erasing space or non-space, just add it to buffer.  Otherwise
	 * use cursor movement routine, so that multiple spaces will be
	 * grouped together */
	if (c > ' ' || linect[curr] >= curc) {
		newpos();	/* make sure position correct */
		addbuf(c);	/* add character to buffer */
		/* fix line length */
		if (c == ' ' && linect[curr] == curc)
			linect[curr]--;
		else
			if (linect[curr] < curc)
				linect[curr] = curc;
		curc++;		/* fix curc */
	} else
		/* use cursor movement routine */
		curmove(curr, curc + 1);
}

void
clend(void)
{
	int     i;

	if (CD) {
		tputs(CD, CO - curr, addbuf);
		for (i = curr; i < LI; i++)
			linect[i] = -1;
		return;
	}
	curmove(i = curr, 0);
	cline();
	while (curr < LI - 1) {
		curmove(curr + 1, 0);
		if (linect[curr] > -1)
			cline();
	}
	curmove(i, 0);
}

void
cline(void)
{
	int     c;

	if (curc > linect[curr])
		return;
	newpos();
	if (CE) {
		tputs(CE, 1, addbuf);
		linect[curr] = curc - 1;
	} else {
		c = curc - 1;
		while (linect[curr] > c) {
			addbuf(' ');
			curc++;
			linect[curr]--;
		}
		curmove(curr, c + 1);
	}
}

static void
newline(void)
{
	cline();
	if (curr == LI - 1)
		curmove(begscr, 0);
	else
		curmove(curr + 1, 0);
}

int
getcaps(const char *s)
{
	char   *code;		/* two letter code */
	char ***cap;		/* pointer to cap string */
	char   *bufp;		/* pointer to cap buffer */
	char    tentry[1024];	/* temporary uncoded caps buffer */

	tgetent(tentry, s);	/* get uncoded termcap entry */

	LI = tgetnum("li");	/* get number of lines */
	if (LI == -1)
		LI = 12;
	CO = tgetnum("co");	/* get number of columns */
	if (CO == -1)
		CO = 65;

	bufp = tbuf;		/* get padding character */
	tgetstr("pc", &bufp);
	if (bufp != tbuf)
		PC = *tbuf;
	else
		PC = 0;

	bufp = tbuf;		/* get string entries */
	cap = tstr;
	for (code = tcap; *code; code += 2)
		**cap++ = (char *) tgetstr(code, &bufp);

	/* get pertinent lengths */
	if (HO)
		lHO = (int)strlen(HO);
	if (BC)
		lBC = (int)strlen(BC);
	else
		lBC = 1;
	if (UP)
		lUP = (int)strlen(UP);
	if (ND)
		lND = (int)strlen(ND);
	if (LI < 24 || CO < 72 || !(CL && UP && ND)) {
		/* force CL to null because this is what's tested in clear() */
		CL = NULL;
		return (0);
	}
	linect = (int *) calloc(LI + 1, sizeof(int));
	if (linect == NULL) {
		write(2, "\r\nOut of memory!\r\n", 18);
		getout(0);
	}
	return (1);
}