Des nombreux jeux de semailles, ou mancala, existent sur presque toute la planète. Des dizaines d’entre eux sont déjà répertoriés sur ludii (choisir la catégorie sow dans le menu déroulant). On distingue quelques catégories :

• Les jeux dits solo [1] où chaque joueur sème uniquement sur son propre territoire, et rapatrie dans son territoire les graines prises à l’adversaire ;
• les jeux dits wari (l’awalé est le plus connu), où les graines prises sont retirées du jeu, et placées dans un grenier souvent hors du plateau de jeu ;
• d’autres mancala essentiellement asiatiques où le grenier (« kalah ») est utilisé au cours du jeu : on y sème mais en général on n’y récolte pas. Exemple, le congklak indonésien où chaque joueur a son grenier [2].
• Finalement, des versions solitaires du jeu, essentiellement asiatiques, où le grenier s’appellerait « Rouma » [3]. Ce jeu est très répandu paraît-il en Inde.

• Le jeu de Tchouka-Rouma a été diffusé par Édouard Lucas [4] [5]
• En 1895, Henri-Auguste Delannoy publie cette description du jeu tel que Lucas le lui avait communiqué :

  

  

• En 1929 c’est au tour de Sainte-Lagüe d’en parler, dans cet extrait de géométrie et situations de jeux :

  

  

• En 1977, dans Wari et Solo, Deledicq et Popova évoquent le jeu de la tchouka et lui attribuent une origine russe (voire paléo-sibérienne) mais reconnaissent qu’il n’est plus pratiqué depuis au moins des décennies.
• Dans le même livre, Véronique Gautheron, pour une étude combinatoire sur ce genre de jeu, a inventé une simplification (sans retour à la case départ, sans répétition du coup) qu’elle a baptisé Tchoukaillon.
• Tchoukaillon aussi a eu droit à des études mathématiques.
• Mais un résultat particulièrement intéressant est celui-ci : Le nombre de graines du tchouka-rouma (appelé tchoukaillon dans l’article) à n trous est asymptotiquement égal à n²/π...
• Une variante a été proposée par Élisabeth Busser et Gilles Cohen dans « les jeux mathématiques du Monde », avec des grains de riz, et où on sème en s’éloignant de la Rouma.
• Le jeu Tchouka-Rouma s’appelle Chuka sur ludii

Voici le script en langage ludii, pour Tchoukaillon :

(define "Rumba" 0)

(define "AllSitesNotRumba" (difference (sites Board) "Rumba"))

(define "LastHole" (last To afterConsequence:True))

(define "AllCountersInRumba" (= 17 (count at:"Rumba")))

//------------------------------------------------------------------------------

(game "Tchoukaillon"
    (players 1)
    (equipment {
        (board 
            (rectangle 1 7) 
            (track "Track" {6..0} loop:False)
            use:Vertex
        )
        (piece "Seed" Shared)
    })
    (rules
        (start (place Stack "Seed" (sites { 1..6 }) counts:{1 1 3 2 4 6}))
        (play 
            (move Select
                (from
                        ("AllSitesNotRumba")
                    if:(!= 0 (count at:(from)))
                )
                (then (sow))
            )
        )
        (end {
            (if ("AllCountersInRumba") (result Mover Win))
            (if 
                (and (= 1 (count at:("LastHole"))) (!= ("LastHole") ("Rumba"))) 
                (result Mover Loss)
            )
        })
    )
)

//------------------------------------------------------------------------------

(metadata 
    
    (info
        {
        (description "Tchoukaillon is a puzzle invented by Veronique Gautheron. It contains the sowing mechanism seen in many mancala-style board games. ")
        (rules "Seven holes arranged in a line. One hole is called the Rumba. The player sows the counters in one direction. If the final counter lands in an empty hole that is not the Rumba, they lose. The goal of the player is to accumulate all of the counters into the Rumba. ")
        (source "Delediqc and Popova 1977: 99-100.")
        (version "1.0.0")
        (classification "puzzle/planning")
        (credit "Alain Busser")
        }
    )
    
    (graphics {
        (board Style Mancala)
    })
    
)

Le jeu Tchoukaillon a été simplifié pour être plus jouable en Grande Section, le résultat s’appelle Kaillon. En fait on a juste enlevé la contrainte de ne terminer le semis que sur une case non vide, ce qui facilite grandement la recherche d’une solution. Le but du jeu devient alors de réussir à semer toutes les graines dans le trou tout à droite (la rumba ou nyumba). Et dans un second temps, de chercher une solution optimale (le moins de mouvements possibles). Mais on peut faire fausse route et rater la solution :

Bien que ce soit un jeu à un seul joueur, une difficulté persiste en Grande Section : les élèves non latéralisés ont tendance à semer depuis un bord plutôt que depuis la case voisine de droite. C’est de là que vient le jeu Fang (un jeu à deux joueurs).

Le jeu Sowing a été inventé par John Conway pour illustrer sa construction des surréels. Il a les caractéristiques suivantes :

• on ne joue (comme à Tchoukaillon) que sur une rangée, commune aux deux joueurs.
• Chaque joueur sème de sa gauche vers sa droite (donc en sens inverse l’un de l’autre).
• Une fois que la dernière graine est semée, on passe la main à l’autre joueur (on ne resème pas).
• Si la dernière graine du semis tombe dans une case vide, on perd le jeu.

Les parties de Sowing étant en général assez courtes, ce jeu est abordable dès la grande section...

Le langage ludii permet de décrire assez simplement toutes sortes de jeux abstraits. Voici le jeu sowing décrit dans ce langage :

(game "Sowing" 
    (players 2) 
    (equipment { 
        (board (rectangle 1 8)
            {
            (track "Track1" "0,E" P1 directed:True)
            (track "Track2" "7,W" P2 directed:True)
            }
            use: Vertex
        )
        (regions P1 (sites Top))      // P1 home
        (regions P2 (sites Top))      // P2 home
        (piece "DiscFlat" Shared)
        (hand Each)
    }) 
    
    (rules 
        (start (place Stack "DiscFlat" (sites { 0..7 }) counts:{1 2 2 1 1 2 2 1}))        
        (play 
            (move Select 
                (from 
                    (sites Mover) 
                    if:(
                        (and
                            {
                            (is Occupied (from))
                            (is Occupied (trackSite Move Mover steps:(size Stack at:(from))))
                            }
                        )
                    )
                )
                (then (sow "Track" owner:(mover)))
            )
        )
        (end ("NoMoves" Loss))
    )
)

//------------------------------------------------------------------------------

(metadata 
    (info
        {
        (description "Sowing is a two players game. ")
        (rules "The last to move wins.")
        (source "https://jeffe.cs.illinois.edu/pubs/pdf/sowing.pdf")
        (version "1.0.0")
        (classification "board/sow")
        (credit "Alain Busser")
        (origin "This game was created by John Conway, who presented it in 1994.")
        }
    )
    
    (graphics {
        (board Checkered)
    })
    
)

En chargeant le script ci-dessus dans le logiciel ludii, on peut jouer contre une IA de son choix, voire regarder des IA s’affronter. On constate alors que la stratégie gagnante pour le premier joueur nécessite tout de même 13 coups, ce qui est plutôt long pour un jeu de Sowing.

On peut aussi tester (avec le ludii player) la variante suivante, où il y a 2 graines par case au début du jeu (ce qui limite l’avantage d’un joueur sur l’autre) :

On appelle longueur du plateau, la différence entre les indices des deux cases extrêmes (la plus dextre et la plus senestre des cases non vides). Julien Lemoine a fait les remarques suivantes :

• si on joue une case extrême, la longueur du plateau décroît strictement ;
• si un semis se termine sur une case extrême, le nombre total de graines dans les cases extrêmes croît strictement ;
• dans les autres cas, les cases extrêmes ne changent pas, mais à l’intérieur du plateau, l’équivalent d’une des quantités précédentes croît ou décroît strictement

De plus, le nombre total de graines dans le plateau est un invariant, que l’on va noter N. Alors on propose de construire un tuple, constitué de (par exemple pour un plateau de longueur initiale 8) :

• la longueur du plateau P,
• N-P₀-P₇
• la longueur de (P₁,P₂,P₃,P₄,P₅,P₆)
• N-P₁-P₆
• la longueur de (P₂,P₃,P₄,P₅)
• N-P₂-P₅
• la longueur de (P₃,P₄)
• N-P₃-P₄

qui est un variant pour l’ordre lexicographique sur les tuples. Existe-t-il un variant plus simple ?

Voici par exemple les valeurs que prend ce variant pour une configuration qui donne des parties particulièrement longues [6] si chaque joueur joue au mieux :

L’existence d’un variant prouve le

Le jeu Wing peut durer longtemps car il est possible d’avoir des cycles (typiquement Sud transfère une graine de la case 3 vers la case 4 -vide- puis Nord transfère la graine de la case 4 vers la case 3, vidée entre-temps etc). Pour que le jeu ne dure pas trop longtemps, on propose de rajouter une règle garantissant la finitude du jeu : il est interdit de faire un coup qui ramène à une situation déjà visitée au cours du jeu. Cela donne ce script :

(game "Wing" 
    (players 2) 
    (equipment { 
        (board (rectangle 1 8)
            {
            (track "Track1" "0,E" P1 directed:True)
            (track "Track2" "7,W" P2 directed:True)
            }
            use: Vertex
        )
        (regions P1 (sites Board))      // P1 home
        (regions P2 (sites Board))      // P2 home
        (piece "Seed" Shared)
        (hand Each)
    }) 
    
    (rules 
        (start (place Random {"Seed"}  count:5))        
        (play 
            (move Select 
                (from 
                    (sites Mover) 
                    if:(
                        (and
                            {
                            (is Occupied (from))
                            (!= Off (trackSite Move Mover steps:(size Stack at:(from))))
                            }
                        )
                    )
                )
                (then (sow "Track" owner:(mover)))
            )
        )
        (end 
                (if (is Repeat) (result Mover Loss))
        )
    )
)


(metadata 
    (info
        {
        (description "Wing is a two players game. ")
        (rules "The first one to repeat a postition looses.")
        (version "1.0.1")
        (classification "board/sow")
        (credit "Alain Busser")
        (origin "This game was created by Alain Busser, on 08/20/2023, for educational purposes.")
        }
    )
    
    (graphics {
        (board Style Mancala)
    })
    
)

La nécessité de mémoriser les états du jeu déjà parcourus complique nettement le jeu, mais les IA de ludii trouvent l’existence d’une stratégie gagnante, pour le joueur Nord ou le joueur Sud, selon la position de départ.

Avec une graine par case (soit 8 graines sur un plateau de 8 cases), celui qui joue en second gagne le jeu.

Chip-firing

Les jeux de semailles offrent quelque ressemblance avec les jeux de chip-firing sur graphes orientés (la différence est qu’on ne sème pas tous les jetons mais juste ce qu’il faut).

awale généralisé sur un graphe

Des variantes du jeu d’awalé peuvent être jouées sur des graphes orientés, en voici quelques-unes :

awale généralisé	le source de l’article

Un jeu de semailles particulièrement remarquable est le Fifangha.