WebSVN – HelenOS-historic – Diff – /uspace/trunk/tetris/tetris.c


/*  $OpenBSD: tetris.c,v 1.21 2006/04/20 03:24:12 ray Exp $ */
/*  $NetBSD: tetris.c,v 1.2 1995/04/22 07:42:47 cgd Exp $   */
 
/*-
 * Copyright (c) 1992, 1993
 *  The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Chris Torek and Darren F. Provine.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
 *
 *  @(#)tetris.c    8.1 (Berkeley) 5/31/93
 */
 
#ifndef lint
static const char copyright[] =
"@(#) Copyright (c) 1992, 1993\n\
    The Regents of the University of California.  All rights reserved.\n";
#endif /* not lint */
 
/*
 * Tetris (or however it is spelled).
 */
 
//#include <sys/param.h>
#include <sys/time.h>
#include <sys/types.h>
 
#include <err.h>
//#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#include "input.h"
#include "scores.h"
#include "screen.h"
#include "tetris.h"
 
cell    board[B_SIZE];
int Rows, Cols;
const struct shape *curshape;
const struct shape *nextshape;
long    fallrate;
int score;
//gid_t gid, egid;
char    key_msg[100];
int showpreview, classic;
 
static void elide(void);
static void setup_board(void);
const struct shape *randshape(void);
void    onintr(int);
void    usage(void);
 
/*
 * 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;
 
    p = board;
    for (i = B_SIZE; i; i--)
        *p++ = i <= (2 * B_COLS) || (i % B_COLS) < 2;
}
 
/*
 * Elide any full active rows.
 */
static void
elide(void)
{
    int rows = 0;
    int i, j, 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, 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;
    int i, j;
 
    tmp = &shapes[random() % 7];
    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);
}
 
int
main(int argc, char *argv[])
{
    int pos, c;
    char *keys;
    int level = 2;
    char key_write[6][10];
    const char *errstr;
    int ch, i, j;
 
    keys = "jkl pq";
 
//  gid = getgid();
//  egid = getegid();
//  setegid(gid);
 
    classic = showpreview = 0;
 
/*  while ((ch = getopt(argc, argv, "ck:l:ps")) != -1) */
/*      switch(ch) { */
/*      case 'c': */
/*          /\* */
/*           * this means: */
/*           *  - rotate the other way; */
/*           *  - no reverse video. */
/*           *\/ */
/*          classic = 1; */
/*          break; */
/*      case 'k': */
/*          if (strlen(keys = optarg) != 6) */
/*              usage(); */
/*          break; */
/*      case 'l': */
/*          level = (int)strtonum(optarg, MINLEVEL, MAXLEVEL, */
/*              &errstr); */
/*          if (errstr) */
/*              errx(1, "level must be from %d to %d", */
/*                  MINLEVEL, MAXLEVEL); */
/*          break; */
/*      case 'p': */
/*          showpreview = 1; */
/*          break; */
/*      case 's': */
/*          showscores(0); */
/*          exit(0); */
/*      default: */
/*          usage(); */
/*      } */
 
/*  argc -= optind; */
/*  argv += optind; */
 
/*  if (argc) */
/*      usage(); */
 
    fallrate = 1000000 / level;
 
    for (i = 0; i <= 5; i++) {
        for (j = i+1; j <= 5; j++) {
            if (keys[i] == keys[j])
                errx(1, "duplicate command keys specified.");
        }
        if (keys[i] == ' ')
            strncpy(key_write[i], "<space>", 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]);
 
//  (void)signal(SIGINT, onintr);
    scr_init();
    setup_board();
 
    srandomdev();
    scr_set();
 
    pos = A_FIRST*B_COLS + (B_COLS/2)-1;
    nextshape = randshape();
    curshape = randshape();
 
    scr_msg(key_msg, 1);
 
    for (;;) {
        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);
//              (void) fflush(stdout);
            } while (rwait((struct timeval *)NULL) == -1);
            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();
    scr_end();
 
    if (showpreview == 0)
        (void)printf("Your score:  %d point%s  x  level %d  =  %d\n",
            score, score == 1 ? "" : "s", level, score * level);
    else {
        (void)printf("Your score:  %d point%s x level %d x preview penalty %0.3f = %d\n",
            score, score == 1 ? "" : "s", level, (double)PRE_PENALTY,
            (int)(score * level * PRE_PENALTY));
        score = score * PRE_PENALTY;
    }
    savescore(level);
 
    printf("\nHit RETURN to see high scores, ^C to skip.\n");
 
    while ((i = getchar()) != '\n')
        if (i == EOF)
            break;
 
    showscores(level);
 
    exit(0);
}
 
/* void */
/* onintr(int signo) */
/* { */
/*  scr_clear();        /\* XXX signal race *\/ */
/*  scr_end();      /\* XXX signal race *\/ */
/*  _exit(0); */
/* } */
 
void
usage(void)
{
    (void)fprintf(stderr, "usage: tetris [-ps] [-k keys] [-l level]\n");
    exit(1);
}
 

Rev 1449	Rev 1472
1	/* $OpenBSD: tetris.c,v 1.21 2006/04/20 03:24:12 ray Exp $ */	1	/* $OpenBSD: tetris.c,v 1.21 2006/04/20 03:24:12 ray Exp $ */
2	/* $NetBSD: tetris.c,v 1.2 1995/04/22 07:42:47 cgd Exp $ */	2	/* $NetBSD: tetris.c,v 1.2 1995/04/22 07:42:47 cgd Exp $ */
3		3
4	/*-	4	/*-
5	* Copyright (c) 1992, 1993	5	* Copyright (c) 1992, 1993
6	* The Regents of the University of California. All rights reserved.	6	* The Regents of the University of California. All rights reserved.
7	*	7	*
8	* This code is derived from software contributed to Berkeley by	8	* This code is derived from software contributed to Berkeley by
9	* Chris Torek and Darren F. Provine.	9	* Chris Torek and Darren F. Provine.
10	*	10	*
11	* Redistribution and use in source and binary forms, with or without	11	* Redistribution and use in source and binary forms, with or without
12	* modification, are permitted provided that the following conditions	12	* modification, are permitted provided that the following conditions
13	* are met:	13	* are met:
14	* 1. Redistributions of source code must retain the above copyright	14	* 1. Redistributions of source code must retain the above copyright
15	* notice, this list of conditions and the following disclaimer.	15	* notice, this list of conditions and the following disclaimer.
16	* 2. Redistributions in binary form must reproduce the above copyright	16	* 2. Redistributions in binary form must reproduce the above copyright
17	* notice, this list of conditions and the following disclaimer in the	17	* notice, this list of conditions and the following disclaimer in the
18	* documentation and/or other materials provided with the distribution.	18	* documentation and/or other materials provided with the distribution.
19	* 3. Neither the name of the University nor the names of its contributors	19	* 3. Neither the name of the University nor the names of its contributors
20	* may be used to endorse or promote products derived from this software	20	* may be used to endorse or promote products derived from this software
21	* without specific prior written permission.	21	* without specific prior written permission.
22	*	22	*
23	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND	23	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	24	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE	25	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE	26	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL	27	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS	28	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)	29	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT	30	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY	31	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF	32	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33	* SUCH DAMAGE.	33	* SUCH DAMAGE.
34	*	34	*
35	* @(#)tetris.c 8.1 (Berkeley) 5/31/93	35	* @(#)tetris.c 8.1 (Berkeley) 5/31/93
36	*/	36	*/
37		37
38	#ifndef lint	38	#ifndef lint
39	static const char copyright[] =	39	static const char copyright[] =
40	"@(#) Copyright (c) 1992, 1993\n\	40	"@(#) Copyright (c) 1992, 1993\n\
41	The Regents of the University of California. All rights reserved.\n";	41	The Regents of the University of California. All rights reserved.\n";
42	#endif /* not lint */	42	#endif /* not lint */
43		43
44	/*	44	/*
45	* Tetris (or however it is spelled).	45	* Tetris (or however it is spelled).
46	*/	46	*/
47		47
48	#include <sys/param.h>	48	//#include <sys/param.h>
49	#include <sys/time.h>	49	#include <sys/time.h>
50	#include <sys/types.h>	50	#include <sys/types.h>
51		51
52	#include <err.h>	52	#include <err.h>
53	//#include <signal.h>	53	//#include <signal.h>
54	#include <stdio.h>	54	#include <stdio.h>
55	#include <stdlib.h>	55	#include <stdlib.h>
56	#include <string.h>	56	#include <string.h>
57	#include <unistd.h>	57	#include <unistd.h>
58		58
59	#include "input.h"	59	#include "input.h"
60	#include "scores.h"	60	#include "scores.h"
61	#include "screen.h"	61	#include "screen.h"
62	#include "tetris.h"	62	#include "tetris.h"
63		63
64	cell board[B_SIZE];	64	cell board[B_SIZE];
65	int Rows, Cols;	65	int Rows, Cols;
66	const struct shape *curshape;	66	const struct shape *curshape;
67	const struct shape *nextshape;	67	const struct shape *nextshape;
68	long fallrate;	68	long fallrate;
69	int score;	69	int score;
70	//gid_t gid, egid;	70	//gid_t gid, egid;
71	char key_msg[100];	71	char key_msg[100];
72	int showpreview, classic;	72	int showpreview, classic;
73		73
74	static void elide(void);	74	static void elide(void);
75	static void setup_board(void);	75	static void setup_board(void);
76	const struct shape *randshape(void);	76	const struct shape *randshape(void);
77	void onintr(int);	77	void onintr(int);
78	void usage(void);	78	void usage(void);
79		79
80	/*	80	/*
81	* Set up the initial board. The bottom display row is completely set,	81	* Set up the initial board. The bottom display row is completely set,
82	* along with another (hidden) row underneath that. Also, the left and	82	* along with another (hidden) row underneath that. Also, the left and
83	* right edges are set.	83	* right edges are set.
84	*/	84	*/
85	static void	85	static void
86	setup_board(void)	86	setup_board(void)
87	{	87	{
88	int i;	88	int i;
89	cell *p;	89	cell *p;
90		90
91	p = board;	91	p = board;
92	for (i = B_SIZE; i; i--)	92	for (i = B_SIZE; i; i--)
93	p++ = i <= (2 B_COLS) \|\| (i % B_COLS) < 2;	93	p++ = i <= (2 B_COLS) \|\| (i % B_COLS) < 2;
94	}	94	}
95		95
96	/*	96	/*
97	* Elide any full active rows.	97	* Elide any full active rows.
98	*/	98	*/
99	static void	99	static void
100	elide(void)	100	elide(void)
101	{	101	{
102	int rows = 0;	102	int rows = 0;
103	int i, j, base;	103	int i, j, base;
104	cell *p;	104	cell *p;
105		105
106	for (i = A_FIRST; i < A_LAST; i++) {	106	for (i = A_FIRST; i < A_LAST; i++) {
107	base = i * B_COLS + 1;	107	base = i * B_COLS + 1;
108	p = &board[base];	108	p = &board[base];
109	for (j = B_COLS - 2; *p++ != 0;) {	109	for (j = B_COLS - 2; *p++ != 0;) {
110	if (--j <= 0) {	110	if (--j <= 0) {
111	/* this row is to be elided */	111	/* this row is to be elided */
112	rows++;	112	rows++;
113	memset(&board[base], 0, B_COLS - 2);	113	memset(&board[base], 0, B_COLS - 2);
114	scr_update();	114	scr_update();
115	tsleep();	115	tsleep();
116	while (--base != 0)	116	while (--base != 0)
117	board[base + B_COLS] = board[base];	117	board[base + B_COLS] = board[base];
118	scr_update();	118	scr_update();
119	tsleep();	119	tsleep();
120	break;	120	break;
121	}	121	}
122	}	122	}
123	}	123	}
124	switch (rows) {	124	switch (rows) {
125	case 1:	125	case 1:
126	score += 10;	126	score += 10;
127	break;	127	break;
128	case 2:	128	case 2:
129	score += 30;	129	score += 30;
130	break;	130	break;
131	case 3:	131	case 3:
132	score += 70;	132	score += 70;
133	break;	133	break;
134	case 4:	134	case 4:
135	score += 150;	135	score += 150;
136	break;	136	break;
137	default:	137	default:
138	break;	138	break;
139	}	139	}
140	}	140	}
141		141
142	const struct shape *	142	const struct shape *
143	randshape(void)	143	randshape(void)
144	{	144	{
145	const struct shape *tmp;	145	const struct shape *tmp;
146	int i, j;	146	int i, j;
147		147
148	tmp = &shapes[random() % 7];	148	tmp = &shapes[random() % 7];
149	j = random() % 4;	149	j = random() % 4;
150	for (i = 0; i < j; i++)	150	for (i = 0; i < j; i++)
151	tmp = &shapes[classic? tmp->rotc : tmp->rot];	151	tmp = &shapes[classic? tmp->rotc : tmp->rot];
152	return (tmp);	152	return (tmp);
153	}	153	}
-		154
-		155	static void srandomdev(void)
154		156	{
-		157	struct timeval tv;
-		158
-		159	gettimeofday(&tv, NULL);
-		160	srandom(tv.tv_sec + tv.tv_usec / 100000);
-		161	}
155		162
156	int	163	int
157	main(int argc, char *argv[])	164	main(int argc, char *argv[])
158	{	165	{
159	int pos, c;	166	int pos, c;
160	char *keys;	167	char *keys;
161	int level = 2;	168	int level = 2;
162	char key_write[6][10];	169	char key_write[6][10];
163	const char *errstr;	170	const char *errstr;
164	int ch, i, j;	171	int ch, i, j;
165		172
166	keys = "jkl pq";	173	keys = "jkl pq";
167		174
168	// gid = getgid();	175	// gid = getgid();
169	// egid = getegid();	176	// egid = getegid();
170	// setegid(gid);	177	// setegid(gid);
171		178
172	classic = showpreview = 0;	179	classic = showpreview = 0;
173		180
174	/* while ((ch = getopt(argc, argv, "ck:l:ps")) != -1) */	181	/* while ((ch = getopt(argc, argv, "ck:l:ps")) != -1) */
175	/* switch(ch) { */	182	/* switch(ch) { */
176	/* case 'c': */	183	/* case 'c': */
177	/* /\* */	184	/* /\* */
178	/* * this means: */	185	/* * this means: */
179	/* * - rotate the other way; */	186	/* * - rotate the other way; */
180	/* * - no reverse video. */	187	/* * - no reverse video. */
181	/* \/ /	188	/* \/ /
182	/* classic = 1; */	189	/* classic = 1; */
183	/* break; */	190	/* break; */
184	/* case 'k': */	191	/* case 'k': */
185	/* if (strlen(keys = optarg) != 6) */	192	/* if (strlen(keys = optarg) != 6) */
186	/* usage(); */	193	/* usage(); */
187	/* break; */	194	/* break; */
188	/* case 'l': */	195	/* case 'l': */
189	/* level = (int)strtonum(optarg, MINLEVEL, MAXLEVEL, */	196	/* level = (int)strtonum(optarg, MINLEVEL, MAXLEVEL, */
190	/* &errstr); */	197	/* &errstr); */
191	/* if (errstr) */	198	/* if (errstr) */
192	/* errx(1, "level must be from %d to %d", */	199	/* errx(1, "level must be from %d to %d", */
193	/* MINLEVEL, MAXLEVEL); */	200	/* MINLEVEL, MAXLEVEL); */
194	/* break; */	201	/* break; */
195	/* case 'p': */	202	/* case 'p': */
196	/* showpreview = 1; */	203	/* showpreview = 1; */
197	/* break; */	204	/* break; */
198	/* case 's': */	205	/* case 's': */
199	/* showscores(0); */	206	/* showscores(0); */
200	/* exit(0); */	207	/* exit(0); */
201	/* default: */	208	/* default: */
202	/* usage(); */	209	/* usage(); */
203	/* } */	210	/* } */
204		211
205	/* argc -= optind; */	212	/* argc -= optind; */
206	/* argv += optind; */	213	/* argv += optind; */
207		214
208	/* if (argc) */	215	/* if (argc) */
209	/* usage(); */	216	/* usage(); */
210		217
211	fallrate = 1000000 / level;	218	fallrate = 1000000 / level;
212		219
213	for (i = 0; i <= 5; i++) {	220	for (i = 0; i <= 5; i++) {
214	for (j = i+1; j <= 5; j++) {	221	for (j = i+1; j <= 5; j++) {
215	if (keys[i] == keys[j])	222	if (keys[i] == keys[j])
216	errx(1, "duplicate command keys specified.");	223	errx(1, "duplicate command keys specified.");
217	}	224	}
218	if (keys[i] == ' ')	225	if (keys[i] == ' ')
219	strlcpy(key_write[i], "<space>", sizeof key_write[i]);	226	strncpy(key_write[i], "<space>", sizeof key_write[i]);
220	else {	227	else {
221	key_write[i][0] = keys[i];	228	key_write[i][0] = keys[i];
222	key_write[i][1] = '\0';	229	key_write[i][1] = '\0';
223	}	230	}
224	}	231	}
225		232
226	snprintf(key_msg, sizeof key_msg,	233	snprintf(key_msg, sizeof key_msg,
227	"%s - left %s - rotate %s - right %s - drop %s - pause %s - quit",	234	"%s - left %s - rotate %s - right %s - drop %s - pause %s - quit",
228	key_write[0], key_write[1], key_write[2], key_write[3],	235	key_write[0], key_write[1], key_write[2], key_write[3],
229	key_write[4], key_write[5]);	236	key_write[4], key_write[5]);
230		237
231	// (void)signal(SIGINT, onintr);	238	// (void)signal(SIGINT, onintr);
232	scr_init();	239	scr_init();
233	setup_board();	240	setup_board();
234		241
235	srandomdev();	242	srandomdev();
236	scr_set();	243	scr_set();
237		244
238	pos = A_FIRST*B_COLS + (B_COLS/2)-1;	245	pos = A_FIRST*B_COLS + (B_COLS/2)-1;
239	nextshape = randshape();	246	nextshape = randshape();
240	curshape = randshape();	247	curshape = randshape();
241		248
242	scr_msg(key_msg, 1);	249	scr_msg(key_msg, 1);
243		250
244	for (;;) {	251	for (;;) {
245	place(curshape, pos, 1);	252	place(curshape, pos, 1);
246	scr_update();	253	scr_update();
247	place(curshape, pos, 0);	254	place(curshape, pos, 0);
248	c = tgetchar();	255	c = tgetchar();
249	if (c < 0) {	256	if (c < 0) {
250	/*	257	/*
251	* Timeout. Move down if possible.	258	* Timeout. Move down if possible.
252	*/	259	*/
253	if (fits_in(curshape, pos + B_COLS)) {	260	if (fits_in(curshape, pos + B_COLS)) {
254	pos += B_COLS;	261	pos += B_COLS;
255	continue;	262	continue;
256	}	263	}
257		264
258	/*	265	/*
259	* Put up the current shape `permanently',	266	* Put up the current shape `permanently',
260	* bump score, and elide any full rows.	267	* bump score, and elide any full rows.
261	*/	268	*/
262	place(curshape, pos, 1);	269	place(curshape, pos, 1);
263	score++;	270	score++;
264	elide();	271	elide();
265		272
266	/*	273	/*
267	* Choose a new shape. If it does not fit,	274	* Choose a new shape. If it does not fit,
268	* the game is over.	275	* the game is over.
269	*/	276	*/
270	curshape = nextshape;	277	curshape = nextshape;
271	nextshape = randshape();	278	nextshape = randshape();
272	pos = A_FIRST*B_COLS + (B_COLS/2)-1;	279	pos = A_FIRST*B_COLS + (B_COLS/2)-1;
273	if (!fits_in(curshape, pos))	280	if (!fits_in(curshape, pos))
274	break;	281	break;
275	continue;	282	continue;
276	}	283	}
277		284
278	/*	285	/*
279	* Handle command keys.	286	* Handle command keys.
280	*/	287	*/
281	if (c == keys[5]) {	288	if (c == keys[5]) {
282	/* quit */	289	/* quit */
283	break;	290	break;
284	}	291	}
285	if (c == keys[4]) {	292	if (c == keys[4]) {
286	static char msg[] =	293	static char msg[] =
287	"paused - press RETURN to continue";	294	"paused - press RETURN to continue";
288		295
289	place(curshape, pos, 1);	296	place(curshape, pos, 1);
290	do {	297	do {
291	scr_update();	298	scr_update();
292	scr_msg(key_msg, 0);	299	scr_msg(key_msg, 0);
293	scr_msg(msg, 1);	300	scr_msg(msg, 1);
294	(void) fflush(stdout);	301	// (void) fflush(stdout);
295	} while (rwait((struct timeval *)NULL) == -1);	302	} while (rwait((struct timeval *)NULL) == -1);
296	scr_msg(msg, 0);	303	scr_msg(msg, 0);
297	scr_msg(key_msg, 1);	304	scr_msg(key_msg, 1);
298	place(curshape, pos, 0);	305	place(curshape, pos, 0);
299	continue;	306	continue;
300	}	307	}
301	if (c == keys[0]) {	308	if (c == keys[0]) {
302	/* move left */	309	/* move left */
303	if (fits_in(curshape, pos - 1))	310	if (fits_in(curshape, pos - 1))
304	pos--;	311	pos--;
305	continue;	312	continue;
306	}	313	}
307	if (c == keys[1]) {	314	if (c == keys[1]) {
308	/* turn */	315	/* turn */
309	const struct shape *new = &shapes[	316	const struct shape *new = &shapes[
310	classic? curshape->rotc : curshape->rot];	317	classic? curshape->rotc : curshape->rot];
311		318
312	if (fits_in(new, pos))	319	if (fits_in(new, pos))
313	curshape = new;	320	curshape = new;
314	continue;	321	continue;
315	}	322	}
316	if (c == keys[2]) {	323	if (c == keys[2]) {
317	/* move right */	324	/* move right */
318	if (fits_in(curshape, pos + 1))	325	if (fits_in(curshape, pos + 1))
319	pos++;	326	pos++;
320	continue;	327	continue;
321	}	328	}
322	if (c == keys[3]) {	329	if (c == keys[3]) {
323	/* move to bottom */	330	/* move to bottom */
324	while (fits_in(curshape, pos + B_COLS)) {	331	while (fits_in(curshape, pos + B_COLS)) {
325	pos += B_COLS;	332	pos += B_COLS;
326	score++;	333	score++;
327	}	334	}
328	continue;	335	continue;
329	}	336	}
330	if (c == '\f') {	337	if (c == '\f') {
331	scr_clear();	338	scr_clear();
332	scr_msg(key_msg, 1);	339	scr_msg(key_msg, 1);
333	}	340	}
334	}	341	}
335		342
336	scr_clear();	343	scr_clear();
337	scr_end();	344	scr_end();
338		345
339	if (showpreview == 0)	346	if (showpreview == 0)
340	(void)printf("Your score: %d point%s x level %d = %d\n",	347	(void)printf("Your score: %d point%s x level %d = %d\n",
341	score, score == 1 ? "" : "s", level, score * level);	348	score, score == 1 ? "" : "s", level, score * level);
342	else {	349	else {
343	(void)printf("Your score: %d point%s x level %d x preview penalty %0.3f = %d\n",	350	(void)printf("Your score: %d point%s x level %d x preview penalty %0.3f = %d\n",
344	score, score == 1 ? "" : "s", level, (double)PRE_PENALTY,	351	score, score == 1 ? "" : "s", level, (double)PRE_PENALTY,
345	(int)(score * level * PRE_PENALTY));	352	(int)(score * level * PRE_PENALTY));
346	score = score * PRE_PENALTY;	353	score = score * PRE_PENALTY;
347	}	354	}
348	savescore(level);	355	savescore(level);
349		356
350	printf("\nHit RETURN to see high scores, ^C to skip.\n");	357	printf("\nHit RETURN to see high scores, ^C to skip.\n");
351		358
352	while ((i = getchar()) != '\n')	359	while ((i = getchar()) != '\n')
353	if (i == EOF)	360	if (i == EOF)
354	break;	361	break;
355		362
356	showscores(level);	363	showscores(level);
357		364
358	exit(0);	365	exit(0);
359	}	366	}
360		367
361	/* void */	368	/* void */
362	/* onintr(int signo) */	369	/* onintr(int signo) */
363	/* { */	370	/* { */
364	/* scr_clear(); /\* XXX signal race \/ /	371	/* scr_clear(); /\* XXX signal race \/ /
365	/* scr_end(); /\* XXX signal race \/ /	372	/* scr_end(); /\* XXX signal race \/ /
366	/* _exit(0); */	373	/* _exit(0); */
367	/* } */	374	/* } */
368		375
369	void	376	void
370	usage(void)	377	usage(void)
371	{	378	{
372	(void)fprintf(stderr, "usage: tetris [-ps] [-k keys] [-l level]\n");	379	(void)fprintf(stderr, "usage: tetris [-ps] [-k keys] [-l level]\n");
373	exit(1);	380	exit(1);
374	}	381	}
375		382

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/tetris/tetris.c – Rev 1449 → 1472