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