C/Visual C - alguna ayuda con el tetris

Hola:
Soy Rolando
Me podia dar alguna ideas de que componentes de los de c++ puedo utilizar para hacer las piezas del juego tetris para poder eliminar las filas cuando esta o estas se llenen porque hasta ahora utilice un TImage pero no me sirvio y no se como seguir
Me hace falta ese componente y los metodos que me sirvan para poder eliminar o que desaparesca esa o esas filas llenas.

Saludos:

Rolando pero bueno ke tetris tienes ke hacer?? el ke lleve las piezasd de distintos colores o el ke todas van del mismo color?? bueno mira en caso ke sea el de un solo color puedes:

Usar el componente ke dices ke no puedes, el Image de la clase TImage.
Podrias dibujar un espacio con instancias de esta clase ke serian Image.

Ejemplo:

for(int i = 0 ; i <20 ; i+)
for(int j =0 ; j<10 ; j++)
{
TImage *image=new TImage(Image1); /* Image1 seria un control de tipo TImage ke tienes insertado en tu Form */

image->parent=Panel1; //pondrias como padre un panel
image->left=j*20; //este 20 seria el ancho y largo del cuadradito
image->top=i*20;
image->Picture=Image1->Picture;
imagenes[ i ][ j ]=image; //las pondrias en una matriz para poder trabajarlas
image[ i ][ j ]->Visible=false; /la pones invisible
}

De esta manera tendrias un tablero ke seria una matriz cargado de objetos TImage los cuales puedes ocultar cargar en ellos imagenes etc....

Hola:
El tetris que tengo que hacer es el que tiene varios colores y diferentes figuras
quizas eso me respondieron sirva de ayuda pero lo que no entiendo del codigo es la matriz imagenes que no la veo declarada
Ademas me haria falta ver como puedo a partir de esa matriz mover para la izquierda, mover a la derecha, rotarla y tirar la piesa porque no tengo ni idea de como hacer eso con una matriz de Image.

Muchas Gracias y espero que me respondan:
Disculpen por las molestias pero por favor de verdad que me hace tremenda falta este trabajo.

Bueno porsupuesto la matriz la declaras normal... ( identificador * [20] [10] )

Pero ese no es el problema,, Mira para hacer una tetris con piezas de diferentes colores la cosa se complica un tilin mas,, tendrias esa misma matriz pero tambien deberias tener un metodo random ke te diera aleatoriamente un numero ke representaria un tipo de ficha , ya sea la L o cualkier otra, me imagino ke cada letra tenga para si un color en especifico, entonces en vez de iniciar cada objeto de TImage con un picture no lo haces,, lo harias ( o sea cargar un picture ) cuando ejecutes el metodo y sepas ke numero tienes ke seria el identificador de una ficha, por ejemplo:

switch( random)
{ //cada x , y seria un cuadradito distinto o sea un objeto TImage distinto
case 0: matriz[ x ][ y ]->Picture=ImagenRoja->Picture;
matriz[ x ][ y ]->Picture=ImagenRoja->Picture;
matriz[ x ][ y ]->Picture=ImagenRoja->Picture;
matriz[ x ][ y ]->Picture=ImagenRoja->Picture;
}
//ImagenRoja seria un control de tipo TImage igual ke tendras cargado en tu form con un cuadradito de color rojo, asi formarias una figura de color rojo.


A ver para el problema de mover las fichas, debes conocer ke el teclado esta representado en codigo ascci, donde las teclas ke te harian falta serian las:
46, 47 , 48 , 49 (prueba con estas ke no recuerdo bien) estas 4 son lo ke llaman diamante, las flechitas ke te permitiran desplazar una figura hacia los lados y hacia abajo. El problema del tetris no es lo complicado de programar sino lo engorroso y monotono,, hay ke escribir mucho codigo. A ver, una figura no es mas ke la composicion de 4 imagenes, ke las cargas en las posiciones tal ke te formen una de las figuras ke gustes en el momento indicado, como las mueves?
facil, solamente tienes ke poner en NULL el Picture de la ke no kieres ke se vea y cargar en el Picture de la otra una imagen de un color segun la ficha, asi para hacer bajar una solo tienes poner en NULL sobre la ke estas parado y cargar en el Picture de la otra (o sea la ke esta debajo ) otro picture del mismo color. Creo ke son alrededor de 5 colores, (mas menos) tendrias sobre tu Form esta misma cantidad de image con Picture cargados uno de cada color...

Un método que yo emplée es el siguiente. Supongamos que las dimensiones de tu pantalla de juego son de 5 columnas y 10 renglones. Entonces, a nivel lógico, podemos esquematizar todo como una matriz bidimensional:

int mtxPantalla[][] =
{
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
};

Si aparece un cuadro en la esquina superior derecha, tenemos

int mtxPantalla[][] =
{
{ 0, 0, 0, 1, 1 },
{ 0, 0, 0, 1, 1 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
};

Entonces, lo único que tienes que hacer a nivel lógico es cambiar los 0s por 1s

int mtxPantalla[][] =
{
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 1 },
{ 0, 0, 0, 1, 1 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
};

En este ejemplo, el cuadro ya se desplazó un renglón. Para aquellos cuadros que ya no se pueden mover, tendríamos algo como:

int mtxPantalla[][] =
{
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 2, 2 },
{ 0, 0, 0, 2, 2 },
};

así, cada vez que desplaces la matrix, al detectar un 2 no lo mueves.

Luego, ya solo queda la cosa de interpretar 0, 1, 2 con un dibujo. En mi caso, emplee OpenGL. Así, haces un método que recorra la matriz y renderice la imagen correspondiente. Claro, yo lo hice de un sólo color.

Un amigo hizo una versión con diferentes colores de cuadros, y lo que hacía era el mismo algoritmo, pero con decimales:

float mtxPantalla[][] =
{
{ 0.0, 0.0, 0.0, 1.0, 1.2 },
{ 0.0, 0.0, 0.0, 1.1, 1.3 },
{ 0.0, 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0, 0.0 },
};

así, mi amigo interpretaba la parte entera -1- como un cuadro que se puede mover, y luego la decimal, con el color. En este caso, el cuadro sería -digamos- 1.0 (blanco), 1.1 (rojo), 1.2 (verde) y 1.3 (azul).

Por cierto, como nota, la palabra "Tetris" o cualquier otra terminación con "tris" para este tipo de juegos está patentada :P

Finalmente, en www.sourceforge.net hay varios juegos de estos, bájate uno y ve el algoritmo que emplea.

Saludos.