Discussion :

[_SamSoft_]

Bonjour, avant tout, pour ceux qui se souviennent de moi (Projet "Life"), je voulais dire que Life v2 est sortie (voir ma signature). Je dis cela car j'avais des problèmes sur la gestion de collision et qu'ils ont été réglés par des membres de cette partie du forum. Merci à eux.

Aujourd'hui, je suis sur un nouveau projet que j'ai bientôt finit (il me reste l'éditeur de map et la gestion de collision qui est à revoir).

Voilà un code permettant de gérer la collision entre un robot et les autres robots de l'environnement :

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
 
int verification_of_position(robot **my_robot, int i, int nbr_of_robots)
{
    robot *temp = NULL;
    int i2 = 0;
    signed error = -1;
 
    if(*my_robot != NULL)
    {
        temp = *my_robot;
 
        for(i2 = 0 ; i2 < nbr_of_robots ; i2++)
        {
            if((temp+i)->position.x > (temp+i2)->position.x && (temp+i)->position.x < (temp+i2)->position.x+SIZE_OF_CASE)
            {
                error = 1;
                if((temp+i)->position.y > (temp+i2)->position.y && (temp+i)->position.y < (temp+i2)->position.y+SIZE_OF_CASE)
                {
                    error = 1; /* Collision possible */
                }
                else
                {
                    error = 0;
                }
            }
            else
            {
                error = 0; /* aucune collision */
            }
        }
 
    }
    else
    {
        fprintf(stderr, "[verification_of_position] : my_robot == NULL\n");
        exit(EXIT_FAILURE);
    }
 
    return error;
}

Le problème c'est que quand un robot i rencontre un robot i2 sur l'écran, il lui marche dessus -_-

Voilà un morceau de code (celui permettant de faire avancer un robot si sa position actuelle est UP, cela veut dire que le robot est tourné vers le haut) :

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
 
if((my_robot+i)->action_in_progress == MOVE_UP)
{
    if((my_robot+i)->position_in_progress == UP)
    {
        if((my_robot+i)->position.y-1 != WALL && (my_robot+i)->position.y-1 > 0 && (my_robot+i)->position.y-1 != ROBOT) /* S'il n'y a pas de murs */
        {
            if((my_robot+i)->step < SIZE_OF_CASE)
            {
                (my_robot+i)->position.y--;
                if(verification_of_position(&my_robot, i, nbr_of_robots) == 0)
                {
                    mapi[(my_robot+i)->position.x][(my_robot+i)->position.y] = BLANK;
                    (my_robot+i)->step++;
                    mapi[(my_robot+i)->position.x][(my_robot+i)->position.y] = ROBOT;
                }
                else
                {
                    (my_robot+i)->position.y++;
                    (my_robot+i)->action_in_progress = NOTHING;
                    (my_robot+i)->step = 0;
                }
            }
            else
            {
                (my_robot+i)->action_in_progress = NOTHING;
                (my_robot+i)->step = 0;
            }
        }
    }
}

Merci d'avance

Ps: Pourquoi step ? Et bien c'est pour rendre plus fluide le mouvement. Je veux dire, le faire avancer "CASE par CASE" est pas super joli alors j'utilise step et on dirait vraiment qu'il roule, c'est la classe à l'écran

AVIS AUX MODOS : Je me suis trompé de forum, mes excuses, je met ceci en délestage et je poste dans la catégorie : développement de jeux 2d et 3D

[fearyourself]

C'est parce que ton test de collision n'est pas complet.

De la bibliothèque SDL_Collision,

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
 
/*
	SDL bounding box collision test
*/
int SDL_CollideBoundingBox(SDL_Surface *sa , int ax , int ay ,
                             SDL_Surface *sb , int bx , int by)
{
	if(bx + sb->w < ax)	return 0;	//just checking if their
	if(bx > ax + sa->w)	return 0;	//bounding boxes even touch
 
	if(by + sb->h < ay)	return 0;
	if(by > ay + sa->h)	return 0;
 
	return 1;				//bounding boxes intersect
}

Jc

[_SamSoft_]

Merci mais j'ai préféré utilisé les tableaux (en 2d) c'est plus rapide et plus simple. Le résultat permet une diminution de l'effet réaliste que devait procurer le simulateur mais je gagne en lisibilité de code et rapidité. Mais sinon merci pour la fonction (qui sait, elle pourra me servir dans un autre simulateur)

Je teste et mon robot traverse tout (les autres robots et même le mur...)

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
 
void verification_of_position(robot **my_robot, int i, int map[NBR_OF_CASES][NBR_OF_CASES], int direction)
{
    robot *temp = NULL;
    int distance = 1, rslt = 1;
 
    if(*my_robot == NULL)
    {
        fprintf(stdout, "[verification_of_position]: *my_robot == NULL\n");
        exit(EXIT_FAILURE);
    }
 
    temp = *my_robot;
 
    if(direction == UP)
    {
        if((temp+i)->position.y - distance > 0 && map[(temp+i)->position.x][((temp+i)->position.y - distance)] == BLANK)
        {
            (temp+i)->position.y--;
            rslt = 0;
        }
    }
    else if(direction == DOWN)
    {
        if((temp+i)->position.y + distance < NBR_OF_CASES && map[(temp+i)->position.x][((temp+i)->position.y + distance)] == BLANK)
        {
            (temp+i)->position.y++;
            rslt = 0;
        }
    }
    else if(direction == RIGHT)
    {
        if((temp+i)->position.x + distance < NBR_OF_CASES && map[((temp+i)->position.x+distance)][(temp+i)->position.y] == BLANK)
        {
            (temp+i)->position.x++;
            rslt = 0;
        }
    }
    else if(direction == LEFT)
    {
        if((temp+i)->position.x - distance > 0 && map[((temp+i)->position.x-distance)][(temp+i)->position.y] == BLANK)
        {
            (temp+i)->position.x--;
            rslt = 0;
        }
    }
 
    if(rslt == 0)
    {
        map[(temp+i)->position.x][(temp+i)->position.y] = BLANK;
    }
}

Voilà l'initialision de mon tableau :

Code :

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

1
2
3
4
5
6
7
8
 
    for(i = 0 ; i < NBR_OF_CASES ; i++)
    {
        for(j = 0 ; j < NBR_OF_CASES ; j++)
        {
            mapi[i][j] = BLANK;
        }
    }

Voilà 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
17
18
19
 
#ifndef CONST_H_
#define CONST_H_
 
#define SIZE_OF_CASE    23 /* en pixels */
#define NBR_OF_CASES    25
#define L_WINDOW        SIZE_OF_CASE*NBR_OF_CASES
#define H_WINDOW        SIZE_OF_CASE*NBR_OF_CASES
 
#define ENERGY          1000
#define TRUE            0
 
enum {BLANK, WALL, FLAG, ROBOT, MOON};
 
enum {NOTHING, START, STOP, MOVE_UP, MOVE_DOWN, TURN_RIGHT, TURN_LEFT, TURN_ON, TURN_OFF};
enum {UP, DOWN, LEFT, RIGHT};
enum {MAVIN, MAVIN2, PROTON, QUICKER, TANK, TANK2};
 
#endif /* CONST_H_ */

Voici comment je gère tout ca :

Le programme lit le fichier contenant la map, chaque ligne est de type :

x>>y>>type

Avec x la position de l'objet (BLANK ou WALL ...)
y idem
type si cet objet est bloquant ou pas. WALL est un objet bloquant (un mur quoi).

Un robot est un objet bloquant. Merci d'avance

[_SamSoft_]

J'ai résolu mon problème. Au lieu de dire qu'en position x, y de la carte il y avait un robot, j'ai dit qu'il y avait rien -_-

Je poste le code :

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
 
void verification_of_position(robot **my_robot, int i, int map[NBR_OF_CASES][NBR_OF_CASES], int direction)
{
    robot *temp = NULL;
    int distance = 1, rslt = 1;
 
    if(*my_robot == NULL)
    {
        fprintf(stdout, "[verification_of_position]: *my_robot == NULL\n");
        exit(EXIT_FAILURE);
    }
 
    temp = *my_robot;
 
    if(direction == UP)
    {
        if((temp+i)->position.y - distance > 0 && map[(temp+i)->position.x][((temp+i)->position.y - distance)] == BLANK)
        {
            map[(temp+i)->position.x][(temp+i)->position.y] = BLANK;
            (temp+i)->position.y--;
            rslt = 0;
        }
    }
    else if(direction == DOWN)
    {
        if((temp+i)->position.y + distance < NBR_OF_CASES && map[(temp+i)->position.x][((temp+i)->position.y + distance)] == BLANK)
        {
            map[(temp+i)->position.x][(temp+i)->position.y] = BLANK;
            (temp+i)->position.y++;
            rslt = 0;
        }
    }
    else if(direction == RIGHT)
    {
        if((temp+i)->position.x + distance < NBR_OF_CASES && map[((temp+i)->position.x+distance)][(temp+i)->position.y] == BLANK)
        {
            map[(temp+i)->position.x][(temp+i)->position.y] = BLANK;
            (temp+i)->position.x++;
            rslt = 0;
        }
    }
    else if(direction == LEFT)
    {
        if((temp+i)->position.x - distance > 0 && map[((temp+i)->position.x-distance)][(temp+i)->position.y] == BLANK)
        {
            map[(temp+i)->position.x][(temp+i)->position.y] = BLANK;
            (temp+i)->position.x--;
            rslt = 0;
        }
    }
 
    if(rslt == 0)
    {
        map[(temp+i)->position.x][(temp+i)->position.y] = ROBOT;
    }
}