Mensajes

estoy en windows entonces pero con un bucle como?

la librería estándar de C++ no dispone de métodos que permitan una lectura no bloqueante sobre el buffer de entrada.

La opción sería crear una tarea con un hilo secundario que se encargase de realizar la lectura... en el hilo principal pones una espera activa hasta que pase el tiempo o el usuario introduzca un valor.... si se produce el timeout entonces matas el hilo secundario. Si antes de acabar el tiempo el usuario introduce un valor entonces dejas que el usuario introduzca su valor con normalidad y el programa continua.

[Nota:]

Nota: Para poner código, usa las etiquetas GeSHi, gracias.

Una posibilidad para evitar repetir las cartas es crearte un arreglo que contenga todas las cartas. Dado que para el caso has utilizado un identificador que va del 1 al 52 te vale con un arreglo de 52 posiciones y lo rellenas con un for de forma secuencial:

Código (c) [Seleccionar] Expandir


int baraja[52];

for ( i = 0; i < 52; i++ )
  baraja[ i ] = i+1;

Después tocaría barajar. Para ello puedes hacer uso de la función 'rand( )'. La idea es realizar permutaciones sobre la baraja para "mezclarla". Algo tal que:

Código (c) [Seleccionar] Expandir


for ( i = 0; i < 52; i++ )
{
  int pos = rand( ) % 52;

  int temp = baraja[ i ];
  baraja[ i ] = baraja[ pos ];
  baraja[ pos ] = temp;
}

Y luego, "repartir" puede ser simplemente asignar los valores del arreglo de forma secuencial:

Código (c) [Seleccionar] Expandir


// Cartas jugador 1
int cartas_jug1[ 4 ];
cartas_jug1[ 0 ] = baraja[ 0 ];
cartas_jug1[ 1 ] = baraja[ 1 ];
cartas_jug1[ 2 ] = baraja[ 2 ];
cartas_jug1[ 3 ] = baraja[ 3 ];

// Cartas jugador 2
int cartas_jug2[ 4 ];
cartas_jug2[ 0 ] = baraja[ 4 ];
cartas_jug2[ 1 ] = baraja[ 5 ];
cartas_jug2[ 2 ] = baraja[ 6 ];
cartas_jug2[ 3 ] = baraja[ 7 ];

// ...

Estos códigos se pueden mejorar bastante, la intención era presentar los conceptos de forma clara.

Por cierto, faltaría inicializar el generador de números aleatorios, pero eso ya te toca investigarlo a tí... no te lo voy a dar todo hecho

Un saludo.

el array así declarado apunta a cadenas que se encuentran en una zona de la memoria que es de solo lectura... te está diciendo que tienes que poner el modificador const a paises_miembros.

Código (c) [Seleccionar] Expandir

const char *paises_miembros[] = {"Argentina","Belgica","Estados Unidos","Francia","Reino Unido",
"Grecia","Hungria","Italia","Nueva Zelanda","Rusia","Suecia","Japon"};

Y el hecho de que fuerce un cast a char es porque el puntero "p" está declarado como apuntador a char, ¿no? ¿Podría haberse elegido cualquier otro tipo para apuntar? ¿No se podría haber elegido tipo int para evitar el casting?

se hace un cast a char* porque "p" es de tipo char*... si "p" fuese de tipo unsigned long long* entonces el cast hubiese sido a unsigned long long*

Código (c) [Seleccionar] Expandir

p = (char*)3500;

En esa línea estás haciendo que el puntero p apunte a la dirección 3500.

El cast lo hace porque a "p" le estás pasando un entero... y dado que "p" es un puntero, fuerza la compatibilidad entre tipos con un cast.

El programa básicamente imprime por pantalla el contenido de la memoria de la posición 3500 a la 5500.

En UTF-8 los valores esperados deberían ser los siguientes:

á: 0xc3 0xa1 - 2 caracteres.
ñ: 0xc3 0xb1 - 2 caracteres.

así pues para poder leer cada carácter necesitas dos lecturas consecutivas de tipo char.

No sabría decirte... a mi me funcionan las dos:

á = -96
ñ = -92

... yo estoy compilando con un compilador de C++, no tengo muy claro hasta que punto influye en este caso.

Ambos tipos usan 8 bits... unsigned char usa los 8 bits para representar el número... char usa el primer bit para representar el signo y los otros 7 para represetnar el número... pero una codificación binaria cualquiera es válida para ambos tipos.

El código binario es el mismo, lo único que cambia es la forma en la que se interpreta esa información.

Cuando tu haces una conversión explícita, lo único que sucede es que le estás diciendo al compilador que sabes que el dato se va a tratar de forma diferente... por lo que evitas la aparición de warnings. Sin embargo la información almacenada en memoria es exactamente la misma.

[Nota:]

Nota: code=c o code=cpp para que el código se coloree según el lenguaje que corresponda.

Código (c) [Seleccionar] Expandir

if ((tablero[x][y] == tablero[x+indice][y]) && ((x+indice) <=8) )

Si "tablero" tiene 8 columnas, la comprobación "((x+indice) <=8)" es peligrosa por necesidad... ya que si "x+indice==8" entonces estarás accediendo a una posición de memoria incorrecta y puede que hasta no válida.

Dicho esto, no entiendo el nombre de la función "cruz_abajo" (soy quisquilloso en el tema de los nombres porque la misma función puede ser la cosa más simple o la más complicada simplemente cambiando los nombres de la función y sus variables). ¿Qué debería hacer exactamente? Entiendo, viendo el código, que encontrar 3 elementos iguales, no?

Si esto es así tienes que tener en cuenta que si tu mueves el elemento posicionado en (x,y), deberías buscar en los rangos (x-2,y)-(x+2,y) y (x,y-2)-(x,y+2). Tu actualmente estás buscando únicamente en el rango (x,y)-(x+8,y)... se parecen los rangos como un sacapuntas a un coche.

Obviamente los rangos indicados son teóricos, luego tienes que asegurar que no "lees" fuera del tablero. Las comprobaciones para el primer rango podrían ser algo tal que:

Código (c) [Seleccionar] Expandir


#define MAXCOLUMNAS 8
#define MAXFILAS 4

int tablero [MAXCOLUMNAS][MAXFILAS] = //...

// ...

int indice;
for ( indice = x-2; indice <= x+2; ++indice )
{
  if ( indice >= 0 && indice < MAXCOLUMNAS )
  {
    if ( tablero[ indice ][ y ] == tablero[ x ][ y ] )
      contador++;
    else
      contador = 0;
  }
}

La definición de "tablero" la he cambiado porque no es buena idea tener valores puestos "a pelo" en el código... sobretodo si son referentes a límites impuestos (como el tamaño de la matriz "tablero").

Bueno, al caso. Con ese código, al finalizar el bucle, "contador" tendrá el tamaño del grupo. Fíjate en que si me encuentro un elemento que no es el buscado reseteo "contador". Esto es para evitar que cuente mal secuencias del tipo "808808". En el ejemplo, si no resetease "contador", éste acabaría con valor 4, cuando obviamente no es cierto.

Lo que sucede es que con este código no sabrás dónde empieza y dónde termina el grupo, por lo que quizás es buena idea almacenar las coordenadas inicial y final del grupo para poder hacer la limpieza de los elementos:

Código (c) [Seleccionar] Expandir


int buscarGrupoHorizontal( int x, int y, int* inicio, int* final )
{
  int contador = 0;
  int indice;
  for ( indice = x-2; indice <= x+2; ++indice )
  {
     if ( indice >= 0 && indice < MAXCOLUMNAS )
    {
      *final = indice;

      if ( tablero[ indice ][ y ] == tablero[ x ][ y ] )
      {
        if ( contador == 0 ) *inicio = indice;
        contador++;
      }
      else
      {
        // Dado que comprobamos 5 posiciones, si tenemos un grupo de 3 o superior no tenemos que seguir buscando.
        if ( contador >= 3 )
          break;

        contador = 0;
      }
    }
  }

  return contador;
}

De esta forma, si "contador >= 3", tendrás en "inicio" y "fin" las coordenadas "x" que delimitan el grupo. Esta información es importante para poder eliminar el grupo, bajar los elementos de esas columnas y generar elementos nuevos para la parte superior.

Te tocaría, eso si, implementar el buscador vertical.

Un saludo.