source: mainline/uspace/app/tetris/screen.c@ 3061bc1

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 3061bc1 was a53ed3a, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 8 years ago

Change (rc != 0) to (rc != EOK), where appropriate.
  • Property mode set to 100644
File size: 8.0 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 suseconds_t timeleft = 0;
78
79console_ctrl_t *console;
80
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 errno_t 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 fprintf(stderr, "aborting: %s", why);
200 abort();
201}
202
203/*
204 * Update the screen.
205 */
206void 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 */
322void 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 */
340void tsleep(void)
341{
342 suseconds_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 */
355int 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 */
394int 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 */
Note: See TracBrowser for help on using the repository browser.