Bonsoir.

Dans le cadre d'un projet personnel, j'ai décidé de créer la table des types en C#. Voici un extrait ce que j'ai fait afin d'exposer plus amplement mon problème par la suite :

List<string> AttTyp = new List<string>(); // Liste qui concerne le type de l'attaque lancée par un Pokémon
        List<string> LiTyp1 = new List<string>(); // Liste qui concerne le premier type du Pokémon touché.
        List<string> LiTyp2 = new List<string>(); // Liste qui concerne le deuxième type du Pokémon touché.

Ici se trouvent les listes pour avoir ci-dessous les images correspondant au type lorsque je vais cliquer dessus

private void cboTypeAttaque_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            //Afficher l'image correspondant au type de l'attaque lancée par un Pokémon
            var uri = new Uri(Environment.CurrentDirectory + AttTyp[cboTypeAttaque.SelectedIndex]);
            ImgTypeAttaque.Source = new BitmapImage(uri);
        }

Maintenant pour le problème : je compte mettre les affinités de types sans passer dans un océan de 'if else' (exemple le type plante est fort contre les types eau, roche et sol mais peu efficace contre les types feu, acier, insecte, poison, vol et dragon), super laborieux. Que me conseillerez-vous de faire ?

Merci d'avance.

Désolé, je ne connais pas les Pokémon, donc les mécanismes d'affinités.

Mais, en générale, l'usage des bonnes structures de données adaptées au problème réduit énormément la quantité et le complexité du code.

Mais mon ignorance ne permet pas de vous guider "définitivement" vers les bonnes structures de données.

Mais "List<String>", c'est vraiment très réduit en terme possibilités.

Par exemple, si vous avez une classe "AttackType" avec une instance par type d'attaque (donc pensez à planquer le constructeur d'instance et à avoir un constructeur statique qui chargera tout le bestiaire d'attaques à partir d'un fichier), accessibles, par exemple, via une map style "Dictionary<String,AttackType>" en Singleton. La clé (String) sera le nom de l'attaque (en espérant qu'il est unique) et la valeur, l'instance d'AttackType.

Vous créez aussi une classe "PokemonType" avec une instance par type de Pokémon (Acier, Feu, etc..., si j'ai bien compris). Même astuce que pour "AttackType" pour avoir un nombre limité et déjà configuré d'instances de ce type et facilement accessible via un Repository (Singleton + Map).

Si j'ai bien compris, une attaque est associée à un type de Pokémon, il faudra donc un champ dans la classe "AttackType" indiquant le type "PokemonType" qui lui est associé. On créera donc le repository des "PokemonType" avant le repository des "AttackType".

Si chaque type de Pokemon est associé une liste d'autres types de Pokémon sur lequel il est "efficace" et une liste d'autres types de Pokémon sur lequel il n'est pas efficace, il suffit de mettre 2 champs de type "List<PokemonType>" dans la classe "PokemonType".

Vous ne pourrez pas "correctement" initialiser ces instances "PokemonType" en un coup, il faut passer par une construction en 2 phases. La première construit l'ensemble des instances, la seconde remplira les 2 champs de type "List<PokemonType>" avec les références vers les instances "PokemonType" correspondante aux types "très sensibles" et aux types "peu sensibles".

Avec ceci en place : un repository des types d'attaque, chaque type d'attaque avec une référence vers sont type de Pokémon et chaque type de Pokémon avec 2 listes de références vers les types "très sensibles" et "peu sensible", il devrait être assez facile, via des requêtes LINQ de faire les "calculs d'affinité" entre une attaque et un type de Pokémon donné.

Et ?

C'est juste le repository des AttackType et la classe AttackType en moins, le reste est strictement identique.