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