![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to move.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / games / snake|
Return to move.c CVS log | Up to [CSRG BSD Unix] / 42BSD / games / snake |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)move.c 4.1 (Berkeley) 7/4/83";
3: #endif
4:
5: /*************************************************************************
6: *
7: * MOVE LIBRARY
8: *
9: * This set of subroutines moves a cursor to a predefined
10: * location, independent of the terminal type. If the
11: * terminal has an addressable cursor, it uses it. If
12: * not, it optimizes for tabs (currently) even if you don't
13: * have them.
14: *
15: * At all times the current address of the cursor must be maintained,
16: * and that is available as structure cursor.
17: *
18: * The following calls are allowed:
19: * move(sp) move to point sp.
20: * up() move up one line.
21: * down() move down one line.
22: * bs() move left one space (except column 0).
23: * nd() move right one space(no write).
24: * clear() clear screen.
25: * home() home.
26: * ll() move to lower left corner of screen.
27: * cr() carriage return (no line feed).
28: * printf() just like standard printf, but keeps track
29: * of cursor position. (Uses pstring).
30: * aprintf() same as printf, but first argument is &point.
31: * (Uses pstring).
32: * pstring(s) output the string of printing characters.
33: * However, '\r' is interpreted to mean return
34: * to column of origination AND do linefeed.
35: * '\n' causes <cr><lf>.
36: * putpad(str) calls tputs to output character with proper
37: * padding.
38: * outch() the output routine for a character used by
39: * tputs. It just calls putchar.
40: * pch(ch) output character to screen and update
41: * cursor address (must be a standard
42: * printing character). WILL SCROLL.
43: * pchar(ps,ch) prints one character if it is on the
44: * screen at the specified location;
45: * otherwise, dumps it.(no wrap-around).
46: *
47: * getcap() initializes strings for later calls.
48: * cap(string) outputs the string designated in the termcap
49: * data base. (Should not move the cursor.)
50: * done(int) returns the terminal to intial state. If int
51: * is not 0, it exits.
52: *
53: * same(&p1,&p2) returns 1 if p1 and p2 are the same point.
54: * point(&p,x,y) return point set to x,y.
55: *
56: * baudrate(x) returns the baudrate of the terminal.
57: * delay(t) causes an approximately constant delay
58: * independent of baudrate.
59: * Duration is ~ t/20 seconds.
60: *
61: ******************************************************************************/
62:
63: #include "snake.h"
64:
65: int CMlength;
66: int NDlength;
67: int BSlength;
68: int delaystr[10];
69: short ospeed;
70:
71: static char str[80];
72:
73: move(sp)
74: struct point *sp;
75: {
76: int distance;
77: int tabcol,ct;
78: struct point z;
79:
80: if (sp->line <0 || sp->col <0 || sp->col > COLUMNS){
81: printf("move to [%d,%d]?",sp->line,sp->col);
82: return;
83: }
84: if (sp->line >= LINES){
85: move(point(&z,sp->col,LINES-1));
86: while(sp->line-- >= LINES)putchar('\n');
87: return;
88: }
89:
90: if (CM != 0) {
91: char *cmstr = tgoto(CM, sp->col, sp->line);
92:
93: CMlength = strlen(cmstr);
94: if(cursor.line == sp->line){
95: distance = sp->col - cursor.col;
96: if(distance == 0)return; /* Already there! */
97: if(distance > 0){ /* Moving to the right */
98: if(distance*NDlength < CMlength){
99: right(sp);
100: return;
101: }
102: if(TA){
103: ct=sp->col&7;
104: tabcol=(cursor.col|7)+1;
105: do{
106: ct++;
107: tabcol=(tabcol|7)+1;
108: }
109: while(tabcol<sp->col);
110: if(ct<CMlength){
111: right(sp);
112: return;
113: }
114: }
115: } else { /* Moving to the left */
116: if (-distance*BSlength < CMlength){
117: gto(sp);
118: return;
119: }
120: }
121: if(sp->col < CMlength){
122: cr();
123: right(sp);
124: return;
125: }
126: /* No more optimizations on same row. */
127: }
128: distance = sp->col - cursor.col;
129: distance = distance > 0 ?
130: distance*NDlength : -distance * BSlength;
131: if(distance < 0)printf("ERROR: distance is negative: %d",distance);
132: distance += abs(sp->line - cursor.line);
133: if(distance >= CMlength){
134: putpad(cmstr);
135: cursor.line = sp->line;
136: cursor.col = sp->col;
137: return;
138: }
139: }
140:
141: /*
142: * If we get here we have a terminal that can't cursor
143: * address but has local motions or one which can cursor
144: * address but can get there quicker with local motions.
145: */
146: gto(sp);
147: }
148: gto(sp)
149: struct point *sp;
150: {
151:
152: int distance,f,tfield,j;
153:
154: if (cursor.line > LINES || cursor.line <0 ||
155: cursor.col <0 || cursor.col > COLUMNS)
156: printf("ERROR: cursor is at %d,%d\n",
157: cursor.line,cursor.col);
158: if (sp->line > LINES || sp->line <0 ||
159: sp->col <0 || sp->col > COLUMNS)
160: printf("ERROR: target is %d,%d\n",sp->line,sp->col);
161: tfield = (sp->col) >> 3;
162: if (sp->line == cursor.line){
163: if (sp->col > cursor.col)right(sp);
164: else{
165: distance = (cursor.col -sp->col)*BSlength;
166: if (((TA) &&
167: (distance > tfield+((sp->col)&7)*NDlength)
168: ) ||
169: (((cursor.col)*NDlength) < distance)
170: ){
171: cr();
172: right(sp);
173: }
174: else{
175: while(cursor.col > sp->col) bs();
176: }
177: }
178: return;
179: }
180: /*must change row */
181: if (cursor.col - sp->col > (cursor.col >> 3)){
182: if (cursor.col == 0)f = 0;
183: else f = -1;
184: }
185: else f = cursor.col >> 3;
186: if (((sp->line << 1) + 1 < cursor.line - f) && (HO != 0)){
187: /*
188: * home quicker than rlf:
189: * (sp->line + f > cursor.line - sp->line)
190: */
191: putpad(HO);
192: cursor.col = cursor.line = 0;
193: gto(sp);
194: return;
195: }
196: if (((sp->line << 1) > cursor.line + LINES+1 + f) && (LL != 0)){
197: /* home,rlf quicker than lf
198: * (LINES+1 - sp->line + f < sp->line - cursor.line)
199: */
200: if (cursor.line > f + 1){
201: /* is home faster than wraparound lf?
202: * (cursor.line + 20 - sp->line > 21 - sp->line + f)
203: */
204: ll();
205: gto(sp);
206: return;
207: }
208: }
209: if ((LL != 0) && (sp->line > cursor.line + (LINES >> 1) - 1))
210: cursor.line += LINES;
211: while(sp->line > cursor.line)down();
212: while(sp->line < cursor.line)up();
213: gto(sp); /*can recurse since cursor.line = sp->line */
214: }
215:
216: right(sp)
217: struct point *sp;
218: {
219: int field,tfield;
220: int tabcol,strlength;
221:
222: if (sp->col < cursor.col)
223: printf("ERROR:right() can't move left\n");
224: if(TA){ /* If No Tabs: can't send tabs because ttydrive
225: * loses count with control characters.
226: */
227: field = cursor.col >> 3;
228: /*
229: * This code is useful for a terminal which wraps around on backspaces.
230: * (Mine does.) Unfortunately, this is not specified in termcap, and
231: * most terminals don't work that way. (Of course, most terminals
232: * have addressible cursors, too).
233: */
234: if (BW && (CM == 0) &&
235: ((sp->col << 1) - field > (COLUMNS - 8) << 1 )
236: ){
237: if (cursor.line == 0){
238: outch('\n');
239: }
240: outch('\r');
241: cursor.col = COLUMNS + 1;
242: while(cursor.col > sp->col)bs();
243: if (cursor.line != 0) outch('\n');
244: return;
245: }
246:
247: tfield = sp->col >> 3;
248:
249: while (field < tfield){
250: putpad(TA);
251: cursor.col = ++field << 3;
252: }
253: tabcol = (cursor.col|7) + 1;
254: strlength = (tabcol - sp->col)*BSlength + 1;
255: /* length of sequence to overshoot */
256: if (((sp->col - cursor.col)*NDlength > strlength) &&
257: (tabcol < COLUMNS)
258: ){
259: /*
260: * Tab past and backup
261: */
262: putpad(TA);
263: cursor.col = (cursor.col | 7) + 1;
264: while(cursor.col > sp->col)bs();
265: }
266: }
267: while (sp->col > cursor.col){
268: nd();
269: }
270: }
271:
272: cr(){
273: outch('\r');
274: cursor.col = 0;
275: }
276:
277: clear(){
278: int i;
279:
280: if (CL){
281: putpad(CL);
282: cursor.col=cursor.line=0;
283: } else {
284: for(i=0; i<LINES; i++) {
285: putchar('\n');
286: }
287: cursor.line = LINES - 1;
288: home();
289: }
290: }
291:
292: home(){
293: struct point z;
294:
295: if(HO != 0){
296: putpad(HO);
297: cursor.col = cursor.line = 0;
298: return;
299: }
300: z.col = z.line = 0;
301: move(&z);
302: }
303:
304: ll(){
305: int j,l;
306: struct point z;
307:
308: l = lcnt + 2;
309: if(LL != NULL && LINES==l){
310: putpad(LL);
311: cursor.line = LINES-1;
312: cursor.col = 0;
313: return;
314: }
315: z.col = 0;
316: z.line = l-1;
317: move(&z);
318: }
319:
320: up(){
321: putpad(UP);
322: cursor.line--;
323: }
324:
325: down(){
326: putpad(DO);
327: cursor.line++;
328: if (cursor.line >= LINES)cursor.line=LINES-1;
329: }
330: bs(){
331: if (cursor.col > 0){
332: putpad(BS);
333: cursor.col--;
334: }
335: }
336:
337: nd(){
338: putpad(ND);
339: cursor.col++;
340: if (cursor.col == COLUMNS+1){
341: cursor.line++;
342: cursor.col = 0;
343: if (cursor.line >= LINES)cursor.line=LINES-1;
344: }
345: }
346:
347: pch(c)
348: {
349: outch(c);
350: if(++cursor.col >= COLUMNS && AM) {
351: cursor.col = 0;
352: ++cursor.line;
353: }
354: }
355:
356: aprintf(ps,st,v0,v1,v2,v3,v4,v5,v6,v7,v8,v9)
357: struct point *ps;
358: char *st;
359: int v0,v1,v2,v3,v4,v5,v6,v7,v8,v9;
360:
361: {
362: struct point p;
363:
364: p.line = ps->line+1; p.col = ps->col+1;
365: move(&p);
366: sprintf(str,st,v0,v1,v2,v3,v4,v5,v6,v7,v8,v9);
367: pstring(str);
368: }
369:
370: printf(st,v0,v1,v2,v3,v4,v5,v6,v7,v8,v9)
371: char *st;
372: int v0,v1,v2,v3,v4,v5,v6,v7,v8,v9;
373: {
374: sprintf(str,st,v0,v1,v2,v3,v4,v5,v6,v7,v8,v9);
375: pstring(str);
376: }
377:
378: pstring(s)
379: char *s;{
380: struct point z;
381: int stcol;
382:
383: stcol = cursor.col;
384: while (s[0] != '\0'){
385: switch (s[0]){
386: case '\n':
387: move(point(&z,0,cursor.line+1));
388: break;
389: case '\r':
390: move(point(&z,stcol,cursor.line+1));
391: break;
392: case '\t':
393: z.col = (((cursor.col + 8) >> 3) << 3);
394: z.line = cursor.line;
395: move(&z);
396: break;
397: case '\b':
398: bs();
399: break;
400: case CTRL(g):
401: outch(CTRL(g));
402: break;
403: default:
404: if (s[0] < ' ')break;
405: pch(s[0]);
406: }
407: s++;
408: }
409: }
410:
411: pchar(ps,ch)
412: struct point *ps;
413: char ch;{
414: struct point p;
415: p.col = ps->col + 1; p.line = ps->line + 1;
416: if (
417: (p.col >= 0) &&
418: (p.line >= 0) &&
419: (
420: (
421: (p.line < LINES) &&
422: (p.col < COLUMNS)
423: ) ||
424: (
425: (p.col == COLUMNS) &&
426: (p.line < LINES-1)
427: )
428: )
429: ){
430: move(&p);
431: pch(ch);
432: }
433: }
434:
435:
436: outch(c)
437: {
438: putchar(c);
439: }
440:
441: putpad(str)
442: char *str;
443: {
444: if (str)
445: tputs(str, 1, outch);
446: }
447: baudrate()
448: {
449:
450: switch (orig.sg_ospeed){
451: case B300:
452: return(300);
453: case B1200:
454: return(1200);
455: case B4800:
456: return(4800);
457: case B9600:
458: return(9600);
459: default:
460: return(0);
461: }
462: }
463: delay(t)
464: int t;
465: {
466: int k,j;
467:
468: k = baudrate() * t / 300;
469: for(j=0;j<k;j++){
470: putchar(PC);
471: }
472: }
473:
474: done()
475: {
476: cook();
477: exit(0);
478: }
479:
480: cook()
481: {
482: delay(1);
483: putpad(TE);
484: putpad(KE);
485: fflush(stdout);
486: stty(0, &orig);
487: #ifdef TIOCSLTC
488: ioctl(0, TIOCSLTC, &olttyc);
489: #endif
490: }
491:
492: raw()
493: {
494: stty(0, &new);
495: #ifdef TIOCSLTC
496: ioctl(0, TIOCSLTC, &nlttyc);
497: #endif
498: }
499:
500: same(sp1,sp2)
501: struct point *sp1, *sp2;
502: {
503: if ((sp1->line == sp2->line) && (sp1->col == sp2->col))return(1);
504: return(0);
505: }
506:
507: struct point *point(ps,x,y)
508: struct point *ps;
509: int x,y;
510: {
511: ps->col=x;
512: ps->line=y;
513: return(ps);
514: }
515:
516: char *ap;
517:
518: getcap()
519: {
520: char *getenv();
521: char *term;
522: char *xPC;
523: struct point z;
524: int stop();
525:
526: term = getenv("TERM");
527: if (term==0) {
528: fprintf(stderr, "No TERM in environment\n");
529: exit(1);
530: }
531:
532: switch (tgetent(tbuf, term)) {
533: case -1:
534: fprintf(stderr, "Cannot open termcap file\n");
535: exit(2);
536: case 0:
537: fprintf(stderr, "%s: unknown terminal", term);
538: exit(3);
539: }
540:
541: ap = tcapbuf;
542:
543: LINES = tgetnum("li");
544: COLUMNS = tgetnum("co");
545: lcnt = LINES;
546: ccnt = COLUMNS - 1;
547:
548: AM = tgetflag("am");
549: BW = tgetflag("bw");
550:
551: ND = tgetstr("nd", &ap);
552: UP = tgetstr("up", &ap);
553:
554: DO = tgetstr("do", &ap);
555: if (DO == 0)
556: DO = "\n";
557:
558: BS = tgetstr("bc", &ap);
559: if (BS == 0 && tgetflag("bs"))
560: BS = "\b";
561: if (BS)
562: xBC = *BS;
563:
564: TA = tgetstr("ta", &ap);
565: if (TA == 0 && tgetflag("pt"))
566: TA = "\t";
567:
568: HO = tgetstr("ho", &ap);
569: CL = tgetstr("cl", &ap);
570: CM = tgetstr("cm", &ap);
571: LL = tgetstr("ll", &ap);
572:
573: KL = tgetstr("kl", &ap);
574: KR = tgetstr("kr", &ap);
575: KU = tgetstr("ku", &ap);
576: KD = tgetstr("kd", &ap);
577: Klength = strlen(KL);
578: /* NOTE: If KL, KR, KU, and KD are not
579: * all the same length, some problems
580: * may arise, since tests are made on
581: * all of them together.
582: */
583:
584: TI = tgetstr("ti", &ap);
585: TE = tgetstr("te", &ap);
586: KS = tgetstr("ks", &ap);
587: KE = tgetstr("ke", &ap);
588:
589: xPC = tgetstr("pc", &ap);
590: if (xPC)
591: PC = *xPC;
592:
593: NDlength = strlen(ND);
594: BSlength = strlen(BS);
595: if ((CM == 0) &&
596: (HO == 0 | UP==0 || BS==0 || ND==0)) {
597: fprintf(stderr, "Terminal must have addressible ");
598: fprintf(stderr, "cursor or home + 4 local motions\n");
599: exit(5);
600: }
601: if (tgetflag("os")) {
602: fprintf(stderr, "Terminal must not overstrike\n");
603: exit(5);
604: }
605: if (LINES <= 0 || COLUMNS <= 0) {
606: fprintf(stderr, "Must know the screen size\n");
607: exit(5);
608: }
609:
610: gtty(0, &orig);
611: new=orig;
612: new.sg_flags &= ~(ECHO|CRMOD|ALLDELAY|XTABS);
613: new.sg_flags |= CBREAK;
614: signal(SIGINT,stop);
615: ospeed = orig.sg_ospeed;
616: #ifdef TIOCGLTC
617: ioctl(0, TIOCGLTC, &olttyc);
618: nlttyc = olttyc;
619: nlttyc.t_suspc = '\377';
620: nlttyc.t_dsuspc = '\377';
621: #endif
622: raw();
623:
624: if ((orig.sg_flags & XTABS) == XTABS) TA=0;
625: putpad(KS);
626: putpad(TI);
627: point(&cursor,0,LINES-1);
628: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.