Test Foro de elhacker.net SMF 2.1

Hola.
Habiendo declarado previamente un array bidimensional de 8x8.
quiero dibujar un tablero utilizando  caracteres de la parte extendida del
código ASCII. Estos son los códigos que tengo que utilizar: 218, 196, 194, 191, 179,195, 197, 180, 192, 193 y 217 y tres "fichas" código 219.

No se cómo relacionar el array bidimensional con el tablero que me tiene que dibujar en pantalla :huh: :-(
________
|__|__|__|
|__|__|__|

La pantalla no es sino una matriz más o menos grande... tiene filas y columnas.

Tu tienes un array de 8x8.

Imagínate que coges una porción de la pantalla de 8x8 y dibujas en esa porción una representación de tu matriz.

Basta con recorrer la matriz por filas... para cada fila recorres sus columnas... en cada posición compruebas el valor de la celda e imprimes por pantalla el caracter que corresponde con ese valor... pasas al siguiente valor. Cuando terminas una fila introduces un salto de línea y repetir.

Hola. ¿Qué simbolos dibujan esos códigos ASCII? A mí no me parecen símbolos de un tablero de ajedrez o similar ...  :huh:

No se si querrás producir algo como esto:

+---+---+---+---+
| a | b | c | d |
+---+---+---+---+
| e | f | g | h |
+---+---+---+---+


Bueno, esperando a que respondas pero si ese es el caso aquí tienes un pequeño código que hace la tarea. Por comodida, creé la función fillRow que rellena una fila dada de la matriz con los caracteres de una cadena pasada como argumento. En este caso puse 'x' como relleno de la casilla, y espacio para dejar vacía la misma. Reemplaza el símbolo de relleno por el que tú requieres. Además, puedes cambiar las constantes M y N por otros valores en caso de querer redimensionar la matriz.


#include <stdlib.h>
#include <stdio.h>

#define M 8
#define N 8

void fillRow( char **, int, const char *);
void printBoard( char ** );

int main() {

char **A;
int i;

/* Inicializa la matriz, y termina si ocurre error */
if ( ( A = (char **) malloc ( M * sizeof(char *) ) ) == NULL )
return -1;
for (i = 0; i < M; i++ )
if ( ( A[i] = (char *) malloc ( N * sizeof(char) ) ) == NULL )
return -1;

fillRow( A, 0, "xxx xx x" );
fillRow( A, 1, "x  x  x " );
fillRow( A, 2, "x x x x " );
fillRow( A, 3, "xxxxx   " );
fillRow( A, 4, "xx      " );
fillRow( A, 5, "xx xx xx" );
fillRow( A, 6, "x  xxxx " );
fillRow( A, 7, "xxxxxxxx" );

/* imprimir el tablero */
printBoard( (char **)A );

return 0;
}

/* Rellena la fila i de la matriz A con los elementos del vector x */
void fillRow( char **A, int i, const char *x) {

int j;

for (j = 0; j < N; j++)
A[i][j] = x[j];
}

/* Imprime un tablero de 8x8, rellenando las casillas con los
* caracteres almacenados en la matriz A
*/
void printBoard( char **A ) {

int i, j;
char c, *s;

puts("+---+---+---+---+---+---+---+---+");
for (i = 0; i < M; i++) {
putchar('|');
for (j = 0; j < N; j++)
if ( A[i][j] != '\0' )
printf(" %c |", A[i][j]);
else
printf("   |");
puts("\n+---+---+---+---+---+---+---+---+");
}
putchar('\n');
}

Creo que no has entendido bien el asunto. Se trata de crear la cuadrícula no sólo con los símbolos + , - | sino usando:

Citar

       ┌   ─   ┬   ┐  │  ├   ┼   ┤   └   ┴  

y colocar en medio de la matriz tres:

Citar

█

Un fuerte saludo querido yoel_alejandro y como se suele decir, pelillos a la mar.

Yo, en particular, estoy muy contento con tus aportes ya que la mayoría de los expertos lo son más de C++ y a mí me interesa más el C puro y duro y creo que tus aportaciones serán muy bienvenidas..... caso aparte es rir3760 al que considero un "maestro" en el conocimiento en profundidad de C y C++.

"Yo, en particular, estoy muy contento con tus aportes ya que la mayoría de los expertos lo son más de C++ y a mí me interesa más el C puro y duro"

Jejeje, pues sí, es un dicho que entre más bajo el nivel más duro es el programador, jeje. De hecho me impongo como costumbre personal tratar de hacer los programas en C puro, salvo que sea estrictamente necesario usar C++ (por ejemplo si se requieren clases).

Ya tengo la respuesta (y creo que me quedó cool :laugh:). Bueno, es cuestión de probar con estos nuevos simbolitos, y tener paciencia hasta "cuadrar" el resultado. Yo te recomendaría anabelangie, definir mnemónicos o nombres simbólicos para los códigos ASCII a usar, de esa forma se trabaja de manera estructurada, y el código es más fácil de comprender y modificar en el futuro.

Siguiendo más o menos la nomenclatura que pude escudriñar en el fichero de cabecera [ncurses.h (el equivalente Linux para conio.h), me "copié" los nombres:

#define ULCORNER 218      /* upper-left corner, esquina superior izquierda */
#define URCORNER 191      /* upper-right corner, esquina superior derecha */
#define LLCORNER 192      /* lower-left corner, esquina inferior izquierda */
#define LRCORNER 217      /* lower-right corner, esquina inferior izquierda */
#define VLINE    179      /* vertical line, linea vertical */
#define HLINE    196      /* horizontal line, linea horizontal (guion) */
#define TTEE     193      /* top-tee, letra 'T' apuntando hacia arriba */
#define RTEE     195      /* right-tee, letra 'T' apuntando hacia la derecha */
#define BTEE     194      /* bottom-tee, letra 'T' apuntando hacia abajo */
#define LTEE     180      /* left-tee, letra 'T' apuntando hacia la izquierda */
#define CROSS    197      /* crossover, cruz grande (de mayor tamaño que el signo '+') */
#define TOKEN    219      /* ficha o pieza */

y disculpen el inglés, es sólo para hacerlo más universal. Lo demás es modificar el printBoard para que el diseño te quede como quieres. Claro, es más laborioso que con '+', '|' y '-', y requiere muchos más caracteres para producir el resultado  ... :rolleyes:

Los caracteres de la matriz A que sean distintos de un nulo '\0' y de un espacio se representarán como la ficha o TOKEN (ASCII 219). Queda la posibilidad de ampliar el programa para permitir varios diseños de fichas, según los caracteres simbólicos en A. El resultado:

┌───┬───┬───┬───┬───┬───┬───┬───┐
│ █ │ █ │ █ │   │ █ │ █ │   │ █ │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │   │   │ █ │   │   │ █ │   │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │   │ █ │   │ █ │   │ █ │   │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │ █ │ █ │ █ │ █ │   │   │   │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │ █ │   │   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │ █ │   │ █ │ █ │   │ █ │ █ │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │   │   │ █ │ █ │ █ │ █ │   │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ █ │ █ │ █ │ █ │ █ │ █ │ █ │ █ │
└───┴───┴───┴───┴───┴───┴───┴───┘


y el código fuente que lo produce:

#include <stdlib.h>
#include <stdio.h>

#define M 8
#define N 8

/* Definiendo mnemonicos para los simbolos ASCII */
#define ULCORNER 218 /* upper-left corner, esquina superior izquierda */
#define URCORNER 191 /* upper-right corner, esquina superior derecha */
#define LLCORNER 192 /* lower-left corner, esquina inferior izquierda */
#define LRCORNER 217 /* lower-right corner, esquina inferior izquierda */
#define VLINE    179 /* vertical line, linea vertical */
#define HLINE    196 /* horizontal line, linea horizontal (guion) */
#define TTEE     193 /* top-tee, letra 'T' apuntando hacia arriba */
#define RTEE     195 /* right-tee, letra 'T' apuntando hacia la derecha */
#define BTEE     194 /* bottom-tee, letra 'T' apuntando hacia abajo */
#define LTEE     180 /* left-tee, letra 'T' apuntando hacia la izquierda */
#define CROSS    197 /* crossover, cruz grande (de mayor tamaño que el signo '+') */
#define TOKEN    219 /* ficha o pieza */

void fillRow( char **, int, const char *);
void printBoard( char ** );

int main() {

char **A;
int i;

/* Inicializa la matriz, y termina si ocurre error */
if ( ( A = (char **) malloc ( M * sizeof(char *) ) ) == NULL )
return -1;
for (i = 0; i < M; i++ )
if ( ( A[i] = (char *) malloc ( N * sizeof(char) ) ) == NULL )
return -1;

fillRow( A, 0, "xxx xx x" );
fillRow( A, 1, "x  x  x " );
fillRow( A, 2, "x x x x " );
fillRow( A, 3, "xxxxx   " );
fillRow( A, 4, "xx      " );
fillRow( A, 5, "xx xx xx" );
fillRow( A, 6, "x  xxxx " );
fillRow( A, 7, "xxxxxxxx" );

/* imprimir el tablero */
printBoard( (char **)A );

return 0;
}

/* Rellena la fila i de la matriz A con los elementos del vector x */
void fillRow( char **A, int i, const char *x) {

int j;

for (j = 0; j < N; j++)
A[i][j] = x[j];
}

/* Imprime un tablero de 8x8, rellenando las casillas con los
* caracteres almacenados en la matriz A
*/
void printBoard( char **A ) {

int i, j;
char c, *s;

printf("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n", ULCORNER,
HLINE, HLINE, HLINE, BTEE,
HLINE, HLINE, HLINE, BTEE,
HLINE, HLINE, HLINE, BTEE,
HLINE, HLINE, HLINE, BTEE,
HLINE, HLINE, HLINE, BTEE,
HLINE, HLINE, HLINE, BTEE,
HLINE, HLINE, HLINE, BTEE,
HLINE, HLINE, HLINE, URCORNER);
for (i = 0; i < M; i++) {
putchar(VLINE);
for (j = 0; j < N; j++)
if ( A[i][j] != '\0' && A[i][j] != ' ')
printf(" %c %c", 219, VLINE);
else
printf("   %c", VLINE);
if ( i < M - 1 )
/* todas las lineas excepto la ultima */
printf("\n%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n", RTEE,
HLINE, HLINE, HLINE, CROSS,
HLINE, HLINE, HLINE, CROSS,
HLINE, HLINE, HLINE, CROSS,
HLINE, HLINE, HLINE, CROSS,
HLINE, HLINE, HLINE, CROSS,
HLINE, HLINE, HLINE, CROSS,
HLINE, HLINE, HLINE, CROSS,
HLINE, HLINE, HLINE, LTEE);
else
/* la linea final */
printf("\n%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n", LLCORNER,
HLINE, HLINE, HLINE, TTEE,
HLINE, HLINE, HLINE, TTEE,
HLINE, HLINE, HLINE, TTEE,
HLINE, HLINE, HLINE, TTEE,
HLINE, HLINE, HLINE, TTEE,
HLINE, HLINE, HLINE, TTEE,
HLINE, HLINE, HLINE, TTEE,
HLINE, HLINE, HLINE, LRCORNER);
}

}[/tt]



---

Ah, por cierto, yo trabajo en consola de Linux, y para que me pudiera representar correctamente los símbolos tuve que poner la codificación "IBM850", no me sirvió ISO-5589-1 ni UTF-8. No se si en Windows será lo mismo ... ¿alguien sabe qué pasa con ésto?  :huh:

Tienes que fijarte un poquito más, tan sólo hay que dibujar TRES del 219.




Muy bueno el uso de las macros. A mí me va más hacerlo a lo "bestia":

Citar

218=┌  196=─  194=┬  191=┐  179=│  195=├

197=┼  180=┤  192=└  193=┴  217=┘  219=█


/**
a0=linea superior
a1=lineas intermedias
a2=linea inferior
a3=lineas laterales
**/

#include <stdio.h>
#include <stdlib.h>

int main()
{
 system("color 70");
 int i,j,cont=0;
 int a1[33]={195,196,196,196,197,196,196,196,197,196,196,196,197,196,196,196,197,196,196,196,197,196,196,196,197,196,196,196,197,196,196,196,180},
     a0[33]={218,196,196,196,194,196,196,196,194,196,196,196,194,196,196,196,194,196,196,196,194,196,196,196,194,196,196,196,194,196,196,196,191},
     a2[33]={192,196,196,196,193,196,196,196,193,196,196,196,193,196,196,196,193,196,196,196,193,196,196,196,193,196,196,196,193,196,196,196,217},
     a3[33]={179,32,32,32,179,32,32,32,179,32,32,32,179,32,32,32,179,32,32,32,179,32,32,32,179,32,32,32,179,32,32,32,179};
 printf("\n\n\t218=%c  196=%c  194=%c  191=%c  179=%c  195=%c  \n\n\t197=%c  180=%c  192=%c  193=%c  217=%c  219=%c \n\n",218,196,194,191,179,195,197,180,192,193,217,219);
 for (j=0;j<33;j++)
   printf("%c",a0[j]);
 putchar ('\n');
   for (j=0;j<33;j++)
     printf("%c",a3[j]);
 for (i=0;i<7;i++){
   putchar ('\n');
   for (j=0;j<33;j++)
     printf("%c",a1[j]);
   putchar ('\n');
   for (j=0;j<33;j++){
     if (a3[j]==32 && a3[j-1]==32  && a3[j+1]==32 && (i*j==18 || i*j==36)){
       cont++;
       if (cont<=3)
         printf("%c",219);
       else
         printf("%c",32);
     }
     else
       printf("%c",a3[j]);
   }
 }
 putchar ('\n');
 for (j=0;j<33;j++)
   printf("%c",a2[j]);
 return 0;
}


Un fuerte saludo amigo yoel_alejandro, esto es lo realmente bueno, lo que yo llamo el pique sano.

Por cierto, en Windows sin problemas, al menos como yo lo tengo planteado.

Leo, ya se que él dijo tres fichas, pero no se en qué posición deben ir. Por eso dejé a potestad del autor del post poner las fichas en su lugar  :D

Y leosansan coincido contigo en lo bueno de la sana competencia, sin hacer la violencia.

Y disertando contigo sobre el tema, pienso (no se si discrepo contingo) que no hay que ser tan extremista en el uso de lo básico, ¿no has considerado positivo de uso de macros, constantes y ficheros de cabecera? Hará tu programa más flexible y configurable, además tendrá la fácil posibilidad de ampliarse o modificarse. Los proyectos profesionales hacen uso de este recurso, por ejemplo los nombres que usé los tomé del fichero de cabecera de la biblioteca ncurses, y supongo que lo mismo ocurre con conio.

No me gusta ser "talibán" o extremista [lo fui cuando era más joven, y creo que fue un error  :-(]. Por ejemplo hay programadores de C que son "linuxeros" exclusivos y hacen sus programas dependientes de Linux, discriminando a los usuarios Windows. Otros lo mismo pero al revés. Aunque yo prefiero Linux, trato de hacer mis programas de C de modo que sean compatibles en ambos sistemas, soy consciente de que el 90% o más de los usuarios del mundo usan Microsoft y eso hay que respetarlo.

No los hago compatible también para Apple porque no la conozco, no tengo Mac (es muy caro en mi país, jeje  :laugh:)

Y para cerrar, aunque no es el motivo de este foro, cuento que mi país (Venezuela) está tomado actualmente por la violencia, pido a todos hagan el deseo de que esto cese, y retornen la Justicia y la Libertad a mi tierra. España pasó por Franco, Chile por Pinochet, ... etc, todos los ciudadanos hispanos han padecido el totalitarismo (de derecha o de izquierda, que al fin resulta lo mismo) y deberían poder comprender mis palabras ...

Solo un detalle tonto yoel_alejandro. Se te olvidó liberar la memoria.

Se que el programa al finalizar la va a liberar por sí mismo... pero no hay que perder las buenas costumbres :D

Cita de: yoel_alejandro en  6 Marzo 2014, 15:33 PM
...........................................................................
Y disertando contigo sobre el tema, pienso (no se si discrepo contigo) que no hay que ser tan extremista en el uso de lo básico, ¿no has considerado positivo de uso de macros, constantes y ficheros de cabecera? Hará tu programa más flexible y configurable, además tendrá la fácil posibilidad de ampliarse o modificarse. Los proyectos profesionales hacen uso de este recurso, por ejemplo los nombres que usé los tomé del fichero de cabecera de la biblioteca ncurses, y supongo que lo mismo ocurre con conio.
.................................................

Sí que lo considero positivo pero no es plan de hacer todo tan "clarito" para alguien que no postea nada de nada de código. En estos casos ofusco un poquitito la respuesta.

Y para que veas que de talibán nada de nada, ahí recojo tu guante:


/**
a0=linea superior
a1=lineas intermedias
a2=linea inferior
a3=lineas laterales
**/

#include <stdio.h>
#include <stdlib.h>

#define ULCORNER 218,196,196,196    /* upper-left corner, esquina superior izquierda y tres guiones*/
#define RTEE     195,196,196,196    /*right-tee, letra 'T' apuntando hacia la derecha y tres guiones*/
#define CROSS    197,196,196,196    /* crossover, cruz grande (de mayor tamaño que el signo '+' y tres guiones) */
#define LTEE     180                /* left-tee, letra 'T' apuntando hacia la izquierda */
#define BTEE     194,196,196,196    /* bottom-tee, letra 'T' apuntando hacia abajo y tres guiones*/
#define URCORNER 191                /* upper-right corner, esquina superior derecha */
#define LLCORNER 192,196,196,196    /* lower-left corner, esquina inferior izquierda y tres guiones */
#define TTEE     193,196,196,196    /* top-tee, letra 'T' apuntando hacia arriba y tres guiones */
#define LRCORNER 217                /* lower-right corner, esquina inferior izquierda */
#define VLINE    179,32,32,32       /*vertical line, linea vertical y tres espacios*/
#define VLINE_   179                /* vertical line, linea vertical */
#define TOKEN    219                /* ficha o pieza */

int main()
{
 int i,j,cont=0;
 int a1[33]={RTEE,CROSS,CROSS,CROSS,CROSS,CROSS,CROSS,CROSS,LTEE},
     a0[33]={ULCORNER,BTEE,BTEE,BTEE,BTEE,BTEE,BTEE,BTEE,URCORNER},
     a2[33]={LLCORNER,TTEE,TTEE,TTEE,TTEE,TTEE,TTEE,TTEE,LRCORNER},
     a3[33]={VLINE,VLINE,VLINE,VLINE,VLINE,VLINE,VLINE,VLINE,VLINE_};
 for (j=0;j<33;j++)
   printf("%c",a0[j]);
 putchar ('\n');
   for (j=0;j<33;j++)
     printf("%c",a3[j]);
 for (i=0;i<7;i++){
   putchar ('\n');
   for (j=0;j<33;j++)
     printf("%c",a1[j]);
   putchar ('\n');
   for (j=0;j<33;j++){
     if (a3[j]==32 && a3[j-1]==32  && a3[j+1]==32 && (i*j==18 || i*j==36 || i*j==12)){
       cont++;
       if (cont<=3)
         printf("%c",TOKEN);
       else
         printf("%c",32);
     }
     else
       printf("%c",a3[j]);
   }
 }
 putchar ('\n');
 for (j=0;j<33;j++)
   printf("%c",a2[j]);
 return 0;
}

Un fuerte abrazo y .... estamos contigo muy cerquita, por algo aquí en Canarias conocemos a Venezuela como la octava isla.

Interesante la simplificación de leosansan, ventajas del trabajo en equipo. Te cuento que soy de Guayana, en el sur de Venezuela, y aquí consideramos como prócer a Manuel Carlos Piar, de quién se dice era hijo de Canarios (y Bolívar desarrolló una infame envidia y rivalidad contra él, mandándolo a fusilar). Piar fue un formidable oficial que combió técnicas de estrategia, en oposición a la lucha de burda de carnicería acostumbrada por entonces, y así llegó invicto en el campo de batalla hasta el final de sus días.

Eferion, gracias, realmente había olvidado liberar la memoria (sorry).

Ahora otra vez leo, me parece interesante tu simplificación del código, pero explícamente la aritmética usada de 12, 18, 36, etc ..... No entiendo esas fórmulas, y creo que también hubiera sido bueno comentariar esa explicación en el programa, los demás no somos adivinos jejejeje (broma)

Cita de: yoel_alejandro en  8 Marzo 2014, 17:08 PM
Interesante la simplificación de leosansan, ventajas del trabajo en equipo
.................................................
Ahora otra vez leo, me parece interesante tu simplificación del código, pero explícamente la aritmética usada de 12, 18, 36, etc ..... No entiendo esas fórmulas, y creo que también hubiera sido bueno comentariar esa explicación en el programa, los demás no somos adivinos jejejeje (broma)

¿Es una coña,no?.

Por si acaso simple cuestión de mates ,,,,sólo te contaré que se corresponden con posiciones centrales de los espacios en blanco, ni a la derecha ni a la izquierda de las paredes laterales, centrados ..... haz números ..... siempre que a mi no se me haya ido el baifo !!!. No olvides que se trataba de no hacerle la tarea al que inicio el tema, así que algo de oscurantismo es inevitable.




.

Pero indistintamente, lo cortés no quita lo valiente, siempre es bueno comentariar al menos a qué refieren las fórmulas aunque no se de una explicación detallada. P.ej.: posiciones centrales de las casillas.

Ya sabes, documentar el código para que sea más fácil de mantener por otra persona o por tí mismo en el futuro. Una vez leí un chiste de programadores que el código más odiado del mundo puede llegar a ser ........ tu propio código (de 6 meses atrás). Por que ya no te acuerdas de qué hacía ni como, jajajaja

espero no lo tomes a mal, saludos!!!

Te lo repito por n-ésima vez, se trataba de resolver un problema pero no de explicarlo, ya que el autor del tema no había puesto ni una misera línea de código, de ahí el cierto oscurantismo. ¿Te imaginas que copie mi código y al entregarlo a su profesor este le pregunte el significado de esos números?  :laugh: :laugh: :laugh:

Otra cosa distinta es "mi" código, el que yo me guardo, donde va una descripción del problema que se plantea y diversa notitas aclaratorias, pero que no pongo  cuando lo cuelgo en el foro. ¡¡¡Que se lo curre un poquito!!!,.....

Cita de: yoel_alejandro en  5 Marzo 2014, 19:28 PM
"Yo, en particular, estoy muy contento con tus aportes ya que la mayoría de los expertos lo son más de C++ y a mí me interesa más el C puro y duro"

Jejeje, pues sí, es un dicho que entre más bajo el nivel más duro es el programador, jeje. De hecho me impongo como costumbre personal tratar de hacer los programas en C puro, salvo que sea estrictamente necesario usar C++ (por ejemplo si se requieren clases).

Nunca es estrictamente necesario usar C++, incluso C se puede orientar a objetos si se quiere.

Cita de: yoel_alejandro en  5 Marzo 2014, 19:28 PMJejeje, pues sí, es un dicho que entre más bajo el nivel más duro es el programador, jeje.

Pero no mejor ;)

Cita de: leosansan en 12 Marzo 2014, 04:46 AMOtra cosa distinta es "mi" código, el que yo me guardo, donde va una descripción del problema que se plantea y diversa notitas aclaratorias, pero que no pongo  cuando lo cuelgo en el foro. ¡¡¡Que se lo curre un poquito!!!,.....

Me intriga lo que guardas en esa carpeta... Deben ser GB y GB de códigos Oo

Creo que lo que el usuario decía, era que dentro de cada celda van a ir 3 fichas. Algo así:


┌─────┬─────┐
│ ███ │  ███ │
├─────┼─────┤
│ ███ │  ███ │
└─────┴─────┘

Y a su vez, cuando hayas dibujado ese tablero 8x8 con sus respectivas fichas, debes relacionar esas fichas con un array bidimensional de forma que cada 3 fichas sea una posición del array. Lo cual me imagino será un array del tipo:  typedef  tipo_array  nombre_array [8][8];

Pd: ups... salió mal el dibujo  :-( bueno, creo que se entiende  ;D

Cita de: JonaLamper en 12 Marzo 2014, 11:37 AM
Creo que lo que el usuario decía, era que dentro de cada celda van a ir 3 fichas. Algo así:


┌─────┬─────┐
│ ███ │  ███ │
├─────┼─────┤
│ ███ │  ███ │
└─────┴─────┘

¿Algo así?:

Citar

┌───┬───┬───┬───┬───┬───┬───┬───┐
│███│███│███│███│███│███│███│███│
├───┼───┼───┼───┼───┼───┼───┼───┤
│███│███│███│███│███│███│███│███│
├───┼───┼───┼───┼───┼───┼───┼───┤
│███│███│███│███│███│███│███│███│
├───┼───┼───┼───┼───┼───┼───┼───┤
│███│███│███│███│███│███│███│███│
├───┼───┼───┼───┼───┼───┼───┼───┤
│███│███│███│███│███│███│███│███│
├───┼───┼───┼───┼───┼───┼───┼───┤
│███│███│███│███│███│███│███│███│
├───┼───┼───┼───┼───┼───┼───┼───┤
│███│███│███│███│███│███│███│███│
├───┼───┼───┼───┼───┼───┼───┼───┤
│███│███│███│███│███│███│███│███│
└───┴───┴───┴───┴───┴───┴───┴───┘

Cita de: amchacon en 12 Marzo 2014, 11:35 AM
.................................
Me intriga lo que guardas en esa carpeta... Deben ser GB y GB de códigos Oo ...............................

Pues estas en lo cierto, son varios GB de códigos, nunca sabes lo que puedes reaprender de ellos. Es como releer un libro, siempre encuentras cosas a mejorar y/o recordar.

Eso es leo. Recuerdo ese ejercicio. La cosa era como referenciar cada bloque de 3 fichas a una posición de un array bidimensional.

Una idea podría ser que cada bloque de 3 fichas sea un string que almacene el código ascii que corresponda y después guardar dicho string en un array.

¿Sería una buena idea?

Cita de: JonaLamper en 13 Marzo 2014, 00:36 AM
Eso es leo. Recuerdo ese ejercicio. La cosa era como referenciar cada bloque de 3 fichas a una posición de un array bidimensional.

Una idea podría ser que cada bloque de 3 fichas sea un string que almacene el código ascii que corresponda y después guardar dicho string en un array.

¿Sería una buena idea?

No me queda clara la idea. Tendrías que poner el enunciado completo.

Pero por lo que capto, eso de referenciar me suena a algo como esto:

Citar

┌───┬───┬───┬───┬───┬───┬───┬───┐
│█1█│█1█│█1█│█1█│█1█│█1█│█1█│█1█│
├───┼───┼───┼───┼───┼───┼───┼───┤
│█1█│█1█│█1█│█1█│█1█│█1█│█1█│█1█│
├───┼───┼───┼───┼───┼───┼───┼───┤
│█1█│█1█│█1█│█1█│█1█│█1█│█1█│█1█│
├───┼───┼───┼───┼───┼───┼───┼───┤
│█1█│█1█│█1█│█1█│█1█│█1█│█1█│█1█│
├───┼───┼───┼───┼───┼───┼───┼───┤
│█1█│█1█│█1█│█1█│█1█│█1█│█1█│█1█│
├───┼───┼───┼───┼───┼───┼───┼───┤
│█1█│█1█│█1█│█1█│█1█│█1█│█1█│█1█│
├───┼───┼───┼───┼───┼───┼───┼───┤
│█1█│█1█│█1█│█1█│█1█│█1█│█1█│█1█│
├───┼───┼───┼───┼───┼───┼───┼───┤
│█1█│█1█│█1█│█1█│█1█│█1█│█1█│█1█│
└───┴───┴───┴───┴───┴───┴───┴───┘

Process returned 0 (0x0)   executi

Y eso se logra sencillamente con una condición en la linea lateral y las intermedias:


          if ((j+2)%4==0)
           printf("1");
         else
           printf("%c",a1[j]/* o a3[j] en donde toca*/);


No lo tengo, pero conseguí una imagen del tablero completo:

(http://imageshack.com/a/img600/3082/im2n3.jpg)

En primer lugar pido perdón porque el siguiente código, es el código con la menor eficiencia que he visto en mi vida (ignorad los typedef que son para usarlos más tarde).

#include <iostream>
#include <fstream>
#include <windows.h>
using namespace std;

const int FILAS = 8;
const int COLUMNAS = 8;

const char ascii218 = 218;
const char ascii196 = 196;
const char ascii194 = 194;
const char ascii179 = 179;
const char ascii195 = 195;
const char ascii197 = 197;
const char ascii192 = 192;
const char ascii193 = 193;
const char ascii217 = 217;
const char ascii191 = 191;
const char ascii180 = 180;
const char ascii219 = 219;

typedef enum {magenta, amarillo, azul, verde, neutro} tFicha;
typedef tFicha tTablero[FILAS][COLUMNAS];


int main() {

//Linea superior
for (int i = 0; i <= 33; i++) {
if (i == 0) {
cout << ascii218;
}
else if (i == 33) {
cout << ascii191 << endl;
}
else if (i%4 == 0) {
cout << ascii194;
}
else {
cout << ascii196;
}
}
//Lineas intermedias
for (int j = 0; j < 7; j++) {
for (int i = 0; i < 33; i++) {
if (i%4 == 0) {
cout << ascii179;
}
else {
cout << ascii219;
}
}
//hacemos un saltito de linea
cout << endl;
for (int i = 0; i < 33; i++) {
if (i == 0) {
cout << ascii195;
}
else if (i == 33) {
cout << ascii180 << endl;
}
else if (i%4 == 0) {
cout << ascii197;
}
else {
cout << ascii196;
}
}
//hacemos otro saltito de linea
cout << endl;
}
//Linea inferior
for (int i = 0; i < 33; i++) {
if (i%4 == 0) {
cout << ascii179;
}
else {
cout << ascii219;
}
}
//hacemos un saltito de linea
cout << endl;
for (int i = 0; i < 33; i++) {
if (i == 0) {
cout << ascii192;
}
else if (i == 33) {
cout << ascii217 << endl;
}
else if (i%4 == 0) {
cout << ascii193;
}
else {
cout << ascii196;
}
}
return 0;
}

Ahora bien, tengo dos problemas... el primero es que no sé cómo solucionar la parte de la derecha de la tabla (las "sobras" que salen remarcadas en rojo). Y el segundo, es hacer algo más eficiente ese código (realmente lo importante es que funcione, pero si además es eficiente sería más mejor  ;D).

(http://imageshack.com/a/img24/8701/5s07.jpg)

Un saludo y si a alguien se le ocurre cualquier cosa por pequeña que sea, no dude en ponerla ^^

La eficiencia es buena, como mucho se puede mejorar creandote un vector fila y ir imprimiendo filas del tirón.

Aparte de eso. El código podría ser más claro. Y sobre todo más genérico (para cualquier tamaño del tablero).

Ah, y los pegotes se puede resolver pintandolos al reves (primero el pegote y despues el cuadrado).

Cita de: amchacon en 14 Marzo 2014, 01:03 AM
La eficiencia es buena, como mucho se puede mejorar creandote un vector fila y ir imprimiendo filas del tirón.

Aparte de eso. El código podría ser más claro. Y sobre todo más genérico (para cualquier tamaño del tablero).

Ah, y los pegotes se puede resolver pintandolos al reves (primero el pegote y despues el cuadrado).

Estimado amigo Maikel Angelo creo que he logrado lo que pedias, ya sabes que tus deseos son como órdenes para mi: eficiente, clarito, genérico y sin pegotes .... y además "cortito", como me gustan a mi los códigos.






/*****************************/
/*

a0=linea superior
a1=lineas intermedias
a2=linea inferior
a3=lineas laterales


  218=┌  196=─  194=┬  191=┐  179=│  195=├

  197=┼  180=┤  192=└  193=┴  217=┘  219=█

*/
/*****************************/
#include <stdio.h>

int main()
{
 int i,j,dim,dim_plus;
 printf("\nDimensi\xA2n del Tablero: ");
 fflush (stdout);
 scanf("%d",&dim);
 printf ("\n\n");
 dim_plus=dim*4+1;
 int a0[dim_plus],a1[dim_plus],a2[dim_plus],a3[dim_plus];
 /** linea superior **/
 for (j=0;j<dim_plus;j++){
   if (j==0 )
     a0[j]=218;
   else if (j==dim_plus-1)
     a0[j]=191;
   else if ((j)%4==0 && j<dim_plus-1)
     a0[j]=194;
   else
     a0[j]=196;
 }
 /** linea inferior **/
 for (j=0;j<dim_plus;j++){
   if (j==0 )
     a2[j]=192;
   else if (j==dim_plus-1)
     a2[j]=217;
   else if ((j)%4==0 && j<dim_plus-1)
     a2[j]=193;
   else
     a2[j]=196;
 }
 /** salto de linea...  **/
 /** y dibujo intermedias y laterales  **/
 for (j=0;j<dim_plus;j++){
   if (j==0 )
     a1[j]=195;
   else if (j==dim_plus-1)
     a1[j]=180;
   else if ((j)%4==0 && j<dim_plus-1)
     a1[j]=197;
   else
     a1[j]=196;
 }
 /** linea lateral **/
 for (j=0;j<dim_plus;j++){
   if (j==0 )
     a3[j]=179;
   else if (j==dim_plus-1)
     a3[j]=179;
   else if ((j)%4==0 && j<dim_plus-1)
     a3[j]=179;
   else
     a3[j]=219;
 }
  /** imprimimos **/
 for (j=0;j<dim_plus;j++)
   printf("%c",a0[j]);
 putchar ('\n');
 for (j=0;j<dim_plus;j++)
   printf("%c",a3[j]);
 for (i=0;i<dim-1;i++){
   putchar ('\n');
   for (j=0;j<dim_plus;j++)
     printf("%c",a1[j]);
   putchar ('\n');
   for (j=0;j<dim_plus;j++)
     printf("%c",a3[j]);
 }
 putchar ('\n');
 for (j=0;j<dim_plus;j++)
   printf("%c",a2[j]);
 return 0;
}

Dejo en el comienzo del código las equivalencias entre números y símbolos del tablero al que ya sólo me queda ponerle algo de colorido. Pero como bien sabes, eso no es problema para mi. Por cierto, en la página web salen símbolos raros para las equivalencias entre números y símbolos pero si le dan a citar pueden copiar desde ahí el código correctamente.

Y al amig@ JonaLamper disculparme por no revisarle el código, sencillamente me pareció más fácil hacerlo nuevo.

Que artista estas hecho Leo.

Sin embargo:

for (j=0;j<dim_plus;j++)
  printf("%c",a0[j]);
putchar ('\n');
for (j=0;j<dim_plus;j++)
  printf("%c",a3[j]);
for (i=0;i<dim-1;i++){
  putchar ('\n');
  for (j=0;j<dim_plus;j++)
    printf("%c",a1[j]);
  putchar ('\n');
  for (j=0;j<dim_plus;j++)
    printf("%c",a3[j]);
}
putchar ('\n');
for (j=0;j<dim_plus;j++)
  printf("%c",a2[j]);

Es mejor que declares los vectores como array de chars y le metas un nulo al final. De ese modo:

printf("%s\n%s",a0,a3);
for (i=0;i<dim-1;i++){
  putchar ('\n');
  printf(a1);
  putchar ('\n');
  printf(a3);
}
putchar ('\n');
printf(a2);

Más compacto y nos ahorramos llamadas a printf (lo que tarda no es el printf en sí, sino llamar al sistema para escribir en la pantalla). Si siguieramos rascando podríamos meter la figura entera en un solo vector y lanzarlo del tiron:
printf(figura);

Una ventaja de estas técnicas esque no tenemos que ceñirnos a dibujar la figura de arriba a abajo. Podemos generarla en el orden que queramos y después imprimirla.

Aunque es una ventaja relativa, ya que el enfoque arriba-abajo es bastante claro y intuitivo.

La idea es buena pero ..... sólo me serviría para las líneas superior e inferior ya que las intermedias las tengo que procesar como caracteres para el tema del color.









/*****************************/

#include <stdio.h>
#include <windows.h>
#include <time.h>
#include <stdlib.h>

int main()
{
  srand((unsigned) time(NULL));
  int i,j,dim,dim_plus;
  char tamanyo_consola[80];
  printf("\nDimensi\xA2n del Tablero: ");
  fflush (stdout);
  scanf("%d",&dim);
  printf ("\n\n");
  dim_plus=dim*4+1;
  int a0[dim_plus],a1[dim_plus],a2[dim_plus],a3[dim_plus];
  /** linea superior **/
  for (j=0;j<dim_plus;j++){
    if (j==0 )
      a0[j]=218;
    else if (j==dim_plus-1)
      a0[j]=191;
    else if ((j)%4==0 && j<dim_plus-1)
      a0[j]=194;
    else
      a0[j]=196;
  }
  /** linea inferior **/
  for (j=0;j<dim_plus;j++){
    if (j==0 )
      a2[j]=192;
    else if (j==dim_plus-1)
      a2[j]=217;
    else if ((j)%4==0 && j<dim_plus-1)
      a2[j]=193;
    else
      a2[j]=196;
  }
  /** salto de linea...  **/
  /** y dibujo intermedias y laterales  **/
  for (j=0;j<dim_plus;j++){
    if (j==0)
      a1[j]=195;
    else if (j==dim_plus-1)
      a1[j]=180;
    else if ((j)%4==0 && j<dim_plus-1)
      a1[j]=197;
    else
      a1[j]=196;
  }
  /** linea lateral **/
  for (j=0;j<dim_plus;j++){
    if (j==0 )
      a3[j]=179;
    else if (j==dim_plus-1)
      a3[j]=179;
    else if ((j)%4==0 && j<dim_plus-1)
      a3[j]=179;
    else
      a3[j]=219;
  }
  /** imprimimos **/
  sprintf(tamanyo_consola, "MODE %d,%d", dim_plus+1,2*dim+1);
  system(tamanyo_consola);
         /** linea superior **/
  for (j=0;j<dim_plus;j++){
    color (6);
    printf("%c",a0[j]);
  }

  putchar ('\n');
  for (j=0;j<dim_plus;j++){
      if ((a3[j]==219) ){
        color (80+rand() % (249-80));
        printf("%c",32);
      }
      else{
        color (6);
        printf("%c",a3[j]);
      }
    }

  /** salto de linea...  **/
  /** y dibujo intermedias y laterales  **/
  for (i=0;i<dim-1;i++){
    putchar ('\n');
    for (j=0;j<dim_plus;j++){
      color (6);
      printf("%c",a1[j]);
      color (7);
    }
    putchar ('\n');
    /** linea lateral **/
    for (j=0;j<dim_plus;j++){
      if ((a3[j]==219) ){
        color (80+rand() % (249-80));
        printf("%c",32);
        color (7);
      }
      else{
        color (6);
        printf("%c",a3[j]);
      }
    }

    }
  putchar ('\n');
   /** linea inferior **/
   for (j=0;j<dim_plus;j++){
    color (6);
    printf("%c",a2[j]);
  }
  system ("pause>null");
  return 0;
}
 
void color (int n)
{
        SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}

No era necesario para cualquier tamaño, sólo necesitaba de 8x8  ;D volviendo a una pregunta que surgió por ahí: ¿cómo hago el primer bloque de tres fichas se almacene en la posición array[0][0], el segundo bloque en la posición array[0][1], etc? ¿Debería guardar un string que contenga tres char(219)? La verdad es que veo que esto no es difícil, pero no logro tener las ideas claras. Disculpadme.

Ya se volvieron unos artistas  :o  :o  :o !!! Mis respetos.

Cita de: JonaLamper en 18 Marzo 2014, 00:21 AM
No era necesario para cualquier tamaño, sólo necesitaba de 8x8  ;D volviendo a una pregunta que surgió por ahí: ¿cómo hago el primer bloque de tres fichas se almacene en la posición array[0][0], el segundo bloque en la posición array[0][1], etc? ¿Debería guardar un string que contenga tres char(219)? La verdad es que veo que esto no es difícil, pero no logro tener las ideas claras. Disculpadme.

Mira que te lo dije: pon el enunciado exacto. El no hacerlo nos lleva a nosotros a tener que especular y, la verdad, tenemos poco de adivinos y lo único que consigues es  hacernos perder el tiempo en elucubraciones psico-mentales inútiles que acaban cabreando al más pintado.

Es la última hasta que aclares lo del enunciado:

Citar

■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █

■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■


/**
a0=linea superior
a1=lineas intermedias
a2=linea inferior
a3=lineas laterales
**/
/**
a0=linea superior
a1=lineas intermedias
a2=linea inferior
a3=lineas laterales
**/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define CUADRADITOS 179,219,179,219,179,219
#define CUADRADITOS1 "\xdb "
#define CUADRADITOS2 "\xfe "
#define ULCORNER 218,196,196,196,196,196    /* upper-left corner, esquina superior izquierda y tres guiones*/
#define RTEE     195,196,196,196,196,196   /*right-tee, letra 'T' apuntando hacia la derecha y tres guiones*/
#define CROSS    197,196,196,196,196,196    /* crossover, cruz grande (de mayor tamaño que el signo '+' y tres guiones) */
#define LTEE     180                /* left-tee, letra 'T' apuntando hacia la izquierda */
#define BTEE     194,196,196,196,196,196   /* bottom-tee, letra 'T' apuntando hacia abajo y tres guiones*/
#define URCORNER 191                /* upper-right corner, esquina superior derecha */
#define LLCORNER 192,196,196,196,196,196   /* lower-left corner, esquina inferior izquierda y tres guiones */
#define TTEE     193,196,196,196,196,196    /* top-tee, letra 'T' apuntando hacia arriba y tres guiones */
#define LRCORNER 217                /* lower-right corner, esquina inferior izquierda */
#define VLINE    CUADRADITOS      /*vertical line, linea vertical y tres espacios*/
#define VLINE_   179                /* vertical line, linea vertical */
#define TOKEN    219                /* ficha o pieza */

int main(){
  int i,j,tam;
  char a[]="\xfe ";
  char b[8][8][6];

/******* AQUI MATRIZ CUADRADITOS=254=xfe 8X8 *******/
/** SOLO CUADRADITOS SIN LINEAS INTERMEDIAS **/

  for (i=0;i<8;i++)
    for (j=0;j<8;j++)
      strcpy( b[i][j], a );

  for (i=0;i<8;i++){
    for (j=0;j<8;j++){
      printf("%s ",b[i][j]);
    }
    putchar ('\n');
  }
  int a1[]={RTEE,CROSS,CROSS,CROSS,CROSS,CROSS,CROSS,CROSS,LTEE},
      a0[]={ULCORNER,BTEE,BTEE,BTEE,BTEE,BTEE,BTEE,BTEE,URCORNER},
      a2[]={LLCORNER,TTEE,TTEE,TTEE,TTEE,TTEE,TTEE,TTEE,LRCORNER},
      a3[]={CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS};
  tam=sizeof (a1)/sizeof (a1[0]);
  /** linea superior **/
  for (j=0;j<tam;j++)
    printf("%c",a0[j]);
  putchar ('\n');
  /** linea lateral **/
  for (j=0;j<tam;j++)
    printf("%c",a3[j]);
  /** salto de linea...  **/
  /** y dibujo intermedias y laterales  **/
  for (i=0;i<7;i++){
    putchar ('\n');
    for (j=0;j<tam;j++)
        printf("%c",a1[j]);
      putchar ('\n');
      for (j=0;j<tam;j++)
          printf("%c",a3[j]);
  }
  /** linea inferior **/
  putchar ('\n');
  for (j=0;j<tam;j++)
    printf("%c",a2[j]);
  putchar ('\n');

/******* AQUI MATRIZ SOLA DE CUADRADITOS=219=xdb 8X8 *******/

  for (i=0;i<8;i++){
    for (j=0;j<8;j++){
      printf("%s ",CUADRADITOS1);
    }
    putchar ('\n');
  }
  putchar ('\n');

/******* AQUI UNA MATRIZ SOLA DE CUADRADITOS=254=xfe 8X8 *******/

  for (i=0;i<8;i++){
    for (j=0;j<8;j++){
      printf("%s ",CUADRADITOS2);
    }
    putchar ('\n');
  }
  putchar ('\n');

  return 0;
}

Lo siento leo. No quería ponerte el enunciado porque... bueno, sé que aquí todos estamos para ayudarnos, pero no querría coger una cosa hecha por ti y copiarla sin más, por eso solo te pregunté cosas exactas, problemas con los que me iba encontrando a medida que iba avanzando en el ejercicio, pero claro, tú no sabías exactamente a qué me refería al no tener el enunciado.

Esta noche lo pongo. Y si no es mucha molestia, cuando lo leas, no pretendo hagas un código y me lo enseñes, preferiría que me lo explicarás o que me dijeras cómo lo harías tú, pero ante todo, no hacerlo.

Gracias y disculpa una vez más, sé lo que vale el tiempo invertido en ayudar de forma desinteresada a los demás.

Buuuueno, vale.

Cita de: JonaLamper en 18 Marzo 2014, 00:21 AM
No era necesario para cualquier tamaño, sólo necesitaba de 8x8  ;D volviendo a una pregunta que surgió por ahí: ¿cómo hago el primer bloque de tres fichas se almacene en la posición array[0][0], el segundo bloque en la posición array[0][1], etc? ¿Debería guardar un string que contenga tres char(219)? La verdad es que veo que esto no es difícil, pero no logro tener las ideas claras. Disculpadme.

Disculpad@ estás y a la espera de que pongas el enunciado, te adelanto una posible solución, en el supuesto de que el problema radique en cómo extraer una matriz de 8x8 a partir de las matrices iniciales, estando esta matriz de 8x8 constituida por cadenas de tres cuadraditos. Aunque otra forma sería obtenerla directamente.

Te explico el proceso:

* la matriz inicial a usar debe ser de 8x8x4, sí, tridimensional. Esto es debido en que para generarla hemos de recorrer, además de las 8 filas y 8 columnas,también  hemos de tener en cuenta que cada elemento almacenado en esa matriz de 8x8 es  de cuatro caracteres .....sí, cuatro, los tres cuadraditos y el caracter nulo. Necesitaremos por lo tanto:

* 1 * un primer for:1->8 para recorrer la matriz en filas.

* 2 * un segundo for:1->8  para recorre la matriz en columnas.

* 3 * un tercer for:1->tam para el for anterior recorrerlo internamente, ya que se compone de los caracteres extremos más los intermedios, tanto cuadraditos como líneas verticales.

Y hemos de quedarnos en este último for con los cuadraditos. ¿Cómo?. Teniendo en cuenta el hecho de cómo se componen las filas LV=línea vertical=179 y de cuadraditos = C=219=\xdb:

    LV     C    LV    C   LV    C   LV    C   LV    C   LV    C   LV    C   .....  
     0      1    2     3    4     5     6    7    8     9    10   11  12   13......
k =          0          1           2          0           1           2          0 .....

Observa que para "pillar" sólo los cuadraditos, que son los números impares, en el último for se empieza desde uno y se avanza con paso 2: i+=2.

Pero además tienes que usar una variable auxiliar k tal que cada tres cuadraditos "pillados", y después de añadirle el caracter nulo, se inicie a cero y se incremente el array.  ES decir empiezas en array[0][0] y una vez que k haya llegado a dos, pasará a valer otra vez cero y empezarás a rellenar el array[0][1] y así sucesivamente.

No te pongo ahora mismo la respuesta porque me has pedido expresamente que tan sólo te lo explicara para tú intentar sacarlo.

Espero que la explicación te encamine hacia la solución.

Por respeto a los seguidores de este tema, que no son pocos, pondré en un día o dos la respuesta.

Ahora te adelanto el código que imprime la matriz, para que veas que es efectivamente de 8x8, y una salida del programa:

for (i=0;i<8;i++){
   printf("\t\t");
   for (j=0;j<8;j++){
     printf("%s  ",c[i][j]);
   }
   puts ("\n");
 }

Citar

             
 A PARTIR DE LA MATRIZ DE 8X8



               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███



               DE FORMA DIRECTA

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

Y para los que estén aburridos y le peguen a la criptografía, aquí pongo el código solución cifrado. He usado un método propio, pero no lo he querido hacer totalmente indescifrable por si se animan ..... pero tranquilos, como comenté próximamente pondré la solución, no es plan de dejar a nadie colgado en este tema:

Citar

Cifrado es:

Æ¿å| æâyiàX¼ÇD¿wD1  lÜ╗ aø`5_}QbM┤^muÄ`;    ê╝x anVåUæG_Hòpp3ñU>      m║© *ÿFrxè
e┐ŪHøYêEz┼]N        sê«┐d,xc▬        ¬ç 9tïkG╬;☼          ö{ìï¡ëë®®ÜCJgöÜu3]Öc│
ïes?6▼          «?àå↕+        Ö♫↓        û¡Åkæ▲)          ⌂Åî®Øo_Ññ½]Zt:CeKA
     skIe_♀        ╣VP      ×E\    è7E  ©?↑H9  æçºtìÉà [üx║OOm ((M  á⌂ú NÅê3T╗c
fiÁnÇyº#4    ¡┐«x|~?[óøêùDvs\↕    ÿ¡║ /àZOKîLlQ£2Xv┤+D      Ö¥┐┐øöK.|©  YSqvóuñü
¼9è]8    Ê(W    üæî╩ A$á|ixoF↓  ø@¶  î╗úvu╗s u3øÅtsé┴Ñ╝í<í♣E

Cita de: leosansan en 19 Marzo 2014, 10:59 AM

Aunque me temo que el procesador de esta página "baile" algunos símbolos extraños para él.

Conviértelo a base64 y así no habrá problemas con el código cifrado... total, el que quiera descifrarlo únicamente tiene que añadir la decodificación de base 64 antes de ponerse a decodificar en serio.

Cita de: eferion en 19 Marzo 2014, 11:28 AM
Conviértelo a base64 y así no habrá problemas con el código cifrado... total, el que quiera descifrarlo únicamente tiene que añadir la decodificación de base 64 antes de ponerse a decodificar en serio.

La base que elijo la tomo para cada mensaje de forma aleatoria, pero pero después de aplicarle otro módulo de cifrado que son varios según el nivel de exigencia de cifrado que se requiera.

Entre los módulos está, por ejemplo, un desplazamiento con un array del mismo tamaño que el mensaje, lo que le da mucha fuerza, obtenido en cada ocasión de forma aleatoria y combinado con otro desplazamiento con otro array aleatorio, también distinto para cada mensaje, en base a números primos tomados a su vez de un intervalo diferente y aleatorio en cada ocasión. Y por supuesto utilizo todos los caracteres ASCII disponibles, ¡y más!, no me limito al abecedario y los números.

Y hay otros 12 módulos adicionales, aunque cada cierto tiempo añado alguno nuevo, cuestión de no aburrirse. ;)

No lo comentaba como algo a añadir en el proceso de cifrado.

Yo me refería para que el texto cifrado pudieses pegarlo en el foro sin distorsión.

Básicamente coger el código ya cifrado y pasarlo a base64 para que el código resultante no tenga caracteres extraños que el foro pueda modificar.

Cita de: eferion en 19 Marzo 2014, 12:36 PM
No lo comentaba como algo a añadir en el proceso de cifrado.

Yo me refería para que el texto cifrado pudieses pegarlo en el foro sin distorsión.

Básicamente coger el código ya cifrado y pasarlo a base64 para que el código resultante no tenga caracteres extraños que el foro pueda modificar.

Citar

XyYjODczNTtMOVNNJiM4NTk1O0UmIzk2NTA7JiM5NzkyOyQtLEAmIzk2NTg7JiM5NTc0O7ImIzg1
OTQ7KSKvMDImIzk2NTA7ICAgICAgICBoJiM5NjQ0OyEmIzk1MTY7J6evJ1ynuFBeXCYjOTc4Nzsm
JiM5NTc3Oy+kYdAmIzgyNTI74zApsiYjODI1MjtSsNJKWiYjODU5NDsiJiM4NTk1OyYjOTc5NDsw
YahoOCsmIzg1OTU7NtnP/iYjOTc5NDsNCmEmIzk3OTQ7JiM5NTMyO0c4YSYjODU5Nju2JyYjOTUz
MjvL0jNCtiYjOTY2ODsmIzg1OTI7JiM5ODM1OyYjOTYwNDtvJiM5NDc0OyYjOTYwODtUMU0mIzk2
NTg7JiM4NTk0O0MnL0jQuyYjOTY1MDtWUzUmIzk2MTk7JiMzMDU7ICYjODU5NDtMuSYjMzA1OyYj
OTU1Njs/piYjOTQ4NDu3JiM5NjMyOyYjOTYxODtpJiM4MjE1O/VfJiM4NTk1OyYjODU5NjsmIzk2
Njg7KSCyJiM4NTk3OyYjOTc5MjtQJiM4NTk1OzlALCYjODU5NztoJiM5NzkyO7LIW7PQJiM5ODI0
OyYjOTUyNDulQw0KzyYjOTY1ODslJiM4MjE1O9964yBfJiM5NjA4O2bNJiM5ODI5O2nPJiM5NDg4
OyYjOTUzMjv1aCIhJiM5NjYwOyYjOTY0NDs9MbcmIzMwNTsmIzk4Mjk7Rbm7JiM4MjUyO8DSJiM5
ODI0OyYjOTQ5NjtQZ1UmIzk4MzU7YSYjOTc4NzsmIzk2NDQ7LGPjpyYjOTU1MjtMpvWvbt6ibSA1
Okkk2SYjODI1MjsmIzk2NTg7TiJSJiM5NTgwOyYjODIxNTsgJiM5NTgwO/4uaiYjODczNTu0JiM4
NTk1OyYjOTY1MDvAJA0KR6c2LEnb1SYjODU5Nzsz8CYjOTQ5MjtNXiYjODU5MztqZsjbQg0KJiM5
NjU4Oz62JiM4NTk1Oz0mIzk2Njg7QDEmIzk0OTY7JyYjOTQ3NDsmIzk0ODg7LbUmIzk2MDg7Tk5S
PrYmIzk3ODY7JiM5ODM1OyQmIzk3ODg72yPBsSQmIzk0ODQ7uGNOODtGTG31p1ZF3yYjOTYxNzsm
Izk3OTI7SiYjODU5MztLZnnGvdko

---

Tal como prometí cuelgo la respuesta a la petición de cómo formar una matriz de 8x8 con los elementos centrales, es decir los cuadraditos. La salida de dicho código es la indicada justamente en el mensaje anterior:

* Lo codificado:

char d[8][8][4];
 for (l=0;l<8;l++){
   for (j=0;j<8;j++){
     for (i=1;i<tam;i+=2){
       if (k<3){
         d[l][j][k]=219;
         k++;
       }
       else{
         d[l][j][k]='\0';
         k=0;
       }
     }
   }
 }


 for (i=0;i<8;i++){
   printf("\t\t");
   for (j=0;j<8;j++){
     printf("%s  ",d[i][j]);
   }
   puts ("\n");
 }
 putchar ('\n');


Y el código entero:

/**
a0=linea superior
a1=lineas intermedias
a2=linea inferior
a3=lineas laterales


  218=┌  196=─  194=┬  191=┐  179=│  195=├

  197=┼  180=┤  192=└  193=┴  217=┘  219=█

**/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <time.h>

#define CUADRADITOS3 "\xdb\xdb\xdb"
#define CUADRADITOS 179,219,179,219,179,219
#define CUADRADITOS1 "\xdb\xdb\xdb"
#define CUADRADITOS2 "\xfe "
#define ULCORNER 218,196,196,196,196,196    /* upper-left corner, esquina superior izquierda y tres guiones*/
#define RTEE     195,196,196,196,196,196   /*right-tee, letra 'T' apuntando hacia la derecha y tres guiones*/
#define CROSS    197,196,196,196,196,196    /* crossover, cruz grande (de mayor tamaño que el signo '+' y tres guiones) */
#define LTEE     180                /* left-tee, letra 'T' apuntando hacia la izquierda */
#define BTEE     194,196,196,196,196,196   /* bottom-tee, letra 'T' apuntando hacia abajo y tres guiones*/
#define URCORNER 191                /* upper-right corner, esquina superior derecha */
#define LLCORNER 192,196,196,196,196,196   /* lower-left corner, esquina inferior izquierda y tres guiones */
#define TTEE     193,196,196,196,196,196    /* top-tee, letra 'T' apuntando hacia arriba y tres guiones */
#define LRCORNER 217                /* lower-right corner, esquina inferior izquierda */
#define VLINE    CUADRADITOS      /*vertical line, linea vertical y tres espacios*/
#define VLINE_   179                /* vertical line, linea vertical */
#define TOKEN    219                /* ficha o pieza */

int main(){
 int i,j,k=0,l,tam,cont=0;
 char a[]="\xfe ";
 char b[8][8][6];

/******* AQUI MATRIZ CUADRADITOS=254=xfe 8X8 *******/
/** SOLO CUADRADITOS SIN LINEAS INTERMEDIAS **/

 /*for (i=0;i<8;i++)
   for (j=0;j<8;j++)
     strcpy( b[i][j], a );
 for (i=0;i<8;i++){
   for (j=0;j<8;j++){
     printf("%s ",b[i][j]);
   }
   putchar ('\n');
 }*/
 int a1[]={RTEE,CROSS,CROSS,CROSS,CROSS,CROSS,CROSS,CROSS,LTEE},
     a0[]={ULCORNER,BTEE,BTEE,BTEE,BTEE,BTEE,BTEE,BTEE,URCORNER},
     a2[]={LLCORNER,TTEE,TTEE,TTEE,TTEE,TTEE,TTEE,TTEE,LRCORNER},
     a3[]={CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS};
 tam=sizeof (a2)/sizeof (a2[0]);
  /****** IMPRIMIMOS LA MATRIZ TOTAL  ************/

 /** linea superior **/
 printf("\t");
 for (j=0;j<tam;j++)
   printf("%c",a0[j]);
 putchar ('\n');
 /** linea lateral **/
 printf("\t");
 for (j=0;j<tam;j++)
   printf("%c",a3[j]);
 /** salto de linea...  **/
 /** y dibujo intermedias y laterales  **/

 for (i=0;i<7;i++){
   putchar ('\n');
   printf("\t");
   for (j=0;j<tam;j++)
       printf("%c",a1[j]);
     putchar ('\n');
     printf("\t");
     for (j=0;j<tam;j++)
         printf("%c",a3[j]);
 }
 /** linea inferior **/
 putchar ('\n');
 printf("\t");
 for (j=0;j<tam;j++)
   printf("%c",a2[j]);
 putchar ('\n');
/******* AQUI LA NEW MATRIZ SOLA DE CUADRADITOS 8X8 *******/
/*********** A PARTIR DE LA MATRIZ INICIAL  ***************/

 puts("\t\tA PARTIR DE LA MATRIZ DE 8X8\n");
 char d[8][8][4];
 for (l=0;l<8;l++){
   for (j=0;j<8;j++){
     for (i=1;i<tam;i+=2){
       if (k<3){
         d[l][j][k]=219;
         k++;
       }
       else{
         d[l][j][k]='\0';
         k=0;
       }
     }
   }
 }


 for (i=0;i<8;i++){
   printf("\t\t");
   for (j=0;j<8;j++){
     printf("%s  ",d[i][j]);
   }
   puts ("\n");
 }
 putchar ('\n');

/*************** OBTENCION DIRECTA ***************/
 /******* OTRA 8X8 *******/

 puts("\t\tDE FORMA DIRECTA\n");
 for (i=0;i<8;i++){
   printf("\t\t");
   for (j=0;j<8;j++){
     printf("%s  ",CUADRADITOS3);
   }
   puts ("\n");
 }
 putchar ('\n');



/******* AQUI UNA MATRIZ SOLA DE CUADRADITOS=254=xfe 8X8 *******/


 for (i=0;i<8;i++){
   printf("\t\t\t");
   for (j=0;j<8;j++){
     printf("%s ",CUADRADITOS2);
   }
   putchar ('\n');
 }
 putchar ('\n');

 return 0;
}

leosansan: por favor no escribas mas mensajes consecutivos en un mismo hilo.

En primer lugar, perdonad por estar tanto tiempo sin contestar. He estado avanzando durante estos días y tal y como lo llevo, creo que no es necesario poner el enunciado de lo que hace este juego. Os dejo el código:

#include <iostream>
#include <string>
#include <Windows.h>
#include <iomanip>
#include <cstdlib>
#include <ctime>
using namespace std;

// Constantes
const int COLUMNAS = 8;
const int FILAS = 8;
const int maxIntentos = 15;
const char tresBloques[4] = {char(219), char(219), char(219), char(0)}; // Vector tresBloques
const char tresLineas[4] = {char(196), char(196), char(196), char(0)};  // Vector tresLineas

// Tipos enumerados
typedef enum {neutro, magenta, amarillo, azul, verde, none} tFicha;
typedef enum {arriba, abajo, derecha, izquierda} tDireccion;
typedef enum {
black, // 0
dark_blue, // 1
dark_green,        // 2
dark_cyan, // 3
dark_red,        // 4
dark_magenta,        // 5
dark_yellow,        // 6
light_gray,        // 7
dark_gray, // 8
light_blue,           // 9
light_green,        // 10
light_cyan,        // 11
light_red,        // 12
light_magenta,     // 13
light_yellow,        // 14
white // 15
} tColor;

// Arrays
typedef tFicha tTablero[FILAS][COLUMNAS];
typedef bool tMatrizBooleana[FILAS][COLUMNAS];

// Estructuras
typedef struct {
tTablero tablero;
int intentos;
int puntos;
} tJuego;

typedef struct {
int fila;
int columna;
tDireccion direccion;
} tMovimiento;

// Prototipos
void colorCrush(tJuego &juego);
void generarTablero(tJuego &juego);
void procesarTablero(tJuego &juego);
void mostrarTablero(tJuego &juego);
void lineaArriba();
void lineaMedio();
void lineaAbajo();
void comprobarGrupo();
void movimientoUsuario();
void rellenarHuecos();
void setColor(tColor color);
void columnas(tTablero tablero, int i);
void pintarEspacios(tFicha cuadrado);
void iniciarArrayBool(tMatrizBooleana arrayBool);
void comprobarFilas(tJuego &juego, tMatrizBooleana arrayBool);
void comprobarColumnas(tJuego &juego, tMatrizBooleana arrayBool);
// Next
void gestionCaida(tJuego &juego);

int main() {
tJuego juego;
srand(time(NULL));
colorCrush(juego);
return 0;
}

void generarTablero(tTablero tablero) {
for (int i = 0; i < FILAS; i++) {
for (int j = 0; j < COLUMNAS; j++) {
tablero[i][j] = tFicha(1 + rand() % 4);
}
}
}

void setColor(tColor color) {
HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(handle, color);
}

void mostrarTablero(tJuego &juego) {
setColor(tColor(15));
cout << setw(15) << "Attempts: " << juego.intentos << setw(15) << "Points: " << juego.puntos << endl;
lineaArriba();
for (int i = FILAS - 1; i > (FILAS - (FILAS)); i--) {
cout << setw(2);
cout << i + 1;
cout << setw(2);
columnas(juego.tablero, i);
lineaMedio();
}
int i = 0;
cout << setw(2);
cout << FILAS - (FILAS - 1);
cout << setw(2);
columnas(juego.tablero, i);
lineaAbajo();
cout << setw(6);
for (int j = 1; j < COLUMNAS; j++) {
cout << j << setw(4);
}
cout << COLUMNAS << endl;
}

void columnas(tTablero tablero, int i) {
for (int j = 0; j < COLUMNAS; j++) {
cout << char(179);
pintarEspacios(tablero[i][j]);
setColor(tColor(15));
}
cout << char(179) << endl;
}

void lineaArriba() {
cout << setw(4) << char(218) << tresLineas;
for (int i = 0; i < COLUMNAS - 2; i++) {
cout << char(194) << tresLineas;
}
cout << char(194) << tresLineas << char(191) << endl;
}

void lineaMedio() {
cout << setw(4) << char(195) << tresLineas;
for (int i = 0; i < COLUMNAS - 2; i++) {
cout << char(197) << tresLineas;
}
cout << char(197) << tresLineas << char(180) << endl;
}

void lineaAbajo() {
cout << setw(4) << char(192) << tresLineas;
for (int i = 0; i < COLUMNAS - 2; i++) {
cout << char(193) << tresLineas;
}
cout << char(193) << tresLineas << char(217) << endl;
}

void pintarEspacios(tFicha cuadrado) {
if (cuadrado == magenta) {
setColor(tColor(13));
cout << tresBloques;
}
else if (cuadrado == amarillo) {
setColor(tColor(14));
cout << tresBloques;
}
else if (cuadrado == azul) {
setColor(tColor(3));
cout << tresBloques;
}
else if (cuadrado == verde) {
setColor(tColor(2));
cout << tresBloques;
}
else if (cuadrado == neutro) {
setColor(tColor(0));
cout << tresBloques;
}
}

void colorCrush(tJuego &juego) {
juego.intentos = maxIntentos;
juego.puntos = 0;
generarTablero(juego.tablero);
mostrarTablero(juego);
procesarTablero(juego);
int j = 0;
while (j < 10) {
cout << endl << endl;
mostrarTablero(juego);
procesarTablero(juego);
cout << endl;
system("pause");
j++;
}
}

void procesarTablero (tJuego &juego) {
tFicha fichaAnterior = neutro;
tMatrizBooleana arrayBool;
iniciarArrayBool(arrayBool);
comprobarFilas(juego, arrayBool);
comprobarColumnas(juego, arrayBool);
}

void iniciarArrayBool(tMatrizBooleana arrayBool) {
for (int i = 0; i < FILAS; i++) {
for (int j = 0; j < COLUMNAS; j++) {
arrayBool[i][j] = false;
}
}
}

void comprobarFilas(tJuego &juego, tMatrizBooleana arrayBool) {
int contador = 0;
int j = 0;
tFicha fichaAnterior = neutro;
for (int i = 0; i < FILAS; i++) {
while (j < COLUMNAS) {
while (juego.tablero[i][j] == fichaAnterior && j < COLUMNAS) {
contador++;
fichaAnterior = juego.tablero[i][j];
j++;
}
if (contador == 2) {
juego.puntos = juego.puntos + 3;
for (int h = contador + 1; h > 0; h--) {
arrayBool[i][j-h] = true;
juego.tablero[i][j-h] = neutro;
}
}
else if (contador == 3) {
juego.puntos = juego.puntos + 8;
for (int h = contador + 1; h > 0; h--) {
arrayBool[i][j-h] = true;
juego.tablero[i][j-h] = neutro;
}
}
else if (contador >= 4) {
juego.puntos = juego.puntos + 15;
for (int h = contador + 1; h > 0; h--) {
arrayBool[i][j-h] = true;
juego.tablero[i][j-h] = neutro;
}
}
contador = 0;
fichaAnterior = juego.tablero[i][j];
j++;
}
j = 0;
fichaAnterior = none;
}
}

void comprobarColumnas(tJuego &juego, tMatrizBooleana arrayBool) {
int contador = 0;
int j = 0;
tFicha fichaAnterior = neutro;
for (int i = 0; i < COLUMNAS; i++) {
while (j < FILAS) {
while (juego.tablero[j][i] == fichaAnterior && j < COLUMNAS) {
contador++;
fichaAnterior = juego.tablero[j][i];
j++;
}
if (contador == 2) {
juego.puntos = juego.puntos + 3;
for (int h = contador + 1; h > 0; h--) {
arrayBool[j-h][i] = true;
juego.tablero[j-h][i] = neutro;
}
}
else if (contador == 3) {
juego.puntos = juego.puntos + 8;
for (int h = contador + 1; h > 0; h--) {
arrayBool[j-h][i] = true;
juego.tablero[j-h][i] = neutro;
}
}
else if (contador >= 4) {
juego.puntos = juego.puntos + 15;
for (int h = contador + 1; h > 0; h--) {
arrayBool[j-h][i] = true;
juego.tablero[j-h][i] = neutro;
}
}
contador = 0;
fichaAnterior = juego.tablero[j][i];
j++;
}
fichaAnterior = neutro;
j = 0;
}
}

// void gestionCaida(tJuego &juego){
// bool hanCaido= true;

// while (hanCaido) {
  // Volvemos a hacer caer todo el tablero
// caidaFichas(juego.tablero, hanCaido);
  // if (hanCaido) {
 // Muestra el tablero
  // mostrarTablero(juego);
// }
// }
// }


Tan solo me faltaría que las casillas de colores fueran desplazándose hacia abajo (para rellenar los huecos) y que, una vez que no hay más combinaciones de 3, 4 o 5 casillas adyacentes del mismo color, se llegara a un estado "estable" del tablero en el que se le pide al usuario qué ficha quiere mover y en qué dirección (arriba, abajo, izquierda o derecha) para que pueda seguir sumando el mayor número de puntos. El juego termina cuando no hay posibles combinaciones para el usuario.

Como ya he dicho, estoy en ello. Una vez que tenga este "Color Crush" terminado, subiré el código por si alguien quiere echarse una partidilla  ;D

Un saludo y gracias!