Bonjour à tous,

Je travaille sur le développement d'un jeu 2D de type RPG au tour par tour (roguelike, mais ce n'est pas important ici).

Comme dans tous RPG, mon joueur va avoir accès à différentes compétences, comme lancer une boule de feu, donner un coup d'épée, se soigner, maudire l'ennemi etc. Très standard quoi.

J'ai un problème dans l'implémentation de la classe Compétence. Chaque compétence ayant un effet différent et particulier, ma fonction LancerSort() sera totalement différente d'un sort à l'autre. Comment feriez-vous cette implémentation ?

Je précise que je vais gérer un grand nombre de sort, il faudra donc que je puisse gérer une base de données de sorts, et pouvoir la parcourir aisément en ayant pas exemple une fonction qui renvoi les sorts disponible uniquement pour la classe du joueur.

Si vous avez une idée ou que vous avez déjà travaillé sur cette problématique, votre aide serait la bienvenue

Il existe une casi-infinité de solutions, ça dépend de comment ton système de compétence est foutu.

Mais globalement, il devrait être possible de stocker une fonction dans une variable : https://answers.unity.com/questions/925943/storing-a-method-in-a-variable.html et de pouvoir appeller n'importe quel fonction depuis ton "LancerSort()".

Tu voudras surement faire passer un paramètre à ton LancerSort(), comme une référence à ton GameObject de joueur : LancerSort(Player_GameObject).

Comme ça quand tu as un sort BouleDeFeu(Player_GameObject) Tu pourras appliquer des paramètres à ton joueur, comme une animation, un effet de particule ect...

Et tu peux mettre tout t'es sorts dans un script à part, ou plusieurs scripts séparés en fonction des types de magies.

L'utilisation d'un Delegate a l'air d'être la solution que je cherchais, je vais essayer d'implémenter ça je te remercie !

Pour infos je n'ai pas besoin de passer Player en paramètre car Player est une instance unique que je peux appeler n'importe quand en faisant Player.instance. De même pour l'ennemi (qui est toujours seul). Je sépare les sorts disponibles au joueur des sorts disponibles aux ennemis pour ne pas avoir à gérer de lanceur/cible.

Merci encore pour ton aide précieuse !

Salut,

Je suis aussi entrain de développer un RPG/roguelike, à priori une première alpha sera disponible d'ici la fin du mois ou début octobre.

J'ai un problème dans l'implémentation de la classe Compétence. Chaque compétence ayant un effet différent et particulier, ma fonction LancerSort() sera totalement différente d'un sort à l'autre. Comment feriez-vous cette implémentation ?

Pour ça j'ai une classe Effect:

public abstract class Effect : ScriptableObject
{
    public abstract void Apply(Vector3Int target, Character Caster, int power);
}

Pour chaque effet différent il suffit de créer une nouvelle classe héritant de Effect:

public class Heal : Effect
{
    public override void Apply(Vector3Int target, Character Caster, int power)
    {
        Character Target = Map.GetCharacterAtPos(target);

        Target.Health += power;
    }
}

Ensuite il suffit d'avoir une liste d'effets dans ta classe compétence (ou, dans mon cas, la classe Action que je sépare de ma classe Ability vu que je peux avoir des compétence qui ne donne pas d'action, avec un effet passif).

[System.Serializable]
public struct EffectsElement
{
    public Effect Effect;
    public int power;
}

public class Action : ScriptableObject
{
     public EffectsElement[] Effects;
     /*il y a 100+ lignes ici que je met pas*/
    public void Apply(Vector3Int targetPos, Character Caster)
    {
        foreach(EffectsElement EffectsElement in Effects)
        {
            EffectsElement.Effect.Apply(targetPos, Caster, EffectsElement.power);
        }
    }
}

J'avais réfléchi à utiliser des delegates aussi, mais je ne suis pas sur que ça mène à du code plus propre que ma façon de faire.

En fait j'avais déjà essayé d'utiliser ta méthode, cad faire une classe abstraite Competence et des sorts qui dérivent de cette classe comme BouleDeFeu : Competence.

Le problème que j'ai rencontré est qu'il était très difficile de parcourir les différents sorts existants (par exemple GetSortsByClasse était difficile à coder, même si c'était faisable dans l'absolue). C'était aussi l'enfer de savoir si un sort était instancié ou non.

Je vais essayer les delegate et je pourrais te dire quelle est la méthode que j'ai préféré.

J'ai un dossier par catégorie de compétences, et un script éditeur qui me créer un ScriptableObject "AbilitiesList" automatiquement pour chaque dossier.

J'ai pas trop de soucis à gérer mon contenu comme ça. Et si j'en rencontre je pourrais toujours ajouter des boutons ou fenêtres dans l'éditeur pour régler le problème.

Et après, si je voulais faire un truc plus propre je pourrais toujours stocker mes ScriptableObject dans une BDD.

Sinon, je ne suis pas sur que créer une classe "boule de feu" soit avisé. Avec mon système je n'ai pas une classe par sort mais une classe par effet (Attack, Heal, Interact, Walk, ModifyAttribute etc.) et les sorts contiennent une liste d'effets. Je ne pense pas dépasser la douzaine d'effets mais j'aurais probablement 100 sorts différents au moins.