IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

sokoban comment faire une Collision entre plusieurs éléments ?


Sujet :

C

  1. #1
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2021
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Boutique - Magasin

    Informations forums :
    Inscription : octobre 2021
    Messages : 5
    Points : 2
    Points
    2
    Par défaut sokoban comment faire une Collision entre plusieurs éléments ?
    Bonjour à tous !

    Je suis en d'apprendre le langage C je suis arrivé au chapitre du sokoban j'arrive à faire une carte avec des murs, déplacer mon personnage mais je n'arrive absolument pas à gérer les collision c'est quelque chose que je ne comprend pas dsl pouvez vous m'expliquer comment m'y prendre car pour le moment je galère voilà mon code désolé d'avance pour le bazar voilà ci-dessous :

    header :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    #ifndef HEADER_H_INCLUDED
    #define HEADER_H_INCLUDED
    typedef struct AABB aabb;
    struct AABB
    {
        int x; // Abscisses
        int y; // Ordonnées
    };
    void jeu(int continuer,SDL_Event event,SDL_Surface * mario,SDL_Rect positionMario,SDL_Surface *ecran, SDL_Surface * wall);
    void maps(SDL_Surface * wall,int nombre_blocs_largeur,int nombre_blocs_hauteur,SDL_Surface *ecran, char**table
              ,SDL_Rect Rect_dest,SDL_Rect Rect_source,int i, int j);
    #endif // HEADER_H_INCLUDED
    voilà le header ne vous souciez pas de la structure car elle n'est pas utiliser parce soit je ne sais pas comment m'en servir et aussi que j'aurai du le faire depuis le debut mais j'avais déjà pris le code de déplacement pour zozor si vous connaissez que j'ai modifier pour mettre à la place Mario

    La map :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
     
    #include <stdlib.h>
    #include <stdio.h>
    #include <SDL/SDL.h>
    #include <SDL/SDL_image.h>
    #include "header.h"
     
    void maps(SDL_Surface * wall,int nombre_blocs_largeur,int nombre_blocs_hauteur,SDL_Surface *ecran
              ,char**table,SDL_Rect Rect_dest,SDL_Rect Rect_source,int i, int j)
    {
        for(i = 0 ; i < nombre_blocs_largeur ; i++)
        {
            for(j = 0 ; j < nombre_blocs_hauteur ; j++)
            {
                Rect_dest.x = i*nombre_blocs_largeur;
                Rect_dest.y = j*nombre_blocs_hauteur;
                Rect_source.x = (table[j][i]-'0')*nombre_blocs_largeur;
                Rect_source.y = (table[j][i]-'0')*nombre_blocs_hauteur;
     
                SDL_BlitSurface(wall, &Rect_source, ecran, &Rect_dest);
            }
        }
    }
    Ci-dessus la map elle blit seulement les position de bloc que je mets dans une constante table qui lui est dans jeu montrer ci-dessous :

    jeu :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
     
    #include <stdlib.h>
    #include <stdio.h>
    #include <SDL/SDL.h>
    #include <SDL/SDL_image.h>
    #include "header.h"
    #define LARGEUR_TILE 34  // hauteur et largeur des tiles.
    #define HAUTEUR_TILE 34
    #define NOMBRE_BLOCS_LARGEUR 32  // nombre a afficher en x et y
    #define NOMBRE_BLOCS_HAUTEUR 26
     
    void jeu(int continuer,SDL_Event event,SDL_Surface * mario,SDL_Rect positionMario
             ,SDL_Surface *ecran,SDL_Surface * wall)
    {
    char* table[] = {
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000007770000000000000000",
    "000000077777777770000000000000",
    "000000077777777770000000000000",
    "000007777777777777700000000000",
    "000007777777777777700000000000",
    "000000077 77777 70000000000000",
    "000000077777777770000000000000",
    "000000077777777777700000000000",
    "000000077777777777700000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000",
    "000000000000000000000000000000"};
     
    int nombre_blocs_largeur = NOMBRE_BLOCS_LARGEUR;
    int nombre_blocs_hauteur = NOMBRE_BLOCS_HAUTEUR;
    int i,j;
    SDL_Rect Rect_dest;
    SDL_Rect Rect_source;
    Rect_source.w = nombre_blocs_largeur;
    Rect_source.h = nombre_blocs_hauteur;
    wall = IMG_Load("mur.jpg");
     
        while (continuer)
        {
            SDL_WaitEvent(&event);
            switch(event.type)
            {
            case SDL_QUIT:
                continuer = 0;
                break;
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                case SDLK_UP: // Flèche haut
                    mario = IMG_Load("mario_haut.gif");
                    positionMario.y--;
                    if(positionMario.y > nombre_blocs_hauteur){
                        positionMario.y = event.resize.h / 2 - mario->h / 2;
                    }
                    break;
                case SDLK_DOWN: // Flèche bas
                    mario = IMG_Load("mario_bas.gif");
                    positionMario.y++;
                    break;
                case SDLK_RIGHT: // Flèche droite
                    mario = IMG_Load("mario_droite.gif");
                    positionMario.x++;
                    break;
                case SDLK_LEFT: // Flèche gauche
                    mario = IMG_Load("mario_gauche.gif");
                    positionMario.x--;
                    break;
                }
                break;
            }
            SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
            maps(wall,nombre_blocs_largeur,nombre_blocs_hauteur,ecran,table,Rect_dest,Rect_source,i,j);
            SDL_BlitSurface(mario, NULL, ecran, &positionMario);
            SDL_Flip(ecran);
     
        }
     
        SDL_FreeSurface(wall);
        SDL_FreeSurface(mario);
        SDL_Quit();
    }
    Le fichier jeu lui fais le fonctionnement du jeu il déplace pour le moment c'est la que j'avais commencé à faire les tests pour la collision, mais je me demande si c'est la bonne solution ?

    Le main ci-dessous :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
     
    #include <stdlib.h>
    #include <stdio.h>
    #include <SDL/SDL.h>
    #include <SDL/SDL_image.h>
    #include "header.h"
     
    int main (int argc, char** argv)
    {
        SDL_Surface *ecran = NULL, *mario = NULL, *wall = NULL;
        SDL_Rect positionMario;
        SDL_Event event;
        int continuer = 1;
     
        SDL_Init(SDL_INIT_VIDEO);
        ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
        SDL_WM_SetCaption("Sokoban", NULL);
        mario = IMG_Load("mario_bas.gif");
        SDL_SetColorKey(mario, SDL_SRCCOLORKEY, SDL_MapRGB(mario->format, 0, 0, 255));
        positionMario.x = ecran->w / 2 - mario->w / 2;
        positionMario.y = ecran->h / 2 - mario->h / 2;
     
     
     
        SDL_EnableKeyRepeat(10, 10);
        jeu(continuer,event,mario,positionMario,ecran, wall);
     
     
        return EXIT_SUCCESS;
     
    }
    Il fait le démarrage du jeu c'est tout, voilà donc pour la collision comment je dois m'y prendre car malheureusement j'ai vu des cours preuve en est map viens de là justement donc j'ai beaucoup rechercher comme essayer de mon coté mais comme vous le voyez sans réelle succès bref tout conseil est bon à prendre merci de votre sollicitude !

  2. #2
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 418
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 418
    Points : 25 880
    Points
    25 880
    Billets dans le blog
    1
    Par défaut
    Bonjour
    Citation Envoyé par yamibilly Voir le message
    Je suis en d'apprendre le langage C je suis arrivé au chapitre du sokoban
    Mouais, je vois pas trop le rapport entre "apprendre un langage" et "programmer un jeu". Parce qu'avant d'en arriver à pouvoir faire un jeu (surtout en C) il faut d'abord s'en sortir avec des trucs simples comme "rechercher d'un mot dans une phrase" ou autres. Et surtout savoir manipuler les pointeurs. Est-ce que par exemple tu sais ce que signifient tous les "&truc" que tu passes à tes diverses fonctions ?

    Citation Envoyé par yamibilly Voir le message
    mais je n'arrive absolument pas à gérer les collision c'est quelque chose que je ne comprend pas dsl pouvez vous m'expliquer
    Ce n'est pas un souci de C ça, c'est un souci d'algo. Un souci de C c'est un souci inhérent au langage et à sa syntaxe.
    Sinon une collision c'est quand un truc en mouvement tente d'aller sur une case déjà occupée. Ca se gère donc en identifiant le jeu, les cases libres et celles qui ne le sont pas. Ensuite c'est au moment où tu programmes l'opération "mouvement du truc" que tu dois d'abord regarder où est-ce que va le truc.
    Et si (comme ça semble le cas pour toi) le truc descend au niveau du pixel (typiquement ton "mario" serait un rectangle), alors soit tu calcules l'intersection entre les divers rectangles représentant les éléments (ce sont des maths) soit tu dissocies la "représentation visible" (les pixels) de la "représentation logique"(les "1" et les "2" représentant mario et les murs par exemple). Ce qui est alors plus facile pour gérer. Et ensuite tu crées une équivalence (ici une homothétie) entre" représentation logique" et "représentation physique" pour afficher ton jeu à l'écran avec les divers presonnages.
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  3. #3
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2021
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Boutique - Magasin

    Informations forums :
    Inscription : octobre 2021
    Messages : 5
    Points : 2
    Points
    2
    Par défaut
    Merci Sve@r pour ta réponse j'aurais du être plus précis dans ma question oui t'as raison c'est un problème d'algo que je ne maitrise pas avec sokoban car il y a des chose que je ne comprend pas comme le rectangle de mario, comment il est créé et aussi comment le manipulez et dsl pour la confusion d'apprentissage du C car en faite je suis en train d'apprendre le C sur openclassrooms et je suis arrivé au tp sokoban que je suis en train de faire pour le moment pour ces &truc c'est à ma compréhension des pointeurs que je passe dans des fonctions de la bibliothèque SDL c'est des adresses pas la valeur brute si je ne me trompe pas sinon dans mes fonction jeu et map je ne me sers pas de pointeurs.

    Ce n'est pas un souci de C ça, c'est un souci d'algo. Un souci de C c'est un souci inhérent au langage et à sa syntaxe.
    Sinon une collision c'est quand un truc en mouvement tente d'aller sur une case déjà occupée. Ca se gère donc en identifiant le jeu, les cases libres et celles qui ne le sont pas. Ensuite c'est au moment où tu programmes l'opération "mouvement du truc" que tu dois d'abord regarder où est-ce que va le truc.
    Et si (comme ça semble le cas pour toi) le truc descend au niveau du pixel (typiquement ton "mario" serait un rectangle), alors soit tu calcules l'intersection entre les divers rectangles représentant les éléments (ce sont des maths) soit tu dissocies la "représentation visible" (les pixels) de la "représentation logique"(les "1" et les "2" représentant mario et les murs par exemple). Ce qui est alors plus facile pour gérer. Et ensuite tu crées une équivalence (ici une homothétie) entre" représentation logique" et "représentation physique" pour afficher ton jeu à l'écran avec les divers presonnages.

    Pour le texte ci-dessus c'est une piste que je vais regarder n'hésite pas s'il y a d'autre chose à dire car en faite je ne comprend pas trop sdl et l'algo qu'il y a derrière si il y a des astuces je prends pas de soucis bref merci pour la réponse

  4. #4
    Expert éminent
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    4 070
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : juillet 2013
    Messages : 4 070
    Points : 9 133
    Points
    9 133
    Par défaut
    Citation Envoyé par yamibilly Voir le message
    il y a des chose que je ne comprend pas comme le rectangle de mario, comment il est créé et aussi comment le manipulez
    Ouais tu sais quoi c'est normal, cela s'appelle programmer 1 jeu 1 tp où il faut programmer 1 jeu c'est n'imp

    Déjà, il faut apprendre la SDL pour l'affichage.

    Pour t'aider mais "programmer 1 jeu 2D" (le truc simple, pas le truc avec l'E C S (Entity Component System)

    Lorsque tu lances ton programme, tu vas avoir la phase d'initialisation de l'inferface avec les menus, les différents écrans : ici ce n'est pas compliqué, c'est de l'automate/ machine à états simple et tu charges écran par écran en répondant aux entrées.
    Lorsque tu lances ton jeu, c'est là que tu vas tout créer : tu vas charger tes assets (carte, texture, ...), initialiser ton jeu et c'est parti.

    1 jeu c'est 1 boucle de gameplay (en gros et simplifié)
    • tu attends, "idle" en anglais
    • si tu as des entrées, tu mets à jour ton jeu
    • et à intervalle fixe (*), tu déplaces les objets qui doivent se déplacer (projectiles ou les caisses qui tombent par exemple), tu calcules les collisions (par exemple tu peux créer des explosions ou jouer des sons en fonction), tu affiches ton jeu
    • tu reviens au début


    * : tu as 1 version sans timer, basé sur le temps de calcul des collisions, mais c'est très très "old-school". Si tu te demandes pourquoi Megaman sur NES est plus rapide en version américaine qu'en version européenne, tu as la réponse


    Citation Envoyé par Sve@r Voir le message
    les divers rectangles représentant les éléments (ce sont des maths)
    Le terme technique c'est boîte englobante ("bounding box" en anglais)

    Il me semble que tu vas avoir 3-4 listes
    • La liste des éléments fixes - murs, décors, ...
    • La liste des éléments qui bougent en fonction des entrées - ton personnage par exemple
    • La liste des éléments temporaires [qui bougent avec le temps] - les projectiles par exemple
    • La liste des éléments qui peuvent interagir avec ton personnage - des caisses par exemple


    Édit : TP : Mario Sokoban, lien openclassrooms
    D'après le peu que je vois c'est

    En gros tu programmes 1 jeu sans en être 1 (c'est juste 1 programme C assez long) :
    • aucuns objets World, ResourceManager, GameStateManager, ViewController, ... - tout est codé direct dans le programme avec des switch, bonjour pour tester et maintenir le truc
    • aucune gestion des erreurs "externes" - tu quittes le programme
    • sans timer - tu bouges à chaque entrée. Les sprites sont animés ? C'est le prochain tp ?

  5. #5
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 418
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 418
    Points : 25 880
    Points
    25 880
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par yamibilly Voir le message
    Merci Sve@r pour ta réponse j'aurais du être plus précis dans ma question oui t'as raison c'est un problème d'algo que je ne maitrise pas avec sokoban car il y a des chose que je ne comprend pas comme le rectangle de mario, comment il est créé et aussi comment le manipuler
    Déjà il faut savoir que je n'ai pas lu ce TP. Et que je ne connais pas la librairie SDL. Donc je ne pourrai que te donner des généralités.
    Toutefois il existe une technique de codage dans laquelle on sépare la gestion de l'affichage. Si par exemple je veux symboliser un petit bonhomme dans un couloir avec 5 cases libres, je peux le faire via un simple 10000 ("1" = bonhomme, "0"= vide).
    Ensuite ne reste qu'à établir une corrélation entre "1" (le bonhomme, Mario) et "0" (le couloir) pour dessiner Mario dans son couloir.
    Cette technique permet de faire facilement évoluer les choses (si demain tu veux utiliser une autre librairie, cela ne changera pas le coeur du jeu qui continuera avec son "10000").
    Et surtout c'est assez facile avec cette technique de voir si un espace est libre ou pas sans avoir besoin de regarder si un pixel de Mario rencontre un pixel du mur. Certes ça fait des jeux assez grossiers mais dans ce cas précis ce n'est pas l'esthétique que l'on recherche.

    Citation Envoyé par foetus Voir le message
    Il me semble que tu vas avoir 3-4 listes
    • La liste des éléments fixes - murs, décors, ...
    • La liste des éléments qui bougent en fonction des entrées - ton personnage par exemple
    • La liste des éléments temporaires [qui bougent avec le temps] - les projectiles par exemple
    • La liste des éléments qui peuvent interagir avec ton personnage - des caisses par exemple
    Je crois que je n'ai pas la même version que toi. Dans mes souvenirs, sokoban c'était un petit bonhomme qui devait pousser des boites à travers un semi-labyrinthe pour les ranger. Il pouvait pousser ou tirer mais s'il devait par exemple changer de sens il devait alors avoir la place pour changer d'axe de poussée (se mettre derrière la boite dans la nouvelle direction). Nulle part il y avait des projectiles ou des trucs qui te courrent après...
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  6. #6
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2021
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Boutique - Magasin

    Informations forums :
    Inscription : octobre 2021
    Messages : 5
    Points : 2
    Points
    2
    Par défaut
    Merci Sve@r je ne la connaissais pas cette technique je vais chercher ça et je verrai comment m'y prendre aprés j'avoue que réduire mon perso à un chiffre franchement ça serait beaucoup plus pratique, je vais chercher et pour sdl 1 je parle du 1 y a plus grand monde qui s'en sert depuis longtemps de cette bibliotheque c'est sdl2 qui est utilisé pour le moment preuve en est il gère les collision plus facilement que lui je pense, je sais pas mais je vais voir cette technique en tout cas.

  7. #7
    Expert éminent
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    4 070
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : juillet 2013
    Messages : 4 070
    Points : 9 133
    Points
    9 133
    Par défaut
    Citation Envoyé par yamibilly Voir le message
    Merci Sve@r je ne la connaissais pas cette technique je vais chercher ça et je verrai comment m'y prendre aprés j'avoue que réduire mon perso à un chiffre franchement ça serait beaucoup plus pratique
    En réalité, tu dois avoir 1 objet "World", qui représente le monde.

    Mais comme ton jeu est [très] très simple, ton monde est juste 1 tableau 2D (1 matrice). Et donc dans cette matrice, tu vas matérialiser les objets soit par des entiers soit par des caractères soit par autre chose.
    Édit : int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};

    Par exemple, 0, emplacement vide - 1, ton personnage - 2, un mur ...
    Édit : enum {VIDE, MUR, CAISSE, OBJECTIF, MARIO, CAISSE_OK};

    D'aiileurs dans tes fichiers pour chaque niveau, c'est qu'il devrait y avoir : au moins 1 tableau avec des 0, 1, 2, ... ou des A, B, C, ...

    C'est l'objet "GameView" (ou assimilé) qui s'occupe de l'affichage via le "ResourceManager".
    Il va soit savoir que tel symbole équivaut à telle texture soit demander au "monde" ce qu'il y a à tel indice (<- je me rappelle plus comment on fait )

    Et donc avec cette représentation, c'est très simple : tu n'as qu'à faire des tests des cases adjacentes à ton personnage pour les collisions.
    Édit : if (carte[pos->x][pos->y - 1] == MUR) { break; } // S'il y a un mur, on arrête

    Mais dans ton TP, tu n'as pas d'objets et tout est codé "en vrac".

  8. #8
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    9 418
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 9 418
    Points : 25 880
    Points
    25 880
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par yamibilly Voir le message
    Merci Sve@r je ne la connaissais pas cette technique je vais chercher ça
    C'est ce qu'on nomme "MVC" (Modèle/Vue/Controleur"). Le Modèle ce sont les données (comment les stocker, comment les récupérer). La Vue c'est le graphique (comment afficher, comment saisir) et le Controleur c'est l'algo (comment utiliser deux données pour calculer la 3°).

    Citation Envoyé par yamibilly Voir le message
    j'avoue que réduire mon perso à un chiffre franchement ça serait beaucoup plus pratique
    C'est justement fait pour ça.

    Citation Envoyé par yamibilly Voir le message
    Citation Envoyé par foetus Voir le message
    Par exemple, 0, emplacement vide - 1, ton personnage - 2, un mur ...
    Exactement. La page wikipedia montre par exemple une version textuelle du jeu
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
        #####
        #   #
        #$  #
      ###  $##
      #  $ $ #
    ### # ## #   ######
    #   # ## #####  ..#
    # $  $          ..#
    ##### ### #@##  ..#
        #     #########
        #######
    De là, regarder si "@" peut aller à gauche ou droite devient trivial. Ensuite convertir "#" en joli mur rouge, "@" en Mario et "$" en caisse de bois ce n'est que du graphique...
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  9. #9
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2021
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Boutique - Magasin

    Informations forums :
    Inscription : octobre 2021
    Messages : 5
    Points : 2
    Points
    2
    Par défaut
    Ok foetus je vois oui les classes n'existe pas dans mon code c'est du prototype c'est tout mais je peux regarder et voir ce que je trouve sinon théorie algorithmiques et là je remettrai de l'ordre dans ce code en vrac pour comprendre tous, y pas de sprite animé ça serai galère lol la suite après c'est les sons je crois dsl comme je suis sur sokoban, j'ai zappé la suite du cours mais l'idée de sve@r me plait bien j'irai regardé sinon comme au début algorithme, test et ensuite ça finira par marché mais c'est sympa vos conseils merci et google programmer jeu 2D et là je prendrai plus temps et de réflexion pour comprendre SDL1.

  10. #10
    Membre éclairé
    Homme Profil pro
    Architecte de système d'information
    Inscrit en
    septembre 2015
    Messages
    173
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Ain (Rhône Alpes)

    Informations professionnelles :
    Activité : Architecte de système d'information

    Informations forums :
    Inscription : septembre 2015
    Messages : 173
    Points : 731
    Points
    731
    Par défaut
    le site proposait déjà une solution : https://chgi.developpez.com/wincode/sokoban/
    (en plus du lien openclassroom donné par foetus)

    Reste la transformation Win32 => SDL qui ne devrait pas être trop compliqué

    comme on peut le voir, il a utilisé le modèle MVC, ainsi pour la partie affichage, il n'y a qu'un endroit à modifier

  11. #11
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2021
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Boutique - Magasin

    Informations forums :
    Inscription : octobre 2021
    Messages : 5
    Points : 2
    Points
    2
    Par défaut
    Merci Xelland je vais regarder ça merci pour ta solution

Discussions similaires

  1. Comment faire une connexion entre talend et weka?
    Par glINSAT dans le forum Weka et MOA
    Réponses: 2
    Dernier message: 15/04/2009, 08h10
  2. Réponses: 1
    Dernier message: 06/07/2007, 10h28
  3. comment faire une query entre 2 tables de 2 bases?
    Par ch_cu2 dans le forum Débuter
    Réponses: 1
    Dernier message: 12/12/2006, 21h45
  4. Comment faire pour choisir entre plusieur elements d'un filelist ?
    Par MegaBigBoss dans le forum VB 6 et antérieur
    Réponses: 15
    Dernier message: 21/07/2006, 18h51
  5. Réponses: 3
    Dernier message: 16/05/2006, 10h32

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo