Ayuda con programa urgente!

[leosansan]

A mí tampoco me va leo. ¿No tendrás activado el fpermissive?

El error se debe a que has declarado una matriz de 27 elementos por columna, tu le has puesto 27 elementos +caracter nulo.

¿Dónde se mira lo del fpermissive?.

En todo caso la matriz sería de 24x28 para incluir el caracter nulo, aunque luego en la impresión se iría hasta<27, como está, teniendo en cuenta que empezamos a contar de cero.

Pero es muy raro. Tengo activado el modo -Wall y el -pedantic  y no me "canta" nada, ni warnings.

Espero noticias.

Saluditos! ..... !!!!        

REEDITO: No, no tengo activado el modo fpermissive.

Lo raro es que lo ejecuté tanto en Code::Blocks como en Dev-C++ y ninguno se "quejo".

Pero bueno, no deja de ser un error y ya lo he corregido en todos los post.

Gracias por la observación.

[vangodp]

a mi si me funciono guardando en .c

[amchacon]

Añado un código que te resuelve el laberinto buscando la ruta más corta:

Código (cpp) [Seleccionar] Expandir

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

#define INIX 1
#define INIY 1
#define FINX 22
#define FINY 25
#define MAX_X 24
#define MAX_Y 28

void mostrar(char a[][MAX_Y],char *msg);
void color (int n);

typedef struct cord
{
   int x,y;
} Cord;

typedef struct nodo
{
   int Distancia;
   Cord Posicion;
   char Calculado;
   struct nodo* anterior;
} Nodo;

char buscarSolucion(char mapa[][MAX_Y],Cord Ini,Cord Fin);
void MarcarNodo(Nodo* Actual,Nodo* Otro);

int main ()
{

   char a[MAX_X][MAX_Y]=
   {
       "000000000000000000000000000",
       "012222222222222222222222220",
       "022020200020002000000000020",
       "022202022020202000000000020",
       "020000000020202000000000020",
       "020222220020220200022222220",
       "022000000000000200020000020",
       "022222222222200200020000020",
       "022200000000200222222222000",
       "022222222200200000020002020",
       "022200000020222222222222220",
       "022222222200200000000000020",
       "020000000000222222222222220",
       "022000022200200000000000020",
       "020000000000200222222222220",
       "022222222222222200000000020",
       "020000000000000222222202020",
       "020000000000000200000202020",
       "022222222222222200000202020",
       "000002000000000200002222220",
       "020222222222222222222200000",
       "020000000000000000000222220",
       "022222222222222222222220010",
       "000000000000000000000000000"
   };
   mostrar(a,"LABERINTO");

   Cord Inicio;
   Inicio.x = INIX;
   Inicio.y = INIY;

   Cord Final;
   Final.x = FINX;
   Final.y = FINY;

   buscarSolucion(a,Inicio,Final);

   return 0;
}

void mostrar(char a[][MAX_Y],char *msg)
{
   system ("cls");
   int i,j;
   for( i=0; i<MAX_X; i++)
   {
       for( j=0; j<MAX_Y-1; j++)
       {
           if ((i==FINX && j==FINY) ||(i==INIX && j==INIY))
               color(215);
           else if (a[i][j]=='X')
               color(125);
           else if (a[i][j]=='0')
               color(175);
           else
               color(7);
           printf("%c ",a[i][j]);
           fflush(stdout);
       }
       putchar('\n');
   }
   color(7);
   printf ("\n\t\t%s\n\n",msg);
   system ("pause");
}

void color (int n)
{
   SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}

char buscarSolucion(char mapa[][MAX_Y],Cord Ini,Cord Fin)
{
   if (Ini.x == Fin.x && Ini.y == Fin.y)
   {
       return 1;
   }
   Cord Actual;
   Actual.x = Ini.x;
   Actual.y = Ini.y;

   Nodo* Totales[MAX_X][MAX_Y];

   int Nodos = 0;
   int i = 0;
   int j = 0;

   for (; i < MAX_X; i++)
   {
       for (j = 0; j < MAX_Y; j++)
       {
           if (mapa[i][j] != '0')
           {
               Totales[i][j] = (Nodo*) malloc(sizeof(Nodo));
               Totales[i][j]->anterior = 0;
               Totales[i][j]->Calculado = 0;
               Totales[i][j]->Distancia = -1;
               Totales[i][j]->Posicion.x = i;
               Totales[i][j]->Posicion.y = j;
               Nodos++;
           }
           else Totales[i][j] = 0;
       }
   }

   Totales[Ini.x][Ini.y]->Distancia = 0;

   Cord Min;

  //mapa[Actual.x][Actual.y] = 'X';

   while ((Actual.x != Fin.x || Actual.y != Fin.y) && Nodos != 0)
   {
       // Izquierda

       if (Totales[Actual.x-1][Actual.y] && Totales[Actual.x-1][Actual.y]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x-1][Actual.y]);
       }

       // Derecha

       if (Totales[Actual.x+1][Actual.y] && Totales[Actual.x+1][Actual.y]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x+1][Actual.y]);
       }

       // Abajo

       if (Totales[Actual.x][Actual.y-1] && Totales[Actual.x][Actual.y-1]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y-1]);
       }

       // Arriba

       if (Totales[Actual.x][Actual.y+1] && Totales[Actual.x][Actual.y+1]->Calculado == 0)
       {
          MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y+1]);
       }

       Totales[Actual.x][Actual.y]->Calculado = 1; //Marcado!
       
       // Buscando un valor de referencia al minimo

       for (i = 0; i < MAX_X; i++)
       {
           for (j = 0; j < MAX_Y; j++)
           {
               if (Totales[i][j] && Totales[i][j]->Calculado == 0 && Totales[i][j]->Distancia != -1)
               {
                   Min.x = i;
                   Min.y = j;
                   i = 25;
                   j = 29;
               }
           }
       }

       // Buscando la distancia minima

       for (; i < MAX_X; i++)
       {
           for (j = 0; j < MAX_Y; j++)
           {
               if (Totales[i][j] && Totales[i][j]->Distancia < Totales[Min.x][Min.y]->Distancia
                   && Totales[i][j]->Distancia != -1 && Totales[i][j]->Calculado == 0)
               {
                   Min.x = i;
                   Min.y = j;
               }
           }
       }
       Actual.x = Min.x;
       Actual.y = Min.y;
       Nodos--;
   }

   Nodo* Cosa = Totales[Actual.x][Actual.y];

   while (Cosa)
   {
       Actual.x = Cosa->Posicion.x;
       Actual.y = Cosa->Posicion.y;
       mapa[Actual.x][Actual.y] = 'X';
       Cosa = Cosa->anterior;
   }

   // borrar

   for (i = 0; i < 24; i++)
   {
       for (j = 0; j < 28; j++)
       {
           free(Totales[i][j]);
       }
   }

   mostrar(mapa,"Prueba");

   return (Nodos != 0);
}

void MarcarNodo(Nodo* Actual,Nodo* Otro)
{
   if (Otro->Distancia == -1)
   {
       Otro->Distancia = Actual->Distancia+1;
       Otro->anterior = Actual;
   }
   else if (Actual->Distancia+1 < Otro->Distancia)
   {
       Otro->Distancia = Actual->Distancia+1;
       Otro->anterior = Actual;
   }
}

[vangodp]

¡waaa eso ya es tecnología punta!
Tengo echo unos pinitos jaja, pero no es nada comparado a esto. XD
Tampoco es a colores como lo de leo y el tuyo.
Un par de ajustes y lo subo si prometéis no reír de mi. ><
Ando algo desanimado pero estoy en ello.
Saludos 

[amchacon]

Tampoco es a colores como lo de leo y el tuyo.

Los colores los he copiado totalmente del código de Leo, es un artista.

Y por último, me falta añadir una función que te busca una ruta aleatoria (sin repetir casillas):

Código (c) [Seleccionar] Expandir

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

#define INIX 1
#define INIY 1
#define FINX 22
#define FINY 25
#define MAX_X 24
#define MAX_Y 28

void mostrar(char a[][MAX_Y],char *msg);
void color (int n);

typedef struct cord
{
   int x,y;
} Cord;

typedef struct nodo
{
   int Distancia;
   Cord Posicion;
   char Calculado;
   struct nodo* anterior;
  // struct nodo* siguiente;
} Nodo;

char buscarSolucion(char mapa[][MAX_Y],Cord Ini,Cord Fin);
char buscarSolucionAleatoria(char mapa[][MAX_Y],Cord Ini,Cord Fin);
void MarcarNodo(Nodo* Actual,Nodo* Otro);

int main ()
{

   char a[MAX_X][MAX_Y]=
   {
       "000000000000000000000000000",
       "012222222222222222222222220",
       "022020200020002000000000020",
       "022202022020202000000000020",
       "020000000020202000000000020",
       "020222220020220200022222220",
       "022000000000000200020000020",
       "022222222222200200020000020",
       "022200000000200222222222000",
       "022222222200200000020002020",
       "022200000020222222222222220",
       "022222222200200000000000020",
       "020000000000222222222222220",
       "022000022200200000000000020",
       "020000000000200222222222220",
       "022222222222222200000000020",
       "020000000000000222222202020",
       "020000000000000200000202020",
       "022222222222222200000202020",
       "000002000000000200002222220",
       "020222222222222222222200000",
       "020000000000000000000222220",
       "022222222222222222222220010",
       "000000000000000000000000000"
   };
   mostrar(a,"LABERINTO");
  srand(time(0));
   Cord Inicio;
   Inicio.x = INIX;
   Inicio.y = INIY;

   Cord Final;
   Final.x = FINX;
   Final.y = FINY;

   buscarSolucion(a,Inicio,Final);

  while(1) buscarSolucionAleatoria(a,Inicio,Final);

   return 0;
}

void mostrar(char a[][MAX_Y],char *msg)
{
   system ("cls");
   int i,j;
   for( i=0; i<MAX_X; i++)
   {
       for( j=0; j<MAX_Y-1; j++)
       {
           if ((i==FINX && j==FINY) ||(i==INIX && j==INIY))
               color(215);
           else if (a[i][j]=='X')
               color(125);
           else if (a[i][j]=='0')
               color(175);
           else
               color(7);
           printf("%c ",a[i][j]);
           fflush(stdout);
       }
       putchar('\n');
   }
   color(7);
   printf ("\n\t\t%s\n\n",msg);
   system ("pause");
}

void color (int n)
{
   SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}

char buscarSolucionAleatoria(char Mapa[][MAX_Y],Cord Ini,Cord Fin)
{
       char mapa[MAX_X][MAX_Y];
   if (Ini.x == Fin.x && Ini.y == Fin.y)
   {
       return 1;
   }
   Cord Actual;
   Actual.x = Ini.x;
   Actual.y = Ini.y;

   Nodo* Totales[MAX_X][MAX_Y];
   int i = 0;
   int j = 0;

   for (; i < MAX_X; i++)
   {
       for (j = 0; j < MAX_Y; j++)
       {
           mapa[i][j] = Mapa[i][j];
           if (mapa[i][j] != '0')
           {
               Totales[i][j] = (Nodo*) malloc(sizeof(Nodo));
               Totales[i][j]->anterior = 0;
               Totales[i][j]->Calculado = 0;
               Totales[i][j]->Distancia = -1;
               Totales[i][j]->Posicion.x = i;
               Totales[i][j]->Posicion.y = j;
           }
           else Totales[i][j] = 0;
       }
   }

   Cord Min;

   int Posibilidades = 0;
   Nodo* Aux[4];

   while ((Actual.x != Fin.x || Actual.y != Fin.y))
   {

       // Izquierda

       Posibilidades = 0;

       if (Totales[Actual.x-1][Actual.y] && Totales[Actual.x-1][Actual.y]->Calculado == 0)
       {
           Aux[0] = Totales[Actual.x-1][Actual.y];
           Posibilidades++;
       }

       // Derecha

       if (Totales[Actual.x+1][Actual.y] && Totales[Actual.x+1][Actual.y]->Calculado == 0)
       {
           Aux[Posibilidades] = Totales[Actual.x+1][Actual.y];
           Posibilidades++;
       }

       // Abajo

       if (Totales[Actual.x][Actual.y-1] && Totales[Actual.x][Actual.y-1]->Calculado == 0)
       {
           Aux[Posibilidades] = Totales[Actual.x][Actual.y-1];
           Posibilidades++;
       }

       // Arriba

       if (Totales[Actual.x][Actual.y+1] && Totales[Actual.x][Actual.y+1]->Calculado == 0)
       {
          Aux[Posibilidades] = Totales[Actual.x][Actual.y+1];
          Posibilidades++;
       }

      Totales[Actual.x][Actual.y]->Calculado = 1; //Marcado!

       if (Posibilidades == 0)
       {
           if (!Totales[Actual.x][Actual.y]->anterior) return 0;

           int aux_x = Actual.x;
           Actual.x = Totales[Actual.x][Actual.y]->anterior->Posicion.x;
           Actual.y = Totales[aux_x][Actual.y]->anterior->Posicion.y;
       }
       else if (Posibilidades == 1)
       {
               char mapa[MAX_X][MAX_Y];Aux[0]->anterior = Totales[Actual.x][Actual.y];
           Actual.x = Aux[0]->Posicion.x;
           Actual.y = Aux[0]->Posicion.y;
       }
       else
       {
           int n = rand()%Posibilidades;
           Aux[n]->anterior = Totales[Actual.x][Actual.y];
           Actual.x = Aux[n]->Posicion.x;
           Actual.y = Aux[n]->Posicion.y;
       }
   }
   Nodo* Cosa = Totales[Actual.x][Actual.y];

   while (Cosa)
   {
       Actual.x = Cosa->Posicion.x;
       Actual.y = Cosa->Posicion.y;
       mapa[Actual.x][Actual.y] = 'X';
       Cosa = Cosa->anterior;
   }
//&mostrar(mapa,"Ruta aleatoria");
   // borrar

   for (i = 0; i < 24; i++)
   {
       for (j = 0; j < 28; j++)
       {
           free(Totales[i][j]);
       }
   }

   mostrar(mapa,"Ruta aleatoria");

   return 1;
}

char buscarSolucion(char Mapa[][MAX_Y],Cord Ini,Cord Fin)
{
   char mapa[MAX_X][MAX_Y];
   if (Ini.x == Fin.x && Ini.y == Fin.y)
   {
       return 1;
   }
   Cord Actual;
   Actual.x = Ini.x;
   Actual.y = Ini.y;

   Nodo* Totales[MAX_X][MAX_Y];

   int Nodos = 0;
   int i = 0;
   int j = 0;

   for (; i < MAX_X; i++)
   {
       for (j = 0; j < MAX_Y; j++)
       {
           mapa[i][j] = Mapa[i][j];
           if (mapa[i][j] != '0')
           {
               Totales[i][j] = (Nodo*) malloc(sizeof(Nodo));
               Totales[i][j]->anterior = 0;
               Totales[i][j]->Calculado = 0;
               Totales[i][j]->Distancia = -1;
               Totales[i][j]->Posicion.x = i;
               Totales[i][j]->Posicion.y = j;
               Nodos++;
           }
           else Totales[i][j] = 0;
       }
   }

   Totales[Ini.x][Ini.y]->Distancia = 0;

   Cord Min;

  //mapa[Actual.x][Actual.y] = 'X';

   while ((Actual.x != Fin.x || Actual.y != Fin.y) && Nodos != 0)
   {
       // Izquierda

       if (Totales[Actual.x-1][Actual.y] && Totales[Actual.x-1][Actual.y]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x-1][Actual.y]);
       }

       // Derecha

       if (Totales[Actual.x+1][Actual.y] && Totales[Actual.x+1][Actual.y]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x+1][Actual.y]);
       }

       // Abajo

       if (Totales[Actual.x][Actual.y-1] && Totales[Actual.x][Actual.y-1]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y-1]);
       }

       // Arriba

       if (Totales[Actual.x][Actual.y+1] && Totales[Actual.x][Actual.y+1]->Calculado == 0)
       {
          MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y+1]);
       }

       Totales[Actual.x][Actual.y]->Calculado = 1; //Marcado!

       // Buscando un valor de referencia al minimo

       for (i = 0; i < MAX_X; i++)
       {
           for (j = 0; j < MAX_Y; j++)
           {
               if (Totales[i][j] && Totales[i][j]->Calculado == 0 && Totales[i][j]->Distancia != -1)
               {
                   Min.x = i;
                   Min.y = j;
                   i = 25;
                   j = 29;
               }
           }
       }

       // Buscando la distancia minima

       for (; i < MAX_X; i++)
       {
           for (j = 0; j < MAX_Y; j++)
           {
               if (Totales[i][j] && Totales[i][j]->Distancia < Totales[Min.x][Min.y]->Distancia
                   && Totales[i][j]->Distancia != -1 && Totales[i][j]->Calculado == 0)
               {
                   Min.x = i;
                   Min.y = j;
               }
           }
       }
       Actual.x = Min.x;
       Actual.y = Min.y;
       Nodos--;
   }

   Nodo* Cosa = Totales[Actual.x][Actual.y];

   while (Cosa)
   {
       Actual.x = Cosa->Posicion.x;
       Actual.y = Cosa->Posicion.y;
       mapa[Actual.x][Actual.y] = 'X';
       Cosa = Cosa->anterior;
   }

   // borrar

   for (i = 0; i < 24; i++)
   {
       for (j = 0; j < 28; j++)
       {
           free(Totales[i][j]);
       }
   }

   mostrar(mapa,"Ruta mas corta");

   return (Nodos != 0);
}

void MarcarNodo(Nodo* Actual,Nodo* Otro)
{
   if (Otro->Distancia == -1)
   {
       Otro->Distancia = Actual->Distancia+1;
       Otro->anterior = Actual;
   }
   else if (Actual->Distancia+1 < Otro->Distancia)
   {
       Otro->Distancia = Actual->Distancia+1;
       Otro->anterior = Actual;
   }
}

El código está chapurreado en pocos tiempo y no es ni bonito ni elegante. Pero funciona perfecto que es lo que importa.

Las dos funciones hacen cosas parecidas:

- Modelan el laberinto en un grafo (sin aristas, puesto que sabemos que todos los nodos tienen siempre 4 conexiones (izquierda,derecha,arriba  y abajo) ).
- Realizan una adaptación de algún algoritmo de grafos. Para el de la ruta más corta es Dijkstra:
Dikstra]http://es.wikipedia.org/wiki/Algoritmo_de_Dijkstra]Dikstra

Y para el de la ruta aleatoria uso una modificación del DFS (Depth First Search). La modificación esque elige las ramas aleatoriamente:
http://es.wikipedia.org/wiki/B%C3%BAsqueda_en_profundidad

El algoritmo finaliza cuando llegan al vértice final, una vez allí "van hacia atrás" pintando el camino hasta el inicio.

[vangodp]

Que dice jaja es un peazo de código jeje
Para que no repitiera el camino, y digo camino sin salida fue hacer una especie de backup del trayecto XD
Primero hice una for para contar todos los números 2 que hay. después  hice un par de tablas con esa cantidad, una para x y una para y.
luego un contador y y le fue grabando a cada vuelta el valor de la posición actual.
Bien...eso solo se activa cuando el punto se encuentra con números 1, o sea ya explorado.
Entonces en ese momento empieza una cuenta atrás del contador y voy imprimiendo lo que había guardado en backupx y backupy
Funciona de perfectamente y es capaz de hacer el personaje volver por todo el camino.
Para marcar ese camino lo relleno con ceros, o sea que se vuelve hasta la primera intercesión hasta encontrar un 2 nuevamente y lo rellena el camino sin salida con ceros para no meterse mas por ahí XDD

hay unos bugcitos jaja

Pero bueno, no soy tan bueno con los punteros jaja
Pero hace el apaño.

Bueno lo pongo aquí:
No se compara con el vuestro pero llego al final.
tampoco le hice que se rompiera el bucle así que si me lo vaes a echar como fallo arreglad vosotros jajaja

Código (cpp) [Seleccionar] Expandir


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

# define udir mapa[y-1][x]
# define ldir mapa[y][x-1]
# define rdir mapa[y][x+1]
# define ddir mapa[y+1][x]
# define po mapa[y][x]
using namespace std;

const int TAMY = 29;
const int TAMX = 29;

int contapasos = 0;

void mostrar(char mapa[TAMY][TAMX]){
system ("cls");

    for(int y=0;y<29;y++)
    {
    for(int x=0;x<29;x++)
    {
    printf("%c",mapa[y][x]);
    //Sleep(5);
    }
    printf("\n");
    //Sleep(5);
    }
   
}
 
int rand4 (){
srand(time(NULL));
int n = (0 + rand() % 4);
return n;
}

void go_up ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
y--;
po = 'X';
}

void go_le ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
x--;
po = 'X';
}

void go_ri ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
x++;
po = 'X';
}

void go_do ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
y++;
po = 'X';
}


int main (){
//variables iniciales
int pasos = 0;
bool nodir = true;
bool fin = true;
int x = 1; //posicion x inicial
int y = 1; //posicion y inicial
int rand;
char mapa[TAMY][TAMX]={
  //0123456789012345678901234567
"000000000000000000000000000",//0
"020222222222222222222222220",//1
"020200000000000000000000020",//2
"020222222222222200000000020",//3
"020200000000000000000000020",//4
"020222222222222200022222220",//5
"020000000000000200020000020",//6
"020222222222200200000000020",//7
"020200000000200222222222020",//8
"020222222200200000000002020",//9
"020000000200222222222222020",//10
"022222220200000000000000020",//11
"020000020200222222222222220",//12
"020000022200200000000000000",//13
"000000000000200222222222220",//14
"022222222222200200000000020",//15
"020000000000000222222202020",//16
"020000000000000200000202020",//17
"022222222222222200000202020",//18
"000000000000000000000202220",//19
"022222222222222222222200000",//20
"020000000000000000000000000",//21
"02222222222222222222222FIN0",//22
"000000000000000000000000000" //23

};
//obtenr cantidad maxima de pasos pocibles.
for ( int fory = 0; fory <= TAMY; fory++  ){
for ( int forx = 0; forx <= TAMX; forx++  ){
if ( mapa[fory][forx] == '2' )
pasos++;
}
}
int xbackup[pasos];
int ybackup[pasos];


while ( fin ){
while ( udir == '1' || ldir == '1' || rdir == '1' || ddir == '1' ){
if ( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){
break;
}

contapasos--;
mapa[y][x]='0';
x = xbackup[contapasos];
y = ybackup[contapasos];
mapa[y][x]='X';
mostrar( mapa );
Sleep ( 100 );
}

contapasos++;
xbackup[contapasos]= x;
ybackup[contapasos]= y;

if( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){

do{

rand = rand4();


if ( udir == '2' && ldir != '2' && rdir != '2' && ddir != '2' ){
go_up( mapa, x, y );
break;
}
else if ( udir != '2' && ldir == '2' && rdir != '2' && ddir != '2' ){
go_le( mapa, x, y );
break;
}
else if ( udir != '2' && ldir != '2' && rdir == '2' && ddir != '2' ){
go_ri( mapa, x, y );
break;
}
else if ( udir != '2' && ldir != '2' && rdir != '2' && ddir == '2' ){
go_do( mapa, x, y );
break;
}

else if ( rand == 0 ){
if ( udir == '0' || udir == '1' ){
nodir = true;
break;
}
else {
go_up( mapa, x, y );
nodir = false;
}

}
else if ( rand == 1 ){
if ( ldir == '0' || ldir == '1' ){
nodir = true;
break;
}
else {
go_le( mapa, x, y );
nodir = false;
}

}
else if ( rand == 2 ){
if ( rdir == '0' || rdir == '1' ){
nodir = true;
break;

}
else {
go_ri( mapa, x, y );
nodir = false;
}

}
else if ( rand == 3 ){
if ( ddir == '0' || ddir == '1' ){
nodir = true;
break;
}
else {
go_do( mapa, x, y );
nodir = false;
}

}

}while( nodir );//FIN DOWHILE

}//FIN IF
mostrar( mapa );
Sleep ( 100 );
}//FIN DEL LOOP

}



Otra cosa, que me gusta ver la x andando por el mapa jaja
Asi puedo analizar lo que va haciendo XD
As veces se queda un rato parado en una intercesión, eso lo hace hasta que obtiene un numero aleatorio correcto.
Podía mejorarlo pero bua lo dejo así que soy mu vaguito XD
Como dije no es como el vuestro pero me sirve.
Saludos a todos, me lo paso bomba con esos códigos  

Como diga que no anda os grabo un video jajaj
Otra cosa que tengo problemas es con la declaracion de las tablas.
No se por que demonios tengo que poner un numero mayor que lo que voy usar.
creo que es por los ceros, a lo mejor si sustituyo los 0 po X o otra cosa.
Creo que es así por que creo que termina la tabla con char( 0 ) no?
Si saben por que, pasa eso me gustaría saber si declaro char tabla[10]
no le puedo meter de 0 a 9 por que me dice no sequela de fpermisive los webos.
Me parece que en el caso de char la ultima letra es 0 no es ¿así?
La cosa es que veo vuestro código funcionar y el mio pues no anda.
es raro pero me esta pasando pffff

[amchacon]

Código (cpp) [Seleccionar] Expandir

int rand4 (){
srand(time(NULL));
int n = (0 + rand() % 4);
return n;
}
El srand debe usarse UNA SOLA VEZ preferentemente al principio. De lo contrario obtendrás siempre los mismos números (ya que no ha pasado el suficiente tiempo como para que cambie la semilla).

Como diga que no anda os grabo un video jajaj
Otra cosa que tengo problemas es con la declaracion de las tablas.
No se por que demonios tengo que poner un numero mayor que lo que voy usar.

El problema es el uso de comillas, si pones comillas el compilador te añade automáticamente un caracter nulo al final. Para que no te lo añadiera tendrías que ponerlos letra a letra con las comillas simples ' '.

Aumenta en uno el tamaño y listo. Eso es lo que he hecho en mi código.

[vangodp]

Pues gracias man, me lo imaginaba pero no tenia certeza XD 

[leosansan]

¡¡¡Pedazo de código amchacon!!!!. Está visto que te lo has currado de lo lindo.

Antes que nada GRACIAS. Es un código muy pero que muy interesante, al menos para mí. Me recuerda que tengo que ponerme las pilas en el tema de estructuras, listas y muy especialmente en arboles, facilita mucho las cosas.

Como comprobarás por mi código final, yo me apaño, creo que bastante bien, con los arrays. Y es que el mundo de donde vengo se pierde en el tiempo. Era una época en que lo más que habían para estas cosas eran los arrays y, en todo caso, los famosos sprites. Eso sí, tenían capacidades gráficas y de sonido de forma nativa, nada de librerías externas ni cosas por el estilo. Sin duda era mucho más fácil programar un ping-pong o un break. La verdad que en ese sentido el C me decepciona ya que las librerías gráficas, al menos las que he ojeado, son todo un *oñazo y poco intuitivas. Pero en fin, es lo que hay.

Y vamos a lo que vamos, a comentar y realizar observaciones, que no críticas -no entra en mi ánimo ni mucho menos- sobre los códigos y métodos usados en vuestros códigos.

Repito querido amigo Mikel Angelo, son sólo observaciones, no quiero que te lo tomes o mal ni las veas como críticas.

Añado un código que te resuelve el laberinto buscando la ruta más corta:

Pues va a ser que no. Algo tendrás que revisar porque no da exactamente la ruta más corta: casi, casi, pero no.

Y como muestra dos botones:

Los colores los he copiado totalmente del código de Leo, es un artista.

No es para tanto. Además lo explique, creo que meridianamente clarito, en el tema de GAMA DE COLORES, tema que aconsejo a todo el que quiera darle un poco de vidilla a sus códigos.

- Realizan una adaptación de algún algoritmo de grafos. Para el de la ruta más corta es Dijkstra:
Dikstra]http://es.wikipedia.org/wiki/Algoritmo_de_Dijkstra]Dikstra
Y para el de la ruta aleatoria uso una modificación del DFS (Depth First Search). La modificación esque elige las ramas aleatoriamente:
http://es.wikipedia.org/wiki/B%C3%BAsqueda_en_profundidad

La verdad es que el tema de grafos es, como diría, espeso, eso es. Lo tuve que dominar en profundidad en su momento, tanto por haberlo dado en la asignatura correspodiente de Álgebra como por las múltiples aplicaciones en otras asignaturas, como Regulación Automática, Administración de Empresas,Procesos químicos, Economía,etc.

Pero siempre me dejo un mal regusto, me parece primitivo en los tiempos que corren con el uso de los ordenadores. Así que me voy a poner a ello y voy a desarrollar mi propio sistema para determinar el camino más corto entre dos puntos, que se note que soy Ingeniero y que hacemos honor al nombre: ingeniar, innovar.

No es moco de pavo el problemita pero si pillo un par de días, la familia ocupa casi todo el tiempo, pero el problema tiene unas implicaciones la mar de interesantes, como la búsqueda del camino más corto entre dos puntos en un viaje en coche, o la mejor ruta para el reparto de mercancías entre dos puntos/ciudades, entre otros muchos casos.

Y respecto al uso del DFS (Depth First Search)  

comentar que el problema que nos traemos entre manos, que no es baladí, es algo más complejo ya que implica que el árbol cierre y/o conecte buena parte de las subramas de las ramas principales y que el origen y fin sean los nodos extremos, es decir que se cierren las ramas por abajo en un punto final, amén de las comentadas interconexciones entre subramas. Vamos que es bastante más complejo que un simple árbol como el que muestra la figura y las modificaciones que abría que hacer al susodicho método DFS son de tal envergadura que yo me pondría, y me voy a poner, a desarrollar un nuevo método.

Lo de pintar el camino hacia atrás ni me molesto porque es como algo obvio.

vangodp, querido amigo, ahora voy a por ti.

.................................................................
Funciona de perfectamente y es capaz de hacer el personaje volver por todo el camino.
.........................................
hay unos bugcitos jaja
.................................................................

A veces se queda un rato parado en una intercesión, eso lo hace hasta que obtiene un numero aleatorio correcto.
Podía mejorarlo pero bua lo dejo así que soy mu vaguito XD
.............................................................................
Como diga que no anda os grabo un video jajaj
Otra cosa que tengo problemas es con la declaracion de las tablas.
..............................................
La cosa es que veo vuestro código funcionar y el mio pues no anda.
es raro pero me esta pasando pffff

Por vídeos que no quede esta vez.

* Por un lado debes dejar un espacio en blanco al lado de %c del printf que te dibuja el laberinto. Tal como lo tienes sale demasiado pegado en horizontal y no se ve bien.

* ¿Intentas provocar un ataque de epilepsia a los usuarios?. Es insufrible el que cada vez que camines por el laberinto se redibuje toda la matriz, eso trae como consecuencia un parpadeo incesante de la imagen que hace difícil seguir el movimiento de la casilla en cuestión. Observa si no:

[youtube=640,360]http://www.youtube.com/watch?v=MN0Q7qENjzA[/youtube]

En cambio más separaditos y con color:

[youtube=640,360]http://www.youtube.com/watch?v=bJjGYkufpPk[/youtube]

Código (cpp) [Seleccionar] Expandir


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

# define udir mapa[y-1][x]
# define ldir mapa[y][x-1]
# define rdir mapa[y][x+1]
# define ddir mapa[y+1][x]
# define po mapa[y][x]
using namespace std;

const int TAMY = 24;
const int TAMX = 28;

int contapasos = 0;
void mostrar(char mapa[TAMY][TAMX]);
void color (int n);
int gotoxy(int x, int y);

void mostrar(char mapa[TAMY][TAMX]){
system ("cls");
   int x,y;
    for( y=0;y<TAMY;y++)
    {
    for( x=0;x<TAMX-1;x++)
    {
    if ((y==TAMY-2 && x==TAMX-3) ||(x==1 && y==1))
               color(195);
           else if (x==0 || y==0 || x==TAMX-2 || y==TAMY-1)
               color(125);
           else if (mapa[y][x]=='0')
               color(175);
           else if (mapa[y][x]=='X'){
             mapa[y][x]='2';
             color(7);
           }
           else if (mapa[y][x]=='1'){
             mapa[y][x]='1';
             color(215);
           }
           else
             color(7);
           printf("%c ",mapa[y][x]);
           fflush(stdout);

    //Sleep(5);
    }
    color(7);
    putchar('\n');
    //Sleep(5);
    }

}

 int rand4 (){
int n = (0 + rand() % 4);
return n;
}

void go_up ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
y--;
po = 'X';
}

void go_le ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
x--;
po = 'X';
}

void go_ri ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
x++;
po = 'X';
}

void go_do ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
y++;
po = 'X';
}


int main (){
//variables iniciales
srand(time(NULL));
system ("pause");
int pasos = 0;
bool nodir = true;
bool fin = true;
int x = 1; //posicion x inicial
int y = 1; //posicion y inicial
int rand;
char mapa[TAMY][TAMX]={
  //0123456789012345678901234567
"000000000000000000000000000",//0
"020222222222222222222222220",//1
"020200000000000000000000020",//2
"020222222222222200000000020",//3
"020200000000000000000000020",//4
"020222222222222200022222220",//5
"020000000000000200020000020",//6
"020222222222200200000000020",//7
"020200000000200222222222020",//8
"020222222200200000000002020",//9
"020000000200222222222222020",//10
"022222220200000000000000020",//11
"020000020200222222222222220",//12
"020000022200200000000000000",//13
"000000000000200222222222220",//14
"022222222222200200000000020",//15
"020000000000000222222202020",//16
"020000000000000200000202020",//17
"022222222222222200000202020",//18
"000000000000000000000202220",//19
"022222222222222222222200000",//20
"020000000000000000000000000",//21
"0222222222222222222222222F0",//22
"000000000000000000000000000" //23

};
//obtenr cantidad maxima de pasos pocibles.
for ( int fory = 0; fory <= TAMY; fory++  ){
for ( int forx = 0; forx <= TAMX; forx++  ){
if ( mapa[fory][forx] == '2' )
pasos++;
}
}
int xbackup[pasos];
int ybackup[pasos];


while ( fin ){
while ( udir == '1' || ldir == '1' || rdir == '1' || ddir == '1' ){
if ( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){
break;
}

contapasos--;
mapa[y][x]='0';
x = xbackup[contapasos];
y = ybackup[contapasos];
mapa[y][x]='X';
mostrar( mapa );
//Sleep ( 100 );
}

contapasos++;
xbackup[contapasos]= x;
ybackup[contapasos]= y;

if( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){

do{

rand = rand4();


if ( udir == '2' && ldir != '2' && rdir != '2' && ddir != '2' ){
go_up( mapa, x, y );
break;
}
else if ( udir != '2' && ldir == '2' && rdir != '2' && ddir != '2' ){
go_le( mapa, x, y );
break;
}
else if ( udir != '2' && ldir != '2' && rdir == '2' && ddir != '2' ){
go_ri( mapa, x, y );
break;
}
else if ( udir != '2' && ldir != '2' && rdir != '2' && ddir == '2' ){
go_do( mapa, x, y );
break;
}

else if ( rand == 0 ){
if ( udir == '0' || udir == '1' ){
nodir = true;
break;
}
else {
go_up( mapa, x, y );
nodir = false;
}

}
else if ( rand == 1 ){
if ( ldir == '0' || ldir == '1' ){
nodir = true;
break;
}
else {
go_le( mapa, x, y );
nodir = false;
}

}
else if ( rand == 2 ){
if ( rdir == '0' || rdir == '1' ){
nodir = true;
break;

}
else {
go_ri( mapa, x, y );
nodir = false;
}

}
else if ( rand == 3 ){
if ( ddir == '0' || ddir == '1' ){
nodir = true;
break;
}
else {
go_do( mapa, x, y );
nodir = false;
}

}

}while( nodir );//FIN DOWHILE

}//FIN IF
mostrar( mapa );
Sleep ( 100 );
}//FIN DEL LOOP

}
void color (int n)
{
       SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}


** ¿Y como evitas el parpadeo?. Sencillo, dibujas una sola vez la matriz y ya no refrescas más la pantalla con el system("pause") cada vez que haces un movimiento. Lo que haces es aprovechar que la matriz está dibujada y sobre esa misma matriz mueves la casilla.

** ¿Y cómo diablos consigues que se mueva la casilla sin cambiar la matriz?.  Sencillo, con una función de las API de Windows que permite situar el cursor en cualquier posición de la pantalla y escribir, e incluso sobrescribir, en un punto determinado. La función que realiza tal cometido es "goto", así como la función "color" es la encargada de dar color. Te pongo un vídeo de muestra, no te preocupes que todos duran menos de un minuto- y el código que te muestra cómo hacer lo que te comento:

[youtube=640,360]http://www.youtube.com/watch?v=7e4W1uDc_Gk[/youtube]

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#define FIL 7
#define COL 8

void color (int n);
int gotoxy(int x, int y);

int main (){

 int i=0,j=0,k=0,fil=1,col=1;
 char a[7][8];
 system ("pause");
 system ("cls");
 for (i=0;i<15;i++){
   gotoxy (10+2*i,10);
   printf ("*" );
 }
 Sleep (2000);
 for (i=0;i<15;i++){
   Sleep (250);
   gotoxy (10+2*i,10);
   printf ("X" );
 }



 puts("\n\n");
 system ("pause");
 system ("cls");
 for (i=0;i<27;i++)
   printf ( "* ");
 putchar ('\n');
 for (i=0;i<27;i++){
   Sleep(150);
   gotoxy (2*i,0);
   printf ( "X ");
 }
 for (i=0;i<27;i++){
   Sleep(100);
   gotoxy (2*i,4);
   printf ( "X");
 }
 for (i=0;i<6;i++){
   for (j=0;j<6;j++){
     gotoxy (2*j+6,i+6);
     printf ( "* ");
   }
 }
 for (i=0;i<6;i++){
   for (j=0;j<6;j++){
     Sleep(250);
     gotoxy (2*j+6,i+6);
     printf ( "X");
   }
 }
 putchar ('\n');
 system ("pause");
 system ("cls");
 for (i=0;i<7;i++){
   a[i][7]='\0';
   for (j=0;j<7;j++){
     if(j>=i-1 && j<i+1 && j>0 && j<6 && i<6)
       a[i][j]='X';
     else if(i==0 || j==0 || i==6 || j==6 )
       a[i][j]='*';
     else
       a[i][j]='0';
   }
 }
 putchar ('\n');
 for (i=0;i<7;i++){
   a[i][7]='\0';
   for (j=0;j<7;j++){
     if((i==j || j==i-1) && i>0 && j<6 && j>0 && i<6)
       a[i][j]='X';
     else if(i==0 || j==0 || i==6 || j==6 )
       a[i][j]='*';
     else
       a[i][j]='0';
   }
 }
 gotoxy (0,10);
 for (i=0;i<7;i++){
   for (j=0;j<7;j++){
     printf ("%c ",a[i][j]);
   }
   putchar ('\n');
 }
 system ("pause");
 /*for (i=0;i<7;i++){
   a[i][7]='\0';
   for (j=0;j<7;j++){
     if (i==0 || j==0 || i==6 || j==6 )
       a[i][j]='*';
     else if (i>=j)
       a[i][j]='X';
     else
       a[i][j]='0';
   }
 }*/
 for (i=0;i<7;i++)
   printf ("%s\n",a[i]);
 system ("pause");
 gotoxy (0,0);

 for (i=0;i<7;i++){
   for (j=0;j<7;j++){
     printf ("%c ",a[i][j]);
   }
   putchar ('\n');
 }
 fil=1,col=1;
 while  (1){
   Sleep(1000);
   if (fil==FIL-2 && col==COL-3){
     gotoxy (2*col,fil);
     printf("%c ",'F');
     break;
   }
   else if (a[fil+1][col]=='X' && fil<FIL){
     color(215);
     gotoxy (2*col,fil);
     printf("%c ",'F');fil++;
   }
   else if (a[fil][col+1]=='X' && col<COL){
     color(215);
     gotoxy (2*(col),fil);
     printf("%c ",'F');col++;
   }
   else if (a[fil-1][col]=='X' && fil>0){
     color(215);
     gotoxy (2*(col),fil);
     printf("%c ",'F');fil--;
   }
   else if (a[fil][col-1]=='X' && col>0){
     color(215);
     gotoxy (2*col,fil);
     printf(" %c ",'F');col--;
   }
 }
 color(7);
 gotoxy (0,30);
 printf ( "Final!");
 putchar ('\n');
 return 0;
}

void color (int n)
{
       SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}


int gotoxy(int x, int y)
{
  COORD coord;
  HANDLE h_stdout;

  coord.X = x;
  coord.Y = y;

  if ((h_stdout = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
     return 0;

  if (SetConsoleCursorPosition(h_stdout, coord) == 0)
     return 0;

  return 1;
}


Como ves es sencillo pero muy efectivo, Todo es jugar con las coordenadas de goto(x,y). Y al respecto te hago una observación, el ordenador usa como ejes coordenados el horizontal superior como eje OX y el vertical izquierdo como eje OY, de forma que el origen de coordenada está en el vértice superior izquierdo de la pantalla, como ya imagino sabrás. Eso provoca una pequeña distorsión y/o problema a la hora de escribir en pantalla con la mencionada función goto(x,y) y es que las coordenadas x,y se corresponden con los índices i,j o, como en tu caso, x,y. Observa que en la matriz normalmente al poner (i,j) la i es para las filas y la y para las columnas. Ahí es donde tienes que tener cuidado ya que las filas, osea la i, se corresponde en pantalla con la Y del goto(x,y), mientras la j se corresponde con la x.

* En cuanto a la declaración de las tablas mencionarte que tenías un problema al indicar la fila y columna final. por eso tenías que sobredimensionarlas. En los códigos que te paso ya he corregido ese problema.

* Efectivamente tienes un pequeño bug principal. Si te fijas en la imagen y  vídeo siguientes quedan unos "1" sin "pintar":

Eso que a primera vista parece un problema nimio resulta que es un problema realmente vital. Se pone de manifiesto al aplicarle yo el que la pantalla no parpadee con el uso del goyo(x,y). Observa el vídeo:

[youtube=640,360]http://www.youtube.com/watch?v=7e4W1uDc_Gk[/youtube]

Código (cpp) [Seleccionar] Expandir


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

# define udir mapa[y-1][x]
# define ldir mapa[y][x-1]
# define rdir mapa[y][x+1]
# define ddir mapa[y+1][x]
# define po mapa[y][x]
using namespace std;

const int TAMY = 24;
const int TAMX = 28;

int contapasos = 0;
void mostrar(char mapa[TAMY][TAMX]);
void color (int n);
int gotoxy(int x, int y);

void mostrar(char mapa[TAMY][TAMX]){
system ("cls");
   int x,y;
    for( y=0;y<TAMY;y++)
    {
    for( x=0;x<TAMX-1;x++)
    {
    if ((y==TAMY-2 && x==TAMX-3) ||(x==1 && y==1))
               color(195);
           else if (x==0 || y==0 || x==TAMX-2 || y==TAMY-1)
               color(125);
           else if (mapa[y][x]=='0')
               color(175);
           else if (mapa[y][x]=='X'){
             mapa[y][x]='2';
             color(7);
           }
           else if (mapa[y][x]=='1'){
             mapa[y][x]='1';
             color(215);
           }
           else
             color(7);
           printf("%c ",mapa[y][x]);
           fflush(stdout);

    //Sleep(5);
    }
    color(7);
    putchar('\n');
    //Sleep(5);
    }
 x=1,y=1;
 while  (1){
   Sleep(250);
   if (y==TAMY-2 && x==TAMX-3 ){
     gotoxy (2*x,y);
     mapa[y][x]='1';
     printf("%c ",'X');
     break;
   }
   else if (mapa[y+1][x]=='2' && y<TAMY){
     color(215);
     gotoxy (2*x,y);
     mapa[y][x]='1';
     printf("%c ",'X');y++;
   }
   else if (mapa[y][x+1]=='2' && x<TAMX){
     color(215);
     mapa[y][x]='1';
     gotoxy (2*(x),y);
     printf("%c ",'X');x++;
   }
   else if (mapa[y-1][x]=='2' && y>0){
     color(215);
     mapa[y][x]='1';
     gotoxy (2*(x),y);
     printf("%c ",'X');y--;
   }
   else if (mapa[y][x-1]=='2' && x>0){
     color(215);
     mapa[y][x]='1';
     gotoxy (2*x,y);
     printf(" %c ",'X');x--;
   }
 }
   color(55);
   gotoxy (45,33);
   printf ("\n\t¡¡¡FINAL!!!\t\t\n\n");
   color(7);
   system ("pause");
}

 int rand4 (){
int n = (0 + rand() % 4);
return n;
}

void go_up ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
y--;
po = 'X';
}

void go_le ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
x--;
po = 'X';
}

void go_ri ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
x++;
po = 'X';
}

void go_do ( char mapa[TAMY][TAMX], int &x , int &y ){
po = '1';
y++;
po = 'X';
}


int main (){
//variables iniciales
srand(time(NULL));
system ("pause");
int pasos = 0;
bool nodir = true;
bool fin = true;
int x = 1; //posicion x inicial
int y = 1; //posicion y inicial
int rand;
char mapa[TAMY][TAMX]={
  //0123456789012345678901234567
"000000000000000000000000000",//0
"020222222222222222222222220",//1
"020200000000000000000000020",//2
"020222222222222200000000020",//3
"020200000000000000000000020",//4
"020222222222222200022222220",//5
"020000000000000200020000020",//6
"020222222222200200000000020",//7
"020200000000200222222222020",//8
"020222222200200000000002020",//9
"020000000200222222222222020",//10
"022222220200000000000000020",//11
"000000020200222222222222220",//12
"000000022200200000000000000",//13
"000000000000200222222222220",//14
"022222222222200200000000020",//15
"020000000000000222222202020",//16
"020000000000000200000202020",//17
"022222222222222200000202020",//18
"000000000000000000000202220",//19
"022222222222222222222200000",//20
"020000000000000000000000000",//21
"0222222222222222222222222F0",//22
"000000000000000000000000000" //23

};
//obtenr cantidad maxima de pasos pocibles.
for ( int fory = 0; fory <= TAMY; fory++  ){
for ( int forx = 0; forx <= TAMX; forx++  ){
if ( mapa[fory][forx] == '2' )
pasos++;
}
}
int xbackup[pasos];
int ybackup[pasos];


while ( fin ){
while ( udir == '1' || ldir == '1' || rdir == '1' || ddir == '1' ){
if ( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){
break;
}

contapasos--;
mapa[y][x]='0';
x = xbackup[contapasos];
y = ybackup[contapasos];
mapa[y][x]='X';
mostrar( mapa );
//Sleep ( 100 );
}

contapasos++;
xbackup[contapasos]= x;
ybackup[contapasos]= y;

if( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){

do{

rand = rand4();


if ( udir == '2' && ldir != '2' && rdir != '2' && ddir != '2' ){
go_up( mapa, x, y );
break;
}
else if ( udir != '2' && ldir == '2' && rdir != '2' && ddir != '2' ){
go_le( mapa, x, y );
break;
}
else if ( udir != '2' && ldir != '2' && rdir == '2' && ddir != '2' ){
go_ri( mapa, x, y );
break;
}
else if ( udir != '2' && ldir != '2' && rdir != '2' && ddir == '2' ){
go_do( mapa, x, y );
break;
}

else if ( rand == 0 ){
if ( udir == '0' || udir == '1' ){
nodir = true;
break;
}
else {
go_up( mapa, x, y );
nodir = false;
}

}
else if ( rand == 1 ){
if ( ldir == '0' || ldir == '1' ){
nodir = true;
break;
}
else {
go_le( mapa, x, y );
nodir = false;
}

}
else if ( rand == 2 ){
if ( rdir == '0' || rdir == '1' ){
nodir = true;
break;

}
else {
go_ri( mapa, x, y );
nodir = false;
}

}
else if ( rand == 3 ){
if ( ddir == '0' || ddir == '1' ){
nodir = true;
break;
}
else {
go_do( mapa, x, y );
nodir = false;
}

}

}while( nodir );//FIN DOWHILE

}//FIN IF
mostrar( mapa );
Sleep ( 100 );
}//FIN DEL LOOP

}
void color (int n)
{
       SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}

int gotoxy(int x, int y)
{
  COORD coord;
  HANDLE h_stdout;

  coord.X = x;
  coord.Y = y;

  if ((h_stdout = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
     return 0;

  if (SetConsoleCursorPosition(h_stdout, coord) == 0)
     return 0;

  return 1;
}


y mira como se "pega" en la rama horizontal. No puede retroceder como sería lo normal y es por lo que te comenté, ese "1" no lo has cambiado al hacer el recorrido y la casilla que se mueve la detecta como errónea:

¿Y yo?.

La verdad es que poca cosa, aunque interesantes, es que con tanta fiestas y familia alrededor no he tenido tiempo pá ná.

Pero bueno, algo si que he adelantado.

La principal novedad que he introducido es el hecho de no trabajar ya con una matriz predefinida en el código, eso era como demasiado fácil. Ahora la matriz se genera de forma aleatoria.

Para hacer el código más rico, introduzco una variables, de nombres peso, c_peso y peso_i, que permiten jugar a poner más o menos 2=camino o 0=pared. Además aseguro que la matriz generada tenga al menos una solución, cosa que si la genero aleatoriamente de forma total no ocurriría la mayor parte de las veces. Y la salida que busco es "UNA", dejo para un posterior código, como ya comenté más arriba, el desarrollo de un método que me permita elegir el camino con menor coste.

Sí, digo bien, con menor coste ya que pueden haber varias soluciones que del principio al final recorran el mismo número de casillas pero con distinto coste. ¿Que qué es eso del coste?. Ni más ni menos que el número de cambios de dirección en el camino. Imaginaos que vais de una ciudad a otra, el camino óptimo será el que tenga menos "curvas", que en este caso se traduce por el menor número de cambios de dirección. No vale eso de abajo. derecha una y otra vez si puedes ir recto hacia abajo y luego directo a la derecha sin tomar curvas en medio.

Y un vídeo de un minutito que muestra el código en acción y después el código:

[youtube=640,360]http://www.youtube.com/watch?v=VksBgSA54Zg[/youtube]

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#define COL 28
#define FIL 27

void mostrar(char a[][COL],char *msg);
void rellenar_laberinto (char  a[][COL], char b[][COL]);
void color (int n);
int gotoxy(int x, int y);
void mostrar_despacio(char a[][COL],char b[][COL],char *msg);

int main (){
 char a[FIL][COL],b[FIL][COL];
 int i,j,x,y,incre_i,incre_j,cont=0,peso=0,c_peso=0,peso_i,flag=0;
 srand((unsigned) time(NULL));
 while (flag==0){
 for( i=0;i<FIL;i++) {
   for( j=0;j<COL-1;j++) {
     if (i==0 || j==0 || i==FIL || j==COL-2)
       a[i][j]=b[i][j]='*';
     else
       a[i][j]=b[i][j]='0';
   }
 }
 a[1][1]='I';
 a[FIL-2][COL-3]='F';
 i=1,j=1;peso=12 ,c_peso=9,peso_i=3;
 while (1){
   x=rand()%peso;
   if (x<peso_i)
     incre_i=-1;
   else if (x>=peso_i && x<c_peso)
     incre_i=1;
   else if (x>=c_peso && x<peso)
     incre_i=0;
   y=rand()%peso;
     if (y<peso_i)
       incre_j=-1;
     else if (y>=peso_i && y<c_peso)
       incre_j=1;
     else if (y>=c_peso && y<peso)
       incre_j=0;
     if (((incre_i!=incre_j) && (incre_i!=-incre_j))  &&(a[i+incre_i][j+incre_j]=='0'  )
       && (i>0 && i<FIL+1 && j>0  && j<COL-2)){
       if ((i+incre_i>0) && (j+incre_j>0) && (i+incre_i<FIL) && (j+incre_j<COL-1)){
         i+=incre_i;
         j+=incre_j;
       if ((i==FIL-1 && j==COL-2)||(i==FIL-3 && j==COL-3)){
           a[i][j]='X';
           flag++;
           break;
         }
       else if ((i==2 && j==1) || (i==1 && j==2))
         a[i][j]='X';
       else if ((a[i][j]=='0' &&
         (a[i+1][j]=='0' && a[i-1][j]=='0' && a[i][j+1]=='0' ) ||
         (a[i+1][j]=='0' && a[i-1][j]=='0' && a[i][j-1]=='0' ) ||
         (a[i][j+1]=='0' && a[i][j-1]=='0' && a[i+1][j]=='0' ) ||
         (a[i][j+1]=='0' && a[i][j-1]=='0' && a[i-1][j]=='0' ))){
           a[i][j]='X';
           cont=0;
         }
       else {
         i-=incre_i;
         j-=incre_j;
         cont++;
         if (cont == 10)
         break;
         }
       }
     }
   }
 }
 rellenar_laberinto (a, b);
 //mostrar(b,"LABERINTO COLOR: ***ESTO ES OTRA COSA***");
 for( i=0;i<FIL;i++)
   for( j=0;j<COL-1;j++)
     if (a[i][j]=='X')
       b[i][j]='X';
 //mostrar(b,"\tUNA SOLUCION");
 system ("pause");
 mostrar_despacio(a,b,"DESPACITO");
 return 0;
}

void rellenar_laberinto (char  a[][COL], char b[][COL]){
 int i,j,x,peso=6 ,c_peso=3;
 for( i=0;i<FIL;i++) {
   for( j=0;j<COL-1;j++) {
     if (i==0 || j==0 || i==FIL-1 || j==COL-2)
       b[i][j]='*';
     else if (a[i][j]=='X')
       b[i][j]='2';
     else {
       x=rand()%peso;
       if (x<peso-c_peso && x>=0)
         b[i][j]='0';
       else if (x>=peso-c_peso && x<peso)
       b[i][j]='2';
       b[1][1]='I';
       b[FIL-2][COL-3]='F';
     }
   }
 }
 b[1][1]='I';
 b[FIL-2][COL-3]='F';
}

void mostrar(char mat[][COL],char *msg){
 int i,j;
 system ("cls");
 system ("pause");
 for( i=0;i<FIL;i++) {
   for( j=0;j<COL-1;j++) {
     if ((i==FIL-2 && j==COL-3) ||(i==1 && j==1))
       color(195);
     else if (i==0 || j==0 || i==FIL-1 || j==COL-2)
       color(125);
     else if (mat[i][j]=='0')
       color(175);
     else if (mat[i][j]=='X')
       color(215);
     else
       color(7);
     printf("%c ",mat[i][j]);
     fflush(stdout);
   }
   putchar('\n');
 }
 color(55);
 printf ("\n\n\nt%s\t\t\n\n",msg);
 color(7);
 system ("pause");
}

void mostrar_despacio(char a[][COL],char b[][COL],char *msg){
 int i,j,fil,col;
 a[1][1]='X',a[FIL-2][COL-3]='X';
 system ("cls");
 for( i=0;i<FIL;i++)
   for( j=0;j<COL-1;j++)
     if (a[i][j]=='X')
       b[i][j]='2';
     else continue;
 //mostrar(b,"\tcon doses");
 system ("cls");
 for( i=0;i<FIL;i++) {
   for( j=0;j<COL-1;j++) {
     if ((i==FIL-2 && j==COL-3) ||(i==1 && j==1))
         color(195);
     else if (i==0 || j==0 || i==FIL-1 || j==COL-2)
       color(125);
     else if (b[i][j]=='0')
       color(175);
     else if (a[i][j]=='X'){
       b[i][j]='2';
       color(7);
     }
     else
       color(7);
       printf("%c ",b[i][j]);
       fflush(stdout);
     }
     putchar('\n');
   }

 fil=1,col=1;
 while  (1){
   Sleep(1000);
   if (fil==FIL-2 && col==COL-3 ){
     gotoxy (2*col,fil);
     a[fil][col]='0';
     printf("%c ",'X');
     break;
   }
   else if (a[fil+1][col]=='X' && fil<FIL){
     color(215);
     gotoxy (2*col,fil);
     a[fil][col]='0';
     printf("%c ",'X');fil++;
   }
   else if (a[fil][col+1]=='X' && col<COL){
     color(215);
     a[fil][col]='0';
     gotoxy (2*(col),fil);
     printf("%c ",'X');col++;
   }
   else if (a[fil-1][col]=='X' && fil>0){
     color(215);
     a[fil][col]='0';
     gotoxy (2*(col),fil);
     printf("%c ",'X');fil--;
   }
   else if (a[fil][col-1]=='X' && col>0){
     color(215);
     a[fil][col]='0';
     gotoxy (2*col,fil);
     printf(" %c ",'X');col--;
   }
 }
 color(55);
 gotoxy (45,28);
 printf ("\n\t%s\t\t\n\n",msg);
 color(7);
 system ("pause");
}


void color (int n){
 SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}

int gotoxy(int x, int y){
 COORD coord;
 HANDLE h_stdout;
 coord.X = x;
 coord.Y = y;
 if ((h_stdout = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
   return 0;
 if (SetConsoleCursorPosition(h_stdout, coord) == 0)
   return 0;
 return 1;
}


Espero les haya gustado las observaciones y aportaciones.

Todo ha sido con ánimo constructivo, insisto. Nada de críticas, sólo observaciones.

Y espero que no decaiga el ánimo en el tema y sigamos juntos aprendiendo cositas.

¡¡¡¡ Saluditos! ..... !!!!

[vangodp]

joe leo! Que laburo te has pillao jeje.
Voy a por las gafas para echar un ojo ^^