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