Index: uspace/dist/src/c/demos/hello/build =================================================================== --- uspace/dist/src/c/demos/hello/build (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/hello/build (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,4 @@ +cc -E -o hello.i hello.c +cc -S -o hello.s hello.i +as -o hello.o hello.s +ld -T /inc/_link.ld -o hello hello.o /lib/libc.a /lib/libsoftint.a Index: uspace/dist/src/c/demos/hello/clean =================================================================== --- uspace/dist/src/c/demos/hello/clean (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/hello/clean (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,4 @@ +rm hello +rm hello.o +rm hello.s +rm hello.i Index: uspace/dist/src/c/demos/hello/hello.c =================================================================== --- uspace/dist/src/c/demos/hello/hello.c (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/hello/hello.c (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,16 @@ +extern int putchar(char); + +#define TERMINATOR '!' + +int main(void) { + /* Prints "hello" to the standard output. */ + putchar('h'); + putchar('e'); + putchar('l'); + putchar('l'); + putchar('o'); + putchar(TERMINATOR); + putchar('\n'); + return 0; +} + Index: uspace/dist/src/c/demos/tetris/build =================================================================== --- uspace/dist/src/c/demos/tetris/build (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/tetris/build (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,16 @@ +cc -I/inc/c -E -o scores.i scores.c +cc -I/inc/c -E -o screen.i screen.c +cc -I/inc/c -E -o shapes.i shapes.c +cc -I/inc/c -E -o tetris.i tetris.c + +cc -S -o scores.s scores.i +cc -S -o screen.s screen.i +cc -S -o shapes.s shapes.i +cc -S -o tetris.s tetris.i + +as -o scores.o scores.s +as -o screen.o screen.s +as -o shapes.o shapes.s +as -o tetris.o tetris.s + +ld -T /inc/_link.ld -o tetris_ scores.o screen.o shapes.o tetris.o /lib/libc.a /lib/libsoftint.a Index: uspace/dist/src/c/demos/tetris/clean =================================================================== --- uspace/dist/src/c/demos/tetris/clean (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/tetris/clean (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,16 @@ +rm tetris_ + +rm scores.o +rm screen.o +rm shapes.o +rm tetris.o + +rm scores.s +rm screen.s +rm shapes.s +rm tetris.s + +rm scores.i +rm screen.i +rm shapes.i +rm tetris.i Index: uspace/dist/src/c/demos/tetris/scores.c =================================================================== --- uspace/dist/src/c/demos/tetris/scores.c (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/tetris/scores.c (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,240 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** Attributations + * + * scores.c 8.1 (Berkeley) 5/31/93 + * NetBSD: scores.c,v 1.2 1995/04/22 07:42:38 cgd + * OpenBSD: scores.c,v 1.11 2006/04/20 03:25:36 ray + * + * Based upon BSD Tetris + * + * Copyright (c) 1992, 1993 + * The Regents of the University of California. + * Distributed under BSD license. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek and Darren F. Provine. + * + */ + +/** @addtogroup tetris + * @{ + */ +/** @file + */ + +/* + * Score code for Tetris, by Darren Provine (kilroy@gboro.glassboro.edu) + * modified 22 January 1992, to limit the number of entries any one + * person has. + * + * Major whacks since then. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "screen.h" +#include "tetris.h" +#include "scores.h" + +/* + * Within this code, we can hang onto one extra "high score", leaving + * room for our current score (whether or not it is high). + * + * We also sometimes keep tabs on the "highest" score on each level. + * As long as the scores are kept sorted, this is simply the first one at + * that level. + */ + +#define NUMSPOTS (MAXHISCORES + 1) +#define NLEVELS (MAXLEVEL + 1) + +static struct highscore scores[NUMSPOTS]; + +/** Copy from hiscore table score with index src to dest + * + */ +static void copyhiscore(int dest, int src) +{ + str_cpy(scores[dest].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, + scores[src].hs_name); + scores[dest].hs_score = scores[src].hs_score; + scores[dest].hs_level = scores[src].hs_level; +} + +void showscores(int firstgame) +{ + int i; + + clear_screen(); + moveto(10, 0); + printf("\tRank \tLevel \tName\t points\n"); + printf("\t========================================================\n"); + + for (i = 0; i < NUMSPOTS - 1; i++) + printf("\t%6d %6d %-16s %20d\n", + i + 1, scores[i].hs_level, scores[i].hs_name, scores[i].hs_score); + + if (!firstgame) { + printf("\t========================================================\n"); + printf("\t Last %6d %-16s %20d\n", + scores[NUMSPOTS - 1].hs_level, scores[NUMSPOTS - 1].hs_name, scores[NUMSPOTS - 1].hs_score); + } + + printf("\n\n\n\n\tPress any key to return to main menu."); + getchar(); +} + +void insertscore(int score, int level) +{ + int i; + int j; + size_t off; + kbd_event_t ev; + + clear_screen(); + moveto(10, 10); + puts("Insert your name: "); + str_cpy(scores[NUMSPOTS - 1].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, + "Player"); + i = 6; + off = 6; + + moveto(10 , 28); + printf("%s%.*s", scores[NUMSPOTS - 1].hs_name, MAXLOGNAME-i, + "........................................"); + + while (1) { + console_flush(console); + if (!console_get_kbd_event(console, &ev)) + exit(1); + + if (ev.type == KEY_RELEASE) + continue; + + if (ev.key == KC_ENTER || ev.key == KC_NENTER) + break; + + if (ev.key == KC_BACKSPACE) { + if (i > 0) { + wchar_t uc; + + --i; + while (off > 0) { + --off; + size_t otmp = off; + uc = str_decode(scores[NUMSPOTS - 1].hs_name, + &otmp, STR_BOUNDS(MAXLOGNAME) + 1); + if (uc != U_SPECIAL) + break; + } + + scores[NUMSPOTS - 1].hs_name[off] = '\0'; + } + } else if (ev.c != '\0') { + if (i < (MAXLOGNAME - 1)) { + if (chr_encode(ev.c, scores[NUMSPOTS - 1].hs_name, + &off, STR_BOUNDS(MAXLOGNAME) + 1) == EOK) { + ++i; + } + scores[NUMSPOTS - 1].hs_name[off] = '\0'; + } + } + + moveto(10, 28); + printf("%s%.*s", scores[NUMSPOTS - 1].hs_name, MAXLOGNAME - i, + "........................................"); + } + + scores[NUMSPOTS - 1].hs_score = score; + scores[NUMSPOTS - 1].hs_level = level; + + i = NUMSPOTS - 1; + while ((i > 0) && (scores[i - 1].hs_score < score)) + i--; + + for (j = NUMSPOTS - 2; j > i; j--) + copyhiscore(j, j-1); + + copyhiscore(i, NUMSPOTS - 1); +} + +void initscores(void) +{ + int i; + for (i = 0; i < NUMSPOTS; i++) { + str_cpy(scores[i].hs_name, STR_BOUNDS(MAXLOGNAME) + 1, "HelenOS Team"); + scores[i].hs_score = (NUMSPOTS - i) * 200; + scores[i].hs_level = (i + 1 > MAXLEVEL ? MAXLEVEL : i + 1); + } +} + +int loadscores(void) +{ + FILE *f; + size_t cnt; + int rc; + + f = fopen("/data/tetris.sco", "rb"); + if (f == NULL) + return ENOENT; + + cnt = fread(scores, sizeof(struct highscore), NUMSPOTS, f); + rc = fclose(f); + + if (cnt != NUMSPOTS || rc != 0) + return EIO; + + return EOK; +} + +void savescores(void) +{ + FILE *f; + size_t cnt; + int rc; + + f = fopen("/data/tetris.sco", "wb"); + cnt = fwrite(scores, sizeof(struct highscore), NUMSPOTS, f); + rc = fclose(f); + + if (cnt != NUMSPOTS || rc != 0) + printf("Error saving score table\n"); +} + +/** @} + */ Index: uspace/dist/src/c/demos/tetris/scores.h =================================================================== --- uspace/dist/src/c/demos/tetris/scores.h (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/tetris/scores.h (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** Attributations + * + * scores.h 8.1 (Berkeley) 5/31/93 + * NetBSD: scores.h,v 1.2 1995/04/22 07:42:40 cgd + * OpenBSD: scores.h,v 1.5 2003/06/03 03:01:41 millert + * + * Based upon BSD Tetris + * + * Copyright (c) 1992, 1993 + * The Regents of the University of California. + * Distributed under BSD license. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek and Darren F. Provine. + * + */ + +/** @addtogroup tetris + * @{ + */ +/** @file + */ + +/* + * Tetris scores. + */ + +#include +#include + +#define MAXLOGNAME 16 +#define MAXHISCORES 10 +#define MAXSCORES 9 /* maximum high score entries per person */ +#define EXPIRATION (5L * 365 * 24 * 60 * 60) + +struct highscore { + char hs_name[STR_BOUNDS(MAXLOGNAME) + 1]; /* login name */ + int hs_score; /* raw score */ + int hs_level; /* play level */ + time_t hs_time; /* time at game end */ +}; + +extern void showscores(int); +extern void initscores(void); +extern void insertscore(int score, int level); +extern int loadscores(void); +extern void savescores(void); + +/** @} + */ Index: uspace/dist/src/c/demos/tetris/screen.c =================================================================== --- uspace/dist/src/c/demos/tetris/screen.c (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/tetris/screen.c (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,413 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** Attributations + * + * screen.c 8.1 (Berkeley) 5/31/93 + * NetBSD: screen.c,v 1.4 1995/04/29 01:11:36 mycroft + * OpenBSD: screen.c,v 1.13 2006/04/20 03:25:36 ray + * + * Based upon BSD Tetris + * + * Copyright (c) 1992, 1993 + * The Regents of the University of California. + * Distributed under BSD license. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek and Darren F. Provine. + * + */ + +/** @addtogroup tetris + * @{ + */ +/** @file + */ + +/* + * Tetris screen control. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "screen.h" +#include "tetris.h" + +#define STOP (B_COLS - 3) + +static cell curscreen[B_SIZE]; /* non-zero => standout (or otherwise marked) */ +static int curscore; +static int isset; /* true => terminal is in game mode */ + +static bool use_color; /* true => use colors */ + +static const struct shape *lastshape; + +static suseconds_t timeleft = 0; + +console_ctrl_t *console; + + +/* + * putstr() is for unpadded strings (either as in termcap(5) or + * simply literal strings); + */ +static inline void putstr(const char *s) +{ + while (*s) + putchar(*(s++)); +} + +static void start_standout(uint32_t color) +{ + console_flush(console); + console_set_rgb_color(console, 0xffffff, + use_color ? color : 0x000000); +} + +static void resume_normal(void) +{ + console_flush(console); + console_set_style(console, STYLE_NORMAL); +} + +void clear_screen(void) +{ + console_clear(console); + moveto(0, 0); +} + +/* + * Clear the screen, forgetting the current contents in the process. + */ +void scr_clear(void) +{ + resume_normal(); + console_clear(console); + curscore = -1; + memset(curscreen, 0, sizeof(curscreen)); +} + +/* + * Set up screen + */ +void scr_init(void) +{ + console_cursor_visibility(console, 0); + resume_normal(); + scr_clear(); +} + +void moveto(sysarg_t r, sysarg_t c) +{ + console_flush(console); + console_set_pos(console, c, r); +} + +winsize_t winsize; + +static int get_display_size(winsize_t *ws) +{ + return console_get_size(console, &ws->ws_col, &ws->ws_row); +} + +static bool get_display_color_sup(void) +{ + sysarg_t ccap; + int rc = console_get_color_cap(console, &ccap); + + if (rc != 0) + return false; + + return (ccap >= CONSOLE_CCAP_RGB); +} + +/* + * Set up screen mode. + */ +void scr_set(void) +{ + winsize_t ws; + + Rows = 0; + Cols = 0; + + if (get_display_size(&ws) == 0) { + Rows = ws.ws_row; + Cols = ws.ws_col; + } + + use_color = get_display_color_sup(); + + if ((Rows < MINROWS) || (Cols < MINCOLS)) { + char smallscr[55]; + + snprintf(smallscr, sizeof(smallscr), + "the screen is too small (must be at least %dx%d)", + MINROWS, MINCOLS); + stop(smallscr); + } + isset = 1; + + scr_clear(); +} + +/* + * End screen mode. + */ +void scr_end(void) +{ + console_cursor_visibility(console, 1); +} + +void stop(const char *why) +{ + if (isset) + scr_end(); + + errx(1, "aborting: %s", why); +} + +/* + * Update the screen. + */ +void scr_update(void) +{ + cell *bp; + cell *sp; + cell so; + cell cur_so = 0; + int i; + int j; + int ccol; + + /* Always leave cursor after last displayed point */ + curscreen[D_LAST * B_COLS - 1] = -1; + + if (score != curscore) { + moveto(0, 0); + printf("Score: %d", score); + curscore = score; + } + + /* Draw preview of next pattern */ + if ((showpreview) && (nextshape != lastshape)) { + int i; + static int r = 5, c = 2; + int tr, tc, t; + + lastshape = nextshape; + + /* Clean */ + resume_normal(); + moveto(r - 1, c - 1); + putstr(" "); + moveto(r, c - 1); + putstr(" "); + moveto(r + 1, c - 1); + putstr(" "); + moveto(r + 2, c - 1); + putstr(" "); + + moveto(r - 3, c - 2); + putstr("Next shape:"); + + /* Draw */ + start_standout(nextshape->color); + moveto(r, 2 * c); + putstr(" "); + for (i = 0; i < 3; i++) { + t = c + r * B_COLS; + t += nextshape->off[i]; + + tr = t / B_COLS; + tc = t % B_COLS; + + moveto(tr, 2*tc); + putstr(" "); + } + resume_normal(); + } + + bp = &board[D_FIRST * B_COLS]; + sp = &curscreen[D_FIRST * B_COLS]; + for (j = D_FIRST; j < D_LAST; j++) { + ccol = -1; + for (i = 0; i < B_COLS; bp++, sp++, i++) { + if (*sp == (so = *bp)) + continue; + + *sp = so; + if (i != ccol) { + if (cur_so) { + resume_normal(); + cur_so = 0; + } + moveto(RTOD(j), CTOD(i)); + } + + if (so != cur_so) { + if (so) + start_standout(so); + else + resume_normal(); + cur_so = so; + } + putstr(" "); + + ccol = i + 1; + /* + * Look ahead a bit, to avoid extra motion if + * we will be redrawing the cell after the next. + * Motion probably takes four or more characters, + * so we save even if we rewrite two cells + * `unnecessarily'. Skip it all, though, if + * the next cell is a different color. + */ + + if ((i > STOP) || (sp[1] != bp[1]) || (so != bp[1])) + continue; + + if (sp[2] != bp[2]) + sp[1] = -1; + else if ((i < STOP) && (so == bp[2]) && (sp[3] != bp[3])) { + sp[2] = -1; + sp[1] = -1; + } + } + } + + if (cur_so) + resume_normal(); + + console_flush(console); +} + +/* + * Write a message (set != 0), or clear the same message (set == 0). + * (We need its length in case we have to overwrite with blanks.) + */ +void scr_msg(char *s, bool set) +{ + int l = str_size(s); + + moveto(Rows - 2, ((Cols - l) >> 1) - 1); + + if (set) + putstr(s); + else + while (--l >= 0) + (void) putchar(' '); +} + +/** Sleep for the current turn time + * + * Eat any input that might be available. + * + */ +void tsleep(void) +{ + suseconds_t timeout = fallrate; + + while (timeout > 0) { + kbd_event_t event; + + if (!console_get_kbd_event_timeout(console, &event, &timeout)) + break; + } +} + +/** Get char with timeout + * + */ +int tgetchar(void) +{ + /* + * Reset timeleft to fallrate whenever it is not positive + * and increase speed. + */ + + if (timeleft <= 0) { + faster(); + timeleft = fallrate; + } + + /* + * Wait to see if there is any input. If so, take it and + * update timeleft so that the next call to tgetchar() + * will not wait as long. If there is no input, + * make timeleft zero and return -1. + */ + + wchar_t c = 0; + + while (c == 0) { + kbd_event_t event; + + if (!console_get_kbd_event_timeout(console, &event, &timeleft)) { + timeleft = 0; + return -1; + } + + if (event.type == KEY_PRESS) + c = event.c; + } + + return (int) c; +} + +/** Get char without timeout + * + */ +int twait(void) +{ + wchar_t c = 0; + + while (c == 0) { + kbd_event_t event; + + if (!console_get_kbd_event(console, &event)) + return -1; + + if (event.type == KEY_PRESS) + c = event.c; + } + + return (int) c; +} + +/** @} + */ Index: uspace/dist/src/c/demos/tetris/screen.h =================================================================== --- uspace/dist/src/c/demos/tetris/screen.h (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/tetris/screen.h (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** Attributations + * + * screen.h 8.1 (Berkeley) 5/31/93 + * NetBSD: screen.h,v 1.2 1995/04/22 07:42:42 cgd + * OpenBSD: screen.h,v 1.5 2003/06/03 03:01:41 millert + * + * Based upon BSD Tetris + * + * Copyright (c) 1992, 1993 + * The Regents of the University of California. + * Distributed under BSD license. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek and Darren F. Provine. + * + */ + +/** @addtogroup tetris + * @{ + */ +/** @file + */ + +/* + * putpad() is for padded strings with count = 1. + */ +#define putpad(s) tputs(s, 1, put) + +#include +#include +#include +#include + +typedef struct { + sysarg_t ws_row; + sysarg_t ws_col; +} winsize_t; + +extern console_ctrl_t *console; +extern winsize_t winsize; + +extern void moveto(sysarg_t r, sysarg_t c); +extern void clear_screen(void); + +extern int put(int); +extern void scr_clear(void); +extern void scr_end(void); +extern void scr_init(void); +extern void scr_msg(char *, bool); +extern void scr_set(void); +extern void scr_update(void); + +extern void tsleep(void); +extern int tgetchar(void); +extern int twait(void); + +/** @} + */ Index: uspace/dist/src/c/demos/tetris/shapes.c =================================================================== --- uspace/dist/src/c/demos/tetris/shapes.c (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/tetris/shapes.c (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** Attributations + * + * shapes.c 8.1 (Berkeley) 5/31/93 + * NetBSD: shapes.c,v 1.2 1995/04/22 07:42:44 cgd + * OpenBSD: shapes.c,v 1.8 2004/07/10 07:26:24 deraadt + * + * Based upon BSD Tetris + * + * Copyright (c) 1992, 1993 + * The Regents of the University of California. + * Distributed under BSD license. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek and Darren F. Provine. + * + */ + +/** @addtogroup tetris + * @{ + */ +/** @file + */ + +/* + * Tetris shapes and related routines. + * + * Note that the first 7 are `well known'. + */ + +#include +#include "tetris.h" + +#define TL (-B_COLS - 1) /* top left */ +#define TC (-B_COLS) /* top center */ +#define TR (-B_COLS + 1) /* top right */ +#define ML -1 /* middle left */ +#define MR 1 /* middle right */ +#define BL (B_COLS - 1) /* bottom left */ +#define BC B_COLS /* bottom center */ +#define BR (B_COLS + 1) /* bottom right */ + +const struct shape shapes[] = { + /* 0 */ { 7, 7, { TL, TC, MR }, 0xff042d}, + /* 1 */ { 8, 8, { TC, TR, ML }, 0xff9304}, + /* 2 */ { 9, 11, { ML, MR, BC }, 0xbeff04}, + /* 3 */ { 3, 3, { TL, TC, ML }, 0x63ff04}, + /* 4 */ { 12, 14, { ML, BL, MR }, 0xce04ff}, + /* 5 */ { 15, 17, { ML, BR, MR }, 0xff04cf}, + /* 6 */ { 18, 18, { ML, MR, 2 }, 0x7604ff}, /* sticks out */ + /* 7 */ { 0, 0, { TC, ML, BL }, 0xff042d}, + /* 8 */ { 1, 1, { TC, MR, BR }, 0xff9304}, + /* 9 */ { 10, 2, { TC, MR, BC }, 0xbeff04}, + /* 10 */ { 11, 9, { TC, ML, MR }, 0xbeff04}, + /* 11 */ { 2, 10, { TC, ML, BC }, 0xbeff04}, + /* 12 */ { 13, 4, { TC, BC, BR }, 0xce04ff}, + /* 13 */ { 14, 12, { TR, ML, MR }, 0xce04ff}, + /* 14 */ { 4, 13, { TL, TC, BC }, 0xce04ff}, + /* 15 */ { 16, 5, { TR, TC, BC }, 0xff04cf}, + /* 16 */ { 17, 15, { TL, MR, ML }, 0xff04cf}, + /* 17 */ { 5, 16, { TC, BC, BL }, 0xff04cf}, + /* 18 */ { 6, 6, { TC, BC, 2 * B_COLS }, 0x7604ff} /* sticks out */ +}; + +/* + * Return true iff the given shape fits in the given position, + * taking the current board into account. + */ +int fits_in(const struct shape *shape, int pos) +{ + const int *o = shape->off; + + if ((board[pos]) || (board[pos + *o++]) || (board[pos + *o++]) || + (board[pos + *o])) + return 0; + + return 1; +} + +/* + * Write the given shape into the current board, turning it on + * if `onoff' is 1, and off if `onoff' is 0. + */ +void place(const struct shape *shape, int pos, int onoff) +{ + const int *o = shape->off; + + board[pos] = onoff ? shape->color : 0x000000; + board[pos + *o++] = onoff ? shape->color : 0x000000; + board[pos + *o++] = onoff ? shape->color : 0x000000; + board[pos + *o] = onoff ? shape->color : 0x000000; +} + +/** @} + */ Index: uspace/dist/src/c/demos/tetris/tetris.c =================================================================== --- uspace/dist/src/c/demos/tetris/tetris.c (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/tetris/tetris.c (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,450 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** Attributations + * + * tetris.c 8.1 (Berkeley) 5/31/93 + * NetBSD: tetris.c,v 1.2 1995/04/22 07:42:47 cgd + * OpenBSD: tetris.c,v 1.21 2006/04/20 03:24:12 ray + * + * Based upon BSD Tetris + * + * Copyright (c) 1992, 1993 + * The Regents of the University of California. + * Distributed under BSD license. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek and Darren F. Provine. + * + */ + +/** @addtogroup tetris Tetris + * @brief Tetris ported from OpenBSD + * @{ + */ +/** @file + */ + +static const char copyright[] = + "@(#) Copyright (c) 1992, 1993\n" + "\tThe Regents of the University of California. All rights reserved.\n"; + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "scores.h" +#include "screen.h" +#include "tetris.h" + +cell board[B_SIZE]; + +int Rows; +int Cols; + +const struct shape *curshape; +const struct shape *nextshape; + +long fallrate; +int score; +char key_msg[100]; +int showpreview; +int classic; + +static void elide(void); +static void setup_board(void); +static const struct shape *randshape(void); + +static void usage(void); + +static int firstgame = 1; + +/* + * Set up the initial board. The bottom display row is completely set, + * along with another (hidden) row underneath that. Also, the left and + * right edges are set. + */ +static void setup_board(void) +{ + int i; + cell *p = board; + + for (i = B_SIZE; i; i--) + *p++ = (i <= (2 * B_COLS) || (i % B_COLS) < 2) ? 0x0000ff : 0x000000; +} + +/* + * Elide any full active rows. + */ +static void elide(void) +{ + int rows = 0; + int i; + int j; + int base; + cell *p; + + for (i = A_FIRST; i < A_LAST; i++) { + base = i * B_COLS + 1; + p = &board[base]; + for (j = B_COLS - 2; *p++ != 0;) { + if (--j <= 0) { + /* This row is to be elided */ + rows++; + memset(&board[base], 0, sizeof(cell) * (B_COLS - 2)); + + scr_update(); + tsleep(); + + while (--base != 0) + board[base + B_COLS] = board[base]; + + scr_update(); + tsleep(); + + break; + } + } + } + + switch (rows) { + case 1: + score += 10; + break; + case 2: + score += 30; + break; + case 3: + score += 70; + break; + case 4: + score += 150; + break; + default: + break; + } +} + +const struct shape *randshape(void) +{ + const struct shape *tmp = &shapes[random() % 7]; + int i; + int j = random() % 4; + + for (i = 0; i < j; i++) + tmp = &shapes[classic ? tmp->rotc : tmp->rot]; + + return (tmp); +} + +static void srandomdev(void) +{ + struct timeval tv; + + gettimeofday(&tv, NULL); + srandom(tv.tv_sec + tv.tv_usec / 100000); +} + +static void tetris_menu_draw(int level) +{ + clear_screen(); + moveto(5, 10); + puts("Tetris\n\n"); + + moveto(8, 10); + printf("Level = %d (press keys 1 - 9 to change)", level); + moveto(9, 10); + printf("Preview is %s (press 'p' to change)", (showpreview ? "on ": "off")); + moveto(12, 10); + printf("Press 'h' to show hiscore table."); + moveto(13, 10); + printf("Press 's' to start game."); + moveto(14, 10); + printf("Press 'q' to quit game."); + moveto(20, 10); + printf("In game controls:"); + moveto(21, 0); + puts(key_msg); +} + +static int tetris_menu(int *level) +{ + tetris_menu_draw(*level); + while (1) { + int i = getchar(); + + switch(i) { + case 'p': + showpreview = !showpreview; + moveto(9, 21); + if (showpreview) + printf("on "); + else + printf("off"); + break; + case 'h': + loadscores(); + showscores(firstgame); + tetris_menu_draw(*level); + break; + case 's': + firstgame = 0; + return 1; + case 'q': + return 0; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + *level = i - '0'; + moveto(8, 18); + printf("%d", *level); + break; + } + } +} + +int main(int argc, char *argv[]) +{ + int pos; + int c; + const char *keys; + int level = 2; + char key_write[6][10]; + int i; + int j; + int ch; + + console = console_init(stdin, stdout); + + keys = "jkl pq"; + + classic = 0; + showpreview = 1; + + while ((ch = getopt(argc, argv, "ck:ps")) != -1) + switch(ch) { + case 'c': + /* + * this means: + * - rotate the other way + * - no reverse video + */ + classic = 1; + break; + case 'k': + if (str_size(keys = optarg) != 6) + usage(); + break; + case 'p': + showpreview = 1; + break; + case 's': + showscores(0); + exit(0); + default: + usage(); + } + + argc -= optind; + argv += optind; + + if (argc) + usage(); + + for (i = 0; i <= 5; i++) { + for (j = i + 1; j <= 5; j++) { + if (keys[i] == keys[j]) + errx(1, "%s", "duplicate command keys specified."); + } + + if (keys[i] == ' ') + str_cpy(key_write[i], sizeof(key_write[i]), ""); + else { + key_write[i][0] = keys[i]; + key_write[i][1] = '\0'; + } + } + + snprintf(key_msg, sizeof(key_msg), + "%s - left %s - rotate %s - right %s - drop %s - pause %s - quit", + key_write[0], key_write[1], key_write[2], key_write[3], + key_write[4], key_write[5]); + + scr_init(); + if (loadscores() != EOK) + initscores(); + + while (tetris_menu(&level)) { + fallrate = 1000000 / level; + + scr_clear(); + setup_board(); + + srandomdev(); + scr_set(); + + pos = A_FIRST * B_COLS + (B_COLS / 2) - 1; + nextshape = randshape(); + curshape = randshape(); + + scr_msg(key_msg, 1); + + while (1) { + place(curshape, pos, 1); + scr_update(); + place(curshape, pos, 0); + c = tgetchar(); + if (c < 0) { + /* + * Timeout. Move down if possible. + */ + if (fits_in(curshape, pos + B_COLS)) { + pos += B_COLS; + continue; + } + + /* + * Put up the current shape `permanently', + * bump score, and elide any full rows. + */ + place(curshape, pos, 1); + score++; + elide(); + + /* + * Choose a new shape. If it does not fit, + * the game is over. + */ + curshape = nextshape; + nextshape = randshape(); + pos = A_FIRST * B_COLS + (B_COLS / 2) - 1; + + if (!fits_in(curshape, pos)) + break; + + continue; + } + + /* + * Handle command keys. + */ + if (c == keys[5]) { + /* quit */ + break; + } + + if (c == keys[4]) { + static char msg[] = + "paused - press RETURN to continue"; + + place(curshape, pos, 1); + do { + scr_update(); + scr_msg(key_msg, 0); + scr_msg(msg, 1); + console_flush(console); + } while (!twait()); + + scr_msg(msg, 0); + scr_msg(key_msg, 1); + place(curshape, pos, 0); + continue; + } + + if (c == keys[0]) { + /* move left */ + if (fits_in(curshape, pos - 1)) + pos--; + continue; + } + + if (c == keys[1]) { + /* turn */ + const struct shape *new = + &shapes[classic ? curshape->rotc : curshape->rot]; + + if (fits_in(new, pos)) + curshape = new; + continue; + } + + if (c == keys[2]) { + /* move right */ + if (fits_in(curshape, pos + 1)) + pos++; + continue; + } + + if (c == keys[3]) { + /* move to bottom */ + while (fits_in(curshape, pos + B_COLS)) { + pos += B_COLS; + score++; + } + continue; + } + + if (c == '\f') { + scr_clear(); + scr_msg(key_msg, 1); + } + } + + scr_clear(); + loadscores(); + insertscore(score, level); + savescores(); + score = 0; + } + + scr_clear(); + printf("\nGame over.\n"); + scr_end(); + + return 0; +} + +void usage(void) +{ + fprintf(stderr, "usage: tetris [-ps] [-k keys]\n"); + exit(1); +} + +/** @} + */ Index: uspace/dist/src/c/demos/tetris/tetris.h =================================================================== --- uspace/dist/src/c/demos/tetris/tetris.h (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) +++ uspace/dist/src/c/demos/tetris/tetris.h (revision 80e9e5edd009650fe1b6323206b0bb22db7900cc) @@ -0,0 +1,199 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** Attributations + * + * tetris.h 8.1 (Berkeley) 5/31/93 + * NetBSD: tetris.h,v 1.2 1995/04/22 07:42:48 cgd + * OpenBSD: tetris.h,v 1.9 2003/06/03 03:01:41 millert + * + * Based upon BSD Tetris + * + * Copyright (c) 1992, 1993 + * The Regents of the University of California. + * Distributed under BSD license. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek and Darren F. Provine. + * + */ + +/** @addtogroup tetris + * @{ + */ +/** @file + */ + +/* + * Definitions for Tetris. + */ + +/* + * The display (`board') is composed of 23 rows of 12 columns of characters + * (numbered 0..22 and 0..11), stored in a single array for convenience. + * Columns 1 to 10 of rows 1 to 20 are the actual playing area, where + * shapes appear. Columns 0 and 11 are always occupied, as are all + * columns of rows 21 and 22. Rows 0 and 22 exist as boundary areas + * so that regions `outside' the visible area can be examined without + * worrying about addressing problems. + */ + +/* The board */ +#define B_COLS 12 +#define B_ROWS 23 +#define B_SIZE (B_ROWS * B_COLS) + +typedef uint32_t cell; + +extern cell board[B_SIZE]; /* 1 => occupied, 0 => empty */ + +/* The displayed area (rows) */ +#define D_FIRST 1 +#define D_LAST 22 + +/* The active area (rows) */ +#define A_FIRST 1 +#define A_LAST 21 + +/* + * Minimum display size. + */ +#define MINROWS 23 +#define MINCOLS 40 + +/* Current screen size */ +extern int Rows; +extern int Cols; + +/* + * Translations from board coordinates to display coordinates. + * As with board coordinates, display coordiates are zero origin. + */ +#define RTOD(x) ((x) - 1) +#define CTOD(x) ((x) * 2 + (((Cols - 2 * B_COLS) >> 1) - 1)) + +/* + * A `shape' is the fundamental thing that makes up the game. There + * are 7 basic shapes, each consisting of four `blots': + * + * X.X X.X X.X + * X.X X.X X.X.X X.X X.X.X X.X.X X.X.X.X + * X X X + * + * 0 1 2 3 4 5 6 + * + * Except for 3 and 6, the center of each shape is one of the blots. + * This blot is designated (0, 0). The other three blots can then be + * described as offsets from the center. Shape 3 is the same under + * rotation, so its center is effectively irrelevant; it has been chosen + * so that it `sticks out' upward and leftward. Except for shape 6, + * all the blots are contained in a box going from (-1, -1) to (+1, +1); + * shape 6's center `wobbles' as it rotates, so that while it `sticks out' + * rightward, its rotation---a vertical line---`sticks out' downward. + * The containment box has to include the offset (2, 0), making the overall + * containment box range from offset (-1, -1) to (+2, +1). (This is why + * there is only one row above, but two rows below, the display area.) + * + * The game works by choosing one of these shapes at random and putting + * its center at the middle of the first display row (row 1, column 5). + * The shape is moved steadily downward until it collides with something: + * either another shape, or the bottom of the board. When the shape can + * no longer be moved downwards, it is merged into the current board. + * At this time, any completely filled rows are elided, and blots above + * these rows move down to make more room. A new random shape is again + * introduced at the top of the board, and the whole process repeats. + * The game ends when the new shape will not fit at (1, 5). + * + * While the shapes are falling, the user can rotate them counterclockwise + * 90 degrees (in addition to moving them left or right), provided that the + * rotation puts the blots in empty spaces. The table of shapes is set up + * so that each shape contains the index of the new shape obtained by + * rotating the current shape. Due to symmetry, each shape has exactly + * 1, 2, or 4 rotations total; the first 7 entries in the table represent + * the primary shapes, and the remaining 12 represent their various + * rotated forms. + */ +struct shape { + int rot; /* index of rotated version of this shape */ + int rotc; /* -- " -- in classic version */ + int off[3]; /* offsets to other blots if center is at (0,0) */ + uint32_t color; +}; + +extern const struct shape shapes[]; + +extern const struct shape *curshape; +extern const struct shape *nextshape; + +/* + * Shapes fall at a rate faster than once per second. + * + * The initial rate is determined by dividing 1 million microseconds + * by the game `level'. (This is at most 1 million, or one second.) + * Each time the fall-rate is used, it is decreased a little bit, + * depending on its current value, via the `faster' macro below. + * The value eventually reaches a limit, and things stop going faster, + * but by then the game is utterly impossible. + */ +extern long fallrate; /* less than 1 million; smaller => faster */ + +#define faster() (fallrate -= fallrate / 3000) + +/* + * Game level must be between 1 and 9. This controls the initial fall rate + * and affects scoring. + */ +#define MINLEVEL 1 +#define MAXLEVEL 9 + +/* + * Scoring is as follows: + * + * When the shape comes to rest, and is integrated into the board, + * we score one point. If the shape is high up (at a low-numbered row), + * and the user hits the space bar, the shape plummets all the way down, + * and we score a point for each row it falls (plus one more as soon as + * we find that it is at rest and integrate it---until then, it can + * still be moved or rotated). + * + * If previewing has been turned on, the score is multiplied by PRE_PENALTY. + */ +#define PRE_PENALTY 0.75 + +extern int score; /* The obvious thing */ + +extern char key_msg[100]; +extern int showpreview; +extern int classic; + +extern int fits_in(const struct shape *, int); +extern void place(const struct shape *, int, int); +extern void stop(const char *); + +/** @} + */