Discussion :

[shirohige]

Bonjour,
Je voudrais connaître la technique (si il y en a une spécifique) pour réaliser un shoot'em up. C'est à dire gérer les vagues d’ennemis.
Mon idée serai de faire une liste de liste de vaisseau d'ennemi et a un certain intervalle de temps ou lorsque une vague d'ennemis est morte je balance la suivante. Merci pour votre aide.

[Kannagi]

Je pense pas que il y a une technique spécifique , mais pour ma part les vaisseau ennemi ont une position (genre un vaisseau et a 100).
Ben vu qu'un shmup a un défilement je faisait que quand j'avais atteint 100 le vaisseau apparaissait., et du coup tu fait tou ton niveau comme cela , avec chaque ennemi son comportement

[shirohige]

J'ai pas tout compris, 100 c'est une position en abscisse ou c'est une file d'attente et c'est le numéro du vaisseau ?
Moi à la base je ne voulais pas réellement faire de défilement, le défilement serait visuel avec une image en fond qui défile mais mon vaisseau lui reste static, il avance pas tous seul, il n'a pas de vitesse. Pour moi le défilement était juste une illusion.
Sinon au lieu de faire un vrai défilement, je pourrais faire un timer. Les vaisseau aurait une sorte de planning.

[MoDDiB]

Il y a plusieurs type de conditions pour faire apparaître les ennemis ; le temps, la destruction d'un groupe, le passage à un endroit précis...

Le mieux c'est de mettre en place une sorte de séquenceur et l'éditeur qui va avec afin de manipuler tout ça facilement.
Tu peux t'inspirer de la manière dont sont gérés les tirs de la librairie bulletML
( http://www.asahi-net.or.jp/~cs8k-cyu..._applet_e.html )

Ça c'est la manière propre, mais tout faire en code est aussi possible et bien plus facile dans un premier temps.

[Kannagi]

Oui excuse moi 100 est un position en abscisse ou en ordonné (ça dépend de ton scrolling en faite) , je parle plutôt d'un défilement virtuel , pas du fond (qui est souvent un défilement en boucle).

Pour ma part j'utilise pas le timer parce que je trouve qu'il y a qql defauts utiliser cette technique.
1)il ne prend pas en compte le fps
2) plus 'dur' a mettre en place et a contrôler (il faudra mettre en pause le timer si en fait un pause , ou imaginons qu'il y est un miniboss donc les autres doivent attendre le 'planning).
Un défilement virtuel c'est juste un if , et si on doit arrête ce défilement on arrête incrémentation.
3) plus difficile de faire un niveau en utilisant un temps que des coordonné (donc plus facile de faire un éditeur qu'on peut voir visuellement).

[shirohige]

Bonjour,
J'essaye de gérer les collision avec les bords de ma fenêtre.
Voici la fonction qui me dit si je sort ou pas:

Code :

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

1
2
3
4
5
6
7
8
9
 
private bool Col_border(float x, float y)
        {
            if (x < 0 || y < 0)
                return (true);
            if ((x + _texture.Width) > Width || (y + _texture.Height) > Height)
                return (true);
            return (false);
        }

Rien de compliqué. Si c'est dans un mur ça me renvoie true sinon false.
Le problème c'est que si ça rentre dans un mur la fonction renvoie false et mon petit bonhomme s’arrête de bouger, et il y a également un espace entre le bonhomme et la bordure, normal.
Dans ma fonction qui gère le déplacement et qui appel cette fonction,
j'ai essayais de gérer ce problème dans le else:

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
 
private void Move_ship(Vector2 posJ, Vector2 posS)
        {
            Vector2 direct = new Vector2();
 
            direct.X = posJ.X - posS.X;
            direct.Y = posJ.Y - posS.Y;
            _direction = direct / speed_move;
            if (Col_border(_direction.X + _position.X, _direction.Y + _position.Y) == false)
                _position += _direction;
            else
            {
                int sgn = 1;
                Vector2 sav = _direction;
                if (sav.X < 0)
                    sgn = -1;
                sav.X *= sgn;
                while (sav.X > 0 && (Col_border(sav.X*sgn, 0) == true))
                {
                    sav.X--;
                }
                _direction.X = sav.X * sgn;
                sgn = 1;
                if (sav.Y < 0)
                    sgn = -1;
                sav.Y *= sgn;
                while (sav.Y > 0 && (Col_border(0, sav.Y*sgn) == true))
                {
                    sav.Y--;
                }
                _direction.Y = sav.Y * sgn;
                _position += _direction;
            }
            pad[0].Position = posJ;
        }

le premier if c'est si le bonhomme peut se déplacer sans risque et le deuxième c'est pour coller le bonhomme au mur en diminuant le vecteur directeur en x puis en y.
Voici ma façon de procéder:
-Je récupère dans une variable sgn le signe négatif ou positif de ma variable de déplacement x ou y.
-Je multiplie ma variable de déplacement par sgn pour le mettre en positif.
-Je boucle tant que le vecteur directeur est trop grand.
-Je remet ma variable à sa valeur initiale si elle étant négatif.

Lorsque je suis coller au mur il se passe de chose:
-Le bonhomme "sautille" contre la bordure.
-A partir du moment où mon x ou y du vecteur directeur est négatif, il reste sur place, j'ai même l'impression qu'il se déplace positivement (très légèrement), en continuant à sautiller.

Si vous avez la solution ou une meilleur idée de gérer les collision.
Merci.

Edit:
Code plus logique mais qui ne marche toujours pas:

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
 
private void Move_ship(Vector2 posJ, Vector2 posS)
        {
            Vector2 direct = new Vector2();
 
            direct.X = posJ.X - posS.X;
            direct.Y = posJ.Y - posS.Y;
            _direction = direct / speed_move;
            if (Col_border(_direction.X + _position.X, _direction.Y + _position.Y) == false)
                _position += _direction;
            else
            {
                int sgn = 1;
                Vector2 sav = _direction;
                if (sav.X < 0)
                    sgn = -1;
                sav.X *= sgn;
                while (sav.X > 1 && (Col_border(_position.X+(sav.X*sgn), _position.Y) == true))
                {
                    sav.X--;
                }
                _direction.X = sav.X * sgn;
                sgn = 1;
                if (sav.Y < 0)
                    sgn = -1;
                sav.Y *= sgn;
                while (sav.Y > 1 && (Col_border(_position.X, _position.Y+(sav.Y*sgn)) == true))
                {
                    sav.Y--;
                }
                _direction.Y = sav.Y * sgn;
                _position += _direction;
            }
            pad[0].Position = posJ;
        }

Maintenant mon perso rentre en mode sable mouvant quant il touche le bord.

[Kannagi]

Un peu étrange de gérer les collisions de cette manière , je dirais que c'est pas la bonne méthode.
Niveau 2D y'a 3 façon de gérer les collisions :
-soit par case (les vieux rpg 2D ,trpg) , pokémon est un exemple.
-soit par un vecteur vitesse plus dans les jeux comme mario et autre jeu de plateforme/action.
-soit une collision simple sans vecteur comme le shoot them up et d'autre jeux basic (pong ect).

Donc pourquoi pas faire un systeme de collision simple , genre :

Code :

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

1
2
3
4
5
6
 
if(position_vaisseau.x < 0) position_vaisseau.x = 0;
if(position_vaisseau.y < 0) position_vaisseau.y = 0;
 
if(position_vaisseau.x > Width) position_vaisseau.x = Width;
if(position_vaisseau.y > Height) position_vaisseau.y = Height;

[shirohige]

xD oui c'est vrai que c'est mieux comme ça. J'avais lu un tuto sur le tile mapping et pour gérer les collision avec différent bloc il faisait de cette manière. Mais dans ce cas là je vais prendre ta méthode.
Tu a parler de 3 méthode:
-soit par case (les vieux rpg 2D ,trpg) , pokémon est un exemple.
C'est par exemple faire un quadrillage et regarder la case sur laquelle on va, si elle est accessible ou non ?
-soit par un vecteur vitesse plus dans les jeux comme mario et autre jeu de plateforme/action. C'est la méthode que je voulais faire ?
-soit une collision simple sans vecteur comme le shoot them up et d'autre jeux basic (pong ect). Je ne sais pas se que c'est. Ce que tu m'a dit ?

Ps: Ta méthode marche très bien merci.

[Guntha]

Bonjour,

Pour la 3ème méthode, je pense qu'il s'agit de savoir si 2 objets se chevauchent pendant 1 frame (collision entre 2 cercles, entre 2 rectangles...).

Personnellement, quand je faisais un shoot'em up, j'utilisais la méthode avec des vecteurs (plus précisément, j'utilisais un segment composé du point de la frame précédente et du point de la frame actuelle). Ça me permettait de faire par exemple des tirs qui traversent l'écran en 1 frame tout en étant sûr qu'ils ne risquent pas de passer à travers les ennemis. Et pour les bords de l'écran, je faisais comme Kannagi.

Pour ce qui est de l'apparition des ennemis, j'avais un fichier texte qui décrivait à partir de quand chaque ennemi apparaissait (par exemple, 2 secondes après le lancement du niveau, tel ennemi apparaît.) Chaque ennemi avait une courbe composée de plusieurs points pour son déplacement, et sa vitesse de déplacement était aussi gérée par le temps (genre, à partir du moment de ton apparition, entre 0 et 2 secondes, tu passes de 0 pixels/seconde à 100 pixels/seconde). C'était pas le plus élégant des systèmes mais ça marchait.

[Kannagi]

-soit par case (les vieux rpg 2D ,trpg) , pokémon est un exemple.
C'est par exemple faire un quadrillage et regarder la case sur laquelle on va, si elle est accessible ou non ?

C'est ça c'est par quadrillage et en regarde si la case est accessible ou pas,c'est une méthode facile a mettre en place et très peu gourmande en CPU (pour cela surement que elle était utilisait sur snes/game boy moins utilisé de nos jours) ,j'avais vu même ce système sur un rpg 3D sur saturn
Par contre les tileset est toujours utilisé.

-soit par un vecteur vitesse plus dans les jeux comme mario et autre jeu de plateforme/action. C'est la méthode que je voulais faire ?

Euh non , ça ressemble pas a un système de vecteur vitesse , le but c'est de faire un vecteur et de lui donné une valeur et par rapport au collision de changer cette valeur.

-soit une collision simple sans vecteur comme le shoot them up et d'autre jeux basic (pong ect). Je ne sais pas se que c'est. Ce que tu m'a dit ?

C'est ça la méthode que je t'ai dit.


Par contre je confirme ce que dis Guntha très bon conseil , j'avais fait pareil que lui a peu prés , pour le vecteur vitesse du vaisseau et le bord de écran comme je l'ai dit auparavant , j'avais fait un fichier texte aussi pour décrire le comportement des ennemis.

Je finirai par dire que utilisai les vecteur vitesse et la plus efficace et compose la plupart des jeux , je utilise aussi pour mes jeux 3D (sauf que les formes géométriques en 3D sont plus complexe en 3D que en 2D).

[shirohige]

Je voudrais savoir comment gérer le scrolling. Voila, je n'ai pas vraiment d'idée simple et efficace.
Merci.

[Kannagi]

Je me demande si c'est une bonne idée de t'aider a chaque fois ,je m'explique de mon point de vue ton souci c'est pas la programmation vu que tu sais codé mais tu as un souci algorithmique et algo ne s'apprend pas avec un tuto mais en s'entrainant , j'avais vu sur le forum une bonne explication http://www.developpez.net/forums/d1260669/c-cpp/cpp/creer-shoot-em-up/#post6901956.
Je soulignerai ceci :

Entre ces deux moment, il y a une série d'étapes qui doivent être franchies, comme:

l'analyse fonctionnelle : le fait d'exprimer clairement ce que l'on veut
l'analyse technique : le fait de déterminer l'ensemble des fonctions, des structures et des classes qui nous permettront d'obtenir ce que l'on veut
La création éventuelle d'algorithme : le fait de trouver la logique "la moins mauvaise" permettant de nous assurer que, partant d'une situation A, nous arriverons bel et bien à une situation B correcte

Ce n'est qu'après que l'on peut envisager "sereinement" d'écrire le code qui correspondra aux algorithmes et aux structures de données que l'on a décidé d'utiliser

En général j'ai répondu des question a des méthode simple , c'est méthode sont facile a trouvé si on prend le temps de dessiner ,de faire des schéma ect , perso ça m'arrive de le faire quand j'arrive pas a le visualiser mentalement.

Pour répondre a ta question un scrolling c'est une simple dés-incrémentation du genre :

Code :

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

1
2
3
4
 
map.x--;
//ou si ou veut une vitesse particulière
map.x -= 2; //2 ou un autre chiffre

Pour un scrolling infini faut juste afficher 2 fois le même fond et les faire 'tourner'.
Un scrolling de stage tu peux juste mettre les différent scrolling tu peut les mettre bout a bout d'ailleurs on peut mélanger ces deux méthode afficher plusieurs fois le même scrolling avant de passer a un suivant.

[shirohige]

Merci tout d'abord.
Le problème c'est que je n'ai pas envie de commencer un algo tout pourri et me rendre compte qu'il y a beaucoup plus efficace, comme avec la collision des bords par exemple.
Merci pour la méthode, j'avais pensé à un truc du genre mais je me demandais comment redimensionner l'image. Si par exemple la taille de la fenêtre fait 500 par 500 et que mon image aussi. Si le joueur décide de mettre la fenêtre à 1000x1000 mon image ne rempliras pas toute la fenêtre. Même si j'ai la possibilité de mettre l'image en fond d'écran et par ce fait ça redimensionne automatiquement, le scrolling risque d'être difficile. Je ne pense pas pouvoir dire, tu met mon image-xpixel en fond d'écran. Je vais regarder si il y a moyen de faire un truc comme ça tout de même. Je fait mon jeux sur windows phone donc la résolution d'écran n'est pas la même pour tous donc la question du redimensionnement m'a été et m'est importante.
Merci encore pour ta réponse.

[Kannagi]

Je comprend que tu ne veuille pas commencé un algo "tout pourri" mais faut bien passé par la

Pour le redimensionnement ce n'est pas un problème , en fait tu dois bosser avec une résolution de base genre 500x500 , après si la fenêtre est différente que ton rendu , alors tu dois juste redimensionner le rendu final.