Des cartes personnalisées pour le jeu « Qui est-ce ? »
Le jeu « Qui-est-ce ? » fut inventé en 1979 — une fameuse année ! Bien que les trentenaires d’aujourd’hui puissent être nostalgiques de ce jeu et des personnages qui le composaient initialement, je me suis décidé à produire d’autres cartes que celles par défaut. En voici les raisons :
Les personnages, au nombre de 24, sont principalement masculins. On ne compte que 5 personnages féminins ! Et il n’y a pas tellement de mixité ethnique non plus…
Les enfants aiment bien renouveler les personnages. Hasbro l’a bien compris en éditant une nouvelle version de ce jeu avec plusieurs sets de personnages (classiques, animaux, monstres, etc…), mais puisque je dispose du vieux jeu, j’aime autant le recycler.
Je souhaitais permettre à ma gamine de jouer avec ses princesses préférées. C’était aussi l’occasion de proposer des sets de personnages sur des thèmes geek.
« Qui est-ce ? » héros Disney humains (ou presque humains)« Qui est-ce ? » Disney non humains et duos« Qui est-ce ? » Disney vilains« Qui est-ce ? » Star Wars
Des planches d’images en PDF et au format A4
J’ai développé un petit programme qui, à partir d’un répertoire de 24 images, consiste à produire 3 planches au format A4 :
une planche de personnages pour le plateau rouge,
une planche de personnages pour le plateau bleu,
une planche de cartes à piocher (la fameuse carte que l’on place devant soi).
Préparer ses 24 personnages
Pour utiliser efficacement ce programme, il y a un petit travail préparatoire à réaliser sur les 24 images :
Le nom du fichier sera écrit en-dessous du personnage, donc il faut correctement nommer chaque image.
Les images doivent avoir pour proportions (ou « ratio ») 26/17 (hauteur/largeur)
Utilisation du script
Ce script Shell fait appel à deux logiciels : ImageMagick pour les multiples traitements d’images, et pdftk pour l’assemblage des 3 planches d’images en un seul fichier PDF prêt à imprimer. Il est donc nécessaire de les installer.
Maintenant, vous allez pouvoir télécharger ce script ! Chouette !
Très régulièrement, on me demande comment renommer chronologiquement un groupe de photos, et les trier dans de multiples sous-répertoires. Sous GNU-Linux évidemment… 😎 Étant donné que je n’avais jamais publié de solution pour cela (et qu’à chaque fois je repars inutilement de zéro), voici un script Shell/Bash, reposant sur les programmes d’ImageMagick, permettant de réaliser très facilement deux ou trois petites choses :
Créer des sous répertoires selon l’ordre « année/mois/jour » à partir des informations Exif de date de prise de vue présentes dans chacune des photos
Copier chacune des photo dans le bon sous-répertoire « jour/ »
Renommer ces photos à l’aide des informations Exif de date et heure de prise de vue
Ajouter une valeur incrémentée en fin du nom du fichier si une autre photo porte déjà le même nom
Tourner la photo dans le bon sens si l’appareil avait été tenu verticalement lors du déclenchement
#! /bin/bash
# Au prealable, on s'assure que les programmes necessaires sont deja installes
which identify >> /dev/null 2>> /dev/null
if test $? -eq 1
then
cat << EOF >&2
Les programmes d'ImageMagick ne sont pas installes. Merci d'executer cette commande en tant qu'utilisateur root :
urpmi imagemagick
EOF
exit 1
fi
i=0
for fic in *jpg *JPG
do
if test -f "$fic"
then
# Increment permettant de ne pas ecraser les noms en doublon (photos prises au meme instante en rafale)
i=$((i + 1))
i2=`printf '%04d' $i`
# De la forme 2013_06_03_10_41_10
nouveau_nom=`identify -verbose $fic | grep 'exif:DateTime:' | sed -e s/'^.*\([0-9][0-9][0-9][0-9]:[0-9][0-9]:[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]\).*$'/'\1'/g | sed s/'[: ]'/'_'/g`
# De la forme 2013/06/03
repertoire=`echo "${nouveau_nom:0:10}" | tr '_' '/'`
mkdir -p $repertoire 2>> /dev/null
nouveau_fic="${repertoire}/${nouveau_nom}.jpg"
# Si un fichier porte deja le meme nom, on ajoute l'increment
test -f $nouveau_fic && nouveau_fic="${repertoire}/${nouveau_nom}_${i2}.jpg"
cp $fic $nouveau_fic
# Verifier l'orientation de la photo
orientation=`identify -verbose $nouveau_fic | grep 'exif:Orientation:' | sed -e s/'^.*\([1368]\).*$'/'\1'/g`
if test "$orientation" != "1"
then
convert $nouveau_fic -auto-orient $nouveau_fic~ && mv $nouveau_fic~ $nouveau_fic
fi
fi
done
Bien évidemment, ce script est perfectible, et il ne répondra pas non plus à tous les besoins, notamment en terme de classement. Mais libre à chacun de se l’approprier et de le modifier.
Voilà quelques jours, ma tendre moitié m’a confié une mission délicate : pour l’enterrement de vie de jeune-fille d’une amie, réaliser des cartes à faire deviner. Si le thème devait fatalement tourner autour de l’Amour, il était question de décliner ces cartes en plusieurs jeux :
Couples célèbres, étendus aux duos célèbres, à faire deviner sur le principe du jeu Time’s Up!
Personnages et personnalités ayant été de grands amoureux, étendus aux gros cochons, à faire deviner sur le principe du jeu Devine-Tête.
Mots se rapportant aux chansons d’amour, pour faire trouver des paroles de chansons sur le principe du jeu Shabadabada.
Carte personnalisée
Lorsqu’on se lance dans la réalisation d’un jeu de cartes, on va rencontrer principalement trois difficultés. Il est donc important de bien penser à tout dès le départ :
Quelle taille devront faire mes cartes, et quel look elles auront ? C’est bien si elles sont rigolotes, mais c’est encore mieux si on peut lire ce qui sera écrit dessus !
Trouver des idées… Trouver des trucs… des choses… des machins… quelque chose, quoi ! Là, il faut se creuser la cervelle pour écrire des sujets sur ces cartes. Hé puis combien de cartes, d’ailleurs ? Car jouer à 3 ou à 12 personnes ne requerra pas nécessairement le même nombre de cartes ; donc mieux vaut en prévoir suffisamment, de quoi tenir trois semaines dans un bunker, on ne sait jamais.
Les textes entrent-ils tous sur les cartes, ou bien certains seront-ils coupés ? Comment les imprimer ? Sur quoi les imprimer ? Le format des pages (communément du A4) et la qualité du papier impacteront directement le rendu final, mais également l’impression. Attention aux marges, notamment ! Pour les plus consciencieux (et les plus riches), un tirage sur papier photo aura un excellent rendu, mais dans ce cas mieux vaut mettre de côté le format A4. Ce ne sera pas mon cas.
Bien. Les bases sont là. Maintenant, s’il faut réaliser cent cartes et éditer les textes un à un, ça peut être long. Un petit coup de publipostage faciliterait quand-même les choses… Malheureusement pour vous, l’affreux geek que je fais se doit de trouver des solutions en adéquation avec son univers où les optimisations sont poussées jusqu’à leur paroxysme (du moins quand ça marche). Par conséquent, bam ! Bash et ImageMagick.
Voici une archive contenant un certain nombre de fichiers, qui devraient permettre à quiconque ayant un peu de volonté (bon, d’accord, beaucoup de volonté !) de produire un jeu de cartes :
Une image de carte vierge, celle-là même de l’exemple ci-dessus. Mais vierge.
Un fichier SVG pré-réglé pour remplacer la carte vierge par défaut. Oui, parce qu’on n’est pas obligé de reprendre mon exemple horrible…
Un fichier TTF correspondant à la police de caractères que j’ai utilisé dans mon exemple.
Deux fichiers TXT proposant chacun une liste de mots prêts à l’emploi.
Le script Bash à exécuter, celui-ci faisant notamment appel aux commandes identify, convert et montage de la suite ImageMagick. Il appelle automatiquement les fichiers JPG et TTF joints dans l’archive, et prend en argument le nom d’un fichier texte (accessoirement l’un des deux fournis, mais ce sera encore mieux avec les vôtres)
Après exécution du script, un fichier appelé « cartes_a_jouer.pdf » est créé. Il s’agit d’un fichier PDF encapsulant toutes les images des cartes produites, à raison de dix cartes par page. Voici un court exemple de cartes qui ont été réalisées avec ce script.
Il ne reste plus qu’à imprimer ce fichier. Les cartes faisant approximativement 9 x 5 cm, il est possible d’imprimer deux pages sur une, soit 20 cartes par page, de façon à ce qu’elles soient plus petites (et de façon à économiser du papier aussi) tout en restant encore lisibles. Pour apporter un peu de rigidité et pour les rendre réutilisables/durables, vous pouvez les plastifier, cela de deux façons :
si vous avez accès à une plastifieuse, le résultat sera au rendez-vous
vous pouvez éventuellement vous tourner vers les rouleaux adhésifs transparents (ceux-là mêmes pour plastifier les livres de vos rejetons), mais leur manipulation sera un peu plus délicate… Une vraie plaie, en fait !
Il ne manque plus qu’à découper chaque carte. Là encore, plusieurs options sont possibles :
les bons vieux ciseaux, ce qui reste la solution la plus simple mais pas la plus efficace
le massicot, encore faut-il en avoir un à portée de main
le scalpel et la règle en aluminium, à utiliser de préférence sur un support ne craignant pas d’être abîmé. C’est une solution peu chère et qui permet d’obtenir de bons résultats rapidement ; mais gare à bien maintenir la feuille !
Dans le magazine GNU/Linux Pratique n°67 de septembre-octobre 2011, un article intitulé « Sprites CSS : découpe d’images en CSS » et écrit par Tristan Colombo, permet de découvrir le principe de la mosaïque d’images pour le déploiement des divers éléments graphiques d’une page Web. Le principe et les avantages évoqués (les performances réseau notamment) sont très intéressants.
Cette mosaïque d’images consiste en une juxtaposition de l’ensemble des « icônes » ou « sprites » qui seront utilisés pour habiller le site, au sein d’une seule et unique image. Depuis que le navigateur Internet Explorer supporte les images PNG (ça ne fait pas si longtemps :???:), c’est d’autant intéressant que l’on peut profiter de la transparence (le fameux canal alpha), chose impossible avec les formats JPG et GIF.
Beaucoup de « webdesigners » (je n’aime pas ce terme…) créent leurs images sources en vectoriel, par exemple en SVG. De cette façon, en plus de modifier très aisément les divers composants d’un dessin, il est très simple de le convertir en PNG, tout en adaptant ses dimensions en fonction des besoins :
si 14px de haut c’est trop petit, hop! on teste avec 16px
utilisation commune d’une version 30×200 et d’une version 90×600
etc…
Lorsqu’on est amené à produire, et des fichiers SVG « sources », et des images PNG, cela revient à gérer deux fichiers par image, là où le SVG seul compte réellement. En outre, en déployant l’ensemble de ses images PNG sur divers sites Web, on n’est pas à l’abri d’une incohérence (une icône n’a plus les mêmes dimensions que les autres, pourquoi ?) ou d’un oubli.
Le principe de la mosaïque d’images a donc bien des avantages. Toutefois on se rend bien compte qu’il n’est pas évident de convertir un fichier SVG en PNG, de faire cela quinze fois, avant d’assembler toutes les images en une seule à la main dans Gimp… Puis devoir tout recommencer pour ajouter trois nouvelles images fraîchement créées, et ainsi de suite… Il va falloir un peu automatiser tout ça !
Le script Bash ci-dessous permet de se concentrer sur la réalisation des images vectorielles et leur déploiement. Il requiert essentiellement Inkscape pour la conversion des dessins vectoriels (grâce à son utilisation en ligne de commande), ainsi qu’ImageMagick pour la juxtaposition des images PNG. Une fois enregistré dans un fichier exécutable comme ~/bin/mosaique.sh, son utilisation est très simple :
Depuis le terminal, on se place dans le répertoire contenant les fichiers SVG
On passe en paramètre la hauteur souhaitée (en pixels) pour toutes les images
En sortie on obtient une seule et unique image PNG.
#! /bin/bash
source ~/bin/common.sh
# Permet de convertir le chemin d'un fichier accessible pour Inkscape depuis ouin-ouin
function windows ()
{
echo "$1" | sed "s/\\/.\\//\\//g" | tr '/' '\\'
}
Hpx=$1
p=`pwd`
if test "$Hpx" = ""
then
printcolor $RED "Veuillez specifier la hauteur (en pixels) que devront avoir les icones" >&2
echo "" >&2
exit 1
fi
# Retrait de la precedente mosaique d'images
rm -f ./mosaique.png 2>> /dev/null
# Conversion des images vectorielles du repertoire courant, en images PNG
for f in `ls ./*svg`
do
test "`uname -o`" = "Cygwin" && f2=`windows "c:/cygwin${p}/${f}"` || f2=$f
h=`inkscape -f ${f2} -H 2>> /dev/null`
w=`inkscape -f ${f2} -W 2>> /dev/null`
Wpx=`echo "$Hpx * $w / $h" | bc`
inkscape \
-f ${f2} \
-e ${f2%svg}png \
-C \
-w $Wpx \
-h $Hpx 2>> /dev/null
done
# Calcul du nombre de lignes et de colonnes constituant la mosaique
n=`ls -1 ./*png | wc -l`
# Nb d'images par ligne
L=`echo "sqrt($n)" | bc`
# On s'arrange pour avoir un nombre impair
test $((L % 2)) -gt 0 && L=$((L + 1))
# Nb de lignes d'images
H=$((n / $L))
# En cas reste sur la division, on ajoute une ligne
test $((n % $L)) -gt 0 && H=$((H + 1))
printcolor $GREEN "$n images : la mosaique va etre organisee sur une grille de ${L} colonnes et ${H} lignes"
echo ""
# Assemblage des images PNG a l'aide d'ImageMagick
montage \
./*.png \
-mode Concatenate \
-tile ${L}x${H} \
-background none \
./mosaique.PNG
# Retrait des fichiers PNG temporaires
rm -f ./*.png 2>> /dev/null
mv ./mosaique.PNG ./mosaique.png
Voici plusieurs exemples réalisés avec un jeu d’images SVG issu du thème hicolor de Gnome, disponible notamment dans l’arborescence d’Ubuntu.
10x1025x2550x5099x99
L’automatisation de cette mosaïque s’avère finalement redoutable d’efficacité. Il est ainsi possible de multiplier les essais ou d’ajouter de nouvelles images sans trop d’effort. Toutefois, cette première ébauche d’automatisation ne répond pas encore à tous les besoins et souffre de quelques failles, tels que :
l’organisation des images est basé uniquement sur le nom des fichiers, il est peut-être judicieux de leur adjoindre un indice
la mosaïque produite comprend des images de même hauteur uniquement, or il serait intéressant de pouvoir mixer plusieurs tailles d’images
Pour les personnes étant sous Windows, Cygwin permet d’installer le paquet ImageMagick sans problème. Pour exécuter Inkscape comme s’il s’agissait d’un programme GNU/Linux, le plus pratique consiste à ajouter un lien symbolique dans son répertoire ~/bin/ de cette façon :
Les quelques cadres proposés par défaut dans Fotowall ne suffisent pas toujours à rassasier la créativité débordante des utilisateurs. Fort heureusement, ce logiciel repose exclusivement sur des standards, notamment le SVG pour la réalisation des cadres. Il est donc relativement simple de créer de nouveaux cadres, moyennant… deux petites contraintes 😉 :
Réaliser un dessin au format SVG nécessite l’utilisation d’un logiciel de dessin vectoriel, ce qui n’est pas très compliqué, mais peut déjà en rebuter plus d’un.
Suivre un certain nombre d’indications, toujours au niveau du SVG, pour un affichage sans problème dans Fotowall… et là, j’ai déjà perdu la moitié de mon lectorat (ce qui doit à peu près représenter un bras ou un pied)…
Avant de proposer une solution qui permettra de s’affranchir de ces deux contraintes, et ainsi faciliter l’intégration d’un « simple dessin » comme cadre dans Fotowall, nous allons voir comment fonctionnent ces fameux cadres.
Comme dit plus haut, les cadres reposent sur des dessins vectoriels au format SVG. Pour qu’ils puissent être utilisés dans Fotowall, ceux-ci sont découpés en 9 morceaux, identifiés par une étiquette au sein du fichier. L’illustration ci-dessous représente ces 9 morceaux composant le cadre, la zone représentée en rose correspondant au positionnement d’une photo du pèle-mêle.
Les différentes parties du cadre SVG
Les étiquettes affichées sur chaque morceau, telles que « topleft » ou « bottom », correspondent aux différents ID sur lesquels repose Fotowall. Sans ces ID, Fotowall ne sera pas en mesure d’utiliser le cadre, et le contour de la photo du petit neveu ou de Médor, restera désespérément vide. A ces 9 morceaux s’ajoutent 4 autres éléments, ci-dessus représentés par des flèches. Bien qu’apparaissant lors de l’édition du dessin vectoriel, ces éléments sont invisibles une fois dans Fotowall. Ils restent pour autant nécessaires. Ceux-ci, identifiés par des ID « hint-[…]-margin », permettent de définir l’épaisseur du contour qui doit être visible. Ainsi, si nous prenons pour exemple la flèche de gauche, voici son impact sur l’image de gauche :
Si l’objet « hint-left-margin » est de longueur égale à l’image « left », alors cette image apparaît dans toute sa largeur.
Si l’objet « hint-left-margin » est de longueur supérieure à l’image « left », alors un espace apparaît entre cette image et le bord de la photo. Cet espace est automatiquement comblé par l’image de fond « center », qui dépasse donc à gauche de la photo.
Si l’objet « hint-left-margin » est de longueur inférieure à l’image « left », alors elle est partiellement recouverte par la photo.
Mathématiquement, la distance de la zone d’espace, ou de la zone recouverte, est la différence de longueur entre l’élément « hint-[…]-margin » et chacune des images concernées (les 3 de gauche, les 3 de droite, les 3 du haut, ou les 3 du bas) : si le cadre fait 5 pixels et la marge 10 pixels, il y aura un écart de 5 pixels entre le cadre et la photo.
Un petit détail qui a son importance, les images « top », « left », « bottom » et « right » seront automatiquement étirées en fonction de la taille de la photo. A partir de là, on se rend malheureusement compte qu’il est difficile de proposer un cadre avec des motifs supportant difficilement d’être déformés… L’exemple ci-dessous illustre assez bien ce problème. Qu’à cela ne tienne ! Il est déjà possible de faire pas mal de trucs pour s’amuser, et ces quelques limitations finiront par être levées avec le temps.
Les bords étant étirés, les motifs sont inévitablement déformés
Nous avons vu qu’un cadre se composait de 9 + 4 éléments graphiques dans un fichier SVG. Pour éviter de saisir les ID de ces éléments à la main dans le fichier SVG (qui est une bête structure XML), dans Inkscape il est possible de les saisir après un clic droit sur chacun de ces éléments, comme illustré ci-dessous.
Edition d'un ID dans Inkscape
Avec les quelques informations que nous venons de voir, nous pouvons nous rendre compte que produire un cadre peut être fait sans trop de difficulté, mais que cela peut aussi devenir fastidieux dès lors qu’on voudra multiplier ces cadres, par exemple pour les décliner en plusieurs couleurs. Hé puis nous l’avons déjà dit, tout le monde n’est pas forcément à l’aise avec le dessin vectoriel ! Dans ce cas, pourquoi ne pas produire un cadre directement en bitmap (JPG, PNG) à l’aide d’un logiciel de retouche photo comme Gimp, pour le convertir aussitôt après en cadre SVG prêt pour Fotowall ?
Nous l’avons très rapidement abordé plus haut, un fichier SVG est un fichier texte au format XML. Ca tombe bien, les outils en ligne de commande foisonnent sur nunux, et Bash (ou tout autre *sh, ne soyons pas –trop– sectaire) est la star quand il s’agit de produire automatiquement des fichiers !
La tentation de faire un tel programme était trop forte. Voici un script qui va nous permettre de nous affranchir du découpage d’une image et de sa conversion en SVG : fotowall_frame_compiler.zip
Une fois décompressé, le fonctionnement de ce script, quoique nécessitant un de ces écrans sombres et étranges qu’on appelle « terminaux« , est d’une grande simplicité d’utilisation. Regardez plutôt :
./fotowall_frame_compiler.sh image.png
Le script peut se contenter d’un seul et unique paramètre, à savoir l’image à convertir. Dans ce cas, les 9 parties du cadre seront autant que possible de hauteur et de largeur égales. Pour un meilleur rendu, attention à préférer des dimensions multiples de 3 dès le départ. En sortie du programme, le fichier SVG est créé, en reprenant le nom de l’image d’origine et en remplaçant l’extension par « .svg » (ce qui donne dans notre exemple image.png > image.svg).
Mais on peut aussi très bien avoir un contour de cadre de largeur ou de hauteur (ou les deux) différente de celle de l’emplacement réservé pour les photos. Pour reprendre l’exemple de la première illustration, on voit très bien que la hauteur de « top » et de « bottom » n’est pas identique à la hauteur de « center ». Dans ce cas, il va donc être nécessaire de connaître la taille exacte que l’on souhaite donner à « center » une fois transformé en SVG. Dans Gimp, il est par exemple possible de mesurer cette zone avec l’outil de sélection rectangulaire. Une fois la hauteur et la largeur connues, il suffit ensuite d’ajouter ces deux nouveaux paramètres au script :
./fotowall_frame_compiler.sh image.png 150 130
Le premier nombre correspondant à la largeur en pixels, et le second nombre correspondant à la hauteur (en pixels aussi, vous l’aurez deviné). En considérant que la zone « center » est parfaitement centrée, le script est alors en mesure de calculer la largeur et la hauteur de chacune des 9 parties, ainsi que les positionner dans l’image SVG. Bref, il n’y a plus rien à faire, le cadre étant immédiatement utilisable par Fotowall ! Si le rendu n’est pas impeccable (un écart d’un ou deux pixels est toujours possible), il suffit de jouer directement sur les deux valeurs dans la ligne de commande, puis rafraîchir le cadre dans Fotowall. Pour illustrer tout ceci, voici un exemple plus concret :
Exemples de découpages d'une image
Ce script, requiert toutefois un ou deux logiciels, qui sont disponibles parmi les dépôts de toute bonne distribution GNU/Linux :
base64 : normalement présent par défaut, ce programme permet de stocker chacune des 9 images directement dans le fichier SVG
Inkscape n’est plus véritablement nécessaire, mais ce serait dommage de continuer à vous en passer…
Attention. Le script crée temporairement 9 images PNG dans le dossier. Ce sont les 9 éléments ensuite stockés dans le fichier SVG, qui ont été découpés par ImageMagick et numérotés ainsi (en reprenant l’exemple ci-dessus) : image_0.png, image_1.png, … image_8.png. Veillez donc à ne pas avoir une image portant le même nom, sans quoi elle sera écrasée. A la fin d’exécution, ces 9 images temporaires sont automatiquement supprimées.
Après avoir abordé le fonctionnement des cadres SVG pour Fotowall, un script nous permet désormais de nous affranchir d’un certain nombre d’étapes peu amusantes (étiquetage, découpage…), et ainsi nous concentrer sur la réalisation purement graphique de l’image. Attention toutefois à préférer le format d’image PNG, qui est le seul à bénéficier à la fois des dégradés de couleur et de la transparence.
En guise de conclusion, on peut résumer ainsi les différents points abordés au sujet des cadres dans Fotowall :
Ils sont au format SVG, et peuvent être dessinés à l’aide des nombreux logiciels de dessin vectoriel, dont Inkscape fait partie.
Un cadre est composé de 9 éléments : les 4 coins, les 4 bords et le centre. A ces 9 éléments s’ajoutent 4 autres éléments pour la distance entre les bords du cadre et les bords de la photo.
Chacun des 9 + 4 éléments possède un ID précis au sein de l’image vectorielle.
Les bords étant étirés, les motifs sont déformés, ce qui limite les possibilités de création pour le moment.
Il est possible de s’affranchir de toute la partie SVG et de réaliser des cadres à partir d’images bitmap (de préférence PNG) à l’aide du script fotowall_frame_compiler.zip (nécessite GNU/Linux et une version récente d’ImageMagick).
