uspace/app/tetris/screen.c

   1 /*
   2  * Copyright (c) 2011 Martin Decky
   3  * 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  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** Attributations
  30  *
  31  * screen.c 8.1 (Berkeley) 5/31/93
  32  * NetBSD: screen.c,v 1.4 1995/04/29 01:11:36 mycroft
  33  * OpenBSD: screen.c,v 1.13 2006/04/20 03:25:36 ray
  34  *
  35  * Based upon BSD Tetris
  36  *
  37  * Copyright (c) 1992, 1993
  38  *      The Regents of the University of California.
  39  *      Distributed under BSD license.
  40  *
  41  * This code is derived from software contributed to Berkeley by
  42  * Chris Torek and Darren F. Provine.
  43  *
  44  */
  45
  46 /** @addtogroup tetris
  47  * @{
  48  */
  49 /** @file
  50  */
  51
  52 /*
  53  * Tetris screen control.
  54  */
  55
  56 #include <stdio.h>
  57 #include <stdlib.h>
  58 #include <str.h>
  59 #include <vfs/vfs.h>
  60 #include <async.h>
  61 #include <stdbool.h>
  62 #include <io/console.h>
  63 #include <io/style.h>
  64 #include "screen.h"
  65 #include "tetris.h"
  66
  67 #define STOP  (B_COLS - 3)
  68
  69 static cell curscreen[B_SIZE];  /* non-zero => standout (or otherwise marked) */
  70 static int curscore;
  71 static int isset;               /* true => terminal is in game mode */
  72
  73 static bool use_color;          /* true => use colors */
  74
  75 static const struct shape *lastshape;
  76
  77 static usec_t timeleft = 0;
  78
  79 console_ctrl_t *console;
  80
  81
  82 /*
  83  * putstr() is for unpadded strings (either as in termcap(5) or
  84  * simply literal strings);
  85  */
  86 static inline void putstr(const char *s)
  87 {
  88         while (*s)
  89                 putchar(*(s++));
  90 }
  91
  92 static void start_standout(uint32_t color)
  93 {
  94         console_flush(console);
  95         console_set_rgb_color(console, use_color ? color : 0x000000,
  96             0xffffff);
  97 }
  98
  99 static void resume_normal(void)
 100 {
 101         console_flush(console);
 102         console_set_style(console, STYLE_NORMAL);
 103 }
 104
 105 void clear_screen(void)
 106 {
 107         console_clear(console);
 108         moveto(0, 0);
 109 }
 110
 111 /*
 112  * Clear the screen, forgetting the current contents in the process.
 113  */
 114 void scr_clear(void)
 115 {
 116         resume_normal();
 117         console_clear(console);
 118         curscore = -1;
 119         memset(curscreen, 0, sizeof(curscreen));
 120 }
 121
 122 /*
 123  * Set up screen
 124  */
 125 void scr_init(void)
 126 {
 127         console_cursor_visibility(console, 0);
 128         resume_normal();
 129         scr_clear();
 130 }
 131
 132 void moveto(sysarg_t r, sysarg_t c)
 133 {
 134         console_flush(console);
 135         console_set_pos(console, c, r);
 136 }
 137
 138 winsize_t winsize;
 139
 140 static errno_t get_display_size(winsize_t *ws)
 141 {
 142         return console_get_size(console, &ws->ws_col, &ws->ws_row);
 143 }
 144
 145 static bool get_display_color_sup(void)
 146 {
 147         sysarg_t ccap;
 148         errno_t rc = console_get_color_cap(console, &ccap);
 149
 150         if (rc != EOK)
 151                 return false;
 152
 153         return ((ccap & CONSOLE_CAP_RGB) == CONSOLE_CAP_RGB);
 154 }
 155
 156 /*
 157  * Set up screen mode.
 158  */
 159 void scr_set(void)
 160 {
 161         winsize_t ws;
 162
 163         Rows = 0;
 164         Cols = 0;
 165
 166         if (get_display_size(&ws) == 0) {
 167                 Rows = ws.ws_row;
 168                 Cols = ws.ws_col;
 169         }
 170
 171         use_color = get_display_color_sup();
 172
 173         if ((Rows < MINROWS) || (Cols < MINCOLS)) {
 174                 char smallscr[55];
 175
 176                 snprintf(smallscr, sizeof(smallscr),
 177                     "the screen is too small (must be at least %dx%d)",
 178                     MINROWS, MINCOLS);
 179                 stop(smallscr);
 180         }
 181         isset = 1;
 182
 183         scr_clear();
 184 }
 185
 186 /*
 187  * End screen mode.
 188  */
 189 void scr_end(void)
 190 {
 191         console_cursor_visibility(console, 1);
 192 }
 193
 194 void stop(const char *why)
 195 {
 196         if (isset)
 197                 scr_end();
 198
 199         fprintf(stderr, "aborting: %s", why);
 200         abort();
 201 }
 202
 203 /*
 204  * Update the screen.
 205  */
 206 void scr_update(void)
 207 {
 208         cell *bp;
 209         cell *sp;
 210         cell so;
 211         cell cur_so = 0;
 212         int i;
 213         int j;
 214         int ccol;
 215
 216         /* Always leave cursor after last displayed point */
 217         curscreen[D_LAST * B_COLS - 1] = -1;
 218
 219         if (score != curscore) {
 220                 moveto(0, 0);
 221                 printf("Score: %d", score);
 222                 curscore = score;
 223         }
 224
 225         /* Draw preview of next pattern */
 226         if ((showpreview) && (nextshape != lastshape)) {
 227                 int i;
 228                 static int r = 5, c = 2;
 229                 int tr, tc, t;
 230
 231                 lastshape = nextshape;
 232
 233                 /* Clean */
 234                 resume_normal();
 235                 moveto(r - 1, c - 1);
 236                 putstr("          ");
 237                 moveto(r, c - 1);
 238                 putstr("          ");
 239                 moveto(r + 1, c - 1);
 240                 putstr("          ");
 241                 moveto(r + 2, c - 1);
 242                 putstr("          ");
 243
 244                 moveto(r - 3, c - 2);
 245                 putstr("Next shape:");
 246
 247                 /* Draw */
 248                 start_standout(nextshape->color);
 249                 moveto(r, 2 * c);
 250                 putstr("  ");
 251                 for (i = 0; i < 3; i++) {
 252                         t = c + r * B_COLS;
 253                         t += nextshape->off[i];
 254
 255                         tr = t / B_COLS;
 256                         tc = t % B_COLS;
 257
 258                         moveto(tr, 2 * tc);
 259                         putstr("  ");
 260                 }
 261                 resume_normal();
 262         }
 263
 264         bp = &board[D_FIRST * B_COLS];
 265         sp = &curscreen[D_FIRST * B_COLS];
 266         for (j = D_FIRST; j < D_LAST; j++) {
 267                 ccol = -1;
 268                 for (i = 0; i < B_COLS; bp++, sp++, i++) {
 269                         if (*sp == (so = *bp))
 270                                 continue;
 271
 272                         *sp = so;
 273                         if (i != ccol) {
 274                                 if (cur_so) {
 275                                         resume_normal();
 276                                         cur_so = 0;
 277                                 }
 278                                 moveto(RTOD(j), CTOD(i));
 279                         }
 280
 281                         if (so != cur_so) {
 282                                 if (so)
 283                                         start_standout(so);
 284                                 else
 285                                         resume_normal();
 286                                 cur_so = so;
 287                         }
 288                         putstr("  ");
 289
 290                         ccol = i + 1;
 291                         /*
 292                          * Look ahead a bit, to avoid extra motion if
 293                          * we will be redrawing the cell after the next.
 294                          * Motion probably takes four or more characters,
 295                          * so we save even if we rewrite two cells
 296                          * `unnecessarily'.  Skip it all, though, if
 297                          * the next cell is a different color.
 298                          */
 299
 300                         if ((i > STOP) || (sp[1] != bp[1]) || (so != bp[1]))
 301                                 continue;
 302
 303                         if (sp[2] != bp[2])
 304                                 sp[1] = -1;
 305                         else if ((i < STOP) && (so == bp[2]) && (sp[3] != bp[3])) {
 306                                 sp[2] = -1;
 307                                 sp[1] = -1;
 308                         }
 309                 }
 310         }
 311
 312         if (cur_so)
 313                 resume_normal();
 314
 315         console_flush(console);
 316 }
 317
 318 /*
 319  * Write a message (set != 0), or clear the same message (set == 0).
 320  * (We need its length in case we have to overwrite with blanks.)
 321  */
 322 void scr_msg(char *s, bool set)
 323 {
 324         int l = str_size(s);
 325
 326         moveto(Rows - 2, ((Cols - l) >> 1) - 1);
 327
 328         if (set)
 329                 putstr(s);
 330         else
 331                 while (--l >= 0)
 332                         (void) putchar(' ');
 333 }
 334
 335 /** Sleep for the current turn time
 336  *
 337  * Eat any input that might be available.
 338  *
 339  */
 340 void tsleep(void)
 341 {
 342         usec_t timeout = fallrate;
 343
 344         while (timeout > 0) {
 345                 cons_event_t event;
 346
 347                 if (!console_get_event_timeout(console, &event, &timeout))
 348                         break;
 349         }
 350 }
 351
 352 /** Get char with timeout
 353  *
 354  */
 355 int tgetchar(void)
 356 {
 357         /*
 358          * Reset timeleft to fallrate whenever it is not positive
 359          * and increase speed.
 360          */
 361
 362         if (timeleft <= 0) {
 363                 faster();
 364                 timeleft = fallrate;
 365         }
 366
 367         /*
 368          * Wait to see if there is any input. If so, take it and
 369          * update timeleft so that the next call to tgetchar()
 370          * will not wait as long. If there is no input,
 371          * make timeleft zero and return -1.
 372          */
 373
 374         wchar_t c = 0;
 375
 376         while (c == 0) {
 377                 cons_event_t event;
 378
 379                 if (!console_get_event_timeout(console, &event, &timeleft)) {
 380                         timeleft = 0;
 381                         return -1;
 382                 }
 383
 384                 if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
 385                         c = event.ev.key.c;
 386         }
 387
 388         return (int) c;
 389 }
 390
 391 /** Get char without timeout
 392  *
 393  */
 394 int twait(void)
 395 {
 396         wchar_t c = 0;
 397
 398         while (c == 0) {
 399                 cons_event_t event;
 400
 401                 if (!console_get_event(console, &event))
 402                         return -1;
 403
 404                 if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
 405                         c = event.ev.key.c;
 406         }
 407
 408         return (int) c;
 409 }
 410
 411 /** @}
 412  */