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