WARNS6 cleanups
[dragonfly.git] / games / snake / snake / snake.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  * @(#) Copyright (c) 1980, 1993 The Regents of the University of California.  All rights reserved.
34  * @(#)snake.c  8.2 (Berkeley) 1/7/94
35  * $FreeBSD: src/games/snake/snake/snake.c,v 1.11.2.1 2000/08/17 06:21:44 jhb Exp $
36  * $DragonFly: src/games/snake/snake/snake.c,v 1.4 2006/09/03 23:47:56 pavalos Exp $
37  */
38
39 /*
40  * snake - crt hack game.
41  *
42  * You move around the screen with arrow keys trying to pick up money
43  * without getting eaten by the snake.  hjkl work as in vi in place of
44  * arrow keys.  You can leave at the exit any time.
45  *
46  * compile as follows:
47  *      cc -O snake.c move.c -o snake -lm -ltermlib
48  */
49
50 #include <sys/param.h>
51
52 #include <curses.h>
53 #include <fcntl.h>
54 #include <pwd.h>
55 #include <time.h>
56 #include <stdlib.h>
57 #include <unistd.h>
58 #include <sys/types.h>
59 #include <err.h>
60 #include <math.h>
61 #include <signal.h>
62 #include <stdio.h>
63 #include <stdlib.h>
64 #include <string.h>
65 #include <termios.h>
66
67 #include "pathnames.h"
68
69 #define cashvalue       chunk*(loot-penalty)/25
70
71 struct point {
72         int col, line;
73 };
74
75 #define same(s1, s2)    ((s1)->line == (s2)->line && (s1)->col == (s2)->col)
76
77 #define PENALTY  10     /* % penalty for invoking spacewarp     */
78
79 #define EOT     '\004'
80 #define LF      '\n'
81 #define DEL     '\177'
82
83 #define ME              'I'
84 #define SNAKEHEAD       'S'
85 #define SNAKETAIL       's'
86 #define TREASURE        '$'
87 #define GOAL            '#'
88
89 #ifndef MIN
90 #define MIN(a, b) ((a) < (b) ? (a) : (b))
91 #endif
92
93 #define pchar(point, c) mvaddch((point)->line + 1, (point)->col + 1, (c))
94 #define delay(t)        usleep(t * 50000);
95
96 struct point you;
97 struct point money;
98 struct point finish;
99 struct point snake[6];
100
101 int loot, penalty;
102 int moves;
103 int     fast = 1;
104
105 int rawscores;
106 FILE *logfile;
107
108 int     lcnt, ccnt;     /* user's idea of screen size */
109 int     chunk;          /* amount of money given at a time */
110
111 void            chase(struct point *, struct point *);
112 int             chk(const struct point *);
113 void            drawbox(void);
114 void            flushi(void);
115 void            home(void);
116 void            length(int);
117 void            logit(const char *);
118 int             main(int, char **);
119 void            mainloop(void) __attribute__((__noreturn__));
120 struct point   *point(struct point *, int, int);
121 int             post(int, int);
122 int             pushsnake(void);
123 void            right(const struct point *);
124 void            setup(void);
125 void            snap(void);
126 void            snrand(struct point *);
127 void            spacewarp(int);
128 void            stop(int) __attribute__((__noreturn__));
129 int             stretch(const struct point *);
130 void            surround(struct point *);
131 void            suspend(void);
132 void            win(const struct point *);
133 void            winnings(int);
134
135 int
136 main(int argc, char **argv)
137 {
138         int ch, i;
139         time_t tv;
140
141         /* Open score files then revoke setgid privileges */
142         rawscores = open(_PATH_RAWSCORES, O_RDWR|O_CREAT, 0664);
143         if (rawscores < 0) {
144                 warn("open %s", _PATH_RAWSCORES);
145                 sleep(2);
146         } else if (rawscores < 3)
147                 exit(1);
148         logfile = fopen(_PATH_LOGFILE, "a");
149         if (logfile == NULL) {
150                 warn("fopen %s", _PATH_LOGFILE);
151                 sleep(2);
152         }
153         setgid(getgid());
154
155         time(&tv);
156
157         while ((ch = getopt(argc, argv, "l:w:t")) != -1)
158                 switch ((char) ch) {
159 #ifdef DEBUG
160                 case 'd':
161                         tv = atol(optarg);
162                         break;
163 #endif
164                 case 'w':       /* width */
165                         ccnt = atoi(optarg);
166                         break;
167                 case 'l':       /* length */
168                         lcnt = atoi(optarg);
169                         break;
170                 case 't':
171                         fast = 0;
172                         break;
173                 case '?':
174                 default:
175 #ifdef DEBUG
176                         fputs("usage: snake [-d seed] [-w width] [-l length] [-t]\n", stderr);
177 #else
178                         fputs("usage: snake [-w width] [-l length] [-t]\n", stderr);
179 #endif
180                         exit(1);
181                 }
182
183         srandom((int) tv);
184
185         penalty = loot = 0;
186         initscr();
187         cbreak();
188         noecho();
189 #ifdef KEY_LEFT
190         keypad(stdscr, TRUE);
191 #endif
192         if (!lcnt || lcnt > LINES - 2)
193                 lcnt = LINES - 2;
194         if (!ccnt || ccnt > COLS - 2)
195                 ccnt = COLS - 2;
196
197         i = MIN(lcnt, ccnt);
198         if (i < 4) {
199                 endwin();
200                 errx(1, "screen too small for a fair game.");
201         }
202
203         /*
204          * chunk is the amount of money the user gets for each $.
205          * The formula below tries to be fair for various screen sizes.
206          * We only pay attention to the smaller of the 2 edges, since
207          * that seems to be the bottleneck.
208          * This formula is a hyperbola which includes the following points:
209          *      (24, $25)       (original scoring algorithm)
210          *      (12, $40)       (experimentally derived by the "feel")
211          *      (48, $15)       (a guess)
212          * This will give a 4x4 screen $99/shot.  We don't allow anything
213          * smaller than 4x4 because there is a 3x3 game where you can win
214          * an infinite amount of money.
215          */
216         if (i < 12) i = 12;     /* otherwise it isn't fair */
217         /*
218          * Compensate for border.  This really changes the game since
219          * the screen is two squares smaller but we want the default
220          * to be $25, and the high scores on small screens were a bit
221          * much anyway.
222          */
223         i += 2;
224         chunk = (675.0 / (i+6)) + 2.5;  /* min screen edge */
225
226         signal (SIGINT, stop);
227
228         snrand(&finish);
229         snrand(&you);
230         snrand(&money);
231         snrand(&snake[0]);
232
233         for(i=1;i<6;i++)
234                 chase (&snake[i], &snake[i-1]);
235         setup();
236         mainloop();
237         /* NOTREACHED */
238         return (0);
239 }
240
241 struct point *
242 point(struct point *ps, int x, int y)
243 {
244         ps->col = x;
245         ps->line = y;
246         return (ps);
247 }
248
249 /* Main command loop */
250 void
251 mainloop(void)
252 {
253         int     k;
254         int     repeat = 1;
255         int     lastc = 0;
256
257         for (;;) {
258                 int     c;
259
260                 /* Highlight you, not left & above */
261                 move(you.line + 1, you.col + 1);
262                 refresh();
263                 if (((c = getch()) <= '9') && (c >= '0')) {
264                         repeat = c - '0';
265                         while (((c = getch()) <= '9') && (c >= '0'))
266                                 repeat = 10 * repeat + (c - '0');
267                 } else {
268                         if (c != '.') repeat = 1;
269                 }
270                 if (c == '.') {
271                         c = lastc;
272                 }
273                 if (!fast) flushi();
274                 lastc = c;
275                 switch (c){
276                 case CTRL('z'):
277                         suspend();
278                         continue;
279                 case EOT:
280                 case 'x':
281                 case 0177:      /* del or end of file */
282                         endwin();
283                         length(moves);
284                         logit("quit");
285                         exit(0);
286                 case CTRL('l'):
287                         setup();
288                         winnings(cashvalue);
289                         continue;
290                 case 'p':
291                 case 'd':
292                         snap();
293                         continue;
294                 case 'w':
295                         spacewarp(0);
296                         continue;
297                 case 'A':
298                         repeat = you.col;
299                         c = 'h';
300                         break;
301                 case 'H':
302                 case 'S':
303                         repeat = you.col - money.col;
304                         c = 'h';
305                         break;
306                 case 'T':
307                         repeat = you.line;
308                         c = 'k';
309                         break;
310                 case 'K':
311                 case 'E':
312                         repeat = you.line - money.line;
313                         c = 'k';
314                         break;
315                 case 'P':
316                         repeat = ccnt - 1 - you.col;
317                         c = 'l';
318                         break;
319                 case 'L':
320                 case 'F':
321                         repeat = money.col - you.col;
322                         c = 'l';
323                         break;
324                 case 'B':
325                         repeat = lcnt - 1 - you.line;
326                         c = 'j';
327                         break;
328                 case 'J':
329                 case 'C':
330                         repeat = money.line - you.line;
331                         c = 'j';
332                         break;
333                 }
334                 for(k=1;k<=repeat;k++){
335                         moves++;
336                         switch(c) {
337                         case 's':
338                         case 'h':
339 #ifdef KEY_LEFT
340                         case KEY_LEFT:
341 #endif
342                         case '\b':
343                                 if (you.col >0) {
344                                         if((fast)||(k == 1))
345                                                 pchar(&you,' ');
346                                         you.col--;
347                                         if((fast) || (k == repeat) ||
348                                            (you.col == 0))
349                                                 pchar(&you,ME);
350                                 }
351                                 break;
352                         case 'f':
353                         case 'l':
354 #ifdef KEY_RIGHT
355                         case KEY_RIGHT:
356 #endif
357                         case ' ':
358                                 if (you.col < ccnt-1) {
359                                         if((fast)||(k == 1))
360                                                 pchar(&you,' ');
361                                         you.col++;
362                                         if((fast) || (k == repeat) ||
363                                            (you.col == ccnt-1))
364                                                 pchar(&you,ME);
365                                 }
366                                 break;
367                         case CTRL('p'):
368                         case 'e':
369                         case 'k':
370 #ifdef KEY_UP
371                         case KEY_UP:
372 #endif
373                         case 'i':
374                                 if (you.line > 0) {
375                                         if((fast)||(k == 1))
376                                                 pchar(&you,' ');
377                                         you.line--;
378                                         if((fast) || (k == repeat) ||
379                                           (you.line == 0))
380                                                 pchar(&you,ME);
381                                 }
382                                 break;
383                         case CTRL('n'):
384                         case 'c':
385                         case 'j':
386 #ifdef KEY_DOWN
387                         case KEY_DOWN:
388 #endif
389                         case LF:
390                         case 'm':
391                                 if (you.line+1 < lcnt) {
392                                         if((fast)||(k == 1))
393                                                 pchar(&you,' ');
394                                         you.line++;
395                                         if((fast) || (k == repeat) ||
396                                           (you.line == lcnt-1))
397                                                 pchar(&you,ME);
398                                 }
399                                 break;
400                         }
401
402                         if (same(&you,&money))
403                         {
404                                 loot += 25;
405                                 if(k < repeat)
406                                         pchar(&you,' ');
407                                 do {
408                                         snrand(&money);
409                                 } while ((money.col == finish.col && money.line == finish.line) ||
410                                          (money.col < 5 && money.line == 0) ||
411                                          (money.col == you.col && money.line == you.line));
412                                 pchar(&money,TREASURE);
413                                 winnings(cashvalue);
414                                 continue;
415                         }
416                         if (same(&you,&finish))
417                         {
418                                 win(&finish);
419                                 flushi();
420                                 endwin();
421                                 printf("You have won with $%d.\n", cashvalue);
422                                 fflush(stdout);
423                                 logit("won");
424                                 post(cashvalue,1);
425                                 length(moves);
426                                 exit(0);
427                         }
428                         if (pushsnake())break;
429                 }
430         }
431 }
432
433 void
434 setup(void)
435 {               /*
436                  * setup the board
437                  */
438         int i;
439
440         erase();
441         pchar(&you,ME);
442         pchar(&finish,GOAL);
443         pchar(&money,TREASURE);
444         for(i=1; i<6; i++) {
445                 pchar(&snake[i],SNAKETAIL);
446         }
447         pchar(&snake[0], SNAKEHEAD);
448         drawbox();
449         refresh();
450 }
451
452 void
453 drawbox(void)
454 {
455         int i;
456
457         for (i = 1; i <= ccnt; i++) {
458                 mvaddch(0, i, '-');
459                 mvaddch(lcnt + 1, i, '-');
460         }
461         for (i = 0; i <= lcnt + 1; i++) {
462                 mvaddch(i, 0, '|');
463                 mvaddch(i, ccnt + 1, '|');
464         }
465 }
466
467 void
468 snrand(struct point *sp)
469 {
470         struct point p;
471         int i;
472
473         for (;;) {
474                 p.col = random() % ccnt;
475                 p.line = random() % lcnt;
476
477                 /* make sure it's not on top of something else */
478                 if (p.line == 0 && p.col < 5)
479                         continue;
480                 if (same(&p, &you))
481                         continue;
482                 if (same(&p, &money))
483                         continue;
484                 if (same(&p, &finish))
485                         continue;
486                 for (i = 0; i < 6; i++)
487                         if (same(&p, &snake[i]))
488                                 break;
489                 if (i < 6)
490                         continue;
491                 break;
492         }
493         *sp = p;
494 }
495
496 int
497 post(int iscore, int flag)
498 {
499         short   score = iscore;
500         short   uid;
501         short   oldbest=0;
502         short   allbwho=0, allbscore=0;
503         struct  passwd *p;
504
505         /* I want to printf() the scores for terms that clear on cook(),
506          * but this routine also gets called with flag == 0 to see if
507          * the snake should wink.  If (flag) then we're at game end and
508          * can printf.
509          */
510         /*
511          * Neg uid, 0, and 1 cannot have scores recorded.
512          */
513         if ((uid = getuid()) <= 1) {
514                 if (flag)
515                         printf("No saved scores for uid %d.\n", uid);
516                 return(1);
517         }
518         if (rawscores < 0) {
519                 /* Error reported earlier */
520                 return(1);
521         }
522         /* Figure out what happened in the past */
523         read(rawscores, &allbscore, sizeof(short));
524         read(rawscores, &allbwho, sizeof(short));
525         lseek(rawscores, ((off_t)uid)*sizeof(short), 0);
526         read(rawscores, &oldbest, sizeof(short));
527         if (!flag) {
528                 lseek(rawscores, 0, SEEK_SET);
529                 return (score > oldbest ? 1 : 0);
530         }
531
532         /* Update this jokers best */
533         if (score > oldbest) {
534                 lseek(rawscores, ((off_t)uid)*sizeof(short), 0);
535                 write(rawscores, &score, sizeof(short));
536                 printf("You bettered your previous best of $%d\n", oldbest);
537         } else
538                 printf("Your best to date is $%d\n", oldbest);
539
540         /* See if we have a new champ */
541         p = getpwuid(allbwho);
542         if (score > allbscore) {
543                 lseek(rawscores, 0, SEEK_SET);
544                 write(rawscores, &score, sizeof(short));
545                 write(rawscores, &uid, sizeof(short));
546                 if (allbwho) {
547                         if (p)
548                                 printf("You beat %s's old record of $%d!\n",
549                             p->pw_name, allbscore);
550                 else
551                                 printf("You beat (%d)'s old record of $%d!\n",
552                                        (int)allbwho, allbscore);
553                 }
554                 else
555                         printf("You set a new record!\n");
556         } else if (p)
557                 printf("The highest is %s with $%d\n", p->pw_name, allbscore);
558         else
559                 printf("The highest is (%d) with $%d\n", (int)allbwho,
560                     allbscore);
561         lseek(rawscores, 0, SEEK_SET);
562         return (1);
563 }
564
565 /*
566  * Flush typeahead to keep from buffering a bunch of chars and then
567  * overshooting.  This loses horribly at 9600 baud, but works nicely
568  * if the terminal gets behind.
569  */
570 void
571 flushi(void)
572 {
573         tcflush(0, TCIFLUSH);
574 }
575 int mx [8] = {
576         0, 1, 1, 1, 0,-1,-1,-1};
577 int my [8] = {
578         -1,-1, 0, 1, 1, 1, 0,-1};
579 float absv[8]= {
580         1, 1.4, 1, 1.4, 1, 1.4, 1, 1.4
581 };
582 int oldw=0;
583
584 void
585 chase(struct point *np, struct point *sp)
586 {
587         /* this algorithm has bugs; otherwise the
588            snake would get too good */
589         struct point d;
590         int w, i, wt[8];
591         double v1, v2, vp, max;
592         point(&d,you.col-sp->col,you.line-sp->line);
593         v1 = sqrt( (double) (d.col*d.col + d.line*d.line) );
594         w=0;
595         max=0;
596         for(i=0; i<8; i++)
597         {
598                 vp = d.col*mx[i] + d.line*my[i];
599                 v2 = absv[i];
600                 if (v1>0)
601                         vp = ((double)vp)/(v1*v2);
602                 else vp=1.0;
603                 if (vp>max)
604                 {
605                         max=vp;
606                         w=i;
607                 }
608         }
609         for(i=0; i<8; i++)
610         {
611                 point(&d,sp->col+mx[i],sp->line+my[i]);
612                 wt[i]=0;
613                 if (d.col<0 || d.col>=ccnt || d.line<0 || d.line>=lcnt)
614                         continue;
615                 /*
616                  * Change to allow snake to eat you if you're on the money,
617                  * otherwise, you can just crouch there until the snake goes
618                  * away.  Not positive it's right.
619                  *
620                  * if (d.line == 0 && d.col < 5) continue;
621                  */
622                 if (same(&d,&money)) continue;
623                 if (same(&d,&finish)) continue;
624                 wt[i]= i==w ? loot/10 : 1;
625                 if (i==oldw) wt [i] += loot/20;
626         }
627         for(w=i=0; i<8; i++)
628                 w+= wt[i];
629         vp = ((random() >> 6) & 01777) % w;
630         for(i=0; i<8; i++)
631                 if (vp <wt[i])
632                         break;
633                 else
634                         vp -= wt[i];
635         if (i==8) {
636                 printw("failure\n");
637                 i=0;
638                 while (wt[i]==0) i++;
639         }
640         oldw=w=i;
641         point(np,sp->col+mx[w],sp->line+my[w]);
642 }
643
644 void
645 spacewarp(int w)
646 {
647         struct point p;
648         int j;
649         const char   *str;
650
651         snrand(&you);
652         point(&p, COLS / 2 - 8, LINES / 2 - 1);
653         if (p.col < 0)
654                 p.col = 0;
655         if (p.line < 0)
656                 p.line = 0;
657         if (w) {
658                 str = "BONUS!!!";
659                 loot = loot - penalty;
660                 penalty = 0;
661         } else {
662                 str = "SPACE WARP!!!";
663                 penalty += loot/PENALTY;
664         }
665         for(j=0;j<3;j++){
666                 erase();
667                 refresh();
668                 delay(5);
669                 mvaddstr(p.line + 1, p.col + 1, str);
670                 refresh();
671                 delay(10);
672         }
673         setup();
674         winnings(cashvalue);
675 }
676
677 void
678 snap(void)
679 {
680         if (!stretch(&money))
681                 if (!stretch(&finish)) {
682                         pchar(&you, '?');
683                         refresh();
684                         delay(10);
685                         pchar(&you, ME);
686                 }
687         refresh();
688 }
689
690 int
691 stretch(const struct point *ps)
692 {
693         struct point p;
694
695         point(&p,you.col,you.line);
696         if ((abs(ps->col - you.col) < (ccnt / 12)) && (you.line != ps->line)) {
697                 if(you.line < ps->line){
698                         for (p.line = you.line+1;p.line <= ps->line;p.line++)
699                                 pchar(&p,'v');
700                         refresh();
701                         delay(10);
702                         for (;p.line > you.line;p.line--)
703                                 chk(&p);
704                 } else {
705                         for (p.line = you.line-1;p.line >= ps->line;p.line--)
706                                 pchar(&p,'^');
707                         refresh();
708                         delay(10);
709                         for (;p.line < you.line;p.line++)
710                                 chk(&p);
711                 }
712                 return(1);
713         } else
714                 if ((abs(ps->line - you.line) < (lcnt/7))
715                     && (you.col != ps->col)) {
716                 p.line = you.line;
717                 if(you.col < ps->col){
718                         for (p.col = you.col+1;p.col <= ps->col;p.col++)
719                                 pchar(&p,'>');
720                         refresh();
721                         delay(10);
722                         for (;p.col > you.col;p.col--)
723                                 chk(&p);
724                 } else {
725                         for (p.col = you.col-1;p.col >= ps->col;p.col--)
726                                 pchar(&p,'<');
727                         refresh();
728                         delay(10);
729                         for (;p.col < you.col;p.col++)
730                                 chk(&p);
731                 }
732                 return(1);
733         }
734         return(0);
735 }
736
737 void
738 surround(struct point *ps)
739 {
740         int j;
741
742         if(ps->col == 0)ps->col++;
743         if(ps->line == 0)ps->line++;
744         if(ps->line == LINES -1)ps->line--;
745         if(ps->col == COLS -1)ps->col--;
746         mvaddstr(ps->line, ps->col, "/*\\");
747         mvaddstr(ps->line + 1, ps->col, "* *");
748         mvaddstr(ps->line + 2, ps->col, "\\*/");
749         for (j=0;j<20;j++){
750                 pchar(ps,'@');
751                 refresh();
752                 delay(1);
753                 pchar(ps,' ');
754                 refresh();
755                 delay(1);
756         }
757         if (post(cashvalue,0)) {
758                 mvaddstr(ps->line, ps->col, "   ");
759                 mvaddstr(ps->line + 1, ps->col, "o.o");
760                 mvaddstr(ps->line + 2, ps->col, "\\_/");
761                 refresh();
762                 delay(6);
763                 mvaddstr(ps->line, ps->col, "   ");
764                 mvaddstr(ps->line + 1, ps->col, "o.-");
765                 mvaddstr(ps->line + 2, ps->col, "\\_/");
766                 refresh();
767                 delay(6);
768         }
769         mvaddstr(ps->line, ps->col, "   ");
770         mvaddstr(ps->line + 1, ps->col, "o.o");
771         mvaddstr(ps->line + 2, ps->col, "\\_/");
772         refresh();
773         delay(6);
774 }
775
776 void
777 win(const struct point *ps)
778 {
779         struct point x;
780         int j,k;
781         int boxsize;    /* actually diameter of box, not radius */
782
783         boxsize = fast ? 10 : 4;
784         point(&x,ps->col,ps->line);
785         for(j=1;j<boxsize;j++){
786                 for(k=0;k<j;k++){
787                         pchar(&x,'#');
788                         x.line--;
789                 }
790                 for(k=0;k<j;k++){
791                         pchar(&x,'#');
792                         x.col++;
793                 }
794                 j++;
795                 for(k=0;k<j;k++){
796                         pchar(&x,'#');
797                         x.line++;
798                 }
799                 for(k=0;k<j;k++){
800                         pchar(&x,'#');
801                         x.col--;
802                 }
803                 refresh();
804                 delay(1);
805         }
806 }
807
808 int
809 pushsnake(void)
810 {
811         int i, bonus;
812         int issame = 0;
813         struct point tmp;
814
815         /*
816          * My manual says times doesn't return a value.  Furthermore, the
817          * snake should get his turn every time no matter if the user is
818          * on a fast terminal with typematic keys or not.
819          * So I have taken the call to times out.
820          */
821         for(i=4; i>=0; i--)
822                 if (same(&snake[i], &snake[5]))
823                         issame++;
824         if (!issame)
825                 pchar(&snake[5],' ');
826         /* Need the following to catch you if you step on the snake's tail */
827         tmp.col = snake[5].col;
828         tmp.line = snake[5].line;
829         for(i=4; i>=0; i--)
830                 snake[i+1]= snake[i];
831         chase(&snake[0], &snake[1]);
832         pchar(&snake[1],SNAKETAIL);
833         pchar(&snake[0],SNAKEHEAD);
834         for(i=0; i<6; i++)
835         {
836                 if (same(&snake[i],&you) || same(&tmp, &you))
837                 {
838                         surround(&you);
839                         i = (cashvalue) % 10;
840                         bonus = ((random() >> 8) & 0377) % 10;
841                         mvprintw(lcnt + 1, 0, "%d\n", bonus);
842                         refresh();
843                         delay(30);
844                         if (bonus == i) {
845                                 spacewarp(1);
846                                 logit("bonus");
847                                 flushi();
848                                 return(1);
849                         }
850                         flushi();
851                         endwin();
852                         if ( loot >= penalty ){
853                                 printf("\nYou and your $%d have been eaten\n",
854                                     cashvalue);
855                         } else {
856                                 printf("\nThe snake ate you.  You owe $%d.\n",
857                                     -cashvalue);
858                         }
859                         logit("eaten");
860                         length(moves);
861                         exit(0);
862                 }
863         }
864         return(0);
865 }
866
867 int
868 chk(const struct point *sp)
869 {
870         int j;
871
872         if (same(sp,&money)) {
873                 pchar(sp,TREASURE);
874                 return(2);
875         }
876         if (same(sp,&finish)) {
877                 pchar(sp,GOAL);
878                 return(3);
879         }
880         if (same(sp,&snake[0])) {
881                 pchar(sp,SNAKEHEAD);
882                 return(4);
883         }
884         for(j=1;j<6;j++){
885                 if(same(sp,&snake[j])){
886                         pchar(sp,SNAKETAIL);
887                         return(4);
888                 }
889         }
890         if ((sp->col < 4) && (sp->line == 0)){
891                 winnings(cashvalue);
892                 if((you.line == 0) && (you.col < 4)) pchar(&you,ME);
893                 return(5);
894         }
895         if (same(sp,&you)) {
896                 pchar(sp,ME);
897                 return(1);
898         }
899         pchar(sp,' ');
900         return(0);
901 }
902
903 void
904 winnings(int won)
905 {
906         if (won > 0) {
907                 mvprintw(1, 1, "$%d", won);
908         }
909 }
910
911 void
912 stop(__unused int dummy)
913 {
914         signal(SIGINT,SIG_IGN);
915         endwin();
916         length(moves);
917         exit(0);
918 }
919
920 void
921 suspend(void)
922 {
923         endwin();
924         kill(getpid(), SIGTSTP);
925         refresh();
926         winnings(cashvalue);
927 }
928
929 void
930 length(int num)
931 {
932         printf("You made %d moves.\n", num);
933 }
934
935 void
936 logit(const char *msg)
937 {
938         time_t t;
939
940         if (logfile != NULL) {
941                 time(&t);
942                 fprintf(logfile, "%s $%d %dx%d %s %s",
943                     getlogin(), cashvalue, lcnt, ccnt, msg, ctime(&t));
944                 fflush(logfile);
945         }
946 }