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