Discussion :

[_SamSoft_]

Bonjour, je développe en ce moment un logiciel avec le langage de programmation C et la librairie SDL. Voilà un screen qui va vous imager mon programme (j'ai pris ce screen hier avant l'implémentation de la gestion de collisions) :

http://www.zimagez.com/zimage/life1.php

En fait, chaque carré représente un être humain. J'ai pour le moment, pour objectif personnel (j'ai que 15 ans ) de faire déplacer ces carrés. Lors d'un contact entre deux carres, il y a naissance d'un nouveau carré ayant pour couleur, un mix entre les couleurs du père et de la mère ainsi, on pourra voir la couleur dominante à l'écran.

Voilà où j'en suis pour le moment :

J'ai implémenté la gestion de collision qui ne fonctionne pas Tout les carres sont au même endroit

Voilà une image du programme en cours : (avec la gestion de collisions foireuse )

http://www.zimagez.com/zimage/life3.php

Voilà le code de main.c :

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
 
/*
 
    Author : Samy Hocine (samyhocine_at_hotmail_dot_fr)
    Date : November 2007
    Licence : GNU/GPL
*/
 
#include <stdlib.h>
#include <stdio.h>
#include "const.h"
#include "life.h"
#include <SDL/SDL.h>
 
void pause();
 
int main(void)
{
    SDL_Init(SDL_INIT_VIDEO);
 
    SDL_Surface *screen = NULL;
 
    screen = SDL_SetVideoMode(L_WINDOW, H_WINDOW, 32, SDL_HWSURFACE);
    SDL_WM_SetCaption("Life", NULL);
 
    // Coloration de la surface ecran en bleu-vert
    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 100, 100, 100));
 
    SDL_Flip(screen); /* Mise à jour de l'écran avec sa nouvelle couleur */
 
 
    if(createLife(screen)!=1)
    {
        fprintf(stdout, "\nErreur lors de la creation des humains\n");
    }
    else
    {
        fprintf(stdout, "\nCreation des humains re'ussie\n");
    }
    fflush(stdout);
 
    pause();
 
    SDL_Quit();
 
    return EXIT_SUCCESS;
}
 
void pause()
{
    int end = 0;
    SDL_Event event;
 
    while (end!=1)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                end = 1;
        }
    }
}

life.c

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
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "const.h"
#include "life.h"
 
struct pos
{
    int x;
    int y;
};
 
struct col
{
    int r;
    int g;
    int b;
};
 
struct life
{
    struct pos position;
    struct col color;
 
};
 
int createLife(SDL_Surface* screen)
{
    int x = 0, y = 0, l = 254, m = 400;
    int r = 0, g = 0, b = 0, people = LIFES;
    int map[L_H_CASE][L_H_CASE] = {};
    int i, j;
 
    SDL_Surface *perso[LIFES] = {NULL};
    SDL_Rect position;
 
    srand((int)time(NULL));
 
    while(people > 0)
    {
        fprintf(stdout, "\nCreation de l'humain : %i\n", people);
 
        perso[people] = SDL_CreateRGBSurface(SDL_HWSURFACE, L_H_CASE, L_H_CASE, 32, 0, 0, 0, 0);
 
        x = rand() % (m+1);
 
        r = rand() % (l+1);
        g = rand() % (l+1);
        b = rand() % (l+1);
 
        y = rand() % (m+1);
 
        for (i = 0 ; i < L_H_CASE ; i++)
        {
            for (j = 0 ; j < L_H_CASE ; j++)
            {
                if (map[i][j] == HUMAN)
                {
                    position.x = i;
                    position.y = j;
                    map[i][j] = NOTHING;
                }
            }
        }
 
        SDL_FillRect(perso[people], NULL, SDL_MapRGB(screen->format, r, g, b));
        SDL_BlitSurface(perso[people], NULL, screen, &position);
        SDL_Flip(screen);
 
        boucle();
 
        people--;
    }
    return 1;
}
 
void boucle()
{
    int a = 1, b = 10, c = 100, d = 0, i = 100;
 
    while(i > 0)
    {
        i--;
        d = a+b+c;
    }
}

life.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#ifndef LIFE_H_
#define LIFE_H_
 
#include <SDL/SDL.h>
 
struct pos;
struct col;
struct life;
void boucle();
int createLife(SDL_Surface* screen);
 
#endif /* LIFE_H_ */

Ce que je pense pour le moment c'est que c'est au niveau de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
        for (i = 0 ; i < L_H_CASE ; i++)
        {
            for (j = 0 ; j < L_H_CASE ; j++)
            {
                if (map[i][j] == VOID)
                {
                    position.x = i;
                    position.y = j;
                    map[i][j] = HUMAN;
                }
            }
        }

q

Que ca cloche, si vous pouviez m'aider

Merci d'avance

PS: const.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#ifndef CONST_H_
#define CONST_H_
 
    #define L_H_CASE    8
    #define L_WINDOW    640
    #define H_WINDOW    480
    #define LIFES  20
 
    enum {UP, DOWN, LEFT, WRITE};
    enum {VOID, HUMAN};
 
 
#endif /* CONST_H_ */

[drcd]

Je ne vois pas ou elle est ta gestion de collisions. Elle est ou?

[_SamSoft_]

J'ai oublié de préciser un truc.
Correspond à la détection d'autres carrés lors de la création des carrés. En gros, il sert à ce que les carés lors de leur création se retrouvent par hasard les uns sur les autres.

Le problème se situe sur ce code, les carrés sont tous au même endroit

Merci d'avance

Voilà le code mis à jour mais qui ne fout rien

Si vous pouviez me faire un petit pseudo code pour arriver à faire ce que je veux faire , ce serait sympa

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
 
int createLife(SDL_Surface* screen)
{
    int x = 0, y = 0, l = 254, m = H_WINDOW;
    int r = 0, g = 0, b = 0, people = LIFES;
    int map[L_H_CASE][L_H_CASE] = {};
    int i = LIFES, start = 0;
 
    SDL_Surface *perso[LIFES] = {NULL};
    SDL_Rect position;
 
    srand((int)time(NULL));
 
    struct life humans[LIFES];
 
    while(people > 0)
    {
        fprintf(stdout, "\nCreation de l'humain : %i\n", people);
 
        perso[people] = SDL_CreateRGBSurface(SDL_HWSURFACE, L_H_CASE, L_H_CASE, 32, 0, 0, 0, 0);
 
        r = rand() % (l+1);
        g = rand() % (l+1);
        b = rand() % (l+1);
 
        x = rand() % (m+1);
        y = rand() % (m+1);
 
        if(start == 0)
        {
            humans[0].position.x = x;
            humans[0].position.y = y;
            map[x][y] = HUMAN;
            start = 1;
        }
 
        while(i < 0)
        {
            x = rand() % (m+1);
            fprintf(stdout, "\n1: x %i\n", x);
            fprintf(stdout, "\n1.1: %i\n", humans[i].position.x);
            while(x != humans[i].position.x)
            {
                printf("\n1: OK\n");
                y = rand() % (m+1);
                fprintf(stdout, "\n2: y %i\n", y);
                fprintf(stdout, "\n2.1: y %i\n", humans[i].position.y);
                while(y != humans[i].position.y)
                {
                    printf("\n2 : OK\n");
                    position.x = x;
                    position.y = y;
                    map[x][y] = HUMAN;
                }
            }
            i--;
        }
 
        i = 0;
 
        SDL_FillRect(perso[people], NULL, SDL_MapRGB(screen->format, r, g, b));
        SDL_BlitSurface(perso[people], NULL, screen, &position);
        SDL_Flip(screen);
 
        boucle();
 
        people--;
    }
    return 1;
}

[_SamSoft_]

Voilà un code qui est correct mais qui fait toujours que les carrés sont à la même position.

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
int createLife(SDL_Surface* screen)
{
    int x = 0, y = 0, l = 254, m = H_WINDOW;
    int r = 0, g = 0, b = 0, people = LIFES;
    int map[L_H_CASE][L_H_CASE] = {};
    int end = 0;
 
    SDL_Surface *perso[LIFES] = {NULL};
    SDL_Rect position;
 
    srand((int)time(NULL));
 
    struct life humans[LIFES];
 
    while(people > 0)
    {
        fprintf(stdout, "\nCreation de l'humain : %i\n", people);
 
        perso[people] = SDL_CreateRGBSurface(SDL_HWSURFACE, L_H_CASE, L_H_CASE, 32, 0, 0, 0, 0);
 
        r = rand() % (l+1);
        g = rand() % (l+1);
        b = rand() % (l+1);
 
        x = rand() % (m+1);
        y = rand() % (m+1);
 
        while(map[x][y] != HUMAN || end != 1)
        {
            humans[people].position.x = x;
            humans[people].position.y = y;
            map[x][y] = HUMAN;
            end = 1;
        }
 
        end = 0;
 
        SDL_FillRect(perso[people], NULL, SDL_MapRGB(screen->format, r, g, b));
        SDL_BlitSurface(perso[people], NULL, screen, &position);
        SDL_Flip(screen);
 
        boucle();
 
        people--;
    }
    return 1;
}

Merci d'avance

[Bibicy]

Sur le dernier code,il y a un problème de dépassement de tableau :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
int r = 0, g = 0, b = 0, people = LIFES;
...
SDL_Surface *perso[LIFES] = {NULL};
...
perso[people] = ...

Les indices de ton tableau "perso" vont de 0 à LIFES-1

Sinon void étant un mot clé j'eviterais de l'utiliser comme un enum.

[_SamSoft_]

Ben, je ne vois pas trop : voilà la sortie :

reation de l'humain : 20

people : 20

Creation de l'humain : 19

people : 19

Creation de l'humain : 18

people : 18

Creation de l'humain : 17

people : 17

Creation de l'humain : 16

people : 16

Creation de l'humain : 15

people : 15

Creation de l'humain : 14

people : 14

Creation de l'humain : 13

people : 13

Creation de l'humain : 12

people : 12

Creation de l'humain : 11

people : 11

Creation de l'humain : 10

people : 10

Creation de l'humain : 9

people : 9

Creation de l'humain : 8

people : 8

Creation de l'humain : 7

people : 7

Creation de l'humain : 6

people : 6

Creation de l'humain : 5

people : 5

Creation de l'humain : 4

people : 4

Creation de l'humain : 3

people : 3

Creation de l'humain : 2

people : 2

Creation de l'humain : 1

people : 1

Creation des humains re'ussie

Faut dire aussi que j'ai changé le code : voilà mes maj :

main.c

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
 
/*
 
    Author : Samy Hocine (samyhocine_at_hotmail_dot_fr)
    Date : November 2007
    Licence : GNU/GPL
*/
 
#include <stdlib.h>
#include <stdio.h>
#include "const.h"
#include "life.h"
#include <SDL/SDL.h>
 
void pause();
 
int main(void)
{
    SDL_Init(SDL_INIT_VIDEO);
 
    SDL_Surface *screen = NULL;
 
    screen = SDL_SetVideoMode(L_WINDOW, H_WINDOW, 32, SDL_HWSURFACE);
    SDL_WM_SetCaption("Life", NULL);
 
    // Coloration de la surface ecran en bleu-vert
    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 100, 100, 100));
 
    SDL_Flip(screen); /* Mise à jour de l'écran avec sa nouvelle couleur */
 
 
    if(createLife(screen)!=1)
    {
        fprintf(stdout, "\nErreur lors de la creation des humains\n");
    }
    else
    {
        fprintf(stdout, "\nCreation des humains re'ussie\n");
    }
    fflush(stdout);
 
    pause();
 
    SDL_Quit();
 
    return EXIT_SUCCESS;
}
 
void pause()
{
    int end = 0;
    SDL_Event event;
 
    while (end!=1)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                end = 1;
        }
    }
}

const.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef CONST_H_
#define CONST_H_
 
    #define L_H_CASE    8
    #define L_WINDOW    640
    #define H_WINDOW    480
    #define LIFES  20
 
    enum {UP, DOWN, LEFT, WRITE};
    enum {NOTHING, HUMAN};
 
 
#endif /* CONST_H_ */

life.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef LIFE_H_
#define LIFE_H_
 
#include <SDL/SDL.h>
 
struct pos;
struct col;
struct life;
void boucle();
int createLife(SDL_Surface* screen);
 
#endif /* LIFE_H_ */

life.c

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "const.h"
#include "life.h"
 
struct pos
{
    int x;
    int y;
};
 
struct col
{
    int r;
    int g;
    int b;
};
 
struct life
{
    struct pos position;
    struct col color;
 
};
 
int createLife(SDL_Surface* screen)
{
    int x = 0, y = 0, l = 254, m = H_WINDOW;
    int r = 0, g = 0, b = 0, people = LIFES;
    int map[L_H_CASE][L_H_CASE] = {};
    int end = 0;
 
    SDL_Surface *perso[LIFES] = {NULL};
    SDL_Rect position;
 
    srand((int)time(NULL));
 
    struct life humans[LIFES];
 
    while(people > 0)
    {
        fprintf(stdout, "\nCreation de l'humain : %i\n", people);
 
        printf("\npeople : %i\n", people);
        perso[people] = SDL_CreateRGBSurface(SDL_HWSURFACE, L_H_CASE, L_H_CASE, 32, 0, 0, 0, 0);
 
        r = rand() % (l+1);
        g = rand() % (l+1);
        b = rand() % (l+1);
 
        x = rand() % (m+1);
        y = rand() % (m+1);
 
        humans[people].position.x = x;
        humans[people].position.y = y;
        map[x][y] = HUMAN;
 
        end = 0;
 
        SDL_FillRect(perso[people], NULL, SDL_MapRGB(screen->format, r, g, b));
        SDL_BlitSurface(perso[people], NULL, screen, &position);
        SDL_Flip(screen);
 
        boucle();
 
        people--;
    }
    return 1;
}
 
void boucle()
{
    int a = 1, b = 10, c = 100, d = 0, i = 100;
 
    while(i > 0)
    {
        i--;
        d = a+b+c;
    }
}

Merci d'avance (ps : si vous avez quoi que ce soit concernant la gestion de collision, passez le moi )

Merci encore

[fearyourself]

Ben, je ne vois pas trop : voilà la sortie :

Juste parce que le code semble fonctionner ne veut pas dire qu'il est correct.

Regardons un peu ce code :

main.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
    SDL_Init(SDL_INIT_VIDEO);
 
    SDL_Surface *screen = NULL;
 
    screen = SDL_SetVideoMode(L_WINDOW, H_WINDOW, 32, SDL_HWSURFACE);

- Il faut tester le retour de chaque fonction SDL. C'est une erreur grave de ne pas le faire.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
    if(createLife(screen)!=1)
    {
        fprintf(stdout, "\nErreur lors de la creation des humains\n");
    }
    else
    {
        fprintf(stdout, "\nCreation des humains re'ussie\n");
    }
    fflush(stdout);

- Si tu utilise fprintf, mets au moins l'erreur dans stderr.

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
 
void pause()
{
    int end = 0;
    SDL_Event event;
 
    while (end!=1)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                end = 1;
        }
    }
}

- Teste le retour de SDL_WaitEvent. C'est une erreur de ne pas le faire : http://jeux.developpez.com/faq/sdl/?...NTS_repetition


life.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
struct pos;
struct col;
struct life;
 
void boucle();
int createLife(SDL_Surface* screen);
 
#endif /* LIFE_H_ */

Très bizarre comme solution de déclaration. Si tu ne veux pas donner les définitions des structures pos, col et life je ne vois pas pourquoi tu mets ces lignes dans ce .h...

Normalement, on laisse la définition de la structure dans le .h directement, à la place de le faire comme cela.


life.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
    int map[L_H_CASE][L_H_CASE] = {};

Attention, à mon souvenir il faudra au moins mettre un 0 pour avoir tout le tableau à 0.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
    srand((int)time(NULL));

Normalement, on met cela dans le main mais c'est un détail. Ensuite, le cast est inutile et en plus faut. time retourne un time_t qui sera probablement un unsigned int et srand prend un unsigned int en paramètre donc...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
    struct life humans[LIFES];

Problème ici, people vaut d'abord LIFES et ton tableau a des indices de 0 à LIFES-1... Ce problème a déjà été remarqué. A corriger donc.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
        perso[people] = SDL_CreateRGBSurface(SDL_HWSURFACE, L_H_CASE, L_H_CASE, 32, 0, 0, 0, 0);

Ok je veux bien mais si la seule chose qui représente un personnage est sa couleur, ce n'est pas la peine de faire si compliqué. Utilise SDL_FillRect correctement et tu n'auras pas besoin du tableau perso...

Au pire, utilise une seule surface de SDL_CreateRGBSurface et colorie là correctement avant de faire le Blit.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
        humans[people].position.x = x;
        humans[people].position.y = y;
        map[x][y] = HUMAN;

Premièrement : ta position pourrait juste être un SDL_Rect, cela simplifierait le code de rendu. Deuxièmement : et la couleur ? Si ta structure contient cette information, il faudrait s'en souvenir, non ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
        SDL_FillRect(perso[people], NULL, SDL_MapRGB(screen->format, r, g, b));
        SDL_BlitSurface(perso[people], NULL, screen, &position);

Et la variable position est initialisée où ? tsk tsk tsk Surtout que c'est pour cela que tes rendus se font au même endroit

Autre problème : que fais-tu si tu as plusieurs humains sur la même case ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
        SDL_Flip(screen);
 
        boucle();
 
        people--;

Ca, par contre, je ne suis pas d'accord. Un code SDL doit être comme ceci :

- Vider la surface écran
- Mettre le fond
- Dessiner les objets visibles
- SDL_Flip

Toujours ! Donc, il va falloir retravailler ton code pour obtenir cela. Deuxièment ta fonction boucle n'est rien d'autre qu'un SDL_Delay avec une certaine valeur. De plus, compiler correctement, cette fonction ne ferait rien du tout car le compilateur l'enléverait tout simplement (vu qu'elle ne fait rien d'intéressant).
[/CODE]

Merci d'avance (ps : si vous avez quoi que ce soit concernant la gestion de collision, passez le moi )

D'abord, il faudrait corriger tout ca. Il faut vraiment commencer par mettre tous les tests en place ensuite il faut mettre le code comme ceci :

Dans le main :

- Initialisation SDL et données du jeu
- Boucle générale avec SDL_WaitEvent ou SDL_PollEvent et le code de rendu ou un appel vers le code de rendu.

Ceci gardera tout le code de rendu au même endroit, ce qui sera beaucoup mieux.

Jc

[_SamSoft_]

Merci. Toutes mes excuses pour ce code sans vérifications. En fait, j'étais si curieux de comprendre comment créer la gestion de collisions que j'en ai oublié la BASE Voilà j'ai remis à niveau (c.f plus bas)
En revanche je préfère nettement laisser dans le main l'initialisation générale de la SDL et dans d'autres fichiers ce qui concernent vraiment mon programme.

main.c

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
 
/*
 
    Author : Samy Hocine (samyhocine_at_hotmail_dot_fr)
    Date : November 2007
    Licence : GNU/GPL
*/
 
#include <stdlib.h>
#include <stdio.h>
#include "const.h"
#include "life.h"
#include <SDL/SDL.h>
 
void pause();
 
int main(void)
{
    if(SDL_Init(SDL_INIT_VIDEO) == ERROR)
    {
        fprintf(stderr, "Erreur lors de l'initialisation de la SDL: %s\n", SDL_GetError());
        return EXIT_FAILURE;
    }
 
    SDL_Surface *screen = NULL;
 
    screen = SDL_SetVideoMode(L_WINDOW, H_WINDOW, 32, SDL_HWSURFACE);
 
    if(screen == NULL)
    {
        fprintf(stderr, "Impossible de definir la surface screen: %s\n", SDL_GetError());
        return EXIT_FAILURE;
    }
 
    SDL_WM_SetCaption("Life", NULL);
 
    // Coloration de la surface ecran en bleu-vert
    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 100, 100, 100));
 
    SDL_Flip(screen); /* Mise à jour de l'écran avec sa nouvelle couleur */
 
 
    if(createLife(screen)!=SUCCES)
    {
        fprintf(stderr, "\nErreur lors de la creation des humains\n");
        return EXIT_FAILURE;
    }
    else
    {
        fprintf(stdout, "\nCreation des humains re'ussie\n");
    }
    fflush(stdout);
 
    pause();
 
    SDL_Quit();
 
    return EXIT_SUCCESS;
}
 
void pause()
{
    int end = 0;
    SDL_Event event;
 
    while (end!=1)
    {
       while(SDL_WaitEvent(&event))
       {
            switch(event.type)
            {
                case SDL_QUIT:
                    end = 1;
            }
       }
    }
}

Pour SDL_Quit(), je ne sais pas s'il retourne une valeur.

life.c

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
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "const.h"
#include "life.h"
 
struct pos
{
    int x;
    int y;
};
 
struct col
{
    int r;
    int g;
    int b;
};
 
struct life
{
    struct pos position;
    struct col color;
 
};
 
int createLife(SDL_Surface* screen)
{
    int x = 0, y = 0, l = 254, m = H_WINDOW;
    int r = 0, g = 0, b = 0, people = LIFES;
    int map[L_H_CASE][L_H_CASE] = {};
    int end = 0;
 
    SDL_Surface *perso[LIFES] = {NULL};
    SDL_Rect position;
 
    srand((int)time(NULL));
 
    struct life humans[LIFES];
 
    while(people > 0)
    {
        fprintf(stdout, "\nCreation de l'humain : %i\n", people);
 
        perso[people] = SDL_CreateRGBSurface(SDL_HWSURFACE, L_H_CASE, L_H_CASE, 32, 0, 0, 0, 0);
 
        r = rand() % (l+1);
        g = rand() % (l+1);
        b = rand() % (l+1);
 
        x = rand() % (m+1);
        y = rand() % (m+1);
 
        humans[people].position.x = x;
        humans[people].position.y = y;
        map[x][y] = HUMAN;
 
        end = 0;
 
        SDL_FillRect(perso[people], NULL, SDL_MapRGB(screen->format, r, g, b));
        SDL_BlitSurface(perso[people], NULL, screen, &position);
        SDL_Flip(screen);
 
        boucle();
 
        people--;
    }
    return SUCCES;
}
 
void boucle()
{
    int a = 1, b = 10, c = 100, d = 0, i = 100;
 
    while(i > 0)
    {
        i--;
        d = a+b+c;
    }
}

pas besoin de mettre life.h ici

const.h

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
 
#ifndef CONST_H_
#define CONST_H_
 
    #define ERROR       -1
    #define SUCCES      0
    #define L_H_CASE    8
    #define L_WINDOW    640
    #define H_WINDOW    480
    #define LIFES       20
 
    enum {UP, DOWN, LEFT, WRITE};
    enum {NOTHING, HUMAN};
 
 
#endif /* CONST_H_ */

Merci d'avance

[fearyourself]

Erreur dans l'écriture de mon post, la grande majorité était mis dans une section code.

Tu peux le relire en entier maintenant, j'ai répondu pourquoi tu avais certains problèmes.

Jc

[_SamSoft_]

Merci Je vais essayer de voir cela cette semaine ou le week end prochain car là j'ai du boulot (disserte oblige )

[_SamSoft_]

J'ai un peu codé, modifié quelques trucs :

main.c

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
 
/*
 
    Author : Samy Hocine (samyhocine_at_hotmail_dot_fr)
    Date : November 2007
    Licence : GNU/GPL
*/
 
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "const.h"
#include "life.h"
#include <SDL/SDL.h>
 
void pause();
 
int main(void)
{
    if(SDL_Init(SDL_INIT_VIDEO) == ERROR)
    {
        fprintf(stderr, "Erreur lors de l'initialisation de la SDL: %s\n", SDL_GetError());
        return EXIT_FAILURE;
    }
 
    SDL_Surface *screen = NULL;
 
    screen = SDL_SetVideoMode(L_WINDOW, H_WINDOW, 32, SDL_HWSURFACE);
 
    if(screen == NULL)
    {
        fprintf(stderr, "Impossible de definir la surface screen: %s\n", SDL_GetError());
        return EXIT_FAILURE;
    }
 
    SDL_WM_SetCaption("Life", NULL);
 
    // Coloration de la surface ecran en bleu-vert
    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 100, 100, 100));
 
    SDL_Flip(screen); /* Mise à jour de l'écran avec sa nouvelle couleur */
 
    srand((int)time(NULL));
 
    if(createLife(screen)!=SUCCES)
    {
        fprintf(stderr, "\nErreur lors de la creation des humains\n");
        return EXIT_FAILURE;
    }
    else
    {
        fprintf(stdout, "\nCreation des humains re'ussie\n");
    }
    fflush(stdout);
 
    pause();
 
    SDL_Quit();
 
    return EXIT_SUCCESS;
}
 
void pause()
{
    int end = 0;
    SDL_Event event;
 
    while (end!=1)
    {
       while(SDL_PollEvent(&event))
       {
            if(event.type == SDL_QUIT)
            {
                    end = 1;
            }
       }
    }
 
    fprintf(stdout, "fin");
 
}

life.c

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
#include <stdio.h>
#include <stdlib.h>
#include "const.h"
#include "life.h"
 
struct pos
{
    int x;
    int y;
};
 
struct col
{
    int r;
    int g;
    int b;
};
 
struct life
{
    struct pos position;
    struct col color;
 
};
 
int createLife(SDL_Surface* screen)
{
    int x = 0, y = 0, l = 254, m = H_WINDOW, n = L_WINDOW;
    int r = 0, g = 0, b = 0, people = LIFES;
    int map[L_WINDOW][H_WINDOW];
    int sizeScrL = L_WINDOW, sizeScrH = H_WINDOW;
    int end = 0;
 
    fprintf(stderr, "\nH: %d, L: %d", sizeScrH, sizeScrL);
 
    while(sizeScrL > 0 || sizeScrH > 0)
    {
        map[sizeScrL][sizeScrH] = NOTHING;
        sizeScrL--;
        sizeScrH--;
    }
 
    sizeScrL = L_WINDOW;
    sizeScrH = H_WINDOW;
 
    SDL_Surface *perso[LIFES] = {NULL};
    SDL_Rect position;
 
    position.x = 0;
    position.y = 0;
 
    struct life humans[LIFES];
 
    while(people > 0)
    {
        fprintf(stdout, "\nCreation de l'humain : %i\n", people);
 
        perso[people] = SDL_CreateRGBSurface(SDL_HWSURFACE, L_H_CASE, L_H_CASE, 32, 0, 0, 0, 0);
 
        r = rand() % (l+1);
        g = rand() % (l+1);
        b = rand() % (l+1);
 
        x = rand() % (m+1);
        y = rand() % (n+1);
 
        printf("\nX: %d, Y: %d\n", x, y);
 
        humans[people].position.x = x;
        humans[people].position.y = y;
 
        printf("\nAUTRE: X: %d, Y: %d\n", x, y);
 
        humans[people].color.r = r;
        humans[people].color.g = g;
        humans[people].color.b = b;
 
        while(sizeScrL > 0 || sizeScrH > 0 || end == 0)
        {
            if(map[sizeScrL][sizeScrH] == NOTHING)
            {
                position.x = x;
                position.y = y;
                map[sizeScrL][sizeScrH] = HUMAN;
                end = 1;
            }
            else
            {
                sizeScrL--;
                sizeScrH--;
            }
        }
 
        end = 0;
 
        sizeScrL = L_WINDOW;
        sizeScrH = H_WINDOW;
 
        SDL_FillRect(perso[people], NULL, SDL_MapRGB(screen->format, r, g, b));
        SDL_BlitSurface(perso[people], NULL, screen, &position);
 
        people--;
    }
 
    SDL_Flip(screen);
 
    return SUCCES;
}

life.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
#ifndef LIFE_H_
#define LIFE_H_
 
#include <SDL/SDL.h>
 
int createLife(SDL_Surface* screen);
 
#endif /* LIFE_H_ */

const.h

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
 
#ifndef CONST_H_
#define CONST_H_
 
    #define ERROR       -1
    #define SUCCES      0
    #define L_H_CASE    8
    #define L_WINDOW    640
    #define H_WINDOW    480
    #define LIFES       20
 
    enum {UP, DOWN, LEFT, WRITE};
    enum {NOTHING, HUMAN};
 
 
#endif /* CONST_H_ */

Merci pour tout et merci d'avance !

PS: Je crois que la gestion de collisions fonctionne mais si je prend une valeur trop grande pour : LIFES (c.f const.h), j'ai un core dumped. Avec une valeur comprise entre 1 et 35, je n'ai aucun carré qui se touche.

[_SamSoft_]

Je n'arrive toujours pas à ajouter la gestion de collisions et je ne comprend pas pourquoi mon code ne permet pas de gérer la collision (voilà une mise à jour de life.c, tout le reste (main.c, const.h) ... reste idem)

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
96
97
98
99
100
101
102
103
 
#include <stdio.h>
#include <stdlib.h>
#include "const.h"
#include "life.h"
 
struct pos
{
    int x;
    int y;
};
 
struct col
{
    int r;
    int g;
    int b;
};
 
struct life
{
    struct pos position;
    struct col color;
 
};
 
int createLife(SDL_Surface* screen)
{
    int x = 0, y = 0, l = 254, m = H_WINDOW, n = L_WINDOW;
    int r = 0, g = 0, b = 0, people = LIFES;
    int map[L_H_CASE][L_H_CASE];
    int sizeCase = L_H_CASE;
    int end = 0;
 
    while(sizeCase > 0)
    {
        map[sizeCase][sizeCase] = NOTHING;
        sizeCase--;
    }
 
    sizeCase = L_H_CASE;
 
    SDL_Surface *perso[LIFES] = {NULL};
    SDL_Rect position;
 
    position.x = 0;
    position.y = 0;
 
    struct life humans[LIFES];
 
    while(people > 0)
    {
        fprintf(stdout, "\nCreation de l'humain : %i\n", people);
 
        perso[people] = SDL_CreateRGBSurface(SDL_HWSURFACE, L_H_CASE, L_H_CASE, 32, 0, 0, 0, 0);
 
        r = rand() % (l+1);
        g = rand() % (l+1);
        b = rand() % (l+1);
 
        x = rand() % (m+1);
        y = rand() % (n+1);
 
        printf("\nX: %d, Y: %d\n", x, y);
 
        humans[people].position.x = x;
        humans[people].position.y = y;
 
        printf("\nAUTRE: X: %d, Y: %d\n", x, y);
 
        humans[people].color.r = r;
        humans[people].color.g = g;
        humans[people].color.b = b;
 
        while(sizeCase > 0 || end == 0)
        {
            if(map[sizeCase][sizeCase] == NOTHING)
            {
                position.x = x;
                position.y = y;
                map[sizeCase][sizeCase] = HUMAN;
                end = 1;
            }
            else
            {
                sizeCase--;
            }
        }
 
        end = 0;
 
        sizeCase = L_H_CASE;
 
        SDL_FillRect(perso[people], NULL, SDL_MapRGB(screen->format, r, g, b));
        SDL_BlitSurface(perso[people], NULL, screen, &position);
 
        people--;
    }
 
    SDL_Flip(screen);
 
    return SUCCES;
}

[Bibicy]

PS: Je crois que la gestion de collisions fonctionne mais si je prend une valeur trop grande pour : LIFES (c.f const.h), j'ai un core dumped. Avec une valeur comprise entre 1 et 35, je n'ai aucun carré qui se touche.

L'erreur "core dumped" c'est sans doute lié au problème de dépassement de tableau qui n'a pas été corrigé.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
int map[L_H_CASE][L_H_CASE];
int sizeCase = L_H_CASE;
    while(sizeCase > 0)
    {
        map[sizeCase][sizeCase] = NOTHING;
        sizeCase--;
    }

A priori tu cherche à créer un tableau 2D et à le remplir de "NOTHING". Mais cela ne marche pas (tu remplis que la diagonale et tu depasse des limites de ton tableau), faudrait plutôt faire un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
int map[L_H_CASE][L_H_CASE];
int i,j;
for(i=0;i<L_H_CASE;i++)
    for(j=0;j<L_H_CASE;j++)
    {
     map[i][j] = NOTHING;
     }

C'est juste un bout de code, mais globalement il y a d'autre erreurs dans le même genre à revoir.

[_SamSoft_]

Merci mais je viens de me rendre compte d'un truc super important. Vu que lors d'un contact entre deux entités, on a naissance d'une nouvelle entité, je viens de voir que la gestion de collisions ne permet pas cela. Ce qu'il me faut, c'est un gestion de superposition. Je m'explique :

Soit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
carre1.position.x = 10
carre1.position.y = 20
carre2.position.x = 10
carre2.position.y = 20
carre1.sex = 0; /* 0 = masculin */
carre2.sex = 1; /*1 = feminin */

Comme carre1 et au dessus ou juste en dessous de carre2 et carre1 et de sexe différent de carre2 alors appel de la fonction : createNewPerso.

Pour le moment, je ne vois pas comment gérer ceci sachant que je suis certain qu'il faut :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
struct life human[NOMBRES_CARRES] = {0};
int people = NOMBRES_CARRES;
boucle
/* Problème: je ne sais pas ce qui doit être dans la boucle */