Discussion :

[yamibilly]

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 !

[Sve@r]

Bonjour

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 ?

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.

[yamibilly]

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 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

[foetus]

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

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

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 ?

[Sve@r]

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.

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...

[yamibilly]

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.

[foetus]

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".

[Sve@r]

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°).

j'avoue que réduire mon perso à un chiffre franchement ça serait beaucoup plus pratique

C'est justement fait pour ça.

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...

[yamibilly]

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.

[Xelland]

le site proposait déjà une solution : https://chgi.developpez.com/wincode/sokoban/

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

[yamibilly]

Merci Xelland je vais regarder ça merci pour ta solution