Add the DragonFly cvs id and perform general cleanups on cvs/rcs/sccs ids. Most
[dragonfly.git] / games / snake / snake / move.c
1 /*
2  * Copyright (c) 1980, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * @(#)move.c   8.1 (Berkeley) 7/19/93
34  * $FreeBSD: src/games/snake/snake/move.c,v 1.5.2.1 2000/08/17 06:21:44 jhb Exp $
35  * $DragonFly: src/games/snake/snake/Attic/move.c,v 1.2 2003/06/17 04:25:25 dillon Exp $
36  */
37
38 /*************************************************************************
39  *
40  *      MOVE LIBRARY
41  *
42  *      This set of subroutines moves a cursor to a predefined
43  *      location, independent of the terminal type.  If the
44  *      terminal has an addressable cursor, it uses it.  If
45  *      not, it optimizes for tabs (currently) even if you don't
46  *      have them.
47  *
48  *      At all times the current address of the cursor must be maintained,
49  *      and that is available as structure cursor.
50  *
51  *      The following calls are allowed:
52  *              move(sp)        move to point sp.
53  *              up()            move up one line.
54  *              down()          move down one line.
55  *              bs()            move left one space (except column 0).
56  *              nd()            move right one space(no write).
57  *              clear()         clear screen.
58  *              home()          home.
59  *              ll()            move to lower left corner of screen.
60  *              cr()            carriage return (no line feed).
61  *              pr()            just like standard printf, but keeps track
62  *                              of cursor position. (Uses pstring).
63  *              apr()           same as printf, but first argument is &point.
64  *                              (Uses pstring).
65  *              pstring(s)      output the string of printing characters.
66  *                              However, '\r' is interpreted to mean return
67  *                              to column of origination AND do linefeed.
68  *                              '\n' causes <cr><lf>.
69  *              putpad(str)     calls tputs to output character with proper
70  *                                      padding.
71  *              outch()         the output routine for a character used by
72  *                                      tputs. It just calls putchar.
73  *              pch(ch)         output character to screen and update
74  *                                      cursor address (must be a standard
75  *                                      printing character). WILL SCROLL.
76  *              pchar(ps,ch)    prints one character if it is on the
77  *                                      screen at the specified location;
78  *                                      otherwise, dumps it.(no wrap-around).
79  *
80  *              getcap()        initializes strings for later calls.
81  *              cap(string)     outputs the string designated in the termcap
82  *                                      data base. (Should not move the cursor.)
83  *              done()          returns the terminal to intial state and exits.
84  *
85  *              point(&p,x,y)   return point set to x,y.
86  *
87  *              baudrate()      returns the baudrate of the terminal.
88  *              delay(t)        causes an approximately constant delay
89  *                                      independent of baudrate.
90  *                                      Duration is ~ t/20 seconds.
91  *
92  ******************************************************************************/
93
94 #include <errno.h>
95 #if __STDC__
96 #include <stdarg.h>
97 #else
98 #include <varargs.h>
99 #endif
100 #include <string.h>
101 #include <unistd.h>
102
103 #include "snake.h"
104
105 int CMlength;
106 int NDlength;
107 int BSlength;
108 int delaystr[10];
109 short ospeed;
110
111 static char str[80];
112
113 move(sp)
114 struct point *sp;
115 {
116         int distance;
117         int tabcol,ct;
118         struct point z;
119
120         if (sp->line <0 || sp->col <0 || sp->col > COLUMNS){
121                 pr("move to [%d,%d]?",sp->line,sp->col);
122                 return;
123         }
124         if (sp->line >= LINES){
125                 move(point(&z,sp->col,LINES-1));
126                 while(sp->line-- >= LINES)putchar('\n');
127                 return;
128         }
129
130         if (CM != 0) {
131                 char *cmstr = tgoto(CM, sp->col, sp->line);
132
133                 CMlength = strlen(cmstr);
134                 if(cursor.line == sp->line){
135                         distance = sp->col - cursor.col;
136                         if(distance == 0)return;        /* Already there! */
137                         if(distance > 0){       /* Moving to the right */
138                                 if(distance*NDlength < CMlength){
139                                         right(sp);
140                                         return;
141                                 }
142                                 if(TA){
143                                         ct=sp->col&7;
144                                         tabcol=(cursor.col|7)+1;
145                                         do{
146                                                 ct++;
147                                                 tabcol=(tabcol|7)+1;
148                                         }
149                                         while(tabcol<sp->col);
150                                         if(ct<CMlength){
151                                                 right(sp);
152                                                 return;
153                                         }
154                                 }
155                         } else {                /* Moving to the left */
156                                 if (-distance*BSlength < CMlength){
157                                         gto(sp);
158                                         return;
159                                 }
160                         }
161                         if(sp->col < CMlength){
162                                 cr();
163                                 right(sp);
164                                 return;
165                         }
166                                 /* No more optimizations on same row. */
167                 }
168                 distance = sp->col - cursor.col;
169                 distance = distance > 0 ?
170                         distance*NDlength : -distance * BSlength;
171                 if (distance < 0)
172                         pr("ERROR: distance is negative: %d",distance);
173                 distance += abs(sp->line - cursor.line);
174                 if(distance >= CMlength){
175                         putpad(cmstr);
176                         cursor.line = sp->line;
177                         cursor.col = sp->col;
178                         return;
179                 }
180         }
181
182         /*
183          * If we get here we have a terminal that can't cursor
184          * address but has local motions or one which can cursor
185          * address but can get there quicker with local motions.
186          */
187          gto(sp);
188 }
189 gto(sp)
190 struct point *sp;
191 {
192
193         int distance,f,tfield;
194
195         if (cursor.line > LINES || cursor.line <0 ||
196             cursor.col <0 || cursor.col > COLUMNS)
197                 pr("ERROR: cursor is at %d,%d\n",
198                         cursor.line,cursor.col);
199         if (sp->line > LINES || sp->line <0 ||
200             sp->col <0 || sp->col >  COLUMNS)
201                 pr("ERROR: target is %d,%d\n",sp->line,sp->col);
202         tfield = (sp->col) >> 3;
203         if (sp->line == cursor.line){
204                 if (sp->col > cursor.col)right(sp);
205                 else{
206                         distance = (cursor.col -sp->col)*BSlength;
207                         if (((TA) &&
208                              (distance > tfield+((sp->col)&7)*NDlength)
209                             ) ||
210                             (((cursor.col)*NDlength) < distance)
211                            ){
212                                 cr();
213                                 right(sp);
214                         }
215                         else{
216                                 while(cursor.col > sp->col) bs();
217                         }
218                 }
219                 return;
220         }
221                                 /*must change row */
222         if (cursor.col - sp->col > (cursor.col >> 3)){
223                 if (cursor.col == 0)f = 0;
224                 else f = -1;
225         }
226         else f = cursor.col >> 3;
227         if (((sp->line << 1) + 1 < cursor.line - f) && (HO != 0)){
228                         /*
229                          * home quicker than rlf:
230                          * (sp->line + f > cursor.line - sp->line)
231                          */
232                 putpad(HO);
233                 cursor.col = cursor.line = 0;
234                 gto(sp);
235                 return;
236         }
237         if (((sp->line << 1) > cursor.line + LINES+1 + f) && (LL != 0)){
238                 /* home,rlf quicker than lf
239                  * (LINES+1 - sp->line + f < sp->line - cursor.line)
240                  */
241                 if (cursor.line > f + 1){
242                 /* is home faster than wraparound lf?
243                  * (cursor.line + 20 - sp->line > 21 - sp->line + f)
244                  */
245                         ll();
246                         gto(sp);
247                         return;
248                 }
249         }
250         if ((LL != 0) && (sp->line > cursor.line + (LINES >> 1) - 1))
251                 cursor.line += LINES;
252         while(sp->line > cursor.line)down();
253         while(sp->line < cursor.line)up();
254         gto(sp);                /*can recurse since cursor.line = sp->line */
255 }
256
257 right(sp)
258 struct point *sp;
259 {
260         int field,tfield;
261         int tabcol,strlength;
262
263         if (sp->col < cursor.col)
264                 pr("ERROR:right() can't move left\n");
265         if(TA){         /* If No Tabs: can't send tabs because ttydrive
266                          * loses count with control characters.
267                          */
268                 field = cursor.col >> 3;
269 /*
270  *      This code is useful for a terminal which wraps around on backspaces.
271  *      (Mine does.)  Unfortunately, this is not specified in termcap, and
272  *      most terminals don't work that way.  (Of course, most terminals
273  *      have addressible cursors, too).
274  */
275                 if (BW && (CM == 0) &&
276                     ((sp->col << 1) - field > (COLUMNS - 8) << 1 )
277                    ){
278                         if (cursor.line == 0){
279                                 outch('\n');
280                         }
281                         outch('\r');
282                         cursor.col = COLUMNS + 1;
283                         while(cursor.col > sp->col)bs();
284                         if (cursor.line != 0) outch('\n');
285                         return;
286                 }
287
288                 tfield = sp->col >> 3;
289
290                 while (field < tfield){
291                         putpad(TA);
292                         cursor.col = ++field << 3;
293                 }
294                 tabcol = (cursor.col|7) + 1;
295                 strlength = (tabcol - sp->col)*BSlength + 1;
296                 /* length of sequence to overshoot */
297                 if (((sp->col - cursor.col)*NDlength > strlength) &&
298                     (tabcol < COLUMNS)
299                    ){
300                         /*
301                          * Tab past and backup
302                          */
303                         putpad(TA);
304                         cursor.col = (cursor.col | 7) + 1;
305                         while(cursor.col > sp->col)bs();
306                 }
307         }
308         while (sp->col > cursor.col){
309                 nd();
310         }
311 }
312
313 cr(){
314         outch('\r');
315         cursor.col = 0;
316 }
317
318 clear(){
319         int i;
320
321         if (CL){
322                 putpad(CL);
323                 cursor.col=cursor.line=0;
324         } else {
325                 for(i=0; i<LINES; i++) {
326                         putchar('\n');
327                 }
328                 cursor.line = LINES - 1;
329                 home();
330         }
331 }
332
333 home(){
334         struct point z;
335
336         if(HO != 0){
337                 putpad(HO);
338                 cursor.col = cursor.line = 0;
339                 return;
340         }
341         z.col = z.line = 0;
342         move(&z);
343 }
344
345 ll(){
346         int l;
347         struct point z;
348
349         l = lcnt + 2;
350         if(LL != NULL && LINES==l){
351                 putpad(LL);
352                 cursor.line = LINES-1;
353                 cursor.col = 0;
354                 return;
355         }
356         z.col = 0;
357         z.line = l-1;
358         move(&z);
359 }
360
361 up(){
362         putpad(UP);
363         cursor.line--;
364 }
365
366 down(){
367         putpad(DO);
368         cursor.line++;
369         if (cursor.line >= LINES)cursor.line=LINES-1;
370 }
371 bs(){
372         if (cursor.col > 0){
373                 putpad(BS);
374                 cursor.col--;
375         }
376 }
377
378 nd(){
379         putpad(ND);
380         cursor.col++;
381         if (cursor.col == COLUMNS+1){
382                 cursor.line++;
383                 cursor.col = 0;
384                 if (cursor.line >= LINES)cursor.line=LINES-1;
385         }
386 }
387
388 pch(c)
389 {
390         outch(c);
391         if(++cursor.col >= COLUMNS && AM) {
392                 cursor.col = 0;
393                 ++cursor.line;
394         }
395 }
396
397 void
398 #if __STDC__
399 apr(struct point *ps, const char *fmt, ...)
400 #else
401 apr(ps, fmt, va_alist)
402         struct point *ps;
403         char *fmt;
404         va_dcl
405 #endif
406 {
407         struct point p;
408         va_list ap;
409
410         p.line = ps->line+1; p.col = ps->col+1;
411         move(&p);
412 #if __STDC__
413         va_start(ap, fmt);
414 #else
415         va_start(ap);
416 #endif
417         (void)vsprintf(str, fmt, ap);
418         va_end(ap);
419         pstring(str);
420 }
421
422 void
423 #if __STDC__
424 pr(const char *fmt, ...)
425 #else
426 pr(fmt, va_alist)
427         char *fmt;
428         va_dcl
429 #endif
430 {
431         va_list ap;
432
433 #if __STDC__
434         va_start(ap, fmt);
435 #else
436         va_start(ap);
437 #endif
438         (void)vsprintf(str, fmt, ap);
439         va_end(ap);
440         pstring(str);
441 }
442
443 pstring(s)
444 char *s;{
445         struct point z;
446         int stcol;
447
448         stcol = cursor.col;
449         while (s[0] != '\0'){
450                 switch (s[0]){
451                 case '\n':
452                         move(point(&z,0,cursor.line+1));
453                         break;
454                 case '\r':
455                         move(point(&z,stcol,cursor.line+1));
456                         break;
457                 case '\t':
458                         z.col = (((cursor.col + 8) >> 3) << 3);
459                         z.line = cursor.line;
460                         move(&z);
461                         break;
462                 case '\b':
463                         bs();
464                         break;
465                 case CTRL('g'):
466                         outch(CTRL('g'));
467                         break;
468                 default:
469                         if (s[0] < ' ')break;
470                         pch(s[0]);
471                 }
472                 s++;
473         }
474 }
475
476 pchar(ps,ch)
477 struct point *ps;
478 char ch;{
479         struct point p;
480         p.col = ps->col + 1; p.line = ps->line + 1;
481         if (
482                 (p.col >= 0) &&
483                 (p.line >= 0) &&
484                 (
485                         (
486                                 (p.line < LINES) &&
487                                 (p.col < COLUMNS)
488                         ) ||
489                         (
490                                 (p.col == COLUMNS) &&
491                                 (p.line < LINES-1)
492                         )
493                 )
494         ){
495                 move(&p);
496                 pch(ch);
497         }
498 }
499
500
501 outch(c)
502 {
503         putchar(c);
504 }
505
506 putpad(str)
507 char *str;
508 {
509         if (str)
510                 tputs(str, 1, outch);
511 }
512
513 #if 0
514 baudrate()
515 {
516
517         switch (orig.sg_ospeed){
518         case B300:
519                 return(300);
520         case B1200:
521                 return(1200);
522         case B4800:
523                 return(4800);
524         case B9600:
525                 return(9600);
526         default:
527                 return(0);
528         }
529 }
530 #endif
531
532 delay(t)
533 unsigned int t;
534 {
535         while (usleep(t*50000U) == -1 && errno == EINTR) ;
536 }
537
538 done()
539 {
540         cook();
541         exit(0);
542 }
543
544 cook()
545 {
546         delay(1);
547         putpad(TE);
548         putpad(KE);
549         putpad(VE);
550         fflush(stdout);
551         stty(0, &orig);
552 #ifdef TIOCSLTC
553         ioctl(0, TIOCSLTC, &olttyc);
554 #endif
555 }
556
557 raw()
558 {
559         stty(0, &new);
560 #ifdef TIOCSLTC
561         ioctl(0, TIOCSLTC, &nlttyc);
562 #endif
563 }
564
565 struct point *point(ps,x,y)
566 struct point *ps;
567 int x,y;
568 {
569         ps->col=x;
570         ps->line=y;
571         return(ps);
572 }
573
574 char *ap;
575
576 getcap()
577 {
578         char *getenv();
579         char *term;
580         char *xPC;
581         void stop();
582 #ifdef TIOCGWINSZ
583         struct winsize win;
584 #endif
585
586         term = getenv("TERM");
587         if (term==0) {
588                 fprintf(stderr, "No TERM in environment\n");
589                 exit(1);
590         }
591
592         switch (tgetent(tbuf, term)) {
593         case -1:
594                 fprintf(stderr, "Cannot open termcap file\n");
595                 exit(2);
596         case 0:
597                 fprintf(stderr, "%s: unknown terminal", term);
598                 exit(3);
599         }
600
601         ap = tcapbuf;
602
603 #ifdef TIOCGWINSZ
604         if (ioctl(0, TIOCGWINSZ, (char *) &win) < 0 ||
605             (LINES = win.ws_row) == 0 || (COLUMNS = win.ws_col) == 0) {
606 #endif
607                 LINES = tgetnum("li");
608                 COLUMNS = tgetnum("co");
609 #ifdef TIOCGWINSZ
610         }
611 #endif
612         if (!lcnt)
613                 lcnt = LINES - 2;
614         if (!ccnt)
615                 ccnt = COLUMNS - 3;
616
617         AM = tgetflag("am");
618         BW = tgetflag("bw");
619
620         ND = tgetstr("nd", &ap);
621         UP = tgetstr("up", &ap);
622
623         DO = tgetstr("do", &ap);
624         if (DO == 0)
625                 DO = "\n";
626
627         BS = tgetstr("bc", &ap);
628         if (BS == 0 && tgetflag("bs"))
629                 BS = "\b";
630         if (BS)
631                 xBC = *BS;
632
633         TA = tgetstr("ta", &ap);
634         if (TA == 0 && tgetflag("pt"))
635                 TA = "\t";
636
637         HO = tgetstr("ho", &ap);
638         CL = tgetstr("cl", &ap);
639         CM = tgetstr("cm", &ap);
640         LL = tgetstr("ll", &ap);
641
642         KL = tgetstr("kl", &ap);
643         KR = tgetstr("kr", &ap);
644         KU = tgetstr("ku", &ap);
645         KD = tgetstr("kd", &ap);
646         if (KL)
647                 Klength = strlen(KL);
648         else
649                 Klength = strlen(KL);
650         /*
651          *      NOTE:   If KL, KR, KU, and KD are not
652          *              all the same length, some problems
653          *              may arise, since tests are made on
654          *              all of them together.
655          */
656
657         TI = tgetstr("ti", &ap);
658         TE = tgetstr("te", &ap);
659         KS = tgetstr("ks", &ap);
660         KE = tgetstr("ke", &ap);
661
662         VI = tgetstr("vi", &ap);
663         VE = tgetstr("ve", &ap);
664
665         xPC = tgetstr("pc", &ap);
666         if (xPC)
667                 PC = *xPC;
668
669         if (ND)
670                 NDlength = strlen(ND); 
671         else
672                 NDlength = 0;
673
674         if (BS)
675                 BSlength = strlen(BS);
676         else
677                 BSlength = 0;
678
679         if ((CM == 0) &&
680                 (HO == 0 || DO == 0 || UP==0 || BS==0 || ND==0))
681         {
682                 /* XXX as written in rev.1.6, we can assert(DO) */
683                 fprintf(stderr, "Terminal must have addressible ");
684                 fprintf(stderr, "cursor or home + 4 local motions\n");
685                 exit(5);
686         }
687         if (tgetflag("os")) {
688                 fprintf(stderr, "Terminal must not overstrike\n");
689                 exit(5);
690         }
691         if (LINES <= 0 || COLUMNS <= 0) {
692                 fprintf(stderr, "Must know the screen size\n");
693                 exit(5);
694         }
695
696         gtty(0, &orig);
697         new=orig;
698         new.sg_flags &= ~(ECHO|CRMOD|ALLDELAY|XTABS);
699         new.sg_flags |= CBREAK;
700         signal(SIGINT,stop);
701         ospeed = orig.sg_ospeed;
702 #ifdef TIOCGLTC
703         ioctl(0, TIOCGLTC, &olttyc);
704         nlttyc = olttyc;
705         nlttyc.t_suspc = '\377';
706         nlttyc.t_dsuspc = '\377';
707 #endif
708         raw();
709
710         if ((orig.sg_flags & XTABS) == XTABS) TA=0;
711         putpad(KS);
712         putpad(TI);
713         point(&cursor,0,LINES-1);
714 }