source: mainline/uspace/dist/src/c/demos/tetris/screen.c

Last change on this file was 28a5ebd, checked in by Martin Decky <martin@…>, 5 years ago

Use char32_t instead of wchat_t to represent UTF-32 strings

The intention of the native HelenOS string API has been always to
support Unicode in the UTF-8 and UTF-32 encodings as the sole character
representations and ignore the obsolete mess of older single-byte and
multibyte character encodings. Before C11, the wchar_t type has been
slightly misused for the purpose of the UTF-32 strings. The newer
char32_t type is obviously a much more suitable option. The standard
defines char32_t as uint_least32_t, thus we can take the liberty to fix
it to uint32_t.

To maintain compatilibity with the C Standard, the putwchar(wchar_t)
functions has been replaced by our custom putuchar(char32_t) functions
where appropriate.
  • 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 <err.h>
57#include <stdio.h>
58#include <stdlib.h>
59#include <str.h>
60#include <vfs/vfs.h>
61#include <async.h>
62#include <stdbool.h>
63#include <io/console.h>
64#include <io/style.h>
65#include "screen.h"
66#include "tetris.h"
67
68#define STOP (B_COLS - 3)
69
70static cell curscreen[B_SIZE]; /* non-zero => standout (or otherwise marked) */
71static int curscore;
72static int isset; /* true => terminal is in game mode */
73
74static bool use_color; /* true => use colors */
75
76static const struct shape *lastshape;
77
78static suseconds_t timeleft = 0;
79
80console_ctrl_t *console;
81
82/*
83 * putstr() is for unpadded strings (either as in termcap(5) or
84 * simply literal strings);
85 */
86static inline void putstr(const char *s)
87{
88 while (*s)
89 putchar(*(s++));
90}
91
92static 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
99static void resume_normal(void)
100{
101 console_flush(console);
102 console_set_style(console, STYLE_NORMAL);
103}
104
105void 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 */
114void 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 */
125void scr_init(void)
126{
127 console_cursor_visibility(console, 0);
128 resume_normal();
129 scr_clear();
130}
131
132void moveto(sysarg_t r, sysarg_t c)
133{
134 console_flush(console);
135 console_set_pos(console, c, r);
136}
137
138winsize_t winsize;
139
140static int get_display_size(winsize_t *ws)
141{
142 return console_get_size(console, &ws->ws_col, &ws->ws_row);
143}
144
145static 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 */
159void 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 */
189void scr_end(void)
190{
191 console_cursor_visibility(console, 1);
192}
193
194void stop(const char *why)
195{
196 if (isset)
197 scr_end();
198
199 errx(1, "aborting: %s", why);
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 suseconds_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 */
354errno_t 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 char32_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 */
393errno_t twait(void)
394{
395 char32_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.