source: mainline/uspace/app/tetris/screen.c@ 08e103d4

Last change on this file since 08e103d4 was 08e103d4, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 7 years ago

Use clearer naming for string length functions

This and the following commit change the names of functions, as well as
their documentation, to use unambiguous terms "bytes" and "code points"
instead of ambiguous terms "size", "length", and "characters".
  • 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_bytes(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.