Get rid of varargs.h.
[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.3 2004/07/27 07:37:39 asmodai 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 #include <stdarg.h>
96 #include <string.h>
97 #include <unistd.h>
98
99 #include "snake.h"
100
101 int CMlength;
102 int NDlength;
103 int BSlength;
104 int delaystr[10];
105 short ospeed;
106
107 static char str[80];
108
109 move(sp)
110 struct point *sp;
111 {
112         int distance;
113         int tabcol,ct;
114         struct point z;
115
116         if (sp->line <0 || sp->col <0 || sp->col > COLUMNS){
117                 pr("move to [%d,%d]?",sp->line,sp->col);
118                 return;
119         }
120         if (sp->line >= LINES){
121                 move(point(&z,sp->col,LINES-1));
122                 while(sp->line-- >= LINES)putchar('\n');
123                 return;
124         }
125
126         if (CM != 0) {
127                 char *cmstr = tgoto(CM, sp->col, sp->line);
128
129                 CMlength = strlen(cmstr);
130                 if(cursor.line == sp->line){
131                         distance = sp->col - cursor.col;
132                         if(distance == 0)return;        /* Already there! */
133                         if(distance > 0){       /* Moving to the right */
134                                 if(distance*NDlength < CMlength){
135                                         right(sp);
136                                         return;
137                                 }
138                                 if(TA){
139                                         ct=sp->col&7;
140                                         tabcol=(cursor.col|7)+1;
141                                         do{
142                                                 ct++;
143                                                 tabcol=(tabcol|7)+1;
144                                         }
145                                         while(tabcol<sp->col);
146                                         if(ct<CMlength){
147                                                 right(sp);
148                                                 return;
149                                         }
150                                 }
151                         } else {                /* Moving to the left */
152                                 if (-distance*BSlength < CMlength){
153                                         gto(sp);
154                                         return;
155                                 }
156                         }
157                         if(sp->col < CMlength){
158                                 cr();
159                                 right(sp);
160                                 return;
161                         }
162                                 /* No more optimizations on same row. */
163                 }
164                 distance = sp->col - cursor.col;
165                 distance = distance > 0 ?
166                         distance*NDlength : -distance * BSlength;
167                 if (distance < 0)
168                         pr("ERROR: distance is negative: %d",distance);
169                 distance += abs(sp->line - cursor.line);
170                 if(distance >= CMlength){
171                         putpad(cmstr);
172                         cursor.line = sp->line;
173                         cursor.col = sp->col;
174                         return;
175                 }
176         }
177
178         /*
179          * If we get here we have a terminal that can't cursor
180          * address but has local motions or one which can cursor
181          * address but can get there quicker with local motions.
182          */
183          gto(sp);
184 }
185 gto(sp)
186 struct point *sp;
187 {
188
189         int distance,f,tfield;
190
191         if (cursor.line > LINES || cursor.line <0 ||
192             cursor.col <0 || cursor.col > COLUMNS)
193                 pr("ERROR: cursor is at %d,%d\n",
194                         cursor.line,cursor.col);
195         if (sp->line > LINES || sp->line <0 ||
196             sp->col <0 || sp->col >  COLUMNS)
197                 pr("ERROR: target is %d,%d\n",sp->line,sp->col);
198         tfield = (sp->col) >> 3;
199         if (sp->line == cursor.line){
200                 if (sp->col > cursor.col)right(sp);
201                 else{
202                         distance = (cursor.col -sp->col)*BSlength;
203                         if (((TA) &&
204                              (distance > tfield+((sp->col)&7)*NDlength)
205                             ) ||
206                             (((cursor.col)*NDlength) < distance)
207                            ){
208                                 cr();
209                                 right(sp);
210                         }
211                         else{
212                                 while(cursor.col > sp->col) bs();
213                         }
214                 }
215                 return;
216         }
217                                 /*must change row */
218         if (cursor.col - sp->col > (cursor.col >> 3)){
219                 if (cursor.col == 0)f = 0;
220                 else f = -1;
221         }
222         else f = cursor.col >> 3;
223         if (((sp->line << 1) + 1 < cursor.line - f) && (HO != 0)){
224                         /*
225                          * home quicker than rlf:
226                          * (sp->line + f > cursor.line - sp->line)
227                          */
228                 putpad(HO);
229                 cursor.col = cursor.line = 0;
230                 gto(sp);
231                 return;
232         }
233         if (((sp->line << 1) > cursor.line + LINES+1 + f) && (LL != 0)){
234                 /* home,rlf quicker than lf
235                  * (LINES+1 - sp->line + f < sp->line - cursor.line)
236                  */
237                 if (cursor.line > f + 1){
238                 /* is home faster than wraparound lf?
239                  * (cursor.line + 20 - sp->line > 21 - sp->line + f)
240                  */
241                         ll();
242                         gto(sp);
243                         return;
244                 }
245         }
246         if ((LL != 0) && (sp->line > cursor.line + (LINES >> 1) - 1))
247                 cursor.line += LINES;
248         while(sp->line > cursor.line)down();
249         while(sp->line < cursor.line)up();
250         gto(sp);                /*can recurse since cursor.line = sp->line */
251 }
252
253 right(sp)
254 struct point *sp;
255 {
256         int field,tfield;
257         int tabcol,strlength;
258
259         if (sp->col < cursor.col)
260                 pr("ERROR:right() can't move left\n");
261         if(TA){         /* If No Tabs: can't send tabs because ttydrive
262                          * loses count with control characters.
263                          */
264                 field = cursor.col >> 3;
265 /*
266  *      This code is useful for a terminal which wraps around on backspaces.
267  *      (Mine does.)  Unfortunately, this is not specified in termcap, and
268  *      most terminals don't work that way.  (Of course, most terminals
269  *      have addressible cursors, too).
270  */
271                 if (BW && (CM == 0) &&
272                     ((sp->col << 1) - field > (COLUMNS - 8) << 1 )
273                    ){
274                         if (cursor.line == 0){
275                                 outch('\n');
276                         }
277                         outch('\r');
278                         cursor.col = COLUMNS + 1;
279                         while(cursor.col > sp->col)bs();
280                         if (cursor.line != 0) outch('\n');
281                         return;
282                 }
283
284                 tfield = sp->col >> 3;
285
286                 while (field < tfield){
287                         putpad(TA);
288                         cursor.col = ++field << 3;
289                 }
290                 tabcol = (cursor.col|7) + 1;
291                 strlength = (tabcol - sp->col)*BSlength + 1;
292                 /* length of sequence to overshoot */
293                 if (((sp->col - cursor.col)*NDlength > strlength) &&
294                     (tabcol < COLUMNS)
295                    ){
296                         /*
297                          * Tab past and backup
298                          */
299                         putpad(TA);
300                         cursor.col = (cursor.col | 7) + 1;
301                         while(cursor.col > sp->col)bs();
302                 }
303         }
304         while (sp->col > cursor.col){
305                 nd();
306         }
307 }
308
309 cr(){
310         outch('\r');
311         cursor.col = 0;
312 }
313
314 clear(){
315         int i;
316
317         if (CL){
318                 putpad(CL);
319                 cursor.col=cursor.line=0;
320         } else {
321                 for(i=0; i<LINES; i++) {
322                         putchar('\n');
323                 }
324                 cursor.line = LINES - 1;
325                 home();
326         }
327 }
328
329 home(){
330         struct point z;
331
332         if(HO != 0){
333                 putpad(HO);
334                 cursor.col = cursor.line = 0;
335                 return;
336         }
337         z.col = z.line = 0;
338         move(&z);
339 }
340
341 ll(){
342         int l;
343         struct point z;
344
345         l = lcnt + 2;
346         if(LL != NULL && LINES==l){
347                 putpad(LL);
348                 cursor.line = LINES-1;
349                 cursor.col = 0;
350                 return;
351         }
352         z.col = 0;
353         z.line = l-1;
354         move(&z);
355 }
356
357 up(){
358         putpad(UP);
359         cursor.line--;
360 }
361
362 down(){
363         putpad(DO);
364         cursor.line++;
365         if (cursor.line >= LINES)cursor.line=LINES-1;
366 }
367 bs(){
368         if (cursor.col > 0){
369                 putpad(BS);
370                 cursor.col--;
371         }
372 }
373
374 nd(){
375         putpad(ND);
376         cursor.col++;
377         if (cursor.col == COLUMNS+1){
378                 cursor.line++;
379                 cursor.col = 0;
380                 if (cursor.line >= LINES)cursor.line=LINES-1;
381         }
382 }
383
384 pch(c)
385 {
386         outch(c);
387         if(++cursor.col >= COLUMNS && AM) {
388                 cursor.col = 0;
389                 ++cursor.line;
390         }
391 }
392
393 void
394 apr(struct point *ps, const char *fmt, ...)
395 {
396         struct point p;
397         va_list ap;
398
399         p.line = ps->line+1; p.col = ps->col+1;
400         move(&p);
401         va_start(ap, fmt);
402         (void)vsprintf(str, fmt, ap);
403         va_end(ap);
404         pstring(str);
405 }
406
407 void
408 pr(const char *fmt, ...)
409 {
410         va_list ap;
411
412         va_start(ap, fmt);
413         (void)vsprintf(str, fmt, ap);
414         va_end(ap);
415         pstring(str);
416 }
417
418 pstring(s)
419 char *s;{
420         struct point z;
421         int stcol;
422
423         stcol = cursor.col;
424         while (s[0] != '\0'){
425                 switch (s[0]){
426                 case '\n':
427                         move(point(&z,0,cursor.line+1));
428                         break;
429                 case '\r':
430                         move(point(&z,stcol,cursor.line+1));
431                         break;
432                 case '\t':
433                         z.col = (((cursor.col + 8) >> 3) << 3);
434                         z.line = cursor.line;
435                         move(&z);
436                         break;
437                 case '\b':
438                         bs();
439                         break;
440                 case CTRL('g'):
441                         outch(CTRL('g'));
442                         break;
443                 default:
444                         if (s[0] < ' ')break;
445                         pch(s[0]);
446                 }
447                 s++;
448         }
449 }
450
451 pchar(ps,ch)
452 struct point *ps;
453 char ch;{
454         struct point p;
455         p.col = ps->col + 1; p.line = ps->line + 1;
456         if (
457                 (p.col >= 0) &&
458                 (p.line >= 0) &&
459                 (
460                         (
461                                 (p.line < LINES) &&
462                                 (p.col < COLUMNS)
463                         ) ||
464                         (
465                                 (p.col == COLUMNS) &&
466                                 (p.line < LINES-1)
467                         )
468                 )
469         ){
470                 move(&p);
471                 pch(ch);
472         }
473 }
474
475
476 outch(c)
477 {
478         putchar(c);
479 }
480
481 putpad(str)
482 char *str;
483 {
484         if (str)
485                 tputs(str, 1, outch);
486 }
487
488 #if 0
489 baudrate()
490 {
491
492         switch (orig.sg_ospeed){
493         case B300:
494                 return(300);
495         case B1200:
496                 return(1200);
497         case B4800:
498                 return(4800);
499         case B9600:
500                 return(9600);
501         default:
502                 return(0);
503         }
504 }
505 #endif
506
507 delay(t)
508 unsigned int t;
509 {
510         while (usleep(t*50000U) == -1 && errno == EINTR) ;
511 }
512
513 done()
514 {
515         cook();
516         exit(0);
517 }
518
519 cook()
520 {
521         delay(1);
522         putpad(TE);
523         putpad(KE);
524         putpad(VE);
525         fflush(stdout);
526         stty(0, &orig);
527 #ifdef TIOCSLTC
528         ioctl(0, TIOCSLTC, &olttyc);
529 #endif
530 }
531
532 raw()
533 {
534         stty(0, &new);
535 #ifdef TIOCSLTC
536         ioctl(0, TIOCSLTC, &nlttyc);
537 #endif
538 }
539
540 struct point *point(ps,x,y)
541 struct point *ps;
542 int x,y;
543 {
544         ps->col=x;
545         ps->line=y;
546         return(ps);
547 }
548
549 char *ap;
550
551 getcap()
552 {
553         char *getenv();
554         char *term;
555         char *xPC;
556         void stop();
557 #ifdef TIOCGWINSZ
558         struct winsize win;
559 #endif
560
561         term = getenv("TERM");
562         if (term==0) {
563                 fprintf(stderr, "No TERM in environment\n");
564                 exit(1);
565         }
566
567         switch (tgetent(tbuf, term)) {
568         case -1:
569                 fprintf(stderr, "Cannot open termcap file\n");
570                 exit(2);
571         case 0:
572                 fprintf(stderr, "%s: unknown terminal", term);
573                 exit(3);
574         }
575
576         ap = tcapbuf;
577
578 #ifdef TIOCGWINSZ
579         if (ioctl(0, TIOCGWINSZ, (char *) &win) < 0 ||
580             (LINES = win.ws_row) == 0 || (COLUMNS = win.ws_col) == 0) {
581 #endif
582                 LINES = tgetnum("li");
583                 COLUMNS = tgetnum("co");
584 #ifdef TIOCGWINSZ
585         }
586 #endif
587         if (!lcnt)
588                 lcnt = LINES - 2;
589         if (!ccnt)
590                 ccnt = COLUMNS - 3;
591
592         AM = tgetflag("am");
593         BW = tgetflag("bw");
594
595         ND = tgetstr("nd", &ap);
596         UP = tgetstr("up", &ap);
597
598         DO = tgetstr("do", &ap);
599         if (DO == 0)
600                 DO = "\n";
601
602         BS = tgetstr("bc", &ap);
603         if (BS == 0 && tgetflag("bs"))
604                 BS = "\b";
605         if (BS)
606                 xBC = *BS;
607
608         TA = tgetstr("ta", &ap);
609         if (TA == 0 && tgetflag("pt"))
610                 TA = "\t";
611
612         HO = tgetstr("ho", &ap);
613         CL = tgetstr("cl", &ap);
614         CM = tgetstr("cm", &ap);
615         LL = tgetstr("ll", &ap);
616
617         KL = tgetstr("kl", &ap);
618         KR = tgetstr("kr", &ap);
619         KU = tgetstr("ku", &ap);
620         KD = tgetstr("kd", &ap);
621         if (KL)
622                 Klength = strlen(KL);
623         else
624                 Klength = strlen(KL);
625         /*
626          *      NOTE:   If KL, KR, KU, and KD are not
627          *              all the same length, some problems
628          *              may arise, since tests are made on
629          *              all of them together.
630          */
631
632         TI = tgetstr("ti", &ap);
633         TE = tgetstr("te", &ap);
634         KS = tgetstr("ks", &ap);
635         KE = tgetstr("ke", &ap);
636
637         VI = tgetstr("vi", &ap);
638         VE = tgetstr("ve", &ap);
639
640         xPC = tgetstr("pc", &ap);
641         if (xPC)
642                 PC = *xPC;
643
644         if (ND)
645                 NDlength = strlen(ND); 
646         else
647                 NDlength = 0;
648
649         if (BS)
650                 BSlength = strlen(BS);
651         else
652                 BSlength = 0;
653
654         if ((CM == 0) &&
655                 (HO == 0 || DO == 0 || UP==0 || BS==0 || ND==0))
656         {
657                 /* XXX as written in rev.1.6, we can assert(DO) */
658                 fprintf(stderr, "Terminal must have addressible ");
659                 fprintf(stderr, "cursor or home + 4 local motions\n");
660                 exit(5);
661         }
662         if (tgetflag("os")) {
663                 fprintf(stderr, "Terminal must not overstrike\n");
664                 exit(5);
665         }
666         if (LINES <= 0 || COLUMNS <= 0) {
667                 fprintf(stderr, "Must know the screen size\n");
668                 exit(5);
669         }
670
671         gtty(0, &orig);
672         new=orig;
673         new.sg_flags &= ~(ECHO|CRMOD|ALLDELAY|XTABS);
674         new.sg_flags |= CBREAK;
675         signal(SIGINT,stop);
676         ospeed = orig.sg_ospeed;
677 #ifdef TIOCGLTC
678         ioctl(0, TIOCGLTC, &olttyc);
679         nlttyc = olttyc;
680         nlttyc.t_suspc = '\377';
681         nlttyc.t_dsuspc = '\377';
682 #endif
683         raw();
684
685         if ((orig.sg_flags & XTABS) == XTABS) TA=0;
686         putpad(KS);
687         putpad(TI);
688         point(&cursor,0,LINES-1);
689 }