2 * Copyright (c) 1980, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * @(#)fancy.c 8.1 (Berkeley) 5/31/93
34 * $FreeBSD: src/games/backgammon/common_source/fancy.c,v 1.7 1999/11/30 03:48:25 billf Exp $
35 * $DragonFly: src/games/backgammon/common_source/fancy.c,v 1.3 2003/11/12 14:53:52 eirikn Exp $
43 char PC; /* padding character */
44 char *BC; /* backspace sequence */
45 char *CD; /* clear to end of screen sequence */
46 char *CE; /* clear to end of line sequence */
47 char *CL; /* clear screen sequence */
48 char *CM; /* cursor movement instructions */
49 char *HO; /* home cursor sequence */
50 char *MC; /* column cursor movement map */
51 char *ML; /* row cursor movement map */
52 char *ND; /* forward cursor sequence */
53 char *UP; /* up cursor sequence */
55 int lHO; /* length of HO */
56 int lBC; /* length of BC */
57 int lND; /* length of ND */
58 int lUP; /* length of UP */
59 int CO; /* number of columns */
60 int LI; /* number of lines */
61 int *linect; /* array of lengths of lines on screen
62 (the actual screen is not stored) */
64 /* two letter codes */
65 char tcap[] = "bccdceclcmhomcmlndup";
66 /* corresponding strings */
67 char **tstr[] = { &BC, &CD, &CE, &CL, &CM, &HO, &MC, &ML, &ND, &UP };
69 int buffnum; /* pointer to output buffer */
71 char tbuf[1024]; /* buffer for decoded termcap entries */
73 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};
77 /* "real" cursor positions, so
78 * it knows when to reposition.
79 * These are -1 if curr and curc
89 curmove (0,0); /* do top line */
90 for (i = 0; i < 53; i++)
93 curmove (15,0); /* do botttom line */
94 for (i = 0; i < 53; i++)
97 l = 1; /* do vertical lines */
98 for (i = 52; i > -1; i -= 28) {
99 curmove ( (l == 1? 1: 15) ,i);
101 for (j = 0; j < 14; j++) {
102 curmove (curr+l,curc-1);
107 l = -l; /* alternate directions */
110 curmove (2,1); /* label positions 13-18 */
111 for (i = 13; i < 18; i++) {
113 fancyc ((i % 10)+'0');
114 curmove (curr,curc+2);
119 curmove (2,29); /* label positions 19-24 */
122 for (i = 20; i < 25; i++) {
123 curmove (curr,curc+2);
125 fancyc ((i % 10)+'0');
128 curmove (14,1); /* label positions 12-7 */
131 for (i = 11; i > 6; i--) {
132 curmove (curr,curc+2);
133 fancyc (i > 9? '1': ' ');
134 fancyc ((i % 10)+'0');
137 curmove (14,30); /* label positions 6-1 */
139 for (i = 5; i > 0; i--) {
140 curmove (curr,curc+3);
144 for (i = 12; i > 6; i--) /* print positions 12-7 */
146 bsect (board[i],13,1+4*(12-i),-1);
148 if (board[0]) /* print red men on bar */
149 bsect (board[0],13,25,-1);
151 for (i = 6; i > 0; i--) /* print positions 6-1 */
153 bsect (board[i],13,29+4*(6-i),-1);
155 l = (off[1] < 0? off[1]+15: off[1]); /* print white's home */
158 curmove (8,25); /* print the word BAR */
163 for (i = 13; i < 19; i++) /* print positions 13-18 */
165 bsect (board[i],3,1+4*(i-13),1);
167 if (board[25]) /* print white's men on bar */
168 bsect (board[25],3,25,1);
170 for (i = 19; i < 25; i++) /* print positions 19-24 */
172 bsect (board[i],3,29+4*(i-19),1);
174 l = (off[0] < 0? off[0]+15: off[0]); /* print red's home */
177 for (i = 0; i < 26; i++) /* save board position
178 * for refresh later */
180 oldr = (off[1] < 0? off[1]+15: off[1]);
181 oldw = -(off[0] < 0? off[0]+15: off[0]);
185 * bsect (b,rpos,cpos,cnext)
186 * Print the contents of a board position. "b" has the value of the
187 * position, "rpos" is the row to start printing, "cpos" is the column to
188 * start printing, and "cnext" is positive if the position starts at the top
189 * and negative if it starts at the bottom. The value of "cpos" is checked
190 * to see if the position is a player's home, since those are printed
194 bsect (b,rpos,cpos,cnext)
195 int b; /* contents of position */
196 int rpos; /* row of position */
197 int cpos; /* column of position */
198 int cnext; /* direction of position */
202 int n; /* number of men on position */
203 int bct; /* counter */
205 char pc; /* color of men on position */
207 n = abs(b); /* initialize n and pc */
208 pc = (b > 0? 'r': 'w');
210 if (n < 6 && cpos < 54) /* position cursor at start */
211 curmove (rpos,cpos+1);
215 for (j = 0; j < 5; j++) { /* print position row by row */
217 for (k = 0; k < 15; k += 5) /* print men */
221 if (j < 4) { /* figure how far to
224 if (n < 6) { /* stop if none left */
227 bct = 1; /* single column */
229 if (n < 11) { /* two columns */
230 if (cpos == 54) { /* home pos */
236 if (cpos < 54) { /* not home */
242 } else { /* three columns */
249 curmove (curr+cnext,curc-bct); /* reposition cursor */
257 r = curr; /* save current position */
260 for (i = 12; i > 6; i--) /* fix positions 12-7 */
261 if (board[i] != oldb[i]) {
262 fixpos (oldb[i],board[i],13,1+(12-i)*4,-1);
266 if (board[0] != oldb[0]) { /* fix red men on bar */
267 fixpos (oldb[0],board[0],13,25,-1);
271 for (i = 6; i > 0; i--) /* fix positions 6-1 */
272 if (board[i] != oldb[i]) {
273 fixpos (oldb[i],board[i],13,29+(6-i)*4,-1);
277 i = -(off[0] < 0? off[0]+15: off[0]); /* fix white's home */
279 fixpos (oldw,i,13,54,-1);
283 for (i = 13; i < 19; i++) /* fix positions 13-18 */
284 if (board[i] != oldb[i]) {
285 fixpos (oldb[i],board[i],3,1+(i-13)*4,1);
289 if (board[25] != oldb[25]) { /* fix white men on bar */
290 fixpos (oldb[25],board[25],3,25,1);
291 oldb[25] = board[25];
294 for (i = 19; i < 25; i++) /* fix positions 19-24 */
295 if (board[i] != oldb[i]) {
296 fixpos (oldb[i],board[i],3,29+(i-19)*4,1);
300 i = (off[1] < 0? off[1]+15: off[1]); /* fix red's home */
302 fixpos (oldr,i,3,54,1);
306 curmove (r,c); /* return to saved position */
311 fixpos (old,new,r,c,inc)
312 int old, new, r, c, inc;
322 col = (old+new > 0? 'r': 'w');
333 fixcol (r+inc*(nv-n*5),nc,abs(ov-nv),' ',inc);
335 fixcol (r+inc*(ov-o*5),nc,abs(ov-nv),col,inc);
341 fixcol (r,c,abs(nv-5),col,inc);
343 fixcol (r+inc*ov,c+1,abs(ov-5),col,inc);
345 fixcol (r,c,abs(ov-5),' ',inc);
347 fixcol (r+inc*nv,c+1,abs(nv-5),' ',inc);
353 fixcol (r+inc*(ov-5),c,abs(ov-10),col,inc);
354 fixcol (r,c+2,abs(nv-10),col,inc);
357 fixcol (r+inc*(nv-5),c,abs(nv-10),' ',inc);
358 fixcol (r,c+2,abs(ov-10),' ',inc);
363 fixcol (r+inc*(ov%5),c+o,abs(5*n-ov),col,inc);
365 fixcol (r,c+n,abs(5*n-nv),col,inc);
367 fixcol (r+inc*(nv%5),c+n,abs(5*n-nv),' ',inc);
369 fixcol (r,c+o,abs(5*o-ov),' ',inc);
375 fixcol (r,c+1,nv,new > 0? 'r': 'w',inc);
376 if (abs(old) <= abs(new))
378 fixcol (r+inc*new,c+1,abs(old+new),' ',inc);
381 fixcol (r,c,l,ch,inc)
382 int l, ch, r, c, inc;
389 for (i = 1; i < l; i++) {
390 curmove (curr+inc,curc-1);
399 if (curr == r && curc == c)
410 int r; /* destination row */
411 int c; /* destination column */
412 int mode = -1; /* mode of movement */
414 int count = 1000; /* character count */
417 int n; /* temporary variable */
418 char *m; /* string containing CM movement */
421 if (realr == -1) /* see if already there */
424 r = curr; /* set current and dest. positions */
429 /* double check position */
430 if (curr == r && curc == c) {
435 if (CM) { /* try CM to get there */
437 m = (char *)tgoto (CM,c,r);
441 /* try HO and local movement */
442 if (HO && (n = r+c*lND+lHO) < count) {
447 /* try various LF combinations */
450 if ((n = (r-curr)+c*lND+1) < count) {
455 if (c >= curc && (n = (r-curr)+(c-curc)*lND) < count) {
460 if (c < curc && (n = (r-curr)+(curc-c)*lBC) < count) {
466 /* try corresponding UP combinations */
469 if ((n = (curr-r)*lUP+c*lND+1) < count) {
474 if (c >= curc && (n = (curr-r)*lUP+(c-curc)*lND) < count) {
479 if (c < curc && (n = (curr-r)*lUP+(curc-c)*lBC) < count) {
486 if (curr == r && c > curc && linect[r] < curc && c-curc < count)
491 case -1: /* error! */
492 write (2,"\r\nInternal cursor error.\r\n",26);
495 /* direct cursor motion */
497 tputs (m,abs(curr-r),addbuf);
500 /* relative to "home" */
503 for (i = 0; i < r; i++)
505 for (i = 0; i < c; i++)
509 /* CR and down and over */
512 for (i = 0; i < r-curr; i++)
514 for (i = 0; i < c; i++)
520 for (i = 0; i < r-curr; i++)
522 for (i = 0; i < c-curc; i++)
528 for (i = 0; i < r-curr; i++)
530 for (i = 0; i < curc-c; i++)
534 /* CR and up and over */
537 for (i = 0; i < curr-r; i++)
539 for (i = 0; i < c; i++)
545 for (i = 0; i < curr-r; i++)
547 for (i = 0; i < c-curc; i++)
553 for (i = 0; i < curr-r; i++)
555 for (i = 0; i < curc-c; i++) {
565 for (i = 0; i < c-curc; i++)
579 /* double space if can't clear */
585 curr = curc = 0; /* fix position markers */
587 for (i = 0; i < 24; i++) /* clear line counts */
589 buffnum = -1; /* ignore leftover buffer contents */
590 tputs (CL,CO,addbuf); /* put CL in buffer */
595 char c; /* character to output */
597 int sp; /* counts spaces in a tab */
599 if (c == '\007') { /* bells go in blindly */
604 /* process tabs, use spaces if the
605 * the tab should be erasing things,
606 * otherwise use cursor movement
607 * routines. Note this does not use
608 * hardware tabs at all. */
610 sp = (curc+8) & (~ 7); /* compute spaces */
611 /* check line length */
612 if (linect[curr] >= curc || sp < 4) {
613 for (; sp > curc; sp--)
615 curc = sp; /* fix curc */
621 /* do newline be calling newline */
627 /* ignore any other control chars */
631 /* if an erasing space or non-space,
632 * just add it to buffer. Otherwise
633 * use cursor movement routine, so that
634 * multiple spaces will be grouped
636 if (c > ' ' || linect[curr] >= curc) {
637 newpos (); /* make sure position correct */
638 addbuf (c); /* add character to buffer */
639 /* fix line length */
640 if (c == ' ' && linect[curr] == curc)
642 else if (linect[curr] < curc)
644 curc++; /* fix curc */
646 /* use cursor movement routine */
647 curmove (curr,curc+1);
656 tputs (CD,CO-curr,addbuf);
657 for (i = curr; i < LI; i++)
662 curmove (i = curr,0);
664 while (curr < LI-1) {
666 if (linect[curr] > -1)
677 if (curc > linect[curr])
682 linect[curr] = curc-1;
685 while (linect[curr] > c) {
707 char *code; /* two letter code */
708 char ***cap; /* pointer to cap string */
709 char *bufp; /* pointer to cap buffer */
710 char tentry[1024]; /* temporary uncoded caps buffer */
712 tgetent (tentry, (char *)s); /* get uncoded termcap entry */
714 LI = tgetnum ("li"); /* get number of lines */
717 CO = tgetnum ("co"); /* get number of columns */
721 bufp = tbuf; /* get padding character */
722 tgetstr ("pc",&bufp);
728 bufp = tbuf; /* get string entries */
730 for (code = tcap; *code; code += 2)
731 **cap++ = (char *)tgetstr (code,&bufp);
733 /* get pertinent lengths */
744 if (LI < 24 || CO < 72 || !(CL && UP && ND))
746 linect = (int *)calloc (LI+1,sizeof(int));