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