Discussion :

[Neckara]

Bonjour,

Je suis confronté à un problème de conception depuis hier soir et j'ai beau retourner le problème dans tous les sens, je ne trouve pas de solutions qui me satisferaient.

Je suis en train de faire une version "personnalisé" du jeux de Go en C++, nous avons donc :

- un contrôleur contenant plusieurs plateaux.
- plusieurs plateaux constitués de plusieurs socles.
- des socles sur lesquels on peut mettre un seul pion sur un socle.

Les pions sont posés par un joueur appartenant à une équipe (4 équipe max. 2 joueur max par équipe).
Un pion appartient à un groupe de pion contenant initialement un seul pion.
Lorsqu'au moins deux groupes appartenant à la même équipes sont côte à côté suite à la pose d'un pion, on fusionne le groupe.
Le groupe pourra par la suite manger un groupe adverse adjacent (si le groupe adverse n'a aucun socle adjacent libre) ou se faire manger.

Mais j'aimerais pouvoir ajouter des règles spéciales pouvant toucher n'importe quel élément cité ci-dessus.
Exemple :
- un pion spécial qui ne pourra jamais être fusionné à un groupe et jamais être mangé
- un contrôleur avec 2 plateau où chaque joueur d'une équipe joue sur un seul plateau chacun.
- un plateau où on ne peut pas poser de pions spéciaux.
- un socle qui, si est libre à la fin du jeux offre non pas 1 pion mais 2.

Tout ceci dans le but d'offrir d'autres perspectives en joueur contre joueur mais aussi pour nous permettre de créer des petites énigmes.

Mais il y a tellement de possibilité que c'en est très complexe.
Dans un sens, j'aimerais faire quelque chose d'assez simple mais en même temps je n'aimerais pas trop être bloqué si jamais je veux rajouter quelque chose.

J'ai déjà penser à quelques simplifications :
- chaque élément (socle/pion...) a une (ou plusieurs) liste d'effet (règles + effets spéciaux).
- un "effet" a un booléen (Activé) permettant de l'activer ou non.
- un "effet" a un pointeur sur l'élément lançant l'effet afin de jouer une animation s'il le faut.
- On peut détruire l'effet en l'enlevant de la liste d'effet de l'élément ( surtout pour les interdictions d'effets sur le plateau).
- On privilégie au maximum la modification d'effet.
ex : un pion spécial interdisant de faire X sur les cases adjacentes, reviendra à un effet de rajout "d'effet interdisant de faire X" sur les socles adjacents.
Les socles transmettent souvent leur effet au pion et le pion transmet souvent son effet au groupe.

Je pense donc à chaque "évènement" transmettre au contrôleur qui regardera dans sa liste "d'effet", qui retransmettra au plateau, qui transmettra au pion à l'origine de l'évènement (ou du socle en cas de pose de pion) qui transmettra aux groupes adjacents.

Mais je compte plus de 5 évènements sachant que certains effets pourront générer d'autres évènements
- pose
- fusion de groupe
- mise en contact d'un groupe adverse
- destruction de groupe
- fin de partie (comptage des points)


L'évènement étant aussi transmit sous forme de numéro d'évènement ainsi qu'un pointeur sur le pion à partir duquel on peut récupérer (et modifier) :
- le joueur qui l'a poser (et par ce biais l'équipe du joueur)
- le groupe auquel il appartient (et par ce biais l'équipe du groupe)
- le socle sur lequel est posé le pion (et par ce biais le plateau auquel le socle appartient et on peut récupérer le contrôleur à partir du plateau).

Ainsi je pense qu'on peut réussir à conserver un maximum de possibilités.
Mais je trouve que c'est assez compliqué...

Surtout qu'au départ, on va pas beaucoup utiliser les éléments avec des effets spéciaux et que ce n'est qu'ensuite que nous rajouterons des pions/socles spéciaux pour les besoins d'une nouvelle énigme ou autre...


J'ai essayé de définir pour chaque élément les types d'effets qu'il pourra produire.
Exemple pour le socle :
- Changer les points lors d'un ajout de pion
- Modifier les effet du pion (notamment pour déclencher un effet lorsque le point est détruit)
Mais soit je me retrouve avec trop de types d'effets, soit je me retrouve uniquement avec des effets faisant varier les points.

Je me demande donc si il n'existe pas de design pattern très pratique pour ce que je veux faire ou si vous aviez des conseils à me donner.

Mon but n'est pas de faire toutes ces choses compliquées tout de suite mais de pouvoir les faire si jamais j'en éprouvait le besoin sans à avoir à réécrire tout le code...

Merci de m'avoir lu,
Neckara

[koala01]

Salut,

Pour les effets, tu pourrais te baser sur le patron de conception "state"...

Tu aurais donc une classe abstraite proche de

Code :

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

1
2
3
4
5
6
7
8
9
class AbstractEffect
{
    public:
        virtual ~AbstractEfect(AbstractEffect * next = nullptr);
        virtual void execute() const = 0;
        AbstractEffect * next() const{return next_;}
    private:
        AbstractEffect * next_;
};

qui serait dérivée en autant de classes d'effet (pourquoi pas combinables ) que ce que tu aurais d'effets réels, sous une forme proche de

Code :

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

1
2
3
4
5
class AddOnePieceEffect : public AbstractEffect
{
     public:
         virtual void execute() const {/* logique nécessaire pour ajouter une piece */ }
};

A coté de cette classe, tu aurais la classe "Case" qui peut contenir zero ou un (ou plusieurs ) effet(s) et zero ou un pion.

L'effet (la liste d'effets ) est fourni(e) directement à la création de la case, alors qu'une case ne contient, par défaut, pas de pion (mais un pion peut, pourquoi pas, être fourni )

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
class Square
{
    public:
        Case(AbstractEffect * firstEffect = nullptr, Pawn* p = nullptr):
            firstEffect_(firstEffect), pawn_(p){}
        /* returns true only if there is no pawn yet  */
        bool canAcceptPawn() const
        {return pawn_ == nullptr;}
        /* set pawn (if no pawn set) and call "executeEffect, if any 
          *
          * throws an exception if pawn allready set
          */
        void acceptPawn(Pawn *p)
        {
            if(pawn_)
            {
                throw PawnAllreadySet();
            }
            pawn_= p;
            excecuteEffect();
        }
    private:
        executeEffect()
        {
            AbstractEffect * e = firstEffect_;
            while (e)
            {
                e->execute();
                e = e->next();
            }
        }
        AbstractEffect * firstEffect_;
        Pawn * pawn_;
};

Tu aurais bien sur, pour terminer, une classe Pawn que tu pourrais dériver (si besoin) en différents types de pions et une classe Plate contenant un ensemble de cases.

En travaillant de la sorte, il "suffit" de créer un(e liste d') effet(s) en fonction de tes besoins, de le fournir à la case qui doit en profiter au moment de la création de ton plateau de jeu, et le tour est joué :

En ajoutant sans doute une "fabrique" d'effets, tu pourras ajouter autant d'effets différents que ce que tu peux vouloir à n'importe quelle case au moment de la création de celle-ci, et ils seront pris en compte lorsque la case acceptera un pion placé par un joueur

Bien sur, il est possible qu'il faille peut etre adapter des paramètres à la fonction execute des effets (il peut etre utile de rajouter le joueur, vu qu'il risque de profiter de l'effet), mais l'idée générale est là

[Neckara]

Bonjour,

Merci pour votre réponse.

Je pense tout de même que finalement je ne ferais pas de pions avec des effets spéciaux, en effet c'est beaucoup trop compliqué à coordonner les effets des socles et des pions.

Je pense plutôt faire différent types de pions qui, posé sur un socle spécifique déclencherons l'effet du socle.

Je vais tout de même continuer de réfléchir un petit peu.