Mensajes

Bueno lo de depurar el código na que decir, por que la razón tiene quien la tiene jaja.
Estoy seguro que el código se puede mejorar, incluyendo el tuyo como bien lo comentas y creo que en su día también lo hice ¡Creo! XD
Al final dejas señalado lo que podías haber mejorado pero no lo has echo por que no te salio lo mismo me pasa jaja. XD
Lo del aleatorio no abro mano XDD. Si no, no seria una búsqueda es mas como una trampa saber el camino ¿no?
Se supone que no sabes el camino, y si llegas a un punto con 3 o mas elecciones¿Que harás, vas hacia el final?  
Estoy de acuerdo contigo sobre que cuando entra en un punto sin salida el se queda perdido por lo que comentas.Pero eso tiene solucion ¡Creame!XD
Lo del final si podías ver que no lo hice pero te lo pongo aquí ya que no dejas pasar una XD:

Código (cpp) [Seleccionar] Expandir

if( mapa[y][x] == 'F' ){
cout << "TACHANNNN!!!!XDLOLOL";
break;
}

Sobre lo del camino sin salida bien puede ser que si al llegar al final y no encuentra nada, lo rellene con ceros envés de unos, marcando así que ese camino no pueda volver a entrar. XDD

Son fallos tontos los que me estas señalando se lo dije que deje muchas cosas por hacer jeje
La cosa es que por no seguir deje mucho que hacer pero bueno
No voy a comentar tu código (¡aun!)por que no lo vi, pero lo mirare con lupa jeje.
Sobre el Dev estoy seguro que hay un millón de compiladores mejor, esta el vim vs emacs de toda la vida y un millón de ellos mas y no creas que no los probé todos jaja.
Pero seguiré con el Dev por que me parece muy muy sencillo y me va bien no me gusta que me de chuletas los programas XD.
Me costo como que 2 días hacer este código, no digo escribiéndole ya que eso me tardo unas 3 o 4 horas XD.
Voy a subir una nueva versión con esos problemas arreglados,  por supuesto tendré tu código en cuenta...si puedo aprender algo seguro lo haré ademas pinta muy bien.
Seguro que podemos afinar ese laberinto y hacerle que encuentre la salida muy rápidamente
¡Gracias por comentar, eres grande!

Yo empece directo por c++ y no me ha ido mal.
No creo que tengas problema por empezar por c++.
Si pretendes trabajar con programas orientado a objetos creo que deberías iniciar por ahí.
Lo que pasa es que la programación estructurada es mas comprensible.
La pagina antes citada "minidosis" es muy buena.
Creo que si puedes echar un ojo en ambas formas c/c++ no seria mala idea.
No te aferres en uno solo lenguaje.
Escoja uno pero puedes echar el ojo al otro.
El c es bastante bueno también.
Si de verdad quieres aprender creo que ambos vas a tener que dominar

usa el comando system("") de windows.h.
Dentro de las "" puedes poner comandos de la consola como copy o yo que se.
Pero solo sirve en gwuinX ya que usa comandos de DOS
copy, xcopy ...

geany te da las "chuletillas"que tanto os gusta XD
Pero si no me equivoco el codeblocks también los da.
si presionas unas cuantas teclas que no se cuales son te salen las chuletas 

Hola ivan, hola a todos.
Tengo una duda.
¿Que hace esta linea?
void (*f[])() = {go_arriba, go_izquierda, go_derecha, go_abajo};
Algunas cosas me son algo confusas por la inesperiencia que tengo?
Si no puedes explicarme al menos dime de que se trata y ya lo investigo por mi cuenta
Suerte!

Lo voy echar un ojo
Gracias, a ver si lo achicamos

Puedes ser amable de decir como valido cada caso con 4 for?
Soy todo oídos
El algoritmo es la casualidad.
la posición actual de la x mira arriba, abajo, izquierda y derecha buscando el mejor camino.
Primero busca el numero 2 que se supone ser no explorado, el 1 es que ya ha estado ahí y 0 no lo puede atravesar(pared).
Si no hay remedio pasa por el uno otra vez pero prefiere el 2.
Hasta llegar al final que aun no esta echo.
Pretendo mejorarlo pero un novato lo tiene muy limitado como yo.
Lo voy mejorando como para leer el mapa desde un archivo.
No perder mucho tiempo en salir de un camino ya explorado.
A ver si lo paso a SDL que me mola.
Si encuentra 2 o mas caminos iguales elige al azar, por eso cuando entra en una calle sin salida se vuelve algo lento, tengo que hacer que al llegar al final recuerde el camino o lo que sea.

Buenas que tal!
Eh mejorado un poco el código
Lo eh echo auto suficiente jaja
Este se busca la salida solo XD
Puedes cambiar el mapa a gusto.
Es algo ineficiente aun, lo estoy puliendo cosillas como cuando encuentra una calle sin salida, le tarda algo en volver al camino, pero lo encuentra.
Aquí le dejo el rollo, jaja me eh reído un montón con el código jaja

Código (cpp) [Seleccionar] Expandir


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

int rand2 (){
srand(time(NULL));
int n = (0 + rand() % 2);
return n;
}
int rand3 (){
srand(time(NULL));
int n = (0 + rand() % 3);
return n;
}
int rand4 (){
srand(time(NULL));
int n = (0 + rand() % 4);
return n;
}

void mostrar(char mapa[29][29]){
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);
    }
   
}

// GO ONE
void go_arriba( char mapa[29][29], int &x, int &y ){
mapa [y][x]='1';
y--;
mapa [y][x]='X';
}
void go_izquierda( char mapa[29][29], int &x, int &y ){
mapa [y][x]='1';
x--;
mapa [y][x]='X';
}
void go_derecha( char mapa[29][29], int &x, int &y ){
mapa [y][x]='1';
x++;
mapa [y][x]='X';
}  
void go_abajo( char mapa[29][29], int &x, int &y ){
mapa [y][x]='1';
y++;
mapa [y][x]='X';
}
// DECIDE 2
void decide_arriba_izquierda ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_izquierda( mapa, x, y );
break;
default:
cout << "error:decide_arriba_izquierda"<<endl;
cin.ignore();
break;
}

}
void decide_arriba_derecha ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_arriba ( mapa, x, y );
break;
case 1:
go_derecha ( mapa, x, y );
break;
default:
cout << "error:decide_arriba_derecha"<<endl;
cin.ignore();
break;
}
}
void decide_arriba_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_abajo( mapa, x, y );
break;
default:
cout << "decide_arriba_abajo"<<endl;
cin.ignore();
break;
}
}
void decide_izquierda_derecha ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_izquierda( mapa, x, y );
break;
case 1:
go_derecha( mapa, x, y );
break;
default:
cout << "error:decide_izquierda_derecha"<<endl;
cin.ignore();
break;
}
}
void decide_izquierda_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_izquierda( mapa, x, y );
break;
case 1:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_izquierda_abajo"<<endl;
cin.ignore();
break;
}
}
void decide_derecha_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand2() ){
case 0:
go_derecha( mapa, x, y );
break;
case 1:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_derecha_abajo"<<endl;
cin.ignore();
break;
}
}
// DECIDE 3
void decide_arriba_izquierda_derecha ( char mapa[29][29], int &x, int &y ){
switch ( rand3() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_izquierda( mapa, x, y );
break;
case 2:
go_derecha( mapa, x, y );
break;
default:
cout << "error:decide_arriba_izquierda_derecha"<<endl;
cin.ignore();
break;
}
}
void decide_arriba_izquierda_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand3() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_izquierda( mapa, x, y );
break;
case 2:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_arriba_izquierda_abajo"<<endl;
cin.ignore();
break;
}  
}
void decide_arriba_derecha_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand3() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_derecha( mapa, x, y );
break;
case 2:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_arriba_derecha_abajo"<<endl;
cin.ignore();
break;
}  
}
void decide_izquierda_derecha_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand3() ){
case 0:
go_izquierda( mapa, x, y );
break;
case 1:
go_derecha( mapa, x, y );
break;
case 2:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_izquierda_derecha_abajo"<<endl;
cin.ignore();
break;
}  
}
// DECIDE 4
void decide_arriba_izquierda_derecha_abajo ( char mapa[29][29], int &x, int &y ){
switch ( rand4() ){
case 0:
go_arriba( mapa, x, y );
break;
case 1:
go_izquierda( mapa, x, y );
break;
case 2:
go_derecha( mapa, x, y );
break;
case 3:
go_abajo( mapa, x, y );
break;
default:
cout << "error:decide_arriba_izquierda_derecha_abajo"<<endl;
cin.ignore();
break;
}  
}
// ESPECIAL CASES

//MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAINMAIN_MAIN_MAIN
int main (){



//MAPA DE TIPO CHAR, MAS ADELANTE HACEMOS UN CAST PARA INT
char mapa[29][29]={

"000000000000000000000000000",
"0X0222222222222222222222220",
"020200000000000000000000020",
"020222222222222200000000020",
"020200000000000000000000020",
"020222222222222200022222220",
"020000000000000200020000020",
"020222222222200200000000020",
"020200000000200222222222020",
"020222222200200000000002020",
"020000000200222222222222020",
"022222220200000000000000020",
"000000020200222222222222220",
"000000022200200000000000000",
"000000000000200222222222220",
"022222222222200200000000020",
"020000000000000222222202020",
"020000000000000200000202020",
"022222222222222200000202020",
"000000000000000000000202220",
"022222222222222222222200000",
"020000000000000000000000000",
"02222222222222222222222FIN0",
"000000000000000000000000000"

};

//VARIABLES LOCALES
int n;
cout << "velocidad de busqueda?" << endl;
cin >> n;

//POSICION INICIAL (CORRDENADAS)
int x = 1;
int y = 1;

//CONVERTIMOS EN INT LOS POCIBLES CAMINOS A TOMAR
int arriba = (int (mapa [ y - 1] [ x ])-48);
int izquierda = (int (mapa [ y ] [ x -1 ])-48);
int derecha = (int (mapa [ y ] [ x + 1 ])-48);
int abajo = (int (mapa [ y + 1] [ x ])-48);

//CONDICION DEL BUCLE PRINCIPAL: SI NO SE ENCUENTRA EL FIN DEL MAPA SIEMPRE SERA FALSO.
bool fin = false;

//BUCLE PRINCIPAL: COMPRUEBA QUE NO ENCONTREMOS LA SALIDA.
while ( !fin ){

//Valores de los pocibles caminos
arriba = (int (mapa [ y - 1] [ x ]-48));
izquierda = (int (mapa [ y ] [ x -1 ]-48));
derecha = (int (mapa [ y ] [ x + 1 ]-48));
abajo = (int (mapa [ y + 1] [ x ]-48));

//CASOS
if ( arriba == 0 && izquierda == 0 && derecha == 0 && abajo == 0 ){//(0,0,0,0)*
//NO SE elige NADA
}
if ( arriba == 0 && izquierda == 0 && derecha == 0 && abajo == 1 ){//(0,0,0,1)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 0 && abajo == 2 ){//(0,0,0,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 1 && abajo == 0 ) {//(0,0,1,0)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 1 && abajo == 1 ){//(0,0,1,1)*
//derecha || abajo
decide_derecha_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 0 && derecha == 1 && abajo == 2 ){//(0,0,1,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 2 && abajo == 0 ){//(0,0,2,0)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 2 && abajo == 1 ){//(0,0,2,1)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 0 && izquierda == 0 && derecha == 2 && abajo == 2 ){//(0,0,2,2)*
//derecha || abajo
decide_derecha_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 1 && derecha == 0 && abajo == 0 ){//(0,1,0,0)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 0 && izquierda == 1 && derecha == 0 && abajo == 1 ){//(0,1,0,1)*
//izquierda || abajo
decide_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 1 && derecha == 0 && abajo == 2 ){//(0,1,0,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 0 && izquierda == 1 && derecha == 1 && abajo == 0 ){//(0,1,1,0)*
//izquierda || derecha
decide_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 1 && derecha == 1 && abajo == 1 ){//(0,1,1,1)*
//izquierda || derecha || abajo
decide_izquierda_derecha_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 1 && derecha == 1 && abajo == 2 ){//(0,1,1,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 0 && izquierda == 1 && derecha == 2 && abajo == 0 ){//(0,1,2,0)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 0 && izquierda == 1 && derecha == 2 && abajo == 1 ){//(0,1,2,1)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 0 && izquierda == 1 && derecha == 2 && abajo == 2 ){//(0,1,2,2)*
//derecha || abajo
decide_derecha_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(0,2,0,0)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 0 && izquierda == 2 && derecha == 0 && abajo == 1 ){//(0,2,0,1)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 0 && izquierda == 2 && derecha == 0 && abajo == 2 ){//(0,2,0,2)*
//izquierda || abajo
decide_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 2 && derecha == 1 && abajo == 0 ){//(0,2,1,0)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 0 && izquierda == 2 && derecha == 1 && abajo == 1 ){//(0,2,1,1)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 0 && izquierda == 2 && derecha == 1 && abajo == 2 ){//(0,2,1,2)*
//izquierda || abajo
decide_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 2 && derecha == 2 && abajo == 0 ){//(0,2,2,0)*
//izquierda || derecha
decide_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 2 && derecha == 2 && abajo == 1 ){//(0,2,2,1)*
//izquierda || derecha
decide_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 0 && izquierda == 2 && derecha == 2 && abajo == 2 ){//(0,2,2,2)*
//izquierda || derecha || abajo
decide_izquierda_derecha_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 0 && derecha == 0 && abajo == 0 ){//(1,0,0,0)*
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 1 && izquierda == 0 && derecha == 0 && abajo == 1 ){//(1,0,0,1)*ESPECIAL
//arriba || abajo
decide_arriba_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 0 && derecha == 0 && abajo == 2 ){//(1,0,0,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 1 && izquierda == 0 && derecha == 1 && abajo == 0 ){//(1,0,1,0)*
//arriba || derecha
decide_arriba_derecha ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 0 && derecha == 1 && abajo == 1 ){//(1,0,1,1)*
//arriba || derecha || abajo
decide_arriba_derecha_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 0 && derecha == 1 && abajo == 2 ){//(1,0,1,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 1 && izquierda == 0 && derecha == 2 && abajo == 0 ){//(1,0,2,0)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 1 && izquierda == 0 && derecha == 2 && abajo == 1 ){//(1,0,2,1)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 1 && izquierda == 0 && derecha == 2 && abajo == 2 ){//(1,0,2,2)*
//derecha || abajo
decide_derecha_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 1 && derecha == 0 && abajo == 0 ){//(1,1,0,0)*
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 1 && derecha == 0 && abajo == 1 ){//(1,1,0,1)*
//arriba || izquierda || abajo
decide_arriba_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 1 && derecha == 0 && abajo == 2 ){//(1,1,0,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 1 && izquierda == 1 && derecha == 1 && abajo == 0 ){//(1,1,1,0)*
//arriba || izquierda || derecha
}
if ( arriba == 1 && izquierda == 1 && derecha == 1 && abajo == 1 ){//(1,1,1,1)
//arriba || izquierda || derecha || abajo
decide_arriba_izquierda_derecha_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 1 && derecha == 1 && abajo == 2 ){//(1,1,1,2)*
//abajo
go_abajo(mapa, x, y);
}
if ( arriba == 1 && izquierda == 1 && derecha == 2 && abajo == 0 ){//(1,1,2,0)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 1 && izquierda == 1 && derecha == 2 && abajo == 1 ){//(1,1,2,1)*
//derecha
go_derecha(mapa, x, y);
}
if ( arriba == 1 && izquierda == 1 && derecha == 2 && abajo == 2 ){//(1,1,2,2)*
//derecha || abajo
decide_derecha_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(1,2,0,0)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 1 && izquierda == 2 && derecha == 0 && abajo == 1 ){//(1,2,0,1)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 1 && izquierda == 2 && derecha == 0 && abajo == 2 ){//(1,2,0,2)*
//izquierda || abajo
decide_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 2 && derecha == 1 && abajo == 0 ){//(1,2,1,0)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 1 && izquierda == 2 && derecha == 1 && abajo == 1 ){//(1,2,1,1)*
//izquierda
go_izquierda(mapa, x, y);
}
if ( arriba == 1 && izquierda == 2 && derecha == 1 && abajo == 2 ){//(1,2,1,2)*
//izquierda || abajo
decide_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 2 && derecha == 2 && abajo == 0 ){//(1,2,2,0)*
//izquierda || derecha
decide_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 2 && derecha == 2 && abajo == 1 ){//(1,2,2,1)*
//izquierda || derecha
decide_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 1 && izquierda == 2 && derecha == 2 && abajo == 2 ){//(1,2,2,2)
//izquierda || derecha || abajo
decide_izquierda_derecha_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 0 && derecha == 0 && abajo == 0 ){//(2,0,0,0)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 0 && derecha == 0 && abajo == 1 ){//(2,0,0,1)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 0 && derecha == 0 && abajo == 2 ){//(2,0,0,2)
//arriba || abajo
decide_arriba_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 0 && derecha == 1 && abajo == 0 ){//(2,0,1,0)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 0 && derecha == 1 && abajo == 1 ){//(2,0,1,1)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 0 && derecha == 1 && abajo == 2 ){//(2,0,1,2)
//arriba || abajo
decide_arriba_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 0 && derecha == 2 && abajo == 0 ){//(2,0,2,0)
//arriba || derecha
decide_arriba_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 0 && derecha == 2 && abajo == 1 ){//(2,0,2,1)
//arriba || derecha
decide_arriba_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 0 && derecha == 2 && abajo == 2 ){//(2,0,2,2)
//arriba || derecha || abajo
decide_arriba_derecha_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 1 && derecha == 0 && abajo == 0 ){//(2,1,0,0)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 1 && derecha == 0 && abajo == 1 ){//(2,1,0,1)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 1 && derecha == 0 && abajo == 2 ){//(2,1,0,2)
//arriba || abajo
decide_arriba_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 1 && derecha == 1 && abajo == 0 ){//(2,1,1,0)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 1 && derecha == 1 && abajo == 1 ){//(2,1,1,1)
//arriba
go_arriba(mapa, x, y);
}
if ( arriba == 2 && izquierda == 1 && derecha == 1 && abajo == 2 ){//(2,1,1,2)
//arriba || abajo
decide_arriba_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 1 && derecha == 2 && abajo == 0 ){//(2,1,2,0)
//arriba || derecha
decide_arriba_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 1 && derecha == 2 && abajo == 1 ){//(2,1,2,1)
//arriba || derecha
decide_arriba_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 1 && derecha == 2 && abajo == 2 ){//(2,1,2,2)
//arriba || derecha || abajo
decide_arriba_derecha_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(2,2,0,0)
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 1 ){//(2,2,0,1)
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(2,2,0,0)
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 2 ){//(2,2,0,2)
//arriba || izquierda || abajo
decide_arriba_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 1 && abajo == 0 ){//(2,2,1,0)
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 1 && abajo == 1 ){//(2,2,1,1)
//arriba || izquierda
decide_arriba_izquierda ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 1 && abajo == 2 ){//(2,2,1,2)
//arriba || izquierda || abajo
decide_arriba_izquierda_abajo ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 2 && abajo == 0 ){//(2,2,2,0)
//arriba || izquierda || derecha
decide_arriba_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 2 && abajo == 1 ){//(2,2,2,1)
//arriba || izquierda || derecha
decide_arriba_izquierda_derecha ( mapa, x, y );
}
if ( arriba == 2 && izquierda == 2 && derecha == 2 && abajo == 2 ){//(2,2,2,2)
//arriba || izquierda || derecha || abajo
decide_arriba_izquierda_derecha_abajo ( mapa, x, y );
}




// ON SCREEN PRINT
mostrar (mapa);
Sleep(n);
//system("pause");
}


return 0;
}


Esta echo en dev cpp orwell
Pronto subo la 2.0 o mejor lo mejoren vosotros si quieren  

Se debe de poner 0 en los bordes o puede ser bug
La X va buscando el 2, si no hay remedio busca 1 y el 0 es como pared.
Debe tener 0 en todo el lado externo.
Tomar el 0 como pared y rodear todo el mapa.

No tengo ni idea sobre API pero a lo mejor te interesa esto
http://www.genbetadev.com/cc/un-ano-mas-tarde-qt-5-2-cumple-con-soporte-completo-para-android-y-ios

Hace 3 años que no veo la tele