Seuls les membres ayant 30 points peuvent parler sur le chat.

Le Jeu du Mois

Picross de Massena a remporté le titre du Jeu du mois de Septembre 2019 !

Nos projets majeurs

Voir le forum des projets
Proposer un article pour la RDP

Réseaux sociaux et partenaires

Bienvenue sur Planète Casio !

Planète Casio est la commauté française de référence pour toutes les calculatrices Casio. Apprenez à utiliser votre machine, téléchargez et partagez des programmes, ou initiez-vous à l'informatique sur le forum. Ou bien venez développer des jeux avec nous pour passer le temps !

Événements en cours

Événements à venir

  • Du 16 au 23 Novembre : concours de programmation 7 Days CPC
  • Du 1er au 31 Décembre : le Puzzle de l'Avent (Édition 2018)
  • Du 13 au 18 Janvier : 1k Basic Casio Gam Jam #2 (1ère édition)
  • Du 27 Janvier au 2 Février : semaine de test de programmes (1ère édition)

Actualités

Lancement du vote du Jeu du Mois d'Octobre 2019


Bonjour à tous !
On se retrouve avec les basses températures pour le lancement du vote du Jeu du Mois d'Octobre 2019 !
Au total, nous avons 12 programmes à départager…


Le but est simple la liste des jeux postés durant le mois d'octobre vous est soumise, à vous de voter pour vos jeux préférés dans les commentaires en classant vos trois préférés.

Le gagnant aura le droit de placer la coupe dorée du Jeu du Mois en insérant un code dans sa description et il bénéficiera d'un mise en avant d'un mois en page d'accueil !

Règles

On ne peut voter qu'une seule fois
Le Top 3 peut contenir des lacunes : vous pouvez ne mettre aucun programme en face des notes.
On ne peut pas voter pour soi-même (Tout vote pour soi est considéré invalide et remplacé par une lacune.)

Exemple de classement : Nous avons les jeux Sony, Mario, Starwars, Zelda, Pizza. J'aime beaucoup Pizza, j'ai bien aimé joué à Mario, sans plus et je n'ai pas aimé les autres :
1-Pizza (3pts)
2-
3-Mario (1pt)
Si j'ai bien aimé Sony mais pas les autres et que je pense que Sony aurait pût être mieux ce vote serait approprié:
1-
2-Sony (2pts)
3-

Si j'ai adoré Mario, Sony et Zelda, mais que je préfère Mario aux deux autres et que je trouve que la prestation de Zelda est bâclée alors mon vote va ressembler à ça :
1-Mario (3pts)
2-Sony (2pts)
3-Zelda (1pt)



Les programmes sont triés par ordre alphabétique.

- Boutique de TheBloodFlow et une sorte de jeu de rôle où vous devez… Je vous laisse découvrir ça…

- Capitales de TheBloodFlow est une sorte de QCM où vous devez trouver les capitales des pays demandés.

- Culture G de TheBloodFlow est un QCM pour tester votre culture générale…

- DAR de TheBloodFlow est un die and retry où le but est de trouver le bon chemin vers la sortie.

- Fusée de Mastermokemo est un programme pour la fx CP-400 qui permet de simuler un tir de fusée avec de nombreux paramètres : étages, carburant, booster,…

- Geo de TheBloodFlow est un quizz sur des capitales du monde.

- GF Simulator de TheBloodFlow est un jeu de rôle où le but est de ne pas rompre avec votre petite amie… Combien d'heures (de minutes ? ) allez vous tenir ?

- Inutile Pack de TheBloodFlow est une compilation de trois mini-jeux que je vous laisse découvrir par vous-même…

- Master Mind de Hashby est un… master mind ! Le but est de découvrir la combinaison colorée déterminée au hasard par la calculatrice.

- Memory Quest de TheBloodFlow est un jeu où il vous faudra épeler un nombre, chiffre par chiffre.

- PlatGame de KikooDX est un jeu d'arcade dans lequel le joueur créer ses propres niveaux ! Mais avant de vous lancer à corps perdu dans votre génie créateur, essayer de finir les 7 niveaux déjà existants…

- Voiture de Friphazeph est un programme où vous manipulez une voiture : vous pouvez tourner, ralentir, et accélérer.

On se retrouve dans plus ou moins 7 jours pour les résultats. Merci d'avance à tout ceux qui votent !

Commentez cette news ! (3)

Publié par Shadow15510 le

Voir toutes les news


La Revue des Projets – 167


Bonjour à tous ! Avec quelques… heures de retard la RdP sort enfin avec trois articles ! Nous aurons, sur le plateau, KikooDX qui va nous parler de son Locate en Python, mais aussi Maxipoint14 qui avance dans son Fortcalc et enfin Shadow15510 et son jeu Aérocie qui continue de grandir !

Allez, c'est partit, place à KikooDX et son Locate ! Lorsque Casio a décider de mettre un port Python sur les nouveaux modèles, le port n'était pas fait pour être puissant, mais pour satisfaire les nouvelles exigences de Ministère de l'Éduc'Nat. De ce fait, on ne pouvait pas faire grand-chose… KikooDX a alors eu l'idée d'exploiter le module Python des Casio au maximum pour pemettre l'affichage de caractères à des coordonnées précises de l'écran. Ce script a ouvert les portes à des jeux de rôles en ASCII art. Bref, Locate et devenu le seul moyen (pour l'instant) de faire des jeux en Python on calc comme on dit dans l'jargon… Et la dernière version de cet outil, vient de sortir !

KikooDX a écrit :
RDP,
RDP...
RDP.
Bonjour.


Cette semaine, j'ai repris mes projets Python en main.

Locate.py 2.4 !
J'ai ajouté une septième ligne à Locate.py 2, rétrocompatible avec les anciens scripts.
Fonctionne avec Pad nativement.
Télécharger la dernière version ici.

J'ai fait la page de wiki expliquant le format de levels.py de mon projet SokobanCMP.
La page en question.
Télécharger SokobanCMP.
SokobanCMP dépend de Locate.py 2.3 ou supérieur ! (fonctionne avec la septième ligne de Locate.py 2.4)


RDP,
RDP...
RDP.
Au revoir.

Une bonne nouvelle ! N'hésitez pas à télécharger Locate et à l'inclure dans vos jeux Python !

Passons à Maxipoint14 ! Il y a quelques années et sorti le jeu Fortnite, devenu célèbre sur smartphone, évidement, les calculatrices sont un peu en reste et Maxipoint14 décide de remédier à ce problème en lançant le 28 février 2018 la première version de son jeu nommé Fortcalc… Jeu qui n'a de cesse de s'améliorer puisque presque 10 mois plus tard, de nouvelles mise à jour continue d'arriver :

Maxipoint14 a écrit :
bonjour,
après plusieurs mois de codage je sors enfin mon fortcalc
c'est un programme lourd mais qui en vaut la peine
Dessus on joue comme dans le jeu on a les système de vie, de stuff, de rareté, d'ennemi, de collecte de munitions, etc...
les commandes sont pas trop compliqués
in game on a 5 choix :
[1]trouver une maison, [2]collecter du bois(inutile en ce moment et va peut-être être retiré), [3]chercher un ennemi, [optn] inventaire, [^]quitter
in fight on est contre un ennemi les touches sont simples
(flèches) déplacer la vue du jeu, [EXE] attaquer (si on a 0 armes fait 0 dégâts), [-](inutile) utiliser objet, (-) recharger, [optn]accéder a l'inventaire
dans l'inventaire:
[Vars] jeter l'objet sélectionné
(1.2.3.4.5) sélectionner objet
[EXE]équiper l'objet
[-]utiliser l'objet si :bandage,kit de soins, potions de bouclier(petite et grande), gourde du brave
Le jeu est en 1.4 mais il y aura des mises à jour chaque semaine (soit pour rajouter des armes, soit pour mettre un mode de jeu temporaire
Actuellement, le mode de jeu temporaire est la ruée vers l'or, donc on n'obtient que du légendaire, et un mode sangsue (si tu tue un ennemi, tu gagnes 50 vie/bouclier) qui sera bientôt retiré
Le jeu marche que pour les Casio ayant les couleurs mais un jour il pourrait être compatible sur toutes les Casio
si vous voulez tester n'hésitez pas et pour faire progresser le jeu me donner des idées ou me reporter des bugs écrivez le sur les commentaires
Sur ce, bon jeu

Pour essayer cette dernière release, c'est par ici Et au passage, oubliez pas le Rédacteur !

On termine cette Revue avec Shadow15510, notre spécialiste des jeux de gestion et son dernier jeu en date : Aérocie ! Aérocie est un jeu de gestion où le but est de faire fructifier une compagnie aérienne. Il faudra donc acheter des avions, les entretenir, les faire voler et accomplir des missions diverses pour ne pas couler… Depuis quelques temps, le jeu n'a pas connu de mise à jour, mais Shadow15510 rattrape son retard…

Shadow15510 a écrit :
Hey !
Après quelques mois de relâche, je reprend Aérocie… Au programme une petite version 1.2 béta suivie dans quelques semaines d'une version 1.3 encore plus complète !


Menu d'accueil


La version 1.2b intègre une nouvelle fonctionnalité : vous pouvez voir l'heure d'arrivée de vos avions en vol. Le prix de carburant a été revu à la hausse et la difficulté du jeu dans l'ensemble, s'est légèrement accrue. Devant le succès du jeu, petit retour sur le jeu : Aérocie est un jeu réaliste avec ses 20 appareils aux caractéristiques fidèles à la réalité, plus de 50 aéroports aux coordonnées exactes, et sa gestion du temps réel. Aérocie est de loin le jeu le plus peaufiné que j'ai fait.


Zoom sur le DC-3 (Douglas Dakota DC-3)


De plus le jeu intègre des outils puissants comme le calculs de distance. La souplesse des systèmes de stockages des avions et des aéropots permet des mise à jours simple et rapides ! Aérocie fait également partit des rares jeux à avoir un title screen animé, c'est accessoire, mais, la qualité graphique du jeu s'en ressent… Le menu principal a un design original.


Écran principal du jeu


Le jeu est doté d'un outil de recherche d'aéroport par le nom, par groupe de lettres, voire même par lettre ! Le jeu permet un réglage de l'heure sans passer par un autre programme, et permet au joueur de designer lui-même le logo de sa compagnie ainsi que le nom de celle-ci !


Ma flotte d'appareil


Pour la version 1.3, je prévoie une nette hausse du nombre d'aéroports dans le monde, avec une densification en Europe, mais aussi en Afrique, en Amérique du sud, en Asie, et autour du détroit de Béring ! Au final, le but ultime et de vous lancer des défis comme : "Faites le tour du monde avec DC-3" ! Bien sûr, vous devrez soigneusement calculer vos étapes… Dans une mise à jour encore plus lointaine, un nouveau pack de missions sera disponible et peut-être même de nouveaux avions !

Présentation des aéroports dans l'outil de recherche par nom. Et outil de recherche par nom.


Cet article clos cette magnifique RdP ! Bon courage pour ce jeu qui malgré les mises à jour ne connait qu'un succès médiocre… N'hésitez donc pas à donner des retours sur la page de téléchargement !

Cette semaine 3 programmes ont été postés :
Chiffrement Hill de hashby
SokobanCMP de kikoodx
ES. Chap 1 de htuoi50

Lire la RdP précédente : La Revue des projets – 165
Besoin d'aide ? Une idée ? Un projet ? Un article !

Commentez cette news ! (10)

Publié par Shadow15510 le

Voir toutes les news


Annonce : CPC #25 du 16 au 23 Novembre


Le Concours canonique de Planète Casio, le CPC, est de retour la semaine prochaine pour sa 25ème édition. Développez un jeu sur le thème imposé pour tenter de gagner une Graph 90+E !

Salut à tous ! Ça fait longtemps qu'on n'a pas eu de CPC, alors reprenons en beauté.

Présentation du concours de programmation

Cette 25ème édition de l'événement suivra essentiellement les règles habituelles. Il s'agit de programmer pendant un temps limité un jeu sur un thème imposé. Les jeux sont ensuite testés par un ou deux jurés et évalués sur un barème fixé à l'avance. Pour cette édition, les règles sont les suivantes :

• N'importe qui peut participer (comme d'habitude).
• Le sujet sera annoncé le Samedi 16 Novembre à 18h, vous devez poster avant le Samedi 23 à 18h.
• Vous devez programmer un jeu en Basic Casio, sur Graph monochrome ou sur Graph 90+E.
• Les résultats seront annoncés le Samedi 30 Novembre.
• Pour pimenter le sujet, vous devrez faire une petite référence à un mois ou une saison (voyez plus bas).

Le lot de cette édition est un modèle spécial de Graph 90+E dans son emballage pédagogique. La calculatrice est à jour avec l'OS 3.30 et supporte Python, les programmes en couleurs, les e-acts, les add-ins et la connexion USB.


Il se peut aussi que j'ajoute des goodies (avant le début du concours) selon mon humeur. Ouvrez l'oeil...

Il n'y aucune condition pour participer, mais essayez d'annoncer votre participation dans les commentaires si possible, ça nous aide à nous organiser.

Participants déclarés jusqu'ici : Disperseur, Kikoodx, Massena, Palpatine_78, Alexot, Youstones, Filoji, Tituya.

Barème d'évaluation des programmes

Les programmes de cette édition seront évalués par Shadow15510 et moi-même. Le barème est le suivant :

• Gameplay : 3 points
• Graphismes et interface : 3 points
• Narration et univers : 2 points
• Level design : 1 point
• Interprétations originales, les bonus : 1 point

La catégorie Gameplay comprend tout le fond de votre jeu. On cherche à savoir si le principe est inventif, si les règles sont bien équilibrées, si la difficulté est correctement ajustée, et si les éléments utilisés sont bien exploités, par exemple.

La catégorie Graphisme et interface concerne tout l'aspect visuel du jeu, ainsi que la gestion des contrôles. C'est là que vous pouvez exploiter tous vos talents d'artistes : Picture, animations, fluidité, tout est bon pour marquer des points. La clarté des contrôles fait aussi partie de cette catégorie.

Dans Narration et univers, on s'intéresse à la partie scénaristique de votre programme. Identifier des personnages, expliquer qui ils sont et pourquoi ils sont là, placer un cadre et donner des objectifs permet d'améliorer grandement le ressenti du joueur. Les pistes sont infinies !

La catégorie Level design consiste à évaluer la façon dont les maps, énigmes, puzzles, niveaux, épreuves sont conçus. Pour gagner des points ici, il faut exploiter à fond les éléments introduits (par exemple des plateformes mouvantes dans un plateformer). Dans le rare cas où cette catégorie ne s'applique pas bien à votre jeu, on en discutera directement avec vous.

Et enfin, les Bonus sont un point supplémentaire attribué pour diverses raisons : éléments positifs ne rentrant pas dans le barème, interprétations originales ou inventives du sujet imposé, utilisation habile de la référence obligatoire (ci-dessous), etc.

J'attire votre attention sur deux points importants :

La durée n'est pas un critère. Visez des jeux amusants plutôt que des jeux longs !
La qualité du code n'est pas un critère. Allez à l'essentiel !

Référence à un mois ou une saison

Votre jeu doit contenir un petit clin d'oeil à un mois ou une saison de l'année. Quelque chose de tout simple suffit. Par exemple, un personnage peut s'appeller Autumn, ou avoir une ligne de dialogue évoquant les vacances de Février, ou l'histoire peut simplement se passer à Noël.

Le but est de vous aider à établir une ligne scénaristique à partir d'un détail, si vous n'êtes pas très inspiré(e).

Conclusion

Il n'y a pas besoin d'aller chercher le diable pour participer. Un programme en mode texte convient tout à fait et peut obtenir des gros points en graphismes s'il est bien conçu. Jouez avec nos attentes !

À Samedi prochain pour le grand lancement de ce CPC !

Commentez cette news ! (35)

Publié par Lephenixnoir le

Voir toutes les news


Résultat du concours de rentrée 2019 - Épreuve de tracé !


Salut à la communauté ! Il est l'heure de passer en revue les participations, méthodes et classement de la première épreuve de notre concours de rentrée annuel.

Le sujet de l'épreuve de tracé était de reproduire avec le code le plus court possible l'image suivante sur fx-92 Scientifique Collège+.


Comme l'année dernière, nous avons reçu pas moins de 93 participations de 18 personnes, présentant de nombreuses techniques pour court-circuiter le dessin et tracer toujours avec toujours moins.

La majorité d'entre vous a travaillé sur la fx-92 SC+ ou son émulateur (15), avec quelques participations en Scratch (1) et Python (2) qui ont été traduites semi-automatiquement vers le langage de la fx-92 SC+.

Alors voyons dès maintenant le classement et les méthodes que vous avez utilisées pour parvenir à vos fins ! Nous avons rédigé un commentaire succinct sur chaque programme avec l'animation du tracé qu'il réalise. Plusieurs d'entre vous ont déjà décrit leurs méthodes en détail. N'hésitez pas à ajouter vos techniques dans les commentaires !

(Pour le choix des lots, voyez à la fin de l'article !)


Le classement

17. On commence tranquillement avec la participation de CaptainLuigi. La façon la plus naturelle d'attaquer une série de rectangles est de tourner de 90° entre chaque trait. On verra vite que ça se chaîne assez bien malgré les irrégularités. Ici l'oubli dommage c'est le curseur, qui dessine beaucoup de pixels superflus. Quatre personnes en tout ont omis de le masquer en le déplaçant hors de l'écran...


16. Avec Leno (TI-Planet, Planète Casio) sur fx-92+ Spéciale Collège, on commence à trouver les techniques permettant de tracer rapidement les cercles en profitant du fait que la position du crayon et l'angle d'orientation de la tortue sont bien plus précis que 1 pixel ou 1 degré. On peut donc tourner de 18.43 degrés ou avancer de 3.2 pixels à son avantage pour tracer tout le cercle à l'aide d'une boucle régulière. La même technique est utilisée pour la série de Z, qui n'est malheureusement pas au bon endroit par rapport au cercle. 326 points.



15. On fait maintenant un bond dans le score, jusqu'à 1344 points points avec Ptitjoz (TI-Planet, Planète Casio). Ici on a les rectangles complets, les cercles, les Z et le texte. Ici on se permet de reproduire une image approximative pour gratter des points : c'était le but de l'épreuve. Dans cette participation, pas de rotation ou pas avec des valeurs décimales, le cercle intérieur rate donc quelques pixels. Pour les rectangles, c'était l'effet attendu : on pensait que les deux pixels en trop valaient les instructions économisées. Voyons ce que vous en avez pensé...


Ptitjoz a écrit :
Je vous explique comment je voulais procéder... Voila la méthode mais faute de temps (je n'en expliquerai pas les raisons... ) je n'ai fait que quelques tests que j'aurais essayé d'optimiser. Une de mes participations où l'on peut voir un peu de ce code est : ici. Le principe retenu est que chaque pixel dessiné vaut 1 et chaque pixel non dessiné vaut 0. Mon idée était d'encoder l'image colonne par colonne en transformant le binaire obtenu en décimal et de le stocker dans une variable. Ensuite avec une boucle pour chaque colonne je décodais la variable en binaire point par point et j'affichai le pixel si la valeur était 1 sinon ne je l'affichais pas. Le code parlera mieux que mes explications.
Voilà, point final pour cette année. Merci à tous.
(message original)


14. Juste au-dessus de ce score, Zocipal attaque justement les rectangles au pixel près. La technique est la même, sauf que les rectangles font maintenant 5 côtés pour ainsi dire. Les cercles sont cependant plus manuels, avec essentiellement des angles droits et des levées et posées fréquentes de stylo. Ça prend de la place mais les points le valent bien, puisque chaque pixel rapporte 10 points contre 1 seul point perdu par octet. 1367 points.



13. Toujours au coude-à-coude, Edgar13 prend la place suivante. On voit ici les premières attaques sérieuses sur le sprite de Link, pour l'instant en exploitant les lignes continues les plus longues dans l'image. C'est un bon moyen d'accumuler les pixels à moindre coût, sans tenter de reproduire toute l'image. On a la même stratégie pour réduire le texte en utilisant des formes simples à programmer, appliquée finement. Bien joué ! 1418 points.


Edgar13 a écrit :
Pour les rectangles j'ai fait très simple juste des petites boucles de 2:

2→M
10→F
Aller à x=M; y=F
Stylo écrit
S'orienter à 270 degrés
Répéter 2
  Avancer de 4 pixels
  Tourner de ↺ -90 degrés
  Avancer de 8 pixels
  Tourner de ↺ -90 degrés

Stylo relevé
Aller à x=4; y=8
Stylo écrit
Répéter 2
  Avancer de 7 pixels
  Tourner de ↺ -90 degrés
  Avancer de 5 pixels
  Tourner de ↺ -90 degrés

Stylo relevé
Aller à x=7; y=4
Stylo écrit
Répéter 2
  Avancer de 6 pixels
  Tourner de ↺ -90 degrés
  Avancer de 5 pixels
  Tourner de ↺ -90 degrés

Stylo relevé

Pour les Z par contre j'ai pas mal réfléchi et je les ai tracé avec X et Y, ce qui m'a donné un code assez court:

16→M
Aller à x=M; y=F
Stylo écrit
2→A
Répéter 6
  F-(A-1)→F
  Aller à x=M; y=F
  S'orienter à 0 degrés
  Avancer de A pixels
  Si A<7 Alors
    A+1→A
  Fin

Ensuite j'ai surtout essayé de faire des rectangle avec des boucles :

Avancer de -1 pixels
Aller à x=16; y=-17
Avancer de 6 pixels
Stylo relevé
Aller à x=42; y=-19
Stylo écrit
Répéter 2
  Avancer de 3 pixels
  Tourner de ↺ 90 degrés
  Avancer de 9 pixels
  Tourner de ↺ 90 degrés

Stylo relevé
Aller à x=40; y=-5
Stylo écrit
Aller à x=32; y=3
Stylo relevé
Aller à x=67; y=-15
Stylo écrit
Répéter 2
  Avancer de 2 pixels
  Tourner de ↺ 90 degrés
  Avancer de 4 pixels
  Tourner de ↺ 90 degrés

Stylo relevé
Aller à x=41; y=-5
Stylo écrit
Répéter 4
  Avancer de 3 pixels
  Tourner de ↺ 90 degrés

Stylo relevé
Aller à x=63; y=-13
Stylo écrit
Répéter 3
  Avancer de 2 pixels
  Tourner de ↺ 90 degrés

Stylo relevé

Ensuite j'ai dessiné le 2019 de façon basique et simple juste en avançant et en relevant le stylo pour passer à une autre lettre :

Aller à x=63; y=-13
Stylo écrit
Répéter 2
  Avancer de 2 pixels
  Tourner de ↺ 90 degrés

Stylo relevé
Aller à x=71; y=-15
Stylo écrit
S'orienter à 0 degrés
Avancer de 2 pixels
Avancer de -1 pixels
Tourner de ↺ 90 degrés
Avancer de 4 pixels
Stylo relevé
Aller à x=75; y=-15
S'orienter à 0 degrés
Stylo écrit
Avancer de 2 pixels
Tourner de ↺ 90 degrés
Avancer de 4 pixels
Tourner de ↺ 90 degrés
Répéter 3
  Avancer de 2 pixels
  Tourner de ↺ 90 degrés

Stylo relevé
Aller à x=38; y=3
Stylo écrit
S'orienter à 0 degrés
Répéter 2
  Avancer de 3 pixels
  Tourner de ↺ 90 degrés
  Avancer de 1 pixels
  Tourner de ↺ 90 degrés

Stylo relevé
Aller à x=35; y=0
Stylo écrit
Avancer de 9 pixels
Tourner de ↺ -90 degrés
Avancer de 6 pixels

Et pour finir j'ai fait sortir la flèche:

Stylo relevé
Avancer de 99 pixels

Mais j'ai eu un problème de temps et j'aurais pu faire mieux il me restait 200 octets.


12. LePetitMage nous propose la première participation en Scratch (lien direct t13.sb3). Une fois retranscrite sur fx-92+ Spéciale Collège, on retrouve plusieurs éléments précédents : sacrifier des pixels inutiles sur les rectangles, tailler dans le vif sur le sprite de Link, et on a même la chance d'apercevoir un brin d'herbe (tiré des premières générations de Pokémon !) au-dessus du 2019. Les techniques pour tracer les cercles avec des avancées décimales sont plus subtiles à reproduire sur Sractch, qui a des règles de rendu un peu différentes... et également un plus grand écran. On s'en sort quand même avec un score très honorable, malgré la traduction, l'écran tronqué et le curseur en plus. Bel effort ! 1610 points.


LePetitMage a écrit :
Bonjour,
je suis le dernier parmi ceux qui ont un lot et je vous présente ici ma méthode.
Merci à Lephe pour l'animation trouvable ici : https://i.imgur.com/Tx4ABSR.gif

J'ai commencé par les rectangles qui s'emboîtent en définissant un pixel qui sera l'origine d'un repère.

Stylo écrit
Aller à x=0; y=-7
Avancer de 5 pixels
Avancer de -2 pixels
Aller à x=3; y=-10
Avancer de 5 pixels
Aller à x=8; y=-4
Avancer de -5 pixels
Avancer de 2 pixels
Aller à x=5; y=0
Avancer de -5 pixels
Aller à x=0; y=-2
Avancer de 3 pixels
Aller à x=3; y=2
Avancer de -8 pixels
Aller à x=-5; y=-2
Avancer de 4 pixels

Vous avez sûrement remarqué que :
-je n'ai pas utilisé de "Tourner de ..." pour économiser des lignes. Pour se déplacer vers la droite ou vers la gauche, j'avance d'un nombre positif ou négatif de pixels. Pour monter ou descendre, j'écris les coordonnées en fonction de l'origine du repère. C'est une technique que je vais utiliser un peu partout.
-j'avance parfois d'un nombre de pixel puis je recule tout de suite après. C'est pour gratter les pixels des "cornes" entre les rectangles.

J'ai continué avec les Z, où il n'y a pas spécialement de remarque à faire.

Avancer de 1 pixels
Aller à x=17; y=2
Stylo écrit
1→A
√(2→B
Avancer de 1 pixels
Répéter 5
  A+1→A
  S'orienter à 225 degrés
  Avancer de B×(A-1) pixels
  S'orienter à 0 degrés
  Avancer de A pixels

Aller à x=17; y=-19
Avancer de 6 pixels
Aller à x=17; y=-25
Avancer de 5 pixels

Et pour les deux cercles, je ne me suis pas embêté avec les angles et j'ai laissé de côté 4 pixels.

Aller à x=0; y=-26
Répéter 4
  Stylo écrit
  Avancer de 3 pixels
  Tourner de ↺ 45 degrés
  Avancer de B pixels
  Tourner de ↺ -45 degrés
  Avancer de 1 pixels
  Tourner de ↺ 45 degrés
  Avancer de B×2 pixels
  Tourner de ↺ 45 degrés
  Avancer de1pixels
  Tourner de ↺ -45 degrés
  Avancer de B-B÷Abs(B pixels
  Stylo relevé
  Avancer de B÷Abs(B pixels
  Tourner de ↺ 45 degrés


Aller à x=0; y=-24
Répéter 4
  Stylo écrit
  Avancer de 3 pixels
  Tourner de ↺ 45 degrés
  Avancer de B×3-B÷Abs(B pixels
  Stylo relevé
  Avancer de B÷Abs(B pixels
  Tourner de ↺ 45 degrés

J'ai continué avec le link en ne dessinant que les diagonales les plus généreuses en points (vous le remarquerez facilement dans l'animation de Lephe).

Aller à x=43; y=-26
Stylo écrit
Aller à x=43; y=-13
Avancer de 2 pixels
Avancer de -4 pixels
Aller à x=33; y=-5
Aller à x=40; y=2
Avancer de 4 pixels
Aller à x=44; y=-4
Avancer de -7 pixels
Aller à x=37; y=-2
Avancer de 5 pixels
Stylo relevé
Avancer de 1 pixels
Aller à x=46; y=-26
Stylo écrit
Aller à x=46; y=-12

J'ai ensuite dessiné 2019 en sacrifiant quelques pixels (certains non dessiné et d'autres en plus pour éviter les "Stylo levé" et "Stylo écrit").

Aller à x=64; y=-19
Stylo écrit
Avancer de 2 pixels
Aller à x=66; y=-21
Avancer de -2 pixels
Aller à x=64; y=-23
Avancer de 6 pixels
Aller à x=70; y=-19
Avancer de -2 pixels
Aller à x=68; y=-23
Avancer de 5 pixels
Aller à x=73; y=-19
Aller à x=73; y=-23
Avancer de 5 pixels
Aller à x=78; y=-19
Avancer de -2 pixels
Aller à x=76; y=-21
Avancer de 1 pixels

Et pour finir, le coeur avec la même technique que les rectangles mais aussi en se déplaçant sans tourner.

Aller à x=71; y=-14
Stylo écrit
Aller à x=71; y=-11
Aller à x=73; y=-9
Avancer de 1 pixels
Aller à x=74; y=-11
Aller à x=71; y=-14
Aller à x=68; y=-11
Aller à x=68; y=-9
Avancer de 1 pixels
Aller à x=71; y=-11

J'ai participé sur Scratch, l'avantage est que je suis plus à l'aise sur Scratch et que c'est plus amusant de glisser des blocs.
Par contre, je ne savais pas que plusieurs bouts de mon dessin seraient en dehors de l'écran et que ces pixels ne sont pas compté, et que la conversion depuis Scratch implique de rajouter des lignes.
(message original)

11. Et on embraye directement sur la première participation Python par Afyu. Le code original (lien direct t14.py) trace l'image complète, mais fait 2094 octets une fois traduit. Il faut donc arrêter le script à un peu plus de la moitié. La plupart du tracé utilise des instructions simples et n'hésite pas à utiliser «Aller à» comme source primaire de déplacement, plutôt que «Avancer de». Si les changements de direction sont trop fréquents, c'est en effet bien plus court (5 octets plus la taille des coordonnées contre 6 octets plus la taille de l'angle et celle du pas), ce qui n'était pas évident en première approche. 1635 points.


Afyu a écrit :
Mon script n'est clairement pas optimisé, et j'en suis conscient. D'abord, j'ai découvert le défi seulement quelques jours avant la fin du concours. J'ai voulu effectuer quelques tests sur une fx92+ sc mais je n'en ai pas, je ne connais personne qui en a une et je n'ai pas pu essayer sur émulateur parce que mon Linux n'est pas à jour et je ne peux pas installer Wine. Ce n'est pas une excuse mais ça explique certains (nombreux) points plutôt impertinents et peu optimisés. J'ai donc écrit mon script en Python avec le module Turtle, en utilisant le support prévu pour la NumWorks proposé pour le concours.

Je cache la tortue (et j'aurais bien aimé qu'une fonction existe pour cacher la flèche sur la fx92+, dommage). Je commence avec le zigzag (éclair ?). La commande fd() correspond à "Avancer de".

  goto(27,7)
  pendown()
  i=1
  fd(1)

Pour tracer le zigzag, les déplacements horizontaux sont faits avec fd(), et les déplacements en biais sont faits avec goto(x,y). Ça économise des changements de direction (et encore une fois, sans pouvoir vérifier sur une vraie fx92+, je ne me suis pas risqué à choisir un angle ou un pas qui risquaient de ne pas convenir ou d'être interprété différemment par une fx92+).
On souhaite descendre de 1, puis de 2, puis de 3, puis de 4... Donc le décalage par rapport au début du zigzag en haut est de 1, puis de 1+2, puis de 1+2+3, puis de 1+2+3+4...
Le décalage total vertical est donc la somme des premiers entiers naturels, qui peut s'écrire sous la forme : 1+2+3+...+n=n(n+1)/2, d'où le i*(i+1)/2.
J'ai envisagé de remplacer cette fraction par un simple goto(28,y-i) mais je ne savais pas comment écrire ça, sachant que dans mon script en Python il n'y a pas de y et je ne suis pas sûr que Turtle comprenne ce genre d'instruction avec y. Ah, si seulement j'avais eu une fx92+ sous la main ! Le dernier virage est en dehors de la boucle pour éviter d'avancer de 7.

  while i<7:
    fd(i)
    goto(28,7-i*(i+1)/2)  #goto(28,y-i)
    i=i+1
  fd(6)
  goto(28,-20)
  fd(6)
  penup()

De même, pour les polygônes, les déplacements horizontaux sont faits avec fd() et les déplacements verticaux sont faits avec goto(x,y).

  goto(14,-1)
  pendown()
  goto(14,1)
  fd(5)
  goto(19,-5)
  fd(-5)
  goto(14,-2)
  penup()
  goto(16,0)
  pendown()
  goto(16,-2)
  fd(-5)
  goto(11,5)
  fd(3)
  goto(14,7)
  fd(-8)
  goto(6,3)
  fd(8)
  goto(14,5)
  fd(2)
  goto(16,1)
  penup()

Pour le 2019, j'ai tracé segment par segment, avec une boucle pour tracer le "0" en deux fois et une autre pour tracer le haut du "9" en 4 fois.

  goto(74,-14)
  pendown()
  fd(3)
  goto(77,-16)
  fd(-2)
  goto(75,-18)
  fd(2)
  penup()
  fd(2)
  pendown()
  for k in range(2): #répéter 2
    fd(2)
    lt(90)
    fd(4)
    lt(90)  #la tortue regarde de nouveau vers la droite (orientation à 0°)
  penup()
  fd(3)
  pendown()
  fd(3)
  fd(-1)
  lt(90)
  fd(4)
  goto(83,-15)
  penup()

  goto(86,-18)
  pendown()
  lt(-90)
  fd(3)
  lt(90)
  fd(2)
  for l in range(4): #répéter 4
    fd(2)
    lt(90)
  penup()

Pour la fée, j'ai enchaîné des segments. Je me pose en bas, je trace le segment vertical, puis je pars à droite, je redescends en biais, je repars à gauche en biais et je termine en revenant vers le milieu. Les déplacements verticaux sont faits avec fd() et je profite du fait que la tortue regarde vers le haut (orientation 90°) à la fin du tracé du "2019".

  goto(82,-10)
  pendown()
  fd(4)
  goto(84,-4)
  goto(85,-4)
  fd(-2)
  goto(82,-9)
  goto(79,-6)
  fd(2)
  goto(80,-4)
  goto(82,-6)
  penup()

Pour les cercles, j'ai utilisé des boucles et de trop nombreux déplacements de 1. Faute de pouvoir tester sur une vraie fx92+ ou sur émulateur, j'ai préféré m'assurer que le tracé était correct et je n'ai pas pu trouver (ni même chercher) le pas et l'angle qui auraient permis de tout tracer avec une seule boucle.
J'ai tout de même utilisé l'astuce que le grand cercle ressemble au petit mais comme si on l'avait découpé en 4, si on avait éloigné les 4 morceaux et si on avait ajouté quelque chose entre deux morceaux adjacents. D'où la partie "Si q>4" et la partie "Si q=5" qui permet de se décaler pour se mettre sur le tracé du grand cercle.

  goto(8,-12)
  setheading(0)     # on oriente la tortue à 0° (elle regarde vers la droite)
  q=1
  while q<9: # répéter 9
      if q==5:
        goto(6,-12)
      pendown()
      fd(1)
      lt(90)
      fd(1)
      lt(-90)
      if q>4:
        penup()
        fd(1)
        lt(90)
        pendown()
        fd(1)
        penup()
        fd(1)
        lt(-90)
        pendown()
        fd(1)
      fd(1)
      penup()
      lt(90)
      fd(1)
      lt(-90)
      pendown()
      fd(4)
      penup()
      fd(1)
      lt(-90)
      q=q+1

Pour Link, j'ai essayé de le tracer segment par segment (comme une ligne brisée) en relevant le stylo un minimum de fois. Les changements d'orientation très nombreux sont remplacés par des goto(x,y). Et dans l'histoire, j'ai oublié 2 pixels vers le haut à gauche.

  setheading(90)    #on oriente la tortue à 90° (donc elle regarde vers le haut)
  goto(54,-4)
  pendown()
  goto(57,-7)
  goto(53,-11)
  fd(-2)
  goto(57,-13)
  fd(-8)
  goto(56,-22)
  goto(55,-22)
  goto(54,-21)
  fd(8)
  goto(58,-13)
  fd(2)
  goto(57,-10)
  fd(1)
  goto(54,-9)
  goto(56,-7)
  fd(4)
  goto(55,-2)
  goto(56,-1)
  fd(1)
  goto(57,1)
  fd(3)
  goto(54,7)
  goto(50,7)
  goto(48,5)
  goto(47,5)
  goto(46,4)
  fd(-3)
  goto(45,1)
  goto(44,0)
  goto(52,-8)
  goto(54,-8)
  goto(51,-8)
  goto(49,-6)
  goto(47,-6)
  goto(46,-5)
  fd(1)
  goto(47,-4)
  fd(3)
  goto(49,-3)
  goto(54,-3)
  goto(53,-4)
  fd(-4)
  goto(52,-7)
  goto(54,-5)
  penup()
  goto(48,5)
  pendown()
  fd(-2)
  lt(-90)
  fd(2)
  penup()
  fd(1)
  pendown()
  fd(4)
  lt(90)
  fd(2)
  lt(90)
  fd(1)
  penup()
  goto(56,3)
  pendown()
  goto(53,0)
  fd(3)
  goto(48,2)
  penup()
  goto(50,-2)
  pendown()
  goto(50,1)
  fd(-3)
  goto(53,-1)
  penup()

  goto(45,2)
  pendown()
  goto(47,0)
  penup()
  goto(48,4)
  pendown()
  goto(50,6)
  penup()

Pour le vaisseau (ou logo, ou je sais pas trop quoi ), j'ai utilisé la symétrie centrale de la zone centrale mais en traçant la figure ligne par ligne (comme des lignes horitontales de pointillés) puis j'ai tracé les deux parenthèses et enfin les deux traits obliques manquants.

  goto(74,2)
  setheading(0)
  q=0
  while q<2:
    pendown()
    fd(1)
    penup()
    fd(6)
    if q==0:
      pendown()
    fd(1)
    penup()
    fd(6)
    pendown()
    fd(1)
    penup()
    goto(90,-3)
    lt(180)
    q=q+1
  goto(79,1)
  for r in range(2):
    for s in range(2):
      pendown()
      fd(2)
      penup()
      fd(1)
    goto(85,-1)
    lt(180)
  goto(76,0)
  for t in range(2):
    pendown()
    fd(3)
    penup()
    fd(5)
  goto(74,-1)
  for u in range(2):
    pendown()
    fd(2)
    penup()
    fd(11)
  goto(74,-3)
  for v in range(2):
    pendown()
    setheading(90)
    fd(4)
    penup()
    goto(90,-3)
  goto(82,-3)
  pendown()
  fd(1)
  penup()

Pour les herbes, je parcours 3 fois une boucle qui met à jour les coordonnées du point de départ à chaque fois.

  a=42
  b=-15
  w=0
  while w<3:
    goto(a+2,b)
    pendown()
    goto(a,b+2)
    penup()
    goto(a+4,b)
    pendown()
    goto(a+6,b+2)
    penup()
    goto(a+3,b+2)
    pendown()
    fd(2)
    penup()
    if w==0:
      a=61
      b=1
    if w==1:
      a=63
      b=-22
    w=w+1


10. Juste au-dessus, on rentre dans le top 10, avec Amiga68000 sur la fx-92+ Spéciale Collège. Et là, surprise ! Un programme composé en moitié d'une longue suite de «Aller à» explicites remporte pas moins de 1722 points. Quelques angles décimaux sont utilisés pour les cercles, mais c'est tout. Ce programme simple en apparence fait facilement tomber la moitié du sprite de Link. Difficile de savoir si la séquence de lignes a été générée automatiquement ou cherchée à la main. En tous cas c'est une piste que l'on attendait fermement et qui a servi à choisir le barème de l'épreuve. Eh oui, même à 1 contre 10, le code compliqué coûte vite cher !


Amiga68000 a écrit :
Je vous partage mon code pour faire les carrés et les cercles. Pour les carrés j'ai pas eu le temps de regarder l'utilisation des boucles. Pour les cercles, j'ai utilisé des boucles imbriquées. Les 4 pixels dans les coins du cercle ne sont pas tracés, je suis preneur d'un code plus optimum. Le gros pâté c'est le pointeur flèche ! script


Voici le code pour les ZZZ : script. J'ai utilisé les boucles avec des coordonnées (x,y) le mieux aurait été d'utiliser les (orientation, déplacement). Là encore je suis preneur d'optimisation.

Chapeau à celui qui a presque tout tracé.
(message original)


9. À la 9ème place, Éléonore D. score 1958 points en combinant la simplicité des «Aller à» avec trois boucles intelligentes. La première permet de tracer la décoration au-dessus du 2019, et la touffe d'herbe d'un coup en profitant de la symétrie. Les deux autres sont des formes super compactes pour le tracé des cercles : 36 pas de 1.12 pixel séparés de 9.9 degrés chacun, et 28 pas de 1 pixel séparés de 12.75 degrés chacun. Cela laisse amplement la place de s'attaquer à Link.


Éléonore D. a écrit :
Pour ma part,je rien fais d'extraordinaire, j'ai beaucoup utilisé de ''aller à''.


8. Une bonne centaine plus haut à 2070 points, Clément C. propose un programme quasi-identique qui se distingue en choisissant mieux les parties de Link et en profitant de l'espace libéré pour tracer plus en détail la décoration symétrique sur la droite.


Clément C. a écrit :
J'ai essayé de faire de mon mieux(donc rien de bien compliquer) pour les cercles j'ai fais comme Amiga68000.


7. On fait ensuite un nouveau bond pour atteindre la 7ème place où le premier participant à cette épreuve, Encephalogramme, atteint les 2227 points. Ici moins de souci de finesse, on factorise le dessin dans des boucles et on couvre les pixels le plus vite possible. On remarque une boucle bien compacte pour le tracé de plusieurs rectangles à la suite. Les octets économisés compensent les pixels sacrifiés. Comme quoi on peut aller loin avec des outils simples : bravo !


Encephalogramme a écrit :
Je pense que ma méthode est assez basique, et mon but était donc d'optimiser avec des boucles et en choisissant les meilleurs morceaux du dessin.

Je mets ici les parties du code de façon séparées pour mieux visualiser

Cette portion du code permet de tracer le petit et le grand cercle, avec des valeurs étranges, comme "avancer de 4.5 pixels", mais ça marche :

Répéter 4
  Avancer de 3 pixels
  Tourner de ↺ -34 degrés
  Avancer de 4,5 pixels
  Tourner de ↺ -31 degrés
  Avancer de 3 pixels
  Tourner de ↺ -26 degrés

S'orienter à 0 degrés
Stylo relevé
Aller à x=x; y=y-2
Stylo écrit
Répéter 4
  Avancer de 1 pixels
  Tourner de ↺ -14 degrés
  Avancer de 4 pixels
  Tourner de ↺ -60 degrés
  Avancer de 2,5 pixels
  Tourner de ↺ -16 degrés

Ici, ça permet de tracer les Z avec des boucles, encore une fois pour gagner de la place :

1→A
Répéter 5
  Aller à x=x+A; y=y
  Aller à x=x-A; y=y-A
  A+1→A

Répéter 2
  Aller à x=x+A; y=y
  Aller à x=x-A; y=y-A

Aller à x=x+A; y=y
Stylo relevé
Aller à x=x-28; y=y+27

Le code qui suit permet de tracer les 3 rectangles au-dessus des cercles, le but est de faire ça en peu de place, même si il faut pour cela tracer des pixels qui devaient rester blancs :

Répéter 2
  Avancer de 8 pixels
  Tourner de ↺ -90 degrés
  Avancer de 4 pixels
  Tourner de ↺ -90 degrés

Stylo relevé
Aller à x=x+5; y=y-9
Stylo écrit
7→A
Répéter 2
  Répéter 2
    Avancer de 5 pixels
    Tourner de ↺ 90 degrés
    Avancer de A pixels
    Tourner de ↺ 90 degrés
  ⤴
  A-1→A
  Stylo relevé
  Aller à x=x+3; y=y-3
  Stylo écrit

Le plus "interessant" est passé, à partir de là c'est le tracé d'une partie du link et de 2019, en utilisant principalement des "aller à", ce qui permet d'aller aussi bien en haut, qu'en bas, mais aussi a droite, à gauche ainsi qu'en diaguonale. L'avantage, c'est que je n'ai pas besoin de changer d'angle pour tracer les figures, et gagne donc facilement des octets.

J'aurais pu avoir plus de points en mettant des "aller à" avec des coordonnées précises et pas relatives à la position actuelle, car d'après les participations des autres cela consomme moins d'octets, mais je m'en suis pas trop mal sorti :3


6. À la 6ème place, une participation très dense de Astrostellar obtient 2405 points. Plein d'astuces sont utilisées ici, mais la plus unique est certainement l'exploitation de la symétrie dans la tête et l'épée de Link, sur une seule boucle ! Avec deux variables de contrôle le même code trace une large moitié du sprite en un temps record. On reconnaît en fait une astuce générale consistant à exécuter une boucle deux fois en changeant le paramètre entre les deux tours. Le niveau de régularité requis est très faible (contrairement à des boucles ayant au moins 3 tours) et ça factorise efficacement le code. Cette participation est aussi la seule, il nous semble, à utiliser des «Avancer de» pour tracer les Z.


Astrostellar a écrit :
J'ai tout d'abord essayer de tracer dans des programmes indépendants les différentes parties de l'image, à savoir les rectangles, les ronds, les Z, Link, 2019 et le petit patern symétrique avec le coeur en dessous. Malheureusement, une fois tous les bouts de programme réunis en un seul, celui-ci dépassait largement la limite des 900 octets. J'ai donc dû faire des sacrifices pour gagner des octets en perdant un minimum de points.

J'ai effectivement utilisé une boucle pour tracer le Link. En effet, j'avais remarqué la symétrie de son visage. Je fais ainsi simplement une boucle qui trace la moitié du Link avant de changer ma valeur A (qui vaut 1 au début) en -1 pour pouvoir tracer la symétrie (au lieu d'avancer de 3 pixels par exemple, j'avance ainsi de -3 pixels. Je fais ainsi l'exacte inverse ). La variable B vaut 0 lors du premier tour de boucle, puis 1 au second. Celle-ci permet de bien placer ma symétrie : en effet, l'axe de symétrie du visage se situe ENTRE 2 pixels. Si je n'utilisais pas B, la symétrie se tracerait 1 pixel plus loin, autour d'un axe de symétrie qui se situerai alors SUR une verticale de pixels. B me permet ainsi de déplacer de 1 pixel toute ma symétrie. Enfin, C est simplement une valeur qui revient souvent (2A+B) et cela me permet de gagner des octets en initialisant une fois C et la réutiliser au lieu de taper à chaque fois 2A+B. Pour finir, j'ai pivoté au tout début de mon programme de 270 degrés (c'est à dire en vertical vers le bas) pour économiser des Aller à et les remplacer simplement par des Avancer de lorsque j'avais besoin d'aller vers le bas.

Pour les rectangles, j'ai tracé 2 rectangles en une boucle Répéter car ils avaient la même largeur, puis dans une seconde boucle le dernier rectangle. J'ai sacrifié au passage 2 pixels pour ne pas perdre d'octets ;).
J'ai ensuite tracé les ronds. Je fais pivoter mon stylo avant de le faire avancer. Mais les angles de rotation obtenus par calculs, une fois mis dans le programme, ne trace pas un cercle parfait... J'ai alors utilisé un "bidouillage" pour obtenir les angles de rotation... J'ai modifié quelques valeurs d'angles (à 1 ou 2 degrés près) pour que le cercle tracé soit régulier, en essayant plusieurs solutions, d'où les 25, 22, 23 puis 20 degrés de rotation un peu bizarre obtenus grâce à plusieurs essais... Je trace ainsi un quart de cercle, que je mets dans une boucle Répéter 4 fois pour le tracer entièrement. Je passe ensuite au second cercle (celui interne) sans lever mon stylo (économie de 2 lignes Relever puis Abaisser le stylo en sacrifiant un seul pixel).

Pour les Z, j'ai remarqué que la longueur supérieure des Z augmentaient de 1 pixel à chaque niveau en descendant. J'ai donc fait une boucle Répéter 8 fois (pour les 8 Z) avec une incrémentation de 1 à A (la longueur du haut des Z) à chaque tour tant que A n'est pas supérieur à 6 (rang à partir duquel les Z ne s'agrandissent plus). Je pivote à 225 degrés vers la gauche pour me mettre en position pour tracer la diagonale du Z. Sachant que la diagonale a la même longueur que la longueur supérieure de Z, j'avance de √2A (√2 comme pour la diagonale d'un carré), puis je pivote de nouveau pour me retrouver à l'horizontale et tracer le haut de mon Z. Le B est une petite variable qui permet de bien tracer le premier Z.

Pour le 2019, je trace simplement des rectangles à la place des chiffres, sauf pour le 1 (je sacrifie pas mal de pixels, mais je n'avais plus la place de mettre un bon 2019 dans le programme).

Enfin, la dernière boucle permet de répéter le tracé des 2 diagonales de la décoration à droite (ce sont celles qui me permettent de tracer un maximum de pixels en aussi peu de lignes )


5. On entre dans le top 5 avec Cala Mar, qui fournit un programme de 2559 points avec... eh bien pas grand-chose ! Uniquement des «Aller à», des «Avancer de», et la technique de tracé de cercles d'Éléonore . Il trace 6 éléments disjoints en ne relevant le stylo que 7 fois en tout. On s'attendait à cette méthode, mais pas à ce qu'elle soit si efficace ! Et pourtant elle montre qu'il n'y a pas besoin de connaissances de gourou pour tutoyer les meilleurs participants. Félicitations


Cala Mar a écrit :
Ah moi j'ai pas fais la même chose qu'Amiga68000 pour les cercles, j'ai fait:

Aller à x=-30 ; y=-12
Stylo écrit
Répéter 36 fois
  Avancer de 1.12 pxl
  Tourner de 9.9

Stylo relevé
S'orienter à 0
Aller à x=-30; y=-10
Stylo écrit
Répéter 28 fois
  Avancer de 1 pxl
  Tourner de 12.75
(message original)


4. À partir de la participation de Extra44 qui atteint 2673 points, on ne plaisante plus sur les calculs. On commence à utiliser les fonctions de la calculatrice pour diverses optimisations, comme tracer les cercles en calculant tout simplement les sinus et cosinus pour différents angles et rayons. Tout est optimisé aux petits oignons, du choix des lignes jusqu'aux petites régularités permettant d'économiser des octets avec des boucles. Et on termine par une longue suite de «Aller à» qui trace l'essentiel de Link et de la décoration. Il n'y a quasiment plus un octet à sauver là-dedans.


Extra44 a écrit :
Bon pour moi : J'avais fait ma 1ère version sur python/ordi, et comme j'étais à l'aise (ben oui j'avais de la place... ça me paraissait optimal... c'était beau quoi...), j'avais réussi (yess ) à dessiner correctement le bitmap.

Mais comme quasiment tout le monde ici, le problème est le manque de place. Et quand j'ai vu qu'une instruction moyenne sur la fx-92+ Spéciale Collège faisait au bas mot 10 octets facile (avec les fins de ligne SVP !); je me suis dit Arghh !

J'ai eu un autre soucis : turtle sur python/ordi et turtle sur fx-92+ Spéciale Collège ont un comportement différent sur la dernière position/pixel avant levé du stylo; sur l'ordi : il n'est pas dessiné, sur fx-92+ Spéciale Collège : il l'est. Du coup une fois passé sur émulateur, je ne suis plus revenu sur le python/ordi !

J'avais attaqué dans cette version les figures par ordre : en 1er la figure à gauche : les cercles. Après quelques essais, j'en suis arrivé a faire le tracé mathématique d'un cercle par cos et sin. Restait à avoir les bons centres et rayons des 2 cercles: j'ai bien vu que le centre n'est pas placé pile sur un pixel entre les 4 pixels ! Sinon dommage pour moi mais je n'avais pas compris/comment utiliser correctement le thêta... Après quelques essais, j'avais un rayon de 6.3 pixels pour le grand cercle, 4.5 pixels pour le petit, et un pas d'angle de . Pourquoi , car c'était la 1ère valeur qui m'a donné un cercle collant au bitmap, et qu'ensuite la valeur de 5 dans C et la valeur de A mise a 135 (°) pouvait me servir pour le zigzag ou pour d'autres angles (2A=270=-90, 3A...).

Ensuite les rectangles : j'avais fait une première version avec les 2 pixels blancs : je me suis rendu vite compte que cela bouffait des octets ⇒ j'ai alors opté pour 3 rectangles pleins. Une petite optimisation ici a été de finir par le rectangle d'en haut et de finir sur le trait horizontal du haut du rectangle, et de finir dans la direction vers l'Est (0°), afin de ne faire qu'un avancer de 22 pixels pour arriver sur le début du zigzag. J'avais réussi a faire une petite optimisation sur le zigzag, mais la participation totale n'étant pas meilleure, elle est passée à la trappe. Voir la dernière participation.

Dans cette version je suis passé ensuite au nombre 2019, en essayant de limiter les nombres d'octets, en voyant que les si finsi, voire les si sinon finsi bouffait de la place ! J'ai essayé avec une boucle en tournant a droite pour la moitié haute du 2, puis autant de boucles que possible pour faire le reste du 2019 en tournant à gauche... sans oublier les saut entre chiffres que j'ai zappé exprès car moins rentables de les prendre en compte...

Pour le logo en haut du cœur : j'ai essayé de regrouper les actions de même type (éventuellement paramétré) : j'ai vu une symétrie d'axe verticale ( → variable D égale a ±1 agissant sur la position x), et une petite symétrie d'axe horizontal entre la pointe centrale haute et la pointe centrale basse du logo : variable C agissant sur y ! D'où le code.

Ben après pour le reste; l'épée et la tête : vu qu'il ne me restait plus beaucoup d'octets, j'ai tracé les plus grands traits, en essayant de lever le moins possible le crayon.

Après cela j'avais essayé de coder les mouvements, mais cela s'est révélé moins meilleur !

Voila, si vous avez des questions, demandez !
(message original)


3. Le programme de Krevo_ (TI-Planet, Planète Casio) à 2805 points nous emmène de nouveau sur le terrain du calcul. Une partie des constantes a clairement été générée, et on retrouve beaucoup de Ent(X÷10) permettant de parcourir tous les chiffres d'un nombre. Alors, une idée ? Eh oui vous ne rêvez pas, ce programme a été compressé en encodant de façon compacte les pas ou les angles à suivre dans des grosses constantes pour éviter de répéter les instructions de déplacement élémentaires ! La logique de décodage occupe une majeure partie de cette soumission qui n'hésite pas à éluder les parenthèses fermantes non nécessaires dans les caculs pour réduire la quantité de code. Tout y est décrocher pour la 3ème place de l'épreuve !


Krevo_ a écrit :
Alors pour les 2 cercles, j'ai fait :

4,5→A
Répéter 2
  0→M
  Stylo relevé
  Répéter 32
    Aller à x=6,5+Acos(M; y=-6,5+Asin(M
    Stylo écrit
   M+90÷8→M
  ⤴
  6,4→A


C'est un peu pareil que Grosged, j'ai un rayon de 4,5 pour le cercle intérieur, puis 6,4 pour le cercle extérieur. Ensuite j'ai 32 tours de la boucle interne car je fait progresser l'angle M de 90°/8 (32x90°/8=4x90°=360°). (La progression de l'angle et le rayon du cercle extérieur : tout ça c'est des réglages un peu empirique en vérifiant que ça dessinais bien les pixels voulus). Je dessine tout simplement un point aux coordonnées (centre + rayon x cos angle ; centre + rayon x sin angle). Et effectivement, j'aurais gagné des octets en utilisant θ.

Je passe sur la boucle qui dessine les Z c'est trivial.

Pour les 3 rectangles, les chiffres et surtout Link et son épée, j'ai fait une sorte de moteur de dessin vectoriel (qui existe donc 3 fois en tout, j'aurais sans doute pu coder les déplacement de stylo et optimisé mais bon c'était déjà consommateur de temps tout ça...). Il s'agit de consommer un à un les chiffres des variable A et M (je me limite à 15 chiffres suite à différents test pour voir ce qui marchais en nombre de chiffre significatif, c'est à dire sans perdre d'informations).

Stylo écrit
1343282468656→A
7833249394235→M
Répéter 3
  Si E=8 Alors
    2453212124178→A
    1821311311322→M
  Fin
  Répéter 15
    S'orienter à 45(A-FEnt(A÷Fdegrés
    Avancer de(M-FEnt(M÷F))(1+,41(2-PGCD(2;A-FEnt(A÷Fpixels
    Ent(A÷F→A
    Ent(M÷F→M
  ⤴
  7463468745678→A
  2232433151413→M
  1+E→E

(Attention ici E valait 6 car j'avais fini de dessiné les Z comme ça, ... donc E=8 est le test du 3è tour de boucle, car ici j'ai 3 fois 15 chiffres pour A et pour M).

Dans A, j'ai mis successivement les angles, l'unité est le multiple de 45°. Ainsi, avec 2453212124178→A, les orientations sont successivement de 90° (2x45°), 180° (4x45°), 225° (5 x 45°), ... Dans M je mets le nombre de pixels. Donc 2232433151413→M signifie qu'il faudra avancer de 2, 2, 3, ... pixels. A chaque fois un couple orientation/avancement en pixels. Problème : quand l'orientation est en diagonale (45°, 135°, 225 °, ...) il faut avancer non pas de n pixels mais de n√2 pixels, donc si le chiffre de l'orientation est impair, on est en diagonale et je multiplie le nombre de pixels d'avancement par 1+1x0.41, ce qui fait 1.41. Sinon, si c'est pair, je multiplie le nombre de pixels d'avancement par 1+0x0.41, ce qui fait tout simplement 1. La parité est testée à l'aide du PGCD du nombre testé et de 2 (le PGCD est 2 pour les nombres pairs, 1 pour les nombres impairs).
(message original 1, message original 2)


2. L'algorithme suivant nous vient de Grosged et défraie le classement en annonçant 400 points de décalage avec son poursuivant. La logique est décuplée par la possibilité d'écrire des tests sans «Si ... alors». On remarque en effet que Ent(cos(X)) vaut essentiellement 1 si X=0 et 0 sinon (pourvu que X soit petit). Et donc Ent(cos(X-Y)) permet de tester efficacement si deux coordonnées sont égales. Combinée avec un système de compression similaire à celui de Krevo_ mais plus compact, cette technique permet de factoriser très aggressivement le code ! Ce programme mérite amplement sa 2ème place et ses 3217 points.


Grosged a écrit :
Je vais vous détailler la meilleure de mes participations. Mais parlons d'abord de quelques astuces.

Afin d'éviter les tests du genre Si...Alors...Fin qui prennent plusieurs lignes (ou qu'on ne peut parfois pas utiliser car au sein de 3 boucles imbriquées), l'idéal aurait été de pouvoir insérer des tests directement dans les calculs, comme par exemple... A+(B=7)→C. La fx-92+ Spéciale Collège ne le permettant pas, j'ai rusé en utilisant Ent(cos(. En effet, grâce à cos(0)=1 , la valeur entière de cos(B-7) sera égale à 1 si B=7, ou à 0 si B≠7. L'exemple précédent devient donc... A+Ent(cos(B-7→C (vous remarquerez , au passage, cette mini-optimisation qui consiste à ne pas refermer les parenthèses en fin de ligne ).

Autre astuce d'optimisation : parfois on a besoin de ne modifier que la variable x ou y. Alors, en fonction de l'orientation actuelle du stylo, un simple Avancer de ... pixels suffit (prends moins d'octets qu'un "Aller à x=... ; y=..."). Et quand on est vraiment obligé d'utiliser Aller à x=... ; y=... , on peut mettre un x=x ou y=y pour la variable qui ne bouge pas.

Intéressante aussi cette variable d'orientation θ dont la valeur sera retranchée de 360 (autant de fois que nécessaire) dès qu'elle dépasse 359. θ est donc une variable modulo 360. C'est bon à savoir car, bien utilisée, ça nous évitera de la (re)paramétrer. A noter que cette variable n'est accessible qu'au moyen de la touche OPTN.

Parfois, on peut aussi optimiser au niveau des Stylo écrit / Stylo relevé : l'idéal étant, bien sûr, de tracer le plus possible sans relever.

Au sujet des boucles, Répéter jusqu'à... n'est pas toujours indispensable. Quand on sait déjà combien de fois la boucle doit tourner, un simple Répéter... suffit.

Au sujet des données, on n'a -à ma connaissance- pas d'autre choix que de stocker ça dans des variables, par exemple en base 2...10 ou autres..., et d'y réinjecter d'autres valeurs au fur-et-à-mesure, au coeur de la/des boucle(s)...


Voilà pour les quelques astuces, maintenant passons au programme. (Merci @Lephe pour l'animation ).

Ca commence par la routine traçant les 3 espèces de rectangles :

Aller à x=4; y=17
44→D
54843253→A
Stylo écrit
Répéter 24
  Tourner de ↺90 degrés
  ,1Ent(A→A
  Avancer de 10(A-Ent(A pixels
  A+50(2031Ent(cos(A))+313064Ent(cos(,1-A→A

Stylo relevé

Ne faites pas attention au 44→D, c'est pour plus tard. Là, j'ai pensé ça comme un pointeur qui va, tout au long du tracé, tourner à chaque fois, à 90° dans le sens inverse des aiguilles d'une montre. Il me restait alors à définir le meilleur point de départ, insérer les longueurs respectives de tracé dans la variable A (en base 10). Ainsi, ça démarre avec un tracé de longueur 3, puis 5... 2... 3... etc (d'où 54843253→A). Parfois le stylo fait du sur place pour, par exemple, faire un demi-tour (donc tracé de longueur 0). Et comme on n'a pas assez de place pour inclure d'un coup toutes les longueurs dans A... A+50(2031Ent(cos(A))+313064Ent(cos(,1-A→A réinjecte des données au fur et à mesure... (factorisation pour grapiller 1 ou 2 octets ).

Puis, l'affichage du bonhomme :

J'ai pensé ça en affichage successif de bandes verticales de 16 pixels, chacune codée en base 2 (en binaire, quoi). Il y a, au total, 15 bandes réelles car certaines, vers la fin, sont vierges (par souci d'optimisation, les 14 premières sont codées par groupes de 2, donc 7 valeurs de 32 bits).

Avancer de 30 pixels
655364x→A
Répéter 21
  Répéter 16
    ,5Ent(A→A
    Aller à x=x; y=52-2θ÷45-Arcsin(A-Ent(A
    Stylo écrit
    Avancer de 0 pixels
    Stylo relevé
    Tourner de ↺ 22,5 degrés
  ⤴
  Avancer de 1 pixels
  A+12Ent(cos(x-52))+3301008851Ent(cos(x-38))+4258383057Ent(cos(x-40→A
  A+2453574741Ent(cos(x-42))+1081671044Ent(cos(x-D→A
  A+797186680Ent(cos(x-34))+878062140Ent(cos(x-36→A

655364x→A pour la 1ère bande de 32 bits, laquelle est un multiple de 32 (et x est justement à 32), ainsi on gagne un octet.
Comme vous pouvez le constater, on réinjecte des données suivant la position actuelle du pointeur (bref, en fonction de l'abscisse x). Les 2 pixels flottants font partie de la toute dernière bande verticale, celle-ci apparaît en abscisse x=52 après quelques bandes vierges. Codée en binaire, elle vaut 12... d'où 12Ent(cos(x-52)). J'utilise la variable θ comme valeur offset pour l'ordonnée y et lorsqu'on n'a pas de pixel à tracer, l'affichage se fait hors-écran. Lorsque ,5Ent(A→A décode en base 2, A-Ent(A nous donne la valeur 0,5 si pixel, sinon 0. On gère le hors-écran grâce au fait qu'Arcsin(0)=0 et Arcsin(0.5)=30... Arcsin(A-Ent(A est préférable à 30(A-Ent(A.

Ensuite , l'affichage des zig-zags :

Aller à x=x; y=22
Répéter 8
  Aller à x=16; y=y+A
  A-1-Ent(10sin(A→A
  Stylo écrit
  Avancer de-Apixels

Là, j'ai focalisé sur les tracés horizontaux uniquement (les diagonales s'affichent d'elles-même puisque le tracé reste en continu). Un petit Ent(10sin... me permet, une fois arrivé à la longueur de 6, de ne pas la dépasser. J'utilise une valeur négative rien que pour ultérieurement réutiliser cette variable A=-6.

Puis, l'affichage de l'épée :

Aller à x=D; y=8
Stylo écrit
Aller à x=45; y=5
Aller à x=42; y=7
Aller à x=41; y=2
Avancer de 5 pixels
Aller à x=x; y=4
Aller à x=45; y=1
Aller à x=x; y=A
Aller à x=D; y=-7
Aller à x=42; y=A
Aller à x=x; y=1
Stylo relevé

J'ai fini par m'apercevoir qu'un affichage en tracé classique s'avérait plus économique qu'en mode sprite ! (Dans un premier temps, j'avais opté pour un affichage en mode "sprite", et de manière symétrique par souci d'économie de donnée)

Maintenant, c'est au tour des 2 cercles :

4,5→A
Répéter 2
  Répéter 45
    Tourner de ↺ 8 degrés
    Aller à x=,5+Acos(θ; y=,5+Asin(θ
    Stylo écrit
  ⤴
  Stylo relevé
  6,35→A

Ensuite, l'affichage de 2019 :

5642465600→A
Aller à x=x; y=2
Répéter 5
  Aller à x=20π; y=y-1
  Répéter 12
    ,5Ent(A→A
    Si A=Ent(A Alors
      Stylo écrit
      Avancer de 0 pixels
      Stylo relevé
    Fin
    Avancer de 4÷3 pixels
  ⤴
  A+16779094Ent(cos(A→A

L'astuce principale réside dans l'économie de données : on fait comme si les 4 caractères composant 2019 faisaient chacuns 3x5 pixels (on fait abstraction du pixel de séparation entre chaque, l'affichage s'occupera de les "détacher", d'où le pas de 4/3 ). Encore pour réduire la taille des données, cette fois-ci , on code le tout en inversion video (si pixel il y a , valeur 0).

Et pour terminer, l'affichage du vaisseau suivi de l'espèce de coeur :

81923201→A
    Répéter 12
        Aller à x=70; y=y
        Répéter 9
            ,5Ent(A→A
            Répéter2
                Aller à x=140-x; y=D-Arctan(A-Ent(A
                Stylo écrit
                Avancer de 0 pixels
                Stylo relevé
            ⤴
            Avancer de 1 pixels
        ⤴
        D-1→D
        A+33686470Ent(cos(D-41))+2364428Ent(cos(D-38))+263685Ent(cos(D-35→A

Là, j'ai opté pour un affichage symétrique (donc presque 2x moins de données ). Cette fois, j'utilise Arctan au lieu d'Arcsin, uniquement par rapport à la variable D préalablement définie.

Voili-voilà ! J'espère avoir été assez clair dans mes explications, si vous souhaitez des détails sur telle ou telle partie, n'hésitez pas à poster Et surtout... Longue vie à la fx-92+ Spéciale Collège ! (hmmmm je sais : c'est juste une question de pile, haha ).
(message original)


1. Et c'est Pavel (TI-Planet, Planète Casio) qui domine ce classement du haut de ses 3270 points. Le programme très court n'a plus grand-chose d'humain et l'animation montre une méthode de tracé très orthodoxe. Après avoir tracé rapidement les cercles et les rectangles, il attaque le sprite de Link et les décorations colonne par colonne, pixel par pixel, s'arrêtant même sur l'herbe (aussi tirée de la première génération de Pokémon) sur son passage. La méthode de chargement des données donne le vertige. J'ai cru un moment à une transformée de Fourier mais ne serait-ce pas un bitmap très bien écrit ? La méthode maître cette épreuve ne révèle pas facilement ses secrets. Une conclusion glorieuse !


Pavel a écrit :
Mon idée initiale était que la méthode la plus simple serait de convertir l'image en colonnes de pixels, d'utiliser des bits pour représenter les pixels et de les dessiner pixel par pixel. Reste à trouver comment coder le plus efficacement les bits.

Étant donné que la hauteur de l'image est de 30 pixels, que 2^30 contient 10 chiffres décimaux et que la fx-92+ Spéciale Collège fonctionne avec des valeurs entières avec 10 chiffres décimaux, les colonnes de pixels peuvent être encodées sous forme de valeurs entières. Afin de convertir les colonnes de pixels en valeurs entières, j'ai écrit un petit script Python:

from scipy import misc
image = misc.imread('LWTC5q8.png')
d = 9
for y in range(85):
  counter = 0
  value = 0
  for x in range(30):
    if image[x+1,y+5,0] == 0:
      counter += 1
      value += 2**x
  if counter > 1:
    length = len(str(abs(value)))+ len(str(abs(y - d)))
    if y - d == 0: length -= 2
    print('%2d %2d %9d %2d' % (counter, length, value, y - d))

Ce script imprime le nombre de pixels par colonne, la valeur entière, le nombre de chiffres décimaux dans la valeur entière et la position de la colonne de pixels. La valeur d=9 du déplacement horizontal de l'image est choisie pour minimiser la somme des longueurs de toutes les valeurs entières. Avec ce script, j'ai obtenu 52 valeurs entières correspondant à des colonnes de plus de 1 pixel.

Le code pour dessiner les colonnes de pixels est assez simple:

S'orienter à -90 degrés
Répéter 85
  f(x) → B
  Aller à x=x+1; y=9
  Répéter 30
    Si 1=PGCD(Ent(B÷2^(9-y)); 2) Alors
      Stylo écrit
      Avancer de 0 pixels
      Stylo relevé
    Fin
    Avancer de 1 pixels
  ⤴

Reste à trouver comment programmer f(x)→B, où f(x) est une fonction qui renvoie une valeur entière correspondant à la colonne de pixels avec la coordonnée x. En C ou en Python, cette fonction peut être programmée comme 123*(x==1)+456*(x==2)+789*(x==3)+.... La seule façon de programmer quelque chose de similaire sur la fx-92+ Spéciale Collège que j'ai pu trouver est la suivante : 123*Ent(Cos(x-1)) + 456*Ent(Cos(x-2)) + 789*Ent(Cos(x-3))+.... En utilisant cette approche, j'ai réussi à obtenir 3025 points avec ce code.

Malheureusement, même si cette approche est facile à implementer, elle n'est pas la plus efficace. J'ai compris ça quand grosged a soumis une solution avec un score plus élevé et j'ai commencé à chercher des méthodes plus optimales pour dessiner certaines parties de l'image. Voyant que je vais devoir tester beaucoup de codes différents et qu'il faudra beaucoup de temps pour les saisir manuellement, j'ai écrit un script Python pour programmer automatiquement l'émulateur fx-92+ Spéciale Collège : https://gitea.planet-casio.com/Pavel/fx92-programmer . En utilisant ce script, j'ai rapidement testé différentes approches pour dessiner les zig-zags, les cercles et les rectangles. Ensuite, j'ai combiné les meilleures parties de tous les codes que j'ai réussi à produire et j'ai obtenu une solution correspondant à 3270 points.

Après la publication des solutions de ce défi, j'ai analysé le code écrit par grosged et j'ai été impressionné par sa solution très efficace pour dessiner les rectangles. J'ai immédiatement voulu vérifier quel score pouvait être obtenu en combinant une approche similaire pour dessiner les rectangles avec d'autres parties de mon code et j'ai réussi à obtenir 3309 points avec ce code.



Conclusion et choix des lots

Encore plus que l'année dernière, ces participations révèlent l'ingéniosité avec laquelle vous avez approché le sujet. Les techniques utilisées dépassent de loin nos attente. Bravo !

Comme prévu par le réglement du concours, les 12 participants ayant obtenu les meilleurs scores vous pouvoir choisir les lots de leur choix par ordre de score. Le premier à se lancer est donc Pavel. Vous pouvez suivre le choix en parallèle sur ce fil et sur TI-Planet. Lorsque votre tour vient, postez sur l'un des forums pour annoncer votre choix.

À bientôt sur Planète Casio !

Article connexe sur TI-Planet : Résultat concours de rentrée 2019 - défi de tracé

Commentez cette news ! (13)

Publié par Lephenixnoir le

Voir toutes les news


Fin de la méga-Edition du Jeu du Mois !


Bonjour à tous ! Avec quelques… 4 mois de retard sur le planning et une jolie bousculade sur la page d'accueil, voici la troisième news de la soirée !

On se retrouve pour annoncer les résultats de la méga-Edition du vote du Jeu du Mois qui contenait, rappelons-le 30 programmes répartit sur les mois de Juillet, Août et Septembre ! Et le grand gagnant est Picross de Massena avec ses 13 points !



Bravo à Alexot et Filoji qui se sont qualifiés pour la finale !

On se retrouve très bientôt puisque le mois d'octobre nous attend déjà !
Bravo et merci à tous les autres : c'est grâce à vos programmes et projets que ce site vit…

Commentez cette news ! (4)

Publié par Shadow15510 le

Voir toutes les news


La Revues des Projets – 166


Bonjour à t…t-tous, et bien… bienvenue dans le 166ème é…é-édition de la Re-vue des Projets (j'insiste avec ma capitalisation d'hérétique et mon st-style at-troce ! ). Ce ce-ce-ce soi-r nous av-vons l'honneur d'ac… d'accueillir Krevo_ ! Lephe' m’ex-excusera de lui v-vo… vo-voler la page d'accueil si t-tôt…

Com-commençons par Krevo_ et son p…pro-jet d'interpréteur BASIC en ligne. Le projet est a…a-assez simple à comprendre : vous s… s-sai… saisi-si… entrez votre code dans un édit…éditeur online et l'interpréteur exécute le programme comme votre calcul…culatrice le ferais ! Krevo_ a récemment implémenté une nouvelle fonctionnalité digne de Casio et son émulateur de fx-92 !

Krevo_ a écrit :
Bonjour,

Je continue d'augmenter le nombre d'instructions supportées par le Casio Basic Web Interpreter.

Aujourd'hui, je voulais vous faire part d'une toute nouvelle feature :

- l'ajout de la possibilité de partager un bout de code basic via une Url spécifique. Pour cela, j'ai rajouté un bouton "share" qui permet de générer une Url amenant directement à l'éxecution de votre programme.

Par exemple, mettons que je veuille vous faire voir ce que donne l'exécution de ce petit programme (exemple pris récemment ici) :

"Quel age as-tu " ? -> X
Clrtext
"Tu as ans"
Locate 7, 1, X


C'est sup-per ! Tous les liens s…s-sont mis ! On dirait un Ré…Ré-édacteur profess…professionnel… Hé-ésitez pas à j…j-jeter un œil au projet et à laisser vos commentaires sur le top… top-ic dédi-é.

Info de dernières minutes ! Krevo_complète son article amputé par un Rédacteur irrespectueux avec deux liens :

le premier correspond à l'exemple de petit programme de l'article https://basic.crevola.org/?src=EQRQrgpgNgBAhgcwvAzgWgC5hsGB+GNAPhgA0AoAYSgCcMIAPDc4AFWzhRm-gDsVg5ADIB7AMZx6MAOwAaGAEZ5pIA

et le second est aussi un lien vers l'interpréteur, mais renvoie un autre programme demo courbe de lissajous (programme fourni par Sentaro21)



On clos cette RdP par le programme de la semaine…

Cette semaine, un programme a été posté
Chiffrement Hill de Hashby : est un programme permettant de chiffrer et de déchiffrer du texte par le chiffrement de Hill.

Lire la RdP précédente : La Revue des Projets – 165
Besoin d'aide ? Une idée ? Un projet ? Un article !

Commentez cette news ! (10)

Publié par Shadow15510 le

Voir toutes les news


Retour sur les journées APMEP 2019


Les journées APMEP sont un événement annuel organisé par l'association APMEP et orienté autour de l'enseignement des mathématiques à tous les niveaux scolaires. Les calculatrices font partie du paysage, c'est pourquoi j'ai été visiter le salon de cette année à Dijon avec Critor le 20 Octobre, juste avant les vacances.

On a pu y voir tous les constructeurs majeures de calculatrices (Casio, TI, HP, Numworks), et aussi pas mal de curiosités. Voici quelques extraits et infos croustillantes !


Le salon

Par chance, notre train est parti à l'heure de Montpellier et de Lyon malgré la grève SNCF. Nous voici donc arrivés à Dijon, la capitale bourguignonne ! On prend rapidement le tramway pour aller aux bâtiment Mirande de l'université des sciences pour s'inscrire et visiter.




Sur le salon, une quarantaine de stands s'alignent de bout en bout du hall de l'université. On retrouve nos fameux constructeurs de calculatrices, mais aussi un bon tiers d'éditeurs de livres scolaires, des magazines mathématiques, et des curiosités mathématiques en tous genres, par exemple cette superbe reproduction en papier d'une fonction à deux paramètres.




Voyons donc ce que les exposants ont à nous présenter !


Constructeurs et calculatrices

On a commencé par le stand de Numworks. Deux personnes de l'équipe étaient là, avec quelques calculatrices, cahiers et des manuels d'exercices de SNT vraiment sympas qui traitent des sujets comme les réseaux sociaux, les structures de données en Python et le codage des couleurs.




L'équipe est super sympa. On a discuté du projet, des différents aspects matériels et logiciels de la machine, et de la méthode de développement. Ils ne sont qu'une dizaine en tout, ça donne un peu le ton !

J'ai appris que la RAM de la Numworks, qui fait 256 ko, est partitionnée avec une zone par application. Ça signifie que chaque programme doit avoir une zone allouée à l'avance et de taille suffisante, que personne d'autre ne pourra utiliser. Comme ils se gardent un peu de place ça fait parfois des petites zones... le plus impacté reste Python, comme vous l'avez vu avec le concours de rentrée. On espère que ça s'améliorera avec le temps.

Ensuite on a visité le stand de TI, où on trouvait des TI-83 Premium CE Édition Python, leure première machine milieu-de-gamme équipée nativement de Python, un TI-Rover, et surtout les modèles récents de TI-Nspire, les CX-II.




Apparemment ils réservent quelques nouveautés pour le salon Didacta de cette année (à Stuttgart), Critor vous en dira plus quand il se rendra sur place.

On a aussi discuté du concours de rentrée, comme avec Numworks d'ailleurs, et du triconcours de l'année dernière.

Ensuite, on a été voir HP. Leur produit phare, comme d'habitude c'est la fameuse HP Prime. Elle a changé de révision matérielle récemment, mais les anciens modèles comme les nouveaux proposent les mêmes fonctionnalités.




J'ai pu discuter un bon moment avec un ancien enseignant du choix de Python au lycée et de programmation en général. Il a démontré une implémentation des tours de Hanoï qui résoud le problème sous vos yeux, ici visible sur l'émulateur (il y avait cinq calculatrices connectées en tout). Fortiche l'émulateur !


Nouvelles côté Casio

Et enfin, on a été visité le stand de Casio. Il y avait là tout une gamme montante de calculatrices Casio, en partant d'un modèle très peu connu en France, la fx-Junior+, jusqu'à la Graph 90+E en passant par la fx-92 Scientifique Collège+ et la Graph 35+E II. Auxquels s'ajoutaient différentes fiches mémo Python et magazines que vous verrez sûrement passer dans le futur.




On a pu discuter avec Casio du concours de rentrée, en particulier de l'épreuve de tracé qui était la plus avancée à ce moment-là et la plus orientée Casio, et du triconcours de l'année dernière, là aussi pour donner quelques chiffres et tirer des comparaisons avec cette année.

Casio nous a aussi donné plusieurs nouvelles très intéressantes.

D'abord, il est question de préparer un module graphique Python pour les Graph 35+E II et 90+E. Ce n'est pas encore avancé, donc on ne sait pas encore si ce serait un port d'un module existant ou quelque chose d'entièrement nouveau à la Numworks. On n'a pas non plus encore de date prévue, mais on se doute que la rentrée prochaine serait un bon créneau pour eux...

De plus, les retours des utilisateurs semblent intéresser les équipes de développement. Il a été question de permettre à la communauté de tester les versions bêta de l'OS pour apporter des retours. Aucun détail n'a été discuté, mais on est très contents de la proposition et on vous tiendra au courant de la suite !

On a fini la journée par un atelier où un formateur Casio a présenté l'utilisation de Pythoon sur les Graph 35+E II et 90+E à un groupe varié d'enseignants, des grands débutants aux experts en programmation. Bien que Python soit dans les programmes depuis un an déjà, l'annoncer ne suffit pas à former tout le monde. Cet atelier était similaire aux tournées pédagogiques où j'avais été pour vous en Avril dernier et l'année précédente.

Et voilà pour mon passage aux journées APMEP ! Critor est resté jusqu'au lendemain, et moi je suis rentré à Lyon, avec du retard bien sûr parce que ç'aurait été trop facile de passer au travers de la grève SNCF...

À bientôt sur Planète Casio !

Commentez cette news ! (26)

Publié par Lephenixnoir le

Voir toutes les news


TDM n°16 – Grands principes de compilation


Le Tuto Du Mercredi [TDM] est une idée qui fut proposée par Ne0tux. Le principe est simple : nous écrivons et postons les Mercredis des tutoriels sur l'Utilisation de la calculatrice, le Transfert, les Graphismes, la Programmation, ou encore la Conception de jeu.

Aujourd'hui, on va parler de compilation et pourquoi c'est important.

Niveau ★ ★ ★ ☆ ☆
Mots-clés: Compilation, C, Édition des liens, Makefile

En programmation, la compilation est une étape du développement qui se trouve entre l'écriture du programme et son exécution. Selon les langages et les outils qu'on utilise, elle peut ne pas exister du tout, ou au contraire être un étape cruciale où énormément de choses se passent. Sur Planète Casio, on la rencontre surtout quand on écrit des add-ins en C ou C++, et ses messages d'erreur parfois cryptiques laissent plus d'un développeur amateur perplexe.

Dans ce tutoriel, je vais vous expliquer les grandes lignes du processus de compilation, avec l'exemple d'un add-in. Je parlerai du compilateur GCC, de l'éditeur de liens, des Makefile, et des rôles qu'ils remplissent. Vous verrez que le code C et les fichiers g1a n'ont rien à voir et que la transformation du premier en le second révèle des mécanismes passionants.

Le principe : construire un programme exécutable

Lorsque vous lancez un programme sur votre PC ou calculatrice, c'est le processeur qui exécute le code. Mais le processeur ne sait pas lire ou comprendre le code C ; il parle un langage bien à lui qu'on appelle assembleur. C'est un langage bas-niveau, peu expressif, et avec lequel il est facile d'écrire des programmes faux et proportionnellement difficile d'écrire des programmes justes.

En plus de ça, le langage assembleur est différent (voire extrêmement différent) d'un processeur à l'autre, à cause des variations d'architecture. Donc un programme assembleur ne marche vraiment que pour un seul processeur ! Tous ces facteurs ont poussé les informaticiens ont inventé des langages plus simples à utiliser, et plus puissants, comme le Basic et le C. L'idée est de programmer par étapes :

1. On écrit des programmes en C (par exemple). Comme le C est un langage expressif, le code est plus facile à lire et à écrire, et il y a moins de bugs.
2. On traduit ce code vers de l'assembleur pour notre processeur à l'aide d'un traducteur. Si le traducteur fait bien son boulot, on obtient automatiquement un programme assembleur qui fait pareil que notre code C.
3. On donne le programme assembleur au processeur et tout le monde est content.

Le traducteur qui transforme le code C en assembleur s'appelle un compilateur. C'est un outil indispensable lorsqu'on veut exécuter un programme directement sur le processeur, car généralement on ne veut pas coder en assembleur !

Il y a des compilateurs de tous poils. GCC sait compiler (entre autres) du C et du C++ vers de l'assembleur pour une large gamme d'architectures. LLVM compile vers un langage intermédiaire qu'il recompile ensuite en assembleur. Le compilateur Haskell compile du code Haskell en du code C puis demande à GCC de finir le travail... les possibilités sont nombreuses. Le seul point commun est que ça traduit des langages de programmation.

Le processus complet : assemblage et édition des liens

Le processus complet se fait en fait en plusieurs étapes. L'assembleur est non seulement difficile à utiliser, mais se présente également sous forme binaire. Cela signifie que le code assembleur ne peut pas s'afficher sous forme de texte... ni s'écrire facilement. (>_<)

Avant d'inventer les langages de haut niveau, les informaticiens ont donc commencé par inventer des représentations textuelles pour l'assembleur. C'est exactement le même langage mais représenté sous forme de texte. Notez que le processeur ne comprend pas le texte, que le binaire : et donc il faut traduire.

Le programme qui traduit le langage assembleur textuel en langage assembleur binaire s'appelle un assembleur. Mais pour éviter les confusions, je vais plutôt dire programme d'assemblage.

Par facilité, le compilateur C produit de l'assembleur texte. Lorsque le compilateur a fini de travailler, on utilise donc le programme d'assemblage pour retransformer le résultat en code binaire. Le schéma complet ressemble à ça :




Ici, chaque fichier .c est un fichier source. Chaque fichier .s correspondant est le code assembleur sous forme textuelle après la compilation. Chaque fichier .o est le code assembleur binaire associé.

À ce stade, tous les fichiers ont été compilés individuellement, mais il reste encore à les réunir, partager les fonctions et les variables globales, ajouter les bibliothèques, et vérifier que tout y est. Cette étape s'appelle l'édition des liens, et le programme qui la fait s'appelle l'éditeur de liens (linker en anglais).

L'édition des liens est un sujet assez compliqué qui mériterait un tutoriel entier à lui tout seul.

En pratique sur la ligne de commande

Prenons un fichier de code C innocent, example.c. Sous sa forme originale, c'est du texte facile à lire et à comprendre.

% cat example.c
#include <stdio.h>

int main(void)
{
    puts("Hello, World!");
    return 0;
}

Compilons-le ensemble avec GCC pour obtenir le fichier example.s contenant une version assembleur textuelle du code.

% gcc -S example.c -o example.s -O3
% cat example.s
    .file    "example.c"
    .text
    .section    .rodata.str1.1,"aMS",@progbits,1
.LC0:
    .string    "Hello, World!"
    .section    .text.startup,"ax",@progbits
    .p2align 4
    .globl    main
    .type    main, @function
main:
    subq    $8, %rsp
    leaq    .LC0(%rip), %rdi
    call    puts@PLT
    xorl    %eax, %eax
    addq    $8, %rsp
    ret
    .size    main, .-main
    .ident    "GCC: (GNU) 9.1.0"
    .section    .note.GNU-stack,"",@progbits

Le code est déjà bien moins avenant ! Et pourtant il fait la même chose, il appelle la fonction puts() avec en paramètre un pointeur vers une chaîne de caractère "Hello, World!".

Maintenant, on peut assembler ça en code objet (assembleur sous forme binaire) à l'aide du programme d'assemblage qui s'appelle as. Une fois cette étape passée, il n'est plus possible d'afficher directement le fichier car ce n'est plus du texte. À la place, on utilise le programme objdump qui décode le binaire pour nous.

% as -c example.s -o example.o
% objdump -d example.o
(...)
0000000000000000 <main>:
   0:    48 83 ec 08              sub    $0x8,%rsp
   4:    48 8d 3d 00 00 00 00     lea    0x0(%rip),%rdi
   b:    e8 00 00 00 00           callq  10 <main+0x10>
  10:    31 c0                    xor    %eax,%eax
  12:    48 83 c4 08              add    $0x8,%rsp
  16:    c3                       retq

Vous voyez qu'on retrouve les mêmes instructions. Cependant le fichier example.o contient uniquement le binaire décrit dans la colonne du milieu. C'est au bord de l'illisible pour des humains.

On peut finalement appeler l'éditeur de liens. L'éditeur de liens s'appelle ld mais il est difficile à invoquer sur la ligne de commande, donc on va s'adresser à GCC qui est capable de l'appeler pour nous avec tous les détails corrects. Ensuite on peut lancer le programme comme voulu.

% gcc example.o -o example
% ./example
Hello, World!

Le fichier example est un fichier ELF (un format de code binaire) et correspond au fichier game.elf sur mon diagramme. Quand on programme sous Linux, le fichier ELF qui est obtenu après l'édition des liens est le dernier maillon de la chaîne.

Sur calculatrice par contre, il y a encore un peu de travail à faire avant d'obtenir un fichier game.g1a. Je ne rentre pas dans les détails aujourd'hui car le fichier G1A contient essentiellement la même chose que le fichier ELF.

Recompilation partielle et Makefile

Comme vous pouvez le voir sur mon schéma, les fichiers d'un programme C sont tous compilés inviduellement et réunis seulement à la toute fin.

Supposons que j'ai modifié main.c et que je veux recompiler mon application. Comme gui.c et map.c n'ont pas changé, les fichiers gui.o et map.o sont déjà à jour. Il me suffit de recompiler main.c en main.o et rappeller l'éditeur de liens pour l'étape finale. Je n'ai donc recompilé qu'un seul des trois fichiers ; ça s'appelle une recompilation partielle.

Ça peut sembler anodin comme ça, car tout recompiler ne serait pas difficile. Mais des gros projets comme Linux ou Firefox peuvent mettre de précieuses minutes (voire des heures parfois...) à compiler. Il est donc important de ne recompiler que ce qui est nécessaire pour gagner du temps !

Et c'est là que compiler commence à devenir très compliqué. D'abord il y a plusieurs programmes à lancer, ensuite on ne veut les lancer que sur les fichiers qui ont été modifiés depuis la dernière compilation. Et si on en oublie, il n'y aura pas d'erreur mais le programme ne marchera pas...

Comme d'habitude, la solution est de tout automatiser et de laisser l'ordinateur faire.

C'est pour accomplir ce travail que des programmes comme make ont été inventés. Le job de make est de compiler des applications pour vous simplifier la vie :

make sait appeller automatiquement le compilateur, l'assembleur et l'éditeur de liens. Même si généralement on personnalise les commandes dans un fichier appelé "Makefile"
make s'arrange pour ne recompiler que les fichiers qui ont été modifiés depuis la dernière compilation.
• Et make fait plein d'autres choses extrêmement utiles.

Le fichier "Makefile" contient des instructions pour make, permettant de personnaliser les commandes de compilation ou carrément de l'utiliser pour autre chose (installer les programmes, générer de la documentation, compiler du LaTeX...).

Comme vous pouvez le voir, make permet de simplifier un travail relativement compliqué, et donc votre vie en tant que développeur.

Conclusion

La compilation est l'art de traduire des langages de programmation. Les processeurs ne comprennent que l'assembleur et on veut programmer dans d'autres langages, donc on fait traduire nos programmes vers l'assembleur à notre place.

Le procédé complet de compilation contient plusieurs étapes et se termine par l'édition des liens qui permet réunir plusieurs fichiers en un seul exécutable.

Comme compiler prend du temps, on aime recompiler uniquement les parties nécessaires d'un projet pour gagner du temps. Les outils comme make le font automatiquement et sont extrêmement utiles pour les développeurs.

À la prochaine !

Lire le TDM précédent : TDM 15- L'utilisation de l'espace graphique en programmation
Consulter l'ensemble des TDM

Commentez cette news ! (4)

Publié par Lephenixnoir le

Voir toutes les news


Finale de la Méga-Édition du Jeu du Mois !


Bonjour à tous ! Les vacances commencent justes avec la finale de la Méga-Édition du vote du jeux du mois regroupant pas moins de 30 jeux sur les mois de Juillet, Août et Septembre ! Aujourd'hui, nous allons départager le grand vainqueur !

Les règles sont les même que la semaine dernière ! Il nous reste trois jeux (les trois meilleurs) à départager ! A la clé une publicité en page d'accueil d'un mois ! Et la possibilité de mettre la mythique coup dorée dans la description de votre programme…

Il nous reste :

Cave Fight de Alexot : est un jeu où vous devez récuperer de l'énergie grâce à un pistolet pour ouvrir un portail…

Picross de Massena : le premier picross sur Casio ! Aurez vous la patience de résoudre les quellques 20 niveaux ?

The Cursed Maze de Filoji : est un jeu de labyrinthe où vous incarnez un explorateur… La nouveauté ? Vous avez un don spécial… qui transforme le labyrinthe.

Tous les votes et scores sont remit à zéro !
On se retrouve dans une semaine à peu près pour désigner le vainqueur final… Merci à tous ceux qui votent !

Commentez cette news ! (6)

Publié par Shadow15510 le

Voir toutes les news


La Revue des Projets — 165


Biiienvenue dans cette (très petite) 165ème Revue des Projets ! C'est déjà les vacances pour certains, ça viendra après pour d'autre. Gardez courage ! Aujourd'hui, Shadow15510 et Massena prennent la plume pour parler de leurs récentes avancées !

On commence par Shadow15510, qui nous pond des projets, malheureusement parfois sans les terminer...
Cette fois-ci, il va nous présenter une nouvelle idée de jeu assez originale sur... Je vous laisse le découvrir :

Shadow15510 a écrit :
La pluie tombe à verses. La nuit est tombée depuis plusieurs heures déjà… La forêt vous noie de son obscurité omniprésente. Un loup hurle au loin, mais d'épais nuages vous occulte la lune. Une forme sombre émerge de l'ombre. Plus noire encore que la nuit, la silhouette s'avance dans un fracas de bois et de fer. La voiture à cheval continue de s'avancer, la route n'est guère plus qu'un chemin de terre battue que la pluie balaye… Le cocher se protège tant bien que mal des éléments et les chevaux sont nerveux. La forêt cède la place à une lande déserte. La voiture s'arrête bientôt devant une forme massive et sombre. Au travers de la route se dresse, menaçantes, des grilles en fer forgé. La porte s'ouvre et une silhouette humaine descend lentement de la voiture. Le cocher se retourne mais aucun humain n'est en vue, du coin de l'œil il voit les grilles de fer se refermer d'elles-même dans un silence glaçant. Les chevaux tirent d'eux-même la voiture loin de cet endroit maudit… la Transylvanie… Mais qui est ce voyageur fantomatique, cette personne à la fois sûre d'elle et sombre ? Qui ? Sinon vous ?

Dans le jeu que je suis en train de faire, le but est simple, vous avez le choix d'incarner soit Dracula, soit Van Helsing. Dans chacun des deux cas, le but est d'éliminer l'autre, dans une course-poursuite dans le château de Dracula ! Évidemment vous ne serez pas seul, peut-être saurez-vous vous faire des alliés parmi vos rencontres… surprenantes !

Dans les fait le jeu est assez simple : il affiche un texte et le choix de chemin à suivre se fait par la saisie de nombre. Pour interagir, la saisie de texte est analysée, par exemple, entrer info permet d'afficher les stats du joueur et entrer quit permet de quitter le jeu !

Aucune image puisqu'il s'agit d'un jeu en mode texte ! Uniquement compatible avec CasioPython et rien d'autre (à cause de l'affichage)… Je compte bien mettre un max d'humour cynique…préparez-vous au pire !

C'est vrai que les jeux textuels se font rares sur Planète Casio. Personnellement, j'approuve l'idée !
Passons maintenant à Massena, qui a une énième annonce à vous faire :

Massena a écrit :
Bonjour !
J'ai peut-être été inactif les deux dernières semaines sur Planète Casio, mais j'ai quand même eu le temps de plancher sur mon Picross durant les cours de maths. Et c'est avec plaisir que je vous annonce que la 1.2 est sortie, toujours sans support pour les niveaux customisés (mais j'y travaille !). Les ajouts ? Il n'y en a pas. J'ai juste corrigé deux grilles qui buggaient (il y en a sûrement d'autre !) mais surtout optimisé le jeu, en lui faisant perdre 10ko !
Vous pouvez le télécharger à cette page !
C'est tout pour aujourd'hui,
Bonne journée !
Masséna

C'est bien tout ça, mais quand arrivera le support des niveaux customisés ?
C'est tout pour aujourd'hui, profitez bien de vos vancances pour ceux qui y sont déjà et puis sinon... Bon courage !

Cette semaine, 1 programme a été posté :
Fusée de Mastermokemo est programme réaliste où l'on peut simuler le décollage de fusées.
PlatGame de KikooDX est un "Mario maker" pour calculatrices.

Lire la RdP précédente : La Revue des Projets – 163
Besoin d'aide ? Une idée ? Un projet ? Un article !

Commentez cette news ! (13)

Publié par Massena le

Voir toutes les news


Planète Casio v42 © créé par Neuronix et Muelsaco 2004 - 2019 | Il y a 91 connectés | Nous contacter | Qui sommes-nous ? | Licences et remerciements

Planète Casio est un site communautaire non affilié à Casio. Toute reproduction de Planète Casio, même partielle, est interdite.
Les programmes et autres publications présentes sur Planète Casio restent la propriété de leurs auteurs et peuvent être soumis à des licences ou copyrights.
CASIO est une marque déposée par CASIO Computer Co., Ltd