📝 Blog

October 7, 2014
6 min read

MatLab Expo 2014

Le jeudi 2 octobre se déroulait une conférence autour du logiciel Matlab : la Matlab Expo 2014.

Ayant découvert il y a peu de temps cette application, sentant un potentiel important pour de petites expériences à la maison ou avec MixTeen, j’ai décidé d’aller passer ma journée là bas pour enquêter un peu.

Ceci est donc mon petit compte rendu, totalement partial et personnel.

Le commencement est forcément un peu difficile : il faut se lever à 5h30 pour aller prendre un TGV. J’ai beau insister, mon cerveau refuse de croire que je suis debout et en route.

Pour une fois, ma réputation de chat noir sera usurpée et le TGV est parti et arrivé à la minute près. Bon, ensuite, j’avais mémorisé qu’il fallait prendre le RER C à la gare d’Austerlitz, mais oublié de noter le nom de la station où descendre. Mini drame, perte de réseau une fois à la gare, petite perte de temps mais un agent souriant et aimable de la RATP m’indique ce qu’il me faut savoir. Je vous dis, cette journée est bien partie ;)

La conférence a lieu dans le Novotel proche de la tour Effeil. L’accueil est très bien géré et sympathique. J’arrive juste pour la fin de la présentation initiale.

J’assite ensuite à la première keynote : “Behind today’s trends : the technologies driving change” par Loren Shure. C’est plutôt interressant, bien tourné, belle analyse des tendances technologiques et challenges associés. Bien sûr, de nombreuses références aux fonctionnalités Matlab, quelques petites annonces : bien ficelé. Je sens bien que je ne suis pas sensible de la même façon que la majorité de l’assistance, qui travaille pour la plupart au quotidien avec Matlab. Mais c’est plutôt enthousiasmant.

La keynote suivante est sur le monde automobile, par Roland Lismonde de chez Bosch : “Le model-sharing au service de l’innovation pour l’industrie automobile”. La présentation montre de quelle manière l’électronique a profondément changé le monde automobile. Je ne suis pas super sensible à l’ensemble, je quitte discrètement la salle.

Je me rend ensuite dans l’espace où différents stands tenus par Mathworks ou des partenaires présentent différentes facettes de Matlab. Comme la plupart des gens sont encore dans l’amphi, je suis un peu sollicité. Ce qui est très intéressant, c’est que lorsque j’explique ma démarche personnelle et les ateliers Mixteen, je suis très loin d’être poliment ignoré comme cela peut être le cas dans d’autres salons professionnels. Il y a un intérêt gigantesque pour tout ce qui touche au numérique et aux enfants. D’ailleurs, j’espère que les associations parisiennes ne m’en voudront pas, mais j’ai balancé des contacts ;)

Une fois sur le stand présentant les capacités de connections arduino/raspberry/mindstorms/Soc FPGA, je vais de surprise en (bonne) surprise. Je découvre que l’intérêt de Mathworks pour le monde de l’éducation est très loin d’être une façade marketing. Il semblerait en plus que la France soit le pays où Mathworks investit le plus dans l’éducation. Je n’ai pas de chiffres, mais le fait de rencontrer des employés visiblement entièrement dédiés me suffirait. Si ce n’était pas le cas, les différents exemples présents m’auraient convaincus. Et si j’étais vraiment borné, parler de tous les projets en cours avec elles aurait achevé le tout. Ok, je suis vaincu, Mathworks fait de gros efforts dans la direction du monde éducatif. Il reste à voir si en dehors des cursus purement scolaire une initiative comme Mixteen a sa place, mais comme toutes les discussions sont restées ouvertes, il y a un univers de possible.

J’ai donc observé les interactions possibles entre Matlab et arduino avec un petit atelier utilisant des boutons poussoirs et un petit ventilateur. La partie Matlab permet d’aborder une machine à état simple et abordable.

Un exemple un peu plus avancé montrait un suivi d’objet par une webcam pilotée par une Raspberry Pi. Deux autres exemples mettaient à contribution des kits Lego Mindstorms : un suiveur de ligne et un robot en self balancing. (j’écris du franglais si je veux, na ;) )

Tout ça me donne bien envie d’essayer en rentrant (j’en parle plus bas)

La pause sera l’occasion de parler licences avec une des personnes en charge de cet aspect. Là encore, ce fut un échange concret et constructif avec quelqu’un à l’esprit ouvert. Je n’ai pas encore vendu mon âme GPL mais voilà un logiciel certes propriétaire mais à qui j’aimerai donner une belle chance.

Je passe ensuite un bon moment au stand du défi Rover. Et là encore, encore un passionné employé par Mathworks. Le robot me parait même suréquipé pour les taches qu’il a eu à réaliser dans le premier défi. A vue de nez, il y aura d’autres défis encore plus complexes dans l’avenir :)

C’est à ce moment que l’amphithéatre principal se vide et que je réalise que mon estomac réclame un peu d’attention. Je sais, on ne juge pas un salon à sa nourriture. Mais c’était bien bon :) Je note l’intérêt des personnes présentes pour ce qui semble destiné à l’éducation. Les sessions de l’après midi vont concerner du monde.

Nouvelle session avec Loren shure, employée de longue date de Mathworks. J’ai toujours trouvé que les américains faisaient des speakers enthousiasmant, c’est bien le cas ici. Et pourtant, certains passages furent corsés pour tous, se faire expliquer une théorie des balancier et les équations de Lagrange correspondantes aurait épuisé n’importe qui :) Au passage, je découvre MuPad qui est un outil de calcul formel, utile pour écrire des documents contenant des formules mathématiques avec un rendu visuel correspondant.

J’avoue que j’écris ces passages quelques jours après et que la fatigue du virus attrapé dans le TGV se fait encore sentir :)

La session suivante est celle du Dr Abdelmoumen Youssef : modélisation, simulation au service de la recherche autour de la cardiologie. Un travail remarquable qui dure depuis 13 ans pour obtenir une modélisation du coeur suffisament réelle et paramétrable pour qu’une aide concrète soit apportée aux équipes médicales.

J’assiste ensuite à la conférence de Yann Labit : simulateur de servo commandes électrique avec Simulink pour le contrôle de vol sur hélicoptère. Beaucoup d’explicartion sur les redondances des contrôles sur un modèle créé par son labo et utilisé par un industriel pour vérifier en amont les réglages prévus.

Vient ensuite Ivan Liebgott : Matlab et simulink pour l’enseignement des sciences de l’ingénieur. Cette présentation montre quel type d’activité peut être présenté dans des lycées pour illustrer la modélisation, l’écart avec le réel…

Pour terminer, Paul Cox : Innover en connectant Matlab et simulink à votre matériel. J’aurais bien passé une journée complète avec Paul :) On a droit à une belle démonstration de la surcharge du firmware d’un drone Parrot par un comportement issus de Matlab. Il ne sera pas avare en explications sur les possibilités d’interaction entre Matlab et divers matériels.

Il nous faut à présent retourner en session finale, mais je vous avoue avoir saisi ce moment pour récupérer mes affaires et dire au revoir à toutes les remarquables personnes croisées ce jour.

Je profite pour ajouter une petite note issue de mes petits essais en rentrant à la maison. Mes essais avec mes cartes arduino se sont plutôt bien passés, je n’ai juste pas réussi à faire reconnaitre ma MicroView, mais je creuserai.

Par contre, impossible d’utiliser Matlab avec la brique NXT de Lego que j’ai : je suis sous Mac Osx et Linux. Je peux comprendre en partie, vu que le logiciel de base est uniquement fourni sous Windows.

Ce que j’ai plus de mal à digérer, c’est la limitation à Matlab sous Windows de la partie hardware Raspberry. C’est quand même un comble de ne pouvoir piloter mes Pi qui sont de purs produits unix. Bon, j’ai encore mis un commentaire sur le package Raspberry à ce sujet, on verra.

J’espère pouvoir très vite vous reparler de Matlab, il faut encore que je récupère quelques plans et modèles que les équipes éduc de Mathworks doivent me faire parvenir. Je suis même prêt à transférer Matlab sur une machine Windows s’il le faut temporairement :)

A bientôt !

September 8, 2014
1 min read

Découvrons Sqlite - 3

Lors du dernier article, nous avions vu comment effectuer quelques opérations simples depuis Python pour manipuler une base Sqlite.

Mais certains d’entre vous se posaient quelques questions.
Dans l’ensemble, la réponse générale serait d’aller voir la documentation de Sqlite puis de reporter les instructions SQL dans la commande execute de la connection.

Prenons un exemple : en reprenant notre table PERSONNES, essayons de récupérer les enregistrements des personnes ayant un âge égal à 11.

Si vous vouliez écrire une requête directement dans Sqlite, vous écririez :

sqlite> SELECT * FROM PERSONNES WHERE AGE=11;
4|Nono|11
5|Tom|11

Il suffit alors de retranscrire ces instructions dans un code Python :

>>> import sqlite3
>>> conn = sqlite3.connect("tonton.db")
>>> cur = conn.cursor()
>>> cur.execute("SELECT * FROM PERSONNES WHERE AGE=11")
<sqlite3.Cursor object at 0x7f50a05586c0>
>>> cur.fetchall()
[(4, u'Nono', 11), (5, u'Tom', 11)]

Ce n’est pas si compliqué finalement ! ;)

August 14, 2014
3 min read

Découvrons Sqlite - 2

Comme nous l’avons vu dans le premier article, nous savons maintenant créer une table, insérer des données et les visualiser.

Oui, mais là, vous allez dire “Tonton, tu nous arnaques, on avait dit depuis Python”.
Ok, mais il fallait bien voir comment le faire depuis Sqlite, promis ça vous servira.

Pour interagir avec Sqlite depuis Python, il faut le module sqlite3.
Heureusement, ce module est inclus dans la distribution de Python depuis la version 2.5.
Pour vérifier la présence du module, lancez Python en ligne de commande et faites juste un import sqlite3. Si vous avez un message d’erreur comme celui ci dessous, faites moi un email pour que je vous aide.

>>> import sqlite3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named sqlite3

Avec ce module, nous allons pouvoir nous connecter à notre base :

>>> import sqlite3
>>> conn =sqlite3.connect("tonton.db")

La fonction connect prend pour paramètre le nom du fichier de la base.
Si vous le souhaitez, vous pouvez indiquer un chemin complet comme par exemple :

>>> import sqlite3
>>> conn =sqlite3.connect("/home/tonton/projects/tontoncodeur/tonton.db")

Ou si vous utilisez Windows :

>>> import sqlite3
>>> conn =sqlite3.connect("C:/projects/tontoncodeur/tonton.db")

Il faut ensuite créer l’objet qui nous servira à effectuer nos opérations sur la base Sqlite :

>>> import sqlite3
>>> conn =sqlite3.connect("tonton.db") 
>>> cur =conn.cursor()

Nous pouvons alors vérifier le contenu de notre table.
Le principe est simple, nous demandons à l’objet cursor d’exécuter notre commande SQL :

>>> import sqlite3
>>> conn =sqlite3.connect("tonton.db") 
>>> cur =conn.cursor()
>>> cur.execute("SELECT * FROM PERSONNES")
<sqlite3.Cursor object at 0x7f41dce2e6c0>
>>> data = cur.fetchone()
>>> print data
(1, u'Bob', 32)

La commande fetchone() nous a permis de récupérer le premier enregistrement de notre table.
Mais comment faire losqu’il y a plusieurs enregistrements ?

Pour le savoir, commençons par insérer d’autres enregistrements :

>>> import sqlite3
>>> conn =sqlite3.connect("tonton.db") 
>>> cur =conn.cursor()
>>> cur.execute("SELECT * FROM PERSONNES")

Nous pouvons alors vérifier le contenu de la table en utilisant une nouvelle fonction fetchall().
Elle nous retournera le tuple de tous les enregistrements.

>>> import sqlite3
>>> conn =sqlite3.connect("tonton.db") 
>>> cur =conn.cursor()
>>> cur.execute("SELECT * FROM PERSONNES")
>>> cur.fetchall()
[(1, u'Bob', 32), (2, u'Fanta', 33), (3, u'Titi', 43)]

Pourquoi ne pas profiter alors de Python pour insérer plusieurs lignes de manière plus programmée ?
Allons y :

>>> import sqlite3
>>> conn =sqlite3.connect("tonton.db") 
>>> cur =conn.cursor()
>>> donnees = [(4, 'Nono', 11), (5, 'Tom', 11), (6, 'Rosa', 14)]
>>> for ligne in donnees:
...     cur.execute("INSERT INTO PERSONNES(ID, NOM, AGE) VALUES(?,?,?)", ligne)
... 
<sqlite3.Cursor object at 0x7f41dce2e6c0>
<sqlite3.Cursor object at 0x7f41dce2e6c0>
<sqlite3.Cursor object at 0x7f41dce2e6c0>
>>> conn.commit()

Nous avons donc parcouru la variable donnees et inséré dans la table PERSONNES en utilisant les caractères ? dans la partie VALUES de notre commande.
Ces points d’interrogation sont remplacés par les valeurs fournies par la variable ligne.
Pour finir, nous appelons la fonction commit() qui indique que nous désirons bien sauvegarder tous ces changements.

Tout ça est assez simple non ?

Par ailleurs, si programmer en Python vous intéresse et que vous êtes au collège, je connais un jeune padawan avec qui vous pourriez échanger.

Comme toujours, n’hésitez pas à me contacter pour toute question ou souci que vous auriez.

August 13, 2014
3 min read

Découvrons Sqlite - 1

Coucou à tous !

Même en vacances, Tonton Codeur pense à vous. Remarquez qu’il est difficile de vous oublier grâce à vos gentils emails.

Il semblerait que parmi vous se cache un futur Zuckerberg. Pour révolutionner le monde des réseaux sociaux, il se pose quelques questions sur l’utilisation d’une base de donnée.

Nous allons donc tous ensemble jeter un oeil à l’utilisation de la base de donnée Sqlite avec Python.

Je n’aborderai pas l’installation de Sqlite et Python pour 2 raisons : notre révolutionnaire l’a déjà fait et si vous étiez sur un OS libre, vous les auriez déjà ;)
Bon, OK, si vous bloquez, vous pouvez me faire un email et je vous aiderai.

Pour nos petits exercices, nous allons créer une simple petite base avec Sqlite.
Ce qu’il faut savoir, c’est que Sqlite est une base de donnée toute simple qui se contente de tout stocker dans un fichier.

Pour commencer, créez un répertoire pour nos petits exercices.
Lancez votre ligne de commande et mettez vous dans ce répertoire.
Il vous suffira alors de lancer la commande :

sqlite3

Vous obtenez donc les informations suivantes à l’écran.

~/projects/tontoncodeur$ sqlite3 
SQLite version 3.8.2 2013-12-06 14:53:30
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Une fois ainsi, toutes les commandes seront des commandes de Sqlite. Une fois terminé vos opérations, vous pouvez quitter Sqlite par la commande :

.sqlite

Pour pouvoir utiliser Sqlite depuis un script Python, nous allons créer une table et quelques données, ce sera plus pratique. Pour créer une table nous utiliserons la commande Sqlite CREATE TABLE

sqlite3 tonton.db
SQLite version 3.8.2 2013-12-06 14:53:30
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> CREATE TABLE PERSONNES
   ...> (ID INT PRIMARY KEY NOT NULL,
   ...> NOM TEXT,
   ...> AGE INT);

La commande sqlite3 tonton.db permet de dire qu’on va travailler avec la base tonton.db.
Si elle existe, on se connecte, si elle n’existait pas, elle la crée.
Vous aurez alors un fichier tonton.db dans votre répertoire.

La première instruction qui suit est compréhensible :
on crée une table qui se nommera PERSONNES.
Tout ce qui suit entre les parenthèses définira les différentes colonnes de la table.

La première colonne sera un entier appelé ID qui servira de clé primaire.
Cette clé est utilisé par Sqlite pour accélérer ses recherches et vous servira à identifier vos enregistrements.
La seconde colonne sera le nom stocké dans un texte.
La dernière sera l’âge.

Pas mal non ?
Nous avons donc maintenant une table.
Il nous reste à insérer des données et les voir ensuite..

Pour ajouter des données, Sqlite utilise une commande appelée INSERT.
Par exemple, ajoutons une personne qui aura pour NOM Bob et agée de 32 ans :

sqlite> INSERT INTO PERSONNES(ID, NOM, AGE)
   ...> VALUES(1, "Bob", "32");

La première partie de la commande INSERT indique les colonnes qui vont être utilisées.
La seconde indique les valeurs que nous allons insérer.

Pour vérifier que les données sont là, il suffit alors d’utiliser la commande SELECT qui permet de voir le contenu d’une table.

sqlite> SELECT * FROM PERSONNES;
1|Bob|32

La commande SELECT permet de choisir les colonnes affichées, ou toutes si on utilise le caractère *.
Le mot FROM est utilisé pour indiquer la table qui sera consultée.

C’est tout simple non ?

Très vite, l’article suivant parlera de l’interaction possible entre Ptyhon et Sqlite.

Bonne vacances à tous.

June 5, 2014
8 min read

A La Découverte De Phaser - 5

Voici la suite de la traduction du tutoriel écrit par Alvin Ourad et Richard Davey.
Elle commence dans ce premier article
Puis se poursuit avec ce second article
Alors que le troisième article est làLogiquement, il y a eu ce quatrième article

Nous en étions resté au moment ou le joueur tombait en ignorant le sol que nous avions créé.

La raison est simple : nous ne testons pas encore la collision entre le sol et le joueur.
Nous avons déjà indiqué à Phaser que notre sol et nos plateformes étaient inamovibles. Si nous ne l’avions pas fait, le joueur les aurait rencontré, aurait marqué un temps d’arrêt, puis tous les élements se seraient dispersés.
A moins d’indiquer le contraire, le Sprite du sol est un objet physique qui peut se déplacer (appellé aussi corps dynamique) et quand le joueur le percute, les forces résultantes sont appliquées au sol, et les deux objects modifient leur vélocités et le sol se met à tomber lui aussi.

Donc, pour permettre au joueur d’entrer en collision et d’utiliser les propriétés physiques, nous devons ajouter un test de collision dans la fonction update :

function update() {

    game.physics.arcade.collide(player, platforms);

}

La fonction update est appelée par la boucle de jeu toutes les frames. La fonction Physics.collide est celle qui fait toute la magie. Elle utilise deux objets pour tester la collision et les sépare. Dans notre cas, nous lui passons notre Sprite de joueur et le Group de plateformes. Cette fonction est suffisament maline pour vérifier la collision avec chaque membre du Group. Cet appel va donc vérifier les collisions avec le sol et les plateformes.

Le résultat est une plateforme solide:

part6

Contrôler le jouer avec le clavier

Gérer les collisions, c’est bien beau, mais nous avons besoin de faire bouger le joueur. Peut être êtes vous tentés de plonger dans la documentation et chercher comment ajouter des event et les écouter, mais ce n’est pas utile ici.
Phaser inclus un gestionnaire de clavier et un des avantages de l’utiliser est cette petite fonction bien pratique :

cursors = game.input.keyboard.createCursorKeys();

Cela va peupler l’objet cursors avec quatre propriétés : up , down , left , right (NdT : haut, bas, gauche, droite) qui sont des instances des objets Phaser.key. Tout ce qu’il nous reste à faire est d’aller vérifier ces instances à chaque boucle :

    //  Reset the players velocity (movement)
    player.body.velocity.x = 0;

    if (cursors.left.isDown)
    {
        //  Move to the left
        player.body.velocity.x = -150;

        player.animations.play('left');
    }
    else if (cursors.right.isDown)
    {
        //  Move to the right
        player.body.velocity.x = 150;

        player.animations.play('right');
    }
    else
    {
        //  Stand still
        player.animations.stop();

        player.frame = 4;
    }

    //  Allow the player to jump if they are touching the ground.
    if (cursors.up.isDown && player.body.touching.down)
    {
        player.body.velocity.y = -350;
    }

Même si nous venons d’ajouter pas mal de code, cela devrait rester assez lisible.
La première chose que nous faisons est de réinitialiser la vélocité horizontale du Sprite.
Nous vérifions ensuite si la flèche vers le bas est appuyée. Si c’est le cas, nous appliquons une vélocité horizontale négative et nous déclenchons l’animation de course à gauche.
Si à la place nous avons la touche flèche vers la droite appuyée, nous faisons exactement l’inverse.
En remettant à zéro la vélocité et en la modifiant de cette façon à chaque frame , cela crée un mouvement de type “stoppe-repart”.

Le Sprite du joueur ne bougera que lorsqu’une touche est appuyée et s’arrête immédiatement quand ce n’est plus le cas.
Phaser vous permet de créer des mouvements plus complexes, avec de l’inertie et de l’accélération, mais nous nous satisferons de notre mouvement pour ce jeu.
La dernière portion de code remet le sprite du joueur avec la frame 4 si aucune touche n’est appuyée. La frame 4 dans la feuille de Sprite est celle où le joueur vous regarde, immobile.

Sautons

La dernière portion de code ajoute la possibilité de sauter. La touche flêche vers le haut sera la touche de saut et nous testons si elle est appuyée.
Malgré tout, nous testerons également si le joueur touche le sol, sinon il pourait sauter alors qu’il serait déjà dans les airs.
Si ces deux conditions sont respectées, nous appliquons une vélocité verticale de 350 pixel/sec.
Le joueur retombera vers le sol automatiquement grâce à la valeur de gravité que nous lui appliquons.
Essayez de jouer avec des valeurs plus ou moins grandes que 350 pour voir l’effet produit.

part7

Pluie d’étoiles

Il est grand temps de donner un but à notre petit jeu. Faisons pleuvoir des étoiles sur la scène et permettons au joueur de les ramasser.
Pour y parvenir, nous allons créer un Group appelé ‘stars’ et nous le peuplerons. Dans notre fonction create , nous ajoutons le code suivant (qui peut être vu dans le fichier part8.html)

    stars = game.add.group();

    stars.enableBody = true;

    //  Here we'll create 12 of them evenly spaced apart
    for (var i = 0; i < 12; i++)
    {
        //  Create a star inside of the 'stars' group
        var star = stars.create(i * 70, 0, 'star');

        //  Let gravity do its thing
        star.body.gravity.y = 6;

        //  This just gives each star a slightly random bounce value
        star.body.bounce.y = 0.7 + Math.random() * 0.2;
    }

Le procédé utilisé est similaire à celui que nous avons utilisé pour le Group de plateformes. En utilisant l’instruction de boucle for de Javascript, nous indiquons que nous créons 12 étoiles dans notre jeu.
Elles ont une coordonnée x de i * 70 , ce qui signifie que nous les répartissons équitablement dans la scène tous les 70 pixels.
Comme pour le joueur, nous leur donnons une gravité pour qu’elles tombent, et une valeur de bounce (NdT : rebond) pour qu’elle rebondissent un peu quand elles touchent les plateformes.
Le rebond bounce a une valeur entre 0 (pas de rebond du tout) et 1 (rebond total). Les notres rebondiront avec une valeur entre 0,7 et 0,9. Si nous executions le code tel que, les étoiles tomberaient et passeraient à travers le bas du jeu. Pour arrêter ce phénomène, nous devons vérifier les collisions entre les étoiles et les plaformes au sein de notre boucle for :

game.physics.arcade.collide(stars, platforms);

Nous en profiterons pour tester si le joueur et les étoiles ne partagent pas la même zone de jeu.

game.physics.arcade.overlap(player, stars, collectStar, null, this);

Cela indique à Phaser qu’il doit vérifier les recoupements entre le joueur et chacune des étoiles du Group. S’il trouve un recoupement, il passe ces éléments à la fonction ‘collecStar’

function collectStar (player, star) {

    // Removes the star from the screen
    star.kill();

}

L’étoile est alors simplement éliminée par l’instruction kill , ce qui a pour effet de la retirer de l’affichage. Le jeu a donc maintenant un joueur qui peut librement se ballader, sauter, bondir des plateformes et ramasser les étoiles qui tombent du ciel.
Pas mal pour quelques lignes de code que l’on peut qualifier d’assez lisibles :)

part8

Touche finale

La dernière petite modification que nous allons faire va consister à ajouter un score.
Pour cela, nous allons utiliser un objet Phaser.Text.
Nous créerons deux nouvelles variables, une qui contiendra le score actuel et l’autre l’objet texte lui même :

var score = 0;
var scoreText;

Le scoreText est paramétré dans la fonction create :

scoreText = game.add.text(16, 16, 'score: 0', { fontSize: '32px', fill: '#000' });

Les deux premiers paramètres 16,16 représentent les coordonnées d’affichage du texte. ‘score: 0’ est la chaîne par défaut qui sera affichée et l’objet qui suit contient la taille de la fonte et sa couleur de remplissage. En ne précisant pas la fonte, nous allons en fait utiliser celle que le navigateur choisira par défaut, ce qui correspond à Arial sous Windows par exemple.

Nous allons devoir ensuite modifier la fonction collectStar pour que lorsque le joueur attrape une étoile son score augmente et le texte est mis à jour pour refléter ce changement :

function collectStar (player, star) {

    // Removes the star from the screen
    star.kill();

    //  Add and update the score
    score += 10;
    scoreText.text = 'Score: ' + score;

}

Donc 10 points seront ajoutés pour chaque étoile et le texte du score scoreText est mis à jour avec le nouveau total.
Si vous ouvrez le fichier part9.html vous verrez le jeu au final.

part9

Conclusion

Vous avez appris comment créer un Sprite avec des propriétés physiques, à contrôler son déplacement et le faire interagir avec d’autres objets dans un petit jeu.
Il y a beaucoup d’autres choses que vous pouvez réaliser pour l’améliorer, par exemple ajouter une fin ou un but. Pourquoi ne pas ajouter des pieux qu’il faudrait éviter ? Vous pourriez créer un nouveau Group ‘spikes’ (NdT: pieux) et vérifier les collisions avec le joueur, puis vous feriez disparaitre le joueur au lieu du pieu. Ou pour un style de jeu non violent, faire du jeu une course contre la montre et simplement défier les joueurs de ramasser les étoiles le plus vite possible.
Nous avons inclus d’autres ressources graphiques dans le fichier zip de ce tutoriel pour vous inspirer.

Avec l’aide de ce que vous avez appris dans ce tutoriel et les plus de 250 exemples à votre disposition, vous devrier alors aboir de solides fondations pour un projet futur.
Mais comme toujours, si vous avez des questions, si vous avez besoin d’un conseil ou si vous souhaitez partager vos travaux, n’hésitez pas à demander de l’aide dans le forum Phaser.

Conclusion de la traduction

J’ajouterai que comme toujours, je répond avec plaisir aux commentaires et emails.
Merci de votre patience et si je vois qu’il y a des motivés pour continuer l’aventure, je prendrai un peu de temps pour rédiger une suite à ce tutoriel.
Qui sait, Alvin ou Richard feront alors une traduction anglaise ;)

Amusez vous, codez comme des fous, à bientôt.