Salut tout le monde

J'ai pour projet de réaliser en c, le déplacement d'un bot sur une surface inconnue.

La surface est un lieu contenant plusieurs pièces comme un plan de maison. Le bot connait sa position, mais le plan ne lui est pas connu à l'avance. Le but est de trouver la sortie unique et il ne la détecte que quand il la touche.

Le bot doit avoir un comportement simple : capteur à l'avant uniquement donc détection d'obstacle que lors de la rencontre avec celui ci lors d'un déplacement.

J'ai essayé de m'aider de personnes ayant eu un peu le même problème avec des labyrinthes sur les forums mais j'ai du mal à amorcer.

J'ai réussi à récupérer  la map qui se situe dans un fichier .h. Je l'ai initialisé en transformant le fichier initial contenant ligne à ligne le plan (entre guillemets) en tableau à deux dimensions.

Ensuite j'ai aussi fait la fonction pour que l'affichage se fait correctement dans le terminal du plan.

Dorénavant, j'essaye de faire bouger le robot, mais j'ai du mal à amorcer, si quelqu'un pouvait aider à me lancer.

Je procède également par compilation séparée dont voila les différents fichiers :

Fichier main.c

#include "appart.h"
#include "carte.h"
#define TAILLE_CARTE 50
 
int main()
{
char map [TAILLE_CARTE][TAILLE_CARTE];
init_carte (appart, map);
affiche_carte(map);
}

Fichier bot.c

#include "robot.h"
 
void move_robot (Robot *robot, char map [][TAILLE_CARTE])
    {
    map[robot->y][robot->x]=' ';
    
    if (map[robot->y][robot->x+1]!='x')
        {
        robot->x++;
        }
    
    else if (map[robot->y+1][robot->x]!='x')
        {
        robot->y++;
        }
 
    else if (map[robot->y-1][robot->x]!='x')
        {
        robot->y--;
        }
    
    else (map[robot->y][robot->x-1]!='x')
        {
        robot->x--;
        }
 
    map[robot->y][robot->x]='R';
    }

Fichier bot.h

#ifndef ROBOT_H
#define ROBOT_H
 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
# define MOVELEFT    0
# define MOVERIGHT    1
# define MOVEFORWARD 2
# define MOVEBACK    3
# define NBCOMMAND    4
 
#define TAILLE_CARTE 50
 
typedef struct 
    {
    int x,y;
    char direction; /*Nord,Est,Sud,West*/
    } Robot;
 
void move_robot (Robot *robot, char map [][TAILLE_CARTE]);
 
/*case MOVELEFT:
        funcMoveLeft();
        break;
case MOVERIGHT:
        funcMoveRight();
        break;
case MOVEFORWARD:
        funcMoveForward();
        break;
case MOVEBACK:
        funcMoveBack();
        break;*/
 
#endif

Fichier map.h

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define TAILLE_CARTE 50
    
void affiche_carte (char map [TAILLE_CARTE][TAILLE_CARTE]);
void init_carte (char appart[], char map[][TAILLE_CARTE]);

Fichier map.c

#include "carte.h"
 
void affiche_carte (char map [][TAILLE_CARTE])
    {
    int i=0, j=0;
    
    for(i=0;i<TAILLE_CARTE;i++)
        {
        for(j=0;j<TAILLE_CARTE;j++)
            {
                printf("%c", map [i][j]);
            }
        printf("\n" );
        }
    }
    
void init_carte (char appart[], char map[][TAILLE_CARTE])
    {
    int i=0, j=0;
        /*for (i=0; i<TAILLE_CARTE; i++)
            {
            for (j=0; j<TAILLE_CARTE; j++)
                {
                map[i][j]=appart[i][j];
                }
            }*/
    memcpy (map, appart,TAILLE_CARTE*TAILLE_CARTE);
    }

Salut,
 
Pour un algorithme puissant, je te conseille de vérifier toutes les cases autour de toi avant de te déplacer, puis de compter pour chaque case (sans obstacle, je parle) la distance de l'arrivée.
Si il y a des obstacles, c'est tout différent, et c'est carrément plus chiant, car pour une optimisation++, il faut le faire en récursif.
Là, tu peux te débrouiller en itératif.
 
Par exemple, tu fais des pointeurs sur fonction:
look_west; look_north; look_east; look_south qui prennent toutes en paramètre :
- ta carte
- la position x du robot
- la position y du robot
- évidemment, la position d'arrivée
- un int* qui représentera la case où la distance est la plus courte, sur laquelle il faudra que tu te déplaces (tu leur enverras l'adresse).
(l'int devra être initialisé à 999 par exemple)
 
Pour chaque fonction look_*, tu vas compter le nombre de cases de l'arrivée, puis tu le met dans cet int, que si cette valeur est inférieure à l'ancienne.
Il te faudrait une structure, dans laquelle tu mettrais cet int, avec en plus, un autre int, qui indiquerait, pour l'int donné, dans quelle direction aller (0, 1, 2, 3, respectivement west, north, east, south).
 
Je pense que tu as totu l'algo ici, mais rappelle toi que c'est valable que pour els maps sans obstacles!

Merci

"puissant" je ne suis que débutant en première année donc si je peux éviter de faire compliqué.

"maps sans obstacles", c'est une map avec des pièces donc des murs internes, et il peut y avoir des ilots également.

Et je n'ai vu que le c pour l'instant, donc pas de C++

Je vais essayer de suivre tes consignes mais ce n'est pas gagné.