Discussion :

[Kropernic]

Hello,

Je me suis mis en tête de réaliser un bejeweled like à mes heures perdues.

J'ai déjà fait un prototype tout à fait fonctionnel mais ... en winforms .

Du coup, pas d'animations évidemment.

Ayant découvert l'existence de XNA il y a 2 jours, je m'y suis mis. J'ai suivi un tuto d'un pong et ça marche plutôt pas mal.
Je passe donc maintenant à au portage de mon projet winforms --> xna.

Déjà, la première question que je me pose est de savoir si on peut ajouter un projet de type bibliothèque de classe à une solution xna. Car les différents niveaux sont stockés en BDD et faut bien aller les chercher. Alors je pensais utiliser la couche DAL que j'ai utilisé pour le projet winforms. Est-ce ok ou bien faut-il aussi tout recoder dans un projet de type Game Library ??

J'aurai probablement d'autres questions au fil du développement et j'utiliserai cette discussion afin de les centraliser (d'où le titre assez vague).

Merci d'avance à ceux qui prendront du temps pour répondre à mes questions.

++

[Kropernic]

Dans mon prototype winforms, sur le haut de la fenêtre, j'avais un contrôle de type NumericUpDown et un Button histoire d'indiquer le numéro de niveau à charger.

Ici à priori, pas moyen... Ou alors faut dessiner la boite de saisie à la main ainsi que le p'tit curseur qui clignote pour indiquer à l'utilisateur qu'il peut écrire quelque chose. C'est correct où j'ai pas compris ça comme il fallait ?

(je continue en supposant que j'suis dans le bon)
Du coup, j'imagine qu'il va me falloir un "premier" écran où, via les flèches haut/bas, l'utilisateur va pouvoir choisir le niveau et valider avec la touche Enter. Une fois le niveau choisi, je peux passer à son affichage et à l'écran du jeu proprement dit.

J'suis toujours dans le bon là ?

Si oui, j'arrive alors à ma question...

Actuellement, dans le main du programme on a ceci :

Code :

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

1
2
3
4
5
6
7
        static void Main(string[] args)
        {
            using (Bejeweled game = new Bejeweled())
            {
                game.Run();
            }
        }

Est-ce correct si je crée une 2e classe qui hérite de Microsoft.Xna.Framework.Game et que, dans l'une j'affiche le jeu proprement dit et dans l'autre, le choix du niveau ?
Le using de la méthode Main utiliserait alors un objet de type LoadingScreen (classe custom à créer) qui, lors de l'appui sur Enter (et après les vérification d'usage) créerait une instance de Bejeweled et exécuterait la méthode Run.

Et pour passer au niveau suivant ??? Le type qui réussi à enchaîner les niveaux, ça va être moche niveau conso mémoire si un niveau lance le suivant... Une astuce ??

EDIT : J'ai donc créé un écran de choix de niveau qui fonctionne nickel (ça vous épate hein ) et lorsque je fais

Code :

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

1
2
3
4
5
6
7
            if (_keyboardState.IsKeyDown(Keys.Enter) && !_oldKeyboardState.IsKeyDown(Keys.Enter))
            {
                using (Bejeweled game = new Bejeweled())
                {
                    game.Run();
                }
            }

ça gueule en me disant que démarrer une deuxième boucle dans le même thread, ce n'est pas bien. VS me dit d'utiliser ShowDialog à la place .


EDIT 2 : J'ai trouvé mon bonheur ici.

[LittleWhite]

Bonjour,

On ne peut faire qu'un seul et unique Game.Run. Par contre, vous pouvez gérer différents écrans (menu, jeu) dans le système de base avec une machine à état (un enum qui indique quel écran afficher).
De plus, la connexion à la BDD c'est possible, mais je ne suis pas sur du comment. XNA étant fait pour développer sur XBox, tout n'est pas présent.
On peut aussi intégrer du .NET ou similaire, mais bon, vous êtes sensé faire un jeu vidéo, donc je vous conseille de réfléchir en "jeux vidéo" et non plus en WinForms :p

[Kropernic]

Hello LittleWhite,

Je t'attendais ^^.

Pour l'enum, ça j'ai trouvé dans le lien que j'indique dans mon message précédent. Ca marche bien. J'dois juste encore regarder pour bien structurer le code histoire de pas avoir des fonctions draw/update de 2000 lignes.

Pour le fait de penser en jeux video et non plus en winforms, j'essaie mais je n'ai jamais fait que ça (ou assimilé).

Par contre, même dans le jeu, tout n'est pas livré avec l'exe et autres ressources qui l'accompagnent. Il faut donc bien aller chercher l'info quelque part. Comment faut-il faire alors ?

Est-ce que cela passe d'office par du client/serveur avec le client qui fait la demande au serveur, le serveur va chercher dans la DB et remballe l'info vers le client ? J'imagine que cela doit fonctionner pas mal et surtout décharger le client pour sauvegarder les performances mais bon, honnêtement, je ne vais pas m'encombrer avec ça pour mon brol de bejeweled like XD.

Sinon, pour le moment, j'en suis à l'initialisation d'une grille de 10*10 cases de 50*50 pixels. J'arrive bien à avoir mes images dans chaque cases mais on dirait qu'il en met plusieurs... Par contre, si je clique dessus (alors que le clic n'est pas du tout géré pour le moment*), celles en arrière-plan disparaissent et il n'en reste plus qu'une... Ca je ne comprends pas pour le moment (je mettrai le code sous peu).

*En fait, ce n'était pas géré au moment où j'ai remarqué cela. Entre temps, j'essaie de faire apparaître la case sur laquelle le joueur à cliquer comme sélectionnée mais j'ai un problème de chargement de Texture2D.

[Kropernic]

Hello,

En pièce jointe, voici mon projet en l'état.

J'ai toujours ce souci d'initialisation où il m'affiche plusieurs images superposées...

[LittleWhite]

Pour les ressources, on va partir du plus simple (toujours commencé par petit ).
Pour "moi", les ressources, ce sont :

• les sprites ;
• les modèles (3D) ;
• les sons (et musiques) ;
• les fontes/polices
• au pire, les sauvegardes, même si on va les appeler les sauvegardes.

Ces données, sont, de base, livrées avec l'exécutable. Pour faire simple, on a un dossier data, avec tout ce qu'il faut pour le jeu.

Ensuite, on peut faire un peu plus dynamique. On récupère les ressources au premier lancement, on les sauvegardent et on les charge normalement.
Mais généralement, tout est "à coté de l'exécutable".
Pour les scores, alors oui, on peut faire une connexion HTTP sur un site web pour upload et partager des scores. On peut faire des connexions à ce que l'on veut, en soit (Facebook, un site perso). Pour cela, une pratique courante est d'utiliser CURL.

Voilà, je pense que j'ai résumé et j'espère ne rien avoir oublié.

[Kropernic]

Hello,

Merci pour ces précisions.

Donc, ça veut dire que si mon jeu contient 5 niveaux, il falloir que je crée des fichiers de ressources qui devront décrire précisément chaque niveau. Avec 5, ça va. S'il y en a 2000, je trouve tout de suite que ça déconne un peu.

On pourrait envisager de tous les regrouper dans un seul fichier (facile si le format utiliser pour stocker l'info est xml par exemple) mais est-ce une bonne idée ?

Qu'est-ce qui est le plus pénalisant pour les performances, devoir chercher dans 2000 fichiers après le bon pour l'ouvrir et avoir rapidement accès à l'info ou ouvrir un seul gros fichier et devoir chercher dans les 2000 "records" qu'il contient après celui qui est utile ?

Personne n'aurait l'adresse d'un bon tuto de niveau advanced ??

Sur ce, je m'en vais regarder sur DVP s'il y a un tuto XNA ^^.

[LittleWhite]

Pour créer les niveaux, on développe un éditeur ... ou un script
Pour la recherche, 2000 fichiers ça ne gêne pas. Car il n'y a pas de recherche. Vous dites juste : je charge le fichier : "./fichier" + niveau_actuel +.txt" et bam, vous l'avez direct.
Un tuto XNA, nous avons pas grand chose. Et pour les tutoriels de jeux (généraliste) on devrait en avoir et en avoir plus.

[Kropernic]

Ah bin oui, c'est le LoadContent avec directement le nom de l'Asset. Donc forcément, on ne cherche pas ^^.

Pour les tutos, effectivement, c'est le néant côté XNA mais y en a pas mal si on en sort. Vu que j'ai pas trop le temps d'apprendre un autre langage pour le moment, je vais rester avec ça.

Sinon, d'après ce tuto, si un jour j'ai du temps, je me mettrai au python...

[Kropernic]

J'ai trouvé la solution à mon problème de sprite superposés. Suffisait de commenter le code de la méthode Draw dans la classe Sprite.

Au fait, pourquoi cela s'appelle un Sprite ???

[Kropernic]

Hello,

Je bute à présent sur comment intervertir 2 images de cases adjacentes.

Pas de souci pour sélectionner une case et détecter que le joueur clique ensuite sur une case adjacente. Ca, ça marche nickel.

Le problème se situe au niveau du déplacement en lui-même.

J'ai produit le code suivant :

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
        void SwapCandy(GameTime gameTime)
        {
            if (Math.Abs(_previousCandy.Col - _currentCandy.Col)==1)
            {
                //déplacement horizontal
 
            }
            else
            {
                //déplacement vertical 
                if (_currentCandy.Row < _previousCandy.Row)
                {
                    _currentCandy.Direction = Vector2.UnitY;
                    _previousCandy.Direction = -Vector2.UnitY;
                }
                else
                {
                    _currentCandy.Direction = -Vector2.UnitY;
                    _previousCandy.Direction = Vector2.UnitY;
                }
                _currentCandy.Update(gameTime);
                _previousCandy.Update(gameTime);
            }
        }

Et, en l'état, je m'attendais à voir la première image partir vers le bas et l'autre vers le haut (ou inversement) sans jamais s'arrêter vu que je remet pas encore leur Direction sur Vector2.Zero.
Or, si les deux images se déplacent bien, on dirait qu'elles ne le font que pour 1 tick.

Je ne comprends pas du tout pourquoi. Il doit y avoir un bout de logique sous-jacente que je n'ai pas encore assimilée...

Help please .

[LittleWhite]

Le problème des animations, c'est toujours un problème "compliqué".
En effet, une animation, c'est une action qui s'effectue sur plusieurs images. Du coup, il faut trouver un moyen, pour que le mouvement soit interprété par le programme.
La meilleure solution (pas la plus simple) que j'ai en tête est de faire une pile d'animation qui seront mis à jour à chaque tour de boucle (boucle de jeu).
Dans SwapBlocks(), vous allez dire : j'ajoute une animation de ce bloc, pour l'emmener à cette position en tant de temps.
Ainsi, c'est votre super fonction de traitement des animations (et donc de la pile) qui va faire le déplacement comme il le faut (interpolation linéaire) et lorsque le bloc atteint sa destination, hop, l'animation est supprimée de la pile.

[Kropernic]

Hello,

Finalement, je suis parvenu à une solution le temps de mon trajet en train. Mais je te demanderai sûrement de plus amples explications sur ce que tu viens de dire quand je devrai afficher une animation qui ne consiste pas en le déplacement d'images déjà présentes.

Voici ma solution :

La fonction Swap :

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
        void SwapCandy(GameTime gameTime, Candy candy1, Candy candy2)
        {
            if (Math.Abs(candy1.Col - candy2.Col)==1)
            {
                //déplacement horizontal
                if (candy2.Col < candy1.Col)
                {
                    candy2.Direction = Vector2.UnitX;
                    candy2.Col++;
                    candy1.Direction = -Vector2.UnitX;
                    candy1.Col--;
                }
                else
                {
                    candy2.Direction = -Vector2.UnitX;
                    candy2.Col--;
                    candy1.Direction = Vector2.UnitX;
                    candy1.Col++;
                }
            }
            else
            {
                //déplacement vertical 
                if (candy2.Row < candy1.Row)
                {
                    candy2.Direction = Vector2.UnitY;
                    candy2.Row++;
                    candy1.Direction = -Vector2.UnitY;
                    candy1.Row--;
                }
                else
                {
                    candy2.Direction = -Vector2.UnitY;
                    candy2.Row--;
                    candy1.Direction = Vector2.UnitY;
                    candy1.Row++;
                }
            }
            _candies[candy1.Row, candy1.Col] = candy1;
            _candies[candy2.Row, candy2.Col] = candy2;
 
 
            candy1.IsMoving = true;
            candy2.IsMoving = true;
        }

Et dans la classe Candy :

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
        public override void Update(GameTime gameTime)
        {
            if (IsMoving)
            {
                if (Direction == Vector2.UnitX)
                {
                    if (Position.X < 50 * Col)
                    {
                        Speed = 0.2f;
                    }
                    else
                    {
                        Speed = 0f;
                        Position = new Vector2(50 * Col, 50 * Row);
                        IsMoving = false;
                    }
                }
                else if (Direction == -Vector2.UnitX)
                {
                    if (Position.X > 50 * Col)
                    {
                        Speed = 0.2f;
                    }
                    else
                    {
                        Speed = 0f;
                        Position = new Vector2(50 * Col, 50 * Row);
                        IsMoving = false;
                    }
                }
                else if (Direction == Vector2.UnitY)
                {
                    if (Position.Y < 50 * Row)
                    {
                        Speed = 0.2f;
                    }
                    else
                    {
                        Speed = 0f;
                        Position = new Vector2(50 * Col, 50 * Row);
                        IsMoving = false;
                    }
                }
                else if (Direction == -Vector2.UnitY)
                {
                    if (Position.Y > 50 * Row)
                    {
                        Speed = 0.2f;
                    }
                    else
                    {
                        Speed = 0f;
                        Position = new Vector2(50 * Col, 50 * Row);
                        IsMoving = false;
                    }
                }
            }
            base.Update(gameTime);
        }
    }

N.B. : Une idée pour factoriser ces if à répétition?

Et ça marche nickel

Je m'attaque maintenant à la détection des patterns et la suppression des blocs qui y participent. Ceux du dessus devront alors tomber dans l'espace laisser libre. Ca va être rigolo à faire ^^.

[Kropernic]

Hello,

A propos des niveaux dont il va falloir stocker la définition dans un fichier de ressources, quel format de fichier est utilisé habituellement dans les jeux vidéos ?

Si je devais utiliser mon expérience en informatique de gestion, j'utiliserais un fichier xml. Mais il y a p-e d'autre format plus adapté.

Qu'utilisent les "vrais" dev de jv en général ?

[Kannagi]

Il n'y a pas de format adapté a des besoins spécifique , le XML c'est suffisantje pense , après ça dépend des époques mais l'utilisation des fichiers data en binaire est utilisé (enfin ça a l'avantage de ne pas créer un parser , et c'est plus rapide a lire qu'un fichier en ASCII).

[Kropernic]

Il n'y a pas de format adapté a des besoins spécifique , le XML c'est suffisantje pense , après ça dépend des époques mais l'utilisation des fichiers data en binaire est utilisé (enfin ça a l'avantage de ne pas créer un parser , et c'est plus rapide a lire qu'un fichier en ASCII).

Fichiers data en binaire... Un peu comme les fichiers typés en delphi à l'époque ??

Si c'est ça, j'adorais ces fichiers ! C'était tellement pratique !

Suffisait de définir une structure et dire que le fichier était composé d'objets du type de cette structure. Du coup, quand on lisait, on avait directement l'objet complet.

Si mes souvenirs sont bon, mon prof appelait ça un fichier à accès relatif (par opposition aux fichiers à accès séquentiel (les fichiers textes quoi)).

J'ignorais qu'il était encore possible de créer ce genre de fichier en .NET .

Je vais creuser la question !!

EDIT : juste pour info et pour les curieux, voici ce dont je parle en delphi. (par contre, on dirait que mes souvenirs ne sont plus de première fraicheur ^^)