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