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
 */
 
/** @addtogroup tetris Tetris
 * @brief   Tetris ported from OpenBSD
 * @{
 */
/** @file
 */
 
#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/time.h>
#include <sys/types.h>
 
#include <err.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);
}
 
 
 
 
 
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)
{
    static int firstgame = 1;
    int i;
/*  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);
 
    showscores(level);
   
    printf("\nHit 's' to new game, 'q' to quit.\n");
*/
    tetris_menu_draw(*level);
    while (1) {
   
        i = getchar();
       
        switch(i) {
            case 'p':
                showpreview = !showpreview;
                moveto(9,21);
                if (showpreview)
                    printf("on ");
                else
                    printf("off");
                   
                break;
            case 'h':
                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, c;
    char *keys;
    int level = 2;
    char key_write[6][10];
 
    int i, j;
 
    keys = "jkl pq";
 
//  gid = getgid();
//  egid = getegid();
//  setegid(gid);
 
    classic = 0;
    showpreview = 1;
 
/*  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(); */
 
   
 
    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]);
 
    scr_init();
    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);
   
        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();
        insertscore(score, level);
        score=0;
    }
   
    scr_clear();
    printf("\n\n\n\t\tGame over.\n");
/* 
    while ((i = getchar()) != '\n')
        if (i == EOF)
            break
*/
    scr_end();
 
    return 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 1710	Rev 1721
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	/** @addtogroup tetris Tetris	38	/** @addtogroup tetris Tetris
39	* @brief Tetris ported from OpenBSD	39	* @brief Tetris ported from OpenBSD
40	* @{	40	* @{
41	*/	41	*/
42	/** @file	42	/** @file
43	*/	43	*/
44		44
45	#ifndef lint	45	#ifndef lint
46	static const char copyright[] =	46	static const char copyright[] =
47	"@(#) Copyright (c) 1992, 1993\n\	47	"@(#) Copyright (c) 1992, 1993\n\
48	The Regents of the University of California. All rights reserved.\n";	48	The Regents of the University of California. All rights reserved.\n";
49	#endif /* not lint */	49	#endif /* not lint */
50		50
51	/*	51	/*
52	* Tetris (or however it is spelled).	52	* Tetris (or however it is spelled).
53	*/	53	*/
54		54
55	#include <sys/time.h>	55	#include <sys/time.h>
56	#include <sys/types.h>	56	#include <sys/types.h>
57		57
58	#include <err.h>	58	#include <err.h>
59	#include <stdio.h>	59	#include <stdio.h>
60	#include <stdlib.h>	60	#include <stdlib.h>
61	#include <string.h>	61	#include <string.h>
62	#include <unistd.h>	62	#include <unistd.h>
63		63
64	#include "input.h"	64	#include "input.h"
65	#include "scores.h"	65	#include "scores.h"
66	#include "screen.h"	66	#include "screen.h"
67	#include "tetris.h"	67	#include "tetris.h"
68		68
69	cell board[B_SIZE];	69	cell board[B_SIZE];
70	int Rows, Cols;	70	int Rows, Cols;
71	const struct shape *curshape;	71	const struct shape *curshape;
72	const struct shape *nextshape;	72	const struct shape *nextshape;
73	long fallrate;	73	long fallrate;
74	int score;	74	int score;
75	//gid_t gid, egid;	75	//gid_t gid, egid;
76	char key_msg[100];	76	char key_msg[100];
77	int showpreview, classic;	77	int showpreview, classic;
78		78
79	static void elide(void);	79	static void elide(void);
80	static void setup_board(void);	80	static void setup_board(void);
81	const struct shape *randshape(void);	81	const struct shape *randshape(void);
82	void onintr(int);	82	void onintr(int);
83	void usage(void);	83	void usage(void);
84		84
85	/*	85	/*
86	* Set up the initial board. The bottom display row is completely set,	86	* Set up the initial board. The bottom display row is completely set,
87	* along with another (hidden) row underneath that. Also, the left and	87	* along with another (hidden) row underneath that. Also, the left and
88	* right edges are set.	88	* right edges are set.
89	*/	89	*/
90	static void	90	static void
91	setup_board(void)	91	setup_board(void)
92	{	92	{
93	int i;	93	int i;
94	cell *p;	94	cell *p;
95		95
96	p = board;	96	p = board;
97	for (i = B_SIZE; i; i--)	97	for (i = B_SIZE; i; i--)
98	p++ = i <= (2 B_COLS) \|\| (i % B_COLS) < 2;	98	p++ = i <= (2 B_COLS) \|\| (i % B_COLS) < 2;
99	}	99	}
100		100
101	/*	101	/*
102	* Elide any full active rows.	102	* Elide any full active rows.
103	*/	103	*/
104	static void	104	static void
105	elide(void)	105	elide(void)
106	{	106	{
107	int rows = 0;	107	int rows = 0;
108	int i, j, base;	108	int i, j, base;
109	cell *p;	109	cell *p;
110		110
111	for (i = A_FIRST; i < A_LAST; i++) {	111	for (i = A_FIRST; i < A_LAST; i++) {
112	base = i * B_COLS + 1;	112	base = i * B_COLS + 1;
113	p = &board[base];	113	p = &board[base];
114	for (j = B_COLS - 2; *p++ != 0;) {	114	for (j = B_COLS - 2; *p++ != 0;) {
115	if (--j <= 0) {	115	if (--j <= 0) {
116	/* this row is to be elided */	116	/* this row is to be elided */
117	rows++;	117	rows++;
118	memset(&board[base], 0, B_COLS - 2);	118	memset(&board[base], 0, B_COLS - 2);
119	scr_update();	119	scr_update();
120	tsleep();	120	tsleep();
121	while (--base != 0)	121	while (--base != 0)
122	board[base + B_COLS] = board[base];	122	board[base + B_COLS] = board[base];
123	scr_update();	123	scr_update();
124	tsleep();	124	tsleep();
125	break;	125	break;
126	}	126	}
127	}	127	}
128	}	128	}
129	switch (rows) {	129	switch (rows) {
130	case 1:	130	case 1:
131	score += 10;	131	score += 10;
132	break;	132	break;
133	case 2:	133	case 2:
134	score += 30;	134	score += 30;
135	break;	135	break;
136	case 3:	136	case 3:
137	score += 70;	137	score += 70;
138	break;	138	break;
139	case 4:	139	case 4:
140	score += 150;	140	score += 150;
141	break;	141	break;
142	default:	142	default:
143	break;	143	break;
144	}	144	}
145	}	145	}
146		146
147	const struct shape *	147	const struct shape *
148	randshape(void)	148	randshape(void)
149	{	149	{
150	const struct shape *tmp;	150	const struct shape *tmp;
151	int i, j;	151	int i, j;
152		152
153	tmp = &shapes[random() % 7];	153	tmp = &shapes[random() % 7];
154	j = random() % 4;	154	j = random() % 4;
155	for (i = 0; i < j; i++)	155	for (i = 0; i < j; i++)
156	tmp = &shapes[classic? tmp->rotc : tmp->rot];	156	tmp = &shapes[classic? tmp->rotc : tmp->rot];
157	return (tmp);	157	return (tmp);
158	}	158	}
159		159
160	static void srandomdev(void)	160	static void srandomdev(void)
161	{	161	{
162	struct timeval tv;	162	struct timeval tv;
163		163
164	gettimeofday(&tv, NULL);	164	gettimeofday(&tv, NULL);
165	srandom(tv.tv_sec + tv.tv_usec / 100000);	165	srandom(tv.tv_sec + tv.tv_usec / 100000);
166	}	166	}
167		167
168	static void tetris_scores(int firstgame)	-
169	{	-
170	}	-
171		-
172	static void tetris_menu_draw(int level)	168	static void tetris_menu_draw(int level)
173	{	169	{
174	clear_screen();	170	clear_screen();
175	moveto(5,10);	171	moveto(5,10);
176	puts("Tetris\n\n");	172	puts("Tetris\n\n");
177		173
178	moveto(8,10);	174	moveto(8,10);
179	printf("Level = %d (press keys 1 - 9 to change)",level);	175	printf("Level = %d (press keys 1 - 9 to change)",level);
180	moveto(9,10);	176	moveto(9,10);
181	printf("Preview is %s (press 'p' to change)", (showpreview?"on ":"off"));	177	printf("Preview is %s (press 'p' to change)", (showpreview?"on ":"off"));
182	moveto(12,10);	178	moveto(12,10);
183	printf("Press 'h' to show hiscore table.");	179	printf("Press 'h' to show hiscore table.");
184	moveto(13,10);	180	moveto(13,10);
185	printf("Press 's' to start game.");	181	printf("Press 's' to start game.");
186	moveto(14,10);	182	moveto(14,10);
187	printf("Press 'q' to quit game.");	183	printf("Press 'q' to quit game.");
188	moveto(20,10);	184	moveto(20,10);
189	printf("In game controls:");	185	printf("In game controls:");
190	moveto(21,0);	186	moveto(21,0);
191	puts(key_msg);	187	puts(key_msg);
192	}	188	}
193		189
194	static int tetris_menu(int *level)	190	static int tetris_menu(int *level)
195	{	191	{
196	static int firstgame = 1;	192	static int firstgame = 1;
197	int i;	193	int i;
198	/* if (showpreview == 0)	194	/* if (showpreview == 0)
199	(void)printf("Your score: %d point%s x level %d = %d\n",	195	(void)printf("Your score: %d point%s x level %d = %d\n",
200	score, score == 1 ? "" : "s", level, score * level);	196	score, score == 1 ? "" : "s", level, score * level);
201	else {	197	else {
202	(void)printf("Your score: %d point%s x level %d x preview penalty %0.3f = %d\n",	198	(void)printf("Your score: %d point%s x level %d x preview penalty %0.3f = %d\n",
203	score, score == 1 ? "" : "s", level, (double)PRE_PENALTY,	199	score, score == 1 ? "" : "s", level, (double)PRE_PENALTY,
204	(int)(score * level * PRE_PENALTY));	200	(int)(score * level * PRE_PENALTY));
205	score = score * PRE_PENALTY;	201	score = score * PRE_PENALTY;
206	}	202	}
207	savescore(level);	203	savescore(level);
208		204
209	showscores(level);	205	showscores(level);
210		206
211	printf("\nHit 's' to new game, 'q' to quit.\n");	207	printf("\nHit 's' to new game, 'q' to quit.\n");
212	*/	208	*/
213	tetris_menu_draw(*level);	209	tetris_menu_draw(*level);
214	while (1) {	210	while (1) {
215		211
216	i = getchar();	212	i = getchar();
217		213
218	switch(i) {	214	switch(i) {
219	case 'p':	215	case 'p':
220	showpreview = !showpreview;	216	showpreview = !showpreview;
221	moveto(9,21);	217	moveto(9,21);
222	if (showpreview)	218	if (showpreview)
223	printf("on ");	219	printf("on ");
224	else	220	else
225	printf("off");	221	printf("off");
226		222
227	break;	223	break;
228	case 'h':	224	case 'h':
229	showscores(firstgame);	225	showscores(firstgame);
230	tetris_menu_draw(*level);	226	tetris_menu_draw(*level);
231	break;	227	break;
232	case 's':	228	case 's':
233	firstgame = 0;	229	firstgame = 0;
234	return 1;	230	return 1;
235	case 'q':	231	case 'q':
236	return 0;	232	return 0;
237	case '1':	233	case '1':
238	case '2':	234	case '2':
239	case '3':	235	case '3':
240	case '4':	236	case '4':
241	case '5':	237	case '5':
242	case '6':	238	case '6':
243	case '7':	239	case '7':
244	case '8':	240	case '8':
245	case '9':	241	case '9':
246	*level = i - '0';	242	*level = i - '0';
247	moveto(8,18);	243	moveto(8,18);
248	printf("%d", *level);	244	printf("%d", *level);
249	break;	245	break;
250	}	246	}
251	}	247	}
252		248
253	}	249	}
254		250
255	int	251	int
256	main(int argc, char *argv[])	252	main(int argc, char *argv[])
257	{	253	{
258	int pos, c;	254	int pos, c;
259	char *keys;	255	char *keys;
260	int level = 2;	256	int level = 2;
261	char key_write[6][10];	257	char key_write[6][10];
262	const char *errstr;	-
263	int ch, i, j;	258	int i, j;
264		259
265	keys = "jkl pq";	260	keys = "jkl pq";
266		261
267	// gid = getgid();	262	// gid = getgid();
268	// egid = getegid();	263	// egid = getegid();
269	// setegid(gid);	264	// setegid(gid);
270		265
271	classic = 0;	266	classic = 0;
272	showpreview = 1;	267	showpreview = 1;
273		268
274	/* while ((ch = getopt(argc, argv, "ck:l:ps")) != -1) */	269	/* while ((ch = getopt(argc, argv, "ck:l:ps")) != -1) */
275	/* switch(ch) { */	270	/* switch(ch) { */
276	/* case 'c': */	271	/* case 'c': */
277	/* /\* */	272	/* /\* */
278	/* * this means: */	273	/* * this means: */
279	/* * - rotate the other way; */	274	/* * - rotate the other way; */
280	/* * - no reverse video. */	275	/* * - no reverse video. */
281	/* \/ /	276	/* \/ /
282	/* classic = 1; */	277	/* classic = 1; */
283	/* break; */	278	/* break; */
284	/* case 'k': */	279	/* case 'k': */
285	/* if (strlen(keys = optarg) != 6) */	280	/* if (strlen(keys = optarg) != 6) */
286	/* usage(); */	281	/* usage(); */
287	/* break; */	282	/* break; */
288	/* case 'l': */	283	/* case 'l': */
289	/* level = (int)strtonum(optarg, MINLEVEL, MAXLEVEL, */	284	/* level = (int)strtonum(optarg, MINLEVEL, MAXLEVEL, */
290	/* &errstr); */	285	/* &errstr); */
291	/* if (errstr) */	286	/* if (errstr) */
292	/* errx(1, "level must be from %d to %d", */	287	/* errx(1, "level must be from %d to %d", */
293	/* MINLEVEL, MAXLEVEL); */	288	/* MINLEVEL, MAXLEVEL); */
294	/* break; */	289	/* break; */
295	/* case 'p': */	290	/* case 'p': */
296	/* showpreview = 1; */	291	/* showpreview = 1; */
297	/* break; */	292	/* break; */
298	/* case 's': */	293	/* case 's': */
299	/* showscores(0); */	294	/* showscores(0); */
300	/* exit(0); */	295	/* exit(0); */
301	/* default: */	296	/* default: */
302	/* usage(); */	297	/* usage(); */
303	/* } */	298	/* } */
304		299
305	/* argc -= optind; */	300	/* argc -= optind; */
306	/* argv += optind; */	301	/* argv += optind; */
307		302
308	/* if (argc) */	303	/* if (argc) */
309	/* usage(); */	304	/* usage(); */
310		305
311		306
312		307
313	for (i = 0; i <= 5; i++) {	308	for (i = 0; i <= 5; i++) {
314	for (j = i+1; j <= 5; j++) {	309	for (j = i+1; j <= 5; j++) {
315	if (keys[i] == keys[j])	310	if (keys[i] == keys[j])
316	errx(1, "duplicate command keys specified.");	311	errx(1, "duplicate command keys specified.");
317	}	312	}
318	if (keys[i] == ' ')	313	if (keys[i] == ' ')
319	strncpy(key_write[i], "<space>", sizeof key_write[i]);	314	strncpy(key_write[i], "<space>", sizeof key_write[i]);
320	else {	315	else {
321	key_write[i][0] = keys[i];	316	key_write[i][0] = keys[i];
322	key_write[i][1] = '\0';	317	key_write[i][1] = '\0';
323	}	318	}
324	}	319	}
325		320
326	snprintf(key_msg, sizeof key_msg,	321	snprintf(key_msg, sizeof key_msg,
327	"%s - left %s - rotate %s - right %s - drop %s - pause %s - quit",	322	"%s - left %s - rotate %s - right %s - drop %s - pause %s - quit",
328	key_write[0], key_write[1], key_write[2], key_write[3],	323	key_write[0], key_write[1], key_write[2], key_write[3],
329	key_write[4], key_write[5]);	324	key_write[4], key_write[5]);
330		325
331	scr_init();	326	scr_init();
332	initscores();	327	initscores();
333	while (tetris_menu(&level)) {	328	while (tetris_menu(&level)) {
334	fallrate = 1000000 / level;	329	fallrate = 1000000 / level;
335		330
336	scr_clear();	331	scr_clear();
337	setup_board();	332	setup_board();
338		333
339	srandomdev();	334	srandomdev();
340	scr_set();	335	scr_set();
341		336
342	pos = A_FIRST*B_COLS + (B_COLS/2)-1;	337	pos = A_FIRST*B_COLS + (B_COLS/2)-1;
343	nextshape = randshape();	338	nextshape = randshape();
344	curshape = randshape();	339	curshape = randshape();
345		340
346	scr_msg(key_msg, 1);	341	scr_msg(key_msg, 1);
347		342
348	for (;;) {	343	for (;;) {
349	place(curshape, pos, 1);	344	place(curshape, pos, 1);
350	scr_update();	345	scr_update();
351	place(curshape, pos, 0);	346	place(curshape, pos, 0);
352	c = tgetchar();	347	c = tgetchar();
353	if (c < 0) {	348	if (c < 0) {
354	/*	349	/*
355	* Timeout. Move down if possible.	350	* Timeout. Move down if possible.
356	*/	351	*/
357	if (fits_in(curshape, pos + B_COLS)) {	352	if (fits_in(curshape, pos + B_COLS)) {
358	pos += B_COLS;	353	pos += B_COLS;
359	continue;	354	continue;
360	}	355	}
361		356
362	/*	357	/*
363	* Put up the current shape `permanently',	358	* Put up the current shape `permanently',
364	* bump score, and elide any full rows.	359	* bump score, and elide any full rows.
365	*/	360	*/
366	place(curshape, pos, 1);	361	place(curshape, pos, 1);
367	score++;	362	score++;
368	elide();	363	elide();
369		364
370	/*	365	/*
371	* Choose a new shape. If it does not fit,	366	* Choose a new shape. If it does not fit,
372	* the game is over.	367	* the game is over.
373	*/	368	*/
374	curshape = nextshape;	369	curshape = nextshape;
375	nextshape = randshape();	370	nextshape = randshape();
376	pos = A_FIRST*B_COLS + (B_COLS/2)-1;	371	pos = A_FIRST*B_COLS + (B_COLS/2)-1;
377	if (!fits_in(curshape, pos))	372	if (!fits_in(curshape, pos))
378	break;	373	break;
379	continue;	374	continue;
380	}	375	}
381		376
382	/*	377	/*
383	* Handle command keys.	378	* Handle command keys.
384	*/	379	*/
385	if (c == keys[5]) {	380	if (c == keys[5]) {
386	/* quit */	381	/* quit */
387	break;	382	break;
388	}	383	}
389	if (c == keys[4]) {	384	if (c == keys[4]) {
390	static char msg[] =	385	static char msg[] =
391	"paused - press RETURN to continue";	386	"paused - press RETURN to continue";
392		387
393	place(curshape, pos, 1);	388	place(curshape, pos, 1);
394	do {	389	do {
395	scr_update();	390	scr_update();
396	scr_msg(key_msg, 0);	391	scr_msg(key_msg, 0);
397	scr_msg(msg, 1);	392	scr_msg(msg, 1);
398	// (void) fflush(stdout);	393	// (void) fflush(stdout);
399	} while (rwait((struct timeval *)NULL) == -1);	394	} while (rwait((struct timeval *)NULL) == -1);
400	scr_msg(msg, 0);	395	scr_msg(msg, 0);
401	scr_msg(key_msg, 1);	396	scr_msg(key_msg, 1);
402	place(curshape, pos, 0);	397	place(curshape, pos, 0);
403	continue;	398	continue;
404	}	399	}
405	if (c == keys[0]) {	400	if (c == keys[0]) {
406	/* move left */	401	/* move left */
407	if (fits_in(curshape, pos - 1))	402	if (fits_in(curshape, pos - 1))
408	pos--;	403	pos--;
409	continue;	404	continue;
410	}	405	}
411	if (c == keys[1]) {	406	if (c == keys[1]) {
412	/* turn */	407	/* turn */
413	const struct shape *new = &shapes[	408	const struct shape *new = &shapes[
414	classic? curshape->rotc : curshape->rot];	409	classic? curshape->rotc : curshape->rot];
415		410
416	if (fits_in(new, pos))	411	if (fits_in(new, pos))
417	curshape = new;	412	curshape = new;
418	continue;	413	continue;
419	}	414	}
420	if (c == keys[2]) {	415	if (c == keys[2]) {
421	/* move right */	416	/* move right */
422	if (fits_in(curshape, pos + 1))	417	if (fits_in(curshape, pos + 1))
423	pos++;	418	pos++;
424	continue;	419	continue;
425	}	420	}
426	if (c == keys[3]) {	421	if (c == keys[3]) {
427	/* move to bottom */	422	/* move to bottom */
428	while (fits_in(curshape, pos + B_COLS)) {	423	while (fits_in(curshape, pos + B_COLS)) {
429	pos += B_COLS;	424	pos += B_COLS;
430	score++;	425	score++;
431	}	426	}
432	continue;	427	continue;
433	}	428	}
434	if (c == '\f') {	429	if (c == '\f') {
435	scr_clear();	430	scr_clear();
436	scr_msg(key_msg, 1);	431	scr_msg(key_msg, 1);
437	}	432	}
438	}	433	}
439		434
440	scr_clear();	435	scr_clear();
441	insertscore(score, level);	436	insertscore(score, level);
442	score=0;	437	score=0;
443	}	438	}
444		439
445	scr_clear();	440	scr_clear();
446	printf("\n\n\n\t\tGame over.\n");	441	printf("\n\n\n\t\tGame over.\n");
447	/*	442	/*
448	while ((i = getchar()) != '\n')	443	while ((i = getchar()) != '\n')
449	if (i == EOF)	444	if (i == EOF)
450	break	445	break
451	*/	446	*/
452	scr_end();	447	scr_end();
-		448
453	exit(0);	449	return 0;
454	}	450	}
455		451
456	/* void */	452	/* void */
457	/* onintr(int signo) */	453	/* onintr(int signo) */
458	/* { */	454	/* { */
459	/* scr_clear(); /\* XXX signal race \/ /	455	/* scr_clear(); /\* XXX signal race \/ /
460	/* scr_end(); /\* XXX signal race \/ /	456	/* scr_end(); /\* XXX signal race \/ /
461	/* _exit(0); */	457	/* _exit(0); */
462	/* } */	458	/* } */
463		459
464	void	460	void
465	usage(void)	461	usage(void)
466	{	462	{
467	(void)fprintf(stderr, "usage: tetris [-ps] [-k keys] [-l level]\n");	463	(void)fprintf(stderr, "usage: tetris [-ps] [-k keys] [-l level]\n");
468	exit(1);	464	exit(1);
469	}	465	}
470		466
471	/** @}	467	/** @}
472	*/	468	*/
473		469
474		470

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/tetris/tetris.c – Rev 1710 → 1721