1 /*
2 * Copyright (c) 1980 Regents of the University of California.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
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.
20 *
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
31 * SUCH DAMAGE.
32 */
33
34 #ifndef lint
35 static char sccsid[] = "@(#)fancy.c 5.5 (Berkeley) 6/1/90";
36 #endif /* not lint */
37
38 #include "back.h"
39
40 char PC; /* padding character */
41 char *BC; /* backspace sequence */
42 char *CD; /* clear to end of screen sequence */
43 char *CE; /* clear to end of line sequence */
44 char *CL; /* clear screen sequence */
45 char *CM; /* cursor movement instructions */
46 char *HO; /* home cursor sequence */
47 char *MC; /* column cursor movement map */
48 char *ML; /* row cursor movement map */
49 char *ND; /* forward cursor sequence */
50 char *UP; /* up cursor sequence */
51
52 int lHO; /* length of HO */
53 int lBC; /* length of BC */
54 int lND; /* length of ND */
55 int lUP; /* length of UP */
56 int CO; /* number of columns */
57 int LI; /* number of lines */
58 int *linect; /* array of lengths of lines on screen
59 (the actual screen is not stored) */
60
61 /* two letter codes */
62 char tcap[] = "bccdceclcmhomcmlndup";
63 /* corresponding strings */
64 char **tstr[] = { &BC, &CD, &CE, &CL, &CM, &HO, &MC, &ML, &ND, &UP };
65
66 int buffnum; /* pointer to output buffer */
67
68 char tbuf[1024]; /* buffer for decoded termcap entries */
69
70 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};
71
72 int oldr;
73 int oldw;
74 /* "real" cursor positions, so
75 * it knows when to reposition.
76 * These are -1 if curr and curc
77 * are accurate */
78 int realr;
79 int realc;
80
81 void addbuf();
82
fboard()83 fboard () {
84 register int i, j, l;
85
86 curmove (0,0); /* do top line */
87 for (i = 0; i < 53; i++)
88 fancyc ('_');
89
90 curmove (15,0); /* do botttom line */
91 for (i = 0; i < 53; i++)
92 fancyc ('_');
93
94 l = 1; /* do vertical lines */
95 for (i = 52; i > -1; i -= 28) {
96 curmove ( (l == 1? 1: 15) ,i);
97 fancyc ('|');
98 for (j = 0; j < 14; j++) {
99 curmove (curr+l,curc-1);
100 fancyc ('|');
101 }
102 if (i == 24)
103 i += 32;
104 l = -l; /* alternate directions */
105 }
106
107 curmove (2,1); /* label positions 13-18 */
108 for (i = 13; i < 18; i++) {
109 fancyc ('1');
110 fancyc ((i % 10)+'0');
111 curmove (curr,curc+2);
112 }
113 fancyc ('1');
114 fancyc ('8');
115
116 curmove (2,29); /* label positions 19-24 */
117 fancyc ('1');
118 fancyc ('9');
119 for (i = 20; i < 25; i++) {
120 curmove (curr,curc+2);
121 fancyc ('2');
122 fancyc ((i % 10)+'0');
123 }
124
125 curmove (14,1); /* label positions 12-7 */
126 fancyc ('1');
127 fancyc ('2');
128 for (i = 11; i > 6; i--) {
129 curmove (curr,curc+2);
130 fancyc (i > 9? '1': ' ');
131 fancyc ((i % 10)+'0');
132 }
133
134 curmove (14,30); /* label positions 6-1 */
135 fancyc ('6');
136 for (i = 5; i > 0; i--) {
137 curmove (curr,curc+3);
138 fancyc (i+'0');
139 }
140
141 for (i = 12; i > 6; i--) /* print positions 12-7 */
142 if (board[i])
143 bsect (board[i],13,1+4*(12-i),-1);
144
145 if (board[0]) /* print red men on bar */
146 bsect (board[0],13,25,-1);
147
148 for (i = 6; i > 0; i--) /* print positions 6-1 */
149 if (board[i])
150 bsect (board[i],13,29+4*(6-i),-1);
151
152 l = (off[1] < 0? off[1]+15: off[1]); /* print white's home */
153 bsect (l,3,54,1);
154
155 curmove (8,25); /* print the word BAR */
156 fancyc ('B');
157 fancyc ('A');
158 fancyc ('R');
159
160 for (i = 13; i < 19; i++) /* print positions 13-18 */
161 if (board[i])
162 bsect (board[i],3,1+4*(i-13),1);
163
164 if (board[25]) /* print white's men on bar */
165 bsect (board[25],3,25,1);
166
167 for (i = 19; i < 25; i++) /* print positions 19-24 */
168 if (board[i])
169 bsect (board[i],3,29+4*(i-19),1);
170
171 l = (off[0] < 0? off[0]+15: off[0]); /* print red's home */
172 bsect (-l,13,54,-1);
173
174 for (i = 0; i < 26; i++) /* save board position
175 * for refresh later */
176 oldb[i] = board[i];
177 oldr = (off[1] < 0? off[1]+15: off[1]);
178 oldw = -(off[0] < 0? off[0]+15: off[0]);
179 }
180
181 /*
182 * bsect (b,rpos,cpos,cnext)
183 * Print the contents of a board position. "b" has the value of the
184 * position, "rpos" is the row to start printing, "cpos" is the column to
185 * start printing, and "cnext" is positive if the position starts at the top
186 * and negative if it starts at the bottom. The value of "cpos" is checked
187 * to see if the position is a player's home, since those are printed
188 * differently.
189 */
190
bsect(b,rpos,cpos,cnext)191 bsect (b,rpos,cpos,cnext)
192 int b; /* contents of position */
193 int rpos; /* row of position */
194 int cpos; /* column of position */
195 int cnext; /* direction of position */
196
197 {
198 register int j; /* index */
199 register int n; /* number of men on position */
200 register int bct; /* counter */
201 int k; /* index */
202 char pc; /* color of men on position */
203
204 n = abs(b); /* initialize n and pc */
205 pc = (b > 0? 'r': 'w');
206
207 if (n < 6 && cpos < 54) /* position cursor at start */
208 curmove (rpos,cpos+1);
209 else
210 curmove (rpos,cpos);
211
212 for (j = 0; j < 5; j++) { /* print position row by row */
213
214 for (k = 0; k < 15; k += 5) /* print men */
215 if (n > j+k)
216 fancyc (pc);
217
218 if (j < 4) { /* figure how far to
219 * back up for next
220 * row */
221 if (n < 6) { /* stop if none left */
222 if (j+1 == n)
223 break;
224 bct = 1; /* single column */
225 } else {
226 if (n < 11) { /* two columns */
227 if (cpos == 54) { /* home pos */
228 if (j+5 >= n)
229 bct = 1;
230 else
231 bct = 2;
232 }
233 if (cpos < 54) { /* not home */
234 if (j+6 >= n)
235 bct = 1;
236 else
237 bct = 2;
238 }
239 } else { /* three columns */
240 if (j+10 >= n)
241 bct = 2;
242 else
243 bct = 3;
244 }
245 }
246 curmove (curr+cnext,curc-bct); /* reposition cursor */
247 }
248 }
249 }
250
refresh()251 refresh() {
252 register int i, r, c;
253
254 r = curr; /* save current position */
255 c = curc;
256
257 for (i = 12; i > 6; i--) /* fix positions 12-7 */
258 if (board[i] != oldb[i]) {
259 fixpos (oldb[i],board[i],13,1+(12-i)*4,-1);
260 oldb[i] = board[i];
261 }
262
263 if (board[0] != oldb[0]) { /* fix red men on bar */
264 fixpos (oldb[0],board[0],13,25,-1);
265 oldb[0] = board[0];
266 }
267
268 for (i = 6; i > 0; i--) /* fix positions 6-1 */
269 if (board[i] != oldb[i]) {
270 fixpos (oldb[i],board[i],13,29+(6-i)*4,-1);
271 oldb[i] = board[i];
272 }
273
274 i = -(off[0] < 0? off[0]+15: off[0]); /* fix white's home */
275 if (oldw != i) {
276 fixpos (oldw,i,13,54,-1);
277 oldw = i;
278 }
279
280 for (i = 13; i < 19; i++) /* fix positions 13-18 */
281 if (board[i] != oldb[i]) {
282 fixpos (oldb[i],board[i],3,1+(i-13)*4,1);
283 oldb[i] = board[i];
284 }
285
286 if (board[25] != oldb[25]) { /* fix white men on bar */
287 fixpos (oldb[25],board[25],3,25,1);
288 oldb[25] = board[25];
289 }
290
291 for (i = 19; i < 25; i++) /* fix positions 19-24 */
292 if (board[i] != oldb[i]) {
293 fixpos (oldb[i],board[i],3,29+(i-19)*4,1);
294 oldb[i] = board[i];
295 }
296
297 i = (off[1] < 0? off[1]+15: off[1]); /* fix red's home */
298 if (oldr != i) {
299 fixpos (oldr,i,3,54,1);
300 oldr = i;
301 }
302
303 curmove (r,c); /* return to saved position */
304 newpos();
305 buflush();
306 }
307
fixpos(old,new,r,c,inc)308 fixpos (old,new,r,c,inc)
309 int old, new, r, c, inc;
310
311 {
312 register int o, n, nv;
313 int ov, nc;
314 char col;
315
316 if (old*new >= 0) {
317 ov = abs(old);
318 nv = abs(new);
319 col = (old+new > 0? 'r': 'w');
320 o = (ov-1)/5;
321 n = (nv-1)/5;
322 if (o == n) {
323 if (o == 2)
324 nc = c+2;
325 if (o == 1)
326 nc = c < 54? c: c+1;
327 if (o == 0)
328 nc = c < 54? c+1: c;
329 if (ov > nv)
330 fixcol (r+inc*(nv-n*5),nc,abs(ov-nv),' ',inc);
331 else
332 fixcol (r+inc*(ov-o*5),nc,abs(ov-nv),col,inc);
333 return;
334 } else {
335 if (c < 54) {
336 if (o+n == 1) {
337 if (n) {
338 fixcol (r,c,abs(nv-5),col,inc);
339 if (ov != 5)
340 fixcol (r+inc*ov,c+1,abs(ov-5),col,inc);
341 } else {
342 fixcol (r,c,abs(ov-5),' ',inc);
343 if (nv != 5)
344 fixcol (r+inc*nv,c+1,abs(nv-5),' ',inc);
345 }
346 return;
347 }
348 if (n == 2) {
349 if (ov != 10)
350 fixcol (r+inc*(ov-5),c,abs(ov-10),col,inc);
351 fixcol (r,c+2,abs(nv-10),col,inc);
352 } else {
353 if (nv != 10)
354 fixcol (r+inc*(nv-5),c,abs(nv-10),' ',inc);
355 fixcol (r,c+2,abs(ov-10),' ',inc);
356 }
357 return;
358 }
359 if (n > o) {
360 fixcol (r+inc*(ov%5),c+o,abs(5*n-ov),col,inc);
361 if (nv != 5*n)
362 fixcol (r,c+n,abs(5*n-nv),col,inc);
363 } else {
364 fixcol (r+inc*(nv%5),c+n,abs(5*n-nv),' ',inc);
365 if (ov != 5*o)
366 fixcol (r,c+o,abs(5*o-ov),' ',inc);
367 }
368 return;
369 }
370 }
371 nv = abs(new);
372 fixcol (r,c+1,nv,new > 0? 'r': 'w',inc);
373 if (abs(old) <= abs(new))
374 return;
375 fixcol (r+inc*new,c+1,abs(old+new),' ',inc);
376 }
377
fixcol(r,c,l,ch,inc)378 fixcol (r,c,l,ch,inc)
379 register int l, ch;
380 int r, c, inc;
381
382 {
383 register int i;
384
385 curmove (r,c);
386 fancyc (ch);
387 for (i = 1; i < l; i++) {
388 curmove (curr+inc,curc-1);
389 fancyc (ch);
390 }
391 }
392
curmove(r,c)393 curmove (r,c)
394 register int r, c;
395
396 {
397 if (curr == r && curc == c)
398 return;
399 if (realr == -1) {
400 realr = curr;
401 realc = curc;
402 }
403 curr = r;
404 curc = c;
405 }
406
newpos()407 newpos () {
408 register int r; /* destination row */
409 register int c; /* destination column */
410 register int mode = -1; /* mode of movement */
411
412 int count = 1000; /* character count */
413 int i; /* index */
414 int j; /* index */
415 int n; /* temporary variable */
416 char *m; /* string containing CM movement */
417
418
419 if (realr == -1) /* see if already there */
420 return;
421
422 r = curr; /* set current and dest. positions */
423 c = curc;
424 curr = realr;
425 curc = realc;
426
427 /* double check position */
428 if (curr == r && curc == c) {
429 realr = realc = -1;
430 return;
431 }
432
433 if (CM) { /* try CM to get there */
434 mode = 0;
435 m = (char *)tgoto (CM,c,r);
436 count = strlen (m);
437 }
438
439 /* try HO and local movement */
440 if (HO && (n = r+c*lND+lHO) < count) {
441 mode = 1;
442 count = n;
443 }
444
445 /* try various LF combinations */
446 if (r >= curr) {
447 /* CR, LF, and ND */
448 if ((n = (r-curr)+c*lND+1) < count) {
449 mode = 2;
450 count = n;
451 }
452 /* LF, ND */
453 if (c >= curc && (n = (r-curr)+(c-curc)*lND) < count) {
454 mode = 3;
455 count = n;
456 }
457 /* LF, BS */
458 if (c < curc && (n = (r-curr)+(curc-c)*lBC) < count) {
459 mode = 4;
460 count = n;
461 }
462 }
463
464 /* try corresponding UP combinations */
465 if (r < curr) {
466 /* CR, UP, and ND */
467 if ((n = (curr-r)*lUP+c*lND+1) < count) {
468 mode = 5;
469 count = n;
470 }
471 /* UP and ND */
472 if (c >= curc && (n = (curr-r)*lUP+(c-curc)*lND) < count) {
473 mode = 6;
474 count = n;
475 }
476 /* UP and BS */
477 if (c < curc && (n = (curr-r)*lUP+(curc-c)*lBC) < count) {
478 mode = 7;
479 count = n;
480 }
481 }
482
483 /* space over */
484 if (curr == r && c > curc && linect[r] < curc && c-curc < count)
485 mode = 8;
486
487 switch (mode) {
488
489 case -1: /* error! */
490 write (2,"\r\nInternal cursor error.\r\n",26);
491 getout();
492
493 /* direct cursor motion */
494 case 0:
495 tputs (m,abs(curr-r),addbuf);
496 break;
497
498 /* relative to "home" */
499 case 1:
500 tputs (HO,r,addbuf);
501 for (i = 0; i < r; i++)
502 addbuf ('\012');
503 for (i = 0; i < c; i++)
504 tputs (ND,1,addbuf);
505 break;
506
507 /* CR and down and over */
508 case 2:
509 addbuf ('\015');
510 for (i = 0; i < r-curr; i++)
511 addbuf ('\012');
512 for (i = 0; i < c; i++)
513 tputs (ND,1,addbuf);
514 break;
515
516 /* down and over */
517 case 3:
518 for (i = 0; i < r-curr; i++)
519 addbuf ('\012');
520 for (i = 0; i < c-curc; i++)
521 tputs (ND,1,addbuf);
522 break;
523
524 /* down and back */
525 case 4:
526 for (i = 0; i < r-curr; i++)
527 addbuf ('\012');
528 for (i = 0; i < curc-c; i++)
529 addbuf ('\010');
530 break;
531
532 /* CR and up and over */
533 case 5:
534 addbuf ('\015');
535 for (i = 0; i < curr-r; i++)
536 tputs (UP,1,addbuf);
537 for (i = 0; i < c; i++)
538 tputs (ND,1,addbuf);
539 break;
540
541 /* up and over */
542 case 6:
543 for (i = 0; i < curr-r; i++)
544 tputs (UP,1,addbuf);
545 for (i = 0; i < c-curc; i++)
546 tputs (ND,1,addbuf);
547 break;
548
549 /* up and back */
550 case 7:
551 for (i = 0; i < curr-r; i++)
552 tputs (UP,1,addbuf);
553 for (i = 0; i < curc-c; i++) {
554 if (BC)
555 tputs (BC,1,addbuf);
556 else
557 addbuf ('\010');
558 }
559 break;
560
561 /* safe space */
562 case 8:
563 for (i = 0; i < c-curc; i++)
564 addbuf (' ');
565 }
566
567 /* fix positions */
568 curr = r;
569 curc = c;
570 realr = -1;
571 realc = -1;
572 }
573
clear()574 clear () {
575 register int i;
576
577 /* double space if can't clear */
578 if (CL == 0) {
579 writel ("\n\n");
580 return;
581 }
582
583 curr = curc = 0; /* fix position markers */
584 realr = realc = -1;
585 for (i = 0; i < 24; i++) /* clear line counts */
586 linect[i] = -1;
587 buffnum = -1; /* ignore leftover buffer contents */
588 tputs (CL,CO,addbuf); /* put CL in buffer */
589 }
590
tos()591 tos () { /* home cursor */
592 curmove (0,0);
593 }
594
fancyc(c)595 fancyc (c)
596 register char c; /* character to output */
597 {
598 register int sp; /* counts spaces in a tab */
599
600 if (c == '\007') { /* bells go in blindly */
601 addbuf (c);
602 return;
603 }
604
605 /* process tabs, use spaces if the
606 * the tab should be erasing things,
607 * otherwise use cursor movement
608 * routines. Note this does not use
609 * hardware tabs at all. */
610 if (c == '\t') {
611 sp = (curc+8) & (~ 7); /* compute spaces */
612 /* check line length */
613 if (linect[curr] >= curc || sp < 4) {
614 for (; sp > curc; sp--)
615 addbuf (' ');
616 curc = sp; /* fix curc */
617 } else
618 curmove (curr,sp);
619 return;
620 }
621
622 /* do newline be calling newline */
623 if (c == '\n') {
624 newline();
625 return;
626 }
627
628 /* ignore any other control chars */
629 if (c < ' ')
630 return;
631
632 /* if an erasing space or non-space,
633 * just add it to buffer. Otherwise
634 * use cursor movement routine, so that
635 * multiple spaces will be grouped
636 * together */
637 if (c > ' ' || linect[curr] >= curc) {
638 newpos (); /* make sure position correct */
639 addbuf (c); /* add character to buffer */
640 /* fix line length */
641 if (c == ' ' && linect[curr] == curc)
642 linect[curr]--;
643 else if (linect[curr] < curc)
644 linect[curr] = curc;
645 curc++; /* fix curc */
646 } else
647 /* use cursor movement routine */
648 curmove (curr,curc+1);
649 }
650
clend()651 clend() {
652 register int i;
653 register char *s;
654
655
656 if (CD) {
657 tputs (CD,CO-curr,addbuf);
658 for (i = curr; i < LI; i++)
659 linect[i] = -1;
660 return;
661 }
662
663 curmove (i = curr,0);
664 cline();
665 while (curr < LI-1) {
666 curmove (curr+1,0);
667 if (linect[curr] > -1)
668 cline ();
669 }
670 curmove (i,0);
671 }
672
cline()673 cline () {
674 register int i;
675 register int c;
676 register char *s;
677
678 if (curc > linect[curr])
679 return;
680 newpos ();
681 if (CE) {
682 tputs (CE,1,addbuf);
683 linect[curr] = curc-1;
684 } else {
685 c = curc-1;
686 while (linect[curr] > c) {
687 addbuf (' ');
688 curc++;
689 linect[curr]--;
690 }
691 curmove (curr,c+1);
692 }
693 }
694
newline()695 newline () {
696 cline();
697 if (curr == LI-1)
698 curmove (begscr,0);
699 else
700 curmove (curr+1,0);
701 }
702
getcaps(s)703 getcaps (s)
704 register char *s;
705
706 {
707 register char *code; /* two letter code */
708 register char ***cap; /* pointer to cap string */
709 char *bufp; /* pointer to cap buffer */
710 char tentry[1024]; /* temporary uncoded caps buffer */
711
712 tgetent (tentry,s); /* get uncoded termcap entry */
713
714 LI = tgetnum ("li"); /* get number of lines */
715 if (LI == -1)
716 LI = 12;
717 CO = tgetnum ("co"); /* get number of columns */
718 if (CO == -1)
719 CO = 65;
720
721 bufp = tbuf; /* get padding character */
722 tgetstr ("pc",&bufp);
723 if (bufp != tbuf)
724 PC = *tbuf;
725 else
726 PC = 0;
727
728 bufp = tbuf; /* get string entries */
729 cap = tstr;
730 for (code = tcap; *code; code += 2)
731 **cap++ = (char *)tgetstr (code,&bufp);
732
733 /* get pertinent lengths */
734 if (HO)
735 lHO = strlen (HO);
736 if (BC)
737 lBC = strlen (BC);
738 else
739 lBC = 1;
740 if (UP)
741 lUP = strlen (UP);
742 if (ND)
743 lND = strlen (ND);
744 if (LI < 24 || CO < 72 || !(CL && UP && ND))
745 return (0);
746 linect = (int *)calloc (LI+1,sizeof(int));
747 return (1);
748 }
749