Sujet Précédent Sujet Suivant

Fonction qui permet de faire un choix sur 10 labyrinthes

Fermé
DEANETEHEI - 20 févr. 2015 à 22:28
[Dal] Messages postés 6194 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 11 octobre 2024 - 4 mars 2015 à 21:11
Bonjour,


je debutes en 1° annee en initiation a la prog, je dois concevoir un programme qui permet a l'utilisateur de choisir 1 labyrinthe sur 10 quelqu'un pourrait me donner un coup de pouce?
A voir également:

3 réponses

Réponse 1 / 3
Lerendra Messages postés 412 Date d'inscription jeudi 26 septembre 2013 Statut Membre Dernière intervention 28 mai 2018 299
20 févr. 2015 à 23:32
Bonjour !

Montre nous le début de ton code pour que l'on puisse t'aider ! :)


0
Réponse 2 / 3
DEANETEHEI Messages postés 7 Date d'inscription vendredi 20 février 2015 Statut Membre Dernière intervention 3 mars 2015
Modifié par DEANETEHEI le 21/02/2015 à 12:30
Salut,

Voici mon code, le but de la manoeuvre est de pouvoir proposer à l'utilisateur different choix de Labyrinthe, la j'en ai mis K'1, j'ai du implementé une fonction A_Lab pour faire appel, mais j'aimerai qu'il puisse faire appel au 10 autre en même temps est-ce la bonne methode?
Dois-je certainement faire appel au structure de contrôle do while ou de (pointeur mais je n'ai pas encore vue).A bon entendeur pour me donner 1 coup de pouce, merci!!!

#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>
#include "affichage.h"

#define LargeurLab 21
#define HauteurLab 20

void A_lab(int LabI[HauteurLab][LargeurLab])
{
int x,y;
int Labyrinthe1 [HauteurLab][LargeurLab]=
{{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}};


for(x=0;x<HauteurLab;x++)
{
for(y=0;y<LargeurLab;y++)
{
if(Labyrinthe1[x][y]==0)
printf(" ");

if(Labyrinthe1[x][y]==1)
wprintf(L"\xDB");

PositionneCurseur(x,y);
Couleur(4,0);
}
printf("\n");
//placement du bonhomme
PositionneCurseur(1,1);
x=5;y=7;
PositionneCurseur(x,y);
printf("A");

}
//deplacement dans labyrinthe
while(1)
{
if(kbhit())
{
touche=getch();
if(touche == 72)
{
PositionneCurseur(x,y);
printf(" ");
y--;
}
if(touche == 80)
{
PositionneCurseur(x,y);
printf(" ");
y++;
}
if(touche == 75)
{
PositionneCurseur(x,y);
printf(" ");
x--;
}
if(touche == 77)
{
PositionneCurseur(x,y);
printf(" ");
x++;
}
if(touche == 13) break;

}
}
}
}
void main()
{
int LabI[HauteurLab][LargeurLab];
A_lab(LabI);
}
0
[Dal] Messages postés 6194 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 11 octobre 2024 1 092
Modifié par [Dal] le 23/02/2015 à 12:27
Salut DEANETEHEI,

Tu peux éventuellement faire un truc comme : 

#include <stdio.h>                                                                                                                                                                                                 

#define LABS 10
#define LABLI 20
#define LABCO 21

int lab[LABS][LABLI][LABCO] = 
{
    [0] /* Labyrinthe 1 */
    {
        {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
    },
    [1] /* Labyrinthe 2 */
    {
        {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
    },
    etc.
    [9] /* Labyrinthe 10 */
    {
        {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
        {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
    }
};

int main(void)
{
    int le_lab;

    le_lab = choix_labyrinthe();
    afficher_labyrinthe(le_lab);
    jouer(le_lab);

    return 0;
}


Dans 
afficher_labyrinthe()
et dans 
jouer()
(à implémenter, ainsi que 
choix_labyrinthe()
), tu utilises 
lab[le_lab][li][co]
pour afficher et gérer les déplacements du labyrinthe concerné. Cela évite de répéter le code.

Dal
0
DEANETEHEI Messages postés 7 Date d'inscription vendredi 20 février 2015 Statut Membre Dernière intervention 3 mars 2015 > [Dal] Messages postés 6194 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 11 octobre 2024
23 févr. 2015 à 15:54
Salut Dal,
Merci pour ton aide!
Sa te dérangerais de m'aider pour ce projet de labyrinthe? Comme là, tu vois je ne suis même pas un as, je débute juste! Serait-il possible te présenter le projet si ce n'est pas trop te demander?
0
[Dal] Messages postés 6194 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 11 octobre 2024 1 092
23 févr. 2015 à 16:14
De rien DEANETEHEI.

Si tu as une question sur la compréhension de mon post ci-dessus, tu peux bien sûr la poser, et je suis persuadé que moi, ou un autre contributeur au forum, t'aideront ou te guideront dans la mesure de leur temps et de leurs capacités.

je pense que mon post répond à ta question sur la sélection (et principe de traitement) de plusieurs labyrinthes dans ton code avec des notions que tu devrais maîtriser.

Si tu as un autre problème identifié sur une partie de ton projet concernant autre chose, poste ta (nouvelle) question sur le forum (dans un nouveau sujet).

Autrement, je ne fais pas de coaching privé, il me faudrait plusieurs vies pour cela :-)

Dal
0
Réponse 3 / 3
sambia39 Messages postés 610 Date d'inscription vendredi 31 juillet 2009 Statut Membre Dernière intervention 9 février 2023 49
23 févr. 2015 à 14:28
Bonjour @Dal
Je pense que le choix des labyrinthes est plus une question de modularité que d'implémentation je m'explique.
Le programme a pour but de proposer un ou des labyrinthes au joueur de ce fait, si on écrit tout dans le programme, nous aurons plus de possibilités d'ajouter de nouvelle carte mais aussi, toutes solutions (des cartes) seront connues et le jeu à long terme servira pas à grand-chose à part si quelque chose est prévu pour ( génération de cartes aléatoirement etc..) ; Mais dans le cas contraire, il est préférable d'associer au programme des cartes Indépendammen dans un répertoire "Map" et parcourir celui-ci afin de proposer les labyrinthes disponibles j'entends par là, compter et proposer le choix des 1 à "N" et si le choix du joueur est maintenu exemple carte 5 alors on charge la carte en question ce qui laisse également la possibilité au joueur d'éditer sa propre carte indépendamment du programme ou à l'aide de l'éditeur de cartes qui fait partie du programme ( enfin s'il existe ).
à bientôt
0
ElementW Messages postés 4816 Date d'inscription dimanche 12 juin 2011 Statut Contributeur Dernière intervention 5 octobre 2021 1 228
23 févr. 2015 à 14:59
dans un répertoire "Map"
Répertoire qui n'est pas garanti d'être dans le dossier depuis lequel le programme est exécuté... M'enfin impossible d'écrire un code C cross-platform qui gérerait ça.
0
[Dal] Messages postés 6194 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 11 octobre 2024 1 092
Modifié par [Dal] le 23/02/2015 à 15:43
@sambia39 : sur le principe, tu as raison, mais on a affaire à un étudiant en 1ère année qui fait un exercice, qui n'a pas encore appris les pointeurs (et par voie de conséquence pas non plus l'allocation dynamique, ni certainement les fonctions de gestion de fichiers), mais qui a visiblement appris les tableaux multidimensionnels et leur initialisation. Mon exemple va dans le prolongement de cela, en ajoutant simplement une 3ème dimension au tableau.

Dans son énoncé, le nombre de cartes est fixé, et les cartes semblent prédéterminées, alors, je pense qu'il faut oublier la génération ou l'ajout de cartes dynamiques.

@gravgun : impossible ?

Dal
0
ElementW Messages postés 4816 Date d'inscription dimanche 12 juin 2011 Statut Contributeur Dernière intervention 5 octobre 2021 1 228 > [Dal] Messages postés 6194 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 11 octobre 2024
23 févr. 2015 à 16:42
Impossible, oui. Le seul moyen de déterminer le chemin d'exécution d'un programme est via les APIs du système sur lequel il tourne, 
GetModuleFileName
sous Window$ et 
readlink
de /proc/PID/exe sous Linux; pour arriver a un chemin absolu qui sera forcément correct vu que le dossier sera à coté de l'exécutable. Sinon, le chemin sera relatif, non pas à l'exécutable mais au dossier duquel il est lancé (current working dir).
0
[Dal] Messages postés 6194 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 11 octobre 2024 1 092
Modifié par [Dal] le 23/02/2015 à 18:44
@gravgun : argv[0] n'est pas fiable et, en ce sens, on peut effectivement dire que tu ne peux pas déterminer de façon certaine l'emplacement de l'exécutable lancé en C standard (en C ISO).

Mais faire du C "cross-platform" pour déterminer l'emplacement de l'exécutable lancé est bien sûr possible en sachant pour quelles plateformes tu programmes et en intégrant leurs particularités dans le code à coup de #define et autres Makefile en utilisant les moyens que tu mentionnes toi même à titre d'exemple pour Windows et Linux.

Note que la question de la détermination du répertoire où peuvent se trouver les données utilisées par un programme est différente selon le système d'exploitation et dépasse la simple question de la détermination de l'emplacement de l'exécutable lancé.

Un make install (ou un paquetage) pour un programme conçu pour Linux devrait mettre les exécutables dans un emplacement situé dans le path (du genre /usr/local/bin/ pour une installation locale) alors que les données pourront se trouver dans un emplacement plus habituellement utilisé par les programmes Linux (comme sous /usr/local/share), mais certainement pas dans un répertoire sous l'emplacement où est situé l'exécutable.

https://tldp.org/LDP/Linux-Filesystem-Hierarchy/html/usr.html

pareil sous Windows, des données pourront se trouver dans le registre, dans un emplacement définit par le système pour un certain usage, ou pourquoi pas dans un sous-répertoire du répertoire d'installation de l'application.

Cela dit, si ces questions sont intéressantes, je pense qu'on est à côté de la plaque dans cette discussion par rapport à la question (et aux préoccupations) de DEANETEHEI.

Dal
0
ElementW Messages postés 4816 Date d'inscription dimanche 12 juin 2011 Statut Contributeur Dernière intervention 5 octobre 2021 1 228 > [Dal] Messages postés 6194 Date d'inscription mercredi 15 septembre 2004 Statut Contributeur Dernière intervention 11 octobre 2024
23 févr. 2015 à 20:05
J'aurais du préciser que par cross-platform, j'entendais le faire sans #defines et #if, qui évidemment résolvent le problème.
0