tetris/input.c

   1 /*-
   2  * Copyright (c) 1992, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Chris Torek and Darren F. Provine.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  *      @(#)input.c     8.1 (Berkeley) 5/31/93
  37  */
  38
  39 /*
  40  * Tetris input.
  41  */
  42
  43 #include <sys/types.h>
  44 #include <sys/time.h>
  45
  46 #include <errno.h>
  47 #include <unistd.h>
  48
  49 #include "input.h"
  50 #include "tetris.h"
  51
  52 /* return true iff the given timeval is positive */
  53 #define TV_POS(tv) \
  54         ((tv)->tv_sec > 0 || ((tv)->tv_sec == 0 && (tv)->tv_usec > 0))
  55
  56 /* subtract timeval `sub' from `res' */
  57 #define TV_SUB(res, sub) \
  58         (res)->tv_sec -= (sub)->tv_sec; \
  59         (res)->tv_usec -= (sub)->tv_usec; \
  60         if ((res)->tv_usec < 0) { \
  61                 (res)->tv_usec += 1000000; \
  62                 (res)->tv_sec--; \
  63         }
  64
  65 /*
  66  * Do a `read wait': select for reading from stdin, with timeout *tvp.
  67  * On return, modify *tvp to reflect the amount of time spent waiting.
  68  * It will be positive only if input appeared before the time ran out;
  69  * otherwise it will be zero or perhaps negative.
  70  *
  71  * If tvp is nil, wait forever, but return if select is interrupted.
  72  *
  73  * Return 0 => no input, 1 => can read() from stdin
  74  */
  75 int
  76 rwait(tvp)
  77         register struct timeval *tvp;
  78 {
  79         int i;
  80         struct timeval starttv, endtv, *s;
  81         extern int errno;
  82 #define NILTZ ((struct timezone *)0)
  83
  84         /*
  85          * Someday, select() will do this for us.
  86          * Just in case that day is now, and no one has
  87          * changed this, we use a temporary.
  88          */
  89         if (tvp) {
  90                 (void) gettimeofday(&starttv, NILTZ);
  91                 endtv = *tvp;
  92                 s = &endtv;
  93         } else
  94                 s = 0;
  95 again:
  96         i = 1;
  97         switch (select(1, (fd_set *)&i, (fd_set *)0, (fd_set *)0, s)) {
  98
  99         case -1:
 100                 if (tvp == 0)
 101                         return (-1);
 102                 if (errno == EINTR)
 103                         goto again;
 104                 stop("select failed, help");
 105                 /* NOTREACHED */
 106
 107         case 0: /* timed out */
 108                 tvp->tv_sec = 0;
 109                 tvp->tv_usec = 0;
 110                 return (0);
 111         }
 112         if (tvp) {
 113                 /* since there is input, we may not have timed out */
 114                 (void) gettimeofday(&endtv, NILTZ);
 115                 TV_SUB(&endtv, &starttv);
 116                 TV_SUB(tvp, &endtv);    /* adjust *tvp by elapsed time */
 117         }
 118         return (1);
 119 }
 120
 121 /*
 122  * `sleep' for the current turn time (using select).
 123  * Eat any input that might be available.
 124  */
 125 void
 126 tsleep()
 127 {
 128         struct timeval tv;
 129         char c;
 130
 131         tv.tv_sec = 0;
 132         tv.tv_usec = fallrate;
 133         while (TV_POS(&tv))
 134                 if (rwait(&tv) && read(0, &c, 1) != 1)
 135                         break;
 136 }
 137
 138 /*
 139  * Eat up any input (used at end of game).
 140  */
 141 void
 142 eat_input()
 143 {
 144         struct timeval tv;
 145         char c;
 146
 147         do {
 148                 tv.tv_sec = tv.tv_usec = 0;
 149         } while (rwait(&tv) && read(0, &c, 1) == 1);
 150 }
 151
 152 /*
 153  * getchar with timeout.
 154  */
 155 int
 156 tgetchar()
 157 {
 158         static struct timeval timeleft;
 159         char c;
 160
 161         /*
 162          * Reset timeleft to fallrate whenever it is not positive.
 163          * In any case, wait to see if there is any input.  If so,
 164          * take it, and update timeleft so that the next call to
 165          * tgetchar() will not wait as long.  If there is no input,
 166          * make timeleft zero or negative, and return -1.
 167          *
 168          * Most of the hard work is done by rwait().
 169          */
 170         if (!TV_POS(&timeleft)) {
 171                 faster();       /* go faster */
 172                 timeleft.tv_sec = 0;
 173                 timeleft.tv_usec = fallrate;
 174         }
 175         if (!rwait(&timeleft))
 176                 return (-1);
 177         if (read(0, &c, 1) != 1)
 178                 stop("end of file, help");
 179         return ((int)(unsigned char)c);
 180 }