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_scores(int firstgame)
{
}
 
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];
    const char *errstr;
    int ch, 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();
    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 1688	Rev 1710
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)	168	static void tetris_scores(int firstgame)
169	{	169	{
170	}	170	}
171		171
172	static void tetris_menu_draw(int level)	172	static void tetris_menu_draw(int level)
173	{	173	{
174	clear_screen();	174	clear_screen();
175	moveto(5,10);	175	moveto(5,10);
176	puts("Tetris\n\n");	176	puts("Tetris\n\n");
177		177
178	moveto(8,10);	178	moveto(8,10);
179	printf("Level = %d (press keys 1 - 9 to change)",level);	179	printf("Level = %d (press keys 1 - 9 to change)",level);
180	moveto(9,10);	180	moveto(9,10);
181	printf("Preview is %s (press 'p' to change)", (showpreview?"on ":"off"));	181	printf("Preview is %s (press 'p' to change)", (showpreview?"on ":"off"));
182	moveto(12,10);	182	moveto(12,10);
183	printf("Press 'h' to show hiscore table.");	183	printf("Press 'h' to show hiscore table.");
184	moveto(13,10);	184	moveto(13,10);
185	printf("Press 's' to start game.");	185	printf("Press 's' to start game.");
186	moveto(14,10);	186	moveto(14,10);
187	printf("Press 'q' to quit game.");	187	printf("Press 'q' to quit game.");
188	moveto(20,10);	188	moveto(20,10);
189	printf("In game controls:");	189	printf("In game controls:");
190	moveto(21,0);	190	moveto(21,0);
191	puts(key_msg);	191	puts(key_msg);
192	}	192	}
193		193
194	static int tetris_menu(int *level)	194	static int tetris_menu(int *level)
195	{	195	{
196	static int firstgame = 1;	196	static int firstgame = 1;
197	int i;	197	int i;
198	/* if (showpreview == 0)	198	/* if (showpreview == 0)
199	(void)printf("Your score: %d point%s x level %d = %d\n",	199	(void)printf("Your score: %d point%s x level %d = %d\n",
200	score, score == 1 ? "" : "s", level, score * level);	200	score, score == 1 ? "" : "s", level, score * level);
201	else {	201	else {
202	(void)printf("Your score: %d point%s x level %d x preview penalty %0.3f = %d\n",	202	(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,	203	score, score == 1 ? "" : "s", level, (double)PRE_PENALTY,
204	(int)(score * level * PRE_PENALTY));	204	(int)(score * level * PRE_PENALTY));
205	score = score * PRE_PENALTY;	205	score = score * PRE_PENALTY;
206	}	206	}
207	savescore(level);	207	savescore(level);
208		208
209	showscores(level);	209	showscores(level);
210		210
211	printf("\nHit 's' to new game, 'q' to quit.\n");	211	printf("\nHit 's' to new game, 'q' to quit.\n");
212	*/	212	*/
213	tetris_menu_draw(*level);	213	tetris_menu_draw(*level);
214	while (1) {	214	while (1) {
215		215
216	i = getchar();	216	i = getchar();
217		217
218	switch(i) {	218	switch(i) {
219	case 'p':	219	case 'p':
220	showpreview = !showpreview;	220	showpreview = !showpreview;
221	moveto(9,21);	221	moveto(9,21);
222	if (showpreview)	222	if (showpreview)
223	printf("on ");	223	printf("on ");
224	else	224	else
225	printf("off");	225	printf("off");
226		226
227	break;	227	break;
228	case 'h':	228	case 'h':
229	showscores(firstgame);	229	showscores(firstgame);
230	tetris_menu_draw(*level);	230	tetris_menu_draw(*level);
231	break;	231	break;
232	case 's':	232	case 's':
233	firstgame = 0;	233	firstgame = 0;
234	return 1;	234	return 1;
235	case 'q':	235	case 'q':
236	return 0;	236	return 0;
237	case '1':	237	case '1':
238	case '2':	238	case '2':
239	case '3':	239	case '3':
240	case '4':	240	case '4':
241	case '5':	241	case '5':
242	case '6':	242	case '6':
243	case '7':	243	case '7':
244	case '8':	244	case '8':
245	case '9':	245	case '9':
246	*level = i - '0';	246	*level = i - '0';
247	moveto(8,18);	247	moveto(8,18);
248	printf("%d", *level);	248	printf("%d", *level);
249	break;	249	break;
250	}	250	}
251	}	251	}
252		252
253	}	253	}
254		254
255	int	255	int
256	main(int argc, char *argv[])	256	main(int argc, char *argv[])
257	{	257	{
258	int pos, c;	258	int pos, c;
259	char *keys;	259	char *keys;
260	int level = 2;	260	int level = 2;
261	char key_write[6][10];	261	char key_write[6][10];
262	const char *errstr;	262	const char *errstr;
263	int ch, i, j;	263	int ch, i, j;
264		264
265	keys = "jkl pq";	265	keys = "jkl pq";
266		266
267	// gid = getgid();	267	// gid = getgid();
268	// egid = getegid();	268	// egid = getegid();
269	// setegid(gid);	269	// setegid(gid);
270		270
271	classic = 0;	271	classic = 0;
272	showpreview = 1;	272	showpreview = 1;
273		273
274	/* while ((ch = getopt(argc, argv, "ck:l:ps")) != -1) */	274	/* while ((ch = getopt(argc, argv, "ck:l:ps")) != -1) */
275	/* switch(ch) { */	275	/* switch(ch) { */
276	/* case 'c': */	276	/* case 'c': */
277	/* /\* */	277	/* /\* */
278	/* * this means: */	278	/* * this means: */
279	/* * - rotate the other way; */	279	/* * - rotate the other way; */
280	/* * - no reverse video. */	280	/* * - no reverse video. */
281	/* \/ /	281	/* \/ /
282	/* classic = 1; */	282	/* classic = 1; */
283	/* break; */	283	/* break; */
284	/* case 'k': */	284	/* case 'k': */
285	/* if (strlen(keys = optarg) != 6) */	285	/* if (strlen(keys = optarg) != 6) */
286	/* usage(); */	286	/* usage(); */
287	/* break; */	287	/* break; */
288	/* case 'l': */	288	/* case 'l': */
289	/* level = (int)strtonum(optarg, MINLEVEL, MAXLEVEL, */	289	/* level = (int)strtonum(optarg, MINLEVEL, MAXLEVEL, */
290	/* &errstr); */	290	/* &errstr); */
291	/* if (errstr) */	291	/* if (errstr) */
292	/* errx(1, "level must be from %d to %d", */	292	/* errx(1, "level must be from %d to %d", */
293	/* MINLEVEL, MAXLEVEL); */	293	/* MINLEVEL, MAXLEVEL); */
294	/* break; */	294	/* break; */
295	/* case 'p': */	295	/* case 'p': */
296	/* showpreview = 1; */	296	/* showpreview = 1; */
297	/* break; */	297	/* break; */
298	/* case 's': */	298	/* case 's': */
299	/* showscores(0); */	299	/* showscores(0); */
300	/* exit(0); */	300	/* exit(0); */
301	/* default: */	301	/* default: */
302	/* usage(); */	302	/* usage(); */
303	/* } */	303	/* } */
304		304
305	/* argc -= optind; */	305	/* argc -= optind; */
306	/* argv += optind; */	306	/* argv += optind; */
307		307
308	/* if (argc) */	308	/* if (argc) */
309	/* usage(); */	309	/* usage(); */
310		310
311		311
312		312
313	for (i = 0; i <= 5; i++) {	313	for (i = 0; i <= 5; i++) {
314	for (j = i+1; j <= 5; j++) {	314	for (j = i+1; j <= 5; j++) {
315	if (keys[i] == keys[j])	315	if (keys[i] == keys[j])
316	errx(1, "duplicate command keys specified.");	316	errx(1, "duplicate command keys specified.");
317	}	317	}
318	if (keys[i] == ' ')	318	if (keys[i] == ' ')
319	strncpy(key_write[i], "<space>", sizeof key_write[i]);	319	strncpy(key_write[i], "<space>", sizeof key_write[i]);
320	else {	320	else {
321	key_write[i][0] = keys[i];	321	key_write[i][0] = keys[i];
322	key_write[i][1] = '\0';	322	key_write[i][1] = '\0';
323	}	323	}
324	}	324	}
325		325
326	snprintf(key_msg, sizeof key_msg,	326	snprintf(key_msg, sizeof key_msg,
327	"%s - left %s - rotate %s - right %s - drop %s - pause %s - quit",	327	"%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],	328	key_write[0], key_write[1], key_write[2], key_write[3],
329	key_write[4], key_write[5]);	329	key_write[4], key_write[5]);
330		330
331	scr_init();	331	scr_init();
332	initscores();	332	initscores();
333	while (tetris_menu(&level)) {	333	while (tetris_menu(&level)) {
334	fallrate = 1000000 / level;	334	fallrate = 1000000 / level;
335		335
336	scr_clear();	336	scr_clear();
337	setup_board();	337	setup_board();
338		338
339	srandomdev();	339	srandomdev();
340	scr_set();	340	scr_set();
341		341
342	pos = A_FIRST*B_COLS + (B_COLS/2)-1;	342	pos = A_FIRST*B_COLS + (B_COLS/2)-1;
343	nextshape = randshape();	343	nextshape = randshape();
344	curshape = randshape();	344	curshape = randshape();
345		345
346	scr_msg(key_msg, 1);	346	scr_msg(key_msg, 1);
347		347
348	for (;;) {	348	for (;;) {
349	place(curshape, pos, 1);	349	place(curshape, pos, 1);
350	scr_update();	350	scr_update();
351	place(curshape, pos, 0);	351	place(curshape, pos, 0);
352	c = tgetchar();	352	c = tgetchar();
353	if (c < 0) {	353	if (c < 0) {
354	/*	354	/*
355	* Timeout. Move down if possible.	355	* Timeout. Move down if possible.
356	*/	356	*/
357	if (fits_in(curshape, pos + B_COLS)) {	357	if (fits_in(curshape, pos + B_COLS)) {
358	pos += B_COLS;	358	pos += B_COLS;
359	continue;	359	continue;
360	}	360	}
361		361
362	/*	362	/*
363	* Put up the current shape `permanently',	363	* Put up the current shape `permanently',
364	* bump score, and elide any full rows.	364	* bump score, and elide any full rows.
365	*/	365	*/
366	place(curshape, pos, 1);	366	place(curshape, pos, 1);
367	score++;	367	score++;
368	elide();	368	elide();
369		369
370	/*	370	/*
371	* Choose a new shape. If it does not fit,	371	* Choose a new shape. If it does not fit,
372	* the game is over.	372	* the game is over.
373	*/	373	*/
374	curshape = nextshape;	374	curshape = nextshape;
375	nextshape = randshape();	375	nextshape = randshape();
376	pos = A_FIRST*B_COLS + (B_COLS/2)-1;	376	pos = A_FIRST*B_COLS + (B_COLS/2)-1;
377	if (!fits_in(curshape, pos))	377	if (!fits_in(curshape, pos))
378	break;	378	break;
379	continue;	379	continue;
380	}	380	}
381		381
382	/*	382	/*
383	* Handle command keys.	383	* Handle command keys.
384	*/	384	*/
385	if (c == keys[5]) {	385	if (c == keys[5]) {
386	/* quit */	386	/* quit */
387	break;	387	break;
388	}	388	}
389	if (c == keys[4]) {	389	if (c == keys[4]) {
390	static char msg[] =	390	static char msg[] =
391	"paused - press RETURN to continue";	391	"paused - press RETURN to continue";
392		392
393	place(curshape, pos, 1);	393	place(curshape, pos, 1);
394	do {	394	do {
395	scr_update();	395	scr_update();
396	scr_msg(key_msg, 0);	396	scr_msg(key_msg, 0);
397	scr_msg(msg, 1);	397	scr_msg(msg, 1);
398	// (void) fflush(stdout);	398	// (void) fflush(stdout);
399	} while (rwait((struct timeval *)NULL) == -1);	399	} while (rwait((struct timeval *)NULL) == -1);
400	scr_msg(msg, 0);	400	scr_msg(msg, 0);
401	scr_msg(key_msg, 1);	401	scr_msg(key_msg, 1);
402	place(curshape, pos, 0);	402	place(curshape, pos, 0);
403	continue;	403	continue;
404	}	404	}
405	if (c == keys[0]) {	405	if (c == keys[0]) {
406	/* move left */	406	/* move left */
407	if (fits_in(curshape, pos - 1))	407	if (fits_in(curshape, pos - 1))
408	pos--;	408	pos--;
409	continue;	409	continue;
410	}	410	}
411	if (c == keys[1]) {	411	if (c == keys[1]) {
412	/* turn */	412	/* turn */
413	const struct shape *new = &shapes[	413	const struct shape *new = &shapes[
414	classic? curshape->rotc : curshape->rot];	414	classic? curshape->rotc : curshape->rot];
415		415
416	if (fits_in(new, pos))	416	if (fits_in(new, pos))
417	curshape = new;	417	curshape = new;
418	continue;	418	continue;
419	}	419	}
420	if (c == keys[2]) {	420	if (c == keys[2]) {
421	/* move right */	421	/* move right */
422	if (fits_in(curshape, pos + 1))	422	if (fits_in(curshape, pos + 1))
423	pos++;	423	pos++;
424	continue;	424	continue;
425	}	425	}
426	if (c == keys[3]) {	426	if (c == keys[3]) {
427	/* move to bottom */	427	/* move to bottom */
428	while (fits_in(curshape, pos + B_COLS)) {	428	while (fits_in(curshape, pos + B_COLS)) {
429	pos += B_COLS;	429	pos += B_COLS;
430	score++;	430	score++;
431	}	431	}
432	continue;	432	continue;
433	}	433	}
434	if (c == '\f') {	434	if (c == '\f') {
435	scr_clear();	435	scr_clear();
436	scr_msg(key_msg, 1);	436	scr_msg(key_msg, 1);
437	}	437	}
438	}	438	}
439		439
440	scr_clear();	440	scr_clear();
441	insertscore(score, level);	441	insertscore(score, level);
-		442	score=0;
442	}	443	}
443		444
444	scr_clear();	445	scr_clear();
445	printf("\n\n\n\t\tGame over.\n");	446	printf("\n\n\n\t\tGame over.\n");
446	/*	447	/*
447	while ((i = getchar()) != '\n')	448	while ((i = getchar()) != '\n')
448	if (i == EOF)	449	if (i == EOF)
449	break	450	break
450	*/	451	*/
451	scr_end();	452	scr_end();
452	exit(0);	453	exit(0);
453	}	454	}
454		455
455	/* void */	456	/* void */
456	/* onintr(int signo) */	457	/* onintr(int signo) */
457	/* { */	458	/* { */
458	/* scr_clear(); /\* XXX signal race \/ /	459	/* scr_clear(); /\* XXX signal race \/ /
459	/* scr_end(); /\* XXX signal race \/ /	460	/* scr_end(); /\* XXX signal race \/ /
460	/* _exit(0); */	461	/* _exit(0); */
461	/* } */	462	/* } */
462		463
463	void	464	void
464	usage(void)	465	usage(void)
465	{	466	{
466	(void)fprintf(stderr, "usage: tetris [-ps] [-k keys] [-l level]\n");	467	(void)fprintf(stderr, "usage: tetris [-ps] [-k keys] [-l level]\n");
467	exit(1);	468	exit(1);
468	}	469	}
469		470
470	/** @}	471	/** @}
471	*/	472	*/
472		473
473		474

Subversion Repositories HelenOS-historic

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