Printable View
Okay, I'm thinking of cracking out a little tetris like blocks game. So what's everyone's "favorite" method of doing tetris-like rotations in a game?
- Pre-rotated arrays
- Code left/right/straight and rotate relative to starting block
- something I missed?
If you put up your image or grids in advance, then the game has the greatest responsiveness for the player. I prefer images done in advance, myself.
I'm going to guess, from your other programs, that you'll be using a text mode here. In that case, rotating a 2D array of say 4x4 elements would take no time at all -- but it would also take very little memory should you decide to pre-rotate them. (I would rotate them with your program as it initializes, not by hand, though.) You should use whatever is easier, I guess.
I would definitely not have any rotation-specific code, however.
I'd be interested to see what you come up with. :)
Since most tetris pieces have 2 orientations you could simply hard code them. You can place the patterns into an array and use the array to later draw the pattern based on current orientation. There will be some rare edge cases that won't completely fit this paradigm which you will have to account for.
Oh, you will.Quote:
Originally Posted by dwks
And bubba, two of the pieces of 4 rotations (the 'L's), four of them have 2 rotations (the 'T', the two zig zags, and the straight) and one of them only has 1 rotation (the square). But the basic idea is that they all have 4.
I would say hard code them. There aren't many different orientations to deal with, so generating a function to rotate the images seems a little unnecessary if you ask me.
I'd be tempted to follow Swarvy's advice - however, I think there are four variants of the T shape as well - the "down" bar of a normal T can point right, up, left and down. [But I've got confused about rotation of stuff before].
It would be fairly easy to come up with a data structure defining the different rotation states of the shapes. Just let all four possible states be represented, that makes the code nice and generic - there will be very little difference in changing the shape and keeping the old shape for those that have less than 4 states - the extra comparison needed will cost almost as much as assigning a new pointer, and pretty often the shape is changing anyways.
--
Mats
Doh! I knew that. I did.Quote:
Originally Posted by matsp
Know what, I'm going to have the program rotate it so I can reserve my data declarations for the "neutral" position of the pieces, that way I can add as many pieces as I want. What's more, I'm going to define nested the "wrong" way so that in my code the shapes themselves can be distinguished, just to be difficult.
One thing to keep in mind is your axis of rotation. For example, when the longest "I" piece is rotated, you probably don't want it rotated on the upper left corner of the shape. Perhaps the second . . . block from the left would stay in place as the object was rotated, but not the block in the corner.
That was probably pretty confusing. Here's what I mean. You might not want this:
->Code:****
----
----
----
As opposed to this:Code:*---
*---
*---
*---
->Code:----
****
----
----
Then again, maybe you do. :)Code:-*--
-*--
-*--
-*--
I told my wife that I felt really bad not having time to program and that I really wanted to make this Tetris program. So she loving took the kids to see grandma and gave me some consecutive hours to get started. I finished it up after she went to bed because I'm up with a cough so basically this was done in one marathon session.
Scroll to the bottom, I got some notes there.
If you see anything obviously less efficient or just plain wrong lemme know.
This is only my second curses program and the first time I've used curses WINDOWS*. The learning curve was steep and probably represented the largest portion of my time. (That, and errors brought up because I want to do my stuff in X,Y and curses does everything Y,X.) My one complaint about WINDOWS*s is the admonition in the documentation NOT to overlap windows. i would love to make the background something other than plain black but I don't want to deal with painting around the already established windows. Ah well, I can live with it, I guess.Code:/* Blocks by Joseph Larson ver 4 April 2008*/
#include <curses.h>
#include <stdlib.h>
#include <time.h>
#define WIDTH 10
#define HEIGHT 20
#define PIECES 8
#define CLEARBLOCKS drawpiece (nwin, next, rot, (level + 1) % 8, 1, 2);\
drawpiece (pwin, piece, rot, level % 8, y, x);
#define DRAWBLOCKS drawpiece (nwin, next, rot, next % 8 + 8, 1, 2);\
drawpiece (pwin, piece, rot, piece % 8 + 8, y, x);
#define REF wrefresh (pwin); wrefresh (nwin);
char blocks[4][PIECES][4] = // [line][shape][col]
{{".X..",".X..",".XX.","..X.",".X..",".X..","....",".XX."},
{".XX.",".X..",".X..",".XX.",".XX.",".X..",".XX.",".X.."},
{".X..",".XX.",".X..",".X..","..X.",".X..",".XX.",".XX."},
{"....","....","....","....","....",".X..","....","...."}};
int buf[HEIGHT + 1][WIDTH + 2];
WINDOW *pwin, *nwin, *iwin, *bwin;
int wfillrect(WINDOW *w, int sy, int sx, int height, int width){
int x, y;
for (x = sx; x < (sx+width); x++){
for (y = sy; y < (sy+height); y++){
mvwaddch (w, y, x, ' ');
}
}
}
int rx (int r, int y, int x) {
switch (r) {
case 0 : return x; break;
case 1 : return y; break;
case 2 : return 3 - x; break;
case 3 : return 3 - y; break;
}
return 0;
}
int clip (int p, int r, int y, int x) {
int c, d;
for (d = 0; d < 4; d++) for (c = 0; c < 4; c++)
if (blocks[rx(r, d, c)][p][rx((r + 1) % 4, d, c)] != '.')
if (buf[d + y][c + x - 1]) return 1;
return 0;
}
void drawpiece (WINDOW *w, int p, int r, int col, int y, int x) {
int c, d;
wattrset (w, COLOR_PAIR(col));
for (d = 0; d < 4; d++) for (c = 0; c < 4; c++)
if (blocks[rx(r, d, c)][p][rx((r + 1) % 4, d, c)] != '.')
mvwaddstr(w, d + y, (c + x - 1) * 2 - 1, " "); // 2 spaces
}
void init() { // Setup Curses the way we want it.
int c, x, y;
srand (time(NULL));
initscr ();
raw (); nodelay(stdscr,1); noecho(); curs_set(0); nonl(); keypad(stdscr,1);
start_color();
for (c = 0; c < COLORS; c++) init_pair(c, COLOR_WHITE, c);
x = (COLS - WIDTH * 2) / 2 - 1; y = (LINES - HEIGHT) / 2;
clear ();
refresh ();
pwin = newwin(HEIGHT + 1, WIDTH * 2 + 2, y, x);
nwin = newwin(6, 10, y + 2, x - 14);
iwin = newwin(10, 15, y + 10, x - 16);
wattrset (iwin, COLOR_PAIR (8));
box (iwin,0,0);
wfillrect (iwin, 1, 1, 8, 13);
mvwaddstr (iwin, 5, 3, "Use arrow");
mvwaddstr (iwin, 6, 2, "keys to play");
mvwaddstr (iwin, 7, 2, "UP = Rotate");
mvwaddstr (iwin, 8, 2, "'Q' to Quit");
bwin = newwin(LINES - 1, 10, 0, x + WIDTH * 2 + 6);
for (y = 0; y < LINES - 3; y += 2) { // Decorate a bit
c = rand () % PIECES; drawpiece (bwin, c, rand () % 4, c % 8 + 1, y, 2);
}
wrefresh (bwin);
}
void drawplay (int lvl) {
int x, y;
lvl %= 8;
wattrset (pwin, COLOR_PAIR (lvl));
wborder(pwin, 0, 0, ' ', 0, ACS_VLINE, ACS_VLINE, 0, 0);
for (y = 0; y < HEIGHT; y++) for (x = 1; x <= WIDTH; x++) {
wattrset (pwin, COLOR_PAIR((buf[y][x]) ? buf[y][x] : lvl));
mvwaddstr (pwin, y, x * 2 - 1, " ");
}
wattrset (nwin, COLOR_PAIR ((lvl + 1) % 8));
box (nwin,0,0);
wfillrect (nwin, 1, 1, 4, 8);
mvwaddstr (nwin, 0, 3, "NEXT");
}
int clearedlines (int l) {
int x, y, c, d, ret;
ret = 0;
for (y = 0; y < HEIGHT; y++) {
c = 0;
for (x = 1; x <= WIDTH; x++) if (buf[y][x]) c++;
if (c == WIDTH) {
ret++;
for (d = y; d > 0; d--) for (x = 1; x <= WIDTH; x++)
buf[d][x] = buf[d - 1][x];
drawplay (l); REF; beep (); napms(75);
}
}
return ret;
}
int play () {
int piece, rot, x, y, next, level, lines, in, c, d;
double delay;
clock_t start, check;
for (y = 0; y < HEIGHT + 1; y ++) for (x = 0; x < WIDTH + 2; x++)
buf[y][x] = (y < HEIGHT && x > 0 && x < WIDTH + 1) ? 0 : 1;
level = 1; lines = 0; rot = 0; x = WIDTH / 2; y = 0; next = rand () % PIECES;
do {
delay = 1.0 - level * .1;
if (delay < 0.1) delay = 0.1;
piece = next; next = rand () % PIECES;
drawplay (level);
do {
mvwprintw (iwin, 1, 2, "Level : %d", level);
mvwprintw (iwin, 3, 2, "Lines : %d", lines);
wrefresh (iwin);
CLEARBLOCKS; y++; DRAWBLOCKS; REF;
start = clock ();
do {
in = getch();
switch (in) {
case KEY_RIGHT : if (!clip(piece, rot, y, x + 1)) {
CLEARBLOCKS; x++; DRAWBLOCKS; REF;
} break;
case KEY_LEFT : if (!clip(piece, rot, y, x - 1)) {
CLEARBLOCKS; x--; DRAWBLOCKS; REF;
} break;
case KEY_DOWN : CLEARBLOCKS;
while (!clip(piece, rot, y + 1, x)) y++;
DRAWBLOCKS; REF; break;
case KEY_UP : if (!clip(piece, (rot + 1) % 4, y, x)) {
CLEARBLOCKS; rot++; rot %= 4; DRAWBLOCKS; REF;
start = clock ();
} break;
case 'q' : return (lines);
}
check = clock ();
} while ((double)(check - start) / CLOCKS_PER_SEC < delay);
} while (!clip (piece, rot, y + 1, x));
for (d = 0; d < 4; d++) for (c = 0; c < 4; c++) // commit piece to buffer;
if (blocks[rx(rot, d, c)][piece][rx((rot + 1) % 4, d, c)] != '.')
buf[d + y][c + x - 1] = piece + 8;
drawplay (level);
REF;
lines += clearedlines(level);
level = lines / 10 + 1;
x = WIDTH / 2; y = 0;
} while (!clip (next, rot, y, x));
drawpiece (pwin, next, rot, next % 8 + 8, y, x);
return (lines);
}
int again (int hs) {
int x, y, ch;
wattrset (pwin, COLOR_PAIR (9));
y = (HEIGHT - 11) / 2; x = (WIDTH - 6);
wfillrect (pwin, y, x, 11, 13);
mvwprintw (pwin, y + 1, x + 1, "High Score:");
mvwprintw (pwin, y + 3, x + 3, " %d lines", hs);
mvwprintw (pwin, y + 6, x + 1, "Do you want");
mvwprintw (pwin, y + 7, x + 3, "to play");
mvwprintw (pwin, y + 8, x + 4, "again");
mvwprintw (pwin, y + 9, x + 4, "(Y/N)");
wrefresh (pwin);
do {ch = getch();}
while ((ch != 'q') && (ch != 'Q')
&& (ch != 'n') && (ch != 'N')
&& (ch != 'y') && (ch != 'Y'));
if ((ch == 'y') || (ch == 'Y')) return 1;
else return 0;
}
int main () {
int highscore;
init();
do {highscore = play ();} while (again (highscore));
endwin();
}
The I knew making the pieces apparent in the code would mean the indexing would get muddled, but the shape index being between the line and column number? Come on! Ah well, that's the price for being able to add/change any piece with the minimum of work. It's so easy I decided to add one, just to make my game different. I resisted the urge to throw in every pentomino that would fit in a 4x4 square. (I count 11.) Maybe I'll do that later. Instead of tetris, pentris.
The rx() function is the one that converts y,x in the data array to a rotated shape on the game board. Originally there was a ry() as well, but strangely enough it was superfluous because if you incremented the rotation you gave to rx() it acted exactly the same way. It was one of those check-it-three-times-cuz-you-don't-believe-it's-that-easy sort of moments.
Once I had nailed down rotation, actually a bit before that, I thought that having to unrotate the new piece every time wouldn't be hard, but wouldn't it be cooler if the piece in the NEXT window rotated with you? I kinda like the effect.
In case you were wondering, Penttris. Click to download. The game is very interesting. You'll start out good with pieces falling into place, thinking your the bomb, and then you'll get two or three pieces in a row that you just don't have room for. Then you get on top of the mess you've got again just in time to step up a level. This is one of the only games I know where advancing feels like a booby prize. "Oh, you thought that was pretty easy, did ya?" "Well, no, I actually I found it quite..." "WELL TRY THIS OUT!" "Whu?!"
There is technically one tetronimo because the shapes have to fit in a 4x4 grid, so the one straight piece is only 4 long. But it's not a big deal.
Now I'm going to go to bed and in the morning I'll decide if this was as cool an idea as it seems like right now.
New version added. Got to thinking that with pentominos as a puzzle you can flip pieces over. So you can now flip a piece left to right. Consequently some pieces became duplicates and unnecessary. Game play-wise it reduces the almost-just-the-wrong-piece moments a little. Same download.
You can actually do this with another add-on library to ncurses. I believe it is called "panel", as in /usr/include/panel.h and /usr/lib/libpanel.a (-lpanel). I've never tried it, but it looks quite useful.Quote:
My one complaint about WINDOWS*s is the admonition in the documentation NOT to overlap windows.
I have a few comments about your code:
- I don't know what you think about single-line comments, but the fact is that they aren't part of C89. You might want to consider not using them.
- Your indentation on the whole is pretty good, but there are some hiccups (wfillrect() for example).
- Whenever you see code like this
you should immediately think "ctype.h". It makes things a lot easier.Code:do {ch = getch();}
while ((ch != 'q') && (ch != 'Q')
&& (ch != 'n') && (ch != 'N')
&& (ch != 'y') && (ch != 'Y'));
if ((ch == 'y') || (ch == 'Y')) return 1;
switch (r) {
case 0 : return x; break;
case 1 : return y; break;
case 2 : return 3 - x; break;
case 3 : return 3 - y; break;
}
Just a thought.Code:n = (r % 2 ? y : x);
if(r / 2) n = 3 - n;
- Please, please never have a variable called 'l' (lowercase L). It's annoying, and stupid, and hard to read, in my opinion. :)
Also, maybe it's just my ncurses implementation, but I do not see any text at all. (Again, this is a 64-bit Debian GNU/Linux lenny system.)
Something I implemented in my tetris a while back that I always miss in other tetrises is a "shadow" underneath the main block area that shows where the block will land. It helps avoid alignment errors, if you know what I mean. And you could also blink lines before making them disappear if you felt adventurous.
I'd post my tetris3 game, but I think it would be too embarrassing. ;)
Thanks. Seriously every comment was dead on. Inline comments. Duh. I should know better. Ctype! Duh again. And I love your re-write of rx. I hate switch statements when they're not necessary.
As for not seeing text, do you have color? Is it possible I accidentally didn't do color on color properly so that there was, like, gray on gray. I don't think so, but it's possible.
As for a shadow, yeah I could, that'd be easy enough except for 2 things, colors will eventually overlap because the duller colors used for the backgrounds would be used for the shadow of some pieces, and I'm not sure I want to do any more fiddling with it. I did make it so when you dropped you were given a second more to position your piece, but that's about all I'll do for now.
Meh, who am I kidding? I'll start on it next week and it'll be shadowed by Tuesday.
[shaking fist at dwks] Thanks for nothing. I mean about that shadow thing. You knew I wouldn't be able to resists. *sigh* at least it wasn't too much more. I think about 5 lines of code once it was all said and done. Then I had to make them optional. Then I had to make the next window optional. THEN I had to update the information window which took a little fandangling. Then I had to update penttris. So from my computer at 4am I say a very sarcastic "thank you veeeeery much."
Lemme post the "final" code. As usual, if you spot anything...
I'm probably going to post a stripped down version that shaved more than 1k off the code on the site to avoid a too-long program.Code:/* Blocks by Joseph Larson ver 7 April 2008*/
#include <curses.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>
#define WIDTH 10
#define HEIGHT 20
#define PIECES 8
#define CLEARBLOCKS c = 0; while (!clip(piece, rot, y + c, x)) c++; c--; \
drawpiece (pwin, piece, rot, level, y + c, x); \
drawpiece (nwin, next, rot, (level + 1) % 8, 1, 2); \
drawpiece (pwin, piece, rot, level % 8, y, x);
#define DRAWBLOCKS c = 0; while (!clip(piece, rot, y + c, x)) c++; c--;\
d = (piece % 8 == level % 8) ? (piece + 1) % 8 : piece % 8; \
if (sop) drawpiece (pwin, piece, rot, d, y + c, x); \
if (nop) drawpiece (nwin, next, rot, next % 8 + 8, 1, 2);\
drawpiece (pwin, piece, rot, piece % 8 + 8, y, x);
#define REF wrefresh (pwin); wrefresh (nwin);
char blocks[4][PIECES][4] = /* [line][shape][col] */
{{".X..",".X..",".XX.","..X.",".X..",".X..","....",".XX."},
{".XX.",".X..",".X..",".XX.",".XX.",".X..",".XX.",".X.."},
{".X..",".XX.",".X..",".X..","..X.",".X..",".XX.",".XX."},
{"....","....","....","....","....",".X..","....","...."}};
int buf[HEIGHT + 1][WIDTH + 2];
WINDOW *pwin, *nwin, *iwin, *bwin;
int wfillrect(WINDOW *w, int sy, int sx, int height, int width){
int x, y;
for (x = sx; x < (sx+width); x++) for (y = sy; y < (sy+height); y++)
mvwaddch (w, y, x, ' ');
}
int rx (int r, int y, int x) {
int n;
n = (r % 2 ? y : x);
if(r / 2) n = 3 - n;
return n;
}
int clip (int p, int r, int y, int x) {
int c, d;
for (d = 0; d < 4; d++) for (c = 0; c < 4; c++)
if (blocks[rx(r, d, c)][p][rx((r + 1) % 4, d, c)] != '.')
if (buf[d + y][c + x - 1]) return 1;
return 0;
}
void drawpiece (WINDOW *w, int p, int r, int col, int y, int x) {
int c, d;
wattrset (w, COLOR_PAIR(col));
for (d = 0; d < 4; d++) for (c = 0; c < 4; c++)
if (blocks[rx(r, d, c)][p][rx((r + 1) % 4, d, c)] != '.')
mvwaddstr(w, d + y, (c + x - 1) * 2 - 1, " "); /* 2 spaces */
}
void init() { /* Setup Curses the way we want it. */
int c, x, y;
srand (time(NULL));
initscr ();
raw (); nodelay(stdscr,1); noecho(); curs_set(0); nonl(); keypad(stdscr,1);
start_color();
for (c = 0; c < COLORS; c++) init_pair(c, COLOR_WHITE, c);
x = (COLS - WIDTH * 2) / 2 - 1; y = (LINES - HEIGHT) / 2;
clear ();
refresh ();
pwin = newwin(HEIGHT + 1, WIDTH * 2 + 2, y, x);
nwin = newwin(6, 10, y + 1, x - 14);
iwin = newwin(12, 15, y + 8, x - 16);
wattrset (iwin, COLOR_PAIR (8));
box (iwin,0,0);
wfillrect (iwin, 1, 1, 10, 13);
mvwaddstr (iwin, 5, 3, "Use arrow");
mvwaddstr (iwin, 6, 2, "keys to play");
mvwaddstr (iwin, 7, 2, "UP = Rotate");
mvwaddstr (iwin, 8, 2, "'N' Next");
mvwaddstr (iwin, 9, 2, "'S' Shadow");
mvwaddstr (iwin, 10, 2, "'Q' to Quit");
bwin = newwin(LINES - 1, 10, 0, x + WIDTH * 2 + 6);
for (y = 0; y < LINES - 3; y += 2) { /* Decorate a bit */
c = rand () % PIECES; drawpiece (bwin, c, rand () % 4, c % 8 + 1, y, 2);
}
wrefresh (bwin);
}
void drawplay (int lvl) {
int x, y;
lvl %= 8;
wattrset (pwin, COLOR_PAIR (lvl));
wborder(pwin, 0, 0, ' ', 0, ACS_VLINE, ACS_VLINE, 0, 0);
for (y = 0; y < HEIGHT; y++) for (x = 1; x <= WIDTH; x++) {
wattrset (pwin, COLOR_PAIR((buf[y][x]) ? buf[y][x] % 8 + 8 : lvl));
mvwaddstr (pwin, y, x * 2 - 1, " ");
}
wattrset (nwin, COLOR_PAIR ((lvl + 1) % 8));
box (nwin,0,0);
wfillrect (nwin, 1, 1, 4, 8);
mvwaddstr (nwin, 0, 3, "NEXT");
}
int clearedlines (int lvl) {
int x, y, c, d, ret;
ret = 0;
for (y = 0; y < HEIGHT; y++) {
c = 0;
for (x = 1; x <= WIDTH; x++) if (buf[y][x]) c++;
if (c == WIDTH) {
ret++;
for (d = y; d > 0; d--) for (x = 1; x <= WIDTH; x++)
buf[d][x] = buf[d - 1][x];
drawplay (lvl); REF; beep (); napms(75);
}
}
return ret;
}
int play () {
int piece, rot, x, y, next, level, lines, in, c, d, nop, sop;
double delay;
clock_t start, check;
for (y = 0; y < HEIGHT + 1; y ++) for (x = 0; x < WIDTH + 2; x++)
buf[y][x] = (y < HEIGHT && x > 0 && x < WIDTH + 1) ? 0 : 1;
level = 1; nop = sop = 1; lines = 0; rot = 0;
x = WIDTH / 2; y = 0; next = rand () % PIECES;
do {
delay = 1.0 - level * .05; if (delay < .2) delay = 0.2;
piece = next; next = rand () % PIECES;
drawplay (level);
do {
mvwprintw (iwin, 1, 2, "Level : %d", level);
mvwprintw (iwin, 3, 2, "Lines : %d", lines);
wrefresh (iwin);
CLEARBLOCKS; y++;
DRAWBLOCKS; REF;
start = clock ();
do {
in = getch();
switch (in) {
case KEY_RIGHT : if (!clip(piece, rot, y, x + 1)) {
CLEARBLOCKS; x++; DRAWBLOCKS; REF;
} break;
case KEY_LEFT : if (!clip(piece, rot, y, x - 1)) {
CLEARBLOCKS; x--; DRAWBLOCKS; REF;
} break;
case KEY_DOWN : CLEARBLOCKS;
while (!clip(piece, rot, y + 1, x)) y++;
DRAWBLOCKS; REF; start = clock (); break;
case KEY_UP : if (!clip(piece, (rot + 1) % 4, y, x)) {
CLEARBLOCKS; rot++; rot %= 4; DRAWBLOCKS; REF;
delay = 1.0 - level * .05;
if (delay < .2) delay = 0.2;
start = clock ();
} break;
case 'n' :
case 'N' : nop = !nop; break;
case 's' :
case 'S' : sop = !sop; break;
case 'q' :
case 'Q' : return (lines);
}
check = clock ();
} while ((double)(check - start) / CLOCKS_PER_SEC < delay);
delay = 1.0 - level * .05; if (delay < .05) delay = 0.05;
} while (!clip (piece, rot, y + 1, x));
for (d = 0; d < 4; d++) for (c = 0; c < 4; c++) /* commit piece to buffer */
if (blocks[rx(rot, d, c)][piece][rx((rot + 1) % 4, d, c)] != '.')
buf[d + y][c + x - 1] = piece + 8;
drawplay (level);
REF;
lines += clearedlines(level);
level = lines / 10 + 1;
x = WIDTH / 2; y = 0;
} while (!clip (next, rot, y, x));
drawpiece (pwin, next, rot, next % 8 + 8, y, x);
return (lines);
}
int again (int hs) {
int x, y, ch;
wattrset (pwin, COLOR_PAIR (9));
y = (HEIGHT - 11) / 2; x = (WIDTH - 6);
wfillrect (pwin, y, x, 11, 13);
mvwprintw (pwin, y + 1, x + 1, "High Score:");
mvwprintw (pwin, y + 3, x + 3, " %d lines", hs);
mvwprintw (pwin, y + 6, x + 1, "Do you want");
mvwprintw (pwin, y + 7, x + 3, "to play");
mvwprintw (pwin, y + 8, x + 4, "again");
mvwprintw (pwin, y + 9, x + 4, "(Y/N)");
wrefresh (pwin);
do {ch = getch();}
while ((tolower(ch) != 'q')&&(tolower(ch) != 'n')&&(tolower(ch) != 'y'));
if (tolower(ch) == 'y') return 1;
else return 0;
}
int main () {
int highscore;
init();
do {highscore = play ();} while (again (highscore));
endwin();
}
That corresponds to wfillrect() and main(). You never use the return value of wfillrect(), and main() doesn't really matter, but I suggest you return 0 from both of those. You could also make wfillrect() return void, but I'm guessting (sorry) that you wanted to match the ncurses style of prototypes and return int. (Assuming that's what it uses.)Code:$ gcc -W -Wall -ansi -pedantic -g block.c -o block -lcurses
block.c: In function ‘wfillrect’:
block.c:34: warning: control reaches end of non-void function
block.c: In function ‘main’:
block.c:211: warning: control reaches end of non-void function
$
The shadow is much nicer than I had envisioned! By "shadow", I just meant the way KSirtet does it. (See attached screenshot.) But yours is even nicer! :) Just one thing: the shadow of the T shape is black on my screen. I'm sure it's just my screen, though. I've attached a screenshot of the game after I've lost (intentionally), to show you the strange colours. (See other attached screenshot.)
Some more comments about the gameplay and such:
- If you keep pressing down, over and over again, the game sort of pauses. It could be considered a cheat, I suppose, since you can get an indefinite break from the game. I'd try to fix it if I were you. Actually, this works for any movement key. Press and hold right or left and watch the fireworks.
[edit] Never mind, I see this was intentional.
[/edit]Quote:
I did make it so when you dropped you were given a second more to position your piece, but that's about all I'll do for now.
- If you press down, you still have time to press left or right and shift the block before it is cemented into place. I'm pretty sure you don't really want this.
- The game always uses 100% of the CPU. I'm sure this isn't really necessary, though it might take another 4 AM programming spree for you to determine this for sure. :)
- You get a big advantage in a larger screen mode. You can see a lot more blocks that are to come. Is this what you wanted? . . . .
- You should consider making "down" move the blocks quickly, but not instantly. That way you could skip ahead if you need to slide a block in sideways or whatever. This is what I did in my tetris game. Note that you'll need to ignore down presses until you get a down keyup event or whatever for the next block, or they'll all come whizzing down, which isn't much fun.
Code comments:
- Your code isn't fully ctype.h'ized! What about that switch(in) statement in play()? . . . .
- You should really have a pause feature. Then I can play, report comments here, and then go back to playing again, and find more bugs and stuff. ;)
- I know you like ugly macros, but how hard is it to use functions instead? I guess you didn't want to pass seven arguments or something, but you could always use a structure or two. (5 AM.)
- I still think your rotation is a bit weird. For example, when a 'T' is flipped, the part that protruded down and now protrudes up has moved. In effect, the whole piece moves one unit to the right. It just feels counter-intuitive to me. (6 AM.)
- Why not make pieces keep their colours once they've fallen down? (You'll never get any sleep at this rate.) Actually, it's not too difficult. Just use ncurses's chtype to store the characters -- chtype stores colour information, as I'm sure you are aware.
From http://www.mkssoftware.com/docs/man3/curs_addch.3.aspQuote:
Video attributes can be combined with a character argument passed to addch() or related functions by logical-ORing them into the character. (Thus, text, including attributes, can be copied from one place to another using inch() and addch().). See the curs_attr() page for values of predefined video attribute constants that can be usefully OR'ed into characters.
- All those mvaddstr()'s in init() and mvprintw()'s in again() would be so much easier like this . . .
You could also make the messages a little more consistent. You have three different formats of specifying keys there. Most of those messages would fit onto one line, too, if you want to save space.Code:const char *message[] = {
" Use arrow",
"keys to play",
"UP = Rotate",
"'N' Next",
"'S' Shadow",
"'Q' to Quit"
};
size_t x;
for(x = 0; x < sizeof(message) / sizeof(*message); x ++) {
mvwaddstr (iwin, 5 + x, 2, message[x]);
}
- Speaking of saving space, I find your practise of putting two for loops on one line disturbing. :)
- In draw_piece():
It seems to me that you don't have to move if you're already in the right place. I'm not sure how efficient ncurses is with moving the cursor to where you already are. Probably very efficient. Forget I said anything. ;)Code:for (d = 0; d < 4; d++) for (c = 0; c < 4; c++)
if (blocks[rx(r, d, c)][p][rx((r + 1) % 4, d, c)] != '.')
mvwaddstr(w, d + y, (c + x - 1) * 2 - 1, " "); /* 2 spaces */
- The handlers for KEY_LEFT and KEY_RIGHT are the same except one uses +1 and the other, -1. Perhaps you could pass either +1 or -1 into a function that handled this . . . .
Glad you like the shadow. I'm really proud of it myself, except what do you mean large screen mode gives you an advantage? The game doesn't decide any but one in advance and should be drawing the screen in the middle of your play field? What you describe shouldn't even be possible.
Many of your game play questions were totally intentional. Rotate causes the piece to "hang", insta-drop, and having a moment to slide pieces in before they cement are all in line with the modern "tournament" versions of Tetris.
As far as using 100% of the CPU, I'm pretty sure that's me using a single main, no threads or anything. Know what, I'm not worried about it. Well, that and I don't know what to do about it.
Most of your code comments I'm gonna blow off. No offense, man, your previous comments were brilliant, but I just don't have another all nighter in me for a while, and I have other projects. The exceptions are going to be that wfillrect should not return a value, main should, and the colors. I took some liberties with the colors and while it works pretty good on my system it appears to have some ill effects on yours. Pieces should keep their colors after they've fallen, the messages should be visible, and what's that big black block in the middle of your screen. In short, there's been some errors going on. Gonna have to fix it. I may need an enum.
I like your solution to the message things, and perhaps i can implement something like that, but probably not on this project. I am absolutely refusing another all nighter.
Sorry, I should have been clearer. I was talking about the "next" blocks on the right-hand side of the screen. In a larger screen mode, you can see more of them.Quote:
Originally Posted by guesst
Mm'kay, I just mentioned them because they're not in any tetris I've ever played, which is admittedly not very many. :)Quote:
Many of your game play questions were totally intentional. Rotate causes the piece to "hang", insta-drop, and having a moment to slide pieces in before they cement are all in line with the modern "tournament" versions of Tetris.
A simple sleep(1) or something would probably fix this, but I don't know of a nice, portable way to do this. Maybe you could implement it with signals. Either way, it would be a bit complicated.Quote:
As far as using 100% of the CPU, I'm pretty sure that's me using a single main, no threads or anything. Know what, I'm not worried about it. Well, that and I don't know what to do about it.
Yes, well, it could just be my system. If I remember correctly, which I may not, you can use up to 16 colours from ncurses, and only the first 8 are guaranteed to be the same across systems.Quote:
Most of your code comments I'm gonna blow off. No offense, man, your previous comments were brilliant, but I just don't have another all nighter in me for a while, and I have other projects. The exceptions are going to be that wfillrect should not return a value, main should, and the colors. I took some liberties with the colors and while it works pretty good on my system it appears to have some ill effects on yours. Pieces should keep their colors after they've fallen, the messages should be visible, and what's that big black block in the middle of your screen. In short, there's been some errors going on. Gonna have to fix it. I may need an enum.
If you say so. :)Quote:
I like your solution to the message things, and perhaps i can implement something like that, but probably not on this project. I am absolutely refusing another all nighter.
Well, good luck anyway. It's a very nice program, much better than my tetris.
I lied. Sure enough, once I set my mind to writing this program... well it's 2:25am right now. I'm just gonna post this before I go to bed.Quote:
Originally Posted by dwks
Okay, it's been a while, but I really needed to rewrite this one. So I stared with a blank file, did some cutting and pasting, but basically I've gone over every inch of this program again. Incorporated a lot of wisdom I've gained and many suggestions; Structs, your message thing (tho the sizeof bits didn't work. Had to fudge it by passing the width) platform independent colors, as well as control suggestions, including space for drop and down for speed down. I still think it's going to eat up 100% as it's running, but at least now it's only doing so in the space of 4 lines. Maybe the processor can optimize it. Maybe not. One thing I couldn't implement was tolower-ing the switch because it affected the DOWN_ARROW and UP_ARROW constants. Curses uses ints for its input. Tolower returns a char.
All in all I'm pleased with this one. I'm gonna fork it and make a striped down version for my site.
If anyone using linux could post me a screen shot, I'd love to see the new color implementation in action.
A fun variation is to change width to 4 (tho is messes with the exit message, hence the attempt to make a temporary window that crashes the second game through for some reason). I'm also going to make it so that an array of pieces are falling one right after the other in a snake. Gonna call it helltris.Code:/* Tetris by Joseph Larson ver 2008-May-01
*/
#include <curses.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>
#include <string.h>
#define WIDTH 10
#define HEIGHT 23
#define PIECES 9
#define BCOL(x) (x % (COLORS / 2)) + (COLORS / 2)
char blocks[4][PIECES][5] = /* [line][shape][col] */
{{".X..",".X..",".XX.","..X.",".X..",".X..","....",".X..","..X."},
{".XX.",".X..",".X..",".XX.",".XX.",".X..",".XX.",".XX.",".XX."},
{".X..",".XX.",".X..",".X..","..X.",".X..",".XX.",".XX.",".XX."},
{"....","....","....","....","....",".X..","....","....","...."}};
int buf[HEIGHT + 1][WIDTH + 2]; /* Buffer for game screen */
WINDOW *pwin, *nwin, *iwin;
typedef struct {
int x, y, rot, piece;
} BRICKTYPE;
char *instruct[10] =
{"Use arrow", "keys to play", "", "UP- Rotate", "DOWN- Faster", "SPACE- Drop",
"S- Shadow", "N- Next", "" ,"Q to Quit"};
char *pausemsg[2] = {" PAUSED", "Press any key"};
char *againmsg[4] = {"Do you want", " to play", " again", " (Y/N)"};
void drawmsg(WINDOW *w, int y, int x, int lines, char **msg) {
int c;
for (c = 0; c < lines; c++)
mvwprintw (w, y + c, x, msg[c]);
}
void wfillrect(WINDOW *w, int sy, int sx, int height, int width){
int x, y;
for (y = sy; y < (sy+height); y++) {
wmove (w, y, sx);
for (x = 0; x < width; x++) waddch (w, ' ');
}
}
int rx (int r, int y, int x) { /* Used for piece rotation. */
int n;
n = (r % 2 ? y : x);
if(r / 2) n = 3 - n;
return n;
}
int clip (BRICKTYPE *b) { /*collision detection */
int c, d;
for (d = 0; d < 4; d++) for (c = 0; c < 4; c++)
if (blocks[rx(b->rot, d, c)][b->piece][rx((b->rot + 1) % 4, d, c)] != '.')
if ((d + b->y < 0) && ((c + b->x - 1 < 1) || (c + b->x - 1 > WIDTH)))
return 1; /* Edge collisions */
else if ((d + b->y >= 0) && (buf[d + b->y][c + b->x - 1])) return 1;
return 0;
}
void init () {
int c, x, y;
srand (time(NULL));
initscr ();
raw (); nodelay(stdscr,1); noecho(); curs_set(0); nonl(); keypad(stdscr,1);
start_color();
for (c = 0; c < COLORS; c++)
if (c == COLOR_WHITE) init_pair(c, COLOR_BLACK, c);
else init_pair(c, COLOR_WHITE, c);
x = (COLS - WIDTH * 2 + 15) / 2 - 1; y = (LINES - HEIGHT) / 2;
clear (); refresh ();
pwin = newwin(HEIGHT + 1, WIDTH * 2 + 2, y, x);
nwin = newwin(6, 10, y + 1, x - 14);
iwin = newwin(15, 15, y + 8, x - 16);
wattrset (iwin, COLOR_PAIR (COLORS / 2));
wfillrect (iwin, 1, 1, 14, 13);
box (iwin, 0,0);
drawmsg (iwin, 4, 1, 10, instruct);
wrefresh (iwin);
}
void drawplay (int lvl) { /* redraws the entire screen. */
int backcol, nextcol, x, y;
backcol = lvl % (COLORS / 2); nextcol = (lvl + 1) % (COLORS / 2);
wattrset (pwin, COLOR_PAIR (backcol));
wborder(pwin, 0, 0, ' ', 0, ACS_VLINE, ACS_VLINE, 0, 0);
for (y = 0; y < HEIGHT; y++) for (x = 1; x <= WIDTH; x++) {
wattrset (pwin, COLOR_PAIR((buf[y][x]) ? buf[y][x] % 8 + 8 : lvl % 8));
mvwaddstr (pwin, y, x * 2 - 1, " ");
}
wattrset (nwin, COLOR_PAIR (nextcol));
box (nwin,0,0);
wfillrect (nwin, 1, 1, 4, 8);
mvwaddstr (nwin, 0, 3, "NEXT");
wrefresh (pwin); wrefresh (nwin);
}
int clearedlines (int lvl) {
int x, y, c, d, ret;
ret = 0;
for (y = 0; y < HEIGHT; y++) {
c = 0;
for (x = 1; x <= WIDTH; x++) if (buf[y][x]) c++;
if (c == WIDTH) {
ret++;
for (d = y; d > 0; d--) for (x = 1; x <= WIDTH; x++)
buf[d][x] = buf[d - 1][x];
drawplay (lvl); wrefresh (pwin); beep (); napms(75);
}
}
return ret;
}
void drawpiece (WINDOW *w, int y, int x, int rot, int piece, int color) {
int c, d;
wattrset (w, COLOR_PAIR (color));
for (d = 0; d < 4; d++) for (c = 0; c < 4; c++)
if (blocks[rx(rot, d, c)][piece][rx((rot + 1) % 4, d, c)] != '.')
mvwaddstr (w, d + y, (c + x - 1) * 2 - 1, " "); /* 2 spaces */
}
int play () {
BRICKTYPE brick, shadow;
int level, next, lines, in, c, d, shadcol, nextop, shadop;
double delay;
clock_t start, check;
level = 1; nextop = shadop = 1; lines = 0;
for (c = 0; c < HEIGHT + 1; c++) for (d = 0; d < WIDTH + 2; d++)
buf[c][d] = (c < HEIGHT && d > 0 && d < WIDTH + 1) ? 0 : 1;
brick.piece = rand () % PIECES;
brick.x = WIDTH / 2;
do { /* Next piece */
delay = 1.0 - level * .05; if (delay < .05) delay = 0.05;
brick.y = -3;
next = rand () % PIECES;
if (brick.piece % (COLORS / 2) == level % (COLORS / 2))
shadcol = (brick.piece + 1) % (COLORS / 2);
else shadcol = brick.piece % (COLORS / 2);
drawplay (level);
mvwprintw (iwin, 1, 2, "Level : %d", level);
mvwprintw (iwin, 2, 2, "Lines : %d", lines);
wrefresh (iwin);
start = clock ();
shadow.piece = brick.piece;
do {
shadow.x = brick.x; shadow.y = brick.y; shadow.rot = brick.rot;
while (!clip(&shadow)) shadow.y++; shadow.y--;
if (nextop) drawpiece (nwin, 1, 2, brick.rot, next, BCOL(next));
if (shadop) drawpiece (pwin, shadow.y, shadow.x, shadow.rot, shadow.piece, shadcol);
drawpiece (pwin, brick.y, brick.x, brick.rot, brick.piece, BCOL(brick.piece));
wrefresh (pwin); wrefresh (nwin);
do {
in = getch ();
check = clock ();
} while ((in == ERR)&&((double)(check - start) / CLOCKS_PER_SEC < delay));
if (nextop)
drawpiece (nwin, 1, 2, brick.rot, next, (level + 1) % (COLORS / 2));
if (shadop)
drawpiece (pwin, shadow.y, shadow.x, shadow.rot, shadow.piece, level % (COLORS / 2));
drawpiece (pwin, brick.y, brick.x, brick.rot, brick.piece, level % (COLORS / 2));
if ((double)(check - start) / CLOCKS_PER_SEC > delay) {
brick.y++; start = clock ();
}
else switch (in) {
case KEY_RIGHT : brick.x++;
if (clip(&brick)) brick.x--;
else start = clock ();
break;
case KEY_LEFT : brick.x--;
if (clip(&brick)) brick.x++;
else start = clock ();
break;
case KEY_UP : brick.rot++; brick.rot %= 4;
if (clip(&brick)) {brick.rot += 3; brick.rot %= 4;}
else start = clock ();
break;
case KEY_DOWN : brick.y++;
start = clock ();
break;
case ' ' : while (!clip(&brick)) brick.y++;
brick.y--;
start = clock ();
break;
case 'n' :
case 'N' : nextop = !nextop; break;
case 's' :
case 'S' : shadop = !shadop; break;
case 'p' :
case 'P' : wattrset (pwin, COLOR_PAIR(level % (COLORS / 2)));
wfillrect (pwin, 0, 1, HEIGHT, WIDTH * 2);
drawmsg (pwin, HEIGHT / 2, 4, 2, pausemsg);
wrefresh (pwin);
while (getch() == ERR) {}
drawplay (level);
wrefresh (pwin);
break;
case 'q' :
case 'Q' : return (lines);
}
} while (!clip (&brick)); /* end of brickfall */
brick.y--;
for (d = 0; d < 4; d++) for (c = 0; c < 4; c++) /* commit piece to buffer */
if (blocks[rx(brick.rot, d, c)][brick.piece][rx((brick.rot + 1) % 4, d, c)] != '.')
buf[d + brick.y][c + brick.x - 1] = BCOL(brick.piece);
drawplay (level);
lines += clearedlines (level);
level = lines / 10 + 1;
brick.piece = next; brick.x = WIDTH / 2; brick.y = 0;
next = rand () % PIECES;
} while (!clip (&brick)); /* end of game */
drawpiece (pwin, brick.x, brick.y, brick.rot, brick.piece, BCOL(brick.piece));
return (lines);
}
int again (int hs) {
int x, y, ch;
WINDOW *againwin;
againwin = newwin(11, 13, (LINES / 2) - 6, (COLS / 2) - 4);
wattrset (againwin, COLOR_PAIR (COLORS / 2 - 1));
wfillrect (againwin, 0, 0, 11, 13);
mvwprintw (againwin, 1, 1, "High Score:");
mvwprintw (againwin, 3, 3, " %d lines", hs);
drawmsg (againwin, 6, 1, 4, againmsg);
wrefresh (againwin);
wclear (againwin);
delwin (againwin);
do {ch = getch();}
while ((tolower(ch) != 'q')&&(tolower(ch) != 'n')&&(tolower(ch) != 'y'));
if (tolower(ch) == 'y') return 1;
else return 0;
}
int main () {
int highscore;
init();
do {highscore = play ();} while (again (highscore));
endwin();
}
i'm resurrecting this because this little program has had quite a life since now. My site featured Alleytris, the 4 column variation and I've been hooked on it. So in order to spread my addiction I've made a video of the game to inspire others to play.
http://www.youtube.com/watch?v=-tTg5y1BLu4
Start a new thread.