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