source: mainline/uspace/app/tetris/screen.c@ 01900b6

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 01900b6 was 09ab0a9a, checked in by Jiri Svoboda <jiri@…>, 7 years ago

Fix vertical spacing with new Ccheck revision.
  • Property mode set to 100644
File size: 7.9 KB
Line 
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
69static cell curscreen[B_SIZE]; /* non-zero => standout (or otherwise marked) */
70static int curscore;
71static int isset; /* true => terminal is in game mode */
72
73static bool use_color; /* true => use colors */
74
75static const struct shape *lastshape;
76
77static usec_t timeleft = 0;
78
79console_ctrl_t *console;
80
81/*
82 * putstr() is for unpadded strings (either as in termcap(5) or
83 * simply literal strings);
84 */
85static inline void putstr(const char *s)
86{
87 while (*s)
88 putchar(*(s++));
89}
90
91static void start_standout(uint32_t color)
92{
93 console_flush(console);
94 console_set_rgb_color(console, use_color ? color : 0x000000,
95 0xffffff);
96}
97
98static void resume_normal(void)
99{
100 console_flush(console);
101 console_set_style(console, STYLE_NORMAL);
102}
103
104void clear_screen(void)
105{
106 console_clear(console);
107 moveto(0, 0);
108}
109
110/*
111 * Clear the screen, forgetting the current contents in the process.
112 */
113void scr_clear(void)
114{
115 resume_normal();
116 console_clear(console);
117 curscore = -1;
118 memset(curscreen, 0, sizeof(curscreen));
119}
120
121/*
122 * Set up screen
123 */
124void scr_init(void)
125{
126 console_cursor_visibility(console, 0);
127 resume_normal();
128 scr_clear();
129}
130
131void moveto(sysarg_t r, sysarg_t c)
132{
133 console_flush(console);
134 console_set_pos(console, c, r);
135}
136
137winsize_t winsize;
138
139static errno_t get_display_size(winsize_t *ws)
140{
141 return console_get_size(console, &ws->ws_col, &ws->ws_row);
142}
143
144static bool get_display_color_sup(void)
145{
146 sysarg_t ccap;
147 errno_t rc = console_get_color_cap(console, &ccap);
148
149 if (rc != EOK)
150 return false;
151
152 return ((ccap & CONSOLE_CAP_RGB) == CONSOLE_CAP_RGB);
153}
154
155/*
156 * Set up screen mode.
157 */
158void scr_set(void)
159{
160 winsize_t ws;
161
162 Rows = 0;
163 Cols = 0;
164
165 if (get_display_size(&ws) == 0) {
166 Rows = ws.ws_row;
167 Cols = ws.ws_col;
168 }
169
170 use_color = get_display_color_sup();
171
172 if ((Rows < MINROWS) || (Cols < MINCOLS)) {
173 char smallscr[55];
174
175 snprintf(smallscr, sizeof(smallscr),
176 "the screen is too small (must be at least %dx%d)",
177 MINROWS, MINCOLS);
178 stop(smallscr);
179 }
180 isset = 1;
181
182 scr_clear();
183}
184
185/*
186 * End screen mode.
187 */
188void scr_end(void)
189{
190 console_cursor_visibility(console, 1);
191}
192
193void stop(const char *why)
194{
195 if (isset)
196 scr_end();
197
198 fprintf(stderr, "aborting: %s", why);
199 abort();
200}
201
202/*
203 * Update the screen.
204 */
205void scr_update(void)
206{
207 cell *bp;
208 cell *sp;
209 cell so;
210 cell cur_so = 0;
211 int i;
212 int j;
213 int ccol;
214
215 /* Always leave cursor after last displayed point */
216 curscreen[D_LAST * B_COLS - 1] = -1;
217
218 if (score != curscore) {
219 moveto(0, 0);
220 printf("Score: %d", score);
221 curscore = score;
222 }
223
224 /* Draw preview of next pattern */
225 if ((showpreview) && (nextshape != lastshape)) {
226 int i;
227 static int r = 5, c = 2;
228 int tr, tc, t;
229
230 lastshape = nextshape;
231
232 /* Clean */
233 resume_normal();
234 moveto(r - 1, c - 1);
235 putstr(" ");
236 moveto(r, c - 1);
237 putstr(" ");
238 moveto(r + 1, c - 1);
239 putstr(" ");
240 moveto(r + 2, c - 1);
241 putstr(" ");
242
243 moveto(r - 3, c - 2);
244 putstr("Next shape:");
245
246 /* Draw */
247 start_standout(nextshape->color);
248 moveto(r, 2 * c);
249 putstr(" ");
250 for (i = 0; i < 3; i++) {
251 t = c + r * B_COLS;
252 t += nextshape->off[i];
253
254 tr = t / B_COLS;
255 tc = t % B_COLS;
256
257 moveto(tr, 2 * tc);
258 putstr(" ");
259 }
260 resume_normal();
261 }
262
263 bp = &board[D_FIRST * B_COLS];
264 sp = &curscreen[D_FIRST * B_COLS];
265 for (j = D_FIRST; j < D_LAST; j++) {
266 ccol = -1;
267 for (i = 0; i < B_COLS; bp++, sp++, i++) {
268 if (*sp == (so = *bp))
269 continue;
270
271 *sp = so;
272 if (i != ccol) {
273 if (cur_so) {
274 resume_normal();
275 cur_so = 0;
276 }
277 moveto(RTOD(j), CTOD(i));
278 }
279
280 if (so != cur_so) {
281 if (so)
282 start_standout(so);
283 else
284 resume_normal();
285 cur_so = so;
286 }
287 putstr(" ");
288
289 ccol = i + 1;
290 /*
291 * Look ahead a bit, to avoid extra motion if
292 * we will be redrawing the cell after the next.
293 * Motion probably takes four or more characters,
294 * so we save even if we rewrite two cells
295 * `unnecessarily'. Skip it all, though, if
296 * the next cell is a different color.
297 */
298
299 if ((i > STOP) || (sp[1] != bp[1]) || (so != bp[1]))
300 continue;
301
302 if (sp[2] != bp[2])
303 sp[1] = -1;
304 else if ((i < STOP) && (so == bp[2]) && (sp[3] != bp[3])) {
305 sp[2] = -1;
306 sp[1] = -1;
307 }
308 }
309 }
310
311 if (cur_so)
312 resume_normal();
313
314 console_flush(console);
315}
316
317/*
318 * Write a message (set != 0), or clear the same message (set == 0).
319 * (We need its length in case we have to overwrite with blanks.)
320 */
321void scr_msg(char *s, bool set)
322{
323 int l = str_size(s);
324
325 moveto(Rows - 2, ((Cols - l) >> 1) - 1);
326
327 if (set)
328 putstr(s);
329 else
330 while (--l >= 0)
331 (void) putchar(' ');
332}
333
334/** Sleep for the current turn time
335 *
336 * Eat any input that might be available.
337 *
338 */
339void tsleep(void)
340{
341 usec_t timeout = fallrate;
342
343 while (timeout > 0) {
344 cons_event_t event;
345
346 if (!console_get_event_timeout(console, &event, &timeout))
347 break;
348 }
349}
350
351/** Get char with timeout
352 *
353 */
354int tgetchar(void)
355{
356 /*
357 * Reset timeleft to fallrate whenever it is not positive
358 * and increase speed.
359 */
360
361 if (timeleft <= 0) {
362 faster();
363 timeleft = fallrate;
364 }
365
366 /*
367 * Wait to see if there is any input. If so, take it and
368 * update timeleft so that the next call to tgetchar()
369 * will not wait as long. If there is no input,
370 * make timeleft zero and return -1.
371 */
372
373 wchar_t c = 0;
374
375 while (c == 0) {
376 cons_event_t event;
377
378 if (!console_get_event_timeout(console, &event, &timeleft)) {
379 timeleft = 0;
380 return -1;
381 }
382
383 if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
384 c = event.ev.key.c;
385 }
386
387 return (int) c;
388}
389
390/** Get char without timeout
391 *
392 */
393int twait(void)
394{
395 wchar_t c = 0;
396
397 while (c == 0) {
398 cons_event_t event;
399
400 if (!console_get_event(console, &event))
401 return -1;
402
403 if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
404 c = event.ev.key.c;
405 }
406
407 return (int) c;
408}
409
410/** @}
411 */
Note: See TracBrowser for help on using the repository browser.