Bonjour,

j'ai besoin de quelques conseils de design objet pour continuer mon système d'aide tactique colorisé pour le jeu d'échecs (voir githun: colorchess-v2 pour le dépôt de code de code) et me permettre de faire évoluer celui-ci...

Le problème est la conception ES2015 (bundle: rollup + typage: flow + transspilation: buble) d'un pipeline de règles de jeu échiquéennes qui permette de séparer (spécifier) les règles de génération et de validation des variations pour le calcul des positions futures possibles à partir de la position courante.

Je lance donc le sujet ici, en espérant avoir les avis de développeurs et joueurs d'échecs...


1. Vovabulaire : Etat du jeu, historique, variations et futures

* l'état du jeu dans colorchess est représenté dans un objet GameState (gs) qui est composé de plusieurs champs Maps et tableaux : Board (Map: ref --> Chessman), Box (boite de rangement tableau), flags (Map de drapeaux booléens) et Move { start: Ref, end: Ref, promotion: string}

* l"historique est un objet avec un champ "entries" (tableau) contenant des GameStates et quelques propriétés remarquables: current et previous et des méthodes telles que commit et revert.

* Les Futures sont un tableau de GameStates validés par le pipeline, représentant l'ensemble des mouvements possibles pour une position donnée : il est vide pour toute position de fin de partie.

* les variations sont un tableau de GameStates non encore vérifiés, à traiter par le pipeline. Les étages du pipeline peuvent : éditer/modifier la variation courante ou en créer d'autres

2. Pipeline des règles

A ce jour j'ai identifié les étages suivants (rçgles) pour le pipeline :
 | name           |mode               |applying to    |options|||
 | Turn           |alter              |flags          |no-turn|||
 | DeltaMove      |generate           |all but pawns  ||
 | PawnFirstMove  |generate           |pawns          ||||
 | PawnOffsetMove |generate           |pawns          ||||
 | PawnCapture    |generate           |pawns          ||||
 | PawnEnPassant  |alter + generatre  |pawns          ||||
 | PawnPromotion  |alter + generatre  |pawns          |-|active la popup de promotion||
 | Castling       |alter + generatre  |kings and rooks||||
 | Third filfy    |alter              |flags          |-|ne pas repeter 3 positions identiques apres le 50eme coup||
 | Check          |alter              |kings          ||
 | EndGame       |alter              |flags          |step-recursive|||
Certaines règles comme le roque (castling) ou la prise en passant devraient pouvoir être désactivées depuis l'interface pouur les débutants notamment.

Certaines règles se contentent de modifier une variation ou ses drapeaux (Turn pour passer au joueur suivant, Check...) d'autre clonent la variation étudiée pour en créer d'autres, comme les règles de mouvement, les roques ou les prmotions de pions.

L'idée générales est de pouvoir écrire quelque chose du genre :

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
 
    // key: 'a1' .. 'h8'
    Refs.keys().forEach ((key) => {
      const ref: Ref = Refs.select(key)
      let variations: Futures = new Futures()
 
      variations.add(history.current.clone())
 
      // étudier  tous les coups possibles depuis la case ref
      this.pipeline.forEach((stage) => {
        stage.process (history, variations, ref, options)
      })
 
      futures.merge (variations)
    })
Chaque règle devrait avoir 3 statuts de retour :

* ACCEPTED: la règle modifie une variation ou en crée d'autres avec succès

* IGNORED: la règle est sans objet (exemple: Castling pour un pion) et donc n'est pas appliquée

* REJECTED: la règle est refusée (bouger une pièce d'un autre camp que celui du joueur courant par exemple) et donc la variation étudiée est abandonnée


3. LA QUESTION QUI TUE:

La règle EndGame qui teste la fin de la partie doit s'assurer que la variation étudiée ne posède pas de successeurs (pas de coup possibles pour le prochain joueur) afin de pouvoir marquer 'fin de jeu' sur la variation étudiée

Cela supposerait de pouvoir itérer de façon récursive dans le pipeline (avec une profondeur de récursion de profondeur 1

COMMENT faire en sorte qu'un étage du pipeline fasse repasser la donnée qu'il possède dans l'intégralité de celui ci ?

Abstraction :

Si on a V(t) une variation:

V(t) --> A --> B --> C --> D --> E --> [ ensemble des V(t+1) }

si E est la règle de fin, alors faire repasser chauqe élément de l'ensemble { V(t+1) } dans tout le pipeline et répondre "VRAI" s'il n'y a pas de successeur à l(élément de V(t+1) considéré et "FAUX" sinon

?????

Voilà, si vous avez tenu bon jusque ici, c'est que vous etes sûrement un dév passionné par les échec et avez peut être un avis sur cette question de prepline récursif ré-entrant

Merci d'avance !

Références:

démo
https://hefeust.github.io/colorchess-v2/#/options