Générer un jeu de Dobble

Lorsque j’ai découvert le jeu de Dobble, je me suis tout de suite demandé comment on pouvait générer un tel ensemble de cartes.

Après y avoir vainement réfléchi, j’ai trouvé quelques références ici et là qui font appel à la géométrie projective.

L’idée m’est alors venue de générer un jeu personnalisé avec des images ayant un thème commun (des visages familiers, des lieux de vacances, etc.)

Le projet :

Trouver une façon de générer les combinaisons de cartes et symboles
Générer les combinaisons et les stocker dans fichier texte
Faire un script qui génère les images de chacune des cartes avec ImageMagick
Faire imprimer les images sur un support se rapprochant d’une carte à jouer

Les points 1 à 3 étant techniquement réglés, j’en partage ici les différentes étapes. Le dernier point est encore en projet…

1. Trouver l’algorithme

Après avoir parcouru liens mentionnés plus haut, il me restait à en faire l’implémentation. Après quelques tâtonnements, je suis tombé sur ce post de stackoverflow qui propose quelques implémentations.

2. Générer les cartes

J’en ai choisi une qui est sous-optimale (elle génère 58 symboles plutôt que 57). Le jeu reste cependant tout à fait valide et le bout de code implémentait aussi une fonction de vérification du jeu généré. J’ai légèrement modifié la sortie pour avoir un fichier texte facile à lire pour la suite.

Le fichier source est ici : mainDobble.cpp

Le résultat du programme est un fichier texte de la forme suivante où chaque ligne représente une carte composée de 8 symboles, eux-même représentés par un entier.

wilhelm@beluga:~/code/dobble$ head -5 dobble.txt
0   1   2   3   4   5   6   50
7   8   9   10  11  12  13  50
14  15  16  17  18  19  20  50
21  22  23  24  25  26  27  50
28  29  30  31  32  33  34  50
wilhelm@beluga:~/code/dobble$

Le format du fichier texte contenant les cartes de Dobble

Fichier des cartes résultant : dobble.txt

On peut aussi générer des jeux avec 4, 6 ou même 12 symboles par carte. Par exemple:

3. Le script de rendu

Pour créer le rendu des cartes, un petit script bash: card.sh.

Syntaxe

Premier argument: le fichier texte en entrée. Second argument: le chemin du répertoire où sont les images. Les cartes sont générées dans un répertoire output

wilhelm@beluga:~/code/dobble$ ./card.sh dobble.txt ~/picture/dobble

Commande pour lancer le rendu des cartes.

On notera la double utilisation de shuf. L’algorithme de génération des cartes est assez ordonné. Un double brassage s’impose. Le premier, c’est pour réarranger l’ordre des cartes (le shuf de la boucle for). Le second (encapsulé dans une fonction Shuffle pour ventiler les éléments d’une ligne plutôt que des lignes), est plus important. Il s’agit de ventiler la position des symboles sur les cartes. Sinon, les mêmes symboles ont tendance à se retrouver aux mêmes positions et ça enlève un peu du piment au jeu.

La boucle principale appelle ImageMagick pour créer un montage à partir d’images stockée dans le répertoire passé en argument et du fichier texte mentionné plus haut.

#!/bin/bash

Shuffle()
{
	 echo $* | tr " " "\n" | shuf | tr -d " " 
}

##############################################
# Main
##############################################
INPUT=$1
DIR=$2
OUTDIR=ouput

BAK_IFS=${IFS}
IFS=$'\r\n' 
Image=($(ls $DIR))
IFS=${BAK_IFS}

mkdir -p ${OUTDIR}
export i=0
export SMSIZE=500
export BIGSIZE=600
export FULLSIZE=1600
shuf ${INPUT} | while read a b c d e f g h; do
	sa=( $( Shuffle ${a} ${b} ${c} ${d} ${e} ${f} ${g} ${h} ) )
	im=( \
		"${DIR}/${Image[ ${sa[0]} ]}"\
		"${DIR}/${Image[ ${sa[1]} ]}"\
		"${DIR}/${Image[ ${sa[2]} ]}"\
		"${DIR}/${Image[ ${sa[3]} ]}"\
		"${DIR}/${Image[ ${sa[4]} ]}"\
		"${DIR}/${Image[ ${sa[5]} ]}"\
		"${DIR}/${Image[ ${sa[6]} ]}"\
		"${DIR}/${Image[ ${sa[7]} ]}" ) 

	OUTPUT=${OUTDIR}/card_${i}.jpeg
	echo ${OUTPUT}
	((i  ))

	 convert  -size "${FULLSIZE}x${FULLSIZE}" xc:white  \
-gravity Center \
\( "${im[0]}" 	-resize "${SMSIZE}x${SMSIZE}"	-gravity Center -rotate -45 	-repage  0 0 		\)		\
		\( "${im[1]}" 	-resize "${SMSIZE}x${SMSIZE}" 	-gravity Center -rotate 45 		-repage  1000 0 	\)		\
		\( "${im[2]}" 	-resize "${SMSIZE}x${SMSIZE}" 	-gravity Center -rotate 0		-repage  0 600	 	\)		\
		\( "${im[3]}" 	-resize "${BIGSIZE}x${BIGSIZE}"	-gravity Center -rotate 60		-repage  400 400  	\)		\
		\( "${im[4]}" 	-resize "${SMSIZE}x${SMSIZE}"	-gravity Center -rotate 180		-repage  1200 500 	\)		\
		\( "${im[5]}" 	-resize "${SMSIZE}x${SMSIZE}"	-gravity Center -rotate -135	-repage  0 1100 	\)		\
		\( "${im[6]}" 	-resize "${SMSIZE}x${SMSIZE}"	-gravity Center -rotate 180		-repage  800 1100 	\)		\
		\( "${im[7]}"	-resize "${SMSIZE}x${SMSIZE}" 	-gravity Center -rotate 135		-repage  1100 1100	 \)		\
		-compose Multiply -layers flatten  tiff:- | convert - 	-mattecolor DarkOrange4 -frame 20x20 0 0 \
${OUTPUT}
done

Script pour le rendu des images de carte

Ci-dessous, un exemple du rendu de quelques cartes générées. Il ne reste plus qu’à ajuster un peu les dimensions en fonction des proportions des cartes à imprimer. Mais pour ça, il faut trouver un fournisseur/site web, qui propose d’imprimer 57 cartes différentes pour un prix raisonnable. C’est la fameuse étape 4, qui est encore en suspend…

8 réflexions sur « Générer un jeu de Dobble »

Bonjour,

Je suis interesse par ton fichier .txt qui donnes les combinaisons des 8 symboles a appliquer sur chacune des cartes. As tu aussi pu generer le meme fichier .txt pour un cas ou il n’y a que 5 symboles par carte, ou bien 6 ou bien 7. Si oui, je serais interesse pour le recuperer.

Merci
Olivier

Répondre

quirysse dit :

novembre 17, 2016 à 19:21

Bonjour Olivier,

le lien vers le fichier est disponible sur l’article (dobble.txt). Pour le générer, il a un code en c++ (mainDobble.cpp) aussi disponible dans l’article. Il devrait être modifiable facilement pour passer à 5, 6 ou 7 symboles (en fait, c’est juste un paramètre de la fonction d’entrée).
Cordialement

Répondre

Bonjour et bravo pour cette article passionant.
Juste un petit détail surle fichier txt. Tu à sauter le N°49, ce qui n’est pas bien grave, mais peut donner l’impression que tu as utilisé 58 symboles, puisque la numérotation commence à 0 et va jusqu’à 57 ;)

Répondre

Bonjour Quirysse,
je suis enseignante de FLE (francais langue étrangere) et j’adore le Dobble (en famille et en classe, également). Les années précédentes, moi aussi, j’ai fabriqué pas mal de jeux de Dobble sur le site gorfo, mais depuis un certain temps, il ne marche plus. J’ai fouillé internet, mais hélas, je n’ai trouvé qu’un site oú on peut créer des jeux de Dobble avec des mots, sans images. Et hop, ensuite, je suis tombée sur ton site et chapeau! Félicitations pour ton travail et grand merci! Puisque je n’y connais pas á l’Informatique, je n’ai compris que le moindre des choses mais au moins, avec ton aide, je serai capable de créer des cartes avec 8 images pour mes lycéens.
Parcontre, j’anime des ateliers pour des maternelles, aussi et pour eux, 8 images, c’est trop (et quant aux mots, ils ne savent pas lire, donc, inutile..). J’ai lu ta réponse pour Olivier, mais je ne comprends pas, désolée, je serais incapable de faire ces modifications.
En tout cas, je serais donc tres reconnaissante si tu pouvais me suggérer un site, si tu en connais, oú je pourrais trouver une liste de nombres, similaire á la tienne, avec laquelle je pourrais fabriquer des jeux de Dobble 4 images par cartes.
Merci d’avance de ta réponse!
Bonne continuation,
Timea

Répondre

quirysse dit :

août 27, 2017 à 18:55

Bonjour Timea,
Je ne connais pas de site pour trouver une liste des cartes de Dobble. En revanche j’ai généré des listes à 4, 6, 8 et 12 symboles qui sont donc disponible en téléchargement. J’ai mis à jour l’article, tu trouveras les liens plus haut.
Bonne rentrée !
Quirysse

Répondre
1. Timea dit :
  
  août 29, 2017 à 07:37
  
  Bonjour Quirysse,
  Grand merci, encore, pour ta réponse et ton travail !! :)
  Bonne journée,
  Timea
  
  Répondre

Bonjour,
Merci de partager votre générateur de dobble. J’aimerais le personnaliser avec des images de formes géométriques pour une utilisation en classe mais je ne sais pas du tout comment m’y prendre et je n’ai aucune connaissance en programmation…!
Pourriez-vous m’aider ?
J’ai réuni toutes les images que je souhaiterais voir figurer sur les cartes dans un dossier mais après cela… je ne sais pas comment utiliser les fichiers que vous publiez sur votre site…

Répondre

quirysse dit :

février 28, 2019 à 21:51

Le plus simple est d’utiliser le script à partir d’un ordinateur équipé d’une distribution linux. Sous Windows, il faudra au préalable installer au minimum bash. Sous Windows 10, il est possible d’utiliser WSL (Windows Subsystem for Linux). Le tout étant d’avoir un environnement permettant de lancer mon script en ligne de commande. Je crois que c’est assez trivial pour la plupart des informaticiens avec lesquels je pense partager ces petits bouts de scripts. En revanche, le jeu de Dobble semble avoir particulièrement touché le corps enseignant qui n’est pas forcément à l’aise avec ce genre de manipulation. Je ne sais pas comment je peux améliorer le système pour ce public… Peut-être que si je prenais le temps, je pourrais créer un générateur de jeu de Dobble en ligne. Ou bien créer un tutoriel adressé au néophyte pour lui permettre de lancer les scripts (dans le droite ligne d' »apprendre à pêcher plutôt que de donner du poisson » comme disait le sage…) Quoi qu’il en soit, en l’état je ne peux que vous donner ces quelques pistes, peut-être qu’une connaissance férue d’informatique pourra vous dépanner à partir de ces quelques bribes d’information.

Répondre

Grandes Bidouilles

1. Trouver l’algorithme

2. Générer les cartes

3. Le script de rendu

Syntaxe

8 réflexions sur « Générer un jeu de Dobble »

Laisser un commentaire Annuler la réponse

Site sur le bricolage, la bidouille et l'informatique